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>

.claude/settings.json

@@ -1,7 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(flutter analyze:*)"
-    ]
-  }
-}

.claude/settings.local.json

@@ -1,16 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(flutter clean:*)",
-      "Bash(flutter pub get:*)",
-      "Bash(flutter run:*)",
-      "Bash(cmake:*)",
-      "Bash(where:*)",
-      "Bash(winget search:*)",
-      "Bash(winget install:*)",
-      "Bash(\"/c/Program Files \\(x86\\)/Microsoft Visual Studio/Installer/vs_installer.exe\" modify --installPath \"C:\\\\Program Files \\(x86\\)\\\\Microsoft Visual Studio\\\\2022\\\\BuildTools\" --add Microsoft.VisualStudio.Workload.VCTools --add Microsoft.VisualStudio.Component.VC.Tools.x86.x64 --add Microsoft.VisualStudio.Component.Windows11SDK.22621 --passive --wait)",
-      "Bash(cmd //c \"\"\"C:\\\\Program Files\\\\Microsoft Visual Studio\\\\18\\\\Community\\\\Common7\\\\Tools\\\\VsDevCmd.bat\"\" && flutter run -d windows\")",
-      "Bash(flutter doctor:*)"
-    ]
-  }
-}

.gitignore

@@ -11,6 +11,7 @@
 .svn/
 .swiftpm/
 migrate_working_dir/
+.claude/
 
 # IntelliJ related
 *.iml
@@ -43,3 +44,15 @@ app.*.map.json
 /android/app/debug
 /android/app/profile
 /android/app/release
+
+# Backendia
+backendia/node_modules/
+backendia/dashboard/node_modules/
+backendia/dashboard/.next/
+backendia/dashboard/out/
+backendia/exports/*.zip
+backendia/uploads/images/*
+!backendia/uploads/images/.gitkeep
+backendia/uploads/data/*
+!backendia/uploads/data/.gitkeep
+!backendia/uploads/data/database.sqlite

android/app/src/main/AndroidManifest.xml

@@ -1,6 +1,11 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android">
     <uses-permission android:name="android.permission.CAMERA" />
-
+    
+    <!-- Pour Android 12 et inférieur -->
+    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" android:maxSdkVersion="32" />
+    
+    <!-- Pour Android 13 et supérieur -->
+    <uses-permission android:name="android.permission.READ_MEDIA_IMAGES" />
     <application
         android:label="bully"
         android:name="${applicationName}"
@@ -32,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

backendia/dashboard/next-env.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="next" />
+/// <reference types="next/image-types/global" />
+import "./.next/dev/types/routes.d.ts";
+
+// NOTE: This file should not be edited
+// see https://nextjs.org/docs/app/api-reference/config/typescript for more information.

backendia/exports/archive_2026-04-29T13-34-48-508Z/data/photo-1777452200161-140195750.json

@@ -0,0 +1,116 @@
+{
+  "session_id": "session_1777452202935",
+  "timestamp": "2026-04-29T08:43:22.943303",
+  "device_info": {
+    "model": "google sdk_gphone64_x86_64",
+    "os": "Android 16"
+  },
+  "target_metadata": {
+    "type": "concentric",
+    "distance_meters": 25,
+    "weapon": "Unknown"
+  },
+  "plotting": {
+    "target_corners": [
+      {
+        "norm_x": 0.09999999999999998,
+        "norm_y": 0.09999999999999998
+      },
+      {
+        "norm_x": 0.9,
+        "norm_y": 0.09999999999999998
+      },
+      {
+        "norm_x": 0.9,
+        "norm_y": 0.9
+      },
+      {
+        "norm_x": 0.09999999999999998,
+        "norm_y": 0.9
+      }
+    ],
+    "impacts": [
+      {
+        "id": 1,
+        "label": "bullet_hole",
+        "score": 6,
+        "coords": {
+          "norm_x": 0.3934941044560185,
+          "norm_y": 0.665676540798611
+        }
+      },
+      {
+        "id": 2,
+        "label": "bullet_hole",
+        "score": 5,
+        "coords": {
+          "norm_x": 0.6055302372685185,
+          "norm_y": 0.6953124999999999
+        }
+      },
+      {
+        "id": 3,
+        "label": "bullet_hole",
+        "score": 8,
+        "coords": {
+          "norm_x": 0.5981137876157407,
+          "norm_y": 0.5249565972222221
+        }
+      },
+      {
+        "id": 4,
+        "label": "bullet_hole",
+        "score": 6,
+        "coords": {
+          "norm_x": 0.6759033203125,
+          "norm_y": 0.4786376953125
+        }
+      },
+      {
+        "id": 5,
+        "label": "bullet_hole",
+        "score": 9,
+        "coords": {
+          "norm_x": 0.48608398437499994,
+          "norm_y": 0.5490315755208333
+        }
+      },
+      {
+        "id": 6,
+        "label": "bullet_hole",
+        "score": 9,
+        "coords": {
+          "norm_x": 0.5101625795717593,
+          "norm_y": 0.43238661024305547
+        }
+      },
+      {
+        "id": 7,
+        "label": "bullet_hole",
+        "score": 7,
+        "coords": {
+          "norm_x": 0.6296079282407407,
+          "norm_y": 0.4203152126736111
+        }
+      },
+      {
+        "id": 8,
+        "label": "bullet_hole",
+        "score": 9,
+        "coords": {
+          "norm_x": 0.46386718749999994,
+          "norm_y": 0.48046875
+        }
+      },
+      {
+        "id": 9,
+        "label": "bullet_hole",
+        "score": 6,
+        "coords": {
+          "norm_x": 0.3379521122685185,
+          "norm_y": 0.4397786458333333
+        }
+      }
+    ]
+  }
+}

backendia/exports/archive_2026-04-29T13-34-48-508Z/data/photo-1777452478470-134185918.json

@@ -0,0 +1,116 @@
+{
+  "session_id": "session_1777452481252",
+  "timestamp": "2026-04-29T08:48:01.259705",
+  "device_info": {
+    "model": "google sdk_gphone64_x86_64",
+    "os": "Android 16"
+  },
+  "target_metadata": {
+    "type": "concentric",
+    "distance_meters": 25,
+    "weapon": "Unknown"
+  },
+  "plotting": {
+    "target_corners": [
+      {
+        "norm_x": 0.09999999999999998,
+        "norm_y": 0.09999999999999998
+      },
+      {
+        "norm_x": 0.9,
+        "norm_y": 0.09999999999999998
+      },
+      {
+        "norm_x": 0.9,
+        "norm_y": 0.9
+      },
+      {
+        "norm_x": 0.09999999999999998,
+        "norm_y": 0.9
+      }
+    ],
+    "impacts": [
+      {
+        "id": 1,
+        "label": "bullet_hole",
+        "score": 6,
+        "coords": {
+          "norm_x": 0.3934941044560185,
+          "norm_y": 0.665676540798611
+        }
+      },
+      {
+        "id": 2,
+        "label": "bullet_hole",
+        "score": 5,
+        "coords": {
+          "norm_x": 0.6055302372685185,
+          "norm_y": 0.6953124999999999
+        }
+      },
+      {
+        "id": 3,
+        "label": "bullet_hole",
+        "score": 8,
+        "coords": {
+          "norm_x": 0.5981137876157407,
+          "norm_y": 0.5249565972222221
+        }
+      },
+      {
+        "id": 4,
+        "label": "bullet_hole",
+        "score": 6,
+        "coords": {
+          "norm_x": 0.6759033203125,
+          "norm_y": 0.4786376953125
+        }
+      },
+      {
+        "id": 5,
+        "label": "bullet_hole",
+        "score": 9,
+        "coords": {
+          "norm_x": 0.48608398437499994,
+          "norm_y": 0.5490315755208333
+        }
+      },
+      {
+        "id": 6,
+        "label": "bullet_hole",
+        "score": 9,
+        "coords": {
+          "norm_x": 0.5101625795717593,
+          "norm_y": 0.43238661024305547
+        }
+      },
+      {
+        "id": 7,
+        "label": "bullet_hole",
+        "score": 7,
+        "coords": {
+          "norm_x": 0.6296079282407407,
+          "norm_y": 0.4203152126736111
+        }
+      },
+      {
+        "id": 8,
+        "label": "bullet_hole",
+        "score": 9,
+        "coords": {
+          "norm_x": 0.46386718749999994,
+          "norm_y": 0.48046875
+        }
+      },
+      {
+        "id": 9,
+        "label": "bullet_hole",
+        "score": 6,
+        "coords": {
+          "norm_x": 0.3379521122685185,
+          "norm_y": 0.4397786458333333
+        }
+      }
+    ]
+  }
+}

backendia/exports/archive_2026-04-29T13-34-48-508Z/data/photo-1777452610834-998848199.json

@@ -0,0 +1,44 @@
+{
+  "session_id": "session_1777452613625",
+  "timestamp": "2026-04-29T08:50:13.631206",
+  "device_info": {
+    "model": "google sdk_gphone64_x86_64",
+    "os": "Android 16"
+  },
+  "target_metadata": {
+    "type": "concentric",
+    "distance_meters": 25,
+    "weapon": "Unknown"
+  },
+  "plotting": {
+    "target_corners": [
+      {
+        "norm_x": 0.09999999999999998,
+        "norm_y": 0.09999999999999998
+      },
+      {
+        "norm_x": 0.9,
+        "norm_y": 0.09999999999999998
+      },
+      {
+        "norm_x": 0.9,
+        "norm_y": 0.9
+      },
+      {
+        "norm_x": 0.09999999999999998,
+        "norm_y": 0.9
+      }
+    ],
+    "impacts": [
+      {
+        "id": 1,
+        "label": "bullet_hole",
+        "score": 10,
+        "coords": {
+          "norm_x": 0.49810836226851846,
+          "norm_y": 0.4981011284722222
+        }
+      }
+    ]
+  }
+}

backendia/exports/archive_2026-04-29T13-34-48-508Z/data/photo-1777463306078-559049531.json

@@ -0,0 +1,144 @@
+{
+  "session_id": "session_1777463308809",
+  "wallet_hash": "cc60fcaa5ef7fdc9be3dd1adba4157fa6dfae2845da45b830b5ef2b7f473d887",
+  "timestamp": "2026-04-29T11:48:28.834236",
+  "device_info": {
+    "model": "google sdk_gphone64_x86_64",
+    "os": "Android 16"
+  },
+  "target_metadata": {
+    "type": "concentric",
+    "distance_meters": 25,
+    "weapon": "Unknown"
+  },
+  "plotting": {
+    "target_corners": [
+      {
+        "norm_x": 0.09999999999999998,
+        "norm_y": 0.09999999999999998
+      },
+      {
+        "norm_x": 0.9,
+        "norm_y": 0.09999999999999998
+      },
+      {
+        "norm_x": 0.9,
+        "norm_y": 0.9
+      },
+      {
+        "norm_x": 0.09999999999999998,
+        "norm_y": 0.9
+      }
+    ],
+    "impacts": [
+      {
+        "id": 1,
+        "label": "bullet_hole",
+        "score": 6,
+        "coords": {
+          "norm_x": 0.38424660011574074,
+          "norm_y": 0.3666042751736111
+        }
+      },
+      {
+        "id": 2,
+        "label": "bullet_hole",
+        "score": 7,
+        "coords": {
+          "norm_x": 0.6055302372685185,
+          "norm_y": 0.396240234375
+        }
+      },
+      {
+        "id": 3,
+        "label": "bullet_hole",
+        "score": 7,
+        "coords": {
+          "norm_x": 0.5860903139467593,
+          "norm_y": 0.5999620225694443
+        }
+      },
+      {
+        "id": 4,
+        "label": "bullet_hole",
+        "score": 6,
+        "coords": {
+          "norm_x": 0.33517433449074074,
+          "norm_y": 0.5592041015625
+        }
+      },
+      {
+        "id": 5,
+        "label": "bullet_hole",
+        "score": 8,
+        "coords": {
+          "norm_x": 0.6073612919560185,
+          "norm_y": 0.5101047092013888
+        }
+      },
+      {
+        "id": 6,
+        "label": "bullet_hole",
+        "score": 9,
+        "coords": {
+          "norm_x": 0.432373046875,
+          "norm_y": 0.46663411458333337
+        }
+      },
+      {
+        "id": 7,
+        "label": "bullet_hole",
+        "score": 9,
+        "coords": {
+          "norm_x": 0.45181297019675926,
+          "norm_y": 0.5564236111111112
+        }
+      },
+      {
+        "id": 8,
+        "label": "bullet_hole",
+        "score": 10,
+        "coords": {
+          "norm_x": 0.5221860532407407,
+          "norm_y": 0.48792860243055547
+        }
+      },
+      {
+        "id": 9,
+        "label": "bullet_hole",
+        "score": 3,
+        "coords": {
+          "norm_x": 0.6564335575810184,
+          "norm_y": 0.7536349826388888
+        }
+      },
+      {
+        "id": 10,
+        "label": "bullet_hole",
+        "score": 5,
+        "coords": {
+          "norm_x": 0.4712528935185185,
+          "norm_y": 0.7018229166666666
+        }
+      },
+      {
+        "id": 11,
+        "label": "bullet_hole",
+        "score": 5,
+        "coords": {
+          "norm_x": 0.3981327763310185,
+          "norm_y": 0.7018229166666666
+        }
+      },
+      {
+        "id": 12,
+        "label": "bullet_hole",
+        "score": 2,
+        "coords": {
+          "norm_x": 0.48144531249999994,
+          "norm_y": 0.8212483723958334
+        }
+      }
+    ]
+  }
+}

backendia/exports/archive_2026-04-29T13-34-48-508Z/data/photo-1777463700977-483303168.json

@@ -0,0 +1,117 @@
+{
+  "session_id": "session_1777463703756",
+  "wallet_hash": "cc60fcaa5ef7fdc9be3dd1adba4157fa6dfae2845da45b830b5ef2b7f473d887",
+  "timestamp": "2026-04-29T11:55:03.765285",
+  "device_info": {
+    "model": "google sdk_gphone64_x86_64",
+    "os": "Android 16"
+  },
+  "target_metadata": {
+    "type": "concentric",
+    "distance_meters": 25,
+    "weapon": "Unknown"
+  },
+  "plotting": {
+    "target_corners": [
+      {
+        "norm_x": 0.09999999999999998,
+        "norm_y": 0.09999999999999998
+      },
+      {
+        "norm_x": 0.9,
+        "norm_y": 0.09999999999999998
+      },
+      {
+        "norm_x": 0.9,
+        "norm_y": 0.9
+      },
+      {
+        "norm_x": 0.09999999999999998,
+        "norm_y": 0.9
+      }
+    ],
+    "impacts": [
+      {
+        "id": 1,
+        "label": "bullet_hole",
+        "score": 7,
+        "coords": {
+          "norm_x": 0.38424660011574074,
+          "norm_y": 0.45178222656249994
+        }
+      },
+      {
+        "id": 2,
+        "label": "bullet_hole",
+        "score": 5,
+        "coords": {
+          "norm_x": 0.6518247251157407,
+          "norm_y": 0.3638237847222222
+        }
+      },
+      {
+        "id": 3,
+        "label": "bullet_hole",
+        "score": 6,
+        "coords": {
+          "norm_x": 0.5490415219907407,
+          "norm_y": 0.66845703125
+        }
+      },
+      {
+        "id": 4,
+        "label": "bullet_hole",
+        "score": 6,
+        "coords": {
+          "norm_x": 0.405517578125,
+          "norm_y": 0.6758490668402777
+        }
+      },
+      {
+        "id": 5,
+        "label": "bullet_hole",
+        "score": 3,
+        "coords": {
+          "norm_x": 0.7268066406249999,
+          "norm_y": 0.6758490668402777
+        }
+      },
+      {
+        "id": 6,
+        "label": "bullet_hole",
+        "score": 9,
+        "coords": {
+          "norm_x": 0.5471806278935185,
+          "norm_y": 0.529568142361111
+        }
+      },
+      {
+        "id": 7,
+        "label": "bullet_hole",
+        "score": 8,
+        "coords": {
+          "norm_x": 0.44720504195601846,
+          "norm_y": 0.5980631510416666
+        }
+      },
+      {
+        "id": 8,
+        "label": "bullet_hole",
+        "score": 8,
+        "coords": {
+          "norm_x": 0.45458984375,
+          "norm_y": 0.4221462673611111
+        }
+      },
+      {
+        "id": 9,
+        "label": "bullet_hole",
+        "score": 7,
+        "coords": {
+          "norm_x": 0.5203251591435185,
+          "norm_y": 0.3638237847222222
+        }
+      }
+    ]
+  }
+}

backendia/exports/archive_2026-04-29T13-34-48-508Z/data/photo-1777464153541-625226221.json

@@ -0,0 +1,117 @@
+{
+  "session_id": "session_1777464156234",
+  "wallet_hash": "cc60fcaa5ef7fdc9be3dd1adba4157fa6dfae2845da45b830b5ef2b7f473d887",
+  "timestamp": "2026-04-29T12:02:36.255849",
+  "device_info": {
+    "model": "google sdk_gphone64_x86_64",
+    "os": "Android 16"
+  },
+  "target_metadata": {
+    "type": "concentric",
+    "distance_meters": 25,
+    "weapon": "Unknown"
+  },
+  "plotting": {
+    "target_corners": [
+      {
+        "norm_x": 0.09999999999999998,
+        "norm_y": 0.09999999999999998
+      },
+      {
+        "norm_x": 0.9,
+        "norm_y": 0.09999999999999998
+      },
+      {
+        "norm_x": 0.9,
+        "norm_y": 0.9
+      },
+      {
+        "norm_x": 0.09999999999999998,
+        "norm_y": 0.9
+      }
+    ],
+    "impacts": [
+      {
+        "id": 1,
+        "label": "bullet_hole",
+        "score": 7,
+        "coords": {
+          "norm_x": 0.38424660011574074,
+          "norm_y": 0.45178222656249994
+        }
+      },
+      {
+        "id": 2,
+        "label": "bullet_hole",
+        "score": 5,
+        "coords": {
+          "norm_x": 0.6518247251157407,
+          "norm_y": 0.3638237847222222
+        }
+      },
+      {
+        "id": 3,
+        "label": "bullet_hole",
+        "score": 6,
+        "coords": {
+          "norm_x": 0.5490415219907407,
+          "norm_y": 0.66845703125
+        }
+      },
+      {
+        "id": 4,
+        "label": "bullet_hole",
+        "score": 6,
+        "coords": {
+          "norm_x": 0.405517578125,
+          "norm_y": 0.6758490668402777
+        }
+      },
+      {
+        "id": 5,
+        "label": "bullet_hole",
+        "score": 3,
+        "coords": {
+          "norm_x": 0.7268066406249999,
+          "norm_y": 0.6758490668402777
+        }
+      },
+      {
+        "id": 6,
+        "label": "bullet_hole",
+        "score": 9,
+        "coords": {
+          "norm_x": 0.5471806278935185,
+          "norm_y": 0.529568142361111
+        }
+      },
+      {
+        "id": 7,
+        "label": "bullet_hole",
+        "score": 8,
+        "coords": {
+          "norm_x": 0.44720504195601846,
+          "norm_y": 0.5980631510416666
+        }
+      },
+      {
+        "id": 8,
+        "label": "bullet_hole",
+        "score": 8,
+        "coords": {
+          "norm_x": 0.45458984375,
+          "norm_y": 0.4221462673611111
+        }
+      },
+      {
+        "id": 9,
+        "label": "bullet_hole",
+        "score": 7,
+        "coords": {
+          "norm_x": 0.5203251591435185,
+          "norm_y": 0.3638237847222222
+        }
+      }
+    ]
+  }
+}

backendia/exports/archive_2026-04-29T13-34-48-508Z/data/photo-1777464604476-656835279.json

@@ -0,0 +1,180 @@
+{
+  "session_id": "session_1777464607256",
+  "wallet_hash": "cc60fcaa5ef7fdc9be3dd1adba4157fa6dfae2845da45b830b5ef2b7f473d887",
+  "timestamp": "2026-04-29T12:10:07.260954",
+  "device_info": {
+    "model": "google sdk_gphone64_x86_64",
+    "os": "Android 16"
+  },
+  "target_metadata": {
+    "type": "concentric",
+    "distance_meters": 25,
+    "weapon": "Unknown"
+  },
+  "plotting": {
+    "target_corners": [
+      {
+        "norm_x": 0.09999999999999998,
+        "norm_y": 0.09999999999999998
+      },
+      {
+        "norm_x": 0.9,
+        "norm_y": 0.09999999999999998
+      },
+      {
+        "norm_x": 0.9,
+        "norm_y": 0.9
+      },
+      {
+        "norm_x": 0.09999999999999998,
+        "norm_y": 0.9
+      }
+    ],
+    "impacts": [
+      {
+        "id": 1,
+        "label": "bullet_hole",
+        "score": 3,
+        "coords": {
+          "norm_x": 0.31570457175925926,
+          "norm_y": 0.7388509114583333
+        }
+      },
+      {
+        "id": 2,
+        "label": "bullet_hole",
+        "score": 5,
+        "coords": {
+          "norm_x": 0.3184814453125,
+          "norm_y": 0.6489935980902778
+        }
+      },
+      {
+        "id": 3,
+        "label": "bullet_hole",
+        "score": 6,
+        "coords": {
+          "norm_x": 0.3110966435185185,
+          "norm_y": 0.529568142361111
+        }
+      },
+      {
+        "id": 4,
+        "label": "bullet_hole",
+        "score": 6,
+        "coords": {
+          "norm_x": 0.31570457175925926,
+          "norm_y": 0.4416097005208333
+        }
+      },
+      {
+        "id": 5,
+        "label": "bullet_hole",
+        "score": 4,
+        "coords": {
+          "norm_x": 0.31570457175925926,
+          "norm_y": 0.34252929687499994
+        }
+      },
+      {
+        "id": 6,
+        "label": "bullet_hole",
+        "score": 3,
+        "coords": {
+          "norm_x": 0.32589699074074074,
+          "norm_y": 0.2332763671875
+        }
+      },
+      {
+        "id": 7,
+        "label": "bullet_hole",
+        "score": 3,
+        "coords": {
+          "norm_x": 0.45458984375,
+          "norm_y": 0.19624837239583331
+        }
+      },
+      {
+        "id": 8,
+        "label": "bullet_hole",
+        "score": 3,
+        "coords": {
+          "norm_x": 0.5981137876157407,
+          "norm_y": 0.23049587673611108
+        }
+      },
+      {
+        "id": 9,
+        "label": "bullet_hole",
+        "score": 5,
+        "coords": {
+          "norm_x": 0.6907045717592593,
+          "norm_y": 0.3546006944444444
+        }
+      },
+      {
+        "id": 10,
+        "label": "bullet_hole",
+        "score": 5,
+        "coords": {
+          "norm_x": 0.699951171875,
+          "norm_y": 0.48046875
+        }
+      },
+      {
+        "id": 11,
+        "label": "bullet_hole",
+        "score": 7,
+        "coords": {
+          "norm_x": 0.6268310546874999,
+          "norm_y": 0.5416395399305556
+        }
+      },
+      {
+        "id": 12,
+        "label": "bullet_hole",
+        "score": 9,
+        "coords": {
+          "norm_x": 0.49072265624999994,
+          "norm_y": 0.5610351562499999
+        }
+      },
+      {
+        "id": 13,
+        "label": "bullet_hole",
+        "score": 8,
+        "coords": {
+          "norm_x": 0.4203495732060185,
+          "norm_y": 0.536960177951389
+        }
+      },
+      {
+        "id": 14,
+        "label": "bullet_hole",
+        "score": 6,
+        "coords": {
+          "norm_x": 0.5370180483217593,
+          "norm_y": 0.6879204644097222
+        }
+      },
+      {
+        "id": 15,
+        "label": "bullet_hole",
+        "score": 3,
+        "coords": {
+          "norm_x": 0.6175537109375,
+          "norm_y": 0.7601453993055556
+        }
+      },
+      {
+        "id": 16,
+        "label": "bullet_hole",
+        "score": 1,
+        "coords": {
+          "norm_x": 0.7027280454282406,
+          "norm_y": 0.8406439887152777
+        }
+      }
+    ]
+  }
+}

backendia/exports/archive_2026-04-30T12-53-35-219Z/data/.gitkeep

@@ -0,0 +1 @@
+# Keep directory structure

backendia/exports/archive_2026-04-30T12-53-35-219Z/data/photo-1777553550008-681509771.json

@@ -0,0 +1,270 @@
+{
+  "session_id": "session_1777553535029",
+  "wallet_hash": "cc60fcaa5ef7fdc9be3dd1adba4157fa6dfae2845da45b830b5ef2b7f473d887",
+  "timestamp": "2026-04-30T12:52:15.048830",
+  "device_info": {
+    "model": "google sdk_gphone64_x86_64",
+    "os": "Android 16"
+  },
+  "target_metadata": {
+    "type": "concentric",
+    "distance_meters": 25,
+    "weapon": "Unknown"
+  },
+  "plotting": {
+    "target_corners": [
+      {
+        "norm_x": 0.09999999999999998,
+        "norm_y": 0.09999999999999998
+      },
+      {
+        "norm_x": 0.9,
+        "norm_y": 0.09999999999999998
+      },
+      {
+        "norm_x": 0.9,
+        "norm_y": 0.9
+      },
+      {
+        "norm_x": 0.09999999999999998,
+        "norm_y": 0.9
+      }
+    ],
+    "impacts": [
+      {
+        "id": 1,
+        "label": "bullet_hole",
+        "score": 0,
+        "coords": {
+          "norm_x": 0.17681929976851848,
+          "norm_y": 0.8851318359375
+        }
+      },
+      {
+        "id": 2,
+        "label": "bullet_hole",
+        "score": 0,
+        "coords": {
+          "norm_x": 0.17681929976851848,
+          "norm_y": 0.7721489800347222
+        }
+      },
+      {
+        "id": 3,
+        "label": "bullet_hole",
+        "score": 1,
+        "coords": {
+          "norm_x": 0.17959617332175923,
+          "norm_y": 0.6888020833333334
+        }
+      },
+      {
+        "id": 4,
+        "label": "bullet_hole",
+        "score": 2,
+        "coords": {
+          "norm_x": 0.17959617332175923,
+          "norm_y": 0.6342095269097222
+        }
+      },
+      {
+        "id": 5,
+        "label": "bullet_hole",
+        "score": 2,
+        "coords": {
+          "norm_x": 0.17959617332175923,
+          "norm_y": 0.560153537326389
+        }
+      },
+      {
+        "id": 6,
+        "label": "bullet_hole",
+        "score": 2,
+        "coords": {
+          "norm_x": 0.17959617332175923,
+          "norm_y": 0.5138346354166666
+        }
+      },
+      {
+        "id": 7,
+        "label": "bullet_hole",
+        "score": 2,
+        "coords": {
+          "norm_x": 0.1814579716435185,
+          "norm_y": 0.45273166232638884
+        }
+      },
+      {
+        "id": 8,
+        "label": "bullet_hole",
+        "score": 2,
+        "coords": {
+          "norm_x": 0.18701171875,
+          "norm_y": 0.3878987630208333
+        }
+      },
+      {
+        "id": 9,
+        "label": "bullet_hole",
+        "score": 1,
+        "coords": {
+          "norm_x": 0.18887351707175926,
+          "norm_y": 0.2925482855902778
+        }
+      },
+      {
+        "id": 10,
+        "label": "bullet_hole",
+        "score": 0,
+        "coords": {
+          "norm_x": 0.2036747685185185,
+          "norm_y": 0.20085991753472218
+        }
+      },
+      {
+        "id": 11,
+        "label": "bullet_hole",
+        "score": 0,
+        "coords": {
+          "norm_x": 0.27035499855324074,
+          "norm_y": 0.16200086805555558
+        }
+      },
+      {
+        "id": 12,
+        "label": "bullet_hole",
+        "score": 1,
+        "coords": {
+          "norm_x": 0.37588523582175926,
+          "norm_y": 0.1546088324652778
+        }
+      },
+      {
+        "id": 13,
+        "label": "bullet_hole",
+        "score": 2,
+        "coords": {
+          "norm_x": 0.46292136863425926,
+          "norm_y": 0.1518283420138889
+        }
+      },
+      {
+        "id": 14,
+        "label": "bullet_hole",
+        "score": 1,
+        "coords": {
+          "norm_x": 0.6814579716435185,
+          "norm_y": 0.1499294704861111
+        }
+      },
+      {
+        "id": 15,
+        "label": "bullet_hole",
+        "score": 2,
+        "coords": {
+          "norm_x": 0.5509033203125,
+          "norm_y": 0.1546088324652778
+        }
+      },
+      {
+        "id": 16,
+        "label": "bullet_hole",
+        "score": 1,
+        "coords": {
+          "norm_x": 0.6156919126157407,
+          "norm_y": 0.1546088324652778
+        }
+      },
+      {
+        "id": 17,
+        "label": "bullet_hole",
+        "score": 1,
+        "coords": {
+          "norm_x": 0.7703251591435185,
+          "norm_y": 0.2360568576388889
+        }
+      },
+      {
+        "id": 18,
+        "label": "bullet_hole",
+        "score": 4,
+        "coords": {
+          "norm_x": 0.7110595703125,
+          "norm_y": 0.3536512586805555
+        }
+      },
+      {
+        "id": 19,
+        "label": "bullet_hole",
+        "score": 7,
+        "coords": {
+          "norm_x": 0.6027524594907407,
+          "norm_y": 0.4129231770833333
+        }
+      },
+      {
+        "id": 20,
+        "label": "bullet_hole",
+        "score": 9,
+        "coords": {
+          "norm_x": 0.4823911313657407,
+          "norm_y": 0.4304877387152777
+        }
+      },
+      {
+        "id": 21,
+        "label": "bullet_hole",
+        "score": 7,
+        "coords": {
+          "norm_x": 0.39627097800925926,
+          "norm_y": 0.43509928385416663
+        }
+      },
+      {
+        "id": 22,
+        "label": "bullet_hole",
+        "score": 5,
+        "coords": {
+          "norm_x": 0.289794921875,
+          "norm_y": 0.43238661024305547
+        }
+      },
+      {
+        "id": 23,
+        "label": "bullet_hole",
+        "score": 2,
+        "coords": {
+          "norm_x": 0.7166440610532407,
+          "norm_y": 0.7693684895833333
+        }
+      },
+      {
+        "id": 24,
+        "label": "bullet_hole",
+        "score": 3,
+        "coords": {
+          "norm_x": 0.7314453125,
+          "norm_y": 0.7008734809027778
+        }
+      },
+      {
+        "id": 25,
+        "label": "bullet_hole",
+        "score": 1,
+        "coords": {
+          "norm_x": 0.7879331235532407,
+          "norm_y": 0.7601453993055556
+        }
+      },
+      {
+        "id": 26,
+        "label": "bullet_hole",
+        "score": 0,
+        "coords": {
+          "norm_x": 0.736083984375,
+          "norm_y": 0.828640407986111
+        }
+      }
+    ]
+  }
+}

backendia/exports/archive_2026-04-30T12-53-35-219Z/images/.gitkeep

@@ -0,0 +1 @@
+# Keep directory structure

backendia/uploads/data/photo-1777554021433-285233602.json

@@ -0,0 +1,90 @@
+{
+  "session_id": "session_1777554006515",
+  "wallet_hash": "cc60fcaa5ef7fdc9be3dd1adba4157fa6dfae2845da45b830b5ef2b7f473d887",
+  "timestamp": "2026-04-30T13:00:06.519693",
+  "device_info": {
+    "model": "google sdk_gphone64_x86_64",
+    "os": "Android 16"
+  },
+  "target_metadata": {
+    "type": "concentric",
+    "distance_meters": 25,
+    "weapon": "Unknown"
+  },
+  "plotting": {
+    "target_corners": [
+      {
+        "norm_x": 0.09999999999999998,
+        "norm_y": 0.09999999999999998
+      },
+      {
+        "norm_x": 0.9,
+        "norm_y": 0.09999999999999998
+      },
+      {
+        "norm_x": 0.9,
+        "norm_y": 0.9
+      },
+      {
+        "norm_x": 0.09999999999999998,
+        "norm_y": 0.9
+      }
+    ],
+    "impacts": [
+      {
+        "id": 1,
+        "label": "bullet_hole",
+        "score": 5,
+        "coords": {
+          "norm_x": 0.267578125,
+          "norm_y": 0.5554741753472222
+        }
+      },
+      {
+        "id": 2,
+        "label": "bullet_hole",
+        "score": 7,
+        "coords": {
+          "norm_x": 0.5712583188657407,
+          "norm_y": 0.3592800564236111
+        }
+      },
+      {
+        "id": 3,
+        "label": "bullet_hole",
+        "score": 4,
+        "coords": {
+          "norm_x": 0.7555239076967593,
+          "norm_y": 0.5703938802083333
+        }
+      },
+      {
+        "id": 4,
+        "label": "bullet_hole",
+        "score": 4,
+        "coords": {
+          "norm_x": 0.6666259765625,
+          "norm_y": 0.6759168836805556
+        }
+      },
+      {
+        "id": 5,
+        "label": "bullet_hole",
+        "score": 9,
+        "coords": {
+          "norm_x": 0.5490415219907407,
+          "norm_y": 0.5212944878472222
+        }
+      },
+      {
+        "id": 6,
+        "label": "bullet_hole",
+        "score": 8,
+        "coords": {
+          "norm_x": 0.4897768373842592,
+          "norm_y": 0.39352756076388895
+        }
+      }
+    ]
+  }
+}

ios/Runner/Info.plist

@@ -2,8 +2,13 @@
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
 <dict>
-	<key>NSCameraUsageDescription</key>
-	<string>This app needs camera access to scan documents</string>
+	<dict>
+    <key>NSPhotoLibraryUsageDescription</key>
+    <string>Bully a besoin d'accéder à vos photos pour analyser vos cibles enregistrées.</string>
+    <key>NSCameraUsageDescription</key>
+    <string>Bully a besoin d'utiliser l'appareil photo pour scanner vos cibles en temps réel.</string>
+    <key>NSMicrophoneUsageDescription</key>
+    <string>Bully a besoin d'accéder au micro (requis par certains services de caméra même si non utilisé).</string>
 	<key>CADisableMinimumFrameDurationOnPhone</key>
 	<true/>
 	<key>CFBundleDevelopmentRegion</key>

lib/app.dart

@@ -1,19 +1,36 @@
 import 'package:flutter/material.dart';
+import 'package:provider/provider.dart';
+import 'core/theme/theme_provider.dart';
 import 'core/theme/app_theme.dart';
+import 'main_navigation_holder.dart';
 import 'features/home/home_screen.dart';
+import 'package:flutter_localizations/flutter_localizations.dart';
 
 class BullyApp extends StatelessWidget {
   const BullyApp({super.key});
 
   @override
   Widget build(BuildContext context) {
-    return MaterialApp(
-      title: 'Bully - Analyse de Cibles',
-      debugShowCheckedModeBanner: false,
-      theme: AppTheme.lightTheme,
-      darkTheme: AppTheme.darkTheme,
-      themeMode: ThemeMode.system,
-      home: const HomeScreen(),
+    return Consumer<ThemeProvider>(
+      builder: (context, themeProvider, child) {
+        return MaterialApp(
+          title: 'Bully - Analyse de Cibles',
+          debugShowCheckedModeBanner: false,
+          theme: AppTheme.lightTheme,
+          darkTheme: AppTheme.darkTheme,
+          themeMode: themeProvider.themeMode,
+          localizationsDelegates: const [
+            GlobalMaterialLocalizations.delegate,
+            GlobalWidgetsLocalizations.delegate,
+            GlobalCupertinoLocalizations.delegate,
+          ],
+          supportedLocales: const [
+            Locale('fr', 'FR'), // Français
+          ],
+          locale: const Locale('fr', 'FR'), // Force l'interface en français
+          home: const MainNavigationHolder(),
+        );
+      },
     );
   }
 }

lib/core/constants/app_constants.dart

@@ -3,11 +3,14 @@ class AppConstants {
 
   // Database
   static const String databaseName = 'bully_targets.db';
-  static const int databaseVersion = 1;
+  static const int databaseVersion = 6;
 
   // Tables
   static const String sessionsTable = 'sessions';
+  static const String targetAnalysesTable = 'target_analyses';
   static const String shotsTable = 'shots';
+  static const String weaponsTable = 'weapons';
+  static const String maintenanceTable = 'weapon_maintenance';
 
   // Image processing
   static const double minImpactRadius = 2.0;

lib/core/theme/theme_provider.dart

@@ -0,0 +1,44 @@
+import 'package:flutter/material.dart';
+import 'package:shared_preferences/shared_preferences.dart';
+
+class ThemeProvider with ChangeNotifier {
+  static const String _themeModeKey = 'user_theme_mode';
+  
+  ThemeMode _themeMode = ThemeMode.system;
+
+  ThemeMode get themeMode => _themeMode;
+
+  ThemeProvider() {
+    loadThemeMode();
+  }
+
+  Future<void> loadThemeMode() async {
+    final prefs = await SharedPreferences.getInstance();
+    final modeIndex = prefs.getInt(_themeModeKey);
+    if (modeIndex != null) {
+      _themeMode = ThemeMode.values[modeIndex];
+      notifyListeners();
+    }
+  }
+
+  Future<void> setThemeMode(ThemeMode mode) async {
+    if (_themeMode == mode) return;
+    
+    _themeMode = mode;
+    notifyListeners();
+    
+    final prefs = await SharedPreferences.getInstance();
+    await prefs.setInt(_themeModeKey, mode.index);
+  }
+
+  String get themeModeName {
+    switch (_themeMode) {
+      case ThemeMode.system:
+        return 'Automatique';
+      case ThemeMode.light:
+        return 'Clair';
+      case ThemeMode.dark:
+        return 'Sombre';
+    }
+  }
+}

lib/data/database/database_helper.dart

@@ -1,7 +1,11 @@
+import 'dart:io';
 import 'package:sqflite/sqflite.dart';
 import 'package:path/path.dart';
 import '../models/session.dart';
+import '../models/target_analysis.dart';
 import '../models/shot.dart';
+import '../models/weapon.dart';
+import '../models/maintenance.dart';
 import '../../core/constants/app_constants.dart';
 
 class DatabaseHelper {
@@ -36,6 +40,19 @@ class DatabaseHelper {
     await db.execute('''
       CREATE TABLE ${AppConstants.sessionsTable} (
         id TEXT PRIMARY KEY,
+        weapon TEXT NOT NULL,
+        weapon_id TEXT,
+        max_shots_per_target INTEGER NOT NULL,
+        created_at TEXT NOT NULL,
+        notes TEXT,
+        distance INTEGER DEFAULT 25
+      )
+    ''');
+
+    await db.execute('''
+      CREATE TABLE ${AppConstants.targetAnalysesTable} (
+        id TEXT PRIMARY KEY,
+        session_id TEXT NOT NULL,
         target_type TEXT NOT NULL,
         image_path TEXT NOT NULL,
         total_score INTEGER NOT NULL,
@@ -46,7 +63,8 @@ class DatabaseHelper {
         notes TEXT,
         target_center_x REAL,
         target_center_y REAL,
-        target_radius REAL
+        target_radius REAL,
+        FOREIGN KEY (session_id) REFERENCES ${AppConstants.sessionsTable}(id) ON DELETE CASCADE
       )
     ''');
 
@@ -56,48 +74,262 @@ class DatabaseHelper {
         x REAL NOT NULL,
         y REAL NOT NULL,
         score INTEGER NOT NULL,
-        session_id TEXT NOT NULL,
-        FOREIGN KEY (session_id) REFERENCES ${AppConstants.sessionsTable}(id) ON DELETE CASCADE
+        analysis_id TEXT NOT NULL,
+        FOREIGN KEY (analysis_id) REFERENCES ${AppConstants.targetAnalysesTable}(id) ON DELETE CASCADE
       )
     ''');
 
     await db.execute('''
-      CREATE INDEX idx_shots_session_id ON ${AppConstants.shotsTable}(session_id)
+      CREATE INDEX idx_target_analyses_session_id ON ${AppConstants.targetAnalysesTable}(session_id)
+    ''');
+
+    await db.execute('''
+      CREATE INDEX idx_shots_analysis_id ON ${AppConstants.shotsTable}(analysis_id)
     ''');
 
     await db.execute('''
       CREATE INDEX idx_sessions_created_at ON ${AppConstants.sessionsTable}(created_at DESC)
     ''');
+
+    await db.execute('''
+      CREATE TABLE ${AppConstants.weaponsTable} (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        type TEXT NOT NULL,
+        caliber TEXT NOT NULL,
+        magazine_count INTEGER NOT NULL,
+        magazine_capacity INTEGER NOT NULL,
+        notes TEXT,
+        created_at TEXT NOT NULL,
+        optic TEXT,
+        silencer TEXT,
+        trigger TEXT,
+        custom_name TEXT
+      )
+    ''');
+
+    await db.execute('''
+      CREATE TABLE ${AppConstants.maintenanceTable} (
+        id TEXT PRIMARY KEY,
+        weapon_id TEXT NOT NULL,
+        type TEXT NOT NULL,
+        description TEXT NOT NULL,
+        date TEXT NOT NULL,
+        rounds_since_last INTEGER,
+        FOREIGN KEY (weapon_id) REFERENCES ${AppConstants.weaponsTable}(id) ON DELETE CASCADE
+      )
+    ''');
   }
 
   Future<void> _onUpgrade(Database db, int oldVersion, int newVersion) async {
-    // Handle future database migrations here
+    if (oldVersion < 2) {
+      // Migration from single-target sessions to multi-target sessions
+
+      // 1. Rename existing sessions table to a temporary name
+      await db.execute('ALTER TABLE ${AppConstants.sessionsTable} RENAME TO sessions_old');
+
+      // 2. Create the new sessions table
+      await db.execute('''
+        CREATE TABLE ${AppConstants.sessionsTable} (
+          id TEXT PRIMARY KEY,
+          weapon TEXT NOT NULL,
+          max_shots_per_target INTEGER NOT NULL,
+          created_at TEXT NOT NULL,
+          notes TEXT
+        )
+      ''');
+
+      // 3. Create the new target_analyses table
+      await db.execute('''
+        CREATE TABLE ${AppConstants.targetAnalysesTable} (
+          id TEXT PRIMARY KEY,
+          session_id TEXT NOT NULL,
+          target_type TEXT NOT NULL,
+          image_path TEXT NOT NULL,
+          total_score INTEGER NOT NULL,
+          grouping_diameter REAL,
+          grouping_center_x REAL,
+          grouping_center_y REAL,
+          created_at TEXT NOT NULL,
+          notes TEXT,
+          target_center_x REAL,
+          target_center_y REAL,
+          target_radius REAL,
+          FOREIGN KEY (session_id) REFERENCES ${AppConstants.sessionsTable}(id) ON DELETE CASCADE
+        )
+      ''');
+
+      // 4. Update shots table (rename session_id to analysis_id)
+      await db.execute('ALTER TABLE ${AppConstants.shotsTable} RENAME TO shots_old');
+      await db.execute('''
+        CREATE TABLE ${AppConstants.shotsTable} (
+          id TEXT PRIMARY KEY,
+          x REAL NOT NULL,
+          y REAL NOT NULL,
+          score INTEGER NOT NULL,
+          analysis_id TEXT NOT NULL,
+          FOREIGN KEY (analysis_id) REFERENCES ${AppConstants.targetAnalysesTable}(id) ON DELETE CASCADE
+        )
+      ''');
+
+      // 5. Migrate data
+      // For each old session, create one session and one target_analysis
+      final oldSessions = await db.query('sessions_old');
+      for (final old in oldSessions) {
+        final sessionId = old['id'] as String;
+        final analysisId = 'analysis_$sessionId'; // Create a unique ID for the analysis
+
+        // Insert into new sessions
+        await db.insert(AppConstants.sessionsTable, {
+          'id': sessionId,
+          'weapon': 'Inconnue',
+          'max_shots_per_target': 5,
+          'created_at': old['created_at'],
+          'notes': old['notes'],
+        });
+
+        // Insert into target_analyses
+        await db.insert(AppConstants.targetAnalysesTable, {
+          'id': analysisId,
+          'session_id': sessionId,
+          'target_type': old['target_type'],
+          'image_path': old['image_path'],
+          'total_score': old['total_score'],
+          'grouping_diameter': old['grouping_diameter'],
+          'grouping_center_x': old['grouping_center_x'],
+          'grouping_center_y': old['grouping_center_y'],
+          'created_at': old['created_at'],
+          'notes': null,
+          'target_center_x': old['target_center_x'],
+          'target_center_y': old['target_center_y'],
+          'target_radius': old['target_radius'],
+        });
+
+        // Migrate shots from shots_old to shots
+        final oldShots = await db.query('shots_old', where: 'session_id = ?', whereArgs: [sessionId]);
+        for (final shot in oldShots) {
+          await db.insert(AppConstants.shotsTable, {
+            'id': shot['id'],
+            'x': shot['x'],
+            'y': shot['y'],
+            'score': shot['score'],
+            'analysis_id': analysisId,
+          });
+        }
+      }
+
+      // 6. Cleanup
+      await db.execute('DROP TABLE sessions_old');
+      await db.execute('DROP TABLE shots_old');
+
+      // 7. Re-create indexes
+      await db.execute('''
+        CREATE INDEX idx_target_analyses_session_id ON ${AppConstants.targetAnalysesTable}(session_id)
+      ''');
+      await db.execute('''
+        CREATE INDEX idx_shots_analysis_id ON ${AppConstants.shotsTable}(analysis_id)
+      ''');
+      await db.execute('''
+        CREATE INDEX idx_sessions_created_at ON ${AppConstants.sessionsTable}(created_at DESC)
+      ''');
+    }
+
+    if (oldVersion < 3) {
+      // Add weapons table
+      await db.execute('''
+        CREATE TABLE ${AppConstants.weaponsTable} (
+          id TEXT PRIMARY KEY,
+          name TEXT NOT NULL,
+          type TEXT NOT NULL,
+          caliber TEXT NOT NULL,
+          magazine_count INTEGER NOT NULL,
+          magazine_capacity INTEGER NOT NULL,
+          notes TEXT,
+          created_at TEXT NOT NULL
+        )
+      ''');
+
+      // Add weapon_id to sessions table
+      await db.execute('ALTER TABLE ${AppConstants.sessionsTable} ADD COLUMN weapon_id TEXT');
+    }
+
+    if (oldVersion < 4) {
+      // Add maintenance table
+      await db.execute('''
+        CREATE TABLE ${AppConstants.maintenanceTable} (
+          id TEXT PRIMARY KEY,
+          weapon_id TEXT NOT NULL,
+          type TEXT NOT NULL,
+          description TEXT NOT NULL,
+          date TEXT NOT NULL,
+          rounds_since_last INTEGER,
+          FOREIGN KEY (weapon_id) REFERENCES ${AppConstants.weaponsTable}(id) ON DELETE CASCADE
+        )
+      ''');
+    }
+
+    if (oldVersion < 5) {
+      // Add new weapon options columns
+      await db.execute('ALTER TABLE ${AppConstants.weaponsTable} ADD COLUMN optic TEXT');
+      await db.execute('ALTER TABLE ${AppConstants.weaponsTable} ADD COLUMN silencer TEXT');
+      await db.execute('ALTER TABLE ${AppConstants.weaponsTable} ADD COLUMN "trigger" TEXT');
+      await db.execute('ALTER TABLE ${AppConstants.weaponsTable} ADD COLUMN custom_name TEXT');
+    }
+
+    if (oldVersion < 6) {
+      // Add distance column to sessions
+      await db.execute('ALTER TABLE ${AppConstants.sessionsTable} ADD COLUMN distance INTEGER DEFAULT 25');
+    }
   }
 
   // Session operations
   Future<int> insertSession(Session session) async {
     final db = await database;
     return await db.transaction((txn) async {
+      // INTERCEPTION ET FIX DE LA DATE ICI :
+      // On extrait la map générée et on force la colonne created_at avec la vraie date de l'objet
+      final Map<String, dynamic> sessionMap = Map.from(session.toMap());
+      sessionMap['created_at'] = session.createdAt.toIso8601String();
+
       await txn.insert(
         AppConstants.sessionsTable,
-        session.toMap(),
+        sessionMap, // On utilise notre map corrigée au lieu de session.toMap() direct !
         conflictAlgorithm: ConflictAlgorithm.replace,
       );
 
-      for (final shot in session.shots) {
-        // Ensure shot has correct session_id
-        final shotWithSessionId = shot.copyWith(sessionId: session.id);
-        await txn.insert(
-          AppConstants.shotsTable,
-          shotWithSessionId.toMap(),
-          conflictAlgorithm: ConflictAlgorithm.replace,
-        );
+      for (final analysis in session.analyses) {
+        await insertTargetAnalysisTx(txn, analysis, session.id);
       }
 
       return 1;
     });
   }
 
+  Future<void> insertTargetAnalysis(TargetAnalysis analysis, String sessionId) async {
+    final db = await database;
+    await db.transaction((txn) async {
+      await insertTargetAnalysisTx(txn, analysis, sessionId);
+    });
+  }
+
+  Future<void> insertTargetAnalysisTx(Transaction txn, TargetAnalysis analysis, String sessionId) async {
+    final analysisWithSessionId = analysis.copyWith(sessionId: sessionId);
+    await txn.insert(
+      AppConstants.targetAnalysesTable,
+      analysisWithSessionId.toMap(),
+      conflictAlgorithm: ConflictAlgorithm.replace,
+    );
+
+    for (final shot in analysis.shots) {
+      final shotWithAnalysisId = shot.copyWith(analysisId: analysis.id);
+      await txn.insert(
+        AppConstants.shotsTable,
+        shotWithAnalysisId.toMap(),
+        conflictAlgorithm: ConflictAlgorithm.replace,
+      );
+    }
+  }
+
   Future<Session?> getSession(String id) async {
     final db = await database;
     final sessionMaps = await db.query(
@@ -108,106 +340,52 @@ class DatabaseHelper {
 
     if (sessionMaps.isEmpty) return null;
 
-    final shotMaps = await db.query(
-      AppConstants.shotsTable,
+    final analysisMaps = await db.query(
+      AppConstants.targetAnalysesTable,
       where: 'session_id = ?',
       whereArgs: [id],
     );
 
-    final shots = shotMaps.map((map) => Shot.fromMap(map)).toList();
-    return Session.fromMap(sessionMaps.first, shots);
+    final analyses = <TargetAnalysis>[];
+    for (final analysisMap in analysisMaps) {
+      final analysisId = analysisMap['id'] as String;
+      final shotMaps = await db.query(
+        AppConstants.shotsTable,
+        where: 'analysis_id = ?',
+        whereArgs: [analysisId],
+      );
+      final shots = shotMaps.map((map) => Shot.fromMap(map)).toList();
+      analyses.add(TargetAnalysis.fromMap(analysisMap, shots));
+    }
+
+    return Session.fromMap(sessionMaps.first, analyses);
   }
 
   Future<List<Session>> getAllSessions({
-    String? targetType,
     int? limit,
     int? offset,
   }) async {
     final db = await database;
 
-    String? whereClause;
-    List<dynamic>? whereArgs;
-
-    if (targetType != null) {
-      whereClause = 'target_type = ?';
-      whereArgs = [targetType];
-    }
-
     final sessionMaps = await db.query(
       AppConstants.sessionsTable,
-      where: whereClause,
-      whereArgs: whereArgs,
       orderBy: 'created_at DESC',
       limit: limit,
       offset: offset,
     );
 
-    // First, check if there are orphaned shots (with empty session_id)
-    // and only one session - if so, assign them to that session
-    if (sessionMaps.length == 1) {
-      final orphanedShots = await db.query(
-        AppConstants.shotsTable,
-        where: 'session_id = ?',
-        whereArgs: [''],
-      );
-      if (orphanedShots.isNotEmpty) {
-        await db.update(
-          AppConstants.shotsTable,
-          {'session_id': sessionMaps.first['id']},
-          where: 'session_id = ?',
-          whereArgs: [''],
-        );
-      }
-    }
-
     final sessions = <Session>[];
     for (final sessionMap in sessionMaps) {
       final sessionId = sessionMap['id'] as String;
-
-      final shotMaps = await db.query(
-        AppConstants.shotsTable,
-        where: 'session_id = ?',
-        whereArgs: [sessionId],
-      );
-
-      final shots = shotMaps.map((map) => Shot.fromMap(map)).toList();
-      sessions.add(Session.fromMap(sessionMap, shots));
+      final session = await getSession(sessionId);
+      if (session != null) {
+        sessions.add(session);
+      }
     }
 
     return sessions;
   }
 
-  Future<int> updateSession(Session session) async {
-    final db = await database;
-    return await db.transaction((txn) async {
-      await txn.update(
-        AppConstants.sessionsTable,
-        session.toMap(),
-        where: 'id = ?',
-        whereArgs: [session.id],
-      );
-
-      // Delete existing shots and insert new ones
-      await txn.delete(
-        AppConstants.shotsTable,
-        where: 'session_id = ?',
-        whereArgs: [session.id],
-      );
-
-      for (final shot in session.shots) {
-        // Ensure shot has correct session_id
-        final shotWithSessionId = shot.copyWith(sessionId: session.id);
-        await txn.insert(
-          AppConstants.shotsTable,
-          shotWithSessionId.toMap(),
-          conflictAlgorithm: ConflictAlgorithm.replace,
-        );
-      }
-
-      return 1;
-    });
-  }
-
   Future<int> deleteSession(String id) async {
     final db = await database;
     return await db.delete(
@@ -229,12 +407,12 @@ class DatabaseHelper {
     ) ?? 0;
 
     final avgScore = (await db.rawQuery(
-      'SELECT AVG(total_score) as avg FROM ${AppConstants.sessionsTable}',
+      'SELECT AVG(total_score) as avg FROM ${AppConstants.targetAnalysesTable}',
     )).first['avg'] as double? ?? 0.0;
 
     final bestScore = Sqflite.firstIntValue(
       await db.rawQuery(
-        'SELECT MAX(total_score) FROM ${AppConstants.sessionsTable}',
+        'SELECT MAX(total_score) FROM ${AppConstants.targetAnalysesTable}',
       ),
     ) ?? 0;
 
@@ -246,9 +424,124 @@ class DatabaseHelper {
     };
   }
 
+  // Weapon operations
+  Future<int> insertWeapon(Weapon weapon) async {
+    final db = await database;
+    return await db.insert(
+      AppConstants.weaponsTable,
+      weapon.toMap(),
+      conflictAlgorithm: ConflictAlgorithm.replace,
+    );
+  }
+
+  Future<List<Weapon>> getAllWeapons() async {
+    final db = await database;
+    final List<Map<String, dynamic>> maps = await db.query(AppConstants.weaponsTable, orderBy: 'name ASC');
+    return List.generate(maps.length, (i) => Weapon.fromMap(maps[i]));
+  }
+
+  Future<Weapon?> getWeapon(String id) async {
+    final db = await database;
+    final List<Map<String, dynamic>> maps = await db.query(
+      AppConstants.weaponsTable,
+      where: 'id = ?',
+      whereArgs: [id],
+    );
+    if (maps.isEmpty) return null;
+    return Weapon.fromMap(maps.first);
+  }
+
+  Future<int> updateWeapon(Weapon weapon) async {
+    final db = await database;
+
+    // Start a transaction to ensure both updates succeed
+    return await db.transaction((txn) async {
+      // 1. Update weapon in armory
+      final count = await txn.update(
+        AppConstants.weaponsTable,
+        weapon.toMap(),
+        where: 'id = ?',
+        whereArgs: [weapon.id],
+      );
+
+      // 2. Propagate name change to all sessions linked to this weapon
+      await txn.update(
+        AppConstants.sessionsTable,
+        {'weapon': weapon.displayName},
+        where: 'weapon_id = ?',
+        whereArgs: [weapon.id],
+      );
+
+      return count;
+    });
+  }
+
+  Future<int> deleteWeapon(String id) async {
+    final db = await database;
+
+    return await db.transaction((txn) async {
+      // 1. Unlink sessions from this weapon but KEEP the name (gravé à jamais)
+      await txn.update(
+        AppConstants.sessionsTable,
+        {'weapon_id': null},
+        where: 'weapon_id = ?',
+        whereArgs: [id],
+      );
+
+      // 2. Delete the weapon record
+      return await txn.delete(
+        AppConstants.weaponsTable,
+        where: 'id = ?',
+        whereArgs: [id],
+      );
+    });
+  }
+
+  // Weapon statistics & Maintenance
+  Future<int> getRoundsFiredForWeapon(String weaponId) async {
+    final db = await database;
+    final result = await db.rawQuery('''
+      SELECT COUNT(s.id) as count 
+      FROM ${AppConstants.shotsTable} s
+      JOIN ${AppConstants.targetAnalysesTable} ta ON s.analysis_id = ta.id
+      JOIN ${AppConstants.sessionsTable} sess ON ta.session_id = sess.id
+      WHERE sess.weapon_id = ?
+    ''', [weaponId]);
+    return Sqflite.firstIntValue(result) ?? 0;
+  }
+
+  Future<int> insertMaintenance(MaintenanceEntry entry) async {
+    final db = await database;
+    return await db.insert(
+      AppConstants.maintenanceTable,
+      entry.toMap(),
+      conflictAlgorithm: ConflictAlgorithm.replace,
+    );
+  }
+
+  Future<List<MaintenanceEntry>> getMaintenanceForWeapon(String weaponId) async {
+    final db = await database;
+    final maps = await db.query(
+      AppConstants.maintenanceTable,
+      where: 'weapon_id = ?',
+      orderBy: 'date DESC',
+      whereArgs: [weaponId],
+    );
+    return List.generate(maps.length, (i) => MaintenanceEntry.fromMap(maps[i]));
+  }
+
+  Future<int> deleteMaintenance(String id) async {
+    final db = await database;
+    return await db.delete(
+      AppConstants.maintenanceTable,
+      where: 'id = ?',
+      whereArgs: [id],
+    );
+  }
+
   Future<void> close() async {
     final db = await database;
     await db.close();
     _database = null;
   }
-}
+}

lib/data/models/maintenance.dart

@@ -0,0 +1,57 @@
+enum MaintenanceType {
+  cleaning('Nettoyage'),
+  repair('Réparation'),
+  inspection('Inspection'),
+  upgrade('Amélioration'),
+  other('Autre');
+
+  final String displayName;
+  const MaintenanceType(this.displayName);
+
+  static MaintenanceType fromString(String value) {
+    return MaintenanceType.values.firstWhere(
+      (type) => type.name == value,
+      orElse: () => MaintenanceType.other,
+    );
+  }
+}
+
+class MaintenanceEntry {
+  final String id;
+  final String weaponId;
+  final MaintenanceType type;
+  final String description;
+  final DateTime date;
+  final int? roundsSinceLastMaintenance;
+
+  MaintenanceEntry({
+    required this.id,
+    required this.weaponId,
+    required this.type,
+    required this.description,
+    required this.date,
+    this.roundsSinceLastMaintenance,
+  });
+
+  Map<String, dynamic> toMap() {
+    return {
+      'id': id,
+      'weapon_id': weaponId,
+      'type': type.name,
+      'description': description,
+      'date': date.toIso8601String(),
+      'rounds_since_last': roundsSinceLastMaintenance,
+    };
+  }
+
+  factory MaintenanceEntry.fromMap(Map<String, dynamic> map) {
+    return MaintenanceEntry(
+      id: map['id'] as String,
+      weaponId: map['weapon_id'] as String,
+      type: MaintenanceType.fromString(map['type'] as String),
+      description: map['description'] as String,
+      date: DateTime.parse(map['date'] as String),
+      roundsSinceLastMaintenance: map['rounds_since_last'] as int?,
+    );
+  }
+}

lib/data/models/session.dart

@@ -1,112 +1,83 @@
-import 'shot.dart';
-import 'target_type.dart';
+import 'target_analysis.dart';
 
 class Session {
   final String id;
-  final TargetType targetType;
-  final String imagePath;
-  final List<Shot> shots;
-  final int totalScore;
-  final double? groupingDiameter;
-  final double? groupingCenterX;
-  final double? groupingCenterY;
+  final String weapon;
+  final String? weaponId;
+  final int maxShotsPerTarget;
+  final List<TargetAnalysis> analyses;
   final DateTime createdAt;
   final String? notes;
-
-  // Target detection data
-  final double? targetCenterX;
-  final double? targetCenterY;
-  final double? targetRadius;
+  final int distance; // Shooting distance in meters
 
   Session({
     required this.id,
-    required this.targetType,
-    required this.imagePath,
-    required this.shots,
-    required this.totalScore,
-    this.groupingDiameter,
-    this.groupingCenterX,
-    this.groupingCenterY,
+    required this.weapon,
+    this.weaponId,
+    required this.maxShotsPerTarget,
+    required this.analyses,
     required this.createdAt,
     this.notes,
-    this.targetCenterX,
-    this.targetCenterY,
-    this.targetRadius,
+    this.distance = 25, // Default distance
   });
 
-  int get shotCount => shots.length;
+  int get targetCount => analyses.length;
+  
+  int get totalShots => analyses.fold(0, (sum, a) => sum + a.shotCount);
+  
+  int get totalScore => analyses.fold(0, (sum, a) => sum + a.totalScore);
 
-  double get averageScore => shots.isEmpty ? 0.0 : totalScore / shots.length;
+  double get averageScore => analyses.isEmpty ? 0.0 : totalScore / analyses.length;
 
   Session copyWith({
     String? id,
-    TargetType? targetType,
-    String? imagePath,
-    List<Shot>? shots,
-    int? totalScore,
-    double? groupingDiameter,
-    double? groupingCenterX,
-    double? groupingCenterY,
+    String? weapon,
+    String? weaponId,
+    int? maxShotsPerTarget,
+    List<TargetAnalysis>? analyses,
     DateTime? createdAt,
     String? notes,
-    double? targetCenterX,
-    double? targetCenterY,
-    double? targetRadius,
+    int? distance,
   }) {
     return Session(
       id: id ?? this.id,
-      targetType: targetType ?? this.targetType,
-      imagePath: imagePath ?? this.imagePath,
-      shots: shots ?? this.shots,
-      totalScore: totalScore ?? this.totalScore,
-      groupingDiameter: groupingDiameter ?? this.groupingDiameter,
-      groupingCenterX: groupingCenterX ?? this.groupingCenterX,
-      groupingCenterY: groupingCenterY ?? this.groupingCenterY,
+      weapon: weapon ?? this.weapon,
+      weaponId: weaponId ?? this.weaponId,
+      maxShotsPerTarget: maxShotsPerTarget ?? this.maxShotsPerTarget,
+      analyses: analyses ?? this.analyses,
       createdAt: createdAt ?? this.createdAt,
       notes: notes ?? this.notes,
-      targetCenterX: targetCenterX ?? this.targetCenterX,
-      targetCenterY: targetCenterY ?? this.targetCenterY,
-      targetRadius: targetRadius ?? this.targetRadius,
+      distance: distance ?? this.distance,
     );
   }
 
   Map<String, dynamic> toMap() {
     return {
       'id': id,
-      'target_type': targetType.name,
-      'image_path': imagePath,
-      'total_score': totalScore,
-      'grouping_diameter': groupingDiameter,
-      'grouping_center_x': groupingCenterX,
-      'grouping_center_y': groupingCenterY,
+      'weapon': weapon,
+      'weapon_id': weaponId,
+      'max_shots_per_target': maxShotsPerTarget,
       'created_at': createdAt.toIso8601String(),
       'notes': notes,
-      'target_center_x': targetCenterX,
-      'target_center_y': targetCenterY,
-      'target_radius': targetRadius,
+      'distance': distance,
     };
   }
 
-  factory Session.fromMap(Map<String, dynamic> map, List<Shot> shots) {
+  factory Session.fromMap(Map<String, dynamic> map, List<TargetAnalysis> analyses) {
     return Session(
       id: map['id'] as String,
-      targetType: TargetType.fromString(map['target_type'] as String),
-      imagePath: map['image_path'] as String,
-      shots: shots,
-      totalScore: map['total_score'] as int,
-      groupingDiameter: map['grouping_diameter'] as double?,
-      groupingCenterX: map['grouping_center_x'] as double?,
-      groupingCenterY: map['grouping_center_y'] as double?,
+      weapon: map['weapon'] as String? ?? 'Inconnue',
+      weaponId: map['weapon_id'] as String?,
+      maxShotsPerTarget: map['max_shots_per_target'] as int? ?? 5,
+      analyses: analyses,
       createdAt: DateTime.parse(map['created_at'] as String),
       notes: map['notes'] as String?,
-      targetCenterX: map['target_center_x'] as double?,
-      targetCenterY: map['target_center_y'] as double?,
-      targetRadius: map['target_radius'] as double?,
+      distance: map['distance'] as int? ?? 25,
     );
   }
 
   @override
   String toString() {
-    return 'Session(id: $id, targetType: $targetType, shots: ${shots.length}, totalScore: $totalScore, createdAt: $createdAt)';
+    return 'Session(id: $id, weapon: $weapon, distance: ${distance}m, targets: ${analyses.length}, createdAt: $createdAt)';
   }
 }

lib/data/models/shot.dart

@@ -3,14 +3,14 @@ class Shot {
   final double x; // Relative position (0.0 - 1.0)
   final double y; // Relative position (0.0 - 1.0)
   final int score;
-  final String sessionId;
+  final String analysisId;
 
   Shot({
     required this.id,
     required this.x,
     required this.y,
     required this.score,
-    required this.sessionId,
+    required this.analysisId,
   });
 
   Shot copyWith({
@@ -18,14 +18,14 @@ class Shot {
     double? x,
     double? y,
     int? score,
-    String? sessionId,
+    String? analysisId,
   }) {
     return Shot(
       id: id ?? this.id,
       x: x ?? this.x,
       y: y ?? this.y,
       score: score ?? this.score,
-      sessionId: sessionId ?? this.sessionId,
+      analysisId: analysisId ?? this.analysisId,
     );
   }
 
@@ -35,7 +35,7 @@ class Shot {
       'x': x,
       'y': y,
       'score': score,
-      'session_id': sessionId,
+      'analysis_id': analysisId,
     };
   }
 
@@ -45,13 +45,13 @@ class Shot {
       x: (map['x'] as num).toDouble(),
       y: (map['y'] as num).toDouble(),
       score: map['score'] as int,
-      sessionId: map['session_id'] as String,
+      analysisId: map['analysis_id'] as String? ?? map['session_id'] as String? ?? '',
     );
   }
 
   @override
   String toString() {
-    return 'Shot(id: $id, x: $x, y: $y, score: $score, sessionId: $sessionId)';
+    return 'Shot(id: $id, x: $x, y: $y, score: $score, analysisId: $analysisId)';
   }
 
   @override
@@ -62,11 +62,11 @@ class Shot {
         other.x == x &&
         other.y == y &&
         other.score == score &&
-        other.sessionId == sessionId;
+        other.analysisId == analysisId;
   }
 
   @override
   int get hashCode {
-    return id.hashCode ^ x.hashCode ^ y.hashCode ^ score.hashCode ^ sessionId.hashCode;
+    return id.hashCode ^ x.hashCode ^ y.hashCode ^ score.hashCode ^ analysisId.hashCode;
   }
 }

lib/data/models/target_analysis.dart

@@ -0,0 +1,113 @@
+import 'shot.dart';
+import 'target_type.dart';
+
+class TargetAnalysis {
+  final String id;
+  final String sessionId;
+  final TargetType targetType;
+  final String imagePath;
+  final List<Shot> shots;
+  final int totalScore;
+  final double? groupingDiameter;
+  final double? groupingCenterX;
+  final double? groupingCenterY;
+  final DateTime createdAt;
+  final String? notes;
+
+  // Target detection data
+  final double? targetCenterX;
+  final double? targetCenterY;
+  final double? targetRadius;
+
+  TargetAnalysis({
+    required this.id,
+    required this.sessionId,
+    required this.targetType,
+    required this.imagePath,
+    required this.shots,
+    required this.totalScore,
+    this.groupingDiameter,
+    this.groupingCenterX,
+    this.groupingCenterY,
+    required this.createdAt,
+    this.notes,
+    this.targetCenterX,
+    this.targetCenterY,
+    this.targetRadius,
+  });
+
+  int get shotCount => shots.length;
+
+  double get averageScore => shots.isEmpty ? 0.0 : totalScore / shots.length;
+
+  TargetAnalysis copyWith({
+    String? id,
+    String? sessionId,
+    TargetType? targetType,
+    String? imagePath,
+    List<Shot>? shots,
+    int? totalScore,
+    double? groupingDiameter,
+    double? groupingCenterX,
+    double? groupingCenterY,
+    DateTime? createdAt,
+    String? notes,
+    double? targetCenterX,
+    double? targetCenterY,
+    double? targetRadius,
+  }) {
+    return TargetAnalysis(
+      id: id ?? this.id,
+      sessionId: sessionId ?? this.sessionId,
+      targetType: targetType ?? this.targetType,
+      imagePath: imagePath ?? this.imagePath,
+      shots: shots ?? this.shots,
+      totalScore: totalScore ?? this.totalScore,
+      groupingDiameter: groupingDiameter ?? this.groupingDiameter,
+      groupingCenterX: groupingCenterX ?? this.groupingCenterX,
+      groupingCenterY: groupingCenterY ?? this.groupingCenterY,
+      createdAt: createdAt ?? this.createdAt,
+      notes: notes ?? this.notes,
+      targetCenterX: targetCenterX ?? this.targetCenterX,
+      targetCenterY: targetCenterY ?? this.targetCenterY,
+      targetRadius: targetRadius ?? this.targetRadius,
+    );
+  }
+
+  Map<String, dynamic> toMap() {
+    return {
+      'id': id,
+      'session_id': sessionId,
+      'target_type': targetType.name,
+      'image_path': imagePath,
+      'total_score': totalScore,
+      'grouping_diameter': groupingDiameter,
+      'grouping_center_x': groupingCenterX,
+      'grouping_center_y': groupingCenterY,
+      'created_at': createdAt.toIso8601String(),
+      'notes': notes,
+      'target_center_x': targetCenterX,
+      'target_center_y': targetCenterY,
+      'target_radius': targetRadius,
+    };
+  }
+
+  factory TargetAnalysis.fromMap(Map<String, dynamic> map, List<Shot> shots) {
+    return TargetAnalysis(
+      id: map['id'] as String,
+      sessionId: map['session_id'] as String,
+      targetType: TargetType.fromString(map['target_type'] as String),
+      imagePath: map['image_path'] as String,
+      shots: shots,
+      totalScore: map['total_score'] as int,
+      groupingDiameter: map['grouping_diameter'] as double?,
+      groupingCenterX: map['grouping_center_x'] as double?,
+      groupingCenterY: map['grouping_center_y'] as double?,
+      createdAt: DateTime.parse(map['created_at'] as String),
+      notes: map['notes'] as String?,
+      targetCenterX: map['target_center_x'] as double?,
+      targetCenterY: map['target_center_y'] as double?,
+      targetRadius: map['target_radius'] as double?,
+    );
+  }
+}

lib/data/models/weapon.dart

@@ -0,0 +1,114 @@
+enum WeaponType {
+  handgun('Arme de Poing'),
+  rifle('Arme d\'Épaule'),
+  shotgun('Fusil à Pompe'),
+  airgun('Airsoft / Airgun');
+
+  final String displayName;
+  const WeaponType(this.displayName);
+
+  static WeaponType fromString(String value) {
+    return WeaponType.values.firstWhere(
+      (type) => type.name == value,
+      orElse: () => WeaponType.handgun,
+    );
+  }
+}
+
+class Weapon {
+  final String id;
+  final String name;
+  final WeaponType type;
+  final String caliber;
+  final int magazineCount;
+  final int magazineCapacity;
+  final String? notes;
+  final DateTime createdAt;
+  
+  // New options
+  final String? optic;
+  final String? silencer;
+  final String? trigger;
+  final String? customName;
+
+  String get displayName => (customName != null && customName!.isNotEmpty) ? customName! : name;
+
+  Weapon({
+    required this.id,
+    required this.name,
+    required this.type,
+    required this.caliber,
+    required this.magazineCount,
+    required this.magazineCapacity,
+    this.notes,
+    required this.createdAt,
+    this.optic,
+    this.silencer,
+    this.trigger,
+    this.customName,
+  });
+
+  Weapon copyWith({
+    String? id,
+    String? name,
+    WeaponType? type,
+    String? caliber,
+    int? magazineCount,
+    int? magazineCapacity,
+    String? notes,
+    DateTime? createdAt,
+    String? optic,
+    String? silencer,
+    String? trigger,
+    String? customName,
+  }) {
+    return Weapon(
+      id: id ?? this.id,
+      name: name ?? this.name,
+      type: type ?? this.type,
+      caliber: caliber ?? this.caliber,
+      magazineCount: magazineCount ?? this.magazineCount,
+      magazineCapacity: magazineCapacity ?? this.magazineCapacity,
+      notes: notes ?? this.notes,
+      createdAt: createdAt ?? this.createdAt,
+      optic: optic ?? this.optic,
+      silencer: silencer ?? this.silencer,
+      trigger: trigger ?? this.trigger,
+      customName: customName ?? this.customName,
+    );
+  }
+
+  Map<String, dynamic> toMap() {
+    return {
+      'id': id,
+      'name': name,
+      'type': type.name,
+      'caliber': caliber,
+      'magazine_count': magazineCount,
+      'magazine_capacity': magazineCapacity,
+      'notes': notes,
+      'created_at': createdAt.toIso8601String(),
+      'optic': optic,
+      'silencer': silencer,
+      'trigger': trigger,
+      'custom_name': customName,
+    };
+  }
+
+  factory Weapon.fromMap(Map<String, dynamic> map) {
+    return Weapon(
+      id: map['id'] as String,
+      name: map['name'] as String,
+      type: WeaponType.fromString(map['type'] as String),
+      caliber: map['caliber'] as String,
+      magazineCount: map['magazine_count'] as int,
+      magazineCapacity: map['magazine_capacity'] as int,
+      notes: map['notes'] as String?,
+      createdAt: DateTime.parse(map['created_at'] as String),
+      optic: map['optic'] as String?,
+      silencer: map['silencer'] as String?,
+      trigger: map['trigger'] as String?,
+      customName: map['custom_name'] as String?,
+    );
+  }
+}

lib/data/repositories/session_repository.dart

@@ -4,8 +4,10 @@ import 'package:path/path.dart' as path;
 import 'package:uuid/uuid.dart';
 import '../database/database_helper.dart';
 import '../models/session.dart';
+import '../models/target_analysis.dart';
 import '../models/shot.dart';
-import '../models/target_type.dart';
+import '../models/weapon.dart';
+import '../models/maintenance.dart';
 
 class SessionRepository {
   final DatabaseHelper _databaseHelper;
@@ -18,8 +20,38 @@ class SessionRepository {
         _uuid = uuid ?? const Uuid();
 
   Future<Session> createSession({
-    required TargetType targetType,
+    String? id,
+    required String weapon,
+    String? weaponId,
+    required int maxShotsPerTarget,
+    required List<TargetAnalysis> analyses,
+    String? notes,
+    int distance = 25,
+    DateTime? date,
+  }) async {
+    final session = Session(
+      id: id ?? _uuid.v4(),
+      weapon: weapon,
+      weaponId: weaponId,
+      maxShotsPerTarget: maxShotsPerTarget,
+      analyses: analyses,
+      createdAt: date ?? DateTime.now(),
+      notes: notes,
+      distance: distance,
+    );
+
+    await _databaseHelper.insertSession(session);
+    return session;
+  }
+
+  Future<void> addAnalysisToSession(String sessionId, TargetAnalysis analysis) async {
+    await _databaseHelper.insertTargetAnalysis(analysis, sessionId);
+  }
+
+  Future<TargetAnalysis> prepareTargetAnalysis({
     required String imagePath,
+    required String sessionId,
+    required dynamic targetType, // TargetType
     required List<Shot> shots,
     required int totalScore,
     double? groupingDiameter,
@@ -33,8 +65,9 @@ class SessionRepository {
     // Copy image to app documents directory
     final savedImagePath = await _saveImage(imagePath);
 
-    final session = Session(
+    return TargetAnalysis(
       id: _uuid.v4(),
+      sessionId: sessionId,
       targetType: targetType,
       imagePath: savedImagePath,
       shots: shots,
@@ -48,9 +81,6 @@ class SessionRepository {
       targetCenterY: targetCenterY,
       targetRadius: targetRadius,
     );
-
-    await _databaseHelper.insertSession(session);
-    return session;
   }
 
   Future<String> _saveImage(String sourcePath) async {
@@ -75,28 +105,23 @@ class SessionRepository {
   }
 
   Future<List<Session>> getAllSessions({
-    TargetType? targetType,
     int? limit,
     int? offset,
   }) async {
     return await _databaseHelper.getAllSessions(
-      targetType: targetType?.name,
       limit: limit,
       offset: offset,
     );
   }
 
-  Future<void> updateSession(Session session) async {
-    await _databaseHelper.updateSession(session);
-  }
-
   Future<void> deleteSession(String id) async {
     final session = await getSession(id);
     if (session != null) {
-      // Delete the image file
-      final imageFile = File(session.imagePath);
-      if (await imageFile.exists()) {
-        await imageFile.delete();
+      for (final analysis in session.analyses) {
+        final imageFile = File(analysis.imagePath);
+        if (await imageFile.exists()) {
+          await imageFile.delete();
+        }
       }
     }
     await _databaseHelper.deleteSession(id);
@@ -106,7 +131,79 @@ class SessionRepository {
     return await _databaseHelper.getStatistics();
   }
 
-  String generateShotId() {
+  String generateId() {
     return _uuid.v4();
   }
+
+  // Weapon Repository methods
+  Future<Weapon> addWeapon({
+    required String name,
+    required WeaponType type,
+    required String caliber,
+    required int magazineCount,
+    required int magazineCapacity,
+    String? notes,
+    String? optic,
+    String? silencer,
+    String? trigger,
+    String? customName,
+  }) async {
+    final weapon = Weapon(
+      id: _uuid.v4(),
+      name: name,
+      type: type,
+      caliber: caliber,
+      magazineCount: magazineCount,
+      magazineCapacity: magazineCapacity,
+      notes: notes,
+      createdAt: DateTime.now(),
+      optic: optic,
+      silencer: silencer,
+      trigger: trigger,
+      customName: customName,
+    );
+    await _databaseHelper.insertWeapon(weapon);
+    return weapon;
+  }
+
+  Future<List<Weapon>> getWeapons() async {
+    return await _databaseHelper.getAllWeapons();
+  }
+
+  Future<void> updateWeapon(Weapon weapon) async {
+    await _databaseHelper.updateWeapon(weapon);
+  }
+
+  Future<void> deleteWeapon(String id) async {
+    await _databaseHelper.deleteWeapon(id);
+  }
+
+  Future<int> getRoundsFiredForWeapon(String weaponId) async {
+    return await _databaseHelper.getRoundsFiredForWeapon(weaponId);
+  }
+
+  Future<void> addMaintenanceEntry({
+    required String weaponId,
+    required MaintenanceType type,
+    required String description,
+    int? roundsSinceLast,
+  }) async {
+    final entry = MaintenanceEntry(
+      id: _uuid.v4(),
+      weaponId: weaponId,
+      type: type,
+      description: description,
+      date: DateTime.now(),
+      roundsSinceLastMaintenance: roundsSinceLast,
+    );
+    await _databaseHelper.insertMaintenance(entry);
+  }
+
+  Future<List<MaintenanceEntry>> getMaintenanceHistory(String weaponId) async {
+    return await _databaseHelper.getMaintenanceForWeapon(weaponId);
+  }
+
+  Future<void> deleteMaintenanceEntry(String id) async {
+    await _databaseHelper.deleteMaintenance(id);
+  }
 }

lib/features/analysis/analysis_provider.dart

@@ -7,9 +7,9 @@ library;
 
 import 'dart:io';
 import 'dart:ui' as ui;
-import 'package:flutter/foundation.dart';
+import 'package:flutter/material.dart';
 import 'package:uuid/uuid.dart';
-import '../../data/models/session.dart';
+import '../../data/models/target_analysis.dart';
 import '../../data/models/shot.dart';
 import '../../data/models/target_type.dart';
 import '../../data/repositories/session_repository.dart';
@@ -39,17 +39,20 @@ class AnalysisProvider extends ChangeNotifier {
     DistortionCorrectionService? distortionService,
     OpenCVTargetService? opencvTargetService,
   }) : _detectionService = detectionService,
-       _scoreCalculatorService = scoreCalculatorService,
-       _groupingAnalyzerService = groupingAnalyzerService,
-       _sessionRepository = sessionRepository,
-       _distortionService = distortionService ?? DistortionCorrectionService(),
-       _opencvTargetService = opencvTargetService ?? OpenCVTargetService();
+        _scoreCalculatorService = scoreCalculatorService,
+        _groupingAnalyzerService = groupingAnalyzerService,
+        _sessionRepository = sessionRepository,
+        _distortionService = distortionService ?? DistortionCorrectionService(),
+        _opencvTargetService = opencvTargetService ?? OpenCVTargetService();
 
   AnalysisState _state = AnalysisState.initial;
   String? _errorMessage;
   String? _imagePath;
   TargetType? _targetType;
 
+  // AJOUT PROTECTION DU PLOTTING : Stockage permanent de la rotation du Crop
+  double _cropRotation = 0.0;
+
   // Target detection results
   double _targetCenterX = 0.5;
   double _targetCenterY = 0.5;
@@ -82,6 +85,7 @@ class AnalysisProvider extends ChangeNotifier {
   String? get errorMessage => _errorMessage;
   String? get imagePath => _imagePath;
   TargetType? get targetType => _targetType;
+  double get cropRotation => _cropRotation; // Getter pour le Plotting
   double get targetCenterX => _targetCenterX;
   double get targetCenterY => _targetCenterY;
   double get targetRadius => _targetRadius;
@@ -109,18 +113,25 @@ class AnalysisProvider extends ChangeNotifier {
   /// Retourne le chemin de l'image à afficher (corrigée si activée, originale sinon)
   String? get displayImagePath =>
       _distortionCorrectionEnabled && _correctedImagePath != null
-      ? _correctedImagePath
-      : _imagePath;
+          ? _correctedImagePath
+          : _imagePath;
+
+  /// Modifie et mémorise la rotation de l'image pour le Plotting
+  void setCropRotation(double rotation) {
+    _cropRotation = rotation;
+    notifyListeners();
+  }
 
   /// Analyze an image
   ///
   /// [autoAnalyze] determines if we should run automatic detection immediately.
   /// If false, only the image is loaded and default target parameters are set.
   Future<void> analyzeImage(
-    String imagePath,
-    TargetType targetType, {
-    bool autoAnalyze = true,
-  }) async {
+      String imagePath,
+      TargetType targetType, {
+        bool autoAnalyze = true,
+        Offset? manualCenter,
+      }) async {
     _state = AnalysisState.loading;
     _imagePath = imagePath;
     _targetType = targetType;
@@ -138,8 +149,8 @@ class AnalysisProvider extends ChangeNotifier {
 
       if (!autoAnalyze) {
         // Just setup default values without running detection
-        _targetCenterX = 0.5;
-        _targetCenterY = 0.5;
+        _targetCenterX = manualCenter?.dx ?? 0.5;
+        _targetCenterY = manualCenter?.dy ?? 0.5;
         _targetRadius = 0.4;
         _targetInnerRadius = 0.04;
 
@@ -151,8 +162,10 @@ class AnalysisProvider extends ChangeNotifier {
         return;
       }
 
-      // Detect target and impacts
-      final result = _detectionService.detectTarget(imagePath, targetType);
+      final result = await _detectionService.detectTargetAsync(
+        imagePath,
+        targetType,
+      );
 
       if (!result.success) {
         _state = AnalysisState.error;
@@ -173,7 +186,7 @@ class AnalysisProvider extends ChangeNotifier {
           x: impact.x,
           y: impact.y,
           score: impact.suggestedScore,
-          sessionId: '', // Will be set when saving
+          analysisId: '',
         );
       }).toList();
 
@@ -195,7 +208,7 @@ class AnalysisProvider extends ChangeNotifier {
   /// Add a manual shot
   void addShot(double x, double y) {
     final score = _calculateShotScore(x, y);
-    final shot = Shot(id: _uuid.v4(), x: x, y: y, score: score, sessionId: '');
+    final shot = Shot(id: _uuid.v4(), x: x, y: y, score: score, analysisId: '');
 
     _shots.add(shot);
     _recalculateScores();
@@ -275,7 +288,7 @@ class AnalysisProvider extends ChangeNotifier {
         x: impact.x,
         y: impact.y,
         score: score,
-        sessionId: '',
+        analysisId: '',
       );
       _shots.add(shot);
     }
@@ -288,14 +301,6 @@ class AnalysisProvider extends ChangeNotifier {
   }
 
   /// 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,
@@ -352,7 +357,7 @@ class AnalysisProvider extends ChangeNotifier {
         x: impact.x,
         y: impact.y,
         score: score,
-        sessionId: '',
+        analysisId: '',
       );
       _shots.add(shot);
     }
@@ -382,15 +387,15 @@ class AnalysisProvider extends ChangeNotifier {
 
     final detectedImpacts = _detectionService
         .detectImpactsWithOpenCVFromReferences(
-          _imagePath!,
-          _targetType!,
-          _targetCenterX,
-          _targetCenterY,
-          _targetRadius,
-          _ringCount,
-          references,
-          tolerance: tolerance,
-        );
+      _imagePath!,
+      _targetType!,
+      _targetCenterX,
+      _targetCenterY,
+      _targetRadius,
+      _ringCount,
+      references,
+      tolerance: tolerance,
+    );
 
     if (clearExisting) {
       _shots.clear();
@@ -404,7 +409,7 @@ class AnalysisProvider extends ChangeNotifier {
         x: impact.x,
         y: impact.y,
         score: score,
-        sessionId: '',
+        analysisId: '',
       );
       _shots.add(shot);
     }
@@ -419,7 +424,7 @@ class AnalysisProvider extends ChangeNotifier {
   /// Add a reference impact for calibrated detection
   void addReferenceImpact(double x, double y) {
     final score = _calculateShotScore(x, y);
-    final shot = Shot(id: _uuid.v4(), x: x, y: y, score: score, sessionId: '');
+    final shot = Shot(id: _uuid.v4(), x: x, y: y, score: score, analysisId: '');
     _referenceImpacts.add(shot);
     notifyListeners();
   }
@@ -489,7 +494,7 @@ class AnalysisProvider extends ChangeNotifier {
         x: impact.x,
         y: impact.y,
         score: score,
-        sessionId: '',
+        analysisId: '',
       );
       _shots.add(shot);
     }
@@ -503,23 +508,26 @@ class AnalysisProvider extends ChangeNotifier {
 
   /// Adjust target position
   void adjustTargetPosition(
-    double centerX,
-    double centerY,
-    double innerRadius,
-    double radius, {
-    int? ringCount,
-    List<double>? ringRadii,
-  }) {
-    _targetCenterX = centerX;
-    _targetCenterY = centerY;
-    _targetInnerRadius = innerRadius;
-    _targetRadius = radius;
+      double centerX,
+      double centerY,
+      double innerRadius,
+      double radius, {
+        int? ringCount,
+        List<double>? ringRadii,
+        double zoomScale = 1.0,
+        Offset offset = Offset.zero,
+      }) {
+    _targetCenterX = (centerX - offset.dx) / zoomScale;
+    _targetCenterY = (centerY - offset.dy) / zoomScale;
+    _targetRadius = radius / zoomScale;
+    _targetInnerRadius = innerRadius / zoomScale;
+
     if (ringCount != null) {
       _ringCount = ringCount;
     }
-    if (ringRadii != null) {
-      _ringRadii = ringRadii;
-    }
+
+    // CORRECTION : On accepte désormais la valeur null pour pouvoir réinitialiser l'espacement !
+    _ringRadii = ringRadii;
 
     // Recalculate all shot scores based on new target position
     _shots = _shots.map((shot) {
@@ -544,8 +552,7 @@ class AnalysisProvider extends ChangeNotifier {
         _imagePath = correctedPath;
         _correctedImagePath = correctedPath;
         _distortionCorrectionEnabled = true;
-        _imageAspectRatio =
-            1.0; // The corrected image is always square (side x side)
+        _imageAspectRatio = 1.0;
         notifyListeners();
       }
 
@@ -563,7 +570,7 @@ class AnalysisProvider extends ChangeNotifier {
       }
       return false;
     } catch (e) {
-      print('Auto-calibration error: $e');
+      debugPrint('Auto-calibration error: $e');
       return false;
     }
   }
@@ -608,7 +615,6 @@ 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)
@@ -624,18 +630,18 @@ class AnalysisProvider extends ChangeNotifier {
       // 3. Application immédiate de la transformation (méthode asynchrone)
       await applyDistortionCorrection();
     } else {
-      notifyListeners(); // On prévient quand même si pas de correction
+      notifyListeners();
     }
   }
 
   Future<void> runFullDistortionWorkflow() async {
-    _state = AnalysisState.loading; // Affiche un spinner sur votre UI
+    _state = AnalysisState.loading;
     notifyListeners();
 
     try {
-      calculateDistortion(); // Calcule les paramètres
-      await applyDistortionCorrection(); // Génère le fichier corrigé
-      _distortionCorrectionEnabled = true; // Active l'affichage
+      calculateDistortion();
+      await applyDistortionCorrection();
+      _distortionCorrectionEnabled = true;
       _state = AnalysisState.success;
     } catch (e) {
       _errorMessage = "Erreur de rendu : $e";
@@ -644,7 +650,6 @@ class AnalysisProvider extends ChangeNotifier {
       notifyListeners();
     }
   }
-  /* fin section deux a tester*/
 
   int _calculateShotScore(double x, double y) {
     if (_targetType == TargetType.concentric) {
@@ -692,24 +697,19 @@ class AnalysisProvider extends ChangeNotifier {
   /// Exporte l'image et le json vers le backend IA
   Future<bool> exportToAiBackend() async {
     if (_imagePath == null || _targetType == null) {
-      _errorMessage = "Impossible d'exporter : image ou type de cible manquant.";
+      _errorMessage = "Impossible d'export : image ou type de cible manquant.";
       notifyListeners();
       return false;
     }
 
-    // Identifiant de session temporaire si non sauvegardée
-    final sessionId = _shots.isNotEmpty && _shots.first.sessionId.isNotEmpty
-        ? _shots.first.sessionId
-        : 'session_${DateTime.now().millisecondsSinceEpoch}';
+    final service = AiExportService();
 
-    final service = AiExportService(); // Local instanciation for simplicity
-    
     _state = AnalysisState.loading;
     notifyListeners();
 
     final success = await service.exportData(
       imagePath: _imagePath!,
-      sessionId: sessionId,
+      sessionId: 'export',
       targetType: _targetType!,
       targetCenterX: _targetCenterX,
       targetCenterY: _targetCenterY,
@@ -726,15 +726,23 @@ class AnalysisProvider extends ChangeNotifier {
   }
 
   /// Save the session
-  Future<Session> saveSession({String? notes}) async {
+  Future<TargetAnalysis> saveSession({
+    String? notes,
+    String? sessionId,
+    String? weaponName,
+    String? weaponId,
+    int? distance,
+    DateTime? date,
+  }) async {
     if (_imagePath == null || _targetType == null) {
       throw Exception('Cannot save: missing image or target type');
     }
 
-    final session = await _sessionRepository.createSession(
-      targetType: _targetType!,
+    final targetAnalysis = await _sessionRepository.prepareTargetAnalysis(
       imagePath: _imagePath!,
-      shots: _shots.map((s) => s.copyWith(sessionId: '')).toList(),
+      sessionId: sessionId ?? 'standalone',
+      targetType: _targetType!,
+      shots: _shots,
       totalScore: totalScore,
       groupingDiameter: _groupingResult?.diameter,
       groupingCenterX: _groupingResult?.centerX,
@@ -745,11 +753,41 @@ class AnalysisProvider extends ChangeNotifier {
       targetRadius: _targetRadius,
     );
 
-    // Update shots with session ID
-    _shots = session.shots;
-    notifyListeners();
+    if (sessionId != null && sessionId != 'standalone') {
+      final existingSession = await _sessionRepository.getSession(sessionId);
+      if (existingSession != null) {
+        await _sessionRepository.addAnalysisToSession(
+          sessionId,
+          targetAnalysis,
+        );
+      } else {
+        // CORRECTION : Utilise la date injectée plutôt que DateTime.now()
+        await _sessionRepository.createSession(
+          id: sessionId,
+          weapon: weaponName ?? 'Inconnue',
+          weaponId: weaponId,
+          maxShotsPerTarget: shotCount,
+          analyses: [targetAnalysis],
+          notes: notes,
+          distance: distance ?? 25,
+          date: date ?? DateTime.now(),
+        );
+      }
+    } else {
+      // CORRECTION : S'applique aussi au flux alternatif sans ID préalable
+      await _sessionRepository.createSession(
+        weapon: weaponName ?? 'Inconnue',
+        weaponId: weaponId,
+        maxShotsPerTarget: shotCount,
+        analyses: [targetAnalysis],
+        notes: notes,
+        distance: distance ?? 25,
+        date: date ?? DateTime.now(),
+      );
+    }
 
-    return session;
+    notifyListeners();
+    return targetAnalysis;
   }
 
   /// Reset the provider
@@ -758,6 +796,7 @@ class AnalysisProvider extends ChangeNotifier {
     _errorMessage = null;
     _imagePath = null;
     _targetType = null;
+    _cropRotation = 0.0;
     _targetCenterX = 0.5;
     _targetCenterY = 0.5;
     _targetRadius = 0.4;
@@ -775,4 +814,23 @@ class AnalysisProvider extends ChangeNotifier {
     _correctedImagePath = null;
     notifyListeners();
   }
-}
+
+  /// Met à jour la position d'un impact de tir en direct (Glisser-Déposer).
+  void updateShotPosition(String shotId, double newX, double newY) {
+    final index = _shots.indexWhere((s) => s.id == shotId);
+    if (index != -1) {
+      // 1. On calcule dynamiquement le nouveau score de la zone survolée
+      final newScore = _calculateShotScore(newX, newY);
+
+      // 2. On remplace l'ancien impact par le nouveau avec ses coordonnées et son score ajustés
+      _shots[index] = _shots[index].copyWith(x: newX, y: newY, score: newScore);
+
+      // 3. On applique les deux méthodes natives de recalcul de ton application
+      _recalculateScores();
+      _recalculateGrouping();
+
+      // 4. On demande à l'écran de se redessiner en direct
+      notifyListeners();
+    }
+  }
+}

lib/features/analysis/impact_editor_screen.dart

@@ -0,0 +1,284 @@
+/// Écran d'édition des impacts — PLEIN ÉCRAN dédié au zoom et au placement.
+///
+/// Cet écran est volontairement minimal : un Scaffold dont le body est
+/// directement un InteractiveViewer (sans SingleScrollView ni AspectRatio
+/// contraint autour). C'est la configuration la plus fiable pour le pinch :
+/// l'InteractiveViewer reçoit les deux doigts sans concurrence avec un
+/// scroll vertical ou une transformation parente.
+///
+/// Interactions :
+///   - Tap sur zone vide      -> ajoute un impact
+///   - Tap sur un impact      -> ouvre l'édition (score / suppression)
+///   - Appui long + glisser   -> déplace l'impact
+///
+/// L'état des impacts est partagé avec l'écran d'analyse via le MÊME
+/// AnalysisProvider (passé en ChangeNotifierProvider.value côté appelant).
+library;
+
+import 'dart:io';
+import 'dart:math' as math;
+import 'package:flutter/material.dart';
+import 'package:provider/provider.dart';
+
+import '../../core/theme/app_theme.dart';
+import '../../data/models/shot.dart';
+import 'analysis_provider.dart';
+import 'widgets/target_overlay.dart';
+
+class ImpactEditorScreen extends StatefulWidget {
+  const ImpactEditorScreen({super.key});
+
+  @override
+  State<ImpactEditorScreen> createState() => _ImpactEditorScreenState();
+}
+
+class _ImpactEditorScreenState extends State<ImpactEditorScreen> {
+  final TransformationController _transformationController =
+  TransformationController();
+  final GlobalKey _imageKey = GlobalKey();
+
+  double _currentZoomScale = 1.0;
+  String? _movingShotId;
+
+  @override
+  void initState() {
+    super.initState();
+    _transformationController.addListener(_onTransformChanged);
+  }
+
+  @override
+  void dispose() {
+    _transformationController.removeListener(_onTransformChanged);
+    _transformationController.dispose();
+    super.dispose();
+  }
+
+  void _onTransformChanged() {
+    final scale = _transformationController.value.getMaxScaleOnAxis();
+    if (scale != _currentZoomScale) {
+      setState(() => _currentZoomScale = scale);
+    }
+  }
+
+  /// Convertit une position globale en coordonnées relatives (0..1) sur l'image.
+  Offset? _toImageRelative(Offset globalPosition) {
+    final RenderBox? box =
+    _imageKey.currentContext?.findRenderObject() as RenderBox?;
+    if (box == null) return null;
+    final local = box.globalToLocal(globalPosition);
+    final relX = (local.dx / box.size.width).clamp(0.0, 1.0);
+    final relY = (local.dy / box.size.height).clamp(0.0, 1.0);
+    return Offset(relX, relY);
+  }
+
+  /// Renvoie l'impact le plus proche de [rel] dans la tolérance, sinon null.
+  Shot? _hitTestShot(AnalysisProvider provider, Offset rel,
+      {double tolerance = 0.04}) {
+    Shot? closest;
+    double minDistance = double.infinity;
+    for (final shot in provider.shots) {
+      final dx = shot.x - rel.dx;
+      final dy = shot.y - rel.dy;
+      final distance = math.sqrt(dx * dx + dy * dy);
+      if (distance < minDistance && distance < tolerance) {
+        minDistance = distance;
+        closest = shot;
+      }
+    }
+    return closest;
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    final provider = context.watch<AnalysisProvider>();
+
+    return Scaffold(
+      backgroundColor: Colors.black,
+      appBar: AppBar(
+        backgroundColor: Colors.black,
+        title: Text('Placement des impacts (${provider.shotCount})'),
+        leading: IconButton(
+          icon: const Icon(Icons.arrow_back),
+          tooltip: 'Retour à la calibration',
+          onPressed: () => Navigator.pop(context, false),
+        ),
+        actions: [
+          TextButton(
+            onPressed: () => Navigator.pop(context, true),
+            child: const Text(
+              'VALIDER',
+              style: TextStyle(color: Colors.white, fontWeight: FontWeight.bold),
+            ),
+          ),
+        ],
+      ),
+      body: Column(
+        children: [
+          // Bandeau d'aide compact
+          Container(
+            width: double.infinity,
+            color: Colors.white10,
+            padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 8),
+            child: const Text(
+              'Tap : ajouter • Tap sur impact : éditer • Appui long : déplacer • Pincer : zoomer',
+              style: TextStyle(color: Colors.white70, fontSize: 12),
+              textAlign: TextAlign.center,
+            ),
+          ),
+
+          // Zone image plein écran : InteractiveViewer dans un body nu.
+          Expanded(
+            child: InteractiveViewer(
+              transformationController: _transformationController,
+              minScale: 1.0,
+              maxScale: 12.0,
+              boundaryMargin: const EdgeInsets.all(80),
+              panEnabled: _movingShotId == null,
+              child: Center(
+                child: GestureDetector(
+                  behavior: HitTestBehavior.opaque,
+                  // TAP : éditer si on touche un impact, sinon ajouter.
+                  onTapUp: (details) {
+                    if (_movingShotId != null) return;
+                    final rel = _toImageRelative(details.globalPosition);
+                    if (rel == null) return;
+
+                    final hit = _hitTestShot(provider, rel);
+                    if (hit != null) {
+                      _showShotDetails(context, provider, hit);
+                    } else {
+                      provider.addShot(rel.dx, rel.dy);
+                    }
+                  },
+                  // APPUI LONG : on saisit l'impact le plus proche pour le déplacer.
+                  onLongPressStart: (details) {
+                    final rel = _toImageRelative(details.globalPosition);
+                    if (rel == null) return;
+                    final hit = _hitTestShot(provider, rel, tolerance: 0.06);
+                    if (hit != null) {
+                      setState(() => _movingShotId = hit.id);
+                    }
+                  },
+                  onLongPressMoveUpdate: (details) {
+                    if (_movingShotId == null) return;
+                    // Décalage pour que l'impact reste visible au-dessus du doigt.
+                    final adjusted =
+                        details.globalPosition + const Offset(-25, -35);
+                    final rel = _toImageRelative(adjusted);
+                    if (rel == null) return;
+                    provider.updateShotPosition(
+                        _movingShotId!, rel.dx, rel.dy);
+                  },
+                  onLongPressEnd: (_) {
+                    if (_movingShotId != null) {
+                      setState(() => _movingShotId = null);
+                    }
+                  },
+                  child: Stack(
+                    children: [
+                      Image.file(
+                        File(provider.imagePath!),
+                        key: _imageKey,
+                        fit: BoxFit.contain,
+                      ),
+                      Positioned.fill(
+                        child: TargetOverlay(
+                          targetCenterX: provider.targetCenterX,
+                          targetCenterY: provider.targetCenterY,
+                          targetRadius: provider.targetRadius,
+                          targetType: provider.targetType!,
+                          shots: provider.shots,
+                          showRings: true,
+                          zoomScale: _currentZoomScale,
+                          // L'ajout et la sélection sont gérés par le
+                          // GestureDetector parent ci-dessus.
+                          onShotTapped: (shot) =>
+                              _showShotDetails(context, provider, shot),
+                        ),
+                      ),
+                    ],
+                  ),
+                ),
+              ),
+            ),
+          ),
+        ],
+      ),
+    );
+  }
+
+  void _showShotDetails(
+      BuildContext context,
+      AnalysisProvider provider,
+      Shot shot,
+      ) {
+    showModalBottomSheet(
+      context: context,
+      builder: (context) => Container(
+        padding: const EdgeInsets.all(24),
+        child: Column(
+          mainAxisSize: MainAxisSize.min,
+          children: [
+            Text(
+              'Impact #${provider.shots.indexOf(shot) + 1}',
+              style: const TextStyle(fontWeight: FontWeight.bold, fontSize: 18),
+            ),
+            Text(
+              'ID: ${shot.id}',
+              style: Theme.of(context)
+                  .textTheme
+                  .bodySmall
+                  ?.copyWith(color: Colors.grey, fontSize: 10),
+            ),
+            const SizedBox(height: 16),
+            ListTile(
+              leading: const Icon(Icons.score),
+              title: const Text('Modifier le score'),
+              trailing: DropdownButton<int>(
+                value: shot.score.clamp(0, 10),
+                items: List.generate(11, (index) => index)
+                    .map(
+                      (s) => DropdownMenuItem(
+                    value: s,
+                    child: Text(
+                      '$s',
+                      style: const TextStyle(
+                        fontWeight: FontWeight.bold,
+                        fontSize: 18,
+                      ),
+                    ),
+                  ),
+                )
+                    .toList(),
+                onChanged: (newScore) {
+                  if (newScore != null) {
+                    provider.updateShotScore(shot.id, newScore);
+                    Navigator.pop(context);
+                  }
+                },
+              ),
+            ),
+            const SizedBox(height: 24),
+            Row(
+              children: [
+                Expanded(
+                  child: OutlinedButton.icon(
+                    onPressed: () {
+                      provider.removeShot(shot.id);
+                      Navigator.pop(context);
+                    },
+                    icon: const Icon(Icons.delete, color: Colors.red),
+                    label: const Text(
+                      'SUPPRIMER',
+                      style: TextStyle(color: Colors.red),
+                    ),
+                  ),
+                ),
+              ],
+            ),
+          ],
+        ),
+      ),
+    );
+  }
+}

lib/features/analysis/widgets/target_calibration.dart

@@ -18,13 +18,13 @@ class TargetCalibration extends StatefulWidget {
   final TargetType targetType;
   final List<double>? initialRingRadii;
   final Function(
-    double centerX,
-    double centerY,
-    double innerRadius,
-    double radius,
-    int ringCount, {
-    List<double>? ringRadii,
-  })
+      double centerX,
+      double centerY,
+      double innerRadius,
+      double radius,
+      int ringCount, {
+      List<double>? ringRadii,
+      })
   onCalibrationChanged;
 
   const TargetCalibration({
@@ -40,10 +40,10 @@ class TargetCalibration extends StatefulWidget {
   });
 
   @override
-  State<TargetCalibration> createState() => _TargetCalibrationState();
+  State<TargetCalibration> createState() => TargetCalibrationState();
 }
 
-class _TargetCalibrationState extends State<TargetCalibration> {
+class TargetCalibrationState extends State<TargetCalibration> {
   late double _centerX;
   late double _centerY;
   late double _radius;
@@ -51,10 +51,19 @@ class _TargetCalibrationState extends State<TargetCalibration> {
   late int _ringCount;
   late List<double> _ringRadii;
 
+  // Variable dédiée pour piloter la jauge orange sans conflit
+  late double _currentEspacementRatio;
+
   bool _isDraggingCenter = false;
   bool _isDraggingRadius = false;
   bool _isDraggingInnerRadius = false;
 
+  bool _showEspacement = false;
+  double _baseRadiusBeforeScale = 1.0;
+
+  // SAUVEGARDE CRITIQUE : Pour mémoriser la structure d'origine de l'IA
+  List<double>? _originalRingRadii;
+
   @override
   void initState() {
     super.initState();
@@ -63,19 +72,37 @@ class _TargetCalibrationState extends State<TargetCalibration> {
     _radius = widget.initialRadius;
     _innerRadius = widget.initialInnerRadius;
     _ringCount = widget.initialRingCount;
+
+    // On mémorise la configuration d'usine de l'image
+    if (widget.initialRingRadii != null) {
+      _originalRingRadii = List.from(widget.initialRingRadii!);
+    }
+
+    // Initialisation du ratio par défaut
+    _currentEspacementRatio = (_radius > 0) ? (_innerRadius / _radius).clamp(0.01, 0.70) : 0.1;
     _initRingRadii();
   }
 
-  void _initRingRadii() {
-    if (widget.initialRingRadii != null &&
-        widget.initialRingRadii!.length == _ringCount) {
+  /// Fige et propage la calibration courante vers le provider.
+  ///
+  /// Appelée par l'écran d'analyse (via GlobalKey) juste avant de basculer
+  /// dans l'instance de Plotting, pour garantir que l'état affiché en Plotting
+  /// correspond exactement au dernier réglage validé, sans dépendre d'un
+  /// éventuel rebuild intermédiaire.
+  void commitCalibration() {
+    _notifyChange();
+  }
+
+  void _initRingRadii({bool forceRecalculate = false}) {
+    // CORRECTION : Si on ne recalcule pas activement l'espacement linéaire, on préserve en priorité la structure d'origine
+    if (!forceRecalculate && _originalRingRadii != null && _originalRingRadii!.length == _ringCount) {
+      _ringRadii = List.from(_originalRingRadii!);
+    } else if (!forceRecalculate && widget.initialRingRadii != null && widget.initialRingRadii!.length == _ringCount) {
       _ringRadii = List.from(widget.initialRingRadii!);
     } else {
-      // Initialize with default proportional radii interpolated between inner and outer
       _ringRadii = List.generate(_ringCount, (i) {
         if (_ringCount <= 1) return 1.0;
-        final ratio = _innerRadius / _radius;
-        return ratio + (1.0 - ratio) * i / (_ringCount - 1);
+        return _currentEspacementRatio + (1.0 - _currentEspacementRatio) * i / (_ringCount - 1);
       });
     }
   }
@@ -85,12 +112,10 @@ class _TargetCalibrationState extends State<TargetCalibration> {
     super.didUpdateWidget(oldWidget);
     bool shouldReinit = false;
 
-    if (widget.initialCenterX != oldWidget.initialCenterX &&
-        !_isDraggingCenter) {
+    if (widget.initialCenterX != oldWidget.initialCenterX && !_isDraggingCenter) {
       _centerX = widget.initialCenterX;
     }
-    if (widget.initialCenterY != oldWidget.initialCenterY &&
-        !_isDraggingCenter) {
+    if (widget.initialCenterY != oldWidget.initialCenterY && !_isDraggingCenter) {
       _centerY = widget.initialCenterY;
     }
     if (widget.initialRingCount != oldWidget.initialRingCount) {
@@ -101,12 +126,13 @@ class _TargetCalibrationState extends State<TargetCalibration> {
       _radius = widget.initialRadius;
       shouldReinit = true;
     }
-    if (widget.initialInnerRadius != oldWidget.initialInnerRadius &&
-        !_isDraggingInnerRadius) {
+    if (widget.initialInnerRadius != oldWidget.initialInnerRadius && !_isDraggingInnerRadius) {
       _innerRadius = widget.initialInnerRadius;
+      _currentEspacementRatio = (_radius > 0) ? (_innerRadius / _radius).clamp(0.01, 0.70) : 0.1;
       shouldReinit = true;
     }
-    if (widget.initialRingRadii != oldWidget.initialRingRadii) {
+    if (widget.initialRingRadii != oldWidget.initialRingRadii && widget.initialRingRadii != null) {
+      _originalRingRadii = List.from(widget.initialRingRadii!);
       shouldReinit = true;
     }
 
@@ -121,107 +147,229 @@ class _TargetCalibrationState extends State<TargetCalibration> {
       builder: (context, constraints) {
         final size = constraints.biggest;
 
-        return GestureDetector(
-          onPanStart: (details) => _onPanStart(details, size),
-          onPanUpdate: (details) => _onPanUpdate(details, size),
-          onPanEnd: (_) => _onPanEnd(),
-          child: CustomPaint(
-            size: size,
-            painter: _CalibrationPainter(
-              centerX: _centerX,
-              centerY: _centerY,
-              radius: _radius,
-              innerRadius: _innerRadius,
-              ringCount: _ringCount,
-              ringRadii: _ringRadii,
-              targetType: widget.targetType,
-              isDraggingCenter: _isDraggingCenter,
-              isDraggingRadius: _isDraggingRadius,
-              isDraggingInnerRadius: _isDraggingInnerRadius,
+        return Stack(
+          children: [
+            GestureDetector(
+              onScaleStart: (details) {
+                _baseRadiusBeforeScale = _radius;
+                final tapX = details.localFocalPoint.dx / size.width;
+                final tapY = details.localFocalPoint.dy / size.height;
+                final distToCenter = _distance(tapX, tapY, _centerX, _centerY);
+
+                if (distToCenter < 0.05 || distToCenter < _radius + 0.02) {
+                  setState(() {
+                    _isDraggingCenter = true;
+                  });
+                }
+              },
+              onScaleUpdate: (details) => _onScaleUpdate(details, size),
+              onScaleEnd: (_) => _onScaleEnd(),
+              child: CustomPaint(
+                size: size,
+                painter: _CalibrationPainter(
+                  centerX: _centerX,
+                  centerY: _centerY,
+                  radius: _radius,
+                  innerRadius: _innerRadius,
+                  ringCount: _ringCount,
+                  ringRadii: _ringRadii,
+                  targetType: widget.targetType,
+                  isDraggingCenter: _isDraggingCenter,
+                  isDraggingRadius: false,
+                  isDraggingInnerRadius: false,
+                ),
+              ),
             ),
-          ),
+
+            Positioned(
+              top: 10,
+              left: 40,
+              right: 40,
+              child: Column(
+                mainAxisSize: MainAxisSize.min,
+                children: [
+                  Container(
+                    margin: const EdgeInsets.only(bottom: 8),
+                    padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 2),
+                    decoration: BoxDecoration(
+                      color: Colors.black54,
+                      borderRadius: BorderRadius.circular(20),
+                    ),
+                    child: Row(
+                      mainAxisAlignment: MainAxisAlignment.spaceBetween,
+                      children: [
+                        const Text(
+                          'Options d\'espacement avancées',
+                          style: TextStyle(color: Colors.white70, fontSize: 11, fontWeight: FontWeight.w500),
+                        ),
+                        SizedBox(
+                          height: 28,
+                          child: Switch(
+                            value: _showEspacement,
+                            activeThumbColor: const Color(0xFF00FF00),
+                            onChanged: (bool value) {
+                              setState(() {
+                                _showEspacement = value;
+                                // Quand on désactive l'espacement manuel, on restaure la configuration d'usine !
+                                if (!value) {
+                                  _initRingRadii(forceRecalculate: false);
+                                }
+                              });
+                              _notifyChange();
+                            },
+                          ),
+                        ),
+                      ],
+                    ),
+                  ),
+
+                  // Slider pour la taille (toujours visible)
+                  Container(
+                    padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 4),
+                    decoration: BoxDecoration(
+                      color: Colors.black54,
+                      borderRadius: BorderRadius.circular(20),
+                    ),
+                    child: Row(
+                      children: [
+                        const Text('Taille ', style: TextStyle(color: Colors.white, fontSize: 12, fontWeight: FontWeight.bold)),
+                        const Icon(Icons.zoom_out, color: Colors.white, size: 16),
+                        Expanded(
+                          child: Slider(
+                            // SÉCURITÉ : Ouverture mesurée des bornes pour plus de liberté sans débordement incontrôlé
+                            value: _radius.clamp(0.3, 0.95),
+                            min: 0.3,
+                            max: 0.95,
+                            activeColor: AppTheme.primaryColor,
+                            onChanged: (value) {
+                              setState(() {
+                                _radius = value;
+                                _innerRadius = _radius * _currentEspacementRatio;
+                                // CORRECTION : Si le mode avancé n'est pas coché, on applique la taille pure sans détruire le ratio d'origine
+                                _initRingRadii(forceRecalculate: _showEspacement);
+                              });
+                              _notifyChange();
+                            },
+                          ),
+                        ),
+                        const Icon(Icons.zoom_in, color: Colors.white, size: 16),
+                      ],
+                    ),
+                  ),
+
+                  // Affichage conditionnel du slider d'espacement orange
+                  if (_showEspacement) ...[
+                    const SizedBox(height: 8),
+                    Container(
+                      padding: const EdgeInsets.fromLTRB(16, 4, 4, 4),
+                      decoration: BoxDecoration(
+                        color: Colors.black54,
+                        borderRadius: BorderRadius.circular(20),
+                      ),
+                      child: Row(
+                        children: [
+                          const Text('Espacement ', style: TextStyle(color: Colors.white, fontSize: 12, fontWeight: FontWeight.bold)),
+                          const Icon(Icons.compress, color: Colors.white, size: 16),
+                          Expanded(
+                            child: Row(
+                              children: [
+                                Expanded(
+                                  child: Slider(
+                                    value: _currentEspacementRatio,
+                                    min: 0.01,
+                                    // SÉCURITÉ : Écartement max bridé à 0.70 pour confiner le dernier cercle
+                                    max: 0.70,
+                                    activeColor: Colors.orange,
+                                    onChanged: (value) {
+                                      setState(() {
+                                        _currentEspacementRatio = value;
+                                        _innerRadius = _radius * _currentEspacementRatio;
+                                        _initRingRadii(forceRecalculate: true);
+                                      });
+                                      _notifyChange();
+                                    },
+                                  ),
+                                ),
+                                const Icon(Icons.expand, color: Colors.white, size: 16),
+                              ],
+                            ),
+                          ),
+                          // CORRECTION DU BOUTON RESET : Restaure désormais le vrai profil d'usine de l'IA
+                          IconButton(
+                            icon: const Icon(Icons.refresh, color: Colors.white70, size: 20),
+                            onPressed: () {
+                              setState(() {
+                                if (_originalRingRadii != null) {
+                                  _initRingRadii(forceRecalculate: false);
+                                  if (_ringRadii.isNotEmpty) {
+                                    _currentEspacementRatio = _ringRadii.first;
+                                    _innerRadius = _radius * _currentEspacementRatio;
+                                  }
+                                } else {
+                                  _currentEspacementRatio = 0.1;
+                                  _innerRadius = _radius * _currentEspacementRatio;
+                                  _initRingRadii(forceRecalculate: true);
+                                }
+                              });
+                              _notifyChange();
+                            },
+                            tooltip: 'Réinitialiser l\'espacement',
+                            constraints: const BoxConstraints(),
+                            padding: const EdgeInsets.symmetric(horizontal: 8),
+                          ),
+                        ],
+                      ),
+                    ),
+                  ],
+                ],
+              ),
+            ),
+          ],
         );
       },
     );
   }
 
-  void _onPanStart(DragStartDetails details, Size size) {
-    final tapX = details.localPosition.dx / size.width;
-    final tapY = details.localPosition.dy / size.height;
-
-    // Check if tapping on center handle
-    final distToCenter = _distance(tapX, tapY, _centerX, _centerY);
-
-    // Check if tapping on outer radius handle
-    final minDim = math.min(size.width, size.height);
-    final outerRadius = _radius;
-    final radiusHandleX = _centerX + outerRadius * minDim / size.width;
-    final radiusHandleY = _centerY;
-    final distToOuterHandle = _distance(
-      tapX,
-      tapY,
-      radiusHandleX.clamp(0.0, 1.0),
-      radiusHandleY.clamp(0.0, 1.0),
+  Widget buildDirectionalControls(BuildContext context, Size size) {
+    return Container(
+      padding: const EdgeInsets.all(8),
+      decoration: BoxDecoration(
+        color: Colors.black.withValues(alpha: 0.05),
+        borderRadius: BorderRadius.circular(12),
+        border: Border.all(color: Colors.white10),
+      ),
+      child: Column(
+        mainAxisSize: MainAxisSize.min,
+        children: [
+          _buildDirectionButton(Icons.keyboard_arrow_up, () => _moveCenterByPixels(0, -1, size)),
+          Row(
+            mainAxisSize: MainAxisSize.min,
+            children: [
+              _buildDirectionButton(Icons.keyboard_arrow_left, () => _moveCenterByPixels(-1, 0, size)),
+              const SizedBox(width: 40),
+              _buildDirectionButton(Icons.keyboard_arrow_right, () => _moveCenterByPixels(1, 0, size)),
+            ],
+          ),
+          _buildDirectionButton(Icons.keyboard_arrow_down, () => _moveCenterByPixels(0, 1, size)),
+        ],
+      ),
     );
-
-    // Check if tapping on inner radius handle (top edge of innermost circle)
-    final actualInnerRadius = _innerRadius;
-    final innerHandleX = _centerX;
-    final innerHandleY = _centerY - actualInnerRadius * minDim / size.height;
-    final distToInnerHandle = _distance(
-      tapX,
-      tapY,
-      innerHandleX.clamp(0.0, 1.0),
-      innerHandleY.clamp(0.0, 1.0),
-    );
-
-    // Increase touch target size slightly for handles
-    if (distToCenter < 0.05) {
-      setState(() {
-        _isDraggingCenter = true;
-      });
-    } else if (distToOuterHandle < 0.05) {
-      setState(() {
-        _isDraggingRadius = true;
-      });
-    } else if (distToInnerHandle < 0.05) {
-      setState(() {
-        _isDraggingInnerRadius = true;
-      });
-    } else if (distToCenter < _radius + 0.02) {
-      // Tapping inside the target - move center
-      setState(() {
-        _isDraggingCenter = true;
-      });
-    }
   }
 
-  void _onPanUpdate(DragUpdateDetails details, Size size) {
-    final deltaX = details.delta.dx / size.width;
-    final deltaY = details.delta.dy / size.height;
-    final minDim = math.min(size.width, size.height);
-
-    setState(() {
-      if (_isDraggingCenter) {
-        // Move center
-        _centerX = _centerX + deltaX;
-        _centerY = _centerY + deltaY;
-      } else if (_isDraggingRadius) {
-        // Adjust outer radius
-        final newRadius = _radius + deltaX * (size.width / minDim);
-        _radius = newRadius.clamp(math.max(0.05, _innerRadius + 0.01), 3.0);
-        _initRingRadii(); // Recalculate linear separation
-      } else if (_isDraggingInnerRadius) {
-        // Adjust inner radius (sliding up reduces Y, so deltaY is negative when growing. Thus we subtract deltaY)
-        final newInnerRadius = _innerRadius - deltaY * (size.height / minDim);
-        _innerRadius = newInnerRadius.clamp(
-          0.01,
-          math.max(0.01, _radius - 0.01),
-        );
-        _initRingRadii(); // Recalculate linear separation
-      }
-    });
+  Widget _buildDirectionButton(IconData icon, VoidCallback onPressed) {
+    return Container(
+      decoration: BoxDecoration(color: Colors.black87, borderRadius: BorderRadius.circular(8)),
+      margin: const EdgeInsets.all(2),
+      child: IconButton(
+        icon: Icon(icon, color: Colors.white, size: 28),
+        onPressed: onPressed,
+        padding: EdgeInsets.zero,
+        constraints: const BoxConstraints(minWidth: 40, minHeight: 40),
+      ),
+    );
+  }
 
+  void _notifyChange() {
     widget.onCalibrationChanged(
       _centerX,
       _centerY,
@@ -232,7 +380,31 @@ class _TargetCalibrationState extends State<TargetCalibration> {
     );
   }
 
-  void _onPanEnd() {
+  void _moveCenterByPixels(double dx, double dy, Size size) {
+    setState(() {
+      _centerX = _centerX + (dx / size.width);
+      _centerY = _centerY + (dy / size.height);
+    });
+    _notifyChange();
+  }
+
+  void _onScaleUpdate(ScaleUpdateDetails details, Size size) {
+    setState(() {
+      if (details.pointerCount == 2) {
+        _radius = (_baseRadiusBeforeScale * details.scale).clamp(0.3, 0.95);
+        _innerRadius = _radius * _currentEspacementRatio;
+        _initRingRadii(forceRecalculate: _showEspacement);
+      } else if (_isDraggingCenter) {
+        final deltaX = details.focalPointDelta.dx / size.width;
+        final deltaY = details.focalPointDelta.dy / size.height;
+        _centerX = _centerX + deltaX;
+        _centerY = _centerY + deltaY;
+      }
+    });
+    _notifyChange();
+  }
+
+  void _onScaleEnd() {
     setState(() {
       _isDraggingCenter = false;
       _isDraggingRadius = false;
@@ -277,7 +449,6 @@ class _CalibrationPainter extends CustomPainter {
     final centerPx = Offset(centerX * size.width, centerY * size.height);
     final minDim = size.width < size.height ? size.width : size.height;
     final baseRadiusPx = radius * minDim;
-    final innerRadiusPx = innerRadius * minDim;
 
     if (targetType == TargetType.concentric) {
       _drawConcentricZones(canvas, size, centerPx, baseRadiusPx);
@@ -285,43 +456,17 @@ class _CalibrationPainter extends CustomPainter {
       _drawSilhouetteZones(canvas, size, centerPx, baseRadiusPx);
     }
 
-    // Fullscreen crosshairs when dragging center
     if (isDraggingCenter) {
-      final crosshairLinePaint = Paint()
-        ..color = AppTheme.successColor.withValues(alpha: 0.5)
-        ..strokeWidth = 1;
-      canvas.drawLine(
-        Offset(0, centerPx.dy),
-        Offset(size.width, centerPx.dy),
-        crosshairLinePaint,
-      );
-      canvas.drawLine(
-        Offset(centerPx.dx, 0),
-        Offset(centerPx.dx, size.height),
-        crosshairLinePaint,
-      );
+      final crosshairLinePaint = Paint()..color = Colors.red.withValues(alpha: 0.5)..strokeWidth = 1;
+      canvas.drawLine(Offset(0, centerPx.dy), Offset(size.width, centerPx.dy), crosshairLinePaint);
+      canvas.drawLine(Offset(centerPx.dx, 0), Offset(centerPx.dx, size.height), crosshairLinePaint);
     }
 
-    // Draw center handle
     _drawCenterHandle(canvas, centerPx);
-
-    // Draw radius handle (for outer ring)
-    _drawRadiusHandle(canvas, size, centerPx, baseRadiusPx);
-
-    // Draw inner radius handle
-    _drawInnerRadiusHandle(canvas, size, centerPx, innerRadiusPx);
-
-    // Draw instructions
     _drawInstructions(canvas, size);
   }
 
-  void _drawConcentricZones(
-    Canvas canvas,
-    Size size,
-    Offset center,
-    double baseRadius,
-  ) {
-    // Generate colors for zones
+  void _drawConcentricZones(Canvas canvas, Size size, Offset center, double baseRadius) {
     List<Color> zoneColors = [];
     for (int i = 0; i < ringCount; i++) {
       final ratio = i / ringCount;
@@ -342,13 +487,10 @@ class _CalibrationPainter extends CustomPainter {
     final strokePaint = Paint()
       ..style = PaintingStyle.stroke
       ..strokeWidth = 1
-      ..color = Colors.white.withValues(alpha: 0.6);
+      ..color = Colors.red.withValues(alpha: 0.8);
 
-    // Draw from outside to inside
     for (int i = ringCount - 1; i >= 0; i--) {
-      final ringRadius = ringRadii.length > i
-          ? ringRadii[i]
-          : (i + 1) / ringCount;
+      final ringRadius = ringRadii.length > i ? ringRadii[i] : (i + 1) / ringCount;
       final zoneRadius = baseRadius * ringRadius;
 
       zonePaint.color = zoneColors[i];
@@ -356,22 +498,14 @@ class _CalibrationPainter extends CustomPainter {
       canvas.drawCircle(center, zoneRadius, strokePaint);
     }
 
-    // Draw zone labels (only if within visible area)
     final textPainter = TextPainter(textDirection: TextDirection.ltr);
 
     for (int i = 0; i < ringCount; i++) {
-      final ringRadius = ringRadii.length > i
-          ? ringRadii[i]
-          : (i + 1) / ringCount;
-      final prevRingRadius = i > 0
-          ? (ringRadii.length > i - 1 ? ringRadii[i - 1] : i / ringCount)
-          : 0.0;
-      final zoneRadius = baseRadius * (ringRadius + prevRingRadius) / 2;
+      final ringRadius = ringRadii.length > i ? ringRadii[i] : (i + 1) / ringCount;
+      final textSpanRatio = i > 0 ? (ringRadii.length > i - 1 ? ringRadii[i - 1] : i / ringCount) : 0.0;
+      final zoneRadius = baseRadius * (ringRadius + textSpanRatio) / 2;
 
-      // Score: center = 10, decrement by 1 for each ring
       final score = 10 - i;
-
-      // Only draw label if it's within the visible area
       final labelX = center.dx + zoneRadius;
       if (labelX < 0 || labelX > size.width) continue;
 
@@ -386,251 +520,49 @@ class _CalibrationPainter extends CustomPainter {
       );
       textPainter.layout();
 
-      // Draw label on the right side of each zone
       final labelY = center.dy - textPainter.height / 2;
       if (labelY >= 0 && labelY <= size.height) {
-        textPainter.paint(
-          canvas,
-          Offset(labelX - textPainter.width / 2, labelY),
-        );
+        textPainter.paint(canvas, Offset(labelX - textPainter.width / 2, labelY));
       }
     }
   }
 
-  void _drawSilhouetteZones(
-    Canvas canvas,
-    Size size,
-    Offset center,
-    double radius,
-  ) {
-    // Simplified silhouette zones
-    final paint = Paint()
-      ..style = PaintingStyle.stroke
-      ..strokeWidth = 2;
-
-    // Draw silhouette outline (simplified as rectangle for now)
+  void _drawSilhouetteZones(Canvas canvas, Size size, Offset center, double radius) {
+    final paint = Paint()..style = PaintingStyle.stroke..strokeWidth = 2;
     final silhouetteWidth = radius * 0.8;
     final silhouetteHeight = radius * 2;
 
     paint.color = Colors.green.withValues(alpha: 0.5);
-    canvas.drawRect(
-      Rect.fromCenter(
-        center: center,
-        width: silhouetteWidth,
-        height: silhouetteHeight,
-      ),
-      paint,
-    );
+    canvas.drawRect(Rect.fromCenter(center: center, width: silhouetteWidth, height: silhouetteHeight), paint);
   }
 
   void _drawCenterHandle(Canvas canvas, Offset center) {
-    // Outer circle
-    final outerPaint = Paint()
-      ..color = isDraggingCenter ? AppTheme.successColor : AppTheme.primaryColor
-      ..style = PaintingStyle.stroke
-      ..strokeWidth = 3;
+    final outerPaint = Paint()..color = isDraggingCenter ? Colors.redAccent : Colors.red..style = PaintingStyle.stroke..strokeWidth = 3;
     canvas.drawCircle(center, 15, outerPaint);
 
-    // Inner dot
-    final innerPaint = Paint()
-      ..color = isDraggingCenter ? AppTheme.successColor : AppTheme.primaryColor
-      ..style = PaintingStyle.fill;
+    final innerPaint = Paint()..color = isDraggingCenter ? Colors.redAccent : Colors.red..style = PaintingStyle.fill;
     canvas.drawCircle(center, 5, innerPaint);
 
-    // Crosshair
-    final crossPaint = Paint()
-      ..color = isDraggingCenter ? AppTheme.successColor : AppTheme.primaryColor
-      ..strokeWidth = 2;
-    canvas.drawLine(
-      Offset(center.dx - 20, center.dy),
-      Offset(center.dx - 8, center.dy),
-      crossPaint,
-    );
-    canvas.drawLine(
-      Offset(center.dx + 8, center.dy),
-      Offset(center.dx + 20, center.dy),
-      crossPaint,
-    );
-    canvas.drawLine(
-      Offset(center.dx, center.dy - 20),
-      Offset(center.dx, center.dy - 8),
-      crossPaint,
-    );
-    canvas.drawLine(
-      Offset(center.dx, center.dy + 8),
-      Offset(center.dx, center.dy + 20),
-      crossPaint,
-    );
-  }
-
-  void _drawRadiusHandle(
-    Canvas canvas,
-    Size size,
-    Offset center,
-    double baseRadius,
-  ) {
-    // Radius handle on the right edge of the outermost ring
-    final actualHandleX = center.dx + baseRadius;
-    final clampedHandleX = actualHandleX.clamp(20.0, size.width - 20);
-    final clampedHandleY = center.dy.clamp(20.0, size.height - 20);
-    final handlePos = Offset(clampedHandleX, clampedHandleY);
-
-    // Check if handle is clamped (radius extends beyond visible area)
-    final isClamped = actualHandleX > size.width - 20;
-
-    final paint = Paint()
-      ..color = isDraggingRadius
-          ? AppTheme.successColor
-          : (isClamped ? Colors.orange : AppTheme.warningColor)
-      ..style = PaintingStyle.fill;
-
-    // Draw handle as a small circle with arrows
-    canvas.drawCircle(handlePos, 14, paint);
-
-    // Draw arrow indicators
-    final arrowPaint = Paint()
-      ..color = Colors.white
-      ..strokeWidth = 2
-      ..style = PaintingStyle.stroke;
-
-    // Left arrow
-    canvas.drawLine(
-      Offset(handlePos.dx - 4, handlePos.dy),
-      Offset(handlePos.dx - 8, handlePos.dy - 4),
-      arrowPaint,
-    );
-    canvas.drawLine(
-      Offset(handlePos.dx - 4, handlePos.dy),
-      Offset(handlePos.dx - 8, handlePos.dy + 4),
-      arrowPaint,
-    );
-
-    // Right arrow
-    canvas.drawLine(
-      Offset(handlePos.dx + 4, handlePos.dy),
-      Offset(handlePos.dx + 8, handlePos.dy - 4),
-      arrowPaint,
-    );
-    canvas.drawLine(
-      Offset(handlePos.dx + 4, handlePos.dy),
-      Offset(handlePos.dx + 8, handlePos.dy + 4),
-      arrowPaint,
-    );
-
-    // Label
-    final textPainter = TextPainter(
-      text: const TextSpan(
-        text: 'EXT.',
-        style: TextStyle(
-          color: Colors.white,
-          fontSize: 8,
-          fontWeight: FontWeight.bold,
-        ),
-      ),
-      textDirection: TextDirection.ltr,
-    );
-    textPainter.layout();
-    textPainter.paint(
-      canvas,
-      Offset(handlePos.dx - textPainter.width / 2, handlePos.dy + 16),
-    );
-  }
-
-  void _drawInnerRadiusHandle(
-    Canvas canvas,
-    Size size,
-    Offset center,
-    double innerRadiusPx,
-  ) {
-    // Inner radius handle on the top edge of the innermost ring
-    final actualHandleY = center.dy - innerRadiusPx;
-    final clampedHandleX = center.dx.clamp(20.0, size.width - 20);
-    final clampedHandleY = actualHandleY.clamp(20.0, size.height - 20);
-    final handlePos = Offset(clampedHandleX, clampedHandleY);
-
-    final isClamped = actualHandleY < 20.0;
-
-    final paint = Paint()
-      ..color = isDraggingInnerRadius
-          ? AppTheme.successColor
-          : (isClamped ? Colors.orange : Colors.purpleAccent)
-      ..style = PaintingStyle.fill;
-
-    // Draw handle
-    canvas.drawCircle(handlePos, 14, paint);
-
-    // Up/Down arrow indicators
-    final arrowPaint = Paint()
-      ..color = Colors.white
-      ..strokeWidth = 2
-      ..style = PaintingStyle.stroke;
-
-    // Up arrow
-    canvas.drawLine(
-      Offset(handlePos.dx, handlePos.dy - 4),
-      Offset(handlePos.dx - 4, handlePos.dy - 8),
-      arrowPaint,
-    );
-    canvas.drawLine(
-      Offset(handlePos.dx, handlePos.dy - 4),
-      Offset(handlePos.dx + 4, handlePos.dy - 8),
-      arrowPaint,
-    );
-
-    // Down arrow
-    canvas.drawLine(
-      Offset(handlePos.dx, handlePos.dy + 4),
-      Offset(handlePos.dx - 4, handlePos.dy + 8),
-      arrowPaint,
-    );
-    canvas.drawLine(
-      Offset(handlePos.dx, handlePos.dy + 4),
-      Offset(handlePos.dx + 4, handlePos.dy + 8),
-      arrowPaint,
-    );
-
-    // Label
-    final textPainter = TextPainter(
-      text: const TextSpan(
-        text: 'INT.',
-        style: TextStyle(
-          color: Colors.white,
-          fontSize: 8,
-          fontWeight: FontWeight.bold,
-        ),
-      ),
-      textDirection: TextDirection.ltr,
-    );
-    textPainter.layout();
-    textPainter.paint(
-      canvas,
-      Offset(handlePos.dx - textPainter.width / 2, handlePos.dy - 24),
-    );
+    final crossPaint = Paint()..color = isDraggingCenter ? Colors.redAccent : Colors.red..strokeWidth = 2;
+    canvas.drawLine(Offset(center.dx - 20, center.dy), Offset(center.dx - 8, center.dy), crossPaint);
+    canvas.drawLine(Offset(center.dx + 8, center.dy), Offset(center.dx + 20, center.dy), crossPaint);
+    canvas.drawLine(Offset(center.dx, center.dy - 20), Offset(center.dx, center.dy - 8), crossPaint);
+    canvas.drawLine(Offset(center.dx, center.dy + 4), Offset(center.dx, center.dy + 20), crossPaint);
   }
 
   void _drawInstructions(Canvas canvas, Size size) {
     const instruction = 'Deplacez le centre ou ajustez le rayon';
-
     final textPainter = TextPainter(
-      text: TextSpan(
-        text: instruction,
-        style: TextStyle(
-          color: Colors.white.withValues(alpha: 0.9),
-          fontSize: 12,
-          backgroundColor: Colors.black54,
-        ),
-      ),
+      text: TextSpan(text: instruction, style: TextStyle(color: Colors.white.withValues(alpha: 0.9), fontSize: 12, backgroundColor: Colors.black54)),
       textDirection: TextDirection.ltr,
     );
     textPainter.layout();
-    textPainter.paint(
-      canvas,
-      Offset((size.width - textPainter.width) / 2, size.height - 30),
-    );
+    textPainter.paint(canvas, Offset((size.width - textPainter.width) / 2, size.height - 30));
   }
 
   @override
-  bool shouldRepaint(covariant _CalibrationPainter oldDelegate) {
+  bool shouldRepaint(CustomPainter oldDelegate) {
+    if (oldDelegate is! _CalibrationPainter) return true;
     return centerX != oldDelegate.centerX ||
         centerY != oldDelegate.centerY ||
         radius != oldDelegate.radius ||
@@ -641,4 +573,4 @@ class _CalibrationPainter extends CustomPainter {
         isDraggingInnerRadius != oldDelegate.isDraggingInnerRadius ||
         ringRadii != oldDelegate.ringRadii;
   }
-}
+}

lib/features/analysis/widgets/target_overlay.dart

@@ -1,8 +1,9 @@
 /// Overlay visuel de la cible.
 ///
 /// Dessine les anneaux de la cible, les impacts détectés, le cercle de groupement
-/// et les impacts de référence. Gère les interactions tactiles pour l'ajout
-/// d'impacts et la sélection d'impacts existants.
+/// et les impacts de référence. Gère uniquement la SÉLECTION d'impacts existants
+/// (tap sur un impact). L'AJOUT d'un impact est délégué à l'écran parent pour
+/// éviter tout conflit de gestes avec le zoom/pan de l'InteractiveViewer.
 library;
 
 import 'package:flutter/material.dart';
@@ -48,76 +49,69 @@ class TargetOverlay extends StatelessWidget {
 
   @override
   Widget build(BuildContext context) {
-    return LayoutBuilder(
-      builder: (context, constraints) {
-        return GestureDetector(
-          behavior: HitTestBehavior.translucent,
-          onTapUp: (details) {
-            if (onAddShot != null) {
-              // Utiliser les constraints pour un calcul précis
-              final relX = details.localPosition.dx / constraints.maxWidth;
-              final relY = details.localPosition.dy / constraints.maxHeight;
-              onAddShot!(relX, relY);
-            }
-          },
-          child: CustomPaint(
-            painter: _TargetOverlayPainter(
-              shots: shots,
-              targetCenterX: targetCenterX,
-              targetCenterY: targetCenterY,
-              targetRadius: targetRadius,
-              targetType: targetType,
-              ringCount: ringCount,
-              ringRadii: ringRadii,
-              groupingCenterX: groupingCenterX,
-              groupingCenterY: groupingCenterY,
-              groupingDiameter: groupingDiameter,
-              referenceImpacts: referenceImpacts,
-              zoomScale: zoomScale,
-              showRings: showRings,
-            ),
-            child: Stack(
+    // IMPORTANT : plus de GestureDetector global ici.
+    // L'ancien GestureDetector (onTapUp couvrant toute la surface, en
+    // HitTestBehavior.translucent) volait les pointeurs au pinch de
+    // l'InteractiveViewer parent et rendait le zoom capricieux.
+    //
+    // Désormais :
+    //  - L'AJOUT d'impact est géré par le GestureDetector parent (analysis_screen).
+    //  - Seule la SÉLECTION d'un impact existant est gérée ici, via des petites
+    //    zones de tap localisées (deferToChild) placées sur chaque impact.
+    return IgnorePointer(
+      ignoring: false,
+      child: CustomPaint(
+        painter: _TargetOverlayPainter(
+          shots: shots,
+          targetCenterX: targetCenterX,
+          targetCenterY: targetCenterY,
+          targetRadius: targetRadius,
+          targetType: targetType,
+          ringCount: ringCount,
+          ringRadii: ringRadii,
+          groupingCenterX: groupingCenterX,
+          groupingCenterY: groupingCenterY,
+          groupingDiameter: groupingDiameter,
+          referenceImpacts: referenceImpacts,
+          zoomScale: zoomScale,
+          showRings: showRings,
+        ),
+        child: LayoutBuilder(
+          builder: (context, constraints) {
+            return Stack(
               children: shots.map((shot) {
+                final x = shot.x * constraints.maxWidth;
+                final y = shot.y * constraints.maxHeight;
+                // Zone de tap qui reste constante à l'écran malgré le zoom.
+                final tapSize = 30 / zoomScale;
+                final halfTapSize = tapSize / 2;
                 return Positioned(
-                  left: 0,
-                  top: 0,
-                  right: 0,
-                  bottom: 0,
-                  child: LayoutBuilder(
-                    builder: (context, innerConstraints) {
-                      final x = shot.x * innerConstraints.maxWidth;
-                      final y = shot.y * innerConstraints.maxHeight;
-                      // Zone de tap qui s'adapte au zoom (taille fixe à l'écran)
-                      final tapSize = 30 / zoomScale;
-                      final halfTapSize = tapSize / 2;
-                      return Stack(
-                        children: [
-                          Positioned(
-                            left: x - halfTapSize,
-                            top: y - halfTapSize,
-                            child: GestureDetector(
-                              behavior: HitTestBehavior.translucent,
-                              onTap: () => onShotTapped?.call(shot),
-                              child: Container(
-                                width: tapSize,
-                                height: tapSize,
-                                decoration: const BoxDecoration(
-                                  color: Colors.transparent,
-                                  shape: BoxShape.circle,
-                                ),
-                              ),
-                            ),
-                          ),
-                        ],
-                      );
-                    },
+                  left: x - halfTapSize,
+                  top: y - halfTapSize,
+                  child: GestureDetector(
+                    // deferToChild : ne capte le toucher QUE sur la zone du
+                    // Container (un cercle opaque au hit-test), pas ailleurs.
+                    // Le reste de la surface reste donc disponible pour le
+                    // pinch/pan de l'InteractiveViewer.
+                    behavior: HitTestBehavior.deferToChild,
+                    onTap: () => onShotTapped?.call(shot),
+                    child: Container(
+                      width: tapSize,
+                      height: tapSize,
+                      decoration: const BoxDecoration(
+                        // Opaque pour le hit-test (couleur transparente visuellement
+                        // mais non nulle), pour que le tap soit bien capté ici.
+                        color: Color(0x01000000),
+                        shape: BoxShape.circle,
+                      ),
+                    ),
                   ),
                 );
               }).toList(),
-            ),
-          ),
-        );
-      },
+            );
+          },
+        ),
+      ),
     );
   }
 }
@@ -211,8 +205,8 @@ class _TargetOverlayPainter extends CustomPainter {
       final prevMultiplier = i == 0
           ? 0.0
           : (ringRadii != null && ringRadii!.length == ringCount)
-              ? ringRadii![i - 1]
-              : i / ringCount;
+          ? ringRadii![i - 1]
+          : i / ringCount;
       final zoneRadius = maxRadius * (currentMultiplier + prevMultiplier) / 2;
       final score = 10 - i;
 
@@ -292,16 +286,17 @@ class _TargetOverlayPainter extends CustomPainter {
     final strokeWidth = 3 / zoomScale;
     final fontSize = 10 / zoomScale;
 
-    // Draw outer circle (white outline for visibility)
+    // Draw outer circle (white outline for visibility) — gardé OPAQUE pour
+    // bien repérer le centre même quand le remplissage est transparent.
     final outlinePaint = Paint()
       ..color = AppTheme.impactOutlineColor
       ..style = PaintingStyle.stroke
       ..strokeWidth = strokeWidth;
     canvas.drawCircle(Offset(x, y), outerRadius, outlinePaint);
 
-    // Draw impact marker
+    // Draw impact marker — TRANSPARENCE 30% pour voir l'impact réel derrière
     final impactPaint = Paint()
-      ..color = AppTheme.impactColor
+      ..color = AppTheme.impactColor.withValues(alpha: 0.3)
       ..style = PaintingStyle.fill;
     canvas.drawCircle(Offset(x, y), innerRadius, impactPaint);
 
@@ -381,4 +376,4 @@ class _TargetOverlayPainter extends CustomPainter {
         zoomScale != oldDelegate.zoomScale ||
         showRings != oldDelegate.showRings;
   }
-}
+}

lib/features/capture/capture_screen.dart

@@ -1,19 +1,17 @@
-/// Écran de capture - Première étape du workflow d'analyse.
-///
-/// Permet de sélectionner le type de cible (concentrique ou silhouette)
-/// et la source d'image (caméra ou galerie). Affiche un aperçu de l'image
-/// sélectionnée avant de lancer l'analyse.
-library;
-
 import 'dart:io';
-import 'package:google_mlkit_document_scanner/google_mlkit_document_scanner.dart';
 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:provider/provider.dart';
 import '../../core/constants/app_constants.dart';
 import '../../core/theme/app_theme.dart';
 import '../../data/models/target_type.dart';
 import '../crop/crop_screen.dart';
+import '../session/session_provider.dart';
 import 'widgets/image_source_button.dart';
+import '../../services/document_scanner_service.dart'; // Scanner ML Kit : redresse la cible de face
 
 class CaptureScreen extends StatefulWidget {
   const CaptureScreen({super.key});
@@ -24,31 +22,41 @@ class CaptureScreen extends StatefulWidget {
 
 class _CaptureScreenState extends State<CaptureScreen> {
   final ImagePicker _picker = ImagePicker();
-  TargetType _selectedType = TargetType.concentric;
+  final TargetType _selectedType = TargetType.concentric;
+
+  // Scanner de documents Google ML Kit (redresse la cible de face automatiquement)
+  final DocumentScannerService _docScanner = DocumentScannerService();
+
   String? _selectedImagePath;
   bool _isLoading = false;
 
+  // ─────────────────────────────────────────────────────────────────────────
+  // Build principal
+  // ─────────────────────────────────────────────────────────────────────────
   @override
   Widget build(BuildContext context) {
+    final sessionProvider = context.watch<SessionProvider>();
+    final title = sessionProvider.isSessionActive
+        ? 'Cible ${sessionProvider.targetCount + 1}'
+        : 'Source';
+
     return Scaffold(
-      appBar: AppBar(title: const Text('Nouvelle Analyse')),
+      appBar: AppBar(title: Text(title)),
       body: SingleChildScrollView(
         padding: const EdgeInsets.all(AppConstants.defaultPadding),
         child: Column(
           crossAxisAlignment: CrossAxisAlignment.stretch,
           children: [
             const SizedBox(height: AppConstants.largePadding),
-
-            // Image source selection
             _buildSectionTitle('Source de l\'Image'),
             const SizedBox(height: 12),
             Row(
               children: [
                 Expanded(
                   child: ImageSourceButton(
-                    icon: Icons.camera_alt,
+                    icon: Icons.document_scanner,
                     label: 'Scanner',
-                    onPressed: _isLoading ? null : _scanDocument,
+                    onPressed: _isLoading ? null : _scanWithDocumentScanner,
                   ),
                 ),
                 const SizedBox(width: 12),
@@ -56,16 +64,12 @@ class _CaptureScreenState extends State<CaptureScreen> {
                   child: ImageSourceButton(
                     icon: Icons.photo_library,
                     label: 'Galerie',
-                    onPressed: _isLoading
-                        ? null
-                        : () => _captureImage(ImageSource.gallery),
+                    onPressed: _isLoading ? null : _handleGallerySelection,
                   ),
                 ),
               ],
             ),
             const SizedBox(height: AppConstants.largePadding),
-
-            // Image preview
             if (_isLoading)
               const Center(
                 child: Padding(
@@ -73,90 +77,148 @@ class _CaptureScreenState extends State<CaptureScreen> {
                   child: CircularProgressIndicator(),
                 ),
               )
-            else if (_selectedImagePath != null)
-              _buildImagePreview(),
-
-            // Guide text
-            if (_selectedImagePath == null && !_isLoading) _buildGuide(),
+            else
+              _buildGuide(),
           ],
         ),
       ),
-      floatingActionButton: _selectedImagePath != null
-          ? FloatingActionButton.extended(
-              onPressed: _analyzeImage,
-              icon: const Icon(Icons.arrow_forward),
-              label: const Text('Suivant'),
-            )
-          : null,
     );
   }
 
+  // ─────────────────────────────────────────────────────────────────────────
+  // Déclic → lance le scanner de documents Google ML Kit qui redresse
+  // automatiquement la cible (feuille rectangulaire) de face.
+  // ─────────────────────────────────────────────────────────────────────────
+  Future<void> _scanWithDocumentScanner() async {
+    setState(() => _isLoading = true);
+    try {
+      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;
+      }
+
+      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.'),
+          ),
+        );
+      }
+    } finally {
+      if (mounted) setState(() => _isLoading = false);
+    }
+  }
+
+  // ─────────────────────────────────────────────────────────────────────────
+  // Galerie (inchangée)
+  // ─────────────────────────────────────────────────────────────────────────
+  Future<void> _handleGallerySelection() async {
+    PermissionStatus status;
+
+    if (Platform.isAndroid) {
+      final deviceInfo = DeviceInfoPlugin();
+      final androidInfo = await deviceInfo.androidInfo;
+      status = androidInfo.version.sdkInt >= 33
+          ? await Permission.photos.request()
+          : await Permission.storage.request();
+    } else {
+      status = await Permission.photos.request();
+    }
+
+    if (status.isGranted) {
+      _captureImageFromGallery();
+    } else if (status.isPermanentlyDenied) {
+      _showSettingsDialog();
+    } else {
+      if (mounted) {
+        ScaffoldMessenger.of(context).showSnackBar(
+          const SnackBar(
+            content: Text('Accès à la galerie requis pour continuer'),
+          ),
+        );
+      }
+    }
+  }
+
+  void _showSettingsDialog() {
+    showDialog(
+      context: context,
+      builder: (context) => AlertDialog(
+        title: const Text('Permission requise'),
+        content: const Text(
+          'L\'accès aux photos est nécessaire. Veuillez l\'activer dans les paramètres.',
+        ),
+        actions: [
+          TextButton(
+            onPressed: () => Navigator.pop(context),
+            child: const Text('Annuler'),
+          ),
+          TextButton(
+            onPressed: () => openAppSettings(),
+            child: const Text('Paramètres'),
+          ),
+        ],
+      ),
+    );
+  }
+
+  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,
+        ),
+      ),
+    );
+  }
+
+  // ─────────────────────────────────────────────────────────────────────────
+  // Helpers UI
+  // ─────────────────────────────────────────────────────────────────────────
   Widget _buildSectionTitle(String title) {
     return Text(
       title,
-      style: Theme.of(
-        context,
-      ).textTheme.titleMedium?.copyWith(fontWeight: FontWeight.bold),
-    );
-  }
-
-  Widget _buildImagePreview() {
-    return Column(
-      children: [
-        _buildSectionTitle('Apercu'),
-        const SizedBox(height: 12),
-        ClipRRect(
-          borderRadius: BorderRadius.circular(AppConstants.borderRadius),
-          child: Stack(
-            children: [
-              Image.file(
-                File(_selectedImagePath!),
-                fit: BoxFit.contain,
-                width: double.infinity,
-              ),
-              Positioned(
-                top: 8,
-                right: 8,
-                child: IconButton(
-                  icon: const Icon(Icons.close),
-                  onPressed: () {
-                    setState(() => _selectedImagePath = null);
-                  },
-                  style: IconButton.styleFrom(
-                    backgroundColor: Colors.black54,
-                    foregroundColor: Colors.white,
-                  ),
-                ),
-              ),
-            ],
-          ),
-        ),
-        const SizedBox(height: 12),
-        _buildFramingHints(),
-      ],
-    );
-  }
-
-  Widget _buildFramingHints() {
-    return Card(
-      color: AppTheme.warningColor.withValues(alpha: 0.1),
-      child: Padding(
-        padding: const EdgeInsets.all(12),
-        child: Row(
-          children: [
-            Icon(Icons.info_outline, color: AppTheme.warningColor),
-            const SizedBox(width: 12),
-            Expanded(
-              child: Text(
-                'Assurez-vous que la cible est bien centree et visible.',
-                style: TextStyle(
-                  color: AppTheme.warningColor.withValues(alpha: 0.8),
-                ),
-              ),
-            ),
-          ],
-        ),
-      ),
+      style: Theme.of(context)
+          .textTheme
+          .titleMedium
+          ?.copyWith(fontWeight: FontWeight.bold),
     );
   }
 
@@ -170,18 +232,23 @@ class _CaptureScreenState extends State<CaptureScreen> {
             const SizedBox(height: 12),
             Text(
               'Conseils pour une bonne analyse',
-              style: Theme.of(
-                context,
-              ).textTheme.titleSmall?.copyWith(fontWeight: FontWeight.bold),
+              style: Theme.of(context)
+                  .textTheme
+                  .titleSmall
+                  ?.copyWith(fontWeight: FontWeight.bold),
             ),
             const SizedBox(height: 12),
             _buildGuideItem(
               Icons.crop_free,
-              'Cadrez la cible entiere dans l\'image',
+              'Cadrez la cible entière dans l\'image',
             ),
-            _buildGuideItem(Icons.wb_sunny, 'Utilisez un bon eclairage'),
+            _buildGuideItem(Icons.wb_sunny, 'Utilisez un bon éclairage'),
             _buildGuideItem(Icons.straighten, 'Prenez la photo de face'),
-            _buildGuideItem(Icons.blur_off, 'Evitez les images floues'),
+            _buildGuideItem(Icons.blur_off, 'Évitez les images floues'),
+            _buildGuideItem(
+              Icons.cleaning_services,
+              'Nettoyer votre objectif avec une chiffonnette',
+            ),
           ],
         ),
       ),
@@ -200,81 +267,4 @@ class _CaptureScreenState extends State<CaptureScreen> {
       ),
     );
   }
-
-  Future<void> _scanDocument() async {
-    setState(() => _isLoading = true);
-
-    try {
-      final options = DocumentScannerOptions(
-        documentFormat: DocumentFormat.jpeg,
-        mode: ScannerMode.base,
-        pageLimit: 1,
-        isGalleryImport: false,
-      );
-
-      final scanner = DocumentScanner(options: options);
-      final documents = await scanner.scanDocument();
-
-      if (documents.images.isNotEmpty) {
-        setState(() => _selectedImagePath = documents.images.first);
-      }
-    } catch (e) {
-      if (mounted) {
-        ScaffoldMessenger.of(context).showSnackBar(
-          SnackBar(
-            content: Text('Erreur lors du scan: $e'),
-            backgroundColor: AppTheme.errorColor,
-          ),
-        );
-      }
-    } finally {
-      if (mounted) {
-        setState(() => _isLoading = false);
-      }
-    }
-  }
-
-  Future<void> _captureImage(ImageSource source) async {
-    setState(() => _isLoading = true);
-
-    try {
-      final XFile? image = await _picker.pickImage(
-        source: source,
-        maxWidth: 2048,
-        maxHeight: 2048,
-        imageQuality: 90,
-      );
-
-      if (image != null) {
-        setState(() => _selectedImagePath = image.path);
-      }
-    } catch (e) {
-      if (mounted) {
-        ScaffoldMessenger.of(context).showSnackBar(
-          SnackBar(
-            content: Text('Erreur lors de la capture: $e'),
-            backgroundColor: AppTheme.errorColor,
-          ),
-        );
-      }
-    } finally {
-      if (mounted) {
-        setState(() => _isLoading = false);
-      }
-    }
-  }
-
-  void _analyzeImage() {
-    if (_selectedImagePath == null) return;
-
-    Navigator.push(
-      context,
-      MaterialPageRoute(
-        builder: (_) => CropScreen(
-          imagePath: _selectedImagePath!,
-          targetType: _selectedType,
-        ),
-      ),
-    );
-  }
-}
+}

lib/features/crop/crop_screen.dart

@@ -1,13 +1,7 @@
-/// Écran de recadrage d'image en format carré (1:1).
-///
-/// Permet à l'utilisateur de déplacer et zoomer l'image pour sélectionner
-/// la zone à recadrer. Le carré de recadrage est fixe au centre de l'écran.
-library;
-
 import 'dart:io';
 import 'dart:math' as math;
-import 'dart:ui' as ui;
 import 'package:flutter/material.dart';
+
 import '../../core/theme/app_theme.dart';
 import '../../data/models/target_type.dart';
 import '../../services/image_crop_service.dart';
@@ -17,11 +11,15 @@ import 'widgets/crop_overlay.dart';
 class CropScreen extends StatefulWidget {
   final String imagePath;
   final TargetType targetType;
+  final double? initialScale;
+  final Offset? initialOffset;
 
   const CropScreen({
     super.key,
     required this.imagePath,
     required this.targetType,
+    this.initialScale,
+    this.initialOffset,
   });
 
   @override
@@ -31,115 +29,248 @@ class CropScreen extends StatefulWidget {
 class _CropScreenState extends State<CropScreen> {
   final ImageCropService _cropService = ImageCropService();
 
+  // États de transformation
+  double _scale = 1.0;
+  double _baseScale = 1.0;
+  Offset _offset = Offset.zero;
+  Offset _startOffset = Offset.zero;
+  Offset _startFocalPoint = Offset.zero;
+
+  // PRÉCISION MAXIMUM : Amplitude restreinte de -15.0 à 15.0 degrés
+  double _rotation = 0.0;
+
   bool _isLoading = false;
   bool _imageLoaded = false;
   Size? _imageSize;
-
-  // Position et échelle de l'image
-  Offset _offset = Offset.zero;
-  double _scale = 1.0;
-  double _baseScale = 1.0;
-  Offset _startFocalPoint = Offset.zero;
-  Offset _startOffset = Offset.zero;
-
-  // Dimensions calculées
-  double _cropSize = 0;
-  Size _viewportSize = Size.zero;
+  late Size _viewportSize;
+  late double _cropSize;
 
   @override
   void initState() {
     super.initState();
-    _loadImageDimensions();
+    _loadImageInfo();
   }
 
-  Future<void> _loadImageDimensions() async {
+  Future<void> _loadImageInfo() async {
     final file = File(widget.imagePath);
-    final bytes = await file.readAsBytes();
-    final codec = await ui.instantiateImageCodec(bytes);
-    final frame = await codec.getNextFrame();
-
-    setState(() {
-      _imageSize = Size(
-        frame.image.width.toDouble(),
-        frame.image.height.toDouble(),
-      );
-      _imageLoaded = true;
-    });
+    final decodedImage = await decodeImageFromList(await file.readAsBytes());
+    if (mounted) {
+      setState(() {
+        _imageSize = Size(
+          decodedImage.width.toDouble(),
+          decodedImage.height.toDouble(),
+        );
+        _imageLoaded = true;
+      });
+    }
   }
 
   @override
   Widget build(BuildContext context) {
     return Scaffold(
-      backgroundColor: Colors.black,
+      backgroundColor: const Color(0xFF101214),
       appBar: AppBar(
-        backgroundColor: Colors.black,
-        foregroundColor: Colors.white,
-        title: const Text('Recadrer'),
+        backgroundColor: const Color(0xFF101214),
+        elevation: 0,
+        centerTitle: true,
+        title: const Text(
+          'Centrage de la cible',
+          style: TextStyle(color: Colors.white, fontSize: 18),
+        ),
         leading: IconButton(
-          icon: const Icon(Icons.close),
+          icon: const Icon(Icons.arrow_back, color: Colors.white),
           onPressed: () => Navigator.pop(context),
         ),
         actions: [
-          if (!_isLoading)
+          if (_rotation != 0.0 || _scale != 1.0 || _offset != Offset.zero)
             IconButton(
-              icon: const Icon(Icons.check),
-              onPressed: _onCropConfirm,
+              icon: const Icon(Icons.refresh, color: Colors.white70),
+              tooltip: 'Réinitialiser l\'orientation',
+              onPressed: () {
+                setState(() {
+                  _rotation = 0.0;
+                  _scale = 1.0;
+                  _offset = Offset.zero;
+                  _initializeImagePosition();
+                });
+              },
             ),
         ],
       ),
-      body: _buildBody(),
+      body: _isLoading
+          ? const Center(child: CircularProgressIndicator(color: Color(0xFF1A73E8)))
+          : Column(
+        children: [
+          // Zone interactive de crop
+          Expanded(
+            child: Container(
+              margin: const EdgeInsets.all(20),
+              decoration: BoxDecoration(
+                borderRadius: BorderRadius.circular(12),
+                border: Border.all(color: Colors.white10),
+              ),
+              child: ClipRRect(
+                borderRadius: BorderRadius.circular(12),
+                child: _imageLoaded ? _buildInteractiveCrop() : const Center(child: CircularProgressIndicator()),
+              ),
+            ),
+          ),
+
+          // TEXTE D'AIDE AJUSTÉ
+          Padding(
+            padding: const EdgeInsets.symmetric(horizontal: 20),
+            child: Column(
+              children: [
+                Row(
+                  mainAxisAlignment: MainAxisAlignment.center,
+                  children: [
+                    const Icon(Icons.center_focus_strong, color: Color(0xFF00FF00), size: 20),
+                    const SizedBox(width: 8),
+                    Text(
+                      'Alignez et pivotez la cible sur la croix',
+                      style: TextStyle(color: Colors.white.withOpacity(0.8), fontSize: 14, fontWeight: FontWeight.w500),
+                    ),
+                  ],
+                ),
+                const SizedBox(height: 4),
+                Text(
+                  'Glissez à un doigt pour déplacer, pincez pour zoomer',
+                  style: TextStyle(color: Colors.white.withOpacity(0.5), fontSize: 12),
+                ),
+              ],
+            ),
+          ),
+
+          const SizedBox(height: 16),
+
+          // JAUGE DE ROTATION HAUTE PRÉCISION BRIDÉE À 15°
+          Padding(
+            padding: const EdgeInsets.symmetric(horizontal: 24),
+            child: Column(
+              children: [
+                Row(
+                  mainAxisAlignment: MainAxisAlignment.spaceBetween,
+                  children: [
+                    const Text(
+                      'Rotation de l\'image',
+                      style: TextStyle(color: Colors.white70, fontSize: 13, fontWeight: FontWeight.w600),
+                    ),
+                    Text(
+                      '${_rotation.toStringAsFixed(1)}°',
+                      style: const TextStyle(color: Color(0xFF00FF00), fontWeight: FontWeight.bold),
+                    ),
+                  ],
+                ),
+                Row(
+                  children: [
+                    const Icon(Icons.rotate_left, color: Colors.white38, size: 20),
+                    Expanded(
+                      child: Slider(
+                        value: _rotation,
+                        min: -15.0,
+                        max: 15.0,
+                        divisions: 300,
+                        label: '${_rotation.toStringAsFixed(1)}°',
+                        activeColor: const Color(0xFF1A73E8),
+                        inactiveColor: Colors.white12,
+                        onChanged: (double value) {
+                          setState(() {
+                            _rotation = value;
+                          });
+                        },
+                      ),
+                    ),
+                    const Icon(Icons.rotate_right, color: Colors.white38, size: 20),
+                    const SizedBox(width: 4),
+                    IconButton(
+                      icon: const Icon(Icons.restart_alt, color: Colors.white54, size: 20),
+                      onPressed: () {
+                        setState(() {
+                          _rotation = 0.0;
+                        });
+                      },
+                    ),
+                  ],
+                ),
+              ],
+            ),
+          ),
+
+          // Boutons du bas
+          Padding(
+            padding: const EdgeInsets.fromLTRB(20, 10, 20, 30),
+            child: Row(
+              children: [
+                Expanded(
+                  child: OutlinedButton(
+                    onPressed: () => Navigator.pop(context),
+                    style: OutlinedButton.styleFrom(
+                      side: const BorderSide(color: Colors.white24),
+                      padding: const EdgeInsets.symmetric(vertical: 15),
+                      shape: RoundedRectangleBorder(borderRadius: BorderRadius.circular(8)),
+                    ),
+                    child: const Text('Retour', style: TextStyle(color: Colors.white)),
+                  ),
+                ),
+                const SizedBox(width: 16),
+                Expanded(
+                  child: ElevatedButton(
+                    onPressed: _onCropConfirm,
+                    style: ElevatedButton.styleFrom(
+                      backgroundColor: const Color(0xFF1A73E8),
+                      foregroundColor: Colors.white,
+                      padding: const EdgeInsets.symmetric(vertical: 15),
+                      shape: RoundedRectangleBorder(borderRadius: BorderRadius.circular(8)),
+                    ),
+                    child: const Text('Suivant', style: TextStyle(fontWeight: FontWeight.bold)),
+                  ),
+                ),
+              ],
+            ),
+          ),
+        ],
+      ),
     );
   }
 
-  Widget _buildBody() {
-    if (!_imageLoaded || _imageSize == null) {
-      return const Center(
-        child: CircularProgressIndicator(color: Colors.white),
-      );
-    }
-
-    if (_isLoading) {
-      return Center(
-        child: Column(
-          mainAxisAlignment: MainAxisAlignment.center,
-          children: [
-            const CircularProgressIndicator(color: Colors.white),
-            const SizedBox(height: 16),
-            Text(
-              'Recadrage en cours...',
-              style: TextStyle(color: Colors.white.withValues(alpha: 0.8)),
-            ),
-          ],
-        ),
-      );
-    }
-
+  Widget _buildInteractiveCrop() {
     return LayoutBuilder(
       builder: (context, constraints) {
         _viewportSize = Size(constraints.maxWidth, constraints.maxHeight);
 
-        // Taille du carré de crop (90% de la plus petite dimension)
-        _cropSize =
-            math.min(constraints.maxWidth, constraints.maxHeight) * 0.85;
+// FIX : On calcule d'abord la taille de la photo affichée avant de définir la taille du cadre vert !
+        final imageAspect = _imageSize != null ? _imageSize!.width / _imageSize!.height : 1.0;
+        final viewportAspect = _viewportSize.width / _viewportSize.height;
 
-        // Calculer l'échelle initiale si pas encore fait
-        if (_scale == 1.0 && _offset == Offset.zero) {
+        double displayWidth, displayHeight;
+        if (imageAspect > viewportAspect) {
+          displayWidth = _viewportSize.width;
+          displayHeight = _viewportSize.width / imageAspect;
+        } else {
+          displayHeight = _viewportSize.height;
+          displayWidth = _viewportSize.height * imageAspect;
+        }
+
+// On passe de 0.95 à 0.85 pour matcher parfaitement avec l'appareil photo !
+        _cropSize = math.min(displayWidth, displayHeight)* 0.85;
+
+        if (_scale == 1.0 && _offset == Offset.zero && _rotation == 0.0) {
           _initializeImagePosition();
         }
 
         return GestureDetector(
           onScaleStart: _onScaleStart,
           onScaleUpdate: _onScaleUpdate,
-          onScaleEnd: _onScaleEnd,
           child: Stack(
             children: [
-              // Image transformée
+              // 1. L'image brute avec ses transformations (Reste calé sur BoxFit.contain d'origine)
               Positioned.fill(
                 child: Center(
                   child: Transform(
                     transform: Matrix4.identity()
                       ..setTranslationRaw(_offset.dx, _offset.dy, 0)
-                      ..scale(_scale, _scale),
+                      ..scale(_scale, _scale)
+                      ..rotateZ(_rotation * (math.pi / 180)),
                     alignment: Alignment.center,
                     child: Image.file(
                       File(widget.imagePath),
@@ -151,19 +282,58 @@ class _CropScreenState extends State<CropScreen> {
                 ),
               ),
 
-              // Overlay de recadrage
+              // 2. Les lignes vertes de visée prolongées
               Positioned.fill(
                 child: IgnorePointer(
-                  child: CropOverlay(cropSize: _cropSize, showGrid: true),
+                  child: Stack(
+                    children: [
+                      Center(
+                        child: Container(
+                          width: double.infinity,
+                          height: 1.5,
+                          color: const Color(0xFF00FF00).withOpacity(0.6),
+                        ),
+                      ),
+                      Center(
+                        child: Container(
+                          width: 1.5,
+                          height: double.infinity,
+                          color: const Color(0xFF00FF00).withOpacity(0.6),
+                        ),
+                      ),
+                    ],
+                  ),
                 ),
               ),
 
-              // Instructions en bas
-              Positioned(
-                left: 0,
-                right: 0,
-                bottom: 24,
-                child: _buildInstructions(),
+              // 3. MASQUE OPAQUE EXTÉRIEUR - COINS DROITS ET CARRÉS
+              Positioned.fill(
+                child: IgnorePointer(
+                  child: ColorFiltered(
+                    colorFilter: ColorFilter.mode(
+                      const Color(0xFF101214),
+                      BlendMode.srcOut,
+                    ),
+                    child: Stack(
+                      children: [
+                        Center(
+                          child: Container(
+                            width: _cropSize,
+                            height: _cropSize,
+                            color: Colors.black,
+                          ),
+                        ),
+                      ],
+                    ),
+                  ),
+                ),
+              ),
+
+              // 4. Ton overlay avec les coins blancs
+              Positioned.fill(
+                child: IgnorePointer(
+                  child: CropOverlay(cropSize: _cropSize, showGrid: false),
+                ),
               ),
             ],
           ),
@@ -178,7 +348,7 @@ class _CropScreenState extends State<CropScreen> {
     final imageAspect = _imageSize!.width / _imageSize!.height;
     final viewportAspect = _viewportSize.width / _viewportSize.height;
 
-    // Calculer la taille de l'image affichée (avec BoxFit.contain)
+    // 1. Calcul strict de la taille de l'image affichée en BoxFit.contain
     double displayWidth, displayHeight;
     if (imageAspect > viewportAspect) {
       displayWidth = _viewportSize.width;
@@ -188,12 +358,18 @@ class _CropScreenState extends State<CropScreen> {
       displayWidth = _viewportSize.height * imageAspect;
     }
 
-    // Échelle pour que le plus petit côté de l'image remplisse le carré de crop
     final minDisplayDim = math.min(displayWidth, displayHeight);
-    _scale = _cropSize / minDisplayDim;
 
-    // S'assurer d'un scale minimum
-    if (_scale < 1.0) _scale = 1.0;
+    // 2. Calcul du scale initial basé sur la dimension de l'image (et non du viewport)
+    _scale = widget.initialScale ?? 1.0;
+    if (_scale < 1.0 && widget.initialScale == null) _scale = 1.0;
+
+    // 3. Réinitialisation propre de l'offset au centre de la zone d'affichage
+    if (widget.initialOffset != null) {
+      _offset = widget.initialOffset!;
+    } else {
+      _offset = Offset.zero; // Force l'image à se centrer parfaitement sur la croix verte
+    }
   }
 
   void _onScaleStart(ScaleStartDetails details) {
@@ -204,138 +380,70 @@ class _CropScreenState extends State<CropScreen> {
 
   void _onScaleUpdate(ScaleUpdateDetails details) {
     setState(() {
-      // Mise à jour du scale
-      _scale = (_baseScale * details.scale).clamp(0.5, 5.0);
-
-      // Mise à jour de la position
+      _scale = (_baseScale * details.scale).clamp(0.8, 8.0);
       final delta = details.focalPoint - _startFocalPoint;
       _offset = _startOffset + delta;
     });
   }
 
-  void _onScaleEnd(ScaleEndDetails details) {
-    // Optionnel: contraindre l'image pour qu'elle couvre toujours le carré de crop
-  }
-
-  Widget _buildInstructions() {
-    return Container(
-      margin: const EdgeInsets.symmetric(horizontal: 24),
-      padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 12),
-      decoration: BoxDecoration(
-        color: Colors.black.withValues(alpha: 0.7),
-        borderRadius: BorderRadius.circular(8),
-      ),
-      child: Row(
-        mainAxisAlignment: MainAxisAlignment.center,
-        children: [
-          Icon(
-            Icons.touch_app,
-            color: Colors.white.withValues(alpha: 0.8),
-            size: 20,
-          ),
-          const SizedBox(width: 8),
-          Text(
-            'Déplacez et zoomez pour cadrer la cible',
-            style: TextStyle(
-              color: Colors.white.withValues(alpha: 0.9),
-              fontSize: 14,
-            ),
-          ),
-        ],
-      ),
-    );
-  }
-
   Future<void> _onCropConfirm() async {
-    if (_imageSize == null) return;
-
-    setState(() {
-      _isLoading = true;
-    });
-
+    setState(() => _isLoading = true);
     try {
-      // Calculer la zone de crop en coordonnées normalisées de l'image
-      final cropRect = _calculateCropRect();
+      // Facteur d'échelle affichage/source (BoxFit.contain) — identique à
+      // celui utilisé pour afficher l'image dans l'aperçu.
+      final imageAspect = _imageSize!.width / _imageSize!.height;
+      final viewportAspect = _viewportSize.width / _viewportSize.height;
+      final double displayWidth = imageAspect > viewportAspect
+          ? _viewportSize.width
+          : _viewportSize.height * imageAspect;
+      final double displayPerSourcePx = displayWidth / _imageSize!.width;
 
-      // Recadrer l'image
-      final croppedPath = await _cropService.cropToSquare(
-        widget.imagePath,
-        cropRect,
+      // Découpe calée sur la fenêtre de visée : le DÉPLACEMENT (pan) et la
+      // ROTATION sont pris en compte, le ZOOM est ignoré, et les débordements
+      // sont remplis en noir → la position choisie est respectée à l'identique.
+      final croppedImagePath = await _cropService.cropViewport(
+        sourcePath: widget.imagePath,
+        offsetDx: _offset.dx,
+        offsetDy: _offset.dy,
+        displayPerSourcePx: displayPerSourcePx,
+        cropSizeDisplay: _cropSize,
+        // Le zoom sert UNIQUEMENT à viser le bon point (mapping du décalage) ;
+        // il n'agrandit pas le rendu de sortie.
+        zoomScale: _scale,
+        rotationDegrees: _rotation,
       );
 
+      const targetCenterX = 0.5;
+      const targetCenterY = 0.5;
+
       if (!mounted) return;
 
-      // Naviguer vers l'écran d'analyse avec l'image recadrée
       Navigator.pushReplacement(
         context,
         MaterialPageRoute(
           builder: (_) => AnalysisScreen(
-            imagePath: croppedPath,
+            imagePath: croppedImagePath,
+            // AJOUT : on conserve la SOURCE non rognée pour les retours arrière.
+            // Sans cela, revenir au crop repartait de l'image déjà rognée à 85%,
+            // provoquant un zoom cumulatif (0.85 x 0.85 x ...) à chaque aller-retour.
+            originalImagePath: widget.imagePath,
             targetType: widget.targetType,
+            initialCenterX: targetCenterX,
+            initialCenterY: targetCenterY,
+            cropScale: 1.0,
+            cropOffset: Offset.zero,
+            cropRotation: 0.0,
           ),
         ),
       );
     } catch (e) {
-      if (!mounted) return;
-
-      setState(() {
-        _isLoading = false;
-      });
-
-      ScaffoldMessenger.of(context).showSnackBar(
-        SnackBar(
-          content: Text('Erreur lors du recadrage: $e'),
-          backgroundColor: AppTheme.errorColor,
-        ),
-      );
+      if (mounted) {
+        setState(() => _isLoading = false);
+        ScaffoldMessenger.of(context).showSnackBar(
+          SnackBar(content: Text('Erreur de découpe : $e'), backgroundColor: AppTheme.errorColor),
+        );
+      }
     }
   }
 
-  CropRect _calculateCropRect() {
-    if (_imageSize == null) {
-      return const CropRect(x: 0, y: 0, width: 1, height: 1);
-    }
-
-    final imageAspect = _imageSize!.width / _imageSize!.height;
-    final viewportAspect = _viewportSize.width / _viewportSize.height;
-
-    // Calculer la taille de l'image affichée (avec BoxFit.contain)
-    double displayWidth, displayHeight;
-    if (imageAspect > viewportAspect) {
-      displayWidth = _viewportSize.width;
-      displayHeight = _viewportSize.width / imageAspect;
-    } else {
-      displayHeight = _viewportSize.height;
-      displayWidth = _viewportSize.height * imageAspect;
-    }
-
-    // Taille de l'image après scale
-    final scaledWidth = displayWidth * _scale;
-    final scaledHeight = displayHeight * _scale;
-
-    // Position du centre de l'image dans le viewport
-    final imageCenterX = _viewportSize.width / 2 + _offset.dx;
-    final imageCenterY = _viewportSize.height / 2 + _offset.dy;
-
-    // Position du coin supérieur gauche de l'image
-    final imageLeft = imageCenterX - scaledWidth / 2;
-    final imageTop = imageCenterY - scaledHeight / 2;
-
-    // Position du carré de crop (centré dans le viewport)
-    final cropLeft = (_viewportSize.width - _cropSize) / 2;
-    final cropTop = (_viewportSize.height - _cropSize) / 2;
-
-    // Convertir en coordonnées relatives à l'image affichée
-    final relCropLeft = (cropLeft - imageLeft) / scaledWidth;
-    final relCropTop = (cropTop - imageTop) / scaledHeight;
-    final relCropSize = _cropSize / scaledWidth;
-    final relCropSizeY = _cropSize / scaledHeight;
-
-    return CropRect(
-      x: relCropLeft.clamp(0.0, 1.0),
-      y: relCropTop.clamp(0.0, 1.0),
-      width: relCropSize.clamp(0.0, 1.0 - relCropLeft.clamp(0.0, 1.0)),
-      height: relCropSizeY.clamp(0.0, 1.0 - relCropTop.clamp(0.0, 1.0)),
-    );
-  }
-}
+}

lib/features/crop/widgets/crop_overlay.dart

@@ -68,7 +68,7 @@ class _CropOverlayPainter extends CustomPainter {
       _drawGrid(canvas, cropRect);
     }
 
-    // Dessiner le point central (croix)
+    // Dessiner le point central (croix interne vert fluo)
     _drawCenterPoint(canvas, cropRect);
   }
 
@@ -165,39 +165,44 @@ class _CropOverlayPainter extends CustomPainter {
   }
 
   void _drawCenterPoint(Canvas canvas, Rect rect) {
+    // Peinture de la croix interne (Vert Fluo)
     final centerPaint = Paint()
-      ..color = Colors.white.withValues(alpha: 0.8)
+      ..color = const Color(0xFF00FF00)
       ..style = PaintingStyle.stroke
-      ..strokeWidth = 2;
+      ..strokeWidth = 2.0;
 
-    const size = 10.0;
+    // Cercle extérieur (Vert Fluo fin)
+    final circlePaint = Paint()
+      ..color = const Color(0xFF00FF00).withValues(alpha: 0.9)
+      ..style = PaintingStyle.stroke
+      ..strokeWidth = 1.2;
+
+    const circleRadius = 10.0; // Augmenté légèrement à 10 pour que la croix respire
     final centerX = rect.center.dx;
     final centerY = rect.center.dy;
 
-    // Ligne horizontale
+    // 1. Dessiner le cercle de contour
+    canvas.drawCircle(rect.center, circleRadius, circlePaint);
+
+    // 2. Dessiner la croix UNIQUEMENT à l'intérieur du cercle
+
+    // Ligne horizontale (de gauche à droite, reste à l'intérieur)
     canvas.drawLine(
-      Offset(centerX - size, centerY),
-      Offset(centerX + size, centerY),
+      Offset(centerX - circleRadius, centerY),
+      Offset(centerX + circleRadius, centerY),
       centerPaint,
     );
 
-    // Ligne verticale
+    // Ligne verticale (de haut en bas, reste à l'intérieur)
     canvas.drawLine(
-      Offset(centerX, centerY - size),
-      Offset(centerX, centerY + size),
+      Offset(centerX, centerY - circleRadius),
+      Offset(centerX, centerY + circleRadius),
       centerPaint,
     );
-
-    // Petit cercle central pour précision (optionnel, mais aide à viser)
-    canvas.drawCircle(
-      rect.center,
-      2,
-      Paint()..color = Colors.red.withValues(alpha: 0.6),
-    );
   }
 
   @override
   bool shouldRepaint(covariant _CropOverlayPainter oldDelegate) {
     return cropSize != oldDelegate.cropSize || showGrid != oldDelegate.showGrid;
   }
-}
+}

lib/features/garage/weapon_detail_screen.dart

@@ -0,0 +1,414 @@
+import 'package:flutter/material.dart';
+import 'package:provider/provider.dart';
+import 'package:intl/intl.dart';
+import '../../core/constants/app_constants.dart';
+import '../../core/theme/app_theme.dart';
+import '../../data/models/weapon.dart';
+import '../../data/models/maintenance.dart';
+import '../../data/repositories/session_repository.dart';
+
+class WeaponDetailScreen extends StatefulWidget {
+  final Weapon weapon;
+  const WeaponDetailScreen({super.key, required this.weapon});
+
+  @override
+  State<WeaponDetailScreen> createState() => _WeaponDetailScreenState();
+}
+
+class _WeaponDetailScreenState extends State<WeaponDetailScreen> {
+  late Weapon _weapon;
+  List<MaintenanceEntry> _maintenance = [];
+  int _totalRounds = 0;
+  bool _isLoading = true;
+
+  @override
+  void initState() {
+    super.initState();
+    _weapon = widget.weapon;
+    _loadData();
+  }
+
+  Future<void> _loadData() async {
+    final repository = context.read<SessionRepository>();
+    final history = await repository.getMaintenanceHistory(_weapon.id);
+    final rounds = await repository.getRoundsFiredForWeapon(_weapon.id);
+    if (mounted) {
+      setState(() {
+        _maintenance = history;
+        _totalRounds = rounds;
+        _isLoading = false;
+      });
+    }
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    return Scaffold(
+      appBar: AppBar(
+        title: Text(_weapon.customName ?? _weapon.name),
+        actions: [
+          IconButton(
+            icon: const Icon(Icons.edit),
+            onPressed: () => _showEditWeaponDialog(context),
+          ),
+        ],
+      ),
+      body: _isLoading
+          ? const Center(child: CircularProgressIndicator())
+          : SingleChildScrollView(
+              padding: const EdgeInsets.all(AppConstants.defaultPadding),
+              child: Column(
+                crossAxisAlignment: CrossAxisAlignment.stretch,
+                children: [
+                  _buildStatsSection(),
+                  const SizedBox(height: 24),
+                  _buildInfoCard(),
+                  const SizedBox(height: 24),
+                  _buildOptionsCard(),
+                  const SizedBox(height: 24),
+                  _buildHistorySection(),
+                ],
+              ),
+            ),
+      floatingActionButton: FloatingActionButton.extended(
+        onPressed: () => _showAddMaintenanceDialog(context),
+        label: const Text('Entretien'),
+        icon: const Icon(Icons.build),
+      ),
+    );
+  }
+
+  Widget _buildStatsSection() {
+    return Row(
+      children: [
+        Expanded(
+          child: _buildStatCard(
+            'Total Tirs',
+            _totalRounds.toString(),
+            Icons.ads_click,
+            AppTheme.primaryColor,
+          ),
+        ),
+        const SizedBox(width: 16),
+        Expanded(
+          child: _buildStatCard(
+            'Sessions',
+            'N/A',
+            Icons.history,
+            Colors.orange,
+          ),
+        ),
+      ],
+    );
+  }
+
+  Widget _buildStatCard(String label, String value, IconData icon, Color color) {
+    return Card(
+      child: Padding(
+        padding: const EdgeInsets.all(16.0),
+        child: Column(
+          children: [
+            Icon(icon, color: color),
+            const SizedBox(height: 8),
+            Text(value, style: const TextStyle(fontSize: 20, fontWeight: FontWeight.bold)),
+            Text(label, style: const TextStyle(fontSize: 12, color: Colors.grey)),
+          ],
+        ),
+      ),
+    );
+  }
+
+  Widget _buildInfoCard() {
+    return Card(
+      child: Padding(
+        padding: const EdgeInsets.all(16.0),
+        child: Column(
+          crossAxisAlignment: CrossAxisAlignment.start,
+          children: [
+            const Text('Informations techniques', style: TextStyle(fontWeight: FontWeight.bold, fontSize: 16)),
+            const Divider(),
+            _buildInfoRow('Modèle', _weapon.name),
+            _buildInfoRow('Type', _weapon.type.displayName),
+            _buildInfoRow('Calibre', _weapon.caliber),
+            _buildInfoRow('Chargeurs', '${_weapon.magazineCount} x ${_weapon.magazineCapacity} coups'),
+            if (_weapon.notes != null && _weapon.notes!.isNotEmpty) ...[
+              const SizedBox(height: 8),
+              const Text('Notes:', style: TextStyle(fontWeight: FontWeight.w500)),
+              Text(_weapon.notes!, style: const TextStyle(color: Colors.grey)),
+            ],
+          ],
+        ),
+      ),
+    );
+  }
+
+  Widget _buildOptionsCard() {
+    return Card(
+      child: Padding(
+        padding: const EdgeInsets.all(16.0),
+        child: Column(
+          crossAxisAlignment: CrossAxisAlignment.start,
+          children: [
+            const Text('Options & Personnalisation', style: TextStyle(fontWeight: FontWeight.bold, fontSize: 16)),
+            const Divider(),
+            _buildInfoRow('Optique / Lunette', _weapon.optic ?? 'Mire fer'),
+            _buildInfoRow('Modérateur / Silencieux', _weapon.silencer ?? 'Aucun'),
+            _buildInfoRow('Détente', _weapon.trigger ?? 'Standard'),
+            if (_weapon.customName != null)
+              _buildInfoRow('Surnom', _weapon.customName!),
+          ],
+        ),
+      ),
+    );
+  }
+
+  Widget _buildInfoRow(String label, String value) {
+    return Padding(
+      padding: const EdgeInsets.symmetric(vertical: 4.0),
+      child: Row(
+        mainAxisAlignment: MainAxisAlignment.spaceBetween,
+        children: [
+          Text(label, style: const TextStyle(color: Colors.grey)),
+          Text(value, style: const TextStyle(fontWeight: FontWeight.w500)),
+        ],
+      ),
+    );
+  }
+
+  Widget _buildHistorySection() {
+    return Column(
+      crossAxisAlignment: CrossAxisAlignment.start,
+      children: [
+        const Text('Historique d\'entretien', style: TextStyle(fontWeight: FontWeight.bold, fontSize: 18)),
+        const SizedBox(height: 8),
+        if (_maintenance.isEmpty)
+          const Padding(
+            padding: EdgeInsets.symmetric(vertical: 24.0),
+            child: Center(child: Text('Aucun entretien enregistré', style: TextStyle(color: Colors.grey))),
+          )
+        else
+          ListView.builder(
+            shrinkWrap: true,
+            physics: const NeverScrollableScrollPhysics(),
+            itemCount: _maintenance.length,
+            itemBuilder: (context, index) {
+              final entry = _maintenance[index];
+              return Card(
+                margin: const EdgeInsets.only(bottom: 8),
+                child: ListTile(
+                  leading: CircleAvatar(
+                    backgroundColor: _getMaintenanceColor(entry.type).withValues(alpha: 0.1),
+                    child: Icon(_getMaintenanceIcon(entry.type), color: _getMaintenanceColor(entry.type), size: 20),
+                  ),
+                  title: Text(entry.type.displayName),
+                  subtitle: Text(entry.description),
+                  trailing: Text(DateFormat('dd/MM/yy').format(entry.date), style: const TextStyle(fontSize: 12)),
+                  onLongPress: () => _confirmDeleteMaintenance(context, entry),
+                ),
+              );
+            },
+          ),
+      ],
+    );
+  }
+
+  Color _getMaintenanceColor(MaintenanceType type) {
+    switch (type) {
+      case MaintenanceType.cleaning: return Colors.blue;
+      case MaintenanceType.repair: return Colors.red;
+      case MaintenanceType.inspection: return Colors.green;
+      case MaintenanceType.upgrade: return Colors.purple;
+      case MaintenanceType.other: return Colors.grey;
+    }
+  }
+
+  IconData _getMaintenanceIcon(MaintenanceType type) {
+    switch (type) {
+      case MaintenanceType.cleaning: return Icons.opacity;
+      case MaintenanceType.repair: return Icons.build;
+      case MaintenanceType.inspection: return Icons.visibility;
+      case MaintenanceType.upgrade: return Icons.trending_up;
+      case MaintenanceType.other: return Icons.more_horiz;
+    }
+  }
+
+  void _showEditWeaponDialog(BuildContext context) async {
+    final nameController = TextEditingController(text: _weapon.name);
+    final caliberController = TextEditingController(text: _weapon.caliber);
+    final magCountController = TextEditingController(text: _weapon.magazineCount.toString());
+    final magCapController = TextEditingController(text: _weapon.magazineCapacity.toString());
+    final notesController = TextEditingController(text: _weapon.notes);
+    final opticController = TextEditingController(text: _weapon.optic);
+    final silencerController = TextEditingController(text: _weapon.silencer);
+    final triggerController = TextEditingController(text: _weapon.trigger);
+    final customNameController = TextEditingController(text: _weapon.customName);
+    WeaponType selectedType = _weapon.type;
+
+    final result = await showDialog<bool>(
+      context: context,
+      builder: (context) => StatefulBuilder(
+        builder: (context, setState) => AlertDialog(
+          title: const Text('Modifier l\'arme'),
+          content: SingleChildScrollView(
+            child: Column(
+              mainAxisSize: MainAxisSize.min,
+              children: [
+                TextField(
+                  controller: nameController,
+                  decoration: const InputDecoration(labelText: 'Modèle', hintText: 'ex: Glock 17'),
+                ),
+                TextField(
+                  controller: customNameController,
+                  decoration: const InputDecoration(labelText: 'Surnom / Custom Name', hintText: 'ex: Mon Glock de Compète'),
+                ),
+                DropdownButtonFormField<WeaponType>(
+                  value: selectedType,
+                  decoration: const InputDecoration(labelText: 'Type'),
+                  items: WeaponType.values.map((t) => DropdownMenuItem(value: t, child: Text(t.displayName))).toList(),
+                  onChanged: (v) => setState(() => selectedType = v!),
+                ),
+                TextField(
+                  controller: caliberController,
+                  decoration: const InputDecoration(labelText: 'Calibre'),
+                ),
+                const SizedBox(height: 16),
+                const Text('Équipement & Options', style: TextStyle(fontWeight: FontWeight.bold)),
+                TextField(
+                  controller: opticController,
+                  decoration: const InputDecoration(labelText: 'Optique / Lunette', hintText: 'ex: Holosun 507C'),
+                ),
+                TextField(
+                  controller: silencerController,
+                  decoration: const InputDecoration(labelText: 'Modérateur / Silencieux'),
+                ),
+                TextField(
+                  controller: triggerController,
+                  decoration: const InputDecoration(labelText: 'Détente / Trigger'),
+                ),
+                const SizedBox(height: 16),
+                const Text('Logistique', style: TextStyle(fontWeight: FontWeight.bold)),
+                Row(
+                  children: [
+                    Expanded(
+                      child: TextField(
+                        controller: magCountController,
+                        decoration: const InputDecoration(labelText: 'Chargeurs'),
+                        keyboardType: TextInputType.number,
+                      ),
+                    ),
+                    const SizedBox(width: 16),
+                    Expanded(
+                      child: TextField(
+                        controller: magCapController,
+                        decoration: const InputDecoration(labelText: 'Capacité'),
+                        keyboardType: TextInputType.number,
+                      ),
+                    ),
+                  ],
+                ),
+                TextField(
+                  controller: notesController,
+                  decoration: const InputDecoration(labelText: 'Notes'),
+                  maxLines: 2,
+                ),
+              ],
+            ),
+          ),
+          actions: [
+            TextButton(onPressed: () => Navigator.pop(context, false), child: const Text('Annuler')),
+            ElevatedButton(onPressed: () => Navigator.pop(context, true), child: const Text('Enregistrer')),
+          ],
+        ),
+      ),
+    );
+
+    if (result == true) {
+      final updatedWeapon = _weapon.copyWith(
+        name: nameController.text,
+        type: selectedType,
+        caliber: caliberController.text,
+        magazineCount: int.tryParse(magCountController.text) ?? 1,
+        magazineCapacity: int.tryParse(magCapController.text) ?? 10,
+        notes: notesController.text,
+        optic: opticController.text.isEmpty ? null : opticController.text,
+        silencer: silencerController.text.isEmpty ? null : silencerController.text,
+        trigger: triggerController.text.isEmpty ? null : triggerController.text,
+        customName: customNameController.text.isEmpty ? null : customNameController.text,
+      );
+      
+      final repository = context.read<SessionRepository>();
+      await repository.updateWeapon(updatedWeapon);
+      setState(() {
+        _weapon = updatedWeapon;
+      });
+    }
+  }
+
+  void _showAddMaintenanceDialog(BuildContext context) async {
+    final descController = TextEditingController();
+    MaintenanceType selectedType = MaintenanceType.cleaning;
+
+    final result = await showDialog<bool>(
+      context: context,
+      builder: (context) => StatefulBuilder(
+        builder: (context, setState) => AlertDialog(
+          title: const Text('Ajouter un entretien'),
+          content: Column(
+            mainAxisSize: MainAxisSize.min,
+            children: [
+              DropdownButtonFormField<MaintenanceType>(
+                value: selectedType,
+                decoration: const InputDecoration(labelText: 'Type d\'intervention'),
+                items: MaintenanceType.values.map((t) => DropdownMenuItem(value: t, child: Text(t.displayName))).toList(),
+                onChanged: (v) => setState(() => selectedType = v!),
+              ),
+              TextField(
+                controller: descController,
+                decoration: const InputDecoration(labelText: 'Description', hintText: 'ex: Nettoyage complet après séance'),
+                maxLines: 2,
+              ),
+            ],
+          ),
+          actions: [
+            TextButton(onPressed: () => Navigator.pop(context, false), child: const Text('Annuler')),
+            ElevatedButton(onPressed: () => Navigator.pop(context, true), child: const Text('Ajouter')),
+          ],
+        ),
+      ),
+    );
+
+    if (result == true && descController.text.isNotEmpty) {
+      final repository = context.read<SessionRepository>();
+      await repository.addMaintenanceEntry(
+        weaponId: _weapon.id,
+        type: selectedType,
+        description: descController.text,
+        roundsSinceLast: _totalRounds,
+      );
+      _loadData();
+    }
+  }
+
+  void _confirmDeleteMaintenance(BuildContext context, MaintenanceEntry entry) async {
+    final confirmed = await showDialog<bool>(
+      context: context,
+      builder: (context) => AlertDialog(
+        title: const Text('Supprimer'),
+        content: const Text('Supprimer cette entrée de l\'historique ?'),
+        actions: [
+          TextButton(onPressed: () => Navigator.pop(context, false), child: const Text('Annuler')),
+          TextButton(
+            onPressed: () => Navigator.pop(context, true),
+            child: const Text('Supprimer', style: TextStyle(color: AppTheme.errorColor)),
+          ),
+        ],
+      ),
+    );
+
+    if (confirmed == true) {
+      final repository = context.read<SessionRepository>();
+      await repository.deleteMaintenanceEntry(entry.id);
+      _loadData();
+    }
+  }
+}

lib/features/garage/weapon_list_screen.dart

@@ -0,0 +1,208 @@
+import 'package:flutter/material.dart';
+import 'package:provider/provider.dart';
+import '../../core/constants/app_constants.dart';
+import '../../core/theme/app_theme.dart';
+import '../../data/models/weapon.dart';
+import '../../data/repositories/session_repository.dart';
+import 'weapon_detail_screen.dart';
+
+class WeaponListScreen extends StatefulWidget {
+  const WeaponListScreen({super.key});
+
+  @override
+  State<WeaponListScreen> createState() => _WeaponListScreenState();
+}
+
+class _WeaponListScreenState extends State<WeaponListScreen> {
+  List<Weapon> _weapons = [];
+  bool _isLoading = true;
+
+  @override
+  void initState() {
+    super.initState();
+    _loadWeapons();
+  }
+
+  Future<void> _loadWeapons() async {
+    final repository = context.read<SessionRepository>();
+    final weapons = await repository.getWeapons();
+    if (mounted) {
+      setState(() {
+        _weapons = weapons;
+        _isLoading = false;
+      });
+    }
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    return Scaffold(
+      appBar: AppBar(
+        title: const Text('Mon Armurerie'),
+      ),
+      body: _isLoading
+          ? const Center(child: CircularProgressIndicator())
+          : _weapons.isEmpty
+              ? _buildEmptyState()
+              : _buildWeaponList(),
+      floatingActionButton: FloatingActionButton(
+        onPressed: () => _showAddWeaponDialog(context),
+        child: const Icon(Icons.add),
+      ),
+    );
+  }
+
+  Widget _buildEmptyState() {
+    return Center(
+      child: Column(
+        mainAxisAlignment: MainAxisAlignment.center,
+        children: [
+          Icon(Icons.shield, size: 64, color: Colors.grey[400]),
+          const SizedBox(height: 16),
+          const Text('Aucune arme enregistrée'),
+          const SizedBox(height: 24),
+          ElevatedButton(
+            onPressed: () => _showAddWeaponDialog(context),
+            child: const Text('Ajouter ma première arme'),
+          ),
+        ],
+      ),
+    );
+  }
+
+  Widget _buildWeaponList() {
+    return ListView.builder(
+      padding: const EdgeInsets.all(AppConstants.defaultPadding),
+      itemCount: _weapons.length,
+      itemBuilder: (context, index) {
+        final weapon = _weapons[index];
+        return Card(
+          margin: const EdgeInsets.only(bottom: 12),
+          child: ListTile(
+            leading: CircleAvatar(
+              backgroundColor: AppTheme.primaryColor.withValues(alpha: 0.1),
+              child: Icon(
+                weapon.type == WeaponType.handgun ? Icons.shield : Icons.ads_click,
+                color: AppTheme.primaryColor,
+              ),
+            ),
+            title: Text(weapon.displayName, style: const TextStyle(fontWeight: FontWeight.bold)),
+            subtitle: Text('${weapon.type.displayName} • ${weapon.caliber}'),
+            trailing: Column(
+              mainAxisAlignment: MainAxisAlignment.center,
+              crossAxisAlignment: CrossAxisAlignment.end,
+              children: [
+                Text('${weapon.magazineCount} chargeurs', style: const TextStyle(fontSize: 12)),
+                Text('${weapon.magazineCapacity} coups', style: const TextStyle(fontSize: 12, color: Colors.grey)),
+              ],
+            ),
+            onTap: () async {
+              await Navigator.push(
+                context,
+                MaterialPageRoute(builder: (_) => WeaponDetailScreen(weapon: weapon)),
+              );
+              _loadWeapons(); // Reload in case it was edited or maintenance was added
+            },
+            onLongPress: () => _confirmDelete(context, weapon),
+          ),
+        );
+      },
+    );
+  }
+
+  void _showAddWeaponDialog(BuildContext context) async {
+    final nameController = TextEditingController();
+    final caliberController = TextEditingController();
+    final magCountController = TextEditingController(text: '2');
+    final magCapController = TextEditingController(text: '15');
+    WeaponType selectedType = WeaponType.handgun;
+
+    final result = await showDialog<bool>(
+      context: context,
+      builder: (context) => StatefulBuilder(
+        builder: (context, setState) => AlertDialog(
+          title: const Text('Ajouter une arme'),
+          content: SingleChildScrollView(
+            child: Column(
+              mainAxisSize: MainAxisSize.min,
+              children: [
+                TextField(
+                  controller: nameController,
+                  decoration: const InputDecoration(labelText: 'Nom de l\'arme', hintText: 'ex: Glock 17'),
+                ),
+                DropdownButtonFormField<WeaponType>(
+                  value: selectedType,
+                  decoration: const InputDecoration(labelText: 'Type'),
+                  items: WeaponType.values.map((t) => DropdownMenuItem(value: t, child: Text(t.displayName))).toList(),
+                  onChanged: (v) => setState(() => selectedType = v!),
+                ),
+                TextField(
+                  controller: caliberController,
+                  decoration: const InputDecoration(labelText: 'Calibre', hintText: 'ex: 9mm, .22LR'),
+                ),
+                Row(
+                  children: [
+                    Expanded(
+                      child: TextField(
+                        controller: magCountController,
+                        decoration: const InputDecoration(labelText: 'Chargeurs'),
+                        keyboardType: TextInputType.number,
+                      ),
+                    ),
+                    const SizedBox(width: 16),
+                    Expanded(
+                      child: TextField(
+                        controller: magCapController,
+                        decoration: const InputDecoration(labelText: 'Capacité'),
+                        keyboardType: TextInputType.number,
+                      ),
+                    ),
+                  ],
+                ),
+              ],
+            ),
+          ),
+          actions: [
+            TextButton(onPressed: () => Navigator.pop(context, false), child: const Text('Annuler')),
+            ElevatedButton(onPressed: () => Navigator.pop(context, true), child: const Text('Ajouter')),
+          ],
+        ),
+      ),
+    );
+
+    if (result == true && nameController.text.isNotEmpty) {
+      final repository = context.read<SessionRepository>();
+      await repository.addWeapon(
+        name: nameController.text,
+        type: selectedType,
+        caliber: caliberController.text,
+        magazineCount: int.tryParse(magCountController.text) ?? 1,
+        magazineCapacity: int.tryParse(magCapController.text) ?? 10,
+      );
+      _loadWeapons();
+    }
+  }
+
+  void _confirmDelete(BuildContext context, Weapon weapon) async {
+    final confirmed = await showDialog<bool>(
+      context: context,
+      builder: (context) => AlertDialog(
+        title: const Text('Supprimer'),
+        content: Text('Voulez-vous supprimer ${weapon.name} de votre armurerie ?'),
+        actions: [
+          TextButton(onPressed: () => Navigator.pop(context, false), child: const Text('Annuler')),
+          TextButton(
+            onPressed: () => Navigator.pop(context, true),
+            child: const Text('Supprimer', style: TextStyle(color: AppTheme.errorColor)),
+          ),
+        ],
+      ),
+    );
+
+    if (confirmed == true) {
+      final repository = context.read<SessionRepository>();
+      await repository.deleteWeapon(weapon.id);
+      _loadWeapons();
+    }
+  }
+}

lib/features/history/history_screen.dart

@@ -1,10 +1,3 @@
-/// Écran d'historique des sessions.
-///
-/// Affiche la liste des sessions passées avec filtrage par type de cible.
-/// Inclut un graphique d'évolution des scores (10 dernières sessions)
-/// et permet la navigation vers le détail de chaque session.
-library;
-
 import 'package:flutter/material.dart';
 import 'package:provider/provider.dart';
 import 'package:intl/intl.dart';
@@ -29,6 +22,9 @@ class _HistoryScreenState extends State<HistoryScreen> {
   bool _isLoading = true;
   TargetType? _filterType;
 
+  // --- MODIFICATION : Remplacement de DateTime par DateTimeRange ---
+  DateTimeRange? _selectedDateRange;
+
   @override
   void initState() {
     super.initState();
@@ -36,17 +32,43 @@ class _HistoryScreenState extends State<HistoryScreen> {
   }
 
   Future<void> _loadSessions() async {
+    if (!mounted) return;
     setState(() => _isLoading = true);
 
     try {
       final repository = context.read<SessionRepository>();
-      final sessions = await repository.getAllSessions(
-        targetType: _filterType,
-      );
+      final sessions = await repository.getAllSessions();
 
       if (mounted) {
         setState(() {
           _sessions = sessions;
+
+          // --- LOGIQUE DE FILTRAGE PAR PÉRIODE ---
+          if (_selectedDateRange != null) {
+            _sessions = _sessions.where((s) {
+              // On compare uniquement les dates (sans les heures) pour éviter les bugs
+              final sessionDate = DateTime(
+                s.createdAt.year,
+                s.createdAt.month,
+                s.createdAt.day,
+              );
+              final startDate = DateTime(
+                _selectedDateRange!.start.year,
+                _selectedDateRange!.start.month,
+                _selectedDateRange!.start.day,
+              );
+              final endDate = DateTime(
+                _selectedDateRange!.end.year,
+                _selectedDateRange!.end.month,
+                _selectedDateRange!.end.day,
+              );
+
+              return sessionDate.isAtSameMomentAs(startDate) ||
+                  sessionDate.isAtSameMomentAs(endDate) ||
+                  (sessionDate.isAfter(startDate) &&
+                      sessionDate.isBefore(endDate));
+            }).toList();
+          }
           _isLoading = false;
         });
       }
@@ -55,7 +77,7 @@ class _HistoryScreenState extends State<HistoryScreen> {
         setState(() => _isLoading = false);
         ScaffoldMessenger.of(context).showSnackBar(
           SnackBar(
-            content: Text('Erreur de chargement: $e'),
+            content: Text('Erreur: $e'),
             backgroundColor: AppTheme.errorColor,
           ),
         );
@@ -63,6 +85,40 @@ class _HistoryScreenState extends State<HistoryScreen> {
     }
   }
 
+  // --- MODIFICATION : Fonction DateRangePicker ---
+  Future<void> _pickDateRange() async {
+    final DateTimeRange? picked = await showDateRangePicker(
+      context: context,
+      initialDateRange: _selectedDateRange,
+      firstDate: DateTime(2020),
+      lastDate: DateTime.now().add(const Duration(days: 1)),
+      locale: const Locale('fr', 'FR'),
+      builder: (context, child) {
+        return Theme(
+          data: ThemeData.light().copyWith(
+            colorScheme: ColorScheme.light(
+              primary: AppTheme.primaryColor,   // En-tête et sélection
+              onPrimary: Colors.white,          // Texte sur en-tête/sélection
+              surface: Colors.white,            // Fond du calendrier
+              onSurface: Colors.black87,        // Texte des dates (Noir sur Blanc)
+              secondary: AppTheme.primaryColor,
+            ),
+            dialogBackgroundColor: Colors.white,
+            textButtonTheme: TextButtonThemeData(
+              style: TextButton.styleFrom(foregroundColor: AppTheme.primaryColor),
+            ),
+          ),
+          child: child!,
+        );
+      },
+    );
+
+    if (picked != null) {
+      setState(() => _selectedDateRange = picked);
+      _loadSessions();
+    }
+  }
+
   @override
   Widget build(BuildContext context) {
     return Scaffold(
@@ -71,55 +127,86 @@ class _HistoryScreenState extends State<HistoryScreen> {
         actions: [
           PopupMenuButton<TargetType?>(
             icon: const Icon(Icons.filter_list),
-            tooltip: 'Filtrer',
             onSelected: (type) {
               setState(() => _filterType = type);
               _loadSessions();
             },
             itemBuilder: (context) => [
-              const PopupMenuItem(
-                value: null,
-                child: Text('Tous'),
+              const PopupMenuItem(value: null, child: Text('Tous')),
+              ...TargetType.values.map(
+                (type) =>
+                    PopupMenuItem(value: type, child: Text(type.displayName)),
               ),
-              ...TargetType.values.map((type) => PopupMenuItem(
-                value: type,
-                child: Text(type.displayName),
-              )),
             ],
           ),
         ],
       ),
-      body: _isLoading
-          ? const Center(child: CircularProgressIndicator())
-          : _sessions.isEmpty
-              ? _buildEmptyState()
-              : _buildContent(),
+      body: Column(
+        children: [
+          Expanded(
+            child: _isLoading
+                ? const Center(child: CircularProgressIndicator())
+                : _sessions.isEmpty
+                ? _buildEmptyState()
+                : _buildContent(),
+          ),
+          _buildBottomFilterBar(),
+        ],
+      ),
+    );
+  }
+
+  Widget _buildBottomFilterBar() {
+    return Container(
+      padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 12),
+      decoration: BoxDecoration(
+        color: Theme.of(context).cardColor,
+        boxShadow: const [
+          BoxShadow(
+            color: Colors.black26,
+            blurRadius: 4,
+            offset: Offset(0, -2),
+          ),
+        ],
+      ),
+      child: SafeArea(
+        top: false,
+        child: Row(
+          children: [
+            Expanded(
+              child: OutlinedButton.icon(
+                onPressed: _pickDateRange,
+                icon: const Icon(Icons.date_range, size: 18),
+                label: Text(
+                  _selectedDateRange == null
+                      ? 'Choisir une période'
+                      : '${DateFormat('dd/MM/yy').format(_selectedDateRange!.start)} - ${DateFormat('dd/MM/yy').format(_selectedDateRange!.end)}',
+                ),
+              ),
+            ),
+            if (_selectedDateRange != null)
+              IconButton(
+                icon: const Icon(Icons.close, color: AppTheme.errorColor),
+                onPressed: () {
+                  setState(() => _selectedDateRange = null);
+                  _loadSessions();
+                },
+              ),
+          ],
+        ),
+      ),
     );
   }
 
   Widget _buildEmptyState() {
     return Center(
-      child: Padding(
-        padding: const EdgeInsets.all(AppConstants.defaultPadding),
-        child: Column(
-          mainAxisAlignment: MainAxisAlignment.center,
-          children: [
-            Icon(Icons.history, size: 64, color: Colors.grey[400]),
-            const SizedBox(height: 16),
-            Text(
-              'Aucune session',
-              style: Theme.of(context).textTheme.titleLarge,
-            ),
-            const SizedBox(height: 8),
-            Text(
-              _filterType != null
-                  ? 'Aucune session de type ${_filterType!.displayName}'
-                  : 'Commencez par analyser une cible',
-              style: TextStyle(color: Colors.grey[600]),
-              textAlign: TextAlign.center,
-            ),
-          ],
-        ),
+      child: Column(
+        mainAxisAlignment: MainAxisAlignment.center,
+        children: [
+          Icon(Icons.history, size: 64, color: Colors.grey[400]),
+          const SizedBox(height: 16),
+          const Text('Aucune session sur cette période'),
+        ],
       ),
     );
   }
@@ -129,49 +216,27 @@ class _HistoryScreenState extends State<HistoryScreen> {
       onRefresh: _loadSessions,
       child: CustomScrollView(
         slivers: [
-          // Chart section
-          if (_sessions.length >= 2)
+          if (_sessions.length >= 2 && _selectedDateRange == null)
             SliverToBoxAdapter(
               child: Padding(
                 padding: const EdgeInsets.all(AppConstants.defaultPadding),
                 child: HistoryChart(sessions: _sessions),
               ),
             ),
-
-          // Filter indicator
-          if (_filterType != null)
-            SliverToBoxAdapter(
-              child: Padding(
-                padding: const EdgeInsets.symmetric(horizontal: AppConstants.defaultPadding),
-                child: Chip(
-                  label: Text('Filtre: ${_filterType!.displayName}'),
-                  deleteIcon: const Icon(Icons.close, size: 18),
-                  onDeleted: () {
-                    setState(() => _filterType = null);
-                    _loadSessions();
-                  },
-                ),
-              ),
-            ),
-
-          // Sessions list
           SliverPadding(
             padding: const EdgeInsets.all(AppConstants.defaultPadding),
             sliver: SliverList(
-              delegate: SliverChildBuilderDelegate(
-                (context, index) {
-                  final session = _sessions[index];
-                  return Padding(
-                    padding: const EdgeInsets.only(bottom: 12),
-                    child: SessionListItem(
-                      session: session,
-                      onTap: () => _openSessionDetail(session),
-                      onDelete: () => _deleteSession(session),
-                    ),
-                  );
-                },
-                childCount: _sessions.length,
-              ),
+              delegate: SliverChildBuilderDelegate((context, index) {
+                final session = _sessions[index];
+                return Padding(
+                  padding: const EdgeInsets.only(bottom: 12),
+                  child: SessionListItem(
+                    session: session,
+                    onTap: () => _openSessionDetail(session),
+                    onDelete: () => _deleteSession(session),
+                  ),
+                );
+              }, childCount: _sessions.length),
             ),
           ),
         ],
@@ -182,11 +247,9 @@ class _HistoryScreenState extends State<HistoryScreen> {
   void _openSessionDetail(Session session) async {
     await Navigator.push(
       context,
-      MaterialPageRoute(
-        builder: (_) => SessionDetailScreen(session: session),
-      ),
+      MaterialPageRoute(builder: (_) => SessionDetailScreen(session: session)),
     );
-    _loadSessions(); // Refresh in case session was deleted
+    _loadSessions();
   }
 
   Future<void> _deleteSession(Session session) async {
@@ -204,7 +267,10 @@ class _HistoryScreenState extends State<HistoryScreen> {
           ),
           TextButton(
             onPressed: () => Navigator.pop(context, true),
-            child: const Text('Supprimer', style: TextStyle(color: AppTheme.errorColor)),
+            child: const Text(
+              'Supprimer',
+              style: TextStyle(color: AppTheme.errorColor),
+            ),
           ),
         ],
       ),
@@ -215,20 +281,8 @@ class _HistoryScreenState extends State<HistoryScreen> {
         final repository = context.read<SessionRepository>();
         await repository.deleteSession(session.id);
         _loadSessions();
-        if (mounted) {
-          ScaffoldMessenger.of(context).showSnackBar(
-            const SnackBar(content: Text('Session supprimee')),
-          );
-        }
       } catch (e) {
-        if (mounted) {
-          ScaffoldMessenger.of(context).showSnackBar(
-            SnackBar(
-              content: Text('Erreur: $e'),
-              backgroundColor: AppTheme.errorColor,
-            ),
-          );
-        }
+        debugPrint('Erreur suppression: $e');
       }
     }
   }

lib/features/history/session_detail_screen.dart

@@ -1,10 +1,3 @@
-/// Écran de détail d'une session.
-///
-/// Affiche la visualisation complète d'une session sauvegardée :
-/// image de la cible avec overlay des impacts, scores recalculés,
-/// statistiques de groupement et lien vers les statistiques détaillées.
-library;
-
 import 'dart:io';
 import 'package:flutter/material.dart';
 import 'package:provider/provider.dart';
@@ -12,6 +5,8 @@ import 'package:intl/intl.dart';
 import '../../core/constants/app_constants.dart';
 import '../../core/theme/app_theme.dart';
 import '../../data/models/session.dart';
+import '../../data/models/target_analysis.dart';
+import '../../data/models/target_type.dart';
 import '../../data/repositories/session_repository.dart';
 import '../../services/score_calculator_service.dart';
 import '../../services/grouping_analyzer_service.dart';
@@ -20,7 +15,7 @@ import '../analysis/widgets/score_card.dart';
 import '../analysis/widgets/grouping_stats.dart';
 import '../statistics/statistics_screen.dart';
 
-class SessionDetailScreen extends StatelessWidget {
+class SessionDetailScreen extends StatefulWidget {
   final Session session;
 
   const SessionDetailScreen({
@@ -28,33 +23,40 @@ class SessionDetailScreen extends StatelessWidget {
     required this.session,
   });
 
+  @override
+  State<SessionDetailScreen> createState() => _SessionDetailScreenState();
+}
+
+class _SessionDetailScreenState extends State<SessionDetailScreen> {
+  int _currentTargetIndex = 0;
+
   @override
   Widget build(BuildContext context) {
     final scoreCalculator = context.read<ScoreCalculatorService>();
     final groupingAnalyzer = context.read<GroupingAnalyzerService>();
+    
+    final currentAnalysis = widget.session.analyses[_currentTargetIndex];
 
     final scoreResult = scoreCalculator.calculateScores(
-      shots: session.shots,
-      targetType: session.targetType,
-      targetCenterX: session.targetCenterX ?? 0.5,
-      targetCenterY: session.targetCenterY ?? 0.5,
-      targetRadius: session.targetRadius ?? 0.4,
+      shots: currentAnalysis.shots,
+      targetType: currentAnalysis.targetType,
+      targetCenterX: currentAnalysis.targetCenterX ?? 0.5,
+      targetCenterY: currentAnalysis.targetCenterY ?? 0.5,
+      targetRadius: currentAnalysis.targetRadius ?? 0.4,
     );
 
-    final groupingResult = groupingAnalyzer.analyzeGrouping(session.shots);
+    final groupingResult = groupingAnalyzer.analyzeGrouping(currentAnalysis.shots);
 
     return Scaffold(
       appBar: AppBar(
-        title: Text(
-          DateFormat('dd/MM/yyyy HH:mm').format(session.createdAt),
-        ),
+        title: Text(widget.session.weapon),
         actions: [
           IconButton(
             icon: const Icon(Icons.analytics),
             onPressed: () => Navigator.push(
               context,
               MaterialPageRoute(
-                builder: (_) => StatisticsScreen(singleSession: session),
+                builder: (_) => StatisticsScreen(singleSession: widget.session),
               ),
             ),
             tooltip: 'Statistiques',
@@ -70,15 +72,22 @@ class SessionDetailScreen extends StatelessWidget {
         child: Column(
           crossAxisAlignment: CrossAxisAlignment.stretch,
           children: [
+            // Weapon and session overview
+            _buildSessionHeader(context),
+
+            // Target selector if multiple targets
+            if (widget.session.targetCount > 1)
+              _buildTargetSelector(),
+
             // Target image with overlay
             AspectRatio(
               aspectRatio: 1,
               child: Stack(
                 fit: StackFit.expand,
                 children: [
-                  if (File(session.imagePath).existsSync())
+                  if (File(currentAnalysis.imagePath).existsSync())
                     Image.file(
-                      File(session.imagePath),
+                      File(currentAnalysis.imagePath),
                       fit: BoxFit.contain,
                     )
                   else
@@ -89,14 +98,14 @@ class SessionDetailScreen extends StatelessWidget {
                       ),
                     ),
                   TargetOverlay(
-                    shots: session.shots,
-                    targetCenterX: session.targetCenterX ?? 0.5,
-                    targetCenterY: session.targetCenterY ?? 0.5,
-                    targetRadius: session.targetRadius ?? 0.4,
-                    targetType: session.targetType,
-                    groupingCenterX: session.groupingCenterX,
-                    groupingCenterY: session.groupingCenterY,
-                    groupingDiameter: session.groupingDiameter,
+                    shots: currentAnalysis.shots,
+                    targetCenterX: currentAnalysis.targetCenterX ?? 0.5,
+                    targetCenterY: currentAnalysis.targetCenterY ?? 0.5,
+                    targetRadius: currentAnalysis.targetRadius ?? 0.4,
+                    targetType: currentAnalysis.targetType,
+                    groupingCenterX: currentAnalysis.groupingCenterX,
+                    groupingCenterY: currentAnalysis.groupingCenterY,
+                    groupingDiameter: currentAnalysis.groupingDiameter,
                   ),
                 ],
               ),
@@ -107,31 +116,37 @@ class SessionDetailScreen extends StatelessWidget {
               child: Column(
                 crossAxisAlignment: CrossAxisAlignment.start,
                 children: [
-                  // Session info
-                  _buildSessionInfo(context),
+                  // Analysis Info
+                  _buildAnalysisInfo(context, currentAnalysis),
                   const SizedBox(height: 12),
 
-                  // Score card
+                  // Score card for current target
                   ScoreCard(
-                    totalScore: session.totalScore,
-                    shotCount: session.shotCount,
+                    totalScore: currentAnalysis.totalScore,
+                    shotCount: currentAnalysis.shotCount,
                     scoreResult: scoreResult,
-                    targetType: session.targetType,
+                    targetType: currentAnalysis.targetType,
                   ),
                   const SizedBox(height: 12),
 
-                  // Grouping stats
-                  if (session.shotCount > 1)
+                  // Grouping stats for current target
+                  if (currentAnalysis.shotCount > 1)
                     GroupingStats(
                       groupingResult: groupingResult,
-                      targetCenterX: session.targetCenterX ?? 0.5,
-                      targetCenterY: session.targetCenterY ?? 0.5,
+                      targetCenterX: currentAnalysis.targetCenterX ?? 0.5,
+                      targetCenterY: currentAnalysis.targetCenterY ?? 0.5,
                     ),
 
-                  // Notes
-                  if (session.notes != null && session.notes!.isNotEmpty) ...[
+                  // Notes for current target
+                  if (currentAnalysis.notes != null && currentAnalysis.notes!.isNotEmpty) ...[
                     const SizedBox(height: 12),
-                    _buildNotesCard(context),
+                    _buildNotesCard(context, currentAnalysis.notes!),
+                  ],
+
+                  // Session notes
+                  if (widget.session.notes != null && widget.session.notes!.isNotEmpty) ...[
+                    const SizedBox(height: 12),
+                    _buildNotesCard(context, widget.session.notes!, title: 'Notes de session'),
                   ],
                 ],
               ),
@@ -142,16 +157,83 @@ class SessionDetailScreen extends StatelessWidget {
     );
   }
 
-  Widget _buildSessionInfo(BuildContext context) {
+  Widget _buildSessionHeader(BuildContext context) {
+    return Container(
+      padding: const EdgeInsets.all(16),
+      color: AppTheme.primaryColor.withValues(alpha: 0.1),
+      child: Column(
+        children: [
+          Row(
+            mainAxisAlignment: MainAxisAlignment.spaceBetween,
+            children: [
+              Column(
+                crossAxisAlignment: CrossAxisAlignment.start,
+                children: [
+                  Text(
+                    DateFormat('EEEE dd MMMM yyyy', 'fr_FR').format(widget.session.createdAt),
+                    style: const TextStyle(fontWeight: FontWeight.bold),
+                  ),
+                  Text(
+                    DateFormat('HH:mm').format(widget.session.createdAt),
+                    style: Theme.of(context).textTheme.bodySmall,
+                  ),
+                ],
+              ),
+              Column(
+                crossAxisAlignment: CrossAxisAlignment.end,
+                children: [
+                  Text(
+                    'Score Total: ${widget.session.totalScore}',
+                    style: const TextStyle(fontWeight: FontWeight.bold, color: AppTheme.primaryColor),
+                  ),
+                  Text(
+                    '${widget.session.totalShots} tirs au total',
+                    style: Theme.of(context).textTheme.bodySmall,
+                  ),
+                ],
+              ),
+            ],
+          ),
+        ],
+      ),
+    );
+  }
+
+  Widget _buildTargetSelector() {
+    return Container(
+      height: 50,
+      margin: const EdgeInsets.symmetric(vertical: 8),
+      child: ListView.builder(
+        scrollDirection: Axis.horizontal,
+        padding: const EdgeInsets.symmetric(horizontal: 16),
+        itemCount: widget.session.targetCount,
+        itemBuilder: (context, index) {
+          final isSelected = _currentTargetIndex == index;
+          return Padding(
+            padding: const EdgeInsets.only(right: 8),
+            child: ChoiceChip(
+              label: Text('Cible ${index + 1}'),
+              selected: isSelected,
+              onSelected: (selected) {
+                if (selected) {
+                  setState(() => _currentTargetIndex = index);
+                }
+              },
+            ),
+          );
+        },
+      ),
+    );
+  }
+
+  Widget _buildAnalysisInfo(BuildContext context, TargetAnalysis analysis) {
     return Card(
       child: Padding(
-        padding: const EdgeInsets.all(AppConstants.defaultPadding),
+        padding: const EdgeInsets.all(12),
         child: Row(
           children: [
             Icon(
-              session.targetType == session.targetType
-                  ? Icons.track_changes
-                  : Icons.person,
+              analysis.targetType == TargetType.concentric ? Icons.track_changes : Icons.person,
               color: AppTheme.primaryColor,
             ),
             const SizedBox(width: 12),
@@ -160,14 +242,11 @@ class SessionDetailScreen extends StatelessWidget {
                 crossAxisAlignment: CrossAxisAlignment.start,
                 children: [
                   Text(
-                    session.targetType.displayName,
-                    style: Theme.of(context).textTheme.titleMedium?.copyWith(
-                      fontWeight: FontWeight.bold,
-                    ),
+                    analysis.targetType.displayName,
+                    style: const TextStyle(fontWeight: FontWeight.bold),
                   ),
                   Text(
-                    DateFormat('EEEE dd MMMM yyyy, HH:mm', 'fr_FR')
-                        .format(session.createdAt),
+                    'Cible ${_currentTargetIndex + 1} sur ${widget.session.targetCount}',
                     style: Theme.of(context).textTheme.bodySmall,
                   ),
                 ],
@@ -179,7 +258,7 @@ class SessionDetailScreen extends StatelessWidget {
     );
   }
 
-  Widget _buildNotesCard(BuildContext context) {
+  Widget _buildNotesCard(BuildContext context, String notes, {String title = 'Notes'}) {
     return Card(
       child: Padding(
         padding: const EdgeInsets.all(AppConstants.defaultPadding),
@@ -188,18 +267,16 @@ class SessionDetailScreen extends StatelessWidget {
           children: [
             Row(
               children: [
-                const Icon(Icons.notes, color: AppTheme.primaryColor),
+                const Icon(Icons.notes, color: AppTheme.primaryColor, size: 20),
                 const SizedBox(width: 8),
                 Text(
-                  'Notes',
-                  style: Theme.of(context).textTheme.titleMedium?.copyWith(
-                    fontWeight: FontWeight.bold,
-                  ),
+                  title,
+                  style: const TextStyle(fontWeight: FontWeight.bold),
                 ),
               ],
             ),
             const Divider(),
-            Text(session.notes!),
+            Text(notes),
           ],
         ),
       ),
@@ -211,7 +288,7 @@ class SessionDetailScreen extends StatelessWidget {
       context: context,
       builder: (context) => AlertDialog(
         title: const Text('Supprimer'),
-        content: const Text('Voulez-vous vraiment supprimer cette session?'),
+        content: const Text('Voulez-vous vraiment supprimer cette session entière ?'),
         actions: [
           TextButton(
             onPressed: () => Navigator.pop(context, false),
@@ -231,20 +308,17 @@ class SessionDetailScreen extends StatelessWidget {
     if (confirmed == true && context.mounted) {
       try {
         final repository = context.read<SessionRepository>();
-        await repository.deleteSession(session.id);
+        await repository.deleteSession(widget.session.id);
         if (context.mounted) {
           ScaffoldMessenger.of(context).showSnackBar(
-            const SnackBar(content: Text('Session supprimee')),
+            const SnackBar(content: Text('Session supprimée')),
           );
           Navigator.pop(context);
         }
       } catch (e) {
         if (context.mounted) {
           ScaffoldMessenger.of(context).showSnackBar(
-            SnackBar(
-              content: Text('Erreur: $e'),
-              backgroundColor: AppTheme.errorColor,
-            ),
+            SnackBar(content: Text('Erreur: $e'), backgroundColor: AppTheme.errorColor),
           );
         }
       }

lib/features/history/widgets/history_chart.dart

@@ -155,7 +155,7 @@ class HistoryChart extends StatelessWidget {
                         return touchedSpots.map((spot) {
                           final session = displaySessions[spot.x.toInt()];
                           return LineTooltipItem(
-                            'Score: ${session.totalScore}\n${session.shotCount} tirs',
+                            'Score: ${session.totalScore}\n${session.totalShots} tirs',
                             const TextStyle(
                               color: Colors.white,
                               fontWeight: FontWeight.bold,

lib/features/history/widgets/session_list_item.dart

@@ -1,15 +1,8 @@
-/// Item de liste représentant une session.
-///
-/// Affiche les informations clés d'une session (date, type de cible,
-/// score, nombre de tirs) avec miniature de l'image et actions de suppression.
-library;
-
 import 'dart:io';
 import 'package:flutter/material.dart';
 import 'package:intl/intl.dart';
 import '../../../core/theme/app_theme.dart';
 import '../../../data/models/session.dart';
-import '../../../data/models/target_type.dart';
 
 class SessionListItem extends StatelessWidget {
   final Session session;
@@ -33,7 +26,7 @@ class SessionListItem extends StatelessWidget {
           padding: const EdgeInsets.all(12),
           child: Row(
             children: [
-              // Thumbnail
+              // Thumbnail (from first target)
               ClipRRect(
                 borderRadius: BorderRadius.circular(8),
                 child: SizedBox(
@@ -51,14 +44,14 @@ class SessionListItem extends StatelessWidget {
                   children: [
                     Row(
                       children: [
-                        Icon(
-                          _getTargetIcon(),
+                        const Icon(
+                          Icons.shield,
                           size: 16,
                           color: AppTheme.primaryColor,
                         ),
                         const SizedBox(width: 4),
                         Text(
-                          session.targetType.displayName,
+                          session.weapon,
                           style: const TextStyle(
                             fontWeight: FontWeight.bold,
                           ),
@@ -70,18 +63,19 @@ class SessionListItem extends StatelessWidget {
                       DateFormat('dd/MM/yyyy HH:mm').format(session.createdAt),
                       style: Theme.of(context).textTheme.bodySmall,
                     ),
-                    if (session.notes != null && session.notes!.isNotEmpty) ...[
-                      const SizedBox(height: 2),
-                      Text(
-                        session.notes!,
-                        style: Theme.of(context).textTheme.bodySmall?.copyWith(
-                          color: Colors.grey[600],
-                          fontStyle: FontStyle.italic,
+                    const SizedBox(height: 4),
+                    Row(
+                      children: [
+                        Icon(Icons.track_changes, size: 14, color: Colors.grey[600]),
+                        const SizedBox(width: 4),
+                        Text(
+                          '${session.targetCount} cible(s) • ${session.distance}m',
+                          style: Theme.of(context).textTheme.bodySmall?.copyWith(
+                            color: Colors.grey[600],
+                          ),
                         ),
-                        maxLines: 1,
-                        overflow: TextOverflow.ellipsis,
-                      ),
-                    ],
+                      ],
+                    ),
                   ],
                 ),
               ),
@@ -98,7 +92,7 @@ class SessionListItem extends StatelessWidget {
                     ),
                   ),
                   Text(
-                    '${session.shotCount} tirs',
+                    '${session.totalShots} tirs',
                     style: Theme.of(context).textTheme.bodySmall,
                   ),
                 ],
@@ -120,7 +114,9 @@ class SessionListItem extends StatelessWidget {
   }
 
   Widget _buildThumbnail() {
-    final file = File(session.imagePath);
+    if (session.analyses.isEmpty) return _buildPlaceholder();
+    
+    final file = File(session.analyses.first.imagePath);
 
     if (file.existsSync()) {
       return Image.file(
@@ -137,18 +133,9 @@ class SessionListItem extends StatelessWidget {
     return Container(
       color: Colors.grey[200],
       child: Icon(
-        _getTargetIcon(),
+        Icons.track_changes,
         color: Colors.grey[400],
       ),
     );
   }
-
-  IconData _getTargetIcon() {
-    switch (session.targetType) {
-      case TargetType.concentric:
-        return Icons.track_changes;
-      case TargetType.silhouette:
-        return Icons.person;
-    }
-  }
 }

lib/features/home/home_screen.dart

@@ -1,9 +1,3 @@
-/// Écran d'accueil - Dashboard principal de l'application.
-///
-/// Affiche les statistiques globales (sessions, tirs, score moyen) et permet
-/// la navigation vers les sections Statistiques, Historique et Nouvelle Analyse.
-library;
-
 import 'package:flutter/material.dart';
 import 'package:provider/provider.dart';
 import '../../core/constants/app_constants.dart';
@@ -12,7 +6,11 @@ import '../../data/repositories/session_repository.dart';
 import '../capture/capture_screen.dart';
 import '../history/history_screen.dart';
 import '../statistics/statistics_screen.dart';
+import 'package:fl_chart/fl_chart.dart';
+import '../../data/models/session.dart';
 import '../settings/settings_screen.dart';
+import '../session/session_setup_screen.dart';
+import '../session/session_provider.dart';
 import 'widgets/stats_card.dart';
 
 class HomeScreen extends StatefulWidget {
@@ -24,6 +22,7 @@ class HomeScreen extends StatefulWidget {
 
 class _HomeScreenState extends State<HomeScreen> {
   Map<String, dynamic>? _stats;
+  List<Session> _recentSessions = [];
   bool _isLoading = true;
 
   @override
@@ -35,9 +34,12 @@ class _HomeScreenState extends State<HomeScreen> {
   Future<void> _loadStats() async {
     final repository = context.read<SessionRepository>();
     final stats = await repository.getStatistics();
+    final sessions = await repository.getAllSessions();
+
     if (mounted) {
       setState(() {
         _stats = stats;
+        _recentSessions = sessions;
         _isLoading = false;
       });
     }
@@ -47,18 +49,14 @@ class _HomeScreenState extends State<HomeScreen> {
   Widget build(BuildContext context) {
     return Scaffold(
       appBar: AppBar(
+        leading: const Center(
+          child: Text(
+            'v1.0.2',
+            style: TextStyle(fontSize: 12, color: Colors.white70),
+          ),
+        ),
         title: const Text('Bully'),
         actions: [
-          IconButton(
-            icon: const Icon(Icons.analytics),
-            onPressed: () => _navigateToStatistics(context),
-            tooltip: 'Statistiques',
-          ),
-          IconButton(
-            icon: const Icon(Icons.history),
-            onPressed: () => _navigateToHistory(context),
-            tooltip: 'Historique',
-          ),
           IconButton(
             icon: const Icon(Icons.settings),
             onPressed: () => _navigateToSettings(context),
@@ -74,15 +72,10 @@ class _HomeScreenState extends State<HomeScreen> {
           child: Column(
             crossAxisAlignment: CrossAxisAlignment.stretch,
             children: [
-              // App logo/header
               _buildHeader(),
               const SizedBox(height: AppConstants.largePadding),
-
-              // Main action button
               _buildMainActionButton(context),
               const SizedBox(height: AppConstants.largePadding),
-
-              // Statistics section
               if (_isLoading)
                 const Center(child: CircularProgressIndicator())
               else if (_stats != null)
@@ -112,16 +105,16 @@ class _HomeScreenState extends State<HomeScreen> {
         const SizedBox(height: 16),
         Text(
           'Analyse de Cibles',
-          style: Theme.of(context).textTheme.headlineMedium?.copyWith(
-            fontWeight: FontWeight.bold,
-          ),
+          style: Theme.of(
+            context,
+          ).textTheme.headlineMedium?.copyWith(fontWeight: FontWeight.bold),
         ),
         const SizedBox(height: 8),
         Text(
           'Scannez vos cibles et analysez vos performances',
-          style: Theme.of(context).textTheme.bodyLarge?.copyWith(
-            color: AppTheme.textSecondary,
-          ),
+          style: Theme.of(
+            context,
+          ).textTheme.bodyLarge?.copyWith(color: AppTheme.textSecondary),
           textAlign: TextAlign.center,
         ),
       ],
@@ -129,21 +122,103 @@ class _HomeScreenState extends State<HomeScreen> {
   }
 
   Widget _buildMainActionButton(BuildContext context) {
-    return ElevatedButton.icon(
-      onPressed: () => _navigateToCapture(context),
-      style: ElevatedButton.styleFrom(
-        backgroundColor: AppTheme.primaryColor,
-        foregroundColor: Colors.white,
-        padding: const EdgeInsets.symmetric(vertical: 20),
-        shape: RoundedRectangleBorder(
-          borderRadius: BorderRadius.circular(AppConstants.borderRadius),
+    final sessionProvider = context.watch<SessionProvider>();
+    final isSessionActive = sessionProvider.isSessionActive;
+
+    // Si aucune session n'est active, on affiche juste le bouton de départ habituel
+    if (!isSessionActive) {
+      return ElevatedButton.icon(
+        onPressed: () => _navigateToSessionSetup(context),
+        style: ElevatedButton.styleFrom(
+          backgroundColor: AppTheme.primaryColor,
+          foregroundColor: Colors.white,
+          padding: const EdgeInsets.symmetric(vertical: 20),
+          shape: RoundedRectangleBorder(
+            borderRadius: BorderRadius.circular(AppConstants.borderRadius),
+          ),
         ),
-      ),
-      icon: const Icon(Icons.add_a_photo, size: 28),
-      label: const Text(
-        'Nouvelle Analyse',
-        style: TextStyle(fontSize: 18, fontWeight: FontWeight.bold),
-      ),
+        icon: const Icon(Icons.add_circle_outline, size: 28),
+        label: const Text(
+          'Nouvelle session',
+          style: TextStyle(fontSize: 18, fontWeight: FontWeight.bold),
+        ),
+      );
+    }
+
+    // MODIFICATION : Alignement sur une seule ligne (80% / 20%) avec une croix pour l'annulation
+    return Row(
+      children: [
+        // 80% de largeur pour continuer la session
+        Expanded(
+          flex: 8,
+          child: ElevatedButton.icon(
+            onPressed: () => _navigateToSessionSetup(context),
+            style: ElevatedButton.styleFrom(
+              backgroundColor: AppTheme.secondaryColor,
+              foregroundColor: Colors.white,
+              padding: const EdgeInsets.symmetric(vertical: 20),
+              shape: RoundedRectangleBorder(
+                borderRadius: BorderRadius.circular(AppConstants.borderRadius),
+              ),
+            ),
+            icon: const Icon(Icons.play_circle_outline, size: 28),
+            label: const Text(
+              'Continuer la session',
+              style: TextStyle(fontSize: 18, fontWeight: FontWeight.bold),
+              maxLines: 1,
+              overflow: TextOverflow.ellipsis,
+            ),
+          ),
+        ),
+        const SizedBox(width: 12),
+        // 20% de largeur pour terminer/annuler la session (Bouton Croix)
+        Expanded(
+          flex: 2,
+          child: OutlinedButton(
+            onPressed: () {
+              // Boite de dialogue de confirmation pour éviter les erreurs
+              showDialog(
+                context: context,
+                builder: (BuildContext context) {
+                  return AlertDialog(
+                    title: const Text('Terminer la session ?'),
+                    content: const Text('Êtes-vous sûr de vouloir clôturer la session en cours ?'),
+                    actions: [
+                      TextButton(
+                        onPressed: () => Navigator.pop(context),
+                        child: const Text('ANNULER'),
+                      ),
+                      TextButton(
+                        onPressed: () {
+                          Navigator.pop(context);
+                          // Clôture propre de la session dans le State global
+                          context.read<SessionProvider>().endSession();
+                          ScaffoldMessenger.of(context).showSnackBar(
+                            const SnackBar(
+                              content: Text('Session terminée avec succès !'),
+                              backgroundColor: AppTheme.successColor,
+                            ),
+                          );
+                        },
+                        child: const Text('TERMINER', style: TextStyle(color: Colors.redAccent)),
+                      ),
+                    ],
+                  );
+                },
+              );
+            },
+            style: OutlinedButton.styleFrom(
+              foregroundColor: Colors.redAccent,
+              side: const BorderSide(color: Colors.redAccent, width: 1.5),
+              padding: const EdgeInsets.symmetric(vertical: 20), // Même hauteur que le bouton continuer
+              shape: RoundedRectangleBorder(
+                borderRadius: BorderRadius.circular(AppConstants.borderRadius),
+              ),
+            ),
+            child: const Icon(Icons.close, size: 28),
+          ),
+        ),
+      ],
     );
   }
 
@@ -153,14 +228,13 @@ class _HomeScreenState extends State<HomeScreen> {
       children: [
         Text(
           'Statistiques',
-          style: Theme.of(context).textTheme.titleLarge?.copyWith(
-                fontWeight: FontWeight.bold,
-              ),
+          style: Theme.of(
+            context,
+          ).textTheme.titleLarge?.copyWith(fontWeight: FontWeight.bold),
         ),
         const SizedBox(height: 12),
         Row(
           children: [
-            // --- BOUTON SESSIONS (Redirige vers Statistiques) ---
             Expanded(
               child: InkWell(
                 onTap: () => _navigateToStatistics(context),
@@ -174,7 +248,6 @@ class _HomeScreenState extends State<HomeScreen> {
               ),
             ),
             const SizedBox(width: 12),
-            // Ce bouton reste statique (ou tu peux ajouter une action)
             Expanded(
               child: StatsCard(
                 icon: Icons.gps_fixed,
@@ -185,10 +258,40 @@ class _HomeScreenState extends State<HomeScreen> {
             ),
           ],
         ),
-        const SizedBox(height: 12),
+        Padding(
+          padding: const EdgeInsets.symmetric(vertical: 16.0),
+          child: Container(
+            height: 150,
+            padding: const EdgeInsets.all(16),
+            decoration: BoxDecoration(
+              color: Theme.of(context).cardColor,
+              borderRadius: BorderRadius.circular(AppConstants.borderRadius),
+              boxShadow: [
+                BoxShadow(
+                  color: Colors.black.withValues(alpha: 0.05),
+                  blurRadius: 10,
+                  offset: const Offset(0, 4),
+                ),
+              ],
+            ),
+            child: _recentSessions.length < 2
+                ? const Center(
+              child: Column(
+                mainAxisAlignment: MainAxisAlignment.center,
+                children: [
+                  Icon(Icons.show_chart, size: 40, color: Colors.grey),
+                  Text(
+                    'Pas assez de données',
+                    style: TextStyle(color: Colors.grey, fontSize: 12),
+                  ),
+                ],
+              ),
+            )
+                : _buildHomeTrendChart(),
+          ),
+        ),
         Row(
           children: [
-            // --- BOUTON SCORE MOYEN (Redirige vers Historique) ---
             Expanded(
               child: InkWell(
                 onTap: () => _navigateToHistory(context),
@@ -202,7 +305,6 @@ class _HomeScreenState extends State<HomeScreen> {
               ),
             ),
             const SizedBox(width: 12),
-            // Ce bouton reste statique
             Expanded(
               child: StatsCard(
                 icon: Icons.emoji_events,
@@ -217,12 +319,19 @@ class _HomeScreenState extends State<HomeScreen> {
     );
   }
 
-  void _navigateToCapture(BuildContext context) async {
-    await Navigator.push(
-      context,
-      MaterialPageRoute(builder: (_) => const CaptureScreen()),
-    );
-    // Refresh stats when returning
+  void _navigateToSessionSetup(BuildContext context) async {
+    final sessionProvider = context.read<SessionProvider>();
+    if (sessionProvider.isSessionActive) {
+      await Navigator.push(
+        context,
+        MaterialPageRoute(builder: (_) => const CaptureScreen()),
+      );
+    } else {
+      await Navigator.push(
+        context,
+        MaterialPageRoute(builder: (_) => const SessionSetupScreen()),
+      );
+    }
     _loadStats();
   }
 
@@ -231,7 +340,6 @@ class _HomeScreenState extends State<HomeScreen> {
       context,
       MaterialPageRoute(builder: (_) => const HistoryScreen()),
     );
-    // Refresh stats when returning
     _loadStats();
   }
 
@@ -240,14 +348,107 @@ class _HomeScreenState extends State<HomeScreen> {
       context,
       MaterialPageRoute(builder: (_) => const StatisticsScreen()),
     );
-    // Refresh stats when returning
     _loadStats();
   }
 
-  void _navigateToSettings(BuildContext context) {
-    Navigator.push(
+  Widget _buildHomeTrendChart() {
+    final sorted = List<Session>.from(_recentSessions)
+      ..sort((a, b) => a.createdAt.compareTo(b.createdAt));
+    final display =
+    sorted.length > 7 ? sorted.sublist(sorted.length - 7) : sorted;
+
+    return LineChart(
+      LineChartData(
+        gridData: FlGridData(
+          show: true,
+          drawVerticalLine: false,
+          getDrawingHorizontalLine: (value) => FlLine(
+            color: Colors.grey.withValues(alpha: 0.1),
+            strokeWidth: 1,
+          ),
+        ),
+        titlesData: FlTitlesData(
+          show: true,
+          rightTitles: const AxisTitles(sideTitles: SideTitles(showTitles: false)),
+          topTitles: const AxisTitles(sideTitles: SideTitles(showTitles: false)),
+          bottomTitles: AxisTitles(
+            sideTitles: SideTitles(
+              showTitles: true,
+              reservedSize: 22,
+              interval: 1,
+              getTitlesWidget: (value, meta) {
+                final index = value.toInt();
+                if (index < 0 || index >= display.length) return const SizedBox();
+                final date = display[index].createdAt;
+                return Padding(
+                  padding: const EdgeInsets.only(top: 4.0),
+                  child: Text(
+                    '${date.day}/${date.month}',
+                    style: TextStyle(
+                      fontSize: 9,
+                      color: Colors.grey.withValues(alpha: 0.8),
+                    ),
+                  ),
+                );
+              },
+            ),
+          ),
+          leftTitles: AxisTitles(
+            sideTitles: SideTitles(
+              showTitles: true,
+              reservedSize: 28,
+              getTitlesWidget: (value, meta) {
+                return Text(
+                  value.toInt().toString(),
+                  style: TextStyle(
+                    fontSize: 9,
+                    color: Colors.grey.withValues(alpha: 0.8),
+                  ),
+                );
+              },
+            ),
+          ),
+        ),
+        borderData: FlBorderData(
+          show: true,
+          border: Border(
+            bottom: BorderSide(color: Colors.grey.withValues(alpha: 0.2)),
+            left: BorderSide(color: Colors.grey.withValues(alpha: 0.2)),
+          ),
+        ),
+        lineBarsData: [
+          LineChartBarData(
+            spots: display.asMap().entries.map((e) {
+              return FlSpot(e.key.toDouble(), e.value.averageScore);
+            }).toList(),
+            isCurved: true,
+            color: AppTheme.primaryColor,
+            barWidth: 3,
+            isStrokeCapRound: true,
+            dotData: FlDotData(
+              show: true,
+              getDotPainter: (spot, percent, barData, index) => FlDotCirclePainter(
+                radius: 3,
+                color: Colors.white,
+                strokeWidth: 2,
+                strokeColor: AppTheme.primaryColor,
+              ),
+            ),
+            belowBarData: BarAreaData(
+              show: true,
+              color: AppTheme.primaryColor.withValues(alpha: 0.1),
+            ),
+          ),
+        ],
+      ),
+    );
+  }
+
+  void _navigateToSettings(BuildContext context) async {
+    await Navigator.push(
       context,
       MaterialPageRoute(builder: (_) => const SettingsScreen()),
     );
+    _loadStats();
   }
-}
+}

lib/features/session/session_provider.dart

@@ -0,0 +1,54 @@
+import 'package:flutter/foundation.dart';
+import '../../data/models/session.dart';
+import '../../data/models/target_analysis.dart';
+import '../../data/models/weapon.dart';
+
+class SessionProvider extends ChangeNotifier {
+  DateTime? _sessionDate;
+  DateTime? get sessionDate => _sessionDate;
+  String? _currentWeaponName;
+  String? _currentWeaponId;
+  int _shotsPerTarget = 5;
+  int _distance = 25;
+  String? _activeSessionId;
+  final List<TargetAnalysis> _currentAnalyses = [];
+  bool _isSessionActive = false;
+
+  String? get currentWeapon => _currentWeaponName;
+  String? get currentWeaponId => _currentWeaponId;
+  int get shotsPerTarget => _shotsPerTarget;
+  int get distance => _distance;
+  bool get isSessionActive => _isSessionActive;
+  String? get activeSessionId => _activeSessionId;
+  List<TargetAnalysis> get currentAnalyses => List.unmodifiable(_currentAnalyses);
+  
+  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}) {
+    _currentWeaponName = weaponName;
+    _currentWeaponId = weaponId;
+    _shotsPerTarget = shots;
+    _distance = distance;
+    _sessionDate = date ?? DateTime.now();
+    _activeSessionId = sessionId;
+    _currentAnalyses.clear();
+    _isSessionActive = true;
+    notifyListeners();
+  }
+
+  void addAnalysis(TargetAnalysis analysis) {
+    _currentAnalyses.add(analysis);
+    notifyListeners();
+  }
+
+  void endSession() {
+    _isSessionActive = false;
+    _activeSessionId = null;
+    _currentWeaponId = null;
+    _currentWeaponName = null;
+    _currentAnalyses.clear();
+    _distance = 25;
+    notifyListeners();
+  }
+}

lib/features/session/session_setup_screen.dart

@@ -0,0 +1,326 @@
+import 'package:flutter/material.dart';
+import 'package:provider/provider.dart';
+import 'package:intl/intl.dart'; // Utile pour formater proprement la date en français
+import '../../core/constants/app_constants.dart';
+import '../../core/theme/app_theme.dart';
+import '../../data/models/weapon.dart';
+import '../../data/repositories/session_repository.dart';
+import 'session_provider.dart';
+import '../capture/capture_screen.dart';
+import '../garage/weapon_list_screen.dart';
+
+class SessionSetupScreen extends StatefulWidget {
+  const SessionSetupScreen({super.key});
+
+  @override
+  State<SessionSetupScreen> createState() => _SessionSetupScreenState();
+}
+
+class _SessionSetupScreenState extends State<SessionSetupScreen> {
+  final _formKey = GlobalKey<FormState>();
+
+  int _shotsPerTarget = 5;
+  int _distance = 25;
+  List<Weapon> _availableWeapons = [];
+  Weapon? _selectedWeapon;
+  bool _isLoadingWeapons = true;
+
+  // AJOUT DE LA VARIABLE DATE : Initialisée par défaut à maintenant
+  DateTime _selectedDate = DateTime.now();
+
+  @override
+  void initState() {
+    super.initState();
+    _loadWeapons();
+  }
+
+  Future<void> _loadWeapons() async {
+    setState(() => _isLoadingWeapons = true);
+    final repository = context.read<SessionRepository>();
+    final weapons = await repository.getWeapons();
+
+    if (mounted) {
+      setState(() {
+        _availableWeapons = weapons;
+        if (_availableWeapons.isNotEmpty && _selectedWeapon == null) {
+          _selectedWeapon = _availableWeapons.first;
+          _updateSettingsForWeapon(_selectedWeapon!);
+        }
+        _isLoadingWeapons = false;
+      });
+    }
+  }
+
+  void _updateSettingsForWeapon(Weapon weapon) {
+    _shotsPerTarget = weapon.magazineCapacity;
+    _distance = (weapon.type == WeaponType.handgun) ? 25 : 50;
+  }
+
+  // Fonction pour ouvrir le calendrier si l'utilisateur clique sur le champ
+  Future<void> _pickDate() async {
+    final DateTime? picked = await showDatePicker(
+      context: context,
+      initialDate: _selectedDate,
+      firstDate: DateTime(2020),
+      lastDate: DateTime(2100),
+      locale: const Locale('fr', 'FR'), // Force le calendrier en français
+    );
+    if (picked != null && picked != _selectedDate) {
+      setState(() {
+        // On garde aussi l'heure actuelle lors du changement de date
+        final now = DateTime.now();
+        _selectedDate = DateTime(picked.year, picked.month, picked.day, now.hour, now.minute);
+      });
+    }
+  }
+
+  void _startSession() {
+    if (_formKey.currentState!.validate() && _selectedWeapon != null) {
+      final repository = context.read<SessionRepository>();
+      final sessionProvider = context.read<SessionProvider>();
+
+      final sessionId = repository.generateId();
+
+      // PASSE-PARTOUT : On envoie la session au provider.
+      // Note : Si ton `sessionProvider.startSession` ne prend pas encore la date en paramètre,
+      // pas de panique, la compilation passera car Dart tolère les arguments nommés optionnels
+      // s'ils sont déjà présents, ou tu pourras l'ajouter à ta méthode startSession.
+      sessionProvider.startSession(
+        _selectedWeapon!.displayName,
+        _shotsPerTarget,
+        sessionId,
+        weaponId: _selectedWeapon!.id,
+        distance: _distance,
+        date: _selectedDate,
+      );
+
+      Navigator.pushReplacement(
+        context,
+        MaterialPageRoute(builder: (_) => const CaptureScreen()),
+      );
+    }
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    // Petit formatage sympa en français (ex: "27 mai 2026")
+    final String formattedDate = DateFormat('dd MMMM yyyy', 'fr_FR').format(_selectedDate);
+
+    return Scaffold(
+      appBar: AppBar(
+        title: const Text('Configuration de la session'),
+      ),
+      body: _isLoadingWeapons
+          ? const Center(child: CircularProgressIndicator())
+          : SingleChildScrollView(
+        padding: const EdgeInsets.all(AppConstants.defaultPadding),
+        child: Form(
+          key: _formKey,
+          child: Column(
+            crossAxisAlignment: CrossAxisAlignment.stretch,
+            children: [
+              const Text(
+                'Informations générales',
+                style: TextStyle(fontSize: 20, fontWeight: FontWeight.bold),
+              ),
+              const SizedBox(height: 16),
+
+              // AFFICHAGE CONDITIONNEL : Armurerie vide vs Armurerie remplie
+              if (_availableWeapons.isEmpty)
+                Container(
+                  padding: const EdgeInsets.all(16),
+                  decoration: BoxDecoration(
+                    color: AppTheme.errorColor.withValues(alpha: 0.1),
+                    borderRadius: BorderRadius.circular(AppConstants.borderRadius),
+                    border: Border.all(color: AppTheme.errorColor.withValues(alpha: 0.5)),
+                  ),
+                  child: Column(
+                    children: [
+                      const Icon(Icons.warning_amber_rounded, color: AppTheme.errorColor, size: 48),
+                      const SizedBox(height: 8),
+                      const Text(
+                        'Ton armurerie est vide.',
+                        style: TextStyle(fontWeight: FontWeight.bold),
+                        textAlign: TextAlign.center,
+                      ),
+                      const SizedBox(height: 4),
+                      const Text(
+                        'Tu dois d\'abord ajouter une arme pour pouvoir démarrer une session de tir.',
+                        textAlign: TextAlign.center,
+                      ),
+                      const SizedBox(height: 16),
+                      ElevatedButton.icon(
+                        onPressed: () {
+                          Navigator.push(
+                            context,
+                            MaterialPageRoute(builder: (_) => const WeaponListScreen()),
+                          ).then((_) {
+                            _loadWeapons();
+                          });
+                        },
+                        icon: const Icon(Icons.add),
+                        label: const Text('ALLER À MON ARMURERIE'),
+                      ),
+                    ],
+                  ),
+                )
+              else
+                Column(
+                  children: [
+                    DropdownButtonFormField<Weapon>(
+                      value: _selectedWeapon,
+                      decoration: InputDecoration(
+                        labelText: 'Sélectionner une arme',
+                        prefixIcon: const Icon(Icons.shield),
+                        border: OutlineInputBorder(
+                          borderRadius: BorderRadius.circular(AppConstants.borderRadius),
+                        ),
+                      ),
+                      items: _availableWeapons.map((w) => DropdownMenuItem(
+                        value: w,
+                        child: Text(w.displayName),
+                      )).toList(),
+                      onChanged: (value) {
+                        if (value != null) {
+                          setState(() {
+                            _selectedWeapon = value;
+                            _updateSettingsForWeapon(value);
+                          });
+                        }
+                      },
+                    ),
+                    const SizedBox(height: 16),
+
+                    // NOUVEAU CHAMP : Sélecteur de date interactif
+                    InkWell(
+                      onTap: _availableWeapons.isEmpty ? null : _pickDate,
+                      borderRadius: BorderRadius.circular(AppConstants.borderRadius),
+                      child: IgnorePointer(
+                        child: TextFormField(
+                          decoration: InputDecoration(
+                            labelText: 'Date de la session',
+                            prefixIcon: const Icon(Icons.calendar_today),
+                            border: OutlineInputBorder(
+                              borderRadius: BorderRadius.circular(AppConstants.borderRadius),
+                            ),
+                          ),
+                          controller: TextEditingController(text: formattedDate),
+                        ),
+                      ),
+                    ),
+                  ],
+                ),
+
+              const SizedBox(height: 24),
+
+              // Distance selector
+              const Text(
+                'Distance de tir (mètres)',
+                style: TextStyle(fontSize: 16, fontWeight: FontWeight.w500),
+              ),
+              const SizedBox(height: 8),
+              Row(
+                children: [
+                  Expanded(
+                    child: Slider(
+                      value: _distance.toDouble(),
+                      min: 5,
+                      max: 300,
+                      divisions: 59,
+                      label: '${_distance}m',
+                      onChanged: _availableWeapons.isEmpty ? null : (value) {
+                        setState(() {
+                          _distance = value.round();
+                        });
+                      },
+                    ),
+                  ),
+                  Container(
+                    width: 70,
+                    height: 50,
+                    alignment: Alignment.center,
+                    decoration: BoxDecoration(
+                      color: AppTheme.secondaryColor.withValues(alpha: 0.1),
+                      borderRadius: BorderRadius.circular(8),
+                    ),
+                    child: Text(
+                      '${_distance}m',
+                      style: const TextStyle(
+                        fontSize: 18,
+                        fontWeight: FontWeight.bold,
+                        color: AppTheme.secondaryColor,
+                      ),
+                    ),
+                  ),
+                ],
+              ),
+              const SizedBox(height: 24),
+
+              // Shots per target
+              const Text(
+                'Nombre de balles pour la cible actuelle',
+                style: TextStyle(fontSize: 16, fontWeight: FontWeight.w500),
+              ),
+              const SizedBox(height: 8),
+              Row(
+                children: [
+                  Expanded(
+                    child: Slider(
+                      value: _shotsPerTarget.toDouble(),
+                      min: 1,
+                      max: 50,
+                      divisions: 49,
+                      label: '$_shotsPerTarget',
+                      onChanged: _availableWeapons.isEmpty ? null : (value) {
+                        setState(() {
+                          _shotsPerTarget = value.round();
+                        });
+                      },
+                    ),
+                  ),
+                  Container(
+                    width: 50,
+                    height: 50,
+                    alignment: Alignment.center,
+                    decoration: BoxDecoration(
+                      color: AppTheme.primaryColor.withValues(alpha: 0.1),
+                      borderRadius: BorderRadius.circular(8),
+                    ),
+                    child: Text(
+                      '$_shotsPerTarget',
+                      style: const TextStyle(
+                        fontSize: 18,
+                        fontWeight: FontWeight.bold,
+                        color: AppTheme.primaryColor,
+                      ),
+                    ),
+                  ),
+                ],
+              ),
+              const SizedBox(height: 48),
+
+              ElevatedButton.icon(
+                onPressed: (_availableWeapons.isEmpty || _selectedWeapon == null)
+                    ? null
+                    : _startSession,
+                style: ElevatedButton.styleFrom(
+                  backgroundColor: AppTheme.primaryColor,
+                  foregroundColor: Colors.white,
+                  padding: const EdgeInsets.symmetric(vertical: 16),
+                  shape: RoundedRectangleBorder(
+                    borderRadius: BorderRadius.circular(AppConstants.borderRadius),
+                  ),
+                ),
+                icon: const Icon(Icons.play_arrow),
+                label: const Text(
+                  'DÉMARRER LA SESSION',
+                  style: TextStyle(fontSize: 16, fontWeight: FontWeight.bold),
+                ),
+              ),
+            ],
+          ),
+        ),
+      ),
+    );
+  }
+}

lib/features/settings/settings_screen.dart

@@ -1,11 +1,14 @@
 import 'package:flutter/material.dart';
+import 'package:provider/provider.dart';
 import 'package:flutter/services.dart';
+import '../../core/theme/theme_provider.dart';
 import 'dart:convert';
 import 'package:crypto/crypto.dart';
 import 'package:http/http.dart' as http;
 import '../../core/constants/app_constants.dart';
 import '../../core/theme/app_theme.dart';
 import '../../services/wallet_identity_service.dart';
+import '../garage/weapon_list_screen.dart';
 
 class SettingsScreen extends StatefulWidget {
   const SettingsScreen({super.key});
@@ -81,6 +84,49 @@ class _SettingsScreenState extends State<SettingsScreen> {
     }
   }
 
+  void _showThemeDialog() {
+    final themeProvider = context.read<ThemeProvider>();
+    
+    showDialog(
+      context: context,
+      builder: (context) => AlertDialog(
+        title: const Text('Apparence'),
+        content: Column(
+          mainAxisSize: MainAxisSize.min,
+          children: [
+            _buildThemeOption(ThemeMode.system, 'Automatique', Icons.brightness_auto),
+            _buildThemeOption(ThemeMode.light, 'Clair', Icons.light_mode),
+            _buildThemeOption(ThemeMode.dark, 'Sombre', Icons.dark_mode),
+          ],
+        ),
+        actions: [
+          TextButton(
+            onPressed: () => Navigator.pop(context),
+            child: const Text('Fermer'),
+          ),
+        ],
+      ),
+    );
+  }
+
+  Widget _buildThemeOption(ThemeMode mode, String label, IconData icon) {
+    final themeProvider = context.watch<ThemeProvider>();
+    final isSelected = themeProvider.themeMode == mode;
+    
+    return ListTile(
+      leading: Icon(icon, color: isSelected ? AppTheme.primaryColor : null),
+      title: Text(label, style: TextStyle(
+        fontWeight: isSelected ? FontWeight.bold : FontWeight.normal,
+        color: isSelected ? AppTheme.primaryColor : null,
+      )),
+      trailing: isSelected ? const Icon(Icons.check, color: AppTheme.primaryColor) : null,
+      onTap: () {
+        themeProvider.setThemeMode(mode);
+        Navigator.pop(context);
+      },
+    );
+  }
+
   void _showIdentityDialog() {
     if (_identityPhrase == null) return;
     
@@ -218,14 +264,29 @@ class _SettingsScreenState extends State<SettingsScreen> {
             subtitle: _identityPhrase != null ? 'Phrase de 15 mots générée' : 'Génération en cours...',
             onTap: _showIdentityDialog,
           ),
+          Consumer<ThemeProvider>(
+            builder: (context, themeProvider, child) {
+              return _buildSettingsTile(
+                context: context,
+                icon: Icons.color_lens_outlined,
+                title: 'Apparence',
+                subtitle: themeProvider.themeModeName,
+                onTap: _showThemeDialog,
+              );
+            },
+          ),
+          
+          const SizedBox(height: 24),
+          _buildSectionHeader('Gestion'),
           _buildSettingsTile(
             context: context,
-            icon: Icons.color_lens_outlined,
-            title: 'Apparence',
-            subtitle: 'Thème clair/sombre (à venir)',
-            onTap: () {
-              ScaffoldMessenger.of(context).showSnackBar(
-                const SnackBar(content: Text('Fonctionnalité en développement')),
+            icon: Icons.shield_outlined,
+            title: 'Mon Armurerie',
+            subtitle: 'Gérer mes armes et équipements',
+            onTap: () async {
+              await Navigator.push(
+                context,
+                MaterialPageRoute(builder: (_) => const WeaponListScreen()),
               );
             },
           ),

lib/main.dart

@@ -5,11 +5,13 @@ import 'package:intl/date_symbol_data_local.dart';
 import 'package:provider/provider.dart';
 import 'package:sqflite_common_ffi/sqflite_ffi.dart';
 import 'app.dart';
+import 'core/theme/theme_provider.dart';
 import 'data/repositories/session_repository.dart';
 import 'services/target_detection_service.dart';
 import 'services/score_calculator_service.dart';
 import 'services/grouping_analyzer_service.dart';
 import 'services/image_processing_service.dart';
+import 'features/session/session_provider.dart';
 
 void main() async {
   WidgetsFlutterBinding.ensureInitialized();
@@ -45,6 +47,8 @@ void main() async {
           create: (_) => GroupingAnalyzerService(),
         ),
         Provider<SessionRepository>(create: (_) => SessionRepository()),
+        ChangeNotifierProvider<ThemeProvider>(create: (_) => ThemeProvider()),
+        ChangeNotifierProvider<SessionProvider>(create: (_) => SessionProvider()),
       ],
       child: const BullyApp(),
     ),

lib/main_navigation_holder.dart

@@ -0,0 +1,82 @@
+import 'package:flutter/material.dart';
+import 'features/home/home_screen.dart';
+import 'features/history/history_screen.dart';
+import 'features/statistics/statistics_screen.dart';
+import 'features/garage/weapon_list_screen.dart';
+import 'core/theme/app_theme.dart';
+
+class MainNavigationHolder extends StatefulWidget {
+  const MainNavigationHolder({super.key});
+
+  @override
+  State<MainNavigationHolder> createState() => _MainNavigationHolderState();
+}
+
+class _MainNavigationHolderState extends State<MainNavigationHolder> {
+  int _selectedIndex = 0;
+
+  final List<Widget> _screens = [
+    const HomeScreen(),
+    const HistoryScreen(),
+    const StatisticsScreen(),
+    const WeaponListScreen(),
+  ];
+
+  void _onItemTapped(int index) {
+    setState(() {
+      _selectedIndex = index;
+    });
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    return Scaffold(
+      body: IndexedStack(
+        index: _selectedIndex,
+        children: _screens,
+      ),
+      bottomNavigationBar: Container(
+        decoration: BoxDecoration(
+          boxShadow: [
+            BoxShadow(
+              color: Colors.black.withValues(alpha: 0.1),
+              blurRadius: 10,
+              offset: const Offset(0, -2),
+            ),
+          ],
+        ),
+        child: BottomNavigationBar(
+          currentIndex: _selectedIndex,
+          onTap: _onItemTapped,
+          type: BottomNavigationBarType.fixed,
+          backgroundColor: Theme.of(context).cardColor,
+          selectedItemColor: AppTheme.primaryColor,
+          unselectedItemColor: Colors.grey,
+          showUnselectedLabels: true,
+          items: const [
+            BottomNavigationBarItem(
+              icon: Icon(Icons.home_outlined),
+              activeIcon: Icon(Icons.home),
+              label: 'Accueil',
+            ),
+            BottomNavigationBarItem(
+              icon: Icon(Icons.history_outlined),
+              activeIcon: Icon(Icons.history),
+              label: 'Historique',
+            ),
+            BottomNavigationBarItem(
+              icon: Icon(Icons.analytics_outlined),
+              activeIcon: Icon(Icons.analytics),
+              label: 'Stats',
+            ),
+            BottomNavigationBarItem(
+              icon: Icon(Icons.shield_outlined),
+              activeIcon: Icon(Icons.shield),
+              label: 'Armurerie',
+            ),
+          ],
+        ),
+      ),
+    );
+  }
+}

lib/services/ai_export_service.dart

@@ -1,4 +1,5 @@
 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';
@@ -37,7 +38,7 @@ class AiExportService {
         deviceData['os'] = 'Windows ${windowsInfo.majorVersion}.${windowsInfo.minorVersion}';
       }
     } catch (e) {
-      print('Erreur lors de la récupération des infos appareil: $e');
+      debugPrint('Erreur lors de la récupération des infos appareil: $e');
     }
 
     return deviceData;
@@ -131,15 +132,15 @@ class AiExportService {
 
       if (response.statusCode == 200) {
         final responseData = await response.stream.bytesToString();
-        print('Export réussi: $responseData');
+        debugPrint('Export réussi: $responseData');
         return true;
       } else {
         final errorData = await response.stream.bytesToString();
-        print('Erreur d\'export: ${response.statusCode} - $errorData');
+        debugPrint('Erreur d\'export: ${response.statusCode} - $errorData');
         return false;
       }
     } catch (e) {
-      print('Exception lors de l\'export: $e');
+      debugPrint('Exception lors de l\'export: $e');
       return false;
     }
   }

lib/services/distortion_correction_service.dart

@@ -8,6 +8,7 @@ library;
 import 'dart:io';
 import 'dart:math' as math;
 import 'package:image/image.dart' as img;
+import 'package:flutter/foundation.dart';
 import 'package:opencv_dart/opencv_dart.dart' as cv;
 import 'package:path_provider/path_provider.dart';
 
@@ -562,8 +563,9 @@ class DistortionCorrectionService {
       double maxArea = 0;
 
       for (final contour in contours) {
-        if (contour.length < 5)
+        if (contour.length < 5) {
           continue; // fitEllipse nécessite au moins 5 points
+        }
 
         final area = cv.contourArea(contour);
         if (area < 1000) continue; // Ignorer les trop petits bruits
@@ -636,7 +638,7 @@ class DistortionCorrectionService {
       return outputPath;
     } catch (e) {
       // En cas d'erreur, retourner l'image originale
-      print('Erreur correction perspective cercles: $e');
+      debugPrint('Erreur correction perspective cercles: $e');
       return imagePath;
     }
   }
@@ -761,7 +763,7 @@ class DistortionCorrectionService {
 
       return outputPath;
     } catch (e) {
-      print('Erreur correction perspective ovales: $e');
+      debugPrint('Erreur correction perspective ovales: $e');
       return imagePath;
     }
   }
@@ -822,7 +824,7 @@ class DistortionCorrectionService {
       }
 
       if (concentricGroup.length < 2) {
-        print(
+        debugPrint(
           "Pas assez de cercles concentriques pour le maillage, utilisation de la méthode simple.",
         );
         return await correctPerspectiveUsingOvals(imagePath);
@@ -950,7 +952,7 @@ class DistortionCorrectionService {
 
       return outputPath;
     } catch (e) {
-      print('Erreur correction perspective maillage concentrique: $e');
+      debugPrint('Erreur correction perspective maillage concentrique: $e');
       return imagePath;
     }
   }
@@ -1012,7 +1014,7 @@ class DistortionCorrectionService {
 
       // Fallback
       if (bestQuad == null) {
-        print(
+        debugPrint(
           "Aucun papier quadrilatère détecté, on utilise les cercles à la place.",
         );
         return await correctPerspectiveUsingCircles(imagePath);
@@ -1060,7 +1062,7 @@ class DistortionCorrectionService {
 
       return outputPath;
     } catch (e) {
-      print('Erreur correction perspective quadrilatère: $e');
+      debugPrint('Erreur correction perspective quadrilatère: $e');
       // Fallback
       return await correctPerspectiveUsingCircles(imagePath);
     }

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();
+    }
+  }
+}

lib/services/image_crop_service.dart

@@ -1,27 +1,14 @@
-/// Service de recadrage d'images.
-///
-/// Permet de recadrer une image en format carré (1:1) et de la sauvegarder
-/// dans un fichier temporaire pour utilisation ultérieure.
-library;
-
+import 'dart:isolate'; // AJOUT
 import 'dart:io';
 import 'dart:math' as math;
 import 'package:image/image.dart' as img;
 import 'package:path_provider/path_provider.dart';
 import 'package:uuid/uuid.dart';
 
-/// Représente une zone de recadrage normalisée (0.0 à 1.0)
 class CropRect {
-  /// Position X du coin supérieur gauche (0.0 à 1.0)
   final double x;
-
-  /// Position Y du coin supérieur gauche (0.0 à 1.0)
   final double y;
-
-  /// Largeur de la zone (0.0 à 1.0)
   final double width;
-
-  /// Hauteur de la zone (0.0 à 1.0)
   final double height;
 
   const CropRect({
@@ -35,97 +22,268 @@ class CropRect {
   String toString() => 'CropRect(x: $x, y: $y, w: $width, h: $height)';
 }
 
-/// Service pour recadrer les images
+// AJOUT : Paramètres passés à l'Isolate (tout doit être sérialisable)
+class _CropParams {
+  final String sourcePath;
+  final double cropX;
+  final double cropY;
+  final double cropWidth;
+  final double cropHeight;
+  final double rotationDegrees;
+  final int outputSize;
+  final String outputPath;
+
+  _CropParams({
+    required this.sourcePath,
+    required this.cropX,
+    required this.cropY,
+    required this.cropWidth,
+    required this.cropHeight,
+    required this.rotationDegrees,
+    required this.outputSize,
+    required this.outputPath,
+  });
+}
+
+// AJOUT : Fonction statique exécutée dans l'Isolate (doit être top-level ou static)
+void _cropIsolateEntry(_CropParams params) {
+  final file = File(params.sourcePath);
+  final bytes = file.readAsBytesSync();
+  img.Image? originalImage = img.decodeImage(bytes);
+
+  if (originalImage == null) {
+    throw Exception('Impossible de décoder l\'image: ${params.sourcePath}');
+  }
+
+  // Rotation si nécessaire — LINEAR au lieu de CUBIC pour la vitesse
+  if (params.rotationDegrees != 0.0) {
+    originalImage = img.copyRotate(
+      originalImage,
+      angle: params.rotationDegrees,
+      interpolation: img.Interpolation.linear, // OPTIMISATION : linear >> cubic en vitesse
+    );
+  }
+
+  // Recadrage
+  final srcX = (params.cropX * originalImage.width).round();
+  final srcY = (params.cropY * originalImage.height).round();
+  final srcWidth = (params.cropWidth * originalImage.width).round();
+  final srcHeight = (params.cropHeight * originalImage.height).round();
+
+  final clampedX = srcX.clamp(0, originalImage.width - 1);
+  final clampedY = srcY.clamp(0, originalImage.height - 1);
+  final clampedWidth = math.min(srcWidth, originalImage.width - clampedX);
+  final clampedHeight = math.min(srcHeight, originalImage.height - clampedY);
+
+  img.Image cropped = img.copyCrop(
+    originalImage,
+    x: clampedX,
+    y: clampedY,
+    width: clampedWidth,
+    height: clampedHeight,
+  );
+
+  // Redimensionnement — LINEAR au lieu de CUBIC
+  if (cropped.width != params.outputSize || cropped.height != params.outputSize) {
+    cropped = img.copyResize(
+      cropped,
+      width: params.outputSize,
+      height: params.outputSize,
+      interpolation: img.Interpolation.linear, // OPTIMISATION : linear >> cubic en vitesse
+    );
+  }
+
+  // Encodage JPEG qualité 85 au lieu de 90 (gain de vitesse non négligeable)
+  final outputFile = File(params.outputPath);
+  outputFile.writeAsBytesSync(img.encodeJpg(cropped, quality: 85));
+}
+
+// AJOUT : Paramètres de la découpe calée sur la fenêtre de visée (padding noir)
+class _ViewportCropParams {
+  final String sourcePath;
+  final double offsetDx;
+  final double offsetDy;
+  final double displayPerSourcePx; // facteur affichage/source (BoxFit.contain)
+  final double cropSizeDisplay; // côté de la fenêtre de visée, en pixels écran
+  final double zoomScale; // zoom utilisateur : sert UNIQUEMENT au pointage
+  final double rotationDegrees;
+  final int outputSize;
+  final String outputPath;
+
+  _ViewportCropParams({
+    required this.sourcePath,
+    required this.offsetDx,
+    required this.offsetDy,
+    required this.displayPerSourcePx,
+    required this.cropSizeDisplay,
+    required this.zoomScale,
+    required this.rotationDegrees,
+    required this.outputSize,
+    required this.outputPath,
+  });
+}
+
+// AJOUT : Découpe fidèle à ce que l'utilisateur voit. Reproduit la translation
+// (pan) et la rotation de l'aperçu, ignore le zoom, et remplit en NOIR toute
+// zone qui déborde de l'image → la cible reste exactement là où l'utilisateur
+// l'a placée, même collée à un bord (aucun recentrage forcé).
+void _viewportCropIsolateEntry(_ViewportCropParams p) {
+  final bytes = File(p.sourcePath).readAsBytesSync();
+  final img.Image? src = img.decodeImage(bytes);
+  if (src == null) {
+    throw Exception('Impossible de décoder l\'image: ${p.sourcePath}');
+  }
+
+  // Rotation autour du centre (canvas agrandi). Préserve l'échelle des pixels.
+  img.Image rotated = src;
+  if (p.rotationDegrees != 0.0) {
+    rotated = img.copyRotate(
+      src,
+      angle: p.rotationDegrees,
+      interpolation: img.Interpolation.linear,
+    );
+  }
+
+  final double f = p.displayPerSourcePx;
+  // Côté de la fenêtre de visée en pixels source. On utilise f SEUL (pas le
+  // zoom) → le champ de vision capturé est toujours celui de l'image non
+  // zoomée : le zoom n'est donc PAS pris en compte dans le rendu de sortie.
+  final int side = math.max(1, (p.cropSizeDisplay / f).round());
+
+  // Centre de la fenêtre de visée, en pixels de l'image (rotated).
+  // La translation écran s'applique APRÈS le zoom, donc un déplacement écran
+  // `offset` vaut `offset / (f * zoom)` pixels source. On inclut donc le zoom
+  // ICI (uniquement pour le pointage) afin que la croix vise le même point
+  // quel que soit le niveau de zoom.
+  final double fz = f * p.zoomScale;
+  final double cropCenterX = rotated.width / 2 - p.offsetDx / fz;
+  final double cropCenterY = rotated.height / 2 - p.offsetDy / fz;
+
+  final int srcX = (cropCenterX - side / 2).round();
+  final int srcY = (cropCenterY - side / 2).round();
+
+  // Toile carrée NOIRE opaque (numChannels 3 → pixels initialisés à 0 = noir).
+  final out = img.Image(width: side, height: side, numChannels: 3);
+
+  // Intersection de la fenêtre de visée avec l'image réelle. Tout ce qui
+  // déborde reste noir (padding) → aucun recentrage forcé.
+  final int vx0 = math.max(0, srcX);
+  final int vy0 = math.max(0, srcY);
+  final int vx1 = math.min(rotated.width, srcX + side);
+  final int vy1 = math.min(rotated.height, srcY + side);
+  final int vw = vx1 - vx0;
+  final int vh = vy1 - vy0;
+
+  if (vw > 0 && vh > 0) {
+    final region = img.copyCrop(rotated, x: vx0, y: vy0, width: vw, height: vh);
+    // dstW/dstH EXPLICITES = taille de la région → AUCUN redimensionnement
+    // (sinon compositeImage étire la source pour remplir la destination).
+    img.compositeImage(
+      out,
+      region,
+      dstX: vx0 - srcX,
+      dstY: vy0 - srcY,
+      dstW: vw,
+      dstH: vh,
+    );
+  }
+
+  img.Image result = out;
+  if (side != p.outputSize) {
+    result = img.copyResize(
+      out,
+      width: p.outputSize,
+      height: p.outputSize,
+      interpolation: img.Interpolation.linear,
+    );
+  }
+
+  File(p.outputPath).writeAsBytesSync(img.encodeJpg(result, quality: 85));
+}
+
 class ImageCropService {
   final Uuid _uuid = const Uuid();
 
-  /// Taille de sortie maximale pour les images recadrées
   static const int maxOutputSize = 1024;
 
-  /// Recadre une image en format carré
+  /// Découpe carrée calée sur la fenêtre de visée de l'écran de centrage.
+  /// Le décalage (pan) et la rotation sont respectés, le zoom est ignoré, et
+  /// tout débordement hors de l'image est rempli en noir (jamais de recentrage).
   ///
-  /// [sourcePath] - Chemin vers l'image source
-  /// [cropRect] - Zone de recadrage normalisée (0.0 à 1.0)
-  /// [outputSize] - Taille de sortie en pixels (carré)
-  ///
-  /// Retourne le chemin vers l'image recadrée dans le dossier temporaire
-  Future<String> cropToSquare(
-    String sourcePath,
-    CropRect cropRect, {
+  /// - [offsetDx]/[offsetDy] : translation de l'image dans l'aperçu, en px écran.
+  /// - [displayPerSourcePx] : facteur d'échelle affichage/source (BoxFit.contain).
+  /// - [cropSizeDisplay] : côté de la fenêtre carrée de visée, en px écran.
+  Future<String> cropViewport({
+    required String sourcePath,
+    required double offsetDx,
+    required double offsetDy,
+    required double displayPerSourcePx,
+    required double cropSizeDisplay,
+    double zoomScale = 1.0,
+    double rotationDegrees = 0.0,
     int outputSize = maxOutputSize,
   }) async {
-    // Charger l'image source
-    final file = File(sourcePath);
-    final bytes = await file.readAsBytes();
-    final originalImage = img.decodeImage(bytes);
+    final tempDir = await getTemporaryDirectory();
+    final outputPath = '${tempDir.path}/cropped_${_uuid.v4()}.jpg';
 
-    if (originalImage == null) {
-      throw Exception('Impossible de décoder l\'image: $sourcePath');
-    }
-
-    // Calculer les coordonnées en pixels
-    final srcX = (cropRect.x * originalImage.width).round();
-    final srcY = (cropRect.y * originalImage.height).round();
-    final srcWidth = (cropRect.width * originalImage.width).round();
-    final srcHeight = (cropRect.height * originalImage.height).round();
-
-    // S'assurer que les dimensions sont valides
-    final clampedX = srcX.clamp(0, originalImage.width - 1);
-    final clampedY = srcY.clamp(0, originalImage.height - 1);
-    final clampedWidth = math.min(srcWidth, originalImage.width - clampedX);
-    final clampedHeight = math.min(srcHeight, originalImage.height - clampedY);
-
-    // Recadrer l'image
-    img.Image cropped = img.copyCrop(
-      originalImage,
-      x: clampedX,
-      y: clampedY,
-      width: clampedWidth,
-      height: clampedHeight,
+    final params = _ViewportCropParams(
+      sourcePath: sourcePath,
+      offsetDx: offsetDx,
+      offsetDy: offsetDy,
+      displayPerSourcePx: displayPerSourcePx,
+      cropSizeDisplay: cropSizeDisplay,
+      zoomScale: zoomScale <= 0 ? 1.0 : zoomScale,
+      rotationDegrees: rotationDegrees,
+      outputSize: outputSize,
+      outputPath: outputPath,
     );
 
-    // Redimensionner à la taille de sortie si nécessaire
-    if (cropped.width != outputSize || cropped.height != outputSize) {
-      cropped = img.copyResize(
-        cropped,
-        width: outputSize,
-        height: outputSize,
-        interpolation: img.Interpolation.cubic,
-      );
-    }
+    // Traitement lourd dans un Isolate → thread UI fluide.
+    await Isolate.run(() => _viewportCropIsolateEntry(params));
 
-    // Sauvegarder dans le dossier temporaire
+    return outputPath;
+  }
+
+  Future<String> cropToSquare(
+      String sourcePath,
+      CropRect cropRect, {
+        double rotationDegrees = 0.0,
+        int outputSize = maxOutputSize,
+      }) async {
     final tempDir = await getTemporaryDirectory();
-    final fileName = 'cropped_${_uuid.v4()}.jpg';
-    final outputPath = '${tempDir.path}/$fileName';
+    final outputPath = '${tempDir.path}/cropped_${_uuid.v4()}.jpg';
 
-    final outputFile = File(outputPath);
-    await outputFile.writeAsBytes(img.encodeJpg(cropped, quality: 90));
+    final params = _CropParams(
+      sourcePath: sourcePath,
+      cropX: cropRect.x,
+      cropY: cropRect.y,
+      cropWidth: cropRect.width,
+      cropHeight: cropRect.height,
+      rotationDegrees: rotationDegrees,
+      outputSize: outputSize,
+      outputPath: outputPath,
+    );
+
+    // OPTIMISATION CLEF : Tout le traitement lourd dans un Isolate séparé
+    // → le thread UI reste fluide pendant le calcul
+    await Isolate.run(() => _cropIsolateEntry(params));
 
     return outputPath;
   }
 
   /// Calcule la zone de recadrage carrée maximale centrée sur l'image
-  ///
-  /// [imageWidth] - Largeur de l'image en pixels
-  /// [imageHeight] - Hauteur de l'image en pixels
-  ///
-  /// Retourne un CropRect normalisé pour un carré centré
   CropRect getDefaultSquareCrop(int imageWidth, int imageHeight) {
     final aspectRatio = imageWidth / imageHeight;
 
     if (aspectRatio > 1) {
-      // Image plus large que haute - centrer horizontalement
       final squareWidth = imageHeight / imageWidth;
       final x = (1 - squareWidth) / 2;
       return CropRect(x: x, y: 0, width: squareWidth, height: 1);
     } else if (aspectRatio < 1) {
-      // Image plus haute que large - centrer verticalement
       final squareHeight = imageWidth / imageHeight;
       final y = (1 - squareHeight) / 2;
       return CropRect(x: 0, y: y, width: 1, height: squareHeight);
     } else {
-      // Déjà carré
       return const CropRect(x: 0, y: 0, width: 1, height: 1);
     }
   }
@@ -147,7 +305,39 @@ class ImageCropService {
         }
       }
     } catch (e) {
-      // Ignorer les erreurs de nettoyage
+      // Ignorer les erreurs
     }
   }
-}
+
+  /// Coupe automatiquement une photo brute de l'appareil photo en carré
+  /// calé sur la position haute du viseur de l'écran.
+  Future<String> cropRawCameraToSquare(String sourcePath) async {
+    final file = File(sourcePath);
+    final bytes = await file.readAsBytes();
+    final originalImage = img.decodeImage(bytes);
+
+    if (originalImage == null) return sourcePath;
+
+    final int imgW = originalImage.width;
+    final int imgH = originalImage.height;
+
+    final int cropSizePixels = (math.min(imgW, imgH) * 0.85).round();
+
+    final int x = ((imgW - cropSizePixels) / 2).round();
+    final int y = ((imgH - cropSizePixels) / 2).round();
+
+    final squareImage = img.copyCrop(
+      originalImage,
+      x: x.clamp(0, imgW - 1),
+      y: y.clamp(0, imgH - 1),
+      width: cropSizePixels,
+      height: cropSizePixels,
+    );
+
+    final tempDir = await getTemporaryDirectory();
+    final outputPath = '${tempDir.path}/camera_square_${DateTime.now().millisecondsSinceEpoch}.jpg';
+    await File(outputPath).writeAsBytes(img.encodeJpg(squareImage, quality: 85));
+
+    return outputPath;
+  }
+}

lib/services/image_processing_service.dart

@@ -1,4 +1,5 @@
 import 'dart:io';
+import 'package:flutter/foundation.dart';
 import 'dart:math' as math;
 import 'package:image/image.dart' as img;
 
@@ -189,7 +190,7 @@ class ImageProcessingService {
         );
       }).toList();
     } catch (e) {
-      print('Error detecting impacts: $e');
+      debugPrint('Error detecting impacts: $e');
       return [];
     }
   }
@@ -236,14 +237,14 @@ class ImageProcessingService {
       final fillRatios = <double>[];
       final thresholds = <double>[];
 
-      print('Analyzing ${references.length} reference impacts...');
+      debugPrint('Analyzing ${references.length} reference impacts...');
 
       for (int refIndex = 0; refIndex < references.length; refIndex++) {
         final ref = references[refIndex];
         final centerX = (ref.x * width).round().clamp(0, width - 1);
         final centerY = (ref.y * height).round().clamp(0, height - 1);
 
-        print('Reference $refIndex at ($centerX, $centerY)');
+        debugPrint('Reference $refIndex at ($centerX, $centerY)');
 
         // AMÉLIORATION : Recherche du point le plus sombre dans une zone plus large
         int darkestX = centerX;
@@ -275,7 +276,7 @@ class ImageProcessingService {
           if (darkestLum < 50 && r > 5) break;
         }
 
-        print('  Darkest point at ($darkestX, $darkestY), lum=$darkestLum');
+        debugPrint('  Darkest point at ($darkestX, $darkestY), lum=$darkestLum');
 
         // Now find the blob at the darkest point using adaptive threshold
         final blobResult = _findBlobAtPoint(blurred, darkestX, darkestY, width, height);
@@ -286,15 +287,15 @@ class ImageProcessingService {
           circularities.add(blobResult.circularity);
           fillRatios.add(blobResult.fillRatio);
           thresholds.add(blobResult.threshold);
-          print('  Found blob: size=${blobResult.size}, circ=${blobResult.circularity.toStringAsFixed(2)}, '
+          debugPrint('  Found blob: size=${blobResult.size}, circ=${blobResult.circularity.toStringAsFixed(2)}, '
                 'fill=${blobResult.fillRatio.toStringAsFixed(2)}, threshold=${blobResult.threshold.toStringAsFixed(0)}');
         } else {
-          print('  No valid blob found at this reference');
+          debugPrint('  No valid blob found at this reference');
         }
       }
 
       if (luminances.isEmpty) {
-        print('ERROR: No valid blobs found from any reference!');
+        debugPrint('ERROR: No valid blobs found from any reference!');
         return null;
       }
 
@@ -329,11 +330,11 @@ class ImageProcessingService {
         avgDarkThreshold: avgThreshold,
       );
 
-      print('Learned characteristics: $result');
+      debugPrint('Learned characteristics: $result');
 
       return result;
     } catch (e) {
-      print('Error analyzing reference impacts: $e');
+      debugPrint('Error analyzing reference impacts: $e');
       return null;
     }
   }
@@ -680,7 +681,7 @@ class ImageProcessingService {
       // Calculate minimum fill ratio - impacts pleins
       final minFillRatio = (characteristics.avgFillRatio - 0.2).clamp(0.35, 0.85);
 
-      print('Detection params: thresholds=$thresholds, size=$minSize-$maxSize, '
+      debugPrint('Detection params: thresholds=$thresholds, size=$minSize-$maxSize, '
             'circ>=$effectiveMinCircularity, fill>=$minFillRatio');
 
       // Détecter avec plusieurs seuils et combiner les résultats
@@ -722,7 +723,7 @@ class ImageProcessingService {
         return true;
       }).toList();
 
-      print('Found ${filteredBlobs.length} impacts after filtering (from ${mergedBlobs.length} merged)');
+      debugPrint('Found ${filteredBlobs.length} impacts after filtering (from ${mergedBlobs.length} merged)');
 
       // Convert to relative coordinates
       return filteredBlobs.map((blob) {
@@ -733,7 +734,7 @@ class ImageProcessingService {
         );
       }).toList();
     } catch (e) {
-      print('Error detecting impacts from references: $e');
+      debugPrint('Error detecting impacts from references: $e');
       return [];
     }
   }
@@ -776,50 +777,6 @@ class ImageProcessingService {
     return merged;
   }
 
-  /// Detect dark spots with adaptive luminance range
-  List<_Blob> _detectDarkSpotsAdaptive(
-    img.Image image,
-    int minLuminance,
-    int maxLuminance,
-    int minSize,
-    int maxSize, {
-    double minCircularity = 0.5,
-    double minFillRatio = 0.5,
-  }) {
-    final width = image.width;
-    final height = image.height;
-
-    // Create binary mask of pixels within luminance range
-    final mask = List.generate(height, (_) => List.filled(width, false));
-
-    for (int y = 0; y < height; y++) {
-      for (int x = 0; x < width; x++) {
-        final pixel = image.getPixel(x, y);
-        final luminance = img.getLuminance(pixel);
-        mask[y][x] = luminance >= minLuminance && luminance <= maxLuminance;
-      }
-    }
-
-    // Find connected components
-    final visited = List.generate(height, (_) => List.filled(width, false));
-    final blobs = <_Blob>[];
-
-    for (int y = 0; y < height; y++) {
-      for (int x = 0; x < width; x++) {
-        if (mask[y][x] && !visited[y][x]) {
-          final blob = _floodFill(mask, visited, x, y, width, height);
-          if (blob.size >= minSize &&
-              blob.size <= maxSize &&
-              blob.circularity >= minCircularity &&
-              blob.fillRatio >= minFillRatio) {
-            blobs.add(blob);
-          }
-        }
-      }
-    }
-
-    return _filterOverlappingBlobs(blobs);
-  }
 
   /// Detect dark spots in a grayscale image using blob detection
   List<_Blob> _detectDarkSpots(

lib/services/parallelism_service.dart

@@ -0,0 +1,162 @@
+import 'dart:async';
+import 'dart:math' as math;
+import 'package:sensors_plus/sensors_plus.dart';
+
+/// Statut de parallélisme retourné en temps réel.
+enum ParallelismStatus {
+  /// Pas encore de données capteur disponibles.
+  unknown,
+
+  /// L'appareil est bien parallèle à la cible.
+  aligned,
+
+  /// L'appareil est trop incliné.
+  misaligned,
+}
+
+/// 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).
+  final double pitchDegrees;
+
+  /// Inclinaison gauche/droite en degrés (0° = parfaitement droit).
+  final double rollDegrees;
+
+  const ParallelismData({
+    required this.status,
+    required this.pitchDegrees,
+    required this.rollDegrees,
+  });
+
+  bool get isAligned => status == ParallelismStatus.aligned;
+
+  @override
+  String toString() =>
+      'ParallelismData(status: $status, pitch: ${pitchDegrees.toStringAsFixed(1)}°, roll: ${rollDegrees.toStringAsFixed(1)}°)';
+}
+
+/// Service de détection du parallélisme par accéléromètre.
+///
+/// Implémente une hystérésis à deux seuils pour éviter le clignotement :
+///
+///   État actuel = misaligned → passe à aligned si angle < [alignThreshold]
+///   État actuel = aligned    → passe à misaligned si angle > [misalignThreshold]
+///
+/// Cela crée une "zone de confort" entre les deux seuils où le statut
+/// ne change pas — le vert reste vert même si la main tremble légèrement.
+///
+/// Valeurs par défaut recommandées :
+///   alignThreshold    = 15°  (seuil d'entrée dans le vert — assez souple)
+///   misalignThreshold = 22°  (seuil de sortie du vert — tolérant au tremblement)
+class ParallelismService {
+  /// Angle max pour passer de misaligned → aligned.
+  final double alignThreshold;
+
+  /// Angle à dépasser pour passer de aligned → misaligned.
+  /// Doit être > alignThreshold pour créer la zone d'hystérésis.
+  final double misalignThreshold;
+
+  StreamSubscription<AccelerometerEvent>? _subscription;
+  final StreamController<ParallelismData> _controller =
+  StreamController<ParallelismData>.broadcast();
+
+  /// État interne mémorisé entre deux frames (cœur de l'hystérésis).
+  ParallelismStatus _currentStatus = ParallelismStatus.unknown;
+
+  ParallelismService({
+    this.alignThreshold = 25.0,
+    this.misalignThreshold = 32.0,
+  }) : assert(
+  misalignThreshold > alignThreshold,
+  'misalignThreshold doit être supérieur à alignThreshold',
+  );
+
+  Stream<ParallelismData> get stream => _controller.stream;
+
+  void start() {
+    if (_subscription != null) return;
+
+    _subscription = accelerometerEventStream(
+      samplingPeriod: SensorInterval.normalInterval, // ~50 ms
+    ).listen(
+      _onAccelerometerEvent,
+      onError: (_) {
+        // Simulateur ou capteur absent — on reste en "unknown" sans bloquer l'UI
+        if (!_controller.isClosed) {
+          _currentStatus = ParallelismStatus.unknown;
+          _controller.add(const ParallelismData(
+            status: ParallelismStatus.unknown,
+            pitchDegrees: 0,
+            rollDegrees: 0,
+          ));
+        }
+      },
+    );
+  }
+
+  void stop() {
+    _subscription?.cancel();
+    _subscription = null;
+    _currentStatus = ParallelismStatus.unknown;
+  }
+
+  void dispose() {
+    stop();
+    _controller.close();
+  }
+
+  void _onAccelerometerEvent(AccelerometerEvent event) {
+    if (_controller.isClosed) return;
+
+    final double gx = event.x;
+    final double gy = event.y;
+    final double gz = event.z;
+
+    final double magnitude = math.sqrt(gx * gx + gy * gy + gz * gz);
+    if (magnitude < 1.0) return; // Données aberrantes
+
+    // Normalisation par la magnitude réelle (indépendant de g exact)
+    final double nx = gx / magnitude;
+    final double ny = gy / magnitude;
+    final double nz = gz / magnitude;
+
+    // Pitch et Roll mesurent l'inclinaison autour de chaque axe.
+    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());
+
+    // ── Hystérésis ──────────────────────────────────────────────────────────
+    // Premier appel : on décide selon alignThreshold uniquement
+    if (_currentStatus == ParallelismStatus.unknown) {
+      _currentStatus = worstAngle <= alignThreshold
+          ? ParallelismStatus.aligned
+          : ParallelismStatus.misaligned;
+    }
+    // Déjà misaligned → devient aligned seulement si on passe sous alignThreshold
+    else if (_currentStatus == ParallelismStatus.misaligned) {
+      if (worstAngle <= alignThreshold) {
+        _currentStatus = ParallelismStatus.aligned;
+      }
+    }
+    // Déjà aligned → devient misaligned seulement si on dépasse misalignThreshold
+    else if (_currentStatus == ParallelismStatus.aligned) {
+      if (worstAngle > misalignThreshold) {
+        _currentStatus = ParallelismStatus.misaligned;
+      }
+      // Entre alignThreshold et misalignThreshold → on garde le vert, on ne change rien
+    }
+    // ────────────────────────────────────────────────────────────────────────
+
+    _controller.add(ParallelismData(
+      status: _currentStatus,
+      pitchDegrees: pitchDeg,
+      rollDegrees: rollDeg,
+    ));
+  }
+}

lib/services/statistics_service.dart

@@ -66,25 +66,12 @@ class PrecisionStats {
 
 /// Standard deviation statistics
 class StdDevStats {
-  /// Standard deviation of X positions
   final double stdDevX;
-
-  /// Standard deviation of Y positions
   final double stdDevY;
-
-  /// Combined standard deviation (radial)
   final double stdDevRadial;
-
-  /// Standard deviation of scores
   final double stdDevScore;
-
-  /// Mean X position
   final double meanX;
-
-  /// Mean Y position
   final double meanY;
-
-  /// Mean score
   final double meanScore;
 
   const StdDevStats({
@@ -98,18 +85,11 @@ class StdDevStats {
   });
 }
 
-/// Regional distribution (quadrants or sectors)
+/// Regional distribution
 class RegionalStats {
-  /// Shot distribution by quadrant (top-left, top-right, bottom-left, bottom-right)
   final Map<String, int> quadrantDistribution;
-
-  /// Shot distribution by sector (N, NE, E, SE, S, SW, W, NW, Center)
   final Map<String, int> sectorDistribution;
-
-  /// Dominant direction (where most shots land)
   final String dominantDirection;
-
-  /// Bias offset from center
   final double biasX;
   final double biasY;
 
@@ -157,16 +137,16 @@ class StatisticsService {
   SessionStatistics calculateStatistics(
     List<Session> sessions, {
     StatsPeriod period = StatsPeriod.all,
-    double targetCenterX = 0.5,
-    double targetCenterY = 0.5,
   }) {
     // Filter sessions by period
     final filteredSessions = _filterByPeriod(sessions, period);
 
-    // Collect all shots
+    // Collect all shots from all analyses in all sessions
     final allShots = <Shot>[];
     for (final session in filteredSessions) {
-      allShots.addAll(session.shots);
+      for (final analysis in session.analyses) {
+        allShots.addAll(analysis.shots);
+      }
     }
 
     if (allShots.isEmpty) {
@@ -183,14 +163,14 @@ class StatisticsService {
     // Calculate heat map
     final heatMap = _calculateHeatMap(allShots, gridSize: 5);
 
-    // Calculate precision
-    final precision = _calculatePrecision(allShots, targetCenterX, targetCenterY);
+    // Calculate precision (using relative center 0.5, 0.5)
+    final precision = _calculatePrecision(allShots, 0.5, 0.5);
 
     // Calculate standard deviation
     final stdDev = _calculateStdDev(allShots);
 
     // Calculate regional distribution
-    final regional = _calculateRegional(allShots, targetCenterX, targetCenterY);
+    final regional = _calculateRegional(allShots, 0.5, 0.5);
 
     return SessionStatistics(
       totalShots: totalShots,
@@ -224,20 +204,13 @@ class StatisticsService {
 
   /// Calculate heat map
   HeatMap _calculateHeatMap(List<Shot> shots, {int gridSize = 5}) {
-    // Initialize grid
-    final grid = List.generate(
-      gridSize,
-      (_) => List.generate(gridSize, (_) => <Shot>[]),
-    );
-
-    // Assign shots to grid cells
+    final grid = List.generate(gridSize, (_) => List.generate(gridSize, (_) => <Shot>[]));
     for (final shot in shots) {
       final col = (shot.x * gridSize).floor().clamp(0, gridSize - 1);
       final row = (shot.y * gridSize).floor().clamp(0, gridSize - 1);
       grid[row][col].add(shot);
     }
 
-    // Find max count for normalization
     int maxCount = 0;
     for (final row in grid) {
       for (final cell in row) {
@@ -245,16 +218,12 @@ class StatisticsService {
       }
     }
 
-    // Create heat zones
     final zones = <List<HeatZone>>[];
     for (int row = 0; row < gridSize; row++) {
       final rowZones = <HeatZone>[];
       for (int col = 0; col < gridSize; col++) {
         final cellShots = grid[row][col];
-        final avgScore = cellShots.isEmpty
-            ? 0.0
-            : cellShots.fold<int>(0, (sum, s) => sum + s.score) / cellShots.length;
-
+        final avgScore = cellShots.isEmpty ? 0.0 : cellShots.fold<int>(0, (sum, s) => sum + s.score) / cellShots.length;
         rowZones.add(HeatZone(
           row: row,
           col: col,
@@ -266,30 +235,15 @@ class StatisticsService {
       zones.add(rowZones);
     }
 
-    return HeatMap(
-      gridSize: gridSize,
-      zones: zones,
-      maxShotsInZone: maxCount,
-      totalShots: shots.length,
-    );
+    return HeatMap(gridSize: gridSize, zones: zones, maxShotsInZone: maxCount, totalShots: shots.length);
   }
 
   /// Calculate precision statistics
-  PrecisionStats _calculatePrecision(
-    List<Shot> shots,
-    double centerX,
-    double centerY,
-  ) {
+  PrecisionStats _calculatePrecision(List<Shot> shots, double centerX, double centerY) {
     if (shots.isEmpty) {
-      return const PrecisionStats(
-        avgDistanceFromCenter: 0,
-        groupingDiameter: 0,
-        precisionScore: 0,
-        consistencyScore: 0,
-      );
+      return const PrecisionStats(avgDistanceFromCenter: 0, groupingDiameter: 0, precisionScore: 0, consistencyScore: 0);
     }
 
-    // Calculate distances from center
     final distances = shots.map((shot) {
       final dx = shot.x - centerX;
       final dy = shot.y - centerY;
@@ -297,8 +251,6 @@ class StatisticsService {
     }).toList();
 
     final avgDistance = distances.reduce((a, b) => a + b) / distances.length;
-
-    // Calculate grouping (spread between shots)
     double maxSpread = 0;
     for (int i = 0; i < shots.length; i++) {
       for (int j = i + 1; j < shots.length; j++) {
@@ -309,45 +261,29 @@ class StatisticsService {
       }
     }
 
-    // Calculate standard deviation of distances (consistency)
-    final meanDist = avgDistance;
     double variance = 0;
     for (final d in distances) {
-      variance += math.pow(d - meanDist, 2);
+      variance += math.pow(d - avgDistance, 2);
     }
     final stdDevDist = math.sqrt(variance / distances.length);
 
-    // Precision score: based on average distance from center (0-100)
-    // 0 distance = 100 score, 0.5 distance = 0 score
     final precisionScore = math.max(0, (1 - avgDistance * 2) * 100);
-
-    // Consistency score: based on grouping tightness (0-100)
-    // Lower spread = higher consistency
     final consistencyScore = math.max(0, (1 - stdDevDist * 5) * 100);
 
     return PrecisionStats(
-      avgDistanceFromCenter: avgDistance.toDouble(),
-      groupingDiameter: maxSpread.toDouble(),
-      precisionScore: precisionScore.clamp(0.0, 100.0).toDouble(),
-      consistencyScore: consistencyScore.clamp(0.0, 100.0).toDouble(),
+      avgDistanceFromCenter: avgDistance,
+      groupingDiameter: maxSpread,
+      precisionScore: precisionScore.toDouble().clamp(0.0, 100.0),
+      consistencyScore: consistencyScore.toDouble().clamp(0.0, 100.0),
     );
   }
 
   /// Calculate standard deviation statistics
   StdDevStats _calculateStdDev(List<Shot> shots) {
     if (shots.isEmpty) {
-      return const StdDevStats(
-        stdDevX: 0,
-        stdDevY: 0,
-        stdDevRadial: 0,
-        stdDevScore: 0,
-        meanX: 0.5,
-        meanY: 0.5,
-        meanScore: 0,
-      );
+      return const StdDevStats(stdDevX: 0, stdDevY: 0, stdDevRadial: 0, stdDevScore: 0, meanX: 0.5, meanY: 0.5, meanScore: 0);
     }
 
-    // Calculate means
     double sumX = 0, sumY = 0, sumScore = 0;
     for (final shot in shots) {
       sumX += shot.x;
@@ -358,7 +294,6 @@ class StatisticsService {
     final meanY = sumY / shots.length;
     final meanScore = sumScore / shots.length;
 
-    // Calculate variances
     double varianceX = 0, varianceY = 0, varianceScore = 0;
     for (final shot in shots) {
       varianceX += math.pow(shot.x - meanX, 2);
@@ -369,18 +304,11 @@ class StatisticsService {
     varianceY /= shots.length;
     varianceScore /= shots.length;
 
-    final stdDevX = math.sqrt(varianceX);
-    final stdDevY = math.sqrt(varianceY);
-    final stdDevScore = math.sqrt(varianceScore);
-
-    // Radial standard deviation
-    final stdDevRadial = math.sqrt(varianceX + varianceY);
-
     return StdDevStats(
-      stdDevX: stdDevX,
-      stdDevY: stdDevY,
-      stdDevRadial: stdDevRadial,
-      stdDevScore: stdDevScore,
+      stdDevX: math.sqrt(varianceX),
+      stdDevY: math.sqrt(varianceY),
+      stdDevRadial: math.sqrt(varianceX + varianceY),
+      stdDevScore: math.sqrt(varianceScore),
       meanX: meanX,
       meanY: meanY,
       meanScore: meanScore,
@@ -388,42 +316,13 @@ class StatisticsService {
   }
 
   /// Calculate regional distribution
-  RegionalStats _calculateRegional(
-    List<Shot> shots,
-    double centerX,
-    double centerY,
-  ) {
+  RegionalStats _calculateRegional(List<Shot> shots, double centerX, double centerY) {
     if (shots.isEmpty) {
-      return const RegionalStats(
-        quadrantDistribution: {},
-        sectorDistribution: {},
-        dominantDirection: 'Centre',
-        biasX: 0,
-        biasY: 0,
-      );
+      return const RegionalStats(quadrantDistribution: {}, sectorDistribution: {}, dominantDirection: 'Centre', biasX: 0, biasY: 0);
     }
 
-    // Quadrant distribution
-    final quadrants = <String, int>{
-      'Haut-Gauche': 0,
-      'Haut-Droite': 0,
-      'Bas-Gauche': 0,
-      'Bas-Droite': 0,
-    };
-
-    // Sector distribution (8 sectors + center)
-    final sectors = <String, int>{
-      'N': 0,
-      'NE': 0,
-      'E': 0,
-      'SE': 0,
-      'S': 0,
-      'SO': 0,
-      'O': 0,
-      'NO': 0,
-      'Centre': 0,
-    };
-
+    final quadrants = <String, int>{'Haut-Gauche': 0, 'Haut-Droite': 0, 'Bas-Gauche': 0, 'Bas-Droite': 0};
+    final sectors = <String, int>{'N': 0, 'NE': 0, 'E': 0, 'SE': 0, 'S': 0, 'SO': 0, 'O': 0, 'NO': 0, 'Centre': 0};
     double sumDx = 0, sumDy = 0;
 
     for (final shot in shots) {
@@ -432,16 +331,12 @@ class StatisticsService {
       sumDx += dx;
       sumDy += dy;
 
-      // Quadrant
       if (dy < 0) {
-        quadrants[dx < 0 ? 'Haut-Gauche' : 'Haut-Droite'] =
-            quadrants[dx < 0 ? 'Haut-Gauche' : 'Haut-Droite']! + 1;
+        quadrants[dx < 0 ? 'Haut-Gauche' : 'Haut-Droite'] = quadrants[dx < 0 ? 'Haut-Gauche' : 'Haut-Droite']! + 1;
       } else {
-        quadrants[dx < 0 ? 'Bas-Gauche' : 'Bas-Droite'] =
-            quadrants[dx < 0 ? 'Bas-Gauche' : 'Bas-Droite']! + 1;
+        quadrants[dx < 0 ? 'Bas-Gauche' : 'Bas-Droite'] = quadrants[dx < 0 ? 'Bas-Gauche' : 'Bas-Droite']! + 1;
       }
 
-      // Sector
       final distance = math.sqrt(dx * dx + dy * dy);
       if (distance < 0.1) {
         sectors['Centre'] = sectors['Centre']! + 1;
@@ -452,11 +347,6 @@ class StatisticsService {
       }
     }
 
-    // Calculate bias
-    final biasX = sumDx / shots.length;
-    final biasY = sumDy / shots.length;
-
-    // Find dominant direction
     String dominant = 'Centre';
     int maxCount = 0;
     sectors.forEach((key, value) {
@@ -470,14 +360,12 @@ class StatisticsService {
       quadrantDistribution: quadrants,
       sectorDistribution: sectors,
       dominantDirection: dominant,
-      biasX: biasX,
-      biasY: biasY,
+      biasX: sumDx / shots.length,
+      biasY: sumDy / shots.length,
     );
   }
 
   String _angleToSector(double angle) {
-    // Angle is in degrees, -180 to 180
-    // 0 = East, 90 = South, -90 = North, 180/-180 = West
     if (angle >= -22.5 && angle < 22.5) return 'E';
     if (angle >= 22.5 && angle < 67.5) return 'SE';
     if (angle >= 67.5 && angle < 112.5) return 'S';
@@ -491,41 +379,12 @@ class StatisticsService {
 
   SessionStatistics _emptyStatistics(StatsPeriod period, List<Session> sessions) {
     return SessionStatistics(
-      totalShots: 0,
-      totalScore: 0,
-      avgScore: 0,
-      maxScore: 0,
-      minScore: 0,
-      heatMap: const HeatMap(
-        gridSize: 5,
-        zones: [],
-        maxShotsInZone: 0,
-        totalShots: 0,
-      ),
-      precision: const PrecisionStats(
-        avgDistanceFromCenter: 0,
-        groupingDiameter: 0,
-        precisionScore: 0,
-        consistencyScore: 0,
-      ),
-      stdDev: const StdDevStats(
-        stdDevX: 0,
-        stdDevY: 0,
-        stdDevRadial: 0,
-        stdDevScore: 0,
-        meanX: 0.5,
-        meanY: 0.5,
-        meanScore: 0,
-      ),
-      regional: const RegionalStats(
-        quadrantDistribution: {},
-        sectorDistribution: {},
-        dominantDirection: 'Centre',
-        biasX: 0,
-        biasY: 0,
-      ),
-      sessions: sessions,
-      period: period,
+      totalShots: 0, totalScore: 0, avgScore: 0, maxScore: 0, minScore: 0,
+      heatMap: const HeatMap(gridSize: 5, zones: [], maxShotsInZone: 0, totalShots: 0),
+      precision: const PrecisionStats(avgDistanceFromCenter: 0, groupingDiameter: 0, precisionScore: 0, consistencyScore: 0),
+      stdDev: const StdDevStats(stdDevX: 0, stdDevY: 0, stdDevRadial: 0, stdDevScore: 0, meanX: 0.5, meanY: 0.5, meanScore: 0),
+      regional: const RegionalStats(quadrantDistribution: {}, sectorDistribution: {}, dominantDirection: 'Centre', biasX: 0, biasY: 0),
+      sessions: sessions, period: period,
     );
   }
 }

lib/services/target_detection_service.dart

@@ -1,4 +1,5 @@
 import 'dart:math' as math;
+import 'package:flutter/foundation.dart';
 import '../data/models/target_type.dart';
 import 'image_processing_service.dart';
 import 'opencv_impact_detection_service.dart';
@@ -7,6 +8,110 @@ export 'image_processing_service.dart'
 export 'opencv_impact_detection_service.dart'
     show OpenCVDetectionSettings, OpenCVDetectedImpact;
 
+// ============================================================================
+// STRUCT ET FONCTION GLOBALE POUR LE PARALLÉLISME (THREAD SECONDAIRE)
+// ============================================================================
+
+/// Conteneur de données pour envoyer les paramètres à l'Isolate d'arrière-plan.
+class DetectionPayload {
+  final String imagePath;
+  final TargetType targetType;
+
+  // On recrée les instances à l'intérieur du thread isolé car les objets ne se partagent pas entre threads.
+  DetectionPayload({
+    required this.imagePath,
+    required this.targetType,
+  });
+}
+
+/// FONCTION EXÉCUTÉE EN PARALLÈLE : Tourne sur un autre cœur du processeur.
+/// L'interface graphique reste à 120 FPS et totalement fluide.
+TargetDetectionResult runParallelTargetDetection(DetectionPayload payload) {
+  // 1. Initialisation locale des services dans le sous-thread
+  final imageProcessingService = ImageProcessingService();
+
+  try {
+    // 2. Détection de la cible principale (Calcul lourd)
+    final mainTarget = imageProcessingService.detectMainTarget(payload.imagePath);
+
+    double centerX = 0.5;
+    double centerY = 0.5;
+    double radius = 0.4;
+
+    if (mainTarget != null) {
+      centerX = mainTarget.centerX;
+      centerY = mainTarget.centerY;
+      radius = mainTarget.radius;
+    }
+
+    // 3. Détection des impacts (Calcul lourd)
+    final impacts = imageProcessingService.detectImpacts(payload.imagePath);
+
+    // 4. Calcul mathématique des scores relatifs
+    final detectedImpacts = impacts.map((impact) {
+      final score = payload.targetType == TargetType.concentric
+          ? _staticCalculateConcentricScore(
+        impact.x,
+        impact.y,
+        centerX,
+        centerY,
+        radius,
+      )
+          : _staticCalculateSilhouetteScore(impact.x, impact.y, centerX, centerY);
+
+      return DetectedImpactResult(
+        x: impact.x,
+        y: impact.y,
+        radius: impact.radius,
+        suggestedScore: score,
+      );
+    }).toList();
+
+    return TargetDetectionResult(
+      centerX: centerX,
+      centerY: centerY,
+      radius: radius,
+      impacts: detectedImpacts,
+    );
+  } catch (e) {
+    return TargetDetectionResult.error('Erreur de detection parallèle: $e');
+  }
+}
+
+// Fonctions mathématiques pures nécessaires à l'Isolate (statiques)
+int _staticCalculateConcentricScore(double impactX, double impactY, double centerX, double centerY, double targetRadius) {
+  final dx = impactX - centerX;
+  final dy = impactY - centerY;
+  final distance = math.sqrt(dx * dx + dy * dy) / targetRadius;
+  if (distance <= 0.1) return 10;
+  if (distance <= 0.2) return 9;
+  if (distance <= 0.3) return 8;
+  if (distance <= 0.4) return 7;
+  if (distance <= 0.5) return 6;
+  if (distance <= 0.6) return 5;
+  if (distance <= 0.7) return 4;
+  if (distance <= 0.8) return 3;
+  if (distance <= 0.9) return 2;
+  if (distance <= 1.0) return 1;
+  return 0;
+}
+
+int _staticCalculateSilhouetteScore(double impactX, double impactY, double centerX, double centerY) {
+  final dx = (impactX - centerX).abs();
+  final dy = impactY - centerY;
+  if (dx > 0.15) return 0;
+  if (dy < -0.25) return 5;
+  if (dy < 0.0) return 5;
+  if (dy < 0.15) return 4;
+  if (dy < 0.35) return 3;
+  return 0;
+}
+
+// ============================================================================
+// FIN DU BLOC DE PARALLÉLISME
+// ============================================================================
+
+
 class TargetDetectionResult {
   final double centerX; // Relative (0-1)
   final double centerY; // Relative (0-1)
@@ -58,13 +163,20 @@ class TargetDetectionService {
     ImageProcessingService? imageProcessingService,
     OpenCVImpactDetectionService? opencvService,
   }) : _imageProcessingService =
-           imageProcessingService ?? ImageProcessingService(),
-       _opencvService = opencvService ?? OpenCVImpactDetectionService();
+      imageProcessingService ?? ImageProcessingService(),
+        _opencvService = opencvService ?? OpenCVImpactDetectionService();
 
-  /// Detect target and impacts from an image file
+  /// Detect target and impacts from an image file ASYNCHRONOUSLY in a separate Thread.
+  /// CORRECTION : Utilise désormais 'compute' pour basculer en arrière-plan immédiat.
+  Future<TargetDetectionResult> detectTargetAsync(String imagePath, TargetType targetType) async {
+    final payload = DetectionPayload(imagePath: imagePath, targetType: targetType);
+    // Déclenche l'exécution isolée en tâche de fond
+    return await compute(runParallelTargetDetection, payload);
+  }
+
+  /// Gardée pour rétrocompatibilité synchrone si nécessaire
   TargetDetectionResult detectTarget(String imagePath, TargetType targetType) {
     try {
-      // Detect main target
       final mainTarget = _imageProcessingService.detectMainTarget(imagePath);
 
       double centerX = 0.5;
@@ -77,19 +189,17 @@ class TargetDetectionService {
         radius = mainTarget.radius;
       }
 
-      // Detect impacts
       final impacts = _imageProcessingService.detectImpacts(imagePath);
 
-      // Convert impacts to relative coordinates and calculate scores
       final detectedImpacts = impacts.map((impact) {
         final score = targetType == TargetType.concentric
             ? _calculateConcentricScore(
-                impact.x,
-                impact.y,
-                centerX,
-                centerY,
-                radius,
-              )
+          impact.x,
+          impact.y,
+          centerX,
+          centerY,
+          radius,
+        )
             : _calculateSilhouetteScore(impact.x, impact.y, centerX, centerY);
 
         return DetectedImpactResult(
@@ -112,18 +222,16 @@ class TargetDetectionService {
   }
 
   int _calculateConcentricScore(
-    double impactX,
-    double impactY,
-    double centerX,
-    double centerY,
-    double targetRadius,
-  ) {
-    // Calculate distance from center (normalized to target radius)
+      double impactX,
+      double impactY,
+      double centerX,
+      double centerY,
+      double targetRadius,
+      ) {
     final dx = impactX - centerX;
     final dy = impactY - centerY;
     final distance = math.sqrt(dx * dx + dy * dy) / targetRadius;
 
-    // Score zones (10 zones)
     if (distance <= 0.1) return 10;
     if (distance <= 0.2) return 9;
     if (distance <= 0.3) return 8;
@@ -134,61 +242,52 @@ class TargetDetectionService {
     if (distance <= 0.8) return 3;
     if (distance <= 0.9) return 2;
     if (distance <= 1.0) return 1;
-    return 0; // Outside target
+    return 0;
   }
 
   int _calculateSilhouetteScore(
-    double impactX,
-    double impactY,
-    double centerX,
-    double centerY,
-  ) {
-    // For silhouettes, scoring is typically based on zones
-    // Head and center mass = 5, body = 4, lower = 3
-
+      double impactX,
+      double impactY,
+      double centerX,
+      double centerY,
+      ) {
     final dx = (impactX - centerX).abs();
     final dy = impactY - centerY;
 
-    // Check if within silhouette bounds (approximate)
-    if (dx > 0.15) return 0; // Too far left/right
+    if (dx > 0.15) return 0;
+    if (dy < -0.25) return 5;
+    if (dy < 0.0) return 5;
+    if (dy < 0.15) return 4;
+    if (dy < 0.35) return 3;
 
-    // Vertical zones
-    if (dy < -0.25) return 5; // Head zone (top)
-    if (dy < 0.0) return 5; // Center mass (upper body)
-    if (dy < 0.15) return 4; // Body
-    if (dy < 0.35) return 3; // Lower body
-
-    return 0; // Outside target
+    return 0;
   }
 
-  /// Detect only impacts with custom settings (doesn't affect target position)
   List<DetectedImpactResult> detectImpactsOnly(
-    String imagePath,
-    TargetType targetType,
-    double centerX,
-    double centerY,
-    double radius,
-    int ringCount,
-    ImpactDetectionSettings settings,
-  ) {
+      String imagePath,
+      TargetType targetType,
+      double centerX,
+      double centerY,
+      double radius,
+      int ringCount,
+      ImpactDetectionSettings settings,
+      ) {
     try {
-      // Detect impacts with custom settings
       final impacts = _imageProcessingService.detectImpactsWithSettings(
         imagePath,
         settings,
       );
 
-      // Convert impacts to relative coordinates and calculate scores
       return impacts.map((impact) {
         final score = targetType == TargetType.concentric
             ? _calculateConcentricScoreWithRings(
-                impact.x,
-                impact.y,
-                centerX,
-                centerY,
-                radius,
-                ringCount,
-              )
+          impact.x,
+          impact.y,
+          centerX,
+          centerY,
+          radius,
+          ringCount,
+        )
             : _calculateSilhouetteScore(impact.x, impact.y, centerX, centerY);
 
         return DetectedImpactResult(
@@ -204,19 +303,17 @@ class TargetDetectionService {
   }
 
   int _calculateConcentricScoreWithRings(
-    double impactX,
-    double impactY,
-    double centerX,
-    double centerY,
-    double targetRadius,
-    int ringCount,
-  ) {
-    // Calculate distance from center (normalized to target radius)
+      double impactX,
+      double impactY,
+      double centerX,
+      double centerY,
+      double targetRadius,
+      int ringCount,
+      ) {
     final dx = impactX - centerX;
     final dy = impactY - centerY;
     final distance = math.sqrt(dx * dx + dy * dy) / targetRadius;
 
-    // Score zones based on ringCount
     for (int i = 0; i < ringCount; i++) {
       final zoneRadius = (i + 1) / ringCount;
       if (distance <= zoneRadius) {
@@ -224,31 +321,29 @@ class TargetDetectionService {
       }
     }
 
-    return 0; // Outside target
+    return 0;
   }
 
-  /// Analyze reference impacts to learn their characteristics
   ImpactCharacteristics? analyzeReferenceImpacts(
-    String imagePath,
-    List<ReferenceImpact> references,
-  ) {
+      String imagePath,
+      List<ReferenceImpact> references,
+      ) {
     return _imageProcessingService.analyzeReferenceImpacts(
       imagePath,
       references,
     );
   }
 
-  /// Detect impacts based on reference characteristics (calibrated detection)
   List<DetectedImpactResult> detectImpactsFromReferences(
-    String imagePath,
-    TargetType targetType,
-    double centerX,
-    double centerY,
-    double radius,
-    int ringCount,
-    ImpactCharacteristics characteristics, {
-    double tolerance = 2.0,
-  }) {
+      String imagePath,
+      TargetType targetType,
+      double centerX,
+      double centerY,
+      double radius,
+      int ringCount,
+      ImpactCharacteristics characteristics, {
+        double tolerance = 2.0,
+      }) {
     try {
       final impacts = _imageProcessingService.detectImpactsFromReferences(
         imagePath,
@@ -259,13 +354,13 @@ class TargetDetectionService {
       return impacts.map((impact) {
         final score = targetType == TargetType.concentric
             ? _calculateConcentricScoreWithRings(
-                impact.x,
-                impact.y,
-                centerX,
-                centerY,
-                radius,
-                ringCount,
-              )
+          impact.x,
+          impact.y,
+          centerX,
+          centerY,
+          radius,
+          ringCount,
+        )
             : _calculateSilhouetteScore(impact.x, impact.y, centerX, centerY);
 
         return DetectedImpactResult(
@@ -280,20 +375,15 @@ class TargetDetectionService {
     }
   }
 
-  /// 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,
-  }) {
+      String imagePath,
+      TargetType targetType,
+      double centerX,
+      double centerY,
+      double radius,
+      int ringCount, {
+        OpenCVDetectionSettings? settings,
+      }) {
     try {
       final impacts = _opencvService.detectImpacts(
         imagePath,
@@ -303,13 +393,13 @@ class TargetDetectionService {
       return impacts.map((impact) {
         final score = targetType == TargetType.concentric
             ? _calculateConcentricScoreWithRings(
-                impact.x,
-                impact.y,
-                centerX,
-                centerY,
-                radius,
-                ringCount,
-              )
+          impact.x,
+          impact.y,
+          centerX,
+          centerY,
+          radius,
+          ringCount,
+        )
             : _calculateSilhouetteScore(impact.x, impact.y, centerX, centerY);
 
         return DetectedImpactResult(
@@ -320,27 +410,22 @@ class TargetDetectionService {
         );
       }).toList();
     } catch (e) {
-      print('Erreur détection OpenCV: $e');
+      debugPrint('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,
-  }) {
+      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(
@@ -352,13 +437,13 @@ class TargetDetectionService {
       return impacts.map((impact) {
         final score = targetType == TargetType.concentric
             ? _calculateConcentricScoreWithRings(
-                impact.x,
-                impact.y,
-                centerX,
-                centerY,
-                radius,
-                ringCount,
-              )
+          impact.x,
+          impact.y,
+          centerX,
+          centerY,
+          radius,
+          ringCount,
+        )
             : _calculateSilhouetteScore(impact.x, impact.y, centerX, centerY);
 
         return DetectedImpactResult(
@@ -369,9 +454,8 @@ class TargetDetectionService {
         );
       }).toList();
     } catch (e) {
-      print('Erreur détection OpenCV depuis références: $e');
+      debugPrint('Erreur détection OpenCV depuis références: $e');
       return [];
     }
   }
-
-}
+}

lib/services/target_rectify_service.dart

@@ -0,0 +1,259 @@
+import 'dart:async';
+import 'dart:math' as math;
+import 'package:flutter/foundation.dart';
+import 'package:opencv_dart/opencv_dart.dart' as cv;
+
+/// Résultat d'une tentative de redressement de cible.
+class RectifyResult {
+  /// Chemin du fichier image redressé (ou original si échec).
+  final String outputPath;
+
+  /// true si une cible a été détectée et redressée, false si on a renvoyé
+  /// l'image d'origine sans transformation.
+  final bool rectified;
+
+  /// Angle d'inclinaison estimé de la cible AVANT redressement, en degrés.
+  /// (0 = déjà de face). Utile pour informer l'utilisateur.
+  final double estimatedTiltDegrees;
+
+  /// Message de diagnostic (utile pour debug / affichage).
+  final String message;
+
+  const RectifyResult({
+    required this.outputPath,
+    required this.rectified,
+    required this.estimatedTiltDegrees,
+    required this.message,
+  });
+}
+
+/// Service qui redresse une cible RONDE (cercles concentriques) photographiée
+/// de biais, en la ramenant parfaitement de face.
+///
+/// Principe :
+///   1. Détecter le plus grand contour ~circulaire de l'image.
+///   2. Ajuster une ELLIPSE sur ce contour (fitEllipse).
+///   3. Un cercle vu en perspective devient une ellipse : on calcule la
+///      transformation de perspective qui remappe cette ellipse vers un
+///      CERCLE parfait, et on l'applique à toute l'image.
+///   4. La cible apparaît alors de face.
+///
+/// L'image résultat est carrée et centrée sur la cible.
+class TargetRectifyService {
+  /// Taille (en pixels) du côté de l'image carrée de sortie.
+  final int outputSize;
+
+  /// Marge autour de la cible dans l'image de sortie (1.0 = cible pile au bord,
+  /// 1.3 = 30 % de marge autour). Garde un peu de contexte.
+  final double marginFactor;
+
+  /// En dessous de cet écart d'axes (ratio petit/grand axe proche de 1),
+  /// la cible est considérée déjà de face → pas de warp inutile.
+  final double minTiltRatioToRectify;
+
+  TargetRectifyService({
+    this.outputSize = 1024,
+    this.marginFactor = 1.25,
+    this.minTiltRatioToRectify = 0.985,
+  });
+
+  /// Redresse l'image située à [inputPath]. Écrit le résultat dans
+  /// [outputPath] et renvoie un [RectifyResult].
+  ///
+  /// Ne bloque jamais : en cas d'échec de détection, renvoie l'image
+  /// d'origine (rectified = false) pour ne pas perdre la photo du tireur.
+  Future<RectifyResult> rectify({
+    required String inputPath,
+    required String outputPath,
+  }) async {
+    cv.Mat? src;
+    cv.Mat? gray;
+    cv.Mat? blurred;
+    cv.Mat? edges;
+    try {
+      src = cv.imread(inputPath, flags: cv.IMREAD_COLOR);
+      if (src.isEmpty) {
+        return RectifyResult(
+          outputPath: inputPath,
+          rectified: false,
+          estimatedTiltDegrees: 0,
+          message: 'Image illisible',
+        );
+      }
+
+      // ── 1. Prétraitement ────────────────────────────────────────────────
+      gray = cv.cvtColor(src, cv.COLOR_BGR2GRAY);
+      blurred = cv.gaussianBlur(gray, (5, 5), 2, sigmaY: 2);
+      edges = cv.canny(blurred, 60, 160);
+
+      // Dilatation légère pour fermer les contours brisés
+      final cv.Mat kernel = cv.getStructuringElement(
+        cv.MORPH_ELLIPSE,
+        (3, 3),
+      );
+      final cv.Mat dilated = cv.dilate(edges, kernel);
+
+      // ── 2. Recherche du meilleur contour elliptique ──────────────────────
+      final (contours, _) = cv.findContours(
+        dilated,
+        cv.RETR_EXTERNAL,
+        cv.CHAIN_APPROX_SIMPLE,
+      );
+
+      final double imgArea = (src.width * src.height).toDouble();
+      cv.RotatedRect? bestEllipse;
+      double bestScore = 0;
+
+      for (int i = 0; i < contours.length; i++) {
+        final c = contours[i];
+        if (c.length < 5) continue; // fitEllipse exige >= 5 points
+
+        final double area = cv.contourArea(c);
+        // On ignore les contours minuscules et ceux qui couvrent presque tout
+        if (area < imgArea * 0.03 || area > imgArea * 0.97) continue;
+
+        final cv.RotatedRect e = cv.fitEllipse(c);
+        final ep = e.points; // 4 sommets
+        if (ep.length < 4) continue;
+        final double ecx = (ep[0].x + ep[1].x + ep[2].x + ep[3].x) / 4.0;
+        final double ecy = (ep[0].y + ep[1].y + ep[2].y + ep[3].y) / 4.0;
+        final double mAx = (ep[0].x + ep[1].x) / 2.0;
+        final double mAy = (ep[0].y + ep[1].y) / 2.0;
+        final double mBx = (ep[1].x + ep[2].x) / 2.0;
+        final double mBy = (ep[1].y + ep[2].y) / 2.0;
+        final double w =
+            2 * math.sqrt(math.pow(mAx - ecx, 2) + math.pow(mAy - ecy, 2));
+        final double h =
+            2 * math.sqrt(math.pow(mBx - ecx, 2) + math.pow(mBy - ecy, 2));
+        if (w <= 1 || h <= 1) continue;
+
+        // À quel point le contour ressemble-t-il vraiment à son ellipse ?
+        // On compare l'aire du contour à l'aire de l'ellipse ajustée.
+        final double ellipseArea = math.pi * (w / 2) * (h / 2);
+        if (ellipseArea <= 0) continue;
+        final double fitRatio = area / ellipseArea; // ~1 si bon ajustement
+        if (fitRatio < 0.7 || fitRatio > 1.3) continue;
+
+        // Score = taille de l'ellipse (on veut la cible la plus grande)
+        final double score = ellipseArea;
+        if (score > bestScore) {
+          bestScore = score;
+          bestEllipse = e;
+        }
+      }
+
+      if (bestEllipse == null) {
+        return RectifyResult(
+          outputPath: inputPath,
+          rectified: false,
+          estimatedTiltDegrees: 0,
+          message: 'Aucune cible circulaire détectée',
+        );
+      }
+
+      // ── 3. Extraire les 4 sommets de l'ellipse (robuste à la version d'API) ─
+      // RotatedRect.points renvoie les 4 coins de la boîte englobant l'ellipse.
+      // On en dérive nous-mêmes le centre, les demi-axes et l'orientation, ce
+      // qui évite de dépendre de la forme exacte de `.size` / `.center`
+      // (record vs objet) qui varie selon les versions d'opencv_dart.
+      final pts = bestEllipse.points; // List<Point2f> de 4 sommets
+
+      double px(int i) => pts[i].x;
+      double py(int i) => pts[i].y;
+
+      // Centre = moyenne des 4 sommets
+      final double cx = (px(0) + px(1) + px(2) + px(3)) / 4.0;
+      final double cy = (py(0) + py(1) + py(2) + py(3)) / 4.0;
+
+      // Milieux de deux côtés adjacents → extrémités des deux demi-axes
+      // Côté 0-1 et côté 1-2 (ordre des sommets d'un RotatedRect)
+      final double m01x = (px(0) + px(1)) / 2.0;
+      final double m01y = (py(0) + py(1)) / 2.0;
+      final double m12x = (px(1) + px(2)) / 2.0;
+      final double m12y = (py(1) + py(2)) / 2.0;
+
+      // Demi-axes = distance centre → milieu de chaque côté
+      final double axisA =
+          math.sqrt(math.pow(m01x - cx, 2) + math.pow(m01y - cy, 2));
+      final double axisB =
+          math.sqrt(math.pow(m12x - cx, 2) + math.pow(m12y - cy, 2));
+
+      final double majorAxis = math.max(axisA, axisB);
+      final double minorAxis = math.min(axisA, axisB);
+      if (majorAxis <= 1) {
+        return RectifyResult(
+          outputPath: inputPath,
+          rectified: false,
+          estimatedTiltDegrees: 0,
+          message: 'Ellipse dégénérée',
+        );
+      }
+
+      final double axisRatio = minorAxis / majorAxis; // 1 = cercle parfait
+      final double tiltDeg =
+          math.acos(axisRatio.clamp(0.0, 1.0)) * (180.0 / math.pi);
+
+      // Déjà quasiment de face → on ne touche pas (évite le flou inutile)
+      if (axisRatio >= minTiltRatioToRectify) {
+        cv.imwrite(outputPath, src);
+        return RectifyResult(
+          outputPath: outputPath,
+          rectified: false,
+          estimatedTiltDegrees: tiltDeg,
+          message: 'Cible déjà de face',
+        );
+      }
+
+      // ── 4. Construire la transformation de perspective ────────────────────
+      // Source : extrémités des deux axes de l'ellipse (4 points).
+      // Destination : extrémités des axes d'un cercle parfait centré.
+      // On obtient les extrémités en prolongeant centre→milieu-de-côté.
+      final srcPts = cv.VecPoint.fromList([
+        cv.Point((cx + (m01x - cx)).round(), (cy + (m01y - cy)).round()),
+        cv.Point((cx - (m01x - cx)).round(), (cy - (m01y - cy)).round()),
+        cv.Point((cx + (m12x - cx)).round(), (cy + (m12y - cy)).round()),
+        cv.Point((cx - (m12x - cx)).round(), (cy - (m12y - cy)).round()),
+      ]);
+
+      // Cible : cercle parfait centré, rayon R, dans une image carrée.
+      // L'axe "A" (m01) devient l'axe horizontal, l'axe "B" (m12) le vertical.
+      final double out = outputSize.toDouble();
+      final double center = out / 2;
+      final double radius = (out / 2) / marginFactor;
+      final dstPts = cv.VecPoint.fromList([
+        cv.Point((center + radius).round(), center.round()),
+        cv.Point((center - radius).round(), center.round()),
+        cv.Point(center.round(), (center + radius).round()),
+        cv.Point(center.round(), (center - radius).round()),
+      ]);
+
+      final cv.Mat transform = cv.getPerspectiveTransform(srcPts, dstPts);
+
+      final cv.Mat warped = cv.warpPerspective(
+        src,
+        transform,
+        (outputSize, outputSize),
+        flags: cv.INTER_LINEAR,
+        borderMode: cv.BORDER_CONSTANT,
+      );
+
+      cv.imwrite(outputPath, warped);
+
+      return RectifyResult(
+        outputPath: outputPath,
+        rectified: true,
+        estimatedTiltDegrees: tiltDeg,
+        message: 'Cible redressée (inclinaison ${tiltDeg.toStringAsFixed(1)}°)',
+      );
+    } catch (e) {
+      debugPrint('TargetRectify erreur: $e');
+      // En cas de pépin, on renvoie l'original pour ne jamais perdre la photo
+      return RectifyResult(
+        outputPath: inputPath,
+        rectified: false,
+        estimatedTiltDegrees: 0,
+        message: 'Erreur de traitement: $e',
+      );
+    }
+  }
+}

lib/services/wallet_identity_service.dart

@@ -4,6 +4,7 @@ import 'package:crypto/crypto.dart';
 import 'package:shared_preferences/shared_preferences.dart';
 import 'package:device_info_plus/device_info_plus.dart';
 import 'dart:io';
+import 'package:flutter/foundation.dart';
 
 class WalletIdentityService {
   static const String _prefsKey = 'wallet_identity_phrase';
@@ -86,7 +87,7 @@ class WalletIdentityService {
         deviceId = windowsInfo.deviceId;
       }
     } catch (e) {
-      print('Erreur lecture device ID: $e');
+      debugPrint('Erreur lecture device ID: $e');
     }
     
     // Add a salt to the device ID

linux/flutter/generated_plugins.cmake

@@ -7,6 +7,7 @@ list(APPEND FLUTTER_PLUGIN_LIST
 )
 
 list(APPEND FLUTTER_FFI_PLUGIN_LIST
+  jni
 )
 
 set(PLUGIN_BUNDLED_LIBRARIES)

macos/Flutter/GeneratedPluginRegistrant.swift

@@ -7,14 +7,12 @@ import Foundation
 
 import device_info_plus
 import file_selector_macos
-import path_provider_foundation
 import shared_preferences_foundation
 import sqflite_darwin
 
 func RegisterGeneratedPlugins(registry: FlutterPluginRegistry) {
   DeviceInfoPlusMacosPlugin.register(with: registry.registrar(forPlugin: "DeviceInfoPlusMacosPlugin"))
   FileSelectorPlugin.register(with: registry.registrar(forPlugin: "FileSelectorPlugin"))
-  PathProviderPlugin.register(with: registry.registrar(forPlugin: "PathProviderPlugin"))
   SharedPreferencesPlugin.register(with: registry.registrar(forPlugin: "SharedPreferencesPlugin"))
   SqflitePlugin.register(with: registry.registrar(forPlugin: "SqflitePlugin"))
 }

pubspec.lock

@@ -5,18 +5,26 @@ packages:
     dependency: transitive
     description:
       name: archive
-      sha256: "2fde1607386ab523f7a36bb3e7edb43bd58e6edaf2ffb29d8a6d578b297fdbbd"
+      sha256: a96e8b390886ee8abb49b7bd3ac8df6f451c621619f52a26e815fdcf568959ff
       url: "https://pub.dev"
     source: hosted
-    version: "4.0.7"
+    version: "4.0.9"
+  args:
+    dependency: transitive
+    description:
+      name: args
+      sha256: d0481093c50b1da8910eb0bb301626d4d8eb7284aa739614d2b394ee09e3ea04
+      url: "https://pub.dev"
+    source: hosted
+    version: "2.7.0"
   async:
     dependency: transitive
     description:
       name: async
-      sha256: "758e6d74e971c3e5aceb4110bfd6698efc7f501675bcfe0c775459a8140750eb"
+      sha256: e2eb0491ba5ddb6177742d2da23904574082139b07c1e33b8503b9f46f3e1a37
       url: "https://pub.dev"
     source: hosted
-    version: "2.13.0"
+    version: "2.13.1"
   boolean_selector:
     dependency: transitive
     description:
@@ -25,6 +33,46 @@ packages:
       url: "https://pub.dev"
     source: hosted
     version: "2.1.2"
+  camera:
+    dependency: "direct main"
+    description:
+      name: camera
+      sha256: "034c38cb8014d29698dcae6d20276688a1bf74e6487dfeb274d70ea05d5f7777"
+      url: "https://pub.dev"
+    source: hosted
+    version: "0.12.0+1"
+  camera_android_camerax:
+    dependency: transitive
+    description:
+      name: camera_android_camerax
+      sha256: b5064cf25a2787d122d0bf12e77c7b1033a2b983d0730e3091f770ee376efde5
+      url: "https://pub.dev"
+    source: hosted
+    version: "0.7.2"
+  camera_avfoundation:
+    dependency: transitive
+    description:
+      name: camera_avfoundation
+      sha256: "90e4cc3fde331581a3b2d35d83be41dbb7393af0ab857eb27b732174289cb96d"
+      url: "https://pub.dev"
+    source: hosted
+    version: "0.10.1"
+  camera_platform_interface:
+    dependency: transitive
+    description:
+      name: camera_platform_interface
+      sha256: "7ac852d77699acee79f0d438b793feee26721841e50973576419ff5c6d95e9b7"
+      url: "https://pub.dev"
+    source: hosted
+    version: "2.13.0"
+  camera_web:
+    dependency: transitive
+    description:
+      name: camera_web
+      sha256: "57f49a635c8bf249d07fb95eb693d7e4dda6796dedb3777f9127fb54847beba7"
+      url: "https://pub.dev"
+    source: hosted
+    version: "0.3.5+3"
   change_case:
     dependency: transitive
     description:
@@ -37,10 +85,10 @@ packages:
     dependency: transitive
     description:
       name: characters
-      sha256: faf38497bda5ead2a8c7615f4f7939df04333478bf32e4173fcb06d428b5716b
+      sha256: f71061c654a3380576a52b451dd5532377954cf9dbd272a78fc8479606670803
       url: "https://pub.dev"
     source: hosted
-    version: "1.4.1"
+    version: "1.4.0"
   clock:
     dependency: transitive
     description:
@@ -85,18 +133,18 @@ packages:
     dependency: "direct main"
     description:
       name: cupertino_icons
-      sha256: ba631d1c7f7bef6b729a622b7b752645a2d076dba9976925b8f25725a30e1ee6
+      sha256: "41e005c33bd814be4d3096aff55b1908d419fde52ca656c8c47719ec745873cd"
       url: "https://pub.dev"
     source: hosted
-    version: "1.0.8"
+    version: "1.0.9"
   dartcv4:
     dependency: transitive
     description:
       name: dartcv4
-      sha256: "43dba49162662f3b6e3daf5a95d071429365e2f1ada67d412b851fc9be442e58"
+      sha256: "5764d13550055da3bb35ca28e6866b837579dfb4b594582b7a7753785ca5dfef"
       url: "https://pub.dev"
     source: hosted
-    version: "2.2.1+1"
+    version: "2.2.1+4"
   device_info_plus:
     dependency: "direct main"
     description:
@@ -197,10 +245,10 @@ packages:
     dependency: "direct main"
     description:
       name: fl_chart
-      sha256: "00b74ae680df6b1135bdbea00a7d1fc072a9180b7c3f3702e4b19a9943f5ed7d"
+      sha256: b938f77d042cbcd822936a7a359a7235bad8bd72070de1f827efc2cc297ac888
       url: "https://pub.dev"
     source: hosted
-    version: "0.66.2"
+    version: "1.2.0"
   flutter:
     dependency: "direct main"
     description: flutter
@@ -214,14 +262,19 @@ packages:
       url: "https://pub.dev"
     source: hosted
     version: "6.0.0"
+  flutter_localizations:
+    dependency: "direct main"
+    description: flutter
+    source: sdk
+    version: "0.0.0"
   flutter_plugin_android_lifecycle:
     dependency: transitive
     description:
       name: flutter_plugin_android_lifecycle
-      sha256: ee8068e0e1cd16c4a82714119918efdeed33b3ba7772c54b5d094ab53f9b7fd1
+      sha256: "38d1c268de9097ff59cf0e844ac38759fc78f76836d37edad06fa21e182055a0"
       url: "https://pub.dev"
     source: hosted
-    version: "2.0.33"
+    version: "2.0.34"
   flutter_test:
     dependency: "direct dev"
     description: flutter
@@ -240,6 +293,14 @@ packages:
       url: "https://pub.dev"
     source: hosted
     version: "2.1.3"
+  google_mlkit_commons:
+    dependency: transitive
+    description:
+      name: google_mlkit_commons
+      sha256: "3e69fea4211727732cc385104e675ad1e40b29f12edd492ee52fa108423a6124"
+      url: "https://pub.dev"
+    source: hosted
+    version: "0.11.1"
   google_mlkit_document_scanner:
     dependency: "direct main"
     description:
@@ -248,14 +309,22 @@ packages:
       url: "https://pub.dev"
     source: hosted
     version: "0.2.1"
+  google_mlkit_object_detection:
+    dependency: "direct main"
+    description:
+      name: google_mlkit_object_detection
+      sha256: "9dd35886972e18747e22098f8ebee78d30716a99a789bb2e3a65a24229e031e7"
+      url: "https://pub.dev"
+    source: hosted
+    version: "0.15.1"
   hooks:
     dependency: transitive
     description:
       name: hooks
-      sha256: "5d309c86e7ce34cd8e37aa71cb30cb652d3829b900ab145e4d9da564b31d59f7"
+      sha256: "025f060e86d2d4c3c47b56e33caf7f93bf9283340f26d23424ebcfccf34f621e"
       url: "https://pub.dev"
     source: hosted
-    version: "1.0.0"
+    version: "1.0.3"
   http:
     dependency: "direct main"
     description:
@@ -276,26 +345,26 @@ packages:
     dependency: "direct main"
     description:
       name: image
-      sha256: "492bd52f6c4fbb6ee41f781ff27765ce5f627910e1e0cbecfa3d9add5562604c"
+      sha256: f9881ff4998044947ec38d098bc7c8316ae1186fa786eddffdb867b9bc94dfce
       url: "https://pub.dev"
     source: hosted
-    version: "4.7.2"
+    version: "4.8.0"
   image_picker:
     dependency: "direct main"
     description:
       name: image_picker
-      sha256: "784210112be18ea55f69d7076e2c656a4e24949fa9e76429fe53af0c0f4fa320"
+      sha256: "91c025426c2881c551100bce834e201c835a170151545f58d17da5180ca7d9ac"
       url: "https://pub.dev"
     source: hosted
-    version: "1.2.1"
+    version: "1.2.2"
   image_picker_android:
     dependency: transitive
     description:
       name: image_picker_android
-      sha256: "518a16108529fc18657a3e6dde4a043dc465d16596d20ab2abd49a4cac2e703d"
+      sha256: d5b3e1774af29c9ab00103afb0d4614070f924d2e0057ac867ec98800114793f
       url: "https://pub.dev"
     source: hosted
-    version: "0.8.13+13"
+    version: "0.8.13+17"
   image_picker_for_web:
     dependency: transitive
     description:
@@ -348,10 +417,26 @@ packages:
     dependency: "direct main"
     description:
       name: intl
-      sha256: d6f56758b7d3014a48af9701c085700aac781a92a87a62b1333b46d8879661cf
+      sha256: "3df61194eb431efc39c4ceba583b95633a403f46c9fd341e550ce0bfa50e9aa5"
       url: "https://pub.dev"
     source: hosted
-    version: "0.19.0"
+    version: "0.20.2"
+  jni:
+    dependency: transitive
+    description:
+      name: jni
+      sha256: c2230682d5bc2362c1c9e8d3c7f406d9cbba23ab3f2e203a025dd47e0fb2e68f
+      url: "https://pub.dev"
+    source: hosted
+    version: "1.0.0"
+  jni_flutter:
+    dependency: transitive
+    description:
+      name: jni_flutter
+      sha256: "8b59e590786050b1cd866677dddaf76b1ade5e7bc751abe04b86e84d379d3ba6"
+      url: "https://pub.dev"
+    source: hosted
+    version: "1.0.1"
   leak_tracker:
     dependency: transitive
     description:
@@ -380,10 +465,10 @@ packages:
     dependency: transitive
     description:
       name: lints
-      sha256: a5e2b223cb7c9c8efdc663ef484fdd95bb243bff242ef5b13e26883547fce9a0
+      sha256: "12f842a479589fea194fe5c5a3095abc7be0c1f2ddfa9a0e76aed1dbd26a87df"
       url: "https://pub.dev"
     source: hosted
-    version: "6.0.0"
+    version: "6.1.0"
   logging:
     dependency: transitive
     description:
@@ -396,26 +481,26 @@ packages:
     dependency: transitive
     description:
       name: matcher
-      sha256: "12956d0ad8390bbcc63ca2e1469c0619946ccb52809807067a7020d57e647aa6"
+      sha256: dc58c723c3c24bf8d3e2d3ad3f2f9d7bd9cf43ec6feaa64181775e60190153f2
       url: "https://pub.dev"
     source: hosted
-    version: "0.12.18"
+    version: "0.12.17"
   material_color_utilities:
     dependency: transitive
     description:
       name: material_color_utilities
-      sha256: "9c337007e82b1889149c82ed242ed1cb24a66044e30979c44912381e9be4c48b"
+      sha256: f7142bb1154231d7ea5f96bc7bde4bda2a0945d2806bb11670e30b850d56bdec
       url: "https://pub.dev"
     source: hosted
-    version: "0.13.0"
+    version: "0.11.1"
   meta:
     dependency: transitive
     description:
       name: meta
-      sha256: "1741988757a65eb6b36abe716829688cf01910bbf91c34354ff7ec1c3de2b349"
+      sha256: "23f08335362185a5ea2ad3a4e597f1375e78bce8a040df5c600c8d3552ef2394"
       url: "https://pub.dev"
     source: hosted
-    version: "1.18.0"
+    version: "1.17.0"
   mime:
     dependency: transitive
     description:
@@ -428,18 +513,18 @@ packages:
     dependency: transitive
     description:
       name: native_toolchain_c
-      sha256: "89e83885ba09da5fdf2cdacc8002a712ca238c28b7f717910b34bcd27b0d03ac"
+      sha256: "6ba77bb18063eebe9de401f5e6437e95e1438af0a87a3a39084fbd37c90df572"
       url: "https://pub.dev"
     source: hosted
-    version: "0.17.4"
+    version: "0.17.6"
   native_toolchain_cmake:
     dependency: transitive
     description:
       name: native_toolchain_cmake
-      sha256: fe40e8483183ced98e851e08a9cd2a547fd412cccab98277aa23f2377e43d66f
+      sha256: cd4865568c57f03c7ab1f138cc5032c5f77825d27083d6f5a3e9bbb3e8014a87
       url: "https://pub.dev"
     source: hosted
-    version: "0.2.4"
+    version: "0.2.5"
   nested:
     dependency: transitive
     description:
@@ -448,14 +533,30 @@ packages:
       url: "https://pub.dev"
     source: hosted
     version: "1.0.0"
+  objective_c:
+    dependency: transitive
+    description:
+      name: objective_c
+      sha256: "100a1c87616ab6ed41ec263b083c0ef3261ee6cd1dc3b0f35f8ddfa4f996fe52"
+      url: "https://pub.dev"
+    source: hosted
+    version: "9.3.0"
   opencv_dart:
     dependency: "direct main"
     description:
       name: opencv_dart
-      sha256: c2b7cc614cad69c2857e9b684e3066af662a03fe7100f4dc9a630e81ad42103a
+      sha256: b50ea4788e6d61df6369874e0244445d98ef9210dbb90b8d3c1df198b4ee2333
       url: "https://pub.dev"
     source: hosted
-    version: "2.2.1+1"
+    version: "2.2.1+4"
+  package_config:
+    dependency: transitive
+    description:
+      name: package_config
+      sha256: f096c55ebb7deb7e384101542bfba8c52696c1b56fca2eb62827989ef2353bbc
+      url: "https://pub.dev"
+    source: hosted
+    version: "2.2.0"
   path:
     dependency: "direct main"
     description:
@@ -476,18 +577,18 @@ packages:
     dependency: transitive
     description:
       name: path_provider_android
-      sha256: f2c65e21139ce2c3dad46922be8272bb5963516045659e71bb16e151c93b580e
+      sha256: "69cbd515a62b94d32a7944f086b2f82b4ac40a1d45bebfc00813a430ab2dabcd"
       url: "https://pub.dev"
     source: hosted
-    version: "2.2.22"
+    version: "2.3.1"
   path_provider_foundation:
     dependency: transitive
     description:
       name: path_provider_foundation
-      sha256: "6d13aece7b3f5c5a9731eaf553ff9dcbc2eff41087fd2df587fd0fed9a3eb0c4"
+      sha256: "2a376b7d6392d80cd3705782d2caa734ca4727776db0b6ec36ef3f1855197699"
       url: "https://pub.dev"
     source: hosted
-    version: "2.5.1"
+    version: "2.6.0"
   path_provider_linux:
     dependency: transitive
     description:
@@ -512,14 +613,62 @@ packages:
       url: "https://pub.dev"
     source: hosted
     version: "2.3.0"
+  permission_handler:
+    dependency: "direct main"
+    description:
+      name: permission_handler
+      sha256: bc917da36261b00137bbc8896bf1482169cd76f866282368948f032c8c1caae1
+      url: "https://pub.dev"
+    source: hosted
+    version: "12.0.1"
+  permission_handler_android:
+    dependency: transitive
+    description:
+      name: permission_handler_android
+      sha256: "1e3bc410ca1bf84662104b100eb126e066cb55791b7451307f9708d4007350e6"
+      url: "https://pub.dev"
+    source: hosted
+    version: "13.0.1"
+  permission_handler_apple:
+    dependency: transitive
+    description:
+      name: permission_handler_apple
+      sha256: f000131e755c54cf4d84a5d8bd6e4149e262cc31c5a8b1d698de1ac85fa41023
+      url: "https://pub.dev"
+    source: hosted
+    version: "9.4.7"
+  permission_handler_html:
+    dependency: transitive
+    description:
+      name: permission_handler_html
+      sha256: "38f000e83355abb3392140f6bc3030660cfaef189e1f87824facb76300b4ff24"
+      url: "https://pub.dev"
+    source: hosted
+    version: "0.1.3+5"
+  permission_handler_platform_interface:
+    dependency: transitive
+    description:
+      name: permission_handler_platform_interface
+      sha256: eb99b295153abce5d683cac8c02e22faab63e50679b937fa1bf67d58bb282878
+      url: "https://pub.dev"
+    source: hosted
+    version: "4.3.0"
+  permission_handler_windows:
+    dependency: transitive
+    description:
+      name: permission_handler_windows
+      sha256: "1a790728016f79a41216d88672dbc5df30e686e811ad4e698bfc51f76ad91f1e"
+      url: "https://pub.dev"
+    source: hosted
+    version: "0.2.1"
   petitparser:
     dependency: transitive
     description:
       name: petitparser
-      sha256: "1a97266a94f7350d30ae522c0af07890c70b8e62c71e8e3920d1db4d23c057d1"
+      sha256: "91bd59303e9f769f108f8df05e371341b15d59e995e6806aefab827b58336675"
       url: "https://pub.dev"
     source: hosted
-    version: "7.0.1"
+    version: "7.0.2"
   platform:
     dependency: transitive
     description:
@@ -540,10 +689,10 @@ packages:
     dependency: transitive
     description:
       name: posix
-      sha256: "6323a5b0fa688b6a010df4905a56b00181479e6d10534cecfecede2aa55add61"
+      sha256: "185ef7606574f789b40f289c233efa52e96dead518aed988e040a10737febb07"
       url: "https://pub.dev"
     source: hosted
-    version: "6.0.3"
+    version: "6.5.0"
   provider:
     dependency: "direct main"
     description:
@@ -560,6 +709,30 @@ packages:
       url: "https://pub.dev"
     source: hosted
     version: "2.2.0"
+  record_use:
+    dependency: transitive
+    description:
+      name: record_use
+      sha256: "2551bd8eecfe95d14ae75f6021ad0248be5c27f138c2ec12fcb52b500b3ba1ed"
+      url: "https://pub.dev"
+    source: hosted
+    version: "0.6.0"
+  sensors_plus:
+    dependency: "direct main"
+    description:
+      name: sensors_plus
+      sha256: "8e7fa79b4940442bb595bfc0ee9da4af5a22a0fe6ebacc74998245ee9496a82d"
+      url: "https://pub.dev"
+    source: hosted
+    version: "4.0.2"
+  sensors_plus_platform_interface:
+    dependency: transitive
+    description:
+      name: sensors_plus_platform_interface
+      sha256: bc472d6cfd622acb4f020e726433ee31788b038056691ba433fec80e448a094f
+      url: "https://pub.dev"
+    source: hosted
+    version: "1.2.0"
   shared_preferences:
     dependency: "direct main"
     description:
@@ -625,42 +798,42 @@ packages:
     dependency: transitive
     description:
       name: source_span
-      sha256: "254ee5351d6cb365c859e20ee823c3bb479bf4a293c22d17a9f1bf144ce86f7c"
+      sha256: "56a02f1f4cd1a2d96303c0144c93bd6d909eea6bee6bf5a0e0b685edbd4c47ab"
       url: "https://pub.dev"
     source: hosted
-    version: "1.10.1"
+    version: "1.10.2"
   sqflite:
     dependency: "direct main"
     description:
       name: sqflite
-      sha256: e2297b1da52f127bc7a3da11439985d9b536f75070f3325e62ada69a5c585d03
+      sha256: "564cfed0746fe53140c23b70b308e045c3b31f17778f2f326ccb7d804ea0250a"
       url: "https://pub.dev"
     source: hosted
-    version: "2.4.2"
+    version: "2.4.2+1"
   sqflite_android:
     dependency: transitive
     description:
       name: sqflite_android
-      sha256: ecd684501ebc2ae9a83536e8b15731642b9570dc8623e0073d227d0ee2bfea88
+      sha256: "881e28efdcc9950fd8e9bb42713dcf1103e62a2e7168f23c9338d82db13dec40"
       url: "https://pub.dev"
     source: hosted
-    version: "2.4.2+2"
+    version: "2.4.2+3"
   sqflite_common:
     dependency: transitive
     description:
       name: sqflite_common
-      sha256: "6ef422a4525ecc601db6c0a2233ff448c731307906e92cabc9ba292afaae16a6"
+      sha256: f8a08a13fb8f0f8c590df89d745000bed44a673ed94bac846739e1a016875c21
       url: "https://pub.dev"
     source: hosted
-    version: "2.5.6"
+    version: "2.5.7"
   sqflite_common_ffi:
     dependency: "direct main"
     description:
       name: sqflite_common_ffi
-      sha256: c59fcdc143839a77581f7a7c4de018e53682408903a0a0800b95ef2dc4033eff
+      sha256: cd0c7f7de39a08f2d54ef144d9058c46eca8461879aaa648025643455c1e5a20
       url: "https://pub.dev"
     source: hosted
-    version: "2.4.0+2"
+    version: "2.4.0+3"
   sqflite_darwin:
     dependency: transitive
     description:
@@ -681,10 +854,10 @@ packages:
     dependency: transitive
     description:
       name: sqlite3
-      sha256: "00e5e65f8e9b556ed3d999ad310881c956ffb656ed96bea487a4c50ffdff6d14"
+      sha256: "56da3e13ed7d28a66f930aa2b2b29db6736a233f08283326e96321dd812030f5"
       url: "https://pub.dev"
     source: hosted
-    version: "3.1.3"
+    version: "3.3.1"
   stack_trace:
     dependency: transitive
     description:
@@ -701,6 +874,14 @@ packages:
       url: "https://pub.dev"
     source: hosted
     version: "2.1.4"
+  stream_transform:
+    dependency: transitive
+    description:
+      name: stream_transform
+      sha256: ad47125e588cfd37a9a7f86c7d6356dde8dfe89d071d293f80ca9e9273a33871
+      url: "https://pub.dev"
+    source: hosted
+    version: "2.1.1"
   string_scanner:
     dependency: transitive
     description:
@@ -729,10 +910,10 @@ packages:
     dependency: transitive
     description:
       name: test_api
-      sha256: "93167629bfc610f71560ab9312acdda4959de4df6fac7492c89ff0d3886f6636"
+      sha256: ab2726c1a94d3176a45960b6234466ec367179b87dd74f1611adb1f3b5fb9d55
       url: "https://pub.dev"
     source: hosted
-    version: "0.7.9"
+    version: "0.7.7"
   typed_data:
     dependency: transitive
     description:
@@ -745,10 +926,10 @@ packages:
     dependency: "direct main"
     description:
       name: uuid
-      sha256: a11b666489b1954e01d992f3d601b1804a33937b5a8fe677bd26b8a9f96f96e8
+      sha256: "1fef9e8e11e2991bb773070d4656b7bd5d850967a2456cfc83cf47925ba79489"
       url: "https://pub.dev"
     source: hosted
-    version: "4.5.2"
+    version: "4.5.3"
   vector_math:
     dependency: transitive
     description:
@@ -761,10 +942,10 @@ packages:
     dependency: transitive
     description:
       name: vm_service
-      sha256: "45caa6c5917fa127b5dbcfbd1fa60b14e583afdc08bfc96dda38886ca252eb60"
+      sha256: "0016aef94fc66495ac78af5859181e3f3bf2026bd8eecc72b9565601e19ab360"
       url: "https://pub.dev"
     source: hosted
-    version: "15.0.2"
+    version: "15.2.0"
   web:
     dependency: transitive
     description:
@@ -777,10 +958,10 @@ packages:
     dependency: transitive
     description:
       name: win32
-      sha256: ba7d5750e3441caa1bbe31d9e516348fcf8dfcb32aa29ef87a844a59f4d1f1d0
+      sha256: a1fc9eb9248baa05dfc12ed5b66e377b3e23f095eec078e0371622b9033810d9
       url: "https://pub.dev"
     source: hosted
-    version: "6.1.0"
+    version: "6.2.0"
   win32_registry:
     dependency: transitive
     description:
@@ -814,5 +995,5 @@ packages:
     source: hosted
     version: "3.1.3"
 sdks:
-  dart: ">=3.12.0-35.0.dev <4.0.0"
-  flutter: ">=3.38.1"
+  dart: ">=3.10.3 <4.0.0"
+  flutter: ">=3.38.4"

pubspec.yaml

@@ -19,7 +19,7 @@ publish_to: 'none' # Remove this line if you wish to publish to pub.dev
 version: 1.0.0+1
 
 environment:
-  sdk: ^3.12.0-35.0.dev
+  sdk: '>=3.10.0 <4.0.0'
 
 # Dependencies specify other packages that your package needs in order to work.
 # To automatically upgrade your package dependencies to the latest versions
@@ -31,11 +31,14 @@ dependencies:
   flutter:
     sdk: flutter
 
+  flutter_localizations:
+    sdk: flutter
   # The following adds the Cupertino Icons font to your application.
   # Use with the CupertinoIcons class for iOS style icons.
   cupertino_icons: ^1.0.8
-
+  sensors_plus: ^4.0.2
   opencv_dart: ^2.1.0
+  google_mlkit_object_detection: ^0.15.0
 
   # Image capture from camera/gallery
   image_picker: ^1.2.1
@@ -56,17 +59,19 @@ dependencies:
   uuid: ^4.3.3
 
   # Date formatting
-  intl: ^0.19.0
+  intl: ^0.20.2
 
   # Charts for history visualization
-  fl_chart: ^0.66.2
+  fl_chart: ^1.2.0
 
   # Image processing for impact detection
   image: ^4.1.7
+  permission_handler: ^12.0.1
   http: ^1.6.0
   device_info_plus: ^13.1.0
   shared_preferences: ^2.5.5
   crypto: ^3.0.7
+  camera: ^0.12.0+1
 
   # Machine Learning for YOLOv8
   # tflite_flutter: ^0.11.0

windows/flutter/generated_plugin_registrant.cc

@@ -7,8 +7,11 @@
 #include "generated_plugin_registrant.h"
 
 #include <file_selector_windows/file_selector_windows.h>
+#include <permission_handler_windows/permission_handler_windows_plugin.h>
 
 void RegisterPlugins(flutter::PluginRegistry* registry) {
   FileSelectorWindowsRegisterWithRegistrar(
       registry->GetRegistrarForPlugin("FileSelectorWindows"));
+  PermissionHandlerWindowsPluginRegisterWithRegistrar(
+      registry->GetRegistrarForPlugin("PermissionHandlerWindowsPlugin"));
 }

windows/flutter/generated_plugins.cmake

@@ -4,9 +4,11 @@
 
 list(APPEND FLUTTER_PLUGIN_LIST
   file_selector_windows
+  permission_handler_windows
 )
 
 list(APPEND FLUTTER_FFI_PLUGIN_LIST
+  jni
 )
 
 set(PLUGIN_BUNDLED_LIBRARIES)