Firebase is back at Google I/O on May 10! Register now

Erkennen Sie Text in Bildern sicher mit Cloud Vision mit Firebase Auth und Funktionen auf Android

Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

Um eine Google Cloud-API von Ihrer App aus aufzurufen, müssen Sie eine zwischengeschaltete REST-API erstellen, die die Autorisierung verarbeitet und geheime Werte wie API-Schlüssel schützt. Sie müssen dann Code in Ihre mobile App schreiben, um sich bei diesem Zwischendienst zu authentifizieren und mit ihm zu kommunizieren.

Eine Möglichkeit, diese REST-API zu erstellen, ist die Verwendung von Firebase Authentication and Functions, wodurch Sie ein verwaltetes, serverloses Gateway zu Google Cloud-APIs erhalten, das die Authentifizierung verarbeitet und von Ihrer mobilen App mit vorgefertigten SDKs aufgerufen werden kann.

In diesem Leitfaden wird gezeigt, wie Sie diese Technik verwenden, um die Cloud Vision-API von Ihrer App aus aufzurufen. Diese Methode ermöglicht allen authentifizierten Benutzern den Zugriff auf kostenpflichtige Cloud Vision-Dienste über Ihr Cloud-Projekt. Überlegen Sie also, ob dieser Authentifizierungsmechanismus für Ihren Anwendungsfall ausreicht, bevor Sie fortfahren.

Bevor Sie beginnen

Konfigurieren Sie Ihr Projekt

  1. Fügen Sie Ihrem Android-Projekt Firebase hinzu, falls Sie dies noch nicht getan haben .

  2. Wenn Sie noch keine Cloud-basierten APIs für Ihr Projekt aktiviert haben, tun Sie dies jetzt:

    1. Öffnen Sie die Seite Firebase ML APIs der Firebase-Konsole.

    2. Wenn Sie Ihr Projekt noch nicht auf den Blaze-Preisplan aktualisiert haben, klicken Sie dazu auf Upgrade . (Sie werden nur dann zum Upgrade aufgefordert, wenn Ihr Projekt nicht im Blaze-Plan enthalten ist.)

      Nur Projekte auf Blaze-Ebene können Cloud-basierte APIs verwenden.

    3. Wenn Cloud-basierte APIs nicht bereits aktiviert sind, klicken Sie auf Cloud-basierte APIs aktivieren .
  3. Konfigurieren Sie Ihre vorhandenen Firebase-API-Schlüssel, um den Zugriff auf die Cloud Vision-API zu verbieten:
    1. Öffnen Sie die Anmeldedaten -Seite der Cloud-Konsole.
    2. Öffnen Sie für jeden API-Schlüssel in der Liste die Bearbeitungsansicht und fügen Sie im Abschnitt „Schlüsseleinschränkungen“ alle verfügbaren APIs mit Ausnahme der Cloud Vision-API zur Liste hinzu.

Stellen Sie die aufrufbare Funktion bereit

Stellen Sie als Nächstes die Cloud-Funktion bereit, mit der Sie Ihre App und die Cloud Vision-API überbrücken. Das Repository functions-samples enthält ein Beispiel, das Sie verwenden können.

Standardmäßig ermöglicht der Zugriff auf die Cloud Vision-API über diese Funktion nur authentifizierten Benutzern Ihrer App den Zugriff auf die Cloud Vision-API. Sie können die Funktion für unterschiedliche Anforderungen modifizieren.

So stellen Sie die Funktion bereit:

  1. Klonen oder laden Sie das Repository functions-samples herunter und wechseln Sie in das Verzeichnis vision-annotate-image :
    git clone https://github.com/firebase/functions-samples
cd vision-annotate-image
  2. Abhängigkeiten installieren:
    cd functions
npm install
cd ..
  3. Wenn Sie die Firebase-Befehlszeilenschnittstelle nicht haben, installieren Sie sie .
  4. Initialisieren Sie ein Firebase-Projekt im Verzeichnis vision-annotate-image . Wenn Sie dazu aufgefordert werden, wählen Sie Ihr Projekt in der Liste aus. 
    firebase init
  5. Stellen Sie die Funktion bereit: 
    firebase deploy --only functions:annotateImage

Fügen Sie Ihrer App Firebase Auth hinzu

Die oben bereitgestellte aufrufbare Funktion lehnt alle Anfragen von nicht authentifizierten Benutzern Ihrer App ab. Falls Sie dies noch nicht getan haben, müssen Sie Ihrer App Firebase Auth hinzufügen.

Fügen Sie Ihrer App die erforderlichen Abhängigkeiten hinzu

  • Fügen Sie die Abhängigkeiten für die Firebase-Funktionen und gson-Android-Bibliotheken zu Ihrer Modul-Gradle-Datei (auf App-Ebene) hinzu (normalerweise app/build.gradle): 
    implementation 'com.google.firebase:firebase-functions:20.2.2'
implementation 'com.google.code.gson:gson:2.8.6'

    • Jetzt können Sie mit dem Erkennen von Text in Bildern beginnen.

    1. Bereiten Sie das Eingabebild vor

    Um Cloud Vision aufzurufen, muss das Bild als base64-codierter String formatiert werden. So verarbeiten Sie ein Bild aus einer gespeicherten Datei-URI:
    1. Holen Sie sich das Bild als Bitmap -Objekt:

      Kotlin+KTX

      var bitmap: Bitmap = MediaStore.Images.Media.getBitmap(contentResolver, uri)

      Java

      Bitmap bitmap = MediaStore.Images.Media.getBitmap(getContentResolver(), uri);
    2. Optional können Sie das Bild verkleinern, um Bandbreite zu sparen. Sehen Sie sich die von Cloud Vision empfohlenen Bildgrößen an.

      Kotlin+KTX

      private fun scaleBitmapDown(bitmap: Bitmap, maxDimension: Int): Bitmap {
    val originalWidth = bitmap.width
    val originalHeight = bitmap.height
    var resizedWidth = maxDimension
    var resizedHeight = maxDimension
    if (originalHeight > originalWidth) {
        resizedHeight = maxDimension
        resizedWidth =
                (resizedHeight * originalWidth.toFloat() / originalHeight.toFloat()).toInt()
    } else if (originalWidth > originalHeight) {
        resizedWidth = maxDimension
        resizedHeight =
                (resizedWidth * originalHeight.toFloat() / originalWidth.toFloat()).toInt()
    } else if (originalHeight == originalWidth) {
        resizedHeight = maxDimension
        resizedWidth = maxDimension
    }
    return Bitmap.createScaledBitmap(bitmap, resizedWidth, resizedHeight, false)
}

      Java

      private Bitmap scaleBitmapDown(Bitmap bitmap, int maxDimension) {
    int originalWidth = bitmap.getWidth();
    int originalHeight = bitmap.getHeight();
    int resizedWidth = maxDimension;
    int resizedHeight = maxDimension;

    if (originalHeight > originalWidth) {
        resizedHeight = maxDimension;
        resizedWidth = (int) (resizedHeight * (float) originalWidth / (float) originalHeight);
    } else if (originalWidth > originalHeight) {
        resizedWidth = maxDimension;
        resizedHeight = (int) (resizedWidth * (float) originalHeight / (float) originalWidth);
    } else if (originalHeight == originalWidth) {
        resizedHeight = maxDimension;
        resizedWidth = maxDimension;
    }
    return Bitmap.createScaledBitmap(bitmap, resizedWidth, resizedHeight, false);
}

      Kotlin+KTX

      // Scale down bitmap size
bitmap = scaleBitmapDown(bitmap, 640)

      Java

      // Scale down bitmap size
bitmap = scaleBitmapDown(bitmap, 640);
    3. Konvertieren Sie das Bitmap-Objekt in eine base64-codierte Zeichenfolge:

      Kotlin+KTX

      // Convert bitmap to base64 encoded string
val byteArrayOutputStream = ByteArrayOutputStream()
bitmap.compress(Bitmap.CompressFormat.JPEG, 100, byteArrayOutputStream)
val imageBytes: ByteArray = byteArrayOutputStream.toByteArray()
val base64encoded = Base64.encodeToString(imageBytes, Base64.NO_WRAP)

      Java

      // Convert bitmap to base64 encoded string
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
bitmap.compress(Bitmap.CompressFormat.JPEG, 100, byteArrayOutputStream);
byte[] imageBytes = byteArrayOutputStream.toByteArray();
String base64encoded = Base64.encodeToString(imageBytes, Base64.NO_WRAP);
      4. Das vom Bitmap -Objekt dargestellte Bild muss aufrecht stehen, ohne dass eine zusätzliche Drehung erforderlich ist.

    2. Rufen Sie die aufrufbare Funktion auf, um Text zu erkennen

    Um Text in einem Bild zu erkennen, rufen Sie die aufrufbare Funktion auf und übergeben Sie eine JSON Cloud Vision-Anfrage .

    1. Initialisieren Sie zunächst eine Instanz von Cloud Functions:

      Kotlin+KTX

      private lateinit var functions: FirebaseFunctions
// ...
functions = Firebase.functions

      Java

      private FirebaseFunctions mFunctions;
// ...
mFunctions = FirebaseFunctions.getInstance();

    2. Definieren Sie eine Methode zum Aufrufen der Funktion:

      Kotlin+KTX

      private fun annotateImage(requestJson: String): Task<JsonElement> {
    return functions
            .getHttpsCallable("annotateImage")
            .call(requestJson)
            .continueWith { task ->
                // This continuation runs on either success or failure, but if the task
                // has failed then result will throw an Exception which will be
                // propagated down.
                val result = task.result?.data
                JsonParser.parseString(Gson().toJson(result))
            }
}

      Java

      private Task<JsonElement> annotateImage(String requestJson) {
    return mFunctions
            .getHttpsCallable("annotateImage")
            .call(requestJson)
            .continueWith(new Continuation<HttpsCallableResult, JsonElement>() {
                @Override
                public JsonElement then(@NonNull Task<HttpsCallableResult> task) {
                    // This continuation runs on either success or failure, but if the task
                    // has failed then getResult() will throw an Exception which will be
                    // propagated down.
                    return JsonParser.parseString(new Gson().toJson(task.getResult().getData()));
                }
            });
}

    3. Erstellen Sie die JSON-Anforderung. Die Cloud Vision API unterstützt zwei Typen der Texterkennung: TEXT_DETECTION und DOCUMENT_TEXT_DETECTION . Informationen zum Unterschied zwischen den beiden Anwendungsfällen finden Sie in den Cloud Vision OCR-Dokumenten .

      Kotlin+KTX

      // Create json request to cloud vision
val request = JsonObject()
// Add image to request
val image = JsonObject()
image.add("content", JsonPrimitive(base64encoded))
request.add("image", image)
//Add features to the request
val feature = JsonObject()
feature.add("type", JsonPrimitive("TEXT_DETECTION"))
// Alternatively, for DOCUMENT_TEXT_DETECTION:
// feature.add("type", JsonPrimitive("DOCUMENT_TEXT_DETECTION"))
val features = JsonArray()
features.add(feature)
request.add("features", features)

      Java

      // Create json request to cloud vision
JsonObject request = new JsonObject();
// Add image to request
JsonObject image = new JsonObject();
image.add("content", new JsonPrimitive(base64encoded));
request.add("image", image);
//Add features to the request
JsonObject feature = new JsonObject();
feature.add("type", new JsonPrimitive("TEXT_DETECTION"));
// Alternatively, for DOCUMENT_TEXT_DETECTION:
//feature.add("type", new JsonPrimitive("DOCUMENT_TEXT_DETECTION"));
JsonArray features = new JsonArray();
features.add(feature);
request.add("features", features);

      Geben Sie optional Sprachhinweise an, um die Spracherkennung zu unterstützen (siehe unterstützte Sprachen ):

      Kotlin+KTX

      val imageContext = JsonObject()
val languageHints = JsonArray()
languageHints.add("en")
imageContext.add("languageHints", languageHints)
request.add("imageContext", imageContext)

      Java

      JsonObject imageContext = new JsonObject();
JsonArray languageHints = new JsonArray();
languageHints.add("en");
imageContext.add("languageHints", languageHints);
request.add("imageContext", imageContext);

    4. Rufen Sie abschließend die Funktion auf:

      Kotlin+KTX

      annotateImage(request.toString())
        .addOnCompleteListener { task ->
            if (!task.isSuccessful) {
                // Task failed with an exception
                // ...
            } else {
                // Task completed successfully
                // ...
            }
        }

      Java

      annotateImage(request.toString())
        .addOnCompleteListener(new OnCompleteListener<JsonElement>() {
            @Override
            public void onComplete(@NonNull Task<JsonElement> task) {
                if (!task.isSuccessful()) {
                    // Task failed with an exception
                    // ...
                } else {
                    // Task completed successfully
                    // ...
                }
            }
        });

    3. Text aus erkannten Textblöcken extrahieren

    Wenn der Texterkennungsvorgang erfolgreich ist, wird eine JSON-Antwort von BatchAnnotateImagesResponse im Ergebnis der Aufgabe zurückgegeben. Die Textanmerkungen befinden sich im fullTextAnnotation Objekt.

    Sie können den erkannten Text als Zeichenfolge im text erhalten. Zum Beispiel:

    Kotlin+KTX

    val annotation = task.result!!.asJsonArray[0].asJsonObject["fullTextAnnotation"].asJsonObject
System.out.format("%nComplete annotation:")
System.out.format("%n%s", annotation["text"].asString)

    Java

    JsonObject annotation = task.getResult().getAsJsonArray().get(0).getAsJsonObject().get("fullTextAnnotation").getAsJsonObject();
System.out.format("%nComplete annotation:%n");
System.out.format("%s%n", annotation.get("text").getAsString());

    Sie können auch spezifische Informationen zu Bereichen des Bildes erhalten. Für jeden block , paragraph , word und symbol können Sie den in der Region erkannten Text und die Begrenzungskoordinaten der Region abrufen. Zum Beispiel:

    Kotlin+KTX

    for (page in annotation["pages"].asJsonArray) {
    var pageText = ""
    for (block in page.asJsonObject["blocks"].asJsonArray) {
        var blockText = ""
        for (para in block.asJsonObject["paragraphs"].asJsonArray) {
            var paraText = ""
            for (word in para.asJsonObject["words"].asJsonArray) {
                var wordText = ""
                for (symbol in word.asJsonObject["symbols"].asJsonArray) {
                    wordText += symbol.asJsonObject["text"].asString
                    System.out.format("Symbol text: %s (confidence: %f)%n",
                        symbol.asJsonObject["text"].asString, symbol.asJsonObject["confidence"].asFloat)
                }
                System.out.format("Word text: %s (confidence: %f)%n%n", wordText,
                    word.asJsonObject["confidence"].asFloat)
                System.out.format("Word bounding box: %s%n", word.asJsonObject["boundingBox"])
                paraText = String.format("%s%s ", paraText, wordText)
            }
            System.out.format("%nParagraph: %n%s%n", paraText)
            System.out.format("Paragraph bounding box: %s%n", para.asJsonObject["boundingBox"])
            System.out.format("Paragraph Confidence: %f%n", para.asJsonObject["confidence"].asFloat)
            blockText += paraText
        }
        pageText += blockText
    }
}

    Java

    for (JsonElement page : annotation.get("pages").getAsJsonArray()) {
    StringBuilder pageText = new StringBuilder();
    for (JsonElement block : page.getAsJsonObject().get("blocks").getAsJsonArray()) {
        StringBuilder blockText = new StringBuilder();
        for (JsonElement para : block.getAsJsonObject().get("paragraphs").getAsJsonArray()) {
            StringBuilder paraText = new StringBuilder();
            for (JsonElement word : para.getAsJsonObject().get("words").getAsJsonArray()) {
                StringBuilder wordText = new StringBuilder();
                for (JsonElement symbol : word.getAsJsonObject().get("symbols").getAsJsonArray()) {
                    wordText.append(symbol.getAsJsonObject().get("text").getAsString());
                    System.out.format("Symbol text: %s (confidence: %f)%n", symbol.getAsJsonObject().get("text").getAsString(), symbol.getAsJsonObject().get("confidence").getAsFloat());
                }
                System.out.format("Word text: %s (confidence: %f)%n%n", wordText.toString(), word.getAsJsonObject().get("confidence").getAsFloat());
                System.out.format("Word bounding box: %s%n", word.getAsJsonObject().get("boundingBox"));
                paraText.append(wordText.toString()).append(" ");
            }
            System.out.format("%nParagraph:%n%s%n", paraText);
            System.out.format("Paragraph bounding box: %s%n", para.getAsJsonObject().get("boundingBox"));
            System.out.format("Paragraph Confidence: %f%n", para.getAsJsonObject().get("confidence").getAsFloat());
            blockText.append(paraText);
        }
        pageText.append(blockText);
    }
}