סריקת ברקודים באמצעות למידת מכונה ב-Android

אפשר להשתמש בערכת ה-ML Kit כדי לזהות ברקודים ולפענח אותם.

יש שתי דרכים לשלב סריקת ברקוד: קיבוץ המודל כחלק מהאפליקציה או שימוש במודל שאינו חלק מחבילה שתלויה בשירותי Google Play. אם בוחרים את המודל שאינו בחבילה, האפליקציה שלכם תהיה קטנה יותר. עיינו כאן בטבלה כדי לקבל פרטים נוספים.

תכונהלא מקובצותבחבילה
יישוםמתבצעת הורדה דינמית של המודל באמצעות שירותי Google Play.המודל מקושר באופן סטטי לאפליקציה שלך בזמן היצירה.
גודל האפליקציהגודל של כ-600KB.גודל של כ-3.2MB.
זמן האתחולייתכן שתצטרכו להמתין עד שהמודל יוריד לפני השימוש הראשון.המודל זמין באופן מיידי.

לפני שמתחילים

  1. בקובץ build.gradle ברמת הפרויקט, חשוב להקפיד לכלול את מאגר הנתונים של Google&#39 גם בקטע buildscript וגם בקטע allprojects.

  2. מוסיפים את יחסי התלות של הספריות ל-Android Kit ב-ML Kit, ברמת הקובץ של האפליקציה, שהיא בדרך כלל app/build.gradle. בחרו באחד מהקשרים התלויים הבאים בהתאם לצרכים שלכם:

    כדי לקבץ את המודל באפליקציה:

    dependencies {
      // ...
      // Use this dependency to bundle the model with your app
      implementation 'com.google.mlkit:barcode-scanning:17.0.2'
    }
    

    כדי להשתמש במודל בשירותי Google Play:

    dependencies {
      // ...
      // Use this dependency to use the dynamically downloaded model in Google Play Services
      implementation 'com.google.android.gms:play-services-mlkit-barcode-scanning:18.1.0'
    }
    
  3. אם בחרתם להשתמש במודל ב-Google Play Services, תוכלו להגדיר שהאפליקציה תוריד באופן אוטומטי את הדגם למכשיר לאחר ההתקנה מחנות Play. כדי לעשות את זה, צריך להוסיף את ההצהרה הבאה לקובץ AndroidManifest.xml של האפליקציה:

    <application ...>
          ...
          <meta-data
              android:name="com.google.mlkit.vision.DEPENDENCIES"
              android:value="barcode" >
          <!-- To use multiple models: android:value="barcode,model2,model3" -->
    </application>
    

    אפשר גם לבדוק באופן מפורש את זמינות הדגם ולבקש הורדה דרך ModuleInstallClient API של Google Play.

    אם לא תפעילו הורדות של המודל בזמן ההתקנה או תבקשו הורדה מפורשת, ההורדה תתבצע במודל בפעם הראשונה שאתם מריצים את הסורק. בקשות שהוגשו לפני סיום ההורדה לא מניבות תוצאות.

הנחיות להזנת תמונה

  • כדי לאפשר ל-ML Kit לקרוא ברקודים, תמונות קלט צריכות להכיל ברקודים שמיוצגים על ידי כמות מספקת של פיקסלים.

    הדרישות הספציפיות לגבי נתוני פיקסל תלויות בסוג הברקוד ובכמות הנתונים שמקודדים בו, כי ברקודים רבים תומכים במטען ייעודי של משתנים. באופן כללי, היחידה המשמעותית ביותר של הברקוד צריכה להיות ברוחב של 2 פיקסלים לפחות, ובגודל של דו-ממד, גובה של 2 פיקסלים.

    לדוגמה, ברקודים של EAN-13 מורכבים מברים ומחללים ברוחב של 1, 2, 3 או 4, לכן תמונת ברקוד מסוג EAN-13 כוללת באופן אידיאלי ברים ורווחים ברוחב של 2, 4, 6 ו-8 פיקסלים לפחות. מכיוון שברקוד EAN-13 יש רוחב של 95 יחידות בסך הכול, הברקוד צריך להיות ברוחב של 190 פיקסלים לפחות.

    לפורמטים של דנוור, כגון PDF417, נדרשים מידות פיקסלים גדולות יותר כדי שערכת ה-ML Kit תוכל לקרוא אותם בצורה אמינה. לדוגמה, קוד PDF417 יכול להיות באורך של עד 34 17 יחידות "בשורה אחת, ועדיף שיהיו ברוחב של 1156 פיקסלים לפחות.

  • התמקדות בתמונה נמוכה עלולה להשפיע על דיוק הסריקה. אם האפליקציה לא מקבלת תוצאות מקובלות, צריך לבקש מהמשתמש לצלם מחדש את התמונה.

  • לגבי אפליקציות אופייניות, מומלץ לספק תמונה ברזולוציה גבוהה יותר, כמו 1280x720 או 1920x1080, כך שניתן לסרוק ברקודים ממרחק גדול יותר מהמצלמה.

    עם זאת, באפליקציות שבהן זמן האחזור הוא קריטי, ניתן לשפר את הביצועים על ידי צילום תמונות ברזולוציה נמוכה יותר, אבל דרישה שהברקוד מהווה את רוב תמונת הקלט. כדאי לעיין גם בטיפים לשיפור הביצועים בזמן אמת.

1. הגדרת סורק הברקוד

אם אתם יודעים אילו פורמטים של ברקוד תרצו לקרוא, תוכלו לשפר את המהירות של מזהה הברקוד באמצעות זיהוי הפורמטים האלה בלבד.

לדוגמה, כדי לזהות רק קוד Aztec וקודי QR, צריך לבנות אובייקט BarcodeScannerOptions כמו בדוגמה הבאה:

Kotlin

val options = BarcodeScannerOptions.Builder()
        .setBarcodeFormats(
                Barcode.FORMAT_QR_CODE,
                Barcode.FORMAT_AZTEC)
        .build()

Java

BarcodeScannerOptions options =
        new BarcodeScannerOptions.Builder()
        .setBarcodeFormats(
                Barcode.FORMAT_QR_CODE,
                Barcode.FORMAT_AZTEC)
        .build();

הפורמטים הבאים נתמכים:

  • קוד 128 (FORMAT_CODE_128)
  • קוד 39 (FORMAT_CODE_39)
  • קוד 93 (FORMAT_CODE_93)
  • Codabar (FORMAT_CODABAR)
  • EAN-13 (FORMAT_EAN_13)
  • EAN-8 (FORMAT_EAN_8)
  • ITF (FORMAT_ITF)
  • קוד UPC-A (FORMAT_UPC_A)
  • קוד מוצר אוניברסלי (UPC-E) (FORMAT_UPC_E)
  • קוד QR (FORMAT_QR_CODE)
  • PDF417 (FORMAT_PDF417)
  • אצטקים (FORMAT_AZTEC)
  • מטריצת נתונים (FORMAT_DATA_MATRIX)

2. הכנת תמונת הקלט

כדי לזהות ברקודים בתמונה, יוצרים אובייקט InputImage מBitmap, media.Image, ByteBuffer, ממערך בייט או מקובץ במכשיר. לאחר מכן, צריך להעביר את האובייקט InputImage אל השיטה process של BarcodeScanner.

ניתן ליצור אובייקט InputImage ממקורות שונים, כפי שמוסבר בהמשך.

באמצעות media.Image

כדי ליצור אובייקט InputImage מאובייקט media.Image, למשל כשמצלמים תמונה ממצלמה של מכשיר, צריך להעביר את האובייקט media.Image ואת הסיבוב של התמונה לInputImage.fromMediaImage().

אם נעשה שימוש בספרייה CameraX, מחלקת OnImageCapturedListener וסיווגים של ImageAnalysis.Analyzer מחשבים את הערך שלך בסבב.

Kotlin

private class YourImageAnalyzer : ImageAnalysis.Analyzer {

    override fun analyze(imageProxy: ImageProxy) {
        val mediaImage = imageProxy.image
        if (mediaImage != null) {
            val image = InputImage.fromMediaImage(mediaImage, imageProxy.imageInfo.rotationDegrees)
            // Pass image to an ML Kit Vision API
            // ...
        }
    }
}

Java

private class YourAnalyzer implements ImageAnalysis.Analyzer {

    @Override
    public void analyze(ImageProxy imageProxy) {
        Image mediaImage = imageProxy.getImage();
        if (mediaImage != null) {
          InputImage image =
                InputImage.fromMediaImage(mediaImage, imageProxy.getImageInfo().getRotationDegrees());
          // Pass image to an ML Kit Vision API
          // ...
        }
    }
}

אם לא משתמשים בספריית מצלמות שמספקת את רמת הסיבוב של התמונה, אפשר לחשב את מידת הסיבוב של המכשיר ואת הכיוון של חיישן המצלמה במכשיר:

Kotlin

private val ORIENTATIONS = SparseIntArray()

init {
    ORIENTATIONS.append(Surface.ROTATION_0, 0)
    ORIENTATIONS.append(Surface.ROTATION_90, 90)
    ORIENTATIONS.append(Surface.ROTATION_180, 180)
    ORIENTATIONS.append(Surface.ROTATION_270, 270)
}

/**
 * Get the angle by which an image must be rotated given the device's current
 * orientation.
 */
@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
@Throws(CameraAccessException::class)
private fun getRotationCompensation(cameraId: String, activity: Activity, isFrontFacing: Boolean): Int {
    // Get the device's current rotation relative to its "native" orientation.
    // Then, from the ORIENTATIONS table, look up the angle the image must be
    // rotated to compensate for the device's rotation.
    val deviceRotation = activity.windowManager.defaultDisplay.rotation
    var rotationCompensation = ORIENTATIONS.get(deviceRotation)

    // Get the device's sensor orientation.
    val cameraManager = activity.getSystemService(CAMERA_SERVICE) as CameraManager
    val sensorOrientation = cameraManager
            .getCameraCharacteristics(cameraId)
            .get(CameraCharacteristics.SENSOR_ORIENTATION)!!

    if (isFrontFacing) {
        rotationCompensation = (sensorOrientation + rotationCompensation) % 360
    } else { // back-facing
        rotationCompensation = (sensorOrientation - rotationCompensation + 360) % 360
    }
    return rotationCompensation
}

Java

private static final SparseIntArray ORIENTATIONS = new SparseIntArray();
static {
    ORIENTATIONS.append(Surface.ROTATION_0, 0);
    ORIENTATIONS.append(Surface.ROTATION_90, 90);
    ORIENTATIONS.append(Surface.ROTATION_180, 180);
    ORIENTATIONS.append(Surface.ROTATION_270, 270);
}

/**
 * Get the angle by which an image must be rotated given the device's current
 * orientation.
 */
@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
private int getRotationCompensation(String cameraId, Activity activity, boolean isFrontFacing)
        throws CameraAccessException {
    // Get the device's current rotation relative to its "native" orientation.
    // Then, from the ORIENTATIONS table, look up the angle the image must be
    // rotated to compensate for the device's rotation.
    int deviceRotation = activity.getWindowManager().getDefaultDisplay().getRotation();
    int rotationCompensation = ORIENTATIONS.get(deviceRotation);

    // Get the device's sensor orientation.
    CameraManager cameraManager = (CameraManager) activity.getSystemService(CAMERA_SERVICE);
    int sensorOrientation = cameraManager
            .getCameraCharacteristics(cameraId)
            .get(CameraCharacteristics.SENSOR_ORIENTATION);

    if (isFrontFacing) {
        rotationCompensation = (sensorOrientation + rotationCompensation) % 360;
    } else { // back-facing
        rotationCompensation = (sensorOrientation - rotationCompensation + 360) % 360;
    }
    return rotationCompensation;
}

לאחר מכן, צריך להעביר את האובייקט media.Image ואת הערך של רמת הסיבוב אל InputImage.fromMediaImage():

Kotlin

val image = InputImage.fromMediaImage(mediaImage, rotation)

Java

InputImage image = InputImage.fromMediaImage(mediaImage, rotation);

שימוש ב-URI של קובץ

כדי ליצור אובייקט InputImage מ-URI של קובץ, צריך להעביר את ההקשר של האפליקציה ואת ה-URI של הקובץ אל InputImage.fromFilePath(). האפשרות הזו שימושית כשמשתמשים בכוונת ACTION_GET_CONTENT כדי לבקש מהמשתמש לבחור תמונה מאפליקציית הגלריה.

Kotlin

val image: InputImage
try {
    image = InputImage.fromFilePath(context, uri)
} catch (e: IOException) {
    e.printStackTrace()
}

Java

InputImage image;
try {
    image = InputImage.fromFilePath(context, uri);
} catch (IOException e) {
    e.printStackTrace();
}

שימוש ב-ByteBuffer או ב-ByteArray

כדי ליצור אובייקט InputImage מ-ByteBuffer או מ-ByteArray, תחילה עליך לחשב את מידת סיבוב התמונה כמתואר למעלה עבור קלט media.Image. לאחר מכן, יוצרים את האובייקט InputImage באמצעות המאגר או המערך, יחד עם הגובה, הרוחב, פורמט קידוד הצבע ומידת הסיבוב של התמונה:

Kotlin

val image = InputImage.fromByteBuffer(
        byteBuffer,
        /* image width */ 480,
        /* image height */ 360,
        rotationDegrees,
        InputImage.IMAGE_FORMAT_NV21 // or IMAGE_FORMAT_YV12
)
// Or:
val image = InputImage.fromByteArray(
        byteArray,
        /* image width */ 480,
        /* image height */ 360,
        rotationDegrees,
        InputImage.IMAGE_FORMAT_NV21 // or IMAGE_FORMAT_YV12
)

Java

InputImage image = InputImage.fromByteBuffer(byteBuffer,
        /* image width */ 480,
        /* image height */ 360,
        rotationDegrees,
        InputImage.IMAGE_FORMAT_NV21 // or IMAGE_FORMAT_YV12
);
// Or:
InputImage image = InputImage.fromByteArray(
        byteArray,
        /* image width */480,
        /* image height */360,
        rotation,
        InputImage.IMAGE_FORMAT_NV21 // or IMAGE_FORMAT_YV12
);

באמצעות Bitmap

כדי ליצור אובייקט InputImage מאובייקט Bitmap, צריך ליצור את ההצהרה הבאה:

Kotlin

val image = InputImage.fromBitmap(bitmap, 0)

Java

InputImage image = InputImage.fromBitmap(bitmap, rotationDegree);

התמונה מיוצגת על ידי אובייקט Bitmap יחד עם מעלות סיבוב.

3. קבלת מכונה של BarcodeScanner

Kotlin

val scanner = BarcodeScanning.getClient()
// Or, to specify the formats to recognize:
// val scanner = BarcodeScanning.getClient(options)

Java

BarcodeScanner scanner = BarcodeScanning.getClient();
// Or, to specify the formats to recognize:
// BarcodeScanner scanner = BarcodeScanning.getClient(options);

4. עיבוד התמונה

יש להעביר את התמונה לשיטה process:

Kotlin

val result = scanner.process(image)
        .addOnSuccessListener { barcodes ->
            // Task completed successfully
            // ...
        }
        .addOnFailureListener {
            // Task failed with an exception
            // ...
        }

Java

Task<List<Barcode>> result = scanner.process(image)
        .addOnSuccessListener(new OnSuccessListener<List<Barcode>>() {
            @Override
            public void onSuccess(List<Barcode> barcodes) {
                // Task completed successfully
                // ...
            }
        })
        .addOnFailureListener(new OnFailureListener() {
            @Override
            public void onFailure(@NonNull Exception e) {
                // Task failed with an exception
                // ...
            }
        });

5. קבלת מידע מברקודים

אם פעולת זיהוי הברקוד תסתיים בהצלחה, רשימה של אובייקטים מסוג Barcode תועבר למאזינים להצלחה. כל אובייקט Barcode מייצג ברקוד שזוהה בתמונה. עבור כל ברקוד אפשר לראות את הקואורדינטות התוחמות שלו בתמונת הקלט, וכן את הנתונים הגולמיים שמקודדים באמצעות הברקוד. כמו כן, אם סורק הברקוד הצליח לקבוע את סוג הנתונים שמקודדים באמצעות הברקוד, תוכלו לקבל אובייקט שמכיל נתונים מנתחים.

למשל:

Kotlin

for (barcode in barcodes) {
    val bounds = barcode.boundingBox
    val corners = barcode.cornerPoints

    val rawValue = barcode.rawValue

    val valueType = barcode.valueType
    // See API reference for complete list of supported types
    when (valueType) {
        Barcode.TYPE_WIFI -> {
            val ssid = barcode.wifi!!.ssid
            val password = barcode.wifi!!.password
            val type = barcode.wifi!!.encryptionType
        }
        Barcode.TYPE_URL -> {
            val title = barcode.url!!.title
            val url = barcode.url!!.url
        }
    }
}

Java

for (Barcode barcode: barcodes) {
    Rect bounds = barcode.getBoundingBox();
    Point[] corners = barcode.getCornerPoints();

    String rawValue = barcode.getRawValue();

    int valueType = barcode.getValueType();
    // See API reference for complete list of supported types
    switch (valueType) {
        case Barcode.TYPE_WIFI:
            String ssid = barcode.getWifi().getSsid();
            String password = barcode.getWifi().getPassword();
            int type = barcode.getWifi().getEncryptionType();
            break;
        case Barcode.TYPE_URL:
            String title = barcode.getUrl().getTitle();
            String url = barcode.getUrl().getUrl();
            break;
    }
}

טיפים לשיפור הביצועים בזמן אמת

אם רוצים לסרוק ברקודים באפליקציה בזמן אמת, יש לפעול לפי ההנחיות הבאות כדי להגיע למסגרות הפריימים הטובות ביותר:

  • לא כדאי לצלם קלט ברזולוציה המקורית של המצלמה. במכשירים מסוימים, צילום קלט ברזולוציה המקורית יוצר תמונות גדולות במיוחד (יותר מ-10 מגה פיקסל). לאחר מכן, זמן האחזור נמוך מאוד ואין יתרון לדיוק. במקום זאת, יש לבקש את הגודל רק מהמצלמה הנדרשת לזיהוי ברקוד, בדרך כלל לא יותר מ-2 מגה-פיקסל.

    אם מהירות הסריקה חשובה, אפשר להקטין את הרזולוציה של התמונה. עם זאת, חשוב לזכור את הדרישות המינימליות בנוגע לגודל הברקוד, כפי שמתואר למעלה.

    אם ניסית לזהות ברקודים מרצף של שידורי וידאו, המזהה עשוי להניב תוצאות שונות בין פריים לפריים. עליך להמתין עד לקבלת סדרה רציפה של אותו ערך כדי להיות בטוח שאת מחזירה תוצאה טובה.

    ספרת הביקורת אינה נתמכת ב-ITF וב-CODE-39.

  • אם משתמשים ב- Camera או ב-camera2 API, מווסתים את השיחות למזהה. אם פריים חדש של וידאו הופך לזמין בזמן שהמזהה פועל, משחררים את הפריים. לדוגמה, אפשר לעיין בקורס VisionProcessorBase באפליקציה למתחילים.
  • אם בחרת להשתמש ב-API CameraX, יש לוודא ששיטת ההחזרה מוגדרת לערך ברירת המחדל ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST. כך ניתן להבטיח שתמונה אחת בלבד תישלח לניתוח בכל פעם. אם יופקו תמונות נוספות כשהמנתח יהיה עסוק, הן יושמטו אוטומטית ולא יתווספו לתור. אחרי שהתמונה תנתח, על ידי קריאה ל-Imageproxy.close() , התמונה הבאה שתישלח.
  • אם משתמשים בפלט של מזהה-העל כדי להציג גרפיקה על תמונת הקלט, תחילה יש לקבל את התוצאה מ-ML Kit, ולאחר מכן לעבד את התמונה ואת שכבת-העל בפעולה אחת. כך מתבצע עיבוד למשטח התצוגה פעם אחת בלבד עבור כל מסגרת קלט. כדי לראות דוגמה, אפשר לעיין בכיתות CameraSourcePreview ו- GraphicOverlay באפליקציה למתחילים.
  • אם משתמשים ב-Camera2 API, צריך לצלם את התמונות בפורמט ImageFormat.YUV_420_888. אם משתמשים בגרסה הישנה יותר של ממשק ה-API של המצלמה, יש לצלם תמונות בפורמט ImageFormat.NV21.