acquisition module

This is the acquisition module.

This subpackage contains geographic metadata structures regarding data acquisition that are derived from the ISO 19115-2:2019 international standard.

AcquisitionInformation

Bases: ABC

Designations for the measuring instruments and their bands, the platform carrying them, and the mission to which the data contributes.

Source code in opengis/metadata/acquisition.py

class AcquisitionInformation(ABC):
    """
    Designations for the measuring instruments and their bands, the platform
    carrying them, and the mission to which the data contributes.
    """

    @property
    @abstractmethod
    def scope(self) -> Optional[Sequence[Scope]]:
        """The specific data to which the acquisition information applies."""

    @property
    @abstractmethod
    def acquisition_plan(self) -> Optional[Sequence[Plan]]:
        """Identifies the plan as implemented by the acquisition."""

    @property
    @abstractmethod
    def acquisition_requirement(self) -> Optional[Sequence[Requirement]]:
        """
        Identifies the requirement the data acquisition intends to satisfy.
        """

    @property
    @abstractmethod
    def environmental_conditions(self) -> Optional[EnvironmentalRecord]:
        """
        A record of the environmental circumstances during the data
        acquisition.
        """

    @property
    @abstractmethod
    def instrument(self) -> Optional[Sequence[Instrument]]:
        """
        General information about the instrument used in data acquisition.
        """

    @property
    @abstractmethod
    def objective(self) -> Optional[Sequence[Objective]]:
        """Identification of the area or object to be sensed."""

    @property
    @abstractmethod
    def operation(self) -> Optional[Sequence[Operation]]:
        """
        General information about an identifiable activity which provided the
        data.
        """

    @property
    @abstractmethod
    def platform(self) -> Optional[Sequence[Platform]]:
        """
        General information about the platform from which the data were taken.
        """

acquisition_plan: Optional[Sequence[Plan]] abstractmethod property

Identifies the plan as implemented by the acquisition.

acquisition_requirement: Optional[Sequence[Requirement]] abstractmethod property

Identifies the requirement the data acquisition intends to satisfy.

environmental_conditions: Optional[EnvironmentalRecord] abstractmethod property

A record of the environmental circumstances during the data acquisition.

instrument: Optional[Sequence[Instrument]] abstractmethod property

General information about the instrument used in data acquisition.

objective: Optional[Sequence[Objective]] abstractmethod property

Identification of the area or object to be sensed.

operation: Optional[Sequence[Operation]] abstractmethod property

General information about an identifiable activity which provided the data.

platform: Optional[Sequence[Platform]] abstractmethod property

General information about the platform from which the data were taken.

scope: Optional[Sequence[Scope]] abstractmethod property

The specific data to which the acquisition information applies.

ContextCode

Bases: Enum

Designation of criterion for defining the context of the scanning process event.

Source code in opengis/metadata/acquisition.py

class ContextCode(Enum):
    """
    Designation of criterion for defining the context of the scanning
    process event.
    """

    ACQUISITION = "acquisition"
    """Event related to a specific collection."""

    PASS = "pass"
    """Event related to a sequence of collections."""

    WAY_POINT = "wayPoint"
    """Event related to a navigational manoeuvre."""

ACQUISITION = 'acquisition' class-attribute instance-attribute

Event related to a specific collection.

PASS = 'pass' class-attribute instance-attribute

Event related to a sequence of collections.

WAY_POINT = 'wayPoint' class-attribute instance-attribute

Event related to a navigational manoeuvre.

EnvironmentalRecord

Bases: ABC

Information about the environmental conditions during the acquisition.

Source code in opengis/metadata/acquisition.py

class EnvironmentalRecord(ABC):
    """
    Information about the environmental conditions during the acquisition.
    """

    @property
    @abstractmethod
    def average_air_temperature(self) -> Optional[float]:
        """
        Average air temperature along the flight pass during the photo flight.
        """

    @property
    @abstractmethod
    def max_relative_humidity(self) -> Optional[float]:
        """
        Maximum realative humitiy along the flight pass during the photo
        flight.
        """

    @property
    @abstractmethod
    def max_altitude(self) -> Optional[float]:
        """
        Maximum altitude during the photo flight.
        """

    @property
    @abstractmethod
    def meteorological_conditions(self) -> Optional[str]:
        """
        Meteorological conditions in the photo flight area, in particular
        clouds, snow, and wind.
        """

    @property
    @abstractmethod
    def solar_azimuth(self) -> Optional[float]:
        """
        Clockwise angle in degrees from north to the centre of the sun's disc.

        NOTE: This Angle is calculated from the nadir point of the sensor, not
        the centre point of the image.
        """

    @property
    @abstractmethod
    def solar_elevation(self) -> Optional[float]:
        """
        Angle between the horizonand the centre of the sun's disk.
        """

average_air_temperature: Optional[float] abstractmethod property

Average air temperature along the flight pass during the photo flight.

max_altitude: Optional[float] abstractmethod property

Maximum altitude during the photo flight.

max_relative_humidity: Optional[float] abstractmethod property

Maximum realative humitiy along the flight pass during the photo flight.

meteorological_conditions: Optional[str] abstractmethod property

Meteorological conditions in the photo flight area, in particular clouds, snow, and wind.

solar_azimuth: Optional[float] abstractmethod property

Clockwise angle in degrees from north to the centre of the sun's disc.

NOTE: This Angle is calculated from the nadir point of the sensor, not the centre point of the image.

solar_elevation: Optional[float] abstractmethod property

Angle between the horizonand the centre of the sun's disk.

Event

Bases: ABC

Identification of a significant collection point within an operation.

Source code in opengis/metadata/acquisition.py

class Event(ABC):
    """
    Identification of a significant collection point within an
    operation.
    """

    @property
    @abstractmethod
    def identifier(self) -> Identifier:
        """Event name or number."""

    @property
    @abstractmethod
    def trigger(self) -> TriggerCode:
        """Initiator of the event."""

    @property
    @abstractmethod
    def context(self) -> ContextCode:
        """Meaning of the event."""

    @property
    @abstractmethod
    def sequence(self) -> SequenceCode:
        """Relative time ordering of the event."""

    @property
    @abstractmethod
    def time(self) -> datetime:
        """Time the event occurred."""

    @property
    @abstractmethod
    def expected_objective(self) -> Optional[Sequence['Objective']]:
        """An objective expected to be completed by the event."""

    @property
    @abstractmethod
    def related_pass(self) -> PlatformPass:
        """A `PlatformPass` related to the `Event`."""

    @property
    @abstractmethod
    def related_sensor(self) -> Sequence[Instrument]:
        """An `Instrument` related to
            the event."""

context: ContextCode abstractmethod property

Meaning of the event.

expected_objective: Optional[Sequence[Objective]] abstractmethod property

An objective expected to be completed by the event.

identifier: Identifier abstractmethod property

Event name or number.

related_pass: PlatformPass abstractmethod property

A PlatformPass related to the Event.

related_sensor: Sequence[Instrument] abstractmethod property

An Instrument related to the event.

sequence: SequenceCode abstractmethod property

Relative time ordering of the event.

time: datetime abstractmethod property

Time the event occurred.

trigger: TriggerCode abstractmethod property

Initiator of the event.

EventTypeCode

Bases: Enum

Type of event related to a platform, instrument, or sensor.

Source code in opengis/metadata/acquisition.py

class EventTypeCode(Enum):
    """Type of event related to a platform, instrument, or sensor."""

    ANNOUNCEMENT = "announcement"
    """
    Announcementannouncement about future events relevant to the
    platform/instrument/sensor.
    """

    CALIBRATION = "calibration"
    """Calibration event for the platform/instrument/sensor."""

    CALIBRATION_COEFFICIENT_UPDATE = "calibrationCoefficientUpdate"
    """Update of calibration information for the platform/instrument/sensor."""

    DATA_LOSS = "dataLoss"
    """Event related to data loss."""

    FATAL = "fatal"
    """Event that renders the platform/instrument/sensor unusable."""

    MANOEUVRE = "manoeuvre"
    """Event related to a manoeuvre of the platform/instrument/sensor."""

    MISSING_DATA = "missingData"
    """Event related to missing data from the platform/instrument/sensor."""

    NOTICE = "notice"
    """Notice about events related to the platform/instrument/sensor."""

    PRELAUNCH = "prelaunch"
    """Event related to prelaunch period for the platform/instrument/sensor."""

    SEVERE = "severe"
    """
    Event with significant impact on the performance of the platform/
    instrument/sensor.
    """

    SWITCH_OFF = "switchOff"
    """Event related to switching off platform/instrument/sensor."""

    SWITCH_ON = "switchOn"
    """Event related to switching on platform/instrument/sensor."""

    CLEAN = "clean"
    """Event related to cleaning the platform/instrument/sensor."""

ANNOUNCEMENT = 'announcement' class-attribute instance-attribute

Announcementannouncement about future events relevant to the platform/instrument/sensor.

CALIBRATION = 'calibration' class-attribute instance-attribute

Calibration event for the platform/instrument/sensor.

CALIBRATION_COEFFICIENT_UPDATE = 'calibrationCoefficientUpdate' class-attribute instance-attribute

Update of calibration information for the platform/instrument/sensor.

CLEAN = 'clean' class-attribute instance-attribute

Event related to cleaning the platform/instrument/sensor.

DATA_LOSS = 'dataLoss' class-attribute instance-attribute

Event related to data loss.

FATAL = 'fatal' class-attribute instance-attribute

Event that renders the platform/instrument/sensor unusable.

MANOEUVRE = 'manoeuvre' class-attribute instance-attribute

Event related to a manoeuvre of the platform/instrument/sensor.

MISSING_DATA = 'missingData' class-attribute instance-attribute

Event related to missing data from the platform/instrument/sensor.

NOTICE = 'notice' class-attribute instance-attribute

Notice about events related to the platform/instrument/sensor.

PRELAUNCH = 'prelaunch' class-attribute instance-attribute

Event related to prelaunch period for the platform/instrument/sensor.

SEVERE = 'severe' class-attribute instance-attribute

Event with significant impact on the performance of the platform/ instrument/sensor.

SWITCH_OFF = 'switchOff' class-attribute instance-attribute

Event related to switching off platform/instrument/sensor.

SWITCH_ON = 'switchOn' class-attribute instance-attribute

Event related to switching on platform/instrument/sensor.

GeometryTypeCode

Bases: Enum

Geometric description of the collection.

Source code in opengis/metadata/acquisition.py

class GeometryTypeCode(Enum):
    """Geometric description of the collection."""

    POINT = "point"
    """Single geographic point of interest."""

    LINEAR = "linear"
    """Extended collection in a single vector."""

    AREAL = "areal"
    """Collection of a geographic area defined by a polygon (coverage)."""

    STRIP = "strip"
    """Series of linear collections grouped by way points."""

AREAL = 'areal' class-attribute instance-attribute

Collection of a geographic area defined by a polygon (coverage).

LINEAR = 'linear' class-attribute instance-attribute

Extended collection in a single vector.

POINT = 'point' class-attribute instance-attribute

Single geographic point of interest.

STRIP = 'strip' class-attribute instance-attribute

Series of linear collections grouped by way points.

Instrument

Bases: ABC

Designations for the measuring instruments.

Source code in opengis/metadata/acquisition.py

class Instrument(ABC):
    """Designations for the measuring instruments."""

    @property
    @abstractmethod
    def citation(self) -> Optional[Sequence[Citation]]:
        """Complete citation of the instrument."""

    @property
    @abstractmethod
    def identifier(self) -> Identifier:
        """Unique identification of the instrument."""

    @property
    @abstractmethod
    def type(self) -> str:
        """
        Name of the type of instrument. Examples: framing, line-scan,
        push-broom, pan-frame.
        """

    @property
    @abstractmethod
    def description(self) -> Optional[str]:
        """Textual description of the instrument."""

    @property
    @abstractmethod
    def mounted_on(self) -> Optional['Platform']:
        """Platform on which the instrument is mounted"""

    @property
    @abstractmethod
    def sensor(self) -> Optional[Sequence['Sensor']]:
        """Instrument has a sensor."""

    @property
    @abstractmethod
    def history(self) -> Optional['InstrumentEventList']:
        """List of events associated with the instrument."""

citation: Optional[Sequence[Citation]] abstractmethod property

Complete citation of the instrument.

description: Optional[str] abstractmethod property

Textual description of the instrument.

history: Optional[InstrumentEventList] abstractmethod property

List of events associated with the instrument.

identifier: Identifier abstractmethod property

Unique identification of the instrument.

mounted_on: Optional[Platform] abstractmethod property

Platform on which the instrument is mounted

sensor: Optional[Sequence[Sensor]] abstractmethod property

Instrument has a sensor.

type: str abstractmethod property

Name of the type of instrument. Examples: framing, line-scan, push-broom, pan-frame.

InstrumentEvent

Bases: ABC

An event related to a platform, instrument, or sensor.

Source code in opengis/metadata/acquisition.py

class InstrumentEvent(ABC):
    """An event related to a platform, instrument, or sensor."""

    @property
    @abstractmethod
    def citation(self) -> Optional[Sequence[Citation]]:
        """Citation to the `InstrumentEvent`."""

    @property
    @abstractmethod
    def description(self) -> str:
        """Description of the `InstumentEvent`."""

    @property
    @abstractmethod
    def extent(self) -> Optional[Sequence[Extent]]:
        """Extent of the `InstrumentEvent`."""

    @property
    @abstractmethod
    def type(self) -> EventTypeCode:
        """Type of the `InstrumentEvent`."""

    @property
    @abstractmethod
    def revision_history(self) -> Optional[Sequence[Revision]]:
        """History of the revisions of the `InstrumentEvent`."""

citation: Optional[Sequence[Citation]] abstractmethod property

Citation to the InstrumentEvent.

description: str abstractmethod property

Description of the InstumentEvent.

extent: Optional[Sequence[Extent]] abstractmethod property

Extent of the InstrumentEvent.

revision_history: Optional[Sequence[Revision]] abstractmethod property

History of the revisions of the InstrumentEvent.

type: EventTypeCode abstractmethod property

Type of the InstrumentEvent.

InstrumentEventList

Bases: ABC

List of events relaed to platform, instrument, or sensor.

Source code in opengis/metadata/acquisition.py

class InstrumentEventList(ABC):
    """List of events relaed to platform, instrument, or sensor."""

    @property
    @abstractmethod
    def citation(self) -> Optional[Sequence[Citation]]:
        """Citation to the `InstrumentEventList`."""

    @property
    @abstractmethod
    def description(self) -> str:
        """
        Description of the language and character set used for the
        `InstrumentationEventList`.
        """

    @property
    @abstractmethod
    def locale(self) -> Optional[str]:
        """
        Description of the language and character set used for the
        `InstrumentationEventList`. A string conforming to IETF BCP 47.
        """

    @property
    @abstractmethod
    def constraints(self) -> Optional[Sequence[Constraints]]:
        """Use and access constraints."""

    @property
    @abstractmethod
    def instrumentation_event(self) -> Optional[Sequence[InstrumentEvent]]:
        """Events(s) in the list of events."""

citation: Optional[Sequence[Citation]] abstractmethod property

Citation to the InstrumentEventList.

constraints: Optional[Sequence[Constraints]] abstractmethod property

Use and access constraints.

description: str abstractmethod property

Description of the language and character set used for the InstrumentationEventList.

instrumentation_event: Optional[Sequence[InstrumentEvent]] abstractmethod property

Events(s) in the list of events.

locale: Optional[str] abstractmethod property

Description of the language and character set used for the InstrumentationEventList. A string conforming to IETF BCP 47.

Objective

Bases: ABC

Describes the characteristics, spatial and temporal extent of the intended object to be observed.

Source code in opengis/metadata/acquisition.py

class Objective(ABC):
    """
    Describes the characteristics, spatial and temporal extent of the intended
    object to be observed.
    """

    @property
    @abstractmethod
    def identifier(self) -> Sequence[Identifier]:
        """Registered code used to identify the objective."""

    @property
    @abstractmethod
    def priority(self) -> Optional[str]:
        """Priority applied to the target."""

    @property
    @abstractmethod
    def type(self) -> Optional[Sequence[ObjectiveTypeCode]]:
        """Collection technique for the objective."""

    @property
    @abstractmethod
    def function(self) -> Optional[Sequence[str]]:
        """Function performed by or at the objective."""

    @property
    @abstractmethod
    def extent(self) -> Optional[Sequence[Extent]]:
        """
        Extent information including the bounding box, bounding polygon,
        vertical and temporal extent of the objective.
        """

    @property
    @abstractmethod
    def objective_occurence(self) -> Optional[Sequence[Event]]:
        """Event or events associated with objective completion."""

    @property
    @abstractmethod
    def platform_pass(self) -> Optional[Sequence[PlatformPass]]:
        """Pass of the platform over the objective."""

    @property
    @abstractmethod
    def sensing_instrument(self) -> Optional[Sequence[Instrument]]:
        """Instrument which senses the objective data."""

extent: Optional[Sequence[Extent]] abstractmethod property

Extent information including the bounding box, bounding polygon, vertical and temporal extent of the objective.

function: Optional[Sequence[str]] abstractmethod property

Function performed by or at the objective.

identifier: Sequence[Identifier] abstractmethod property

Registered code used to identify the objective.

objective_occurence: Optional[Sequence[Event]] abstractmethod property

Event or events associated with objective completion.

platform_pass: Optional[Sequence[PlatformPass]] abstractmethod property

Pass of the platform over the objective.

priority: Optional[str] abstractmethod property

Priority applied to the target.

sensing_instrument: Optional[Sequence[Instrument]] abstractmethod property

Instrument which senses the objective data.

type: Optional[Sequence[ObjectiveTypeCode]] abstractmethod property

Collection technique for the objective.

ObjectiveTypeCode

Bases: Enum

Temporal persistence of collection objective.

Source code in opengis/metadata/acquisition.py

class ObjectiveTypeCode(Enum):
    """Temporal persistence of collection objective."""

    INSTANTANEOUS_COLLECTION = "instantaneousCollection"
    """Single instance of collection."""

    PERSISTENT_VIEW = "persistentView"
    """Multiple instances of collection."""

    SURVEY = "survey"
    """Collection over specified domain."""

INSTANTANEOUS_COLLECTION = 'instantaneousCollection' class-attribute instance-attribute

Single instance of collection.

PERSISTENT_VIEW = 'persistentView' class-attribute instance-attribute

Multiple instances of collection.

SURVEY = 'survey' class-attribute instance-attribute

Collection over specified domain.

Operation

Bases: ABC

Designations for the operation used to acquire the dataset.

Source code in opengis/metadata/acquisition.py

class Operation(ABC):
    """Designations for the operation used to acquire the dataset."""

    @property
    @abstractmethod
    def description(self) -> Optional[str]:
        """
        Description of the mission on which the platform observations are part
        and the objectives of that mission.
        """

    @property
    @abstractmethod
    def citation(self) -> Optional[Citation]:
        """Identification of the mission."""

    @property
    @abstractmethod
    def identifier(self) -> Optional[Identifier]:
        """Unique identification of the operation."""

    @property
    @abstractmethod
    def status(self) -> ProgressCode:
        """Status of the data acquisition."""

    @property
    @abstractmethod
    def type(self) -> Optional[OperationTypeCode]:
        """Collection technique for the operation."""

    @property
    @abstractmethod
    def other_property(self) -> Optional[Record]:
        """Instance of other property type not included in `Sensor`."""

    @property
    @abstractmethod
    def other_property_type(self) -> Optional[RecordType]:
        """Type of other property description."""

    @property
    @abstractmethod
    def child_operation(self) -> Optional[Sequence['Operation']]:
        """Sub-missions that make up part of a larger mission."""

    @property
    @abstractmethod
    def objective(self) -> Optional[Sequence[Objective]]:
        """Object(s) or area(s) of interest to be sensed."""

    @property
    @abstractmethod
    def parent_operation(self) -> 'Operation':
        """Heritage of the operation."""

    @property
    @abstractmethod
    def plan(self) -> Optional['Plan']:
        """Plan satisfied by th operation."""

    @property
    @abstractmethod
    def platform(self) -> Optional[Sequence[Platform]]:
        """Platform (or platforms) used in the operation."""

    @property
    @abstractmethod
    def significant_event(self) -> Optional[Sequence[Event]]:
        """Record of an event occuring during an operation."""

child_operation: Optional[Sequence[Operation]] abstractmethod property

Sub-missions that make up part of a larger mission.

citation: Optional[Citation] abstractmethod property

Identification of the mission.

description: Optional[str] abstractmethod property

Description of the mission on which the platform observations are part and the objectives of that mission.

identifier: Optional[Identifier] abstractmethod property

Unique identification of the operation.

objective: Optional[Sequence[Objective]] abstractmethod property

Object(s) or area(s) of interest to be sensed.

other_property: Optional[Record] abstractmethod property

Instance of other property type not included in Sensor.

other_property_type: Optional[RecordType] abstractmethod property

Type of other property description.

parent_operation: Operation abstractmethod property

Heritage of the operation.

plan: Optional[Plan] abstractmethod property

Plan satisfied by th operation.

platform: Optional[Sequence[Platform]] abstractmethod property

Platform (or platforms) used in the operation.

significant_event: Optional[Sequence[Event]] abstractmethod property

Record of an event occuring during an operation.

status: ProgressCode abstractmethod property

Status of the data acquisition.

type: Optional[OperationTypeCode] abstractmethod property

Collection technique for the operation.

OperationTypeCode

Bases: Enum

Code indicating whether the data contained in this packet is real (originates from live-fly or other non-simulated operational sources), simulated (originates from target simulator sources), or synthesized (a mix of real and simulated data).

Source code in opengis/metadata/acquisition.py

class OperationTypeCode(Enum):
    """
    Code indicating whether the data contained in this packet is real
    (originates from live-fly or other non-simulated operational sources),
    simulated (originates from target simulator sources), or synthesized
    (a mix of real and simulated data).
    """

    REAL = "real"
    """Originates from live-fly or other non-simulated operational source."""

    SIMULATED = "simulated"
    """Originates from target simulator sources."""

    SYNTHESIZED = "synthesized"
    """Mix of real and simulated data."""

REAL = 'real' class-attribute instance-attribute

Originates from live-fly or other non-simulated operational source.

SIMULATED = 'simulated' class-attribute instance-attribute

Originates from target simulator sources.

SYNTHESIZED = 'synthesized' class-attribute instance-attribute

Mix of real and simulated data.

Plan

Bases: ABC

Designations for the planning information related to meeting requirements.

Source code in opengis/metadata/acquisition.py

class Plan(ABC):
    """
    Designations for the planning information related to meeting requirements.
    """

    @property
    @abstractmethod
    def type(self) -> Optional[GeometryTypeCode]:
        """
        Manner of sampling geometry the planner expects for collection of the
        objective data.
        """

    @property
    @abstractmethod
    def status(self) -> ProgressCode:
        """Current status of the plan (pending, completed, etc.)."""

    @property
    @abstractmethod
    def citation(self) -> Citation:
        """Identification of authority requesting target collection."""

    @property
    @abstractmethod
    def operation(self) -> Optional[Sequence[Operation]]:
        """Identification of the activity or activities that satisfy a plan."""

    @property
    @abstractmethod
    def satisfied_requirement(self) -> Optional[Sequence[Requirement]]:
        """Requirement satisfied by the plan."""

citation: Citation abstractmethod property

Identification of authority requesting target collection.

operation: Optional[Sequence[Operation]] abstractmethod property

Identification of the activity or activities that satisfy a plan.

satisfied_requirement: Optional[Sequence[Requirement]] abstractmethod property

Requirement satisfied by the plan.

status: ProgressCode abstractmethod property

Current status of the plan (pending, completed, etc.).

type: Optional[GeometryTypeCode] abstractmethod property

Manner of sampling geometry the planner expects for collection of the objective data.

Platform

Bases: ABC

Designations for the platform used to acquire the dataset.

Source code in opengis/metadata/acquisition.py

class Platform(ABC):
    """Designations for the platform used to acquire the dataset."""

    @property
    @abstractmethod
    def citation(self) -> Optional[Citation]:
        """Complete citation of the platform."""

    @property
    @abstractmethod
    def identifier(self) -> Identifier:
        """Unique identification of the platform."""

    @property
    @abstractmethod
    def description(self) -> str:
        """Narrative description of the platform supporting the instrument."""

    @property
    @abstractmethod
    def sponsor(self) -> Optional[Sequence[Responsibility]]:
        """
        Organisation responsible for building, launch, or operation of the
        platform.
        """

    @property
    @abstractmethod
    def other_property(self) -> Optional[Record]:
        """Instance of other property type not included in `Sensor`."""

    @property
    @abstractmethod
    def other_property_type(self) -> Optional[RecordType]:
        """Type of other property description."""

    @property
    @abstractmethod
    def instrument(self) -> Sequence[Instrument]:
        """Instrument(s) mounted on a platform"""

    @property
    @abstractmethod
    def history(self) -> Optional[Sequence[InstrumentEventList]]:
        """List of events affecting a platform."""

citation: Optional[Citation] abstractmethod property

Complete citation of the platform.

description: str abstractmethod property

Narrative description of the platform supporting the instrument.

history: Optional[Sequence[InstrumentEventList]] abstractmethod property

List of events affecting a platform.

identifier: Identifier abstractmethod property

Unique identification of the platform.

instrument: Sequence[Instrument] abstractmethod property

Instrument(s) mounted on a platform

other_property: Optional[Record] abstractmethod property

Instance of other property type not included in Sensor.

other_property_type: Optional[RecordType] abstractmethod property

Type of other property description.

sponsor: Optional[Sequence[Responsibility]] abstractmethod property

Organisation responsible for building, launch, or operation of the platform.

PlatformPass

Bases: ABC

Identification of collection coverage. Identifies a particular pass made by the platform during data acquisition. A platform pass is used to provide supporting identifying information for an event and for data acquisition of a particular objective.

Source code in opengis/metadata/acquisition.py

class PlatformPass(ABC):
    """Identification of collection coverage. Identifies a particular pass
    made by the platform during data acquisition. A platform pass is used to
    provide supporting identifying information for an event and for data
    acquisition of a particular objective."""

    @property
    @abstractmethod
    def identifier(self) -> Identifier:
        """Unique name of the pass."""

    @property
    @abstractmethod
    def extent(self) -> Optional[Extent]:
        """Temporal and spatial extent of the pass."""

    @property
    @abstractmethod
    def related_event(self) -> Optional[Sequence['Event']]:
        """Occurrence of one or more events for a pass."""

extent: Optional[Extent] abstractmethod property

Temporal and spatial extent of the pass.

identifier: Identifier abstractmethod property

Unique name of the pass.

related_event: Optional[Sequence[Event]] abstractmethod property

Occurrence of one or more events for a pass.

PriorityCode

Bases: Enum

Ordered list of priorities.

Source code in opengis/metadata/acquisition.py

class PriorityCode(Enum):
    """Ordered list of priorities."""

    CRITICAL = "critical"
    """Of decisive importance."""

    HIGH_IMPORTANCE = "highImportance"
    """Requires resources to be made available."""

    MEDIUM_IMPORTANCE = "mediumImportance"
    """Normal operation priority."""

    LOW_IMPORTANCE = "lowImportance"
    """To be completed when resources are available."""

CRITICAL = 'critical' class-attribute instance-attribute

Of decisive importance.

HIGH_IMPORTANCE = 'highImportance' class-attribute instance-attribute

Requires resources to be made available.

LOW_IMPORTANCE = 'lowImportance' class-attribute instance-attribute

To be completed when resources are available.

MEDIUM_IMPORTANCE = 'mediumImportance' class-attribute instance-attribute

Normal operation priority.

RequestedDate

Bases: ABC

Range of date validity.

Source code in opengis/metadata/acquisition.py

class RequestedDate(ABC):
    """Range of date validity."""

    @property
    @abstractmethod
    def requested_date_of_collection(self) -> datetime:
        """Preferred date and time of collection."""

    @property
    @abstractmethod
    def latest_acceptable_date(self) -> datetime:
        """Latest date and time collection must be completed."""

latest_acceptable_date: datetime abstractmethod property

Latest date and time collection must be completed.

requested_date_of_collection: datetime abstractmethod property

Preferred date and time of collection.

Requirement

Bases: ABC

Requirement to be satisfied by the planned data acquisition.

Source code in opengis/metadata/acquisition.py

class Requirement(ABC):
    """Requirement to be satisfied by the planned data acquisition."""

    @property
    @abstractmethod
    def citation(self) -> Optional[Citation]:
        """
        Identification of reference or guidance material for the requirement.
        """

    @property
    @abstractmethod
    def identifier(self) -> Identifier:
        """Unique name, or code, for the requirement."""

    @property
    @abstractmethod
    def requestor(self) -> Sequence[Responsibility]:
        """Origin of requirement."""

    @property
    @abstractmethod
    def recipient(self) -> Sequence[Responsibility]:
        """Person(s), or body(ies), to receive results of requirement."""

    @property
    @abstractmethod
    def priority(self) -> PriorityCode:
        """Relative ordered importance, or urgency, of the requirement."""

    @property
    @abstractmethod
    def requested_date(self) -> RequestedDate:
        """Required or preferred acquisition date and time."""

    @property
    @abstractmethod
    def expiry_date(self) -> datetime:
        """Date and time after which collection is no longer valid."""

    @property
    @abstractmethod
    def satisfied_plan(self) -> Optional[Sequence['Plan']]:
        """Plan that identifies solution to satisfy the requirement."""

citation: Optional[Citation] abstractmethod property

Identification of reference or guidance material for the requirement.

expiry_date: datetime abstractmethod property

Date and time after which collection is no longer valid.

identifier: Identifier abstractmethod property

Unique name, or code, for the requirement.

priority: PriorityCode abstractmethod property

Relative ordered importance, or urgency, of the requirement.

recipient: Sequence[Responsibility] abstractmethod property

Person(s), or body(ies), to receive results of requirement.

requested_date: RequestedDate abstractmethod property

Required or preferred acquisition date and time.

requestor: Sequence[Responsibility] abstractmethod property

Origin of requirement.

satisfied_plan: Optional[Sequence[Plan]] abstractmethod property

Plan that identifies solution to satisfy the requirement.

Revision

Bases: ABC

History of the revision of an event

Source code in opengis/metadata/acquisition.py

class Revision(ABC):
    """History of the revision of an event"""

    @property
    @abstractmethod
    def description(self) -> str:
        """Description of the revision."""

    @property
    @abstractmethod
    def responsible_party(self) -> Sequence[Responsibility]:
        """Individual or organisation responsible for the revision."""

    @property
    @abstractmethod
    def date_info(self) -> Sequence[date]:
        """Information about dates related to the revision."""

date_info: Sequence[date] abstractmethod property

Information about dates related to the revision.

description: str abstractmethod property

Description of the revision.

responsible_party: Sequence[Responsibility] abstractmethod property

Individual or organisation responsible for the revision.

Sensor

Bases: Instrument

Specific type of instrument

Source code in opengis/metadata/acquisition.py

class Sensor(Instrument):
    """Specific type of instrument"""

    @property
    @abstractmethod
    def hosted(self) -> Optional[Instrument]:
        """Instrument on which the sensor is hosted"""

hosted: Optional[Instrument] abstractmethod property

Instrument on which the sensor is hosted

SequenceCode

Bases: Enum

Temporal relation of activation.

Source code in opengis/metadata/acquisition.py

class SequenceCode(Enum):
    """Temporal relation of activation."""

    START = "start"
    """Beginning of collection."""

    END = "end"
    """End of collection."""

    INSTANTANEOUS = "instantaneous"
    """Collection without a significant duration."""

END = 'end' class-attribute instance-attribute

End of collection.

INSTANTANEOUS = 'instantaneous' class-attribute instance-attribute

Collection without a significant duration.

START = 'start' class-attribute instance-attribute

Beginning of collection.

TriggerCode

Bases: Enum

Mechanism of activation.

Source code in opengis/metadata/acquisition.py

class TriggerCode(Enum):
    """Mechanism of activation."""

    AUTOMATIC = "automatic"
    """Event due to external stimuli."""

    MANUAL = "manual"
    """Event manually instigated."""

    PRE_PROGRAMMED = "preProgrammed"
    """Event instaigated by planned internal stimuli."""

AUTOMATIC = 'automatic' class-attribute instance-attribute

Event due to external stimuli.

MANUAL = 'manual' class-attribute instance-attribute

Event manually instigated.

PRE_PROGRAMMED = 'preProgrammed' class-attribute instance-attribute

Event instaigated by planned internal stimuli.