def get_angles(self, angle_id):
"""Get sun-satellite viewing angles"""
tic = datetime.now()
sunz40km = self._data["ang"][:, :, 0] * 1e-2
satz40km = self._data["ang"][:, :, 1] * 1e-2
azidiff40km = self._data["ang"][:, :, 2] * 1e-2
try:
from geotiepoints.interpolator import Interpolator
except ImportError:
logger.warning("Could not interpolate sun-sat angles, "
"python-geotiepoints missing.")
self.sunz, self.satz, self.azidiff = sunz40km, satz40km, azidiff40km
else:
cols40km = np.arange(24, 2048, 40)
cols1km = np.arange(2048)
lines = sunz40km.shape[0]
rows40km = np.arange(lines)
rows1km = np.arange(lines)
along_track_order = 1
cross_track_order = 3
satint = Interpolator(
[sunz40km, satz40km, azidiff40km], (rows40km, cols40km),
(rows1km, cols1km), along_track_order, cross_track_order)
self.sunz, self.satz, self.azidiff = satint.interpolate()
logger.debug("Interpolate sun-sat angles: time %s",
str(datetime.now() - tic))
return create_xarray(getattr(self, ANGLES[angle_id]))
def get_angles(self, angle_id):
"""Get sun-satellite viewing angles"""
tic = datetime.now()
sunz40km = self._data["ang"][:, :, 0] * 1e-2
satz40km = self._data["ang"][:, :, 1] * 1e-2
azidiff40km = self._data["ang"][:, :, 2] * 1e-2
try:
from geotiepoints.interpolator import Interpolator
except ImportError:
logger.warning("Could not interpolate sun-sat angles, "
"python-geotiepoints missing.")
self.sunz, self.satz, self.azidiff = sunz40km, satz40km, azidiff40km
else:
cols40km = np.arange(24, 2048, 40)
cols1km = np.arange(2048)
lines = sunz40km.shape[0]
rows40km = np.arange(lines)
rows1km = np.arange(lines)
along_track_order = 1
cross_track_order = 3
satint = Interpolator([sunz40km, satz40km, azidiff40km],
(rows40km, cols40km), (rows1km, cols1km),
along_track_order, cross_track_order)
self.sunz, self.satz, self.azidiff = satint.interpolate()
logger.debug("Interpolate sun-sat angles: time %s",
str(datetime.now() - tic))
return create_xarray(getattr(self, ANGLES[angle_id]))
def test_results_in_c_order(self):
lons = np.arange(10).reshape((2, 5), order="F")
lats = np.arange(10).reshape((2, 5), order="C")
lines = np.array([2, 7])
cols = np.array([2, 7, 12, 17, 22])
hlines = np.arange(10)
hcols = np.arange(24)
satint = Interpolator((lons, lats), (lines, cols), (hlines, hcols))
interp_results = satint.interpolate()
assert interp_results[0].flags['C_CONTIGUOUS'] is True
def get_dataset(self, key, info):
"""Load a dataset
"""
if key.name not in self.datasets:
return
if self.nc is None:
self.nc = h5netcdf.File(self.filename, 'r')
logger.debug('Reading %s.', key.name)
variable = self.nc[self.datasets[key.name]]
values = (np.ma.masked_equal(variable[:],
variable.attrs['_FillValue'], copy=False) *
variable.attrs.get('scale_factor', 1) +
variable.attrs.get('add_offset', 0))
units = variable.attrs['units']
l_step = self.nc.attrs['al_subsampling_factor']
c_step = self.nc.attrs['ac_subsampling_factor']
if c_step != 1 or l_step != 1:
from geotiepoints.interpolator import Interpolator
tie_lines = np.arange(
0, (values.shape[0] - 1) * l_step + 1, l_step)
tie_cols = np.arange(0, (values.shape[1] - 1) * c_step + 1, c_step)
lines = np.arange((values.shape[0] - 1) * l_step + 1)
cols = np.arange((values.shape[1] - 1) * c_step + 1)
along_track_order = 1
cross_track_order = 3
satint = Interpolator([values],
(tie_lines, tie_cols),
(lines, cols),
along_track_order,
cross_track_order)
(values, ) = satint.interpolate()
proj = Dataset(values,
copy=False,
units=units,
platform_name=self.platform_name,
sensor=self.sensor)
proj.info.update(key.to_dict())
return proj
def get_dataset(self, key, info):
"""Load a dataset
"""
if key.name not in self.datasets:
return
if self.nc is None:
self.nc = h5netcdf.File(self.filename, 'r')
logger.debug('Reading %s.', key.name)
variable = self.nc[self.datasets[key.name]]
values = (np.ma.masked_equal(variable[:],
variable.attrs['_FillValue'], copy=False) *
variable.attrs.get('scale_factor', 1) +
variable.attrs.get('add_offset', 0))
units = variable.attrs['units']
l_step = self.nc.attrs['al_subsampling_factor']
c_step = self.nc.attrs['ac_subsampling_factor']
if c_step != 1 or l_step != 1:
from geotiepoints.interpolator import Interpolator
tie_lines = np.arange(
0, (values.shape[0] - 1) * l_step + 1, l_step)
tie_cols = np.arange(0, (values.shape[1] - 1) * c_step + 1, c_step)
lines = np.arange((values.shape[0] - 1) * l_step + 1)
cols = np.arange((values.shape[1] - 1) * c_step + 1)
along_track_order = 1
cross_track_order = 3
satint = Interpolator([values],
(tie_lines, tie_cols),
(lines, cols),
along_track_order,
cross_track_order)
(values, ) = satint.interpolate()
proj = Projectable(values,
copy=False,
units=units,
platform_name=self.platform_name,
sensor=self.sensor)
return proj
def _do_interpolate(self, data):
if not isinstance(data, tuple):
data = (data, )
shape = data[0].shape
from geotiepoints.interpolator import Interpolator
tie_lines = np.arange(0, (shape[0] - 1) * self.l_step + 1, self.l_step)
tie_cols = np.arange(0, (shape[1] - 1) * self.c_step + 1, self.c_step)
lines = np.arange((shape[0] - 1) * self.l_step + 1)
cols = np.arange((shape[1] - 1) * self.c_step + 1)
along_track_order = 1
cross_track_order = 3
satint = Interpolator([x.values for x in data], (tie_lines, tie_cols),
(lines, cols), along_track_order,
cross_track_order)
int_data = satint.interpolate()
return [
xr.DataArray(da.from_array(x, chunks=(CHUNK_SIZE, CHUNK_SIZE)),
dims=['y', 'x']) for x in int_data
]
def interpolate(self):
newx, newy, newz = Interpolator.interpolate(self)
lon = get_lons_from_cartesian(newx, newy)
lat = get_lats_from_cartesian(newx, newy, newz)
return lon, lat
def get_dataset(self, key, info):
"""Load a dataset."""
if key.name not in self.datasets:
return
if self.nc is None:
self.nc = xr.open_dataset(self.filename,
decode_cf=True,
mask_and_scale=True,
engine='h5netcdf',
chunks={'tie_columns': CHUNK_SIZE,
'tie_rows': CHUNK_SIZE})
self.nc = self.nc.rename({'tie_columns': 'x', 'tie_rows': 'y'})
logger.debug('Reading %s.', key.name)
l_step = self.nc.attrs['al_subsampling_factor']
c_step = self.nc.attrs['ac_subsampling_factor']
if (c_step != 1 or l_step != 1) and self.cache.get(key.name) is None:
if key.name.startswith('satellite'):
zen = self.nc[self.datasets['satellite_zenith_angle']]
zattrs = zen.attrs
azi = self.nc[self.datasets['satellite_azimuth_angle']]
aattrs = azi.attrs
elif key.name.startswith('solar'):
zen = self.nc[self.datasets['solar_zenith_angle']]
zattrs = zen.attrs
azi = self.nc[self.datasets['solar_azimuth_angle']]
aattrs = azi.attrs
else:
raise NotImplementedError("Don't know how to read " + key.name)
x, y, z = angle2xyz(azi, zen)
shape = x.shape
from geotiepoints.interpolator import Interpolator
tie_lines = np.arange(
0, (shape[0] - 1) * l_step + 1, l_step)
tie_cols = np.arange(0, (shape[1] - 1) * c_step + 1, c_step)
lines = np.arange((shape[0] - 1) * l_step + 1)
cols = np.arange((shape[1] - 1) * c_step + 1)
along_track_order = 1
cross_track_order = 3
satint = Interpolator([x.values, y.values, z.values],
(tie_lines, tie_cols),
(lines, cols),
along_track_order,
cross_track_order)
(x, y, z, ) = satint.interpolate()
del satint
x = xr.DataArray(da.from_array(x, chunks=(CHUNK_SIZE, CHUNK_SIZE)),
dims=['y', 'x'])
y = xr.DataArray(da.from_array(y, chunks=(CHUNK_SIZE, CHUNK_SIZE)),
dims=['y', 'x'])
z = xr.DataArray(da.from_array(z, chunks=(CHUNK_SIZE, CHUNK_SIZE)),
dims=['y', 'x'])
azi, zen = xyz2angle(x, y, z)
azi.attrs = aattrs
zen.attrs = zattrs
if 'zenith' in key.name:
values = zen
elif 'azimuth' in key.name:
values = azi
else:
raise NotImplementedError("Don't know how to read " + key.name)
if key.name.startswith('satellite'):
self.cache['satellite_zenith_angle'] = zen
self.cache['satellite_azimuth_angle'] = azi
elif key.name.startswith('solar'):
self.cache['solar_zenith_angle'] = zen
self.cache['solar_azimuth_angle'] = azi
elif key.name in self.cache:
values = self.cache[key.name]
else:
values = self.nc[self.datasets[key.name]]
values.attrs['platform_name'] = self.platform_name
values.attrs['sensor'] = self.sensor
values.attrs.update(key.to_dict())
return values
def get_dataset(self, key, info):
"""Load a dataset."""
if key.name not in self.datasets:
return
if self.nc is None:
self.nc = h5netcdf.File(self.filename, 'r')
logger.debug('Reading %s.', key.name)
l_step = self.nc.attrs['al_subsampling_factor']
c_step = self.nc.attrs['ac_subsampling_factor']
if (c_step != 1 or l_step != 1) and key.name not in self.cache:
if key.name.startswith('satellite'):
zen, zattrs = self._get_scaled_variable(
self.datasets['satellite_zenith_angle'])
azi, aattrs = self._get_scaled_variable(
self.datasets['satellite_azimuth_angle'])
elif key.name.startswith('solar'):
zen, zattrs = self._get_scaled_variable(
self.datasets['solar_zenith_angle'])
azi, aattrs = self._get_scaled_variable(
self.datasets['solar_azimuth_angle'])
else:
raise NotImplementedError("Don't know how to read " + key.name)
x, y, z = angle2xyz(azi, zen)
shape = x.shape
from geotiepoints.interpolator import Interpolator
tie_lines = np.arange(0, (shape[0] - 1) * l_step + 1, l_step)
tie_cols = np.arange(0, (shape[1] - 1) * c_step + 1, c_step)
lines = np.arange((shape[0] - 1) * l_step + 1)
cols = np.arange((shape[1] - 1) * c_step + 1)
along_track_order = 1
cross_track_order = 3
satint = Interpolator([x, y, z], (tie_lines, tie_cols),
(lines, cols), along_track_order,
cross_track_order)
(
x,
y,
z,
) = satint.interpolate()
azi, zen = xyz2angle(x, y, z)
if 'zenith' in key.name:
values, attrs = zen, zattrs
elif 'azimuth' in key.name:
values, attrs = azi, aattrs
else:
raise NotImplementedError("Don't know how to read " + key.name)
if key.name.startswith('satellite'):
self.cache['satellite_zenith_angle'] = zen, zattrs
self.cache['satellite_azimuth_angle'] = azi, aattrs
elif key.name.startswith('solar'):
self.cache['solar_zenith_angle'] = zen, zattrs
self.cache['solar_azimuth_angle'] = azi, aattrs
elif key.name in self.cache:
values, attrs = self.cache[key.name]
else:
values, attrs = self._get_scaled_variable(self.datasets[key.name])
units = attrs['units']
proj = Dataset(values,
copy=False,
units=units,
platform_name=self.platform_name,
sensor=self.sensor)
proj.info.update(key.to_dict())
return proj
def interpolate(self):
newx, newy, newz = Interpolator.interpolate(self)
lon = get_lons_from_cartesian(newx, newy)
lat = get_lats_from_cartesian(newx, newy, newz)
return lon, lat
