Exemple #1
0
 public static Point2d1T offsetToAbsolute(Point2d1T offset)
 {
     if (offset.target < 1 || 5 < offset.target)
     {
         throw new InvalidOperationException("offset.target is not in the range 1-5.");
     }
     return(new Point2d1T(TargetCoords[offset.target].x + offset.x, TargetCoords[offset.target].y - offset.y, offset.target));
 }
        public void offsetToAbsolute_Test1()
        {
            var pdt     = new Point2d1T(0, 0, 1);
            var testPdt = offsetToAbsolute(pdt);

            Assert.AreEqual(TargetCoords[1].x, testPdt.x);
            Assert.AreEqual(TargetCoords[1].y, testPdt.y);
            Assert.AreEqual(1, testPdt.target);

            pdt.target = 2;
            pdt.x      = 1;
            pdt.y      = 1;
            testPdt    = offsetToAbsolute(pdt);
            Assert.AreEqual(TargetCoords[2].x + 1, testPdt.x);
            Assert.AreEqual(TargetCoords[2].y + k * 1, testPdt.y);
            Assert.AreEqual(2, testPdt.target);

            pdt.target = 3;
            pdt.x      = -12;
            pdt.y      = 0.12;
            testPdt    = offsetToAbsolute(pdt);
            Assert.AreEqual(TargetCoords[3].x - 12, testPdt.x);
            Assert.AreEqual(TargetCoords[3].y + k * 0.12, testPdt.y);
            Assert.AreEqual(3, testPdt.target);

            pdt.target = 4;
            pdt.x      = 78.521;
            pdt.y      = -0.000112;
            testPdt    = offsetToAbsolute(pdt);
            Assert.AreEqual(TargetCoords[4].x + 78.521, testPdt.x);
            Assert.AreEqual(TargetCoords[4].y - k * 0.000112, testPdt.y);
            Assert.AreEqual(4, testPdt.target);

            pdt.target = 5;
            pdt.x      = -78.521;
            pdt.y      = 0.000112;
            testPdt    = offsetToAbsolute(pdt);
            Assert.AreEqual(TargetCoords[5].x - 78.521, testPdt.x);
            Assert.AreEqual(TargetCoords[5].y + k * 0.000112, testPdt.y);
            Assert.AreEqual(5, testPdt.target);


            pdt.target = 6;
            Assert.ThrowsException <InvalidOperationException>(() => offsetToAbsolute(pdt));
        }
        public void offsetToAbsolute_Test2()
        {
            var emptyList = new List <Point2d1T> {
            };

            Assert.AreEqual(0, offsetToAbsolute(emptyList).Count());

            var p = new Point2d1T(0, 0, 1);

            p.target = -1;
            var testList = new List <Point2d1T> {
                p
            };

            //offsetToAbsolute(testList);
            Assert.ThrowsException <InvalidOperationException>(() => offsetToAbsolute(testList));

            var p1 = new Point2d1T(0, 0, 1);
            var p2 = new Point2d1T(1, 1, 2);
            var p3 = new Point2d1T(-12, 0.12, 3);
            var p4 = new Point2d1T(78.521, -0.000112, 4);
            var p5 = new Point2d1T(-78.521, 0.000112, 5);
            var q1 = new Point2d1T(TargetCoords[1].x, TargetCoords[1].y, 1);
            var q2 = new Point2d1T(TargetCoords[2].x + 1, TargetCoords[2].y + k * 1, 2);
            var q3 = new Point2d1T(TargetCoords[3].x - 12, TargetCoords[3].y + k * 0.12, 3);
            var q4 = new Point2d1T(TargetCoords[4].x + 78.521, TargetCoords[4].y - k * 0.000112, 4);
            var q5 = new Point2d1T(TargetCoords[5].x - 78.521, TargetCoords[5].y + k * 0.000112, 5);

            testList = new List <Point2d1T> {
                p1, p2, p3, p4, p5
            };
            var retList = offsetToAbsolute(testList).ToList();
            var ansList = new List <Point2d1T> {
                q1, q2, q3, q4, q5
            };

            for (int i = 0; i < 5; i++)
            {
                Assert.AreEqual(ansList[i].x, retList[i].x, "Error for retList[" + i.ToString() + "].x");
                Assert.AreEqual(ansList[i].y, retList[i].y, "Error for retList[" + i.ToString() + "].y");
                Assert.AreEqual(ansList[i].target, retList[i].target, "Error for retList[" + i.ToString() + "].target");
            }
        }