Text in Bildern mit ML Kit unter Android erkennen

Mit ML Kit können Sie Text in Bildern oder Videos erkennen, z. B. Text von ein Straßenschild. Die Hauptmerkmale dieser Funktion sind:

Jetzt ausprobieren

• Probieren Sie die Beispiel-App aus, um sehen Sie sich ein Anwendungsbeispiel für diese API an.
• Probieren Sie den Code mit der Codelab erhalten.

Hinweis

1. Fügen Sie in der Datei build.gradle auf Projektebene das Maven-Repository von Google in die Abschnitte buildscript und allprojects ein.

2. Fügen Sie die Abhängigkeiten für die ML Kit-Android-Bibliotheken in die Gradle-Datei auf App-Ebene Ihres Moduls ein, die normalerweise app/build.gradle ist:

   So bündeln Sie das Modell mit Ihrer App:

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

   Verwendung des Modells in den 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 konfigurieren Sie Ihre App so, dass das Modell nach der Einrichtung automatisch auf das Gerät heruntergeladen wird. Ihre App über den Play Store installiert wurde. Fügen Sie dazu Folgendes hinzu: Deklaration in der Datei AndroidManifest.xml deiner App an:

   <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 prüfen und den Download anfordern über die ModuleInstallClient API der Google Play-Dienste. Wenn Sie das Installationszeitmodell nicht aktivieren herunterladen oder expliziten Download anfordern, wird das Modell zuerst wenn Sie den Scanner ausführen. Anfragen, die Sie stellen, bevor der Download Fertigstellen, erzeugen 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 ein Bitmap-, media.Image-, ByteBuffer-, Byte-Array oder eine Datei im . Übergeben Sie dann das InputImage-Objekt an den Die Methode processImage von TextRecognizer.

Sie können eine InputImage erstellen aus verschiedenen Quellen stammen. Diese werden im Folgenden erläutert.

Mit einem media.Image

So erstellen Sie eine InputImage: media.Image-Objekts erstellen, beispielsweise wenn Sie ein Bild von einem des Geräts an, übergeben Sie das media.Image-Objekt und die Drehung auf InputImage.fromMediaImage().

Wenn Sie das <ph type="x-smartling-placeholder"></ph> CameraX-Bibliothek, den OnImageCapturedListener und ImageAnalysis.Analyzer-Klassen berechnen 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 Drehungsgrad des Bildes anzeigt, lässt sich anhand des Drehungsgrads des Geräts und der Ausrichtung der Kamera berechnen. Sensor im Gerät:

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 Wert für Rotationsgrad auf InputImage.fromMediaImage():

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

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

Datei-URI verwenden

So erstellen Sie eine InputImage: aus einem Datei-URI entfernen möchten, übergeben Sie den App-Kontext und den Datei-URI an InputImage.fromFilePath(). Dies ist nützlich, wenn Sie Verwenden Sie den Intent ACTION_GET_CONTENT, um den Nutzer zur Auswahl aufzufordern ein Bild aus ihrer Galerie-App.

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

ByteBuffer oder ByteArray verwenden

So erstellen Sie eine InputImage: aus einem ByteBuffer- oder ByteArray-Objekt zu erstellen, berechnen Sie Drehung wie zuvor für die media.Image-Eingabe beschrieben. Erstellen Sie dann das InputImage-Objekt mit dem Zwischenspeicher oder Array Höhe, Breite, Farbcodierungsformat und Drehungsgrad:

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 eine InputImage: Bitmap-Objekt zu erstellen, nehmen Sie folgende Deklaration vor:

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

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

Das Bild wird durch ein Bitmap-Objekt in Verbindung mit Drehungsgrad 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. Text aus erkannten Textblöcken extrahieren

Wenn die Texterkennung erfolgreich ist, wird ein Text-Objekt an die Zuhörer zu präsentieren. Ein Text-Objekt enthält den vollständigen Text, der erkannt wird in das Bild und null oder mehr TextBlock-Objekte.

Jedes TextBlock steht für einen rechteckigen Textblock. die null oder mehr Line-Objekte enthält. Jedes Das Objekt Line stellt eine Textzeile dar, die null enthält oder mehr Element-Objekte. Jedes Element -Objekt stellt ein Wort oder eine wortähnliche Entität dar, die null oder mehr enthält Symbol-Objekte. Jedes Symbol -Objekt ein Zeichen, eine Zahl oder eine wortähnliche Entität darstellt.

Für jedes TextBlock, Line, Element- und Symbol-Objekts enthält, den in der Region erkannten Text abrufen kann, die Begrenzungskoordinaten der Region, Region und viele andere Attribute wie Rotationsinformationen, Konfidenzwert usw.

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 ML Kit Text richtig erkennt, müssen die Eingabebilder Folgendes enthalten: Text, der durch ausreichende Pixeldaten dargestellt wird. Idealerweise sollte jedes Zeichen mindestens 16 x 16 Pixel groß sein. In der Regel gibt es keine Verbesserung der Genauigkeit bei Zeichen, die größer als 24 x 24 Pixel sind.

  Ein Bild im Format 640 x 480 eignet sich also gut zum Scannen einer Visitenkarte. das die volle Breite des Bilds ausfüllt. So scannen Sie ein aufgedrucktes Dokument: im Schriftformat erforderlich ist, ist möglicherweise ein Bild mit 720 x 1280 Pixeln erforderlich.

• Ein schlechter Bildfokus kann die Genauigkeit der Texterkennung beeinträchtigen. Wenn nicht akzeptable Ergebnisse erzielen, versuchen Sie, das Bild erneut aufzunehmen.

• Wenn Sie Text in einer Echtzeitanwendung erkennen, sollten Sie die Gesamtabmessungen der Eingabebilder. Kleiner Bilder schneller verarbeitet werden. Stellen Sie sicher, dass der Text möglichst viel möglichst genaue Bilder zu erstellen und sie mit geringerer Auflösung zu erfassen. Dabei ist die Genauigkeit oben genannten Anforderungen). Weitere Informationen finden Sie unter Tipps zur Leistungssteigerung

Tipps zur Verbesserung der Leistung

• Wenn Sie das Camera oder camera2 API, drosselt Aufrufe an den Detektor. Wenn ein neues Video wenn der Detektor aktiv ist, lassen Sie den Frame weg. Weitere Informationen finden Sie in der <ph type="x-smartling-placeholder"></ph> VisionProcessorBase in der Beispielanwendung „Kurzanleitung“ finden Sie ein Beispiel.
• Wenn Sie die CameraX API verwenden, Achten Sie darauf, dass die Rückstaustrategie auf den Standardwert eingestellt ist ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST Dadurch wird garantiert, dass jeweils nur ein Bild zur Analyse geliefert wird. Wenn weitere Bilder wenn der Analysator beschäftigt ist, werden sie automatisch abgebrochen und nicht in die Warteschlange Auslieferung. Sobald das zu analysierende Bild durch Aufrufen ImageProxy.close() wird das nächste Bild geliefert.
• Wenn Sie die Ausgabe des Detektors verwenden, um Grafiken Eingabebild, rufen Sie zuerst das Ergebnis aus ML Kit ab und rendern Sie das Bild in einem Schritt übereinanderlegen. Dadurch wird die Anzeigeoberfläche gerendert, für jeden Eingabe-Frame nur einmal. Weitere Informationen finden Sie in der <ph type="x-smartling-placeholder"></ph> CameraSourcePreview und GraphicOverlay-Klassen in der Schnellstart-Beispiel-App als Beispiel.
• Wenn Sie die Camera2 API verwenden, nehmen Sie Bilder in ImageFormat.YUV_420_888-Format. Wenn Sie die ältere Camera API verwenden, nehmen Sie Bilder in ImageFormat.NV21-Format.
• Nehmen Sie Bilder mit einer niedrigeren Auflösung auf. Denken Sie jedoch auch daran, Anforderungen an die Bildabmessungen dieser API.