def test_CythonInterface():
from isce3.extensions.isceextension import pyEllipsoid
import numpy.testing as npt
elp = pyEllipsoid(a=6387137., e2=0.00000001)
assert elp.a == 6387137.
assert elp.e2 == 0.00000001
def test_geo2rdr():
"""
Test single call to geo2rdr.
"""
import datetime
from osgeo import gdal
# Open the HDF5 SLC product for the master scene
h5 = isceextension.pyIH5File(iscetest.data + "envisat.h5")
# Create product
product = isceextension.pyProduct(h5)
# Make ISCE objects
ellps = isceextension.pyEllipsoid()
orbit = product.metadata.orbit
doppler = product.metadata.procInfo.dopplerCentroid(freq='A')
wvl = product.swathA.processedWavelength
side = product.lookSide
# Call geo2rdr
llh = [
np.radians(-115.72466801139711),
np.radians(34.65846532785868), 1772.0
]
aztime, slantrange = isceextension.py_geo2rdr(llh,
ellps,
orbit,
doppler,
wvl,
side,
threshold=1.0e-10,
dR=10.0)
# Test it
np.testing.assert_almost_equal(aztime, 237333.993088889, decimal=9)
np.testing.assert_almost_equal(slantrange, 830450.1859454865, decimal=6)
# Repeat with zero doppler
zero_doppler = isceextension.pyLUT2d()
aztime, slantrange = isceextension.py_geo2rdr(llh,
ellps,
orbit,
zero_doppler,
wvl,
side,
threshold=1.0e-10,
dR=10.0)
# Test it
np.testing.assert_almost_equal(aztime, 237334.1228937040, decimal=9)
np.testing.assert_almost_equal(slantrange, 830449.6727720449, decimal=6)
def test_lonLatToXyzPoints():
from isce3.extensions.isceextension import pyEllipsoid
import numpy.testing as npt
wgs84 = pyEllipsoid()
for entry in data:
tname = entry[0]
llh = entry[1]
xyz = entry[2]
res = wgs84.lonLatToXyz(llh)
npt.assert_array_almost_equal(xyz,
res,
decimal=6,
err_msg="Failed {0}".format(tname))
def test_lonLattoXyzArray():
from isce3.extensions.isceextension import pyEllipsoid
import numpy.testing as npt
tname = "lon lat to xyz array"
wgs84 = pyEllipsoid()
nPts = len(data)
llh = np.array([x[1] for x in data])
xyz = np.array([x[2] for x in data])
res = wgs84.lonLatToXyz(llh)
npt.assert_array_almost_equal(xyz,
res,
decimal=6,
err_msg="Failed {0}".format(tname))
def test_xyzToLonLatPoints():
from isce3.extensions.isceextension import pyEllipsoid
import numpy.testing as npt
wgs84 = pyEllipsoid()
for entry in data:
tname = entry[0]
llh = entry[1]
xyz = entry[2]
res = wgs84.xyzToLonLat(xyz)
npt.assert_array_almost_equal(llh[0:2],
res[0:2],
decimal=9,
err_msg="Failed {0}".format(tname))
npt.assert_array_almost_equal(llh[2],
res[2],
decimal=6,
err_msg="Failed {0}".format(tname))
def test_xyztoLonLatArray():
from isce3.extensions.isceextension import pyEllipsoid
import numpy.testing as npt
tname = "xyz to lat lon array"
wgs84 = pyEllipsoid()
nPts = len(data)
llh = np.array([x[1] for x in data])
xyz = np.array([x[2] for x in data])
res = wgs84.xyzToLonLat(xyz)
npt.assert_array_almost_equal(llh[:, :2],
res[:, :2],
decimal=9,
err_msg="Failed {0}".format(tname))
npt.assert_array_almost_equal(llh[:, 2],
res[:, 2],
decimal=6,
err_msg="Failed {0}".format(tname))
def _runGeocodeFrequency(self, frequency):
self._print(f'starting geocode module for frequency: {frequency}')
state = self.state
pol_list = state.subset_dict[frequency]
radar_grid = self.radar_grid_list[frequency]
orbit = self.orbit
raster_ref_list = []
for pol in pol_list:
h5_ds = f'//science/LSAR/SLC/swaths/frequency{frequency}/{pol}'
raster_ref = f'HDF5:"{state.input_hdf5}":{h5_ds}'
raster_ref_list.append(raster_ref)
self._print('raster list:', raster_ref_list)
self._print('pol list: ', pol_list)
# set temporary files
time_id = str(time.time())
input_temp = os.path.join(state.scratch_path,
f'temp_rslc2gcov_{frequency}_{time_id}.vrt')
output_file = os.path.join(state.scratch_path,
f'temp_rslc2gcov_{frequency}_{time_id}.bin')
output_off_diag_file = os.path.join(
state.scratch_path,
f'temp_rslc2gcov_{frequency}_{time_id}_off_diag.bin')
out_geo_nlooks = os.path.join(state.scratch_path,
f'temp_geo_nlooks_{time_id}.bin')
out_geo_rtc = os.path.join(state.scratch_path,
f'temp_geo_rtc_{time_id}.bin')
out_dem_vertices = os.path.join(state.scratch_path,
f'temp_dem_vertices_{time_id}.bin')
out_geo_vertices = os.path.join(state.scratch_path,
f'temp_geo_vertices_{time_id}.bin')
# build input VRT
gdal.BuildVRT(input_temp, raster_ref_list, separate=True)
input_raster_obj = isce3.pyRaster(input_temp)
ellps = isce3.pyEllipsoid()
# Reading processing parameters
flag_fullcovariance = self.get_value(
['processing', 'input_subset', 'fullcovariance'])
# RTC
rtc_dict = self.get_value(['processing', 'rtc'])
rtc_output_type = rtc_dict['output_type']
rtc_geogrid_upsampling = rtc_dict['geogrid_upsampling']
rtc_algorithm_type = rtc_dict['algorithm_type']
input_terrain_radiometry = rtc_dict['input_terrain_radiometry']
rtc_min_value_db = rtc_dict['rtc_min_value_db']
# Geocode
geocode_dict = self.get_value(['processing', 'geocode'])
geocode_algorithm_type = geocode_dict['algorithm_type']
memory_mode = geocode_dict['memory_mode']
geogrid_upsampling = geocode_dict['geogrid_upsampling']
abs_cal_factor = geocode_dict['abs_rad_cal']
clip_min = geocode_dict['clip_min']
clip_max = geocode_dict['clip_max']
min_nlooks = geocode_dict['min_nlooks']
flag_upsample_radar_grid = geocode_dict['upsample_radargrid']
flag_save_nlooks = geocode_dict['save_nlooks']
flag_save_rtc = geocode_dict['save_rtc']
flag_save_dem_vertices = geocode_dict['save_dem_vertices']
flag_save_geo_vertices = geocode_dict['save_geo_vertices']
# Geogrid
state.output_epsg = geocode_dict['outputEPSG']
y_snap = geocode_dict['y_snap']
x_snap = geocode_dict['x_snap']
y_max = geocode_dict['top_left']['y_abs']
x_min = geocode_dict['top_left']['x_abs']
y_min = geocode_dict['bottom_right']['y_abs']
x_max = geocode_dict['bottom_right']['x_abs']
step = geocode_dict['output_posting']
# fix types
rtc_min_value_db = self.cast_input(rtc_min_value_db,
dtype=float,
frequency=frequency)
state.output_epsg = self.cast_input(state.output_epsg,
dtype=int,
frequency=frequency)
geogrid_upsampling = self.cast_input(geogrid_upsampling,
dtype=float,
frequency=frequency)
rtc_geogrid_upsampling = self.cast_input(rtc_geogrid_upsampling,
dtype=float,
frequency=frequency)
abs_cal_factor = self.cast_input(abs_cal_factor,
dtype=float,
frequency=frequency)
clip_min = self.cast_input(clip_min,
dtype=float,
default=0,
frequency=frequency)
clip_max = self.cast_input(clip_max,
dtype=float,
default=2,
frequency=frequency)
min_nlooks = self.cast_input(min_nlooks, dtype=float, frequency=frequency)
y_snap = self.cast_input(y_snap,
dtype=float,
default=np.nan,
frequency=frequency)
x_snap = self.cast_input(x_snap,
dtype=float,
default=np.nan,
frequency=frequency)
y_max = self.cast_input(y_max,
dtype=float,
default=np.nan,
frequency=frequency)
x_min = self.cast_input(x_min,
dtype=float,
default=np.nan,
frequency=frequency)
y_min = self.cast_input(y_min,
dtype=float,
default=np.nan,
frequency=frequency)
x_max = self.cast_input(x_max,
dtype=float,
default=np.nan,
frequency=frequency)
step_x = self.cast_input(step,
dtype=float,
default=np.nan,
frequency=frequency)
step_y = -step_x if _is_valid(step_x) else None
# prepare parameters
zero_doppler = isce3.pyLUT2d()
# Instantiate Geocode object according to the raster type
if input_raster_obj.getDatatype() == gdal.GDT_Float32:
geo = isce3.pyGeocodeFloat(orbit, ellps)
elif input_raster_obj.getDatatype() == gdal.GDT_Float64:
geo = isce3.pyGeocodeDouble(orbit, ellps)
elif input_raster_obj.getDatatype() == gdal.GDT_CFloat32:
geo = isce3.pyGeocodeComplexFloat(orbit, ellps)
elif input_raster_obj.getDatatype() == gdal.GDT_CFloat64:
geo = isce3.pyGeocodeComplexDouble(orbit, ellps)
else:
raise NotImplementedError('Unsupported raster type for geocoding')
dem_raster = isce3.pyRaster(state.dem_file)
if state.output_epsg is None:
state.output_epsg = dem_raster.EPSG
if state.geotransform_dict is None:
state.geotransform_dict = {}
if (_is_valid(y_min) and _is_valid(y_max) and _is_valid(step_y)):
size_y = int(np.round((y_min - y_max) / step_y))
else:
size_y = -32768
if (_is_valid(x_max) and _is_valid(x_min) and _is_valid(step_x)):
size_x = int(np.round((x_max - x_min) / step_x))
else:
size_x = -32768
# if Geogrid is not fully determined, let Geocode find the missing values
if (size_x == -32768 or size_y == -32768):
geo.geoGrid(x_min, y_max, step_x, step_y, size_x, size_y,
state.output_epsg)
geo.updateGeoGrid(radar_grid, dem_raster)
# update only missing values
if not _is_valid(x_min):
x_min = geo.geoGridStartX
if not _is_valid(y_max):
y_max = geo.geoGridStartY
if not _is_valid(step_x):
step_x = geo.geoGridSpacingX
if not _is_valid(step_y):
step_y = geo.geoGridSpacingY
if not _is_valid(x_max):
x_max = geo.geoGridStartX + geo.geoGridSpacingX * geo.geoGridWidth
if not _is_valid(y_min):
y_min = geo.geoGridStartY + geo.geoGridSpacingY * geo.geoGridLength
x_min = _snap_coordinate(x_min, x_snap, np.floor)
y_max = _snap_coordinate(y_max, y_snap, np.ceil)
x_max = _snap_coordinate(x_max, x_snap, np.ceil)
y_min = _snap_coordinate(y_min, y_snap, np.floor)
size_y = int(np.round((y_min - y_max) / step_y))
size_x = int(np.round((x_max - x_min) / step_x))
geo.geoGrid(x_min, y_max, step_x, step_y, size_x, size_y,
state.output_epsg)
output_dir = os.path.dirname(output_file)
if output_dir and not os.path.isdir(output_dir):
os.makedirs(output_dir)
output_dtype = gdal.GDT_Float32
output_dtype_off_diag_terms = gdal.GDT_CFloat32
exponent = 2
nbands = input_raster_obj.numBands
if geogrid_upsampling is None:
geogrid_upsampling = 1
self._print(f'creating temporary output raster: {output_file}')
geocoded_dict = defaultdict(lambda: None)
output_raster_obj = isce3.pyRaster(output_file, gdal.GA_Update,
output_dtype, size_x, size_y, nbands,
"ENVI")
geocoded_dict['output_file'] = output_file
nbands_off_diag_terms = 0
out_off_diag_terms_obj = None
if flag_fullcovariance:
nbands_off_diag_terms = (nbands**2 - nbands) // 2
if nbands_off_diag_terms > 0:
out_off_diag_terms_obj = isce3.pyRaster(
output_off_diag_file, gdal.GA_Update,
output_dtype_off_diag_terms, size_x, size_y,
nbands_off_diag_terms, "ENVI")
geocoded_dict['output_off_diag_file'] = \
output_off_diag_file
if flag_save_nlooks:
out_geo_nlooks_obj = isce3.pyRaster(out_geo_nlooks, gdal.GA_Update,
gdal.GDT_Float32, size_x, size_y,
1, "ENVI")
geocoded_dict['out_geo_nlooks'] = out_geo_nlooks
else:
out_geo_nlooks_obj = None
if flag_save_rtc:
out_geo_rtc_obj = isce3.pyRaster(out_geo_rtc, gdal.GA_Update,
gdal.GDT_Float32, size_x, size_y, 1,
"ENVI")
geocoded_dict['out_geo_rtc'] = out_geo_rtc
else:
out_geo_rtc_obj = None
if flag_save_dem_vertices:
out_dem_vertices_obj = isce3.pyRaster(out_dem_vertices, gdal.GA_Update,
gdal.GDT_Float32, size_x + 1,
size_y + 1, 1, "ENVI")
geocoded_dict['out_dem_vertices'] = out_dem_vertices
else:
out_dem_vertices_obj = None
if flag_save_geo_vertices:
out_geo_vertices_obj = isce3.pyRaster(out_geo_vertices, gdal.GA_Update,
gdal.GDT_Float32, size_x + 1,
size_y + 1, 2, "ENVI")
geocoded_dict['out_geo_vertices'] = out_geo_vertices
else:
out_geo_vertices_obj = None
# Run geocoding
flag_apply_rtc = (rtc_output_type
and rtc_output_type != input_terrain_radiometry
and 'gamma' in rtc_output_type)
if flag_apply_rtc is None:
flag_apply_rtc = False
geotransform = [x_min, step_x, 0, y_max, 0, step_y]
state.geotransform_dict[frequency] = geotransform
# output mode
if ('interp' in geocode_algorithm_type and flag_apply_rtc):
raise NotImplementedError('ERROR interp algorithm does not provide'
' RTC correction')
elif 'interp' in geocode_algorithm_type:
output_mode = 'interp'
elif not flag_apply_rtc:
output_mode = 'area-projection'
else:
output_mode = 'area-projection-gamma_naught'
# input terrain radiometry
if (input_terrain_radiometry is not None
and 'sigma' in input_terrain_radiometry):
input_radiometry = 'sigma-naught-ellipsoid'
else:
input_radiometry = 'beta-naught'
if flag_apply_rtc:
output_radiometry_str = 'gamma-naught'
else:
output_radiometry_str = input_radiometry
# number of looks
radar_grid_nlooks = state.nlooks_az * state.nlooks_rg
# rtc min value
kwargs = {}
if rtc_min_value_db is not None:
kwargs['rtc_min_value_db'] = rtc_min_value_db
# absolute calibration factor
if abs_cal_factor is not None:
kwargs['abs_cal_factor'] = abs_cal_factor
# memory mode
if memory_mode is not None:
kwargs['memory_mode'] = memory_mode
if (rtc_algorithm_type is not None
and ('DAVID' in rtc_algorithm_type.upper()
or 'SMALL' in rtc_algorithm_type.upper())):
kwargs['rtc_algorithm'] = 'RTC_DAVID_SMALL'
elif rtc_algorithm_type is not None:
kwargs['rtc_algorithm'] = 'RTC_AREA_PROJECTION'
if (rtc_geogrid_upsampling is not None
and np.isfinite(rtc_geogrid_upsampling)):
kwargs['rtc_upsampling'] = rtc_geogrid_upsampling
if clip_min is not None:
kwargs['clip_min'] = clip_min
if clip_max is not None:
kwargs['clip_max'] = clip_max
if min_nlooks is not None:
kwargs['min_nlooks'] = min_nlooks
# call the geocode module
geo.geocode(radar_grid,
input_raster_obj,
output_raster_obj,
dem_raster,
flag_upsample_radar_grid=flag_upsample_radar_grid,
output_mode=output_mode,
upsampling=geogrid_upsampling,
input_radiometry=input_radiometry,
exponent=exponent,
radar_grid_nlooks=radar_grid_nlooks,
out_off_diag_terms=out_off_diag_terms_obj,
out_geo_nlooks=out_geo_nlooks_obj,
out_geo_rtc=out_geo_rtc_obj,
out_dem_vertices=out_dem_vertices_obj,
out_geo_vertices=out_geo_vertices_obj,
**kwargs)
del output_raster_obj
if flag_save_nlooks:
del out_geo_nlooks_obj
if flag_save_rtc:
del out_geo_rtc_obj
if flag_fullcovariance:
del out_off_diag_terms_obj
if flag_save_dem_vertices:
del out_dem_vertices_obj
if flag_save_geo_vertices:
del out_geo_vertices_obj
self._print(f'removing temporary file: {input_temp}')
_remove(input_temp)
output_hdf5 = state.output_hdf5
h5_ds_list = []
with h5py.File(output_hdf5, 'a') as hdf5_obj:
hdf5_obj.attrs['Conventions'] = np.string_("CF-1.8")
root_ds = os.path.join('//', 'science', 'LSAR', 'GCOV', 'grids',
f'frequency{frequency}')
# radiometricTerrainCorrectionFlag
h5_ds = os.path.join(root_ds, 'listOfPolarizations')
if h5_ds in hdf5_obj:
del hdf5_obj[h5_ds]
pol_list_s2 = np.array(pol_list, dtype='S2')
dset = hdf5_obj.create_dataset(h5_ds, data=pol_list_s2)
h5_ds_list.append(h5_ds)
dset.attrs['description'] = np.string_(
'List of processed polarization layers with frequency ' +
frequency)
h5_ds = os.path.join(root_ds, 'radiometricTerrainCorrectionFlag')
if h5_ds in hdf5_obj:
del hdf5_obj[h5_ds]
dset = hdf5_obj.create_dataset(h5_ds,
data=np.string_(str(flag_apply_rtc)))
h5_ds_list.append(h5_ds)
# X and Y coordinates
geotransform = self.state.geotransform_dict[frequency]
dx = geotransform[1]
dy = geotransform[5]
x0 = geotransform[0] + 0.5 * dx
y0 = geotransform[3] + 0.5 * dy
xf = x0 + (size_x - 1) * dx
yf = y0 + (size_y - 1) * dy
# xCoordinates
h5_ds = os.path.join(root_ds, 'xCoordinates') # float64
x_vect = np.linspace(x0, xf, size_x, dtype=np.float64)
if h5_ds in hdf5_obj:
del hdf5_obj[h5_ds]
xds = hdf5_obj.create_dataset(h5_ds, data=x_vect)
h5_ds_list.append(h5_ds)
try:
xds.make_scale()
except AttributeError:
pass
# yCoordinates
h5_ds = os.path.join(root_ds, 'yCoordinates') # float64
y_vect = np.linspace(y0, yf, size_y, dtype=np.float64)
if h5_ds in hdf5_obj:
del hdf5_obj[h5_ds]
yds = hdf5_obj.create_dataset(h5_ds, data=y_vect)
h5_ds_list.append(h5_ds)
try:
yds.make_scale()
except AttributeError:
pass
#Associate grid mapping with data - projection created later
h5_ds = os.path.join(root_ds, "projection")
#Set up osr for wkt
srs = osr.SpatialReference()
srs.ImportFromEPSG(self.state.output_epsg)
###Create a new single int dataset for projections
if h5_ds in hdf5_obj:
del hdf5_obj[h5_ds]
projds = hdf5_obj.create_dataset(h5_ds, (), dtype='i')
projds[()] = self.state.output_epsg
h5_ds_list.append(h5_ds)
##WGS84 ellipsoid
projds.attrs['semi_major_axis'] = 6378137.0
projds.attrs['inverse_flattening'] = 298.257223563
projds.attrs['ellipsoid'] = np.string_("WGS84")
##Additional fields
projds.attrs['epsg_code'] = self.state.output_epsg
##CF 1.7+ requires this attribute to be named "crs_wkt"
##spatial_ref is old GDAL way. Using that for testing only.
##For NISAR replace with "crs_wkt"
projds.attrs['spatial_ref'] = np.string_(srs.ExportToWkt())
##Here we have handcoded the attributes for the different cases
##Recommended method is to use pyproj.CRS.to_cf() as shown above
##To get complete set of attributes.
###Geodetic latitude / longitude
if self.state.output_epsg == 4326:
#Set up grid mapping
projds.attrs['grid_mapping_name'] = np.string_(
'latitude_longitude')
projds.attrs['longitude_of_prime_meridian'] = 0.0
#Setup units for x and y
xds.attrs['standard_name'] = np.string_("longitude")
xds.attrs['units'] = np.string_("degree_east")
yds.attrs['standard_name'] = np.string_("latitude")
yds.attrs['units'] = np.string_("degree_north")
### UTM zones
elif (
(self.state.output_epsg > 32600 and self.state.output_epsg < 32661)
or (self.state.output_epsg > 32700
and self.state.output_epsg < 32761)):
#Set up grid mapping
projds.attrs['grid_mapping_name'] = np.string_(
'universal_transverse_mercator')
projds.attrs['utm_zone_number'] = self.state.output_epsg % 100
#Setup units for x and y
xds.attrs['standard_name'] = np.string_("projection_x_coordinate")
xds.attrs['long_name'] = np.string_("x coordinate of projection")
xds.attrs['units'] = np.string_("m")
yds.attrs['standard_name'] = np.string_("projection_y_coordinate")
yds.attrs['long_name'] = np.string_("y coordinate of projection")
yds.attrs['units'] = np.string_("m")
### Polar Stereo North
elif self.state.output_epsg == 3413:
#Set up grid mapping
projds.attrs['grid_mapping_name'] = np.string_(
"polar_stereographic")
projds.attrs['latitude_of_projection_origin'] = 90.0
projds.attrs['standard_parallel'] = 70.0
projds.attrs['straight_vertical_longitude_from_pole'] = -45.0
projds.attrs['false_easting'] = 0.0
projds.attrs['false_northing'] = 0.0
#Setup units for x and y
xds.attrs['standard_name'] = np.string_("projection_x_coordinate")
xds.attrs['long_name'] = np.string_("x coordinate of projection")
xds.attrs['units'] = np.string_("m")
yds.attrs['standard_name'] = np.string_("projection_y_coordinate")
yds.attrs['long_name'] = np.string_("y coordinate of projection")
yds.attrs['units'] = np.string_("m")
### Polar Stereo south
elif self.state.output_epsg == 3031:
#Set up grid mapping
projds.attrs['grid_mapping_name'] = np.string_(
"polar_stereographic")
projds.attrs['latitude_of_projection_origin'] = -90.0
projds.attrs['standard_parallel'] = -71.0
projds.attrs['straight_vertical_longitude_from_pole'] = 0.0
projds.attrs['false_easting'] = 0.0
projds.attrs['false_northing'] = 0.0
#Setup units for x and y
xds.attrs['standard_name'] = np.string_("projection_x_coordinate")
xds.attrs['long_name'] = np.string_("x coordinate of projection")
xds.attrs['units'] = np.string_("m")
yds.attrs['standard_name'] = np.string_("projection_y_coordinate")
yds.attrs['long_name'] = np.string_("y coordinate of projection")
yds.attrs['units'] = np.string_("m")
### EASE 2 for soil moisture L3
elif self.state.output_epsg == 6933:
#Set up grid mapping
projds.attrs['grid_mapping_name'] = np.string_(
"lambert_cylindrical_equal_area")
projds.attrs['longitude_of_central_meridian'] = 0.0
projds.attrs['standard_parallel'] = 30.0
projds.attrs['false_easting'] = 0.0
projds.attrs['false_northing'] = 0.0
#Setup units for x and y
xds.attrs['standard_name'] = np.string_("projection_x_coordinate")
xds.attrs['long_name'] = np.string_("x coordinate of projection")
xds.attrs['units'] = np.string_("m")
yds.attrs['standard_name'] = np.string_("projection_y_coordinate")
yds.attrs['long_name'] = np.string_("y coordinate of projection")
yds.attrs['units'] = np.string_("m")
### Europe Equal Area for Deformation map (to be implemented in isce3)
elif self.state.output_epsg == 3035:
#Set up grid mapping
projds.attrs['grid_mapping_name'] = np.string_(
"lambert_azimuthal_equal_area")
projds.attrs['longitude_of_projection_origin'] = 10.0
projds.attrs['latitude_of_projection_origin'] = 52.0
projds.attrs['standard_parallel'] = -71.0
projds.attrs['straight_vertical_longitude_from_pole'] = 0.0
projds.attrs['false_easting'] = 4321000.0
projds.attrs['false_northing'] = 3210000.0
#Setup units for x and y
xds.attrs['standard_name'] = np.string_("projection_x_coordinate")
xds.attrs['long_name'] = np.string_("x coordinate of projection")
xds.attrs['units'] = np.string_("m")
yds.attrs['standard_name'] = np.string_("projection_y_coordinate")
yds.attrs['long_name'] = np.string_("y coordinate of projection")
yds.attrs['units'] = np.string_("m")
else:
raise NotImplementedError(
'Waiting for implementation / Not supported in ISCE3')
# save GCOV diagonal elements
diag_terms_list = [p.upper() + p.upper() for p in pol_list]
_save_hdf5_dataset(self,
'output_file',
hdf5_obj,
root_ds,
h5_ds_list,
geocoded_dict,
frequency,
yds,
xds,
diag_terms_list,
standard_name=output_radiometry_str,
long_name=output_radiometry_str,
units='unitless',
fill_value=np.nan,
valid_min=clip_min,
valid_max=clip_max)
# save GCOV off-diagonal elements
if flag_fullcovariance:
off_diag_terms_list = []
for b1, p1 in enumerate(pol_list):
for b2, p2 in enumerate(pol_list):
if (b2 <= b1):
continue
off_diag_terms_list.append(p1.upper() + p2.upper())
_save_hdf5_dataset(self,
'output_off_diag_file',
hdf5_obj,
root_ds,
h5_ds_list,
geocoded_dict,
frequency,
yds,
xds,
off_diag_terms_list,
standard_name=output_radiometry_str,
long_name=output_radiometry_str,
units='unitless',
fill_value=np.nan,
valid_min=clip_min,
valid_max=clip_max)
# save nlooks
_save_hdf5_dataset(self,
'out_geo_nlooks',
hdf5_obj,
root_ds,
h5_ds_list,
geocoded_dict,
frequency,
yds,
xds,
'numberOfLooks',
standard_name='numberOfLooks',
long_name='number of looks',
units='looks',
fill_value=np.nan,
valid_min=0)
# save rtc
if flag_apply_rtc:
_save_hdf5_dataset(self,
'out_geo_rtc',
hdf5_obj,
root_ds,
h5_ds_list,
geocoded_dict,
frequency,
yds,
xds,
'areaNormalizationFactor',
standard_name='areaNormalizationFactor',
long_name='RTC area factor',
units='unitless',
fill_value=np.nan,
valid_min=0,
valid_max=2)
if ('out_dem_vertices' in geocoded_dict
or 'out_geo_vertices' in geocoded_dict):
# X and Y coordinates
geotransform = self.state.geotransform_dict[frequency]
dx = geotransform[1]
dy = geotransform[5]
x0 = geotransform[0]
y0 = geotransform[3]
xf = xf + size_x * dx
yf = yf + size_y * dy
# xCoordinates
h5_ds = os.path.join(root_ds, 'xCoordinatesVertices') # float64
x_vect_vertices = np.linspace(x0, xf, size_x + 1, dtype=np.float64)
if h5_ds in hdf5_obj:
del hdf5_obj[h5_ds]
xds_vertices = hdf5_obj.create_dataset(h5_ds, data=x_vect_vertices)
h5_ds_list.append(h5_ds)
try:
xds_vertices.make_scale()
except AttributeError:
pass
# yCoordinates
h5_ds = os.path.join(root_ds, 'yCoordinatesVertices') # float64
y_vect_vertices = np.linspace(y0, yf, size_y + 1, dtype=np.float64)
if h5_ds in hdf5_obj:
del hdf5_obj[h5_ds]
yds_vertices = hdf5_obj.create_dataset(h5_ds, data=y_vect_vertices)
h5_ds_list.append(h5_ds)
try:
yds_vertices.make_scale()
except AttributeError:
pass
# save geo grid
_save_hdf5_dataset(self,
'out_dem_vertices',
hdf5_obj,
root_ds,
h5_ds_list,
geocoded_dict,
frequency,
yds_vertices,
xds_vertices,
'interpolatedDem',
standard_name='interpolatedDem',
long_name='interpolated dem',
units='meters',
fill_value=np.nan,
valid_min=-500,
valid_max=9000)
# save geo vertices
_save_hdf5_dataset(self, 'out_geo_vertices', hdf5_obj, root_ds,
h5_ds_list, geocoded_dict, frequency,
yds_vertices, xds_vertices,
['vertices_a', 'vertices_r'])
for h5_ds_str in h5_ds_list:
h5_ref = f'HDF5:{output_hdf5}:{h5_ds_str}'
state.outputList[frequency].append(h5_ref)