Example #1
0
    def test_union_polygons_overlap_partially(self):
        """Test the union method."""
        vertices = np.array([[180, 90, 0, -90],
                             [89, 89, 89, 89]]).T
        poly1 = SphPolygon(np.deg2rad(vertices))
        vertices = np.array([[-45, -135, 135, 45],
                             [89, 89, 89, 89]]).T
        poly2 = SphPolygon(np.deg2rad(vertices))

        uni = np.array([[157.5, 89.23460094],
                        [-225., 89.],
                        [112.5, 89.23460094],
                        [90., 89.],
                        [67.5, 89.23460094],
                        [45., 89.],
                        [22.5, 89.23460094],
                        [0., 89.],
                        [-22.5, 89.23460094],
                        [-45., 89.],
                        [-67.5, 89.23460094],
                        [-90., 89.],
                        [-112.5, 89.23460094],
                        [-135., 89.],
                        [-157.5, 89.23460094],
                        [-180., 89.]])

        poly_union = poly1.union(poly2)

        self.assertTrue(np.allclose(poly_union.vertices, np.deg2rad(uni)))
Example #2
0
    def test_union_polygons_overlaps_completely(self):
        """Test the union method when one polygon is entirely inside the other."""
        vertices = np.array([[1, 1, 20, 20], [1, 20, 20, 1]]).T

        poly1 = SphPolygon(np.deg2rad(vertices))

        vertices = np.array([[0, 0, 30, 30], [0, 30, 30, 0]]).T
        poly2 = SphPolygon(np.deg2rad(vertices))

        poly_union1 = poly1.union(poly2)
        poly_union2 = poly2.union(poly1)

        expected = np.deg2rad(np.array([[0, 0, 30, 30], [0, 30, 30, 0]]).T)

        np.testing.assert_allclose(poly_union1.vertices, expected)
        np.testing.assert_allclose(poly_union2.vertices, expected)
Example #3
0
    def test_bool(self):
        """Test the intersection and union functions."""
        vertices = np.array([[180, 90, 0, -90], [89, 89, 89, 89]]).T
        poly1 = SphPolygon(np.deg2rad(vertices))
        vertices = np.array([[-45, -135, 135, 45], [89, 89, 89, 89]]).T
        poly2 = SphPolygon(np.deg2rad(vertices))

        uni = np.array([[157.5, 89.23460094], [-225.,
                                               89.], [112.5, 89.23460094],
                        [90., 89.], [67.5, 89.23460094], [45., 89.],
                        [22.5, 89.23460094], [0., 89.], [-22.5, 89.23460094],
                        [-45., 89.], [-67.5, 89.23460094], [-90., 89.],
                        [-112.5, 89.23460094], [-135., 89.],
                        [-157.5, 89.23460094], [-180., 89.]])
        inter = np.array([[157.5, 89.23460094], [112.5, 89.23460094],
                          [67.5, 89.23460094], [22.5, 89.23460094],
                          [-22.5, 89.23460094], [-67.5, 89.23460094],
                          [-112.5, 89.23460094], [-157.5, 89.23460094]])
        poly_inter = poly1.intersection(poly2)
        poly_union = poly1.union(poly2)

        self.assertTrue(poly_inter.area() <= poly_union.area())

        self.assertTrue(np.allclose(poly_inter.vertices, np.deg2rad(inter)))
        self.assertTrue(np.allclose(poly_union.vertices, np.deg2rad(uni)))

        # Test 2 polygons sharing 2 contiguous edges.

        vertices1 = np.array([[-10, 10], [-5, 10], [0, 10], [5, 10], [10, 10],
                              [10, -10], [-10, -10]])

        vertices2 = np.array([[-5, 10], [0, 10], [5, 10], [5, -5], [-5, -5]])

        vertices3 = np.array([[5, 10], [5, -5], [-5, -5], [-5, 10], [0, 10]])

        poly1 = SphPolygon(np.deg2rad(vertices1))
        poly2 = SphPolygon(np.deg2rad(vertices2))
        poly_inter = poly1.intersection(poly2)

        self.assertTrue(np.allclose(poly_inter.vertices,
                                    np.deg2rad(vertices3)))

        # Test when last node of the intersection is the last vertice of the
        # second polygon.

        swath_vertices = np.array([[-115.32268301, 66.32946139],
                                   [-61.48397172, 58.56799254],
                                   [-60.25004314, 58.00754686],
                                   [-71.35057076, 49.60229517],
                                   [-113.746486, 56.03008985]])
        area_vertices = np.array([[-68.32812107, 52.3480829],
                                  [-67.84993896, 53.07015692],
                                  [-55.54651296, 64.9254637],
                                  [-24.63341856, 74.24628796],
                                  [-31.8996363, 27.99907764],
                                  [-39.581043, 37.0639821],
                                  [-50.90185988, 45.56296169],
                                  [-67.43022017, 52.12399581]])

        res = np.array([[-62.77837918,
                         59.12607053], [-61.48397172, 58.56799254],
                        [-60.25004314,
                         58.00754686], [-71.35057076, 49.60229517],
                        [-113.746486, 56.03008985],
                        [-115.32268301, 66.32946139]])

        poly1 = SphPolygon(np.deg2rad(swath_vertices))
        poly2 = SphPolygon(np.deg2rad(area_vertices))

        poly_inter = poly1.intersection(poly2)
        self.assertTrue(np.allclose(poly_inter.vertices, np.deg2rad(res)))

        poly_inter = poly2.intersection(poly1)
        self.assertTrue(np.allclose(poly_inter.vertices, np.deg2rad(res)))