def read(self, filename, **kwargs):
"""
:param filename: ROI_PAC binary file
:type filename: str
:param par_file: Corresponding parameter (:file:`*rsc`) file.
(optional)
:type par_file: str
:returns: Import dictionary
:rtype: dict
:raises: ImportError
"""
par_file = kwargs.pop('par_file', self._getParameterFile(filename))
par = self._parseParameterFile(par_file)
nlines = int(par['FILE_LENGTH'])
nrows = int(par['WIDTH'])
wavelength = par['WAVELENGTH']
heading = par['HEADING_DEG']
lat_ref = par['LAT_REF1']
lon_ref = par['LON_REF1']
look_ref1 = par['LOOK_REF1']
look_ref2 = par['LOOK_REF2']
look_ref3 = par['LOOK_REF3']
look_ref4 = par['LOOK_REF4']
utm_zone_letter = utm.latitude_to_zone_letter(
par['LAT_REF1'])
utm_zone = utm.latlon_to_zone_number(par['LAT_REF1'], par['LON_REF1'])
look = num.mean(
num.array([look_ref1, look_ref2, look_ref3, look_ref4]))
data = num.memmap(filename, dtype='<f4')
data = data.reshape(nlines, nrows*2)
displ = data[:, nrows:]
displ[displ == -0.] = num.nan
displ = displ / (4.*num.pi) * wavelength
z_scale = par.get('Z_SCALE', 1.)
z_offset = par.get('Z_OFFSET', 0.)
displ += z_offset
displ *= z_scale
c = self.container
c.displacement = displ
c.theta = 90. - look
c.phi = -heading - 180
c.meta.title = par.get('TITLE', 'None')
c.meta.wavelength = par['WAVELENGTH']
c.bin_file = filename
c.par_file = par_file
c.frame.llLat = par['Y_FIRST'] + par['Y_STEP'] * nrows
c.frame.llLon = par['X_FIRST']
c.frame.dLon = par['X_STEP']
c.frame.dLat = par['Y_STEP']
return self.container
def utm_from_latlon(lats, lons):
import utm
import pyproj
n = utm.latlon_to_zone_number(lats[0], lons[0])
l = utm.latitude_to_zone_letter(lats[0])
proj_src = pyproj.Proj('+proj=latlong')
proj_dst = pyproj.Proj('+proj=utm +zone={}{}'.format(n, l))
return pyproj.transform(proj_src, proj_dst, lons, lats)
def utm_from_latlon(lats, lons):
"""
Fast function to convert latitudes, longitudes to UTM coordinates.
"""
import utm
import pyproj
n = utm.latlon_to_zone_number(lats[0], lons[0])
l = utm.latitude_to_zone_letter(lats[0])
proj_src = pyproj.Proj('+proj=latlong')
srs = '+proj=utm +zone={}{}'.format(n, l)
if l < 'N': # latitude bands in the southern hemisphere range from 'C' to 'M'
srs += ' +south'
proj_dst = pyproj.Proj(srs)
return pyproj.transform(proj_src, proj_dst, lons, lats)
def get_utm_zone(x, y, epsg_in=4326):
# type: (float, float, int) -> (int, str)
"""
Get UTM zone from a given coordinate.
:param x: x-coordinate
:param y: y-coordinate
:param epsg_in: EPSG code of input coordinates
:return: Tuple of UTM zone number as integer and Hemisphere as string
"""
if epsg_in != 4326:
x, y = project_coords_epsg(x, y, epsg_in, 4326)
zone_num = utm.latlon_to_zone_number(y, x)
zone_letter = utm.latitude_to_zone_letter(y)
zone_letter = 'N' if zone_letter > 'M' else 'S'
return zone_num, zone_letter
def read(self, filename, **kwargs):
"""
:param filename: ROI_PAC binary file
:type filename: str
:param par_file: Corresponding parameter (:file:`*rsc`) file.
(optional)
:type par_file: str
:returns: Import dictionary
:rtype: dict
:raises: ImportError
"""
par_file = kwargs.pop('par_file', self._getParameterFile(filename))
par, geo_ref = self._parseParameterFile(par_file)
nlines = int(par['FILE_LENGTH'])
nrows = int(par['WIDTH'])
wavelength = par['WAVELENGTH']
heading = par['HEADING_DEG']
if geo_ref == 'latlon':
lat_ref = par['Y_FIRST']
lon_ref = par['X_FIRST']
elif geo_ref == 'all':
lat_ref = par['LAT_REF3']
lon_ref = par['LON_REF3']
look_ref1 = par['LOOK_REF1']
look_ref2 = par['LOOK_REF2']
look_ref3 = par['LOOK_REF3']
look_ref4 = par['LOOK_REF4']
utm_zone_letter = utm.latitude_to_zone_letter(lat_ref)
utm_zone = utm.latlon_to_zone_number(lat_ref, lon_ref)
look = num.mean(
num.array([look_ref1, look_ref2, look_ref3, look_ref4]))
data = num.memmap(filename, dtype='<f4')
data = data.reshape(nlines, nrows*2)
displ = data[:, nrows:]
displ = num.flipud(displ)
displ[displ == -0.] = num.nan
displ = displ / (4.*num.pi) * wavelength
z_scale = par.get('Z_SCALE', 1.)
z_offset = par.get('Z_OFFSET', 0.)
displ += z_offset
displ *= z_scale
c = self.container
c.displacement = displ
c.theta = num.deg2rad(90. - look)
c.phi = num.deg2rad(-heading + 180.)
c.meta.title = par.get('TITLE', 'None')
c.meta.wavelength = par['WAVELENGTH']
c.bin_file = filename
c.par_file = par_file
if geo_ref == 'all':
if par['X_UNIT'] == 'meters':
c.frame.spacing = 'meter'
c.frame.dE = par['X_STEP']
c.frame.dN = -par['Y_STEP']
geo_ref = 'utm'
elif par['X_UNIT'] == 'degree':
c.frame.spacing = 'degree'
geo_ref = 'latlon'
elif geo_ref == 'latlon':
self._log.info('Georeferencing is in Lat-Lon [degrees].')
c.frame.spacing = 'degree'
c.frame.llLat = par['Y_FIRST'] + par['Y_STEP'] * nrows
c.frame.llLon = par['X_FIRST']
# c_utm_0 = utm.from_latlon(lat_ref, lon_ref)
# c_utm_1 = utm.from_latlon(lat_ref + par['Y_STEP'],
# lon_ref + par['X_STEP'])
# c.frame.dE = c_utm_1[0] - c_utm_0[0]
# c.frame.dN = abs(c_utm_1[1] - c_utm_0[1])
c.frame.dE = par['X_STEP']
c.frame.dN = -par['Y_STEP']
elif geo_ref == 'utm':
self._log.info('Georeferencing is in UTM (zone %d%s)',
utm_zone, utm_zone_letter)
y_ll = par['Y_FIRST'] + par['Y_STEP'] * nrows
c.frame.llLat, c.frame.llLon = utm.to_latlon(
par['X_FIRST'], y_ll, utm_zone,
zone_letter=utm_zone_letter)
return self.container
def read(self, filename, **kwargs):
"""
:param filename: Gamma software parameter file
:type filename: str
:param par_file: Corresponding parameter (:file:`*par`) file.
(optional)
:type par_file: str
:returns: Import dictionary
:rtype: dict
:raises: ImportError
"""
par_file = kwargs.pop('par_file', filename)
params = self._getParameters(par_file, log=True)
try:
params_slc = self._getSLCParameters(par_file)
except ImportError as e:
raise e
fill = None
nrows = int(params['width'])
nlines = int(params['nlines'])
radar_frequency = params_slc.get('radar_frequency', None)
displ = num.fromfile(filename, dtype='>f4')
# Resize array if last line is not scanned completely
if (displ.size % nrows) != 0:
fill = num.empty(nrows - displ.size % nrows)
fill.fill(num.nan)
displ = num.append(displ, fill)
displ = displ.reshape(nlines, nrows)
displ[displ == -0.] = num.nan
displ = num.flipud(displ)
if radar_frequency is not None:
radar_frequency = float(radar_frequency)
self._log.info('Scaling displacement by radar_frequency %f GHz'
% (radar_frequency/1e9))
wavelength = util.C / radar_frequency
displ /= -4*num.pi
displ *= wavelength
else:
wavelength = 'None'
self._log.warning(
'Could not determine radar_frequency from *.slc.par file!'
' Leaving displacement to radians.')
phi = self._getLOSAngles(filename, '*phi*')
theta = self._getLOSAngles(filename, '*theta*')
theta = theta
if isinstance(phi, num.ndarray):
phi = phi.reshape(nlines, nrows)
phi = num.flipud(phi)
if isinstance(theta, num.ndarray):
theta = theta.reshape(nlines, nrows)
theta = num.flipud(theta)
if fill is not None:
theta = num.append(theta, fill)
phi = num.append(phi, fill)
c = self.container
c.displacement = displ
c.theta = theta
c.phi = phi
c.meta.wavelength = wavelength
c.meta.title = params.get('title', 'None')
c.bin_file = filename
c.par_file = par_file
if params['DEM_projection'] == 'UTM':
utm_zone = params['projection_zone']
try:
utm_zone_letter = utm.latitude_to_zone_letter(
params['center_latitude'])
except ValueError:
self._log.warning('Could not parse UTM Zone letter,'
' defaulting to N!')
utm_zone_letter = 'N'
self._log.info('Using UTM reference: Zone %d%s'
% (utm_zone, utm_zone_letter))
dN = params['post_north']
dE = params['post_east']
utm_corn_e = params['corner_east']
utm_corn_n = params['corner_north']
utm_corn_eo = utm_corn_e + dE * displ.shape[1]
utm_corn_no = utm_corn_n + dN * displ.shape[0]
utm_e = num.linspace(utm_corn_e, utm_corn_eo, displ.shape[1])
utm_n = num.linspace(utm_corn_n, utm_corn_no, displ.shape[0])
llLat, llLon = utm.to_latlon(utm_e.min(), utm_n.min(),
utm_zone, utm_zone_letter)
c.frame.llLat = llLat
c.frame.llLon = llLon
c.frame.dE = abs(dE)
c.frame.dN = abs(dN)
else:
self._log.info('Using Lat/Lon reference')
c.frame.spacing = 'degree'
c.frame.llLat = params['corner_lat'] \
+ params['post_lat'] * nrows
c.frame.llLon = params['corner_lon']
c.frame.dE = abs(params['post_lon'])
c.frame.dN = abs(params['post_lat'])
return c
def read(self, filename, **kwargs):
"""
:param filename: ROI_PAC binary file
:type filename: str
:param par_file: Corresponding parameter (:file:`*rsc`) file.
(optional)
:type par_file: str
:returns: Import dictionary
:rtype: dict
:raises: ImportError
"""
par_file = kwargs.pop("par_file", self._getParameterFile(filename))
par, geo_ref = self._parseParameterFile(par_file)
nlines = int(par["FILE_LENGTH"])
ncols = int(par["WIDTH"])
wavelength = par["WAVELENGTH"]
heading = par["HEADING_DEG"]
if geo_ref == "latlon":
lat_ref = par["Y_FIRST"]
lon_ref = par["X_FIRST"]
elif geo_ref == "all":
lat_ref = par["LAT_REF3"]
lon_ref = par["LON_REF3"]
look_ref1 = par["LOOK_REF1"]
look_ref2 = par["LOOK_REF2"]
look_ref3 = par["LOOK_REF3"]
look_ref4 = par["LOOK_REF4"]
utm_zone_letter = utm.latitude_to_zone_letter(lat_ref)
utm_zone = utm.latlon_to_zone_number(lat_ref, lon_ref)
look = num.mean(num.array([look_ref1, look_ref2, look_ref3,
look_ref4]))
data = num.memmap(filename, dtype="<f4")
data = data.reshape(nlines, ncols * 2)
displ = data[:, ncols:]
displ = num.flipud(displ)
displ[displ == -0.0] = num.nan
displ = displ / (4.0 * num.pi) * wavelength
z_scale = par.get("Z_SCALE", 1.0)
z_offset = par.get("Z_OFFSET", 0.0)
displ += z_offset
displ *= z_scale
container = self.container
container.displacement = displ
container.theta = num.deg2rad(90.0 - look)
container.phi = num.deg2rad(-heading + 180.0)
container.meta.title = par.get("TITLE", "None")
container.meta.wavelength = par["WAVELENGTH"]
container.bin_file = filename
container.par_file = par_file
if geo_ref == "all":
if par["X_UNIT"] == "meters":
container.frame.spacing = "meter"
container.frame.dE = par["X_STEP"]
container.frame.dN = -par["Y_STEP"]
geo_ref = "utm"
elif par["X_UNIT"] == "degree":
container.frame.spacing = "degree"
geo_ref = "latlon"
elif geo_ref == "latlon":
self._log.info("Georeferencing is in Lat-Lon [degrees].")
container.frame.spacing = "degree"
container.frame.llLat = par["Y_FIRST"] + par["Y_STEP"] * nlines
container.frame.llLon = par["X_FIRST"]
# c_utm_0 = utm.from_latlon(lat_ref, lon_ref)
# c_utm_1 = utm.from_latlon(lat_ref + par['Y_STEP'],
# lon_ref + par['X_STEP'])
# c.frame.dE = c_utm_1[0] - c_utm_0[0]
# c.frame.dN = abs(c_utm_1[1] - c_utm_0[1])
container.frame.dE = par["X_STEP"]
container.frame.dN = -par["Y_STEP"]
elif geo_ref == "utm":
self._log.info("Georeferencing is in UTM (zone %d%s)", utm_zone,
utm_zone_letter)
y_ll = par["Y_FIRST"] + par["Y_STEP"] * nlines
container.frame.llLat, container.frame.llLon = utm.to_latlon(
par["X_FIRST"], y_ll, utm_zone, zone_letter=utm_zone_letter)
return self.container
def read(self, filename, **kwargs):
"""
:param filename: Gamma software parameter file
:type filename: str
:param par_file: Corresponding parameter (:file:`*par`) file.
(optional)
:type par_file: str
:returns: Import dictionary
:rtype: dict
:raises: ImportError
"""
par_file = kwargs.pop("par_file", filename)
params = self._getParameters(par_file, log=True)
try:
params_slc = self._getSLCParameters(par_file)
except ImportError as e:
raise e
fill = None
ncols = int(params["width"])
nlines = int(params["nlines"])
radar_frequency = float(params_slc.get("radar_frequency", None))
displ = num.fromfile(filename, dtype=">f4")
# Resize array if last line is not scanned completely
if (displ.size % ncols) != 0:
fill = num.empty(ncols - displ.size % ncols)
fill.fill(num.nan)
displ = num.append(displ, fill)
displ = displ.reshape(nlines, ncols)
displ[displ == -0.0] = num.nan
displ = num.flipud(displ)
if radar_frequency is not None:
radar_frequency = float(radar_frequency)
self._log.info("Scaling displacement by radar_frequency %f GHz" %
(radar_frequency / 1e9))
wavelength = util.C / radar_frequency
displ /= -4 * num.pi
displ *= wavelength
else:
wavelength = "None"
self._log.warning(
"Could not determine radar_frequency from *.slc.par file!"
" Leaving displacement to radians.")
phi = self._getLOSAngles(filename, "*phi*")
theta = self._getLOSAngles(filename, "*theta*")
theta = theta
if isinstance(phi, num.ndarray):
phi = phi.reshape(nlines, ncols)
phi = num.flipud(phi)
if isinstance(theta, num.ndarray):
theta = theta.reshape(nlines, ncols)
theta = num.flipud(theta)
if fill is not None:
theta = num.append(theta, fill)
phi = num.append(phi, fill)
container = self.container
container.displacement = displ
container.theta = theta
container.phi = phi
container.meta.wavelength = wavelength
container.meta.title = params.get("title", "None")
container.bin_file = filename
container.par_file = par_file
if params["DEM_projection"] == "UTM":
utm_zone = params["projection_zone"]
try:
utm_zone_letter = utm.latitude_to_zone_letter(
params["center_latitude"])
except ValueError:
self._log.warning("Could not parse UTM Zone letter,"
" defaulting to N!")
utm_zone_letter = "N"
self._log.info("Using UTM reference: Zone %d%s" %
(utm_zone, utm_zone_letter))
dN = params["post_north"]
dE = params["post_east"]
utm_corn_e = params["corner_east"]
utm_corn_n = params["corner_north"]
utm_corn_eo = utm_corn_e + dE * displ.shape[1]
utm_corn_no = utm_corn_n + dN * displ.shape[0]
utm_e = num.linspace(utm_corn_e, utm_corn_eo, displ.shape[1])
utm_n = num.linspace(utm_corn_n, utm_corn_no, displ.shape[0])
llLat, llLon = utm.to_latlon(utm_e.min(), utm_n.min(), utm_zone,
utm_zone_letter)
container.frame.llLat = llLat
container.frame.llLon = llLon
container.frame.dE = abs(dE)
container.frame.dN = abs(dN)
else:
self._log.info("Using Lat/Lon reference")
container.frame.spacing = "degree"
container.frame.llLat = params[
"corner_lat"] + params["post_lat"] * nlines
container.frame.llLon = params["corner_lon"]
container.frame.dE = abs(params["post_lon"])
container.frame.dN = abs(params["post_lat"])
return container
def read(self, filename, **kwargs):
"""
:param filename: Gamma software parameter file
:type filename: str
:param par_file: Corresponding parameter (:file:`*par`) file.
(optional)
:type par_file: str
:returns: Import dictionary
:rtype: dict
:raises: ImportError
"""
par_file, params = self._getParameters(op.dirname(
op.abspath(filename)),
log=True)
ncols = int(params["num_samples_per_line"])
nlines = int(params["num_output_lines"])
radar_frequency = params.get("radar_frequency", None)
heading_par = float(params.get("centre_heading", None))
displ = num.fromfile(filename, dtype=">f4")
# Resize array if last line is not scanned completely
fill = 0
if (displ.size % ncols) != 0:
fill = num.empty(ncols - displ.size % ncols)
fill.fill(num.nan)
displ = num.append(displ, fill)
displ = displ.reshape(nlines, ncols)
displ[displ == -0.0] = num.nan
displ = num.flipud(displ)
if radar_frequency and "_dsp_" not in par_file:
radar_frequency = float(radar_frequency)
radar_frequency *= 1e6 # SNAP gives MHz
self._log.info("Scaling displacement by radar_frequency %f GHz",
radar_frequency / 1e9)
wavelength = util.C / radar_frequency
displ /= -4 * num.pi
displ *= wavelength
elif not radar_frequency and "_dsp_" not in par_file:
self._log.warning("Could not determine radar_frequency!")
wavelength = None
else:
wavelength = None
inc_angle = self._getLOSAngles(
filename, "incidenceAngleFromEllipsoid.rslc").copy()
if fill:
inc_angle = num.append(inc_angle, fill)
inc_angle[inc_angle == 0.0] = num.nan
phi = num.full_like(displ, (180.0 - heading_par))
theta = 90.0 - inc_angle.reshape(displ.shape)
theta = num.flipud(theta)
c = self.container
c.displacement = displ
c.theta = theta * d2r
c.phi = phi * d2r
c.meta.wavelength = wavelength
c.meta.title = params.get("PRODUCT", "SNAP Import")
c.meta.satellite_name = params.get("SPH_DESCRIPTOR", "None")
orb = params.get("PASS", None)
c.meta.orbital_node = orb.title() if orb else None
c.bin_file = filename
c.par_file = par_file
if params["map_projection"] == "UTM":
utm_zone = params["projection_zone"]
try:
utm_zone_letter = utm.latitude_to_zone_letter(
params["center_latitude"])
except ValueError:
self._log.warning("Could not parse UTM Zone letter,"
" defaulting to N!")
utm_zone_letter = "N"
self._log.info("Using UTM reference: Zone %d%s", utm_zone,
utm_zone_letter)
c.frame.spacing = "meter"
dN = abs(params["post_north"])
dE = abs(params["post_east"])
utm_corn_e = params["corner_east"]
utm_corn_n = params["corner_north"]
utm_corn_eo = utm_corn_e + dE * displ.shape[1]
utm_corn_no = utm_corn_n + dN * displ.shape[0]
utm_e = num.linspace(utm_corn_e, utm_corn_eo, displ.shape[1])
utm_n = num.linspace(utm_corn_n, utm_corn_no, displ.shape[0])
llLat, llLon = utm.to_latlon(utm_e.min(), utm_n.min(), utm_zone,
utm_zone_letter)
else:
self._log.info("Using Lat/Lon reference")
c.frame.spacing = "degree"
if orb.lower() == "ascending":
llLat = params["last_near_lat"]
llLon = params["last_near_long"]
elif orb.lower() == "descending":
llLat = params["last_far_lat"]
llLon = params["first_near_long"]
else:
raise AttributeError("cannot determine orbit")
dE = abs(params["lon_pixel_res"])
dN = abs(params["lat_pixel_res"])
c.frame.llLat = llLat
c.frame.llLon = llLon
c.frame.dE = dE
c.frame.dN = dN
return c
def read(self, filename, **kwargs):
"""
:param filename: Gamma software parameter file
:type filename: str
:param par_file: Corresponding parameter (:file:`*par`) file.
(optional)
:type par_file: str
:returns: Import dictionary
:rtype: dict
:raises: ImportError
"""
par_file, params = self._getParameters(
op.dirname(op.abspath(filename)), log=True)
ncols = int(params['num_samples_per_line'])
nlines = int(params['num_output_lines'])
radar_frequency = params.get('radar_frequency', None)
heading_par = float(params.get('centre_heading', None))
displ = num.fromfile(filename, dtype='>f4')
# Resize array if last line is not scanned completely
fill = 0
if (displ.size % ncols) != 0:
fill = num.empty(ncols - displ.size % ncols)
fill.fill(num.nan)
displ = num.append(displ, fill)
displ = displ.reshape(nlines, ncols)
displ[displ == -0.] = num.nan
displ = num.flipud(displ)
if radar_frequency and '_dsp_' not in par_file:
radar_frequency = float(radar_frequency)
radar_frequency *= 1e6 # SNAP gives MHz
self._log.info('Scaling displacement by radar_frequency %f GHz',
radar_frequency/1e9)
wavelength = util.C / radar_frequency
displ /= -4*num.pi
displ *= wavelength
elif not radar_frequency and '_dsp_' not in par_file:
self._log.warning('Could not determine radar_frequency!')
wavelength = None
else:
wavelength = None
inc_angle = self._getLOSAngles(
filename, 'incidenceAngleFromEllipsoid.rslc').copy()
if fill:
inc_angle = num.append(inc_angle, fill)
inc_angle[inc_angle == 0.] = num.nan
phi = num.full_like(displ, (180. - heading_par))
theta = 90. - inc_angle.reshape(displ.shape)
theta = num.flipud(theta)
c = self.container
c.displacement = displ
c.theta = theta * d2r
c.phi = phi * d2r
c.meta.wavelength = wavelength
c.meta.title = params.get('PRODUCT', 'SNAP Import')
c.meta.satellite_name = params.get('SPH_DESCRIPTOR', 'None')
orb = params.get('PASS', None)
c.meta.orbital_node = orb.title() if orb else None
c.bin_file = filename
c.par_file = par_file
if params['map_projection'] == 'UTM':
utm_zone = params['projection_zone']
try:
utm_zone_letter = utm.latitude_to_zone_letter(
params['center_latitude'])
except ValueError:
self._log.warning('Could not parse UTM Zone letter,'
' defaulting to N!')
utm_zone_letter = 'N'
self._log.info('Using UTM reference: Zone %d%s',
utm_zone, utm_zone_letter)
c.frame.spacing = 'meter'
dN = abs(params['post_north'])
dE = abs(params['post_east'])
utm_corn_e = params['corner_east']
utm_corn_n = params['corner_north']
utm_corn_eo = utm_corn_e + dE * displ.shape[1]
utm_corn_no = utm_corn_n + dN * displ.shape[0]
utm_e = num.linspace(utm_corn_e, utm_corn_eo, displ.shape[1])
utm_n = num.linspace(utm_corn_n, utm_corn_no, displ.shape[0])
llLat, llLon = utm.to_latlon(utm_e.min(), utm_n.min(),
utm_zone, utm_zone_letter)
else:
self._log.info('Using Lat/Lon reference')
c.frame.spacing = 'degree'
if orb.lower() == 'ascending':
llLat = params['last_near_lat']
llLon = params['last_near_long']
elif orb.lower() == 'descending':
llLat = params['last_far_lat']
llLon = params['first_near_long']
else:
raise AttributeError('cannot determine orbit')
dE = abs(params['lon_pixel_res'])
dN = abs(params['lat_pixel_res'])
c.frame.llLat = llLat
c.frame.llLon = llLon
c.frame.dE = dE
c.frame.dN = dN
return c
def read(self, filename, **kwargs):
"""
:param filename: Gamma software parameter file
:type filename: str
:param par_file: Corresponding parameter (:file:`*par`) file.
(optional)
:type par_file: str
:returns: Import dictionary
:rtype: dict
:raises: ImportError
"""
par_file = kwargs.pop('par_file',
self._getParameterFile(filename))
par = self._parseParameterFile(par_file)
fill = None
nrows = int(par['width'])
nlines = int(par['nlines'])
radar_frequency = par.get('radar_frequency', None)
displ = num.fromfile(filename, dtype='>f4')
# Resize array if last line is not scanned completely
if (displ.size % nrows) != 0:
fill = num.empty(nrows - displ.size % nrows)
fill.fill(num.nan)
displ = num.append(displ, fill)
displ = displ.reshape(nlines, nrows)
displ[displ == -0.] = num.nan
displ = num.fliplr(displ)
phi = self._getAngle(filename, '*phi*')
theta = self._getAngle(filename, '*theta*')
theta = num.cos(theta)
if isinstance(phi, num.ndarray):
phi = phi.reshape(nlines, nrows)
if isinstance(theta, num.ndarray):
theta = theta.reshape(nlines, nrows)
if fill is not None:
theta = num.append(theta, fill)
phi = num.append(phi, fill)
c = self.container
if radar_frequency is not None:
self._log.info('Scaling radian displacement by radar_frequency')
wavelength = 299792458. / radar_frequency
displ = (displ / (4.*num.pi)) * wavelength
c['meta']['wavelength'] = wavelength
c['displacement'] = displ
c['theta'] = theta
c['phi'] = phi
c['meta']['title'] = par.get('title', 'None')
c['bin_file'] = filename
c['par_file'] = par_file
if par['DEM_projection'] == 'UTM':
self._log.info('Parameter file provides UTM reference')
import utm
c['displacement'] = num.transpose(displ/100)
c['theta'] = num.transpose(theta)
c['phi'] = num.transpose(phi)
utm_zone = par['projection_zone']
try:
utm_zone_letter = utm.latitude_to_zone_letter(
par['center_latitude'])
except ValueError:
self._log.warning('Could not parse UTM Zone letter,'
' defaulting to N!')
utm_zone_letter = 'N'
utm_e = utm_n = None
dN = par['post_north']
dE = par['post_east']
utm_corn_e = par['corner_east']
utm_corn_n = par['corner_north']
utm_corn_eo = utm_corn_e + dE * displ.shape[1]
utm_corn_no = utm_corn_n + dN * displ.shape[0]
utm_e = num.linspace(utm_corn_e, utm_corn_eo, displ.shape[1])
utm_n = num.linspace(utm_corn_n, utm_corn_no, displ.shape[0])
c['frame']['llLat'], c['frame']['llLon'] =\
utm.to_latlon(utm_e.min(), utm_n.min(),
utm_zone, utm_zone_letter)
urlat, urlon = utm.to_latlon(utm_e.max(), utm_n.max(),
utm_zone, utm_zone_letter)
c['frame']['dLat'] =\
(urlat - c['frame']['llLat']) / displ.shape[0]
c['frame']['dLon'] =\
(urlon - c['frame']['llLon']) / displ.shape[1]
else:
self._log.info('Parameter file provides Lat/Lon reference')
c['frame']['llLat'] = par['corner_lat'] + par['post_lat'] * nrows
c['frame']['llLon'] = par['corner_lon']
c['frame']['dLon'] = par['post_lon']
c['frame']['dLat'] = par['post_lat']
return self.container
def zonestring_from_lonlat(lon, lat):
import utm
n = utm.latlon_to_zone_number(lat, lon)
l = utm.latitude_to_zone_letter(lat)
s = "%d%s" % (n, l)
return s
def aoi_info_from_geotiff_gt(ref_filename,
gt_filename,
padding=0.0,
height_guard=[-5, +5]):
''' aoi_from_gt
Returns an aoi from an image and a gt
padding: relative to the size the gt region (e.g. 0.1 adds a 10% of the extension of
the region on the four boundaries)
'''
# get the dimensions of the first image
width, height, pixel_dim = s2p.common.image_size_gdal(ref_filename)
# get the rpc of the first image
ref_image_rpc = rpcm.rpc_from_geotiff(ref_filename)
# get the localization of the center of the image
lon_center, lat_center = ref_image_rpc.localization(
width // 2, height // 2, 0)
zone_number = utm.latlon_to_zone_number(lat_center, lon_center)
zone_letter = utm.latitude_to_zone_letter(lat_center)
# Build the AOI of the GT ------------------------------
gt_metadata = readGTIFFmeta(gt_filename)
bounding_box = gt_metadata[1]
gt_min_easting = bounding_box.left
gt_max_easting = bounding_box.right
gt_min_northing = bounding_box.bottom
gt_max_northing = bounding_box.top
# padding
gt_easting_extension = gt_max_easting - gt_min_easting
gt_northing_extension = gt_max_northing - gt_min_northing
gt_min_easting -= padding * gt_easting_extension
gt_max_easting += padding * gt_easting_extension
gt_min_northing -= padding * gt_northing_extension
gt_max_northing += padding * gt_northing_extension
# update the extension
gt_easting_extension = gt_max_easting - gt_min_easting
gt_northing_extension = gt_max_northing - gt_min_northing
# convert easting, northing to lon,lat
gt_min_lat, gt_min_lon = utm.to_latlon(gt_min_easting, gt_min_northing,
zone_number, zone_letter)
gt_max_lat, gt_max_lon = utm.to_latlon(gt_max_easting, gt_max_northing,
zone_number, zone_letter)
zone_hemisphere = 'N' if gt_min_lat > 0 else 'S'
aoi = {
'coordinates': [[[gt_min_lon, gt_min_lat], [gt_min_lon, gt_max_lat],
[gt_max_lon, gt_max_lat], [gt_max_lon, gt_min_lat],
[gt_min_lon, gt_min_lat]]],
'type':
'Polygon'
}
utm_bbx = [
gt_min_easting, gt_max_easting, gt_min_northing, gt_max_northing
]
lonlat_bbx = [gt_min_lon, gt_max_lon, gt_min_lat, gt_max_lat]
# get min and max height from the gt image
gt = s2p.common.gdal_read_as_array_with_nans(gt_filename)
min_height, max_height = robust_image_min_max(gt)
# add height guard
min_height += height_guard[0]
max_height += height_guard[1]
return aoi, min_height, max_height, zone_hemisphere, zone_letter, zone_number, utm_bbx, lonlat_bbx
def convert_to_latlon(self, zone: LatLon):
zone_number = latlon_to_zone_number(zone.lat, zone.lon)
zone_letter = latitude_to_zone_letter(zone.lat)
lat, lon = to_latlon(self.east, self.north, zone_number, zone_letter)
return LatLon(lat, lon)
def get_grid_latitudes_longitudes_from_aoi(aoi, resolution=1, **kwargs):
r""" get_grid_latitudes_longitudes_from_aoi
Returns the arrays of latitudes and longitudes for a certain grid resolution on the aoi .
Parameters
----------
aoi : dict with 'coordinates' key
Area of interest (a rectangle is expected)
resolution : double
Resolution of the grid. Defaults to 1 (meter)
**kwargs
Arbitrary optional keyword argument.
grid_shape : tuple or list or array of two integers defining the grid shape (rows (latitudes), cols (longitudes))
This parameter overrides resolution
Returns
-------
latitudes: 1D numpy array
Array of latitudes of the grid
longitudes: 1D numpy array
Array of longitudes of the grid
"""
min_easting, max_easting, min_northing, max_northing = utils.utm_bounding_box_from_lonlat_aoi(
aoi)
if 'grid_shape' in kwargs.keys():
m, n = kwargs.get('grid_shape')
latitudes = np.arange(
start=np.min(np.array(aoi['coordinates'])[0, :, 1]),
stop=np.max(np.array(aoi['coordinates'])[0, :, 1]),
step=(np.max(np.array(aoi['coordinates'])[0, :, 1]) -
np.min(np.array(aoi['coordinates'])[0, :, 1])) / m)
longitudes = np.arange(
start=np.min(np.array(aoi['coordinates'])[0, :, 0]),
stop=np.max(np.array(aoi['coordinates'])[0, :, 0]),
step=(np.max(np.array(aoi['coordinates'])[0, :, 0]) -
np.min(np.array(aoi['coordinates'])[0, :, 0])) / n)
else:
Northings = np.arange(min_northing, max_northing, resolution)
Eastings = np.arange(min_easting, max_easting, resolution)
zone_number = utm.latlon_to_zone_number(aoi['coordinates'][0][0][1],
aoi['coordinates'][0][0][0])
zone_letter = utm.latitude_to_zone_letter(aoi['coordinates'][0][0][1])
latitudes = [
utm.to_latlon(Eastings[0], Northings[i], zone_number,
zone_letter)[0] for i in range(len(Northings))
]
longitudes = [
utm.to_latlon(Eastings[i], Northings[0], zone_number,
zone_letter)[1] for i in range(len(Eastings))
]
latitudes = np.array(latitudes)
longitudes = np.array(longitudes)
return latitudes, longitudes
