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();
}
}
public async Task <InkTransformResult> TransformTextAndShapesAsync()
{
var result = new InkTransformResult(_drawingCanvas);
var inkStrokes = GetStrokesToConvert();
if (inkStrokes.Any())
{
_inkAnalyzer.ClearDataForAllStrokes();
_inkAnalyzer.AddDataForStrokes(inkStrokes);
var inkAnalysisResults = await _inkAnalyzer.AnalyzeAsync();
if (inkAnalysisResults.Status == InkAnalysisStatus.Updated)
{
var words = AnalyzeWords();
var shapes = AnalyzeShapes();
//Generate result
result.Strokes.AddRange(inkStrokes);
result.TextAndShapes.AddRange(words);
result.TextAndShapes.AddRange(shapes);
}
}
return(result);
}
private void ClearButton_Click(object sender, RoutedEventArgs e)
{
// Don't run analysis when there is nothing to analyze.
dispatcherTimer.Stop();
inkPresenter.StrokeContainer.Clear();
inkAnalyzer.ClearDataForAllStrokes();
canvas.Children.Clear();
}
private async static void recognize(InkPresenter presenter)
{
IReadOnlyList <InkStroke> strokes = presenter.StrokeContainer.GetStrokes();
if (strokes.Any())
{
inkAnalyzer.AddDataForStrokes(strokes);
InkAnalysisResult results = await inkAnalyzer.AnalyzeAsync();
if (results.Status == InkAnalysisStatus.Updated)
{
ConvertShapes(presenter, inkAnalyzer.AnalysisRoot);
}
}
inkAnalyzer.ClearDataForAllStrokes();
}
private async Task AnalyzeInkAsync()
{
// Does all the recognition
var result = await _inkAnalyzer.AnalyzeAsync();
if (result.Status == InkAnalysisStatus.Updated)
{
// Filter recognition by shapes. Options inlcude lists, paragraphs, words etc.
var drawings = _inkAnalyzer.AnalysisRoot.FindNodes(InkAnalysisNodeKind.InkDrawing);
foreach (InkAnalysisInkDrawing drawing in drawings)
{
if (drawing.DrawingKind == InkAnalysisDrawingKind.Circle)
{
AddHeart(drawing);
RemoveInkStrokes(drawing);
}
else if (drawing.DrawingKind == InkAnalysisDrawingKind.Triangle || drawing.DrawingKind == InkAnalysisDrawingKind.EquilateralTriangle)
{
if (string.IsNullOrEmpty(customEmojiGlyph))
{
await PickEmoji();
}
if (!string.IsNullOrEmpty(customEmojiGlyph))
{
AddEmoji(drawing, customEmojiGlyph);
}
RemoveInkStrokes(drawing);
}
}
_inkAnalyzer.ClearDataForAllStrokes();
_inkPresenter.StrokeContainer.DeleteSelected();
}
}
internal void StopRecognizingStrokes()
{
inkAnalyzer.ClearDataForAllStrokes();
}
private async void Analyze()
{
InkAnalysisResult result = await inkAnalyzer.AnalyzeAsync();
Shape drawnShape = null;
if (result.Status == InkAnalysisStatus.Updated && inkAnalyzer.AnalysisRoot.Children.Count > 0)
{
if (inkAnalyzer.AnalysisRoot.Children.Last().Kind == InkAnalysisNodeKind.InkDrawing)
{
// the things we can recognise: https://docs.microsoft.com/en-us/uwp/api/windows.ui.input.inking.analysis.inkanalysisdrawingkind
LinearGradientBrush newRandomBrush = GetRandomGradientBrush();
InkAnalysisInkDrawing drawing = inkAnalyzer.AnalysisRoot.Children.Last() as InkAnalysisInkDrawing;
if (drawing.DrawingKind == InkAnalysisDrawingKind.Circle ||
drawing.DrawingKind == InkAnalysisDrawingKind.Ellipse)
{
// we have detected a circle or ellipse
CompositeTransform transform = new CompositeTransform();
Ellipse ellipse = new Ellipse();
AttachDragHandlers(ellipse);
ellipse.Fill = newRandomBrush;
ellipse.Stroke = new SolidColorBrush(Colors.Black);
ellipse.Width = Distance(drawing.Points[0], drawing.Points[2]);
var center = new Point((drawing.Points[0].X + drawing.Points[2].X) / 2.0,
(drawing.Points[0].Y + drawing.Points[2].Y) / 2.0);
if (drawing.DrawingKind == InkAnalysisDrawingKind.Circle)
{
ellipse.Height = ellipse.Width;
}
else
{
ellipse.Height = Distance(drawing.Points[1], drawing.Points[3]);
double rotationAngle = Math.Atan2(drawing.Points[2].Y - drawing.Points[0].Y,
drawing.Points[2].X - drawing.Points[0].X);
transform.Rotation = rotationAngle * 180.0 / Math.PI;
}
transform.TranslateX = center.X - ellipse.Width / 2.0d;
transform.TranslateY = center.Y - ellipse.Height / 2.0d;
ellipse.RenderTransform = transform;
ellipse.RenderTransformOrigin = new Point(0.5, 0.5);
root.Children.Add(ellipse);
drawnShape = ellipse;
if (animationToggle.IsChecked == true)
{
AddAnimation(ellipse);
}
}
else
{
// we have detected a polygon
Polygon polygon = new Polygon();
AttachDragHandlers(polygon);
polygon.Fill = newRandomBrush;
polygon.Stroke = new SolidColorBrush(Colors.Black);
foreach (Point pt in drawing.Points)
{
polygon.Points.Add(pt);
}
CompositeTransform transform = new CompositeTransform();
transform.CenterX = drawing.Center.X;
transform.CenterY = drawing.Center.Y;
polygon.RenderTransform = transform;
root.Children.Add(polygon);
drawnShape = polygon;
if (animationToggle.IsChecked == true)
{
AddAnimation(polygon);
}
}
}
else
{
// neither ellipse or polygon
System.Diagnostics.Debug.WriteLine(inkAnalyzer.AnalysisRoot.Children.Last().Kind.ToString());
}
// see if we have a match
if (drawnShape != null)
{
ViewModel.SeekTarget(drawnShape);
}
}
inkCanvas.InkPresenter.StrokeContainer.Clear();
inkAnalyzer.ClearDataForAllStrokes();
}
/// <summary>
/// Analyzes all the strokes collected from the ink presenter
/// </summary>
private async Task AnalyzeInkAsync()
{
// Does all the recognition
var result = await _inkAnalyzer.AnalyzeAsync();
if (result.Status == InkAnalysisStatus.Updated)
{
// Filter recognition by shapes. Options inlcude lists, paragraphs, words etc.
var drawings = _inkAnalyzer.AnalysisRoot.FindNodes(InkAnalysisNodeKind.InkDrawing);
foreach (InkAnalysisInkDrawing drawing in drawings)
{
if (drawing.DrawingKind == InkAnalysisDrawingKind.Rectangle ||
drawing.DrawingKind == InkAnalysisDrawingKind.Square)
{
// Swap strokes with border, using details from drawing
var border = new Border
{
Width = drawing.BoundingRect.Width,
Height = drawing.BoundingRect.Height,
Margin = new Thickness(drawing.BoundingRect.X, drawing.BoundingRect.Y, 0, 0),
BorderThickness = new Thickness(new Random((int)DateTime.Now.Ticks).Next(5, 30)),
BorderBrush = new SolidColorBrush(Colors.Black),
Background = new SolidColorBrush(Colors.WhiteSmoke),
IsHitTestVisible = false
};
// Using the same composition show hide animation technique
ElementCompositionPreview.SetImplicitShowAnimation(border, _fadeIn);
ElementCompositionPreview.SetImplicitHideAnimation(border, _fadeOut);
Canvas.SetZIndex(border, -1);
// Image placeholder
var image = new Image
{
Width = drawing.BoundingRect.Width,
Height = drawing.BoundingRect.Height,
Margin = new Thickness(drawing.BoundingRect.X, drawing.BoundingRect.Y, 0, 0),
Stretch = Stretch.UniformToFill,
IsHitTestVisible = false,
Visibility = Visibility.Collapsed
};
ElementCompositionPreview.SetImplicitShowAnimation(image, _fadeIn);
_images.Add(image);
LayoutGrid.Children.Add(image);
LayoutGrid.Children.Add(border);
}
}
// Same as shapes, we filter by words
var inkWords = _inkAnalyzer.AnalysisRoot.FindNodes(InkAnalysisNodeKind.InkWord);
foreach (InkAnalysisInkWord inkWord in inkWords)
{
var textBlock = new TextBlock
{
Text = inkWord.RecognizedText,
Margin = new Thickness(inkWord.BoundingRect.X, inkWord.BoundingRect.Y, 0, 0),
FontSize = 128,
IsHitTestVisible = false
};
LayoutGrid.Children.Add(textBlock);
}
// Remove all strokes from canvas and analyzer.
_inkAnalyzer.ClearDataForAllStrokes();
_inkPresenter.StrokeContainer.Clear();
}
}
public void Clear(ref TextBlock display)
{
display.Text = string.Empty;
_presenter.StrokeContainer.Clear();
_analyser.ClearDataForAllStrokes();
}
//Recognizes text from ink strokes
private async void timer_TickAsync(object sender, object e)
{
timer.Stop();
if (!analyzerText.IsAnalyzing)
{
InkAnalysisResult resultText = await analyzerText.AnalyzeAsync();
if (resultText.Status == InkAnalysisStatus.Updated)
{
var words = analyzerText.AnalysisRoot.FindNodes(InkAnalysisNodeKind.InkWord);
foreach (InkAnalysisInkWord word in words)
{
if (gameEnded)
{
NewGame();
}
else if (gridResults[currentCanvasNumber] == ' ')
{
if (isXNext && (word.RecognizedText == "x" || word.RecognizedText == "X"))
{
DrawText(word.RecognizedText, word.BoundingRect);
gridResults[currentCanvasNumber] = 'x';
isXNext = !isXNext;
Info.Text = "Now it is Player 2's turn. Draw an 'O' in any remaining square.";
}
else if (!isXNext && (word.RecognizedText == "o" || word.RecognizedText == "O" || word.RecognizedText == "0"))
{
DrawText(word.RecognizedText, word.BoundingRect);
gridResults[currentCanvasNumber] = 'o';
isXNext = !isXNext;
Info.Text = "Now it is Player 1's turn. Draw an 'X' in any remaining square.";
}
}
foreach (var strokeId in word.GetStrokeIds())
{
var stroke = inkCanvas[currentCanvasNumber].InkPresenter.StrokeContainer.GetStrokeById(strokeId);
stroke.Selected = true;
}
analyzerText.RemoveDataForStrokes(word.GetStrokeIds());
}
inkCanvas[currentCanvasNumber].InkPresenter.StrokeContainer.DeleteSelected();
}
else
{
timer.Start();
}
analyzerText.ClearDataForAllStrokes();
checkForWinner();
}
}
//Recognizes text from the ink strokes
private async void timer_TickAsync(object sender, object e)
{
timer.Stop();
if (!analyzerText.IsAnalyzing)
{
InkAnalysisResult resultText = await analyzerText.AnalyzeAsync();
if (resultText.Status == InkAnalysisStatus.Updated)
{
var words = analyzerText.AnalysisRoot.FindNodes(InkAnalysisNodeKind.InkWord);
foreach (InkAnalysisInkWord word in words)
{
int userAnswer = 0;
if (Int32.TryParse(word.RecognizedText, out userAnswer))
{
if (userAnswer == answer)
{
Info.Text = "Correct!";
await Task.Delay(TimeSpan.FromSeconds(2));
Info.Text = "";
generateNewEquation();
}
else
{
Info.Text = "Wrong, try again!";
await Task.Delay(TimeSpan.FromSeconds(2));
Info.Text = "";
}
}
else
{
Info.Text = "Could not detect a number. Try again!";
await Task.Delay(TimeSpan.FromSeconds(2));
Info.Text = "";
}
foreach (var strokeId in word.GetStrokeIds())
{
var stroke = inkCanvas.InkPresenter.StrokeContainer.GetStrokeById(strokeId);
stroke.Selected = true;
}
analyzerText.RemoveDataForStrokes(word.GetStrokeIds());
}
inkCanvas.InkPresenter.StrokeContainer.DeleteSelected();
}
else
{
timer.Start();
}
analyzerText.ClearDataForAllStrokes();
}
}
//Recognizes text from ink strokes
private async void timer_TickAsync(object sender, object e)
{
timer.Stop();
if (!analyzerText.IsAnalyzing)
{
InkAnalysisResult resultText = await analyzerText.AnalyzeAsync();
if (resultText.Status == InkAnalysisStatus.Updated)
{
var words = analyzerText.AnalysisRoot.FindNodes(InkAnalysisNodeKind.InkWord);
foreach (InkAnalysisInkWord word in words)
{
if (calculated)
{
clear();
}
else if (currentCanvasNumber == 0)
{
int temp = numbers[0];
if (Int32.TryParse(word.RecognizedText, out numbers[0]))
{
textBlock[0].Text = numbers[0] + "";
hasValues[0] = true;
}
else if (hasValues[0])
{
numbers[0] = temp;
}
}
else if (currentCanvasNumber == 1)
{
if (word.RecognizedText == "/")
{
mathOperator = '/';
textBlock[1].Text = "/";
}
else if (word.RecognizedText == "*" || word.RecognizedText == "x" || word.RecognizedText == "X")
{
mathOperator = '*';
textBlock[1].Text = "*";
}
else if (word.RecognizedText == "+")
{
mathOperator = '+';
textBlock[1].Text = "+";
}
else if (word.RecognizedText == "-" || word.RecognizedText == '_')
{
mathOperator = '-';
textBlock[1].Text = "-";
}
}
else if (currentCanvasNumber == 2)
{
int temp = numbers[1];
if (Int32.TryParse(word.RecognizedText, out numbers[1]))
{
textBlock[2].Text = numbers[1] + "";
hasValues[1] = true;
}
else if (hasValues[1])
{
numbers[1] = temp;
}
}
else if (currentCanvasNumber == 3)
{
if (word.RecognizedText == "=" && canCalculate())
{
textBlock[3].Text = "=";
calculate();
}
}
foreach (var strokeId in word.GetStrokeIds())
{
var stroke = inkCanvas[currentCanvasNumber].InkPresenter.StrokeContainer.GetStrokeById(strokeId);
stroke.Selected = true;
}
analyzerText.RemoveDataForStrokes(word.GetStrokeIds());
}
inkCanvas[currentCanvasNumber].InkPresenter.StrokeContainer.DeleteSelected();
}
else
{
timer.Start();
}
analyzerText.ClearDataForAllStrokes();
}
}
