capacitor-card-scanner 0.3.1 → 0.3.3

package/README.md

@@ -328,18 +328,22 @@ requestPermissions() => Promise<PermissionStatus>
 
 #### DetectionOptions
 
-| Prop                  | Type                 | Description                                                                                                                                                                                                                                          | Default                         |
-| --------------------- | -------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------- |
-| **`intervalMs`**      | <code>number</code>  | Minimum time between two OCR runs, in milliseconds. The red rectangle is updated on every frame regardless.                                                                                                                                          | <code>300</code>                |
-| **`stableFrames`**    | <code>number</code>  | How many consecutive OCR runs must read the same card before `cardDetected` fires.                                                                                                                                                                   | <code>2</code>                  |
-| **`includeImage`**    | <code>boolean</code> | Include a JPEG of the detected card in the event.                                                                                                                                                                                                    | <code>false</code>              |
-| **`cardAspectRatio`** | <code>number</code>  | Expected width / height of an upright card. Only upright cards are detected; a card lying sideways falls outside the tolerance.                                                                                                                      | <code>0.716 (63 x 88 mm)</code> |
-| **`aspectTolerance`** | <code>number</code>  | Allowed relative deviation from `cardAspectRatio` (0.15 = ±15%). Increase it if tilted cards are not detected.                                                                                                                                       | <code>0.15</code>               |
-| **`minCardArea`**     | <code>number</code>  | Smallest card size, as a fraction of the camera frame (0-1).                                                                                                                                                                                         | <code>0.08</code>               |
-| **`maxCardArea`**     | <code>number</code>  | Largest card size, as a fraction of the camera frame (0-1).                                                                                                                                                                                          | <code>0.9</code>                |
-| **`requireCard`**     | <code>boolean</code> | Only read text when a card-shaped object is visible. When false, the whole frame is read if no card is found.                                                                                                                                        | <code>true</code>               |
-| **`debug`**           | <code>boolean</code> | Every object found is always outlined: red when accepted as a card, grey when rejected. With `debug`, each outline is also labelled with its area (`a`), width/height ratio (`r`) and the filter that rejected it. Use it to tune the filters above. | <code>false</code>              |
-| **`showRejected`**    | <code>boolean</code> | Outline (in grey) the objects that were not accepted as a card. The accepted card is always outlined in red.                                                                                                                                         | <code>true</code>               |
+| Prop                   | Type                  | Description                                                                                                                                                                                                                                          | Default                                                                                                                                                        |
+| ---------------------- | --------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| **`intervalMs`**       | <code>number</code>   | Minimum time between two OCR runs, in milliseconds. The red rectangle is updated on every frame regardless.                                                                                                                                          | <code>300</code>                                                                                                                                               |
+| **`stableFrames`**     | <code>number</code>   | How many consecutive OCR runs must read the same card before `cardDetected` fires.                                                                                                                                                                   | <code>2</code>                                                                                                                                                 |
+| **`includeImage`**     | <code>boolean</code>  | Include a JPEG of the detected card in the event.                                                                                                                                                                                                    | <code>false</code>                                                                                                                                             |
+| **`cardAspectRatio`**  | <code>number</code>   | Expected width / height of an upright card. Only upright cards are detected; a card lying sideways falls outside the tolerance.                                                                                                                      | <code>0.716 (63 x 88 mm)</code>                                                                                                                                |
+| **`aspectTolerance`**  | <code>number</code>   | Allowed relative deviation from `cardAspectRatio` (0.15 = ±15%). Increase it if tilted cards are not detected.                                                                                                                                       | <code>0.15</code>                                                                                                                                              |
+| **`minCardArea`**      | <code>number</code>   | Smallest card size, as a fraction of the camera frame (0-1).                                                                                                                                                                                         | <code>0.08</code>                                                                                                                                              |
+| **`maxCardArea`**      | <code>number</code>   | Largest card size, as a fraction of the camera frame (0-1).                                                                                                                                                                                          | <code>0.9</code>                                                                                                                                               |
+| **`requireCard`**      | <code>boolean</code>  | Only read text when a card-shaped object is visible. When false, the whole frame is read if no card is found.                                                                                                                                        | <code>true</code>                                                                                                                                              |
+| **`debug`**            | <code>boolean</code>  | Every object found is always outlined: red when accepted as a card, grey when rejected. With `debug`, each outline is also labelled with its area (`a`), width/height ratio (`r`) and the filter that rejected it. Use it to tune the filters above. | <code>false</code>                                                                                                                                             |
+| **`showRejected`**     | <code>boolean</code>  | Outline (in grey) the objects that were not accepted as a card. The accepted card is always outlined in red.                                                                                                                                         | <code>true</code>                                                                                                                                              |
+| **`repeatAfterMs`**    | <code>number</code>   | How long (ms) the card must be out of view before the same card can be reported again. While a card stays in view it is reported only once.                                                                                                          | <code>1500</code>                                                                                                                                              |
+| **`nameLines`**        | <code>number</code>   | The card name is looked for only in the first N lines of text on the card, top to bottom.                                                                                                                                                            | <code>3</code>                                                                                                                                                 |
+| **`reservedWords`**    | <code>string[]</code> | Words/phrases that are never the card name (card types, subtypes...). A line made only of these words is skipped, so "Trainer" or "Stage 1" are ignored but "Energy Retrieval" is still a name. Replaces the defaults.                               | <code>['Basic', 'Stage 1', 'Stage 2', 'Trainer', 'Item', 'Supporter', 'Stadium', 'Energy', 'Special Energy', 'Basic Energy', 'Pokémon', 'Pokémon Tool']</code> |
+| **`reservedPrefixes`** | <code>string[]</code> | Lines starting with any of these are never the card name. Replaces the defaults.                                                                                                                                                                     | <code>['Evolves from', 'HP']</code>                                                                                                                            |
 
 
 #### PluginListenerHandle

package/android/src/main/java/pt/tcgclassifier/cardscanner/CardDetector.java

@@ -24,7 +24,10 @@ import com.google.mlkit.vision.text.TextRecognition;
 import com.google.mlkit.vision.text.TextRecognizer;
 import com.google.mlkit.vision.text.latin.TextRecognizerOptions;
 import java.io.ByteArrayOutputStream;
+import java.text.Normalizer;
 import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Comparator;
 import java.util.List;
 import java.util.Locale;
 import java.util.regex.Matcher;
@@ -64,6 +67,20 @@ public class CardDetector implements ImageAnalysis.Analyzer {
         public boolean debug = false;
         /** Outline (in grey) the objects that were not accepted as a card. */
         public boolean showRejected = true;
+        /** How long the card must be out of view before the same card can be reported again. */
+        public long repeatAfterMs = 1500;
+        /** The name is looked for only in the first N lines of the card (top to bottom). */
+        public int nameLines = 3;
+        /**
+         * Words/phrases that are never the card name (card types, subtypes...).
+         * A line made only of these words is skipped; "Energy Retrieval" is still a name.
+         */
+        public List<String> reservedWords = Arrays.asList(
+            "Basic", "Stage 1", "Stage 2", "Trainer", "Item", "Supporter", "Stadium",
+            "Energy", "Special Energy", "Basic Energy", "Pokémon", "Pokémon Tool"
+        );
+        /** Lines starting with any of these are never the card name. */
+        public List<String> reservedPrefixes = Arrays.asList("Evolves from", "HP");
     }
 
     /** An object found by ML Kit, with the values the card filters were checked against. */
@@ -102,14 +119,10 @@ public class CardDetector implements ImageAnalysis.Analyzer {
 
     // e.g. "025/165", "SV001/SV122", "TG05/TG30", "GG01/GG70"
     private static final Pattern NUMBER = Pattern.compile("\\b([A-Za-z]{0,4}\\d{1,3}[a-z]?)\\s*/\\s*([A-Za-z]{0,4}\\d{1,3})\\b");
-    private static final Pattern HEADER = Pattern.compile(
-        "^(basic|stage\\s*\\d|trainer|item|supporter|stadium|energy|pok[eé]mon|evolves|hp\\b)",
-        Pattern.CASE_INSENSITIVE
-    );
     private static final Pattern HP_SUFFIX = Pattern.compile("\\s*HP\\s*\\d+\\s*$", Pattern.CASE_INSENSITIVE);
     private static final Pattern LETTER = Pattern.compile("\\p{L}");
-    /** After this long without reading a card, the same card can be reported again. */
-    private static final long RESET_AFTER_MS = 1500;
+    /** Names at least this similar are treated as the same card. */
+    private static final float SAME_NAME_SIMILARITY = 0.8f;
     /** Extra margin around the detected card before running OCR. */
     private static final float CROP_MARGIN = 0.04f;
 
@@ -119,6 +132,9 @@ public class CardDetector implements ImageAnalysis.Analyzer {
     private final TextRecognizer recognizer = TextRecognition.getClient(TextRecognizerOptions.DEFAULT_OPTIONS);
     private final Options options;
     private final Listener listener;
+    /** reservedWords / reservedPrefixes, normalized; words longest first. */
+    private final List<String> reservedWords = new ArrayList<>();
+    private final List<String> reservedPrefixes = new ArrayList<>();
     private volatile BoxListener boxListener;
 
     // Only touched from the analyzer thread.
@@ -126,12 +142,26 @@ public class CardDetector implements ImageAnalysis.Analyzer {
     private long lastSeenAt;
     private String candidateKey;
     private int candidateCount;
-    private String lastEmittedKey;
+    // Last reported card. A reading is the same card if either its name or its
+    // number matches, because OCR does not read the number on every frame.
+    private String lastEmittedName;
+    private String lastEmittedNumber;
 
     public CardDetector(Options options, Listener listener) {
         this.options = options;
         this.options.stableFrames = Math.max(1, options.stableFrames);
+        this.options.nameLines = Math.max(1, options.nameLines);
         this.listener = listener;
+        for (String w : options.reservedWords) {
+            String n = normalize(w);
+            if (!n.isEmpty()) reservedWords.add(n);
+        }
+        // Longest first, so "Pokémon Tool" is removed before "Pokémon".
+        reservedWords.sort(Comparator.comparingInt(String::length).reversed());
+        for (String p : options.reservedPrefixes) {
+            String n = normalize(p);
+            if (!n.isEmpty()) reservedPrefixes.add(n);
+        }
     }
 
     public boolean isDebug() {
@@ -169,6 +199,9 @@ public class CardDetector implements ImageAnalysis.Analyzer {
             List<Candidate> candidates = new ArrayList<>();
             Rect card = pickCard(objects, frameW, frameH, candidates);
             RectF cardBox = card == null ? null : normalize(card, frameW, frameH);
+            // The card counts as "in view" while its outline is visible, even if
+            // its text is not readable on this frame.
+            if (card != null) lastSeenAt = now;
             BoxListener bl = boxListener;
             if (bl != null) bl.onDetections(cardBox, candidates, frameW, frameH);
 
@@ -249,8 +282,7 @@ public class CardDetector implements ImageAnalysis.Analyzer {
         float h = region.getHeight();
         JSArray lines = new JSArray();
         String number = null;
-        String name = null;
-        int nameTop = Integer.MAX_VALUE;
+        List<Text.Line> ordered = new ArrayList<>();
 
         for (Text.TextBlock block : text.getTextBlocks()) {
             for (Text.Line line : block.getLines()) {
@@ -267,12 +299,10 @@ public class CardDetector implements ImageAnalysis.Analyzer {
                     Matcher m = NUMBER.matcher(s);
                     if (m.find()) number = m.group(1) + "/" + m.group(2);
                 }
-                if (r.top < nameTop && isNameCandidate(s)) {
-                    name = HP_SUFFIX.matcher(s).replaceAll("").trim();
-                    nameTop = r.top;
-                }
+                ordered.add(line);
             }
         }
+        String name = findName(ordered);
 
         String key = number != null ? number : name;
         if (key == null) {
@@ -287,8 +317,9 @@ public class CardDetector implements ImageAnalysis.Analyzer {
             candidateKey = key;
             candidateCount = 1;
         }
-        if (candidateCount < options.stableFrames || key.equals(lastEmittedKey)) return;
-        lastEmittedKey = key;
+        if (candidateCount < options.stableFrames || isLastEmitted(name, number)) return;
+        lastEmittedName = name;
+        lastEmittedNumber = number;
 
         JSObject result = new JSObject();
         result.put("name", name);
@@ -309,7 +340,33 @@ public class CardDetector implements ImageAnalysis.Analyzer {
     private void noCardRead(long now) {
         candidateKey = null;
         candidateCount = 0;
-        if (now - lastSeenAt > RESET_AFTER_MS) lastEmittedKey = null;
+        if (now - lastSeenAt > options.repeatAfterMs) {
+            lastEmittedName = null;
+            lastEmittedNumber = null;
+        }
+    }
+
+    private boolean isLastEmitted(String name, String number) {
+        if (number != null && number.equals(lastEmittedNumber)) return true;
+        return name != null && lastEmittedName != null && similarity(name, lastEmittedName) >= SAME_NAME_SIMILARITY;
+    }
+
+    /** 0-1 similarity (LCS based), so an OCR slip like "Evolutlon" still matches "Evolution". */
+    private static float similarity(String a, String b) {
+        a = a.toLowerCase(Locale.ROOT);
+        b = b.toLowerCase(Locale.ROOT);
+        if (a.equals(b)) return 1f;
+        int[] prev = new int[b.length() + 1];
+        int[] cur = new int[b.length() + 1];
+        for (int i = 1; i <= a.length(); i++) {
+            for (int j = 1; j <= b.length(); j++) {
+                cur[j] = a.charAt(i - 1) == b.charAt(j - 1) ? prev[j - 1] + 1 : Math.max(prev[j], cur[j - 1]);
+            }
+            int[] tmp = prev;
+            prev = cur;
+            cur = tmp;
+        }
+        return 2f * prev[b.length()] / (a.length() + b.length());
     }
 
     private static JSObject box(float x, float y, float width, float height) {
@@ -321,11 +378,41 @@ public class CardDetector implements ImageAnalysis.Analyzer {
         return box;
     }
 
-    private static boolean isNameCandidate(String s) {
-        if (HEADER.matcher(s).find()) return false;
+    /** First line, among the top {@code nameLines}, that is not made of reserved words. */
+    @Nullable
+    private String findName(List<Text.Line> lines) {
+        lines.sort(Comparator.comparingInt(l -> l.getBoundingBox().top));
+        for (int i = 0; i < lines.size() && i < options.nameLines; i++) {
+            String s = HP_SUFFIX.matcher(lines.get(i).getText().trim()).replaceAll("").trim();
+            if (!isReserved(s) && countLetters(s) >= 3) return s;
+        }
+        return null;
+    }
+
+    private boolean isReserved(String line) {
+        String rest = " " + normalize(line) + " ";
+        for (String w : reservedWords) {
+            rest = rest.replace(" " + w + " ", " ");
+        }
+        rest = rest.trim();
+        if (countLetters(rest) < 3) return true;
+        // Checked after removing reserved words, so "STAGE 1 Evolves from Pichu" is caught too.
+        for (String p : reservedPrefixes) {
+            if (rest.equals(p) || rest.startsWith(p + " ")) return true;
+        }
+        return false;
+    }
+
+    /** Upper case, no accents, only letters/digits separated by single spaces. */
+    private static String normalize(String s) {
+        String n = Normalizer.normalize(s, Normalizer.Form.NFD).replaceAll("\\p{M}", "");
+        return n.toUpperCase(Locale.ROOT).replaceAll("[^\\p{L}\\p{Nd}]+", " ").trim();
+    }
+
+    private static int countLetters(String s) {
         Matcher m = LETTER.matcher(s);
         int letters = 0;
         while (m.find()) letters++;
-        return letters >= 3;
+        return letters;
     }
 }

package/android/src/main/java/pt/tcgclassifier/cardscanner/CardScannerPlugin.java

@@ -1,6 +1,8 @@
 package pt.tcgclassifier.cardscanner;
 
 import android.Manifest;
+import androidx.annotation.Nullable;
+import com.getcapacitor.JSArray;
 import com.getcapacitor.JSObject;
 import com.getcapacitor.PermissionState;
 import com.getcapacitor.Plugin;
@@ -9,6 +11,8 @@ import com.getcapacitor.PluginMethod;
 import com.getcapacitor.annotation.CapacitorPlugin;
 import com.getcapacitor.annotation.Permission;
 import com.getcapacitor.annotation.PermissionCallback;
+import java.util.ArrayList;
+import java.util.List;
 
 @CapacitorPlugin(name = "CardScanner", permissions = { @Permission(strings = { Manifest.permission.CAMERA }, alias = CardScannerPlugin.CAMERA) })
 public class CardScannerPlugin extends Plugin {
@@ -102,6 +106,12 @@ public class CardScannerPlugin extends Plugin {
         options.requireCard = call.getBoolean("requireCard", options.requireCard);
         options.debug = call.getBoolean("debug", options.debug);
         options.showRejected = call.getBoolean("showRejected", options.showRejected);
+        options.repeatAfterMs = call.getInt("repeatAfterMs", (int) options.repeatAfterMs);
+        options.nameLines = call.getInt("nameLines", options.nameLines);
+        List<String> reservedWords = stringList(call, "reservedWords");
+        if (reservedWords != null) options.reservedWords = reservedWords;
+        List<String> reservedPrefixes = stringList(call, "reservedPrefixes");
+        if (reservedPrefixes != null) options.reservedPrefixes = reservedPrefixes;
 
         CardDetector detector = new CardDetector(options, result -> notifyListeners("cardDetected", result));
         getActivity().runOnUiThread(() -> {
@@ -142,6 +152,19 @@ public class CardScannerPlugin extends Plugin {
         call.resolve();
     }
 
+    /** A string array option, or null when it was not passed. */
+    @Nullable
+    private static List<String> stringList(PluginCall call, String key) {
+        JSArray array = call.getArray(key, null);
+        if (array == null) return null;
+        List<String> list = new ArrayList<>();
+        for (int i = 0; i < array.length(); i++) {
+            String s = array.optString(i, null);
+            if (s != null) list.add(s);
+        }
+        return list;
+    }
+
     private boolean ensureRunning(PluginCall call) {
         if (!implementation.isRunning()) {
             call.reject("Camera is not running", "NOT_RUNNING");

package/dist/docs.json

@@ -420,6 +420,54 @@
           "docs": "Outline (in grey) the objects that were not accepted as a card.\nThe accepted card is always outlined in red.",
           "complexTypes": [],
           "type": "boolean | undefined"
+        },
+        {
+          "name": "repeatAfterMs",
+          "tags": [
+            {
+              "text": "1500",
+              "name": "default"
+            }
+          ],
+          "docs": "How long (ms) the card must be out of view before the same card can be\nreported again. While a card stays in view it is reported only once.",
+          "complexTypes": [],
+          "type": "number | undefined"
+        },
+        {
+          "name": "nameLines",
+          "tags": [
+            {
+              "text": "3",
+              "name": "default"
+            }
+          ],
+          "docs": "The card name is looked for only in the first N lines of text on the\ncard, top to bottom.",
+          "complexTypes": [],
+          "type": "number | undefined"
+        },
+        {
+          "name": "reservedWords",
+          "tags": [
+            {
+              "text": "['Basic', 'Stage 1', 'Stage 2', 'Trainer', 'Item', 'Supporter', 'Stadium', 'Energy', 'Special Energy', 'Basic Energy', 'Pokémon', 'Pokémon Tool']",
+              "name": "default"
+            }
+          ],
+          "docs": "Words/phrases that are never the card name (card types, subtypes...).\nA line made only of these words is skipped, so \"Trainer\" or \"Stage 1\" are\nignored but \"Energy Retrieval\" is still a name. Replaces the defaults.",
+          "complexTypes": [],
+          "type": "string[] | undefined"
+        },
+        {
+          "name": "reservedPrefixes",
+          "tags": [
+            {
+              "text": "['Evolves from', 'HP']",
+              "name": "default"
+            }
+          ],
+          "docs": "Lines starting with any of these are never the card name.\nReplaces the defaults.",
+          "complexTypes": [],
+          "type": "string[] | undefined"
         }
       ]
     },

package/dist/esm/definitions.d.ts

@@ -90,6 +90,31 @@ export interface DetectionOptions {
      * @default true
      */
     showRejected?: boolean;
+    /**
+     * How long (ms) the card must be out of view before the same card can be
+     * reported again. While a card stays in view it is reported only once.
+     * @default 1500
+     */
+    repeatAfterMs?: number;
+    /**
+     * The card name is looked for only in the first N lines of text on the
+     * card, top to bottom.
+     * @default 3
+     */
+    nameLines?: number;
+    /**
+     * Words/phrases that are never the card name (card types, subtypes...).
+     * A line made only of these words is skipped, so "Trainer" or "Stage 1" are
+     * ignored but "Energy Retrieval" is still a name. Replaces the defaults.
+     * @default ['Basic', 'Stage 1', 'Stage 2', 'Trainer', 'Item', 'Supporter', 'Stadium', 'Energy', 'Special Energy', 'Basic Energy', 'Pokémon', 'Pokémon Tool']
+     */
+    reservedWords?: string[];
+    /**
+     * Lines starting with any of these are never the card name.
+     * Replaces the defaults.
+     * @default ['Evolves from', 'HP']
+     */
+    reservedPrefixes?: string[];
 }
 /** Normalized rectangle (0-1). */
 export interface Box {

package/dist/esm/definitions.js.map

@@ -1 +1 @@
-{"version":3,"file":"definitions.js","sourceRoot":"","sources":["../../src/definitions.ts"],"names":[],"mappings":"","sourcesContent":["import type { PermissionState, PluginListenerHandle } from '@capacitor/core';\n\nexport type CameraPosition = 'rear' | 'front';\n\nexport interface StartOptions {\n  /**\n   * Which camera to use.\n   * @default 'rear'\n   */\n  position?: CameraPosition;\n}\n\nexport interface CaptureOptions {\n  /**\n   * JPEG quality (0-100).\n   * @default 85\n   */\n  quality?: number;\n}\n\nexport interface CaptureResult {\n  /** Base64 encoded JPEG (without the `data:` prefix). */\n  base64: string;\n  width: number;\n  height: number;\n}\n\nexport interface TorchOptions {\n  enabled: boolean;\n}\n\nexport interface ZoomOptions {\n  /** Zoom ratio, clamped between the camera's min and max. */\n  ratio: number;\n}\n\nexport interface PermissionStatus {\n  camera: PermissionState;\n}\n\nexport interface DetectionOptions {\n  /**\n   * Minimum time between two OCR runs, in milliseconds.\n   * The red rectangle is updated on every frame regardless.\n   * @default 300\n   */\n  intervalMs?: number;\n  /**\n   * How many consecutive OCR runs must read the same card before\n   * `cardDetected` fires.\n   * @default 2\n   */\n  stableFrames?: number;\n  /**\n   * Include a JPEG of the detected card in the event.\n   * @default false\n   */\n  includeImage?: boolean;\n  /**\n   * Expected width / height of an upright card. Only upright cards are\n   * detected; a card lying sideways falls outside the tolerance.\n   * @default 0.716 (63 x 88 mm)\n   */\n  cardAspectRatio?: number;\n  /**\n   * Allowed relative deviation from `cardAspectRatio` (0.15 = ±15%).\n   * Increase it if tilted cards are not detected.\n   * @default 0.15\n   */\n  aspectTolerance?: number;\n  /**\n   * Smallest card size, as a fraction of the camera frame (0-1).\n   * @default 0.08\n   */\n  minCardArea?: number;\n  /**\n   * Largest card size, as a fraction of the camera frame (0-1).\n   * @default 0.9\n   */\n  maxCardArea?: number;\n  /**\n   * Only read text when a card-shaped object is visible. When false, the whole\n   * frame is read if no card is found.\n   * @default true\n   */\n  requireCard?: boolean;\n  /**\n   * Every object found is always outlined: red when accepted as a card, grey\n   * when rejected. With `debug`, each outline is also labelled with its area\n   * (`a`), width/height ratio (`r`) and the filter that rejected it. Use it to\n   * tune the filters above.\n   * @default false\n   */\n  debug?: boolean;\n  /**\n   * Outline (in grey) the objects that were not accepted as a card.\n   * The accepted card is always outlined in red.\n   * @default true\n   */\n  showRejected?: boolean;\n}\n\n/** Normalized rectangle (0-1). */\nexport interface Box {\n  x: number;\n  y: number;\n  width: number;\n  height: number;\n}\n\nexport interface TextLine {\n  text: string;\n  /** Position inside the card image. */\n  box: Box;\n}\n\nexport interface CardDetectedEvent {\n  /** Best guess for the card name (topmost line of text on the card). */\n  name?: string;\n  /** Collector number, e.g. `025/165`. */\n  collectorNumber?: string;\n  /** All text read on the card. */\n  text: string;\n  lines: TextLine[];\n  /** Where the card is in the camera frame. Missing if no card outline was found. */\n  cardBox?: Box;\n  /** Base64 JPEG of the card, when `includeImage` is true. */\n  image?: string;\n}\n\nexport interface CardScannerPlugin {\n  /**\n   * Opens the camera **behind** the WebView. The WebView background is made\n   * transparent, so the HTML page must also use transparent backgrounds\n   * where the camera should be visible.\n   */\n  start(options?: StartOptions): Promise<void>;\n\n  /** Stops the camera and removes the preview. */\n  stop(): Promise<void>;\n\n  /** Takes a photo from the running camera. */\n  capture(options?: CaptureOptions): Promise<CaptureResult>;\n\n  /** Turns the flashlight on/off. */\n  setTorch(options: TorchOptions): Promise<void>;\n\n  /** Sets the zoom ratio. */\n  setZoom(options: ZoomOptions): Promise<void>;\n\n  /** Switches between the rear and front camera. */\n  flip(): Promise<void>;\n\n  /**\n   * Starts looking for cards: draws a red rectangle around the card and reads\n   * its text, emitting `cardDetected`. Requires `start()` first. Android only.\n   */\n  startDetection(options?: DetectionOptions): Promise<void>;\n\n  /** Stops card detection and hides the rectangle. */\n  stopDetection(): Promise<void>;\n\n  /** Fired once per card, when its text has been read consistently. */\n  addListener(eventName: 'cardDetected', listener: (event: CardDetectedEvent) => void): Promise<PluginListenerHandle>;\n\n  removeAllListeners(): Promise<void>;\n\n  checkPermissions(): Promise<PermissionStatus>;\n\n  requestPermissions(): Promise<PermissionStatus>;\n}\n"]}
+{"version":3,"file":"definitions.js","sourceRoot":"","sources":["../../src/definitions.ts"],"names":[],"mappings":"","sourcesContent":["import type { PermissionState, PluginListenerHandle } from '@capacitor/core';\n\nexport type CameraPosition = 'rear' | 'front';\n\nexport interface StartOptions {\n  /**\n   * Which camera to use.\n   * @default 'rear'\n   */\n  position?: CameraPosition;\n}\n\nexport interface CaptureOptions {\n  /**\n   * JPEG quality (0-100).\n   * @default 85\n   */\n  quality?: number;\n}\n\nexport interface CaptureResult {\n  /** Base64 encoded JPEG (without the `data:` prefix). */\n  base64: string;\n  width: number;\n  height: number;\n}\n\nexport interface TorchOptions {\n  enabled: boolean;\n}\n\nexport interface ZoomOptions {\n  /** Zoom ratio, clamped between the camera's min and max. */\n  ratio: number;\n}\n\nexport interface PermissionStatus {\n  camera: PermissionState;\n}\n\nexport interface DetectionOptions {\n  /**\n   * Minimum time between two OCR runs, in milliseconds.\n   * The red rectangle is updated on every frame regardless.\n   * @default 300\n   */\n  intervalMs?: number;\n  /**\n   * How many consecutive OCR runs must read the same card before\n   * `cardDetected` fires.\n   * @default 2\n   */\n  stableFrames?: number;\n  /**\n   * Include a JPEG of the detected card in the event.\n   * @default false\n   */\n  includeImage?: boolean;\n  /**\n   * Expected width / height of an upright card. Only upright cards are\n   * detected; a card lying sideways falls outside the tolerance.\n   * @default 0.716 (63 x 88 mm)\n   */\n  cardAspectRatio?: number;\n  /**\n   * Allowed relative deviation from `cardAspectRatio` (0.15 = ±15%).\n   * Increase it if tilted cards are not detected.\n   * @default 0.15\n   */\n  aspectTolerance?: number;\n  /**\n   * Smallest card size, as a fraction of the camera frame (0-1).\n   * @default 0.08\n   */\n  minCardArea?: number;\n  /**\n   * Largest card size, as a fraction of the camera frame (0-1).\n   * @default 0.9\n   */\n  maxCardArea?: number;\n  /**\n   * Only read text when a card-shaped object is visible. When false, the whole\n   * frame is read if no card is found.\n   * @default true\n   */\n  requireCard?: boolean;\n  /**\n   * Every object found is always outlined: red when accepted as a card, grey\n   * when rejected. With `debug`, each outline is also labelled with its area\n   * (`a`), width/height ratio (`r`) and the filter that rejected it. Use it to\n   * tune the filters above.\n   * @default false\n   */\n  debug?: boolean;\n  /**\n   * Outline (in grey) the objects that were not accepted as a card.\n   * The accepted card is always outlined in red.\n   * @default true\n   */\n  showRejected?: boolean;\n  /**\n   * How long (ms) the card must be out of view before the same card can be\n   * reported again. While a card stays in view it is reported only once.\n   * @default 1500\n   */\n  repeatAfterMs?: number;\n  /**\n   * The card name is looked for only in the first N lines of text on the\n   * card, top to bottom.\n   * @default 3\n   */\n  nameLines?: number;\n  /**\n   * Words/phrases that are never the card name (card types, subtypes...).\n   * A line made only of these words is skipped, so \"Trainer\" or \"Stage 1\" are\n   * ignored but \"Energy Retrieval\" is still a name. Replaces the defaults.\n   * @default ['Basic', 'Stage 1', 'Stage 2', 'Trainer', 'Item', 'Supporter', 'Stadium', 'Energy', 'Special Energy', 'Basic Energy', 'Pokémon', 'Pokémon Tool']\n   */\n  reservedWords?: string[];\n  /**\n   * Lines starting with any of these are never the card name.\n   * Replaces the defaults.\n   * @default ['Evolves from', 'HP']\n   */\n  reservedPrefixes?: string[];\n}\n\n/** Normalized rectangle (0-1). */\nexport interface Box {\n  x: number;\n  y: number;\n  width: number;\n  height: number;\n}\n\nexport interface TextLine {\n  text: string;\n  /** Position inside the card image. */\n  box: Box;\n}\n\nexport interface CardDetectedEvent {\n  /** Best guess for the card name (topmost line of text on the card). */\n  name?: string;\n  /** Collector number, e.g. `025/165`. */\n  collectorNumber?: string;\n  /** All text read on the card. */\n  text: string;\n  lines: TextLine[];\n  /** Where the card is in the camera frame. Missing if no card outline was found. */\n  cardBox?: Box;\n  /** Base64 JPEG of the card, when `includeImage` is true. */\n  image?: string;\n}\n\nexport interface CardScannerPlugin {\n  /**\n   * Opens the camera **behind** the WebView. The WebView background is made\n   * transparent, so the HTML page must also use transparent backgrounds\n   * where the camera should be visible.\n   */\n  start(options?: StartOptions): Promise<void>;\n\n  /** Stops the camera and removes the preview. */\n  stop(): Promise<void>;\n\n  /** Takes a photo from the running camera. */\n  capture(options?: CaptureOptions): Promise<CaptureResult>;\n\n  /** Turns the flashlight on/off. */\n  setTorch(options: TorchOptions): Promise<void>;\n\n  /** Sets the zoom ratio. */\n  setZoom(options: ZoomOptions): Promise<void>;\n\n  /** Switches between the rear and front camera. */\n  flip(): Promise<void>;\n\n  /**\n   * Starts looking for cards: draws a red rectangle around the card and reads\n   * its text, emitting `cardDetected`. Requires `start()` first. Android only.\n   */\n  startDetection(options?: DetectionOptions): Promise<void>;\n\n  /** Stops card detection and hides the rectangle. */\n  stopDetection(): Promise<void>;\n\n  /** Fired once per card, when its text has been read consistently. */\n  addListener(eventName: 'cardDetected', listener: (event: CardDetectedEvent) => void): Promise<PluginListenerHandle>;\n\n  removeAllListeners(): Promise<void>;\n\n  checkPermissions(): Promise<PermissionStatus>;\n\n  requestPermissions(): Promise<PermissionStatus>;\n}\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "capacitor-card-scanner",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "description": "Recognize a pokemon card with camera open in background",
   "main": "dist/plugin.cjs.js",
   "module": "dist/esm/index.js",