def test_proj4_str_dict_conversion(self):
from pyresample import utils
proj_str = "+proj=lcc +ellps=WGS84 +lon_0=-95 +no_defs"
proj_dict = utils.proj4_str_to_dict(proj_str)
proj_str2 = utils.proj4_dict_to_str(proj_dict)
proj_dict2 = utils.proj4_str_to_dict(proj_str2)
self.assertDictEqual(proj_dict, proj_dict2)
def test_basic_numbered_tiles(self):
"""Test creating a multiple numbered tiles"""
from satpy.writers.scmi import SCMIWriter
from xarray import DataArray
from pyresample.geometry import AreaDefinition
from pyresample.utils import proj4_str_to_dict
w = SCMIWriter(base_dir=self.base_dir, compress=True)
area_def = AreaDefinition(
'test',
'test',
'test',
proj_dict=proj4_str_to_dict(
'+proj=lcc +datum=WGS84 +ellps=WGS84 +lon_0=-95. +lat_0=25 +lat_1=25 +units=m +no_defs'
),
x_size=100,
y_size=200,
area_extent=(-1000., -1500., 1000., 1500.),
)
now = datetime.utcnow()
ds = DataArray(np.linspace(0., 1., 20000, dtype=np.float32).reshape(
(200, 100)),
attrs=dict(name='test_ds',
platform_name='PLAT',
sensor='SENSOR',
units='1',
area=area_def,
start_time=now,
end_time=now + timedelta(minutes=20)))
fn = w.save_datasets([ds],
sector_id='TEST',
source_name="TESTS",
tile_count=(3, 3))
# `fn` is currently the last file created
self.assertTrue(os.path.isfile(fn))
self.assertIn('T009', fn)
def _get_test_one_dataset(self):
"""Helper function to create a single test dataset."""
import xarray as xr
import dask.array as da
from datetime import datetime
from pyresample.geometry import AreaDefinition
from pyresample.utils import proj4_str_to_dict
area_def = AreaDefinition(
'test',
'test',
'test',
proj_dict=proj4_str_to_dict('+proj=geos +datum=WGS84 +ellps=WGS84 \
+lon_0=0. h=36000. +units=km'),
x_size=100,
y_size=200,
area_extent=(-1000., -1500., 1000., 1500.),
)
ds1 = xr.DataArray(da.zeros((100, 200), chunks=50),
dims=('y', 'x'),
attrs={
'name': 'test',
'start_time': datetime.utcnow(),
'platform_name': "TEST_PLATFORM_NAME",
'sensor': 'TEST_SENSOR_NAME',
'area': area_def
})
return ds1
def test_basic1(self):
from pyresample.ewa import ll2cr
from pyresample.geometry import SwathDefinition, AreaDefinition
from pyresample.utils import proj4_str_to_dict
lon_arr = create_test_longitude(-95.0, -75.0, (50, 100), dtype=np.float64)
lat_arr = create_test_latitude(18.0, 40.0, (50, 100), dtype=np.float64)
swath_def = SwathDefinition(lon_arr, lat_arr)
grid_info = static_lcc.copy()
cw = grid_info["cell_width"]
ch = grid_info["cell_height"]
ox = grid_info["origin_x"]
oy = grid_info["origin_y"]
w = grid_info["width"]
h = grid_info["height"]
half_w = abs(cw / 2.)
half_h = abs(ch / 2.)
extents = [
ox - half_w, oy - h * abs(ch) - half_h,
ox + w * abs(cw) + half_w, oy + half_h
]
area = AreaDefinition('test_area', 'test_area', 'test_area',
proj4_str_to_dict(grid_info['proj4_definition']),
w, h, extents)
points_in_grid, lon_res, lat_res, = ll2cr(swath_def, area,
fill=np.nan, copy=False)
self.assertEqual(points_in_grid, lon_arr.size, "all points should be contained in a dynamic grid")
self.assertIs(lon_arr, lon_res)
self.assertIs(lat_arr, lat_res)
self.assertEqual(points_in_grid, lon_arr.size, "all these test points should fall in this grid")
def __init__(self, projparams=None, preserve_units=True, **kwargs):
# Copy dict-type arguments as they will be modified in-place
if isinstance(projparams, dict):
projparams = projparams.copy()
# Pyproj<2 uses __new__ to initiate data and does not define its own __init__ method.
if is_pyproj2():
# If init is found in any of the data, override any other area parameters.
if 'init' in kwargs:
warnings.warn('init="EPSG:XXXX" is no longer supported. Use "EPSG:XXXX" as a proj string instead')
projparams = kwargs.pop('init')
# Proj takes params in projparams over the params in kwargs.
if isinstance(projparams, (dict, str)) and 'init' in projparams:
warn_msg = '{"init": "EPSG:XXXX"} is no longer supported. Use "EPSG:XXXX" as a proj string instead'
if isinstance(projparams, str):
warn_msg = '"+init=EPSG:XXXX" is no longer supported. Use "EPSG:XXXX" as a proj string instead'
# Proj-dicts are cleaner to parse than strings.
projparams = proj4_str_to_dict(projparams)
warnings.warn(warn_msg)
projparams = projparams.pop('init')
# New syntax 'EPSG:XXXX'
if 'EPSG' in kwargs or (isinstance(projparams, dict) and 'EPSG' in projparams):
if 'EPSG' in kwargs:
epsg_code = kwargs.pop('EPSG')
else:
epsg_code = projparams.pop('EPSG')
projparams = 'EPSG:{}'.format(epsg_code)
super(BaseProj, self).__init__(projparams=projparams, preserve_units=preserve_units, **kwargs)
def test_expand_dims_3d(self):
"""Test expanding native resampling with 3D data."""
from satpy.resample import NativeResampler
import numpy as np
import dask.array as da
from xarray import DataArray
from pyresample.geometry import AreaDefinition
from pyresample.utils import proj4_str_to_dict
ds1 = DataArray(da.zeros((3, 100, 50), chunks=85),
dims=('bands', 'y', 'x'),
coords={
'bands': ['R', 'G', 'B'],
'y': da.arange(100, chunks=85),
'x': da.arange(50, chunks=85)
})
proj_dict = proj4_str_to_dict('+proj=lcc +datum=WGS84 +ellps=WGS84 '
'+lon_0=-95. +lat_0=25 +lat_1=25 '
'+units=m +no_defs')
target = AreaDefinition(
'test',
'test',
'test',
proj_dict,
100,
200,
(-1000., -1500., 1000., 1500.),
)
# source geo def doesn't actually matter
resampler = NativeResampler(None, target)
new_arr = resampler.resample(ds1)
self.assertEqual(new_arr.shape, (3, 200, 100))
new_arr2 = resampler.resample(ds1.compute())
self.assertTrue(np.all(new_arr == new_arr2))
def __init__(self, projparams=None, preserve_units=True, **kwargs):
# Copy dict-type arguments as they will be modified in-place
if isinstance(projparams, dict):
projparams = projparams.copy()
# Pyproj<2 uses __new__ to initiate data and does not define its own __init__ method.
if is_pyproj2():
# If init is found in any of the data, override any other area parameters.
if 'init' in kwargs:
warnings.warn(
'init="EPSG:XXXX" is no longer supported. Use "EPSG:XXXX" as a proj string instead'
)
projparams = kwargs.pop('init')
# Proj takes params in projparams over the params in kwargs.
if isinstance(projparams, (dict, str)) and 'init' in projparams:
warn_msg = '{"init": "EPSG:XXXX"} is no longer supported. Use "EPSG:XXXX" as a proj string instead'
if isinstance(projparams, str):
warn_msg = '"+init=EPSG:XXXX" is no longer supported. Use "EPSG:XXXX" as a proj string instead'
# Proj-dicts are cleaner to parse than strings.
projparams = proj4_str_to_dict(projparams)
warnings.warn(warn_msg)
projparams = projparams.pop('init')
# New syntax 'EPSG:XXXX'
if 'EPSG' in kwargs or (isinstance(projparams, dict)
and 'EPSG' in projparams):
if 'EPSG' in kwargs:
epsg_code = kwargs.pop('EPSG')
else:
epsg_code = projparams.pop('EPSG')
projparams = 'EPSG:{}'.format(epsg_code)
super(BaseProj, self).__init__(projparams=projparams,
preserve_units=preserve_units,
**kwargs)
def _get_test_dataset_three_bands_two_prereq(self, bands=3):
"""Helper function to create a single test dataset."""
import xarray as xr
import dask.array as da
from datetime import datetime
from pyresample.geometry import AreaDefinition
from pyresample.utils import proj4_str_to_dict
from satpy import DatasetID
area_def = AreaDefinition(
'test',
'test',
'test',
proj4_str_to_dict('+proj=stere +datum=WGS84 +ellps=WGS84 '
'+lon_0=0. +lat_0=90 +lat_ts=60 +units=km'),
100,
200,
(-1000., -1500., 1000., 1500.),
)
ds1 = xr.DataArray(
da.zeros((bands, 100, 200), chunks=50),
coords=[['R', 'G', 'B'], list(range(100)), list(range(200))],
dims=('bands', 'y', 'x'),
attrs={'name': 'test',
'start_time': datetime.utcnow(),
'platform_name': "TEST_PLATFORM_NAME",
'sensor': 'TEST_SENSOR_NAME',
'area': area_def,
'prerequisites': [DatasetID(name='1', calibration='reflectance'),
DatasetID(name='2', calibration='reflectance')]}
)
return ds1
def get_area_def(self, dsid):
"""Get area definition."""
if not self.is_geo:
raise NotImplementedError("Don't know how to get the Area Definition for this file")
platform = self.get_platform(self['/attr/Platform_Name'])
res = self._calc_area_resolution(dsid.resolution)
proj = self._get_proj(platform, float(self['/attr/Subsatellite_Longitude']))
area_name = '{} {} Area at {}m'.format(
platform,
self.metadata.get('sector_id', ''),
int(res))
lon = self._load_nav('pixel_longitude')
lat = self._load_nav('pixel_latitude')
extents = self._get_extents(proj, res, lon, lat)
area_def = geometry.AreaDefinition(
area_name,
area_name,
area_name,
proj4_str_to_dict(proj),
lon.shape[1],
lon.shape[0],
area_extent=extents,
)
return area_def
def test_basic1(self):
from pyresample.ewa import ll2cr
from pyresample.geometry import SwathDefinition, AreaDefinition
from pyresample.utils import proj4_str_to_dict
lon_arr = create_test_longitude(-95.0,
-75.0, (50, 100),
dtype=np.float64)
lat_arr = create_test_latitude(18.0, 40.0, (50, 100), dtype=np.float64)
swath_def = SwathDefinition(lon_arr, lat_arr)
grid_info = static_lcc.copy()
cw = grid_info["cell_width"]
ch = grid_info["cell_height"]
ox = grid_info["origin_x"]
oy = grid_info["origin_y"]
w = grid_info["width"]
h = grid_info["height"]
half_w = abs(cw / 2.)
half_h = abs(ch / 2.)
extents = [
ox - half_w, oy - h * abs(ch) - half_h, ox + w * abs(cw) + half_w,
oy + half_h
]
area = AreaDefinition('test_area', 'test_area', 'test_area',
proj4_str_to_dict(grid_info['proj4_definition']),
w, h, extents)
points_in_grid, lon_res, lat_res, = ll2cr(swath_def,
area,
fill=np.nan,
copy=False)
self.assertEqual(points_in_grid, lon_arr.size,
"all points should be contained in a dynamic grid")
self.assertIs(lon_arr, lon_res)
self.assertIs(lat_arr, lat_res)
self.assertEqual(points_in_grid, lon_arr.size,
"all these test points should fall in this grid")
def _get_proj_data(projection):
"""Takes a proj4_dict or proj4_string and returns a proj4_dict and a Proj function.
There is special handling for the "EPSG:XXXX" case where "XXXX" is an
EPSG number code. It can be provided as a string `"EPSG:XXXX"` or as a
dictionary (when provided via YAML) as `{'EPSG': XXXX}`.
If it is passed as a string ("EPSG:XXXX") then the rules of
:func:`~pyresample.utils._proj.proj4_str_to_dict` are followed.
If a dictionary and pyproj 2.0+ is installed then the string
`"EPSG:XXXX"` is passed to ``proj4_str_to_dict``. If pyproj<2.0
is installed then the string ``+init=EPSG:XXXX`` is passed to
``proj4_str_to_dict`` which provides limited information to area
config operations.
"""
if isinstance(projection, dict) and 'EPSG' in projection:
projection = "EPSG:{}".format(projection['EPSG'])
if isinstance(projection, str):
proj_dict = proj4_str_to_dict(projection)
elif isinstance(projection, dict):
proj_dict = projection
else:
raise TypeError(
'Wrong type for projection: {0}. Expected dict or string.'.format(
type(projection)))
return proj_dict
def test_basic_numbered_tiles(self):
"""Test creating a multiple numbered tiles"""
from satpy.writers.scmi import SCMIWriter
from xarray import DataArray
from pyresample.geometry import AreaDefinition
from pyresample.utils import proj4_str_to_dict
w = SCMIWriter(base_dir=self.base_dir, compress=True)
area_def = AreaDefinition(
'test',
'test',
'test',
proj_dict=proj4_str_to_dict('+proj=lcc +datum=WGS84 +ellps=WGS84 +lon_0=-95. +lat_0=25 +lat_1=25 +units=m +no_defs'),
x_size=100,
y_size=200,
area_extent=(-1000., -1500., 1000., 1500.),
)
now = datetime.utcnow()
ds = DataArray(
np.linspace(0., 1., 20000, dtype=np.float32).reshape((200, 100)),
attrs=dict(
name='test_ds',
platform_name='PLAT',
sensor='SENSOR',
units='1',
area=area_def,
start_time=now,
end_time=now + timedelta(minutes=20))
)
fn = w.save_datasets([ds],
sector_id='TEST',
source_name="TESTS",
tile_count=(3, 3))
# `fn` is currently the last file created
self.assertTrue(os.path.isfile(fn))
self.assertIn('T009', fn)
def _get_test_dataset_with_bad_values(self, bands=3):
"""Helper function to create a single test dataset."""
import xarray as xr
import numpy as np
from datetime import datetime
from pyresample.geometry import AreaDefinition
from pyresample.utils import proj4_str_to_dict
area_def = AreaDefinition(
'test',
'test',
'test',
proj4_str_to_dict('+proj=stere +datum=WGS84 +ellps=WGS84 '
'+lon_0=0. +lat_0=90 +lat_ts=60 +units=km'),
100,
200,
(-1000., -1500., 1000., 1500.),
)
data = np.arange(-210, 790, 100).reshape((2, 5)) * 0.95
data /= 5.605
data[0, 0] = np.nan # need a nan value
data[0, 1] = 0. # Need a 0 value
rgb_data = np.stack([data, data, data])
ds1 = xr.DataArray(rgb_data,
dims=('bands', 'y', 'x'),
attrs={
'name': 'test',
'start_time': datetime.utcnow(),
'platform_name': "TEST_PLATFORM_NAME",
'sensor': 'TEST_SENSOR_NAME',
'area': area_def,
'prerequisites': ['1', '2', '3']
})
return ds1
def test_expand_without_dims(self):
from satpy.resample import NativeResampler
import numpy as np
import dask.array as da
from xarray import DataArray
from pyresample.geometry import AreaDefinition
from pyresample.utils import proj4_str_to_dict
ds1 = DataArray(da.zeros((100, 50), chunks=85))
proj_dict = proj4_str_to_dict('+proj=lcc +datum=WGS84 +ellps=WGS84 '
'+lon_0=-95. +lat_0=25 +lat_1=25 '
'+units=m +no_defs')
target = AreaDefinition(
'test',
'test',
'test',
proj_dict,
x_size=100,
y_size=200,
area_extent=(-1000., -1500., 1000., 1500.),
)
# source geo def doesn't actually matter
resampler = NativeResampler(None, target)
new_arr = resampler.resample(ds1)
self.assertEqual(new_arr.shape, (200, 100))
new_arr2 = resampler.resample(ds1.compute())
self.assertTrue(np.all(new_arr == new_arr2))
def get_generic_projection_from_proj4(lat, lon, proj4_srs):
"""Short summary.
Parameters
----------
lat : type
Description of parameter `lat`.
lon : type
Description of parameter `lon`.
proj4_srs : type
Description of parameter `proj4_srs`.
Returns
-------
type
Description of returned object.
"""
try:
from pyresample.utils import proj4_str_to_dict
from pyresample.geometry import SwathDefinition
except ImportError:
print('please install pyresample to use this functionality')
swath = SwathDefinition(lats=lat, lons=lon)
area = swath.compute_optimal_bb_area(proj4_str_to_dict(proj4_srs))
return area
def test_lettered_tiles_bad_filename(self):
"""Test creating a lettered grid with a bad filename"""
from satpy.writers.scmi import SCMIWriter
from xarray import DataArray
from pyresample.geometry import AreaDefinition
from pyresample.utils import proj4_str_to_dict
w = SCMIWriter(base_dir=self.base_dir, compress=True, file_pattern="{Bad Key}.nc")
area_def = AreaDefinition(
'test',
'test',
'test',
proj_dict=proj4_str_to_dict('+proj=lcc +datum=WGS84 +ellps=WGS84 +lon_0=-95. +lat_0=25 +lat_1=25 +units=m +no_defs'),
x_size=1000,
y_size=2000,
area_extent=(-1000000., -1500000., 1000000., 1500000.),
)
now = datetime.utcnow()
ds = DataArray(
np.linspace(0., 1., 2000000, dtype=np.float32).reshape((2000, 1000)),
attrs=dict(
name='test_ds',
platform_name='PLAT',
sensor='SENSOR',
units='1',
area=area_def,
start_time=now,
end_time=now + timedelta(minutes=20))
)
self.assertRaises(KeyError, w.save_datasets,
[ds],
sector_id='LCC',
source_name="TESTS",
tile_count=(3, 3),
lettered_grid=True)
def test_expand_without_dims(self):
"""Test expanding native resampling with no dimensions specified."""
from satpy.resample import NativeResampler
import numpy as np
import dask.array as da
from xarray import DataArray
from pyresample.geometry import AreaDefinition
from pyresample.utils import proj4_str_to_dict
ds1 = DataArray(da.zeros((100, 50), chunks=85))
proj_dict = proj4_str_to_dict('+proj=lcc +datum=WGS84 +ellps=WGS84 '
'+lon_0=-95. +lat_0=25 +lat_1=25 '
'+units=m +no_defs')
target = AreaDefinition(
'test',
'test',
'test',
proj_dict,
x_size=100,
y_size=200,
area_extent=(-1000., -1500., 1000., 1500.),
)
# source geo def doesn't actually matter
resampler = NativeResampler(None, target)
new_arr = resampler.resample(ds1)
self.assertEqual(new_arr.shape, (200, 100))
new_arr2 = resampler.resample(ds1.compute())
self.assertTrue(np.all(new_arr == new_arr2))
def test_lettered_tiles_no_valid_data(self):
"""Test creating a lettered grid with no valid data."""
from satpy.writers.awips_tiled import AWIPSTiledWriter
from xarray import DataArray
from pyresample.geometry import AreaDefinition
from pyresample.utils import proj4_str_to_dict
w = AWIPSTiledWriter(base_dir=self.base_dir, compress=True)
area_def = AreaDefinition(
'test',
'test',
'test',
proj4_str_to_dict('+proj=lcc +datum=WGS84 +ellps=WGS84 +lon_0=-95. '
'+lat_0=25 +lat_1=25 +units=m +no_defs'),
1000,
2000,
(-1000000., -1500000., 1000000., 1500000.),
)
now = datetime(2018, 1, 1, 12, 0, 0)
ds = DataArray(
da.full((2000, 1000), np.nan, chunks=500, dtype=np.float32),
attrs=dict(
name='test_ds',
platform_name='PLAT',
sensor='SENSOR',
units='1',
area=area_def,
start_time=now,
end_time=now + timedelta(minutes=20))
)
w.save_datasets([ds], sector_id='LCC', source_name="TESTS", tile_count=(3, 3), lettered_grid=True)
# No files created - all NaNs should result in no tiles being created
all_files = glob(os.path.join(self.base_dir, 'TESTS_AII*.nc'))
assert not all_files
def _get_test_lcc_data(self):
from xarray import DataArray
from pyresample.geometry import AreaDefinition
from pyresample.utils import proj4_str_to_dict
area_def = AreaDefinition(
'test',
'test',
'test',
proj4_str_to_dict(
'+proj=lcc +datum=WGS84 +ellps=WGS84 +lon_0=-95. '
'+lat_0=25 +lat_1=25 +units=m +no_defs'),
100,
200,
(-1000., -1500., 1000., 1500.),
)
now = datetime(2018, 1, 1, 12, 0, 0)
data = np.linspace(0., 1., 20000, dtype=np.float32).reshape((200, 100))
ds = DataArray(da.from_array(data, chunks=50),
attrs=dict(name='test_ds',
platform_name='PLAT',
sensor='SENSOR',
units='1',
area=area_def,
start_time=now,
end_time=now + timedelta(minutes=20)))
return ds
def _get_test_dataset(self, bands=3):
"""Helper function to create a single test dataset."""
import xarray as xr
import dask.array as da
from datetime import datetime
from pyresample.geometry import AreaDefinition
from pyresample.utils import proj4_str_to_dict
area_def = AreaDefinition(
'test',
'test',
'test',
proj4_str_to_dict('+proj=stere +datum=WGS84 +ellps=WGS84 '
'+lon_0=0. +lat_0=90 +lat_ts=60 +units=km'),
100,
200,
(-1000., -1500., 1000., 1500.),
)
ds1 = xr.DataArray(da.zeros((bands, 100, 200), chunks=50),
dims=('bands', 'y', 'x'),
attrs={
'name': 'test',
'start_time': datetime.utcnow(),
'platform_name': "TEST_PLATFORM_NAME",
'sensor': 'TEST_SENSOR_NAME',
'area': area_def,
'prerequisites': ['1', '2', '3']
})
return ds1
def _get_test_dataset_calibration_one_dataset(self, bands=1):
"""Helper function to create a single test dataset."""
import xarray as xr
import dask.array as da
from datetime import datetime
from pyresample.geometry import AreaDefinition
from pyresample.utils import proj4_str_to_dict
from satpy import DatasetID
from satpy.scene import Scene
area_def = AreaDefinition(
'test',
'test',
'test',
proj4_str_to_dict('+proj=stere +datum=WGS84 +ellps=WGS84 '
'+lon_0=0. +lat_0=90 +lat_ts=60 +units=km'),
100,
200,
(-1000., -1500., 1000., 1500.),
)
d = [DatasetID(name='4', calibration='brightness_temperature')]
scene = Scene()
scene["4"] = xr.DataArray(
da.zeros((100, 200), chunks=50),
dims=('y', 'x'),
attrs={'calibration': 'brightness_temperature'})
data = scene['4']
calibration = []
for p in scene:
calibration.append(p.attrs['calibration'])
new_attrs = {
'name': 'datasets',
'start_time': datetime.utcnow(),
'platform_name': "TEST_PLATFORM_NAME",
'sensor': 'test-sensor',
'area': area_def,
'prerequisites': d,
'metadata_requirements': {
'order': ['4'],
'config': {
'4': {
'alias': 'BT',
'calibration': 'brightness_temperature',
'min-val': '-150',
'max-val': '50'
},
},
'translate': {
'4': '4',
},
'file_pattern': 'test-dataset-{start_time:%Y%m%d%H%M%S}.mitiff'
}
}
ds1 = xr.DataArray(data=data.data,
attrs=new_attrs,
dims=data.dims,
coords=data.coords)
return ds1
def _get_proj4_args(proj4_args):
"""Create dict from proj4 args."""
from pyresample.utils._proj4 import convert_proj_floats
if isinstance(proj4_args, (str, six.text_type)):
proj_config = proj4_str_to_dict(str(proj4_args))
else:
from configobj import ConfigObj
proj_config = ConfigObj(proj4_args)
return convert_proj_floats(proj_config.items())
def test_3d_ewa(self, ll2cr, fornav):
"""Test EWA with a 3D dataset."""
import numpy as np
import dask.array as da
import xarray as xr
from satpy.resample import resample_dataset
from pyresample.geometry import SwathDefinition, AreaDefinition
from pyresample.utils import proj4_str_to_dict
lons = xr.DataArray(da.zeros((10, 10), chunks=5))
lats = xr.DataArray(da.zeros((10, 10), chunks=5))
ll2cr.return_value = (100, np.zeros(
(10, 10), dtype=np.float32), np.zeros((10, 10), dtype=np.float32))
fornav.return_value = ([100 * 200] * 3,
[np.zeros((200, 100), dtype=np.float32)] * 3)
sgd = SwathDefinition(lons, lats)
proj_dict = proj4_str_to_dict('+proj=lcc +datum=WGS84 +ellps=WGS84 '
'+lon_0=-95. +lat_0=25 +lat_1=25 '
'+units=m +no_defs')
tgd = AreaDefinition(
'test',
'test',
'test',
proj_dict,
100,
200,
(-1000., -1500., 1000., 1500.),
)
input_data = xr.DataArray(da.zeros((3, 10, 10),
chunks=5,
dtype=np.float32),
dims=('bands', 'y', 'x'),
attrs={
'area': sgd,
'test': 'test'
})
new_data = resample_dataset(input_data, tgd, resampler='ewa')
self.assertTupleEqual(new_data.shape, (3, 200, 100))
self.assertEqual(new_data.dtype, np.float32)
self.assertEqual(new_data.attrs['test'], 'test')
self.assertIs(new_data.attrs['area'], tgd)
# make sure we can actually compute everything
new_data.compute()
previous_calls = ll2cr.call_count
# resample a different dataset and make sure cache is used
input_data = xr.DataArray(da.zeros((3, 10, 10),
chunks=5,
dtype=np.float32),
dims=('bands', 'y', 'x'),
attrs={
'area': sgd,
'test': 'test'
})
new_data = resample_dataset(input_data, tgd, resampler='ewa')
self.assertEqual(ll2cr.call_count, previous_calls)
new_data.compute()
def _get_proj_data(projection):
"""Takes a proj4_dict or proj4_string and returns a proj4_dict and a Proj function."""
if isinstance(projection, str):
proj_dict = proj4_str_to_dict(projection)
elif isinstance(projection, dict):
proj_dict = projection
else:
raise TypeError('Wrong type for projection: {0}. Expected dict or string.'.format(type(projection)))
return proj_dict
def _get_proj4_args(proj4_args):
"""Create dict from proj4 args."""
from pyresample.utils._proj4 import convert_proj_floats
if isinstance(proj4_args, (str, six.text_type)):
proj_config = proj4_str_to_dict(str(proj4_args))
else:
from configobj import ConfigObj
proj_config = ConfigObj(proj4_args)
return convert_proj_floats(proj_config.items())
def _get_proj4_args(proj4_args):
"""Create dict from proj4 args."""
from pyresample.utils._proj4 import convert_proj_floats
if isinstance(proj4_args, str):
# float conversion is done in `proj4_str_to_dict` already
return proj4_str_to_dict(str(proj4_args))
from configobj import ConfigObj
proj_config = ConfigObj(proj4_args)
return convert_proj_floats(proj_config.items())
def __init__(self, proj4_terms, globe=None, bounds=None):
terms = proj4_str_to_dict(proj4_terms)
globe = _globe_from_proj4(terms) if globe is None else globe
other_terms = []
for term in terms.items():
if term[0] not in _GLOBE_PARAMS:
other_terms.append(term)
super(_PROJ4Projection, self).__init__(other_terms, globe)
self.bounds = bounds
def test_basic_numbered_tiles_rgb(self):
"""Test creating a multiple numbered tiles with RGB."""
from satpy.writers.awips_tiled import AWIPSTiledWriter
import xarray as xr
from xarray import DataArray
from pyresample.geometry import AreaDefinition
from pyresample.utils import proj4_str_to_dict
w = AWIPSTiledWriter(base_dir=self.base_dir, compress=True)
area_def = AreaDefinition(
'test',
'test',
'test',
proj4_str_to_dict(
'+proj=lcc +datum=WGS84 +ellps=WGS84 +lon_0=-95. '
'+lat_0=25 +lat_1=25 +units=m +no_defs'),
100,
200,
(-1000., -1500., 1000., 1500.),
)
now = datetime(2018, 1, 1, 12, 0, 0)
ds = DataArray(da.from_array(np.linspace(0.,
1.,
60000,
dtype=np.float32).reshape(
(3, 200, 100)),
chunks=50),
dims=('bands', 'y', 'x'),
coords={'bands': ['R', 'G', 'B']},
attrs=dict(name='test_ds',
platform_name='PLAT',
sensor='SENSOR',
units='1',
area=area_def,
start_time=now,
end_time=now + timedelta(minutes=20)))
w.save_datasets([ds],
sector_id='TEST',
source_name="TESTS",
tile_count=(3, 3))
chan_files = glob(
os.path.join(self.base_dir, 'TESTS_AII*test_ds_R*.nc'))
all_files = chan_files[:]
assert len(chan_files) == 9
chan_files = glob(
os.path.join(self.base_dir, 'TESTS_AII*test_ds_G*.nc'))
all_files.extend(chan_files)
assert len(chan_files) == 9
chan_files = glob(
os.path.join(self.base_dir, 'TESTS_AII*test_ds_B*.nc'))
assert len(chan_files) == 9
all_files.extend(chan_files)
for fn in all_files:
ds = xr.open_dataset(fn, mask_and_scale=False)
check_required_common_attributes(ds)
def _get_proj_data(projection):
"""Takes a proj4_dict or proj4_string and returns a proj4_dict and a Proj function."""
if isinstance(projection, str):
proj_dict = proj4_str_to_dict(projection)
elif isinstance(projection, dict):
proj_dict = projection
else:
raise TypeError(
'Wrong type for projection: {0}. Expected dict or string.'.format(
type(projection)))
return proj_dict
def test_nearest_neighbor_area_area(self):
from pyresample import utils, geometry
proj_str = "+proj=lcc +datum=WGS84 +ellps=WGS84 +lat_0=25 +lat_1=25 +lon_0=-95 +units=m +no_defs"
proj_dict = utils.proj4_str_to_dict(proj_str)
extents = [0, 0, 1000. * 5000, 1000. * 5000]
area_def = geometry.AreaDefinition('CONUS', 'CONUS', 'CONUS',
proj_dict, 400, 500, extents)
extents2 = [-1000, -1000, 1000. * 4000, 1000. * 4000]
area_def2 = geometry.AreaDefinition('CONUS', 'CONUS', 'CONUS',
proj_dict, 600, 700, extents2)
rows, cols = utils.generate_nearest_neighbour_linesample_arrays(area_def, area_def2, 12000.)
def test_nearest_neighbor_grid_area(self):
from pyresample import utils, geometry
proj_str = "+proj=lcc +datum=WGS84 +ellps=WGS84 +lat_0=25 +lat_1=25 +lon_0=-95 +units=m +no_defs"
proj_dict = utils.proj4_str_to_dict(proj_str)
extents = [0, 0, 1000. * 2500., 1000. * 2000.]
area_def = geometry.AreaDefinition('CONUS', 'CONUS', 'CONUS',
proj_dict, 40, 50, extents)
lon_arr = create_test_longitude(-100.0, -60.0, (550, 500), dtype=np.float64)
lat_arr = create_test_latitude(20.0, 45.0, (550, 500), dtype=np.float64)
grid = geometry.GridDefinition(lons=lon_arr, lats=lat_arr)
rows, cols = utils.generate_nearest_neighbour_linesample_arrays(grid, area_def, 12000.)
def _create_test_area(proj_str=None, shape=DEFAULT_SHAPE, extents=None):
"""Create a test area definition."""
from pyresample.geometry import AreaDefinition
from pyresample.utils import proj4_str_to_dict
if proj_str is None:
proj_str = '+proj=lcc +datum=WGS84 +ellps=WGS84 +lon_0=-95. ' \
'+lat_0=25 +lat_1=25 +units=m +no_defs'
proj_dict = proj4_str_to_dict(proj_str)
extents = extents or (-1000., -1500., 1000., 1500.)
return AreaDefinition('test', 'test', 'test', proj_dict, shape[1],
shape[0], extents)
def get_ioapi_pyresample_area_def(ds, proj4_srs):
from pyresample import geometry, utils
y_size = ds.NROWS
x_size = ds.NCOLS
projection = utils.proj4_str_to_dict(proj4_srs)
proj_id = 'IOAPI_Dataset'
description = 'IOAPI area_def for pyresample'
area_id = 'MONET_Object_Grid'
x_ll, y_ll = ds.XORIG + ds.XCELL * .5, ds.YORIG + ds.YCELL * .5
x_ur, y_ur = ds.XORIG + (ds.NCOLS * ds.XCELL) + .5 * ds.XCELL, ds.YORIG + (
ds.YCELL * ds.NROWS) + .5 * ds.YCELL
area_extent = (x_ll, y_ll, x_ur, y_ur)
area_def = geometry.AreaDefinition(area_id, description, proj_id,
projection, x_size, y_size, area_extent)
return area_def
def test_3d_ewa(self, ll2cr, fornav):
"""Test EWA with a 3D dataset."""
import numpy as np
import dask.array as da
import xarray as xr
from satpy.resample import resample_dataset
from pyresample.geometry import SwathDefinition, AreaDefinition
from pyresample.utils import proj4_str_to_dict
lons = xr.DataArray(da.zeros((10, 10), chunks=5))
lats = xr.DataArray(da.zeros((10, 10), chunks=5))
ll2cr.return_value = (100,
np.zeros((10, 10), dtype=np.float32),
np.zeros((10, 10), dtype=np.float32))
fornav.return_value = ([100 * 200] * 3,
[np.zeros((200, 100), dtype=np.float32)] * 3)
sgd = SwathDefinition(lons, lats)
proj_dict = proj4_str_to_dict('+proj=lcc +datum=WGS84 +ellps=WGS84 '
'+lon_0=-95. +lat_0=25 +lat_1=25 '
'+units=m +no_defs')
tgd = AreaDefinition(
'test',
'test',
'test',
proj_dict,
x_size=100,
y_size=200,
area_extent=(-1000., -1500., 1000., 1500.),
)
input_data = xr.DataArray(
da.zeros((3, 10, 10), chunks=5, dtype=np.float32),
dims=('bands', 'y', 'x'), attrs={'area': sgd, 'test': 'test'})
new_data = resample_dataset(input_data, tgd, resampler='ewa')
self.assertTupleEqual(new_data.shape, (3, 200, 100))
self.assertEqual(new_data.dtype, np.float32)
self.assertEqual(new_data.attrs['test'], 'test')
self.assertIs(new_data.attrs['area'], tgd)
# make sure we can actually compute everything
new_data.compute()
previous_calls = ll2cr.call_count
# resample a different dataset and make sure cache is used
input_data = xr.DataArray(
da.zeros((3, 10, 10), chunks=5, dtype=np.float32),
dims=('bands', 'y', 'x'), attrs={'area': sgd, 'test': 'test'})
new_data = resample_dataset(input_data, tgd, resampler='ewa')
self.assertEqual(ll2cr.call_count, previous_calls)
new_data.compute()
def test_lettered_tiles_sector_ref(self):
"""Test creating a lettered grid using the sector as reference."""
import xarray as xr
from satpy.writers.scmi import SCMIWriter
from xarray import DataArray
from pyresample.geometry import AreaDefinition
from pyresample.utils import proj4_str_to_dict
w = SCMIWriter(base_dir=self.base_dir, compress=True)
area_def = AreaDefinition(
'test',
'test',
'test',
proj4_str_to_dict(
'+proj=lcc +datum=WGS84 +ellps=WGS84 +lon_0=-95. '
'+lat_0=25 +lat_1=25 +units=m +no_defs'),
1000,
2000,
(-1000000., -1500000., 1000000., 1500000.),
)
now = datetime(2018, 1, 1, 12, 0, 0)
ds = DataArray(da.from_array(np.linspace(0.,
1.,
2000000,
dtype=np.float32).reshape(
(2000, 1000)),
chunks=500),
attrs=dict(name='test_ds',
platform_name='PLAT',
sensor='SENSOR',
units='1',
area=area_def,
start_time=now,
end_time=now + timedelta(minutes=20)))
w.save_datasets([ds],
sector_id='LCC',
source_name="TESTS",
lettered_grid=True,
use_sector_reference=True,
use_end_time=True)
all_files = glob(os.path.join(self.base_dir, 'TESTS_AII*.nc'))
self.assertEqual(len(all_files), 16)
for fn in all_files:
nc = xr.open_dataset(fn, mask_and_scale=False)
# geolocation coordinates should be monotonically increasing by 1
np.testing.assert_equal(np.diff(nc['x']), 1)
np.testing.assert_equal(np.diff(nc['y']), 1)
assert nc.attrs['start_date_time'] == (
now + timedelta(minutes=20)).strftime('%Y-%m-%dT%H:%M:%S')
def _get_test_target_area(output_shape, output_proj=None):
from pyresample.geometry import AreaDefinition
from pyresample.utils import proj4_str_to_dict
if output_proj is None:
output_proj = ('+proj=lcc +datum=WGS84 +ellps=WGS84 '
'+lon_0=-95. +lat_0=25 +lat_1=25 +units=m +no_defs')
target = AreaDefinition(
'test_target',
'test_target',
'test_target',
proj4_str_to_dict(output_proj),
output_shape[1], # width
output_shape[0], # height
(-100000., -150000., 100000., 150000.),
)
return target
def test_basic_numbered_tiles_rgb(self):
"""Test creating a multiple numbered tiles with RGB."""
from satpy.writers.scmi import SCMIWriter
from xarray import DataArray
from pyresample.geometry import AreaDefinition
from pyresample.utils import proj4_str_to_dict
w = SCMIWriter(base_dir=self.base_dir, compress=True)
area_def = AreaDefinition(
'test',
'test',
'test',
proj_dict=proj4_str_to_dict(
'+proj=lcc +datum=WGS84 +ellps=WGS84 +lon_0=-95. '
'+lat_0=25 +lat_1=25 +units=m +no_defs'),
x_size=100,
y_size=200,
area_extent=(-1000., -1500., 1000., 1500.),
)
now = datetime(2018, 1, 1, 12, 0, 0)
ds = DataArray(da.from_array(np.linspace(0.,
1.,
60000,
dtype=np.float32).reshape(
(3, 200, 100)),
chunks=50),
dims=('bands', 'y', 'x'),
coords={'bands': ['R', 'G', 'B']},
attrs=dict(name='test_ds',
platform_name='PLAT',
sensor='SENSOR',
units='1',
area=area_def,
start_time=now,
end_time=now + timedelta(minutes=20)))
w.save_datasets([ds],
sector_id='TEST',
source_name="TESTS",
tile_count=(3, 3))
all_files = glob(os.path.join(self.base_dir,
'TESTS_AII*test_ds_R*.nc'))
self.assertEqual(len(all_files), 9)
all_files = glob(os.path.join(self.base_dir,
'TESTS_AII*test_ds_G*.nc'))
self.assertEqual(len(all_files), 9)
all_files = glob(os.path.join(self.base_dir,
'TESTS_AII*test_ds_B*.nc'))
self.assertEqual(len(all_files), 9)
def __init__(self, projparams=None, preserve_units=True, **kwargs):
# Pyproj<2 uses __new__ to initiate data and does not define its own __init__ method.
if pyproj.__version__ >= '2':
# If init is found in any of the data, override any other area parameters.
if 'init' in kwargs:
warnings.warn('init="EPSG:XXXX" is no longer supported. Use "EPSG:XXXX" as a proj string instead')
projparams = kwargs.pop('init')
# Proj takes params in projparams over the params in kwargs.
if isinstance(projparams, (dict, str)) and 'init' in projparams:
warn_msg = '{"init": "EPSG:XXXX"} is no longer supported. Use "EPSG:XXXX" as a proj string instead'
if isinstance(projparams, str):
warn_msg = '"+init=EPSG:XXXX" is no longer supported. Use "EPSG:XXXX" as a proj string instead'
# Proj-dicts are cleaner to parse than strings.
projparams = proj4_str_to_dict(projparams)
warnings.warn(warn_msg)
projparams = projparams.pop('init')
super(BaseProj, self).__init__(projparams=projparams, preserve_units=preserve_units, **kwargs)
def get_area_def(self, dsid):
if not self.is_geo:
raise NotImplementedError("Don't know how to get the Area Definition for this file")
platform = self.get_platform(self['/attr/Platform_Name'])
res = self._calc_area_resolution(dsid.resolution)
proj = self._get_proj(platform, float(self['/attr/Subsatellite_Longitude']))
area_name = '{} {} Area at {}m'.format(
platform,
self.metadata.get('sector_id', ''),
int(res))
lon = self._load_nav('pixel_longitude')
lat = self._load_nav('pixel_latitude')
extents = self._get_extents(proj, res, lon, lat)
area_def = geometry.AreaDefinition(
area_name,
area_name,
area_name,
proj_dict=proj4_str_to_dict(proj),
x_size=lon.shape[1],
y_size=lon.shape[0],
area_extent=extents,
)
return area_def
def _create_debug_array(sector_info, num_subtiles, font_path='Verdana.ttf'):
from PIL import Image, ImageDraw, ImageFont
from pkg_resources import resource_filename as get_resource_filename
size = (1000, 1000)
img = Image.new("L", size, 0)
draw = ImageDraw.Draw(img)
if ':' in font_path:
# load from a python package
font_path = get_resource_filename(*font_path.split(':'))
font = ImageFont.truetype(font_path, 25)
ll_extent = sector_info['lower_left_xy']
ur_extent = sector_info['upper_right_xy']
total_meters_x = ur_extent[0] - ll_extent[0]
total_meters_y = ur_extent[1] - ll_extent[1]
fcs_x = np.ceil(float(sector_info['resolution'][1]) / num_subtiles[1])
fcs_y = np.ceil(float(sector_info['resolution'][0]) / num_subtiles[0])
total_cells_x = np.ceil(total_meters_x / fcs_x)
total_cells_y = np.ceil(total_meters_y / fcs_y)
total_cells_x = np.ceil(total_cells_x / num_subtiles[1]) * num_subtiles[1]
total_cells_y = np.ceil(total_cells_y / num_subtiles[0]) * num_subtiles[0]
total_alpha_cells_x = int(total_cells_x / num_subtiles[1])
total_alpha_cells_y = int(total_cells_y / num_subtiles[0])
# "round" the total meters up to the number of alpha cells
total_meters_x = total_cells_x * fcs_x
total_meters_y = total_cells_y * fcs_y
# Pixels per tile
ppt_x = np.floor(float(size[0]) / total_cells_x)
ppt_y = np.floor(float(size[1]) / total_cells_y)
half_ppt_x = np.floor(ppt_x / 2.)
half_ppt_y = np.floor(ppt_y / 2.)
# Meters per pixel
meters_ppx = fcs_x / ppt_x
meters_ppy = fcs_y / ppt_y
for idx, alpha in enumerate(string.ascii_uppercase):
for i in range(4):
st_x = i % num_subtiles[1]
st_y = int(i / num_subtiles[1])
t = "{}{:02d}".format(alpha, i + 1)
t_size = font.getsize(t)
cell_x = (idx * num_subtiles[1] + st_x) % total_cells_x
cell_y = int(idx / (total_cells_x / num_subtiles[1])) * num_subtiles[0] + st_y
if cell_x > total_cells_x:
continue
elif cell_y > total_cells_y:
continue
x = ppt_x * cell_x + half_ppt_x
y = ppt_y * cell_y + half_ppt_y
# draw box around the tile edge
# PIL Documentation: "The second point is just outside the drawn rectangle."
# we want to be just inside 0 and just inside the outer edge of the tile
draw_rectangle(draw,
(x - half_ppt_x, y - half_ppt_y,
x + half_ppt_x, y + half_ppt_y), outline=255, fill=75, width=3)
draw.text((x - t_size[0] / 2., y - t_size[1] / 2.), t, fill=255, font=font)
img.save("test.png")
from pyresample.utils import proj4_str_to_dict
new_extents = (
ll_extent[0],
ur_extent[1] - 1001. * meters_ppy,
ll_extent[0] + 1001. * meters_ppx,
ur_extent[1],
)
grid_def = AreaDefinition(
'debug_grid',
'debug_grid',
'debug_grid',
proj4_str_to_dict(sector_info['projection']),
1000,
1000,
new_extents
)
return grid_def, np.array(img)
