class GeographicAndTargetType(Serializable): """ Container specifying the image coverage area in geographic coordinates, as well as optional data about the target of the collection/product. """ _fields = ('GeographicCoverage', 'TargetInformations') _required = ('GeographicCoverage', ) _collections_tags = {'TargetInformations': {'array': False, 'child_tag': 'TargetInformation'}} # Descriptors GeographicCoverage = _SerializableDescriptor( 'GeographicCoverage', GeographicCoverageType, _required, strict=DEFAULT_STRICT, docstring='Provides geographic coverage information.') # type: GeographicCoverageType TargetInformations = _SerializableListDescriptor( 'TargetInformations', TargetInformationType, _collections_tags, _required, strict=DEFAULT_STRICT, docstring='Provides target specific geographic ' 'information.') # type: Union[None, List[TargetInformationType]] def __init__(self, GeographicCoverage=None, TargetInformations=None, **kwargs): """ Parameters ---------- GeographicCoverage : GeographicCoverageType TargetInformations : None|List[TargetInformationType] 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.GeographicCoverage = GeographicCoverage self.TargetInformations = TargetInformations super(GeographicAndTargetType, self).__init__(**kwargs)
class ChannelType(Serializable): """ Channel specific parameters for CPHD. """ _fields = ('Parameters', ) _required = ('Parameters', ) _collections_tags = {'Parameters': {'array': False, 'child_tag': 'Parameters'}} # descriptors Parameters = _SerializableListDescriptor( 'Parameters', ParametersType, _collections_tags, _required, strict=DEFAULT_STRICT, docstring='Channel dependent parameter list.') # type: List[ParametersType] def __init__(self, Parameters=None, **kwargs): """ Parameters ---------- Parameters : List[ParametersType] 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.Parameters = Parameters super(ChannelType, self).__init__(**kwargs)
class AnnotationsType(Serializable): """ The list of annotations. """ _fields = ('Annotations', ) _required = ('Annotations', ) _collections_tags = {'Annotations': {'array': False, 'child_tag': 'Annotation'}} # Descriptor Annotations = _SerializableListDescriptor( 'Annotations', AnnotationType, _collections_tags, _required, strict=DEFAULT_STRICT, docstring='') # type: List[AnnotationType] def __init__(self, Annotations=None, **kwargs): """ Parameters ---------- Annotations : List[AnnotationType] 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.Annotations = Annotations super(AnnotationsType, self).__init__(**kwargs) def __len__(self): return len(self.Annotations) def __getitem__(self, item): return self.Annotations[item]
class DataType(Serializable): """ Parameters that describe binary data components contained in the product. """ _fields = ('SampleType', 'NumCPHDChannels', 'NumBytesVBP', 'ArraySize') _required = ('SampleType', 'NumBytesVBP', 'ArraySize') _collections_tags = {'ArraySize': {'array': False, 'child_tag': 'ArraySize'}} # descriptors SampleType = _StringEnumDescriptor( 'SampleType', ("RE32F_IM32F", "RE16I_IM16I", "RE08I_IM08I"), _required, strict=True, docstring="Indicates the PHD sample format of the PHD array(s). All arrays " "have the sample type. Real and imaginary components stored in adjacent " "bytes, real component stored first.") # type: str NumBytesVBP = _IntegerDescriptor( 'NumBytesVBP', _required, strict=DEFAULT_STRICT, bounds=(1, None), docstring='Number of bytes per set of Vector Based Parameters.') # type: int ArraySize = _SerializableListDescriptor( 'ArraySize', ArraySizeType, _collections_tags, _required, strict=DEFAULT_STRICT, docstring='CPHD array size parameters.') # type: List[ArraySizeType] def __init__(self, SampleType=None, NumBytesVBP=None, ArraySize=None, **kwargs): """ Parameters ---------- SampleType : str NumBytesVBP : int ArraySize : List[ArraySizeType] 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.SampleType = SampleType self.NumBytesVBP = NumBytesVBP self.ArraySize = ArraySize super(DataType, self).__init__(**kwargs) @property def NumCPHDChannels(self): """ int: The number of CPHD channels. """ if self.ArraySize is None: return 0 return len(self.ArraySize)
class AnnotationType(Serializable): """ The annotation type. """ _fields = ('Identifier', 'SpatialReferenceSystem', 'Objects') _required = ('Identifier', 'Objects') _collections_tags = {'Objects': {'array': False, 'child_tag': 'Object'}} # Descriptor Identifier = _StringDescriptor('Identifier', _required, strict=DEFAULT_STRICT, docstring='') # type: str SpatialReferenceSystem = _SerializableDescriptor( 'SpatialReferenceSystem', ReferenceSystemType, _required, strict=DEFAULT_STRICT, docstring='') # type: Union[None, ReferenceSystemType] Objects = _SerializableListDescriptor( 'Objects', AnnotationObjectType, _collections_tags, _required, strict=DEFAULT_STRICT, docstring='') # type: List[AnnotationObjectType] def __init__(self, Identifier=None, SpatialReferenceSystem=None, Objects=None, **kwargs): """ Parameters ---------- Identifier : str SpatialReferenceSystem : None|ReferenceSystemType Objects : List[AnnotationObjectType] 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.SpatialReferenceSystem = SpatialReferenceSystem self.Objects = Objects super(AnnotationType, self).__init__(**kwargs)
class DownstreamReprocessingType(Serializable): """ Further processing after initial image creation. """ _fields = ('GeometricChip', 'ProcessingEvents') _required = () _collections_tags = { 'ProcessingEvents': { 'array': False, 'child_tag': 'ProcessingEvent' } } # Descriptor GeometricChip = _SerializableDescriptor( 'GeometricChip', GeometricChipType, _required, strict=DEFAULT_STRICT, docstring='') # type: Union[None, GeometricChipType] ProcessingEvents = _SerializableListDescriptor( 'ProcessingEvents', ProcessingEventType, _collections_tags, _required, strict=DEFAULT_STRICT, docstring='') # type: Union[None, List[ProcessingEventType]] def __init__(self, GeometricChip=None, ProcessingEvents=None, **kwargs): """ Parameters ---------- GeometricChip : None|GeometricChipType ProcessingEvents : None|List[ProcessingEventType] 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.GeometricChip = GeometricChip self.ProcessingEvents = ProcessingEvents super(DownstreamReprocessingType, self).__init__(**kwargs)
class ExploitationFeaturesType(Serializable): """ Computed metadata regarding the collect. """ _fields = ('Collections', 'Products') _required = ('Collections', 'Products') _collections_tags = { 'Collections': { 'array': False, 'child_tag': 'Collection' }, 'Products': { 'array': False, 'child_tag': 'Product' } } # Descriptor Collections = _SerializableListDescriptor( 'Collections', CollectionType, _collections_tags, _required, strict=DEFAULT_STRICT, docstring='') # type: List[CollectionType] Products = _SerializableListDescriptor( 'Products', ExploitationFeaturesProductType, _collections_tags, _required, strict=DEFAULT_STRICT, docstring='') # type: List[ExploitationFeaturesProductType] def __init__(self, Collections=None, Products=None, **kwargs): """ Parameters ---------- Collections : List[CollectionType] Products : List[ExploitationFeaturesProductType] 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.Collections = Collections self.Products = Products super(ExploitationFeaturesType, self).__init__(**kwargs) @classmethod def from_sicd(cls, sicd, row_vector, col_vector): """ Construct from a sicd element. Parameters ---------- sicd : SICDType|List[SICDType] row_vector : numpy.ndarray col_vector : numpy.ndarray Returns ------- ExploitationFeaturesType """ if isinstance(sicd, (list, tuple)): collections = [] feats = [] for i, entry in sicd: calculator = ExploitationCalculator.from_sicd( entry, row_vector, col_vector) collections.append( CollectionType.from_calculator(calculator, entry)) feats.append(ExploitationFeaturesProductType.from_sicd(entry)) return cls(Collections=collections, Products=feats) if not isinstance(sicd, SICDType): raise TypeError('Requires SICDType instance, got type {}'.format( type(sicd))) return cls(Collections=[ CollectionType.from_calculator( ExploitationCalculator.from_sicd(sicd, row_vector, col_vector), sicd), ], Products=[ExploitationFeaturesProductType.from_sicd(sicd)])
class SupportArrayType(Serializable): """ Parameters that describe the binary support array(s) content and grid coordinates. """ _fields = ('IAZArray', 'AntGainPhase', 'AddedSupportArray') _required = () _collections_tags = { 'IAZArray': { 'array': False, 'child_tag': 'IAZArray' }, 'AntGainPhase': { 'array': False, 'child_tag': 'AntGainPhase' }, 'AddedSupportArray': { 'array': False, 'child_tag': 'AddedSupportArray' } } # descriptors IAZArray = _SerializableListDescriptor( 'IAZArray', IAZArrayType, _collections_tags, _required, strict=DEFAULT_STRICT, docstring= 'Arrays of scene surface heights expressed in image coordinate IAZ ' 'values (meters). Grid coordinates are image area coordinates ' '(IAX, IAY).') # type: Union[None, List[IAZArrayType]] AntGainPhase = _SerializableListDescriptor( 'AntGainPhase', AntGainPhaseType, _collections_tags, _required, strict=DEFAULT_STRICT, docstring= 'Antenna arrays with values are antenna gain and phase expressed in dB ' 'and cycles. Array coordinates are direction cosines with respect to ' 'the ACF (DCX, DCY).') # type: Union[None, List[AntGainPhaseType]] AddedSupportArray = _SerializableListDescriptor( 'AddedSupportArray', AddedSupportArrayType, _collections_tags, _required, strict=DEFAULT_STRICT, docstring= 'Additional arrays (two-dimensional), where the content and format and units of each ' 'element are user defined.' ) # type: Union[None, List[AddedSupportArrayType]] def __init__(self, IAZArray=None, AntGainPhase=None, AddedSupportArray=None, **kwargs): """ Parameters ---------- IAZArray : None|List[IAZArrayType] AntGainPhase : None|List[AntGainPhaseType] AddedSupportArray : None|List[AddedSupportArrayType] 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.IAZArray = IAZArray self.AntGainPhase = AntGainPhase self.AddedSupportArray = AddedSupportArray super(SupportArrayType, self).__init__(**kwargs) def find_support_array(self, identifier): """ Find and return the details for support array associated with the given identifier. Parameters ---------- identifier : str Returns ------- IAZArrayType|AntGainPhaseType|AddedSupportArrayType """ if self.IAZArray is not None: for entry in self.IAZArray: if entry.Identifier == identifier: return entry if self.AntGainPhase is not None: for entry in self.AntGainPhase: if entry.Identifier == identifier: return entry if self.AddedSupportArray is not None: for entry in self.AddedSupportArray: if entry.Identifier == identifier: return entry raise KeyError( 'Identifier {} not associated with a support array.'.format( identifier))
class PVPType(Serializable): _fields = ('TxTime', 'TxPos', 'TxVel', 'RcvTime', 'RcvPos', 'RcvVel', 'SRPPos', 'AmpSF', 'aFDOP', 'aFRR1', 'aFRR2', 'FX1', 'FX2', 'FXN1', 'FXN2', 'TOA1', 'TOA2', 'TOAE1', 'TOAE2', 'TDTropoSRP', 'TDIonoSRP', 'SC0', 'SCSS', 'SIGNAL', 'AddedPVP') _required = ('TxTime', 'TxPos', 'TxVel', 'RcvTime', 'RcvPos', 'RcvVel', 'SRPPos', 'aFDOP', 'aFRR1', 'aFRR2', 'FX1', 'FX2', 'TOA1', 'TOA2', 'TDTropoSRP', 'SC0', 'SCSS') _collections_tags = {'AddedPVP': {'array': False, 'child_tag': 'AddedPVP'}} # descriptors TxTime = _SerializableDescriptor( 'TxTime', PerVectorParameterF8, _required, strict=DEFAULT_STRICT, docstring='') # type: PerVectorParameterF8 TxPos = _SerializableDescriptor( 'TxPos', PerVectorParameterXYZ, _required, strict=DEFAULT_STRICT, docstring='') # type: PerVectorParameterXYZ TxVel = _SerializableDescriptor( 'TxVel', PerVectorParameterXYZ, _required, strict=DEFAULT_STRICT, docstring='') # type: PerVectorParameterXYZ RcvTime = _SerializableDescriptor( 'RcvTime', PerVectorParameterF8, _required, strict=DEFAULT_STRICT, docstring='') # type: PerVectorParameterF8 RcvPos = _SerializableDescriptor( 'RcvPos', PerVectorParameterXYZ, _required, strict=DEFAULT_STRICT, docstring='') # type: PerVectorParameterXYZ RcvVel = _SerializableDescriptor( 'RcvVel', PerVectorParameterXYZ, _required, strict=DEFAULT_STRICT, docstring='') # type: PerVectorParameterXYZ SRPPos = _SerializableDescriptor( 'SRPPos', PerVectorParameterXYZ, _required, strict=DEFAULT_STRICT, docstring='') # type: PerVectorParameterXYZ AmpSF = _SerializableDescriptor('AmpSF', PerVectorParameterF8, _required, strict=DEFAULT_STRICT, docstring='') # type: PerVectorParameterF8 aFDOP = _SerializableDescriptor('aFDOP', PerVectorParameterF8, _required, strict=DEFAULT_STRICT, docstring='') # type: PerVectorParameterF8 aFRR1 = _SerializableDescriptor('aFRR1', PerVectorParameterF8, _required, strict=DEFAULT_STRICT, docstring='') # type: PerVectorParameterF8 aFRR2 = _SerializableDescriptor('aFRR2', PerVectorParameterF8, _required, strict=DEFAULT_STRICT, docstring='') # type: PerVectorParameterF8 FX1 = _SerializableDescriptor('FX1', PerVectorParameterF8, _required, strict=DEFAULT_STRICT, docstring='') # type: PerVectorParameterF8 FX2 = _SerializableDescriptor('FX2', PerVectorParameterF8, _required, strict=DEFAULT_STRICT, docstring='') # type: PerVectorParameterF8 FXN1 = _SerializableDescriptor('FXN1', PerVectorParameterF8, _required, strict=DEFAULT_STRICT, docstring='') # type: PerVectorParameterF8 FXN2 = _SerializableDescriptor('FXN2', PerVectorParameterF8, _required, strict=DEFAULT_STRICT, docstring='') # type: PerVectorParameterF8 TOA1 = _SerializableDescriptor('TOA1', PerVectorParameterF8, _required, strict=DEFAULT_STRICT, docstring='') # type: PerVectorParameterF8 TOA2 = _SerializableDescriptor('TOA2', PerVectorParameterF8, _required, strict=DEFAULT_STRICT, docstring='') # type: PerVectorParameterF8 TOAE1 = _SerializableDescriptor('TOAE1', PerVectorParameterF8, _required, strict=DEFAULT_STRICT, docstring='') # type: PerVectorParameterF8 TOAE2 = _SerializableDescriptor('TOAE2', PerVectorParameterF8, _required, strict=DEFAULT_STRICT, docstring='') # type: PerVectorParameterF8 TDTropoSRP = _SerializableDescriptor( 'TDTropoSRP', PerVectorParameterF8, _required, strict=DEFAULT_STRICT, docstring='') # type: PerVectorParameterF8 TDIonoSRP = _SerializableDescriptor( 'TDIonoSRP', PerVectorParameterF8, _required, strict=DEFAULT_STRICT, docstring='') # type: PerVectorParameterF8 SC0 = _SerializableDescriptor('SC0', PerVectorParameterF8, _required, strict=DEFAULT_STRICT, docstring='') # type: PerVectorParameterF8 SCSS = _SerializableDescriptor('SCSS', PerVectorParameterF8, _required, strict=DEFAULT_STRICT, docstring='') # type: PerVectorParameterF8 SIGNAL = _SerializableDescriptor( 'SIGNAL', PerVectorParameterI8, _required, strict=DEFAULT_STRICT, docstring='') # type: PerVectorParameterI8 AddedPVP = _SerializableListDescriptor( 'AddedPVP', UserDefinedPVPType, _collections_tags, _required, strict=DEFAULT_STRICT, docstring='') # type: Union[None, List[UserDefinedPVPType]] def __init__(self, TxTime=None, TxPos=None, TxVel=None, RcvTime=None, RcvPos=None, RcvVel=None, SRPPos=None, AmpSF=None, aFDOP=None, aFRR1=None, aFRR2=None, FX1=None, FX2=None, FXN1=None, FXN2=None, TOA1=None, TOA2=None, TOAE1=None, TOAE2=None, TDTropoSRP=None, TDIonoSRP=None, SC0=None, SCSS=None, SIGNAL=None, AddedPVP=None, **kwargs): """ Parameters ---------- TxTime : PerVectorParameterF8 TxPos : PerVectorParameterXYZ TxVel : PerVectorParameterXYZ RcvTime : PerVectorParameterF8 RcvPos : PerVectorParameterXYZ RcvVel : PerVectorParameterXYZ SRPPos : PerVectorParameterXYZ AmpSF : None|PerVectorParameterF8 aFDOP : PerVectorParameterF8 aFRR1 : PerVectorParameterF8 aFRR2 : PerVectorParameterF8 FX1 : PerVectorParameterF8 FX2 : PerVectorParameterF8 FXN1 : None|PerVectorParameterF8 FXN2 : None|PerVectorParameterF8 TOA1 : PerVectorParameterF8 TOA2 : PerVectorParameterF8 TOAE1 : None|PerVectorParameterF8 TOAE2 : None|PerVectorParameterF8 TDTropoSRP : PerVectorParameterF8 TDIonoSRP : None|PerVectorParameterF8 SC0 : PerVectorParameterF8 SCSS : PerVectorParameterF8 SIGNAL : None|PerVectorParameterI8 AddedPVP : None|List[UserDefinedPVPType] 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.TxTime = TxTime self.TxPos = TxPos self.TxVel = TxVel self.RcvTime = RcvTime self.RcvPos = RcvPos self.RcvVel = RcvVel self.SRPPos = SRPPos self.AmpSF = AmpSF self.aFDOP = aFDOP self.aFRR1 = aFRR1 self.aFRR2 = aFRR2 self.FX1 = FX1 self.FX2 = FX2 self.FXN1 = FXN1 self.FXN2 = FXN2 self.TOA1 = TOA1 self.TOA2 = TOA2 self.TOAE1 = TOAE1 self.TOAE2 = TOAE2 self.TDTropoSRP = TDTropoSRP self.TDIonoSRP = TDIonoSRP self.SC0 = SC0 self.SCSS = SCSS self.SIGNAL = SIGNAL self.AddedPVP = AddedPVP super(PVPType, self).__init__(**kwargs) def get_size(self): """ Gets the size in bytes of each vector. Returns ------- int """ out = 0 for fld in self._fields[:-1]: val = getattr(self, fld) if val is not None: out += val.Size * 8 if self.AddedPVP is not None: for entry in self.AddedPVP: out += entry.Size * 8 return out def get_offset_size_format(self, field): """ Get the Offset (in bytes), Size (in bytes) for the given field, as well as the corresponding struct format string. Parameters ---------- field : str The desired field name. Returns ------- None|(int, int, str) """ if field in self._fields[:-1]: val = getattr(self, field) if val is None: return None return val.Offset * 8, val.Size * 8, homogeneous_format(val.Format) else: if self.AddedPVP is None: return None for val in self.AddedPVP: if field == val.Name: return val.Offset * 8, val.Size * 8, homogeneous_format( val.Format) return None
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', 'RGBL8U', '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)
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 AntennaType(Serializable): """ Antenna parameters that describe antenna orientation, mainlobe steering and gain patterns vs. time. """ _fields = ('NumTxAnt', 'NumRcvAnt', 'NumTWAnt', 'Tx', 'Rcv', 'TwoWay') _required = () _collections_tags = { 'Tx': { 'array': False, 'child_tag': 'Tx' }, 'Rcv': { 'array': False, 'child_tag': 'Rcv' }, 'TwoWay': { 'array': False, 'child_tag': 'TwoWay' } } # descriptors Tx = _SerializableListDescriptor( 'Tx', AntParamType, _collections_tags, _required, strict=DEFAULT_STRICT, docstring='Transmit antenna pattern parameters.' ) # type: Union[None, List[AntParamType]] Rcv = _SerializableListDescriptor( 'Rcv', AntParamType, _collections_tags, _required, strict=DEFAULT_STRICT, docstring='Receive antenna pattern parameters.' ) # type: Union[None, List[AntParamType]] TwoWay = _SerializableListDescriptor( 'TwoWay', AntParamType, _collections_tags, _required, strict=DEFAULT_STRICT, docstring='Two-way antenna pattern parameters.' ) # type: Union[None, List[AntParamType]] def __init__(self, Tx=None, Rcv=None, TwoWay=None, **kwargs): """ Parameters ---------- Tx : None|List[AntParamType] Rcv : None|List[AntParamType] TwoWay : None|List[AntParamType] 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.Tx = Tx self.Rcv = Rcv self.TwoWay = TwoWay super(AntennaType, self).__init__(**kwargs) @property def NumTxAnt(self): """ int: The number of transmit elements. """ if self.Tx is None: return 0 return len(self.Tx) @property def NumRcvAnt(self): """ int: The number of receive elements. """ if self.Rcv is None: return 0 return len(self.Rcv) @property def NumTWAnt(self): """ int: The number of two way elements. """ if self.TwoWay is None: return 0 return len(self.TwoWay)
class ProductInfoType(Serializable): """ Parameters that provide general information about the CPHD product and/or the derived products that may be created from it. """ _fields = ('Profile', 'CreationInfos', 'Parameters') _required = () _collections_tags = { 'CreationInfos': { 'array': False, 'child_tag': 'CreationInfo' }, 'Parameters': { 'array': False, 'child_tag': 'Parameter' } } # descriptors Profile = _StringDescriptor( 'Profile', _required, strict=DEFAULT_STRICT, docstring='Identifies what profile was used to create this CPHD product.' ) # type: str CreationInfos = _SerializableListDescriptor( 'CreationInfos', CreationInfoType, _collections_tags, _required, strict=DEFAULT_STRICT, docstring='Parameters that provide general information about the CPHD ' 'product generation.') # type: Union[None, List[CreationInfoType]] Parameters = _ParametersDescriptor( 'Parameters', _collections_tags, _required, strict=DEFAULT_STRICT, docstring='Additional parameters.' ) # type: Union[None, ParametersCollection] def __init__(self, Profile=None, CreationInfos=None, Parameters=None, **kwargs): """ Parameters ---------- Profile : str CreationInfos : None|List[CreationInfoType] Parameters : 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.Profile = Profile self.CreationInfos = CreationInfos self.Parameters = Parameters super(ProductInfoType, self).__init__(**kwargs)
class ExploitationFeaturesCollectionInformationType(Serializable): """ General collection information. """ _fields = ('SensorName', 'RadarMode', 'CollectionDateTime', 'LocalDateTime', 'CollectionDuration', 'Resolution', 'InputROI', 'Polarizations') _required = ('SensorName', 'RadarMode', 'CollectionDateTime', 'CollectionDuration') _collections_tags = { 'Polarizations': { 'array': False, 'child_tag': 'Polarization' } } _numeric_format = {'CollectionDuration': '0.16G'} # Descriptor SensorName = _StringDescriptor('SensorName', _required, strict=DEFAULT_STRICT, docstring='The name of the sensor.') # str RadarMode = _SerializableDescriptor( 'RadarMode', RadarModeType, _required, strict=DEFAULT_STRICT, docstring='Radar collection mode.') # type: RadarModeType CollectionDateTime = _DateTimeDescriptor( 'CollectionDateTime', _required, strict=DEFAULT_STRICT, docstring= 'Collection date and time defined in Coordinated Universal Time (UTC). The seconds ' 'should be followed by a Z to indicate UTC.') # type: numpy.datetime64 CollectionDuration = _FloatDescriptor( 'CollectionDuration', _required, strict=DEFAULT_STRICT, docstring='The duration of the collection (units = seconds).' ) # type: float Resolution = _SerializableDescriptor( 'Resolution', RangeAzimuthType, _required, strict=DEFAULT_STRICT, docstring= 'Uniformly-weighted resolution (range and azimuth) processed in ' 'the slant plane.') # type: Union[None, RangeAzimuthType] InputROI = _SerializableDescriptor( 'InputROI', InputROIType, _required, strict=DEFAULT_STRICT, docstring='ROI representing portion of input data used to make ' 'this product.') # type: Union[None, InputROIType] Polarizations = _SerializableListDescriptor( 'Polarizations', TxRcvPolarizationType, _collections_tags, _required, strict=DEFAULT_STRICT, docstring='Transmit and receive polarization(s).' ) # type: Union[None, List[TxRcvPolarizationType]] def __init__(self, SensorName=None, RadarMode=None, CollectionDateTime=None, LocalDateTime=None, CollectionDuration=None, Resolution=None, Polarizations=None, **kwargs): """ Parameters ---------- SensorName : str RadarMode : RadarModeType CollectionDateTime : numpy.datetime64|datetime.datetime|datetime.date|str LocalDateTime : None|str|datetime.datetime CollectionDuration : float Resolution : None|RangeAzimuthType|numpy.ndarray|list|tuple Polarizations : None|List[TxRcvPolarizationType] kwargs """ self._local_date_time = None 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.SensorName = SensorName self.RadarMode = RadarMode self.CollectionDateTime = CollectionDateTime self.CollectionDuration = CollectionDuration self.LocalDateTime = LocalDateTime self.Resolution = Resolution self.Polarizations = Polarizations super(ExploitationFeaturesCollectionInformationType, self).__init__(**kwargs) @property def LocalDateTime(self): """None|str: The local date/time string of the collection. *Optional.*""" return self._local_date_time @LocalDateTime.setter def LocalDateTime( self, value): # type: (Union[None, str, datetime.datetime]) -> None if value is None: self._local_date_time = None return elif isinstance(value, datetime.datetime): value = value.isoformat('T') if isinstance(value, string_types): self._local_date_time = value else: logging.error( 'Attribute LocalDateTime of class ExploitationFeaturesCollectionInformationType ' 'requires a datetime.datetime or string. Got unsupported type {}. ' 'Setting value to None.'.format(type(value))) self._local_date_time = None @classmethod def from_sicd(cls, sicd): """ Construct from a sicd element. Parameters ---------- sicd : SICDType Returns ------- ExploitationFeaturesCollectionInformationType """ if not isinstance(sicd, SICDType): raise TypeError('Requires SICDType instance, got type {}'.format( type(sicd))) polarizations = [ TxRcvPolarizationType.from_sicd_value(entry.TxRcvPolarization) for entry in sicd.RadarCollection.RcvChannels ] return cls( SensorName=sicd.CollectionInfo.CollectorName, RadarMode=RadarModeType(**sicd.CollectionInfo.RadarMode.to_dict()), CollectionDateTime=sicd.Timeline.CollectStart, CollectionDuration=sicd.Timeline.CollectDuration, Resolution=(sicd.Grid.Row.SS, sicd.Grid.Col.SS), Polarizations=polarizations)
class ExploitationFeaturesProductType(Serializable): """ Metadata regarding the product. """ _fields = ('Resolution', 'Ellipticity', 'Polarizations', 'North', 'Extensions') _required = ('Resolution', 'Ellipticity', 'Polarizations') _collections_tags = { 'Polarizations': { 'array': False, 'child_tag': 'Polarization' }, 'Extensions': { 'array': False, 'child_tag': 'Extension' } } _numeric_format = {'Ellipticity': '0.16G', 'North': '0.16G'} # Descriptor Resolution = _SerializableDescriptor( 'Resolution', RowColDoubleType, _required, strict=DEFAULT_STRICT, docstring= 'Uniformly-weighted resolution projected into the Earth Tangent ' 'Plane (ETP).') # type: RowColDoubleType Ellipticity = _FloatDescriptor( 'Ellipticity', _required, strict=DEFAULT_STRICT, docstring= "Ellipticity of the 2D-IPR at the ORP, measured in the *Earth Geodetic " "Tangent Plane (EGTP)*. Ellipticity is the ratio of the IPR ellipse's " "major axis to minor axis.") # type: float Polarizations = _SerializableListDescriptor( 'Polarizations', ProcTxRcvPolarizationType, _collections_tags, _required, strict=DEFAULT_STRICT, docstring= 'Describes the processed transmit and receive polarizations for the ' 'product.') # type: List[ProcTxRcvPolarizationType] North = _FloatModularDescriptor( 'North', 180.0, _required, strict=DEFAULT_STRICT, docstring= 'Counter-clockwise angle from increasing row direction to north at the center ' 'of the image.') # type: float Extensions = _ParametersDescriptor( 'Extensions', _collections_tags, _required, strict=DEFAULT_STRICT, docstring='Exploitation feature extension related to geometry for a ' 'single input image.') # type: ParametersCollection def __init__(self, Resolution=None, Ellipticity=None, Polarizations=None, North=None, Extensions=None, **kwargs): """ Parameters ---------- Resolution : RowColDoubleType|numpy.ndarray|list|tuple Ellipticity : float Polarizations : List[ProcTxRcvPolarizationType] North : None|float Extensions : 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.Resolution = Resolution self.Ellipticity = Ellipticity self.Polarizations = Polarizations self.North = North self.Extensions = Extensions super(ExploitationFeaturesProductType, self).__init__(**kwargs) @classmethod def from_sicd(cls, sicd): """ Construct from a sicd element. Parameters ---------- sicd : SICDType Returns ------- ExploitationFeaturesProductType """ if not isinstance(sicd, SICDType): raise TypeError('Requires SICDType instance, got type {}'.format( type(sicd))) row_ground, col_ground = sicd.get_ground_resolution() ellipticity = row_ground / col_ground if row_ground >= col_ground else col_ground / row_ground return cls(Resolution=(row_ground, col_ground), Ellipticity=ellipticity, Polarizations=[ ProcTxRcvPolarizationType.from_sicd_value( sicd.ImageFormation.TxRcvPolarizationProc), ])
class AntennaType(Serializable): """ Parameters that describe the transmit and receive antennas used to collect the signal array(s). """ _fields = ('NumACFs', 'NumAPCs', 'NumAntPats', 'AntCoordFrame', 'AntPhaseCenter', 'AntPattern') _required = ('AntCoordFrame', 'AntPhaseCenter', 'AntPattern') _collections_tags = { 'AntCoordFrame': { 'array': False, 'child_tag': 'AntCoordFrame' }, 'AntPhaseCenter': { 'array': False, 'child_tag': 'AntPhaseCenter' }, 'AntPattern': { 'array': False, 'child_tag': 'AntPattern' } } # descriptors AntCoordFrame = _SerializableListDescriptor( 'AntCoordFrame', AntCoordFrameType, _collections_tags, _required, strict=DEFAULT_STRICT, docstring= 'Unit vectors that describe the orientation of an Antenna Coordinate Frame (ACF) ' 'as function of time. Parameter set repeated for ' 'each ACF.') # type: List[AntCoordFrameType] AntPhaseCenter = _SerializableListDescriptor( 'AntPhaseCenter', AntPhaseCenterType, _collections_tags, _required, strict=DEFAULT_STRICT, docstring= 'Parameters that describe each Antenna Phase Center (APC). Parameter ' 'set repeated for each APC.') # type: List[AntPhaseCenterType] AntPattern = _SerializableListDescriptor( 'AntPattern', AntPatternType, _collections_tags, _required, strict=DEFAULT_STRICT, docstring= 'Parameter set that defines each Antenna Pattern as function time. Parameters ' 'set repeated for each Antenna Pattern.') # type: List[AntPatternType] def __init__(self, AntCoordFrame=None, AntPhaseCenter=None, AntPattern=None, **kwargs): """ Parameters ---------- AntCoordFrame : List[AntCoordFrameType] AntPhaseCenter : List[AntPhaseCenterType] AntPattern : List[AntPatternType] 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.AntCoordFrame = AntCoordFrame self.AntPhaseCenter = AntPhaseCenter self.AntPattern = AntPattern super(AntennaType, self).__init__(**kwargs) @property def NumACFs(self): """ int: The number of antenna coordinate frame elements. """ if self.AntCoordFrame is None: return 0 return len(self.AntCoordFrame) @property def NumAPCs(self): """ int: The number of antenna phase center elements. """ if self.AntPhaseCenter is None: return 0 return len(self.AntPhaseCenter) @property def NumAntPats(self): """ int: The number of antenna pattern elements. """ if self.AntPattern is None: return 0 return len(self.AntPattern)
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 DataType(Serializable): """ Parameters that describe binary data components contained in the product. """ _fields = ('SignalArrayFormat', 'NumBytesPVP', 'NumCPHDChannels', 'SignalCompressionID', 'Channels', 'NumSupportArrays', 'SupportArrays') _required = ('SignalArrayFormat', 'NumBytesPVP', 'Channels') _collections_tags = { 'Channels': { 'array': False, 'child_tag': 'Channel' }, 'SupportArrays': { 'array': False, 'child_tag': 'SupportArray' } } # descriptors SignalArrayFormat = _StringEnumDescriptor( 'SignalArrayFormat', ('CI2', 'CI4', 'CF8'), _required, strict=DEFAULT_STRICT, docstring= 'Signal Array sample binary format of the CPHD signal arrays in standard ' '(i.e. uncompressed) format, where `CI2` denotes a 1 byte signed integer ' "parameter, 2's complement format, and 2 Bytes Per Sample; `CI4` denotes " "a 2 byte signed integer parameter, 2's complement format, and " "4 Bytes Per Sample; `CF8` denotes a 4 byte floating point parameter, and " "8 Bytes Per Sample.") # type: str NumBytesPVP = _IntegerDescriptor( 'NumBytesPVP', _required, strict=DEFAULT_STRICT, bounds=(0, None), docstring= 'Number of bytes per set of Per Vector Parameters, where there is ' 'one set of PVPs for each CPHD signal vector') # type: int SignalCompressionID = _StringDescriptor( 'SignalCompressionID', _required, strict=DEFAULT_STRICT, docstring= 'Parameter that indicates the signal arrays are in compressed format. Value ' 'identifies the method of decompression. Parameter included if and only if ' 'the signal arrays are in compressed format.') # type: str Channels = _SerializableListDescriptor( 'Channels', ChannelSizeType, _collections_tags, _required, strict=DEFAULT_STRICT, docstring= 'Parameters that define the Channel signal array and PVP array size ' 'and location.') # type: List[ChannelSizeType] SupportArrays = _SerializableListDescriptor( 'SupportArrays', SupportArraySizeType, _collections_tags, _required, strict=DEFAULT_STRICT, docstring= 'Support Array size parameters. Branch repeated for each binary support array. ' 'Support Array referenced by its unique Support Array ' 'identifier.') # type: List[SupportArraySizeType] def __init__(self, SignalArrayFormat=None, NumBytesPVP=None, SignalCompressionID=None, Channels=None, SupportArrays=None, **kwargs): """ Parameters ---------- SignalArrayFormat : str NumBytesPVP : int SignalCompressionID : None|str Channels : List[ChannelSizeType] SupportArrays : None|List[SupportArraySizeType] 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.SignalArrayFormat = SignalArrayFormat self.NumBytesPVP = NumBytesPVP self.SignalCompressionID = SignalCompressionID self.Channels = Channels self.SupportArrays = SupportArrays super(DataType, self).__init__(**kwargs) @property def NumSupportArrays(self): """ int: The number of support arrays. """ if self.SupportArrays is None: return 0 else: return len(self.SupportArrays) @property def NumCPHDChannels(self): """ int: The number of CPHD channels. """ if self.Channels is None: return 0 else: return len(self.Channels)
class DwellType(Serializable): """ Parameters that specify the dwell time supported by the signal arrays contained in the CPHD product. """ _fields = ('NumCODTimes', 'CODTimes', 'NumDwellTimes', 'DwellTimes') _required = ('CODTimes', 'DwellTimes') _collections_tags = { 'CODTimes': { 'array': False, 'child_tag': 'CODTime' }, 'DwellTimes': { 'array': False, 'child_tag': 'DwellTime' } } # descriptors CODTimes = _SerializableListDescriptor( 'CODTimes', CODTimeType, _collections_tags, _required, strict=DEFAULT_STRICT, docstring='The Center of Dwell (COD) time polynomials.' ) # type: List[CODTimeType] DwellTimes = _SerializableListDescriptor( 'DwellTimes', DwellTimeType, _collections_tags, _required, strict=DEFAULT_STRICT, docstring='The dwell time polynomials.') # type: List[DwellTimeType] def __init__(self, CODTimes=None, DwellTimes=None, **kwargs): """ Parameters ---------- CODTimes : List[CODTimeType] DwellTimes : List[DwellTimeType] 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.CODTimes = CODTimes self.DwellTimes = DwellTimes super(DwellType, self).__init__(**kwargs) @property def NumCODTimes(self): """ int: The number of cod time polynomial elements. """ if self.CODTimes is None: return 0 else: return len(self.CODTimes) @property def NumDwellTimes(self): """ int: The number of dwell time polynomial elements. """ if self.DwellTimes is None: return 0 else: return len(self.DwellTimes)
class TxRcvType(Serializable): """ Parameters that describe the transmitted waveform(s) and receiver configurations used in the collection """ _fields = ('NumTxWFs', 'TxWFParameters', 'NumRcvs', 'RcvParameters') _required = ('TxWFParameters', 'RcvParameters') _collections_tags = { 'TxWFParameters': { 'array': False, 'child_tag': 'TxWFParameters' }, 'RcvParameters': { 'array': False, 'child_tag': 'RcvParameters' } } # descriptors TxWFParameters = _SerializableListDescriptor( 'TxWFParameters', TxWFParametersType, _collections_tags, _required, strict=DEFAULT_STRICT, docstring='Parameters that describe a Transmit Waveform.' ) # type: List[TxWFParametersType] RcvParameters = _SerializableListDescriptor( 'RcvParameters', RcvParametersType, _collections_tags, _required, strict=DEFAULT_STRICT, docstring='Parameters that describe a Receive configuration.' ) # type: List[RcvParametersType] def __init__(self, TxWFParameters=None, RcvParameters=None, **kwargs): """ Parameters ---------- TxWFParameters : List[TxWFParametersType] RcvParameters : List[RcvParametersType] 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.TxWFParameters = TxWFParameters self.RcvParameters = RcvParameters super(TxRcvType, self).__init__(**kwargs) @property def NumTxWFs(self): """ int: The number of transmit waveforms used. """ if self.TxWFParameters is None: return 0 return len(self.TxWFParameters) @property def NumRcvs(self): """ int: The number of receive configurations used. """ if self.RcvParameters is None: return 0 return len(self.RcvParameters)