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_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_grid(): # type: () -> GridType
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.17E}'.format(coefficient)}
out = WgtTypeType(WindowName=weight_name, Parameters=params)
if weight_name != 'HAMMING':
logger.warning(
'Got unexpected weight scheme {} for {}.\n\t'
'The weighting will not be properly populated.'.format(
weight_name, direction))
return out
if re.sub(
' ', '',
h5_dict['Projection ID']).upper() == 'SLANTRANGE/AZIMUTH':
image_plane = 'SLANT'
gr_type = 'RGZERO'
else:
image_plane = 'GROUND'
gr_type = 'PLANE'
# Row
row_window_name = h5_dict[
'Range Focusing Weighting Function'].rstrip().upper()
row_coefficient = h5_dict.get(
'Range Focusing Weighting Coefficient', None)
row_weight = get_wgt_type(row_window_name, row_coefficient, 'Row')
row = DirParamType(Sgn=-1,
KCtr=2 * center_frequency / speed_of_light,
DeltaKCOAPoly=Poly2DType(Coefs=[
[
0,
],
]),
WgtType=row_weight)
# Col
col_window_name = h5_dict[
'Azimuth Focusing Weighting Function'].rstrip().upper()
col_coefficient = h5_dict.get(
'Azimuth Focusing Weighting Coefficient', None)
col_weight = get_wgt_type(col_window_name, col_coefficient, 'Col')
col = DirParamType(Sgn=-1, KCtr=0, WgtType=col_weight)
return GridType(ImagePlane=image_plane,
Type=gr_type,
Row=row,
Col=col)
def try_ACFT():
if tres is None:
return
tre = tres['ACFTA']
if tre is None:
tre = tres['ACFTB']
if tre is None:
return
acft = tre.DATA
sensor_id = acft.SENSOR_ID.strip()
if len(sensor_id) > 1:
if the_sicd.CollectionInfo is None:
the_sicd.CollectionInfo = CollectionInfoType(
CollectorName=sensor_id)
elif the_sicd.CollectionInfo.CollectorName is None:
the_sicd.CollectionInfo.CollectorName = sensor_id
row_ss = float(acft.ROW_SPACING)
col_ss = float(acft.COL_SPACING)
if hasattr(acft, 'ROW_SPACING_UNITS') and acft.ROW_SPACING_UNITS.strip(
).lower() == 'f':
row_ss *= foot
if hasattr(acft, 'COL_SPACING_UNITS') and acft.COL_SPACING_UNITS.strip(
).lower() == 'f':
col_ss *= foot
# NB: these values are actually ground plane values, and should be
# corrected to slant plane if possible
if the_sicd.SCPCOA is not None:
if the_sicd.SCPCOA.GrazeAng is not None:
col_ss *= numpy.cos(numpy.deg2rad(the_sicd.SCPCOA.GrazeAng))
if the_sicd.SCPCOA.TwistAng is not None:
row_ss *= numpy.cos(numpy.deg2rad(the_sicd.SCPCOA.TwistAng))
if the_sicd.Grid is None:
the_sicd.Grid = GridType(Row=DirParamType(SS=row_ss),
Col=DirParamType(SS=col_ss))
return
if the_sicd.Grid.Row is None:
the_sicd.Grid.Row = DirParamType(SS=row_ss)
elif the_sicd.Grid.Row.SS is None:
the_sicd.Grid.Row.SS = row_ss
if the_sicd.Grid.Col is None:
the_sicd.Grid.Col = DirParamType(SS=col_ss)
elif the_sicd.Grid.Col.SS is None:
the_sicd.Grid.Col.SS = col_ss
def set_uvects(row_unit, col_unit):
if the_sicd.Grid is None:
the_sicd.Grid = GridType(Row=DirParamType(UVectECF=row_unit),
Col=DirParamType(UVectECF=col_unit))
return
if the_sicd.Grid.Row is None:
the_sicd.Grid.Row = DirParamType(UVectECF=row_unit)
elif the_sicd.Grid.Row.UVectECF is None:
the_sicd.Grid.Row.UVectECF = row_unit
if the_sicd.Grid.Col is None:
the_sicd.Grid.Col = DirParamType(UVectECF=col_unit)
elif the_sicd.Grid.Col.UVectECF is None:
the_sicd.Grid.Col.UVectECF = col_unit
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 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 get_grid():
# type: () -> GridType
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']))
img = collect['image']
img_geometry = img['image_geometry']
if img_geometry.get('type', None) == 'slant_plane':
image_plane = 'SLANT'
else:
image_plane = 'OTHER'
grid_type = 'PLANE'
if self._img_desc_tags['product_type'] == 'SLC' and img[
'algorithm'] != 'backprojection':
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'],
Sgn=-1,
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=get_weight(img['range_window']))
# get timecoa value
timecoa_value = get_seconds(
coa_time, start_time) # TODO: this is not generally correct
# 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,
Sgn=-1,
ImpRespWid=img['azimuth_resolution'],
ImpRespBW=dop_bw / arp_speed,
KCtr=0,
WgtType=get_weight(img['azimuth_window']))
# TODO:
# column deltakcoa poly - it's in there at ["image"]["frequency_doppler_centroid_polynomial"]
# weight functions?
return GridType(ImagePlane=image_plane,
Type=grid_type,
TimeCOAPoly=[
[
timecoa_value,
],
],
Row=row,
Col=col)
def get_grid():
# type: () -> GridType
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
image_plane = 'SLANT'
grid_type = 'RGZERO'
coa_time = parse_timestring(img['center_pixel']['center_time'],
precision='ns')
row_bw = img.get('processed_range_bandwidth', bw)
row_imp_rsp_bw = 2 * row_bw / speed_of_light
row_wgt, row_wgt_funct = get_weight(img['range_window'])
row = DirParamType(SS=img['image_geometry']['delta_range_sample'],
Sgn=-1,
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,
],
],
WgtFunct=row_wgt_funct,
WgtType=row_wgt)
# get timecoa value
timecoa_value = get_seconds(coa_time, start_time)
# find an approximation for zero doppler spacing - necessarily rough for backprojected images
col_ss = img['pixel_spacing_row']
dop_bw = img['processed_azimuth_bandwidth']
col_wgt, col_wgt_funct = get_weight(img['azimuth_window'])
col = DirParamType(SS=col_ss,
Sgn=-1,
ImpRespWid=img['azimuth_resolution'],
ImpRespBW=dop_bw * abs(ss_zd_s) / col_ss,
KCtr=0,
WgtFunct=col_wgt_funct,
WgtType=col_wgt)
# TODO:
# column deltakcoa poly - it's in there at ["image"]["frequency_doppler_centroid_polynomial"]
return GridType(ImagePlane=image_plane,
Type=grid_type,
TimeCOAPoly=[
[
timecoa_value,
],
],
Row=row,
Col=col)
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'
