Reconnaissance de l'encre numérique avec ML Kit sur iOS

Grâce à la reconnaissance d'encre numérique de ML Kit, vous pouvez reconnaître du texte manuscrit sur une surface numérique dans des centaines de langues, et classer des croquis.

Essayer

Avant de commencer

  1. Incluez les bibliothèques ML Kit suivantes dans votre Podfile:

    pod 'GoogleMLKit/DigitalInkRecognition', '7.0.0'

  2. Après avoir installé ou mis à jour les pods de votre projet, ouvrez votre projet Xcode à l'aide de son .xcworkspace. ML Kit est compatible avec la version 13.2.1 ou ultérieure de Xcode.

Vous êtes maintenant prêt à commencer à reconnaître le texte dans les objets Ink.

Créer un objet Ink

Le principal moyen de créer un objet Ink consiste à le dessiner sur un écran tactile. Sur iOS, vous pouvez utiliser un UIImageView avec des gestionnaires d'événements tactiles qui dessinent les traits à l'écran et stockent également les points des traits pour créer l'objet Ink. Ce schéma général est illustré dans l'extrait de code suivant. Pour obtenir un exemple plus complet, consultez l'application de démarrage rapide, qui sépare la gestion des événements tactiles, le dessin à l'écran et la gestion des données de trait.

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];
}

Notez que l'extrait de code inclut un exemple de fonction permettant de dessiner le trait dans l'UIImageView, qui doit être adapté si nécessaire pour votre application. Nous vous recommandons d'utiliser des capuchons arrondis lorsque vous dessinez des segments de ligne afin que les segments de longueur nulle soient représentés par un point (comme le point sur la lettre minuscule i). La fonction doRecognition() est appelée après l'écriture de chaque trait et sera définie ci-dessous.

Obtenir une instance de DigitalInkRecognizer

Pour effectuer la reconnaissance, nous devons transmettre l'objet Ink à une instance DigitalInkRecognizer. Pour obtenir l'instance DigitalInkRecognizer, nous devons d'abord télécharger le modèle de reconnaissance pour la langue souhaitée, puis le charger dans la RAM. Pour ce faire, utilisez l'extrait de code suivant, qui est placé dans la méthode viewDidLoad() pour plus de simplicité et qui utilise un nom de langue encodé en dur. Consultez l'application de démarrage rapide pour découvrir comment afficher la liste des langues disponibles à l'utilisateur et télécharger la langue sélectionnée.

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];
}

Les applications de démarrage rapide incluent du code supplémentaire qui montre comment gérer plusieurs téléchargements en même temps et comment déterminer quel téléchargement a réussi en gérant les notifications de fin.

Reconnaître un objet Ink

Nous passons ensuite à la fonction doRecognition(), qui est appelée à partir de touchesEnded() pour simplifier. Dans d'autres applications, vous pouvez ne vouloir appeler la reconnaissance qu'après un délai avant expiration ou lorsque l'utilisateur a appuyé sur un bouton pour déclencher la reconnaissance.

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];
  }];
}

Gérer les téléchargements de modèles

Nous avons déjà vu comment télécharger un modèle de reconnaissance. Les extraits de code suivants montrent comment vérifier si un modèle a déjà été téléchargé ou comment supprimer un modèle lorsqu'il n'est plus nécessaire pour récupérer l'espace de stockage.

Vérifier si un modèle a déjà été téléchargé

Swift

let model : DigitalInkRecognitionModel = ...
let modelManager = ModelManager.modelManager()
modelManager.isModelDownloaded(model)

Objective-C

MLKDigitalInkRecognitionModel *model = ...;
MLKModelManager *modelManager = [MLKModelManager modelManager];
[modelManager isModelDownloaded:model];

Supprimer un modèle téléchargé

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.");
                                }];
}

Conseils pour améliorer la précision de la reconnaissance du texte

La précision de la reconnaissance de texte peut varier selon les langues. La justesse dépend également du style d'écriture. Bien que la reconnaissance de l'encre numérique soit entraînée pour gérer de nombreux types de styles d'écriture, les résultats peuvent varier d'un utilisateur à l'autre.

Voici quelques conseils pour améliorer la précision d'un outil de reconnaissance de texte. Notez que ces techniques ne s'appliquent pas aux classificateurs de dessins pour les emoji, AutoDraw et les formes.

Zone d'écriture

De nombreuses applications disposent d'une zone d'écriture bien définie pour la saisie utilisateur. La signification d'un symbole est partiellement déterminée par sa taille par rapport à la taille de la zone d'écriture qui le contient. Par exemple, la différence entre une lettre minuscule ou majuscule "o" ou "c", et une virgule ou une barre oblique.

Indiquer la largeur et la hauteur de la zone d'écriture au système de reconnaissance peut améliorer la précision. Toutefois, le système de reconnaissance suppose que la zone de saisie ne contient qu'une seule ligne de texte. Si la zone d'écriture physique est suffisamment grande pour permettre à l'utilisateur d'écrire deux lignes ou plus, vous pouvez obtenir de meilleurs résultats en transmettant une WritingArea dont la hauteur correspond à votre meilleure estimation de la hauteur d'une seule ligne de texte. L'objet WritingArea que vous transmettez au lecteur ne doit pas nécessairement correspondre exactement à la zone de saisie physique à l'écran. Modifier la hauteur de WritingArea de cette manière fonctionne mieux dans certaines langues que dans d'autres.

Lorsque vous spécifiez la zone d'écriture, spécifiez sa largeur et sa hauteur dans les mêmes unités que les coordonnées du trait. Les arguments de coordonnées x,y ne nécessitent aucune unité. L'API normalise toutes les unités. La seule chose qui compte est la taille et la position relatives des traits. Vous pouvez transmettre des coordonnées dans l'échelle qui convient le mieux à votre système.

Précontexte

Le pré-contexte est le texte qui précède immédiatement les traits dans le Ink que vous essayez de reconnaître. Vous pouvez aider le système de reconnaissance en lui indiquant le pré-contexte.

Par exemple, les lettres cursives "n" et "u" sont souvent confondues. Si l'utilisateur a déjà saisi le mot partiel "arg", il peut continuer avec des traits qui peuvent être reconnus comme "ument" ou "nment". Spécifier le précontexte "arg" résout l'ambiguïté, car le mot "argument" est plus probable que "argnment".

Le précontexte peut également aider le système de reconnaissance à identifier les coupures de mots et les espaces entre les mots. Vous pouvez saisir un espace, mais vous ne pouvez pas en dessiner un. Comment un outil de reconnaissance peut-il déterminer quand un mot se termine et que le suivant commence ? Si l'utilisateur a déjà écrit "bonjour" et continue avec le mot "monde", sans précontexte, le système de reconnaissance renvoie la chaîne "monde". Toutefois, si vous spécifiez le pré-contexte "hello", le modèle renverra la chaîne "world", avec un espace initial, car "helloworld" a plus de sens que "helloword".

Vous devez fournir la chaîne de pré-contexte la plus longue possible, jusqu'à 20 caractères, espaces compris. Si la chaîne est plus longue, le système de reconnaissance n'utilise que les 20 derniers caractères.

L'exemple de code ci-dessous montre comment définir une zone de saisie et utiliser un objet RecognitionContext pour spécifier un pré-contexte.

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

Ordre des traits

La précision de la reconnaissance est sensible à l'ordre des traits. Les outils de reconnaissance s'attendent à ce que les traits soient effectués dans l'ordre dans lequel les utilisateurs écrivent naturellement, par exemple de gauche à droite pour l'anglais. Tout cas qui s'écarte de ce modèle, comme écrire une phrase en anglais en commençant par le dernier mot, donne des résultats moins précis.

Un autre exemple est le cas où un mot au milieu d'un Ink est supprimé et remplacé par un autre. La révision se trouve probablement au milieu d'une phrase, mais les traits de la révision se trouvent à la fin de la séquence de traits. Dans ce cas, nous vous recommandons d'envoyer le mot nouvellement écrit séparément à l'API et de fusionner le résultat avec les reconnaissances précédentes à l'aide de votre propre logique.

Gérer les formes ambiguës

Il arrive que la signification de la forme fournie au lecteur soit ambiguë. Par exemple, un rectangle aux bords très arrondis peut être considéré comme un rectangle ou une ellipse.

Ces cas peu clairs peuvent être traités à l'aide des scores de reconnaissance lorsqu'ils sont disponibles. Seuls les classificateurs de forme fournissent des scores. Si le modèle est très confiant, le score du meilleur résultat sera beaucoup meilleur que celui du deuxième meilleur résultat. En cas d'incertitude, les scores des deux premiers résultats seront proches. N'oubliez pas non plus que les classificateurs de forme interprètent l'ensemble de l'Ink comme une seule forme. Par exemple, si le Ink contient un rectangle et une ellipse côte à côte, le système de reconnaissance peut renvoyer l'un ou l'autre (ou quelque chose de complètement différent) en tant que résultat, car un seul candidat de reconnaissance ne peut pas représenter deux formes.