@sanctum-key/react-native-sdk 1.0.14 → 1.0.15

package/src/utils/cropByObb.ts

@@ -1,7 +1,6 @@
 import { Image as RNImage, Platform } from 'react-native';
 import * as ImageManipulator from "expo-image-manipulator";
-import { truncateFields } from '../modules/api/KYCService';
-import { logger } from './logger';
+
 
 type Point = [number, number];
 
@@ -30,24 +29,13 @@ export function getObbConfidence(cardObb: any): number | null {
   return typeof score === 'number' ? score : null;
 }
 
-/**
- * Extracts the card_in_frame flag from card_obb when present.
- * Returns:
- * - true  => card fully in frame
- * - false => card not fully in frame
- * - null  => field not present (backward compatibility)
- */
 /**
  * Extracts the framing data from card_obb.
  * STRICT CHECK: Returns true ONLY if card_in_frame is true AND cropped_sides is empty.
- * Returns:
- * - true  => card fully in frame (no sides cropped)
- * - false => card not fully in frame OR edges are cropped
- * - null  => field not present (backward compatibility)
  */
 export function getCardInFrame(cardObb: any): boolean | null {
   if (!cardObb) return null;
-
+  
   // card_obb can be an array of objects or a single object
   const first = Array.isArray(cardObb) ? cardObb[0] : cardObb;
 
@@ -60,11 +48,11 @@ export function getCardInFrame(cardObb: any): boolean | null {
       if (hasCroppedSides) {
         console.warn(`Card is cropped on sides: ${first.cropped_sides.join(', ')}`);
       }
-      return false; 
+      return false;
     }
 
     // If we made it here, card_in_frame is true AND cropped_sides is empty.
-    return true; 
+    return true;
   }
 
   // Backward compatibility check
@@ -101,14 +89,8 @@ async function cropWeb(uri: string, points: Point[]): Promise<string> {
       if (!ctx) return reject(new Error('Canvas context not available'));
       ctx.drawImage(
         img,
-        minX, // sx
-        minY, // sy
-        width, // sw
-        height, // sh
-        0,
-        0,
-        canvas.width,
-        canvas.height
+        minX, minY, width, height, // Source 
+        0, 0, canvas.width, canvas.height // Destination
       );
       resolve(canvas.toDataURL('image/jpeg', 0.92));
     };
@@ -117,10 +99,9 @@ async function cropWeb(uri: string, points: Point[]): Promise<string> {
   });
 }
 
-// Fallback: return original for native (no dependency added); caller can still use bbox to draw overlay
+// Fallback: return original for native
 export async function cropByObb(uri: string, cardObb: any): Promise<{ base64?: string; bbox?: { minX: number; minY: number; width: number; height: number } }> {
   try {
-    // card_obb format: [ [ [p1,p2,p3,p4], score ] ] — if confidence too low, don't crop (send full image)
     const confidence = getObbConfidence(cardObb);
     if (confidence !== null && confidence < OBB_CONFIDENCE_THRESHOLD) {
       return {};
@@ -135,7 +116,7 @@ export async function cropByObb(uri: string, cardObb: any): Promise<{ base64?: s
       const base64 = await cropWeb(uri, points);
       return { base64, bbox: { minX, minY, width, height } };
     }
-    // Native: return bbox only; keep base64 undefined
+    
     return { bbox: { minX, minY, width, height } };
   } catch (e) {
     return {};
@@ -143,112 +124,94 @@ export async function cropByObb(uri: string, cardObb: any): Promise<{ base64?: s
 }
 
 
-
-
-// exemple d'appel :
-export async function cropImageWithBBox(uri: string, bbox: any) {
-  // 1️⃣ Récupère la taille originale de l'image
-  await RNImage.getSize(uri, (width, height) => {
-    console.log("Image originale:", width, height);
-  });
-
-  // // 2️⃣ Suppose que ton bbox vient d'une image affichée dans `displayedSize`
-  // const scaleX = originalWidth / displayedSize.width;
-  // const scaleY = originalHeight / displayedSize.height;
-
-  // 3️⃣ Convertir le bbox à la taille réelle scale 0.10 = 10%
-  const crop = {
-    originX: bbox.minX,
-    originY: bbox.minY,
-    width: bbox.width,
-    height: bbox.height,
-  };
-
-  // 4️⃣ Appliquer le crop
-  // @ts-ignore - manipulateAsync is deprecated but still functional, new API (useImageManipulator) is a React hook and not suitable for utility functions
-  const result = await ImageManipulator.manipulateAsync(
-    uri,
-    [{ crop }],
-    { compress: 1, format: ImageManipulator.SaveFormat.PNG }
-  );
-
-  console.log("Image recadrée:", result.uri);
-  return result.uri;
-}
-
-// Fonction pour rogner avec une tolérance de 10% autour du bbox
-export async function cropImageWithBBoxWithTolerance(uri: string, bbox: any, tolerance: number = 0.1): Promise<string> {
-  console.log("cropImageWithBBoxWithTolerance", JSON.stringify(truncateFields({ uri, bbox, tolerance }), null, 2));
-  
-  return new Promise<string>((resolve, reject) => {
+export async function cropImageWithBBoxWithTolerance(uri: string, bbox: any, tolerance: number = 0.02): Promise<string> {
+  return new Promise<string>((resolve) => {
     let isResolved = false;
-    
-    // Timeout de sécurité (15 secondes)
+
+    // Safety Timeout (10 seconds)
     const timeout = setTimeout(() => {
       if (!isResolved) {
         isResolved = true;
-        console.warn("Timeout lors du rognage avec tolérance, utilisation de l'image originale");
-        resolve(uri); // Retourner l'URI original en cas de timeout
+        console.warn("Crop timeout, returning original.");
+        resolve(uri);
       }
-    }, 15000);
-
-    // 1️⃣ Récupère la taille originale de l'image
-    RNImage.getSize(uri, (imageWidth, imageHeight) => {
-      if (isResolved) return;
-      
-      // 2️⃣ Calculer la tolérance en pixels (10% de chaque côté)
-      const toleranceX = bbox.width * tolerance;
-      const toleranceY = bbox.height * tolerance;
-
-      // 3️⃣ Ajuster le bbox avec la tolérance
-      // Calculer les nouvelles coordonnées avec tolérance
-      const newMinX = Math.max(0, bbox.minX - toleranceX);
-      const newMinY = Math.max(0, bbox.minY - toleranceY);
-      const newMaxX = Math.min(imageWidth, bbox.minX + bbox.width + toleranceX);
-      const newMaxY = Math.min(imageHeight, bbox.minY + bbox.height + toleranceY);
-
-      // Calculer la largeur et hauteur finales
-      const finalWidth = newMaxX - newMinX;
-      const finalHeight = newMaxY - newMinY;
-
-      const crop = {
-        originX: newMinX,
-        originY: newMinY,
-        width: finalWidth,
-        height: finalHeight,
-      };
-
-      logger.log("cropImageWithBBoxWithTolerance - crop params", JSON.stringify(truncateFields({ uri, crop, tolerance, imageWidth, imageHeight }), null, 2));
-
-      // 4️⃣ Appliquer le crop avec tolérance
-      // @ts-ignore - manipulateAsync is deprecated but still functional, new API (useImageManipulator) is a React hook and not suitable for utility functions
-      ImageManipulator.manipulateAsync(
-        uri,
-        [{ crop }],
-        { compress: 0.95, format: ImageManipulator.SaveFormat.JPEG }
-      )
-        .then((result) => {
-          if (isResolved) return;
-          isResolved = true;
-          clearTimeout(timeout);
-          console.log("Image recadrée avec tolérance:", result.uri);
-          resolve(result.uri);
-        })
-        .catch((error) => {
-          if (isResolved) return;
+    }, 10000);
+
+    try {
+      RNImage.getSize(uri, async (actualWidth, actualHeight) => {
+        if (isResolved) return;
+
+        // 1. Detect if bbox is percentage (e.g., 0.15) or absolute pixels (e.g., 800)
+        // Since we pass UI percentages, this will be true.
+        const isPercentageBased = bbox.width <= 1.5 && bbox.height <= 1.5;
+
+        let pixelMinX, pixelMinY, pixelWidth, pixelHeight;
+
+        if (isPercentageBased) {
+          pixelMinX = bbox.minX * actualWidth;
+          pixelMinY = bbox.minY * actualHeight;
+          pixelWidth = bbox.width * actualWidth;
+          pixelHeight = bbox.height * actualHeight;
+        } else {
+          // Fallback if backend pixels somehow bypass the check
+          pixelMinX = bbox.minX;
+          pixelMinY = bbox.minY;
+          pixelWidth = bbox.width;
+          pixelHeight = bbox.height;
+        }
+
+        // 2. Add Tolerance (Expands the box slightly to avoid cutting off physical card edges)
+        const toleranceX = pixelWidth * tolerance;
+        const toleranceY = pixelHeight * tolerance;
+
+        // Clamp values to ensure we don't try to crop outside the image bounds
+        const newMinX = Math.max(0, pixelMinX - toleranceX);
+        const newMinY = Math.max(0, pixelMinY - toleranceY);
+        const newMaxX = Math.min(actualWidth, pixelMinX + pixelWidth + toleranceX);
+        const newMaxY = Math.min(actualHeight, pixelMinY + pixelHeight + toleranceY);
+
+        const finalCrop = {
+          originX: Math.floor(newMinX),
+          originY: Math.floor(newMinY),
+          width: Math.floor(newMaxX - newMinX),
+          height: Math.floor(newMaxY - newMinY),
+        };
+
+        // 3. Perform Final Crop
+        try {
+          // @ts-ignore - Required for utility functions outside React components
+          const result = await ImageManipulator.manipulateAsync(
+            uri,
+            [{ crop: finalCrop }],
+            { compress: 0.95, format: ImageManipulator.SaveFormat.JPEG }
+          );
+          
+          if (!isResolved) {
+            isResolved = true;
+            clearTimeout(timeout);
+            resolve(result.uri);
+          }
+        } catch (err) {
+          if (!isResolved) {
+            isResolved = true;
+            clearTimeout(timeout);
+            console.error("ImageManipulator failed, returning raw image", err);
+            resolve(uri);
+          }
+        }
+      }, () => {
+        if (!isResolved) {
           isResolved = true;
           clearTimeout(timeout);
-          console.error("Erreur lors du rognage avec tolérance:", error);
-          // En cas d'erreur, retourner l'URI original au lieu de rejeter
           resolve(uri);
-        });
-    }, (error) => {
-      if (isResolved) return;
-      isResolved = true;
-      clearTimeout(timeout);
-      console.error("Erreur lors de la récupération de la taille de l'image:", error);
-      // En cas d'erreur, retourner l'URI original au lieu de rejeter
-      resolve(uri);
-    });
+        }
+      });
+    } catch (e) {
+      if (!isResolved) {
+        isResolved = true;
+        clearTimeout(timeout);
+        resolve(uri);
+      }
+    }
   });
-}
+}