private static Point PointOnCircle([NotNull] IArcSegment segment,
                                    double angleInDegreesRelativeToYAxisCounterclockwise)
 {
     return(PointOnCircle(segment.CentrePoint,
                          segment.Radius,
                          angleInDegreesRelativeToYAxisCounterclockwise));
 }
        private bool IsDistanceToPointGreaterThanRadius(IArcSegment segment,
                                                        Point point)
        {
            var centreToPoint = new Line(segment.CentrePoint,
                                         point);

            return(Math.Abs(centreToPoint.Length - segment.Radius) > SelkieConstants.EpsilonDistance);
        }
        internal TurnCircleArcSegment(IArcSegment arcSegment,
                                      Constants.TurnDirection direction,
                                      Constants.CircleOrigin circleOrigin)
        {
            ArcSegment     = arcSegment;
            m_Direction    = direction;
            m_CircleOrigin = circleOrigin;

            AngleToXAxisAtEndPoint   = arcSegment.AngleToXAxisAtEndPoint;
            AngleToXAxisAtStartPoint = arcSegment.AngleToXAxisAtStartPoint;
        }
        /// <summary>
        /// ArcTo - append an ArcTo to the current figure.
        /// </summary>
        public override void ArcTo(Point point, Size size, double rotationAngle, bool isLargeArc,
                                   SweepDirection sweepDirection)
        {
            Debug.Assert(_currentFigure != null);

            FinishSegment();

            IArcSegment segment = _geometryFactory.CreateArcSegment(point, size, rotationAngle, isLargeArc, sweepDirection);

            _currentFigure !.Segments.Add(segment);

            _currentSegment = new PathSegmentInfo(MIL_SEGMENT_TYPE.MilSegmentArc, 0);
        }
        public void UnknonTest()
        {
            IArcSegment segment = ArcSegment.Unknown;

            Assert.True(segment.IsUnknown,
                        "IsUnknown");
            Assert.AreEqual(Point.Unknown,
                            segment.CentrePoint,
                            "CentrePoint");
            Assert.AreEqual(Point.Unknown,
                            segment.StartPoint,
                            "StartPoint");
            Assert.AreEqual(Point.Unknown,
                            segment.EndPoint,
                            "EndPoint");
            Assert.AreEqual(Constants.TurnDirection.Unknown,
                            segment.TurnDirection,
                            "TurnDirection");
        }
        public void Constructor_CreatesArcSegment_WhenCalled()
        {
            // Arrange
            Angle expectedAngle = Angle.For270Degrees;

            // Act
            IArcSegment actual = m_Sut.ArcSegment;

            // Assert
            Assert.AreEqual(m_Circle.CentrePoint,
                            actual.CentrePoint,
                            "CentrePoint");
            Assert.AreEqual(m_StartPoint,
                            actual.StartPoint,
                            "StartPoint");
            Assert.AreEqual(m_EndPoint,
                            actual.EndPoint,
                            "EndPoint");
            Assert.AreEqual(expectedAngle,
                            actual.AngleClockwise,
                            "AngleClockwise");
        }
        private bool CalculateIfPointIsOnArcSegment([NotNull] IArcSegment segment,
                                                    [NotNull] Point point)
        {
            if (segment.StartPoint.Equals(point) ||
                segment.EndPoint.Equals(point))
            {
                return(true);
            }

            if (IsDistanceToPointGreaterThanRadius(segment,
                                                   point))
            {
                return(false);
            }

            ICircleCentreToPointCalculator calculatorStart = new CircleCentreToPointCalculator(segment.CentrePoint,
                                                                                               segment.StartPoint);
            ICircleCentreToPointCalculator calculatorEnd = new CircleCentreToPointCalculator(segment.CentrePoint,
                                                                                             segment.EndPoint);
            ICircleCentreToPointCalculator calculatorPoint = new CircleCentreToPointCalculator(segment.CentrePoint,
                                                                                               point);

            Angle angleStart = calculatorStart.AngleRelativeToYAxisCounterclockwise;
            Angle angleEnd   = calculatorEnd.AngleRelativeToYAxisCounterclockwise;
            Angle anglePoint = calculatorPoint.AngleRelativeToYAxisCounterclockwise;

            if (!(angleStart.Degrees >= 0.0))
            {
                return(false);
            }
            if (!(angleEnd.Degrees >= 0.0))
            {
                return(false);
            }
            return((anglePoint >= angleStart) &&
                   (anglePoint <= angleEnd));
        }