def get_dataset(self, key, info):
"""Load a dataset."""
if key['name'] not in self.datasets:
return
self._open_dataset()
logger.debug('Reading %s.', key['name'])
if self._need_interpolation() 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)
x, y, z = self._do_interpolate((x, y, z))
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 test_xyz2angle(self):
"""Test xyz2angle."""
azi, zen = xyz2angle(1, 0, 0)
self.assertAlmostEqual(azi, 90)
self.assertAlmostEqual(zen, 90)
azi, zen = xyz2angle(0, 1, 0)
self.assertAlmostEqual(azi, 0)
self.assertAlmostEqual(zen, 90)
azi, zen = xyz2angle(0, 0, 1)
self.assertAlmostEqual(azi, 0)
self.assertAlmostEqual(zen, 0)
azi, zen = xyz2angle(0, 0, 1, acos=True)
self.assertAlmostEqual(azi, 0)
self.assertAlmostEqual(zen, 0)
azi, zen = xyz2angle(np.sqrt(2) / 2, np.sqrt(2) / 2, 0)
self.assertAlmostEqual(azi, 45)
self.assertAlmostEqual(zen, 90)
azi, zen = xyz2angle(-1, 0, 0)
self.assertAlmostEqual(azi, -90)
self.assertAlmostEqual(zen, 90)
azi, zen = xyz2angle(0, -1, 0)
self.assertAlmostEqual(azi, 180)
self.assertAlmostEqual(zen, 90)
def convert_to_angles(x, y, z):
"""Convert the cartesian coordinates to angles."""
# Conversion to ECEF is recommended by the provider, but no significant
# difference has been seen.
# x, y, z = (-np.sin(lon) * x - np.sin(lat) * np.cos(lon) * y + np.cos(lat) * np.cos(lon) * z,
# np.cos(lon) * x - np.sin(lat) * np.sin(lon) * y + np.cos(lat) * np.sin(lon) * z,
# np.cos(lat) * y + np.sin(lat) * z)
azi, zen = xyz2angle(x, y, z, acos=True)
return azi, zen
def _interpolate_angles(self, azi, zen):
aattrs = azi.attrs
zattrs = zen.attrs
x, y, z = angle2xyz(azi, zen)
x, y, z = self._do_interpolate((x, y, z))
azi, zen = xyz2angle(x, y, z)
azi.attrs = aattrs
zen.attrs = zattrs
return azi, zen
def angles(self, azi_name, zen_name):
all_lat = self.geostuff["Latitude"].value
all_zen = self.geostuff[zen_name].value
all_azi = self.geostuff[azi_name].value
res = []
param_start = 0
for tpz_size, nb_tpz, start in zip(self.tpz_sizes, self.nb_tpzs,
self.group_locations):
lat = all_lat[:, start:start + nb_tpz + 1]
zen = all_zen[:, start:start + nb_tpz + 1]
azi = all_azi[:, start:start + nb_tpz + 1]
c_align = self.c_align[:, :, param_start:param_start + nb_tpz, :]
c_exp = self.c_exp[:, :, param_start:param_start + nb_tpz, :]
param_start += nb_tpz
if (np.max(azi) - np.min(azi) >
5) or (np.min(zen) < 10) or (np.max(abs(lat)) > 80):
expanded = []
for data in angle2xyz(azi, zen):
expanded.append(
expand_array(data, self.scans, c_align, c_exp,
self.scan_size, tpz_size, nb_tpz,
self.track_offset, self.scan_offset))
azi, zen = xyz2angle(*expanded)
res.append((azi, zen))
else:
expanded = []
for data in (azi, zen):
expanded.append(
expand_array(data, self.scans, c_align, c_exp,
self.scan_size, tpz_size, nb_tpz,
self.track_offset, self.scan_offset))
res.append(expanded)
azi, zen = zip(*res)
return da.hstack(azi), da.hstack(zen)
def angles(self, azi_name, zen_name):
all_lat = self.geostuff["Latitude"].value
all_zen = self.geostuff[zen_name].value
all_azi = self.geostuff[azi_name].value
res = []
param_start = 0
for tpz_size, nb_tpz, start in zip(self.tpz_sizes, self.nb_tpzs,
self.group_locations):
lat = all_lat[:, start:start + nb_tpz + 1]
zen = all_zen[:, start:start + nb_tpz + 1]
azi = all_azi[:, start:start + nb_tpz + 1]
c_align = self.c_align[:, :, param_start:param_start + nb_tpz, :]
c_exp = self.c_exp[:, :, param_start:param_start + nb_tpz, :]
param_start += nb_tpz
if (np.max(azi) - np.min(azi) > 5) or (np.min(zen) < 10) or (
np.max(abs(lat)) > 80):
expanded = []
for data in angle2xyz(azi, zen):
expanded.append(expand_array(
data, self.scans, c_align, c_exp, self.scan_size,
tpz_size, nb_tpz, self.track_offset, self.scan_offset))
azi, zen = xyz2angle(*expanded)
res.append((azi, zen))
else:
expanded = []
for data in (azi, zen):
expanded.append(expand_array(
data, self.scans, c_align, c_exp, self.scan_size,
tpz_size, nb_tpz, self.track_offset, self.scan_offset))
res.append(expanded)
azi, zen = zip(*res)
return da.hstack(azi), da.hstack(zen)
def test_xyz2angle(self):
azi, zen = xyz2angle(1, 0, 0)
self.assertAlmostEqual(azi, 90)
self.assertAlmostEqual(zen, 90)
azi, zen = xyz2angle(0, 1, 0)
self.assertAlmostEqual(azi, 0)
self.assertAlmostEqual(zen, 90)
azi, zen = xyz2angle(0, 0, 1)
self.assertAlmostEqual(azi, 0)
self.assertAlmostEqual(zen, 0)
azi, zen = xyz2angle(sqrt(2) / 2, sqrt(2) / 2, 0)
self.assertAlmostEqual(azi, 45)
self.assertAlmostEqual(zen, 90)
azi, zen = xyz2angle(-1, 0, 0)
self.assertAlmostEqual(azi, -90)
self.assertAlmostEqual(zen, 90)
azi, zen = xyz2angle(0, -1, 0)
self.assertAlmostEqual(azi, 180)
self.assertAlmostEqual(zen, 90)
def test_xyz2angle(self):
azi, zen = xyz2angle(1, 0, 0)
self.assertAlmostEqual(azi, 90)
self.assertAlmostEqual(zen, 90)
azi, zen = xyz2angle(0, 1, 0)
self.assertAlmostEqual(azi, 0)
self.assertAlmostEqual(zen, 90)
azi, zen = xyz2angle(0, 0, 1)
self.assertAlmostEqual(azi, 0)
self.assertAlmostEqual(zen, 0)
azi, zen = xyz2angle(sqrt(2) / 2, sqrt(2) / 2, 0)
self.assertAlmostEqual(azi, 45)
self.assertAlmostEqual(zen, 90)
azi, zen = xyz2angle(-1, 0, 0)
self.assertAlmostEqual(azi, -90)
self.assertAlmostEqual(zen, 90)
azi, zen = xyz2angle(0, -1, 0)
self.assertAlmostEqual(azi, 180)
self.assertAlmostEqual(zen, 90)
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
