def test_createGeoTiffFloat():
from isce3.extensions.isceextension import pyRaster
import os
import numpy as np
cmn = commonClass()
if os.path.exists(cmn.latFilename):
os.remove(cmn.latFilename)
raster = pyRaster(cmn.latFilename,
width=cmn.nc,
length=cmn.nl,
numBands=1,
dtype=gdal.GDT_Float32,
driver='GTiff',
access=gdal.GA_Update)
assert (os.path.exists(cmn.latFilename))
assert (raster.width == cmn.nc)
assert (raster.length == cmn.nl)
assert (raster.numBands == 1)
assert (raster.getDatatype() == gdal.GDT_Float32)
del raster
data = np.zeros((cmn.nl, cmn.nc))
data[:, :] = np.arange(cmn.nc)[None, :]
ds = gdal.Open(cmn.latFilename, gdal.GA_Update)
ds.GetRasterBand(1).WriteArray(data)
ds = None
def test_createMultiBandVRT():
from isce3.extensions.isceextension import pyRaster
import os
cmn = commonClass()
lat = pyRaster(cmn.latFilename)
lon = pyRaster(cmn.lonFilename)
inc = pyRaster(cmn.incFilename)
if os.path.exists(cmn.vrtFilename):
os.remove(cmn.vrtFilename)
vrt = pyRaster(cmn.vrtFilename, collection=[lat, lon, inc])
assert (vrt.width == cmn.nc)
assert (vrt.length == cmn.nl)
assert (vrt.numBands == 4)
assert (vrt.getDatatype(1) == gdal.GDT_Float32)
assert (vrt.getDatatype(2) == gdal.GDT_Float64)
assert (vrt.getDatatype(3) == gdal.GDT_Int16)
assert (vrt.getDatatype(4) == gdal.GDT_Int16)
vrt = None
def test_raster_filenotfound():
"""
Test resulting exception when a raster is created from a nonexistent file
"""
global err
try:
# Open a nonexistent file
pyRaster("nonexistent_filename")
# We shouldn't be here (exception should be raised)
assert (False)
except Exception as e:
err = e
# Extract error info
filename = e.args[0][0] # which C++ file the error was raised from
lineno = e.args[0][1] # which line number in that file
funcname = e.args[0][2] # the name of the C++ function
errmsg = e.args[1] # a string containing all of the above,
# as a readymade printable error message
# check types
assert (type(filename) is str)
assert (type(lineno) is int)
assert (type(funcname) is str)
# check error message
assert (filename in errmsg)
assert (str(lineno) in errmsg)
assert (funcname in errmsg)
# check values
assert ("Raster.cpp" in filename)
assert ("Raster(" in funcname)
def test_createNumpyDataset():
import numpy as np
from isce3.extensions.isceextension import pyRaster
from osgeo import gdal_array
import os
ny, nx = 200, 100
data = np.random.randn(ny, nx).astype(np.float32)
dset = gdal_array.OpenArray(data)
raster = pyRaster('', dataset=dset)
assert (raster.width == nx)
assert (raster.length == ny)
assert (raster.getDatatype() == 6)
dset = None
del raster
def testh5pyReadOnly():
from isce3.extensions.isceextension import pyRaster
import os
#Create and write to file
fid = h5py.File('test.h5', 'w')
ds = fid.create_dataset('data', shape=(50, 70), dtype=numpy.float32)
ds[:] = numpy.arange(50 * 70).reshape((50, 70))
img = pyRaster('', h5=ds)
assert (img.width == 70)
assert (img.length == 50)
assert (img.numBands == 1)
assert (img.getDatatype() == gdal.GDT_Float32)
assert (img.isReadOnly == True)
del img
fid.close()
os.remove('test.h5')
def test_createVRTDouble_setGetValue():
from isce3.extensions.isceextension import pyRaster
import os
import numpy as np
import numpy.testing as npt
cmn = commonClass()
if os.path.exists(cmn.lonFilename):
os.remove(cmn.lonFilename)
raster = pyRaster(cmn.lonFilename,
width=cmn.nc,
length=cmn.nl,
numBands=1,
dtype=gdal.GDT_Float64,
driver='VRT',
access=gdal.GA_Update)
assert (os.path.exists(cmn.lonFilename))
assert (raster.getDatatype() == gdal.GDT_Float64)
del raster
data = np.zeros((cmn.nl, cmn.nc))
data[:, :] = np.arange(cmn.nl)[:, None]
##Open and populate
ds = gdal.Open(cmn.lonFilename, gdal.GA_Update)
ds.GetRasterBand(1).WriteArray(data)
arr = ds.GetRasterBand(1).ReadAsArray()
npt.assert_array_equal(data, arr, err_msg='RW in Update mode')
ds = None
##Read array
ds = gdal.Open(cmn.lonFilename, gdal.GA_ReadOnly)
arr = ds.GetRasterBand(1).ReadAsArray()
ds = None
npt.assert_array_equal(data, arr, err_msg='Readonly mode')
def test_createTwoBandEnvi():
from isce3.extensions.isceextension import pyRaster
import os
import numpy as np
cmn = commonClass()
if os.path.exists(cmn.incFilename):
os.remove(cmn.incFilename)
raster = pyRaster(cmn.incFilename,
width=cmn.nc,
length=cmn.nl,
numBands=2,
dtype=gdal.GDT_Int16,
driver='ENVI',
access=gdal.GA_Update)
assert (os.path.exists(cmn.incFilename))
assert (raster.width == cmn.nc)
assert (raster.length == cmn.nl)
assert (raster.numBands == 2)
assert (raster.getDatatype() == gdal.GDT_Int16)
del raster
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)
def test_deminterp(code):
'''
Unit test for dem interpolator.
'''
import numpy as np
import numpy.testing as npt
import os
from osgeo import gdal
import isce3.extensions.isceextension as isceextension
if gdal.VersionInfo()[0] == '3':
latIndex = 0
else:
latIndex = 1
tifffile = "epsg{0}.tif".format(code)
if os.path.exists(tifffile):
os.remove(tifffile)
###Create the file
trans = createTiffDEM(code, tifffile)
###Create the raster
raster = isceextension.pyRaster(tifffile)
####Create interpolator
intp = isceextension.pyDEMInterpolator()
###Get geotransform
geotrans = raster.GeoTransform
width = raster.width
lgth = raster.length
minX = geotrans[0]
maxX = minX + width * geotrans[1]
maxY = geotrans[3]
minY = maxY + geotrans[5] * lgth
###Load the DEM
intp.loadDEM(raster)
### Pick 25 points in random
Xs = geotrans[0] + np.linspace(5, width-6,5) * geotrans[1]
Ys = geotrans[3] + np.linspace(5, width-6,5) * geotrans[5]
###Test values first
for ii in range(5):
for jj in range(5):
res = trans.TransformPoint(Xs[ii], Ys[jj], 0.)
val = 100.0 * res[latIndex]
hxy = intp.interpolateXY(Xs[ii], Ys[jj])
npt.assert_almost_equal(hxy, val, decimal=3)
hll = intp.interpolateLonLat(np.radians(res[1-latIndex]), np.radians(res[latIndex]))
npt.assert_almost_equal(hll, val, decimal=3)
if os.path.exists(tifffile):
os.remove(tifffile)
