Exemplo n.º 1
0
        public void LineAlgorithmsIntersectionTest()
        {
            // coinciding lines
            Coordinate         firstLineStart  = new Coordinate(1, 1);
            Coordinate         firstLineEnd    = new Coordinate(4, 1);
            Coordinate         secondLineStart = new Coordinate(1, 1);
            Coordinate         secondLineEnd   = new Coordinate(4, 1);
            IList <Coordinate> expectedResult  = new List <Coordinate> {
                new Coordinate(1, 1), new Coordinate(4, 1)
            };

            Assert.AreEqual(expectedResult, LineAlgorithms.Intersection(firstLineStart, firstLineEnd, secondLineStart, secondLineEnd));


            // lines intersecting in one point
            firstLineStart  = new Coordinate(1, 1);
            firstLineEnd    = new Coordinate(1, 4);
            secondLineStart = new Coordinate(4, 2);
            secondLineEnd   = new Coordinate(0, 2);
            expectedResult  = new List <Coordinate> {
                new Coordinate(1, 2)
            };
            Assert.AreEqual(expectedResult, LineAlgorithms.Intersection(firstLineStart, firstLineEnd, secondLineStart, secondLineEnd));

            firstLineStart  = new Coordinate(-1, 6);
            firstLineEnd    = new Coordinate(1, 2);
            secondLineStart = new Coordinate(4, 0);
            secondLineEnd   = new Coordinate(0, 4);
            expectedResult  = new List <Coordinate> {
                new Coordinate(0, 4)
            };

            Assert.AreEqual(expectedResult, LineAlgorithms.Intersection(firstLineStart, firstLineEnd, secondLineStart, secondLineEnd));
            firstLineStart  = new Coordinate(2, 2);
            firstLineEnd    = new Coordinate(2, 2);
            secondLineStart = new Coordinate(2, 2);
            secondLineEnd   = new Coordinate(2, 2);
            expectedResult  = new List <Coordinate> {
                new Coordinate(2, 2)
            };
            Assert.AreEqual(expectedResult, LineAlgorithms.Intersection(firstLineStart, firstLineEnd, secondLineStart, secondLineEnd));


            // lines intersecting in more than one point
            firstLineStart  = new Coordinate(2, 2);
            firstLineEnd    = new Coordinate(2, 8);
            secondLineStart = new Coordinate(2, 5);
            secondLineEnd   = new Coordinate(2, 10);
            expectedResult  = new List <Coordinate> {
                new Coordinate(2, 5), new Coordinate(2, 8)
            };
            Assert.AreEqual(expectedResult, LineAlgorithms.Intersection(firstLineStart, firstLineEnd, secondLineStart, secondLineEnd));

            firstLineStart  = new Coordinate(4, 1);
            firstLineEnd    = new Coordinate(1, 4);
            secondLineStart = new Coordinate(3, 2);
            secondLineEnd   = new Coordinate(2, 3);
            expectedResult  = new List <Coordinate> {
                new Coordinate(3, 2), new Coordinate(2, 3)
            };
            Assert.AreEqual(expectedResult, LineAlgorithms.Intersection(firstLineStart, firstLineEnd, secondLineStart, secondLineEnd));


            // parallel lines
            firstLineStart  = new Coordinate(1.3, 1.3);
            firstLineEnd    = new Coordinate(1.3, 4.3);
            secondLineStart = new Coordinate(2.3, 1.3);
            secondLineEnd   = new Coordinate(2.3, 4.3);
            expectedResult  = new List <Coordinate> {
            };
            Assert.AreEqual(expectedResult, LineAlgorithms.Intersection(firstLineStart, firstLineEnd, secondLineStart, secondLineEnd));


            // not intersecting lines
            firstLineStart  = new Coordinate(2, 2);
            firstLineEnd    = new Coordinate(2, 8);
            secondLineStart = new Coordinate(2.1, 1);
            secondLineEnd   = new Coordinate(10, 8);
            expectedResult  = new List <Coordinate> {
            };
            Assert.AreEqual(expectedResult, LineAlgorithms.Intersection(firstLineStart, firstLineEnd, secondLineStart, secondLineEnd));


            // coinciding infinite lines
            firstLineStart = new Coordinate(2, 4);
            CoordinateVector firstVector = new CoordinateVector(0, 1);

            secondLineStart = new Coordinate(2, 5);
            CoordinateVector secondVector = new CoordinateVector(0, 4);

            Assert.AreEqual(new Coordinate(2, 4), LineAlgorithms.Intersection(firstLineStart, firstVector, secondLineStart, secondVector));


            // intersecting infinite lines
            firstLineStart  = new Coordinate(1, 2);
            firstVector     = new CoordinateVector(1, -2);
            secondLineStart = new Coordinate(4, 0);
            secondVector    = new CoordinateVector(1, -1);
            Assert.AreEqual(new Coordinate(0, 4), LineAlgorithms.Intersection(firstLineStart, firstVector, secondLineStart, secondVector));

            firstLineStart  = new Coordinate(1, 1);
            firstVector     = new CoordinateVector(0, 1);
            secondLineStart = new Coordinate(1, 1);
            secondVector    = new CoordinateVector(1, 0);
            Assert.AreEqual(new Coordinate(1, 1), LineAlgorithms.Intersection(firstLineStart, firstVector, secondLineStart, secondVector));


            // not intersecting infinite lines
            firstLineStart  = new Coordinate(1, 1);
            firstVector     = new CoordinateVector(0, 1);
            secondLineStart = new Coordinate(2, 2);
            secondVector    = new CoordinateVector(0, 1);
            Assert.IsFalse(LineAlgorithms.Intersection(firstLineStart, firstVector, secondLineStart, secondVector).IsValid);


            // internally intersecting lines
            firstLineStart  = new Coordinate(1, 4);
            firstLineEnd    = new Coordinate(4, 1);
            secondLineStart = new Coordinate(3, 2);
            secondLineEnd   = new Coordinate(2, 3);
            expectedResult  = new List <Coordinate> {
                new Coordinate(3, 2), new Coordinate(2, 3)
            };
            Assert.AreEqual(expectedResult, LineAlgorithms.InternalIntersection(firstLineStart, firstLineEnd, secondLineStart, secondLineEnd));

            firstLineStart  = new Coordinate(1, 4);
            firstLineEnd    = new Coordinate(4, 1);
            secondLineStart = new Coordinate(1, 2);
            secondLineEnd   = new Coordinate(200, 2);
            expectedResult  = new List <Coordinate> {
                new Coordinate(3, 2)
            };
            Assert.AreEqual(expectedResult, LineAlgorithms.InternalIntersection(firstLineStart, firstLineEnd, secondLineStart, secondLineEnd));

            firstLineStart  = new Coordinate(10.58, 4);
            firstLineEnd    = new Coordinate(4, 1);
            secondLineStart = new Coordinate(10.58, 4);
            secondLineEnd   = new Coordinate(4, 1);
            expectedResult  = new List <Coordinate> {
                new Coordinate(10.58, 4), new Coordinate(4, 1)
            };
            Assert.AreEqual(expectedResult, LineAlgorithms.InternalIntersection(firstLineStart, firstLineEnd, secondLineStart, secondLineEnd));


            // not internally intersecting lines
            firstLineStart  = new Coordinate(1, 1);
            firstLineEnd    = new Coordinate(10, 1);
            secondLineStart = new Coordinate(1, 4);
            secondLineEnd   = new Coordinate(1, 1);
            expectedResult  = new List <Coordinate> {
            };
            Assert.AreEqual(expectedResult, LineAlgorithms.InternalIntersection(firstLineStart, firstLineEnd, secondLineStart, secondLineEnd));


            // intersecting lines with fixed precision
            PrecisionModel precision = new PrecisionModel(0.001);

            firstLineStart  = new Coordinate(1000, 1000);
            firstLineEnd    = new Coordinate(1000, 4000);
            secondLineStart = new Coordinate(4000, 2000);
            secondLineEnd   = new Coordinate(-2000, 1000);
            expectedResult  = new List <Coordinate> {
                new Coordinate(1000, 2000)
            };
            Assert.AreEqual(expectedResult, LineAlgorithms.Intersection(firstLineStart, firstLineEnd, secondLineStart, secondLineEnd, precision));

            secondLineEnd  = new Coordinate(-2000, 0);
            expectedResult = new List <Coordinate> {
                new Coordinate(1000, 1000)
            };
            Assert.AreEqual(expectedResult, LineAlgorithms.Intersection(firstLineStart, firstLineEnd, secondLineStart, secondLineEnd, precision));
        }
Exemplo n.º 2
0
        public void LineAlgorithmsIntersectionTest()
        {
            // coinciding lines
            Coordinate   firstLineStart  = new Coordinate(1, 1);
            Coordinate   firstLineEnd    = new Coordinate(4, 1);
            Coordinate   secondLineStart = new Coordinate(1, 1);
            Coordinate   secondLineEnd   = new Coordinate(4, 1);
            Intersection intersection    = LineAlgorithms.Intersection(firstLineStart, firstLineEnd, secondLineStart, secondLineEnd);

            intersection.Type.ShouldBe(IntersectionType.Interval);
            intersection.Start.ShouldBe(new Coordinate(1, 1));
            intersection.End.ShouldBe(new Coordinate(4, 1));

            // lines intersecting in one point
            firstLineStart  = new Coordinate(1, 1);
            firstLineEnd    = new Coordinate(1, 4);
            secondLineStart = new Coordinate(4, 2);
            secondLineEnd   = new Coordinate(0, 2);
            intersection    = LineAlgorithms.Intersection(firstLineStart, firstLineEnd, secondLineStart, secondLineEnd);
            intersection.Type.ShouldBe(IntersectionType.Coordinate);
            intersection.Coordinate.ShouldBe(new Coordinate(1, 2));

            firstLineStart  = new Coordinate(0, 0);
            firstLineEnd    = new Coordinate(10, 0);
            secondLineStart = new Coordinate(0, 0);
            secondLineEnd   = new Coordinate(0, 3);
            intersection    = LineAlgorithms.Intersection(firstLineStart, firstLineEnd, secondLineStart, secondLineEnd);
            intersection.Type.ShouldBe(IntersectionType.Coordinate);
            intersection.Coordinate.ShouldBe(new Coordinate(0, 0));

            firstLineStart  = new Coordinate(-1, 6);
            firstLineEnd    = new Coordinate(1, 2);
            secondLineStart = new Coordinate(4, 0);
            secondLineEnd   = new Coordinate(0, 4);
            intersection    = LineAlgorithms.Intersection(firstLineStart, firstLineEnd, secondLineStart, secondLineEnd);
            intersection.Type.ShouldBe(IntersectionType.Coordinate);
            intersection.Coordinate.ShouldBe(new Coordinate(0, 4));

            firstLineStart  = new Coordinate(2, 2);
            firstLineEnd    = new Coordinate(2, 2);
            secondLineStart = new Coordinate(2, 2);
            secondLineEnd   = new Coordinate(2, 2);
            intersection    = LineAlgorithms.Intersection(firstLineStart, firstLineEnd, secondLineStart, secondLineEnd);
            intersection.Type.ShouldBe(IntersectionType.Coordinate);
            intersection.Coordinate.ShouldBe(new Coordinate(2, 2));

            // lines intersecting in more than one point
            firstLineStart  = new Coordinate(2, 2);
            firstLineEnd    = new Coordinate(2, 8);
            secondLineStart = new Coordinate(2, 5);
            secondLineEnd   = new Coordinate(2, 10);
            intersection    = LineAlgorithms.Intersection(firstLineStart, firstLineEnd, secondLineStart, secondLineEnd);
            intersection.Type.ShouldBe(IntersectionType.Interval);
            intersection.Start.ShouldBe(new Coordinate(2, 5));
            intersection.End.ShouldBe(new Coordinate(2, 8));

            firstLineStart  = new Coordinate(4, 1);
            firstLineEnd    = new Coordinate(1, 4);
            secondLineStart = new Coordinate(3, 2);
            secondLineEnd   = new Coordinate(2, 3);
            intersection    = LineAlgorithms.Intersection(firstLineStart, firstLineEnd, secondLineStart, secondLineEnd);
            intersection.Type.ShouldBe(IntersectionType.Interval);
            intersection.Start.ShouldBe(new Coordinate(3, 2));
            intersection.End.ShouldBe(new Coordinate(2, 3));

            firstLineStart  = new Coordinate(2, 8);
            firstLineEnd    = new Coordinate(6, 8);
            secondLineStart = new Coordinate(0, 8);
            secondLineEnd   = new Coordinate(8, 8);
            intersection    = LineAlgorithms.Intersection(firstLineStart, firstLineEnd, secondLineStart, secondLineEnd);
            intersection.Type.ShouldBe(IntersectionType.Interval);
            intersection.Start.ShouldBe(new Coordinate(2, 8));
            intersection.End.ShouldBe(new Coordinate(6, 8));

            // parallel lines
            firstLineStart  = new Coordinate(1.3, 1.3);
            firstLineEnd    = new Coordinate(1.3, 4.3);
            secondLineStart = new Coordinate(2.3, 1.3);
            secondLineEnd   = new Coordinate(2.3, 4.3);
            LineAlgorithms.Intersection(firstLineStart, firstLineEnd, secondLineStart, secondLineEnd).ShouldBeNull();

            // not intersecting lines
            firstLineStart  = new Coordinate(2, 2);
            firstLineEnd    = new Coordinate(2, 8);
            secondLineStart = new Coordinate(2.1, 1);
            secondLineEnd   = new Coordinate(10, 8);
            LineAlgorithms.Intersection(firstLineStart, firstLineEnd, secondLineStart, secondLineEnd).ShouldBeNull();

            // coinciding infinite lines
            firstLineStart = new Coordinate(2, 4);
            CoordinateVector firstVector = new CoordinateVector(0, 1);

            secondLineStart = new Coordinate(2, 5);
            CoordinateVector secondVector = new CoordinateVector(0, 4);

            intersection = LineAlgorithms.Intersection(firstLineStart, firstVector, secondLineStart, secondVector);
            intersection.Type.ShouldBe(IntersectionType.Coordinate);
            intersection.Coordinate.ShouldBe(new Coordinate(2, 4));

            // intersecting infinite lines
            firstLineStart  = new Coordinate(1, 2);
            firstVector     = new CoordinateVector(1, -2);
            secondLineStart = new Coordinate(4, 0);
            secondVector    = new CoordinateVector(1, -1);
            intersection    = LineAlgorithms.Intersection(firstLineStart, firstVector, secondLineStart, secondVector);
            intersection.Type.ShouldBe(IntersectionType.Coordinate);
            intersection.Coordinate.ShouldBe(new Coordinate(0, 4));

            firstLineStart  = new Coordinate(1, 1);
            firstVector     = new CoordinateVector(0, 1);
            secondLineStart = new Coordinate(1, 1);
            secondVector    = new CoordinateVector(1, 0);
            intersection    = LineAlgorithms.Intersection(firstLineStart, firstVector, secondLineStart, secondVector);
            intersection.Type.ShouldBe(IntersectionType.Coordinate);
            intersection.Coordinate.ShouldBe(new Coordinate(1, 1));

            // not intersecting infinite lines
            firstLineStart  = new Coordinate(1, 1);
            firstVector     = new CoordinateVector(0, 1);
            secondLineStart = new Coordinate(2, 2);
            secondVector    = new CoordinateVector(0, 1);
            LineAlgorithms.Intersection(firstLineStart, firstVector, secondLineStart, secondVector).ShouldBeNull();

            // internally intersecting lines
            firstLineStart  = new Coordinate(1, 4);
            firstLineEnd    = new Coordinate(4, 1);
            secondLineStart = new Coordinate(3, 2);
            secondLineEnd   = new Coordinate(2, 3);
            intersection    = LineAlgorithms.InternalIntersection(firstLineStart, firstLineEnd, secondLineStart, secondLineEnd);
            intersection.Type.ShouldBe(IntersectionType.Interval);
            intersection.Start.ShouldBe(new Coordinate(3, 2));
            intersection.End.ShouldBe(new Coordinate(2, 3));

            firstLineStart  = new Coordinate(1, 4);
            firstLineEnd    = new Coordinate(4, 1);
            secondLineStart = new Coordinate(1, 2);
            secondLineEnd   = new Coordinate(200, 2);
            intersection    = LineAlgorithms.InternalIntersection(firstLineStart, firstLineEnd, secondLineStart, secondLineEnd);
            intersection.Type.ShouldBe(IntersectionType.Coordinate);
            intersection.Coordinate.ShouldBe(new Coordinate(3, 2));

            firstLineStart  = new Coordinate(10.58, 4);
            firstLineEnd    = new Coordinate(4, 1);
            secondLineStart = new Coordinate(10.58, 4);
            secondLineEnd   = new Coordinate(4, 1);
            intersection    = LineAlgorithms.InternalIntersection(firstLineStart, firstLineEnd, secondLineStart, secondLineEnd);
            intersection.Type.ShouldBe(IntersectionType.Interval);
            intersection.Start.ShouldBe(new Coordinate(10.58, 4));
            intersection.End.ShouldBe(new Coordinate(4, 1));

            // not internally intersecting lines
            firstLineStart  = new Coordinate(1, 1);
            firstLineEnd    = new Coordinate(10, 1);
            secondLineStart = new Coordinate(1, 4);
            secondLineEnd   = new Coordinate(1, 1);
            LineAlgorithms.InternalIntersection(firstLineStart, firstLineEnd, secondLineStart, secondLineEnd).ShouldBeNull();

            // intersecting lines with fixed precision
            PrecisionModel precisionModel = new PrecisionModel(0.001);

            firstLineStart  = new Coordinate(1000, 1000);
            firstLineEnd    = new Coordinate(1000, 4000);
            secondLineStart = new Coordinate(4000, 2000);
            secondLineEnd   = new Coordinate(-2000, 1000);
            intersection    = LineAlgorithms.Intersection(firstLineStart, firstLineEnd, secondLineStart, secondLineEnd, precisionModel);
            intersection.Type.ShouldBe(IntersectionType.Coordinate);
            intersection.Coordinate.ShouldBe(new Coordinate(1000, 2000));

            secondLineEnd = new Coordinate(-2000, 0);
            intersection  = LineAlgorithms.Intersection(firstLineStart, firstLineEnd, secondLineStart, secondLineEnd, precisionModel);
            intersection.Type.ShouldBe(IntersectionType.Coordinate);
            intersection.Coordinate.ShouldBe(new Coordinate(1000, 1000));
        }