Bezpieczne rozpoznawanie tekstu na obrazach dzięki Cloud Vision przy użyciu uwierzytelniania i funkcji Firebase w systemie Android

W celu wywołania API Google Cloud z aplikacji, trzeba utworzyć pośredni REST API, które upoważnienie uchwyty i chroni tajne wartości, takie jak klucze API. Następnie trzeba napisać kod w aplikacji mobilnej do uwierzytelniania i komunikować się z tego pośredniego usługi.

Jednym ze sposobów, aby stworzyć ten REST API jest przy użyciu uwierzytelniania Firebase i funkcji, co daje zarządzany, bramy Serverless do API Google chmura uwierzytelniania uchwyty i mogą być wywoływane z aplikacji mobilnej z gotowych zestawów SDK.

Ten poradnik pokazuje, jak używać tej techniki zadzwonić Vision Cloud API z aplikacji. Ta metoda pozwoli wszystkim uwierzytelnionym użytkownikom dostęp do usługi cloud Vision zapowiadane przez projekcie chmurze, więc rozważyć, czy ten mechanizm uwierzytelniania jest wystarczająca dla przypadku użycia przed kontynuowaniem.

Zanim zaczniesz

Skonfiguruj swój projekt

  1. Jeśli tego nie zrobiłeś, dodaj Firebase do projektu Android .
  2. Jeśli nie masz już włączone API chmurze dla swojego projektu, zrób to teraz:

    1. Otwórz stronę Firebase ML API konsoli Firebase.
    2. Jeśli nie masz już uaktualniony projekt do planu cenowego Blaze, kliknij przycisk Zmień , aby to zrobić. (Zostaniesz poproszony, aby uaktualnić tylko jeśli projekt nie jest na planie Blaze).

      Jedynie projekty Blaze szczebla mogą używać API chmurowej.

    3. Jeśli API w chmurze nie są już włączone, kliknij przycisk Włącz API chmurowej .
  3. Skonfigurować istniejące Firebase klucze API, aby uniemożliwić dostęp do API Chmura Vision:
    1. Otwórz Poświadczenia stronę konsoli chmurze.
    2. Dla każdego klucza API na liście, otwórz widok edycji, aw sekcji głównych ograniczeń, dodać wszystkie dostępne API wyjątkiem API Chmura wizja listy.

Wdrożyć funkcję wpłacone

Następnie wdrożyć funkcji Chmura będzie używany do zniwelowania swoją aplikację i API Chmura Vision. functions-samples repozytorium zawiera przykład można użyć.

Domyślnie dostęp do API Chmura Vision dzięki tej funkcji pozwoli tylko uwierzytelnionych użytkowników swojej aplikacji dostęp do API Chmura Vision. Można zmodyfikować funkcję do różnych wymagań.

Aby wdrożyć funkcję:

  1. Klon lub pobrać funkcje-samples repo i zmiana vision-annotate-image katalogu:
    git clone https://github.com/firebase/functions-samples
    cd vision-annotate-image
    
  2. Zainstalować zależności:
    cd functions
    npm install
    cd ..
    
  3. Jeśli nie masz Firebase CLI, zainstalować go .
  4. Zainicjować projekt Firebase w vision-annotate-image katalogu. Gdy pojawi się monit, wybierz swój projekt na liście.
    firebase init
  5. Wdrożyć funkcję:
    firebase deploy --only functions:annotateImage

Dodaj Firebase Auth do swojej aplikacji

Wywoływalnym funkcja rozmieszczone powyżej odrzuci każdą prośbę niewyspecjalizowanych uwierzytelnione użytkowników aplikacji. Jeśli nie zostało to jeszcze zrobione, trzeba będzie dodać Firebase Auth do swojej aplikacji.

Dodaj niezbędne zależności do swojej aplikacji

  • Dodaj zależności dla funkcji Firebase i gson Android biblioteki do modułu (ok szczebla) Gradle plik (zazwyczaj app / build.gradle):
    implementation 'com.google.firebase:firebase-functions:20.1.0'
    implementation 'com.google.code.gson:gson:2.8.6'
    
  • Teraz jesteś gotowy, aby rozpocząć rozpoznawanie tekstu w obrazach.

    1. Przygotować obraz wejściowy

    W celu wywołania Chmura Vision, obraz musi być sformatowany jako ciąg base64 zakodowany. Do przetwarzania obrazu z zapisanym URI pliku:
    1. Uzyskać obraz jako Bitmap obiektu:

      Java

      Bitmap bitmap = MediaStore.Images.Media.getBitmap(getContentResolver(), uri);

      Kotlin+KTX

      var bitmap: Bitmap = MediaStore.Images.Media.getBitmap(contentResolver, uri)
    2. Opcjonalnie, skalowanie w dół obrazu, aby zaoszczędzić na przepustowości. Zobacz Chmura Vision rozmiary zaleca graficznych.

      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

      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

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

      Kotlin+KTX

      // Scale down bitmap size
      bitmap = scaleBitmapDown(bitmap, 640)
    3. Konwersja obiektu bitmapy do base64 zakodowany ciąg znaków:

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

      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)
    4. Obraz przedstawiony przez Bitmap obiektu musi być wyprostowany, bez dodatkowego obrotu wymagane.

    2. Wywołaj wywoływalnym funkcja rozpoznawania tekstu

    Aby rozpoznać tekst w obrazie, należy wywołać funkcję wpłacone, przekazując żądania JSON Chmura Vision .

    1. Po pierwsze, zainicjować instancję funkcji Cloud

      Java

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

      Kotlin+KTX

      private lateinit var functions: FirebaseFunctions
      // ...
      functions = Firebase.functions
      
    2. Zdefiniować sposób wywoływania funkcji:

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

      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))
                  }
      }
      
    3. Tworzenie żądania JSON. Vision Cloud API obsługuje dwa typy wykrywania tekstem: TEXT_DETECTION i DOCUMENT_TEXT_DETECTION . Zobacz Chmura Vision OCR Dokumenty do różnicy między tymi dwoma przypadkami użycia.

      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

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

      Ewentualnie dostarczyć wskazówek językowych do pomocy przy wykrywaniu języka (patrz obsługiwanych języków ):

      Java

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

      Kotlin+KTX

      val imageContext = JsonObject()
      val languageHints = JsonArray()
      languageHints.add("en")
      imageContext.add("languageHints", languageHints)
      request.add("imageContext", imageContext)
      
    4. Wreszcie, należy wywołać funkcję:

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

      Kotlin+KTX

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

    3. Wyciąg z bloków tekstu rozpoznanym tekście

    Jeśli operacja się powiedzie rozpoznawania tekstu, odpowiedź JSON BatchAnnotateImagesResponse zostaną zwrócone w wyniku zadania jest. Adnotacje tekstowe mogą być znalezione w fullTextAnnotation obiektu.

    Można uzyskać rozpoznany tekst jako ciąg w text polu. Na przykład:

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

    Kotlin+KTX

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

    Można również uzyskać informacje na temat konkretnych obszarów obrazu. Dla każdego block , paragraph , word i symbol , można uzyskać tekst rozpoznany w regionie oraz obwiedni współrzędne regionu. Na przykład:

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

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