Digitale Tinte mit ML Kit unter Android erkennen

Mit der Erkennung digitaler Tinte von ML Kit können Sie handgeschriebenen Text auf einer digitalen Oberfläche in Hunderten von Sprachen erkennen und Skizzen klassifizieren.

Jetzt ausprobieren

Vorbereitung

  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 (in der Regel app/build.gradle) die Abhängigkeiten für die ML Kit-Android-Bibliotheken hinzu:
dependencies {
  // ...
  implementation 'com.google.mlkit:digital-ink-recognition:18.1.0'
}

Sie können jetzt mit dem Erkennen von Text in Ink-Objekten beginnen.

Ink-Objekt erstellen

Die Hauptmethode zum Erstellen eines Ink-Objekts besteht darin, es auf einem Touchscreen zu zeichnen. Unter Android können Sie dazu einen Canvas verwenden. Die Handler für Touch-Ereignisse sollten die Methode addNewTouchEvent() aufrufen, die im folgenden Code-Snippet dargestellt ist, um die Punkte in den Strichen zu speichern, die der Nutzer in das Ink-Objekt zeichnet.

Dieses allgemeine Muster wird im folgenden Code-Snippet demonstriert. Ein vollständigeres Beispiel finden Sie im ML Kit-Schnellstartbeispiel.

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

Um die Erkennung durchzuführen, senden Sie die Ink-Instanz an ein DigitalInkRecognizer-Objekt. Im folgenden Code wird gezeigt, wie ein solcher Erkenner aus einem BCP-47-Tag erstellt 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 wie im nächsten Abschnitt beschrieben.

Modelldownloads verwalten

Die Digital Ink Detection API unterstützt Hunderte von Sprachen, Sprache erfordert, dass einige Daten vor der Erkennung heruntergeladen werden. Ungefähr Pro Sprache sind 20 MB Speicherplatz erforderlich. Dies wird vom RemoteModelManager-Objekt.

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 Sie ein Modell aus dem Gerätespeicher entfernen, 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 Texterkennung

Die Genauigkeit der Texterkennung kann je nach Sprache variieren. Die Genauigkeit hängt auch von zum Schreibstil. Die digitale Tintenerkennung wurde für viele verschiedene Schreibstile trainiert, können die Ergebnisse von Nutzer zu Nutzer variieren.

Hier finden Sie einige Möglichkeiten, die Genauigkeit einer Texterkennung zu verbessern. Beachten Sie, dass diese Methoden gelten nicht für die Zeichenklassifikatoren für Emojis, AutoDraw und Formen.

Schreibbereich

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

Wenn Sie der Erkennung die Breite und Höhe des Schreibbereichs mitteilen, kann die Genauigkeit verbessert werden. Der Erkenner geht jedoch davon aus, dass der Schreibbereich nur eine einzige Textzeile enthält. Wenn der physische Schreibbereich groß genug ist, dass der Nutzer zwei oder mehr Zeilen schreiben kann, erzielen 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 den Erkenner übergeben, muss nicht genau mit dem physischen Schreibbereich auf dem Bildschirm übereinstimmen. Die Höhe des Schreibbereichs auf diese Weise zu ändern, funktioniert in einigen Sprachen besser als in anderen.

Wenn Sie den Schreibbereich angeben, geben Sie dessen Breite und Höhe in denselben Einheiten wie der Strich an. Koordinaten. Für die Argumente der X‑ und Y‑Koordinaten sind keine Einheiten erforderlich. Die API normalisiert alle Einheiten. Daher sind nur die relative Größe und Position der Striche wichtig. Sie können Koordinaten in einem beliebigen Maßstab für Ihr System übergeben.

Vor dem Kontext

Der Vorkontext ist der Text, der unmittelbar vor den Strichen in der Ink steht, die Sie erkennen möchten. Sie können dem Erkennungstool helfen, indem Sie ihm den vorherigen Kontext mitteilen.

So werden beispielsweise die kursiven Buchstaben „n“ und „u“ häufig miteinander verwechselt. Wenn der Nutzer bereits das Teilwort „arg“ eingegeben hat, werden sie möglicherweise mit Strichen fortgesetzt, die als „Ument“ oder „Nment“. Durch die Angabe des vorherigen Kontexts „arg“ wird die Mehrdeutigkeit beseitigt, da das Wort „Argument“ wahrscheinlicher ist als „Argnment“.

Vor dem Kontext kann die Erkennung auch dabei helfen, Wortumbrüche, also die Leerzeichen zwischen Wörtern, zu erkennen. Sie können Leerzeichen eingeben, aber nicht zeichnen. Wie kann eine Erkennung feststellen, wann ein Wort endet? und die nächste beginnt? Wenn der Nutzer bereits „Hallo“ geschrieben hat und mit dem geschriebenen Wort „Welt“ fortfährt, gibt der Erkenner ohne vorherigen Kontext den String „Welt“ zurück. Wenn Sie jedoch den vorherigen Kontext „hallo“ angeben, gibt das Modell den String „welt“ mit einem vorangestellten Leerzeichen zurück, da „hallowelt“ mehr Sinn macht als „hallowort“.

Geben Sie den längstmöglichen Pre-Kontext-String an, der bis zu 20 Zeichen umfasst, einschließlich Leerzeichen. Ist der String länger, werden nur die letzten 20 Zeichen verwendet.

Das folgende Codebeispiel zeigt, wie Sie einen Schreibbereich definieren und einen RecognitionContext-Objekt, um einen Vorkontext anzugeben.

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

Stroke-Reihenfolge

Die Erkennungsgenauigkeit ist von der Reihenfolge der Striche abhängig. Die Erkennungsfunktionen erwarten, dass in der Reihenfolge, in der die Nutzer schreiben würden; z. B. von links nach rechts für Englisch. Beliebiger Fall zum Beispiel einen englischen Satz, der mit dem letzten Wort beginnt, führt zu weniger genauen Ergebnissen.

Ein weiteres Beispiel ist, wenn ein Wort in der Mitte eines Ink entfernt und durch ein anderes Wort ersetzt wird. Die Korrektur befindet sich wahrscheinlich in der Mitte eines Satzes, die Striche für die Korrektur sind aber am Ende der Strichsequenz. In diesem Fall empfehlen wir, das neu geschriebene Wort separat an die API zu senden und die Ergebnis mit den vorherigen Erkennungen unter Verwendung Ihrer eigenen Logik erhalten.

Mehrdeutige Formen

Es gibt Fälle, in denen die Bedeutung der dem Erkennungsmodul übergebenen Form mehrdeutig ist. Ein Rechteck mit sehr abgerundeten Ecken kann beispielsweise als Rechteck oder als Ellipse erkannt werden.

Diese unklaren Fälle können mithilfe von Erkennungswerten bearbeitet werden, sofern sie verfügbar sind. Nur Formklassifikatoren liefern Bewertungen. Wenn das Modell sehr sicher ist, ist der Wert des Top-Ergebnisses viel besser als der des zweitbesten. Bei Unsicherheit sind die Bewertungen der beiden besten Ergebnisse nah beieinander. Beachten Sie außerdem, dass die Formklassifikatoren das gesamte Ink als in eine einzelne Form ein. Wenn Ink beispielsweise ein Rechteck und eine Ellipse daneben enthält, kann das Erkennungsmodul das eine oder das andere (oder etwas völlig anderes) als da ein Erkennungskandidat nicht zwei Formen darstellen kann.