fix: recentrage incorrect si loin du centre d origine

lib/services/image_crop_service.dart

@@ -98,11 +98,122 @@ void _cropIsolateEntry(_CropParams params) {
   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 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.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, exprimé en pixels source (rotation = même échelle)
+  final int side = math.max(1, (p.cropSizeDisplay / f).round());
+
+  // Centre de la fenêtre de visée, en pixels de l'image (rotated) :
+  // le centre de l'image est affiché à (centre_viewport + offset), la fenêtre
+  // est centrée sur le viewport → décalage de -offset/f par rapport au centre.
+  final double cropCenterX = rotated.width / 2 - p.offsetDx / f;
+  final double cropCenterY = rotated.height / 2 - p.offsetDy / f;
+
+  final int srcX = (cropCenterX - side / 2).round();
+  final int srcY = (cropCenterY - side / 2).round();
+
+  // Toile carrée noire opaque ; compositeImage rogne automatiquement les bords
+  // hors-cadre, donc les débordements restent noirs (padding).
+  final out = img.Image(width: side, height: side, numChannels: 3);
+  img.compositeImage(out, rotated, dstX: -srcX, dstY: -srcY);
+
+  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();
 
   static const int maxOutputSize = 1024;
 
+  /// 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).
+  ///
+  /// - [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 rotationDegrees = 0.0,
+    int outputSize = maxOutputSize,
+  }) async {
+    final tempDir = await getTemporaryDirectory();
+    final outputPath = '${tempDir.path}/cropped_${_uuid.v4()}.jpg';
+
+    final params = _ViewportCropParams(
+      sourcePath: sourcePath,
+      offsetDx: offsetDx,
+      offsetDy: offsetDy,
+      displayPerSourcePx: displayPerSourcePx,
+      cropSizeDisplay: cropSizeDisplay,
+      rotationDegrees: rotationDegrees,
+      outputSize: outputSize,
+      outputPath: outputPath,
+    );
+
+    // Traitement lourd dans un Isolate → thread UI fluide.
+    await Isolate.run(() => _viewportCropIsolateEntry(params));
+
+    return outputPath;
+  }
+
   Future<String> cropToSquare(
       String sourcePath,
       CropRect cropRect, {