Podstawowa próbka analizy tuszu

W przykładzie Basic Ink Analysis pokazano, jak klasa InkAnalyzer dzieli atrament na różne segmenty wyrazów i rysunków.

Ten przykład jest zaktualizowaną wersją próbki dzielnika atramentu i. Przykład dzielnika pisma odręcznego używa klasy Divider, podczas gdy ten przykład wykorzystuje nowszy i preferowany interfejs API InkAnalysis. API InkAnalysis łączy RecognizerContext i Divider w jedno API i rozszerza funkcjonalność obu.

Podczas aktualizacji formularza przykładowo rysowany jest prostokąt wokół każdej analizowanej jednostki: wyrazów, wierszy, akapitów, regionów pisania, rysunków i punktorów. Formularz używa różnych kolorów dla różnych jednostek. Prostokąty są również powiększone o różne rozmiary, aby upewnić się, że żaden prostokąt nie jest zasłonięty przez inne.

W poniższej tabeli przedstawiono kolor i rozszerzenie dla każdej przeanalizowanej jednostki.

Przeanalizowana jednostka	Kolor prostokąta	Rozszerzenie prostokąta (piksele)
Słowo	Zielony	1
Linia	Purpurowy	3
Akapit	Niebieski	5
Pisanie regionu	Żółty	7
Rysunek	Czerwony	1
Pocisk	Pomarańcza	1

Możesz wymazać pociągnięcia w formularzu. W przykładowej aplikacji możesz przełączać się między trybem pisma odręcznego i wymazywania, aby zmienić funkcję pióra.

        private void miInk_Click(object sender, System.EventArgs e)
        {
            // Turn on the inking mode
            myInkOverlay.EditingMode = InkOverlayEditingMode.Ink;

            // Update the state of the Ink and Erase menu items
            miInk.Checked = true;
            miErase.Checked = false;

            // Update the UI
            this.Refresh();
        }

        private void miErase_Click(object sender, System.EventArgs e)
        {
            // Turn on the ink deletion mode
            myInkOverlay.EditingMode = InkOverlayEditingMode.Delete;

            // Update the state of the Ink and Erase menu items
            miInk.Checked = false;
            miErase.Checked = true;

            // Update the UI
            this.Refresh();
        }

Podczas dodawania lub usuwania pociągnięć, aktualizacja próbek w InkAnalyzerodbywa się automatycznie.

        private void myInkOverlay_Stroke(object sender, InkCollectorStrokeEventArgs e)
        {
            // Filter out the eraser stroke.
            if (InkOverlayEditingMode.Ink == myInkOverlay.EditingMode)
            {

                // Add the new stroke to the InkAnalyzer's stroke collection
                myInkAnalyzer.AddStroke(e.Stroke);

                if (miAutomaticLayoutAnalysis.Checked)
                {
                    // Invoke an analysis operation on the background thread
                    myInkAnalyzer.BackgroundAnalyze();
                }
            }
        }

        void myInkOverlay_StrokeDeleting(object sender, InkOverlayStrokesDeletingEventArgs e)
        {
            // Remove the strokes to be deleted from the InkAnalyzer's stroke collection
            myInkAnalyzer.RemoveStrokes(e.StrokesToDelete);

            // If automatic layout analysis is turned on, analyze the ink on the background thread
            if ( miAutomaticLayoutAnalysis.Checked )
            {
                // Invoke an analysis operation on the background thread
                myInkAnalyzer.BackgroundAnalyze ( );
            }
        }

Zwróć uwagę, że w menu Tryb domyślnie jest włączona automatyczna analiza układu. Po wybraniu tej opcji programy obsługi zdarzeń InkOverlay obiektu pociągnięcia i StrokesDeleting wywołają metodę BackgroundAnalyze za każdym razem, gdy pociągnięcie zostanie utworzone lub usunięte.

Notatka

Wywołanie metody InkAnalyzer obiektu Analyze z więcej niż kilkoma widocznymi pociągnięciami powoduje zauważalne opóźnienie w aplikacji. Dzieje się tak, ponieważ funkcja Analizuj jest synchroniczną operacją analizy tuszu. W praktyce wywołaj metodę Analyze tylko wtedy, gdy potrzebujesz wyniku. W przeciwnym razie użyj metody asynchronicznej BackgroundAnalyze, jak pokazano w przykładzie.

Obsługa wyników analizy

Przykład tworzy dwie tablice do przechowywania różnych prostokątów, poziomych lub obróconych. Użyj obróconej ramki ograniczającej, aby uzyskać kąt, pod którym jest napisany wiersz wyrazów. Przykład przedstawia właściwości zwrócone przez InkAnalyzer i wyświetla ramkę ograniczającą lub obróconą ramkę ograniczającą (w zależności od zaznaczenia menu).

      private Rectangle[] GetHorizontalBBoxes(Guid nodeType, int inflate)
        {
            // Declare the array of rectangles to hold the result
            Rectangle[] analysisRects;

            // Get the division units from the division result of division type
            ContextNodeCollection nodes = myInkAnalyzer.FindNodesOfType(nodeType);

            // If there is at least one unit, we construct the rectangles
            if ((null != nodes) && (0 < nodes.Count))
            {
                // We need to convert rectangles from ink units to
                // pixel units. For that, we need Graphics object
                // to pass to InkRenderer.InkSpaceToPixel method
                using (Graphics g = drawArea.CreateGraphics())
                {
                    // Construct the rectangles
                    analysisRects = new Rectangle[nodes.Count];

                    // InkRenderer.InkSpaceToPixel takes Point as parameter. 
                    // Create two Point objects to point to (Top, Left) and
                    // (Width, Height) properties of rectangle. (Width, Height)
                    // is used instead of (Right, Bottom) because (Right, Bottom)
                    // are read-only properties on Rectangle
                    Point ptLocation = new Point();
                    Point ptSize = new Point();

                    // Index into the bounding boxes
                    int i = 0;

                    // Iterate through the collection of division units to obtain the bounding boxes
                    foreach (ContextNode node in nodes)
                    {
                        // Get the bounding box of the strokes of the division unit
                        analysisRects[i] = node.Location.GetBounds();

                        // The bounding box is in ink space unit. Convert them into pixel unit. 
                        ptLocation = analysisRects[i].Location;
                        ptSize.X = analysisRects[i].Width;
                        ptSize.Y = analysisRects[i].Height;

                        // Convert the Location from Ink Space to Pixel Space
                        myInkOverlay.Renderer.InkSpaceToPixel(g, ref ptLocation);

                        // Convert the Size from Ink Space to Pixel Space
                        myInkOverlay.Renderer.InkSpaceToPixel(g, ref ptSize);

                        // Assign the result back to the corresponding properties
                        analysisRects[i].Location = ptLocation;
                        analysisRects[i].Width = ptSize.X;
                        analysisRects[i].Height = ptSize.Y;

                        // Inflate the rectangle by inflate pixels in both directions
                        analysisRects[i].Inflate(inflate, inflate);

                        // Increment the index
                        ++i;
                    }

                } // Relinquish the Graphics object
            }
            else
            {
                // Otherwise we return null
                analysisRects = null;
            }

            // Return the Rectangle[] object
            return analysisRects;
        }

        private System.Collections.ArrayList GetRotatedBBoxes(Guid nodeType, int inflate)
        {
            //Find the correct collection of results nodes.
            ContextNodeCollection Nodes = myInkAnalyzer.FindNodesOfType(nodeType);

            // Declare the array list to hold the results; 
            // This array represents the four points of a rectangle, with the first point
            // copied again to complete the cycle of points.

            ArrayList polygonPoints = new ArrayList(Nodes.Count);

            // Cycle through each results node, get and convert the
            // rotated bounding box points
            foreach (ContextNode node in Nodes)
            {
                //Declare the point array
                Point[] rotatedBoundingBox = null;

                //Switch on the type of ContextNode to cast into the
                //appropriate type.  This is required to access the 
                //type specific property "RotatedBoundingBox" which
                //is not found on all ContextNode types.
                if (nodeType == ContextNodeType.InkWord)
                {
                    rotatedBoundingBox = ((InkWordNode)node).GetRotatedBoundingBox();
                }
                else if (nodeType == ContextNodeType.Line)
                {
                    rotatedBoundingBox = ((LineNode)node).GetRotatedBoundingBox();
                }
                else if (nodeType == ContextNodeType.Paragraph)
                {
                    rotatedBoundingBox = ((ParagraphNode)node).GetRotatedBoundingBox();
                }
                else if (nodeType == ContextNodeType.WritingRegion ||
                         nodeType == ContextNodeType.InkDrawing ||
                         nodeType == ContextNodeType.InkBullet )
                {

                    // Rotated Bounding Boxes are not a supported option for 
                    // Writing Regions or Drawings.  We return the axis aligned 
                    // bounding box instead
                    Rectangle rect = node.Location.GetBounds();

                    // We need to create a looped list of 4 points to be consistent
                    // with the way InkAnalysis represents rotated bounding boxes.  
                    rotatedBoundingBox = new Point[4];

                    rotatedBoundingBox[0] = new Point(rect.X, rect.Y);
                    rotatedBoundingBox[1] = new Point(rect.Right, rect.Y);
                    rotatedBoundingBox[2] = new Point(rect.Right, rect.Bottom);
                    rotatedBoundingBox[3] = new Point(rect.X, rect.Bottom);

                }


                if (null != rotatedBoundingBox)
                {
                    // We need to convert rectangles from ink units to
                    // pixel units. For that, we need Graphics object
                    // to pass to InkRenderer.InkSpaceToPixel method
                    using (Graphics g = drawArea.CreateGraphics())
                    {
                        // convert each of the points from ink space to pixel space
                        for (int i = 0; i < rotatedBoundingBox.Length; i++)
                        {
                            myInkOverlay.Renderer.InkSpaceToPixel(g, ref rotatedBoundingBox[i]);
                        }

                        //inflate the points by calling helper method
                        InflateHelperMethod(ref rotatedBoundingBox, inflate);

                        // increment the node portion of the polygonPoints array
                        polygonPoints.Add(rotatedBoundingBox);
                    }
                }
            }
            //Return the results
            return polygonPoints;
        }

Analizator oblicza GetRotatedBoundingBox podczas analizy. Możesz uzyskać dostęp do informacji z obróconych pól ograniczenia w aplikacji z wielu przydatnych powodów:

• Wykrywaj lub rysuj granice pojedynczego wiersza, akapitu lub innej jednostki.
• Określ kąt, pod którym jest zapisywany wiersz lub akapit.
• Zaimplementuj funkcje, takie jak wybór wiersza, akapitu lub innej jednostki.

Tematy pokrewne

Podstawowe rozpoznawanie i analiza tuszu

Przykład zeskanowanego formularza papierowego

Przykład Dzielnika tuszu