class DwellTimeType(Serializable): """ The dwell time object. """ _fields = ('DwellTimePoly', 'CODTimePoly') _required = _fields # descriptors DwellTimePoly = _SerializableDescriptor( 'DwellTimePoly', Poly2DType, _required, strict=DEFAULT_STRICT, docstring='The dwell time polynomial.') # type: Poly2DType CODTimePoly = _SerializableDescriptor( 'CODTimePoly', Poly2DType, _required, strict=DEFAULT_STRICT, docstring='The cod time polynomial.') # type: Poly2DType def __init__(self, DwellTimePoly=None, CODTimePoly=None, **kwargs): """ Parameters ---------- DwellTimePoly : Poly2DType|numpy.ndarray|list|tuple 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.DwellTimePoly = DwellTimePoly self.CODTimePoly = CODTimePoly super(DwellTimeType, self).__init__(**kwargs)
class InputROIType(Serializable): """ ROI representing portion of input data used to make this product. """ _fields = ('Size', 'UpperLeft') _required = ('Size', 'UpperLeft') # Descriptor Size = _SerializableDescriptor( 'Size', RowColIntType, _required, strict=DEFAULT_STRICT, docstring='Number of rows and columns extracted from the input.') # type: RowColIntType UpperLeft = _SerializableDescriptor( 'UpperLeft', RowColIntType, _required, strict=DEFAULT_STRICT, docstring='The upper-left pixel extracted from the input.') # type: RowColIntType def __init__(self, Size=None, UpperLeft=None, **kwargs): """ Parameters ---------- Size : RowColIntType|numpy.ndarray|list|tuple UpperLeft : RowColIntType|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.Size = Size self.UpperLeft = UpperLeft super(InputROIType, self).__init__(**kwargs)
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 J2KType(Serializable): """ Jpeg 2000 parameters. """ _fields = ('Original', 'Parsed') _required = ('Original', ) # Descriptor Original = _SerializableDescriptor('Original', J2KSubtype, _required, strict=DEFAULT_STRICT, docstring='') # type: J2KSubtype Parsed = _SerializableDescriptor( 'Parsed', J2KSubtype, _required, strict=DEFAULT_STRICT, docstring='Conditional fields that exist only for parsed images.' ) # type: Union[None, J2KSubtype] def __init__(self, Original=None, Parsed=None, **kwargs): if '_xml_ns' in kwargs: self._xml_ns = kwargs['_xml_ns'] if '_xml_ns_key' in kwargs: self._xml_ns_key = kwargs['_xml_ns_key'] self.Original = Original self.Parsed = Parsed super(J2KType, self).__init__(**kwargs)
class BistaticType(Serializable): """ Error parameters for bistatic parameters. """ _fields = ('TxPlatform', 'RcvPlatform', 'AddedParameters') _required = ('TxPlatform', ) _collections_tags = { 'AddedParameters': { 'array': False, 'child_tag': 'Parameter' } } # descriptors TxPlatform = _SerializableDescriptor( 'TxPlatform', PlatformType, _required, strict=DEFAULT_STRICT, docstring='Error statistics for the transmit platform.' ) # type: PlatformType RcvPlatform = _SerializableDescriptor( 'RcvPlatform', PlatformType, _required, strict=DEFAULT_STRICT, docstring='Error statistics for the receive platform.' ) # type: PlatformType AddedParameters = _ParametersDescriptor( 'AddedParameters', _collections_tags, _required, strict=DEFAULT_STRICT, docstring='Additional error parameters.') # type: ParametersCollection def __init__(self, TxPlatform=None, RcvPlatform=None, AddedParameters=None, **kwargs): """ Parameters ---------- TxPlatform : PlatformType RcvPlatform : PlatformType AddedParameters : 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.TxPlatform = TxPlatform self.RcvPlatform = RcvPlatform self.AddedParameters = AddedParameters super(BistaticType, self).__init__(**kwargs)
class ProductGenerationOptionsType(Serializable): """ """ _fields = ('BandEqualization', 'ModularTransferFunctionRestoration', 'DataRemapping', 'AsymmetricPixelCorrection') _required = ('DataRemapping', ) # Descriptor BandEqualization = _SerializableDescriptor( 'BandEqualization', BandEqualizationType, _required, strict=DEFAULT_STRICT, docstring= 'Band equalization ensures that real-world neutral colors have equal digital count values ' '(i.e. are represented as neutral colors) across the dynamic range ' 'of the imaged scene.') # type: BandEqualizationType ModularTransferFunctionRestoration = _SerializableDescriptor( 'ModularTransferFunctionRestoration', FilterType, _required, strict=DEFAULT_STRICT, docstring=r'If present, the filter must not exceed :math:`15 \times 15`.' ) # type: FilterType DataRemapping = _SerializableDescriptor( 'DataRemapping', NewLookupTableType, _required, strict=DEFAULT_STRICT, docstring= 'Data remapping refers to the specific need to convert the data of incoming, expanded or ' 'uncompressed image band data to non-mapped image data.' ) # type: NewLookupTableType AsymmetricPixelCorrection = _SerializableDescriptor( 'AsymmetricPixelCorrection', FilterType, _required, strict=DEFAULT_STRICT, docstring='The asymmetric pixel correction.') # type: FilterType def __init__(self, BandEqualization=None, ModularTransferFunctionRestoration=None, DataRemapping=None, **kwargs): if '_xml_ns' in kwargs: self._xml_ns = kwargs['_xml_ns'] if '_xml_ns_key' in kwargs: self._xml_ns_key = kwargs['_xml_ns_key'] self.BandEqualization = BandEqualization self.ModularTransferFunctionRestoration = ModularTransferFunctionRestoration self.DataRemapping = DataRemapping super(ProductGenerationOptionsType, self).__init__(**kwargs)
class RRDSType(Serializable): """ RRDS type. """ _fields = ('DownsamplingMethod', 'AntiAlias', 'Interpolation') _required = ('DownsamplingMethod', ) # Descriptor DownsamplingMethod = _StringEnumDescriptor( 'DownsamplingMethod', ('DECIMATE', 'MAX PIXEL', 'AVERAGE', 'NEAREST NEIGHBOR', 'BILINEAR', 'LAGRANGE'), _required, strict=DEFAULT_STRICT, docstring='Algorithm used to perform RRDS downsampling') # type: str AntiAlias = _SerializableDescriptor( 'AntiAlias', FilterType, _required, strict=DEFAULT_STRICT, docstring='The anti-aliasing filter. Should only be included if ' '`DownsamplingMethod= "DECIMATE"`') # type: FilterType Interpolation = _SerializableDescriptor( 'Interpolation', FilterType, _required, strict=DEFAULT_STRICT, docstring='The interpolation filter. Should only be included if ' '`DownsamplingMethod= "DECIMATE"`') # type: FilterType def __init__(self, DownsamplingMethod=None, AntiAlias=None, Interpolation=None, **kwargs): """ Parameters ---------- DownsamplingMethod : str AntiAlias : None|FilterType Interpolation : None|FilterType kwargs """ if '_xml_ns' in kwargs: self._xml_ns = kwargs['_xml_ns'] if '_xml_ns_key' in kwargs: self._xml_ns_key = kwargs['_xml_ns_key'] self.DownsamplingMethod = DownsamplingMethod self.AntiAlias = AntiAlias self.Interpolation = Interpolation super(RRDSType, self).__init__(**kwargs)
class 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 AreaType(Serializable): """ An area object. """ _fields = ('X1Y1', 'X2Y2', 'Polygon') _required = _fields _collections_tags = {'Polygon': {'array': True, 'child_tag': 'Vertex'}} # descriptors X1Y1 = _SerializableDescriptor( 'X1Y1', XYType, _required, strict=DEFAULT_STRICT, docstring='*"Minimum"* corner of the rectangle in Image ' 'coordinates.') # type: XYType X2Y2 = _SerializableDescriptor( 'X2Y2', XYType, _required, strict=DEFAULT_STRICT, docstring='*"Maximum"* corner of the rectangle in Image ' 'coordinates.') # type: XYType Polygon = _SerializableArrayDescriptor( 'Polygon', XYVertexType, _collections_tags, _required, strict=DEFAULT_STRICT, minimum_length=3, docstring='Polygon further reducing the bounding box, in Image ' 'coordinates.') # type: Union[SerializableArray, List[XYVertexType]] def __init__(self, X1Y1=None, X2Y2=None, Polygon=None, **kwargs): """ Parameters ---------- X1Y1 : XYType|numpy.ndarray|list|tuple X2Y2 : XYType|numpy.ndarray|list|tuple Polygon : SerializableArray|List[XYVertexType]|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.X1Y1 = X1Y1 self.X2Y2 = X2Y2 self.Polygon = Polygon super(AreaType, self).__init__(**kwargs)
class SharpnessEnhancementType(Serializable): """ Sharpness enhancement filter parameters. """ _fields = ('ModularTransferFunctionCompensation', 'ModularTransferFunctionEnhancement') _required = _fields _choice = ({ 'required': True, 'collection': ('ModularTransferFunctionCompensation', 'ModularTransferFunctionEnhancement') }, ) # Descriptor ModularTransferFunctionCompensation = _SerializableDescriptor( 'ModularTransferFunctionCompensation', FilterType, _required, strict=DEFAULT_STRICT, docstring= r'If defining a custom Filter, it must be no larger than :math:`5\times 5`.' ) # type: FilterType ModularTransferFunctionEnhancement = _SerializableDescriptor( 'ModularTransferFunctionEnhancement', FilterType, _required, strict=DEFAULT_STRICT, docstring= r'If defining a custom Filter, it must be no larger than :math:`5\times 5`.' ) # type: FilterType def __init__(self, ModularTransferFunctionCompensation=None, ModularTransferFunctionEnhancement=None, **kwargs): """ Parameters ---------- ModularTransferFunctionCompensation : FilterType ModularTransferFunctionEnhancement : FilterType kwargs """ if '_xml_ns' in kwargs: self._xml_ns = kwargs['_xml_ns'] if '_xml_ns_key' in kwargs: self._xml_ns_key = kwargs['_xml_ns_key'] self.ModularTransferFunctionCompensation = ModularTransferFunctionCompensation self.ModularTransferFunctionEnhancement = ModularTransferFunctionEnhancement super(SharpnessEnhancementType, 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 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 GeographicAndTargetType(Serializable): """ Container specifying the image coverage area in geographic coordinates, as well as optional data about the target of the collection/product. """ _fields = ('GeographicCoverage', 'TargetInformations') _required = ('GeographicCoverage', ) _collections_tags = {'TargetInformations': {'array': False, 'child_tag': 'TargetInformation'}} # Descriptors GeographicCoverage = _SerializableDescriptor( 'GeographicCoverage', GeographicCoverageType, _required, strict=DEFAULT_STRICT, docstring='Provides geographic coverage information.') # type: GeographicCoverageType TargetInformations = _SerializableListDescriptor( 'TargetInformations', TargetInformationType, _collections_tags, _required, strict=DEFAULT_STRICT, docstring='Provides target specific geographic ' 'information.') # type: Union[None, List[TargetInformationType]] def __init__(self, GeographicCoverage=None, TargetInformations=None, **kwargs): """ Parameters ---------- GeographicCoverage : GeographicCoverageType TargetInformations : None|List[TargetInformationType] kwargs """ if '_xml_ns' in kwargs: self._xml_ns = kwargs['_xml_ns'] if '_xml_ns_key' in kwargs: self._xml_ns_key = kwargs['_xml_ns_key'] self.GeographicCoverage = GeographicCoverage self.TargetInformations = TargetInformations super(GeographicAndTargetType, self).__init__(**kwargs)
class ImageAreaType(Serializable): """ The collection area. """ _fields = ('Corner', 'Plane') _required = ('Corner', ) _collections_tags = { 'Corner': {'array': True, 'child_tag': 'ACP'}, } # descriptors Corner = _SerializableCPArrayDescriptor( 'Corner', LatLonHAECornerRestrictionType, _collections_tags, _required, strict=DEFAULT_STRICT, docstring='The collection area corner point definition array.' ) # type: Union[SerializableCPArray, List[LatLonHAECornerRestrictionType]] Plane = _SerializableDescriptor( 'Plane', PlaneType, _required, strict=DEFAULT_STRICT, docstring='A rectangular area in a geo-located display plane.') # type: PlaneType def __init__(self, Corner=None, Plane=None, **kwargs): """ Parameters ---------- Corner : SerializableCPArray|List[LatLonHAECornerRestrictionType]|numpy.ndarray|list|tuple Plane : PlaneType 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.Corner = Corner self.Plane = Plane super(ImageAreaType, self).__init__(**kwargs)
class CompressionType(Serializable): """ Contains information regarding any compression that has occurred to the image data. """ _fields = ('J2K', ) _required = ('J2K', ) # Descriptor J2K = _SerializableDescriptor( 'J2K', J2KType, _required, strict=DEFAULT_STRICT, docstring='Block describing details of JPEG 2000 compression.') # type: J2KType def __init__(self, J2K=None, **kwargs): """ Parameters ---------- J2K : J2KType 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.J2K = J2K super(CompressionType, self).__init__(**kwargs)
class CustomLookupType(Serializable): """ A custom lookup table. """ _fields = ('LUTInfo', ) _required = ('LUTInfo', ) # Descriptor LUTInfo = _SerializableDescriptor( 'LUTInfo', LUTInfoType, _required, strict=DEFAULT_STRICT, docstring='The lookup table.') # type: LUTInfoType def __init__(self, LUTInfo=None, **kwargs): """ Parameters ---------- LUTInfo: LUTInfoType|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.LUTInfo = LUTInfo super(CustomLookupType, self).__init__(**kwargs)
class BaseProjectionType(Serializable): """ The base geometric projection system. """ _fields = ('ReferencePoint', ) _required = ('ReferencePoint', ) # Descriptor ReferencePoint = _SerializableDescriptor( 'ReferencePoint', ReferencePointType, _required, strict=DEFAULT_STRICT, docstring='Reference point for the geometrical system.' ) # type: ReferencePointType def __init__(self, ReferencePoint=None, **kwargs): """ Parameters ---------- ReferencePoint : ReferencePointType 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.ReferencePoint = ReferencePoint super(BaseProjectionType, self).__init__(**kwargs)
class DatumType(Serializable): """ """ _fields = ('Spheroid', ) _required = ('Spheroid', ) # Descriptor Spheroid = _SerializableDescriptor( 'Spheroid', SpheroidType, _required, strict=DEFAULT_STRICT, docstring='') # type: SpheroidType def __init__(self, Spheroid=None, **kwargs): """ Parameters ---------- Spheroid : SpheroidType 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.Spheroid = Spheroid super(DatumType, self).__init__(**kwargs)
class ColorSpaceTransformType(Serializable): """ Parameters describing any color transformation. """ _fields = ('ColorManagementModule', ) _required = _fields # Descriptor ColorManagementModule = _SerializableDescriptor( 'ColorManagementModule', ColorManagementModuleType, _required, strict=DEFAULT_STRICT, docstring='Parameters describing the Color Management Module (CMM).' ) # type: ColorManagementModuleType def __init__(self, ColorManagementModule=None, **kwargs): """ Parameters ---------- ColorManagementModule : ColorManagementModuleType 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.ColorManagementModule = ColorManagementModule super(ColorSpaceTransformType, 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 RemapChoiceType(Serializable): """ The remap choice type. """ _fields = ('ColorDisplayRemap', 'MonochromeDisplayRemap') _required = () _choice = ({ 'required': False, 'collection': ('ColorDisplayRemap', 'MonochromeDisplayRemap') }, ) # Descriptor ColorDisplayRemap = _SerializableDescriptor( 'ColorDisplayRemap', ColorDisplayRemapType, _required, strict=DEFAULT_STRICT, docstring='Information for proper color display of the ' 'data.') # type: Union[None, ColorDisplayRemapType] MonochromeDisplayRemap = _SerializableDescriptor( 'MonochromeDisplayRemap', MonochromeDisplayRemapType, _required, strict=DEFAULT_STRICT, docstring='Information for proper monochrome display of the ' 'data.') # type: Union[None, MonochromeDisplayRemapType] def __init__(self, ColorDisplayRemap=None, MonochromeDisplayRemap=None, **kwargs): """ Parameters ---------- ColorDisplayRemap : None|ColorDisplayRemapType|numpy.ndarray|list|type MonochromeDisplayRemap : None|MonochromeDisplayRemapType 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.ColorDisplayRemap = ColorDisplayRemap self.MonochromeDisplayRemap = MonochromeDisplayRemap super(RemapChoiceType, self).__init__(**kwargs)
class MeasurableProjectionType(BaseProjectionType): """ A physical base projection. """ _fields = ('ReferencePoint', 'SampleSpacing', 'TimeCOAPoly') _required = ('ReferencePoint', 'SampleSpacing', 'TimeCOAPoly') # Descriptor SampleSpacing = _SerializableDescriptor( 'SampleSpacing', RowColDoubleType, _required, strict=DEFAULT_STRICT, docstring='Sample spacing in row and column.' ) # type: RowColDoubleType TimeCOAPoly = _SerializableDescriptor( 'TimeCOAPoly', Poly2DType, _required, strict=DEFAULT_STRICT, docstring= 'Time (units = seconds) at which center of aperture for a given pixel ' 'coordinate in the product occurs.') # type: Poly2DType def __init__(self, ReferencePoint=None, SampleSpacing=None, TimeCOAPoly=None, **kwargs): """ Parameters ---------- ReferencePoint : ReferencePointType SampleSpacing : RowColDoubleType|numpy.ndarray|list|tuple TimeCOAPoly : 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'] super(MeasurableProjectionType, self).__init__(ReferencePoint=ReferencePoint, **kwargs) self.SampleSpacing = SampleSpacing self.TimeCOAPoly = TimeCOAPoly
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 LLPlanarType(Serializable): """ Parameters for Lat/Lon planar surface of constant HAE, implicitly assumed to be the HAE at the `IARP`. """ _fields = ('uIAXLL', 'uIAYLL') _required = _fields # descriptors uIAXLL = _SerializableDescriptor( 'uIAXLL', LatLonType, _required, strict=DEFAULT_STRICT, docstring= 'Image coordinate IAX *"unit vector"* expressed as an increment ' 'in latitude and longitude corresponding to a 1.0 meter increment ' 'in image coordinate `IAX`.') # type: LatLonType uIAYLL = _SerializableDescriptor( 'uIAYLL', LatLonType, _required, strict=DEFAULT_STRICT, docstring= 'Image coordinate IAY *"unit vector"* expressed as an increment ' 'in latitude and longitude corresponding to a 1.0 meter increment ' 'in image coordinate `IAY`.') # type: LatLonType def __init__(self, uIAXLL=None, uIAYLL=None, **kwargs): """ Parameters ---------- uIAXLL : LatLonType|numpy.ndarray|list|tuple uIAYLL : LatLonType|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.uIAXLL = uIAXLL self.uIAYLL = uIAYLL super(LLPlanarType, 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 CylindricalProjectionType(MeasurableProjectionType): """ Cylindrical mapping of the pixel grid. """ _fields = ('ReferencePoint', 'SampleSpacing', 'TimeCOAPoly', 'StripmapDirection', 'CurvatureRadius') _required = ('ReferencePoint', 'SampleSpacing', 'TimeCOAPoly', 'StripmapDirection') _numeric_format = {'CurvatureRadius': '0.16G'} # Descriptor StripmapDirection = _SerializableDescriptor( 'StripmapDirection', XYZType, _required, strict=DEFAULT_STRICT, docstring='Along stripmap direction.') # type: XYZType CurvatureRadius = _FloatDescriptor( 'CurvatureRadius', _required, strict=DEFAULT_STRICT, docstring= 'Radius of Curvature defined at scene center. If not present, the radius of ' 'curvature will be derived based upon the equations provided in the ' 'Design and Exploitation Document') # type: Union[None, float] def __init__(self, ReferencePoint=None, SampleSpacing=None, TimeCOAPoly=None, StripmapDirection=None, CurvatureRadius=None, **kwargs): """ Parameters ---------- ReferencePoint : ReferencePointType SampleSpacing : RowColDoubleType|numpy.ndarray|list|tuple TimeCOAPoly : Poly2DType|numpy.ndarray|list|tuple StripmapDirection : XYZType|numpy.ndarray|list|tuple CurvatureRadius : None|float kwargs """ if '_xml_ns' in kwargs: self._xml_ns = kwargs['_xml_ns'] if '_xml_ns_key' in kwargs: self._xml_ns_key = kwargs['_xml_ns_key'] super(CylindricalProjectionType, self).__init__(ReferencePoint=ReferencePoint, SampleSpacing=SampleSpacing, TimeCOAPoly=TimeCOAPoly, **kwargs) self.StripmapDirection = StripmapDirection self.CurvatureRadius = CurvatureRadius
class ReferenceSystemType(Serializable): """ The reference system. """ _fields = ('ProjectedCoordinateSystem', 'GeographicCoordinateSystem', 'GeocentricCoordinateSystem', 'AxisNames') _required = ('ProjectedCoordinateSystem', 'GeographicCoordinateSystem', 'GeocentricCoordinateSystem', 'AxisNames') _collections_tags = {'AxisNames': {'array': False, 'child_tag': 'AxisName'}} # Descriptor ProjectedCoordinateSystem = _SerializableDescriptor( 'ProjectedCoordinateSystem', ProjectedCoordinateSystemType, _required, strict=DEFAULT_STRICT, docstring='') # type: ProjectedCoordinateSystemType GeographicCoordinateSystem = _SerializableDescriptor( 'GeographicCoordinateSystem', GeographicCoordinateSystemType, _required, strict=DEFAULT_STRICT, docstring='') # type: GeographicCoordinateSystemType GeocentricCoordinateSystem = _SerializableDescriptor( 'GeocentricCoordinateSystem', GeocentricCoordinateSystemType, _required, strict=DEFAULT_STRICT, docstring='') # type: GeocentricCoordinateSystemType AxisNames = _StringListDescriptor( 'AxisNames', _required, strict=DEFAULT_STRICT, docstring='') # type: List[str] def __init__(self, ProjectedCoordinateSystem=None, GeographicCoordinateSystem=None, GeocentricCoordinateSystem=None, AxisNames=None, **kwargs): """ Parameters ---------- ProjectedCoordinateSystem : ProjectedCoordinateSystemType GeographicCoordinateSystem : GeographicCoordinateSystemType GeocentricCoordinateSystem : GeocentricCoordinateSystemType AxisNames : List[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.ProjectedCoordinateSystem = ProjectedCoordinateSystem self.GeographicCoordinateSystem = GeographicCoordinateSystem self.GeocentricCoordinateSystem = GeocentricCoordinateSystem self.AxisNames = AxisNames super(ReferenceSystemType, self).__init__(**kwargs)
class PlaneType(Serializable): """ The reference plane. """ _fields = ('RefPt', 'XDir', 'YDir', 'DwellTime') _required = ('RefPt', 'XDir', 'YDir') # other class variable # descriptors RefPt = _SerializableDescriptor( 'RefPt', ReferencePointType, _required, strict=DEFAULT_STRICT, docstring='The reference point.') # type: ReferencePointType XDir = _SerializableDescriptor( 'XDir', XDirectionType, _required, strict=DEFAULT_STRICT, docstring='The X direction collection plane parameters.') # type: XDirectionType YDir = _SerializableDescriptor( 'YDir', YDirectionType, _required, strict=DEFAULT_STRICT, docstring='The Y direction collection plane parameters.') # type: YDirectionType DwellTime = _SerializableDescriptor( 'DwellTime', DwellTimeType, _required, strict=DEFAULT_STRICT, docstring='The dwell time parameters.') # type: DwellTimeType def __init__(self, RefPt=None, XDir=None, YDir=None, DwellTime=None, **kwargs): """ Parameters ---------- RefPt : ReferencePointType XDir : XDirectionType YDir : YDirectionType DwellTime : DwellTimeType kwargs """ if '_xml_ns' in kwargs: self._xml_ns = kwargs['_xml_ns'] if '_xml_ns_key' in kwargs: self._xml_ns_key = kwargs['_xml_ns_key'] self.RefPt = RefPt self.XDir = XDir self.YDir = YDir self.DwellTime = DwellTime super(PlaneType, self).__init__(**kwargs)
class ErrorParametersType(Serializable): """ Parameters that describe the statistics of errors in measured or estimated parameters that describe the collection. """ _fields = ('Monostatic', 'Bistatic') _required = () _choice = ({'required': True, 'collection': _fields}, ) # descriptors Monostatic = _SerializableDescriptor('Monostatic', MonostaticType, _required, strict=DEFAULT_STRICT, docstring='The monstatic parameters.' ) # type: Union[None, MonostaticType] Bistatic = _SerializableDescriptor('Bistatic', BistaticType, _required, strict=DEFAULT_STRICT, docstring='The bistatic parameters.' ) # type: Union[None, BistaticType] def __init__(self, Monostatic=None, Bistatic=None, **kwargs): """ Parameters ---------- Monostatic : None|MonostaticType Bistatic : None|BistaticType 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.Monostatic = Monostatic self.Bistatic = Bistatic super(ErrorParametersType, self).__init__(**kwargs)
class ScalingType(Serializable): """ Scaling for geometric transformation """ _fields = ('AntiAlias', 'Interpolation') _required = _fields # Descriptor AntiAlias = _SerializableDescriptor( 'AntiAlias', FilterType, _required, strict=DEFAULT_STRICT, docstring= 'The Anti-Alias Filter used for scaling. Refer to program-specific ' 'documentation for population guidance.') # type: FilterType Interpolation = _SerializableDescriptor( 'Interpolation', FilterType, _required, strict=DEFAULT_STRICT, docstring= 'The Interpolation Filter used for scaling. Refer to program-specific ' 'documentation for population guidance.') # type: FilterType def __init__(self, AntiAlias=None, Interpolation=None, **kwargs): """ Parameters ---------- AntiAlias : FilterType Interpolation : FilterType kwargs """ if '_xml_ns' in kwargs: self._xml_ns = kwargs['_xml_ns'] if '_xml_ns_key' in kwargs: self._xml_ns_key = kwargs['_xml_ns_key'] self.AntiAlias = AntiAlias self.Interpolation = Interpolation super(ScalingType, self).__init__(**kwargs)