Пример #1
0
        private void DrawEllipse(StreamGeometryContext context)
        {
            // Do not use because it is in DrawLine(...)
            // context.BeginFigure(...);

            double controlPointRatio = (Math.Sqrt(2) - 1) * 4 / 3;

            var x0 = X2 - Radius;
            var x1 = X2 - Radius * controlPointRatio;
            var x2 = X2;
            var x3 = X2 + Radius * controlPointRatio;
            var x4 = X2 + Radius;

            var y0 = Y2 - Radius;
            var y1 = Y2 - Radius * controlPointRatio;
            var y2 = Y2;
            var y3 = Y2 + Radius * controlPointRatio;
            var y4 = Y2 + Radius;

            context.BeginFigure(new Point(x2, y0), false, true);
            context.BezierTo(new Point(x3, y0), new Point(x4, y1), new Point(x4, y2), true, true);
            context.BezierTo(new Point(x4, y3), new Point(x3, y4), new Point(x2, y4), true, true);
            context.BezierTo(new Point(x1, y4), new Point(x0, y3), new Point(x0, y2), true, true);
            context.BezierTo(new Point(x0, y1), new Point(x1, y0), new Point(x2, y0), true, true);
        }
Пример #2
0
        /// <summary>
        /// Draw an arc
        /// </summary>
        /// <param name="context"></param>
        private void InternalDrawNodeGeometry(StreamGeometryContext context)
        {
            if (R == 0 || Spokes == null || Spokes.Count < 2)
            {
                return;
            }

            context.BeginFigure(Center, false, false);

            context.LineTo(spokep(0), true, false);

            for (int i = 1; i < Spokes.Count; i++)
            {
                if (Math.Abs(Spokes[i] - Spokes[i - 1]) > 2 * Math.PI - .001)
                {
                    // Display a circle
                    double ControlPointRatio = (Math.Sqrt(2) - 1) * 4 / 3;

                    var x0 = Center.X - R;
                    var x1 = Center.X - R * ControlPointRatio;
                    var x2 = Center.X;
                    var x3 = Center.X + R * ControlPointRatio;
                    var x4 = Center.X + R;

                    var y0 = Center.Y - R;
                    var y1 = Center.Y - R * ControlPointRatio;
                    var y2 = Center.Y;
                    var y3 = Center.Y + R * ControlPointRatio;
                    var y4 = Center.Y + R;

                    context.BeginFigure(new Point(x2, y0), true, true);
                    context.BezierTo(new Point(x3, y0), new Point(x4, y1), new Point(x4, y2), true, true);
                    context.BezierTo(new Point(x4, y3), new Point(x3, y4), new Point(x2, y4), true, true);
                    context.BezierTo(new Point(x1, y4), new Point(x0, y3), new Point(x0, y2), true, true);
                    context.BezierTo(new Point(x0, y1), new Point(x1, y0), new Point(x2, y0), true, true);
                }
                else
                {
                    bool           largearc = Math.Abs(Spokes[i] - Spokes[i - 1]) > Math.PI;
                    SweepDirection sd       = SweepDirection.Counterclockwise;
                    if (Spokes[i] < Spokes[i - 1])
                    {
                        sd = SweepDirection.Clockwise;
                    }

                    context.ArcTo(spokep(i), new Size(R, R), 0, largearc, sd, true, false);
                }

                context.BeginFigure(Center, false, false);
                context.LineTo(spokep(i), true, false);
            }
        }
Пример #3
0
        private void button1_Click(object sender, System.Windows.RoutedEventArgs e)
        {
            Path path = new Path();

            Canvas.SetLeft(path, 00);           //设置和canvas1的相对位置
            Canvas.SetTop(path, 00);
            path.Stroke          = Brushes.Red;
            path.StrokeThickness = 2;
            StreamGeometry sg = new StreamGeometry();

            sg.FillRule = FillRule.EvenOdd;          //取消交叉部分
            //打开1个属于sg的StreamGeometryContext(sg.Open())
            using (StreamGeometryContext sgc = sg.Open()){
                //设置图形的起点,true可利用图形剪裁,true构成封闭图形
                sgc.BeginFigure(new Point(0, 200), true, true);
                //绘制直线,终点,true描边,true平滑连接
                sgc.LineTo(new Point(100, 150), true, true);
                Point p = new Point(200, 150);          //椭圆弧终点
                Size  s = new Size(100, 50);            //圆弧宽、高
                //绘制圆弧参数:终点,大小,沿X轴旋转角度,大于180度弧线,旋转方向,描边,平滑连接
                sgc.ArcTo(p, s, 0, true, SweepDirection.Clockwise, true, true);
                Point p1 = new Point(200, 150);            //第1个控制点
                Point p2 = new Point(300, 10);             //第2个控制点
                Point p3 = new Point(400, 230);            //终点
                sgc.BezierTo(p1, p2, p3, true, true);      //绘制贝塞尔曲线
            }
            path.Data = sg;
            this.canvas1.Children.Add(path); //canvas1是path的容器
            this.image.Clip = sg;            //剪裁图片
        }
Пример #4
0
        /// <summary>
        /// 使用原始序列和指定的连接方式绘制几何图形
        /// </summary>
        /// <param name="points">样本序列</param>
        /// <param name="isFilled">是否填充</param>
        /// <param name="isClosed">是否闭合</param>
        /// <returns>连接得到的几何图形</returns>
        private Geometry DrawGeometry(List <Point> points, bool isFilled, bool isClosed, LineType type)
        {
            if (points != null)
            {
                StreamGeometry geometry = new StreamGeometry();

                using (StreamGeometryContext ctx = geometry.Open())                                 //打开一个画板
                {
                    ctx.BeginFigure(points[0], isFilled /* is filled */, isClosed /* is closed */); //设定画图的起始点

                    //画出一系列线段并且以折线的形式顺次连接
                    if (type == LineType.Line)
                    {
                        for (int i = 1; i < points.Count && points[i].X <= 480; i++)
                        {
                            ctx.LineTo(points[i], true, false);
                        }
                    }
                    //使用bezier曲线进行连接
                    else if (type == LineType.Bezier)
                    {
                        Bezier bezier = new Bezier(points, 0.7);
                        for (int i = 1; i < points.Count; i++)
                        {
                            ctx.BezierTo(bezier.controlPointCollection[2 * i - 2], bezier.controlPointCollection[2 * i - 1], points[i], true, false);
                        }
                    }
                }
                return(geometry);//返回得到的点列
            }
            else
            {
                throw new Exception("请先输入参数");
            }
        }
Пример #5
0
        private void OnMeasurePropertyChanged(DependencyPropertyChangedEventArgs args)
        {
            if (_StreamGeometry == null)
            {
                _StreamGeometry = new StreamGeometry();
            }

            if (Points == null)
            {
                return;
            }

            using (StreamGeometryContext sgc = _StreamGeometry.Open()) {
                // Get Bezier Spline Control Points.

                PointCollection pnts = cardinalSpline(Points, .5, Closed);

                sgc.BeginFigure(pnts[0], true, false);
                for (int i = 1; i < pnts.Count; i += 3)
                {
                    sgc.BezierTo(pnts[i], pnts[i + 1], pnts[i + 2], true, false);
                }
            }
            InvalidateMeasure();
            OnRenderPropertyChanged(args);
        }
Пример #6
0
        internal static void DrawArc(this StreamGeometryContext ctx,
                                     Point center, double radiusX, double radiusY,
                                     ArcPos pos)
        {
            var x0 = center.X - radiusX;
            var x1 = center.X - radiusX * ControlPointRatio;
            var x2 = center.X;
            var x3 = center.X + radiusX * ControlPointRatio;
            var x4 = center.X + radiusX;

            var y0 = center.Y - radiusY;
            var y1 = center.Y - radiusY * ControlPointRatio;
            var y2 = center.Y;
            var y3 = center.Y + radiusY * ControlPointRatio;
            var y4 = center.Y + radiusY;

            switch (pos)
            {
            case ArcPos.RightTop:
                ctx.BeginFigure(new Point(x2, y0), false, false);
                ctx.BezierTo(new Point(x3, y0), new Point(x4, y1), new Point(x4, y2), true, true);
                break;

            case ArcPos.LeftTop:
                ctx.BeginFigure(new Point(x2, y0), false, false);
                ctx.BezierTo(new Point(x1, y0), new Point(x0, y1), new Point(x0, y2), true, true);
                break;

            case ArcPos.RightBottom:
                ctx.BeginFigure(new Point(x2, y4), false, false);
                ctx.BezierTo(new Point(x3, y4), new Point(x4, y3), new Point(x4, y2), true, true);
                break;

            case ArcPos.LeftBottom:
                ctx.BeginFigure(new Point(x2, y4), false, false);
                ctx.BezierTo(new Point(x1, y4), new Point(x0, y3), new Point(x0, y2), true, true);
                break;

            default:
                throw new ArgumentOutOfRangeException(nameof(pos), pos, null);
            }
        }
Пример #7
0
        internal static void DrawEllipse(this StreamGeometryContext ctx,
                                         Point center, double radiusX, double radiusY, bool isFilled, bool isStroked)
        {
            var x0 = center.X - radiusX;
            var x1 = center.X - radiusX * ControlPointRatio;
            var x2 = center.X;
            var x3 = center.X + radiusX * ControlPointRatio;
            var x4 = center.X + radiusX;

            var y0 = center.Y - radiusY;
            var y1 = center.Y - radiusY * ControlPointRatio;
            var y2 = center.Y;
            var y3 = center.Y + radiusY * ControlPointRatio;
            var y4 = center.Y + radiusY;

            ctx.BeginFigure(new Point(x2, y0), isFilled, true);
            ctx.BezierTo(new Point(x3, y0), new Point(x4, y1), new Point(x4, y2), isStroked, true);
            ctx.BezierTo(new Point(x4, y3), new Point(x3, y4), new Point(x2, y4), isStroked, true);
            ctx.BezierTo(new Point(x1, y4), new Point(x0, y3), new Point(x0, y2), isStroked, true);
            ctx.BezierTo(new Point(x0, y1), new Point(x1, y0), new Point(x2, y0), isStroked, true);
        }
Пример #8
0
        public override void Draw(DrawingContext ctx, Matrix matrix)
        {
            if (!this.IsValid)
            {
                return;
            }
            PathFigureEditor      pathFigureEditor      = new PathFigureEditor(this.PathGeometry.Figures[this.FigureIndex]);
            StreamGeometry        streamGeometry        = new StreamGeometry();
            StreamGeometryContext streamGeometryContext = streamGeometry.Open();

            switch (this.PathPointKind)
            {
            case PathPointKind.Start:
                throw new InvalidOperationException(ExceptionStringTable.PathSegmentAdornerIsolatedPointSegment);

            case PathPointKind.Arc:
                ArcSegment arcSegment = (ArcSegment)pathFigureEditor.PathFigure.Segments[this.SegmentIndex];
                streamGeometryContext.BeginFigure(this.GetPoint(pathFigureEditor, -1), false, false);
                streamGeometryContext.ArcTo(arcSegment.Point, arcSegment.Size, arcSegment.RotationAngle, arcSegment.IsLargeArc, arcSegment.SweepDirection, true, false);
                break;

            case PathPointKind.Line:
                streamGeometryContext.BeginFigure(this.GetPoint(pathFigureEditor, -1), false, false);
                streamGeometryContext.LineTo(this.GetPoint(pathFigureEditor, 0), true, false);
                break;

            case PathPointKind.Quadratic:
                streamGeometryContext.BeginFigure(this.GetPoint(pathFigureEditor, -2), false, false);
                streamGeometryContext.QuadraticBezierTo(this.GetPoint(pathFigureEditor, -1), this.GetPoint(pathFigureEditor, 0), true, false);
                break;

            case PathPointKind.Cubic:
                streamGeometryContext.BeginFigure(this.GetPoint(pathFigureEditor, -3), false, false);
                streamGeometryContext.BezierTo(this.GetPoint(pathFigureEditor, -2), this.GetPoint(pathFigureEditor, -1), this.GetPoint(pathFigureEditor, 0), true, false);
                break;

            case PathPointKind.BezierHandle:
                throw new InvalidOperationException(ExceptionStringTable.PathSegmentAdornerLastPointIsBezier);

            default:
                throw new NotImplementedException(ExceptionStringTable.PathSegmentAdornerUnknownPathPoint);
            }
            streamGeometryContext.Close();
            MatrixTransform matrixTransform = new MatrixTransform(matrix);

            matrixTransform.Freeze();
            streamGeometry.Transform = (Transform)matrixTransform;
            streamGeometry.Freeze();
            Pen pen = this.IsActive ? this.ThickPathSegmentPen : this.ThinPathSegmentPen;

            ctx.DrawGeometry((Brush)null, pen, (System.Windows.Media.Geometry)streamGeometry);
            ctx.DrawGeometry((Brush)null, PathSegmentAdorner.HitTestPen, (System.Windows.Media.Geometry)streamGeometry);
        }
Пример #9
0
        /// <summary>
        /// Draws the And-Control
        /// </summary>
        /// <param name="context"></param>
        protected void InternalDrawAndGeometry(StreamGeometryContext context)
        {
            Point pt1 = new Point(Width, 0);
            Point pt2 = new Point(Width / 2, 0);
            Point pt3 = new Point(-Width / 2, Height / 2);
            Point pt4 = new Point(Width / 2, Height);
            Point pt5 = new Point(Width, Height);

            context.BeginFigure(pt1, true, true);
            context.LineTo(pt2, true, false);
            context.BezierTo(pt2, pt3, pt4, true, true);
            context.LineTo(pt5, true, false);
        }
Пример #10
0
        public void DrawCurve(double x0, double y0, double x1, double y1, double x2, double y2,
                              double x3, double y3, Brush strokeBrush, double lineWidth)
        {
            StreamGeometry geometry = new StreamGeometry();

            using (StreamGeometryContext ctx = geometry.Open())
            {
                ctx.BeginFigure(new Point(x0, y0), false, false);
                ctx.BezierTo(new Point(x1, y1), new Point(x2, y2),
                             new Point(x3, y3), true, false);
            }
            dc.DrawGeometry(Brushes.Transparent, new Pen(strokeBrush, lineWidth), geometry);
        }
Пример #11
0
        public void DrawAndFillBeziers(Pen pen, Brush brush, TPointF[] points, TClippingStyle clippingStyle)
        {
            if (points == null || points.Length <= 1)
            {
                return;
            }
            if (!CheckPoints(points))
            {
                return;
            }

            StreamGeometry Line = new StreamGeometry();

            using (StreamGeometryContext sc = Line.Open())
            {
                sc.BeginFigure(new Point(points[0].X, points[0].Y), brush != null, false);
                for (int i = 1; i < points.Length - 2; i += 3)
                {
                    sc.BezierTo(new Point(points[i].X, points[i].Y), new Point(points[i + 1].X, points[i + 1].Y), new Point(points[i + 2].X, points[i + 2].Y), true, true);
                }
            }

            if (Line.CanFreeze)
            {
                Line.Freeze();
            }

            if (brush != null)
            {
                switch (clippingStyle)
                {
                case TClippingStyle.Exclude:
                    IntersectClip(Reverse(Line));
                    break;

                case TClippingStyle.Include:
                    IntersectClip(Line);
                    break;

                default:
                    //Will be handled below.
                    break;
                }
            }

            if (clippingStyle == TClippingStyle.None)
            {
                FCanvas.DrawGeometry(brush, pen, Line);
            }
        }
        public void DrawPath(IEnumerable <PathOp> ops, Pen pen, Brush brush)
        {
            StreamGeometry streamGeometry = new StreamGeometry();

            using (StreamGeometryContext geometryContext = streamGeometry.Open())
            {
                foreach (var op in ops)
                {
                    var mt = op as MoveTo;
                    if (mt != null)
                    {
                        geometryContext.BeginFigure(mt.Point.GetPoint(), true, false);
                        continue;
                    }

                    var lt = op as LineTo;
                    if (lt != null)
                    {
                        geometryContext.LineTo(lt.Point.GetPoint(), true, false);
                        continue;
                    }

                    var at = op as ArcTo;
                    if (at != null)
                    {
                        /*
                         * Point c1, c2;
                         * at.GetCircles(pp, out c1, out c2);
                         * var circleCenter = at.LargeArc ^ !at.SweepClockwise ? c2 : c1;
                         * var rotationAngle = (float)Math.Atan2(at.Point.Y - circleCenter.Y, at.Point.X - circleCenter.X);
                         * geometryContext.ArcTo(at.Point.GetPoint(), at.Radius.GetSize(), rotationAngle,
                         *  at.LargeArc, at.SweepClockwise ? SweepDirection.Clockwise : SweepDirection.Counterclockwise,
                         *  true, false
                         * );*/
                        throw new NotImplementedException();
                    }

                    var ct = op as CurveTo;
                    if (ct != null)
                    {
                        geometryContext.BezierTo(ct.Control1.GetPoint(), ct.Control2.GetPoint(), ct.Point.GetPoint(), true, false);
                    }

                    throw new NotSupportedException();
                }
            }

            dc.DrawGeometry(brush?.GetBrush(), pen?.GetPen(), streamGeometry);
        }
Пример #13
0
        public static void DrawFigure(this StreamGeometryContext ctx, PathFigure figure)
        {
            ctx.BeginFigure(figure.StartPoint, figure.IsFilled, figure.IsClosed);
            foreach (var segment in figure.Segments)
            {
                if (segment is LineSegment lineSegment)
                {
                    ctx.LineTo(lineSegment.Point, lineSegment.IsStroked, lineSegment.IsSmoothJoin);
                    continue;
                }

                if (segment is BezierSegment bezierSegment)
                {
                    ctx.BezierTo(bezierSegment.Point1, bezierSegment.Point2, bezierSegment.Point3, bezierSegment.IsStroked, bezierSegment.IsSmoothJoin);
                    continue;
                }

                if (segment is QuadraticBezierSegment quadraticSegment)
                {
                    ctx.QuadraticBezierTo(quadraticSegment.Point1, quadraticSegment.Point2, quadraticSegment.IsStroked, quadraticSegment.IsSmoothJoin);
                    continue;
                }

                if (segment is PolyLineSegment polyLineSegment)
                {
                    ctx.PolyLineTo(polyLineSegment.Points, polyLineSegment.IsStroked, polyLineSegment.IsSmoothJoin);
                    continue;
                }

                if (segment is PolyBezierSegment polyBezierSegment)
                {
                    ctx.PolyBezierTo(polyBezierSegment.Points, polyBezierSegment.IsStroked, polyBezierSegment.IsSmoothJoin);
                    continue;
                }

                if (segment is PolyQuadraticBezierSegment polyQuadraticSegment)
                {
                    ctx.PolyQuadraticBezierTo(polyQuadraticSegment.Points, polyQuadraticSegment.IsStroked, polyQuadraticSegment.IsSmoothJoin);
                    continue;
                }

                if (segment is ArcSegment arcSegment)
                {
                    ctx.ArcTo(arcSegment.Point, arcSegment.Size, arcSegment.RotationAngle, arcSegment.IsLargeArc, arcSegment.SweepDirection, arcSegment.IsStroked, arcSegment.IsSmoothJoin);
                    continue;
                }
            }
        }
Пример #14
0
        public static void DrawFigure(StreamGeometryContext ctx, PathFigure figure)
        {
            ctx.BeginFigure(figure.StartPoint, figure.IsFilled, figure.IsClosed);
            foreach (var segment in figure.Segments)
            {
                var lineSegment = segment as WpfLineSegment;
                if (lineSegment != null)
                {
                    ctx.LineTo(lineSegment.Point, lineSegment.IsStroked, lineSegment.IsSmoothJoin); continue;
                }

                var bezierSegment = segment as BezierSegment;
                if (bezierSegment != null)
                {
                    ctx.BezierTo(bezierSegment.Point1, bezierSegment.Point2, bezierSegment.Point3, bezierSegment.IsStroked, bezierSegment.IsSmoothJoin); continue;
                }

                var quadraticSegment = segment as QuadraticBezierSegment;
                if (quadraticSegment != null)
                {
                    ctx.QuadraticBezierTo(quadraticSegment.Point1, quadraticSegment.Point2, quadraticSegment.IsStroked, quadraticSegment.IsSmoothJoin); continue;
                }

                var polyLineSegment = segment as PolyLineSegment;
                if (polyLineSegment != null)
                {
                    ctx.PolyLineTo(polyLineSegment.Points, polyLineSegment.IsStroked, polyLineSegment.IsSmoothJoin); continue;
                }

                var polyBezierSegment = segment as PolyBezierSegment;
                if (polyBezierSegment != null)
                {
                    ctx.PolyBezierTo(polyBezierSegment.Points, polyBezierSegment.IsStroked, polyBezierSegment.IsSmoothJoin); continue;
                }

                var polyQuadraticSegment = segment as PolyQuadraticBezierSegment;
                if (polyQuadraticSegment != null)
                {
                    ctx.PolyQuadraticBezierTo(polyQuadraticSegment.Points, polyQuadraticSegment.IsStroked, polyQuadraticSegment.IsSmoothJoin); continue;
                }

                var arcSegment = segment as ArcSegment;
                if (arcSegment != null)
                {
                    ctx.ArcTo(arcSegment.Point, arcSegment.Size, arcSegment.RotationAngle, arcSegment.IsLargeArc, arcSegment.SweepDirection, arcSegment.IsStroked, arcSegment.IsSmoothJoin); continue;
                }
            }
        }
        /// <summary>
        /// Generates a WPF geometry for a single graphic path geometry
        /// </summary>
        public static Geometry GenerateGeometry(GraphicPathGeometry graphicPathGeometry)
        {
            if (graphicPathGeometry == null)
            {
                return(null);
            }

            StreamGeometry geometry = new StreamGeometry();

            geometry.FillRule = ConvertFillRule(graphicPathGeometry.FillRule);
            StreamGeometryContext ctx = geometry.Open();

            foreach (var segment in graphicPathGeometry.Segments)
            {
                switch (segment)
                {
                case GraphicMoveSegment graphicMove:
                {
                    ctx.BeginFigure(graphicMove.StartPoint, true, graphicMove.IsClosed);
                    break;
                }

                case GraphicLineSegment graphicLineTo:
                {
                    ctx.LineTo(graphicLineTo.To, true, true);
                    break;
                }

                case GraphicCubicBezierSegment graphicCubicBezier:
                {
                    ctx.BezierTo(graphicCubicBezier.ControlPoint1, graphicCubicBezier.ControlPoint2, graphicCubicBezier.EndPoint, true, true);
                    break;
                }

                case GraphicQuadraticBezierSegment graphicQuadraticBezier:
                {
                    ctx.QuadraticBezierTo(graphicQuadraticBezier.ControlPoint, graphicQuadraticBezier.EndPoint, true, true);
                    break;
                }
                }
            }

            ctx.Close();
            geometry.Freeze();

            return(geometry);
        }
Пример #16
0
        internal void FillContextForICurve(StreamGeometryContext context, ICurve iCurve)
        {
            if (iCurve == null)
            {
                return;
            }
            context.BeginFigure(CommonX.WpfPoint(iCurve.Start), false, false);

            var c = iCurve as Curve;

            if (c != null)
            {
                FillContexForCurve(context, c);
            }
            else
            {
                var cubicBezierSeg = iCurve as CubicBezierSegment;
                if (cubicBezierSeg != null)
                {
                    context.BezierTo(CommonX.WpfPoint(cubicBezierSeg.B(1)), CommonX.WpfPoint(cubicBezierSeg.B(2)),
                                     CommonX.WpfPoint(cubicBezierSeg.B(3)), true, false);
                }
                else
                {
                    var ls = iCurve as LineSegment;
                    if (ls != null)
                    {
                        context.LineTo(CommonX.WpfPoint(ls.End), true, false);
                    }
                    else
                    {
                        var rr = iCurve as RoundedRect;
                        if (rr != null)
                        {
                            FillContexForCurve(context, rr.Curve);
                        }
                        else
                        {
                            var poly = iCurve as Polyline;
                            FillContexForPolyline(context, poly);
                        }
                    }
                }
            }
        }
Пример #17
0
        private void InternalDrawArrowGeometry(StreamGeometryContext context)
        {
            _lstCtrPoints.Clear();
            List <Point> lstPoints    = new List <Point>();
            List <Point> lstCtrPoints = new List <Point>();

            foreach (Point pt in BezierPoints)
            {
                lstPoints.Add(new Point(pt.X, pt.Y));
            }
            if (_bDrawing == true && (BezierTmpPoint.X > 0 || BezierTmpPoint.Y > 0))
            {
                lstPoints.Add(new Point(BezierTmpPoint.X, BezierTmpPoint.Y));

                for (int i = 0; i < lstPoints.Count; i++)
                {
                    lstCtrPoints.AddRange(Control1(lstPoints, i));
                    if (i < lstPoints.Count - 1)
                    {
                        _lstCtrPoints.AddRange(Control1(lstPoints, i));
                    }
                }
            }
            else if (_bDrawing == false)
            {
                for (int i = 0; i < lstPoints.Count; i++)
                {
                    lstCtrPoints.AddRange(Control1(lstPoints, i));
                    _lstCtrPoints.AddRange(Control1(lstPoints, i));
                }
            }
            if (lstPoints != null && lstPoints.Count > 1)
            {
                Point ptStart = lstPoints[0];
                Point ptEnd   = lstPoints[lstPoints.Count - 1];
                //先绘制开始线帽
                SetLineCap(lstPoints[lstPoints.Count - 2], ptEnd, ptStart, lstPoints[1]);
                context.BeginFigure(ptStart, true, false);
                //再绘制曲线
                for (int i = 1; i < lstPoints.Count; i++)
                {
                    context.BezierTo(lstCtrPoints[i * 2 - 1], lstCtrPoints[i * 2], lstPoints[i], true, true);
                }
            }
        }
Пример #18
0
        public void DrawBezier(Point[] pts, DrawingContext dc, Brush brush)
        {
            foreach (Point pt in pts)//绘制点
            {
                dc.DrawEllipse(brush, null, pt, 5, 5);
            }
            StreamGeometry        sg  = new StreamGeometry();
            StreamGeometryContext sgc = sg.Open();

            sgc.BeginFigure(pts[0], true, false);
            sgc.BezierTo(pts[1], pts[2], pts[3], true, true);
            sgc.BeginFigure(pts[0], true, false);
            sgc.PolyLineTo(pts, true, true);
            sgc.Close();
            Pen pen = new Pen(brush, 1);

            dc.DrawGeometry(null, pen, sg);
        }
Пример #19
0
        private static void DeserializeBezierTo(BinaryReader br, byte firstByte, StreamGeometryContext sc)
        {
            Point point1;
            Point point2 = new Point();
            Point point3 = new Point();

            bool isStroked;
            bool isSmoothJoin;

            DeserializePointAndTwoBools(br, firstByte, out point1, out isStroked, out isSmoothJoin);

            point2.X = XamlSerializationHelper.ReadDouble(br);
            point2.Y = XamlSerializationHelper.ReadDouble(br);

            point3.X = XamlSerializationHelper.ReadDouble(br);
            point3.Y = XamlSerializationHelper.ReadDouble(br);

            sc.BezierTo(point1, point2, point3, isStroked, isSmoothJoin);
        }
Пример #20
0
 static void FillContexForCurve(StreamGeometryContext context, Curve c)
 {
     foreach (ICurve seg in c.Segments)
     {
         var bezSeg = seg as CubicBezierSegment;
         if (bezSeg != null)
         {
             context.BezierTo(CommonX.WpfPoint(bezSeg.B(1)),
                              CommonX.WpfPoint(bezSeg.B(2)), CommonX.WpfPoint(bezSeg.B(3)), true, false);
         }
         else
         {
             var ls = seg as LineSegment;
             if (ls != null)
             {
                 context.LineTo(CommonX.WpfPoint(ls.End), true, false);
             }
             else
             {
                 var ellipse = seg as Ellipse;
                 if (ellipse != null)
                 {
                     //       context.LineTo(Common.WpfPoint(ellipse.End),true,false);
                     double    sweepAngle = EllipseSweepAngle(ellipse);
                     bool      largeArc   = Math.Abs(sweepAngle) >= Math.PI;
                     Rectangle box        = ellipse.FullBox();
                     context.ArcTo(CommonX.WpfPoint(ellipse.End),
                                   new Size(box.Width / 2, box.Height / 2),
                                   sweepAngle,
                                   largeArc,
                                   sweepAngle < 0
                                       ? SweepDirection.Counterclockwise
                                       : SweepDirection.Clockwise,
                                   true, true);
                 }
                 else
                 {
                     throw new NotImplementedException();
                 }
             }
         }
     }
 }
Пример #21
0
        /// <summary>
        /// Returns the geometry scaled to the provided size.
        /// </summary>
        /// <param name="width">The width.</param>
        /// <param name="height">The height.</param>
        public Geometry Scaled(double width, double height)
        {
            StreamGeometry Result = new StreamGeometry();

            GeometryScale ScaledWidth  = (WidthScale != null) ? new GeometryScale(WidthScale, width) : null;
            GeometryScale ScaledHeight = (HeightScale != null) ? new GeometryScale(HeightScale, height) : null;

            using (StreamGeometryContext sgc = Result.Open())
            {
                sgc.BeginFigure(ScaledPoint(Figure.StartPoint, ScaledWidth, ScaledHeight), Figure.IsFilled, Figure.IsClosed);

                foreach (PathSegment Segment in Figure.Segments)
                {
                    LineSegment       AsLineSegment;
                    PolyLineSegment   AsPolyLineSegment;
                    BezierSegment     AsBezierSegment;
                    PolyBezierSegment AsPolyBezierSegment;

                    if ((AsLineSegment = Segment as LineSegment) != null)
                    {
                        sgc.LineTo(ScaledPoint(AsLineSegment.Point, ScaledWidth, ScaledHeight), AsLineSegment.IsStroked, AsLineSegment.IsSmoothJoin);
                    }

                    else if ((AsPolyLineSegment = Segment as PolyLineSegment) != null)
                    {
                        sgc.PolyLineTo(ScaledPointList(AsPolyLineSegment.Points, ScaledWidth, ScaledHeight), AsPolyLineSegment.IsStroked, AsPolyLineSegment.IsSmoothJoin);
                    }

                    else if ((AsBezierSegment = Segment as BezierSegment) != null)
                    {
                        sgc.BezierTo(ScaledPoint(AsBezierSegment.Point1, ScaledWidth, ScaledHeight), ScaledPoint(AsBezierSegment.Point2, ScaledWidth, ScaledHeight), ScaledPoint(AsBezierSegment.Point3, ScaledWidth, ScaledHeight), AsBezierSegment.IsStroked, AsBezierSegment.IsSmoothJoin);
                    }

                    else if ((AsPolyBezierSegment = Segment as PolyBezierSegment) != null)
                    {
                        sgc.PolyBezierTo(ScaledPointList(AsPolyBezierSegment.Points, ScaledWidth, ScaledHeight), AsPolyBezierSegment.IsStroked, AsPolyBezierSegment.IsSmoothJoin);
                    }
                }
            }

            return(Result);
        }
Пример #22
0
 private void clearAndDrawCurves(IEnumerable <CubicBezier> curves, bool colorize)
 {
     using (DrawingContext dctx = _drawing.Open())
     {
         clearDrawing(dctx);
         int i = 0;
         foreach (CubicBezier curve in curves)
         {
             // each curve segment is a seperate StreamGeometry since they use different pens
             Pen            pen = colorize ? _partPens[i++ % _partPens.Length] : _partPens[0];
             StreamGeometry geo = new StreamGeometry();
             using (StreamGeometryContext gctx = geo.Open())
             {
                 gctx.BeginFigure(toWpfPoint(curve.p0), false, false);
                 gctx.BezierTo(toWpfPoint(curve.p1), toWpfPoint(curve.p2), toWpfPoint(curve.p3), true, false);
             }
             geo.Freeze();
             dctx.DrawGeometry(null, pen, geo);
         }
     }
 }
Пример #23
0
        private void button1_Click(object sender, System.Windows.RoutedEventArgs e)
        {
            StreamGeometry sg = new StreamGeometry();

            sg.FillRule = FillRule.EvenOdd;
            using (StreamGeometryContext sgc = sg.Open()){
                sgc.BeginFigure(new Point(0, 200), true, true);
                sgc.LineTo(new Point(100, 150), true, true);
                Point p = new Point(200, 150);                   //椭圆弧终点
                Size  s = new Size(100, 50);                     //圆弧宽、高
                sgc.ArcTo(p, s, 0, true, SweepDirection.Clockwise, true, true);
                Point p1 = new Point(200, 150);                  //第1个控制点
                Point p2 = new Point(300, 10);                   //第2个控制点
                Point p3 = new Point(400, 230);                  //终点
                sgc.BezierTo(p1, p2, p3, true, true);            //绘制贝塞尔曲线
            }
            GeometryDrawing gd = new GeometryDrawing();          //定义绘制几何形状对象

            gd.Geometry = sg;                                    //绘制的几何图形
            LinearGradientBrush lgb = new LinearGradientBrush(); //定义线性渐变

            //默认的线性渐变是沿对角线方向进行的,
            //StartPoint是被填充区域的左上角 (0,0),EndPoint是被填充区域的右下角 (1,1),
            //EndPoint(1,0)水平方向,EndPoint(0,1)垂直方向。
            lgb.StartPoint = new Point(0, 0);
            lgb.EndPoint   = new Point(1, 0);
            lgb.GradientStops.Add(new GradientStop(Colors.Red, 0.1));            //插入渐变停止点
            lgb.GradientStops.Add(new GradientStop(Colors.LightSkyBlue, 0.25));
            lgb.GradientStops.Add(new GradientStop(Colors.Blue, 0.5));
            lgb.GradientStops.Add(new GradientStop(Colors.LightGreen, 0.75));
            gd.Brush = lgb;                              //绘制图形填充色
            gd.Pen   = new Pen(Brushes.Red, 2);          //描边色
            DrawingImage di      = new DrawingImage(gd); //绘制图像用于显示
            Image        myimage = new Image();          //定义图像对象

            myimage.Source = di;                         //赋予图像对象
            Canvas.SetLeft(myimage, 60);                 //位置坐标
            Canvas.SetTop(myimage, 30);
            this.canvas1.Children.Add(myimage);          //图像装入容器显示
        }
Пример #24
0
        /// <span class="code-SummaryComment"><summary></span>
        /// Draws an Arrow
        /// <span class="code-SummaryComment"></summary></span>
        private void InternalDrawArrowGeometry(StreamGeometryContext context)
        {
            vm = DataContext as ConnectionViewModel;
            if (vm == null)
            {
                return;
            }

            if (vm.Type == EdgeLineType.Line)
            {
                context.BeginFigure(FromPoint, false, false);

                context.LineTo(ToPoint, true, false);
            }
            else if (vm.Type == EdgeLineType.Bezier)
            {
                var bezierPoints = vm.GetBezierPoints();

                context.BeginFigure(bezierPoints[0], false, false);
                context.BezierTo(bezierPoints[1], bezierPoints[2], bezierPoints[3], true, true);
            }
        }
        public StreamGeometryBezierToExample()
        {
            // Create a StreamGeometry to use to specify myPath.
            StreamGeometry geometry = new StreamGeometry();

            geometry.FillRule = FillRule.EvenOdd;

            // Open a StreamGeometryContext that can be used to describe this StreamGeometry
            // object's contents.
            using (StreamGeometryContext ctx = geometry.Open())
            {
                // Set the begin point of the shape.
                ctx.BeginFigure(new Point(10, 100), true /* is filled */, false /* is closed */);

                // Create a Bezier curve using the 3 specifed points where the first two points
                // are control points and the last point is the destination point for the curve.
                ctx.BezierTo(new Point(100, 0), new Point(200, 200), new Point(300, 100),
                             true /* is stroked */, false /* is smooth join */);
            }

            // Create a path to draw a geometry with.
            Path myPath = new Path();

            myPath.Stroke          = Brushes.Black;
            myPath.StrokeThickness = 1;

            // Freeze the geometry (make it unmodifiable)
            // for additional performance benefits.
            geometry.Freeze();

            // specify the shape (Bezier Curve) of the path using the StreamGeometry.
            myPath.Data = geometry;

            // Add path shape to the UI.
            StackPanel mainPanel = new StackPanel();

            mainPanel.Children.Add(myPath);
            this.Content = mainPanel;
        }
Пример #26
0
        /// <summary>
        /// 绘图函数绘出图像如果过于折现化说明样本点密度过低,请改用bezier函数连接以改善图形
        /// </summary>
        /// <param name="values">样本序列</param>
        /// <param name="isFilled"></param>
        /// <param name="isClosed">是否闭合</param>
        /// <returns></returns>
        private Geometry DrawGeometry(List <Point> values, bool isFilled, bool isClosed, Type type)
        {
            try
            {
                StreamGeometry geometry = new StreamGeometry();

                using (StreamGeometryContext ctx = geometry.Open())
                {
                    ctx.BeginFigure(values[0], isFilled /* is filled */, isClosed /* is closed */);

                    //画出一系列线段并且连接成曲线
                    if (type == Type.Line)
                    {
                        for (int i = 1; i < values.Count && values[i].X <= 480; i++)
                        {
                            ctx.LineTo(values[i], true, false);
                        }
                    }
                    //使用bezier曲线进行连接
                    else if (type == Type.Bezier)
                    {
                        Bezier bezier = new Bezier(values, 0.7);
                        for (int i = 1; i < values.Count; i++)
                        {
                            ctx.BezierTo(bezier.controlPointCollection[2 * i - 2], bezier.controlPointCollection[2 * i - 1], values[i], true, false);
                        }
                    }
                }

                return(geometry);
            }
            catch (Exception)
            {
                MessageBox.Show("请先输入频率");
                return(null);
            }
        }
Пример #27
0
        public static void Write(this StreamGeometryContext ctx, PathSegment pathSegment)
        {
            switch (pathSegment)
            {
            case ArcSegment arc:
                ctx.ArcTo(arc.Point, arc.Size, arc.RotationAngle, arc.IsLargeArc, arc.SweepDirection, false, false);
                break;

            case BezierSegment bezier:
                ctx.BezierTo(bezier.Point1, bezier.Point2, bezier.Point3, false, false);
                break;

            case PolyBezierSegment polyBezier:
                ctx.PolyBezierTo(polyBezier.Points, false, false);
                break;

            case PolyLineSegment polyLine:
                ctx.PolyLineTo(polyLine.Points, false, false);
                break;

            case QuadraticBezierSegment quadraticBezier:
                ctx.QuadraticBezierTo(quadraticBezier.Point1, quadraticBezier.Point2, false, false);
                break;

            case PolyQuadraticBezierSegment polyQuadraticBezier:
                ctx.PolyQuadraticBezierTo(polyQuadraticBezier.Points, false, false);
                break;

            case LineSegment line:
                ctx.LineTo(line.Point, false, false);
                break;

            default:
                break;
            }
        }
Пример #28
0
        /// <summary>
        /// Parse a PathFigureCollection string
        /// </summary>
        internal void ParseToGeometryContext(
            StreamGeometryContext context,
            string pathString,
            int startIndex)
        {
            // [BreakingChange] Dev10 Bug #453199
            // We really should throw an ArgumentNullException here for context and pathString.

            // From original code
            // This is only used in call to Double.Parse
            _formatProvider = System.Globalization.CultureInfo.InvariantCulture;

            _context    = context;
            _pathString = pathString;
            _pathLength = pathString.Length;
            _curIndex   = startIndex;

            _secondLastPoint = new Point(0, 0);
            _lastPoint       = new Point(0, 0);
            _lastStart       = new Point(0, 0);

            _figureStarted = false;

            bool first = true;

            char last_cmd = ' ';

            while (ReadToken()) // Empty path is allowed in XAML
            {
                char cmd = _token;

                if (first)
                {
                    if ((cmd != 'M') && (cmd != 'm'))  // Path starts with M|m
                    {
                        ThrowBadToken();
                    }

                    first = false;
                }

                switch (cmd)
                {
                case 'm':
                case 'M':
                    // XAML allows multiple points after M/m
                    _lastPoint = ReadPoint(cmd, !AllowComma);

                    context.BeginFigure(_lastPoint, IsFilled, !IsClosed);
                    _figureStarted = true;
                    _lastStart     = _lastPoint;
                    last_cmd       = 'M';

                    while (IsNumber(AllowComma))
                    {
                        _lastPoint = ReadPoint(cmd, !AllowComma);

                        context.LineTo(_lastPoint, IsStroked, !IsSmoothJoin);
                        last_cmd = 'L';
                    }
                    break;

                case 'l':
                case 'L':
                case 'h':
                case 'H':
                case 'v':
                case 'V':
                    EnsureFigure();

                    do
                    {
                        switch (cmd)
                        {
                        case 'l': _lastPoint = ReadPoint(cmd, !AllowComma); break;

                        case 'L': _lastPoint = ReadPoint(cmd, !AllowComma); break;

                        case 'h': _lastPoint.X += ReadNumber(!AllowComma); break;

                        case 'H': _lastPoint.X = ReadNumber(!AllowComma); break;

                        case 'v': _lastPoint.Y += ReadNumber(!AllowComma); break;

                        case 'V': _lastPoint.Y = ReadNumber(!AllowComma); break;
                        }

                        context.LineTo(_lastPoint, IsStroked, !IsSmoothJoin);
                    }while (IsNumber(AllowComma));

                    last_cmd = 'L';
                    break;

                case 'c':
                case 'C':           // cubic Bezier
                case 's':
                case 'S':           // smooth cublic Bezier
                    EnsureFigure();

                    do
                    {
                        Point p;

                        if ((cmd == 's') || (cmd == 'S'))
                        {
                            if (last_cmd == 'C')
                            {
                                p = Reflect();
                            }
                            else
                            {
                                p = _lastPoint;
                            }

                            _secondLastPoint = ReadPoint(cmd, !AllowComma);
                        }
                        else
                        {
                            p = ReadPoint(cmd, !AllowComma);

                            _secondLastPoint = ReadPoint(cmd, AllowComma);
                        }

                        _lastPoint = ReadPoint(cmd, AllowComma);

                        context.BezierTo(p, _secondLastPoint, _lastPoint, IsStroked, !IsSmoothJoin);

                        last_cmd = 'C';
                    }while (IsNumber(AllowComma));

                    break;

                case 'q':
                case 'Q':           // quadratic Bezier
                case 't':
                case 'T':           // smooth quadratic Bezier
                    EnsureFigure();

                    do
                    {
                        if ((cmd == 't') || (cmd == 'T'))
                        {
                            if (last_cmd == 'Q')
                            {
                                _secondLastPoint = Reflect();
                            }
                            else
                            {
                                _secondLastPoint = _lastPoint;
                            }

                            _lastPoint = ReadPoint(cmd, !AllowComma);
                        }
                        else
                        {
                            _secondLastPoint = ReadPoint(cmd, !AllowComma);
                            _lastPoint       = ReadPoint(cmd, AllowComma);
                        }

                        context.QuadraticBezierTo(_secondLastPoint, _lastPoint, IsStroked, !IsSmoothJoin);

                        last_cmd = 'Q';
                    }while (IsNumber(AllowComma));

                    break;

                case 'a':
                case 'A':
                    EnsureFigure();

                    do
                    {
                        // A 3,4 5, 0, 0, 6,7
                        double w        = ReadNumber(!AllowComma);
                        double h        = ReadNumber(AllowComma);
                        double rotation = ReadNumber(AllowComma);
                        bool   large    = ReadBool();
                        bool   sweep    = ReadBool();

                        _lastPoint = ReadPoint(cmd, AllowComma);

                        context.ArcTo(
                            _lastPoint,
                            new Size(w, h),
                            rotation,
                            large,
#if PBTCOMPILER
                            sweep,
#else
                            sweep ? SweepDirection.Clockwise : SweepDirection.Counterclockwise,
#endif
                            IsStroked,
                            !IsSmoothJoin
                            );
                    }while (IsNumber(AllowComma));

                    last_cmd = 'A';
                    break;

                case 'z':
                case 'Z':
                    EnsureFigure();
                    context.SetClosedState(IsClosed);

                    _figureStarted = false;
                    last_cmd       = 'Z';

                    _lastPoint = _lastStart; // Set reference point to be first point of current figure
                    break;

                default:
                    ThrowBadToken();
                    break;
                }
            }
        }
Пример #29
0
        static private void CreateEdgePathFromCurve(StreamGeometryContext context, ICurve iCurve)
        {
            context.BeginFigure(iCurve.Start.ToWpf(), false, false);

            var c = iCurve as Curve;

            if (c != null)
            {
                FillContexForCurve(context, c);
                return;
            }

            var cubicBezierSeg = iCurve as CubicBezierSegment;

            if (cubicBezierSeg != null)
            {
                context.BezierTo(cubicBezierSeg.B(1).ToWpf(), cubicBezierSeg.B(2).ToWpf(), cubicBezierSeg.B(3).ToWpf(), true, false);
                return;
            }

            var ls = iCurve as GeometryLineSegment;

            if (ls != null)
            {
                context.LineTo(ls.End.ToWpf(), true, false);
                return;
            }

            var rr = iCurve as RoundedRect;

            if (rr != null)
            {
                FillContexForCurve(context, rr.Curve);
                return;
            }

            var poly = iCurve as GeometryPolyline;

            if (poly != null)
            {
                FillContexForPolyline(context, poly);
                return;
            }

            var ellipse = iCurve as GeometryEllipse;

            if (ellipse != null)
            {
                //       context.LineTo(Common.WpfPoint(ellipse.End),true,false);
                double            sweepAngle = EllipseSweepAngle(ellipse);
                bool              largeArc   = Math.Abs(sweepAngle) >= Math.PI;
                GeometryRectangle box        = ellipse.FullBox();
                context.ArcTo(ellipse.End.ToWpf(),
                              new Size(box.Width / 2, box.Height / 2),
                              sweepAngle,
                              largeArc,
                              sweepAngle < 0
                                    ? SweepDirection.Counterclockwise
                                    : SweepDirection.Clockwise,
                              true, true);

                return;
            }
            else
            {
                throw new NotImplementedException($"{iCurve.GetType()}");
            }
        }
Пример #30
0
        private static void DeserializeBezierTo(BinaryReader br, byte firstByte, StreamGeometryContext sc)
        {
            Point point1;
            Point point2 = new Point();
            Point point3 = new Point();

            bool isStroked;
            bool isSmoothJoin;

            DeserializePointAndTwoBools(br, firstByte, out point1, out isStroked, out isSmoothJoin);

            point2.X = XamlSerializationHelper.ReadDouble(br);
            point2.Y = XamlSerializationHelper.ReadDouble(br);

            point3.X = XamlSerializationHelper.ReadDouble(br);
            point3.Y = XamlSerializationHelper.ReadDouble(br);

            sc.BezierTo(point1, point2, point3, isStroked, isSmoothJoin);
        }
Пример #31
0
        void ellipse(double xm, double ym, double r, StreamGeometryContext context)
        {
            double ctrl_ell_x1 = Radius * kappa;
            double ctrl_ell_y1 = Radius;

            double ctrl_ell_x2 = Radius;
            double ctrl_ell_y2 = Radius * kappa;

            double ell_x = Radius * Math.Sin(2 * Math.PI * 0.25);
            double ell_y = Radius * Math.Cos(2 * Math.PI * 0.25);

            var ctrlPoint1 = new Point(xm + ctrl_ell_x1, ym - ctrl_ell_y1);
            var ctrlPoint2 = new Point(xm + ctrl_ell_x2, ym - ctrl_ell_y2);
            var point      = new Point(xm + ell_x, ym - ell_y);

            context.BezierTo(ctrlPoint1, ctrlPoint2, point, true, true);
            //--------------------------------------------------------------------------

            ctrl_ell_x2 = Radius * kappa;
            ctrl_ell_y2 = -Radius;

            ctrl_ell_x1 = Radius;
            ctrl_ell_y1 = -Radius * kappa;

            ell_x = Radius * Math.Sin(2 * Math.PI * 0.50);
            ell_y = Radius * Math.Cos(2 * Math.PI * 0.50);

            ctrlPoint1 = new Point(xm + ctrl_ell_x1, ym - ctrl_ell_y1);
            ctrlPoint2 = new Point(xm + ctrl_ell_x2, ym - ctrl_ell_y2);
            point      = new Point(xm + ell_x, ym - ell_y);

            context.BezierTo(ctrlPoint1, ctrlPoint2, point, true, true);
            //--------------------------------------------------------------------------
            ctrl_ell_x1 = -Radius * kappa;
            ctrl_ell_y1 = -Radius;

            ctrl_ell_x2 = -Radius;
            ctrl_ell_y2 = -Radius * kappa;

            ell_x = Radius * Math.Sin(2 * Math.PI * 0.75);
            ell_y = Radius * Math.Cos(2 * Math.PI * 0.75);

            ctrlPoint1 = new Point(xm + ctrl_ell_x1, ym - ctrl_ell_y1);
            ctrlPoint2 = new Point(xm + ctrl_ell_x2, ym - ctrl_ell_y2);
            point      = new Point(xm + ell_x, ym - ell_y);

            context.BezierTo(ctrlPoint1, ctrlPoint2, point, true, true);
            //--------------------------------------------------------------------------
            ctrl_ell_x2 = -Radius * kappa;
            ctrl_ell_y2 = Radius;

            ctrl_ell_x1 = -Radius;
            ctrl_ell_y1 = Radius * kappa;

            ell_x = Radius * Math.Sin(2 * Math.PI * 1);
            ell_y = Radius * Math.Cos(2 * Math.PI * 1);

            ctrlPoint1 = new Point(xm + ctrl_ell_x1, ym - ctrl_ell_y1);
            ctrlPoint2 = new Point(xm + ctrl_ell_x2, ym - ctrl_ell_y2);
            point      = new Point(xm + ell_x, ym - ell_y);

            context.BezierTo(ctrlPoint1, ctrlPoint2, point, true, true);
            //--------------------------------------------------------------------------
        }