Con il riconoscimento dell'inchiostro digitale di ML Kit, puoi riconoscere il testo scritto a mano su una superficie digitale in centinaia di lingue e classificare gli schizzi.
Provalo
- Prova l'app di esempio per vedere un esempio di utilizzo di questa API.
Prima di iniziare
- Nel file
build.gradle
a livello di progetto, assicurati di includere il Repository Maven di Google in entrambe le sezionibuildscript
eallprojects
. - Aggiungi le dipendenze per le librerie Android ML Kit al file Gradle a livello di app del 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 negli oggetti Ink
.
Crea un oggetto Ink
Il modo principale per creare un oggetto Ink
è disegnarlo su un touchscreen. Su
Android, puoi utilizzare un
Canvas a questo scopo. I gestori di eventi touch devono chiamare il metodo addNewTouchEvent()
mostrato al seguente snippet di codice per memorizzare i punti nei tratti che l'utente disegna nell'oggetto Ink
.
Questo pattern generale viene dimostrato nel seguente snippet di codice. Consulta l'esempio della guida rapida di ML Kit per un esempio più completo.
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();
Recupera un'istanza di DigitalInkRecognition
Per eseguire il riconoscimento, invia l'istanza Ink
a un
oggetto DigitalInkRecognizer
. Il codice seguente mostra come creare un'istanza di questo riconoscimento da un tag BCP-47.
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());
Elabora un oggetto Ink
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));
Il codice campione sopra riportato presuppone che il modello di riconoscimento sia già stato scaricato, come descritto nella sezione successiva.
Gestione dei download dei modelli
Sebbene l'API per il riconoscimento dell'inchiostro digitale supporti centinaia di lingue, ogni lingua richiede il download di alcuni dati prima di ogni riconoscimento. Sono necessari circa 20 MB di spazio di archiviazione per lingua. Questa operazione viene gestita
dall'oggetto RemoteModelManager
.
Scarica un nuovo modello
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));
Controllare se un modello è già stato scaricato
Kotlin
var model: DigitalInkRecognitionModel = ... remoteModelManager.isModelDownloaded(model)
Java
DigitalInkRecognitionModel model = ...; remoteModelManager.isModelDownloaded(model);
Eliminare un modello scaricato
Se rimuovi un modello dallo spazio di archiviazione del dispositivo, viene liberato spazio.
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));
Suggerimenti per migliorare la precisione del riconoscimento del testo
La precisione del riconoscimento del testo può variare a seconda della lingua. La precisione dipende anche dallo stile di scrittura. Sebbene il riconoscimento a inchiostro digitale sia addestrato per gestire molti tipi di stili di scrittura, i risultati possono variare da utente a utente.
Di seguito sono riportati alcuni modi per migliorare la precisione di un riconoscimento del testo. Tieni presente che queste tecniche non si applicano ai classificatori dei disegni per emoji, autoDraw e forme.
Area di scrittura
Molte applicazioni dispongono di un'area di scrittura ben definita per l'input dell'utente. Il significato di un simbolo è determinato in parte dalle sue dimensioni rispetto a quelle dell'area di scrittura che lo contiene. Ad esempio, la differenza tra una lettera "o" o "c" o una lettera maiuscola e una virgola rispetto a una barra.
Indicare al riconoscimento la larghezza e l'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 inserendo un'area di scrittura con un'altezza che rappresenti la tua stima migliore dell'altezza di una singola riga di testo. L'oggetto WriteArea che passi al riconoscimento non deve corrispondere esattamente all'area di scrittura fisica sullo schermo. Modificare l'altezza dell'area di scrittura 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 delle coordinate x,y non hanno requisiti di unità: l'API normalizza tutte le unità, quindi l'unica cosa che conta sono la dimensione e la posizione relative dei tratti. Puoi passare liberamente nelle coordinate nella scala più adeguata per il tuo sistema.
Pre-contesto
Il pre-contesto è il testo che precede immediatamente i tratti nel Ink
che
stai cercando di riconoscere. Puoi aiutare il riconoscimento parlando del pre-contesto.
Ad esempio, le lettere corsie "n" e "u" vengono spesso scambiate l'una per l'altra. Se l'utente ha già inserito la parola parziale "arg", potrebbe continuare con tratti che possono essere riconosciuti come "ument" o "nment". Specificare il pre-contesto "arg" risolve l'ambiguità, poiché la parola "argomento" è più probabile di "argomento".
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 riesci a disegnarne uno, quindi come fa un riconoscimento a determinare quando termina una parola e inizia la successiva? Se l'utente ha già scritto "hello" e continua con la parola scritta "mondo", senza pre-contesto, il riconoscimento restituisce la stringa "mondo". 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 pre-contesto 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 riportato di seguito mostra come definire un'area di scrittura e utilizzare un
oggetto RecognitionContext
per specificare il pre-contesto.
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);
Ordinazione tratto
La precisione del riconoscimento dipende dall'ordine dei tratti. I responsabili del riconoscimento si aspettano che i tratti siano nell'ordine in cui le persone scrivono, ad esempio da sinistra a destra per l'inglese. Qualsiasi caso che si discosti da questo schema, come scrivere una frase in inglese che inizia con l'ultima parola, dà risultati meno precisi.
Un altro esempio è quando una parola al centro di un Ink
viene rimossa e sostituita con un'altra parola. La revisione probabilmente si trova nel mezzo di una frase, ma i tratti per la revisione sono alla fine della sequenza.
In questo caso, consigliamo di inviare la parola appena scritta separatamente all'API e di unire il risultato con i riconoscimenti precedenti utilizzando la tua logica.
Gestire forme ambigue
Esistono casi in cui il significato della forma fornita al riconoscimento è ambiguo. Ad esempio, un rettangolo con bordi molto arrotondati può essere visto come un rettangolo o un'ellisse.
Questi casi non chiari possono essere gestiti utilizzando i punteggi di riconoscimento, se disponibili. Solo i classificatori di forma forniscono punteggi. Se il modello è molto sicuro, il punteggio del miglior risultato sarà
di gran lunga migliore del secondo migliore. In caso di incertezza, i punteggi dei due risultati principali
saranno vicini. Inoltre, tieni presente che i classificatori di forme interpretano l'intero Ink
come una
singola forma. Ad esempio, se Ink
contiene un rettangolo e un'ellisse uno accanto all'altro, il riconoscimento potrebbe restituire l'una o l'altra (o qualcosa di completamente diverso) come risultato, poiché un singolo candidato al riconoscimento non può rappresentare due forme.