Digitale Tinte mit ML Kit unter Android erkennen

Mit der digitalen Tintenerkennung von ML Kit können Sie handschriftliche Texte auf einer digitalen Oberfläche in Hunderten von Sprachen erkennen und Skizzen klassifizieren.

Ausprobieren

  • Probieren Sie die Beispiel-App aus, um ein Beispiel für die Verwendung dieser API zu sehen.

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 der Gradle-Datei Ihres Moduls auf App-Ebene die Abhängigkeiten für die ML Kit-Android-Bibliotheken hinzu. Diese ist normalerweise app/build.gradle:
dependencies {
  // ...
  implementation 'com.google.mlkit:digital-ink-recognition:18.1.0'
}

Sie können jetzt mit der Texterkennung in Ink-Objekten beginnen.

Ink-Objekt erstellen

Die Hauptmethode zum Erstellen eines Ink-Objekts besteht darin, es auf einen Touchscreen zu zeichnen. Unter Android können Sie zu diesem Zweck einen Canvas verwenden. Ihre Touch-Event-Handler sollten die addNewTouchEvent()-Methode wie im folgenden Code-Snippet aufrufen, um die Punkte in den Strichen zu speichern, die der Nutzer in das Ink-Objekt eingezeichnet hat.

Dieses allgemeine Muster wird im folgenden Code-Snippet veranschaulicht. Ein ausführlicheres Beispiel finden Sie im ML Kit-Kurzanleitungsbeispiel.

Kotlin

var inkBuilder = Ink.builder()
lateinit var strokeBuilder: Ink.Stroke.Builder

// Call this each time there is a new event.
fun addNewTouchEvent(event: MotionEvent) {
  val action = event.actionMasked
  val x = event.x
  val y = event.y
  var t = System.currentTimeMillis()

  // If your setup does not provide timing information, you can omit the
  // third paramater (t) in the calls to Ink.Point.create
  when (action) {
    MotionEvent.ACTION_DOWN -> {
      strokeBuilder = Ink.Stroke.builder()
      strokeBuilder.addPoint(Ink.Point.create(x, y, t))
    }
    MotionEvent.ACTION_MOVE -> strokeBuilder!!.addPoint(Ink.Point.create(x, y, t))
    MotionEvent.ACTION_UP -> {
      strokeBuilder.addPoint(Ink.Point.create(x, y, t))
      inkBuilder.addStroke(strokeBuilder.build())
    }
    else -> {
      // Action not relevant for ink construction
    }
  }
}

...

// This is what to send to the recognizer.
val ink = inkBuilder.build()

Java

Ink.Builder inkBuilder = Ink.builder();
Ink.Stroke.Builder strokeBuilder;

// Call this each time there is a new event.
public void addNewTouchEvent(MotionEvent event) {
  float x = event.getX();
  float y = event.getY();
  long t = System.currentTimeMillis();

  // If your setup does not provide timing information, you can omit the
  // third paramater (t) in the calls to Ink.Point.create
  int action = event.getActionMasked();
  switch (action) {
    case MotionEvent.ACTION_DOWN:
      strokeBuilder = Ink.Stroke.builder();
      strokeBuilder.addPoint(Ink.Point.create(x, y, t));
      break;
    case MotionEvent.ACTION_MOVE:
      strokeBuilder.addPoint(Ink.Point.create(x, y, t));
      break;
    case MotionEvent.ACTION_UP:
      strokeBuilder.addPoint(Ink.Point.create(x, y, t));
      inkBuilder.addStroke(strokeBuilder.build());
      strokeBuilder = null;
      break;
  }
}

...

// This is what to send to the recognizer.
Ink ink = inkBuilder.build();

Instanz von DigitalInkDetectr abrufen

Senden Sie die Ink-Instanz zur Erkennung an ein DigitalInkRecognizer-Objekt. Der folgende Code zeigt, wie eine solche Erkennung von einem BCP-47-Tag aus instanziiert wird.

Kotlin

// Specify the recognition model for a language
var modelIdentifier: DigitalInkRecognitionModelIdentifier
try {
  modelIdentifier = DigitalInkRecognitionModelIdentifier.fromLanguageTag("en-US")
} catch (e: MlKitException) {
  // language tag failed to parse, handle error.
}
if (modelIdentifier == null) {
  // no model was found, handle error.
}
var model: DigitalInkRecognitionModel =
    DigitalInkRecognitionModel.builder(modelIdentifier).build()


// Get a recognizer for the language
var recognizer: DigitalInkRecognizer =
    DigitalInkRecognition.getClient(
        DigitalInkRecognizerOptions.builder(model).build())

Java

// Specify the recognition model for a language
DigitalInkRecognitionModelIdentifier modelIdentifier;
try {
  modelIdentifier =
    DigitalInkRecognitionModelIdentifier.fromLanguageTag("en-US");
} catch (MlKitException e) {
  // language tag failed to parse, handle error.
}
if (modelIdentifier == null) {
  // no model was found, handle error.
}

DigitalInkRecognitionModel model =
    DigitalInkRecognitionModel.builder(modelIdentifier).build();

// Get a recognizer for the language
DigitalInkRecognizer recognizer =
    DigitalInkRecognition.getClient(
        DigitalInkRecognizerOptions.builder(model).build());

Ink-Objekt verarbeiten

Kotlin

recognizer.recognize(ink)
    .addOnSuccessListener { result: RecognitionResult ->
      // `result` contains the recognizer's answers as a RecognitionResult.
      // Logs the text from the top candidate.
      Log.i(TAG, result.candidates[0].text)
    }
    .addOnFailureListener { e: Exception ->
      Log.e(TAG, "Error during recognition: $e")
    }

Java

recognizer.recognize(ink)
    .addOnSuccessListener(
        // `result` contains the recognizer's answers as a RecognitionResult.
        // Logs the text from the top candidate.
        result -> Log.i(TAG, result.getCandidates().get(0).getText()))
    .addOnFailureListener(
        e -> Log.e(TAG, "Error during recognition: " + e));

Im Beispielcode oben wird davon ausgegangen, dass das Erkennungsmodell bereits heruntergeladen wurde, wie im nächsten Abschnitt beschrieben.

Modelldownloads verwalten

Die Digital Ink Recognition API unterstützt zwar Hunderte von Sprachen, für jede Sprache müssen jedoch vor der Erkennung einige Daten heruntergeladen werden. Pro Sprache sind etwa 20 MB Speicherplatz erforderlich. Dies wird vom RemoteModelManager-Objekt verarbeitet.

Neues Modell herunterladen

Kotlin

import com.google.mlkit.common.model.DownloadConditions
import com.google.mlkit.common.model.RemoteModelManager

var model: DigitalInkRecognitionModel =  ...
val remoteModelManager = RemoteModelManager.getInstance()

remoteModelManager.download(model, DownloadConditions.Builder().build())
    .addOnSuccessListener {
      Log.i(TAG, "Model downloaded")
    }
    .addOnFailureListener { e: Exception ->
      Log.e(TAG, "Error while downloading a model: $e")
    }

Java

import com.google.mlkit.common.model.DownloadConditions;
import com.google.mlkit.common.model.RemoteModelManager;

DigitalInkRecognitionModel model = ...;
RemoteModelManager remoteModelManager = RemoteModelManager.getInstance();

remoteModelManager
    .download(model, new DownloadConditions.Builder().build())
    .addOnSuccessListener(aVoid -> Log.i(TAG, "Model downloaded"))
    .addOnFailureListener(
        e -> Log.e(TAG, "Error while downloading a model: " + e));

Prüfen, ob ein Modell bereits heruntergeladen wurde

Kotlin

var model: DigitalInkRecognitionModel =  ...
remoteModelManager.isModelDownloaded(model)

Java

DigitalInkRecognitionModel model = ...;
remoteModelManager.isModelDownloaded(model);

Heruntergeladenes Modell löschen

Wenn du ein Modell aus dem Gerätespeicher entfernst, wird Speicherplatz freigegeben.

Kotlin

var model: DigitalInkRecognitionModel =  ...
remoteModelManager.deleteDownloadedModel(model)
    .addOnSuccessListener {
      Log.i(TAG, "Model successfully deleted")
    }
    .addOnFailureListener { e: Exception ->
      Log.e(TAG, "Error while deleting a model: $e")
    }

Java

DigitalInkRecognitionModel model = ...;
remoteModelManager.deleteDownloadedModel(model)
                  .addOnSuccessListener(
                      aVoid -> Log.i(TAG, "Model successfully deleted"))
                  .addOnFailureListener(
                      e -> Log.e(TAG, "Error while deleting a model: " + e));

Tipps zur Verbesserung der Genauigkeit der Texterkennung

Die Genauigkeit der Texterkennung kann je nach Sprache variieren. Genauigkeit hängt auch vom Schreibstil ab. Die digitale Tintenerkennung wurde für die Verarbeitung vieler Arten von Schreibstilen trainiert, die Ergebnisse können jedoch von Nutzer zu Nutzer variieren.

Im Folgenden finden Sie einige Möglichkeiten, die Genauigkeit der Texterkennung zu verbessern. Diese Verfahren gelten nicht für Zeichenklassifikatoren für Emojis, das Autozeichnen und die Formen.

Schreibbereich

Viele Anwendungen haben einen genau definierten Schreibbereich für Nutzereingaben. Die Bedeutung eines Symbols wird zum Teil durch seine Größe im Verhältnis zur Größe des Schreibbereichs bestimmt, in dem es enthalten ist. Zum Beispiel der Unterschied zwischen einem Klein- oder Großbuchstaben „o“ oder „c“ sowie einem Komma und einem Schrägstrich.

Wenn der Erkennung die Breite und Höhe des Schreibbereichs mitgeteilt wird, kann dies die Genauigkeit verbessern. Bei der Erkennung wird jedoch davon ausgegangen, dass der Schreibbereich nur eine einzige Textzeile enthält. Wenn der physische Schreibbereich groß genug ist, um dem Nutzer das Schreiben von zwei oder mehr Zeilen zu ermöglichen, erhalten Sie möglicherweise bessere Ergebnisse, wenn Sie einen Schreibbereich mit einer Höhe übergeben, die Ihrer besten Schätzung der Höhe einer einzelnen Textzeile entspricht. Das WritingArea-Objekt, das Sie an die Erkennung übergeben, muss nicht genau mit dem physischen Schreibbereich auf dem Bildschirm übereinstimmen. Diese Änderung der WritingArea-Höhe funktioniert in einigen Sprachen besser als in anderen.

Breite und Höhe des Schreibbereichs müssen dabei in denselben Einheiten wie für die Strichkoordinaten verwendet werden. Für die x- und y-Koordinatenargumente ist keine Einheit erforderlich – die API normalisiert alle Einheiten, sodass nur die relative Größe und Position der Striche wichtig sind. Sie können Koordinaten in jedem für Ihr System sinnvollen Maßstab übergeben.

Vorkontext

„Pre-Kontext“ ist der Text, der den Strichen in der Ink, die Sie erkennen möchten, unmittelbar vorausgeht. Sie können der Erkennung helfen, indem Sie sie über den Vorkontext informieren.

Zum Beispiel werden die Kursivbuchstaben „n“ und „u“ oft verwechselt. Wenn der Nutzer den Teilwort "arg" bereits eingegeben hat, kann er mit Strichen fortfahren, die als "ument" oder "nment" erkannt werden. Durch Angabe des vorkontextbezogenen „arg“-Elements wird die Mehrdeutigkeit beseitigt, da das Wort „Argument“ wahrscheinlicher als „argnment“ ist.

Vorkontext kann der Erkennung auch dabei helfen, Wortumbrüche zu erkennen, also Leerzeichen zwischen Wörtern. Sie können ein Leerzeichen eingeben, aber kein Zeichen zeichnen. Wie kann eine Erkennung also ermitteln, wann ein Wort endet und das nächste beginnt? Wenn der Nutzer bereits "hello" geschrieben hat und mit dem geschriebenen Wort "world" fortfährt, gibt das Erkennungssystem ohne Vorkontext den String "world" zurück. Wenn Sie jedoch „hello“ im Vorkontext angeben, gibt das Modell den String „world“ mit einem vorangestellten Leerzeichen zurück, da „hello world“ sinnvoller ist als „helloword“.

Geben Sie den längstmöglichen präkontextbasierten String mit bis zu 20 Zeichen an, einschließlich Leerzeichen. Wenn der String länger ist, verwendet die Erkennung nur die letzten 20 Zeichen.

Das folgende Codebeispiel zeigt, wie Sie einen Schreibbereich definieren und ein RecognitionContext-Objekt verwenden, um einen Kontext festzulegen.

Kotlin

var preContext : String = ...;
var width : Float = ...;
var height : Float = ...;
val recognitionContext : RecognitionContext =
    RecognitionContext.builder()
        .setPreContext(preContext)
        .setWritingArea(WritingArea(width, height))
        .build()

recognizer.recognize(ink, recognitionContext)

Java

String preContext = ...;
float width = ...;
float height = ...;
RecognitionContext recognitionContext =
    RecognitionContext.builder()
                      .setPreContext(preContext)
                      .setWritingArea(new WritingArea(width, height))
                      .build();

recognizer.recognize(ink, recognitionContext);

Strichanordnung

Die Erkennungsgenauigkeit hängt von der Reihenfolge der Striche ab. Das Erkennungssystem erwartet, dass die Striche in der Reihenfolge auftreten, in der Menschen normalerweise schreiben, z. B. von links nach rechts für Englisch. In allen Fällen, die von diesem Muster abweichen, z. B. wenn ein Satz auf Englisch mit dem letzten Wort beginnt, erhalten Sie weniger genaue Ergebnisse.

Ein anderes Beispiel wäre, wenn ein Wort mitten in einem Ink entfernt und durch ein anderes Wort ersetzt wird. Die Überarbeitung befindet sich wahrscheinlich mitten in einem Satz, aber die Striche für die Überarbeitung befinden sich am Ende der Strichsequenz. In diesem Fall empfehlen wir, das neu geschriebene Wort separat an die API zu senden und das Ergebnis mit der vorherigen Erkennung unter Verwendung Ihrer eigenen Logik zusammenzuführen.

Umgang mit zweideutigen Formen

Es gibt Fälle, in denen die Bedeutung der Form, die der Erkennung bereitgestellt wird, nicht eindeutig ist. Ein Rechteck mit stark abgerundeten Kanten kann beispielsweise als Rechteck oder Ellipse betrachtet werden.

Diese unklaren Fälle können mithilfe von Erkennungswerten behoben werden, sofern diese verfügbar sind. Bewertungen werden nur von Formklassifikatoren bereitgestellt. Wenn das Modell sehr zuversichtlich ist, ist die Punktzahl des besten Ergebnisses viel besser als das zweitbeste Ergebnis. Bei Unsicherheit liegen die Werte für die beiden besten Ergebnisse nahe. Beachten Sie außerdem, dass die Formklassifikatoren das gesamte Ink-Element als eine einzelne Form interpretieren. Wenn die Ink beispielsweise ein Rechteck und eine Ellipse nebeneinander enthält, gibt die Erkennung möglicherweise das eine oder das andere oder etwas völlig anderes zurück, da ein einzelner Erkennungskandidat nicht zwei Formen darstellen kann.