Text in Bildern mit ML Kit auf Android-Geräten erkennen

Sie können ML Kit verwenden, um Text in Bildern oder Videos zu erkennen, z. B. auf einem Straßenschild. Diese Funktion zeichnet sich durch folgende Eigenschaften aus:

Ausprobieren

• Probieren Sie die Beispiel-App aus, um sich ein Beispiel für die Verwendung dieser API anzusehen.
• Probieren Sie den Code selbst mit dem Codelab aus.

Hinweis

1. Achten Sie darauf, dass Sie in der Datei build.gradle auf Projektebene das Maven-Repository von Google in die Abschnitte buildscript und allprojects aufnehmen.

2. Fügen Sie der Gradle-Datei auf Modulebene (in der Regel app/build.gradle) die Abhängigkeiten für die Android-Bibliotheken des ML Kits hinzu:

   Wenn Sie das Modell mit Ihrer App kombinieren:

   dependencies {
     // To recognize Latin script
     implementation 'com.google.mlkit:text-recognition:16.0.0'
   
     // To recognize Chinese script
     implementation 'com.google.mlkit:text-recognition-chinese:16.0.0'
   
     // To recognize Devanagari script
     implementation 'com.google.mlkit:text-recognition-devanagari:16.0.0'
   
     // To recognize Japanese script
     implementation 'com.google.mlkit:text-recognition-japanese:16.0.0'
   
     // To recognize Korean script
     implementation 'com.google.mlkit:text-recognition-korean:16.0.0'
   }
   

   Zur Verwendung des Modells in Google Play-Diensten:

   dependencies {
     // To recognize Latin script
     implementation 'com.google.android.gms:play-services-mlkit-text-recognition:19.0.0'
   
     // To recognize Chinese script
     implementation 'com.google.android.gms:play-services-mlkit-text-recognition-chinese:16.0.0'
   
     // To recognize Devanagari script
     implementation 'com.google.android.gms:play-services-mlkit-text-recognition-devanagari:16.0.0'
   
     // To recognize Japanese script
     implementation 'com.google.android.gms:play-services-mlkit-text-recognition-japanese:16.0.0'
   
     // To recognize Korean script
     implementation 'com.google.android.gms:play-services-mlkit-text-recognition-korean:16.0.0'
   }
   

3. Wenn Sie das Modell in den Google Play-Diensten verwenden, können Sie die App so konfigurieren, dass das Modell nach der Installation aus dem Play Store automatisch auf das Gerät heruntergeladen wird. Fügen Sie dazu die folgende Deklaration in die Datei AndroidManifest.xml Ihrer App ein:

   <application ...>
         ...
         <meta-data
             android:name="com.google.mlkit.vision.DEPENDENCIES"
             android:value="ocr" >
         <!-- To use multiple models: android:value="ocr,ocr_chinese,ocr_devanagari,ocr_japanese,ocr_korean,..." -->
   </application>
   

   Sie können die Modellverfügbarkeit auch explizit überprüfen und einen Download über die ModuleInstallClient API der Google Play-Dienste anfordern. Wenn Sie das Herunterladen des Modells während der Installation nicht aktivieren oder einen expliziten Download anfordern, wird das Modell beim ersten Ausführen des Scanners heruntergeladen. Anfragen, die vor Abschluss des Downloads gestellt werden, liefern keine Ergebnisse.

1. Instanz von TextRecognizer erstellen

// When using Latin script library
val recognizer = TextRecognition.getClient(TextRecognizerOptions.DEFAULT_OPTIONS)

// When using Chinese script library
val recognizer = TextRecognition.getClient(ChineseTextRecognizerOptions.Builder().build())

// When using Devanagari script library
val recognizer = TextRecognition.getClient(DevanagariTextRecognizerOptions.Builder().build())

// When using Japanese script library
val recognizer = TextRecognition.getClient(JapaneseTextRecognizerOptions.Builder().build())

// When using Korean script library
val recognizer = TextRecognition.getClient(KoreanTextRecognizerOptions.Builder().build())

// When using Latin script library
TextRecognizer recognizer =
  TextRecognition.getClient(TextRecognizerOptions.DEFAULT_OPTIONS);

// When using Chinese script library
TextRecognizer recognizer =
  TextRecognition.getClient(new ChineseTextRecognizerOptions.Builder().build());

// When using Devanagari script library
TextRecognizer recognizer =
  TextRecognition.getClient(new DevanagariTextRecognizerOptions.Builder().build());

// When using Japanese script library
TextRecognizer recognizer =
  TextRecognition.getClient(new JapaneseTextRecognizerOptions.Builder().build());

// When using Korean script library
TextRecognizer recognizer =
  TextRecognition.getClient(new KoreanTextRecognizerOptions.Builder().build());

2. Eingabebild vorbereiten

Um Text in einem Bild zu erkennen, erstellen Sie ein InputImage-Objekt aus einem Bitmap, media.Image, ByteBuffer, einem Bytearray oder einer Datei auf dem Gerät. Übergeben Sie dann das InputImage-Objekt an die Methode processImage von TextRecognizer.

Sie können ein InputImage-Objekt aus verschiedenen Quellen erstellen. Dies wird im Folgenden beschrieben.

Mit einem media.Image

Um ein InputImage-Objekt aus einem media.Image-Objekt zu erstellen, z. B. wenn ein Bild von der Kamera eines Geräts aufgenommen wird, übergeben Sie das media.Image-Objekt und die Rotation des Bildes an InputImage.fromMediaImage().

Wenn Sie die KameraX-Bibliothek verwenden, berechnen die Klassen OnImageCapturedListener und ImageAnalysis.Analyzer den Rotationswert für Sie.

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
            // ...
        }
    }
}

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
          // ...
        }
    }
}

Wenn Sie keine Kamerabibliothek verwenden, die Ihnen den Grad der Drehung des Bildes liefert, können Sie ihn anhand des Grades der Drehung und der Ausrichtung des Kamerasensors im Gerät berechnen:

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
}
MLKitVisionImage.kt

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;
}

Übergeben Sie dann das media.Image-Objekt und den Rotationsgradwert an InputImage.fromMediaImage():

val image = InputImage.fromMediaImage(mediaImage, rotation)
MLKitVisionImage.kt

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

Datei-URI verwenden

Übergeben Sie den Anwendungskontext und den Datei-URI an InputImage.fromFilePath(), um ein InputImage-Objekt aus einem Datei-URI zu erstellen. Dies ist hilfreich, wenn Sie den Intent ACTION_GET_CONTENT verwenden, um den Nutzer aufzufordern, ein Bild aus seiner Galerie-App auszuwählen.

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

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

Mit ByteBuffer oder ByteArray

Um ein InputImage-Objekt aus einer ByteBuffer oder ByteArray zu erstellen, berechnen Sie zuerst den Grad der Bilddrehung, wie zuvor für die media.Image-Eingabe beschrieben. Dann erstellen Sie das InputImage-Objekt mit dem Puffer oder Array. Erstellen Sie dabei Höhe, Breite, Farbcodierungsformat und Rotationsgrad des Bildes:

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

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

Mit einem Bitmap

So erstellen Sie ein InputImage-Objekt aus einem Bitmap-Objekt:

val image = InputImage.fromBitmap(bitmap, 0)
MLKitVisionImage.kt

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

Das Bild wird durch ein Bitmap-Objekt mit Rotationsgrad dargestellt.

3. Bild verarbeiten

Übergeben Sie das Bild an die Methode process:

val result = recognizer.process(image)
        .addOnSuccessListener { visionText ->
            // Task completed successfully
            // ...
        }
        .addOnFailureListener { e ->
            // Task failed with an exception
            // ...
        }
TextRecognitionActivity.kt

Task<Text> result =
        recognizer.process(image)
                .addOnSuccessListener(new OnSuccessListener<Text>() {
                    @Override
                    public void onSuccess(Text visionText) {
                        // Task completed successfully
                        // ...
                    }
                })
                .addOnFailureListener(
                        new OnFailureListener() {
                            @Override
                            public void onFailure(@NonNull Exception e) {
                                // Task failed with an exception
                                // ...
                            }
                        });
TextRecognitionActivity.java

4. Extrahiert Text aus Blöcken für erkannten Text

Wenn der Texterkennungsvorgang erfolgreich ist, wird ein Text-Objekt an den Erfolgs-Listener übergeben. Ein Text-Objekt enthält den vollständigen, im Bild erkannten Text und null oder mehr TextBlock-Objekte.

Jeder TextBlock steht für einen rechteckigen Textblock, der keine oder mehrere Line-Objekte enthält. Jedes Line-Objekt steht für eine Textzeile, die keine oder mehrere Element-Objekte enthält. Jedes Element-Objekt steht für ein Wort oder eine wortähnliche Entität, die keine oder mehrere Symbol-Objekte enthält. Jedes Symbol-Objekt stellt ein Zeichen, eine Ziffer oder eine wortähnliche Entität dar.

Für jedes TextBlock-, Line-, Element- und Symbol-Objekt können Sie den in der Region erkannten Text, die Begrenzungskoordinaten der Region und viele andere Attribute wie Rotationsinformationen, Konfidenzwerte usw. abrufen.

Beispiel:

val resultText = result.text
for (block in result.textBlocks) {
    val blockText = block.text
    val blockCornerPoints = block.cornerPoints
    val blockFrame = block.boundingBox
    for (line in block.lines) {
        val lineText = line.text
        val lineCornerPoints = line.cornerPoints
        val lineFrame = line.boundingBox
        for (element in line.elements) {
            val elementText = element.text
            val elementCornerPoints = element.cornerPoints
            val elementFrame = element.boundingBox
        }
    }
}
TextRecognitionActivity.kt

String resultText = result.getText();
for (Text.TextBlock block : result.getTextBlocks()) {
    String blockText = block.getText();
    Point[] blockCornerPoints = block.getCornerPoints();
    Rect blockFrame = block.getBoundingBox();
    for (Text.Line line : block.getLines()) {
        String lineText = line.getText();
        Point[] lineCornerPoints = line.getCornerPoints();
        Rect lineFrame = line.getBoundingBox();
        for (Text.Element element : line.getElements()) {
            String elementText = element.getText();
            Point[] elementCornerPoints = element.getCornerPoints();
            Rect elementFrame = element.getBoundingBox();
            for (Text.Symbol symbol : element.getSymbols()) {
                String symbolText = symbol.getText();
                Point[] symbolCornerPoints = symbol.getCornerPoints();
                Rect symbolFrame = symbol.getBoundingBox();
            }
        }
    }
}
TextRecognitionActivity.java

Richtlinien für Eingabebilder

• Damit das ML Kit Text korrekt erkennt, müssen Eingabebilder Text enthalten, der durch genügend Pixeldaten dargestellt wird. Idealerweise sollte jedes Zeichen mindestens 16 x 16 Pixel groß sein. Im Allgemeinen besteht kein Vorteil, wenn die Zeichen größer als 24 x 24 Pixel sind.

  So kann beispielsweise ein Bild mit 640 × 480 Pixeln geeignet sein, eine Visitenkarte zu scannen, die die volle Breite des Bildes einnimmt. Zum Scannen eines Dokuments, das auf Papier im Briefformat gedruckt wird, ist möglicherweise ein Bild mit 720 × 1.280 Pixeln erforderlich.

• Ein schlechter Bildfokus kann die Genauigkeit der Texterkennung beeinträchtigen. Wenn Sie keine akzeptablen Ergebnisse erhalten, bitten Sie den Nutzer, das Bild neu aufzunehmen.

• Wenn Sie Text in einer Echtzeitanwendung erkennen, sollten Sie die Gesamtabmessungen der Eingabebilder berücksichtigen. Kleinere Bilder können schneller verarbeitet werden. Damit die Latenz verringert wird, muss der Text einen möglichst großen Teil des Bilds aufnehmen und dabei Bilder mit einer geringeren Auflösung aufnehmen. (Unter Beachtung der oben genannten Anforderungen an die Genauigkeit) Weitere Informationen findest du unter Tipps zur Verbesserung der Leistung.

Tipps zum Verbessern der Leistung

• Wenn Sie die Camera oder camera2 API verwenden, drosseln Sie Aufrufe an den Detektor. Wenn während der Ausführung des Detektors ein neuer Videoframe verfügbar ist, lassen Sie den Frame los. Ein Beispiel dafür finden Sie in der Beispiel-App VisionProcessorBase.
• Wenn du die CameraX API verwendest, muss die Rückdruckstrategie auf den Standardwert ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST festgelegt sein. So ist sichergestellt, dass immer nur ein Bild zur Analyse bereitgestellt wird. Wenn das Analysesystem ausgelastet ist, werden weitere Bilder automatisch gelöscht und nicht in die Auslieferung aufgenommen. Sobald das zu analysierende Bild durch Aufrufen von „ImageProxy.close()“ geschlossen wird, wird das nächste aktuelle Bild gesendet.
• Wenn Sie die Ausgabe des Detektors verwenden, um Grafiken auf dem Eingabebild einzublenden, erhalten Sie zuerst das Ergebnis aus ML Kit und rendern Sie dann das Bild und das Overlay in einem einzigen Schritt. Dies wird für jeden Eingabeframe nur einmal auf der Anzeigeoberfläche gerendert. Ein Beispiel dafür finden Sie in den Beispielklassen CameraSourcePreview und GraphicOverlay in der Kurzanleitung.
• Wenn Sie die Camera2 API verwenden, erfassen Sie Bilder im ImageFormat.YUV_420_888-Format. Wenn Sie die ältere Camera API verwenden, sollten Sie Bilder im Format ImageFormat.NV21 aufnehmen.
• Du kannst Bilder mit einer geringeren Auflösung aufnehmen. Beachten Sie jedoch auch die Anforderungen an die Bildabmessungen dieser API.