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 PositionalAccuracyType(Serializable):
"""
Describes the horizontal and vertical point and regional information for the DED.
"""
_fields = ('NumRegions', 'AbsoluteAccuracy', 'PointToPointAccuracy')
_required = ('NumRegions', 'AbsoluteAccuracy', 'PointToPointAccuracy')
# Descriptor
NumRegions = _IntegerDescriptor(
'NumRegions',
_required,
strict=DEFAULT_STRICT,
docstring='Number of positional accuracy regions.') # type: int
AbsoluteAccuracy = _SerializableDescriptor(
'AbsoluteAccuracy',
AccuracyType,
_required,
strict=DEFAULT_STRICT,
docstring='') # type: AccuracyType
PointToPointAccuracy = _SerializableDescriptor(
'PointToPointAccuracy',
AccuracyType,
_required,
strict=DEFAULT_STRICT,
docstring='') # type: AccuracyType
def __init__(self,
NumRegions=None,
AbsoluteAccuracy=None,
PointToPointAccuracy=None,
**kwargs):
"""
Parameters
----------
NumRegions : int
AbsoluteAccuracy : AccuracyType
PointToPointAccuracy : AccuracyType
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.NumRegions = NumRegions
self.AbsoluteAccuracy = AbsoluteAccuracy
self.PointToPointAccuracy = PointToPointAccuracy
super(PositionalAccuracyType, self).__init__(**kwargs)
class NonInteractiveProcessingType(Serializable):
"""
The non-interactive processing information.
"""
_fields = ('ProductGenerationOptions', 'RRDS', 'band')
_required = ('ProductGenerationOptions', 'RRDS', 'band')
_set_as_attribute = ('band', )
# Descriptor
ProductGenerationOptions = _SerializableDescriptor(
'ProductGenerationOptions',
ProductGenerationOptionsType,
_required,
strict=DEFAULT_STRICT,
docstring=
'Performs several key actions on an image to prepare it for necessary additional processing to '
'achieve the desired output product.'
) # type: ProductGenerationOptionsType
RRDS = _SerializableDescriptor(
'RRDS',
RRDSType,
_required,
strict=DEFAULT_STRICT,
docstring=
'Creates a set of sub-sampled versions of an image to provide processing chains '
'with quick access to lower magnification values for faster computation '
'speeds and performance.') # type: RRDSType
band = _IntegerDescriptor(
'band',
_required,
strict=DEFAULT_STRICT,
docstring='The image band to which this applies.') # type: int
def __init__(self,
ProductGenerationOptions=None,
RRDS=None,
band=1,
**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.ProductGenerationOptions = ProductGenerationOptions
self.RRDS = RRDS
self.band = band
super(NonInteractiveProcessingType, self).__init__(**kwargs)
class PerVectorParameterF8(Serializable):
_fields = ('Offset', 'Size', 'Format')
_required = ('Offset', )
# descriptors
Offset = _IntegerDescriptor('Offset',
_required,
strict=DEFAULT_STRICT,
bounds=(0, None),
docstring='The offset value.') # type: int
def __init__(self, Offset=None, **kwargs):
"""
Parameters
----------
Offset : 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.Offset = Offset
super(PerVectorParameterF8, self).__init__(**kwargs)
@property
def Size(self):
"""
int: The size of the vector, constant value 1 here.
"""
return 1
@property
def Format(self):
"""
str: The format of the vector data, constant value 'F8' here.
"""
return 'F8'
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 CPHDHeader(CPHDHeaderBase):
_fields = ('XML_DATA_SIZE', 'XML_BYTE_OFFSET', 'VB_DATA_SIZE',
'VB_BYTE_OFFSET', 'CPHD_DATA_SIZE', 'CPHD_BYTE_OFFSET',
'CLASSIFICATION', 'RELEASE_INFO')
_required = ('XML_DATA_SIZE', 'XML_BYTE_OFFSET', 'VB_DATA_SIZE',
'VB_BYTE_OFFSET', 'CPHD_DATA_SIZE', 'CPHD_BYTE_OFFSET')
# descriptor
XML_DATA_SIZE = _IntegerDescriptor(
'XML_DATA_SIZE',
_required,
strict=True,
docstring=
'Size of the XML Metadata in bytes. Does not include the 2 bytes '
'of the section terminator.') # type: int
XML_BYTE_OFFSET = _IntegerDescriptor(
'XML_BYTE_OFFSET',
_required,
strict=True,
docstring='Offset to the first byte of the XML Metadata in bytes.'
) # type: int
VB_DATA_SIZE = _IntegerDescriptor(
'VB_DATA_SIZE',
_required,
strict=True,
docstring='Size of the Vector Based Metadata in bytes.') # type: int
VB_BYTE_OFFSET = _IntegerDescriptor(
'VB_BYTE_OFFSET',
_required,
strict=True,
docstring=
'Offset to the first byte of the Vector Based Metadata in bytes.'
) # type: int
CPHD_DATA_SIZE = _IntegerDescriptor(
'CPHD_DATA_SIZE',
_required,
strict=True,
docstring='Size of the Compensated PHD arrays in bytes.') # type: int
CPHD_BYTE_OFFSET = _IntegerDescriptor(
'CPHD_BYTE_OFFSET',
_required,
strict=True,
docstring='Offset to the first byte of the CPHD data in bytes.'
) # type: int
CLASSIFICATION = _StringDescriptor(
'CLASSIFICATION',
_required,
strict=True,
default_value='UNCLASSIFIED',
docstring=
'Product classification information that is the human-readable banner.'
) # type: str
RELEASE_INFO = _StringDescriptor(
'RELEASE_INFO',
_required,
strict=True,
default_value='UNRESTRICTED',
docstring='Product release information.') # type: str
def __init__(self,
XML_DATA_SIZE=None,
XML_BYTE_OFFSET=None,
VB_DATA_SIZE=None,
VB_BYTE_OFFSET=None,
CPHD_DATA_SIZE=None,
CPHD_BYTE_OFFSET=None,
CLASSIFICATION='UNCLASSIFIED',
RELEASE_INFO='UNRESTRICTED'):
self.XML_DATA_SIZE = XML_DATA_SIZE
self.XML_BYTE_OFFSET = XML_BYTE_OFFSET
self.VB_DATA_SIZE = VB_DATA_SIZE
self.VB_BYTE_OFFSET = VB_BYTE_OFFSET
self.CPHD_DATA_SIZE = CPHD_DATA_SIZE
self.CPHD_BYTE_OFFSET = CPHD_BYTE_OFFSET
self.CLASSIFICATION = CLASSIFICATION
self.RELEASE_INFO = RELEASE_INFO
super(CPHDHeader, self).__init__()
class CPHDHeader(CPHDHeaderBase):
_fields = (
'XML_BLOCK_SIZE', 'XML_BLOCK_BYTE_OFFSET', 'SUPPORT_BLOCK_SIZE', 'SUPPORT_BLOCK_BYTE_OFFSET',
'PVP_BLOCK_SIZE', 'PVP_BLOCK_BYTE_OFFSET', 'SIGNAL_BLOCK_SIZE', 'SIGNAL_BLOCK_BYTE_OFFSET',
'CLASSIFICATION', 'RELEASE_INFO')
_required = (
'XML_BLOCK_SIZE', 'XML_BLOCK_BYTE_OFFSET', 'PVP_BLOCK_SIZE', 'PVP_BLOCK_BYTE_OFFSET',
'SIGNAL_BLOCK_SIZE', 'SIGNAL_BLOCK_BYTE_OFFSET', 'CLASSIFICATION', 'RELEASE_INFO')
# descriptor
XML_BLOCK_SIZE = _IntegerDescriptor(
'XML_BLOCK_SIZE', _required, strict=True,
docstring='ize of the XML instance that describes the product in bytes. '
'Size does NOT include the 2 bytes of the section terminator.') # type: int
XML_BLOCK_BYTE_OFFSET = _IntegerDescriptor(
'XML_BLOCK_BYTE_OFFSET', _required, strict=True,
docstring='Offset to the first byte of the XML block in bytes.') # type: int
SUPPORT_BLOCK_SIZE = _IntegerDescriptor(
'SUPPORT_BLOCK_SIZE', _required, strict=True,
docstring='Size of the Support block in bytes. Note - If the Support block is omitted, this '
'is not included.') # type: int
SUPPORT_BLOCK_BYTE_OFFSET = _IntegerDescriptor(
'SUPPORT_BLOCK_BYTE_OFFSET', _required, strict=True,
docstring='Offset to the first byte of the Support block in bytes. Note - If the Support '
'block is omitted, this is not included.') # type: int
PVP_BLOCK_SIZE = _IntegerDescriptor(
'PVP_BLOCK_SIZE', _required, strict=True,
docstring='Size of the PVP block in bytes.') # type: int
PVP_BLOCK_BYTE_OFFSET = _IntegerDescriptor(
'PVP_BLOCK_BYTE_OFFSET', _required, strict=True,
docstring='Offset to the first byte of the PVP block in bytes.') # type: int
SIGNAL_BLOCK_SIZE = _IntegerDescriptor(
'SIGNAL_BLOCK_SIZE', _required, strict=True,
docstring='Size of the Signal block in bytes.') # type: int
SIGNAL_BLOCK_BYTE_OFFSET = _IntegerDescriptor(
'SIGNAL_BLOCK_BYTE_OFFSET', _required, strict=True,
docstring='Offset to the first byte of the Signal block in bytes.') # type: int
CLASSIFICATION = _StringDescriptor(
'CLASSIFICATION', _required, strict=True, default_value='UNCLASSIFIED',
docstring='Product classification information that is human-readable.') # type: str
RELEASE_INFO = _StringDescriptor(
'RELEASE_INFO', _required, strict=True, default_value='UNRESTRICTED',
docstring='Product release information that is human-readable.') # type: str
def __init__(self, XML_BLOCK_SIZE=None, XML_BLOCK_BYTE_OFFSET=None,
SUPPORT_BLOCK_SIZE= None, SUPPORT_BLOCK_BYTE_OFFSET=None,
PVP_BLOCK_SIZE=None, PVP_BLOCK_BYTE_OFFSET=None,
SIGNAL_BLOCK_SIZE=None, SIGNAL_BLOCK_BYTE_OFFSET=None,
CLASSIFICATION='UNCLASSIFIED', RELEASE_INFO='UNRESTRICTED'):
self.XML_BLOCK_SIZE = XML_BLOCK_SIZE
self.XML_BLOCK_BYTE_OFFSET = XML_BLOCK_BYTE_OFFSET
self.SUPPORT_BLOCK_SIZE = SUPPORT_BLOCK_SIZE
self.SUPPORT_BLOCK_BYTE_OFFSET = SUPPORT_BLOCK_BYTE_OFFSET
self.PVP_BLOCK_SIZE = PVP_BLOCK_SIZE
self.PVP_BLOCK_BYTE_OFFSET = PVP_BLOCK_BYTE_OFFSET
self.SIGNAL_BLOCK_SIZE = SIGNAL_BLOCK_SIZE
self.SIGNAL_BLOCK_BYTE_OFFSET = SIGNAL_BLOCK_BYTE_OFFSET
self.CLASSIFICATION = CLASSIFICATION
self.RELEASE_INFO = RELEASE_INFO
super(CPHDHeader, self).__init__()
def to_string(self):
"""
Forms a CPHD file header string (not including the section terminator) from populated attributes.
"""
return ('CPHD/{}\n'.format(_CPHD_SPECIFICATION_VERSION)
+ ''.join(["{} := {}\n".format(f, getattr(self,f)) for f in self._fields if getattr(self, f) is not None]))
class ChannelParametersType(Serializable):
_fields = ('Identifier', 'RefVectorIndex', 'FXFixed', 'TOAFixed',
'SRPFixed', 'SignalNormal', 'Polarization', 'FxC', 'FxBW',
'FxBWNoise', 'TOASaved', 'TOAExtended', 'DwellTimes',
'ImageArea', 'Antenna', 'TxRcv', 'TgtRefLevel', 'NoiseLevel')
_required = ('Identifier', 'RefVectorIndex', 'FXFixed', 'TOAFixed',
'SRPFixed', 'Polarization', 'FxC', 'FxBW', 'TOASaved',
'DwellTimes')
_numeric_format = {
'FxC': '0.16G',
'FxBW': '0.16G',
'FxBWNoise': '0.16G',
'TOASaved': '0.16G'
}
# descriptors
Identifier = _StringDescriptor(
'Identifier',
_required,
strict=DEFAULT_STRICT,
docstring='String that uniquely identifies this CPHD data channel.'
) # type: str
RefVectorIndex = _IntegerDescriptor(
'RefVectorIndex',
_required,
strict=DEFAULT_STRICT,
bounds=(0, None),
docstring='Index of the reference vector for the channel.'
) # type: int
FXFixed = _BooleanDescriptor(
'FXFixed',
_required,
strict=DEFAULT_STRICT,
docstring=
'Flag to indicate when a constant FX band is saved for all signal '
'vectors of the channel.') # type: bool
TOAFixed = _BooleanDescriptor(
'TOAFixed',
_required,
strict=DEFAULT_STRICT,
docstring='Flag to indicate when a constant TOA swath is saved for all '
'signal vectors of the channel.') # type: bool
SRPFixed = _BooleanDescriptor(
'SRPFixed',
_required,
strict=DEFAULT_STRICT,
docstring='Flag to indicate when a constant SRP position is used all '
'signal vectors of the channel.') # type: bool
SignalNormal = _BooleanDescriptor(
'SignalNormal',
_required,
strict=DEFAULT_STRICT,
docstring='Flag to indicate when all signal array vectors are normal. '
'Included if and only if the SIGNAL PVP is also included.'
) # type: bool
Polarization = _SerializableDescriptor(
'Polarization',
PolarizationType,
_required,
strict=DEFAULT_STRICT,
docstring='Polarization(s) of the signals that formed the signal '
'array.') # type: PolarizationType
FxC = _FloatDescriptor(
'FxC',
_required,
strict=DEFAULT_STRICT,
bounds=(0, None),
docstring=
'FX center frequency value for saved bandwidth for the channel. '
'Computed from all vectors of the signal array.') # type: float
FxBW = _FloatDescriptor(
'FxBW',
_required,
strict=DEFAULT_STRICT,
bounds=(0, None),
docstring='FX band spanned for the saved bandwidth for the channel. '
'Computed from all vectors of the signal array.') # type: float
FxBWNoise = _FloatDescriptor(
'FxBWNoise',
_required,
strict=DEFAULT_STRICT,
bounds=(0, None),
docstring=
'FX signal bandwidth saved that includes noise signal below or '
'above the retained echo signal bandwidth.') # type: float
TOASaved = _FloatDescriptor(
'TOASaved',
_required,
strict=DEFAULT_STRICT,
bounds=(0, None),
docstring=
'TOA swath saved for the full resolution echoes for the channel.'
) # type: float
TOAExtended = _SerializableDescriptor(
'TOAExtended',
TOAExtendedType,
_required,
strict=DEFAULT_STRICT,
docstring='TOA extended swath information.'
) # type: Union[None, TOAExtendedType]
DwellTimes = _SerializableDescriptor(
'DwellTimes',
DwellTimesType,
_required,
strict=DEFAULT_STRICT,
docstring='COD Time and Dwell Time polynomials over the image area.'
) # type: DwellTimesType
ImageArea = _SerializableDescriptor(
'ImageArea',
AreaType,
_required,
strict=DEFAULT_STRICT,
docstring=
'Image Area for the CPHD channel defined by a rectangle aligned with '
'(IAX, IAY). May be reduced by the optional '
'polygon.') # type: Union[None, AreaType]
Antenna = _SerializableDescriptor(
'Antenna',
AntennaType,
_required,
strict=DEFAULT_STRICT,
docstring=
'Antenna Phase Center and Antenna Pattern identifiers for the antenna(s) '
'used to collect and form the signal array data.'
) # type: Union[None, AntennaType]
TxRcv = _SerializableDescriptor(
'TxRcv',
TxRcvType,
_required,
strict=DEFAULT_STRICT,
docstring=
'Parameters to identify the Transmit and Receive parameter sets '
'used to collect the signal array.') # type: Union[None, TxRcvType]
TgtRefLevel = _SerializableDescriptor(
'TgtRefLevel',
TgtRefLevelType,
_required,
strict=DEFAULT_STRICT,
docstring=
'Signal level for an ideal point scatterer located at the SRP for '
'reference signal vector.') # type: Union[None, TgtRefLevelType]
NoiseLevel = _SerializableDescriptor(
'NoiseLevel',
NoiseLevelType,
_required,
strict=DEFAULT_STRICT,
docstring='Thermal noise level for the reference signal '
'vector.') # type: Union[None, NoiseLevelType]
def __init__(self,
Identifier=None,
RefVectorIndex=None,
FXFixed=None,
TOAFixed=None,
SRPFixed=None,
SignalNormal=None,
Polarization=None,
FxC=None,
FxBW=None,
FxBWNoise=None,
TOASaved=None,
TOAExtended=None,
DwellTimes=None,
ImageArea=None,
Antenna=None,
TxRcv=None,
TgtRefLevel=None,
NoiseLevel=None,
**kwargs):
"""
Parameters
----------
Identifier : str
RefVectorIndex : int
FXFixed : bool
TOAFixed : bool
SRPFixed : bool
SignalNormal : None|bool
Polarization : PolarizationType
FxC : float
FxBW : float
FxBWNoise : None|float
TOASaved : float
TOAExtended : None|TOAExtendedType
DwellTimes : DwellTimesType
ImageArea : None|AreaType
Antenna : None|AntennaType
TxRcv : None|TxRcvType
TgtRefLevel : None|TgtRefLevelType
NoiseLevel : None|NoiseLevelType
kwargs
"""
if '_xml_ns' in kwargs:
self._xml_ns = kwargs['_xml_ns']
if '_xml_ns_key' in kwargs:
self._xml_ns_key = kwargs['_xml_ns_key']
self.Identifier = Identifier
self.RefVectorIndex = RefVectorIndex
self.FXFixed = FXFixed
self.TOAFixed = TOAFixed
self.SRPFixed = SRPFixed
self.SignalNormal = SignalNormal
self.Polarization = Polarization
self.FxC = FxC
self.FxBW = FxBW
self.FxBWNoise = FxBWNoise
self.TOASaved = TOASaved
self.TOAExtended = TOAExtended
self.DwellTimes = DwellTimes
self.ImageArea = ImageArea
self.Antenna = Antenna
self.TxRcv = TxRcv
self.TgtRefLevel = TgtRefLevel
self.NoiseLevel = NoiseLevel
super(ChannelParametersType, self).__init__(**kwargs)
class ChannelSizeType(Serializable):
"""
Parameters that define the Channel signal array and PVP array size and location.
"""
_fields = ('Identifier', 'NumVectors', 'NumSamples',
'SignalArrayByteOffset', 'PVPArrayByteOffset',
'CompressedSignalSize')
_required = ('Identifier', 'NumVectors', 'NumSamples',
'SignalArrayByteOffset', 'PVPArrayByteOffset')
# descriptors
Identifier = _StringDescriptor(
'Identifier',
_required,
strict=DEFAULT_STRICT,
docstring=
'String that uniquely identifies the CPHD channel for which the data '
'applies.') # type: str
NumVectors = _IntegerDescriptor(
'NumVectors',
_required,
strict=DEFAULT_STRICT,
bounds=(1, None),
docstring='Number of vectors in the signal array.') # type: int
NumSamples = _IntegerDescriptor(
'NumSamples',
_required,
strict=DEFAULT_STRICT,
bounds=(1, None),
docstring='Number of samples per vector in the signal array.'
) # type: int
SignalArrayByteOffset = _IntegerDescriptor(
'SignalArrayByteOffset',
_required,
strict=DEFAULT_STRICT,
bounds=(0, None),
docstring=
'Signal Array offset from the start of the Signal block (in bytes) to the '
'start of the Signal Array for the channel.') # type: int
PVPArrayByteOffset = _IntegerDescriptor(
'PVPArrayByteOffset',
_required,
strict=DEFAULT_STRICT,
bounds=(0, None),
docstring=
'PVP Array offset from the start of the PVP block (in bytes) to the '
'start of the PVP Array for the channel.') # type: int
CompressedSignalSize = _IntegerDescriptor(
'CompressedSignalSize',
_required,
strict=DEFAULT_STRICT,
bounds=(1, None),
docstring=
'Size (in bytes) of the compressed signal array byte sequence for the data channel. '
'Parameter included if and only if the signal arrays are stored in '
'compressed format.') # type: int
def __init__(self,
Identifier=None,
NumVectors=None,
NumSamples=None,
SignalArrayByteOffset=None,
PVPArrayByteOffset=None,
CompressedSignalSize=None,
**kwargs):
"""
Parameters
----------
Identifier : str
NumVectors : int
NumSamples : int
SignalArrayByteOffset : int
PVPArrayByteOffset : int
CompressedSignalSize : 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.Identifier = Identifier
self.NumVectors = NumVectors
self.NumSamples = NumSamples
self.SignalArrayByteOffset = SignalArrayByteOffset
self.PVPArrayByteOffset = PVPArrayByteOffset
self.CompressedSignalSize = CompressedSignalSize
super(ChannelSizeType, self).__init__(**kwargs)
class SupportArraySizeType(Serializable):
"""
Support Array size parameters.
"""
_fields = ('Identifier', 'NumRows', 'NumCols', 'BytesPerElement',
'ArrayByteOffset')
_required = _fields
# descriptors
Identifier = _StringDescriptor(
'Identifier',
_required,
strict=DEFAULT_STRICT,
docstring='Unique string that identifies this support array.'
) # type: str
NumRows = _IntegerDescriptor(
'NumRows',
_required,
strict=DEFAULT_STRICT,
bounds=(1, None),
docstring='Number of rows in the array.') # type: int
NumCols = _IntegerDescriptor(
'NumCols',
_required,
strict=DEFAULT_STRICT,
bounds=(1, None),
docstring='Number of columns per row in the array.') # type: int
BytesPerElement = _IntegerDescriptor(
'BytesPerElement',
_required,
strict=DEFAULT_STRICT,
bounds=(1, None),
docstring=
'Indicates the size in bytes of each data element in the support '
'array. Each element contains 1 or more binary-formatted '
'components.') # type: int
ArrayByteOffset = _IntegerDescriptor(
'ArrayByteOffset',
_required,
strict=DEFAULT_STRICT,
bounds=(0, None),
docstring=
'Array offset from the start of the Support block (in bytes) to '
'the start of the support array.') # type: int
def __init__(self,
Identifier=None,
NumRows=None,
NumCols=None,
BytesPerElement=None,
ArrayByteOffset=None,
**kwargs):
"""
Parameters
----------
Identifier : str
NumRows : int
NumCols : int
BytesPerElement : int
ArrayByteOffset : 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.Identifier = Identifier
self.NumRows = NumRows
self.NumCols = NumCols
self.BytesPerElement = BytesPerElement
self.ArrayByteOffset = ArrayByteOffset
super(SupportArraySizeType, self).__init__(**kwargs)
class ProductClassificationType(Serializable):
"""
The overall classification of the product.
"""
_fields = ('DESVersion', 'resourceElement', 'createDate', 'compliesWith',
'ISMCATCESVersion', 'classification', 'ownerProducer',
'SCIcontrols', 'SARIdentifier', 'disseminationControls',
'FGIsourceOpen', 'FGIsourceProtected', 'releasableTo',
'nonICmarkings', 'classifiedBy', 'compilationReason',
'derivativelyClassifiedBy', 'classificationReason',
'nonUSControls', 'derivedFrom', 'declassDate', 'declassEvent',
'declassException', 'typeOfExemptedSource',
'dateOfExemptedSource', 'SecurityExtensions')
_required = ('DESVersion', 'createDate', 'classification', 'ownerProducer',
'compliesWith', 'ISMCATCESVersion')
_collections_tags = {
'SecurityExtensions': {
'array': False,
'child_tag': 'SecurityExtension'
}
}
_set_as_attribute = ('DESVersion', 'resourceElement', 'createDate',
'compliesWith', 'ISMCATCESVersion', 'classification',
'ownerProducer', 'SCIcontrols', 'SARIdentifier',
'disseminationControls', 'FGIsourceOpen',
'FGIsourceProtected', 'releasableTo', 'nonICmarkings',
'classifiedBy', 'compilationReason',
'derivativelyClassifiedBy', 'classificationReason',
'nonUSControls', 'derivedFrom', 'declassDate',
'declassEvent', 'declassException',
'typeOfExemptedSource', 'dateOfExemptedSource')
_child_xml_ns_key = {
the_field: 'ism'
for the_field in _fields if the_field != 'SecurityExtensions'
}
# Descriptor
DESVersion = _IntegerDescriptor(
'DESVersion',
_required,
strict=DEFAULT_STRICT,
default_value=13,
docstring=
'The version number of the DES. Should there be multiple specified in an instance document '
'the one at the root node is the one that will apply to the entire document.'
) # type: int
createDate = _StringDescriptor(
'createDate',
_required,
strict=DEFAULT_STRICT,
docstring=
'This should be a date of format :code:`YYYY-MM-DD`, but this is not checked.'
) # type: str
compliesWith = _StringDescriptor('compliesWith',
_required,
strict=DEFAULT_STRICT,
default_value='USGov',
docstring='') # type: Union[None, str]
ISMCATCESVersion = _StringDescriptor(
'ISMCATCESVersion',
_required,
strict=DEFAULT_STRICT,
default_value='201903',
docstring='') # type: Union[None, str]
classification = _StringEnumDescriptor('classification',
('U', 'C', 'R', 'S', 'TS'),
_required,
strict=DEFAULT_STRICT,
docstring='') # type: str
ownerProducer = _StringDescriptor(
'ownerProducer',
_required,
strict=DEFAULT_STRICT, # default_value='USA',
docstring='') # type: str
SCIcontrols = _StringDescriptor('SCIcontrols',
_required,
strict=DEFAULT_STRICT,
docstring='') # type: Union[None, str]
SARIdentifier = _StringDescriptor('SARIdentifier',
_required,
strict=DEFAULT_STRICT,
docstring='') # type: Union[None, str]
disseminationControls = _StringDescriptor(
'disseminationControls',
_required,
strict=DEFAULT_STRICT,
docstring='') # type: Union[None, str]
FGIsourceOpen = _StringDescriptor('FGIsourceOpen',
_required,
strict=DEFAULT_STRICT,
docstring='') # type: Union[None, str]
FGIsourceProtected = _StringDescriptor(
'FGIsourceProtected', _required, strict=DEFAULT_STRICT,
docstring='') # type: Union[None, str]
releasableTo = _StringDescriptor('releasableTo',
_required,
strict=DEFAULT_STRICT,
docstring='') # type: Union[None, str]
nonICmarkings = _StringDescriptor('nonICmarkings',
_required,
strict=DEFAULT_STRICT,
docstring='') # type: Union[None, str]
classifiedBy = _StringDescriptor('classifiedBy',
_required,
strict=DEFAULT_STRICT,
docstring='') # type: Union[None, str]
compilationReason = _StringDescriptor(
'compilationReason', _required, strict=DEFAULT_STRICT,
docstring='') # type: Union[None, str]
derivativelyClassifiedBy = _StringDescriptor(
'derivativelyClassifiedBy',
_required,
strict=DEFAULT_STRICT,
docstring='') # type: Union[None, str]
classificationReason = _StringDescriptor(
'classificationReason', _required, strict=DEFAULT_STRICT,
docstring='') # type: Union[None, str]
nonUSControls = _StringDescriptor('nonUSControls',
_required,
strict=DEFAULT_STRICT,
docstring='') # type: Union[None, str]
derivedFrom = _StringDescriptor('derivedFrom',
_required,
strict=DEFAULT_STRICT,
docstring='') # type: Union[None, str]
declassDate = _StringDescriptor('declassDate',
_required,
strict=DEFAULT_STRICT,
docstring='') # type: Union[None, str]
declassEvent = _StringDescriptor('declassEvent',
_required,
strict=DEFAULT_STRICT,
docstring='') # type: Union[None, str]
declassException = _StringDescriptor(
'declassException', _required, strict=DEFAULT_STRICT,
docstring='') # type: Union[None, str]
typeOfExemptedSource = _StringDescriptor(
'typeOfExemptedSource', _required, strict=DEFAULT_STRICT,
docstring='') # type: Union[None, str]
dateOfExemptedSource = _StringDescriptor(
'dateOfExemptedSource', _required, strict=DEFAULT_STRICT,
docstring='') # type: Union[None, str]
SecurityExtensions = _ParametersDescriptor(
'SecurityExtensions',
_collections_tags,
_required,
strict=DEFAULT_STRICT,
docstring=
'Extensible parameters used to support profile-specific needs related to '
'product security.') # type: ParametersCollection
def __init__(self,
DESVersion=13,
createDate=None,
compliesWith='USGov',
ISMCATCESVersion='201903',
classification='U',
ownerProducer='USA',
SCIcontrols=None,
SARIdentifier=None,
disseminationControls=None,
FGIsourceOpen=None,
FGIsourceProtected=None,
releasableTo=None,
nonICmarkings=None,
classifiedBy=None,
compilationReason=None,
derivativelyClassifiedBy=None,
classificationReason=None,
nonUSControls=None,
derivedFrom=None,
declassDate=None,
declassEvent=None,
declassException=None,
typeOfExemptedSource=None,
dateOfExemptedSource=None,
SecurityExtensions=None,
**kwargs):
"""
Parameters
----------
DESVersion : int
createDate : str
compliesWith : None|str
ISMCATCESVersion : None|str
classification : str
ownerProducer : str
SCIcontrols : None|str
SARIdentifier : None|str
disseminationControls : None|str
FGIsourceOpen : None|str
FGIsourceProtected : None|str
releasableTo : None|str
nonICmarkings : None|str
classifiedBy : None|str
compilationReason : None|str
derivativelyClassifiedBy : None|str
classificationReason : None|str
nonUSControls : None|str
derivedFrom : None|str
declassDate : None|str
declassEvent : None|str
declassException : None|str
typeOfExemptedSource : None|str
dateOfExemptedSource : None|str
SecurityExtensions : 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.DESVersion = DESVersion
self.createDate = createDate
self.compliesWith = compliesWith
self.ISMCATCESVersion = ISMCATCESVersion
self.classification = classification
self.ownerProducer = ownerProducer
self.SCIcontrols = SCIcontrols
self.SARIdentifier = SARIdentifier
self.disseminationControls = disseminationControls
self.FGIsourceOpen = FGIsourceOpen
self.FGIsourceProtected = FGIsourceProtected
self.releasableTo = releasableTo
self.nonICmarkings = nonICmarkings
self.classifiedBy = classifiedBy
self.compilationReason = compilationReason
self.derivativelyClassifiedBy = derivativelyClassifiedBy
self.classificationReason = classificationReason
self.nonUSControls = nonUSControls
self.derivedFrom = derivedFrom
self.declassDate = declassDate
self.declassEvent = declassEvent
self.declassException = declassException
self.typeOfExemptedSource = typeOfExemptedSource
self.dateOfExemptedSource = dateOfExemptedSource
self.SecurityExtensions = SecurityExtensions
super(ProductClassificationType, self).__init__(**kwargs)
@property
def resourceElement(self):
return 'true'
@classmethod
def from_sicd(cls, sicd, create_date=None):
"""
Extract best guess from SICD.
Parameters
----------
sicd : SICDType
create_date : str
Returns
-------
ProductClassificationType
"""
if not isinstance(sicd, SICDType):
raise TypeError('Requires SICDType instance, got type {}'.format(
type(sicd)))
c_str = sicd.CollectionInfo.Classification
if 'UNCLASS' in c_str.upper():
clas = 'U'
elif 'CONFIDENTIAL' in c_str.upper():
clas = 'C'
elif 'TOP SECRET' in c_str.upper():
clas = 'TS'
elif 'SECRET' in c_str.upper():
clas = 'S'
elif 'FOUO' in c_str.upper() or 'RESTRICTED' in c_str.upper():
clas = 'R'
else:
logging.critical(
'Unclear how to extract classification code for classification string {}. '
'Should be set appropriately.'.format(c_str))
clas = None
if create_date is None:
create_date = datetime.now().strftime('%Y-%m-%d')
return cls(classification=clas, createDate=create_date)
class GeopositioningType(Serializable):
"""
Describes the absolute coordinate system to which the data is referenced.
"""
_fields = ('CoordinateSystemType', 'GeodeticDatum', 'ReferenceEllipsoid',
'VerticalDatum', 'SoundingDatum', 'FalseOrigin',
'UTMGridZoneNumber')
_required = ('CoordinateSystemType', 'GeodeticDatum', 'ReferenceEllipsoid',
'VerticalDatum', 'SoundingDatum', 'FalseOrigin')
# Descriptor
CoordinateSystemType = _StringEnumDescriptor('CoordinateSystemType',
('GGS', 'UTM'),
_required,
strict=DEFAULT_STRICT,
docstring='') # type: str
GeodeticDatum = _StringEnumDescriptor(
'GeodeticDatum', ('World Geodetic System 1984', ),
_required,
strict=DEFAULT_STRICT,
default_value='World Geodetic System 1984',
docstring='') # type: str
ReferenceEllipsoid = _StringEnumDescriptor(
'ReferenceEllipsoid', ('World Geodetic System 1984', ),
_required,
strict=DEFAULT_STRICT,
default_value='World Geodetic System 1984',
docstring='') # type: str
VerticalDatum = _StringEnumDescriptor('VerticalDatum',
('Mean Sea Level', ),
_required,
strict=DEFAULT_STRICT,
default_value='Mean Sea Level',
docstring='') # type: str
SoundingDatum = _StringEnumDescriptor('SoundingDatum',
('Mean Sea Level', ),
_required,
strict=DEFAULT_STRICT,
default_value='Mean Sea Level',
docstring='') # type: str
FalseOrigin = _IntegerDescriptor(
'FalseOrigin',
_required,
strict=DEFAULT_STRICT,
docstring='Z values false origin.') # type: int
UTMGridZoneNumber = _IntegerDescriptor(
'UTMGridZoneNumber',
_required,
strict=DEFAULT_STRICT,
docstring='Gride zone number, required for UTM, not include for GCS. '
'**Values -** `+001` to `+060` (northern hemisphere) and `-001` to `-060` '
'(southern hemisphere)') # type: int
def __init__(self,
CoordinateSystemType=None,
GeodeticDatum='World Geodetic System 1984',
ReferenceEllipsoid='World Geodetic System 1984',
VerticalDatum='Mean Sea Level',
SoundingDatum='Mean Sea Level',
FalseOrigin=None,
UTMGridZoneNumber=None,
**kwargs):
"""
Parameters
----------
CoordinateSystemType : str
GeodeticDatum : str
ReferenceEllipsoid : str
VerticalDatum : str
SoundingDatum : str
FalseOrigin : int
UTMGridZoneNumber : None|int
kwargs
"""
if '_xml_ns' in kwargs:
self._xml_ns = kwargs['_xml_ns']
self.CoordinateSystemType = CoordinateSystemType
self.GeodeticDatum = GeodeticDatum
self.ReferenceEllipsoid = ReferenceEllipsoid
self.VerticalDatum = VerticalDatum
self.SoundingDatum = SoundingDatum
self.FalseOrigin = FalseOrigin
self.UTMGridZoneNumber = UTMGridZoneNumber
super(GeopositioningType, self).__init__(**kwargs)
class DigitalElevationDataType(Serializable):
"""
This describes any Digital Elevation Data included with the SIDD product.
"""
_fields = ('GeographicCoordinates', 'Geopositioning', 'PositionalAccuracy',
'NullValue')
_required = ('GeographicCoordinates', 'Geopositioning',
'PositionalAccuracy')
# Descriptor
GeographicCoordinates = _SerializableDescriptor(
'GeographicCoordinates',
GeographicCoordinatesType,
_required,
strict=DEFAULT_STRICT,
docstring=
'Describes the Local Geographic Coordinate system linking row/column to the '
'absolute geographic coordinate (lat/lon)'
) # type: GeographicCoordinatesType
Geopositioning = _SerializableDescriptor(
'Geopositioning',
GeopositioningType,
_required,
strict=DEFAULT_STRICT,
docstring=
'Describes the absolute coordinate system to which the data is '
'referenced.') # type: GeopositioningType
PositionalAccuracy = _SerializableDescriptor(
'PositionalAccuracy',
PositionalAccuracyType,
_required,
strict=DEFAULT_STRICT,
docstring=
'Describes the horizontal and vertical point and regional information '
'for the DED.') # type: PositionalAccuracyType
NullValue = _IntegerDescriptor(
'NullValue',
_required,
strict=DEFAULT_STRICT,
docstring='The value in the DEM corresponding to `No Value`.'
) # type: Union[None, int]
def __init__(self,
GeographicCoordinates=None,
Geopositioning=None,
PositionalAccuracy=None,
NullValue=None,
**kwargs):
"""
Parameters
----------
GeographicCoordinates : GeographicCoordinatesType
Geopositioning : GeopositioningType
PositionalAccuracy : PositionalAccuracyType
NullValue : 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.GeographicCoordinates = GeographicCoordinates
self.Geopositioning = Geopositioning
self.PositionalAccuracy = PositionalAccuracy
self.NullValue = NullValue
super(DigitalElevationDataType, self).__init__(**kwargs)
class CPHDHeader(CPHDHeaderBase):
_fields = ('XML_BLOCK_SIZE', 'XML_BLOCK_BYTE_OFFSET', 'SUPPORT_BLOCK_SIZE',
'SUPPORT_BLOCK_BYTE_OFFSET', 'PVP_BLOCK_SIZE',
'PVP_BLOCK_BYTE_OFFSET', 'SIGNAL_BLOCK_SIZE',
'SIGNAL_BLOCK_BYTE_OFFSET', 'CLASSIFICATION', 'RELEASE_INFO')
_required = ('XML_BLOCK_SIZE', 'XML_BLOCK_BYTE_OFFSET', 'PVP_BLOCK_SIZE',
'PVP_BLOCK_BYTE_OFFSET', 'SIGNAL_BLOCK_SIZE',
'SIGNAL_BLOCK_BYTE_OFFSET', 'CLASSIFICATION', 'RELEASE_INFO')
# descriptor
XML_BLOCK_SIZE = _IntegerDescriptor(
'XML_BLOCK_SIZE',
_required,
strict=True,
docstring='ize of the XML instance that describes the product in bytes. '
'Size does NOT include the 2 bytes of the section terminator.'
) # type: int
XML_BLOCK_BYTE_OFFSET = _IntegerDescriptor(
'XML_BLOCK_BYTE_OFFSET',
_required,
strict=True,
docstring='Offset to the first byte of the XML block in bytes.'
) # type: int
SUPPORT_BLOCK_SIZE = _IntegerDescriptor(
'SUPPORT_BLOCK_SIZE',
_required,
strict=True,
docstring=
'Size of the Support block in bytes. Note - If the Support block is omitted, this '
'is not included.') # type: int
SUPPORT_BLOCK_BYTE_OFFSET = _IntegerDescriptor(
'SUPPORT_BLOCK_BYTE_OFFSET',
_required,
strict=True,
docstring=
'Offset to the first byte of the Support block in bytes. Note - If the Support '
'block is omitted, this is not included.') # type: int
PVP_BLOCK_SIZE = _IntegerDescriptor(
'PVP_BLOCK_SIZE',
_required,
strict=True,
docstring='Size of the PVP block in bytes.') # type: int
PVP_BLOCK_BYTE_OFFSET = _IntegerDescriptor(
'PVP_BLOCK_BYTE_OFFSET',
_required,
strict=True,
docstring='Offset to the first byte of the PVP block in bytes.'
) # type: int
SIGNAL_BLOCK_SIZE = _IntegerDescriptor(
'SIGNAL_BLOCK_SIZE',
_required,
strict=True,
docstring='Size of the Signal block in bytes.') # type: int
SIGNAL_BLOCK_BYTE_OFFSET = _IntegerDescriptor(
'SIGNAL_BLOCK_BYTE_OFFSET',
_required,
strict=True,
docstring='Offset to the first byte of the Signal block in bytes.'
) # type: int
CLASSIFICATION = _StringDescriptor(
'CLASSIFICATION',
_required,
strict=True,
default_value='UNCLASSIFIED',
docstring='Product classification information that is human-readable.'
) # type: str
RELEASE_INFO = _StringDescriptor(
'RELEASE_INFO',
_required,
strict=True,
default_value='UNRESTRICTED',
docstring='Product release information that is human-readable.'
) # type: str
def __init__(self,
XML_BLOCK_SIZE=None,
XML_BLOCK_BYTE_OFFSET=None,
SUPPORT_BLOCK_SIZE=None,
SUPPORT_BLOCK_BYTE_OFFSET=None,
PVP_BLOCK_SIZE=None,
PVP_BLOCK_BYTE_OFFSET=None,
SIGNAL_BLOCK_SIZE=None,
SIGNAL_BLOCK_BYTE_OFFSET=None,
CLASSIFICATION='UNCLASSIFIED',
RELEASE_INFO='UNRESTRICTED'):
self.XML_BLOCK_SIZE = XML_BLOCK_SIZE
self.XML_BLOCK_BYTE_OFFSET = XML_BLOCK_BYTE_OFFSET
self.SUPPORT_BLOCK_SIZE = SUPPORT_BLOCK_SIZE
self.SUPPORT_BLOCK_BYTE_OFFSET = SUPPORT_BLOCK_BYTE_OFFSET
self.PVP_BLOCK_SIZE = PVP_BLOCK_SIZE
self.PVP_BLOCK_BYTE_OFFSET = PVP_BLOCK_BYTE_OFFSET
self.SIGNAL_BLOCK_SIZE = SIGNAL_BLOCK_SIZE
self.SIGNAL_BLOCK_BYTE_OFFSET = SIGNAL_BLOCK_BYTE_OFFSET
self.CLASSIFICATION = CLASSIFICATION
self.RELEASE_INFO = RELEASE_INFO
super(CPHDHeader, self).__init__()
class InteractiveProcessingType(Serializable):
"""
The interactive processing information.
"""
_fields = ('GeometricTransform', 'SharpnessEnhancement',
'ColorSpaceTransform', 'DynamicRangeAdjustment',
'TonalTransferCurve', 'band')
_required = ('GeometricTransform', 'SharpnessEnhancement',
'DynamicRangeAdjustment', 'band')
_set_as_attribute = ('band', )
# Descriptor
GeometricTransform = _SerializableDescriptor(
'GeometricTransform',
GeometricTransformType,
_required,
strict=DEFAULT_STRICT,
docstring=
'The geometric transform element is used to perform various geometric distortions '
'to each band of image data. These distortions include image '
'chipping, scaling, rotation, shearing, etc.'
) # type: GeometricTransformType
SharpnessEnhancement = _SerializableDescriptor(
'SharpnessEnhancement',
SharpnessEnhancementType,
_required,
strict=DEFAULT_STRICT,
docstring='Sharpness enhancement.') # type: SharpnessEnhancementType
ColorSpaceTransform = _SerializableDescriptor(
'ColorSpaceTransform',
ColorSpaceTransformType,
_required,
strict=DEFAULT_STRICT,
docstring='Color space transform.') # type: ColorSpaceTransformType
DynamicRangeAdjustment = _SerializableDescriptor(
'DynamicRangeAdjustment',
DynamicRangeAdjustmentType,
_required,
strict=DEFAULT_STRICT,
docstring='Specifies the recommended ELT DRA overrides.'
) # type: DynamicRangeAdjustmentType
TonalTransferCurve = _SerializableDescriptor(
'TonalTransferCurve',
NewLookupTableType,
_required,
strict=DEFAULT_STRICT,
docstring=
"The 1-D LUT element uses one or more 1-D LUTs to stretch or compress tone data "
"in valorous regions within a digital image's dynamic range. 1-D LUT can be "
"implemented using a Tonal Transfer Curve (TTC). There are 12 families of TTCs "
"- Range = [0, 11]. There are 64 members for each "
"family - Range=[0, 63].") # type: NewLookupTableType
band = _IntegerDescriptor(
'band',
_required,
strict=DEFAULT_STRICT,
docstring='The image band to which this applies.')
def __init__(self,
GeometricTransform=None,
SharpnessEnhancement=None,
ColorSpaceTransform=None,
DynamicRangeAdjustment=None,
band=1,
**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.GeometricTransform = GeometricTransform
self.SharpnessEnhancement = SharpnessEnhancement
self.ColorSpaceTransform = ColorSpaceTransform
self.DynamicRangeAdjustment = DynamicRangeAdjustment
self.band = band
super(InteractiveProcessingType, 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 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 GlobalType(Serializable):
"""
The Global type definition.
"""
_fields = (
'DomainType', 'PhaseSGN', 'RefFreqIndex', 'CollectStart',
'CollectDuration', 'TxTime1', 'TxTime2', 'ImageArea')
_required = (
'DomainType', 'PhaseSGN', 'CollectStart', 'CollectDuration',
'TxTime1', 'TxTime2', 'ImageArea')
_numeric_format = {
'CollectDuration': '0.16G', 'TxTime1': '0.16G', 'TxTime2': '0.16G'}
# 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
PhaseSGN = _IntegerEnumDescriptor(
'PhaseSGN', (-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
RefFreqIndex = _IntegerDescriptor(
'RefFreqIndex', _required, strict=DEFAULT_STRICT,
docstring='Indicates if the RF frequency values are expressed as offsets from '
'a reference frequency (RefFreq).') # type: Union[None, int]
CollectStart = _DateTimeDescriptor(
'CollectStart', _required, strict=DEFAULT_STRICT, numpy_datetime_units='us',
docstring='Collection Start date and time (UTC). Time reference used for times '
'measured from collection start (i.e. slow time t = 0). For bistatic '
'collections, the time is the transmit platform collection '
'start time. The default display precision is microseconds, but this '
'does not that accuracy in value.') # type: numpy.datetime64
CollectDuration = _FloatDescriptor(
'CollectDuration', _required, strict=DEFAULT_STRICT,
docstring='The duration of the collection, in seconds.') # type: float
TxTime1 = _FloatDescriptor(
'TxTime1', _required, strict=DEFAULT_STRICT, bounds=(0, None),
docstring='Earliest TxTime value for any signal vector in the product. '
'Time relative to Collection Start in seconds.') # type: float
TxTime2 = _FloatDescriptor(
'TxTime2', _required, strict=DEFAULT_STRICT, bounds=(0, None),
docstring='Latest TxTime value for any signal vector in the product. '
'Time relative to Collection Start in seconds.') # type: float
ImageArea = _SerializableDescriptor(
'ImageArea', ImageAreaType, _required, strict=DEFAULT_STRICT,
docstring='Parameters describing the ground area covered by this '
'product.') # type: ImageAreaType
def __init__(self, DomainType=None, PhaseSGN=None, RefFreqIndex=None, CollectStart=None,
CollectDuration=None, TxTime1=None, TxTime2=None, ImageArea=None, **kwargs):
"""
Parameters
----------
DomainType : str
PhaseSGN : int
RefFreqIndex : None|int
CollectStart : numpy.datetime64|datetime.datetime|str
CollectDuration : float
TxTime1 : float
TxTime2 : float
ImageArea : ImageAreaType
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.PhaseSGN = PhaseSGN
self.RefFreqIndex = RefFreqIndex
self.CollectStart = CollectStart
self.CollectDuration = CollectDuration
self.TxTime1 = TxTime1
self.TxTime2 = TxTime2
self.ImageArea = ImageArea
super(GlobalType, self).__init__(**kwargs)
class SegmentType(Serializable):
"""
Rectangle segment.
"""
_fields = ('Identifier', 'StartLine', 'StartSample', 'EndLine',
'EndSample', 'SegmentPolygon')
_required = ('Identifier', 'StartLine', 'StartSample', 'EndLine',
'EndSample')
_collections_tags = {'SegmentPolygon': {'array': True, 'child_tag': 'SV'}}
# descriptors
Identifier = _StringDescriptor(
'Identifier',
_required,
strict=DEFAULT_STRICT,
docstring='String that uniquely identifies the Image Segment.'
) # type: str
StartLine = _IntegerDescriptor(
'StartLine',
_required,
strict=DEFAULT_STRICT,
docstring='Start line of the segment.') # type: int
StartSample = _IntegerDescriptor(
'StartSample',
_required,
strict=DEFAULT_STRICT,
docstring='Start sample of the segment.') # type: int
EndLine = _IntegerDescriptor(
'EndLine',
_required,
strict=DEFAULT_STRICT,
docstring='End line of the segment.') # type: int
EndSample = _IntegerDescriptor(
'EndSample',
_required,
strict=DEFAULT_STRICT,
docstring='End sample of the segment.') # type: int
SegmentPolygon = _SerializableArrayDescriptor(
'SegmentPolygon',
LSVertexType,
_collections_tags,
_required,
strict=DEFAULT_STRICT,
minimum_length=3,
docstring='Polygon that describes a portion of the segment '
'rectangle.') # type: Union[SerializableArray, List[LSVertexType]]
def __init__(self,
Identifier=None,
StartLine=None,
StartSample=None,
EndLine=None,
EndSample=None,
SegmentPolygon=None,
**kwargs):
"""
Parameters
----------
Identifier : str
StartLine : int
StartSample : int
EndLine : int
EndSample : int
SegmentPolygon : SerializableArray|List[LSVertexType]|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.Identifier = Identifier
self.StartLine = StartLine
self.StartSample = StartSample
self.EndLine = EndLine
self.EndSample = EndSample
self.SegmentPolygon = SegmentPolygon
super(SegmentType, self).__init__(**kwargs)
class ParametersType(Serializable):
"""
Channel dependent parameters.
"""
_fields = (
'SRP_Index', 'NomTOARateSF', 'FxCtrNom', 'BWSavedNom', 'TOASavedNom',
'TxAnt_Index', 'RcvAnt_Index', 'TWAnt_Index')
_required = (
'SRP_Index', 'NomTOARateSF', 'FxCtrNom', 'BWSavedNom', 'TOASavedNom')
_numeric_format = {
'NomTOARateSF': '0.16G', 'FxCtrNom': '0.16G', 'BWSavedNom': '0.16G',
'TOASavedNom': '0.16G'}
# descriptors
SRP_Index = _IntegerDescriptor(
'SRP_Index', _required, strict=DEFAULT_STRICT,
docstring='Index to identify the SRP position function used for the '
'channel.') # type: int
NomTOARateSF = _FloatDescriptor(
'NomTOARateSF', _required, strict=DEFAULT_STRICT,
docstring='Scale factor to indicate the fraction of the Doppler spectrum '
'that is clear.') # type: float
FxCtrNom = _FloatDescriptor(
'FxCtrNom', _required, strict=DEFAULT_STRICT,
docstring='Nominal center transmit frequency associated with the channel (Hz). '
'For DomainType = TOA, FxCtrNom is the center frequency for all '
'vectors.') # type: float
BWSavedNom = _FloatDescriptor(
'BWSavedNom', _required, strict=DEFAULT_STRICT,
docstring='Nominal transmit bandwidth associated with the channel (Hz). '
'For DomainType = TOA, BWSavedNom is the bandwidth saved for all '
'vectors.') # type: float
TOASavedNom = _FloatDescriptor(
'TOASavedNom', _required, strict=DEFAULT_STRICT,
docstring='Nominal span in TOA saved for the channel. For DomainType = FX, '
'TOASavedNom is the bandwidth saved for all '
'vectors.') # type: float
TxAnt_Index = _IntegerDescriptor(
'TxAnt_Index', _required, strict=DEFAULT_STRICT,
docstring='Indicates the Transmit Antenna pattern for data collected to form '
'the CPHD channel.') # type: Union[None, int]
RcvAnt_Index = _IntegerDescriptor(
'RcvAnt_Index', _required, strict=DEFAULT_STRICT,
docstring='Indicates the Receive Antenna pattern for data collected to form '
'the CPHD channel.') # type: Union[None, int]
TWAnt_Index = _IntegerDescriptor(
'TWAnt_Index', _required, strict=DEFAULT_STRICT,
docstring='Indicates the T wo-way Antenna pattern for data collected to form '
'the CPHD channel.') # type: Union[None, int]
def __init__(self, SRP_Index=None, NomTOARateSF=None, FxCtrNom=None, BWSavedNom=None,
TOASavedNom=None, TxAnt_Index=None, RcvAnt_Index=None, TWAnt_Index=None,
**kwargs):
"""
Parameters
----------
SRP_Index : int
NomTOARateSF : float
FxCtrNom : float
BWSavedNom : float
TOASavedNom : float
TxAnt_Index : None|int
RcvAnt_Index : None|int
TWAnt_Index : 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.SRP_Index = SRP_Index
self.NomTOARateSF = NomTOARateSF
self.FxCtrNom = FxCtrNom
self.BWSavedNom = BWSavedNom
self.TOASavedNom = TOASavedNom
self.TxAnt_Index = TxAnt_Index
self.RcvAnt_Index = RcvAnt_Index
self.TWAnt_Index = TWAnt_Index
super(ParametersType, self).__init__(**kwargs)
