private static void AddTextToCanvas(InkAnalysisRoot analysisRoot, Canvas drawingSurface)
        {
            //var rect = analysisRoot.BoundingRect;
            //Rectangle r = new Rectangle();
            //r.IsHitTestVisible = false;
            //r.SetValue(Canvas.LeftProperty, rect.Left);
            //r.SetValue(Canvas.TopProperty, rect.Top);
            //r.SetValue(Canvas.WidthProperty, rect.Width);
            //r.SetValue(Canvas.HeightProperty, rect.Height);
            //r.Stroke = new SolidColorBrush(canvas.InkPresenter.CopyDefaultDrawingAttributes().Color);
            //r.StrokeThickness = 1;
            //drawingSurface.Children.Add(r);

            //double rotationAngle = Math.Atan2(points[2].Y - points[0].Y, points[2].X - points[0].X);
            //double rotationAngle = Math.Atan2(analysisRoot.BoundingRect.Height, analysisRoot.BoundingRect.Width);
            //rotationAngle = -(rotationAngle * 180.0 / Math.PI);
            var attributes = canvas.InkPresenter.CopyDefaultDrawingAttributes();

            var container = new Viewbox();

            container.RenderTransformOrigin = new Point(0.5, 0.5);
            container.IsHitTestVisible      = false;
            container.SetValue(Canvas.LeftProperty, analysisRoot.BoundingRect.Left);
            container.SetValue(Canvas.TopProperty, analysisRoot.BoundingRect.Top + analysisRoot.BoundingRect.Height);
            container.Width  = analysisRoot.BoundingRect.Width;
            container.Height = analysisRoot.BoundingRect.Height;
            //container.RenderTransform = new RotateTransform() { Angle = rotationAngle };
            container.Child = new Border()
            {
                Child = new TextBlock()
                {
                    Text             = analysisRoot.RecognizedText,
                    IsHitTestVisible = false,
                    Foreground       = new SolidColorBrush(attributes.Color)
                }
            };
            drawingSurface.Children.Add(container);

            if (RecognitionOccured != null)
            {
                RecognitionOccured(null, new RecognitionEventArgs(container)
                {
                    Description = $"Text '{analysisRoot.RecognizedText}'"
                });
            }
        }
        private static void ConvertShapes(InkPresenter presenter, InkAnalysisRoot analysisRoot)
        {
            var drawingSurface = GetTargetCanvas(canvas);

            if (drawingSurface == null)
            {
                return;
            }

            IReadOnlyList <IInkAnalysisNode> nodes = inkAnalyzer.AnalysisRoot.FindNodes(InkAnalysisNodeKind.WritingRegion);

            foreach (var item in nodes)
            {
                AddTextToCanvas(analysisRoot, drawingSurface);
            }

            IReadOnlyList <IInkAnalysisNode> drawings = inkAnalyzer.AnalysisRoot.FindNodes(InkAnalysisNodeKind.InkDrawing);

            if (drawings.Any())
            {
                ICommand cmd = null;

                foreach (IInkAnalysisNode drawing in drawings)
                {
                    var shape = (InkAnalysisInkDrawing)drawing;

                    if (shape.DrawingKind == InkAnalysisDrawingKind.Drawing)
                    {
                        // Omit unsupported shape
                        continue;
                    }

                    switch (shape.DrawingKind)
                    {
                    case InkAnalysisDrawingKind.Circle:
                    {
                        cmd = GetCircle(canvas);
                        AddEllipseToCanvas(shape, drawingSurface);
                        break;
                    }

                    case InkAnalysisDrawingKind.Ellipse:
                    {
                        AddEllipseToCanvas(shape, drawingSurface);
                        break;
                    }

                    case InkAnalysisDrawingKind.Triangle:
                    {
                        AddPolygonToCanvas(shape, drawingSurface);
                        break;
                    }

                    case InkAnalysisDrawingKind.IsoscelesTriangle:
                    {
                        AddPolygonToCanvas(shape, drawingSurface);
                        break;
                    }

                    case InkAnalysisDrawingKind.EquilateralTriangle:
                    {
                        AddPolygonToCanvas(shape, drawingSurface);
                        break;
                    }

                    case InkAnalysisDrawingKind.RightTriangle:
                    {
                        AddPolygonToCanvas(shape, drawingSurface);
                        break;
                    }

                    case InkAnalysisDrawingKind.Quadrilateral:
                    {
                        AddPolygonToCanvas(shape, drawingSurface);
                        break;
                    }

                    case InkAnalysisDrawingKind.Rectangle:
                    {
                        AddPolygonToCanvas(shape, drawingSurface);
                        break;
                    }

                    case InkAnalysisDrawingKind.Square:
                    {
                        cmd = GetSquare(canvas);
                        AddPolygonToCanvas(shape, drawingSurface);
                        break;
                    }

                    case InkAnalysisDrawingKind.Diamond:
                    {
                        AddPolygonToCanvas(shape, drawingSurface);
                        break;
                    }

                    case InkAnalysisDrawingKind.Trapezoid:
                    {
                        AddPolygonToCanvas(shape, drawingSurface);
                        break;
                    }

                    case InkAnalysisDrawingKind.Parallelogram:
                    {
                        AddPolygonToCanvas(shape, drawingSurface);
                        break;
                    }

                    case InkAnalysisDrawingKind.Pentagon:
                    {
                        AddPolygonToCanvas(shape, drawingSurface);
                        break;
                    }

                    case InkAnalysisDrawingKind.Hexagon:
                    {
                        AddPolygonToCanvas(shape, drawingSurface);
                        break;
                    }
                    }

                    // 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 = presenter.StrokeContainer.GetStrokeById(strokeId);
                        stroke.Selected = true;
                    }

                    cmd?.Execute(null);
                }
            }

            // presenter.StrokeContainer.DeleteSelected();
            presenter.StrokeContainer.Clear();
        }