public void ShouldComputePointsForCircle()
        {
            CircleLogic circle = new CircleLogic();

            // number of points to plot 16
            // value of theta(t) intervals in radians = (2*Math.PI)/16
            // assume unit circle, r = 1
            // h = 200, k = 200
            int    h = 200;
            int    k = 200;
            int    r = 1;
            int    numberOfPoints             = 16;
            double theta_intervals_in_radians = (2 * Math.PI) / numberOfPoints;
            List <PointLocation> locations    = circle.ComputePointsForCirclePlot(h, k, r, theta_intervals_in_radians);

            string locationPoints = JsonConvert.SerializeObject(locations);
        }
        private async Task MoveCircle(int radius, int detailLevel = 8, bool reverse = false)
        {
            if (this._stoppedManually)
            {
                return;
            }

            this.PrepareDrawing();

            await Task.Run(() =>
            {
                this._panTiltControl.PanTiltAbsolute(0, 0);
                this._waitMovementResetEvent.WaitOne(1000);
                this._positionChecker.ComparePosition(new PanTiltPosition(0, 0), 0.2, 20, 40);
            });

            var circleLogic = new CircleLogic();

            this._currentPosition          = new PanTiltPosition(0, 0);
            this._deviationOverrunDetected = false;

            var items = new List <PanTiltPosition>();

            for (var r = radius; r <= 180; r += radius)
            {
                var positions = circleLogic.CalculatePtPositions(r, detailLevel);

                if (reverse)
                {
                    positions.Reverse();
                }

                items.AddRange(positions);
            }

            this._lastPosition = null;

            for (var i = 1; i < items.Count; i++)
            {
                if (this._stoppedManually)
                {
                    return;
                }

                var previousPt = items[i - 1];
                var currentPt  = items[i];

                this._drawEngine.DrawLine(previousPt, currentPt, Color.DarkGreen, 4);

                if (this._lastPosition != null)
                {
                    this._drawEngine.DrawLine(this._lastPosition, this._currentPosition, Color.HotPink, 2);
                }

                this._lastPosition = new PanTiltPosition(this._currentPosition.Pan, this._currentPosition.Tilt);

                this.labelPanTiltPosition.Text = $"Pan:{currentPt.Pan:0.00} Tilt:{currentPt.Tilt:0.00}";
                this.UpdateCurrentImage();

                await Task.Run(() =>
                {
                    this._panTiltControl.PanTiltAbsolute(currentPt.Pan, currentPt.Tilt);
                    this._positionChecker.ComparePosition(new PanTiltPosition(currentPt.Pan, currentPt.Tilt), 0.1, 50, 40);
                });
            }

            this.UpdateCurrentImage();
            this.SaveCircleTestImageToFile(radius, detailLevel);
        }
Пример #3
0
 public void TestCheckCirclesOnOneLine()
 {
     Assert.AreEqual(1, CircleLogic.CheckCirclesOnOneLine(items).Count);
     items.Add(new CircleItem(new Point(4, 7), 3));
     Assert.AreEqual(2, CircleLogic.CheckCirclesOnOneLine(items).Count);
 }
Пример #4
0
 public void TestFindCirclesMaxPerimeter()
 {
     Assert.AreEqual(2, CircleLogic.FindCirclesMaxPerimeter(items).Count);
 }
Пример #5
0
 public void TestFindkCirclesMaxSquare()
 {
     Assert.AreEqual(2, CircleLogic.FindCirclesMaxSquare(items).Count);
 }