Reconnaître les traits Windows Ink en tant que texte et formes

Convertissez des traits d’encre en texte et en formes à l’aide des fonctionnalités de reconnaissance intégrées à Windows Ink.

API importantes : InkCanvas, Windows.UI.Input.Inking

Reconnaissance de texte libre avec analyse de l'encre numérique

Ici, nous montrons comment utiliser le moteur d’analyse Windows Ink (Windows.UI.Input.Inking.Analysis) pour classifier, analyser et reconnaître un ensemble de traits de forme libre sur un InkCanvas en tant que texte ou forme. (En plus de la reconnaissance de texte et de forme, l'analyse de l'encre peut également être utilisée pour reconnaître la structure des documents, les listes à puces et les dessins génériques.)

Dans cet exemple, la reconnaissance est lancée lorsque l’utilisateur clique sur un bouton pour indiquer qu’il a terminé le dessin.

Téléchargez cet exemple à partir de l’exemple d’analyse de l'encre (de base)

1. Tout d’abord, nous avons configuré l’interface utilisateur (MainPage.xaml).

   L’interface utilisateur inclut un bouton « Reconnaître », un InkCanvas et un Canvas standard. Lorsque le bouton « Reconnaître » est enfoncé, tous les traits d’encre du canevas manuscrit sont analysés et (s’ils sont reconnus) les formes correspondantes et le texte sont dessinés sur le canevas standard. Les traits d’encre d’origine sont ensuite supprimés du canevas d’encre.

   <Grid Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">
        <Grid.RowDefinitions>
            <RowDefinition Height="Auto"/>
            <RowDefinition Height="*"/>
        </Grid.RowDefinitions>
        <StackPanel x:Name="HeaderPanel" 
                    Orientation="Horizontal" 
                    Grid.Row="0">
            <TextBlock x:Name="Header" 
                        Text="Basic ink analysis sample" 
                        Style="{ThemeResource HeaderTextBlockStyle}" 
                        Margin="10,0,0,0" />
            <Button x:Name="recognize" 
                    Content="Recognize" 
                    Margin="50,0,10,0"/>
        </StackPanel>
        <Grid x:Name="drawingCanvas" Grid.Row="1">
   
            <!-- The canvas where we render the replacement text and shapes. -->
            <Canvas x:Name="recognitionCanvas" />
            <!-- The canvas for ink input. -->
            <InkCanvas x:Name="inkCanvas" />
   
        </Grid>
   </Grid>
   

2. Dans le fichier code-behind de l’interface utilisateur (MainPage.xaml.cs), ajoutez les références de type d’espace de noms nécessaires pour les fonctions d'encre et d'analyse d'encre :

   • Windows.UI.Input.Inking
   • windows.UI.Input.Inking.Analysis
   • windows.UI.Xaml.Shapes

3. Nous spécifions ensuite nos variables globales :

    InkAnalyzer inkAnalyzer = new InkAnalyzer();
    IReadOnlyList<InkStroke> inkStrokes = null;
    InkAnalysisResult inkAnalysisResults = null;
   

4. Ensuite, nous définissons quelques comportements d’entrée manuscrite de base :

   • InkPresenter est configuré pour interpréter les données d’entrée à partir du stylet, de la souris et du toucher en tant que traits d’encre (InputDeviceTypes).
   • Les traits d’encre sont rendus sur InkCanvas à l’aide des inkDrawingAttributes spécifiés.
   • Un écouteur pour l’événement clic sur le bouton « Reconnaître » est également déclaré.

   /// <summary>
   /// Initialize the UI page.
   /// </summary>
   public MainPage()
   {
       this.InitializeComponent();
   
       // Set supported inking device types.
       inkCanvas.InkPresenter.InputDeviceTypes =
           Windows.UI.Core.CoreInputDeviceTypes.Mouse |
           Windows.UI.Core.CoreInputDeviceTypes.Pen | 
           Windows.UI.Core.CoreInputDeviceTypes.Touch;
   
       // Set initial ink stroke attributes.
       InkDrawingAttributes drawingAttributes = new InkDrawingAttributes();
       drawingAttributes.Color = Windows.UI.Colors.Black;
       drawingAttributes.IgnorePressure = false;
       drawingAttributes.FitToCurve = true;
       inkCanvas.InkPresenter.UpdateDefaultDrawingAttributes(drawingAttributes);
   
       // Listen for button click to initiate recognition.
       recognize.Click += RecognizeStrokes_Click;
   }
   

5. Pour cet exemple, nous effectuons l'analyse d'encre dans le gestionnaire d'événements clic du bouton « Reconnaître ».

   • Tout d’abord, appelez GetStrokes sur StrokeContainer de InkCanvas.InkPresenter pour obtenir la collection de tous les traits d’encre actuels.
   • Si des traits d’encre sont présents, passez-les dans un appel à AddDataForStrokes de InkAnalyzer.
   • Nous essayons de reconnaître à la fois les dessins et le texte, mais vous pouvez utiliser la méthode SetStrokeDataKind pour spécifier si vous êtes intéressé uniquement par le texte (y compris la structure de documents et les listes de puces) ou uniquement dans les dessins (y compris la reconnaissance de forme).
   • Appelez AnalyzeAsync pour lancer l'analyse d'encre et obtenir InkAnalysisResult.
   • Si Status retourne un état de Mise à jour, appelez FindNodes pour InkAnalysisNodeKind.InkWord et InkAnalysisNodeKind.InkDrawing.
   • Effectuez une itération dans les deux ensembles de types de nœuds et dessinez le texte ou la forme respectifs sur le canevas de reconnaissance (sous le canevas manuscrit).
   • Enfin, supprimez les nœuds reconnus de l’InkAnalyzer et les traits d'encre correspondants du canvas d’encre.

   /// <summary>
   /// The "Analyze" button click handler.
   /// Ink recognition is performed here.
   /// </summary>
   /// <param name="sender">Source of the click event</param>
   /// <param name="e">Event args for the button click routed event</param>
   private async void RecognizeStrokes_Click(object sender, RoutedEventArgs e)
   {
       inkStrokes = inkCanvas.InkPresenter.StrokeContainer.GetStrokes();
       // Ensure an ink stroke is present.
       if (inkStrokes.Count > 0)
       {
           inkAnalyzer.AddDataForStrokes(inkStrokes);
   
           // In this example, we try to recognizing both 
           // writing and drawing, so the platform default 
           // of "InkAnalysisStrokeKind.Auto" is used.
           // If you're only interested in a specific type of recognition,
           // such as writing or drawing, you can constrain recognition 
           // using the SetStrokDataKind method as follows:
           // foreach (var stroke in strokesText)
           // {
           //     analyzerText.SetStrokeDataKind(
           //      stroke.Id, InkAnalysisStrokeKind.Writing);
           // }
           // This can improve both efficiency and recognition results.
           inkAnalysisResults = await inkAnalyzer.AnalyzeAsync();
   
           // Have ink strokes on the canvas changed?
           if (inkAnalysisResults.Status == InkAnalysisStatus.Updated)
           {
               // Find all strokes that are recognized as handwriting and 
               // create a corresponding ink analysis InkWord node.
               var inkwordNodes = 
                   inkAnalyzer.AnalysisRoot.FindNodes(
                       InkAnalysisNodeKind.InkWord);
   
               // Iterate through each InkWord node.
               // Draw primary recognized text on recognitionCanvas 
               // (for this example, we ignore alternatives), and delete 
               // ink analysis data and recognized strokes.
               foreach (InkAnalysisInkWord node in inkwordNodes)
               {
                   // Draw a TextBlock object on the recognitionCanvas.
                   DrawText(node.RecognizedText, node.BoundingRect);
   
                   foreach (var strokeId in node.GetStrokeIds())
                   {
                       var stroke = 
                           inkCanvas.InkPresenter.StrokeContainer.GetStrokeById(strokeId);
                       stroke.Selected = true;
                   }
                   inkAnalyzer.RemoveDataForStrokes(node.GetStrokeIds());
               }
               inkCanvas.InkPresenter.StrokeContainer.DeleteSelected();
   
               // Find all strokes that are recognized as a drawing and 
               // create a corresponding ink analysis InkDrawing node.
               var inkdrawingNodes =
                   inkAnalyzer.AnalysisRoot.FindNodes(
                       InkAnalysisNodeKind.InkDrawing);
               // Iterate through each InkDrawing node.
               // Draw recognized shapes on recognitionCanvas and
               // delete ink analysis data and recognized strokes.
               foreach (InkAnalysisInkDrawing node in inkdrawingNodes)
               {
                   if (node.DrawingKind == InkAnalysisDrawingKind.Drawing)
                   {
                       // Catch and process unsupported shapes (lines and so on) here.
                   }
                   // Process generalized shapes here (ellipses and polygons).
                   else
                   {
                       // Draw an Ellipse object on the recognitionCanvas (circle is a specialized ellipse).
                       if (node.DrawingKind == InkAnalysisDrawingKind.Circle || node.DrawingKind == InkAnalysisDrawingKind.Ellipse)
                       {
                           DrawEllipse(node);
                       }
                       // Draw a Polygon object on the recognitionCanvas.
                       else
                       {
                           DrawPolygon(node);
                       }
                       foreach (var strokeId in node.GetStrokeIds())
                       {
                           var stroke = inkCanvas.InkPresenter.StrokeContainer.GetStrokeById(strokeId);
                           stroke.Selected = true;
                       }
                   }
                   inkAnalyzer.RemoveDataForStrokes(node.GetStrokeIds());
               }
               inkCanvas.InkPresenter.StrokeContainer.DeleteSelected();
           }
       }
   }
   

6. Voici la fonction permettant de dessiner un TextBlock sur notre canevas de reconnaissance. Nous utilisons le rectangle englobant du trait d’encre associé sur le canevas d’encre pour définir la position et la taille de police du TextBlock.

    /// <summary>
    /// Draw ink recognition text string on the recognitionCanvas.
    /// </summary>
    /// <param name="recognizedText">The string returned by text recognition.</param>
    /// <param name="boundingRect">The bounding rect of the original ink writing.</param>
    private void DrawText(string recognizedText, Rect boundingRect)
    {
        TextBlock text = new TextBlock();
        Canvas.SetTop(text, boundingRect.Top);
        Canvas.SetLeft(text, boundingRect.Left);
   
        text.Text = recognizedText;
        text.FontSize = boundingRect.Height;
   
        recognitionCanvas.Children.Add(text);
    }
   

7. Voici les fonctions permettant de dessiner des ellipses et des polygones sur notre espace de travail de reconnaissance. Nous utilisons le rectangle englobant du trait d’encre associé sur le canevas d’encre pour définir la position et la taille de police des formes.

    // Draw an ellipse on the recognitionCanvas.
    private void DrawEllipse(InkAnalysisInkDrawing shape)
    {
        var points = shape.Points;
        Ellipse ellipse = new Ellipse();
   
        ellipse.Width = shape.BoundingRect.Width;
        ellipse.Height = shape.BoundingRect.Height;
   
        Canvas.SetTop(ellipse, shape.BoundingRect.Top);
        Canvas.SetLeft(ellipse, shape.BoundingRect.Left);
   
        var brush = new SolidColorBrush(Windows.UI.ColorHelper.FromArgb(255, 0, 0, 255));
        ellipse.Stroke = brush;
        ellipse.StrokeThickness = 2;
        recognitionCanvas.Children.Add(ellipse);
    }
   
    // Draw a polygon on the recognitionCanvas.
    private void DrawPolygon(InkAnalysisInkDrawing shape)
    {
        List<Point> points = new List<Point>(shape.Points);
        Polygon polygon = new Polygon();
   
        foreach (Point point in points)
        {
            polygon.Points.Add(point);
        }
   
        var brush = new SolidColorBrush(Windows.UI.ColorHelper.FromArgb(255, 0, 0, 255));
        polygon.Stroke = brush;
        polygon.StrokeThickness = 2;
        recognitionCanvas.Children.Add(polygon);
    }
   

Voici cet exemple en action :

Avant l’analyse	Après analyse

Reconnaissance de l'écriture manuscrite sous contrainte

Dans la section précédente (reconnaissance de forme libre avec analyse d’encre), nous avons montré comment utiliser les API d’analyse d’encre pour analyser et reconnaître des traits d’encre arbitraires dans une zone InkCanvas.

Dans cette section, nous montrons comment utiliser le moteur de reconnaissance de l’écriture manuscrite Windows Ink (et non l’analyse manuscrite) pour convertir un ensemble de traits sur un InkCanvas en texte (en fonction du module linguistique par défaut installé).

Dans cet exemple, la reconnaissance est lancée lorsque l’utilisateur clique sur un bouton pour indiquer qu’il a terminé l’écriture.

Télécharger cet exemple à partir de l’exemple de reconnaissance manuscrite Ink

1. Tout d’abord, nous avons configuré l’interface utilisateur.

   L’interface utilisateur inclut un bouton « Reconnaître », inkCanvas et une zone pour afficher les résultats de la reconnaissance.

   <Grid Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">
        <Grid.RowDefinitions>
            <RowDefinition Height="Auto"/>
            <RowDefinition Height="*"/>
        </Grid.RowDefinitions>
        <StackPanel x:Name="HeaderPanel"
                    Orientation="Horizontal"
                    Grid.Row="0">
                <TextBlock x:Name="Header"
                    Text="Basic ink recognition sample"
                    Style="{ThemeResource HeaderTextBlockStyle}"
                    Margin="10,0,0,0" />
                <Button x:Name="recognize"
                    Content="Recognize"
                    Margin="50,0,10,0"/>
        </StackPanel>
        <Grid Grid.Row="1">
            <Grid.RowDefinitions>
                <RowDefinition Height="*"/>
                <RowDefinition Height="Auto"/>
            </Grid.RowDefinitions>
            <InkCanvas x:Name="inkCanvas"
                Grid.Row="0"/>
            <TextBlock x:Name="recognitionResult"
                Grid.Row="1"
                Margin="50,0,10,0"/>
        </Grid>
    </Grid>
   

2. Pour cet exemple, vous devez d’abord ajouter les références de types nécessaires à l'espace de noms requises pour notre fonctionnalité d'encre :

   • Windows.UI.Input
   • Windows.UI.Input.Inking

3. Nous définissons ensuite des comportements d’entrée manuscrite de base.

   InkPresenter est configuré pour interpréter les données d’entrée du stylet et de la souris en tant que traits d’encre (InputDeviceTypes). Les traits d’encre sont rendus sur InkCanvas à l’aide des inkDrawingAttributes spécifiés. Un écouteur pour l’événement clic sur le bouton « Reconnaître » est également déclaré.

   public MainPage()
       {
           this.InitializeComponent();
   
           // Set supported inking device types.
           inkCanvas.InkPresenter.InputDeviceTypes =
               Windows.UI.Core.CoreInputDeviceTypes.Mouse |
               Windows.UI.Core.CoreInputDeviceTypes.Pen;
   
           // Set initial ink stroke attributes.
           InkDrawingAttributes drawingAttributes = new InkDrawingAttributes();
           drawingAttributes.Color = Windows.UI.Colors.Black;
           drawingAttributes.IgnorePressure = false;
           drawingAttributes.FitToCurve = true;
           inkCanvas.InkPresenter.UpdateDefaultDrawingAttributes(drawingAttributes);
   
           // Listen for button click to initiate recognition.
           recognize.Click += Recognize_Click;
       }
   

4. Enfin, nous effectuons la reconnaissance de l’écriture manuscrite de base. Pour cet exemple, nous utilisons le gestionnaire d’événements click du bouton « Reconnaître » pour effectuer la reconnaissance de l’écriture manuscrite.

   • Un inkPresenter stocke tous les traits d’encre dans un objet InkStrokeContainer . Les traits sont exposés via la propriété StrokeContainer de InkPresenter et récupérés à l’aide de la méthode GetStrokes.

   // Get all strokes on the InkCanvas.
       IReadOnlyList<InkStroke> currentStrokes = inkCanvas.InkPresenter.StrokeContainer.GetStrokes();
   

   • Un InkRecognizerContainer est créé pour gérer le processus de reconnaissance de l’écriture manuscrite.

   // Create a manager for the InkRecognizer object
       // used in handwriting recognition.
       InkRecognizerContainer inkRecognizerContainer =
           new InkRecognizerContainer();
   

   • RecognizeAsync est appelé pour récupérer un ensemble d’objets InkRecognitionResult . Les résultats de reconnaissance sont générés pour chaque mot détecté par un InkRecognizer.

   // Recognize all ink strokes on the ink canvas.
       IReadOnlyList<InkRecognitionResult> recognitionResults =
           await inkRecognizerContainer.RecognizeAsync(
               inkCanvas.InkPresenter.StrokeContainer,
               InkRecognitionTarget.All);
   

   • Chaque objet InkRecognitionResult contient un ensemble de candidats de texte. L’élément le plus haut de cette liste est considéré par le moteur de reconnaissance comme étant le meilleur match, suivi des candidats restants dans l’ordre de diminution de la confiance.

     Nous itérons à travers chaque InkRecognitionResult et compilons la liste des candidats. Les candidats sont ensuite affichés et inkStrokeContainer est effacé (qui efface également InkCanvas).

   string str = "Recognition result\n";
       // Iterate through the recognition results.
       foreach (var result in recognitionResults)
       {
           // Get all recognition candidates from each recognition result.
           IReadOnlyList<string> candidates = result.GetTextCandidates();
           str += "Candidates: " + candidates.Count.ToString() + "\n";
           foreach (string candidate in candidates)
           {
               str += candidate + " ";
           }
       }
       // Display the recognition candidates.
       recognitionResult.Text = str;
       // Clear the ink canvas once recognition is complete.
       inkCanvas.InkPresenter.StrokeContainer.Clear();
   

   • Voici l’exemple de gestionnaire de clics, en intégralité.

   // Handle button click to initiate recognition.
       private async void Recognize_Click(object sender, RoutedEventArgs e)
       {
           // Get all strokes on the InkCanvas.
           IReadOnlyList<InkStroke> currentStrokes = inkCanvas.InkPresenter.StrokeContainer.GetStrokes();
   
           // Ensure an ink stroke is present.
           if (currentStrokes.Count > 0)
           {
               // Create a manager for the InkRecognizer object
               // used in handwriting recognition.
               InkRecognizerContainer inkRecognizerContainer =
                   new InkRecognizerContainer();
   
               // inkRecognizerContainer is null if a recognition engine is not available.
               if (!(inkRecognizerContainer == null))
               {
                   // Recognize all ink strokes on the ink canvas.
                   IReadOnlyList<InkRecognitionResult> recognitionResults =
                       await inkRecognizerContainer.RecognizeAsync(
                           inkCanvas.InkPresenter.StrokeContainer,
                           InkRecognitionTarget.All);
                   // Process and display the recognition results.
                   if (recognitionResults.Count > 0)
                   {
                       string str = "Recognition result\n";
                       // Iterate through the recognition results.
                       foreach (var result in recognitionResults)
                       {
                           // Get all recognition candidates from each recognition result.
                           IReadOnlyList<string> candidates = result.GetTextCandidates();
                           str += "Candidates: " + candidates.Count.ToString() + "\n";
                           foreach (string candidate in candidates)
                           {
                               str += candidate + " ";
                           }
                       }
                       // Display the recognition candidates.
                       recognitionResult.Text = str;
                       // Clear the ink canvas once recognition is complete.
                       inkCanvas.InkPresenter.StrokeContainer.Clear();
                   }
                   else
                   {
                       recognitionResult.Text = "No recognition results.";
                   }
               }
               else
               {
                   Windows.UI.Popups.MessageDialog messageDialog = new Windows.UI.Popups.MessageDialog("You must install handwriting recognition engine.");
                   await messageDialog.ShowAsync();
               }
           }
           else
           {
               recognitionResult.Text = "No ink strokes to recognize.";
           }
       }
   

Reconnaissance internationale

La reconnaissance de l’écriture manuscrite intégrée à la plateforme d’encre Windows comprend un sous-ensemble complet de paramètres régionaux et de langues pris en charge par Windows.

Consultez la rubrique de propriété InkRecognizer.Name pour obtenir la liste des langues prises en charge par InkRecognizer .

Votre application peut interroger l’ensemble des moteurs de reconnaissance d’écriture manuscrite installés et utiliser l’un de ces moteurs, ou laisser un utilisateur sélectionner sa langue préférée.

Note Les utilisateurs peuvent afficher la liste des langues installées en accédant aux paramètres -> Heure et langue. Les langues installées sont répertoriées sous Langues.

Pour installer de nouveaux modules linguistiques et activer la reconnaissance de l’écriture manuscrite pour cette langue :

1. Accédez à Paramètres Heure & langue Région & langue.
2. Sélectionnez Ajouter une langue.
3. Sélectionnez une langue dans la liste, puis choisissez la version de la région. La langue est désormais répertoriée dans la page Région et langue .
4. Cliquez sur la langue et sélectionnez Options.
5. Sur la page Options de langue , téléchargez le moteur de reconnaissance de l’écriture manuscrite (ils peuvent également télécharger le module linguistique complet, le moteur de reconnaissance vocale et la disposition du clavier ici).

Ici, nous montrons comment utiliser le moteur de reconnaissance de l’écriture manuscrite pour interpréter un ensemble de traits sur un InkCanvas basé sur le module de reconnaissance sélectionné.

La reconnaissance est lancée par l’utilisateur en cliquant sur un bouton lorsqu’il a terminé l’écriture.

1. Tout d’abord, nous avons configuré l’interface utilisateur.

   L’interface utilisateur inclut un bouton « Reconnaître », une zone de liste déroulante qui répertorie tous les modules de reconnaissance d’écriture manuscrite installés, InkCanvas et une zone pour afficher les résultats de la reconnaissance.

   <Grid Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">
           <Grid.RowDefinitions>
               <RowDefinition Height="Auto"/>
               <RowDefinition Height="*"/>
           </Grid.RowDefinitions>
           <StackPanel x:Name="HeaderPanel"
                       Orientation="Horizontal"
                       Grid.Row="0">
               <TextBlock x:Name="Header"
                          Text="Advanced international ink recognition sample"
                          Style="{ThemeResource HeaderTextBlockStyle}"
                          Margin="10,0,0,0" />
               <ComboBox x:Name="comboInstalledRecognizers"
                        Margin="50,0,10,0">
                   <ComboBox.ItemTemplate>
                       <DataTemplate>
                           <StackPanel Orientation="Horizontal">
                               <TextBlock Text="{Binding Name}" />
                           </StackPanel>
                       </DataTemplate>
                   </ComboBox.ItemTemplate>
               </ComboBox>
               <Button x:Name="buttonRecognize"
                       Content="Recognize"
                       IsEnabled="False"
                       Margin="50,0,10,0"/>
           </StackPanel>
           <Grid Grid.Row="1">
               <Grid.RowDefinitions>
                   <RowDefinition Height="*"/>
                   <RowDefinition Height="Auto"/>
               </Grid.RowDefinitions>
               <InkCanvas x:Name="inkCanvas"
                          Grid.Row="0"/>
               <TextBlock x:Name="recognitionResult"
                          Grid.Row="1"
                          Margin="50,0,10,0"/>
           </Grid>
       </Grid>
   

2. Nous définissons ensuite des comportements d’entrée manuscrite de base.

   InkPresenter est configuré pour interpréter les données d’entrée du stylet et de la souris en tant que traits d’encre (InputDeviceTypes). Les traits d’encre sont rendus sur InkCanvas à l’aide des inkDrawingAttributes spécifiés.

   Nous appelons une InitializeRecognizerList fonction pour remplir la zone de liste déroulante du module de reconnaissance avec une liste des modules de reconnaissance d’écriture manuscrite installés.

   Nous déclarons également les écouteurs pour l’événement de clic sur le bouton « Reconnaître » et l’événement de modification de sélection sur le menu déroulant du sélecteur de reconnaissance.

    public MainPage()
    {
       this.InitializeComponent();
   
       // Set supported inking device types.
       inkCanvas.InkPresenter.InputDeviceTypes =
           Windows.UI.Core.CoreInputDeviceTypes.Mouse |
           Windows.UI.Core.CoreInputDeviceTypes.Pen;
   
       // Set initial ink stroke attributes.
       InkDrawingAttributes drawingAttributes = new InkDrawingAttributes();
       drawingAttributes.Color = Windows.UI.Colors.Black;
       drawingAttributes.IgnorePressure = false;
       drawingAttributes.FitToCurve = true;
       inkCanvas.InkPresenter.UpdateDefaultDrawingAttributes(drawingAttributes);
   
       // Populate the recognizer combo box with installed recognizers.
       InitializeRecognizerList();
   
       // Listen for combo box selection.
       comboInstalledRecognizers.SelectionChanged +=
           comboInstalledRecognizers_SelectionChanged;
   
       // Listen for button click to initiate recognition.
       buttonRecognize.Click += Recognize_Click;
   }
   

3. Nous remplissons la zone de liste déroulante des reconnaisseurs avec une liste des reconnaisseurs d'écriture manuscrite installés.

   Un InkRecognizerContainer est créé pour gérer le processus de reconnaissance de l’écriture manuscrite. Utilisez cet objet pour appeler GetRecognizers et récupérer la liste des modules de reconnaissance installés pour remplir la zone de liste déroulante du module de reconnaissance.

   // Populate the recognizer combo box with installed recognizers.
   private void InitializeRecognizerList()
   {
       // Create a manager for the handwriting recognition process.
       inkRecognizerContainer = new InkRecognizerContainer();
       // Retrieve the collection of installed handwriting recognizers.
       IReadOnlyList<InkRecognizer> installedRecognizers =
           inkRecognizerContainer.GetRecognizers();
       // inkRecognizerContainer is null if a recognition engine is not available.
       if (!(inkRecognizerContainer == null))
       {
           comboInstalledRecognizers.ItemsSource = installedRecognizers;
           buttonRecognize.IsEnabled = true;
       }
   }
   

4. Mettez à jour le module de reconnaissance de l’écriture manuscrite si la sélection de la zone de liste modifiable du module de reconnaissance change.

   Utilisez InkRecognizerContainer pour appeler SetDefaultRecognizer en fonction du module de reconnaissance sélectionné dans la boîte de sélection du module de reconnaissance.

   // Handle recognizer change.
       private void comboInstalledRecognizers_SelectionChanged(
           object sender, SelectionChangedEventArgs e)
       {
           inkRecognizerContainer.SetDefaultRecognizer(
               (InkRecognizer)comboInstalledRecognizers.SelectedItem);
       }
   

5. Enfin, nous effectuons la reconnaissance de l’écriture manuscrite en fonction du module de reconnaissance d’écriture manuscrite sélectionné. Pour cet exemple, nous utilisons le gestionnaire d’événements click du bouton « Reconnaître » pour effectuer la reconnaissance de l’écriture manuscrite.

   • Un inkPresenter stocke tous les traits d’encre dans un objet InkStrokeContainer . Les traits sont exposés via la propriété StrokeContainer de InkPresenter et récupérés à l’aide de la méthode GetStrokes.

   // Get all strokes on the InkCanvas.
       IReadOnlyList<InkStroke> currentStrokes =
           inkCanvas.InkPresenter.StrokeContainer.GetStrokes();
   

   • RecognizeAsync est appelé pour récupérer un ensemble d’objets InkRecognitionResult .

     Les résultats de reconnaissance sont générés pour chaque mot détecté par un InkRecognizer.

   // Recognize all ink strokes on the ink canvas.
   IReadOnlyList<InkRecognitionResult> recognitionResults =
       await inkRecognizerContainer.RecognizeAsync(
           inkCanvas.InkPresenter.StrokeContainer,
           InkRecognitionTarget.All);
   

   • Chaque objet InkRecognitionResult contient un ensemble de candidats de texte. L’élément le plus haut de cette liste est considéré par le moteur de reconnaissance comme étant le meilleur match, suivi des candidats restants dans l’ordre de diminution de la confiance.

     Nous itérons à travers chaque InkRecognitionResult et compilons la liste des candidats. Les candidats sont ensuite affichés et inkStrokeContainer est effacé (qui efface également InkCanvas).

   string str = "Recognition result\n";
   // Iterate through the recognition results.
   foreach (InkRecognitionResult result in recognitionResults)
   {
           // Get all recognition candidates from each recognition result.
           IReadOnlyList<string> candidates =
               result.GetTextCandidates();
           str += "Candidates: " + candidates.Count.ToString() + "\n";
           foreach (string candidate in candidates)
           {
               str += candidate + " ";
           }
   }
   // Display the recognition candidates.
   recognitionResult.Text = str;
   // Clear the ink canvas once recognition is complete.
   inkCanvas.InkPresenter.StrokeContainer.Clear();
   

   • Voici l’exemple de gestionnaire de clics, en intégralité.

   // Handle button click to initiate recognition.
   private async void Recognize_Click(object sender, RoutedEventArgs e)
   {
       // Get all strokes on the InkCanvas.
       IReadOnlyList<InkStroke> currentStrokes =
           inkCanvas.InkPresenter.StrokeContainer.GetStrokes();
   
       // Ensure an ink stroke is present.
       if (currentStrokes.Count > 0)
       {
           // inkRecognizerContainer is null if a recognition engine is not available.
           if (!(inkRecognizerContainer == null))
           {
               // Recognize all ink strokes on the ink canvas.
               IReadOnlyList<InkRecognitionResult> recognitionResults =
                   await inkRecognizerContainer.RecognizeAsync(
                       inkCanvas.InkPresenter.StrokeContainer,
                       InkRecognitionTarget.All);
               // Process and display the recognition results.
               if (recognitionResults.Count > 0)
               {
                   string str = "Recognition result\n";
                   // Iterate through the recognition results.
                   foreach (InkRecognitionResult result in recognitionResults)
                   {
                       // Get all recognition candidates from each recognition result.
                       IReadOnlyList<string> candidates =
                           result.GetTextCandidates();
                       str += "Candidates: " + candidates.Count.ToString() + "\n";
                       foreach (string candidate in candidates)
                       {
                           str += candidate + " ";
                       }
                   }
                   // Display the recognition candidates.
                   recognitionResult.Text = str;
                   // Clear the ink canvas once recognition is complete.
                   inkCanvas.InkPresenter.StrokeContainer.Clear();
               }
               else
               {
                   recognitionResult.Text = "No recognition results.";
               }
           }
           else
           {
               Windows.UI.Popups.MessageDialog messageDialog =
                   new Windows.UI.Popups.MessageDialog(
                       "You must install handwriting recognition engine.");
               await messageDialog.ShowAsync();
           }
       }
       else
       {
           recognitionResult.Text = "No ink strokes to recognize.";
       }
   }
   

Reconnaissance dynamique

Bien que les deux exemples précédents exigent que l’utilisateur appuie sur un bouton pour démarrer la reconnaissance, vous pouvez également effectuer une reconnaissance dynamique à l’aide d’une entrée de trait jumelée à une fonction de minutage de base.

Pour cet exemple, nous allons utiliser les mêmes paramètres d’interface utilisateur et de trait que l’exemple de reconnaissance internationale précédent.

1. Ces objets globaux (InkAnalyzer, InkStroke, InkAnalysisResult, DispatcherTimer) sont utilisés dans toute notre application.

   // Stroke recognition globals.
   InkAnalyzer inkAnalyzer;
   DispatcherTimer recoTimer;
   

2. Au lieu d’un bouton pour lancer la reconnaissance, nous ajoutons des gestionnaires pour deux événements de trait InkPresenter (StrokesCollected et StrokeStarted), et nous configurons un minuteur de base (DispatcherTimer) avec un intervalle d'une seconde .

   public MainPage()
   {
       this.InitializeComponent();
   
       // Set supported inking device types.
       inkCanvas.InkPresenter.InputDeviceTypes =
           Windows.UI.Core.CoreInputDeviceTypes.Mouse |
           Windows.UI.Core.CoreInputDeviceTypes.Pen;
   
       // Listen for stroke events on the InkPresenter to 
       // enable dynamic recognition.
       // StrokesCollected is fired when the user stops inking by 
       // lifting their pen or finger, or releasing the mouse button.
       inkCanvas.InkPresenter.StrokesCollected += inkCanvas_StrokesCollected;
       // StrokeStarted is fired when ink input is first detected.
       inkCanvas.InkPresenter.StrokeInput.StrokeStarted +=
           inkCanvas_StrokeStarted;
   
       inkAnalyzer = new InkAnalyzer();
   
       // Timer to manage dynamic recognition.
       recoTimer = new DispatcherTimer();
       recoTimer.Interval = TimeSpan.FromSeconds(1);
       recoTimer.Tick += recoTimer_TickAsync;
   }
   

3. Nous définissons ensuite les gestionnaires des événements InkPresenter que nous avons déclarés à la première étape (nous substituons également l’événement OnNavigatingFrom page pour gérer notre minuteur).

   • StrokesCollected
     Ajoutez des traits d’encre (AddDataForStrokes) à InkAnalyzer et démarrez le minuteur de reconnaissance lorsque l’utilisateur arrête l’entrée manuscrite (en levant son stylet ou son doigt, ou en libérant le bouton de la souris). Après une seconde sans entrée d'encre, la reconnaissance est lancée.

     Utilisez la méthode SetStrokeDataKind pour spécifier si vous êtes intéressé uniquement par le texte (y compris les listes de puces et la structure de document) ou uniquement par les dessins (y compris la reconnaissance de forme).

   • StrokeStarted
     Si un nouveau trait commence avant le prochain tic du minuteur, il faut arrêter le minuteur car le nouveau trait est probablement la continuation d’une seule entrée d’écriture manuscrite.

   // Handler for the InkPresenter StrokeStarted event.
   // Don't perform analysis while a stroke is in progress.
   // If a new stroke starts before the next timer tick event,
   // stop the timer as the new stroke is likely the continuation
   // of a single handwriting entry.
   private void inkCanvas_StrokeStarted(InkStrokeInput sender, PointerEventArgs args)
   {
       recoTimer.Stop();
   }
   // Handler for the InkPresenter StrokesCollected event.
   // Stop the timer and add the collected strokes to the InkAnalyzer.
   // Start the recognition timer when the user stops inking (by 
   // lifting their pen or finger, or releasing the mouse button).
   // If ink input is not detected after one second, initiate recognition.
   private void inkCanvas_StrokesCollected(InkPresenter sender, InkStrokesCollectedEventArgs args)
   {
       recoTimer.Stop();
       // If you're only interested in a specific type of recognition,
       // such as writing or drawing, you can constrain recognition 
       // using the SetStrokDataKind method, which can improve both 
       // efficiency and recognition results.
       // In this example, "InkAnalysisStrokeKind.Writing" is used.
       foreach (var stroke in args.Strokes)
       {
           inkAnalyzer.AddDataForStroke(stroke);
           inkAnalyzer.SetStrokeDataKind(stroke.Id, InkAnalysisStrokeKind.Writing);
       }
       recoTimer.Start();
   }
   // Override the Page OnNavigatingFrom event handler to 
   // stop our timer if user leaves page.
   protected override void OnNavigatingFrom(NavigatingCancelEventArgs e)
   {
       recoTimer.Stop();
   }
   

4. Enfin, nous effectuons la reconnaissance de l’écriture manuscrite. Pour cet exemple, nous utilisons le gestionnaire d’événements Tick d’un DispatcherTimer pour lancer la reconnaissance de l’écriture manuscrite.

   • Appelez AnalyzeAsync pour lancer l'analyse d'encre et obtenir InkAnalysisResult.
   • Si Status retourne un état de Mise à jour, appelez FindNodes pour les types de nœuds d’InkAnalysisNodeKind.InkWord.
   • Itérer sur les nœuds et afficher le texte reconnu.
   • Enfin, supprimez les nœuds reconnus de l’InkAnalyzer et les traits d'encre correspondants du canvas d’encre.

   private async void recoTimer_TickAsync(object sender, object e)
   {
       recoTimer.Stop();
       if (!inkAnalyzer.IsAnalyzing)
       {
           InkAnalysisResult result = await inkAnalyzer.AnalyzeAsync();
   
           // Have ink strokes on the canvas changed?
           if (result.Status == InkAnalysisStatus.Updated)
           {
               // Find all strokes that are recognized as handwriting and 
               // create a corresponding ink analysis InkWord node.
               var inkwordNodes =
                   inkAnalyzer.AnalysisRoot.FindNodes(
                       InkAnalysisNodeKind.InkWord);
   
               // Iterate through each InkWord node.
               // Display the primary recognized text (for this example, 
               // we ignore alternatives), and then delete the 
               // ink analysis data and recognized strokes.
               foreach (InkAnalysisInkWord node in inkwordNodes)
               {
                   string recognizedText = node.RecognizedText;
                   // Display the recognition candidates.
                   recognitionResult.Text = recognizedText;
   
                   foreach (var strokeId in node.GetStrokeIds())
                   {
                       var stroke =
                           inkCanvas.InkPresenter.StrokeContainer.GetStrokeById(strokeId);
                       stroke.Selected = true;
                   }
                   inkAnalyzer.RemoveDataForStrokes(node.GetStrokeIds());
               }
               inkCanvas.InkPresenter.StrokeContainer.DeleteSelected();
           }
       }
       else
       {
           // Ink analyzer is busy. Wait a while and try again.
           recoTimer.Start();
       }
   }
   

Articles connexes

• Interactions entre stylo et stylet

Exemples de rubriques

• Exemple d'analyse de l'encre (de base) (C#)
• Exemple de reconnaissance de l'écriture manuscrite (C#)

Autres exemples

• Exemple d’encre simple (C#/C++)
• Exemple d’encre complexe (C++)
• Exemple d’encre (JavaScript)
• Tutoriel de démarrage : Supporter l'encre dans votre application Windows
• Exemple de livre de coloration
• Exemple de notes de famille