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 e classificar esboços.
Testar
- Teste o app de exemplo para ver um exemplo de uso da API.
Antes de começar
Inclua as seguintes bibliotecas do Kit de ML no seu Podfile:
pod 'GoogleMLKit/DigitalInkRecognition', '3.2.0'
Depois de instalar ou atualizar os pods do seu projeto, abra o projeto do Xcode usando o
.xcworkspace
. O Kit de ML é compatível com o Xcode versão 13.2.1 ou superior.
Agora está tudo pronto para você reconhecer texto em objetos Ink
.
Criar um objeto Ink
A principal maneira de criar um objeto Ink
é desenhá-lo em uma tela sensível ao toque. No iOS, você pode usar uma UIImageView junto com manipuladores de eventos de toque que desenham os traços na tela e também armazenam os pontos dos traços para criar o objeto Ink
. Esse padrão geral é demonstrado no snippet de código a seguir. Consulte o app de início rápido para ver um exemplo mais completo, que separa o gerenciamento de eventos de toque, o desenho de tela e o gerenciamento de dados de traço.
Swift
@IBOutlet weak var mainImageView: UIImageView! var kMillisecondsPerTimeInterval = 1000.0 var lastPoint = CGPoint.zero private var strokes: [Stroke] = [] private var points: [StrokePoint] = [] func drawLine(from fromPoint: CGPoint, to toPoint: CGPoint) { UIGraphicsBeginImageContext(view.frame.size) guard let context = UIGraphicsGetCurrentContext() else { return } mainImageView.image?.draw(in: view.bounds) context.move(to: fromPoint) context.addLine(to: toPoint) context.setLineCap(.round) context.setBlendMode(.normal) context.setLineWidth(10.0) context.setStrokeColor(UIColor.white.cgColor) context.strokePath() mainImageView.image = UIGraphicsGetImageFromCurrentImageContext() mainImageView.alpha = 1.0 UIGraphicsEndImageContext() } override func touchesBegan(_ touches: Set, with event: UIEvent?) { guard let touch = touches.first else { return } lastPoint = touch.location(in: mainImageView) let t = touch.timestamp points = [StrokePoint.init(x: Float(lastPoint.x), y: Float(lastPoint.y), t: Int(t * kMillisecondsPerTimeInterval))] drawLine(from:lastPoint, to:lastPoint) } override func touchesMoved(_ touches: Set , with event: UIEvent?) { guard let touch = touches.first else { return } let currentPoint = touch.location(in: mainImageView) let t = touch.timestamp points.append(StrokePoint.init(x: Float(currentPoint.x), y: Float(currentPoint.y), t: Int(t * kMillisecondsPerTimeInterval))) drawLine(from: lastPoint, to: currentPoint) lastPoint = currentPoint } override func touchesEnded(_ touches: Set , with event: UIEvent?) { guard let touch = touches.first else { return } let currentPoint = touch.location(in: mainImageView) let t = touch.timestamp points.append(StrokePoint.init(x: Float(currentPoint.x), y: Float(currentPoint.y), t: Int(t * kMillisecondsPerTimeInterval))) drawLine(from: lastPoint, to: currentPoint) lastPoint = currentPoint strokes.append(Stroke.init(points: points)) self.points = [] doRecognition() }
Objective-C
// Interface @property (weak, nonatomic) IBOutlet UIImageView *mainImageView; @property(nonatomic) CGPoint lastPoint; @property(nonatomic) NSMutableArray*strokes; @property(nonatomic) NSMutableArray *points; // Implementations static const double kMillisecondsPerTimeInterval = 1000.0; - (void)drawLineFrom:(CGPoint)fromPoint to:(CGPoint)toPoint { UIGraphicsBeginImageContext(self.mainImageView.frame.size); [self.mainImageView.image drawInRect:CGRectMake(0, 0, self.mainImageView.frame.size.width, self.mainImageView.frame.size.height)]; CGContextMoveToPoint(UIGraphicsGetCurrentContext(), fromPoint.x, fromPoint.y); CGContextAddLineToPoint(UIGraphicsGetCurrentContext(), toPoint.x, toPoint.y); CGContextSetLineCap(UIGraphicsGetCurrentContext(), kCGLineCapRound); CGContextSetLineWidth(UIGraphicsGetCurrentContext(), 10.0); CGContextSetRGBStrokeColor(UIGraphicsGetCurrentContext(), 1, 1, 1, 1); CGContextSetBlendMode(UIGraphicsGetCurrentContext(), kCGBlendModeNormal); CGContextStrokePath(UIGraphicsGetCurrentContext()); CGContextFlush(UIGraphicsGetCurrentContext()); self.mainImageView.image = UIGraphicsGetImageFromCurrentImageContext(); UIGraphicsEndImageContext(); } - (void)touchesBegan:(NSSet *)touches withEvent:(nullable UIEvent *)event { UITouch *touch = [touches anyObject]; self.lastPoint = [touch locationInView:self.mainImageView]; NSTimeInterval time = [touch timestamp]; self.points = [NSMutableArray array]; [self.points addObject:[[MLKStrokePoint alloc] initWithX:self.lastPoint.x y:self.lastPoint.y t:time * kMillisecondsPerTimeInterval]]; [self drawLineFrom:self.lastPoint to:self.lastPoint]; } - (void)touchesMoved:(NSSet *)touches withEvent:(nullable UIEvent *)event { UITouch *touch = [touches anyObject]; CGPoint currentPoint = [touch locationInView:self.mainImageView]; NSTimeInterval time = [touch timestamp]; [self.points addObject:[[MLKStrokePoint alloc] initWithX:currentPoint.x y:currentPoint.y t:time * kMillisecondsPerTimeInterval]]; [self drawLineFrom:self.lastPoint to:currentPoint]; self.lastPoint = currentPoint; } - (void)touchesEnded:(NSSet *)touches withEvent:(nullable UIEvent *)event { UITouch *touch = [touches anyObject]; CGPoint currentPoint = [touch locationInView:self.mainImageView]; NSTimeInterval time = [touch timestamp]; [self.points addObject:[[MLKStrokePoint alloc] initWithX:currentPoint.x y:currentPoint.y t:time * kMillisecondsPerTimeInterval]]; [self drawLineFrom:self.lastPoint to:currentPoint]; self.lastPoint = currentPoint; if (self.strokes == nil) { self.strokes = [NSMutableArray array]; } [self.strokes addObject:[[MLKStroke alloc] initWithPoints:self.points]]; self.points = nil; [self doRecognition]; }
Observe que o snippet de código inclui uma função de exemplo para desenhar o traço na UIImageView, que deve ser adaptada conforme necessário para o seu app. Recomendamos o uso
de letras maiúsculas ao desenhar os segmentos de linha para que os segmentos de comprimento zero sejam
desenhados como um ponto (pense no ponto em uma letra i minúscula). A função doRecognition()
é chamada depois que cada traço é gravado e será definida abaixo.
Receba uma instância de DigitalInkRecognizer
Para realizar o reconhecimento, precisamos transmitir o objeto Ink
para uma
instância DigitalInkRecognizer
. Para conseguir a instância DigitalInkRecognizer
,
primeiro precisamos fazer o download do modelo de reconhecimento para o idioma desejado e
carregar o modelo na RAM. Isso pode ser feito usando o snippet de código
a seguir, que, para simplificar, está no método viewDidLoad()
e usa um
nome de idioma fixado no código. Consulte o app de início rápido para ver um exemplo de como mostrar a lista de idiomas disponíveis para o usuário e fazer o download do idioma selecionado.
Swift
override func viewDidLoad() { super.viewDidLoad() let languageTag = "en-US" let identifier = DigitalInkRecognitionModelIdentifier(forLanguageTag: languageTag) if identifier == nil { // no model was found or the language tag couldn't be parsed, handle error. } let model = DigitalInkRecognitionModel.init(modelIdentifier: identifier!) let modelManager = ModelManager.modelManager() let conditions = ModelDownloadConditions.init(allowsCellularAccess: true, allowsBackgroundDownloading: true) modelManager.download(model, conditions: conditions) // Get a recognizer for the language let options: DigitalInkRecognizerOptions = DigitalInkRecognizerOptions.init(model: model) recognizer = DigitalInkRecognizer.digitalInkRecognizer(options: options) }
Objective-C
- (void)viewDidLoad { [super viewDidLoad]; NSString *languagetag = @"en-US"; MLKDigitalInkRecognitionModelIdentifier *identifier = [MLKDigitalInkRecognitionModelIdentifier modelIdentifierForLanguageTag:languagetag]; if (identifier == nil) { // no model was found or the language tag couldn't be parsed, handle error. } MLKDigitalInkRecognitionModel *model = [[MLKDigitalInkRecognitionModel alloc] initWithModelIdentifier:identifier]; MLKModelManager *modelManager = [MLKModelManager modelManager]; [modelManager downloadModel:model conditions:[[MLKModelDownloadConditions alloc] initWithAllowsCellularAccess:YES allowsBackgroundDownloading:YES]]; MLKDigitalInkRecognizerOptions *options = [[MLKDigitalInkRecognizerOptions alloc] initWithModel:model]; self.recognizer = [MLKDigitalInkRecognizer digitalInkRecognizerWithOptions:options]; }
Os apps do guia de início rápido incluem um código extra que mostra como processar vários downloads ao mesmo tempo e como determinar qual download foi bem-sucedido processando as notificações de conclusão.
Reconhecer um objeto Ink
Em seguida, chegamos à função doRecognition()
, que, para simplificar, é chamada
em touchesEnded()
. Em outros aplicativos, pode ser necessário invocar
o reconhecimento somente após um tempo limite ou quando o usuário pressionou um botão para acioná-lo.
Swift
func doRecognition() { let ink = Ink.init(strokes: strokes) recognizer.recognize( ink: ink, completion: { [unowned self] (result: DigitalInkRecognitionResult?, error: Error?) in var alertTitle = "" var alertText = "" if let result = result, let candidate = result.candidates.first { alertTitle = "I recognized this:" alertText = candidate.text } else { alertTitle = "I hit an error:" alertText = error!.localizedDescription } let alert = UIAlertController(title: alertTitle, message: alertText, preferredStyle: UIAlertController.Style.alert) alert.addAction(UIAlertAction(title: "OK", style: UIAlertAction.Style.default, handler: nil)) self.present(alert, animated: true, completion: nil) } ) }
Objective-C
- (void)doRecognition { MLKInk *ink = [[MLKInk alloc] initWithStrokes:self.strokes]; __weak typeof(self) weakSelf = self; [self.recognizer recognizeInk:ink completion:^(MLKDigitalInkRecognitionResult *_Nullable result, NSError *_Nullable error) { typeof(weakSelf) strongSelf = weakSelf; if (strongSelf == nil) { return; } NSString *alertTitle = nil; NSString *alertText = nil; if (result.candidates.count > 0) { alertTitle = @"I recognized this:"; alertText = result.candidates[0].text; } else { alertTitle = @"I hit an error:"; alertText = [error localizedDescription]; } UIAlertController *alert = [UIAlertController alertControllerWithTitle:alertTitle message:alertText preferredStyle:UIAlertControllerStyleAlert]; [alert addAction:[UIAlertAction actionWithTitle:@"OK" style:UIAlertActionStyleDefault handler:nil]]; [strongSelf presentViewController:alert animated:YES completion:nil]; }]; }
Como gerenciar downloads de modelos
Já vimos como fazer o download de um modelo de reconhecimento. Os snippets de código a seguir ilustram como verificar se um modelo já foi transferido por download ou como excluir um modelo quando ele não for mais necessário para recuperar o espaço de armazenamento.
Verificar se um modelo já foi baixado
Swift
let model : DigitalInkRecognitionModel = ... let modelManager = ModelManager.modelManager() modelManager.isModelDownloaded(model)
Objective-C
MLKDigitalInkRecognitionModel *model = ...; MLKModelManager *modelManager = [MLKModelManager modelManager]; [modelManager isModelDownloaded:model];
Excluir um modelo baixado
Swift
let model : DigitalInkRecognitionModel = ... let modelManager = ModelManager.modelManager() if modelManager.isModelDownloaded(model) { modelManager.deleteDownloadedModel( model!, completion: { error in if error != nil { // Handle error return } NSLog(@"Model deleted."); }) }
Objective-C
MLKDigitalInkRecognitionModel *model = ...; MLKModelManager *modelManager = [MLKModelManager modelManager]; if ([self.modelManager isModelDownloaded:model]) { [self.modelManager deleteDownloadedModel:model completion:^(NSError *_Nullable error) { if (error) { // Handle error. return; } NSLog(@"Model deleted."); }]; }
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.
Aqui estão algumas maneiras de melhorar a precisão de um reconhecedor de texto. Essas técnicas não se aplicam aos classificadores de desenho de emojis, desenho automático e formas.
Área de escrita
Muitos aplicativos têm uma área de gravação bem definida para entradas do usuário. O significado de um símbolo é parcialmente determinado pelo tamanho dele em relação ao tamanho da área de escrita que o contém. Por exemplo, a diferença entre uma letra minúscula ou "o" ou "c" e uma vírgula ou uma barra.
Dizer ao reconhecedor a largura e a altura da área de escrita pode melhorar a precisão. No entanto, o reconhecedor supõe que a área de escrita contém apenas uma linha de texto. Se a área de gravação física for grande o suficiente para permitir que o usuário escreva duas ou mais linhas, você poderá conseguir melhores resultados transmitindo uma área de escrita com uma altura que seja a melhor estimativa da altura de uma única linha de texto. O objeto WritingArea que você transmite ao reconhecedor não precisa corresponder exatamente à área de gravação física na tela. Alterar a altura da WritingArea dessa maneira funciona melhor em alguns idiomas do que em outros.
Ao especificar a área de escrita, especifique a largura e a altura nas mesmas unidades que as coordenadas do traço. Os argumentos de coordenadas x,y não têm requisito de unidade. A API normaliza todas as unidades, então o que importa é o tamanho relativo e a posição dos traços. Você pode passar as coordenadas em qualquer escala que faça sentido para seu sistema.
Pré-contexto
Pré-contexto é o texto que precede imediatamente os traços no Ink
que você
está tentando reconhecer. Você pode ajudar o reconhecedor contando sobre o pré-contexto.
Por exemplo, as letras cursivas "n" e "u" são frequentemente confundidas uma com a outra. Se o usuário já tiver inserido a palavra parcial "arg", ele poderá continuar com traços que possam ser reconhecidos como "ument" ou "nment". Especificar o "arg" de pré-contexto resolve a ambiguidade, já que a palavra "argumento" é mais provável do que "argnment".
O pré-contexto também pode ajudar o reconhecedor a identificar quebras de palavras, os espaços entre palavras. 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 pré-contexto, o reconhecedor retornará a string "world". No entanto, se você especificar o pré-contexto "hello", o modelo 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 maior, o reconhecedor usará apenas os últimos 20 caracteres.
O exemplo de código abaixo mostra como definir uma área de escrita e usar um objeto
RecognitionContext
para especificar o pré-contexto.
Swift
let ink: Ink = ...; let recognizer: DigitalInkRecognizer = ...; let preContext: String = ...; let writingArea = WritingArea.init(width: ..., height: ...); let context: DigitalInkRecognitionContext.init( preContext: preContext, writingArea: writingArea); recognizer.recognizeHandwriting( from: ink, context: context, completion: { (result: DigitalInkRecognitionResult?, error: Error?) in if let result = result, let candidate = result.candidates.first { NSLog("Recognized \(candidate.text)") } else { NSLog("Recognition error \(error)") } })
Objective-C
MLKInk *ink = ...; MLKDigitalInkRecognizer *recognizer = ...; NSString *preContext = ...; MLKWritingArea *writingArea = [MLKWritingArea initWithWidth:... height:...]; MLKDigitalInkRecognitionContext *context = [MLKDigitalInkRecognitionContext initWithPreContext:preContext writingArea:writingArea]; [recognizer recognizeHandwritingFromInk:ink context:context completion:^(MLKDigitalInkRecognitionResult *_Nullable result, NSError *_Nullable error) { NSLog(@"Recognition result %@", result.candidates[0].text); }];
Ordenação dos traços
A precisão do reconhecimento depende da ordem dos traços. Os reconhecedores esperam que os traços ocorram na ordem em que as pessoas escreveriam naturalmente, por exemplo, da esquerda para a direita no inglês. Qualquer caso que se desvie desse padrão, como escrever uma frase em inglês começando com a última palavra, oferece resultados menos precisos.
Outro exemplo é quando uma palavra no meio de uma Ink
é removida e substituída por
outra palavra. A revisão provavelmente está no meio de uma frase, mas os traços da revisão estão no final da sequência do traço.
Nesse caso, recomendamos enviar a palavra recém-escrita 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 pouco claros podem ser tratados com o uso de pontuações de reconhecimento quando disponíveis. Somente os classificadores de formas fornecem pontuações. Se o modelo estiver muito confiante, a pontuação do primeiro resultado será
muito melhor do que o segundo melhor. Se houver incerteza, as pontuações dos dois primeiros resultados serão próximas. Além disso, lembre-se de que os classificadores de formas interpretam a Ink
inteira como uma
única forma. Por exemplo, se a Ink
contiver um retângulo e uma elipse lado a lado, 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.