private IEnumerable <UIElement> AnalyzeWords() { var inkwordNodes = _inkAnalyzer.AnalysisRoot.FindNodes(InkAnalysisNodeKind.InkWord); foreach (InkAnalysisInkWord node in inkwordNodes) { var textblock = DrawText(node.RecognizedText, node.BoundingRect); var strokesIds = node.GetStrokeIds(); _strokeService.RemoveStrokesByIds(strokesIds); _inkAnalyzer.RemoveDataForStrokes(strokesIds); yield return(textblock); } }
// End "Step 5: Support handwriting recognition" // Begin "Step 6: Recognize shapes" //On click recognise shape private async void recognizeShape_ClickAsync(object sender, RoutedEventArgs e) { strokesShape = inkCanvas.InkPresenter.StrokeContainer.GetStrokes(); if (strokesShape.Count > 0) { analyzerShape.AddDataForStrokes(strokesShape); resultShape = await analyzerShape.AnalyzeAsync(); if (resultShape.Status == InkAnalysisStatus.Updated) { var drawings = analyzerShape.AnalysisRoot.FindNodes(InkAnalysisNodeKind.InkDrawing); foreach (var drawing in drawings) { var shape = (InkAnalysisInkDrawing)drawing; if (shape.DrawingKind == InkAnalysisDrawingKind.Drawing) { // Catch and process unsupported shapes (lines and so on) here. } else { // Process recognized shapes here. if (shape.DrawingKind == InkAnalysisDrawingKind.Circle || shape.DrawingKind == InkAnalysisDrawingKind.Ellipse) { DrawEllipse(shape); } else { DrawPolygon(shape); } foreach (var strokeId in shape.GetStrokeIds()) { var stroke = inkCanvas.InkPresenter.StrokeContainer.GetStrokeById(strokeId); stroke.Selected = true; } } analyzerShape.RemoveDataForStrokes(shape.GetStrokeIds()); } inkCanvas.InkPresenter.StrokeContainer.DeleteSelected(); } } }
internal async void RecognizeStrokes(IEnumerable <InkStroke> strokes) { inkAnalyzer.AddDataForStrokes(strokes); inkAnalysisResults = await inkAnalyzer.AnalyzeAsync(); // Find all strokes that are recognized as a drawing and create a corresponding ink analysis InkDrawing node. var inkdrawingNodes = inkAnalyzer.AnalysisRoot.FindNodes(InkAnalysisNodeKind.InkDrawing); foreach (InkAnalysisInkDrawing node in inkdrawingNodes) { // Draw an Ellipse object on the recognitionCanvas (circle is a specialized ellipse). if (node.DrawingKind == InkAnalysisDrawingKind.Circle || node.DrawingKind == InkAnalysisDrawingKind.Ellipse) { DrawEllipse(node); inkAnalyzer.RemoveDataForStrokes(node.GetStrokeIds()); } else if (node.DrawingKind != InkAnalysisDrawingKind.Drawing) // Draw a Polygon object on the inkCanvas. { DrawPolygon(node); inkAnalyzer.RemoveDataForStrokes(node.GetStrokeIds()); } } }
private async void RecognizeButton_Click(object sender, RoutedEventArgs e) { var inkStrokes = inkCanvas.InkPresenter.StrokeContainer.GetStrokes(); // Ensure an ink stroke is present. if (inkStrokes.Count > 0) { _inkAnalyzer.AddDataForStrokes(inkStrokes); var inkAnalysisResults = await _inkAnalyzer.AnalyzeAsync(); // Have ink strokes on the canvas changed? if (inkAnalysisResults.Status == InkAnalysisStatus.Updated) { var inkdrawingNodes = _inkAnalyzer.AnalysisRoot.FindNodes( InkAnalysisNodeKind.InkDrawing); foreach (InkAnalysisInkDrawing node in inkdrawingNodes) { if (node.DrawingKind != InkAnalysisDrawingKind.Drawing) { // Draw an Ellipse object on the recognitionCanvas (circle is a specialized ellipse). if (node.DrawingKind == InkAnalysisDrawingKind.Circle || node.DrawingKind == InkAnalysisDrawingKind.Ellipse) { DrawEllipse(node); } // Draw a Polygon object on the recognitionCanvas. else { DrawPolygon(node); } foreach (var strokeId in node.GetStrokeIds()) { var stroke = inkCanvas.InkPresenter.StrokeContainer.GetStrokeById(strokeId); stroke.Selected = true; } } _inkAnalyzer.RemoveDataForStrokes(node.GetStrokeIds()); } inkCanvas.InkPresenter.StrokeContainer.DeleteSelected(); } } }
private void InkCanvas_DoubleTapped(object sender, DoubleTappedRoutedEventArgs e) { // Convert the selected paragraph or list item if (paragraphSelected != null) { Rect rect = paragraphSelected.BoundingRect; var text = ExtractTextFromParagraph(paragraphSelected); if ((rect.X > 0) && (rect.Y > 0) && (text != string.Empty)) { // Create text box with recognized text var textBlock = new TextBlock(); textBlock.Text = text; textBlock.MaxWidth = rect.Width; textBlock.MaxHeight = rect.Height; Canvas.SetLeft(textBlock, rect.X); Canvas.SetTop(textBlock, rect.Y); // Remove strokes from InkPresenter IReadOnlyList <uint> strokeIds = paragraphSelected.GetStrokeIds(); foreach (var strokeId in strokeIds) { var stroke = inkPresenter.StrokeContainer.GetStrokeById(strokeId); stroke.Selected = true; } inkPresenter.StrokeContainer.DeleteSelected(); // Remove strokes from InkAnalyzer inkAnalyzer.RemoveDataForStrokes(strokeIds); // Hide the SelectionRect SelectionRect.Visibility = Visibility.Collapsed; canvas.Children.Add(textBlock); paragraphSelected = null; } } }
private void ConvertShapes() { IReadOnlyList <IInkAnalysisNode> drawings = inkAnalyzer.AnalysisRoot.FindNodes(InkAnalysisNodeKind.InkDrawing); foreach (IInkAnalysisNode drawing in drawings) { var shape = (InkAnalysisInkDrawing)drawing; if (shape.DrawingKind == InkAnalysisDrawingKind.Drawing) { // Omit unsupported shape continue; } if (shape.DrawingKind == InkAnalysisDrawingKind.Circle || shape.DrawingKind == InkAnalysisDrawingKind.Ellipse) { // Create a Circle or Ellipse on the canvas. AddEllipseToCanvas(shape); } else { // Create a Polygon on the canvas. AddPolygonToCanvas(shape); } // Select the strokes that were recognized, so we can delete them. // The effect is that the shape added to the canvas replaces the strokes. foreach (var strokeId in shape.GetStrokeIds()) { InkStroke stroke = inkPresenter.StrokeContainer.GetStrokeById(strokeId); stroke.Selected = true; } // Remove the recognized strokes from the analyzer // so it won't re-analyze them. inkAnalyzer.RemoveDataForStrokes(shape.GetStrokeIds()); } inkPresenter.StrokeContainer.DeleteSelected(); }
private void InkPresenter_StrokesErased(InkPresenter sender, InkStrokesErasedEventArgs args) { _inkAnalyzer.RemoveDataForStrokes(args.Strokes.Select(i => i.Id)); }
private async void InkPresenter_StrokesErased(Windows.UI.Input.Inking.InkPresenter sender, Windows.UI.Input.Inking.InkStrokesErasedEventArgs args) { _analyzer.RemoveDataForStrokes(args.Strokes.Select(x => x.Id)); await Analyze(); }
private async Task FreeFormHandWriting() { inkStrokes = InputCanvas.InkPresenter.StrokeContainer.GetStrokes(); // Ensure an ink stroke is present. if (inkStrokes.Count > 0) { inkAnalyzer.AddDataForStrokes(inkStrokes); // In this example, we try to recognizing both // writing and drawing, so the platform default // of "InkAnalysisStrokeKind.Auto" is used. // If you're only interested in a specific type of recognition, // such as writing or drawing, you can constrain recognition // using the SetStrokDataKind method as follows: // foreach (var stroke in strokesText) // { // analyzerText.SetStrokeDataKind( // stroke.Id, InkAnalysisStrokeKind.Writing); // } // This can improve both efficiency and recognition results. inkAnalysisResults = await inkAnalyzer.AnalyzeAsync(); // Have ink strokes on the canvas changed? if (inkAnalysisResults.Status == InkAnalysisStatus.Updated) { // Find all strokes that are recognized as handwriting and // create a corresponding ink analysis InkWord node. var inkwordNodes = inkAnalyzer.AnalysisRoot.FindNodes( InkAnalysisNodeKind.InkWord); // Iterate through each InkWord node. // Draw primary recognized text on recognitionCanvas // (for this example, we ignore alternatives), and delete // ink analysis data and recognized strokes. foreach (InkAnalysisInkWord node in inkwordNodes) { // Draw a TextBlock object on the recognitionCanvas. DrawText(node.RecognizedText, node.BoundingRect); foreach (var strokeId in node.GetStrokeIds()) { var stroke = InputCanvas.InkPresenter.StrokeContainer.GetStrokeById(strokeId); stroke.Selected = true; } inkAnalyzer.RemoveDataForStrokes(node.GetStrokeIds()); } InputCanvas.InkPresenter.StrokeContainer.DeleteSelected(); // Find all strokes that are recognized as a drawing and // create a corresponding ink analysis InkDrawing node. var inkdrawingNodes = inkAnalyzer.AnalysisRoot.FindNodes( InkAnalysisNodeKind.InkDrawing); // Iterate through each InkDrawing node. // Draw recognized shapes on recognitionCanvas and // delete ink analysis data and recognized strokes. foreach (InkAnalysisInkDrawing node in inkdrawingNodes) { if (node.DrawingKind == InkAnalysisDrawingKind.Drawing) { // Catch and process unsupported shapes (lines and so on) here. } // Process generalized shapes here (ellipses and polygons). else { // Draw an Ellipse object on the recognitionCanvas (circle is a specialized ellipse). if (node.DrawingKind == InkAnalysisDrawingKind.Circle || node.DrawingKind == InkAnalysisDrawingKind.Ellipse) { DrawEllipse(node); } // Draw a Polygon object on the recognitionCanvas. else { DrawPolygon(node); } foreach (var strokeId in node.GetStrokeIds()) { var stroke = InputCanvas.InkPresenter.StrokeContainer.GetStrokeById(strokeId); stroke.Selected = true; } } inkAnalyzer.RemoveDataForStrokes(node.GetStrokeIds()); } InputCanvas.InkPresenter.StrokeContainer.DeleteSelected(); } } }
//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(); } }
private void InkPresenter_StrokesErased(InkPresenter sender, InkStrokesErasedEventArgs args) { var ids = from a in args.Strokes select a.Id; inkAnalyzer.RemoveDataForStrokes(ids); }
//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(); } }
private async void Recognize_OnClick(object sender, RoutedEventArgs e) { var analyzer = new InkAnalyzer(); var strokes = InkCanvas.InkPresenter.StrokeContainer.GetStrokes(); if (strokes.Count <= 0) { return; } analyzer.AddDataForStrokes(strokes); var results = await analyzer.AnalyzeAsync(); if (results.Status != InkAnalysisStatus.Updated) { return; } // find recognized strokes var textNodes = analyzer.AnalysisRoot.FindNodes(InkAnalysisNodeKind.InkWord); // draw all text foreach (InkAnalysisInkWord node in textNodes) { DrawText(node.RecognizedText, node.BoundingRect); foreach (var strokeId in node.GetStrokeIds()) { var stroke = InkCanvas.InkPresenter.StrokeContainer.GetStrokeById(strokeId); if (UseSystemFocusVisuals) { stroke.Selected = true; } } analyzer.RemoveDataForStrokes(node.GetStrokeIds()); } InkCanvas.InkPresenter.StrokeContainer.DeleteSelected(); var shapeNodes = analyzer.AnalysisRoot.FindNodes(InkAnalysisNodeKind.InkDrawing); // draw shapes foreach (InkAnalysisInkDrawing node in shapeNodes) { if (node.DrawingKind == InkAnalysisDrawingKind.Drawing) { // unsupported shape continue; } Draw(node); foreach (var strokeId in node.GetStrokeIds()) { var stroke = InkCanvas.InkPresenter.StrokeContainer.GetStrokeById(strokeId); stroke.Selected = true; } analyzer.RemoveDataForStrokes(node.GetStrokeIds()); } InkCanvas.InkPresenter.StrokeContainer.DeleteSelected(); }
/// <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(); } } }