class STDeskewType(Serializable): """ Parameters to describe image domain ST Deskew processing. """ _fields = ('Applied', 'STDSPhasePoly') _required = _fields # descriptors Applied = BooleanDescriptor( 'Applied', _required, strict=DEFAULT_STRICT, docstring='Parameter indicating if slow time *(ST)* Deskew Phase function has been applied.') # type: bool STDSPhasePoly = SerializableDescriptor( 'STDSPhasePoly', Poly2DType, _required, strict=DEFAULT_STRICT, docstring='Slow time deskew phase function to perform the *ST/Kaz* shift. Two-dimensional phase ' '(cycles) polynomial function of image range coordinate *(variable 1)* and ' 'azimuth coordinate *(variable 2)*.') # type: Poly2DType def __init__(self, Applied=None, STDSPhasePoly=None, **kwargs): """ Parameters ---------- Applied : bool STDSPhasePoly : Poly2DType|numpy.ndarray|list|tuple kwargs : dict """ if '_xml_ns' in kwargs: self._xml_ns = kwargs['_xml_ns'] if '_xml_ns_key' in kwargs: self._xml_ns_key = kwargs['_xml_ns_key'] self.Applied = Applied # noinspection PytypeChecker self.STDSPhasePoly = STDSPhasePoly super(STDeskewType, self).__init__(**kwargs)
class PolarizationCalibrationType(Serializable): """The polarization calibration""" _fields = ('DistortCorrectApplied', 'Distortion') _required = _fields # descriptors DistortCorrectApplied = BooleanDescriptor( 'DistortCorrectApplied', _required, strict=DEFAULT_STRICT, docstring='Indicates whether the polarization calibration has been applied.') # type: bool Distortion = SerializableDescriptor( 'Distortion', DistortionType, _required, strict=DEFAULT_STRICT, docstring='The distortion parameters.') # type: DistortionType def __init__(self, DistortCorrectApplied=None, Distortion=None, **kwargs): """ Parameters ---------- DistortCorrectApplied : bool Distortion : DistortionType kwargs : dict """ if '_xml_ns' in kwargs: self._xml_ns = kwargs['_xml_ns'] if '_xml_ns_key' in kwargs: self._xml_ns_key = kwargs['_xml_ns_key'] self.DistortCorrectApplied = DistortCorrectApplied self.Distortion = Distortion super(PolarizationCalibrationType, self).__init__(**kwargs)
class ProcessingType(Serializable): """The transmit frequency range""" _fields = ('Type', 'Applied', 'Parameters') _required = ('Type', 'Applied') _collections_tags = {'Parameters': {'array': False, 'child_tag': 'Parameter'}} # descriptors Type = StringDescriptor( 'Type', _required, strict=DEFAULT_STRICT, docstring='The processing type identifier.') # type: str Applied = BooleanDescriptor( 'Applied', _required, strict=DEFAULT_STRICT, docstring='Indicates whether the given processing type has been applied.') # type: bool Parameters = ParametersDescriptor( 'Parameters', _collections_tags, _required, strict=DEFAULT_STRICT, docstring='The parameters collection.') # type: ParametersCollection def __init__(self, Type=None, Applied=None, Parameters=None, **kwargs): """ Parameters ---------- Type : str Applied : bool Parameters : ParametersCollection|dict kwargs """ if '_xml_ns' in kwargs: self._xml_ns = kwargs['_xml_ns'] if '_xml_ns_key' in kwargs: self._xml_ns_key = kwargs['_xml_ns_key'] self.Type = Type self.Applied = Applied self.Parameters = Parameters super(ProcessingType, self).__init__(**kwargs)
class SARImagingType(Serializable): """ The SAR Imaging parameters """ _fields = ('TxLFMFixed', 'TxPol', 'DwellTimes', 'TxAntenna', 'ImageArea') _required = ('TxPol', 'DwellTimes') # descriptors TxLFMFixed = BooleanDescriptor( 'TxLFMFixed', _required, strict=DEFAULT_STRICT, docstring='Flag to indicate the same transmit LFM waveform is used for all pulses.' ' vectors of the channel.') # type: Union[None, bool] TxPol = StringEnumDescriptor( 'TxPol', POLARIZATION_TYPE, _required, strict=DEFAULT_STRICT, docstring='Transmitted signal polarization for the channel.') # type: str DwellTimes = SerializableDescriptor( 'DwellTimes', DwellTimesType, _required, strict=DEFAULT_STRICT, docstring='COD Time and Dwell Time polynomials over the image area.') # type: DwellTimesType TxAntenna = SerializableDescriptor( 'TxAntenna', TxAntennaType, _required, strict=DEFAULT_STRICT, docstring='Antenna Phase Center and Antenna Pattern identifiers for the transmit antenna' ' used to illuminate the imaged area.') # type: Union[None, TxAntennaType] ImageArea = SerializableDescriptor( 'ImageArea', AreaType, _required, strict=DEFAULT_STRICT, docstring='SAR Image Area for the channel defined by a rectangle aligned with (IAX, IAY).' ' May be reduced by the optional polygon.') # type: Union[None, AreaType] def __init__(self, TxLFMFixed=None, TxPol=None, DwellTimes=None, TxAntenna=None, ImageArea=None, **kwargs): """ Parameters ---------- TxLFMFixed : None|bool TxPol : PolarizationType DwellTimes : DwellTimesType TxAntenna : None|TxAntennaType ImageArea : None|AreaType kwargs """ if '_xml_ns' in kwargs: self._xml_ns = kwargs['_xml_ns'] if '_xml_ns_key' in kwargs: self._xml_ns_key = kwargs['_xml_ns_key'] self.TxLFMFixed = TxLFMFixed self.TxPol = TxPol self.DwellTimes = DwellTimes self.TxAntenna = TxAntenna self.ImageArea = ImageArea super(SARImagingType, self).__init__(**kwargs)
class INCAType(Serializable): """Parameters for Imaging Near Closest Approach (INCA) image description.""" _fields = ('TimeCAPoly', 'R_CA_SCP', 'FreqZero', 'DRateSFPoly', 'DopCentroidPoly', 'DopCentroidCOA') _required = ('TimeCAPoly', 'R_CA_SCP', 'FreqZero', 'DRateSFPoly') _numeric_format = {'R_CA_SCP': '0.17E', 'FreqZero': '0.17E'} # descriptors TimeCAPoly = SerializableDescriptor( 'TimeCAPoly', Poly1DType, _required, strict=DEFAULT_STRICT, docstring= 'Polynomial function that yields *Time of Closest Approach* as function of ' 'image column *(azimuth)* coordinate in meters. Time relative to ' 'collection start in seconds.') # type: Poly1DType R_CA_SCP = FloatDescriptor( 'R_CA_SCP', _required, strict=DEFAULT_STRICT, docstring= '*Range at Closest Approach (R_CA)* for the *Scene Center Point (SCP)* in meters.' ) # type: float FreqZero = FloatDescriptor( 'FreqZero', _required, strict=DEFAULT_STRICT, docstring=r'*RF frequency* :\math:`(f_0)` in Hz used for computing ' r'Doppler Centroid values. Typical :math:`f_0` ' r'set equal to center transmit frequency.') # type: float DRateSFPoly = SerializableDescriptor( 'DRateSFPoly', Poly2DType, _required, strict=DEFAULT_STRICT, docstring= 'Polynomial function that yields *Doppler Rate scale factor (DRSF)* ' 'as a function of image location. Yields `DRSF` as a function of image ' 'range coordinate ``(variable 1)`` and azimuth coordinate ``(variable 2)``. ' 'Used to compute Doppler Rate at closest approach.' ) # type: Poly2DType DopCentroidPoly = SerializableDescriptor( 'DopCentroidPoly', Poly2DType, _required, strict=DEFAULT_STRICT, docstring='Polynomial function that yields Doppler Centroid value as a ' 'function of image location *(fdop_DC)*. The *fdop_DC* is the ' 'Doppler frequency at the peak signal response. The polynomial is a function ' 'of image range coordinate ``(variable 1)`` and azimuth coordinate ``(variable 2)``. ' '*Note: Only used for Stripmap and Dynamic Stripmap collections.*' ) # type: Poly2DType DopCentroidCOA = BooleanDescriptor( 'DopCentroidCOA', _required, strict=DEFAULT_STRICT, docstring= """Flag indicating that the COA is at the peak signal :math`fdop_COA = fdop_DC`. * `True` - if Pixel COA at peak signal for all pixels. * `False` otherwise. *Note:* Only used for Stripmap and Dynamic Stripmap.""") # type: bool def __init__(self, TimeCAPoly=None, R_CA_SCP=None, FreqZero=None, DRateSFPoly=None, DopCentroidPoly=None, DopCentroidCOA=None, **kwargs): """ Parameters ---------- TimeCAPoly : Poly1DType|numpy.ndarray|list|tuple R_CA_SCP : float FreqZero : float DRateSFPoly : Poly2DType|numpy.ndarray|list|tuple DopCentroidPoly : Poly2DType|numpy.ndarray|list|tuple DopCentroidCOA : bool kwargs """ if '_xml_ns' in kwargs: self._xml_ns = kwargs['_xml_ns'] if '_xml_ns_key' in kwargs: self._xml_ns_key = kwargs['_xml_ns_key'] self.TimeCAPoly = TimeCAPoly self.R_CA_SCP = R_CA_SCP self.FreqZero = FreqZero self.DRateSFPoly = DRateSFPoly self.DopCentroidPoly = DopCentroidPoly self.DopCentroidCOA = DopCentroidCOA super(INCAType, self).__init__(**kwargs) def _apply_reference_frequency(self, reference_frequency): if self.FreqZero is not None: self.FreqZero += reference_frequency
class AntPatternType(Serializable): """ Parameter set that defines each one-way Antenna Pattern. """ _fields = ('Identifier', 'FreqZero', 'EBFreqShift', 'MLFreqDilation', 'GainZero', 'GainBSPoly', 'ArrayGPId', 'ElementGPId') _required = ('Identifier', 'FreqZero', 'EBFreqShift', 'MLFreqDilation', 'ArrayGPId', 'ElementGPId') _numeric_format = {'FreqZero': FLOAT_FORMAT, 'GainZero': FLOAT_FORMAT} # descriptors Identifier = StringDescriptor( 'Identifier', _required, strict=DEFAULT_STRICT, docstring='String that uniquely identifies this Antenna Pattern' ) # type: str FreqZero = FloatDescriptor( 'FreqZero', _required, strict=DEFAULT_STRICT, docstring= 'The reference frequency value for which the patterns are computed.' ) # type: float EBFreqShift = BooleanDescriptor( 'EBFreqShift', _required, strict=DEFAULT_STRICT, docstring= "Parameter indicating whether the electronic boresight shifts with " "frequency.") # type: bool MLFreqDilation = BooleanDescriptor( 'MLFreqDilation', _required, strict=DEFAULT_STRICT, docstring="Parameter indicating the mainlobe (ML) width changes with " "frequency.") # type: bool GainZero = FloatDescriptor( 'GainZero', _required, strict=DEFAULT_STRICT, docstring='The reference antenna gain at zero steering angle at the ' 'reference frequency, measured in dB.') # type: float GainBSPoly = SerializableDescriptor( 'GainBSPoly', Poly1DType, _required, strict=DEFAULT_STRICT, docstring= 'Gain polynomial *(in dB)* as a function of frequency for boresight *(BS)* ' 'at :math:`DCX=0, DCY=0`. ' 'Frequency ratio :math:`(f-f0)/f0` is the input variable, and the constant ' 'coefficient is always `0.0`.') # type: Poly1DType ArrayGPId = StringDescriptor( 'ArrayGPId', _required, strict=DEFAULT_STRICT, docstring= 'Support array identifier of the sampled gain/phase of the array ' 'at ref frequency.') # type: str ElementGPId = StringDescriptor( 'ElementGPId', _required, strict=DEFAULT_STRICT, docstring= 'Support array identifier of the sampled gain/phase of the element ' 'at ref frequency.') # type: str def __init__(self, Identifier=None, FreqZero=None, EBFreqShift=None, MLFreqDilation=None, GainZero=None, GainBSPoly=None, ArrayGPId=None, ElementGPId=None, **kwargs): """ Parameters ---------- Identifier : str FreqZero : float EBFreqShift : bool MLFreqDilation : bool GainZero : None|float GainBSPoly : None|Poly1DType ArrayGPId : str ElementGPId : str kwargs """ if '_xml_ns' in kwargs: self._xml_ns = kwargs['_xml_ns'] if '_xml_ns_key' in kwargs: self._xml_ns_key = kwargs['_xml_ns_key'] self.Identifier = Identifier self.FreqZero = FreqZero self.EBFreqShift = EBFreqShift self.MLFreqDilation = MLFreqDilation self.GainZero = GainZero self.GainBSPoly = GainBSPoly self.ArrayGPId = ArrayGPId self.ElementGPId = ElementGPId super(AntPatternType, self).__init__(**kwargs)
class ImageInfoType(Serializable): _fields = ('DataFilename', 'ClassificationMarkings', 'Filetype', 'DataCheckSum', 'DataSize', 'DataPlane', 'DataDomain', 'DataType', 'BitsPerSample', 'DataFormat', 'DataByteOrder', 'NumPixels', 'ImageCollectionDate', 'ZuluOffset', 'SensorReferencePoint', 'SensorCalibrationFactor', 'DataCalibrated', 'Resolution', 'PixelSpacing', 'WeightingType', 'OverSamplingFactor', 'IPRWidth3dB', 'ImageQualityDescription', 'ImageHeading', 'ImageCorners', 'SlantPlane', 'GroundPlane', 'SceneCenterReferenceLine', 'ProjectionPerturbation') _required = ('DataFilename', 'ClassificationMarkings', 'DataCheckSum', 'DataPlane', 'DataDomain', 'DataType', 'DataFormat', 'NumPixels', 'ImageCollectionDate', 'SensorReferencePoint', 'DataCalibrated', 'Resolution', 'PixelSpacing', 'WeightingType', 'ImageCorners') _numeric_format = { 'ImageHeading': '0.17G', 'SensorCalibrationFactor': '0.17G', 'SceneCenterReferenceLine': '0.17G', } # descriptors DataFilename = StringDescriptor( 'DataFilename', _required, docstring='The base file name to which this information pertains' ) # type: str ClassificationMarkings = SerializableDescriptor( 'ClassificationMarkings', ClassificationMarkingsType, _required, docstring='The classification information' ) # type: ClassificationMarkingsType Filetype = StringDescriptor( 'Filetype', _required, docstring='The image file type') # type: Optional[str] DataCheckSum = StringDescriptor( 'DataCheckSum', _required, docstring='The 32 character (hexidecimal digest) MD5 checksum of the ' 'full image file') # type: str DataSize = IntegerDescriptor( 'DataSize', _required, docstring='The image size in bytes') # type: Optional[int] DataPlane = StringEnumDescriptor('DataPlane', {'Slant', 'Ground'}, _required, default_value='Slant', docstring='The image plane.') # type: str DataDomain = StringEnumDescriptor( 'DataDomain', { 'Image', }, _required, # todo: values docstring='The image data domain') # type: str DataType = StringEnumDescriptor( 'DataType', {'Magnitude/Phase', 'In-phase/Quadrature'}, _required, docstring='The image data type') # type: str BitsPerSample = IntegerDescriptor( 'BitsPerSample', _required, docstring='The number of bits per sample') # type: Optional[int] DataFormat = StringDescriptor( 'DataFormat', _required, docstring='The image data format') # type: str DataByteOrder = StringEnumDescriptor( 'DataByteOrder', {'Big-Endian', 'Little-Endian'}, _required, docstring='The image data byte order.') # type: Optional[str] NumPixels = SerializableDescriptor( 'NumPixels', NumPixelsType, _required, docstring='The number of image pixels') # type: NumPixelsType ImageCollectionDate = DateTimeDescriptor( 'ImageCollectionDate', _required, docstring='The date/time of the image collection in UTC' ) # type: Optional[numpy.datetime64] ZuluOffset = StringDescriptor( 'ZuluOffset', _required, docstring='The local time offset from UTC') # type: Optional[str] SensorReferencePoint = StringEnumDescriptor( 'DataPlane', {'Left', 'Right', 'Top', 'Bottom'}, _required, docstring='Description of the sensor location relative to the scene.' ) # type: Optional[str] SensorCalibrationFactor = FloatDescriptor( 'SensorCalibrationFactor', _required, docstring= 'Multiplicative factor used to scale raw image data to the return ' 'of a calibrated reference reflector or active source' ) # type: Optional[float] DataCalibrated = BooleanDescriptor( 'DataCalibrated', _required, docstring='Has the data been calibrated?') # type: bool Resolution = SerializableDescriptor( 'Resolution', RangeCrossRangeType, _required, docstring='Resolution (intrinsic) of the sensor system/mode in meters.' ) # type: RangeCrossRangeType PixelSpacing = SerializableDescriptor( 'PixelSpacing', RangeCrossRangeType, _required, docstring='Pixel spacing of the image in meters.' ) # type: RangeCrossRangeType WeightingType = SerializableDescriptor( 'WeightingType', StringRangeCrossRangeType, _required, docstring='Weighting function applied to the image during formation.' ) # type: StringRangeCrossRangeType OverSamplingFactor = SerializableDescriptor( 'OverSamplingFactor', RangeCrossRangeType, _required, docstring='The factor by which the pixel space is oversampled.' ) # type: Optional[RangeCrossRangeType] IPRWidth3dB = SerializableDescriptor( 'IPRWidth3dB', RangeCrossRangeType, _required, docstring='The 3 dB system impulse response with, in meters' ) # type: Optional[RangeCrossRangeType] ImageQualityDescription = StringDescriptor( 'ImageQualityDescription', _required, docstring='General description of image quality' ) # type: Optional[str] ImageHeading = FloatDescriptor( 'ImageHeading', _required, docstring='Image heading relative to True North, in degrees' ) # type: Optional[float] ImageCorners = SerializableDescriptor( 'ImageCorners', ImageCornerType, _required, docstring='The image corners') # type: ImageCornerType SlantPlane = SerializableDescriptor( 'SlantPlane', PixelSpacingType, _required, docstring='The slant plane pixel spacing' ) # type: Optional[PixelSpacingType] GroundPlane = SerializableDescriptor( 'GroundPlane', PixelSpacingType, _required, docstring='The ground plane pixel spacing' ) # type: Optional[PixelSpacingType] SceneCenterReferenceLine = FloatDescriptor( 'SceneCenterReferenceLine', _required, docstring='The ideal line (heading) at the intersection of the radar ' 'line-of-sight with the horizontal reference plane ' 'created by the forward motion of the aircraft, ' 'in degrees') # type: Optional[float] ProjectionPerturbation = SerializableDescriptor( 'ProjectionPerturbation', ProjectionPerturbationType, _required, docstring='') # type: Optional[ProjectionPerturbationType] def __init__(self, DataFilename=None, ClassificationMarkings=None, FileType=None, DataCheckSum=None, DataSize=None, DataPlane='Slant', DataDomain=None, DataType=None, BitsPerSample=None, DataFormat=None, DataByteOrder=None, NumPixels=None, ImageCollectionDate=None, ZuluOffset=None, SensorReferencePoint=None, SensorCalibrationFactor=None, DataCalibrated=None, Resolution=None, PixelSpacing=None, WeightingType=None, OverSamplingFactor=None, IPRWidth3dB=None, ImageQualityDescription=None, ImageHeading=None, ImageCorners=None, SlantPlane=None, GroundPlane=None, SceneCenterReferenceLine=None, ProjectionPerturbation=None, **kwargs): """ Parameters ---------- DataFilename : str ClassificationMarkings : ClassificationMarkingsType FileType : str DataCheckSum : str DataSize : int DataPlane : str DataDomain : None|str DataType : None|str BitsPerSample : None|int DataFormat : None|str DataByteOrder : None|str NumPixels : NumPixelsType|numpy.ndarray|list|tuple ImageCollectionDate : numpy.datetime64|datetime|date|str ZuluOffset : None|str SensorReferencePoint : None|str SensorCalibrationFactor : None|float DataCalibrated : bool Resolution : RangeCrossRangeType|numpy.ndarray|list|tuple PixelSpacing : RangeCrossRangeType|numpy.ndarray|list|tuple WeightingType : StringRangeCrossRangeType OverSamplingFactor : None|RangeCrossRangeType IPRWidth3dB : None|RangeCrossRangeType|numpy.ndarray|list|tuple ImageQualityDescription : None|str ImageHeading : None|float ImageCorners : ImageCornerType SlantPlane : None|PixelSpacingType GroundPlane : None|PixelSpacingType SceneCenterReferenceLine : None|float ProjectionPerturbation : None|ProjectionPerturbationType kwargs Other keyword arguments """ if '_xml_ns' in kwargs: self._xml_ns = kwargs['_xml_ns'] if '_xml_ns_key' in kwargs: self._xml_ns_key = kwargs['_xml_ns_key'] self.DataFilename = DataFilename if ClassificationMarkings is None: self.ClassificationMarkings = ClassificationMarkingsType() else: self.ClassificationMarkings = ClassificationMarkings self.Filetype = FileType self.DataCheckSum = DataCheckSum self.DataSize = DataSize self.DataPlane = DataPlane self.DataDomain = DataDomain self.DataType = DataType self.BitsPerSample = BitsPerSample self.DataFormat = DataFormat self.DataByteOrder = DataByteOrder self.NumPixels = NumPixels self.ImageCollectionDate = ImageCollectionDate self.ZuluOffset = ZuluOffset self.SensorReferencePoint = SensorReferencePoint self.SensorCalibrationFactor = SensorCalibrationFactor self.DataCalibrated = DataCalibrated self.Resolution = Resolution self.PixelSpacing = PixelSpacing self.WeightingType = WeightingType self.OverSamplingFactor = OverSamplingFactor self.IPRWidth3dB = IPRWidth3dB self.ImageQualityDescription = ImageQualityDescription self.ImageHeading = ImageHeading self.ImageCorners = ImageCorners self.SlantPlane = SlantPlane self.GroundPlane = GroundPlane self.SceneCenterReferenceLine = SceneCenterReferenceLine self.ProjectionPerturbation = ProjectionPerturbation super(ImageInfoType, self).__init__(**kwargs) @classmethod def from_sicd(cls, sicd, base_file_name, file_type='NITF02.10', md5_checksum=None): """ Construct the ImageInfo from the sicd object and given image file name. Parameters ---------- sicd : SICDType base_file_name : str file_type : str The file type. This should probably always be NITF02.10 for now. md5_checksum : None|str The md5 checksum of the full image file. Returns ------- ImageInfoType """ pixel_type = sicd.ImageData.PixelType if pixel_type == 'RE32F_IM32F': data_type = 'In-phase/Quadrature' bits_per_sample = 32 data_format = 'float' elif pixel_type == 'RE16I_IM16I': data_type = 'In-phase/Quadrature' bits_per_sample = 16 data_format = 'integer' elif pixel_type == 'AMP8I_PHS8I': data_type = 'Magnitude/Phase' bits_per_sample = 8 data_format = 'unsigned integer' else: raise ValueError('Unhandled') data_cal = sicd.Radiometric is not None icps = ImageCornerType(UpperLeft=sicd.GeoData.ImageCorners.FRFC, UpperRight=sicd.GeoData.ImageCorners.FRLC, LowerRight=sicd.GeoData.ImageCorners.LRLC, LowerLeft=sicd.GeoData.ImageCorners.LRFC) if sicd.Grid.ImagePlane == 'SLANT': data_plane = 'Slant' elif sicd.Grid.ImagePlane == 'Ground': data_plane = 'Ground' else: data_plane = None has_perturb = False proj_perturb = None coa = sicd.coa_projection if coa is not None: delta_arp = coa.delta_arp if numpy.any(delta_arp != 0): has_perturb = True else: delta_arp = None delta_varp = coa.delta_varp if numpy.any(delta_varp != 0): has_perturb = True else: delta_varp = None delta_range = coa.delta_range if delta_range != 0: has_perturb = True else: delta_range = None if has_perturb: proj_perturb = ProjectionPerturbationType( CoordinateFrame='ECF', DeltaArp=delta_arp, DeltaVarp=delta_varp, DeltaRange=delta_range) return ImageInfoType( DataFilename=base_file_name, ClassificationMarkings=ClassificationMarkingsType( Classification=sicd.CollectionInfo.Classification), FileType=file_type, DataCheckSum=md5_checksum, DataPlane=data_plane, DataType=data_type, DataCalibrated=data_cal, BitsPerSample=bits_per_sample, DataDomain='Image', DataFormat=data_format, DataByteOrder='Big-Endian', NumPixels=(sicd.ImageData.NumRows, sicd.ImageData.NumCols), ImageCollectionDate=sicd.Timeline.CollectStart, SensorReferencePoint='Top', Resolution=(sicd.Grid.Row.ImpRespWid, sicd.Grid.Col.ImpRespWid), PixelSpacing=(sicd.Grid.Row.SS, sicd.Grid.Col.SS), WeightingType=StringRangeCrossRangeType( Range=sicd.Grid.Row.WgtType.WindowName, CrossRange=sicd.Grid.Col.WgtType.WindowName), ImageHeading=sicd.SCPCOA.AzimAng, ImageCorners=icps, ProjectionPerturbation=proj_perturb)
class AntPatternType(Serializable): """ Parameter set that defines each Antenna Pattern as function time. """ _fields = ('Identifier', 'FreqZero', 'GainZero', 'EBFreqShift', 'MLFreqDilation', 'GainBSPoly', 'EB', 'Array', 'Element', 'GainPhaseArray') _required = ('Identifier', 'FreqZero', 'EB', 'Array', 'Element') _collections_tags = { 'GainPhaseArray': { 'array': False, 'child_tag': 'GainPhaseArray' } } _numeric_format = {'FreqZero': '0.16G', 'GainZero': '0.16G'} # descriptors Identifier = StringDescriptor( 'Identifier', _required, strict=DEFAULT_STRICT, docstring='String that uniquely identifies this ACF.') # type: str FreqZero = FloatDescriptor( 'FreqZero', _required, strict=DEFAULT_STRICT, docstring= 'The reference frequency value for which the Electrical Boresight ' 'and array pattern polynomials are computed.') # type: float GainZero = FloatDescriptor( 'GainZero', _required, strict=DEFAULT_STRICT, docstring='The reference antenna gain at zero steering angle at the ' 'reference frequency, measured in dB.') # type: float EBFreqShift = BooleanDescriptor( 'EBFreqShift', _required, strict=DEFAULT_STRICT, docstring= "Parameter indicating whether the electronic boresite shifts with " "frequency.") # type: bool MLFreqDilation = BooleanDescriptor( 'MLFreqDilation', _required, strict=DEFAULT_STRICT, docstring="Parameter indicating the mainlobe (ML) width changes with " "frequency.") # type: bool GainBSPoly = SerializableDescriptor( 'GainBSPoly', Poly1DType, _required, strict=DEFAULT_STRICT, docstring= 'Gain polynomial *(in dB)* as a function of frequency for boresight *(BS)* ' 'at :math:`DCX=0, DCY=0`. ' 'Frequency ratio :math:`(f-f0)/f0` is the input variable, and the constant ' 'coefficient is always `0.0`.') # type: Poly1DType EB = SerializableDescriptor( 'EB', EBType, _required, strict=DEFAULT_STRICT, docstring= 'Electrical boresight *(EB)* steering directions for an electronically ' 'steered array.') # type: EBType Array = SerializableDescriptor( 'Array', GainPhasePolyType, _required, strict=DEFAULT_STRICT, docstring='Array pattern polynomials that define the shape of the ' 'main-lobe.') # type: GainPhasePolyType Element = SerializableDescriptor( 'Element', GainPhasePolyType, _required, strict=DEFAULT_STRICT, docstring='Element array pattern polynomials for electronically steered ' 'arrays.') # type: GainPhasePolyType GainPhaseArray = SerializableListDescriptor( 'GainPhaseArray', GainPhaseArrayType, _collections_tags, _required, strict=DEFAULT_STRICT, docstring= 'Array of parameters that identify 2-D sampled Gain and Phase patterns at ' 'single frequency value.' ) # type: Union[None, List[GainPhaseArrayType]] def __init__(self, Identifier=None, FreqZero=None, GainZero=None, EBFreqShift=None, MLFreqDilation=None, GainBSPoly=None, EB=None, Array=None, Element=None, GainPhaseArray=None, **kwargs): """ Parameters ---------- Identifier : str FreqZero : float GainZero : float EBFreqShift : bool MLFreqDilation : bool GainBSPoly : None|Poly1DType EB : EBType Array : GainPhasePolyType Element : GainPhasePolyType GainPhaseArray : None|List[GainPhaseArrayType] kwargs """ if '_xml_ns' in kwargs: self._xml_ns = kwargs['_xml_ns'] if '_xml_ns_key' in kwargs: self._xml_ns_key = kwargs['_xml_ns_key'] self.Identifier = Identifier self.FreqZero = FreqZero self.GainZero = GainZero self.EBFreqShift = EBFreqShift self.MLFreqDilation = MLFreqDilation self.GainBSPoly = GainBSPoly self.EB = EB self.Array = Array self.Element = Element self.GainPhaseArray = GainPhaseArray super(AntPatternType, self).__init__(**kwargs)
class ChannelParametersType(Serializable): """ The CRSD data channel parameters """ _fields = ( 'Identifier', 'RefVectorIndex', 'RefFreqFixed', 'FrcvFixed', 'DemodFixed', 'F0Ref', 'Fs', 'BWInst', 'RcvPol', 'SignalNormal', 'RcvAntenna', 'SignalRefLevel', 'NoiseLevel', 'AddedParameters', 'SARImaging') _required = ( 'Identifier', 'RefVectorIndex', 'RefFreqFixed', 'FrcvFixed', 'DemodFixed', 'F0Ref', 'Fs', 'BWInst', 'RcvPol') _numeric_format = { 'F0Ref': FLOAT_FORMAT, 'Fs': FLOAT_FORMAT, 'BWInst': FLOAT_FORMAT} _collections_tags = { 'AddedParameters': {'array': False, 'child_tag': 'AddedParameters'}} # descriptors Identifier = StringDescriptor( 'Identifier', _required, strict=DEFAULT_STRICT, docstring='String that uniquely identifies this CRSD data channel.') # type: str RefVectorIndex = IntegerDescriptor( 'RefVectorIndex', _required, strict=DEFAULT_STRICT, bounds=(0, None), docstring='Index of the reference vector for the channel.') # type: int RefFreqFixed = BooleanDescriptor( 'RefFreqFixed', _required, strict=DEFAULT_STRICT, docstring='Flag to indicate a constant reference frequency is used for' ' the channel.') # type: bool FrcvFixed = BooleanDescriptor( 'FrcvFixed', _required, strict=DEFAULT_STRICT, docstring='Flag to indicate a constant receive band is saved for the' ' channel.') # type: bool DemodFixed = BooleanDescriptor( 'DemodFixed', _required, strict=DEFAULT_STRICT, docstring='Flag to indicate a constant demodulation is used for the' ' channel.') # type: bool F0Ref = FloatDescriptor( 'F0Ref', _required, strict=DEFAULT_STRICT, bounds=(0, None), docstring='Reference frequency for the reference signal vector.') # type: float Fs = FloatDescriptor( 'Fs', _required, strict=DEFAULT_STRICT, bounds=(0, None), docstring='Fast time sample rate for the signal array.') # type: float BWInst = FloatDescriptor( 'BWInst', _required, strict=DEFAULT_STRICT, bounds=(0, None), docstring='Nominal instantaneous bandwidth for the channel.') # type: float RcvPol = StringEnumDescriptor( 'RcvPol', POLARIZATION_TYPE, _required, strict=DEFAULT_STRICT, docstring='Receive polarization for the signal data processed to form the signal array.' ' Parameter describes the E-Field orientation of the signal.') # type: str SignalNormal = BooleanDescriptor( 'SignalNormal', _required, strict=DEFAULT_STRICT, docstring='Flag to indicate when all signal array vectors are normal.' ' Included if and only if the SIGNAL PVP is also included.') # type: Union[None, bool] RcvAntenna = SerializableDescriptor( 'RcvAntenna', RcvAntennaType, _required, strict=DEFAULT_STRICT, docstring='Antenna Phase Center and Antenna Pattern identifiers for the receive antenna' ' used to collect and form the signal array data.') # type: Union[None, RcvAntennaType] SignalRefLevel = SerializableDescriptor( 'SignalRefLevel', SignalRefLevelType, _required, strict=DEFAULT_STRICT, docstring='Signal power levels for a received CW signal with f = f_0_REF and polarization' ' matched to RcvPol of the channel.') # type: Union[None, SignalRefLevelType] NoiseLevel = SerializableDescriptor( 'NoiseLevel', NoiseLevelType, _required, strict=DEFAULT_STRICT, docstring='Thermal noise level in the CRSD signal vector for f_IC(v,t) =' ' f_0(v_CH_REF).') # type: Union[None, NoiseLevelType] AddedParameters = ParametersDescriptor( 'AddedParameters', _collections_tags, _required, strict=DEFAULT_STRICT, docstring='Additional free form parameters.') # type: Union[None, ParametersCollection] SARImaging = SerializableDescriptor( 'SARImaging', SARImagingType, _required, strict=DEFAULT_STRICT, docstring='Structure included for all SAR imaging collections.') # type: Union[None, SARImagingType] def __init__(self, Identifier=None, RefVectorIndex=None, RefFreqFixed=None, FrcvFixed=None, DemodFixed=None, F0Ref=None, Fs=None, BWInst=None, RcvPol=None, SignalNormal=None, RcvAntenna=None, SignalRefLevel=None, NoiseLevel=None, AddedParameters=None, SARImaging=None, **kwargs): """ Parameters ---------- Identifier : str RefVectorIndex : int RefFreqFixed : bool FrcvFixed : bool DemodFixed : bool F0Ref : float Fs : float BWInst : float RcvPol : str SignalNormal : None|bool RcvAntenna : None|RcvAntennaType SignalRefLevel : None|SignalRefLevelType NoiseLevel : None|NoiseLevelType AddedParameters : None|ParametersCollection SARImaging : None|SARImagingType kwargs """ if '_xml_ns' in kwargs: self._xml_ns = kwargs['_xml_ns'] if '_xml_ns_key' in kwargs: self._xml_ns_key = kwargs['_xml_ns_key'] self.Identifier = Identifier self.RefVectorIndex = RefVectorIndex self.RefFreqFixed = RefFreqFixed self.FrcvFixed = FrcvFixed self.DemodFixed = DemodFixed self.F0Ref = F0Ref self.Fs = Fs self.BWInst = BWInst self.RcvPol = RcvPol self.SignalNormal = SignalNormal self.RcvAntenna = RcvAntenna self.SignalRefLevel = SignalRefLevel self.NoiseLevel = NoiseLevel self.AddedParameters = AddedParameters self.SARImaging = SARImaging super(ChannelParametersType, self).__init__(**kwargs)
class AntParamType(Serializable): """ The antenna parameters container. """ _fields = ('XAxisPoly', 'YAxisPoly', 'FreqZero', 'EB', 'Array', 'Elem', 'GainBSPoly', 'EBFreqShift', 'MLFreqDilation') _required = ('XAxisPoly', 'YAxisPoly', 'FreqZero', 'Array') _numeric_format = {'FreqZero': FLOAT_FORMAT} # descriptors XAxisPoly = SerializableDescriptor( 'XAxisPoly', XYZPolyType, _required, strict=DEFAULT_STRICT, docstring= 'Antenna X-Axis unit vector in ECF coordinates as a function of time ``(variable 1)``.' ) # type: XYZPolyType YAxisPoly = SerializableDescriptor( 'YAxisPoly', XYZPolyType, _required, strict=DEFAULT_STRICT, docstring= 'Antenna Y-Axis unit vector in ECF coordinates as a function of time ``(variable 1)``.' ) # type: XYZPolyType FreqZero = FloatDescriptor( 'FreqZero', _required, strict=DEFAULT_STRICT, docstring= 'RF frequency *(f0)* used to specify the array pattern and electrical boresite *(EB)* ' 'steering direction cosines.') # type: float EB = SerializableDescriptor( 'EB', EBType, _required, strict=DEFAULT_STRICT, docstring= 'Electrical boresight *(EB)* steering directions for an electronically ' 'steered array.') # type: EBType Array = SerializableDescriptor( 'Array', GainPhasePolyType, _required, strict=DEFAULT_STRICT, docstring= 'Array pattern polynomials that define the shape of the main-lobe.' ) # type: GainPhasePolyType Elem = SerializableDescriptor( 'Elem', GainPhasePolyType, _required, strict=DEFAULT_STRICT, docstring= 'Element array pattern polynomials for electronically steered arrays.' ) # type: GainPhasePolyType GainBSPoly = SerializableDescriptor( 'GainBSPoly', Poly1DType, _required, strict=DEFAULT_STRICT, docstring= 'Gain polynomial *(in dB)* as a function of frequency for boresight *(BS)* at :math:`DCX=0, DCY=0`. ' 'Frequency ratio :math:`(f-f0)/f0` is the input variable ``(variable 1)``, and the constant ' 'coefficient is always `0.0`.') # type: Poly1DType EBFreqShift = BooleanDescriptor('EBFreqShift', _required, strict=DEFAULT_STRICT, docstring=""" Parameter indicating whether the electronic boresite shifts with frequency for an electronically steered array. * `False` - No shift with frequency. * `True` - Shift with frequency per ideal array theory. """) # type: bool MLFreqDilation = BooleanDescriptor('MLFreqDilation', _required, strict=DEFAULT_STRICT, docstring=""" Parameter indicating the mainlobe (ML) width changes with frequency. * `False` - No change with frequency. * `True` - Change with frequency per ideal array theory. """) # type: bool def __init__(self, XAxisPoly=None, YAxisPoly=None, FreqZero=None, EB=None, Array=None, Elem=None, GainBSPoly=None, EBFreqShift=None, MLFreqDilation=None, **kwargs): """ Parameters ---------- XAxisPoly : XYZPolyType YAxisPoly : XYZPolyType FreqZero : float EB : EBType Array : GainPhasePolyType Elem : GainPhasePolyType GainBSPoly : Poly1DType|numpy.ndarray|list|tuple EBFreqShift : bool MLFreqDilation : bool kwargs : dict """ if '_xml_ns' in kwargs: self._xml_ns = kwargs['_xml_ns'] if '_xml_ns_key' in kwargs: self._xml_ns_key = kwargs['_xml_ns_key'] self.XAxisPoly, self.YAxisPoly = XAxisPoly, YAxisPoly self.FreqZero = FreqZero self.EB = EB self.Array, self.Elem = Array, Elem self.GainBSPoly = GainBSPoly self.EBFreqShift, self.MLFreqDilation = EBFreqShift, MLFreqDilation super(AntParamType, self).__init__(**kwargs) def _apply_reference_frequency(self, reference_frequency): if self.FreqZero is not None: self.FreqZero += reference_frequency
class ChannelType(Serializable): """ The channel definition. """ _fields = ( 'RefChId', 'FXFixedCPHD', 'TOAFixedCPHD', 'SRPFixedCPHD', 'Parameters', 'AddedParameters') _required = ( 'RefChId', 'FXFixedCPHD', 'TOAFixedCPHD', 'SRPFixedCPHD', 'Parameters') _collections_tags = { 'Parameters': {'array': False, 'child_tag': 'Parameters'}, 'AddedParameters': {'array': False, 'child_tag': 'AddedParameters'}} # descriptors RefChId = StringDescriptor( 'RefChId', _required, strict=DEFAULT_STRICT, docstring='Channel ID for the Reference Channel in the ' 'product.') # type: str FXFixedCPHD = BooleanDescriptor( 'FXFixedCPHD', _required, strict=DEFAULT_STRICT, docstring='Flag to indicate when a constant FX band is saved for all ' 'signal vectors of all channels.') # type: bool TOAFixedCPHD = BooleanDescriptor( 'TOAFixedCPHD', _required, strict=DEFAULT_STRICT, docstring='Flag to indicate when a constant TOA swath is saved for all ' 'signal vectors of all channels.') # type: bool SRPFixedCPHD = BooleanDescriptor( 'SRPFixedCPHD', _required, strict=DEFAULT_STRICT, docstring='Flag to indicate when a constant SRP position is used all ' 'signal vectors of all channels.') # type: bool Parameters = SerializableListDescriptor( 'Parameters', ChannelParametersType, _collections_tags, _required, strict=DEFAULT_STRICT, docstring='Parameter Set that describes a CPHD data ' 'channel.') # type: List[ChannelParametersType] AddedParameters = ParametersDescriptor( 'AddedParameters', _collections_tags, _required, strict=DEFAULT_STRICT, docstring='Additional free form parameters.') # type: Union[None, ParametersCollection] def __init__(self, RefChId=None, FXFixedCPHD=None, TOAFixedCPHD=None, SRPFixedCPHD=None, Parameters=None, AddedParameters=None, **kwargs): """ Parameters ---------- RefChId : str FXFixedCPHD : bool TOAFixedCPHD : bool SRPFixedCPHD : bool Parameters : List[ChannelParametersType] AddedParameters kwargs """ if '_xml_ns' in kwargs: self._xml_ns = kwargs['_xml_ns'] if '_xml_ns_key' in kwargs: self._xml_ns_key = kwargs['_xml_ns_key'] self.RefChId = RefChId self.FXFixedCPHD = FXFixedCPHD self.TOAFixedCPHD = TOAFixedCPHD self.SRPFixedCPHD = SRPFixedCPHD self.Parameters = Parameters self.AddedParameters = AddedParameters super(ChannelType, self).__init__(**kwargs)
class ChannelParametersType(Serializable): _fields = ( 'Identifier', 'RefVectorIndex', 'FXFixed', 'TOAFixed', 'SRPFixed', 'SignalNormal', 'Polarization', 'FxC', 'FxBW', 'FxBWNoise', 'TOASaved', 'TOAExtended', 'DwellTimes', 'ImageArea', 'Antenna', 'TxRcv', 'TgtRefLevel', 'NoiseLevel') _required = ( 'Identifier', 'RefVectorIndex', 'FXFixed', 'TOAFixed', 'SRPFixed', 'Polarization', 'FxC', 'FxBW', 'TOASaved', 'DwellTimes') _numeric_format = { 'FxC': FLOAT_FORMAT, 'FxBW': FLOAT_FORMAT, 'FxBWNoise': FLOAT_FORMAT, 'TOASaved': FLOAT_FORMAT} # descriptors Identifier = StringDescriptor( 'Identifier', _required, strict=DEFAULT_STRICT, docstring='String that uniquely identifies this CPHD data channel.') # type: str RefVectorIndex = IntegerDescriptor( 'RefVectorIndex', _required, strict=DEFAULT_STRICT, bounds=(0, None), docstring='Index of the reference vector for the channel.') # type: int FXFixed = BooleanDescriptor( 'FXFixed', _required, strict=DEFAULT_STRICT, docstring='Flag to indicate when a constant FX band is saved for all signal ' 'vectors of the channel.') # type: bool TOAFixed = BooleanDescriptor( 'TOAFixed', _required, strict=DEFAULT_STRICT, docstring='Flag to indicate when a constant TOA swath is saved for all ' 'signal vectors of the channel.') # type: bool SRPFixed = BooleanDescriptor( 'SRPFixed', _required, strict=DEFAULT_STRICT, docstring='Flag to indicate when a constant SRP position is used all ' 'signal vectors of the channel.') # type: bool SignalNormal = BooleanDescriptor( 'SignalNormal', _required, strict=DEFAULT_STRICT, docstring='Flag to indicate when all signal array vectors are normal. ' 'Included if and only if the SIGNAL PVP is also included.') # type: bool Polarization = SerializableDescriptor( 'Polarization', PolarizationType, _required, strict=DEFAULT_STRICT, docstring='Polarization(s) of the signals that formed the signal ' 'array.') # type: PolarizationType FxC = FloatDescriptor( 'FxC', _required, strict=DEFAULT_STRICT, bounds=(0, None), docstring='FX center frequency value for saved bandwidth for the channel. ' 'Computed from all vectors of the signal array.') # type: float FxBW = FloatDescriptor( 'FxBW', _required, strict=DEFAULT_STRICT, bounds=(0, None), docstring='FX band spanned for the saved bandwidth for the channel. ' 'Computed from all vectors of the signal array.') # type: float FxBWNoise = FloatDescriptor( 'FxBWNoise', _required, strict=DEFAULT_STRICT, bounds=(0, None), docstring='FX signal bandwidth saved that includes noise signal below or ' 'above the retained echo signal bandwidth.') # type: float TOASaved = FloatDescriptor( 'TOASaved', _required, strict=DEFAULT_STRICT, bounds=(0, None), docstring='TOA swath saved for the full resolution echoes for the channel.') # type: float TOAExtended = SerializableDescriptor( 'TOAExtended', TOAExtendedType, _required, strict=DEFAULT_STRICT, docstring='TOA extended swath information.') # type: Union[None, TOAExtendedType] DwellTimes = SerializableDescriptor( 'DwellTimes', DwellTimesType, _required, strict=DEFAULT_STRICT, docstring='COD Time and Dwell Time polynomials over the image area.') # type: DwellTimesType ImageArea = SerializableDescriptor( 'ImageArea', AreaType, _required, strict=DEFAULT_STRICT, docstring='Image Area for the CPHD channel defined by a rectangle aligned with ' '(IAX, IAY). May be reduced by the optional ' 'polygon.') # type: Union[None, AreaType] Antenna = SerializableDescriptor( 'Antenna', AntennaType, _required, strict=DEFAULT_STRICT, docstring='Antenna Phase Center and Antenna Pattern identifiers for the antenna(s) ' 'used to collect and form the signal array data.') # type: Union[None, AntennaType] TxRcv = SerializableDescriptor( 'TxRcv', TxRcvType, _required, strict=DEFAULT_STRICT, docstring='Parameters to identify the Transmit and Receive parameter sets ' 'used to collect the signal array.') # type: Union[None, TxRcvType] TgtRefLevel = SerializableDescriptor( 'TgtRefLevel', TgtRefLevelType, _required, strict=DEFAULT_STRICT, docstring='Signal level for an ideal point scatterer located at the SRP for ' 'reference signal vector.') # type: Union[None, TgtRefLevelType] NoiseLevel = SerializableDescriptor( 'NoiseLevel', NoiseLevelType, _required, strict=DEFAULT_STRICT, docstring='Thermal noise level for the reference signal ' 'vector.') # type: Union[None, NoiseLevelType] def __init__(self, Identifier=None, RefVectorIndex=None, FXFixed=None, TOAFixed=None, SRPFixed=None, SignalNormal=None, Polarization=None, FxC=None, FxBW=None, FxBWNoise=None, TOASaved=None, TOAExtended=None, DwellTimes=None, ImageArea=None, Antenna=None, TxRcv=None, TgtRefLevel=None, NoiseLevel=None, **kwargs): """ Parameters ---------- Identifier : str RefVectorIndex : int FXFixed : bool TOAFixed : bool SRPFixed : bool SignalNormal : None|bool Polarization : PolarizationType FxC : float FxBW : float FxBWNoise : None|float TOASaved : float TOAExtended : None|TOAExtendedType DwellTimes : DwellTimesType ImageArea : None|AreaType Antenna : None|AntennaType TxRcv : None|TxRcvType TgtRefLevel : None|TgtRefLevelType NoiseLevel : None|NoiseLevelType kwargs """ if '_xml_ns' in kwargs: self._xml_ns = kwargs['_xml_ns'] if '_xml_ns_key' in kwargs: self._xml_ns_key = kwargs['_xml_ns_key'] self.Identifier = Identifier self.RefVectorIndex = RefVectorIndex self.FXFixed = FXFixed self.TOAFixed = TOAFixed self.SRPFixed = SRPFixed self.SignalNormal = SignalNormal self.Polarization = Polarization self.FxC = FxC self.FxBW = FxBW self.FxBWNoise = FxBWNoise self.TOASaved = TOASaved self.TOAExtended = TOAExtended self.DwellTimes = DwellTimes self.ImageArea = ImageArea self.Antenna = Antenna self.TxRcv = TxRcv self.TgtRefLevel = TgtRefLevel self.NoiseLevel = NoiseLevel super(ChannelParametersType, self).__init__(**kwargs)
class TxRcvPolarizationType(Serializable): """ The transmit/receive polarization information. """ _fields = ('TxPolarization', 'RcvPolarization', 'RcvPolarizationOffset', 'Processed') _required = ('TxPolarization', 'RcvPolarization') _numeric_format = {'RcvPolarizationOffset': '0.16G'} # Descriptor TxPolarization = StringEnumDescriptor( 'TxPolarization', POLARIZATION1_VALUES, _required, strict=DEFAULT_STRICT, docstring='Transmit polarization type.') # type: str RcvPolarization = StringEnumDescriptor( 'RcvPolarization', POLARIZATION1_VALUES, _required, strict=DEFAULT_STRICT, docstring='Receive polarization type.') # type: str RcvPolarizationOffset = FloatModularDescriptor( 'RcvPolarizationOffset', 180.0, _required, strict=DEFAULT_STRICT, docstring= 'Angle offset for the receive polarization defined at aperture ' 'center.') # type: Union[None, float] Processed = BooleanDescriptor('Processed', _required, strict=DEFAULT_STRICT, docstring='') # type: Union[None, bool] def __init__(self, TxPolarization=None, RcvPolarization=None, RcvPolarizationOffset=None, Processed=None, **kwargs): """ Parameters ---------- TxPolarization : str RcvPolarization : str RcvPolarizationOffset : None|float Processed : None|bool kwargs """ if '_xml_ns' in kwargs: self._xml_ns = kwargs['_xml_ns'] if '_xml_ns_key' in kwargs: self._xml_ns_key = kwargs['_xml_ns_key'] self.TxPolarization = TxPolarization self.RcvPolarization = RcvPolarization self.RcvPolarizationOffset = RcvPolarizationOffset self.Processed = Processed super(TxRcvPolarizationType, self).__init__(**kwargs) @classmethod def from_sicd_value(cls, str_in): """ Construct from the sicd style tx/rcv polarization string. Parameters ---------- str_in : str Returns ------- TxRcvPolarizationType """ tx, rcv = _extract_sicd_tx_rcv_pol(str_in) return cls(TxPolarization=tx, RcvPolarization=rcv)