private async void recognizeText_ClickAsync(object sender, RoutedEventArgs e)
{
strokesText = inkCanvas.InkPresenter.StrokeContainer.GetStrokes();
// Ensure an ink stroke is present.
if (strokesText.Count > 0)
{
analyzerText.AddDataForStrokes(strokesText);
resultText = await analyzerText.AnalyzeAsync();
if (resultText.Status == InkAnalysisStatus.Updated)
{
words = analyzerText.AnalysisRoot.FindNodes(InkAnalysisNodeKind.InkWord);
foreach (var word in words)
{
InkAnalysisInkWord concreteWord = (InkAnalysisInkWord)word;
foreach (string s in concreteWord.TextAlternates)
{
recognitionResult.Text += s;
}
}
}
analyzerText.ClearDataForAllStrokes();
}
strokesText = inkCanvas.InkPresenter.StrokeContainer.GetStrokes();
// Ensure an ink stroke is present.
if (strokesText.Count > 0)
{
analyzerText.AddDataForStrokes(strokesText);
// Force analyzer to process strokes as handwriting.
foreach (var stroke in strokesText)
{
analyzerText.SetStrokeDataKind(stroke.Id, InkAnalysisStrokeKind.Writing);
}
// Clear recognition results string.
recognitionResult.Text = "";
resultText = await analyzerText.AnalyzeAsync();
if (resultText.Status == InkAnalysisStatus.Updated)
{
var text = analyzerText.AnalysisRoot.RecognizedText;
words = analyzerText.AnalysisRoot.FindNodes(InkAnalysisNodeKind.InkWord);
foreach (var word in words)
{
InkAnalysisInkWord concreteWord = (InkAnalysisInkWord)word;
foreach (string s in concreteWord.TextAlternates)
{
recognitionResult.Text += s + " ";
}
recognitionResult.Text += " / ";
}
}
analyzerText.ClearDataForAllStrokes();
}
}
//Detects when the writing strokes are finished
private void inkCanvas_StrokesCollected(InkPresenter sender, InkStrokesCollectedEventArgs args)
{
timer.Stop();
foreach (var stroke in args.Strokes)
{
analyzerText.AddDataForStroke(stroke);
analyzerText.SetStrokeDataKind(stroke.Id, InkAnalysisStrokeKind.Writing);
}
timer.Start();
}
private void InkPresenter_StrokesCollected(Windows.UI.Input.Inking.InkPresenter sender, Windows.UI.Input.Inking.InkStrokesCollectedEventArgs args)
{
strokeTimer.Stop();
inkAnalyzer.AddDataForStrokes(args.Strokes);
foreach (InkStroke stroke in args.Strokes)
{
// since this is a drawing application, we can tell InkAnalyzer about
// the nature of the stroke - it's optional but will improve the shape
// recognition result for small drawings that may get confused with
// handwritten letters
inkAnalyzer.SetStrokeDataKind(stroke.Id, InkAnalysisStrokeKind.Drawing);
}
strokeTimer.Start();
}
public async void Analyse(TextBlock display)
{
IReadOnlyList <InkStroke> strokes = _presenter.StrokeContainer.GetStrokes();
foreach (InkStroke stroke in strokes)
{
_analyser.SetStrokeDataKind(stroke.Id, InkAnalysisStrokeKind.Writing);
}
InkAnalysisResult result = await _analyser.AnalyzeAsync();
if (result.Status == InkAnalysisStatus.Updated)
{
display.Text = _analyser.AnalysisRoot.RecognizedText;
}
}
//Detects when the writing strokes are finished
private void inkCanvas_StrokesCollected(InkPresenter sender, InkStrokesCollectedEventArgs args)
{
timer.Stop();
for (int i = 0; i < inkCanvas.Length; i++)
{
if (inkCanvas[i].InkPresenter == sender)
{
currentCanvasNumber = i;
}
}
foreach (var stroke in args.Strokes)
{
analyzerText.AddDataForStroke(stroke);
analyzerText.SetStrokeDataKind(stroke.Id, InkAnalysisStrokeKind.Writing);
}
timer.Start();
}
/// <summary>
/// Process drawn ink strokes into a bounding box to track
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private async void UIUpdateButton_Click(object sender, RoutedEventArgs e)
{
var inkStrokes = UIInkCanvasOverlay.InkPresenter.StrokeContainer.GetStrokes();
// Ensure an ink stroke is present.
if (inkStrokes.Count > 0)
{
m_inkAnalyzer.AddDataForStrokes(inkStrokes);
// Only analyze as drawings
foreach (var strokeNode in inkStrokes)
{
m_inkAnalyzer.SetStrokeDataKind(strokeNode.Id, InkAnalysisStrokeKind.Drawing);
}
var inkAnalysisResults = await m_inkAnalyzer.AnalyzeAsync();
// Have ink strokes on the canvas changed?
if (inkAnalysisResults.Status == InkAnalysisStatus.Updated)
{
// Find all strokes that are recognized as a drawing and
// create a corresponding ink analysis InkDrawing node.
var inkdrawingNodes = m_inkAnalyzer.AnalysisRoot.FindNodes(InkAnalysisNodeKind.InkDrawing);
// Draw recognized shapes on UICanvasOverlay and
// delete ink analysis data and recognized strokes.
List <Rect> drawnRects = new List <Rect>();
foreach (InkAnalysisInkDrawing node in inkdrawingNodes)
{
if (node.DrawingKind == InkAnalysisDrawingKind.Drawing)
{
// Catch and process unsupported shapes (lines and so on) here.
foreach (var strokeId in node.GetStrokeIds())
{
var stroke = UIInkCanvasOverlay.InkPresenter.StrokeContainer.GetStrokeById(strokeId);
var drawingAttributes = stroke.DrawingAttributes;
drawingAttributes.Color = Windows.UI.Colors.Red;
stroke.DrawingAttributes = drawingAttributes;
}
}
// Process generalized shapes here (ellipses and polygons).
else
{
// Normalized rect
var boundingRectNormalized = new Rect(node.BoundingRect.X / UIInkCanvasOverlay.ActualWidth,
node.BoundingRect.Y / UIInkCanvasOverlay.ActualHeight,
node.BoundingRect.Width / UIInkCanvasOverlay.ActualWidth,
node.BoundingRect.Height / UIInkCanvasOverlay.ActualHeight);
drawnRects.Add(boundingRectNormalized);
// Mark ink node strokes for deletion
foreach (var strokeId in node.GetStrokeIds())
{
var stroke = UIInkCanvasOverlay.InkPresenter.StrokeContainer.GetStrokeById(strokeId);
stroke.Selected = true;
}
}
m_inkAnalyzer.RemoveDataForStrokes(node.GetStrokeIds());
}
UIInkCanvasOverlay.InkPresenter.StrokeContainer.DeleteSelected();
await m_bboxLock.WaitAsync();
{
m_drawnRects.AddRange(drawnRects);
m_objectTrackRenderer.RenderRects(m_drawnRects);
}
m_bboxLock.Release();
}
}
}
