class ProcTxRcvPolarizationType(Serializable): """ The processed transmit/receive polarization. """ _fields = ('TxPolarizationProc', 'RcvPolarizationProc') _required = ('TxPolarizationProc', 'RcvPolarizationProc') # Descriptor TxPolarizationProc = StringEnumDescriptor( 'TxPolarizationProc', POLARIZATION1_VALUES, _required, strict=DEFAULT_STRICT, docstring='Transmit polarization type.') # type: str RcvPolarizationProc = StringEnumDescriptor( 'RcvPolarizationProc', POLARIZATION1_VALUES, _required, strict=DEFAULT_STRICT, docstring='Receive polarization type.') # type: str def __init__(self, TxPolarizationProc=None, RcvPolarizationProc=None, **kwargs): """ Parameters ---------- TxPolarizationProc : str RcvPolarizationProc : 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.TxPolarizationProc = TxPolarizationProc self.RcvPolarizationProc = RcvPolarizationProc super(ProcTxRcvPolarizationType, 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 ------- ProcTxRcvPolarizationType """ tx, rcv = _extract_sicd_tx_rcv_pol(str_in) return cls(TxPolarizationProc=tx, RcvPolarizationProc=rcv)
class BandEqualizationType(Serializable): """ """ _fields = ('Algorithm', 'BandLUTs') _required = ('Algorithm', 'BandLUTs') _collections_tags = {'BandLUTs': {'array': True, 'child_tag': 'BandLUT'}} # Descriptor Algorithm = StringEnumDescriptor( 'Algorithm', ('1DLUT', ), _required, strict=DEFAULT_STRICT, default_value='1DLUT', docstring='The algorithm type.') # type: str BandLUTs = SerializableArrayDescriptor( 'BandLUTs', BandLUTType, _collections_tags, _required, strict=DEFAULT_STRICT, array_extension=BandLUTArray, docstring='') # type: Union[BandLUTArray, List[BandLUTType]] def __init__(self, Algorithm='1DLUT', BandLUTs=None, **kwargs): """ Parameters ---------- Algorithm : str `1DLUT` is currently the only allowed value. BandLUTs : BandLUTArray|List[BandLUTType] 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.Algorithm = Algorithm self.BandLUTs = BandLUTs super(BandEqualizationType, self).__init__(**kwargs)
class NoiseLevelType_(Serializable): """ Noise level structure. """ _fields = ('NoiseLevelType', 'NoisePoly') _required = _fields # class variables _NOISE_LEVEL_TYPE_VALUES = ('ABSOLUTE', 'RELATIVE') # descriptors NoiseLevelType = StringEnumDescriptor( 'NoiseLevelType', _NOISE_LEVEL_TYPE_VALUES, _required, strict=DEFAULT_STRICT, docstring= 'Indicates that the noise power polynomial yields either absolute power level or power ' 'level relative to the *SCP* pixel location.') # type: str NoisePoly = SerializableDescriptor( 'NoisePoly', Poly2DType, _required, strict=DEFAULT_STRICT, docstring= 'Polynomial coefficients that yield thermal noise power *(in dB)* in a pixel as a function of ' 'image row coordinate *(variable 1)* and column coordinate *(variable 2)*.' ) # type: Poly2DType def __init__(self, NoiseLevelType=None, NoisePoly=None, **kwargs): """ Parameters ---------- NoiseLevelType : str NoisePoly : Poly2DType|numpy.ndarray|list|tuple 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.NoiseLevelType = NoiseLevelType self.NoisePoly = NoisePoly super(NoiseLevelType_, self).__init__(**kwargs) self._derive_noise_level() def _derive_noise_level(self): if self.NoiseLevelType is not None: return if self.NoisePoly is None: return # nothing to be done scp_val = self.NoisePoly.Coefs[0, 0] # the value at SCP if scp_val == 1: # the relative noise levels should be 1 at SCP self.NoiseLevelType = 'RELATIVE' else: # it seems safe that it's not absolute, in this case? self.NoiseLevelType = 'ABSOLUTE'
class AntGainPhaseType(SupportArrayCore): """ Antenna array with values are antenna gain and phase expressed in dB and cycles. Array coordinates are direction cosines with respect to the ACF (DCX, DCY). """ _fields = ('Identifier', 'ElementFormat', 'X0', 'Y0', 'XSS', 'YSS', 'NODATA') _required = ('Identifier', 'ElementFormat', 'X0', 'Y0', 'XSS', 'YSS') # descriptors ElementFormat = StringEnumDescriptor( 'ElementFormat', ('Gain=F4;Phase=F4;', ), _required, strict=DEFAULT_STRICT, default_value='Gain=F4;Phase=F4;', docstring='The data element format.') # type: str def __init__(self, Identifier=None, ElementFormat='Gain=F4;Phase=F4;', X0=None, Y0=None, XSS=None, YSS=None, NODATA=None, **kwargs): """ Parameters ---------- Identifier : str X0 : float Y0 : float XSS : float YSS : float NODATA : str kwargs """ super(AntGainPhaseType, self).__init__( Identifier=Identifier, ElementFormat=ElementFormat, X0=X0, Y0=Y0, XSS=XSS, YSS=YSS, NODATA=NODATA, **kwargs)
class FilterKernelType(Serializable): """ The filter kernel parameters. Provides the specifics for **either** a predefined or custom filter kernel. """ _fields = ('Predefined', 'Custom') _required = () _choice = ({'required': True, 'collection': ('Predefined', 'Custom')}, ) # Descriptor Predefined = SerializableDescriptor( 'Predefined', PredefinedFilterType, _required, strict=DEFAULT_STRICT, docstring='') # type: PredefinedFilterType Custom = StringEnumDescriptor( 'Custom', ('GENERAL', 'FILTER BANK'), _required, strict=DEFAULT_STRICT, docstring='') # type: str def __init__(self, Predefined=None, Custom=None, **kwargs): """ Parameters ---------- Predefined : None|PredefinedFilterType Custom : None|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.Predefined = Predefined self.Custom = Custom super(FilterKernelType, self).__init__(**kwargs)
class IAZArrayType(SupportArrayCore): """ Array of scene surface heights expressed in image coordinate IAZ values (meters). Grid coordinates are image area coordinates (IAX, IAY). """ _fields = ('Identifier', 'ElementFormat', 'X0', 'Y0', 'XSS', 'YSS', 'NODATA') _required = ('Identifier', 'ElementFormat', 'X0', 'Y0', 'XSS', 'YSS') # descriptors ElementFormat = StringEnumDescriptor( 'ElementFormat', ('IAZ=F4;', ), _required, strict=DEFAULT_STRICT, default_value='IAZ=F4;', docstring='The data element format.') # type: str def __init__(self, Identifier=None, ElementFormat='IAZ=F4;', X0=None, Y0=None, XSS=None, YSS=None, NODATA=None, **kwargs): """ Parameters ---------- Identifier : str ElementFormat : str X0 : float Y0 : float XSS : float YSS : float NODATA : str kwargs """ super(IAZArrayType, self).__init__( Identifier=Identifier, ElementFormat=ElementFormat, X0=X0, Y0=Y0, XSS=XSS, YSS=YSS, NODATA=NODATA, **kwargs)
class ChanParametersType(Serializable): """ Transmit receive sequence step details. """ _fields = ('TxRcvPolarization', 'RcvAPCIndex', 'index') _required = ('TxRcvPolarization', 'index', ) _set_as_attribute = ('index', ) # descriptors TxRcvPolarization = StringEnumDescriptor( 'TxRcvPolarization', DUAL_POLARIZATION_VALUES, _required, strict=DEFAULT_STRICT, docstring='Combined Transmit and Receive signal polarization for the channel.') # type: str RcvAPCIndex = IntegerDescriptor( 'RcvAPCIndex', _required, strict=DEFAULT_STRICT, docstring='Index of the Receive Aperture Phase Center (Rcv APC). Only include if Receive APC position ' 'polynomial(s) are included.') # type: int index = IntegerDescriptor( 'index', _required, strict=DEFAULT_STRICT, docstring='The parameter index') # type: int def __init__(self, TxRcvPolarization=None, RcvAPCIndex=None, index=None, **kwargs): """ Parameters ---------- TxRcvPolarization : str RcvAPCIndex : int index : int 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.TxRcvPolarization = TxRcvPolarization self.RcvAPCIndex = RcvAPCIndex self.index = index super(ChanParametersType, self).__init__(**kwargs) def get_transmit_polarization(self): if self.TxRcvPolarization is None: return None elif self.TxRcvPolarization in ['OTHER', 'UNKNOWN']: return 'OTHER' else: return self.TxRcvPolarization.split(':')[0] def permits_version_1_1(self): """ Does this value permit storage in SICD version 1.1? Returns ------- bool """ return is_polstring_version1(self.TxRcvPolarization)
class RadarModeType(Serializable): """ Radar mode type container class """ _fields = ('ModeType', 'ModeID') _required = ('ModeType', ) # other class variable _MODE_TYPE_VALUES = ('SPOTLIGHT', 'STRIPMAP', 'DYNAMIC STRIPMAP', 'SCANSAR') # descriptors ModeType = StringEnumDescriptor( 'ModeType', _MODE_TYPE_VALUES, _required, strict=True, docstring="The Radar imaging mode.") # type: str ModeID = StringDescriptor( 'ModeID', _required, strict=DEFAULT_STRICT, docstring='Radar imaging mode per Program Specific Implementation Document.') # type: str def __init__(self, ModeID=None, ModeType=None, **kwargs): """ Parameters ---------- ModeID : str ModeType : str 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.ModeID, self.ModeType = ModeID, ModeType super(RadarModeType, self).__init__(**kwargs) def get_mode_abbreviation(self): """ Get the mode abbreviation for the suggested name. Returns ------- str """ mode = self.ModeType if mode is None: return 'UN' elif mode == 'SPOTLIGHT': return 'SL' elif mode == 'STRIPMAP': return 'ST' elif mode == 'DYNAMIC STRIPMAP': return 'DS' elif mode == 'SCANSAR': return 'SS' else: return 'UN'
class RRDSType(Serializable): """ RRDS type. """ _fields = ('DownsamplingMethod', 'AntiAlias', 'Interpolation') _required = ('DownsamplingMethod', ) # Descriptor DownsamplingMethod = StringEnumDescriptor( 'DownsamplingMethod', ('DECIMATE', 'MAX PIXEL', 'AVERAGE', 'NEAREST NEIGHBOR', 'BILINEAR', 'LAGRANGE'), _required, strict=DEFAULT_STRICT, docstring='Algorithm used to perform RRDS downsampling') # type: str AntiAlias = SerializableDescriptor( 'AntiAlias', FilterType, _required, strict=DEFAULT_STRICT, docstring='The anti-aliasing filter. Should only be included if ' '`DownsamplingMethod= "DECIMATE"`') # type: FilterType Interpolation = SerializableDescriptor( 'Interpolation', FilterType, _required, strict=DEFAULT_STRICT, docstring='The interpolation filter. Should only be included if ' '`DownsamplingMethod= "DECIMATE"`') # type: FilterType def __init__(self, DownsamplingMethod=None, AntiAlias=None, Interpolation=None, **kwargs): """ Parameters ---------- DownsamplingMethod : str AntiAlias : None|FilterType Interpolation : None|FilterType 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.DownsamplingMethod = DownsamplingMethod self.AntiAlias = AntiAlias self.Interpolation = Interpolation super(RRDSType, 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 PolarizationType(Serializable): """ Polarization(s) of the signals that formed the signal array. """ _fields = ('TxPol', 'RcvPol') _required = _fields # descriptors TxPol = StringEnumDescriptor( 'TxPol', POLARIZATION_TYPE, _required, strict=DEFAULT_STRICT, docstring='Transmitted signal polarization for the channel.') # type: str RcvPol = StringEnumDescriptor( 'RcvPol', POLARIZATION_TYPE, _required, strict=DEFAULT_STRICT, docstring='Receive polarization for the channel.') # type: str def __init__(self, TxPol=None, RcvPol=None, **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.TxPol = TxPol self.RcvPol = RcvPol super(PolarizationType, self).__init__(**kwargs)
class TxStepType(Serializable): """ Transmit sequence step details. """ _fields = ('WFIndex', 'TxPolarization', 'index') _required = ('index', ) _set_as_attribute = ('index', ) # descriptors WFIndex = IntegerDescriptor( 'WFIndex', _required, strict=DEFAULT_STRICT, docstring='The waveform number for this step.') # type: int TxPolarization = StringEnumDescriptor( 'TxPolarization', POLARIZATION2_VALUES, _required, strict=DEFAULT_STRICT, docstring='Transmit signal polarization for this step.') # type: str index = IntegerDescriptor('index', _required, strict=DEFAULT_STRICT, docstring='The step index') # type: int def __init__(self, WFIndex=None, TxPolarization=None, index=None, **kwargs): """ Parameters ---------- WFIndex : int TxPolarization : str index : int 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.WFIndex = WFIndex self.TxPolarization = TxPolarization self.index = index super(TxStepType, self).__init__(**kwargs)
class LabelSourceType(Serializable): _fields = ('SourceType', 'SourceID', 'Description') _required = ('SourceType', ) SourceType = StringEnumDescriptor( 'SourceType', { 'Ground Truth', 'Analyst Truth', 'Algorithm Truth', 'Other', 'Unknown' }, _required, docstring='The source type of the labeling effort') # type: str SourceID = StringDescriptor( 'SourceID', _required, docstring='The "ID" of the labeling source. ' 'This should be populated following program guidance.' ) # type: Optional[str] Description = StringDescriptor( 'Description', _required, docstring='A description of the labeling source' ) # type: Optional[str] def __init__(self, SourceType='Unknown', SourceID=None, Description=None, **kwargs): """ Parameters ---------- SourceType : str SourceID : None|str Description : None|str 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.SourceType = SourceType self.SourceID = SourceID self.Description = Description super(LabelSourceType, self).__init__(**kwargs)
class PredefinedFilterType(Serializable): """ The predefined filter type. """ _fields = ('DatabaseName', 'FilterFamily', 'FilterMember') _required = () # Descriptor DatabaseName = StringEnumDescriptor( 'DatabaseName', ('BILINEAR', 'CUBIC', 'LAGRANGE', 'NEAREST NEIGHBOR'), _required, strict=DEFAULT_STRICT, docstring='The filter name.') # type: str FilterFamily = IntegerDescriptor( 'FilterFamily', _required, strict=DEFAULT_STRICT, docstring='The filter family number.') # type: int FilterMember = IntegerDescriptor( 'FilterMember', _required, strict=DEFAULT_STRICT, docstring='The filter member number.') # type: int def __init__(self, DatabaseName=None, FilterFamily=None, FilterMember=None, **kwargs): """ Parameters ---------- DatabaseName : None|str FilterFamily : None|int FilterMember : None|int 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.DatabaseName = DatabaseName self.FilterFamily = FilterFamily self.FilterMember = FilterMember super(PredefinedFilterType, self).__init__(**kwargs)
class FilterType(Serializable): """ Filter parameters for a variety of purposes. Provides **either** the filter bank or filter kernel parameters. """ _fields = ('FilterName', 'FilterKernel', 'FilterBank', 'Operation') _required = ('FilterName', 'Operation') _choice = ({'required': True, 'collection': ('FilterKernel', 'FilterBank')}, ) # Descriptor FilterName = StringDescriptor( 'FilterName', _required, strict=DEFAULT_STRICT, docstring='The name of the filter.') # type : str FilterKernel = SerializableDescriptor( 'FilterKernel', FilterKernelType, _required, strict=DEFAULT_STRICT, docstring='The filter kernel.') # type: FilterKernelType FilterBank = SerializableDescriptor( 'FilterBank', FilterBankType, _required, strict=DEFAULT_STRICT, docstring='The filter bank.') # type: FilterBankType Operation = StringEnumDescriptor( 'Operation', ('CONVOLUTION', 'CORRELATION'), _required, strict=DEFAULT_STRICT, docstring='') # type: str def __init__(self, FilterName=None, FilterKernel=None, FilterBank=None, Operation=None, **kwargs): """ Parameters ---------- FilterName : str FilterKernel : None|FilterKernelType FilterBank : None|FilterBankType Operation : 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.FilterName = FilterName self.FilterKernel = FilterKernel self.FilterBank = FilterBank self.Operation = Operation super(FilterType, self).__init__(**kwargs)
class ColorManagementModuleType(Serializable): """ Parameters describing the Color Management Module (CMM). """ _fields = ('RenderingIntent', 'SourceProfile', 'DisplayProfile', 'ICCProfile') _required = ('RenderingIntent', 'SourceProfile') # Descriptor RenderingIntent = StringEnumDescriptor( 'RenderingIntent', ('PERCEPTUAL', 'SATURATION', 'RELATIVE', 'ABSOLUTE'), _required, strict=DEFAULT_STRICT, default_value='PERCEPTUAL', docstring='The rendering intent for this color management.') # type: str SourceProfile = StringDescriptor( 'SourceProfile', _required, strict=DEFAULT_STRICT, docstring='Name of sensor profile in ICC Profile database.') # type: str DisplayProfile = StringDescriptor( 'DisplayProfile', _required, strict=DEFAULT_STRICT, docstring='Name of display profile in ICC Profile database.') # type: str ICCProfile = StringDescriptor( 'ICCProfile', _required, strict=DEFAULT_STRICT, docstring='Valid ICC profile signature.') # type: str def __init__(self, RenderingIntent='PERCEPTUAL', SourceProfile=None, DisplayProfile=None, ICCProfile=None, **kwargs): """ Parameters ---------- RenderingIntent : str SourceProfile : str DisplayProfile : str ICCProfile : 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.RenderingIntent = RenderingIntent self.SourceProfile = SourceProfile self.DisplayProfile = DisplayProfile self.ICCProfile = ICCProfile super(ColorManagementModuleType, self).__init__(**kwargs)
class TropoParametersType(Serializable): """ Parameters used to compute the propagation delay due to the troposphere. """ _fields = ('N0', 'RefHeight') _required = _fields _numeric_format = {'N0': FLOAT_FORMAT} # descriptors N0 = FloatDescriptor( 'N0', _required, strict=DEFAULT_STRICT, bounds=(0, None), docstring= 'Refractivity value of the troposphere for the imaged scene used ' 'to form the product (dimensionless). Value at the IARP ' 'location.') # type: float RefHeight = StringEnumDescriptor( 'RefHeight', ('IARP', 'ZERO'), _required, strict=DEFAULT_STRICT, docstring='Reference Height for the `N0` value.') # type: str def __init__(self, N0=None, RefHeight=None, **kwargs): """ Parameters ---------- N0 : float RefHeight : 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.N0 = N0 self.RefHeight = RefHeight super(TropoParametersType, self).__init__(**kwargs)
class DynamicRangeAdjustmentType(Serializable): """ The dynamic range adjustment (DRA) parameters. """ _fields = ('AlgorithmType', 'BandStatsSource', 'DRAParameters', 'DRAOverrides') _required = ('AlgorithmType', 'BandStatsSource', ) # Descriptor AlgorithmType = StringEnumDescriptor( 'AlgorithmType', ('AUTO', 'MANUAL', 'NONE'), _required, strict=DEFAULT_STRICT, default_value='NONE', docstring='Algorithm used for dynamic range adjustment.') # type: str BandStatsSource = IntegerDescriptor( 'BandStatsSource', _required, strict=DEFAULT_STRICT, docstring='') # type: int DRAParameters = SerializableDescriptor( 'DRAParameters', DRAParametersType, _required, strict=DEFAULT_STRICT, docstring='The dynamic range adjustment parameters.') # type: DRAParametersType DRAOverrides = SerializableDescriptor( 'DRAOverrides', DRAOverridesType, _required, strict=DEFAULT_STRICT, docstring='The dynamic range adjustment overrides.') # type: DRAOverridesType def __init__(self, AlgorithmType='NONE', BandStatsSource=None, DRAParameters=None, DRAOverrides=None, **kwargs): """ Parameters ---------- AlgorithmType : str BandStatsSource : int DRAParameters : DRAParametersType DRAOverrides : DRAOverridesType 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.AlgorithmType = AlgorithmType self.BandStatsSource = BandStatsSource self.DRAParameters = DRAParameters self.DRAOverrides = DRAOverrides super(DynamicRangeAdjustmentType, self).__init__(**kwargs)
class OrientationType(Serializable): """ Parameters describing the default orientation of the product. """ _fields = ('ShadowDirection', ) _required = _fields # Descriptor ShadowDirection = StringEnumDescriptor( 'ShadowDirection', ('UP', 'DOWN', 'LEFT', 'RIGHT', 'ARBITRARY'), _required, strict=DEFAULT_STRICT, default_value='DOWN', docstring='Describes the shadow direction relative to the ' 'pixels in the file.') # type: str def __init__(self, ShadowDirection='DOWN', **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.ShadowDirection = ShadowDirection super(OrientationType, self).__init__(**kwargs)
class ProductDisplayType(Serializable): """ """ _fields = ('PixelType', 'RemapInformation', 'MagnificationMethod', 'DecimationMethod', 'DRAHistogramOverrides', 'MonitorCompensationApplied', 'DisplayExtensions') _required = ('PixelType', ) _collections_tags = { 'DisplayExtensions': { 'array': False, 'child_tag': 'DisplayExtension' } } # Descriptors PixelType = StringEnumDescriptor( 'PixelType', ('MONO8I', 'MONO8LU', 'MONO16I', 'RGB8LU', 'RGB24I'), _required, strict=DEFAULT_STRICT, docstring='Enumeration of the pixel type. Definition in ' 'Design and Exploitation document.') # type: str RemapInformation = SerializableDescriptor( 'RemapInformation', RemapChoiceType, _required, strict=DEFAULT_STRICT, docstring='Information regarding the encoding of the pixel data. ' 'Used for 8-bit pixel types.') # type: Union[None, RemapChoiceType] MagnificationMethod = StringEnumDescriptor( 'MagnificationMethod', ('NEAREST_NEIGHBOR', 'BILINEAR', 'LAGRANGE'), _required, strict=DEFAULT_STRICT, docstring='Recommended ELT magnification method for this data.' ) # type: Union[None, str] DecimationMethod = StringEnumDescriptor( 'DecimationMethod', ('NEAREST_NEIGHBOR', 'BILINEAR', 'BRIGHTEST_PIXEL', 'LAGRANGE'), _required, strict=DEFAULT_STRICT, docstring= 'Recommended ELT decimation method for this data. Also used as default for ' 'reduced resolution dataset generation (if applicable).' ) # type: Union[None, str] DRAHistogramOverrides = SerializableDescriptor( 'DRAHistogramOverrides', DRAHistogramOverridesType, _required, strict=DEFAULT_STRICT, docstring='Recommended ELT DRA overrides.' ) # type: Union[None, DRAHistogramOverridesType] MonitorCompensationApplied = SerializableDescriptor( 'MonitorCompensationApplied', MonitorCompensationAppliedType, _required, strict=DEFAULT_STRICT, docstring= 'Describes monitor compensation that may have been applied to the product ' 'during processing.' ) # type: Union[None, MonitorCompensationAppliedType] DisplayExtensions = ParametersDescriptor( 'DisplayExtensions', _collections_tags, _required, strict=DEFAULT_STRICT, docstring= 'Optional extensible parameters used to support profile-specific needs related to ' 'product display. Predefined filter types.' ) # type: Union[None, ParametersCollection] def __init__(self, PixelType=None, RemapInformation=None, MagnificationMethod=None, DecimationMethod=None, DRAHistogramOverrides=None, MonitorCompensationApplied=None, DisplayExtensions=None, **kwargs): """ Parameters ---------- PixelType : PixelTypeType RemapInformation : None|RemapChoiceType MagnificationMethod : None|str DecimationMethod : None|str DRAHistogramOverrides : None|DRAHistogramOverridesType MonitorCompensationApplied : None|MonitorCompensationAppliedType DisplayExtensions : None|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.PixelType = PixelType self.RemapInformation = RemapInformation self.MagnificationMethod = MagnificationMethod self.DecimationMethod = DecimationMethod self.DRAHistogramOverrides = DRAHistogramOverrides self.MonitorCompensationApplied = MonitorCompensationApplied self.DisplayExtensions = DisplayExtensions super(ProductDisplayType, self).__init__(**kwargs)
class CollectionInfoType(Serializable): """General information about the collection.""" _collections_tags = { 'Parameters': {'array': False, 'child_tag': 'Parameter'}, 'CountryCodes': {'array': False, 'child_tag': 'CountryCode'}, } _fields = ( 'CollectorName', 'IlluminatorName', 'CoreName', 'CollectType', 'RadarMode', 'Classification', 'CountryCodes', 'Parameters') _required = ('CollectorName', 'CoreName', 'RadarMode', 'Classification') # other class variable _COLLECT_TYPE_VALUES = ('MONOSTATIC', 'BISTATIC') # descriptors CollectorName = StringDescriptor( 'CollectorName', _required, strict=DEFAULT_STRICT, docstring='Radar platform identifier. For Bistatic collections, list the Receive platform.') # type: str IlluminatorName = StringDescriptor( 'IlluminatorName', _required, strict=DEFAULT_STRICT, docstring='Radar platform identifier that provided the illumination. For Bistatic collections, ' 'list the transmit platform.') # type: str CoreName = StringDescriptor( 'CoreName', _required, strict=DEFAULT_STRICT, docstring='Collection and imaging data set identifier. Uniquely identifies imaging collections per ' 'Program Specific Implementation Doc.') # type: str CollectType = StringEnumDescriptor( 'CollectType', _COLLECT_TYPE_VALUES, _required, docstring="Collection type identifier. Monostatic collections include single platform collections with " "unique transmit and receive apertures.") # type: str RadarMode = SerializableDescriptor( 'RadarMode', RadarModeType, _required, strict=DEFAULT_STRICT, docstring='The radar mode.') # type: RadarModeType Classification = StringDescriptor( 'Classification', _required, strict=DEFAULT_STRICT, default_value='UNCLASSIFIED', docstring='Contains the human-readable banner. Contains classification, file control and handling, ' 'file releasing, and/or proprietary markings. Specified per Program Specific ' 'Implementation Document.') # type: str CountryCodes = StringListDescriptor( 'CountryCodes', _required, strict=DEFAULT_STRICT, docstring="List of country codes for region covered by the image.") # type: List[str] Parameters = ParametersDescriptor( 'Parameters', _collections_tags, _required, strict=DEFAULT_STRICT, docstring='Free form parameters object collection.') # type: ParametersCollection def __init__(self, CollectorName=None, IlluminatorName=None, CoreName=None, CollectType=None, RadarMode=None, Classification="UNCLASSIFIED", CountryCodes=None, Parameters=None, **kwargs): """ Parameters ---------- CollectorName : str IlluminatorName : str CoreName : str CollectType : str RadarMode : RadarModeType Classification : str CountryCodes : list|str Parameters : ParametersCollection|dict 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.CollectorName, self.IlluminatorName = CollectorName, IlluminatorName self.CoreName, self.CollectType = CoreName, CollectType self.RadarMode = RadarMode self.Classification = Classification self.CountryCodes, self.Parameters = CountryCodes, Parameters super(CollectionInfoType, self).__init__(**kwargs)
class PosVelErrType(Serializable): """ Position and velocity error statistics for the radar platform. """ _fields = ('Frame', 'P1', 'P2', 'P3', 'V1', 'V2', 'V3', 'CorrCoefs', 'PositionDecorr') _required = ('Frame', 'P1', 'P2', 'P3', 'V1', 'V2', 'V3') _numeric_format = {'P1': '0.16G', 'P2': '0.16G', 'P3': '0.16G', 'V1': '0.16G', 'V2': '0.16G', 'V3': '0.16G'} # class variables _FRAME_VALUES = ('ECF', 'RIC_ECF', 'RIC_ECI') # descriptors Frame = StringEnumDescriptor( 'Frame', _FRAME_VALUES, _required, strict=True, docstring='Coordinate frame used for expressing P,V errors statistics. Note: ' '*RIC = Radial, In-Track, Cross-Track*, where radial is defined to be from earth center through ' 'the platform position.') # type: str P1 = FloatDescriptor( 'P1', _required, strict=DEFAULT_STRICT, docstring='Position coordinate 1 standard deviation.') # type: float P2 = FloatDescriptor( 'P2', _required, strict=DEFAULT_STRICT, docstring='Position coordinate 2 standard deviation.') # type: float P3 = FloatDescriptor( 'P3', _required, strict=DEFAULT_STRICT, docstring='Position coordinate 3 standard deviation.') # type: float V1 = FloatDescriptor( 'V1', _required, strict=DEFAULT_STRICT, docstring='Velocity coordinate 1 standard deviation.') # type: float V2 = FloatDescriptor( 'V2', _required, strict=DEFAULT_STRICT, docstring='Velocity coordinate 2 standard deviation.') # type: float V3 = FloatDescriptor( 'V3', _required, strict=DEFAULT_STRICT, docstring='Velocity coordinate 3 standard deviation.') # type: float CorrCoefs = SerializableDescriptor( 'CorrCoefs', CorrCoefsType, _required, strict=DEFAULT_STRICT, docstring='Correlation Coefficient parameters.') # type: CorrCoefsType PositionDecorr = SerializableDescriptor( 'PositionDecorr', ErrorDecorrFuncType, _required, strict=DEFAULT_STRICT, docstring='Platform position error decorrelation function.') # type: ErrorDecorrFuncType def __init__(self, Frame=None, P1=None, P2=None, P3=None, V1=None, V2=None, V3=None, CorrCoefs=None, PositionDecorr=None, **kwargs): """ Parameters ---------- Frame : str P1 : float P2 : float P3 : float V1 : float V2 : float V3 : float CorrCoefs : CorrCoefsType PositionDecorr : ErrorDecorrFuncType 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.Frame = Frame self.P1, self.P2, self.P3 = P1, P2, P3 self.V1, self.V2, self.V3 = V1, V2, V3 self.CorrCoefs, self.PositionDecorr = CorrCoefs, PositionDecorr super(PosVelErrType, self).__init__(**kwargs)
class TxRcvPolarizationType(Serializable): """ The transmit/receive polarization information. """ _fields = ('TxPolarization', 'RcvPolarization', 'RcvPolarizationOffset') _required = ('TxPolarization', 'RcvPolarization') _numeric_format = {'RcvPolarizationOffset': FLOAT_FORMAT} # 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: float def __init__(self, TxPolarization=None, RcvPolarization=None, RcvPolarizationOffset=None, **kwargs): """ Parameters ---------- TxPolarization : str RcvPolarization : str RcvPolarizationOffset : None|float 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 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)
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 ImageDataType(Serializable): """The image pixel data.""" _collections_tags = { 'AmpTable': { 'array': True, 'child_tag': 'Amplitude' }, 'ValidData': { 'array': True, 'child_tag': 'Vertex' }, } _fields = ('PixelType', 'AmpTable', 'NumRows', 'NumCols', 'FirstRow', 'FirstCol', 'FullImage', 'SCPPixel', 'ValidData') _required = ('PixelType', 'NumRows', 'NumCols', 'FirstRow', 'FirstCol', 'FullImage', 'SCPPixel') _numeric_format = {'AmpTable': FLOAT_FORMAT} _PIXEL_TYPE_VALUES = ("RE32F_IM32F", "RE16I_IM16I", "AMP8I_PHS8I") # descriptors PixelType = StringEnumDescriptor( 'PixelType', _PIXEL_TYPE_VALUES, _required, strict=True, docstring= "The PixelType attribute which specifies the interpretation of the file data." ) # type: str AmpTable = FloatArrayDescriptor( 'AmpTable', _collections_tags, _required, strict=DEFAULT_STRICT, minimum_length=256, maximum_length=256, docstring="The amplitude look-up table. This is required if " "`PixelType == 'AMP8I_PHS8I'`") # type: numpy.ndarray NumRows = IntegerDescriptor( 'NumRows', _required, strict=True, docstring='The number of Rows in the product. May include zero rows.' ) # type: int NumCols = IntegerDescriptor( 'NumCols', _required, strict=True, docstring='The number of Columns in the product. May include zero rows.' ) # type: int FirstRow = IntegerDescriptor( 'FirstRow', _required, strict=DEFAULT_STRICT, docstring='Global row index of the first row in the product. ' 'Equal to 0 in full image product.') # type: int FirstCol = IntegerDescriptor( 'FirstCol', _required, strict=DEFAULT_STRICT, docstring='Global column index of the first column in the product. ' 'Equal to 0 in full image product.') # type: int FullImage = SerializableDescriptor( 'FullImage', FullImageType, _required, strict=DEFAULT_STRICT, docstring='Original full image product.') # type: FullImageType SCPPixel = SerializableDescriptor( 'SCPPixel', RowColType, _required, strict=DEFAULT_STRICT, docstring= 'Scene Center Point pixel global row and column index. Should be located near the ' 'center of the full image.') # type: RowColType ValidData = SerializableArrayDescriptor( 'ValidData', RowColArrayElement, _collections_tags, _required, strict=DEFAULT_STRICT, minimum_length=3, docstring= 'Indicates the full image includes both valid data and some zero filled pixels. ' 'Simple polygon encloses the valid data (may include some zero filled pixels for simplification). ' 'Vertices in clockwise order.' ) # type: Union[SerializableArray, List[RowColArrayElement]] def __init__(self, PixelType=None, AmpTable=None, NumRows=None, NumCols=None, FirstRow=None, FirstCol=None, FullImage=None, SCPPixel=None, ValidData=None, **kwargs): """ Parameters ---------- PixelType : str AmpTable : numpy.ndarray|list|tuple NumRows : int NumCols : int FirstRow : int FirstCol : int FullImage : FullImageType|numpy.ndarray|list|tuple SCPPixel : RowColType|numpy.ndarray|list|tuple ValidData : SerializableArray|List[RowColArrayElement]|numpy.ndarray|list|tuple 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.PixelType = PixelType self.AmpTable = AmpTable self.NumRows, self.NumCols = NumRows, NumCols self.FirstRow, self.FirstCol = FirstRow, FirstCol self.FullImage = FullImage self.SCPPixel = SCPPixel self.ValidData = ValidData super(ImageDataType, self).__init__(**kwargs) def _check_valid_data(self): if self.ValidData is None: return True if len(self.ValidData) < 2: return True value = True valid_data = self.ValidData.get_array(dtype='float64') lin_ring = LinearRing(coordinates=valid_data) area = lin_ring.get_area() if area == 0: self.log_validity_error('ValidData encloses no area.') value = False elif area > 0: self.log_validity_error( "ValidData must be traversed in clockwise direction.") value = False for i, entry in enumerate(valid_data): if not ( (self.FirstRow <= entry[0] <= self.FirstRow + self.NumRows) and (self.FirstCol <= entry[1] <= self.FirstCol + self.NumCols)): self.log_validity_warning( 'ValidData entry {} is not contained in the image bounds'. format(i)) value = False return value def _basic_validity_check(self): condition = super(ImageDataType, self)._basic_validity_check() if (self.PixelType == 'AMP8I_PHS8I') and (self.AmpTable is None): self.log_validity_error( "We have `PixelType='AMP8I_PHS8I'` and `AmpTable` is not defined for ImageDataType." ) condition = False if (self.PixelType != 'AMP8I_PHS8I') and (self.AmpTable is not None): self.log_validity_error( "We have `PixelType != 'AMP8I_PHS8I'` and `AmpTable` is defined for ImageDataType." ) condition = False if (self.ValidData is not None) and (len(self.ValidData) < 3): self.log_validity_error( "We have `ValidData` defined with fewer than 3 entries.") condition = False condition &= self._check_valid_data() return condition def get_valid_vertex_data(self, dtype=numpy.int64): """ Gets an array of `[row, col]` indices defining the valid data. If this is not viable, then `None` will be returned. Parameters ---------- dtype : object the data type for the array Returns ------- numpy.ndarray|None """ if self.ValidData is None: return None out = numpy.zeros((self.ValidData.size, 2), dtype=dtype) for i, entry in enumerate(self.ValidData): out[i, :] = entry.get_array(dtype=dtype) return out def get_full_vertex_data(self, dtype=numpy.int64): """ Gets an array of `[row, col]` indices defining the full vertex data. If this is not viable, then `None` will be returned. Parameters ---------- dtype : object the data type for the array Returns ------- numpy.ndarray|None """ if self.NumRows is None or self.NumCols is None: return None return numpy.array( [[0, 0], [0, self.NumCols - 1], [self.NumRows - 1, self.NumCols - 1], [self.NumRows - 1, 0]], dtype=dtype) def get_pixel_size(self) -> int: """ Gets the size per pixel, in bytes. Returns ------- int """ if self.PixelType == "RE32F_IM32F": return 8 elif self.PixelType == "RE16I_IM16I": return 4 elif self.PixelType == "AMP8I_PHS8I": return 2 else: raise ValueError('Got unhandled pixel type `{}`'.format( self.PixelType))
class ProductDisplayType(Serializable): """ """ _fields = ('PixelType', 'NumBands', 'DefaultBandDisplay', 'NonInteractiveProcessing', 'InteractiveProcessing', 'DisplayExtensions') _required = ('PixelType', 'NumBands', 'NonInteractiveProcessing', 'InteractiveProcessing') _collections_tags = { 'NonInteractiveProcessing': { 'array': False, 'child_tag': 'NonInteractiveProcessing' }, 'InteractiveProcessing': { 'array': False, 'child_tag': 'InteractiveProcessing' }, 'DisplayExtensions': { 'array': False, 'child_tag': 'DisplayExtension' } } # Descriptors PixelType = StringEnumDescriptor( 'PixelType', ('MONO8I', 'MONO8LU', 'MONO16I', 'RGB8LU', 'RGB24I'), _required, strict=DEFAULT_STRICT, docstring='Enumeration of the pixel type. Definition in ' 'Design and Exploitation document.') # type: str NumBands = IntegerDescriptor( 'NumBands', _required, strict=DEFAULT_STRICT, docstring= 'Number of bands contained in the image. Populate with the number of bands ' 'present after remapping. For example an 8-bit RGB image (RGBLU), this will ' 'be 3.') # type: int DefaultBandDisplay = IntegerDescriptor( 'DefaultBandDisplay', _required, strict=DEFAULT_STRICT, docstring='Indicates which band to display by default. ' 'Valid range = 1 to NumBands.') # type: int NonInteractiveProcessing = SerializableListDescriptor( 'NonInteractiveProcessing', NonInteractiveProcessingType, _collections_tags, _required, strict=DEFAULT_STRICT, docstring='Non-interactive processing details.' ) # type: List[NonInteractiveProcessingType] InteractiveProcessing = SerializableListDescriptor( 'InteractiveProcessing', InteractiveProcessingType, _collections_tags, _required, strict=DEFAULT_STRICT, docstring='Interactive processing details.' ) # type: List[InteractiveProcessingType] DisplayExtensions = ParametersDescriptor( 'DisplayExtensions', _collections_tags, _required, strict=DEFAULT_STRICT, docstring= 'Optional extensible parameters used to support profile-specific needs related to ' 'product display. Predefined filter types.' ) # type: ParametersCollection def __init__(self, PixelType=None, NumBands=1, DefaultBandDisplay=None, NonInteractiveProcessing=None, InteractiveProcessing=None, DisplayExtensions=None, **kwargs): """ Parameters ---------- PixelType : PixelTypeType NumBands : int DefaultBandDisplay : int|None NonInteractiveProcessing : List[NonInteractiveProcessingType] InteractiveProcessing : List[InteractiveProcessingType] DisplayExtensions : 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.PixelType = PixelType self.NumBands = NumBands self.DefaultBandDisplay = DefaultBandDisplay self.NonInteractiveProcessing = NonInteractiveProcessing self.InteractiveProcessing = InteractiveProcessing self.DisplayExtensions = DisplayExtensions super(ProductDisplayType, self).__init__(**kwargs) def get_pixel_size(self) -> int: """ Gets the raw size per pixel, in bytes. Returns ------- int """ if self.PixelType == 'MONO8I': return 1 elif self.PixelType == 'MONO8LU': return 1 elif self.PixelType == 'MONO16I': return 2 elif self.PixelType == 'RGB8LU': return 1 elif self.PixelType == 'RGB24I': return 3 else: raise ValueError('Got unhandled pixel type `{}`'.format( self.PixelType))
class RMAType(Serializable): """Parameters included when the image is formed using the Range Migration Algorithm.""" _fields = ('RMAlgoType', 'ImageType', 'RMAT', 'RMCR', 'INCA') _required = ('RMAlgoType', 'ImageType') _choice = ({'required': True, 'collection': ('RMAT', 'RMCR', 'INCA')}, ) # class variables _RM_ALGO_TYPE_VALUES = ('OMEGA_K', 'CSA', 'RG_DOP') # descriptors RMAlgoType = StringEnumDescriptor('RMAlgoType', _RM_ALGO_TYPE_VALUES, _required, strict=DEFAULT_STRICT, docstring=r""" Identifies the type of migration algorithm used: * `OMEGA_K` - Algorithms that employ Stolt interpolation of the Kxt dimension. :math:`Kx = \sqrt{Kf^2 - Ky^2}` * `CSA` - Wave number algorithm that process two-dimensional chirp signals. * `RG_DOP` - Range-Doppler algorithms that employ *RCMC* in the compressed range domain. """) # type: str RMAT = SerializableDescriptor( 'RMAT', RMRefType, _required, strict=DEFAULT_STRICT, docstring= 'Parameters for *RMA with Along Track (RMAT)* motion compensation.' ) # type: RMRefType RMCR = SerializableDescriptor( 'RMCR', RMRefType, _required, strict=DEFAULT_STRICT, docstring= 'Parameters for *RMA with Cross Range (RMCR)* motion compensation.' ) # type: RMRefType INCA = SerializableDescriptor( 'INCA', INCAType, _required, strict=DEFAULT_STRICT, docstring= 'Parameters for *Imaging Near Closest Approach (INCA)* image description.' ) # type: INCAType def __init__(self, RMAlgoType=None, RMAT=None, RMCR=None, INCA=None, **kwargs): """ Parameters ---------- RMAlgoType : str RMAT : RMRefType RMCR : RMRefType INCA : INCAType 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.RMAlgoType = RMAlgoType self.RMAT = RMAT self.RMCR = RMCR self.INCA = INCA super(RMAType, self).__init__(**kwargs) @property def ImageType(self): # type: () -> Union[None, str] """ str: READ ONLY attribute. Identifies the specific RM image type / metadata type supplied. This is determined by returning the (first) attribute among `'RMAT', 'RMCR', 'INCA'` which is populated. `None` will be returned if none of them are populated. """ for attribute in self._choice[0]['collection']: if getattr(self, attribute) is not None: return attribute return None def _derive_parameters(self, SCPCOA, Position, RadarCollection, ImageFormation): """ Expected to be called from SICD parent. Parameters ---------- SCPCOA : sarpy.io.complex.sicd_elements.SCPCOA.SCPCOAType Position : sarpy.io.complex.sicd_elements.Position.PositionType RadarCollection : sarpy.io.complex.sicd_elements.RadarCollection.RadarCollectionType ImageFormation : sarpy.io.complex.sicd_elements.ImageFormation.ImageFormationType Returns ------- None """ if SCPCOA is None: return scp = None if SCPCOA.ARPPos is None else SCPCOA.ARPPos.get_array() im_type = self.ImageType if im_type in ['RMAT', 'RMCR']: rm_ref = getattr(self, im_type) # type: RMRefType if rm_ref.PosRef is None and SCPCOA.ARPPos is not None: rm_ref.PosRef = SCPCOA.ARPPos.copy() if rm_ref.VelRef is None and SCPCOA.ARPVel is not None: rm_ref.VelRef = SCPCOA.ARPVel.copy() if scp is not None and rm_ref.PosRef is not None and rm_ref.VelRef is not None: pos_ref = rm_ref.PosRef.get_array() vel_ref = rm_ref.VelRef.get_array() uvel_ref = vel_ref / norm(vel_ref) ulos = (scp - pos_ref ) # it absolutely could be that scp = pos_ref ulos_norm = norm(ulos) if ulos_norm > 0: ulos /= ulos_norm if rm_ref.DopConeAngRef is None: rm_ref.DopConeAngRef = numpy.rad2deg( numpy.arccos(numpy.dot(uvel_ref, ulos))) elif im_type == 'INCA': if scp is not None and self.INCA.TimeCAPoly is not None and \ Position is not None and Position.ARPPoly is not None: t_zero = self.INCA.TimeCAPoly.Coefs[0] ca_pos = Position.ARPPoly(t_zero) if self.INCA.R_CA_SCP is None: self.INCA.R_CA_SCP = norm(ca_pos - scp) if self.INCA.FreqZero is None: self.INCA.FreqZero = _get_center_frequency( RadarCollection, ImageFormation) def _apply_reference_frequency(self, reference_frequency): """ If the reference frequency is used, adjust the necessary fields accordingly. Expected to be called by SICD parent. Parameters ---------- reference_frequency : float The reference frequency. Returns ------- None """ if self.INCA is not None: # noinspection PyProtectedMember self.INCA._apply_reference_frequency(reference_frequency)
class MeasurementType(Serializable): """ Geometric SAR information required for measurement/geolocation. """ _fields = ('PolynomialProjection', 'GeographicProjection', 'PlaneProjection', 'CylindricalProjection', 'PixelFootprint', 'ARPFlag', 'ARPPoly', 'ValidData') _required = ('PixelFootprint', 'ARPPoly', 'ValidData') _collections_tags = {'ValidData': {'array': True, 'child_tag': 'Vertex'}} _numeric_format = {'ValidData': '0.16G'} _choice = ({ 'required': False, 'collection': ('PolynomialProjection', 'GeographicProjection', 'PlaneProjection', 'CylindricalProjection') }, ) # Descriptor PolynomialProjection = SerializableDescriptor( 'PolynomialProjection', PolynomialProjectionType, _required, strict=DEFAULT_STRICT, docstring= 'Polynomial pixel to ground. Should only used for sensor systems where the radar ' 'geometry parameters are not recorded.' ) # type: Union[None, PolynomialProjectionType] GeographicProjection = SerializableDescriptor( 'GeographicProjection', GeographicProjectionType, _required, strict=DEFAULT_STRICT, docstring= 'Geographic mapping of the pixel grid referred to as GGD in the ' 'Design and Exploitation document.' ) # type: Union[None, GeographicProjectionType] PlaneProjection = SerializableDescriptor( 'PlaneProjection', PlaneProjectionType, _required, strict=DEFAULT_STRICT, docstring= 'Planar representation of the pixel grid referred to as PGD in the ' 'Design and Exploitation document.' ) # type: Union[None, PlaneProjectionType] CylindricalProjection = SerializableDescriptor( 'CylindricalProjection', CylindricalProjectionType, _required, strict=DEFAULT_STRICT, docstring= 'Cylindrical mapping of the pixel grid referred to as CGD in the ' 'Design and Exploitation document.' ) # type: Union[None, CylindricalProjectionType] PixelFootprint = SerializableDescriptor( 'PixelFootprint', RowColIntType, _required, strict=DEFAULT_STRICT, docstring='Size of the image in pixels.') # type: RowColIntType ARPFlag = StringEnumDescriptor( 'ARPFlag', ('REALTIME', 'PREDICTED', 'POST PROCESSED'), _required, strict=DEFAULT_STRICT, docstring= 'Flag indicating whether ARP polynomial is based on the best available (`collect time` or ' '`predicted`) ephemeris.') # type: Union[None, str] ARPPoly = SerializableDescriptor('ARPPoly', XYZPolyType, _required, strict=DEFAULT_STRICT, docstring='') # type: XYZPolyType ValidData = SerializableArrayDescriptor( 'ValidData', RowColArrayElement, _collections_tags, _required, strict=DEFAULT_STRICT, minimum_length=3, docstring= 'Indicates the full image includes both valid data and some zero filled pixels. ' 'Simple polygon encloses the valid data (may include some zero filled pixels for simplification). ' 'Vertices in clockwise order.' ) # type: Union[SerializableArray, List[RowColArrayElement]] def __init__(self, PolynomialProjection=None, GeographicProjection=None, PlaneProjection=None, CylindricalProjection=None, PixelFootprint=None, ARPFlag=None, ARPPoly=None, ValidData=None, **kwargs): """ Parameters ---------- PolynomialProjection : PolynomialProjectionType GeographicProjection : GeographicProjectionType PlaneProjection : PlaneProjectionType CylindricalProjection : CylindricalProjectionType PixelFootprint : RowColIntType|numpy.ndarray|list|tuple ARPFlag : str ARPPoly : XYZPolyType|numpy.ndarray|list|tuple ValidData : SerializableArray|List[RowColArrayElement]|numpy.ndarray|list|tuple 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.PolynomialProjection = PolynomialProjection self.GeographicProjection = GeographicProjection self.PlaneProjection = PlaneProjection self.CylindricalProjection = CylindricalProjection self.PixelFootprint = PixelFootprint self.ARPFlag = ARPFlag self.ARPPoly = ARPPoly self.ValidData = ValidData super(MeasurementType, self).__init__(**kwargs) @property def ProjectionType(self): """str: *READ ONLY* Identifies the specific image projection type supplied.""" for attribute in self._choice[0]['collection']: if getattr(self, attribute) is not None: return attribute return None
class GlobalType(Serializable): """ The Global type definition. """ _fields = ('DomainType', 'SGN', 'Timeline', 'FxBand', 'TOASwath', 'TropoParameters', 'IonoParameters') _required = ('DomainType', 'SGN', 'Timeline', 'FxBand', 'TOASwath') # descriptors DomainType = StringEnumDescriptor( 'DomainType', ('FX', 'TOA'), _required, strict=DEFAULT_STRICT, docstring= 'Indicates the domain represented by the sample dimension of the ' 'CPHD signal array(s), where "FX" denotes Transmit Frequency, and ' '"TOA" denotes Difference in Time of Arrival') # type: str SGN = IntegerEnumDescriptor( 'SGN', (-1, 1), _required, strict=DEFAULT_STRICT, docstring= 'Phase SGN applied to compute target signal phase as a function of ' r'target :math:`\Delta TOA^{TGT}`. Target phase in cycles. ' r'For simple phase model :math:`Phase(fx) = SGN \times fx \times \Delta TOA^{TGT}` ' r'In TOA domain, phase of the mainlobe peak ' r':math:`Phase(\Delta TOA^{TGT}) = SGN \times fx_C \times \Delta TOA^{TGT}`' '.') # type: int Timeline = SerializableDescriptor( 'Timeline', TimelineType, _required, strict=DEFAULT_STRICT, docstring= 'Parameters that describe the collection times for the data contained ' 'in the product') # type: TimelineType FxBand = SerializableDescriptor( 'FxBand', FxBandType, _required, strict=DEFAULT_STRICT, docstring= 'Parameters that describe the FX frequency limits for the signal array(s) ' 'contained in the product.') # type: FxBandType TOASwath = SerializableDescriptor( 'TOASwath', TOASwathType, _required, strict=DEFAULT_STRICT, docstring= 'Parameters that describe the time-of-arrival (TOA) swath limits for the ' 'signal array(s) contained in the product.') # type: TOASwathType TropoParameters = SerializableDescriptor( 'TropoParameters', TropoParametersType, _required, strict=DEFAULT_STRICT, docstring='Parameters used to compute the propagation delay due to the ' 'troposphere.') # type: Union[None, TropoParametersType] IonoParameters = SerializableDescriptor( 'IonoParameters', IonoParametersType, _required, strict=DEFAULT_STRICT, docstring='Parameters used to compute propagation effects due to the ' 'ionosphere.') # type: Union[None, IonoParametersType] def __init__(self, DomainType=None, SGN=None, Timeline=None, FxBand=None, TOASwath=None, TropoParameters=None, IonoParameters=None, **kwargs): """ Parameters ---------- DomainType : str SGN : int Timeline : TimelineType FxBand : FxBandType|numpy.ndarray|list|tuple TOASwath : TOASwathType|numpy.ndarray|list|tuple TropoParameters : None|TropoParametersType IonoParameters : None|IonoParametersType 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.DomainType = DomainType self.SGN = SGN self.Timeline = Timeline self.FxBand = FxBand self.TOASwath = TOASwath self.TropoParameters = TropoParameters self.IonoParameters = IonoParameters super(GlobalType, self).__init__(**kwargs)
class ReferenceGeometryCore(Serializable): """ The base reference geometry implementation. """ _fields = ('SideOfTrack', 'SlantRange', 'GroundRange', 'DopplerConeAngle', 'GrazeAngle', 'IncidenceAngle', 'AzimuthAngle') _required = _fields _numeric_format = { 'SlantRange': '0.16G', 'GroundRange': '0.16G', 'DopplerConeAngle': '0.16G', 'GrazeAngle': '0.16G', 'IncidenceAngle': '0.16G', 'AzimuthAngle': '0.16G' } # descriptors SideOfTrack = StringEnumDescriptor( 'SideOfTrack', ('L', 'R'), _required, strict=DEFAULT_STRICT, docstring='Side of Track parameter for the collection.') # type: str SlantRange = FloatDescriptor( 'SlantRange', _required, strict=DEFAULT_STRICT, bounds=(0, None), docstring='Slant range from the ARP to the SRP.') # type: float GroundRange = FloatDescriptor( 'GroundRange', _required, strict=DEFAULT_STRICT, bounds=(0, None), docstring='Ground range from the ARP to the SRP.') # type: float DopplerConeAngle = FloatDescriptor( 'DopplerConeAngle', _required, strict=DEFAULT_STRICT, bounds=(0, 180), docstring='Doppler Cone Angle between ARP velocity and deg SRP Line of ' 'Sight (LOS).') # type: float GrazeAngle = FloatDescriptor( 'GrazeAngle', _required, strict=DEFAULT_STRICT, bounds=(0, 90), docstring= 'Grazing angle for the ARP to SRP LOS and the deg Earth Tangent ' 'Plane (ETP) at the SRP.') # type: float IncidenceAngle = FloatDescriptor( 'IncidenceAngle', _required, strict=DEFAULT_STRICT, bounds=(0, 90), docstring='Incidence angle for the ARP to SRP LOS and the Earth Tangent ' 'Plane (ETP) at the SRP.') # type: float AzimuthAngle = FloatDescriptor( 'AzimuthAngle', _required, strict=DEFAULT_STRICT, bounds=(0, 360), docstring='Angle from north to the line from the SRP to the ARP ETP ' 'Nadir (i.e. North to +GPX). Measured clockwise from North ' 'toward East.') # type: float def __init__(self, SideOfTrack=None, SlantRange=None, GroundRange=None, DopplerConeAngle=None, GrazeAngle=None, IncidenceAngle=None, AzimuthAngle=None, **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.SideOfTrack = SideOfTrack self.SlantRange = SlantRange self.GroundRange = GroundRange self.DopplerConeAngle = DopplerConeAngle self.GrazeAngle = GrazeAngle self.IncidenceAngle = IncidenceAngle self.AzimuthAngle = AzimuthAngle super(ReferenceGeometryCore, self).__init__(**kwargs) @property def look(self): """ int: An integer version of `SideOfTrack`: * None if `SideOfTrack` is not defined * -1 if SideOfTrack == 'R' * 1 if SideOftrack == 'L' """ if self.SideOfTrack is None: return None return -1 if self.SideOfTrack == 'R' else 1