Inchiostro digitale riconosciuto con ML Kit su Android

Con il riconoscimento dell'inchiostro digitale di ML Kit, puoi riconoscere il testo scritto a mano su una superficie digitale in centinaia di lingue, nonché classificare gli schizzi.

Prova

• Prova l'app di esempio per un esempio di utilizzo di questa API.

Prima di iniziare

1. Nel file build.gradle a livello di progetto, assicurati di includere il repository Maven di Google nelle sezioni buildscript e allprojects.
2. Aggiungi le dipendenze delle librerie Android di ML Kit al file Gradle a livello di app del tuo modulo, che in genere è app/build.gradle:

dependencies {
  // ...
  implementation 'com.google.mlkit:digital-ink-recognition:18.1.0'
}

Ora puoi iniziare a riconoscere il testo in oggetti Ink.

Crea un oggetto Ink

Il modo principale per creare un oggetto Ink è tracciarlo su un touchscreen. Su Android, puoi utilizzare una Canvas per questo scopo. I tuoi gestori di eventi con tocco devono chiamare il metodo addNewTouchEvent() mostrato nel seguente snippet di codice per memorizzare i punti nei tratti che l'utente attira nell'oggetto Ink.

Questo pattern generale è illustrato nel seguente snippet di codice. Per un esempio più completo, consulta l'esempio di guida rapida di ML Kit.

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

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

Ottieni un'istanza di DigitalInkRecognizer

Per eseguire il riconoscimento, invia l'istanza Ink a un oggetto DigitalInkRecognizer. Il codice riportato di seguito mostra come creare un'istanza di un riconoscimento da un tag BCP-47.

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

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

Elabora un oggetto Ink

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

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

Il codice campione sopra riportato presuppone che il modello di riconoscimento sia già stato scaricato, come descritto nella sezione successiva.

Gestione dei download del modello

Sebbene l'API Ink Recognition digitale supporti centinaia di lingue, ogni lingua richiede il download di alcuni dati prima di qualsiasi riconoscimento. Sono necessari circa 20 MB di spazio di archiviazione per lingua. Ciò viene gestito dall'oggetto RemoteModelManager.

Scarica un nuovo modello

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

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

Controllare se un modello è già stato scaricato

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

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

Eliminare un modello scaricato

La rimozione di un modello dallo spazio di archiviazione del dispositivo libera spazio.

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

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

Suggerimenti per migliorare l'accuratezza del riconoscimento del testo

La precisione del riconoscimento del testo può variare in base alla lingua. L'accuratezza dipende anche dallo stile di scrittura. Sebbene il riconoscimento dell'inchiostro digitale sia addestrato per gestire molti tipi di stili di scrittura, i risultati possono variare da utente a utente.

Ecco alcuni modi per migliorare la precisione di un riconoscimento di testo. Tieni presente che queste tecniche non si applicano ai classificatori di disegno per emoji, disegno automatico e forme.

Area di scrittura

Molte applicazioni hanno un'area di scrittura ben definita per l'input dell'utente. Il significato di un simbolo è determinato in parte dalle sue dimensioni rispetto all'area di scrittura che lo contiene. Ad esempio, la differenza tra una lettera minuscola o iniziale "o" o "c" e una virgola rispetto a una barra.

Indicare al riconoscimento della larghezza e dell'altezza dell'area di scrittura può migliorare la precisione. Tuttavia, il riconoscimento presuppone che l'area di scrittura contenga solo una singola riga di testo. Se l'area di scrittura fisica è abbastanza grande da consentire all'utente di scrivere due o più righe, potresti ottenere risultati migliori passando in un'area di scrittura con un'altezza che è la tua stima migliore dell'altezza di una singola riga di testo. L'oggetto WritingArea che trasmetti al riconoscimento non deve corrispondere esattamente all'area di scrittura fisica sullo schermo. La modifica dell'altezza Writing Area in questo modo funziona meglio in alcune lingue.

Quando specifichi l'area di scrittura, specifica la larghezza e l'altezza nelle stesse unità delle coordinate del tratto. Gli argomenti coordinati x,y non hanno requisiti per le unità: l'API normalizza tutte le unità, pertanto l'unica cosa importante è la dimensione e la posizione relative dei tratti. Puoi inviare le coordinate in qualsiasi scala adatta al tuo sistema.

Pre-contesto

Il pre-contesto è il testo che precede immediatamente i tratti del Ink che stai cercando di riconoscere. Puoi aiutare il riconoscimento comunicandogli il pre-contesto.

Ad esempio, le lettere corsive "n" e "u" sono spesso scambiate tra loro. Se l'utente ha già inserito la parola parziale "arg," potrebbe continuare con tratti che possono essere riconosciuti come "mento" o "nment". La specifica del pre-contesto "arg" risolve l'ambiguità, poiché la parola "argomento" è più probabile che "argnment".

Il pre-contesto può anche aiutare il riconoscimento a identificare le interruzioni di parola, ovvero gli spazi tra le parole. Puoi digitare uno spazio, ma non ne puoi disegnare uno, quindi in che modo un riconoscimento può determinare quando una parola termina e inizia la successiva? Se l'utente ha già scritto "hello" e continua con la parola scritta "world", senza pre-contesto, il riconoscimento restituisce la stringa "world". Tuttavia, se specifichi il pre-contesto "hello", il modello restituirà la stringa "world", con uno spazio iniziale, poiché "hello world" ha più senso di "helloword".

Devi fornire la stringa di contesto contestuale più lunga possibile, fino a 20 caratteri, spazi inclusi. Se la stringa è più lunga, il riconoscimento utilizza solo gli ultimi 20 caratteri.

L'esempio di codice seguente mostra come definire un'area di scrittura e utilizzare un oggetto RecognitionContext per specificare il pre-contesto.

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)

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

recognizer.recognize(ink, recognitionContext);

Ordinamento bracciate

La precisione del riconoscimento è sensibile all'ordine dei tratti. I riconoscitori si aspettano che i tratti avvengano nell'ordine in cui le persone scriverebbero naturalmente, ad esempio da sinistra a destra per l'inglese. Qualsiasi caso che si discosti da questo pattern, ad esempio la scrittura di una frase inglese che inizia con l'ultima parola, fornisce risultati meno precisi.

Un altro esempio è quando una parola al centro di un elemento Ink viene rimossa e sostituita con un'altra parola. Probabilmente la revisione si trova a metà di una frase, ma i tratti della revisione sono alla fine della sequenza di tratti. In questo caso consigliamo di inviare separatamente la parola appena scritta all'API e di unire il risultato con i riconoscimenti precedenti utilizzando la tua logica.

Gestire forme ambigue

Ci sono casi in cui il significato della forma fornita al riconoscente è ambiguo. Ad esempio, un rettangolo con bordi molto arrotondati può essere considerato un rettangolo o un'ellisse.

Queste richieste non chiare possono essere gestite utilizzando i punteggi di riconoscimento, se disponibili. Solo i classificatori di forma forniscono punteggi. Se il modello è molto sicuro, il punteggio del risultato migliore sarà di gran lunga migliore rispetto al secondo. In caso di incertezza, i punteggi dei primi due risultati saranno vicini. Ricorda inoltre che i classificatori di forma interpretano l'intero Ink come una singola forma. Ad esempio, se Ink contiene un rettangolo e un'ellissi uno accanto all'altro, il riconoscimento può restituire l'uno o l'altro (o qualcosa di completamente diverso) come risultato, perché un singolo candidato di riconoscimento non può rappresentare due forme.