Text in Bildern mit Cloud Vision sicher mit Firebase Auth und Functions auf Apple-Plattformen erkennen

Wenn Sie eine Google Cloud API von Ihrer App aus aufrufen möchten, müssen Sie eine Zwischen-REST-API erstellen, die die Autorisierung verarbeitet und geheime Werte wie API-Schlüssel schützt. Sie müssen dann Code in Ihrer mobilen 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 und Firebase Functions. So erhalten Sie ein verwaltetes, serverloses Gateway zu Google Cloud APIs, das die Authentifizierung übernimmt und mit vorgefertigten SDKs von Ihrer mobilen App aufgerufen werden kann.

In diesem Leitfaden wird gezeigt, wie Sie mit dieser Methode die Cloud Vision API von Ihrer App aus aufrufen. Mit dieser Methode können alle authentifizierten Nutzer über Ihr Cloud-Projekt auf die in Rechnung gestellten Cloud Vision-Dienste zugreifen. Überlegen Sie daher, ob dieser Authentifizierungsmechanismus für Ihren Anwendungsfall ausreicht, bevor Sie fortfahren.

Hinweis

Projekt konfigurieren

Verwenden Sie Swift Package Manager, um Firebase-Abhängigkeiten zu installieren und zu verwalten.

1. Öffnen Sie Ihr App-Projekt und gehen Sie in Xcode zu File > Add Packages (Datei > Pakete hinzufügen).
2. Fügen Sie bei entsprechender Aufforderung das Firebase Apple Platforms SDK-Repository hinzu:

  https://github.com/firebase/firebase-ios-sdk.git

3. Wählen Sie die Bibliothek Firebase ML aus.
4. Fügen Sie das Flag -ObjC dem Abschnitt Other Linker Flags (Weitere Verknüpfungsmerker) in den Build-Einstellungen des Ziels hinzu.
5. Wenn Sie fertig, beginnt Xcode automatisch, Ihre Abhängigkeiten im Hintergrund aufzulösen und herunterzuladen.

Führe als Nächstes einige In-App-Einrichtungen durch:

1. Importieren Sie Firebase in Ihre App:

   Swift

   import FirebaseMLModelDownloader

   Objective-C

   @import FirebaseMLModelDownloader;

Es sind nur noch ein paar Konfigurationsschritte erforderlich:

1. Wenn Sie cloudbasierte APIs für Ihr Projekt noch nicht aktiviert haben, tun Sie dies jetzt:

   1. Öffnen Sie in der Firebase-Konsole die Seite Firebase MLAPIs.

   2. Wenn Sie Ihr Projekt noch nicht auf den Blaze-Tarif umgestellt haben, klicken Sie auf Upgrade. Sie werden nur dann zum Umstellen aufgefordert, wenn Ihr Projekt nicht den Blaze-Tarif hat.

      Cloud-basierte APIs können nur in Projekten auf Blaze-Ebene verwendet werden.

   3. Wenn cloudbasierte APIs noch nicht aktiviert sind, klicken Sie auf Cloudbasierte APIs aktivieren.
2. Konfigurieren Sie Ihre vorhandenen Firebase API-Schlüssel so, dass der Zugriff auf die Cloud Vision API nicht zulässig ist:
   1. Öffnen Sie in der Cloud Console die Seite Anmeldedaten.
   2. Öffnen Sie für jeden API-Schlüssel in der Liste die Bearbeitungsansicht und fügen Sie im Abschnitt „Einschränkungen für Schlüssel“ alle verfügbaren APIs außer der Cloud Vision API zur Liste hinzu.

Aufrufbare Funktion bereitstellen

Stellen Sie als Nächstes die Cloud Functions-Funktion bereit, mit der Sie eine Brücke zwischen Ihrer App und der Cloud Vision API herstellen. Das functions-samples-Repository enthält ein Beispiel, das Sie verwenden können.

Standardmäßig können nur authentifizierte Nutzer Ihrer App über diese Funktion auf die Cloud Vision API zugreifen. Sie können die Funktion für unterschiedliche Anforderungen anpassen.

So stellen Sie die Funktion bereit:

1. Klonen Sie das Repository „functions-samples“ oder laden Sie es herunter und wechseln Sie in das Verzeichnis Node-1st-gen/vision-annotate-image:

   git clone https://github.com/firebase/functions-samples
   cd Node-1st-gen/vision-annotate-image
   

2. Installieren Sie die Abhängigkeiten:

   cd functions
   npm install
   cd ..

3. Wenn Sie die Firebase CLI noch nicht haben, installieren Sie sie.
4. Initialisieren Sie ein Firebase-Projekt im Verzeichnis vision-annotate-image. Wählen Sie bei Aufforderung Ihr Projekt in der Liste aus.

   firebase init

5. Die Funktion bereitstellen:

   firebase deploy --only functions:annotateImage

Firebase Auth zur App hinzufügen

Die oben bereitgestellte aufrufbare Funktion lehnt alle Anfragen von nicht authentifizierten Nutzern Ihrer App ab. Wenn 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

Verwenden Sie den Swift Package Manager, um die Cloud Functions for Firebase-Bibliothek zu installieren.

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

1. Eingabebild vorbereiten

guard let imageData = uiImage.jpegData(compressionQuality: 1.0) else { return }
let base64encodedImage = imageData.base64EncodedString()

NSData *imageData = UIImageJPEGRepresentation(uiImage, 1.0f);
NSString *base64encodedImage =
  [imageData base64EncodedStringWithOptions:NSDataBase64Encoding76CharacterLineLength];

2. Aufrufbare Funktion zum Erkennen von Text aufrufen

1. Initialisieren Sie zuerst eine Cloud Functions-Instanz:

   Swift

   lazy var functions = Functions.functions()
   

   Objective-C

   @property(strong, nonatomic) FIRFunctions *functions;
   

2. Erstellen Sie die Anfrage. Die Cloud Vision API unterstützt zwei Typen der Texterkennung: TEXT_DETECTION und DOCUMENT_TEXT_DETECTION. Informationen zu den Unterschieden zwischen den beiden Anwendungsfällen finden Sie in der Cloud Vision OCR-Dokumentation.

   Swift

   let requestData = [
     "image": ["content": base64encodedImage],
     "features": ["type": "TEXT_DETECTION"],
     "imageContext": ["languageHints": ["en"]]
   ]
   

   Objective-C

   NSDictionary *requestData = @{
     @"image": @{@"content": base64encodedImage},
     @"features": @{@"type": @"TEXT_DETECTION"},
     @"imageContext": @{@"languageHints": @[@"en"]}
   };
   

3. Rufen Sie abschließend die Funktion auf:

   Swift

   do {
     let result = try await functions.httpsCallable("annotateImage").call(requestData)
     print(result)
   } catch {
     if let error = error as NSError? {
       if error.domain == FunctionsErrorDomain {
         let code = FunctionsErrorCode(rawValue: error.code)
         let message = error.localizedDescription
         let details = error.userInfo[FunctionsErrorDetailsKey]
       }
       // ...
     }
   }
   

   Objective-C

   [[_functions HTTPSCallableWithName:@"annotateImage"]
                             callWithObject:requestData
                                 completion:^(FIRHTTPSCallableResult * _Nullable result, NSError * _Nullable error) {
           if (error) {
             if ([error.domain isEqualToString:@"com.firebase.functions"]) {
               FIRFunctionsErrorCode code = error.code;
               NSString *message = error.localizedDescription;
               NSObject *details = error.userInfo[@"details"];
             }
             // ...
           }
           // Function completed succesfully
           // Get information about labeled objects
   
         }];
   

3. Text aus Blöcken erkannten Texts extrahieren

Wenn der Texterkennungsvorgang erfolgreich war, wird im Ergebnis der Aufgabe eine JSON-Antwort vom Typ BatchAnnotateImagesResponse zurückgegeben. Die Texthinweise finden Sie im Objekt fullTextAnnotation.

Sie können den erkannten Text als String im Feld text abrufen. Beispiel:

let annotation = result.flatMap { $0.data as? [String: Any] }
    .flatMap { $0["fullTextAnnotation"] }
    .flatMap { $0 as? [String: Any] }
guard let annotation = annotation else { return }

if let text = annotation["text"] as? String {
  print("Complete annotation: \(text)")
}

NSDictionary *annotation = result.data[@"fullTextAnnotation"];
if (!annotation) { return; }
NSLog(@"\nComplete annotation:");
NSLog(@"\n%@", annotation[@"text"]);

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

guard let pages = annotation["pages"] as? [[String: Any]] else { return }
for page in pages {
  var pageText = ""
  guard let blocks = page["blocks"] as? [[String: Any]] else { continue }
  for block in blocks {
    var blockText = ""
    guard let paragraphs = block["paragraphs"] as? [[String: Any]] else { continue }
    for paragraph in paragraphs {
      var paragraphText = ""
      guard let words = paragraph["words"] as? [[String: Any]] else { continue }
      for word in words {
        var wordText = ""
        guard let symbols = word["symbols"] as? [[String: Any]] else { continue }
        for symbol in symbols {
          let text = symbol["text"] as? String ?? ""
          let confidence = symbol["confidence"] as? Float ?? 0.0
          wordText += text
          print("Symbol text: \(text) (confidence: \(confidence)%n")
        }
        let confidence = word["confidence"] as? Float ?? 0.0
        print("Word text: \(wordText) (confidence: \(confidence)%n%n")
        let boundingBox = word["boundingBox"] as? [Float] ?? [0.0, 0.0, 0.0, 0.0]
        print("Word bounding box: \(boundingBox.description)%n")
        paragraphText += wordText
      }
      print("%nParagraph: %n\(paragraphText)%n")
      let boundingBox = paragraph["boundingBox"] as? [Float] ?? [0.0, 0.0, 0.0, 0.0]
      print("Paragraph bounding box: \(boundingBox)%n")
      let confidence = paragraph["confidence"] as? Float ?? 0.0
      print("Paragraph Confidence: \(confidence)%n")
      blockText += paragraphText
    }
    pageText += blockText
  }
}

for (NSDictionary *page in annotation[@"pages"]) {
  NSMutableString *pageText = [NSMutableString new];
  for (NSDictionary *block in page[@"blocks"]) {
    NSMutableString *blockText = [NSMutableString new];
    for (NSDictionary *paragraph in block[@"paragraphs"]) {
      NSMutableString *paragraphText = [NSMutableString new];
      for (NSDictionary *word in paragraph[@"words"]) {
        NSMutableString *wordText = [NSMutableString new];
        for (NSDictionary *symbol in word[@"symbols"]) {
          NSString *text = symbol[@"text"];
          [wordText appendString:text];
          NSLog(@"Symbol text: %@ (confidence: %@\n", text, symbol[@"confidence"]);
        }
        NSLog(@"Word text: %@ (confidence: %@\n\n", wordText, word[@"confidence"]);
        NSLog(@"Word bounding box: %@\n", word[@"boundingBox"]);
        [paragraphText appendString:wordText];
      }
      NSLog(@"\nParagraph: \n%@\n", paragraphText);
      NSLog(@"Paragraph bounding box: %@\n", paragraph[@"boundingBox"]);
      NSLog(@"Paragraph Confidence: %@\n", paragraph[@"confidence"]);
      [blockText appendString:paragraphText];
    }
    [pageText appendString:blockText];
  }
}