Example #1
0
 public IEnumerable <PointF> GetSpiralPoints()
 {
     for (float theta = 0;; theta += deltaAngle)
     {
         var   r = thickness * theta;
         float x, y;
         (x, y) = PointConverter.TransformPolarToCartesian(r, theta);
         x     += center.X;
         y     += center.Y;
         yield return(new PointF(x, y));
     }
 }
Example #2
0
        private bool TryFindPointAtSpiralOneSpinAgo(PointF currentSpinPoint, float a, out PointF previousSpinPoint)
        {
            var(r, theta) =
                PointConverter.TransformCartesianToPolar(currentSpinPoint.X - center.X, currentSpinPoint.Y - center.Y);
            theta -= (float)(2 * Math.PI * a);
            if (theta < 0)
            {
                previousSpinPoint = new PointF(0, 0);
                return(false);
            }

            r                 = theta * a;
            var(x, y)         = PointConverter.TransformPolarToCartesian(r, theta);
            previousSpinPoint = new PointF(x + center.X, y + center.Y);
            return(true);
        }
Example #3
0
        public void IEnumerator_YieldsSequenceInCorrectOrder(float thickness, float centerX, float centerY,
                                                             int elementIndex)
        {
            generator = new ArchimedesSpiral(new PointF(centerX, centerY), thickness, DeltaAngle).GetSpiralPoints()
                        .GetEnumerator();
            for (var i = 0; i <= elementIndex; i++)
            {
                generator.MoveNext();
            }
            var firstPoint = generator.Current;

            generator.MoveNext();
            float theta, r;

            (r, theta) = PointConverter.TransformCartesianToPolar(firstPoint.X - centerX, firstPoint.Y - centerY);
            theta     += DeltaAngle;
            r          = thickness * theta;
            var nextX = (float)(r * Math.Cos(theta)) + centerX;
            var nextY = (float)(r * Math.Sin(theta)) + centerY;

            generator.Current.X.Should().BeApproximately(nextX, (float)Epsilon);
            generator.Current.Y.Should().BeApproximately(nextY, (float)Epsilon);
        }