Reconhecimento de tinta digital com o Kit de ML no Android

Com o reconhecimento de tinta digital do Kit de ML, é possível reconhecer texto escrito à mão em uma superfície digital em centenas de idiomas, além de classificar esboços.

Faça um teste

• Teste o app de exemplo para conferir um exemplo de uso dessa API.

Antes de começar

1. No arquivo build.gradle no nível do projeto, inclua o repositório Maven do Google nas seções buildscript e allprojects.
2. Adicione as dependências das bibliotecas do Android do Kit de ML ao arquivo Gradle do módulo no nível do app, que geralmente é app/build.gradle:

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

Agora você já pode começar a reconhecer texto em objetos Ink.

Criar um objeto Ink

A principal maneira de criar um objeto Ink é desenhá-lo em uma tela touchscreen. No Android, é possível usar uma tela para essa finalidade. Seus manipuladores de evento de toque precisam chamar o método addNewTouchEvent() mostrado no snippet de código abaixo para armazenar os pontos nos traços que o usuário desenha no objeto Ink.

Esse padrão geral é demonstrado no snippet de código abaixo. Consulte o exemplo de início rápido do Kit de ML para conferir um exemplo mais completo.

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

Criar uma instância de DigitalInkRecognizer

Para realizar o reconhecimento, envie a instância Ink para um objeto DigitalInkRecognizer. O código abaixo mostra como instanciar esse reconhecedor de uma 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());

Processar um objeto 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));

O exemplo de código acima pressupõe que o modelo de reconhecimento já foi baixado, conforme descrito na próxima seção.

Como gerenciar downloads de modelos

Embora a API de reconhecimento de tinta digital ofereça suporte a centenas de idiomas, cada idioma exige que alguns dados sejam transferidos antes de qualquer reconhecimento. Cerca de 20 MB de armazenamento são necessários por idioma. Isso é tratado pelo objeto RemoteModelManager.

Fazer o download de um novo modelo

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

Verificar se um modelo já foi transferido por download

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

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

Excluir um modelo salvo

Remover um modelo do armazenamento do dispositivo libera espaço.

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

Dicas para melhorar a precisão do reconhecimento de texto

A precisão do reconhecimento de texto pode variar de acordo com o idioma. A precisão também depende do estilo de escrita. Embora o reconhecimento de tinta digital seja treinado para lidar com muitos tipos de estilos de escrita, os resultados podem variar de usuário para usuário.

Confira algumas maneiras de melhorar a precisão de um reconhecedor de texto. Essas técnicas não se aplicam aos classificadores de desenho para emojis, desenho automático e formas.

Área de escrita

Muitos aplicativos têm uma área de escrita bem definida para a entrada do usuário. O significado de um símbolo é determinado parcialmente pelo tamanho dele em relação ao tamanho da área de escrita que o contém. Por exemplo, a diferença entre uma letra maiúscula ou minúscula "o" ou "c" e uma vírgula em vez de um barra.

Informar ao reconhecedor a largura e a altura da área de escrita pode melhorar a precisão. No entanto, o reconhecedor presume que a área de escrita contém apenas uma linha de texto. Se a área de escrita física for grande o suficiente para permitir que o usuário escreva duas ou mais linhas, você poderá ter resultados melhores transmitindo uma WritingArea com uma altura que seja sua melhor estimativa da altura de uma única linha de texto. O objeto WritingArea transmitido ao reconhecedor não precisa corresponder exatamente à área de escrita física na tela. Mudar a altura da WritingArea dessa forma funciona melhor em alguns idiomas do que em outros.

Ao especificar a área de escrita, especifique a largura e a altura nas mesmas unidades das coordenadas de traço. Os argumentos de coordenadas x,y não têm requisitos de unidade. A API normaliza todas as unidades. Portanto, a única coisa que importa é o tamanho e a posição relativa dos traços. Você pode transmitir coordenadas em qualquer escala que faça sentido para seu sistema.

Pré-contexto

O pré-contexto é o texto que precede imediatamente os traços no Ink que você está tentando reconhecer. Você pode ajudar o reconhecedor informando sobre o pré-contexto.

Por exemplo, as letras cursivas "n" e "u" são frequentemente confundidas. Se o usuário já tiver digitado a palavra parcial "arg", ele poderá continuar com traços que podem ser reconhecidos como "ument" ou "nment". Especificar o pré-contexto "arg" resolve a ambiguidade, já que a palavra "argument" é mais provável do que "argnment".

O pré-contexto também pode ajudar o reconhecedor a identificar quebras de palavras, os espaços entre elas. Você pode digitar um caractere de espaço, mas não pode desenhar um. Então, como um reconhecedor pode determinar quando uma palavra termina e a próxima começa? Se o usuário já tiver escrito "hello" e continuar com a palavra escrita "world", sem o pré-contexto, o reconhecedor vai retornar a string "world". No entanto, se você especificar o pré-contexto "hello", o modelo vai retornar a string "world", com um espaço inicial, já que "hello world" faz mais sentido do que "helloword".

Forneça a string de pré-contexto mais longa possível, com até 20 caracteres, incluindo espaços. Se a string for mais longa, o reconhecedor vai usar apenas os últimos 20 caracteres.

O exemplo de código abaixo mostra como definir uma área de gravação e usar um objeto RecognitionContext para especificar o pré-contexto.

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

Ordem do traço

A precisão do reconhecimento é sensível à ordem dos traços. Os reconhecedores esperam que os traços ocorram na ordem em que as pessoas escrevem naturalmente. Por exemplo, da esquerda para a direita no inglês. Qualquer caso que se afaste desse padrão, como escrever uma frase em inglês começando pela última palavra, dá resultados menos precisos.

Outro exemplo é quando uma palavra no meio de um Ink é removida e substituída por outra. A revisão provavelmente está no meio de uma frase, mas os traços da revisão estão no final da sequência de traços. Nesse caso, recomendamos enviar a palavra recém-gravada separadamente para a API e mesclar o resultado com os reconhecimentos anteriores usando sua própria lógica.

Como lidar com formas ambíguas

Há casos em que o significado da forma fornecida ao reconhecedor é ambíguo. Por exemplo, um retângulo com bordas muito arredondadas pode ser visto como um retângulo ou uma elipse.

Esses casos podem ser resolvidos usando as pontuações de reconhecimento quando elas estiverem disponíveis. Somente classificadores de forma fornecem pontuações. Se o modelo tiver muita confiança, a pontuação do resultado principal será muito melhor do que a segunda melhor. Se houver incerteza, as pontuações dos dois melhores resultados serão próximas. Além disso, lembre-se de que os classificadores de forma interpretam o Ink inteiro como uma única forma. Por exemplo, se o Ink contiver um retângulo e uma elipse ao lado um do outro, o reconhecedor poderá retornar um ou outro (ou algo completamente diferente) como resultado, já que um único candidato de reconhecimento não pode representar duas formas.