RecognitionAlternate.Descender Property

Article
12/12/2007

Gets the descender line for a RecognitionAlternate object that represents a single line of text.

Namespace: Microsoft.Ink
Assembly: Microsoft.Ink (in microsoft.ink.dll)

Syntax

'Declaration
Public ReadOnly Property Descender As Line
'Usage
Dim instance As RecognitionAlternate
Dim value As Line

value = instance.Descender

public Line Descender { get; }

public:
property Line Descender {
    Line get ();
}

/** @property */
public Line get_Descender ()

public function get Descender () : Line

Not applicable.

Property Value

The descender line for a RecognitionAlternate object that represents a single line of text.

Remarks

For western languages, the descender corresponds to the portion of a lowercase letter that falls below the baseline, such as the vertical line of a "p" that extends below the lowest point of the circle in that letter. The descender line is the imaginary horizontal line across the bottom of the descenders.

Note

If the recognition alternate spans more than one recognition segment within a line of text, then this property returns a line parallel to the baseline for the alternate. The distance of the descender line below the baseline is determined by the corresponding distance within the first segment.

You can use the AlternatesWithConstantPropertyValues method with the g parameter set to the RecognitionProperty.Segmentation globally unique identifier (GUID) to get a collection of one segment recognition alternates that correspond to a segmentation of your original alternate.

Note

If the recognition alternate spans more than one line, this property throws COMException exception. You can use the LineAlternates property to get a collection of one line recognition alternates that corresponds to a multiple line recognition alternate.

Example

This C# example defines event handlers for a form, RecognitionResultForm, to which a ListBox control, theListBox, and two Button controls, theRecognizeButton and theGetDataButton, have been added. The sample also defines an InkCollector, theInkCollector, a RecognizerContext, theRecognizerContext, and a RecognitionResult, theRecognitionResult, which are used to collect ink and to perform recognition.

The event handler for the theRecognizeButton's click event performs recognition on the strokes in the ink collector and puts information about the top alternate of the recognition result into theListBox.

The event handler for the theGetDataButton's click event gets the line alternates collection for the top alternate. The handler then draws the ascender line, midline, baseline, and descender line for each line alternate. The handler also puts information about the line number and confidence of each line alternate into theListBox.

[C#]

// Declare ink elements and create pens.
Microsoft.Ink.InkCollector theInkCollector;
Microsoft.Ink.RecognizerContext theRecognizerContext;
Microsoft.Ink.RecognitionResult theRecognitionResult;

System.Drawing.Pen thePen1 = new Pen(Color.Red);
System.Drawing.Pen thePen2 = new Pen(Color.Orange);
System.Drawing.Pen thePen3 = new Pen(Color.Yellow);
System.Drawing.Pen thePen4 = new Pen(Color.Green);

// Event handler for the form's Load event.
private void RecognitionResultForm_Load(object sender, System.EventArgs e)
{
    // Create the ink collector.
    this.theInkCollector = new Microsoft.Ink.InkCollector(this.Handle);
    this.theInkCollector.Enabled = true;

    // Create the default recognizer context.
    this.theRecognizerContext = new Microsoft.Ink.RecognizerContext();
}

// Event handler for the "Recognize" button's Click event.
private void theRecognizeButton_Click(object sender, System.EventArgs e)
{
    // Check for ink before performing recognition.
    this.theListBox.Items.Clear();
    if (0 == this.theInkCollector.Ink.Strokes.Count)
    {
        this.theListBox.Items.Add("No ink to recognize.");
        return;
    }

    // Perform recognition on the strokes currently in the ink collector.
    Microsoft.Ink.RecognitionStatus theRecognitionStatus;
    this.theRecognizerContext.Strokes = this.theInkCollector.Ink.Strokes;
    this.theRecognitionResult =
        this.theRecognizerContext.Recognize(out theRecognitionStatus);

    // Display information about the recognition result in the list box.
    this.theListBox.Items.Add("The top alternate is: " +
        this.theRecognitionResult.TopString);
    this.theListBox.Items.Add("The top confidence is: " +
        this.theRecognitionResult.TopConfidence);
    this.theListBox.Items.Add("The number of strokes is:" +
        this.theRecognitionResult.Strokes.Count);
}

// Event handler for the "Get Data" button's Click event.
private void theGetDataButton_Click(object sender, System.EventArgs e)
{
    // Refresh the list box and check for a recognition result.
    this.theListBox.Items.Clear();
    if (null == this.theRecognitionResult)
    {
        this.theListBox.Items.Add("No recognition result available.");
        return;
    }

    // Get the line alternates collection for the top alternate.
    Microsoft.Ink.RecognitionAlternates theLineAlternates =
        this.theRecognitionResult.TopAlternate.LineAlternates;

    using (System.Drawing.Graphics g = this.CreateGraphics())
    {
        // Clear the drawing surface
        g.Clear(this.BackColor);

        // For each line alternate in the collection:
        foreach(Microsoft.Ink.RecognitionAlternate theAlternate
                    in theLineAlternates)
        {
            // Add information about the alternate to the list box.
            this.theListBox.Items.Add("The Line Number is: " +
                theAlternate.LineNumber.ToString());
            this.theListBox.Items.Add("The alternate's text is: " +
                theAlternate.ToString());
            this.theListBox.Items.Add("The number of strokes is: " +
                theAlternate.Strokes.Count);
            this.theListBox.Items.Add("The Confidence is: " +
                theAlternate.Confidence.ToString());

            // Draw the ascender, midline, baseline, and descender.
            DrawLine(g, theAlternate.Ascender, this.thePen1);
            DrawLine(g, theAlternate.Midline, this.thePen2);
            DrawLine(g, theAlternate.Baseline, this.thePen3);
            DrawLine(g, theAlternate.Descender, this.thePen4);

            this.theListBox.Items.Add(string.Empty);
        }

        // Redraw the ink.
        this.theInkCollector.Renderer.Draw(g, this.theRecognitionResult.Strokes);
    }
}

// Event handler for the form's Closed event.
private void RecognitionResultForm_Closed(object sender, System.EventArgs e)
{
    // Free the resources for the ink collector, recognizer context, and pens.
    this.theInkCollector.Dispose();
    this.theInkCollector = null;
    this.theRecognizerContext.Dispose();
    this.theRecognizerContext = null;

    this.thePen1.Dispose();
    this.thePen1 = null;
    this.thePen2.Dispose();
    this.thePen2 = null;
    this.thePen3.Dispose();
    this.thePen3 = null;
    this.thePen4.Dispose();
    this.thePen4 = null;
}

// Helper function to draw the lines.
private void DrawLine(System.Drawing.Graphics g,
    Microsoft.Ink.Line line, System.Drawing.Pen pen)
{
    System.Drawing.Point point1 = line.BeginPoint;
    System.Drawing.Point point2 = line.EndPoint;

    this.theInkCollector.Renderer.InkSpaceToPixel(g, ref point1);
    this.theInkCollector.Renderer.InkSpaceToPixel(g, ref point2);

    g.DrawLine(pen, point1, point2);
}

This Microsoft® Visual Basic® .NET example defines event handlers for a form, RecognitionResultForm, to which a ListBox control, theListBox, and two Button controls, theRecognizeButton and theGetDataButton, have been added. The sample also defines an InkCollector, theInkCollector, a RecognizerContext, theRecognizerContext, and a RecognitionResult, theRecognitionResult, which are used to collect ink and to perform recognition.

[Visual Basic]

    Dim theInkCollector As Microsoft.Ink.InkCollector
    Dim theRecognizerContext As Microsoft.Ink.RecognizerContext
    Dim theRecognitionResult As Microsoft.Ink.RecognitionResult

    Dim thePen1 As System.Drawing.Pen = New Pen(Color.Red)
    Dim thePen2 As System.Drawing.Pen = New Pen(Color.Orange)
    Dim thePen3 As System.Drawing.Pen = New Pen(Color.Yellow)
    Dim thePen4 As System.Drawing.Pen = New Pen(Color.Green)

    ' Event handler for the form's Load event.
    Private Sub RecognitionResultForm_Load(ByVal sender As System.Object, _
        ByVal e As System.EventArgs) Handles MyBase.Load

        ' Create the ink collector.
        Me.theInkCollector = New Microsoft.Ink.InkCollector(Me.Handle)
        Me.theInkCollector.Enabled = True

        ' Create the default recognizer context.
        Me.theRecognizerContext = New Microsoft.Ink.RecognizerContext
    End Sub

    ' Event handler for the "Recognize" button's Click event.
    Private Sub theRecognizeButton_Click(ByVal sender As System.Object, _
        ByVal e As System.EventArgs) Handles theRecognizeButton.Click

        ' Check for ink before performing recognition.
        Me.theListBox.Items.Clear()
        If Me.theInkCollector.Ink.Strokes.Count = 0 Then
            Me.theListBox.Items.Add("No ink to recognize.")
            Return
        End If

        ' Perform recognition on the strokes currently in the ink collector.
        Dim theRecognitionStatus As Microsoft.Ink.RecognitionStatus
        Me.theRecognizerContext.Strokes = Me.theInkCollector.Ink.Strokes
        Me.theRecognitionResult = _
            Me.theRecognizerContext.Recognize(theRecognitionStatus)

        ' Display information about the recognition result in the list box.
        Me.theListBox.Items.Add("The top alternate is: " & _
                                    theRecognitionResult.TopString)
        Me.theListBox.Items.Add("The top confidence is: " & _
                                    theRecognitionResult.TopConfidence.ToString())
        Me.theListBox.Items.Add("The number of strokes is:" & _
                                    theRecognitionResult.Strokes.Count)
    End Sub

    ' Event handler for the "Get Data" button's Click event.
    Private Sub theGetDataButton_Click(ByVal sender As System.Object, _
        ByVal e As System.EventArgs) Handles theGetDataButton.Click

        ' Refresh the list box and check for a recognition result.
        Me.theListBox.Items.Clear()
        If (Me.theRecognitionResult Is Nothing) Then
            Me.theListBox.Items.Add("No recognition result available.")
            Return
        End If

        ' Get the line alternates collection for the top alternate.
        Dim theLineAlternates As Microsoft.Ink.RecognitionAlternates = _
            Me.theRecognitionResult.TopAlternate.LineAlternates()

        ' Create a temporary graphics object.
        Dim g As System.Drawing.Graphics = Me.CreateGraphics()

        ' Clear the drawing surface
        g.Clear(Me.BackColor)

        ' For each line alternate in the collection:
        For Each theAlternate As Microsoft.Ink.RecognitionAlternate _
                    In theLineAlternates

            ' Add information about the alternate to the list box.
            Me.theListBox.Items.Add("The Line Number is: " & _
                theAlternate.LineNumber.ToString())
            Me.theListBox.Items.Add("The alternate's text is: " & _
                theAlternate.ToString())
            Me.theListBox.Items.Add("The number of strokes is: " & _
                theAlternate.Strokes.Count)
            Me.theListBox.Items.Add("The Confidence is: " & _
                theAlternate.Confidence.ToString())

            ' Draw the ascender, midline, baseline, and descender.
            DrawLine(g, theAlternate.Ascender, Me.thePen1)
            DrawLine(g, theAlternate.Midline, Me.thePen2)
            DrawLine(g, theAlternate.Baseline, Me.thePen3)
            DrawLine(g, theAlternate.Descender, Me.thePen4)

            Me.theListBox.Items.Add(String.Empty)
        Next

        ' Redraw the ink.
        Me.theInkCollector.Renderer.Draw(g, Me.theRecognitionResult.Strokes)

        ' Dispose of the graphics object.
        g.Dispose()
    End Sub

    ' Event handler for the form's Closed event.
    Private Sub RecognitionResultForm_Closed(ByVal sender As System.Object, _
        ByVal e As System.EventArgs) Handles MyBase.Closed

        ' Free the resources for the ink collector and recognizer context.
        Me.theInkCollector.Dispose()
        Me.theInkCollector = Nothing
        Me.theRecognizerContext.Dispose()
        Me.theRecognizerContext = Nothing

        Me.thePen1.Dispose()
        Me.thePen1 = Nothing
        Me.thePen2.Dispose()
        Me.thePen2 = Nothing
        Me.thePen3.Dispose()
        Me.thePen3 = Nothing
        Me.thePen4.Dispose()
        Me.thePen4 = Nothing
    End Sub

    ' Helper function to draw the lines.
    Private Sub DrawLine(ByVal g As System.Drawing.Graphics, _
        ByVal line As Microsoft.Ink.Line, ByVal pen As System.Drawing.Pen)

        Dim point1 As System.Drawing.Point = line.BeginPoint
        Dim point2 As System.Drawing.Point = line.EndPoint

        Me.theInkCollector.Renderer.InkSpaceToPixel(g, point1)
        Me.theInkCollector.Renderer.InkSpaceToPixel(g, point2)

        g.DrawLine(pen, point1, point2)
    End Sub

Platforms

Windows 98, Windows Server 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile for Pocket PC, Windows Mobile for Smartphone, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

The Microsoft .NET Framework 3.0 is supported on Windows Vista, Microsoft Windows XP SP2, and Windows Server 2003 SP1.

Version Information

.NET Framework

Supported in: 3.0

Share via