def get_grid(): # type: () -> GridType
if h5_dict['Projection ID'] == 'SLANT RANGE/AZIMUTH':
image_plane = 'SLANT'
gr_type = 'RGZERO'
else:
image_plane = 'GROUND'
gr_type = None
# Row
row_window_name = h5_dict['Range Focusing Weighting Function'].rstrip().upper()
row_params = None
if row_window_name == 'HAMMING':
row_params = {'COEFFICIENT': '{0:15f}'.format(h5_dict['Range Focusing Weighting Coefficient'])}
row = DirParamType(Sgn=-1,
KCtr=2*center_frequency/speed_of_light,
DeltaKCOAPoly=Poly2DType(Coefs=[[0, ], ]),
WgtType=WgtTypeType(WindowName=row_window_name, Parameters=row_params))
# Col
col_window_name = h5_dict['Azimuth Focusing Weighting Function'].rstrip().upper()
col_params = None
if col_window_name == 'HAMMING':
col_params = {'COEFFICIENT': '{0:15f}'.format(h5_dict['Azimuth Focusing Weighting Coefficient'])}
col = DirParamType(Sgn=-1,
KCtr=0,
WgtType=WgtTypeType(WindowName=col_window_name, Parameters=col_params))
return GridType(ImagePlane=image_plane, Type=gr_type, Row=row, Col=col)
def get_grid():
# type: () -> GridType
time_coa_poly = Poly2DType(Coefs=time_coa_poly_coeffs)
if collect_info.RadarMode.ModeType == 'SPOTLIGHT':
time_coa_poly = Poly2DType(Coefs=[[float(time_coa_poly_coeffs[0, 0]), ], ])
row_win = _stringify(hf['window_function_range'][()])
if row_win == 'NONE':
row_win = 'UNIFORM'
row = DirParamType(
SS=row_ss,
Sgn=-1,
KCtr=2*center_freq/speed_of_light,
ImpRespBW=2*tx_bandwidth/speed_of_light,
DeltaKCOAPoly=Poly2DType(Coefs=[[0,]]),
WgtType=WgtTypeType(WindowName=row_win))
col_win = _stringify(hf['window_function_azimuth'][()])
if col_win == 'NONE':
col_win = 'UNIFORM'
col = DirParamType(
SS=col_ss,
Sgn=-1,
KCtr=0,
ImpRespBW=col_imp_res_bw,
WgtType=WgtTypeType(WindowName=col_win),
DeltaKCOAPoly=Poly2DType(Coefs=dop_centroid_poly_coeffs*ss_zd_s/col_ss))
return GridType(
Type='RGZERO',
ImagePlane='SLANT',
TimeCOAPoly=time_coa_poly,
Row=row,
Col=col)
def get_grid():
# type: () -> GridType
# TODO: Future Change Required - JPL states that uniform weighting in data simulated
# from UAVSAR is a placeholder, not an accurate description of the data.
# At this point, it is not clear what the final weighting description for NISAR
# will be.
gp = hf['/science/LSAR/SLC/metadata/processingInformation/parameters']
row_wgt = gp['rangeChirpWeighting'][:]
win_name = 'UNIFORM' if numpy.all(row_wgt == row_wgt[0]) else 'UNKNOWN'
row = DirParamType(
Sgn=-1,
DeltaKCOAPoly=[[0,]],
WgtFunct=numpy.cast[numpy.float64](row_wgt),
WgtType=WgtTypeType(WindowName=win_name))
col_wgt = gp['azimuthChirpWeighting'][:]
win_name = 'UNIFORM' if numpy.all(col_wgt == col_wgt[0]) else 'UNKNOWN'
col = DirParamType(
Sgn=-1,
KCtr=0,
WgtFunct=numpy.cast[numpy.float64](col_wgt),
WgtType=WgtTypeType(WindowName=win_name))
return GridType(ImagePlane='SLANT', Type='RGZERO', Row=row, Col=col)
def get_weight(window_dict):
window_name = window_dict['name']
if window_name.lower() == 'rectangular':
return WgtTypeType(WindowName='UNIFORM')
else:
# TODO: what is the proper interpretation for the avci-nacaroglu window?
return WgtTypeType(WindowName=window_name,
Parameters=convert_string_dict(
window_dict['parameters']))
def get_grid():
# type: () -> GridType
img = collect['image']
image_plane = 'OTHER'
grid_type = 'PLANE'
if self._img_desc_tags['product_type'] == 'SLC' and img['algorithm'] != 'backprojection':
image_plane = 'SLANT'
grid_type = 'RGZERO'
coa_time = parse_timestring(img['center_pixel']['center_time'], precision='ns')
row_imp_rsp_bw = 2*bw/speed_of_light
row = DirParamType(
SS=img['pixel_spacing_column'],
ImpRespBW=row_imp_rsp_bw,
ImpRespWid=img['range_resolution'],
KCtr=2*fc/speed_of_light,
DeltaK1=-0.5*row_imp_rsp_bw,
DeltaK2=0.5*row_imp_rsp_bw,
DeltaKCOAPoly=[[0.0, ], ],
WgtType=WgtTypeType(
WindowName=img['range_window']['name'],
Parameters=convert_string_dict(img['range_window']['parameters'])))
# get timecoa value
timecoa_value = get_seconds(coa_time, start_time) # TODO: constant?
# find an approximation for zero doppler spacing - necessarily rough for backprojected images
# find velocity at coatime
arp_velocity = position.ARPPoly.derivative_eval(timecoa_value, der_order=1)
arp_speed = numpy.linalg.norm(arp_velocity)
col_ss = img['pixel_spacing_row']
dop_bw = img['processed_azimuth_bandwidth']
# ss_zd_s = col_ss/arp_speed
col = DirParamType(
SS=col_ss,
ImpRespWid=img['azimuth_resolution'],
ImpRespBW=dop_bw/arp_speed,
KCtr=0,
WgtType=WgtTypeType(
WindowName=img['azimuth_window']['name'],
Parameters=convert_string_dict(img['azimuth_window']['parameters'])))
# TODO: from Wade - account for numeric WgtFunct
return GridType(
ImagePlane=image_plane,
Type=grid_type,
TimeCOAPoly=[[timecoa_value, ], ],
Row=row,
Col=col)
def get_weight(window_dict):
window_name = window_dict['name']
if window_name.lower() == 'rectangular':
return WgtTypeType(WindowName='UNIFORM'), None
elif window_name.lower() == 'avci-nacaroglu':
return WgtTypeType(
WindowName=window_name.upper(),
Parameters=convert_string_dict(window_dict['parameters'])), \
avci_nacaroglu_window(64, alpha=window_dict['parameters']['alpha'])
else:
return WgtTypeType(WindowName=window_name,
Parameters=convert_string_dict(
window_dict['parameters'])), None
def _get_grid_row(self):
"""
Gets the Grid.Row metadata.
Returns
-------
DirParamType
"""
center_freq = self._get_center_frequency()
if self.generation == 'RS2':
row_ss = float(
self._find('./imageAttributes'
'/rasterAttributes'
'/sampledPixelSpacing').text)
elif self.generation == 'RCM':
row_ss = float(
self._find('./imageReferenceAttributes'
'/rasterAttributes'
'/sampledPixelSpacing').text)
else:
raise ValueError('unhandled generation {}'.format(self.generation))
row_irbw = 2 * float(
self._find('./imageGenerationParameters'
'/sarProcessingInformation'
'/totalProcessedRangeBandwidth').text) / speed_of_light
row_wgt_type = WgtTypeType(
WindowName=self._find('./imageGenerationParameters'
'/sarProcessingInformation'
'/rangeWindow/windowName').text.upper())
if row_wgt_type.WindowName == 'KAISER':
row_wgt_type.Parameters = {
'BETA':
self._find('./imageGenerationParameters'
'/sarProcessingInformation'
'/rangeWindow/windowCoefficient').text
}
return DirParamType(SS=row_ss,
ImpRespBW=row_irbw,
Sgn=-1,
KCtr=2 * center_freq / speed_of_light,
DeltaKCOAPoly=Poly2DType(Coefs=((0, ), )),
WgtType=row_wgt_type)
def _get_grid_col(self):
"""
Gets the Grid.Col metadata.
Returns
-------
DirParamType
"""
col_wgt_type = WgtTypeType(
WindowName=self._find('./imageGenerationParameters'
'/sarProcessingInformation'
'/azimuthWindow/windowName').text.upper())
if col_wgt_type.WindowName == 'KAISER':
col_wgt_type.Parameters = {
'BETA':
self._find('./imageGenerationParameters'
'/sarProcessingInformation'
'/azimuthWindow/windowCoefficient').text
}
return DirParamType(Sgn=-1, KCtr=0, WgtType=col_wgt_type)
def get_wgt_type(weight_name, coefficient, direction):
if weight_name == 'GENERAL_COSINE':
# probably only for kompsat?
weight_name = 'HAMMING'
coefficient = 1-coefficient
if coefficient is None:
params = None
else:
params = {'COEFFICIENT': '{0:0.16G}'.format(coefficient)}
out = WgtTypeType(WindowName=weight_name, Parameters=params)
if weight_name != 'HAMMING':
logging.warning(
'Got unexpected weight scheme {} for {}. The weighting will '
'not be properly populated.'.format(weight_name, direction))
return out
def do_dimension(dimension):
if dimension == 0:
dir_params = sicd.Grid.Row
aperture_in = row_aperture
weighting_in = row_weighting
dimension_limits = row_limits
else:
dir_params = sicd.Grid.Col
aperture_in = column_aperture
weighting_in = column_weighting
dimension_limits = column_limits
not_skewed = is_not_skewed(sicd, dimension)
uniform_weight = is_uniform_weight(sicd, dimension)
delta_kcoa = dir_params.DeltaKCOAPoly.get_array(dtype='float64')
st_beam_comp = sicd.ImageFormation.STBeamComp if sicd.ImageFormation is not None else None
if dimension == 1 and (not uniform_weight or weighting_in is not None):
if st_beam_comp is None:
logger.warning(
'Processing along the column direction requires modification\n\t'
'of the original weighting scheme, and the value for\n\t'
'ImageFormation.STBeamComp is not populated.\n\t'
'It is unclear how imperfect the de-weighting effort along the column may be.'
)
elif st_beam_comp == 'NO':
logger.warning(
'Processing along the column direction requires modification\n\t'
'of the original weighting scheme, and the value for\n\t'
'ImageFormation.STBeamComp is populated as `NO`.\n\t'
'It is likely that the de-weighting effort along the column is imperfect.'
)
if aperture_in is None and weighting_in is None:
# nothing to be done in this dimension
return noise_adjustment_multiplier
new_weight = None if weighting_in is None else weighting_in['WgtFunct']
dimension_limits, cur_aperture_limits, cur_weight_function, \
new_aperture_limits, new_weight_function = aperture_dimension_params(
old_sicd, dimension, dimension_limits=dimension_limits,
aperture_limits=aperture_in, new_weight_function=new_weight)
index_count = dimension_limits[1] - dimension_limits[0]
cur_center_index = 0.5 * (cur_aperture_limits[0] +
cur_aperture_limits[1])
new_center_index = 0.5 * (new_aperture_limits[0] +
new_aperture_limits[1])
noise_multiplier = noise_scaling(cur_aperture_limits,
cur_weight_function,
new_aperture_limits,
new_weight_function)
# perform deskew, if necessary
if not not_skewed:
if dimension == 0:
row_array = get_direction_array_meters(0, 0, out_data_shape[0])
for (_start_ind, _stop_ind) in col_iterations:
col_array = get_direction_array_meters(
1, _start_ind, _stop_ind)
working_data[:, _start_ind:_stop_ind] = apply_skew_poly(
working_data[:, _start_ind:_stop_ind],
delta_kcoa,
row_array,
col_array,
dir_params.Sgn,
0,
forward=False)
else:
col_array = get_direction_array_meters(1, 0, out_data_shape[1])
for (_start_ind, _stop_ind) in row_iterations:
row_array = get_direction_array_meters(
0, _start_ind, _stop_ind)
working_data[_start_ind:_stop_ind, :] = apply_skew_poly(
working_data[_start_ind:_stop_ind, :],
delta_kcoa,
row_array,
col_array,
dir_params.Sgn,
1,
forward=False)
# perform fourier transform along the given dimension
if dimension == 0:
for (_start_ind, _stop_ind) in col_iterations:
working_data[:, _start_ind:_stop_ind] = fftshift(
fft_sicd(working_data[:, _start_ind:_stop_ind], dimension,
sicd),
axes=dimension)
else:
for (_start_ind, _stop_ind) in row_iterations:
working_data[_start_ind:_stop_ind, :] = fftshift(
fft_sicd(working_data[_start_ind:_stop_ind, :], dimension,
sicd),
axes=dimension)
# perform deweight, if necessary
if not uniform_weight:
if dimension == 0:
working_data[cur_aperture_limits[0]:cur_aperture_limits[
1], :] /= cur_weight_function[:, numpy.newaxis]
else:
working_data[:, cur_aperture_limits[0]:
cur_aperture_limits[1]] /= cur_weight_function
# do sub-aperture, if necessary
if aperture_in is not None:
if dimension == 0:
working_data[:new_aperture_limits[0], :] = 0
working_data[new_aperture_limits[1]:, :] = 0
else:
working_data[:, :new_aperture_limits[0]] = 0
working_data[:, new_aperture_limits[1]:] = 0
the_ratio = float(new_aperture_limits[1] - new_aperture_limits[0]) / \
float(cur_aperture_limits[1] - cur_aperture_limits[0])
# modify the ImpRespBW value (derived ImpRespWid handled at the end)
dir_params.ImpRespBW *= the_ratio
# perform reweight, if necessary
if weighting_in is not None:
if dimension == 0:
working_data[new_aperture_limits[0]:new_aperture_limits[
1], :] *= new_weight_function[:, numpy.newaxis]
else:
working_data[:, new_aperture_limits[0]:
new_aperture_limits[1]] *= new_weight_function
# modify the weight definition
dir_params.WgtType = WgtTypeType(
WindowName=weighting_in['WindowName'],
Parameters=weighting_in.get('Parameters', None))
dir_params.WgtFunct = weighting_in['WgtFunct'].copy()
elif not uniform_weight:
if dimension == 0:
working_data[new_aperture_limits[0]:new_aperture_limits[
1], :] *= new_weight_function[:, numpy.newaxis]
else:
working_data[:, new_aperture_limits[0]:
new_aperture_limits[1]] *= new_weight_function
# perform inverse fourier transform along the given dimension
if dimension == 0:
for (_start_ind, _stop_ind) in col_iterations:
working_data[:, _start_ind:_stop_ind] = ifft_sicd(
ifftshift(working_data[:, _start_ind:_stop_ind],
axes=dimension), dimension, sicd)
else:
for (_start_ind, _stop_ind) in row_iterations:
working_data[_start_ind:_stop_ind, :] = ifft_sicd(
ifftshift(working_data[_start_ind:_stop_ind, :],
axes=dimension), dimension, sicd)
# perform the (original) reskew, if necessary
if not numpy.all(delta_kcoa == 0):
if dimension == 0:
row_array = get_direction_array_meters(0, 0, out_data_shape[0])
for (_start_ind, _stop_ind) in col_iterations:
col_array = get_direction_array_meters(
1, _start_ind, _stop_ind)
working_data[:, _start_ind:_stop_ind] = apply_skew_poly(
working_data[:, _start_ind:_stop_ind],
delta_kcoa,
row_array,
col_array,
dir_params.Sgn,
0,
forward=True)
else:
col_array = get_direction_array_meters(1, 0, out_data_shape[1])
for (_start_ind, _stop_ind) in row_iterations:
row_array = get_direction_array_meters(
0, _start_ind, _stop_ind)
working_data[_start_ind:_stop_ind, :] = apply_skew_poly(
working_data[_start_ind:_stop_ind, :],
delta_kcoa,
row_array,
col_array,
dir_params.Sgn,
1,
forward=True)
# modify the delta_kcoa_poly - introduce the shift necessary for additional offset
if new_center_index != cur_center_index:
additional_shift = dir_params.Sgn * (
cur_center_index - new_center_index) / float(
index_count * dir_params.SS)
delta_kcoa[0, 0] += additional_shift
dir_params.DeltaKCOAPoly = delta_kcoa
return noise_adjustment_multiplier * noise_multiplier
def do_dimension(dimension):
if dimension == 0:
dir_params = sicd.Grid.Row
aperture_in = row_aperture
weighting_in = row_weighting
index_count = sicd.ImageData.NumRows
else:
dir_params = sicd.Grid.Col
aperture_in = column_aperture
weighting_in = column_weighting
index_count = sicd.ImageData.NumCols
not_skewed = is_not_skewed(sicd, dimension)
uniform_weight = is_uniform_weight(sicd, dimension)
delta_kcoa = dir_params.DeltaKCOAPoly.get_array(dtype='float64')
st_beam_comp = sicd.ImageFormation.STBeamComp if sicd.ImageFormation is not None else None
if dimension == 1 and (not uniform_weight or weighting_in is not None):
if st_beam_comp is None:
logger.warning(
'Processing along the column direction requires modification\n\t'
'of the original weighting scheme, and the value for\n\t'
'ImageFormation.STBeamComp is not populated.\n\t'
'It is unclear how imperfect the de-weighting effort along the column may be.'
)
elif st_beam_comp == 'NO':
logger.warning(
'Processing along the column direction requires modification\n\t'
'of the original weighting scheme, and the value for\n\t'
'ImageFormation.STBeamComp is populated as `NO`.\n\t'
'It is likely that the de-weighting effort along the column is imperfect.'
)
if aperture_in is None and weighting_in is None:
# nothing to be done in this dimension
return
oversample = max(1., 1. / (dir_params.SS * dir_params.ImpRespBW))
old_weight, start_index, end_index = determine_weight_array(
out_data_shape, dir_params.WgtFunct.copy(), oversample, dimension)
center_index = 0.5 * (start_index + end_index)
# perform deskew, if necessary
if not not_skewed:
if dimension == 0:
row_array = get_direction_array_meters(0, 0, out_data_shape[0])
for (_start_ind, _stop_ind) in col_iterations:
col_array = get_direction_array_meters(
1, _start_ind, _stop_ind)
working_data[:, _start_ind:_stop_ind] = apply_skew_poly(
working_data[:, _start_ind:_stop_ind],
delta_kcoa,
row_array,
col_array,
dir_params.Sgn,
0,
forward=False)
else:
col_array = get_direction_array_meters(1, 0, out_data_shape[1])
for (_start_ind, _stop_ind) in row_iterations:
row_array = get_direction_array_meters(
0, _start_ind, _stop_ind)
working_data[_start_ind:_stop_ind, :] = apply_skew_poly(
working_data[_start_ind:_stop_ind, :],
delta_kcoa,
row_array,
col_array,
dir_params.Sgn,
1,
forward=False)
# perform fourier transform along the given dimension
if dimension == 0:
for (_start_ind, _stop_ind) in col_iterations:
working_data[:, _start_ind:_stop_ind] = fftshift(
fft_sicd(working_data[:, _start_ind:_stop_ind], dimension,
sicd),
axes=dimension)
else:
for (_start_ind, _stop_ind) in row_iterations:
working_data[_start_ind:_stop_ind, :] = fftshift(
fft_sicd(working_data[_start_ind:_stop_ind, :], dimension,
sicd),
axes=dimension)
# perform deweight, if necessary
if not uniform_weight:
if dimension == 0:
working_data[
start_index:end_index, :] /= old_weight[:, numpy.newaxis]
else:
working_data[:, start_index:end_index] /= old_weight
# do sub-aperture, if necessary
if aperture_in is not None:
new_start_index = max(int(aperture_in[0]), start_index)
new_end_index = min(int(aperture_in[1]), end_index)
new_center_index = 0.5 * (new_start_index + new_end_index)
if dimension == 0:
working_data[:new_start_index, :] = 0
working_data[new_end_index:, :] = 0
else:
working_data[:, :new_start_index] = 0
working_data[:, new_end_index:] = 0
new_oversample = oversample * float(
end_index - start_index) / float(new_end_index -
new_start_index)
the_ratio = new_oversample / oversample
# modify the ImpRespBW value (derived ImpRespWid handled at the end)
dir_params.ImpRespBW /= the_ratio
else:
new_center_index = center_index
new_oversample = oversample
# perform reweight, if necessary
if weighting_in is not None:
new_weight, start_index, end_index = determine_weight_array(
out_data_shape, weighting_in['WgtFunction'].copy(),
new_oversample, dimension)
start_index += int(new_center_index - center_index)
end_index += int(new_center_index - center_index)
if dimension == 0:
working_data[
start_index:end_index, :] *= new_weight[:, numpy.newaxis]
else:
working_data[:, start_index:end_index] *= new_weight
# modify the weight definition
dir_params.WgtType = WgtTypeType(
WindowName=weighting_in['WindowName'],
Parameters=weighting_in.get('Parameters', None))
dir_params.WgtFunct = weighting_in['WgtFunction'].copy()
elif not uniform_weight:
# weight remained the same, and it's not uniform
new_weight, start_index, end_index = determine_weight_array(
out_data_shape, dir_params.WgtFunct.copy(), new_oversample,
dimension)
if dimension == 0:
working_data[
start_index:end_index, :] *= new_weight[:, numpy.newaxis]
else:
working_data[:, start_index:end_index] *= new_weight
# perform inverse fourier transform along the given dimension
if dimension == 0:
for (_start_ind, _stop_ind) in col_iterations:
working_data[:, _start_ind:_stop_ind] = ifft_sicd(
ifftshift(working_data[:, _start_ind:_stop_ind],
axes=dimension), dimension, sicd)
else:
for (_start_ind, _stop_ind) in row_iterations:
working_data[_start_ind:_stop_ind, :] = ifft_sicd(
ifftshift(working_data[_start_ind:_stop_ind, :],
axes=dimension), dimension, sicd)
# perform the (original) reskew, if necessary
if not numpy.all(delta_kcoa == 0):
if dimension == 0:
row_array = get_direction_array_meters(0, 0, out_data_shape[0])
for (_start_ind, _stop_ind) in col_iterations:
col_array = get_direction_array_meters(
1, _start_ind, _stop_ind)
working_data[:, _start_ind:_stop_ind] = apply_skew_poly(
working_data[:, _start_ind:_stop_ind],
delta_kcoa,
row_array,
col_array,
dir_params.Sgn,
0,
forward=True)
else:
col_array = get_direction_array_meters(1, 0, out_data_shape[1])
for (_start_ind, _stop_ind) in row_iterations:
row_array = get_direction_array_meters(
0, _start_ind, _stop_ind)
working_data[_start_ind:_stop_ind, :] = apply_skew_poly(
working_data[_start_ind:_stop_ind, :],
delta_kcoa,
row_array,
col_array,
dir_params.Sgn,
1,
forward=True)
# modify the delta_kcoa_poly - introduce the shift necessary for additional offset
if center_index != new_center_index:
additional_shift = dir_params.Sgn * (
center_index - new_center_index) / float(
index_count * dir_params.SS)
delta_kcoa[0, 0] += additional_shift
dir_params.DeltaKCOAPoly = delta_kcoa
# re-derive the various ImpResp parameters
sicd.Grid.derive_direction_params(sicd.ImageData, populate=True)
def try_CMETAA():
tre = None if tres is None else tres['CMETAA'] # type: CMETAA
if tre is None:
return
cmetaa = tre.DATA
if the_sicd.GeoData is None:
the_sicd.GeoData = GeoDataType()
if the_sicd.SCPCOA is None:
the_sicd.SCPCOA = SCPCOAType()
if the_sicd.Grid is None:
the_sicd.Grid = GridType()
if the_sicd.Timeline is None:
the_sicd.Timeline = TimelineType()
if the_sicd.RadarCollection is None:
the_sicd.RadarCollection = RadarCollectionType()
if the_sicd.ImageFormation is None:
the_sicd.ImageFormation = ImageFormationType()
the_sicd.SCPCOA.SCPTime = 0.5*float(cmetaa.WF_CDP)
the_sicd.GeoData.SCP = SCPType(ECF=tre.get_scp())
the_sicd.SCPCOA.ARPPos = tre.get_arp()
the_sicd.SCPCOA.SideOfTrack = cmetaa.CG_LD.strip().upper()
the_sicd.SCPCOA.SlantRange = float(cmetaa.CG_SRAC)
the_sicd.SCPCOA.DopplerConeAng = float(cmetaa.CG_CAAC)
the_sicd.SCPCOA.GrazeAng = float(cmetaa.CG_GAAC)
the_sicd.SCPCOA.IncidenceAng = 90 - float(cmetaa.CG_GAAC)
if hasattr(cmetaa, 'CG_TILT'):
the_sicd.SCPCOA.TwistAng = float(cmetaa.CG_TILT)
if hasattr(cmetaa, 'CG_SLOPE'):
the_sicd.SCPCOA.SlopeAng = float(cmetaa.CG_SLOPE)
the_sicd.ImageData.SCPPixel = [int(cmetaa.IF_DC_IS_COL), int(cmetaa.IF_DC_IS_ROW)]
img_corners = tre.get_image_corners()
if img_corners is not None:
the_sicd.GeoData.ImageCorners = img_corners
if cmetaa.CMPLX_SIGNAL_PLANE.upper() == 'S':
the_sicd.Grid.ImagePlane = 'SLANT'
elif cmetaa.CMPLX_SIGNAL_PLANE.upper() == 'G':
the_sicd.Grid.ImagePlane = 'GROUND'
else:
logger.warning(
'Got unexpected CMPLX_SIGNAL_PLANE value {},\n\t'
'setting ImagePlane to SLANT'.format(cmetaa.CMPLX_SIGNAL_PLANE))
the_sicd.Grid.Row = DirParamType(
SS=float(cmetaa.IF_RSS),
ImpRespWid=float(cmetaa.IF_RGRES),
Sgn=1 if cmetaa.IF_RFFTS.strip() == '-' else -1, # opposite sign convention
ImpRespBW=float(cmetaa.IF_RFFT_SAMP)/(float(cmetaa.IF_RSS)*float(cmetaa.IF_RFFT_TOT)))
the_sicd.Grid.Col = DirParamType(
SS=float(cmetaa.IF_AZSS),
ImpRespWid=float(cmetaa.IF_AZRES),
Sgn=1 if cmetaa.IF_AFFTS.strip() == '-' else -1, # opposite sign convention
ImpRespBW=float(cmetaa.IF_AZFFT_SAMP)/(float(cmetaa.IF_AZSS)*float(cmetaa.IF_AZFFT_TOT)))
cmplx_weight = cmetaa.CMPLX_WEIGHT.strip().upper()
if cmplx_weight == 'UWT':
the_sicd.Grid.Row.WgtType = WgtTypeType(WindowName='UNIFORM')
the_sicd.Grid.Col.WgtType = WgtTypeType(WindowName='UNIFORM')
elif cmplx_weight == 'HMW':
the_sicd.Grid.Row.WgtType = WgtTypeType(WindowName='HAMMING')
the_sicd.Grid.Col.WgtType = WgtTypeType(WindowName='HAMMING')
elif cmplx_weight == 'HNW':
the_sicd.Grid.Row.WgtType = WgtTypeType(WindowName='HANNING')
the_sicd.Grid.Col.WgtType = WgtTypeType(WindowName='HANNING')
elif cmplx_weight == 'TAY':
the_sicd.Grid.Row.WgtType = WgtTypeType(
WindowName='TAYLOR',
Parameters={
'SLL': '-{0:d}'.format(int(cmetaa.CMPLX_RNG_SLL)),
'NBAR': '{0:d}'.format(int(cmetaa.CMPLX_RNG_TAY_NBAR))})
the_sicd.Grid.Col.WgtType = WgtTypeType(
WindowName='TAYLOR',
Parameters={
'SLL': '-{0:d}'.format(int(cmetaa.CMPLX_AZ_SLL)),
'NBAR': '{0:d}'.format(int(cmetaa.CMPLX_AZ_TAY_NBAR))})
else:
logger.warning(
'Got unsupported CMPLX_WEIGHT value {}.\n\tThe resulting SICD will '
'not have valid weight array populated'.format(cmplx_weight))
the_sicd.Grid.Row.define_weight_function()
the_sicd.Grid.Col.define_weight_function()
# noinspection PyBroadException
try:
date_str = cmetaa.T_UTC_YYYYMMMDD
time_str = cmetaa.T_HHMMSSUTC
date_time = _iso_date_format.format(
date_str[:4], date_str[4:6], date_str[6:8],
time_str[:2], time_str[2:4], time_str[4:6])
the_sicd.Timeline.CollectStart = numpy.datetime64(date_time, 'us')
except Exception:
logger.info('Failed extracting start time from CMETAA')
pass
the_sicd.Timeline.CollectDuration = float(cmetaa.WF_CDP)
the_sicd.Timeline.IPP = [
IPPSetType(TStart=0,
TEnd=float(cmetaa.WF_CDP),
IPPStart=0,
IPPEnd=numpy.floor(float(cmetaa.WF_CDP)*float(cmetaa.WF_PRF)),
IPPPoly=[0, float(cmetaa.WF_PRF)])]
the_sicd.RadarCollection.TxFrequency = TxFrequencyType(
Min=float(cmetaa.WF_SRTFR),
Max=float(cmetaa.WF_ENDFR))
the_sicd.RadarCollection.TxPolarization = cmetaa.POL_TR.upper()
the_sicd.RadarCollection.Waveform = [WaveformParametersType(
TxPulseLength=float(cmetaa.WF_WIDTH),
TxRFBandwidth=float(cmetaa.WF_BW),
TxFreqStart=float(cmetaa.WF_SRTFR),
TxFMRate=float(cmetaa.WF_CHRPRT)*1e12)]
tx_rcv_pol = '{}:{}'.format(cmetaa.POL_TR.upper(), cmetaa.POL_RE.upper())
the_sicd.RadarCollection.RcvChannels = [
ChanParametersType(TxRcvPolarization=tx_rcv_pol)]
the_sicd.ImageFormation.TxRcvPolarizationProc = tx_rcv_pol
if_process = cmetaa.IF_PROCESS.strip().upper()
if if_process == 'PF':
the_sicd.ImageFormation.ImageFormAlgo = 'PFA'
scp_ecf = tre.get_scp()
fpn_ned = numpy.array(
[float(cmetaa.CG_FPNUV_X), float(cmetaa.CG_FPNUV_Y), float(cmetaa.CG_FPNUV_Z)], dtype='float64')
ipn_ned = numpy.array(
[float(cmetaa.CG_IDPNUVX), float(cmetaa.CG_IDPNUVY), float(cmetaa.CG_IDPNUVZ)], dtype='float64')
fpn_ecf = ned_to_ecf(fpn_ned, scp_ecf, absolute_coords=False)
ipn_ecf = ned_to_ecf(ipn_ned, scp_ecf, absolute_coords=False)
the_sicd.PFA = PFAType(FPN=fpn_ecf, IPN=ipn_ecf)
elif if_process in ['RM', 'CD']:
the_sicd.ImageFormation.ImageFormAlgo = 'RMA'
# the remainder of this is guesswork to define required fields
the_sicd.ImageFormation.TStartProc = 0 # guess work
the_sicd.ImageFormation.TEndProc = float(cmetaa.WF_CDP)
the_sicd.ImageFormation.TxFrequencyProc = TxFrequencyProcType(
MinProc=float(cmetaa.WF_SRTFR), MaxProc=float(cmetaa.WF_ENDFR))
# all remaining guess work
the_sicd.ImageFormation.STBeamComp = 'NO'
the_sicd.ImageFormation.ImageBeamComp = 'SV' if cmetaa.IF_BEAM_COMP[0] == 'Y' else 'NO'
the_sicd.ImageFormation.AzAutofocus = 'NO' if cmetaa.AF_TYPE[0] == 'N' else 'SV'
the_sicd.ImageFormation.RgAutofocus = 'NO'
def try_CMETAA():
tre = None if tres is None else tres['CMETAA']
if tre is None:
return
cmetaa = tre.DATA
if the_sicd.GeoData is None:
the_sicd.GeoData = GeoDataType()
if the_sicd.SCPCOA is None:
the_sicd.SCPCOA = SCPCOAType()
if the_sicd.Grid is None:
the_sicd.Grid = GridType()
if the_sicd.Timeline is None:
the_sicd.Timeline = TimelineType()
if the_sicd.RadarCollection is None:
the_sicd.RadarCollection = RadarCollectionType()
if the_sicd.ImageFormation is None:
the_sicd.ImageFormation = ImageFormationType()
the_sicd.SCPCOA.SCPTime = 0.5 * cmetaa.WF_CDP
if cmetaa.CG_MODEL == 'ECEF':
the_sicd.GeoData.SCP = SCPType(ECF=[
cmetaa.CG_SCECN_X, cmetaa.CG_SCECN_Y, cmetaa.cmetaa.CG_SCECN_Z
])
the_sicd.SCPCOA.ARPPos = [
cmetaa.CG_APCEN_X, cmetaa.CG_APCEN_Y, cmetaa.CG_APCEN_Z
]
elif cmetaa.CG_MODEL == 'WGS84':
the_sicd.GeoData.SCP = SCPType(LLH=[
cmetaa.CG_SCECN_X, cmetaa.CG_SCECN_Y, cmetaa.cmetaa.CG_SCECN_Z
])
the_sicd.SCPCOA.ARPPos = geodetic_to_ecf(
[cmetaa.CG_APCEN_X, cmetaa.CG_APCEN_Y, cmetaa.CG_APCEN_Z])
the_sicd.SCPCOA.SideOfTrack = cmetaa.CG_LD
the_sicd.SCPCOA.SlantRange = cmetaa.CG_SRAC
the_sicd.SCPCOA.DopplerConeAng = cmetaa.CG_CAAC
the_sicd.SCPCOA.GrazeAng = cmetaa.CG_GAAC
the_sicd.SCPCOA.IncidenceAng = 90 - cmetaa.CG_GAAC
if hasattr(cmetaa, 'CG_TILT'):
the_sicd.SCPCOA.TwistAng = cmetaa.CG_TILT
if hasattr(cmetaa, 'CG_SLOPE'):
the_sicd.SCPCOA.SlopeAng = cmetaa.CG_SLOPE
the_sicd.ImageData.SCPPixel = [
cmetaa.IF_DC_IS_COL, cmetaa.IF_DC_IS_ROW
]
if cmetaa.CG_MAP_TYPE == 'GEOD':
the_sicd.GeoData.ImageCorners = [
[cmetaa.CG_PATCH_LTCORUL, cmetaa.CG_PATCH_LGCORUL],
[cmetaa.CG_PATCH_LTCORUR, cmetaa.CG_PATCH_LGCORUR],
[cmetaa.CG_PATCH_LTCORLR, cmetaa.CG_PATCH_LGCORLR],
[cmetaa.CG_PATCH_LTCORLL, cmetaa.CG_PATCH_LNGCOLL]
]
if cmetaa.CMPLX_SIGNAL_PLANE[0].upper() == 'S':
the_sicd.Grid.ImagePlane = 'SLANT'
elif cmetaa.CMPLX_SIGNAL_PLANE[0].upper() == 'G':
the_sicd.Grid.ImagePlane = 'GROUND'
the_sicd.Grid.Row = DirParamType(
SS=cmetaa.IF_RSS,
ImpRespWid=cmetaa.IF_RGRES,
Sgn=1
if cmetaa.IF_RFFTS == '-' else -1, # opposite sign convention
ImpRespBW=cmetaa.IF_RFFT_SAMP /
(cmetaa.IF_RSS * cmetaa.IF_RFFT_TOT))
the_sicd.Grid.Col = DirParamType(
SS=cmetaa.IF_AZSS,
ImpRespWid=cmetaa.IF_AZRES,
Sgn=1
if cmetaa.IF_AFFTS == '-' else -1, # opposite sign convention
ImpRespBW=cmetaa.IF_AZFFT_SAMP /
(cmetaa.IF_AZSS * cmetaa.IF_AZFFT_TOT))
cmplx_weight = cmetaa.CMPLX_WEIGHT
if cmplx_weight == 'UWT':
the_sicd.Grid.Row.WgtType = WgtTypeType(WindowName='UNIFORM')
the_sicd.Grid.Col.WgtType = WgtTypeType(WindowName='UNIFORM')
elif cmplx_weight == 'HMW':
the_sicd.Grid.Row.WgtType = WgtTypeType(WindowName='HAMMING')
the_sicd.Grid.Col.WgtType = WgtTypeType(WindowName='HAMMING')
elif cmplx_weight == 'HNW':
the_sicd.Grid.Row.WgtType = WgtTypeType(WindowName='HANNING')
the_sicd.Grid.Col.WgtType = WgtTypeType(WindowName='HANNING')
elif cmplx_weight == 'TAY':
the_sicd.Grid.Row.WgtType = WgtTypeType(
WindowName='TAYLOR',
Parameters={
'SLL': '{0:0.16G}'.format(-cmetaa.CMPLX_RNG_SLL),
'NBAR': '{0:0.16G}'.format(cmetaa.CMPLX_RNG_TAY_NBAR)
})
the_sicd.Grid.Col.WgtType = WgtTypeType(
WindowName='TAYLOR',
Parameters={
'SLL': '{0:0.16G}'.format(-cmetaa.CMPLX_AZ_SLL),
'NBAR': '{0:0.16G}'.format(cmetaa.CMPLX_AZ_TAY_NBAR)
})
the_sicd.Grid.Row.define_weight_function()
the_sicd.Grid.Col.define_weight_function()
# noinspection PyBroadException
try:
date_str = cmetaa.T_UTC_YYYYMMMDD
time_str = cmetaa.T_HHMMSSUTC
date_time = '{}-{}-{}T{}:{}:{}Z'.format(
date_str[:4], date_str[4:6], date_str[6:8], time_str[:2],
time_str[2:4], time_str[4:6])
the_sicd.Timeline.CollectStart = numpy.datetime64(date_time, 'us')
except:
pass
the_sicd.Timeline.CollectDuration = cmetaa.WF_CDP
the_sicd.Timeline.IPP = [
IPPSetType(TStart=0,
TEnd=cmetaa.WF_CDP,
IPPStart=0,
IPPEnd=numpy.floor(cmetaa.WF_CDP * cmetaa.WF_PRF),
IPPPoly=[0, cmetaa.WF_PRF])
]
the_sicd.RadarCollection.TxFrequency = TxFrequencyType(
Min=cmetaa.WF_SRTFR, Max=cmetaa.WF_ENDFR)
the_sicd.RadarCollection.TxPolarization = cmetaa.POL_TR.upper()
the_sicd.RadarCollection.Waveform = [
WaveformParametersType(TxPulseLength=cmetaa.WF_WIDTH,
TxRFBandwidth=cmetaa.WF_BW,
TxFreqStart=cmetaa.WF_SRTFR,
TxFMRate=cmetaa.WF_CHRPRT * 1e12)
]
tx_rcv_pol = '{}:{}'.format(cmetaa.POL_TR.upper(),
cmetaa.POL_RE.upper())
the_sicd.RadarCollection.RcvChannels = [
ChanParametersType(TxRcvPolarization=tx_rcv_pol)
]
the_sicd.ImageFormation.TxRcvPolarizationProc = tx_rcv_pol
if_process = cmetaa.IF_PROCESS
if if_process == 'PF':
the_sicd.ImageFormation.ImageFormAlgo = 'PFA'
scp_ecf = the_sicd.GeoData.SCP.ECF.get_array()
fpn_ned = numpy.array(
[cmetaa.CG_FPNUV_X, cmetaa.CG_FPNUV_Y, cmetaa.CG_FPNUV_Z],
dtype='float64')
ipn_ned = numpy.array(
[cmetaa.CG_IDPNUVX, cmetaa.CG_IDPNUVY, cmetaa.CG_IDPNUVZ],
dtype='float64')
fpn_ecf = ned_to_ecf(fpn_ned, scp_ecf, absolute_coords=False)
ipn_ecf = ned_to_ecf(ipn_ned, scp_ecf, absolute_coords=False)
the_sicd.PFA = PFAType(FPN=fpn_ecf, IPN=ipn_ecf)
elif if_process in ['RM', 'CD']:
the_sicd.ImageFormation.ImageFormAlgo = 'RMA'
# the remainder of this is guesswork to define required fields
the_sicd.ImageFormation.TStartProc = 0 # guess work
the_sicd.ImageFormation.TEndProc = cmetaa.WF_CDP
the_sicd.ImageFormation.TxFrequencyProc = TxFrequencyProcType(
MinProc=cmetaa.WF_SRTFR, MaxProc=cmetaa.WF_ENDFR)
# all remaining guess work
the_sicd.ImageFormation.STBeamComp = 'NO'
the_sicd.ImageFormation.ImageBeamComp = 'SV' if cmetaa.IF_BEAM_COMP[
0] == 'Y' else 'NO'
the_sicd.ImageFormation.AzAutofocus = 'NO' if cmetaa.AF_TYPE[
0] == 'N' else 'SV'
the_sicd.ImageFormation.RgAutofocus = 'NO'