internal double CalculateAngle(Point startPoint,
                                       Point endPoint,
                                       Constants.LineDirection direction)
        {
            var geoStartPoint = new Geometry.Shapes.Point(startPoint.X,
                                                          startPoint.Y);
            var geoEndPoint = new Geometry.Shapes.Point(endPoint.X,
                                                        endPoint.Y);

            var line = new Line(geoStartPoint,
                                geoEndPoint,
                                direction);

            return line.AngleToXAxis.Degrees;
        }
        public void CalculateIsLargeArcReturnsFalseForCounterClockwiseAndStartTest()
        {
            var circle = new Circle(10.0,
                                    10.0,
                                    10);
            var startPoint = new Geometry.Shapes.Point(20.0,
                                                       10.0);
            var endPoint = new Geometry.Shapes.Point(0.0,
                                                     10.0);

            var segment = new TurnCircleArcSegment(circle,
                                                   Constants.TurnDirection.Counterclockwise,
                                                   Constants.CircleOrigin.Start,
                                                   startPoint,
                                                   endPoint);

            Assert.False(m_Helper.CalculateIsLargeArc(segment));
        }
        public void SegmentToArcSegmentForTurnDirectionCounterClockwiseCaseOneTest()
        {
            var helper = new PathSegmentHelper(new GeometryPointToWindowsPointConverter());

            var circle = new Circle(new Geometry.Shapes.Point(350.0,
                                                              490.0),
                                    30.0);
            var startPoint = new Geometry.Shapes.Point(327.639320225002,
                                                       510.0);
            var endPoint = new Geometry.Shapes.Point(350.0,
                                                     520.0);


            var segment = new TurnCircleArcSegment(circle,
                                                   Constants.TurnDirection.Counterclockwise,
                                                   Constants.CircleOrigin.Finish,
                                                   startPoint,
                                                   endPoint);

            ArcSegment actual = helper.SegmentToArcSegment(segment);

            Assert.AreEqual(new Point(400,
                                      1430),
                            actual.Point,
                            "Point");
            Assert.AreEqual(new Size(30.0,
                                     30.0),
                            actual.Size,
                            "Size");
            Assert.AreEqual(SweepDirection.Counterclockwise,
                            actual.SweepDirection,
                            "SweepDirection");
            Assert.True(actual.IsLargeArc,
                        "IsLargeArc");
        }
        public void SegmentToArcSegmentForTurnDirectionCounterClockwiseTest()
        {
            var circle = new Circle(10.0,
                                    10.0,
                                    10);
            var startPoint = new Geometry.Shapes.Point(20.0,
                                                       10.0);
            var endPoint = new Geometry.Shapes.Point(0.0,
                                                     10.0);

            var segment = new TurnCircleArcSegment(circle,
                                                   Constants.TurnDirection.Counterclockwise,
                                                   Constants.CircleOrigin.Start,
                                                   startPoint,
                                                   endPoint);

            ArcSegment actual = m_Helper.SegmentToArcSegment(segment);

            Assert.AreEqual(m_Point,
                            actual.Point,
                            "Point");
            Assert.AreEqual(new Size(10.0,
                                     10.0),
                            actual.Size,
                            "Size");
            Assert.AreEqual(SweepDirection.Counterclockwise,
                            actual.SweepDirection,
                            "SweepDirection");
            Assert.False(actual.IsLargeArc,
                         "IsLargeArc");
        }
        public void PointRelativeToOriginTest()
        {
            var point = new Geometry.Shapes.Point(10.0,
                                                  10.0);

            Point actual = m_Helper.PointRelativeToOrigin(point);

            Assert.AreEqual(m_Point,
                            actual);
        }