在 2024 年演示日活动中，观看有关如何使用 Firebase 构建和运行 AI 赋能应用的演示。立即观看。

หน้านี้ได้รับการแปลโดย Cloud Translation API

สแกนบาร์โค้ดด้วย ML Kit บน Android

คุณสามารถใช้ ML Kit เพื่อจดจำและถอดรหัสบาร์โค้ดได้

firebase-ml-vision เวอร์ชัน 24.0.0 เปิดตัวรูปแบบการสแกนบาร์โค้ดแบบใหม่ ซึ่งมาพร้อมกับการปรับปรุงอย่างมีนัยสำคัญทั้งในด้านเวลาในการตอบสนองและความแม่นยำเมื่อเทียบกับรุ่นเก่า นอกจากนี้ API เวอร์ชันล่าสุดยังช่วยให้คุณเข้าถึงไบต์ดิบของข้อมูลบาร์โค้ดที่ไม่ได้เข้ารหัส UTF-8 ได้ด้วย

อย่าลืมเพิ่มfirebase-ml-vision-barcode-modelโมดูลใหม่ ลงในทรัพยากรที่ต้องพึ่งพาของโปรเจ็กต์เพื่อใช้รูปแบบใหม่

ก่อนเริ่มต้น

เพิ่ม Firebase ลงในโปรเจ็กต์ Android หากยังไม่ได้ดำเนินการ

เพิ่มทรัพยากร Dependency สำหรับคลัง ML Kit สำหรับ Android ลงในไฟล์ Gradle ของโมดูล (ระดับแอป) (โดยปกติจะเป็น app/build.gradle)

apply plugin: 'com.android.application'
apply plugin: 'com.google.gms.google-services'

dependencies {
  // ...

  implementation 'com.google.firebase:firebase-ml-vision:24.0.3'
  implementation 'com.google.firebase:firebase-ml-vision-barcode-model:16.0.1'
}

หลักเกณฑ์เกี่ยวกับรูปภาพอินพุต

หากต้องการให้ ML Kit อ่านบาร์โค้ดได้อย่างแม่นยำ รูปภาพอินพุตต้องมีบาร์โค้ดที่แสดงโดยข้อมูลพิกเซลที่เพียงพอ

ข้อกําหนดเฉพาะของข้อมูลพิกเซลจะขึ้นอยู่กับทั้งประเภทของบาร์โค้ดและจํานวนข้อมูลที่เข้ารหัสในบาร์โค้ด (เนื่องจากบาร์โค้ดส่วนใหญ่รองรับเพย์โหลดที่มีความยาวแปรผัน) โดยทั่วไป หน่วยที่เล็กที่สุดที่สื่อความหมายของบาร์โค้ดควรมีความกว้างอย่างน้อย 2 พิกเซล (และสำหรับรหัส 2 มิติ ความสูงควรอยู่ที่ 2 พิกเซล)

ตัวอย่างเช่น บาร์โค้ด EAN-13 ประกอบด้วยแถบและเว้นวรรคที่มีความกว้าง 1, 2, 3 หรือ 4 หน่วย ดังนั้นรูปภาพบาร์โค้ด EAN-13 ควรมีแถบและเว้นวรรคที่มีความกว้างอย่างน้อย 2, 4, 6 และ 8 พิกเซล เนื่องจากบาร์โค้ด EAN-13 มีความกว้างทั้งหมด 95 หน่วย บาร์โค้ดจึงควรมีความกว้างอย่างน้อย 190 พิกเซล

รูปแบบที่หนาแน่นกว่า เช่น PDF417 ต้องใช้ขนาดพิกเซลที่ใหญ่ขึ้นเพื่อให้ ML Kit อ่านได้อย่างน่าเชื่อถือ ตัวอย่างเช่น รหัส PDF417 อาจมี "คำ" กว้าง 17 หน่วยได้สูงสุด 34 รายการในแถวเดียว ซึ่งควรมีความกว้างอย่างน้อย 1,156 พิกเซล
รูปภาพที่โฟกัสไม่ดีอาจทำให้การสแกนไม่ถูกต้อง หากไม่พบผลลัพธ์ที่ยอมรับได้ ให้ลองขอให้ผู้ใช้ถ่ายภาพอีกครั้ง
สําหรับการใช้งานทั่วไป เราขอแนะนําให้ใช้รูปภาพที่มีความละเอียดสูงขึ้น (เช่น 1280x720 หรือ 1920x1080) ซึ่งจะช่วยให้ตรวจจับบาร์โค้ดได้ในระยะที่ห่างจากกล้องมากขึ้น

อย่างไรก็ตาม ในแอปพลิเคชันที่เวลาในการตอบสนองมีความสำคัญ คุณสามารถปรับปรุงประสิทธิภาพโดยการจับภาพที่มีความละเอียดต่ำลง แต่กำหนดให้บาร์โค้ดเป็นส่วนประกอบส่วนใหญ่ของรูปภาพอินพุต และดูเคล็ดลับในการปรับปรุงประสิทธิภาพแบบเรียลไทม์

1. กำหนดค่าตัวตรวจจับบาร์โค้ด

หากทราบว่าต้องการอ่านบาร์โค้ดรูปแบบใด คุณสามารถปรับปรุงความเร็วของเครื่องมือตรวจหาบาร์โค้ดได้โดยกำหนดค่าให้ตรวจหาเฉพาะรูปแบบเหล่านั้น

เช่น หากต้องการตรวจหาเฉพาะ Aztec Code และ QR Code ให้สร้างออบเจ็กต์ FirebaseVisionBarcodeDetectorOptions ดังตัวอย่างต่อไปนี้

Java

FirebaseVisionBarcodeDetectorOptions options =
        new FirebaseVisionBarcodeDetectorOptions.Builder()
        .setBarcodeFormats(
                FirebaseVisionBarcode.FORMAT_QR_CODE,
                FirebaseVisionBarcode.FORMAT_AZTEC)
        .build();

Kotlin

val options = FirebaseVisionBarcodeDetectorOptions.Builder()
        .setBarcodeFormats(
                FirebaseVisionBarcode.FORMAT_QR_CODE,
                FirebaseVisionBarcode.FORMAT_AZTEC)
        .build()

ระบบรองรับรูปแบบต่อไปนี้

Code 128 (FORMAT_CODE_128)
Code 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)
คิวอาร์โค้ด (FORMAT_QR_CODE)
PDF417 (FORMAT_PDF417)
ภาษาแอซเท็ก (FORMAT_AZTEC)
Data Matrix (FORMAT_DATA_MATRIX)

2. เรียกใช้เครื่องมือตรวจจับบาร์โค้ด

หากต้องการจดจำบาร์โค้ดในรูปภาพ ให้สร้างออบเจ็กต์ FirebaseVisionImage จาก Bitmap, media.Image, ByteBuffer, อาร์เรย์ไบต์ หรือไฟล์ในอุปกรณ์ จากนั้นส่งออบเจ็กต์ FirebaseVisionImage ไปยังเมธอด detectInImage ของ FirebaseVisionBarcodeDetector

สร้างออบเจ็กต์ FirebaseVisionImage จากรูปภาพ

หากต้องการสร้างออบเจ็กต์ FirebaseVisionImage จากออบเจ็กต์ media.Image เช่น เมื่อจับภาพจากกล้องของอุปกรณ์ ให้ส่งออบเจ็กต์ media.Image และการหมุนของรูปภาพไปยัง FirebaseVisionImage.fromMediaImage()

หากคุณใช้ไลบรารี CameraX คลาส OnImageCapturedListener และ ImageAnalysis.Analyzer จะคํานวณค่าการหมุนให้คุณ คุณจึงต้องแปลงการหมุนเป็นค่าคงที่ ROTATION_ ของ ML Kit ก่อนเรียกใช้ FirebaseVisionImage.fromMediaImage()

Java

private class YourAnalyzer implements ImageAnalysis.Analyzer {

    private int degreesToFirebaseRotation(int degrees) {
        switch (degrees) {
            case 0:
                return FirebaseVisionImageMetadata.ROTATION_0;
            case 90:
                return FirebaseVisionImageMetadata.ROTATION_90;
            case 180:
                return FirebaseVisionImageMetadata.ROTATION_180;
            case 270:
                return FirebaseVisionImageMetadata.ROTATION_270;
            default:
                throw new IllegalArgumentException(
                        "Rotation must be 0, 90, 180, or 270.");
        }
    }

    @Override
    public void analyze(ImageProxy imageProxy, int degrees) {
        if (imageProxy == null || imageProxy.getImage() == null) {
            return;
        }
        Image mediaImage = imageProxy.getImage();
        int rotation = degreesToFirebaseRotation(degrees);
        FirebaseVisionImage image =
                FirebaseVisionImage.fromMediaImage(mediaImage, rotation);
        // Pass image to an ML Kit Vision API
        // ...
    }
}

Kotlin

private class YourImageAnalyzer : ImageAnalysis.Analyzer {
    private fun degreesToFirebaseRotation(degrees: Int): Int = when(degrees) {
        0 -> FirebaseVisionImageMetadata.ROTATION_0
        90 -> FirebaseVisionImageMetadata.ROTATION_90
        180 -> FirebaseVisionImageMetadata.ROTATION_180
        270 -> FirebaseVisionImageMetadata.ROTATION_270
        else -> throw Exception("Rotation must be 0, 90, 180, or 270.")
    }

    override fun analyze(imageProxy: ImageProxy?, degrees: Int) {
        val mediaImage = imageProxy?.image
        val imageRotation = degreesToFirebaseRotation(degrees)
        if (mediaImage != null) {
            val image = FirebaseVisionImage.fromMediaImage(mediaImage, imageRotation)
            // Pass image to an ML Kit Vision API
            // ...
        }
    }
}

หากไม่ได้ใช้คลังกล้องที่ระบุการหมุนของรูปภาพ คุณจะคำนวณการหมุนได้จากการหมุนของอุปกรณ์และการวางแนวของเซ็นเซอร์กล้องในอุปกรณ์ โดยทำดังนี้

Java

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

/**
 * 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, Context context)
        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);

    // On most devices, the sensor orientation is 90 degrees, but for some
    // devices it is 270 degrees. For devices with a sensor orientation of
    // 270, rotate the image an additional 180 ((270 + 270) % 360) degrees.
    CameraManager cameraManager = (CameraManager) context.getSystemService(CAMERA_SERVICE);
    int sensorOrientation = cameraManager
            .getCameraCharacteristics(cameraId)
            .get(CameraCharacteristics.SENSOR_ORIENTATION);
    rotationCompensation = (rotationCompensation + sensorOrientation + 270) % 360;

    // Return the corresponding FirebaseVisionImageMetadata rotation value.
    int result;
    switch (rotationCompensation) {
        case 0:
            result = FirebaseVisionImageMetadata.ROTATION_0;
            break;
        case 90:
            result = FirebaseVisionImageMetadata.ROTATION_90;
            break;
        case 180:
            result = FirebaseVisionImageMetadata.ROTATION_180;
            break;
        case 270:
            result = FirebaseVisionImageMetadata.ROTATION_270;
            break;
        default:
            result = FirebaseVisionImageMetadata.ROTATION_0;
            Log.e(TAG, "Bad rotation value: " + rotationCompensation);
    }
    return result;
}VisionImage.java

Kotlin

private val ORIENTATIONS = SparseIntArray()

init {
    ORIENTATIONS.append(Surface.ROTATION_0, 90)
    ORIENTATIONS.append(Surface.ROTATION_90, 0)
    ORIENTATIONS.append(Surface.ROTATION_180, 270)
    ORIENTATIONS.append(Surface.ROTATION_270, 180)
}
/**
 * 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, context: Context): 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)

    // On most devices, the sensor orientation is 90 degrees, but for some
    // devices it is 270 degrees. For devices with a sensor orientation of
    // 270, rotate the image an additional 180 ((270 + 270) % 360) degrees.
    val cameraManager = context.getSystemService(CAMERA_SERVICE) as CameraManager
    val sensorOrientation = cameraManager
            .getCameraCharacteristics(cameraId)
            .get(CameraCharacteristics.SENSOR_ORIENTATION)!!
    rotationCompensation = (rotationCompensation + sensorOrientation + 270) % 360

    // Return the corresponding FirebaseVisionImageMetadata rotation value.
    val result: Int
    when (rotationCompensation) {
        0 -> result = FirebaseVisionImageMetadata.ROTATION_0
        90 -> result = FirebaseVisionImageMetadata.ROTATION_90
        180 -> result = FirebaseVisionImageMetadata.ROTATION_180
        270 -> result = FirebaseVisionImageMetadata.ROTATION_270
        else -> {
            result = FirebaseVisionImageMetadata.ROTATION_0
            Log.e(TAG, "Bad rotation value: $rotationCompensation")
        }
    }
    return result
}VisionImage.kt

จากนั้นส่งออบเจ็กต์ media.Image และค่าการหมุนไปยัง FirebaseVisionImage.fromMediaImage() ดังนี้

Java

FirebaseVisionImage image = FirebaseVisionImage.fromMediaImage(mediaImage, rotation);VisionImage.java

Kotlin

val image = FirebaseVisionImage.fromMediaImage(mediaImage, rotation)VisionImage.kt

หากต้องการสร้างออบเจ็กต์ FirebaseVisionImage จาก URI ของไฟล์ ให้ส่งบริบทแอปและ URI ของไฟล์ไปยัง FirebaseVisionImage.fromFilePath() ซึ่งจะมีประโยชน์เมื่อคุณใช้ Intent ACTION_GET_CONTENT เพื่อแจ้งให้ผู้ใช้เลือกรูปภาพจากแอปแกลเลอรี
Java
```
FirebaseVisionImage image;
try {
    image = FirebaseVisionImage.fromFilePath(context, uri);
} catch (IOException e) {
    e.printStackTrace();
}VisionImage.java
```
Kotlin
```
val image: FirebaseVisionImage
try {
    image = FirebaseVisionImage.fromFilePath(context, uri)
} catch (e: IOException) {
    e.printStackTrace()
}VisionImage.kt
```

หากต้องการสร้างออบเจ็กต์ FirebaseVisionImage จาก ByteBuffer หรืออาร์เรย์ไบต์ ให้คำนวณการหมุนภาพก่อนตามที่อธิบายไว้ข้างต้นสำหรับอินพุต media.Image

จากนั้นสร้างออบเจ็กต์ FirebaseVisionImageMetadata ซึ่งมีข้อมูลความสูง กว้าง รูปแบบการเข้ารหัสสี และการหมุนของรูปภาพ

Java

FirebaseVisionImageMetadata metadata = new FirebaseVisionImageMetadata.Builder()
        .setWidth(480)   // 480x360 is typically sufficient for
        .setHeight(360)  // image recognition
        .setFormat(FirebaseVisionImageMetadata.IMAGE_FORMAT_NV21)
        .setRotation(rotation)
        .build();VisionImage.java

Kotlin

val metadata = FirebaseVisionImageMetadata.Builder()
        .setWidth(480) // 480x360 is typically sufficient for
        .setHeight(360) // image recognition
        .setFormat(FirebaseVisionImageMetadata.IMAGE_FORMAT_NV21)
        .setRotation(rotation)
        .build()VisionImage.kt

ใช้บัฟเฟอร์หรืออาร์เรย์ รวมถึงออบเจ็กต์ข้อมูลเมตาเพื่อสร้างออบเจ็กต์ FirebaseVisionImage ดังนี้

Java

FirebaseVisionImage image = FirebaseVisionImage.fromByteBuffer(buffer, metadata);
// Or: FirebaseVisionImage image = FirebaseVisionImage.fromByteArray(byteArray, metadata);VisionImage.java

Kotlin

val image = FirebaseVisionImage.fromByteBuffer(buffer, metadata)
// Or: val image = FirebaseVisionImage.fromByteArray(byteArray, metadata)VisionImage.kt

วิธีสร้างออบเจ็กต์ FirebaseVisionImage จากออบเจ็กต์ Bitmap
Java
```
FirebaseVisionImage image = FirebaseVisionImage.fromBitmap(bitmap);VisionImage.java
```
Kotlin
```
val image = FirebaseVisionImage.fromBitmap(bitmap)VisionImage.kt
```
รูปภาพที่แสดงโดยออบเจ็กต์ Bitmap ต้องตั้งตรงโดยไม่จำเป็นต้องหมุนเพิ่มเติม

รับอินสแตนซ์ของ FirebaseVisionBarcodeDetector

Java

FirebaseVisionBarcodeDetector detector = FirebaseVision.getInstance()
        .getVisionBarcodeDetector();
// Or, to specify the formats to recognize:
// FirebaseVisionBarcodeDetector detector = FirebaseVision.getInstance()
//        .getVisionBarcodeDetector(options);

Kotlin

val detector = FirebaseVision.getInstance()
        .visionBarcodeDetector
// Or, to specify the formats to recognize:
// val detector = FirebaseVision.getInstance()
//        .getVisionBarcodeDetector(options)

สุดท้าย ให้ส่งรูปภาพไปยังเมธอด detectInImage ดังนี้

Java

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

Kotlin

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

3. รับข้อมูลจากบาร์โค้ด

หากการดําเนินการจดจําบาร์โค้ดสําเร็จ ระบบจะส่งรายการออบเจ็กต์ FirebaseVisionBarcode ไปยัง Listener ของความสําเร็จ ออบเจ็กต์ FirebaseVisionBarcode แต่ละรายการแสดงบาร์โค้ดที่ตรวจพบในรูปภาพ สําหรับบาร์โค้ดแต่ละรายการ คุณจะดูพิกัดขอบเขตได้ในรูปภาพอินพุต รวมถึงดูข้อมูลดิบที่บาร์โค้ดเข้ารหัสไว้ นอกจากนี้ หากเครื่องตรวจหาบาร์โค้ดสามารถระบุประเภทข้อมูลที่เข้ารหัสโดยบาร์โค้ด คุณจะได้รับออบเจ็กต์ที่มีข้อมูลที่แยกวิเคราะห์แล้ว

เช่น

Java

for (FirebaseVisionBarcode 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 FirebaseVisionBarcode.TYPE_WIFI:
            String ssid = barcode.getWifi().getSsid();
            String password = barcode.getWifi().getPassword();
            int type = barcode.getWifi().getEncryptionType();
            break;
        case FirebaseVisionBarcode.TYPE_URL:
            String title = barcode.getUrl().getTitle();
            String url = barcode.getUrl().getUrl();
            break;
    }
}

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) {
        FirebaseVisionBarcode.TYPE_WIFI -> {
            val ssid = barcode.wifi!!.ssid
            val password = barcode.wifi!!.password
            val type = barcode.wifi!!.encryptionType
        }
        FirebaseVisionBarcode.TYPE_URL -> {
            val title = barcode.url!!.title
            val url = barcode.url!!.url
        }
    }
}

เคล็ดลับในการปรับปรุงประสิทธิภาพแบบเรียลไทม์

หากต้องการสแกนบาร์โค้ดในแอปพลิเคชันแบบเรียลไทม์ ให้ทำตามหลักเกณฑ์ต่อไปนี้เพื่อให้ได้อัตราเฟรมที่ดีที่สุด

อย่าจับภาพอินพุตที่ความละเอียดจริงของกล้อง ในอุปกรณ์บางรุ่น การจับภาพอินพุตที่ความละเอียดระดับเนทีฟจะสร้างรูปภาพขนาดใหญ่มาก (มากกว่า 10 เมกะพิกเซล) ซึ่งส่งผลให้เวลาในการตอบสนองแย่มากโดยไม่มีจุดดีในด้านความแม่นยำ แต่ให้ขอเฉพาะขนาดจากกล้องที่จําเป็นสําหรับการตรวจหาบาร์โค้ด ซึ่งโดยปกติแล้วจะไม่เกิน 2 ล้านพิกเซล

หากความเร็วในการสแกนสำคัญ คุณก็ลดความละเอียดในการจับภาพรูปภาพได้ อย่างไรก็ตาม โปรดคำนึงถึงข้อกำหนดขนาดบาร์โค้ดขั้นต่ำที่ระบุไว้ข้างต้น
จำกัดการเรียกใช้เครื่องตรวจจับ หากเฟรมวิดีโอใหม่พร้อมใช้งานขณะที่ตัวตรวจจับทำงานอยู่ ให้วางเฟรม
หากคุณใช้เอาต์พุตของตัวตรวจจับเพื่อวางกราฟิกซ้อนทับบนรูปภาพอินพุต ให้รับผลลัพธ์จาก ML Kit ก่อน จากนั้นจึงแสดงผลรูปภาพและวางซ้อนในขั้นตอนเดียว ซึ่งจะทำให้คุณแสดงผลไปยังพื้นผิวการแสดงผลเพียงครั้งเดียวสำหรับเฟรมอินพุตแต่ละเฟรม
หากคุณใช้ Camera2 API ให้จับภาพในรูปแบบ ImageFormat.YUV_420_888

หากคุณใช้ Camera API เวอร์ชันเก่า ให้ถ่ายภาพในรูปแบบ ImageFormat.NV21