זיהוי מאובטח של טקסט בתמונות באמצעות Cloud Vision, באמצעות אימות ופונקציות של Firebase ב-Android

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

אחת הדרכים ליצור את ממשק ה-API ל-REST היא באמצעות Firebase Authentication and Functions, שמספק שער מנוהל ללא שרת לממשקי Google Cloud API שמטפל באימות, ואפשר לקרוא אליו מהאפליקציה לנייד באמצעות ערכות SDK מוכנות מראש.

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

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

הגדרת הפרויקט

  1. אם עדיין לא עשיתם זאת, מוסיפים את Firebase לפרויקט Android.

  2. אם עדיין לא הפעלתם ממשקי API מבוססי-Cloud בפרויקט, עליכם לעשות זאת עכשיו:

    1. פותחים את דף ממשקי ה-API של Firebase ML במסוף Firebase.

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

      רק בפרויקטים ברמת Blaze אפשר להשתמש בממשקי API מבוססי-ענן.

    3. אם ממשקי API מבוססי-ענן עדיין לא מופעלים, לוחצים על הפעלת ממשקי API מבוססי-ענן. ממשקי API.
  3. להגדיר את מפתחות ה-API הקיימים של Firebase כדי למנוע גישה לענן Vision API:
    1. פותחים את הדף Credentials במסוף Cloud.
    2. לכל מפתח API ברשימה, פותחים את תצוגת העריכה ובקטע Key Restrictions מוסיפים לרשימת כל ממשקי ה-API הזמינים למעט Cloud Vision API.

פריסת הפונקציה שניתנת לקריאה

בשלב הבא, פורסים את הפונקציה של Cloud Functions שתשמש לגשר בין האפליקציה לבין Cloud Vision API המאגר functions-samples מכיל דוגמה שאפשר להשתמש בה.

כברירת מחדל, הגישה ל-Cloud Vision API דרך הפונקציה הזו תאפשר רק למשתמשים מאומתים באפליקציה שלכם לגשת ל-Cloud Vision API. אפשר לשנות את הפונקציה לדרישות שונות.

כדי לפרוס את הפונקציה:

  1. שכפול או הורדה של מאגר פונקציות-דוגמאות ומשנים לספרייה Node-1st-gen/vision-annotate-image: 
    git clone https://github.com/firebase/functions-samples
cd Node-1st-gen/vision-annotate-image
  2. יחסי תלות של התקנות: 
    cd functions
npm install
cd ..
  3. אם אין לכם את Firebase CLI, מתקינים אותו.
  4. מאתחלים פרויקט Firebase בספרייה vision-annotate-image. כשמוצגת בקשה, בוחרים את הפרויקט ברשימה. 
    firebase init
  5. פורסים את הפונקציה: 
    firebase deploy --only functions:annotateImage

הוספת אימות מ-Firebase לאפליקציה

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

הוספת יחסי התלות הנדרשים לאפליקציה

  • מוסיפים את התלות בספריות Cloud Functions for Firebase (לקוח) ו-gson ל-Android לקובץ Gradle של המודול (ברמת האפליקציה) (בדרך כלל <project>/<app-module>/build.gradle.kts או <project>/<app-module>/build.gradle): 
    implementation("com.google.firebase:firebase-functions:21.0.0")
implementation("com.google.code.gson:gson:2.8.6")

    • עכשיו אתם מוכנים להתחיל לזהות טקסט בתמונות.

    1. הכנת קובץ הקלט

    כדי לקרוא ל-Cloud Vision, התמונה צריכה להיות בפורמט של מחרוזת בקידוד base64. כדי לעבד תמונה מ-URI של קובץ ששמור:
    1. מקבלים את התמונה כאובייקט Bitmap:

      Kotlin+KTX

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

      Java

      Bitmap bitmap = MediaStore.Images.Media.getBitmap(getContentResolver(), uri);
    2. אפשר גם לשנות את הגודל של התמונה כדי לחסוך ברוחב הפס. גדלים מומלצים של תמונות ב-Cloud Vision.

      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. ממירים את אובייקט מפת הסיביות למחרוזת בקידוד base64:

      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. התמונה שמיוצגת על ידי האובייקט Bitmap חייבת להיות מוצבת בצורה זקופה, ללא צורך בסיבוב נוסף.

    2. הפעלת הפונקציה הניתנת לקריאה כדי לזהות טקסט

    כדי לזהות טקסט בתמונה, יש להפעיל את הפונקציה לקריאה, להעביר בקשת JSON Cloud Vision.

    1. קודם כול, מאתחלים מכונה של Cloud Functions:

      Kotlin+KTX 

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

      Java 

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

    2. מגדירים שיטה להפעלת הפונקציה:

      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. יוצרים את בקשת ה-JSON. Cloud Vision API תומך בשני סוגים של זיהוי טקסט: TEXT_DETECTION ו-DOCUMENT_TEXT_DETECTION. עיון במסמכי התיעוד של Cloud Vision OCR לגבי ההבדל בין שני התרחישים לדוגמה.

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

      אופציונלי: לספק רמזים לשפה כדי לסייע בזיהוי שפה (ראו שפות נתמכות):

      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. בשלב האחרון, מפעילים את הפונקציה:

      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. חילוץ טקסט מבלוקים של טקסט מזוהה

    אם פעולת זיהוי הטקסט מצליחה, תגובת JSON של BatchAnnotateImagesResponse יוחזר בתוצאה של המשימה. הערות הטקסט נמצאות אובייקט fullTextAnnotation.

    הטקסט המזוהה יכול להופיע כמחרוזת בשדה text. לדוגמה:

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

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

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