def radar2geo(self, az, rg, print_msg=True, debug_mode=False):
"""Convert radar coordinates into geo coordinates (pixel center)
Parameters: rg/az - np.array / int, range/azimuth pixel number
Returns: lon/lat - np.array / float, longitude/latitude of input point (rg,az);
nan if not found.
latlon_res - float, residul/uncertainty of coordinate conversion
"""
self.open()
if self.geocoded:
lat = self.yx2lalo(az, coord_type='az')
lon = self.yx2lalo(rg, coord_type='rg')
return lat, lon, 0, 0
if not isinstance(az, np.ndarray):
az = np.array(az)
rg = np.array(rg)
# read lookup table file
if self.lookup_file is None:
raise FileNotFoundError('No lookup table file found!')
if self.lut_y is None or self.lut_x is None:
self.read_lookup_table(print_msg=print_msg)
# For lookup table in geo-coord, search the buffer and use center pixel
if 'Y_FIRST' in self.lut_metadata.keys():
lut = self._read_geo_lut_metadata()
# Get buffer ratio from range/azimuth ground resolution/step
try:
az_step = ut0.azimuth_ground_resolution(self.src_metadata)
rg_step = ut0.range_ground_resolution(self.src_metadata,
print_msg=False)
x_factor = 2 * np.ceil(abs(lut.lon_step) / rg_step)
y_factor = 2 * np.ceil(abs(lut.lat_step) / az_step)
except:
x_factor = 10
y_factor = 10
if 'SUBSET_XMIN' in self.src_metadata.keys():
rg += int(self.src_metadata['SUBSET_XMIN'])
az += int(self.src_metadata['SUBSET_YMIN'])
lut_row = np.zeros(rg.shape)
lut_col = np.zeros(rg.shape)
if rg.size == 1:
lut_row, lut_col = self._get_lookup_row_col(
az, rg, y_factor, x_factor, debug_mode=debug_mode)
else:
for i in range(rg.size):
(lut_row[i], lut_col[i]) = self._get_lookup_row_col(
az[i],
rg[i],
y_factor,
x_factor,
debug_mode=debug_mode)
lat = (lut_row + 0.5) * lut.lat_step_deg + lut.lat0
lon = (lut_col + 0.5) * lut.lon_step_deg + lut.lon0
lat_resid = abs(y_factor * lut.lat_step_deg)
lon_resid = abs(x_factor * lut.lon_step_deg)
# For lookup table in radar-coord, read the value directly.
else:
lat = self.lut_y[az, rg]
lon = self.lut_x[az, rg]
lat_resid = 0.
lon_resid = 0.
return lat, lon, lat_resid, lon_resid
def geo2radar(self, lat, lon, print_msg=True, debug_mode=False):
"""Convert geo coordinates into radar coordinates.
Parameters: lat/lon - np.array / float, latitude/longitude
Returns: az/rg - np.array / int, range/azimuth pixel number
az/rg_res - float, residul/uncertainty of coordinate conversion
"""
self.open()
if self.geocoded:
az = self.lalo2yx(lat, coord_type='lat')
rg = self.lalo2yx(lon, coord_type='lon')
return az, rg, 0, 0
if not isinstance(lat, np.ndarray):
lat = np.array(lat)
lon = np.array(lon)
# read lookup table
if self.lookup_file is None:
raise FileNotFoundError('No lookup table file found!')
if self.lut_y is None or self.lut_x is None:
self.read_lookup_table(print_msg=print_msg)
# For lookup table in geo-coord, read value directly (GAMMA and ROI_PAC)
if 'Y_FIRST' in self.lut_metadata.keys():
lut = self._read_geo_lut_metadata()
# if source data file is subsetted before
az0 = 0
rg0 = 0
if 'SUBSET_YMIN' in self.src_metadata.keys():
az0 = int(self.src_metadata['SUBSET_YMIN'])
if 'SUBSET_XMIN' in self.src_metadata.keys():
rg0 = int(self.src_metadata['SUBSET_XMIN'])
# uncertainty due to different resolution between src and lut file
try:
az_step = ut0.azimuth_ground_resolution(self.src_metadata)
rg_step = ut0.range_ground_resolution(self.src_metadata,
print_msg=False)
x_factor = np.ceil(abs(lut.lon_step) / rg_step).astype(int)
y_factor = np.ceil(abs(lut.lat_step) / az_step).astype(int)
except:
x_factor = 2
y_factor = 2
# read y/x value from lookup table
row = np.rint((lat - lut.lat0) / lut.lat_step_deg).astype(int)
col = np.rint((lon - lut.lon0) / lut.lon_step_deg).astype(int)
rg = np.rint(self.lut_x[row, col]).astype(int) - rg0
az = np.rint(self.lut_y[row, col]).astype(int) - az0
# For lookup table in radar-coord, search the buffer and use center pixel (ISCE)
else:
# get resolution in degree in range/azimuth direction
az_step = ut0.azimuth_ground_resolution(self.src_metadata)
rg_step = ut0.range_ground_resolution(self.src_metadata,
print_msg=False)
lat_c = (np.nanmax(lat) + np.nanmin(lat)) / 2.
az_step_deg = 180. / np.pi * az_step / (self.earth_radius)
rg_step_deg = 180. / np.pi * rg_step / (
self.earth_radius * np.cos(lat_c * np.pi / 180.))
az, rg = np.zeros(lat.shape), np.zeros(lat.shape)
x_factor = 10
y_factor = 10
# search the overlap area of buffer in x/y direction and use the cross center
if lat.size == 1:
az, rg = self._get_lookup_row_col(lat,
lon,
y_factor * az_step_deg,
x_factor * rg_step_deg,
geo_coord=True,
debug_mode=debug_mode)
else:
for i in range(rg.size):
az[i], rg[i] = self._get_lookup_row_col(
lat[i],
lon[i],
y_factor * az_step_deg,
x_factor * rg_step_deg,
geo_coord=True,
debug_mode=debug_mode)
az = np.floor(az).astype(int)
rg = np.floor(rg).astype(int)
rg_resid = x_factor
az_resid = y_factor
return az, rg, az_resid, rg_resid