InkAnalyzerBase.AddStrokesToCustomRecognizer Method
Adds stroke data for multiple strokes to a custom recognizer node.
Namespace: System.Windows.Ink.AnalysisCore
Assembly: IACore (in IACore.dll)
Syntax
'Declaration
Public Function AddStrokesToCustomRecognizer ( _
strokeIds As Integer(), _
strokePacketCount As Integer(), _
strokePacketData As Integer(), _
strokePacketDescription As Guid(), _
customRecognizer As ContextNodeBase _
) As ContextNodeBase
'Usage
Dim instance As InkAnalyzerBase
Dim strokeIds As Integer()
Dim strokePacketCount As Integer()
Dim strokePacketData As Integer()
Dim strokePacketDescription As Guid()
Dim customRecognizer As ContextNodeBase
Dim returnValue As ContextNodeBase
returnValue = instance.AddStrokesToCustomRecognizer(strokeIds, _
strokePacketCount, strokePacketData, _
strokePacketDescription, customRecognizer)
public ContextNodeBase AddStrokesToCustomRecognizer(
int[] strokeIds,
int[] strokePacketCount,
int[] strokePacketData,
Guid[] strokePacketDescription,
ContextNodeBase customRecognizer
)
public:
ContextNodeBase^ AddStrokesToCustomRecognizer(
array<int>^ strokeIds,
array<int>^ strokePacketCount,
array<int>^ strokePacketData,
array<Guid>^ strokePacketDescription,
ContextNodeBase^ customRecognizer
)
public function AddStrokesToCustomRecognizer(
strokeIds : int[],
strokePacketCount : int[],
strokePacketData : int[],
strokePacketDescription : Guid[],
customRecognizer : ContextNodeBase
) : ContextNodeBase
Parameters
strokeIds
Type: array<System.Int32[]An array containing the stroke identifiers.
strokePacketCount
Type: array<System.Int32[]An array containing the number of packets in each stroke.
strokePacketData
Type: array<System.Int32[]An array containing the packet data for the strokes.
strokePacketDescription
Type: array<System.Guid[]An array containing the packet property identifiers.
customRecognizer
Type: System.Windows.Ink.AnalysisCore.ContextNodeBaseThe custom recognizer node to which the strokes are added.
Return Value
Type: System.Windows.Ink.AnalysisCore.ContextNodeBase
The context node to which the ink analyzer added the strokes.
Remarks
The InkAnalyzerBase adds the strokes to a ContextNodeBase that has a Type property value of UnclassifiedInk.
During analysis the ink analyzer assigns the culture identifier of the active input thread to the stroke and adds the stroke to the first unclassified ink node under the ink recognizer. If no unclassified node exists, it is created. If the custom recognizer does not support the culture identifier, the ink analyzer continues analyzing and generates an AnalysisWarningBase warning. This warning has its WarningCode property set to the AnalysisWarningCode value of LanguageIdNotRespected.
Only strokes with the same packet descriptions can be added in a single call to AddStrokes.
This method expands the DirtyRegion to the union of the region's current value and the bounding box of the added strokes.
The InkAnalyzerBase throws an exception under the following circumstances.
The InkAnalyzerBase already contains a stroke with the same identifier as one of the strokes to be added.
The customRecognizer parameter contains a ContextNodeBase that is associated with a different InkAnalyzerBase object.
The customRecognizer parameter contains a ContextNodeBase that does not have a Type property value of CustomRecognizer.
Examples
This example defines a method that converts a Strokes collection to packet data and adds the strokes to a custom recognizer node. The method returns the ContextNodeBase to which the ink analyzer added the strokes.
''' <summary>
''' Adds a collection of strokes to a custom recognizer node.
''' </summary>
''' <param name="baseInkAnalyzer">The ink analyzer that contains the
''' custom recognizer node.</param>
''' <param name="theStrokes">The strokes to add.</param>
''' <param name="theCustomRecognizerNode">The custom recognizer node
''' to which to add the strokes.</param>
''' <returns>The node to which the analyzer added the strokes.</returns>
''' <remarks>
''' This method converts stroke data to packet data for example only.
''' The InkAnalyzerBase is used when your application is handling packet
''' data. If your application uses stroke data from an Ink object, then
''' you would use InkAnalyzer.
''' </remarks>
Public Overloads Shared Function MyAddStrokesToCustomRecognizer( _
ByVal baseInkAnalyzer As System.Windows.Ink.AnalysisCore.InkAnalyzerBase, _
ByVal theStrokes As Microsoft.Ink.Strokes, _
ByVal theCustomRecognizerNode As System.Windows.Ink.AnalysisCore.ContextNodeBase) _
As System.Windows.Ink.AnalysisCore.ContextNodeBase
If Nothing Is baseInkAnalyzer Then
Throw New ArgumentNullException("baseInkAnalyzer")
End If
If Nothing Is theStrokes Then
Throw New ArgumentNullException("theStrokes")
End If
If 0 = theStrokes.Count Then
Throw New ArgumentException("Empty strokes collection.")
End If
If System.Windows.Ink.AnalysisCore.ContextNodeTypeBase.CustomRecognizer <> theCustomRecognizerNode.Type Then
Throw New ArgumentException("The context node is not a custom recognizer node.", "theCustomRecognizer")
End If
If Nothing Is baseInkAnalyzer.FindNode(theCustomRecognizerNode.Id) Then
Throw New ArgumentException("The custom recognizer node is not attached to the ink analyzer.")
End If
' Only strokes that have the same packet description GUIDs
' can be added in one call to InkAnalyzerBase.AddStrokes.
Dim thePacketDescription As Guid() = theStrokes(0).PacketDescription
' Accumulate the stroke data in collections.
Dim theStrokeIdentifiers As New ArrayList()
Dim thePacketCounts As New ArrayList()
Dim thePacketData As New ArrayList()
Dim aStroke As Microsoft.Ink.Stroke
For Each aStroke In theStrokes
If Not InkAnalyzerHelper.AreElementwiseEquivalent(aStroke.PacketDescription, thePacketDescription) Then
Throw New ApplicationException("The strokes collection contains strokes with different packet descriptions.")
End If
' Add the stroke data to the collections.
theStrokeIdentifiers.Add(aStroke.Id)
thePacketCounts.Add(aStroke.PacketCount)
thePacketData.AddRange(aStroke.GetPacketData())
Next aStroke
' Add the stroke data to the base layer ink analyzer.
Dim result As System.Windows.Ink.AnalysisCore.ContextNodeBase = _
baseInkAnalyzer.AddStrokesToCustomRecognizer( _
DirectCast(theStrokeIdentifiers.ToArray(GetType(Integer)), Integer()), _
DirectCast(thePacketCounts.ToArray(GetType(Integer)), Integer()), _
DirectCast(thePacketData.ToArray(GetType(Integer)), Integer()), _
thePacketDescription, _
theCustomRecognizerNode)
Return result
End Function 'AddStrokesToCustomRecognizer
/// <summary>
/// Adds a collection of strokes to a custom recognizer node.
/// </summary>
/// <param name="baseInkAnalyzer">The ink analyzer that contains the
/// custom recognizer node.</param>
/// <param name="theStrokes">The strokes to add.</param>
/// <param name="theCustomRecognizerNode">The custom recognizer node
/// to which to add the strokes.</param>
/// <returns>The node to which the analyzer added the strokes.</returns>
/// <remarks>
/// This method converts stroke data to packet data for example only.
/// The InkAnalyzerBase is used when your application is handling packet
/// data. If your application uses stroke data from an Ink object, then
/// you would use InkAnalyzer.
/// </remarks>
public static System.Windows.Ink.AnalysisCore.ContextNodeBase MyAddStrokesToCustomRecognizer(
System.Windows.Ink.AnalysisCore.InkAnalyzerBase baseInkAnalyzer,
Microsoft.Ink.Strokes theStrokes,
System.Windows.Ink.AnalysisCore.ContextNodeBase theCustomRecognizerNode)
{
if (null == baseInkAnalyzer)
{
throw new ArgumentNullException("baseInkAnalyzer");
}
if (null == theStrokes)
{
throw new ArgumentNullException("theStrokes");
}
if (0 == theStrokes.Count)
{
throw new ArgumentException("Empty strokes collection.");
}
if (System.Windows.Ink.AnalysisCore.ContextNodeTypeBase.CustomRecognizer
!= theCustomRecognizerNode.Type)
{
throw new ArgumentException(
"The context node is not a custom recognizer node.",
"theCustomRecognizer");
}
if (null == baseInkAnalyzer.FindNode(theCustomRecognizerNode.Id))
{
throw new ArgumentException(
"The custom recognizer node is not attached to the ink analyzer.");
}
// Only strokes that have the same packet description GUIDs
// can be added in one call to InkAnalyzerBase.AddStrokes.
Guid[] thePacketDescription = theStrokes[0].PacketDescription;
// Accumulate the stroke data in collections.
ArrayList theStrokeIdentifiers = new ArrayList();
ArrayList thePacketCounts = new ArrayList();
ArrayList thePacketData = new ArrayList();
foreach (Microsoft.Ink.Stroke aStroke in theStrokes)
{
if (!InkAnalyzerHelper.AreElementwiseEquivalent(
aStroke.PacketDescription, thePacketDescription))
{
throw new ApplicationException(
"The strokes collection contains strokes with different packet descriptions.");
}
// Add the stroke data to the collections.
theStrokeIdentifiers.Add(aStroke.Id);
thePacketCounts.Add(aStroke.PacketCount);
thePacketData.AddRange(aStroke.GetPacketData());
}
// Add the stroke data to the base layer ink analyzer.
System.Windows.Ink.AnalysisCore.ContextNodeBase result =
baseInkAnalyzer.AddStrokesToCustomRecognizer(
theStrokeIdentifiers.ToArray(typeof(int)) as int[],
thePacketCounts.ToArray(typeof(int)) as int[],
thePacketData.ToArray(typeof(int)) as int[],
thePacketDescription,
theCustomRecognizerNode);
return result;
}
Platforms
Windows 7, Windows Vista, Windows XP SP2, Windows Server 2008 R2, Windows Server 2008, Windows Server 2003
The .NET Framework and .NET Compact Framework do not support all versions of every platform. For a list of the supported versions, see .NET Framework System Requirements.
Version Information
.NET Framework
Supported in: 3.0