InkAnalyzerBase.AddStrokesToCustomRecognizer, méthode
Mise à jour : November 2007
Ajoute les données relatives à plusieurs traits à un nœud de reconnaissance personnalisée.
Espace de noms : System.Windows.Ink.AnalysisCore
Assembly : IACore (dans IACore.dll)
Syntaxe
'Déclaration
Public Function AddStrokesToCustomRecognizer ( _
strokeIds As Integer(), _
strokePacketCount As Integer(), _
strokePacketData As Integer(), _
strokePacketDescription As Guid(), _
customRecognizer As ContextNodeBase _
) As ContextNodeBase
'Utilisation
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 ContextNodeBase AddStrokesToCustomRecognizer(
int[] strokeIds,
int[] strokePacketCount,
int[] strokePacketData,
Guid[] strokePacketDescription,
ContextNodeBase customRecognizer
)
public function AddStrokesToCustomRecognizer(
strokeIds : int[],
strokePacketCount : int[],
strokePacketData : int[],
strokePacketDescription : Guid[],
customRecognizer : ContextNodeBase
) : ContextNodeBase
Paramètres
- strokeIds
Type : array<System.Int32[]
Tableau contenant les identificateurs des traits.
- strokePacketCount
Type : array<System.Int32[]
Tableau contenant le nombre de paquets de chaque trait.
- strokePacketData
Type : array<System.Int32[]
Tableau contenant les données de paquet des traits.
- strokePacketDescription
Type : array<System.Guid[]
Tableau contenant les identificateurs de la propriété du paquet.
- customRecognizer
Type : System.Windows.Ink.AnalysisCore.ContextNodeBase
Nœud de reconnaissance personnalisée auquel les traits sont ajoutés.
Valeur de retour
Type : System.Windows.Ink.AnalysisCore.ContextNodeBase
Nœud de contexte auquel l'analyseur d'entrée manuscrite a ajouté les traits.
Notes
Le InkAnalyzerBase ajoute les traits à un ContextNodeBase dont la propriété Type a la valeur UnclassifiedInk().
Pendant l'analyse, l'analyseur d'entrée manuscrite assigne l'identificateur de culture du thread d'entrée actif au trait et ajoute le trait au premier nœud d'entrée manuscrite non classé sous le module de reconnaissance de l'écriture manuscrite. Si aucun nœud non classifié n'existe, il est créé. Si la reconnaissance personnalisée ne prend pas en charge l'identificateur de culture, l'analyseur d'entrée manuscrite continue l'analyse et génère un avertissement AnalysisWarningBase. La valeur AnalysisWarningCode de la propriété WarningCode de cet avertissement est LanguageIdNotRespected.
Seuls les traits avec les mêmes descriptions de paquet peuvent être ajoutés dans un appel unique de AddStrokes.
Cette méthode étend la propriété DirtyRegion à l'union de la valeur actuelle de la région et du cadre englobant des traits ajoutés.
Le InkAnalyzerBase lève une exception dans les conditions suivantes.
Le InkAnalyzerBase contient déjà un trait présentant le même identificateur que l'un des traits à ajouter.
Le paramètre customRecognizer contient un ContextNodeBase associé à un autre objet InkAnalyzerBase.
Le paramètre customRecognizer contient un ContextNodeBase dont la propriété Type n'a pas la valeur CustomRecognizer().
Exemples
Cet exemple définit une méthode qui convertit une collection Strokes en données de paquet et ajoute les traits à un nœud de reconnaissance personnalisée. La méthode retourne le ContextNodeBase auquel l'analyseur d'entrée manuscrite a ajouté les traits.
''' <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;
}
Plateformes
Windows Vista, Windows XP SP2, Windows Server 2003
Le .NET Framework et le .NET Compact Framework ne prennent pas en charge toutes les versions de chaque plateforme. Pour obtenir la liste des versions prises en charge, consultez Configuration requise du .NET Framework.
Informations de version
.NET Framework
Pris en charge dans : 3.0