class GeographicCoordinateSystemType(Serializable):
"""
"""
_fields = ('Csname', 'Datum', 'PrimeMeridian', 'AngularUnit', 'LinearUnit')
_required = ('Csname', 'Datum', 'PrimeMeridian', 'AngularUnit')
# Descriptor
Csname = _StringDescriptor('Csname',
_required,
strict=DEFAULT_STRICT,
docstring='') # type: str
Datum = _SerializableDescriptor('Datum',
DatumType,
_required,
strict=DEFAULT_STRICT,
docstring='') # type: DatumType
PrimeMeridian = _SerializableDescriptor(
'PrimeMeridian',
PrimeMeridianType,
_required,
strict=DEFAULT_STRICT,
docstring='') # type: PrimeMeridianType
AngularUnit = _StringDescriptor('AngularUnit',
_required,
strict=DEFAULT_STRICT,
docstring='') # type: str
LinearUnit = _StringDescriptor('LinearUnit',
_required,
strict=DEFAULT_STRICT,
docstring='') # type: str
def __init__(self,
Csname=None,
Datum=None,
PrimeMeridian=None,
AngularUnit=None,
LinearUnit=None,
**kwargs):
"""
Parameters
----------
Csname : str
Datum : DatumType
PrimeMeridian : PrimeMeridianType
AngularUnit : str
LinearUnit : str
kwargs
"""
if '_xml_ns' in kwargs:
self._xml_ns = kwargs['_xml_ns']
if '_xml_ns_key' in kwargs:
self._xml_ns_key = kwargs['_xml_ns_key']
self.Csname = Csname
self.Datum = Datum
self.PrimeMeridian = PrimeMeridian
self.AngularUnit = AngularUnit
self.LinearUnit = LinearUnit
super(GeographicCoordinateSystemType, self).__init__(**kwargs)
class ProcessorInformationType(Serializable):
"""
Details regarding the processor.
"""
_fields = ('Application', 'ProcessingDateTime', 'Site', 'Profile')
_required = ('Application', 'ProcessingDateTime', 'Site')
# descriptors
Application = _StringDescriptor(
'Application',
_required,
strict=DEFAULT_STRICT,
docstring='Name and version of the application used to create the image.'
) # type: str
ProcessingDateTime = _DateTimeDescriptor(
'ProcessingDateTime',
_required,
strict=DEFAULT_STRICT,
numpy_datetime_units='us',
docstring=
'Date and time the image creation application processed the image (UTC).'
) # type: numpy.datetime64
Site = _StringDescriptor(
'Site',
_required,
strict=DEFAULT_STRICT,
docstring='The creation site of this SICD product.') # type: str
Profile = _StringDescriptor(
'Profile',
_required,
strict=DEFAULT_STRICT,
docstring='Identifies what profile was used to create this SICD product.'
) # type: str
def __init__(self,
Application=None,
ProcessingDateTime=None,
Site=None,
Profile=None,
**kwargs):
"""
Parameters
----------
Application : str
ProcessingDateTime : numpy.datetime64|datetime|date|str
Site : str
Profile : str
kwargs
"""
if '_xml_ns' in kwargs:
self._xml_ns = kwargs['_xml_ns']
if '_xml_ns_key' in kwargs:
self._xml_ns_key = kwargs['_xml_ns_key']
self.Application = Application
self.ProcessingDateTime = ProcessingDateTime
self.Site = Site
self.Profile = Profile
super(ProcessorInformationType, self).__init__(**kwargs)
class UserDefinedPVPType(Serializable):
"""
A user defined PVP structure.
"""
_fields = ('Name', 'Offset', 'Size', 'Format')
_required = _fields
# descriptors
Name = _StringDescriptor('Name',
_required,
strict=DEFAULT_STRICT,
docstring='') # type: str
Offset = _IntegerDescriptor('Offset',
_required,
strict=DEFAULT_STRICT,
bounds=(0, None),
docstring='') # type: int
Size = _IntegerDescriptor('Size',
_required,
strict=DEFAULT_STRICT,
bounds=(1, None),
docstring='') # type: int
Format = _StringDescriptor('Format',
_required,
strict=DEFAULT_STRICT,
docstring='') # type: str
def __init__(self,
Name=None,
Offset=None,
Size=None,
Format=None,
**kwargs):
"""
Parameters
----------
Name : str
Offset : int
Size : int
Format : str
kwargs
"""
if '_xml_ns' in kwargs:
self._xml_ns = kwargs['_xml_ns']
if '_xml_ns_key' in kwargs:
self._xml_ns_key = kwargs['_xml_ns_key']
self.Name = Name
self.Offset = Offset
self.Size = Size
self.Format = Format
super(UserDefinedPVPType, self).__init__(**kwargs)
class GainPhaseArrayType(Serializable):
"""
Parameters that identify 2-D sampled Gain & Phase patterns at single
frequency value.
"""
_fields = ('Freq', 'ArrayId', 'ElementId')
_required = ('Freq', 'ArrayId')
# descriptors
Freq = _FloatDescriptor(
'Freq',
_required,
strict=DEFAULT_STRICT,
bounds=(0, None),
docstring='Frequency value for which the sampled Array and Element '
'pattern(s) are provided, in Hz.') # type: float
ArrayId = _StringDescriptor(
'ArrayId',
_required,
strict=DEFAULT_STRICT,
docstring=
'Support array identifier of the sampled gain/phase of the array '
'at ref Frequency.') # type: str
ElementId = _StringDescriptor(
'ElementId',
_required,
strict=DEFAULT_STRICT,
docstring=
'Support array identifier of the sampled gain/phase of the element '
'at ref frequency.') # type: str
def __init__(self, Freq=None, ArrayId=None, ElementId=None, **kwargs):
"""
Parameters
----------
Freq : float
ArrayId : str
ElementId : None|str
kwargs
"""
if '_xml_ns' in kwargs:
self._xml_ns = kwargs['_xml_ns']
if '_xml_ns_key' in kwargs:
self._xml_ns_key = kwargs['_xml_ns_key']
self.Freq = Freq
self.ArrayId = ArrayId
self.ElementId = ElementId
super(GainPhaseArrayType, self).__init__(**kwargs)
class ParameterType(Serializable):
"""
The parameter type.
"""
_fields = ('ParameterName', 'Value')
_required = _fields
_numeric_format = {'Value': '0.16G'}
# Descriptor
ParameterName = _StringDescriptor(
'ParameterName', _required, strict=DEFAULT_STRICT,
docstring='') # type: str
Value = _FloatDescriptor(
'Value', _required, strict=DEFAULT_STRICT,
docstring='') # type: float
def __init__(self, ParameterName=None, Value=None, **kwargs):
"""
Parameters
----------
ParameterName : str
Value : float
kwargs
"""
if '_xml_ns' in kwargs:
self._xml_ns = kwargs['_xml_ns']
if '_xml_ns_key' in kwargs:
self._xml_ns_key = kwargs['_xml_ns_key']
self.ParameterName = ParameterName
self.Value = Value
super(ParameterType, self).__init__(**kwargs)
class ProjectionType(Serializable):
"""
The projection type.
"""
_fields = ('ProjectionName', )
_required = ('ProjectionName', )
# Descriptor
ProjectionName = _StringDescriptor(
'ProjectionName', _required, strict=DEFAULT_STRICT,
docstring='') # type: str
def __init__(self, ProjectionName=None, **kwargs):
"""
Parameters
----------
ProjectionName : str
kwargs
"""
if '_xml_ns' in kwargs:
self._xml_ns = kwargs['_xml_ns']
if '_xml_ns_key' in kwargs:
self._xml_ns_key = kwargs['_xml_ns_key']
self.ProjectionName = ProjectionName
super(ProjectionType, self).__init__(**kwargs)
class PrimeMeridianType(Serializable):
"""
The prime meridian location.
"""
_fields = ('Name', 'Longitude')
_required = _fields
_numeric_format = {'Longitude': '0.16G'}
# Descriptor
Name = _StringDescriptor(
'Name', _required, strict=DEFAULT_STRICT,
docstring='') # type: str
Longitude = _FloatDescriptor(
'Longitude', _required, strict=DEFAULT_STRICT,
docstring='') # type: float
def __init__(self, Name=None, Longitude=None, **kwargs):
"""
Parameters
----------
Name : str
Longitude : float
kwargs
"""
if '_xml_ns' in kwargs:
self._xml_ns = kwargs['_xml_ns']
if '_xml_ns_key' in kwargs:
self._xml_ns_key = kwargs['_xml_ns_key']
self.Name = Name
self.Longitude = Longitude
super(PrimeMeridianType, self).__init__(**kwargs)
class AntPhaseCenterType(Serializable):
"""
Parameters that describe each Antenna Phase Center (APC).
"""
_fields = ('Identifier', 'ACFId', 'APCXYZ')
_required = _fields
# descriptors
Identifier = _StringDescriptor(
'Identifier',
_required,
strict=DEFAULT_STRICT,
docstring='String that uniquely identifies this APC.') # type: str
ACFId = _StringDescriptor(
'ACFId',
_required,
strict=DEFAULT_STRICT,
docstring=
'Identifier of Antenna Coordinate Frame used for computing the '
'antenna gain and phase patterns.') # type: str
APCXYZ = _SerializableDescriptor(
'APCXYZ',
XYZType,
_required,
strict=DEFAULT_STRICT,
docstring='The APC location in the ACF XYZ coordinate '
'frame.') # type: XYZType
def __init__(self, Identifier=None, ACFId=None, APCXYZ=None, **kwargs):
"""
Parameters
----------
Identifier : str
ACFId : str
APCXYZ : XYZType|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.ACFId = ACFId
self.APCXYZ = APCXYZ
super(AntPhaseCenterType, self).__init__(**kwargs)
class ProjectedCoordinateSystemType(Serializable):
"""
"""
_fields = ('Csname', 'GeographicCoordinateSystem', 'Projection', 'Parameter', 'LinearUnit')
_required = ('Csname', 'GeographicCoordinateSystem', 'Projection', 'LinearUnit')
# Descriptor
Csname = _StringDescriptor(
'Csname', _required, strict=DEFAULT_STRICT,
docstring='') # type: str
GeographicCoordinateSystem = _SerializableDescriptor(
'GeographicCoordinateSystem', GeographicCoordinateSystemType, _required, strict=DEFAULT_STRICT,
docstring='') # type: GeographicCoordinateSystemType
Projection = _SerializableDescriptor(
'Projection', ProjectionType, _required, strict=DEFAULT_STRICT,
docstring='') # type: ProjectionType
Parameter = _SerializableDescriptor(
'Parameter', ParameterType, _required, strict=DEFAULT_STRICT,
docstring='') # type: Union[None, ParameterType]
LinearUnit = _StringDescriptor(
'LinearUnit', _required, strict=DEFAULT_STRICT,
docstring='') # type: str
def __init__(self, Csname=None, GeographicCoordinateSystem=None, Projection=None, Parameter=None,
LinearUnit=None, **kwargs):
"""
Parameters
----------
Csname : str
GeographicCoordinateSystem : GeographicCoordinateSystemType
Projection : ProjectionType
Parameter : None|ParameterType
LinearUnit : str
kwargs
"""
if '_xml_ns' in kwargs:
self._xml_ns = kwargs['_xml_ns']
if '_xml_ns_key' in kwargs:
self._xml_ns_key = kwargs['_xml_ns_key']
self.Csname = Csname
self.GeographicCoordinateSystem = GeographicCoordinateSystem
self.Projection = Projection
self.Parameter = Parameter
self.LinearUnit = LinearUnit
super(ProjectedCoordinateSystemType, self).__init__(**kwargs)
class CollectionIDType(CollectionInfoType):
"""
The CollectionID type definition.
"""
_fields = ('CollectorName', 'IlluminatorName', 'CoreName', 'CollectType',
'RadarMode', 'Classification', 'ReleaseInfo', 'Parameters',
'CountryCodes')
_required = ('CollectorName', 'CoreName', 'RadarMode', 'Classification',
'ReleaseInfo')
# descriptors
ReleaseInfo = _StringDescriptor(
'ReleaseInfo',
_required,
strict=DEFAULT_STRICT,
default_value='UNRESTRICTED',
docstring='The product release information.') # type: str
def __init__(self,
CollectorName=None,
IlluminatorName=None,
CoreName=None,
CollectType=None,
RadarMode=None,
Classification="UNCLASSIFIED",
ReleaseInfo='UNRESTRICTED',
CountryCodes=None,
Parameters=None,
**kwargs):
"""
Parameters
----------
CollectorName : str
IlluminatorName : str
CoreName : str
CollectType : str
RadarMode : RadarModeType
Classification : str
ReleaseInfo : str
CountryCodes : list|str
Parameters : ParametersCollection|dict
kwargs : dict
"""
if '_xml_ns' in kwargs:
self._xml_ns = kwargs['_xml_ns']
if '_xml_ns_key' in kwargs:
self._xml_ns_key = kwargs['_xml_ns_key']
self.ReleaseInfo = ReleaseInfo
super(CollectionIDType, self).__init__(CollectorName=CollectorName,
IlluminatorName=IlluminatorName,
CoreName=CoreName,
CollectType=CollectType,
RadarMode=RadarMode,
Classification=Classification,
CountryCodes=CountryCodes,
Parameters=Parameters,
**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)
def calculate_size(self):
"""
Calculates the size of the support array in bytes as described by the contained fields.
"""
return self.BytesPerElement * self.NumRows * self.NumCols
class AntCoordFrameType(Serializable):
"""
Unit vectors that describe the orientation of an Antenna Coordinate Frame
(ACF) as function of time.
"""
_fields = ('Identifier', 'XAxisPoly', 'YAxisPoly')
_required = _fields
# descriptors
Identifier = _StringDescriptor(
'Identifier',
_required,
strict=DEFAULT_STRICT,
docstring='String that uniquely identifies this ACF.') # type: str
XAxisPoly = _SerializableDescriptor(
'XAxisPoly',
XYZPolyType,
_required,
strict=DEFAULT_STRICT,
docstring='Antenna X-Axis unit vector in ECF coordinates as a function '
'of time.') # type: XYZPolyType
YAxisPoly = _SerializableDescriptor(
'YAxisPoly',
XYZPolyType,
_required,
strict=DEFAULT_STRICT,
docstring='Antenna Y-Axis unit vector in ECF coordinates as a function '
'of time.') # type: XYZPolyType
def __init__(self,
Identifier=None,
XAxisPoly=None,
YAxisPoly=None,
**kwargs):
"""
Parameters
----------
Identifier : str
XAxisPoly : XYZPolyType
YAxisPoly : XYZPolyType
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.XAxisPoly = XAxisPoly
self.YAxisPoly = YAxisPoly
super(AntCoordFrameType, self).__init__(**kwargs)
class ReferencePointType(Serializable):
"""
A reference point.
"""
_fields = ('ECEF', 'Point', 'name')
_required = ('ECEF', 'Point')
_set_as_attribute = ('name', )
_child_xml_ns_key = {'ECEF': 'sicommon', 'Point': 'sicommon'}
# Descriptor
ECEF = _SerializableDescriptor(
'ECEF',
XYZType,
_required,
strict=DEFAULT_STRICT,
docstring='The ECEF coordinates of the reference point.'
) # type: XYZType
Point = _SerializableDescriptor(
'Point',
RowColDoubleType,
_required,
strict=DEFAULT_STRICT,
docstring='The pixel coordinates of the reference point.'
) # type: RowColDoubleType
name = _StringDescriptor(
'name',
_required,
strict=DEFAULT_STRICT,
docstring=
'Used for implementation specific signifier for the reference point.'
) # type: Union[None, str]
def __init__(self, ECEF=None, Point=None, name=None, **kwargs):
"""
Parameters
----------
ECEF : XYZType|numpy.ndarray|list|tuple
Point : RowColDoubleType|numpy.ndarray|list|tuple
name : None|str
kwargs
"""
if '_xml_ns' in kwargs:
self._xml_ns = kwargs['_xml_ns']
if '_xml_ns_key' in kwargs:
self._xml_ns_key = kwargs['_xml_ns_key']
self.ECEF = ECEF
self.Point = Point
self.name = name
super(ReferencePointType, self).__init__(**kwargs)
class DwellTimesType(Serializable):
"""
COD Time and Dwell Time polynomials over the image area.
"""
_fields = ('CODId', 'DwellId')
_required = _fields
# descriptors
CODId = _StringDescriptor(
'CODId',
_required,
strict=DEFAULT_STRICT,
docstring='Identifier of the Center of Dwell Time polynomial that maps '
'reference surface position to COD time.') # type: str
DwellId = _StringDescriptor(
'DwellId',
_required,
strict=DEFAULT_STRICT,
docstring='Identifier of the Dwell Time polynomial that maps reference '
'surface position to dwell time.') # type: str
def __init__(self, CODId=None, DwellId=None, **kwargs):
"""
Parameters
----------
CODId : str
DwellId : str
kwargs
"""
if '_xml_ns' in kwargs:
self._xml_ns = kwargs['_xml_ns']
if '_xml_ns_key' in kwargs:
self._xml_ns_key = kwargs['_xml_ns_key']
self.CODId = CODId
self.DwellId = DwellId
super(DwellTimesType, self).__init__(**kwargs)
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 PredefinedLookupType(Serializable):
"""
The predefined lookup table type. Allows for reference **either** by name, or family/member id number.
"""
_fields = ('DatabaseName', 'RemapFamily', 'RemapMember')
_required = ()
# Descriptor
DatabaseName = _StringDescriptor(
'DatabaseName',
_required,
strict=DEFAULT_STRICT,
docstring='Database name of LUT to use.') # type: str
RemapFamily = _IntegerDescriptor(
'RemapFamily',
_required,
strict=DEFAULT_STRICT,
docstring='The lookup family number.') # type: int
RemapMember = _IntegerDescriptor(
'RemapMember',
_required,
strict=DEFAULT_STRICT,
docstring='The lookup member number.') # type: int
def __init__(self,
DatabaseName=None,
RemapFamily=None,
RemapMember=None,
**kwargs):
"""
Parameters
----------
DatabaseName : None|str
RemapFamily : None|int
RemapMember : None|int
kwargs
"""
if '_xml_ns' in kwargs:
self._xml_ns = kwargs['_xml_ns']
if '_xml_ns_key' in kwargs:
self._xml_ns_key = kwargs['_xml_ns_key']
self.DatabaseName = DatabaseName
self.RemapFamily = RemapFamily
self.RemapMember = RemapMember
super(PredefinedLookupType, self).__init__(**kwargs)
class NewLookupTableType(Serializable):
"""
The lookup table. Allows **either** a reference to a prefined lookup table, or
custom lookup table array.
"""
_fields = ('LUTName', 'Predefined', 'Custom')
_required = ('LUTName', )
_choice = ({'required': True, 'collection': ('Predefined', 'Custom')}, )
# Descriptor
LUTName = _StringDescriptor('LUTName',
_required,
strict=DEFAULT_STRICT,
docstring='The lookup table name') # type: str
Predefined = _SerializableDescriptor(
'Predefined',
PredefinedLookupType,
_required,
strict=DEFAULT_STRICT,
docstring='') # type: PredefinedLookupType
Custom = _SerializableDescriptor('Custom',
CustomLookupType,
_required,
strict=DEFAULT_STRICT,
docstring='') # type: CustomLookupType
def __init__(self, LUTName=None, Predefined=None, Custom=None, **kwargs):
"""
Parameters
----------
LUTName : str
Predefined : None|PredefinedLookupType
Custom : None|CustomLookupType
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.LUTName = LUTName
self.Predefined = Predefined
self.Custom = Custom
super(NewLookupTableType, self).__init__(**kwargs)
class SpheroidType(Serializable):
"""
"""
_fields = ('SpheroidName', 'SemiMajorAxis', 'InverseFlattening')
_required = _fields
_numeric_format = {'SemiMajorAxis': '0.16G', 'InverseFlattening': '0.16G'}
# Descriptor
SpheroidName = _StringDescriptor('SpheroidName',
_required,
strict=DEFAULT_STRICT,
docstring='') # type: str
SemiMajorAxis = _FloatDescriptor('SemiMajorAxis',
_required,
strict=DEFAULT_STRICT,
docstring='') # type: float
InverseFlattening = _FloatDescriptor('InverseFlattening',
_required,
strict=DEFAULT_STRICT,
docstring='') # type: float
def __init__(self,
SpheroidName=None,
SemiMajorAxis=None,
InverseFlattening=None,
**kwargs):
"""
Parameters
----------
SpheroidName : str
SemiMajorAxis : float
InverseFlattening : float
kwargs
"""
if '_xml_ns' in kwargs:
self._xml_ns = kwargs['_xml_ns']
if '_xml_ns_key' in kwargs:
self._xml_ns_key = kwargs['_xml_ns_key']
self.SpheroidName = SpheroidName
self.SemiMajorAxis = SemiMajorAxis
self.InverseFlattening = InverseFlattening
super(SpheroidType, self).__init__(**kwargs)
class GeographicInformationType(Serializable):
"""
Geographic information.
"""
_fields = ('CountryCodes', 'SecurityInfo', 'GeographicInfoExtensions')
_required = ()
_collections_tags = {
'CountryCodes': {'array': False, 'child_tag': 'CountryCode'},
'GeographicInfoExtensions': {'array': False, 'child_tag': 'GeographicInfoExtension'}}
# descriptors
CountryCodes = _StringListDescriptor(
'CountryCodes', _required, strict=DEFAULT_STRICT,
docstring="List of country codes for region covered by the image.") # type: List[str]
SecurityInfo = _StringDescriptor(
'SecurityInfo', _required, strict=DEFAULT_STRICT,
docstring='Specifies classification level or special handling designators '
'for this geographic region.') # type: Union[None, str]
GeographicInfoExtensions = _ParametersDescriptor(
'GeographicInfoExtensions', _collections_tags, _required, strict=DEFAULT_STRICT,
docstring='Implementation specific geographic information.') # type: ParametersCollection
def __init__(self, CountryCodes=None, SecurityInfo=None, GeographicInfoExtensions=None, **kwargs):
"""
Parameters
----------
CountryCodes : None|List[str]
SecurityInfo : None|str
GeographicInfoExtensions : None|ParametersCollection|dict
kwargs : dict
"""
if '_xml_ns' in kwargs:
self._xml_ns = kwargs['_xml_ns']
if '_xml_ns_key' in kwargs:
self._xml_ns_key = kwargs['_xml_ns_key']
self.CountryCodes = CountryCodes
self.SecurityInfo = SecurityInfo
self.GeographicInfoExtensions = GeographicInfoExtensions
super(GeographicInformationType, self).__init__(**kwargs)
class CODTimeType(Serializable):
"""
Center of Dwell (COD) time polynomial object.
"""
_fields = ('Identifier', 'CODTimePoly')
_required = _fields
# descriptors
Identifier = _StringDescriptor(
'Identifier',
_required,
strict=DEFAULT_STRICT,
docstring='String that uniquely identifies this COD Time '
'polynomial.') # type: str
CODTimePoly = _SerializableDescriptor(
'CODTimePoly',
Poly2DType,
_required,
strict=DEFAULT_STRICT,
docstring='The polynomial.') # type: Poly2DType
def __init__(self, Identifier=None, CODTimePoly=None, **kwargs):
"""
Parameters
----------
Identifier : str
CODTimePoly : Poly2DType|numpy.ndarray|list|tuple
kwargs
"""
if '_xml_ns' in kwargs:
self._xml_ns = kwargs['_xml_ns']
if '_xml_ns_key' in kwargs:
self._xml_ns_key = kwargs['_xml_ns_key']
self.Identifier = Identifier
self.CODTimePoly = CODTimePoly
super(CODTimeType, 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 CollectionType(Serializable):
"""
Metadata regarding one of the input collections.
"""
_fields = ('Information', 'Geometry', 'Phenomenology', 'identifier')
_required = ('Information', 'identifier')
_set_as_attribute = ('identifier', )
# Descriptor
Information = _SerializableDescriptor(
'Information',
ExploitationFeaturesCollectionInformationType,
_required,
strict=DEFAULT_STRICT,
docstring='General collection information.'
) # type: ExploitationFeaturesCollectionInformationType
Geometry = _SerializableDescriptor(
'Geometry',
ExploitationFeaturesCollectionGeometryType,
_required,
strict=DEFAULT_STRICT,
docstring='Key geometry parameters independent of product '
'processing.'
) # type: Union[None, ExploitationFeaturesCollectionGeometryType]
Phenomenology = _SerializableDescriptor(
'Phenomenology',
ExploitationFeaturesCollectionPhenomenologyType,
_required,
strict=DEFAULT_STRICT,
docstring='Phenomenology related to both the geometry and the final '
'product processing.'
) # type: Union[None, ExploitationFeaturesCollectionPhenomenologyType]
identifier = _StringDescriptor(
'identifier',
_required,
strict=DEFAULT_STRICT,
docstring='The exploitation feature identifier.') # type: str
def __init__(self,
Information=None,
Geometry=None,
Phenomenology=None,
identifier=None,
**kwargs):
"""
Parameters
----------
Information : ExploitationFeaturesCollectionInformationType
Geometry : None|ExploitationFeaturesCollectionGeometryType
Phenomenology : None|ExploitationFeaturesCollectionPhenomenologyType
identifier : str
kwargs
"""
if '_xml_ns' in kwargs:
self._xml_ns = kwargs['_xml_ns']
if '_xml_ns_key' in kwargs:
self._xml_ns_key = kwargs['_xml_ns_key']
self.Information = Information
self.Geometry = Geometry
self.Phenomenology = Phenomenology
self.identifier = identifier
super(CollectionType, self).__init__(**kwargs)
@classmethod
def from_calculator(cls, calculator, sicd):
"""
Create from an ExploitationCalculator object.
Parameters
----------
calculator : ExploitationCalculator
sicd : SICDType
Returns
-------
CollectionType
"""
if not isinstance(calculator, ExploitationCalculator):
raise TypeError(
'Requires input which is an instance of ExploitationCalculator, got type {}'
.format(type(calculator)))
return cls(
identifier=sicd.CollectionInfo.CoreName,
Information=ExploitationFeaturesCollectionInformationType.
from_sicd(sicd),
Geometry=ExploitationFeaturesCollectionGeometryType.
from_calculator(calculator),
Phenomenology=ExploitationFeaturesCollectionPhenomenologyType.
from_calculator(calculator))
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 CreationInfoType(Serializable):
"""
Parameters that provide general information about the CPHD product generation.
"""
_fields = ('Application', 'DateTime', 'Site', 'Parameters')
_required = ('DateTime', )
_collections_tags = {
'Parameters': {
'array': False,
'child_tag': 'Parameter'
}
}
# descriptors
Application = _StringDescriptor(
'Application',
_required,
strict=DEFAULT_STRICT,
docstring='Name and version of the application used to create the CPHD.'
) # type: str
DateTime = _DateTimeDescriptor(
'DateTime',
_required,
strict=DEFAULT_STRICT,
numpy_datetime_units='us',
docstring=
'Date and time the image creation application processed the image (UTC).'
) # type: numpy.datetime64
Site = _StringDescriptor(
'Site',
_required,
strict=DEFAULT_STRICT,
docstring='The creation site of this CPHD product.') # type: str
Parameters = _ParametersDescriptor(
'Parameters',
_collections_tags,
_required,
strict=DEFAULT_STRICT,
docstring='Additional parameters.'
) # type: Union[None, ParametersCollection]
def __init__(self,
Application=None,
DateTime=None,
Site=None,
Parameters=None,
**kwargs):
"""
Parameters
----------
Application : str
DateTime : numpy.datetime64|datetime|date|str
Site : str
Profile : str
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.Application = Application
self.DateTime = DateTime
self.Site = Site
self.Parameters = Parameters
super(CreationInfoType, self).__init__(**kwargs)
class AddedSupportArrayType(SupportArrayCore):
"""
Additional arrays (two-dimensional), where the content and format and units
of each element are user defined.
"""
_fields = ('Identifier', 'ElementFormat', 'X0', 'Y0', 'XSS', 'YSS',
'NODATA', 'XUnits', 'YUnits', 'ZUnits', 'Parameters')
_required = ('Identifier', 'ElementFormat', 'X0', 'Y0', 'XSS', 'YSS',
'XUnits', 'YUnits', 'ZUnits')
_collections_tags = {
'Parameters': {
'array': False,
'child_tag': 'Parameter'
}
}
# descriptors
XUnits = _StringDescriptor('XUnits',
_required,
strict=DEFAULT_STRICT,
docstring='The X units.') # type: str
YUnits = _StringDescriptor('YUnits',
_required,
strict=DEFAULT_STRICT,
docstring='The Y units.') # type: str
ZUnits = _StringDescriptor('ZUnits',
_required,
strict=DEFAULT_STRICT,
docstring='The Z units.') # type: str
Parameters = _ParametersDescriptor(
'Parameters',
_collections_tags,
_required,
strict=DEFAULT_STRICT,
docstring='Other necessary free-form parameters.'
) # type: Union[None, ParametersCollection]
def __init__(self,
Identifier=None,
ElementFormat=None,
X0=None,
Y0=None,
XSS=None,
YSS=None,
NODATA=None,
XUnits=None,
YUnits=None,
ZUnits=None,
Parameters=None,
**kwargs):
"""
Parameters
----------
Identifier : str
ElementFormat : str
X0 : float
Y0 : float
XSS : float
YSS : float
NODATA : str
XUnits : str
YUnits : str
ZUnits : str
Parameters : ParametersCollection|dict
kwargs
"""
if '_xml_ns' in kwargs:
self._xml_ns = kwargs['_xml_ns']
if '_xml_ns_key' in kwargs:
self._xml_ns_key = kwargs['_xml_ns_key']
self.XUnits = XUnits
self.YUnits = YUnits
self.ZUnits = ZUnits
self.Parameters = Parameters
super(AddedSupportArrayType,
self).__init__(Identifier=Identifier,
ElementFormat=ElementFormat,
X0=X0,
Y0=Y0,
XSS=XSS,
YSS=YSS,
NODATA=NODATA,
**kwargs)
class SupportArrayCore(Serializable):
"""
The support array base case.
"""
_fields = ('Identifier', 'ElementFormat', 'X0', 'Y0', 'XSS', 'YSS',
'NODATA')
_required = ('Identifier', 'ElementFormat', 'X0', 'Y0', 'XSS', 'YSS')
_numeric_format = {
'X0': '0.16G',
'Y0': '0.16G',
'XSS': '0.16G',
'YSS': '0.16G'
}
# descriptors
Identifier = _StringDescriptor(
'Identifier',
_required,
strict=DEFAULT_STRICT,
docstring='The support array identifier.') # type: str
ElementFormat = _StringDescriptor(
'ElementFormat',
_required,
strict=DEFAULT_STRICT,
docstring='The data element format.') # type: str
X0 = _FloatDescriptor('X0', _required, strict=DEFAULT_STRICT,
docstring='') # type: float
Y0 = _FloatDescriptor('Y0', _required, strict=DEFAULT_STRICT,
docstring='') # type: float
XSS = _FloatDescriptor('XSS',
_required,
strict=DEFAULT_STRICT,
bounds=(0, None),
docstring='') # type: float
YSS = _FloatDescriptor('YSS',
_required,
strict=DEFAULT_STRICT,
bounds=(0, None),
docstring='') # type: float
def __init__(self,
Identifier=None,
ElementFormat=None,
X0=None,
Y0=None,
XSS=None,
YSS=None,
NODATA=None,
**kwargs):
"""
Parameters
----------
Identifier : str
ElementFormat : str
X0 : float
Y0 : float
XSS : float
YSS : float
NODATA : None|str
kwargs
"""
self._NODATA = 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.Identifier = Identifier
self.ElementFormat = ElementFormat
self.X0 = X0
self.Y0 = Y0
self.XSS = XSS
self.YSS = YSS
self.NODATA = NODATA
super(SupportArrayCore, self).__init__(**kwargs)
@property
def NODATA(self):
"""
None|str: The no data hex string value.
"""
return self._NODATA
@NODATA.setter
def NODATA(self, value):
if value is None:
self._NODATA = None
return
if isinstance(value, ElementTree.Element):
value = _get_node_value(value)
if isinstance(value, string_types):
self._NODATA = value
elif isinstance(value, bytes):
self._NODATA = value.decode('utf-8')
elif isinstance(value, int):
raise NotImplementedError
elif isinstance(value, float):
raise NotImplementedError
else:
raise TypeError('Got unexpected type {}'.format(type(value)))
def get_nodata_as_int(self):
"""
Get the no data value as an integer value.
Returns
-------
None|int
"""
if self._NODATA is None:
return None
raise NotImplementedError
def get_nodata_as_float(self):
"""
Gets the no data value as a floating point value.
Returns
-------
None|float
"""
if self._NODATA is None:
return None
raise NotImplementedError
def get_numpy_format(self):
"""
Convert the element format to a numpy dtype (including endianness) and depth.
Returns
-------
numpy.dtype, int
"""
return homogeneous_dtype(self.ElementFormat, return_length=True)
class ColorManagementModuleType(Serializable):
"""
Parameters describing the Color Management Module (CMM).
"""
_fields = ('RenderingIntent', 'SourceProfile', 'DisplayProfile',
'ICCProfile')
_required = _fields
# Descriptor
RenderingIntent = _StringEnumDescriptor(
'RenderingIntent',
('PERCEPTUAL', 'SATURATION', 'RELATIVE INTENT', 'ABSOLUTE INTENT'),
_required,
strict=DEFAULT_STRICT,
default_value='PERCEPTUAL',
docstring='The rendering intent for this color management.'
) # type: str
SourceProfile = _StringDescriptor(
'SourceProfile',
_required,
strict=DEFAULT_STRICT,
docstring='Name of sensor profile in ICC Profile database.'
) # type: str
DisplayProfile = _StringDescriptor(
'DisplayProfile',
_required,
strict=DEFAULT_STRICT,
docstring='Name of display profile in ICC Profile database.'
) # type: str
ICCProfile = _StringDescriptor(
'ICCProfile',
_required,
strict=DEFAULT_STRICT,
docstring='Valid ICC profile signature.') # type: str
def __init__(self,
RenderingIntent='PERCEPTUAL',
SourceProfile=None,
DisplayProfile=None,
ICCProfile=None,
**kwargs):
"""
Parameters
----------
RenderingIntent : str
SourceProfile : str
DisplayProfile : str
ICCProfile : str
kwargs
"""
if '_xml_ns' in kwargs:
self._xml_ns = kwargs['_xml_ns']
if '_xml_ns_key' in kwargs:
self._xml_ns_key = kwargs['_xml_ns_key']
self.RenderingIntent = RenderingIntent
self.SourceProfile = SourceProfile
self.DisplayProfile = DisplayProfile
self.ICCProfile = ICCProfile
super(ColorManagementModuleType, self).__init__(**kwargs)
class 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 ImageGridType(Serializable):
"""
Parameters that describe a geo-referenced image grid for image data products
that may be formed from the CPHD signal array(s).
"""
_fields = ('Identifier', 'IARPLocation', 'IAXExtent', 'IAYExtent',
'SegmentList')
_required = ('IARPLocation', 'IAXExtent', 'IAYExtent')
_collections_tags = {
'SegmentList': {
'array': True,
'child_tag': 'Segemnt'
}
}
# descriptors
Identifier = _StringDescriptor(
'Identifier',
_required,
strict=DEFAULT_STRICT,
docstring='String that uniquely identifies the Image Grid.'
) # type: Union[None, str]
IARPLocation = _SerializableDescriptor(
'IARPLocation',
LSType,
_required,
strict=DEFAULT_STRICT,
docstring=
'IARP grid location. Grid locations indexed by (line, sample) or (L,S). '
'Image grid line and sample are pixel-centered indices.'
) # type: LSType
IAXExtent = _SerializableDescriptor(
'IAXExtent',
IAXExtentType,
_required,
strict=DEFAULT_STRICT,
docstring='Increasing line index is in the +IAX direction.'
) # type: IAXExtentType
IAYExtent = _SerializableDescriptor(
'IAYExtent',
IAYExtentType,
_required,
strict=DEFAULT_STRICT,
docstring='Increasing sample index is in the +IAY direction.'
) # type: IAYExtentType
SegmentList = _SerializableArrayDescriptor(
'SegmentList',
SegmentType,
_collections_tags,
_required,
strict=DEFAULT_STRICT,
array_extension=SegmentListType,
docstring='List of image grid segments defined relative to the image '
'grid.') # type: Union[SegmentListType, List[SegmentType]]
def __init__(self,
Identifier=None,
IARPLocation=None,
IAXExtent=None,
IAYExtent=None,
SegmentList=None,
**kwargs):
"""
Parameters
----------
Identifier : None|str
IARPLocation : LSType
IAXExtent : IAXExtentType
IAYExtent : IAYExtentType
SegmentList : SegmentListType|List[SegmentType]|numpy.array|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.IARPLocation = IARPLocation
self.IAXExtent = IAXExtent
self.IAYExtent = IAYExtent
self.SegmentList = SegmentList
super(ImageGridType, 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)
