def _get_swathsegment(filelist, time_start, time_end=None, area=None):
"""
Return only the granule files for the time interval or area.
"""
if area is not None:
from trollsched.spherical import SphPolygon
from trollsched.boundary import AreaBoundary
lons, lats = area.get_boundary_lonlats()
area_boundary = AreaBoundary((lons.side1, lats.side1),
(lons.side2, lats.side2),
(lons.side3, lats.side3),
(lons.side4, lats.side4))
area_boundary.decimate(500)
contour_poly = area_boundary.contour_poly
segment_files = []
for filename in filelist:
timetup = _get_times_from_npp(filename)
# Search for multiple granules using an area
if area is not None:
md = NPPMetaData(filename)
md.read()
coords = np.vstack(md.get_ring_lonlats())
poly = SphPolygon(np.deg2rad(coords))
if poly.intersection(contour_poly) is not None:
segment_files.append(filename)
continue
# Search for single granule using time start
if time_end is None:
if time_start >= timetup[0] and time_start <= timetup[1]:
segment_files.append(filename)
continue
# search for multiple granules
else:
# check that granule start time is inside interval
if timetup[0] >= time_start and timetup[0] <= time_end:
segment_files.append(filename)
continue
# check that granule end time is inside interval
if timetup[1] >= time_start and timetup[1] <= time_end:
segment_files.append(filename)
continue
segment_files.sort()
return segment_files
def _get_swathsegment(filelist, time_start, time_end=None, area=None):
"""
Return only the granule files for the time interval or area.
"""
if area is not None:
from trollsched.spherical import SphPolygon
from trollsched.boundary import AreaBoundary
lons, lats = area.get_boundary_lonlats()
area_boundary = AreaBoundary(
(lons.side1, lats.side1), (lons.side2, lats.side2),
(lons.side3, lats.side3), (lons.side4, lats.side4))
area_boundary.decimate(500)
contour_poly = area_boundary.contour_poly
segment_files = []
for filename in filelist:
timetup = _get_times_from_npp(filename)
# Search for multiple granules using an area
if area is not None:
md = NPPMetaData(filename)
md.read()
coords = np.vstack(md.get_ring_lonlats())
poly = SphPolygon(np.deg2rad(coords))
if poly.intersection(contour_poly) is not None:
segment_files.append(filename)
continue
# Search for single granule using time start
if time_end is None:
if time_start >= timetup[0] and time_start <= timetup[1]:
segment_files.append(filename)
continue
# search for multiple granules
else:
# check that granule start time is inside interval
if timetup[0] >= time_start and timetup[0] <= time_end:
segment_files.append(filename)
continue
# check that granule end time is inside interval
if timetup[1] >= time_start and timetup[1] <= time_end:
segment_files.append(filename)
continue
segment_files.sort()
return segment_files
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)))
def test_is_inside(self):
"""Test checking if a polygon is inside of another.
"""
vertices = np.array([[1, 1, 20, 20],
[1, 20, 20, 1]]).T
polygon1 = SphPolygon(np.deg2rad(vertices))
vertices = np.array([[0, 0, 30, 30],
[0, 30, 30, 0]]).T
polygon2 = SphPolygon(np.deg2rad(vertices))
self.assertTrue(polygon1._is_inside(polygon2))
self.assertFalse(polygon2._is_inside(polygon1))
self.assertTrue(polygon2.area() > polygon1.area())
polygon2.invert()
self.assertFalse(polygon1._is_inside(polygon2))
self.assertFalse(polygon2._is_inside(polygon1))
vertices = np.array([[0, 0, 30, 30],
[21, 30, 30, 21]]).T
polygon2 = SphPolygon(np.deg2rad(vertices))
self.assertFalse(polygon1._is_inside(polygon2))
self.assertFalse(polygon2._is_inside(polygon1))
polygon2.invert()
self.assertTrue(polygon1._is_inside(polygon2))
self.assertFalse(polygon2._is_inside(polygon1))
vertices = np.array([[100, 100, 130, 130],
[41, 50, 50, 41]]).T
polygon2 = SphPolygon(np.deg2rad(vertices))
self.assertFalse(polygon1._is_inside(polygon2))
self.assertFalse(polygon2._is_inside(polygon1))
polygon2.invert()
self.assertTrue(polygon1._is_inside(polygon2))
self.assertFalse(polygon2._is_inside(polygon1))
vertices = np.array([[-1.54009253, 82.62402855],
[3.4804808, 82.8105746],
[20.7214892, 83.00875812],
[32.8857629, 82.7607758],
[41.53844302, 82.36024339],
[47.92062759, 81.91317164],
[52.82785062, 81.45769791],
[56.75107895, 81.00613046],
[59.99843787, 80.56042986],
[62.76998034, 80.11814453],
[65.20076209, 79.67471372],
[67.38577498, 79.22428],
[69.39480149, 78.75981318],
[71.28163984, 78.27283234],
[73.09016378, 77.75277976],
[74.85864685, 77.18594725],
[76.62327682, 76.55367303],
[78.42162204, 75.82918893],
[80.29698409, 74.97171721],
[82.30538638, 73.9143231],
[84.52973107, 72.53535661],
[87.11696138, 70.57600156],
[87.79163209, 69.98712409],
[72.98142447, 67.1760143],
[61.79517279, 63.2846272],
[53.50600609, 58.7098766],
[47.26725347, 53.70533139],
[42.44083259, 48.42199571],
[38.59682041, 42.95008531],
[35.45189206, 37.3452509],
[32.43435578, 30.72373327],
[31.73750748, 30.89485287],
[29.37284023, 31.44344415],
[27.66001308, 31.81016309],
[26.31358296, 32.08057499],
[25.1963477, 32.29313986],
[24.23118049, 32.46821821],
[23.36993508, 32.61780082],
[22.57998837, 32.74952569],
[21.8375532, 32.86857867],
[21.12396693, 32.97868717],
[20.42339605, 33.08268331],
[19.72121983, 33.18284728],
[19.00268283, 33.28113306],
[18.2515215, 33.3793305],
[17.4482606, 33.47919405],
[16.56773514, 33.58255576],
[15.57501961, 33.6914282],
[14.4180087, 33.8080799],
[13.01234319, 33.93498577],
[11.20625437, 34.0742239],
[8.67990371, 34.22415978],
[7.89344478, 34.26018768],
[8.69446485, 41.19823568],
[9.25707165, 47.17351118],
[9.66283477, 53.14128114],
[9.84134875, 59.09937166],
[9.65054241, 65.04458004],
[8.7667375, 70.97023122],
[6.28280904, 76.85731403]])
polygon1 = SphPolygon(np.deg2rad(vertices))
vertices = np.array([[49.94506701, 46.52610743],
[51.04293649, 46.52610743],
[62.02163129, 46.52610743],
[73.0003261, 46.52610743],
[83.9790209, 46.52610743],
[85.05493299, 46.52610743],
[85.05493299, 45.76549301],
[85.05493299, 37.58315571],
[85.05493299, 28.39260587],
[85.05493299, 18.33178739],
[85.05493299, 17.30750918],
[83.95706351, 17.30750918],
[72.97836871, 17.30750918],
[61.9996739, 17.30750918],
[51.0209791, 17.30750918],
[49.94506701, 17.30750918],
[49.94506701, 18.35262921],
[49.94506701, 28.41192025],
[49.94506701, 37.60055422],
[49.94506701, 45.78080831]])
polygon2 = SphPolygon(np.deg2rad(vertices))
self.assertFalse(polygon2._is_inside(polygon1))
self.assertFalse(polygon1._is_inside(polygon2))
def test_area(self):
"""Test the area function
"""
vertices = np.array([[1, 2, 3, 4, 3, 2],
[3, 4, 3, 2, 1, 2]]).T
polygon = SphPolygon(np.deg2rad(vertices))
self.assertAlmostEqual(0.00121732523118, polygon.area())
vertices = np.array([[1, 2, 3, 2],
[3, 4, 3, 2]]).T
polygon = SphPolygon(np.deg2rad(vertices))
self.assertAlmostEqual(0.000608430665842, polygon.area())
vertices = np.array([[0, 0, 1, 1],
[0, 1, 1, 0]]).T
polygon = SphPolygon(np.deg2rad(vertices))
self.assertAlmostEqual(0.000304609684862, polygon.area())
# Across the dateline
vertices = np.array([[179.5, -179.5, -179.5, 179.5],
[1, 1, 0, 0]]).T
polygon = SphPolygon(np.deg2rad(vertices))
self.assertAlmostEqual(0.000304609684862, polygon.area())
vertices = np.array([[0, 90, 90, 0],
[1, 1, 0, 0]]).T
polygon = SphPolygon(np.deg2rad(vertices))
self.assertAlmostEqual(0.0349012696772, polygon.area())
vertices = np.array([[90, 0, 0],
[0, 0, 90]]).T
polygon = SphPolygon(np.deg2rad(vertices))
self.assertAlmostEqual(np.pi / 2, polygon.area())
# Around the north pole
vertices = np.array([[0, -90, 180, 90],
[89, 89, 89, 89]]).T
polygon = SphPolygon(np.deg2rad(vertices))
self.assertAlmostEqual(0.000609265770322, polygon.area())
# Around the south pole
vertices = np.array([[0, 90, 180, -90],
[-89, -89, -89, -89]]).T
polygon = SphPolygon(np.deg2rad(vertices))
self.assertAlmostEqual(0.000609265770322, polygon.area())
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)))
def test_is_inside(self):
"""Test checking if a polygon is inside of another.
"""
vertices = np.array([[1, 1, 20, 20], [1, 20, 20, 1]]).T
polygon1 = SphPolygon(np.deg2rad(vertices))
vertices = np.array([[0, 0, 30, 30], [0, 30, 30, 0]]).T
polygon2 = SphPolygon(np.deg2rad(vertices))
self.assertTrue(polygon1._is_inside(polygon2))
self.assertFalse(polygon2._is_inside(polygon1))
self.assertTrue(polygon2.area() > polygon1.area())
polygon2.invert()
self.assertFalse(polygon1._is_inside(polygon2))
self.assertFalse(polygon2._is_inside(polygon1))
vertices = np.array([[0, 0, 30, 30], [21, 30, 30, 21]]).T
polygon2 = SphPolygon(np.deg2rad(vertices))
self.assertFalse(polygon1._is_inside(polygon2))
self.assertFalse(polygon2._is_inside(polygon1))
polygon2.invert()
self.assertTrue(polygon1._is_inside(polygon2))
self.assertFalse(polygon2._is_inside(polygon1))
vertices = np.array([[100, 100, 130, 130], [41, 50, 50, 41]]).T
polygon2 = SphPolygon(np.deg2rad(vertices))
self.assertFalse(polygon1._is_inside(polygon2))
self.assertFalse(polygon2._is_inside(polygon1))
polygon2.invert()
self.assertTrue(polygon1._is_inside(polygon2))
self.assertFalse(polygon2._is_inside(polygon1))
vertices = np.array([[-1.54009253,
82.62402855], [3.4804808, 82.8105746],
[20.7214892,
83.00875812], [32.8857629, 82.7607758],
[41.53844302, 82.36024339],
[47.92062759, 81.91317164],
[52.82785062, 81.45769791],
[56.75107895, 81.00613046],
[59.99843787, 80.56042986],
[62.76998034, 80.11814453],
[65.20076209,
79.67471372], [67.38577498, 79.22428],
[69.39480149, 78.75981318],
[71.28163984, 78.27283234],
[73.09016378, 77.75277976],
[74.85864685, 77.18594725],
[76.62327682, 76.55367303],
[78.42162204, 75.82918893],
[80.29698409, 74.97171721],
[82.30538638, 73.9143231],
[84.52973107, 72.53535661],
[87.11696138, 70.57600156],
[87.79163209, 69.98712409],
[72.98142447, 67.1760143],
[61.79517279, 63.2846272],
[53.50600609, 58.7098766],
[47.26725347, 53.70533139],
[42.44083259, 48.42199571],
[38.59682041, 42.95008531],
[35.45189206, 37.3452509],
[32.43435578, 30.72373327],
[31.73750748, 30.89485287],
[29.37284023, 31.44344415],
[27.66001308, 31.81016309],
[26.31358296, 32.08057499],
[25.1963477, 32.29313986],
[24.23118049, 32.46821821],
[23.36993508, 32.61780082],
[22.57998837, 32.74952569],
[21.8375532, 32.86857867],
[21.12396693, 32.97868717],
[20.42339605, 33.08268331],
[19.72121983, 33.18284728],
[19.00268283, 33.28113306],
[18.2515215,
33.3793305], [17.4482606, 33.47919405],
[16.56773514, 33.58255576],
[15.57501961, 33.6914282],
[14.4180087, 33.8080799],
[13.01234319, 33.93498577],
[11.20625437, 34.0742239],
[8.67990371, 34.22415978],
[7.89344478, 34.26018768],
[8.69446485, 41.19823568],
[9.25707165, 47.17351118],
[9.66283477, 53.14128114],
[9.84134875, 59.09937166],
[9.65054241,
65.04458004], [8.7667375, 70.97023122],
[6.28280904, 76.85731403]])
polygon1 = SphPolygon(np.deg2rad(vertices))
vertices = np.array([[49.94506701, 46.52610743],
[51.04293649, 46.52610743],
[62.02163129, 46.52610743],
[73.0003261, 46.52610743],
[83.9790209, 46.52610743],
[85.05493299, 46.52610743],
[85.05493299, 45.76549301],
[85.05493299, 37.58315571],
[85.05493299, 28.39260587],
[85.05493299, 18.33178739],
[85.05493299, 17.30750918],
[83.95706351, 17.30750918],
[72.97836871, 17.30750918],
[61.9996739, 17.30750918],
[51.0209791, 17.30750918],
[49.94506701, 17.30750918],
[49.94506701, 18.35262921],
[49.94506701, 28.41192025],
[49.94506701, 37.60055422],
[49.94506701, 45.78080831]])
polygon2 = SphPolygon(np.deg2rad(vertices))
self.assertFalse(polygon2._is_inside(polygon1))
self.assertFalse(polygon1._is_inside(polygon2))
def test_area(self):
"""Test the area function
"""
vertices = np.array([[1, 2, 3, 4, 3, 2], [3, 4, 3, 2, 1, 2]]).T
polygon = SphPolygon(np.deg2rad(vertices))
self.assertAlmostEqual(0.00121732523118, polygon.area())
vertices = np.array([[1, 2, 3, 2], [3, 4, 3, 2]]).T
polygon = SphPolygon(np.deg2rad(vertices))
self.assertAlmostEqual(0.000608430665842, polygon.area())
vertices = np.array([[0, 0, 1, 1], [0, 1, 1, 0]]).T
polygon = SphPolygon(np.deg2rad(vertices))
self.assertAlmostEqual(0.000304609684862, polygon.area())
# Across the dateline
vertices = np.array([[179.5, -179.5, -179.5, 179.5], [1, 1, 0, 0]]).T
polygon = SphPolygon(np.deg2rad(vertices))
self.assertAlmostEqual(0.000304609684862, polygon.area())
vertices = np.array([[0, 90, 90, 0], [1, 1, 0, 0]]).T
polygon = SphPolygon(np.deg2rad(vertices))
self.assertAlmostEqual(0.0349012696772, polygon.area())
vertices = np.array([[90, 0, 0], [0, 0, 90]]).T
polygon = SphPolygon(np.deg2rad(vertices))
self.assertAlmostEqual(np.pi / 2, polygon.area())
# Around the north pole
vertices = np.array([[0, -90, 180, 90], [89, 89, 89, 89]]).T
polygon = SphPolygon(np.deg2rad(vertices))
self.assertAlmostEqual(0.000609265770322, polygon.area())
# Around the south pole
vertices = np.array([[0, 90, 180, -90], [-89, -89, -89, -89]]).T
polygon = SphPolygon(np.deg2rad(vertices))
self.assertAlmostEqual(0.000609265770322, polygon.area())
