/// <summary>
        /// Сравнивает результаты полученные с помощью работы алгоритма для сферы,
        /// с результатами полученными с помощью алгоритма эллипсоида
        /// </summary>
        private void EllipsoidSpheroidCompare(Point point1, Point point2)
        {
            var directProblemService  = new DirectProblemService(new Spheroid());
            var inverseProblemService = new InverseProblemService(new Spheroid());

            PrivateObject distance    = new PrivateObject(inverseProblemService);
            PrivateObject coordinates = new PrivateObject(directProblemService);

            // Решение обратной задачи
            var byEllipsoidInverse =
                (InverseProblemAnswer)distance.Invoke("OrthodromicEllipsoidDistance", point1, point2);
            var bySpheroidInverse =
                (InverseProblemAnswer)distance.Invoke("OrthodromicSpheroidDistance", point1, point2);

            Assert.AreEqual(byEllipsoidInverse.Distance, bySpheroidInverse.Distance, 0.0006); // 0.06 мм
            Assert.AreEqual(byEllipsoidInverse.ForwardAzimuth, bySpheroidInverse.ForwardAzimuth, 0.000000001);
            Assert.AreEqual(byEllipsoidInverse.ReverseAzimuth, bySpheroidInverse.ReverseAzimuth, 0.000000001);

            // Решение прямой задачи
            var byEllipsoidDirect =
                (DirectProblemAnswer)
                coordinates.Invoke("DirectProblemEllipsoid", point1, byEllipsoidInverse.ForwardAzimuth,
                                   byEllipsoidInverse.Distance);
            var bySpheroidDirect =
                (DirectProblemAnswer)
                coordinates.Invoke("DirectProblemSpheroid", point1, bySpheroidInverse.ForwardAzimuth,
                                   bySpheroidInverse.Distance);

            Assert.AreEqual(byEllipsoidDirect.ReverseAzimuth, bySpheroidDirect.ReverseAzimuth, 0.000000001);
            Assert.AreEqual(byEllipsoidDirect.Сoordinate.Latitude, bySpheroidDirect.Сoordinate.Latitude, 0.000000001);
            Assert.AreEqual(byEllipsoidDirect.Сoordinate.Longitude, bySpheroidDirect.Сoordinate.Longitude, 0.000000001);
        }
Example #2
0
        /// <summary>
        /// Тестирование решения прямой и обратной задач
        /// </summary>
        /// <remarks>
        /// Тест состоит из нескольких частей:
        ///     1. Задаются координаты между которыми рассчитывается ортодромическая дистанция и определяется азимут
        ///         - решается обратная геодезическая задача
        ///     2. По первой координате, дистанции и прямому направлению (азимуту) находим вторую координату
        ///         - решается прямая геодезическая задача
        ///     3. Выполняется проверка
        ///         - вторая координата из условий обратной задачи должна совпасть с координатой из решения прямой задачи,
        ///         - обратный азимут из решения обратной задачи, должен совпадать с обратным азимутом из решения прямой задачи
        ///     4. По второй координате, дистанции и обратному направлению (азимуту) находим первую координату
        ///         - решаетая прямая геодезическая задача
        ///     5. Выполняется проверка
        ///         - первая координата из условий обратной задачи должна совпасть с координатой из решения прямой задачи
        ///         - прямой азимут из решения обратной задачи, должен совпадать с обратным азимутом из решения прямой задачи
        /// </remarks>
        public override void Tests(Point point1, Point point2, IEllipsoid ellipsoid)
        {
            var inverseProblemService = new InverseProblemService(ellipsoid);
            var directProblemService  = new DirectProblemService(ellipsoid);

            // Решение обратной задачи
            var inverseAnswer = inverseProblemService.OrthodromicDistance(point1, point2);

            // Решение прямой задачи 1
            var directAnswerForward = directProblemService.DirectProblem(point1,
                                                                         inverseAnswer.ForwardAzimuth, inverseAnswer.Distance);
            var distance1 =
                inverseProblemService.OrthodromicDistance(
                    new Point(directAnswerForward.Сoordinate.Longitude, directAnswerForward.Сoordinate.Latitude),
                    point2).Distance;

            Assert.AreEqual(distance1, 0, 0.0006); // 0.06 мм
            Assert.AreEqual(directAnswerForward.Сoordinate.Longitude, point2.Longitude, 0.000000001);
            Assert.AreEqual(directAnswerForward.Сoordinate.Latitude, point2.Latitude, 0.000000001);
            Assert.AreEqual(inverseAnswer.ReverseAzimuth, directAnswerForward.ReverseAzimuth, 0.000000001);

            // Решение прямой задачи 2
            var directAnswerReverse = directProblemService.DirectProblem(point2,
                                                                         inverseAnswer.ReverseAzimuth, inverseAnswer.Distance);
            var distance2 =
                inverseProblemService.OrthodromicDistance(
                    new Point(directAnswerReverse.Сoordinate.Longitude, directAnswerReverse.Сoordinate.Latitude),
                    point1)
                .Distance;

            Assert.AreEqual(distance2, 0, 0.0006); // 0.06 мм
            Assert.AreEqual(directAnswerReverse.Сoordinate.Longitude, point1.Longitude, 0.000000001);
            Assert.AreEqual(directAnswerReverse.Сoordinate.Latitude, point1.Latitude, 0.000000001);
            Assert.AreEqual(inverseAnswer.ForwardAzimuth, directAnswerReverse.ReverseAzimuth, 0.000000001);
        }
        /// <summary>
        /// Тестируется правильность вычисления точки пересечения двух ортодром
        /// </summary>
        /// <remarks>
        /// Методика тестирования следующая:
        ///     - находим координаты точки пересечения двух ортодром заданных начальной и конечной координатой
        ///     - решаем обратную геодезическую задачу для обоих ортодром - определяем прямой азимут
        ///     - решаем обратную геодезическую задачу от начальной точки до найденной точки пересечения (для обоих ортодром)
        ///     - сравниваем азимуты, если точка пересечения найдена верно, азимуты не должны поменяться
        /// </remarks>
        public void Tests(Point point1, Point point2, Point point3, Point point4, IEllipsoid ellipsoid)
        {
            var intersectService      = new IntersectService(ellipsoid);
            var inverseProblemService = new InverseProblemService(ellipsoid);

            var intersectCoord = intersectService.IntersectOrthodromic(point1, point2, point3, point4);

            var firstOrtodrom  = inverseProblemService.OrthodromicDistance(point1, point2);
            var secondOrtodrom = inverseProblemService.OrthodromicDistance(point3, point4);

            var firstOrtodrom2 = inverseProblemService.OrthodromicDistance(point1, new Point(intersectCoord.Longitude,
                                                                                             intersectCoord.Latitude));
            var secondOrtodrom2 = inverseProblemService.OrthodromicDistance(point3, new Point(intersectCoord.Longitude,
                                                                                              intersectCoord.Latitude));

            Assert.AreEqual(firstOrtodrom.ForwardAzimuth, firstOrtodrom2.ForwardAzimuth, 0.00000001);
            Assert.AreEqual(secondOrtodrom.ForwardAzimuth, secondOrtodrom2.ForwardAzimuth, 0.00000001);
        }
Example #4
0
        /// <summary>
        /// Тестируется правильность определения азимута
        /// </summary>
        /// <remarks>
        /// Первый критерий правильности определения азимута таков:
        ///     - сначала решается обратная геодезическая задача для определения азимута из первой точки до второй
        ///     - затем решается обратная геодезическая задача для определения азимута из второй точки до первой
        ///     - сравниваются прямые и обратные азимуты двух решений
        /// Второй критерий:
        ///     - сначала решается обратная геодезическая задача для определения азимута и дистанции
        ///     - из первой точки по заданной дистанции мы решаем прямую геодезическую задача: должны попасть во вторую точку
        ///     - и наоборот
        /// </remarks>
        public override void Tests(Point point1, Point point2, IEllipsoid ellipsoid)
        {
            var inverseProblemService = new InverseProblemService(ellipsoid);
            var directProblemService  = new DirectProblemService(ellipsoid);

            var answer1 = inverseProblemService.OrthodromicDistance(point1, point2);
            var answer2 = inverseProblemService.OrthodromicDistance(point2, point1);

            Assert.AreEqual(answer1.ForwardAzimuth, answer2.ReverseAzimuth, 0.000000001);
            Assert.AreEqual(answer1.ReverseAzimuth, answer2.ForwardAzimuth, 0.000000001);

            var answerPoint1 = directProblemService.DirectProblem(point1, answer1.ForwardAzimuth, answer1.Distance);

            Assert.AreEqual(point2.Latitude, answerPoint1.Сoordinate.Latitude, 0.000000001);
            Assert.AreEqual(point2.Longitude, answerPoint1.Сoordinate.Longitude, 0.000000001);

            var answerPoint2 = directProblemService.DirectProblem(point2, answer2.ForwardAzimuth, answer2.Distance);

            Assert.AreEqual(point1.Latitude, answerPoint2.Сoordinate.Latitude, 0.000000001);
            Assert.AreEqual(point1.Longitude, answerPoint2.Сoordinate.Longitude, 0.000000001);
        }
        public override void Tests(Point point1, Point point2, IEllipsoid ellipsoid)
        {
            var intermediatePointService = new IntermediatePointService(ellipsoid);
            var inverseProblemService    = new InverseProblemService(ellipsoid);

            if (Math.Abs(point1.Latitude - point2.Latitude) < 0.000000001 ||
                Math.Abs(point1.Longitude - point2.Longitude) < 0.000000001)
            {
                return;
            }

            // По серёдке возьмём
            var lat = (point1.Latitude + point2.Latitude) / 2;

            var iLon = intermediatePointService.GetLongitude(lat, point1, point2);
            var iLat = intermediatePointService.GetLatitude(iLon, point1, point2);

            // Сравнить изначальную широту, и получившуюся в результате рассчётов
            Assert.AreEqual(lat, iLat, 0.000000001);

            // Рассчитанная долгота должна быть между двух координат,
            //  кроме случая когда пересекает 180ый меридиан
            if (Math.Abs(point1.Longitude) + Math.Abs(point2.Longitude) < 180 && point2.Longitude * point1.Longitude < 0)
            {
                Assert.IsTrue(iLon >= point1.Longitude && iLon <= point2.Longitude ||
                              iLon <= point1.Longitude && iLon >= point2.Longitude);
            }


            // Точка должна лежать точно на линии,
            //  значит при решении обратной геодезической задачи азимут не должен измениться
            var answer1 = inverseProblemService.OrthodromicDistance(point1, point2);
            var answer2 = inverseProblemService.OrthodromicDistance(point1, new Point(iLon, iLat));

            Assert.AreEqual(answer1.ForwardAzimuth, answer2.ForwardAzimuth, 0.0000001, answer1.ToString());
        }
Example #6
0
        public double TestsAzimuth(Point point1, Point point2, IEllipsoid ellipsoid)
        {
            var inverseProblemService = new InverseProblemService(ellipsoid);

            return(inverseProblemService.OrthodromicDistance(point1, point2).ForwardAzimuth);
        }