types

Different type mappings of geo engine types

SpatialBounds Objects

class SpatialBounds()

A spatial bounds object

__init__

def __init__(xmin: float, ymin: float, xmax: float, ymax: float) -> None

Initialize a new SpatialBounds object

as_bbox_str

def as_bbox_str(y_axis_first=False) -> str

A comma-separated string representation of the spatial bounds with OGC axis ordering

as_bbox_tuple

def as_bbox_tuple(y_axis_first=False) -> tuple[float, float, float, float]

Return the bbox with OGC axis ordering of the srs

x_axis_size

def x_axis_size() -> float

The size of the x axis

y_axis_size

def y_axis_size() -> float

The size of the y axis

BoundingBox2D Objects

class BoundingBox2D(SpatialBounds)

‘A 2D bounding box.

from_response

@staticmethod
def from_response(
        response: geoengine_api_client.BoundingBox2D) -> BoundingBox2D

create a BoundingBox2D from an API response

SpatialPartition2D Objects

class SpatialPartition2D(SpatialBounds)

A 2D spatial partition.

from_response

@staticmethod
def from_response(
        response: geoengine_api_client.SpatialPartition2D
) -> SpatialPartition2D

create a SpatialPartition2D from an API response

to_bounding_box

def to_bounding_box() -> BoundingBox2D

convert to a BoundingBox2D

from_bounding_box

@staticmethod
def from_bounding_box(bbox: BoundingBox2D) -> SpatialPartition2D

Creates a SpatialPartition2D from a BoundingBox2D

TimeInterval Objects

class TimeInterval()

‘A time interval.

__init__

def __init__(start: datetime | np.datetime64,
             end: datetime | np.datetime64 | None = None) -> None

Initialize a new TimeInterval object

time_str

@property
def time_str() -> str

Return the time instance or interval as a string representation

from_response

@staticmethod
def from_response(
        response: geoengine_api_client.models.TimeInterval) -> TimeInterval

create a TimeInterval from an API response

to_api_dict

def to_api_dict() -> geoengine_api_client.TimeInterval

create a openapi TimeInterval from self

__eq__

def __eq__(other: Any) -> bool

Check if two TimeInterval objects are equal.

SpatialResolutionDict Objects

class SpatialResolutionDict(TypedDict)

A spatial resolution as a dictionary

SpatialResolution Objects

class SpatialResolution()

‘A spatial resolution.

__init__

def __init__(x_resolution: float, y_resolution: float) -> None

Initialize a new SpatialResolution object

from_response

@staticmethod
def from_response(response: SpatialResolutionDict) -> SpatialResolution

create a SpatialResolution from an API response

resolution_ogc

def resolution_ogc(srs_code: str) -> tuple[float, float]

Return the resolution in OGC style

QueryRectangle Objects

class QueryRectangle()

A multi-dimensional query rectangle, consisting of spatial and temporal information.

__init__

def __init__(spatial_bounds: BoundingBox2D | SpatialPartition2D
             | tuple[float, float, float, float],
             time_interval: TimeInterval | tuple[datetime, datetime | None],
             srs="EPSG:4326") -> None

Initialize a new QueryRectangle object

Parameters

spatial_bounds The spatial bounds of the query rectangle. Either a BoundingBox2D or a tuple of floats (xmin, ymin, xmax, ymax) time_interval The time interval of the query rectangle. Either a TimeInterval or a tuple of datetime.datetime objects (start, end)

bbox_str

@property
def bbox_str() -> str

A comma-separated string representation of the spatial bounds

bbox_ogc_str

@property
def bbox_ogc_str() -> str

A comma-separated string representation of the spatial bounds with OGC axis ordering

bbox_ogc

@property
def bbox_ogc() -> tuple[float, float, float, float]

Return the bbox with OGC axis ordering of the srs

time

@property
def time() -> TimeInterval

Return the time instance or interval

spatial_bounds

@property
def spatial_bounds() -> BoundingBox2D

Return the spatial bounds

time_str

@property
def time_str() -> str

Return the time instance or interval as a string representation

srs

@property
def srs() -> str

Return the SRS string

__repr__

def __repr__() -> str

Return a string representation of the query rectangle.

with_raster_bands

def with_raster_bands(raster_bands: list[int]) -> RasterQueryRectangle

Converts a QueryRectangle into a RasterQueryRectangle

RasterQueryRectangle Objects

class RasterQueryRectangle(QueryRectangle)

A multi-dimensional query rectangle, consisting of spatial and temporal information and raster bands.

__init__

def __init__(spatial_bounds: BoundingBox2D | SpatialPartition2D
             | tuple[float, float, float, float],
             time_interval: TimeInterval | tuple[datetime, datetime | None],
             raster_bands: list[int] | None | int,
             srs="EPSG:4326") -> None

Initialize a new QueryRectangle object

Parameters

spatial_bounds The spatial bounds of the query rectangle. Either a BoundingBox2D or a tuple of floats (xmin, ymin, xmax, ymax) time_interval The time interval of the query rectangle. Either a TimeInterval or a tuple of datetime.datetime objects (start, end) bands The raster bands of the query rectangle. A List of ints representing the band numbers.

raster_bands

@property
def raster_bands() -> list[int]

Return the query bands

__repr__

def __repr__() -> str

Return a string representation of the query rectangle.

ResultDescriptor Objects

class ResultDescriptor()

Base class for result descriptors

__init__

def __init__(spatial_reference: str,
             time_bounds: TimeInterval | None = None) -> None

Initialize a new ResultDescriptor object

from_response

@staticmethod
def from_response(
        response: geoengine_api_client.TypedResultDescriptor
) -> ResultDescriptor

Parse a result descriptor from an http response

is_raster_result

@classmethod
def is_raster_result(cls) -> bool

Return true if the result is of type raster

is_vector_result

@classmethod
def is_vector_result(cls) -> bool

Return true if the result is of type vector

is_plot_result

@classmethod
def is_plot_result(cls) -> bool

Return true if the result is of type plot

spatial_reference

@property
def spatial_reference() -> str

Return the spatial reference

time_bounds

@property
def time_bounds() -> TimeInterval | None

Return the time bounds

VectorResultDescriptor Objects

class VectorResultDescriptor(ResultDescriptor)

A vector result descriptor

__init__

def __init__(spatial_reference: str,
             data_type: VectorDataType,
             columns: dict[str, VectorColumnInfo],
             time_bounds: TimeInterval | None = None,
             spatial_bounds: BoundingBox2D | None = None) -> None

Initialize a vector result descriptor

from_response_vector

@staticmethod
def from_response_vector(
    response: geoengine_api_client.TypedVectorResultDescriptor
) -> VectorResultDescriptor

Parse a vector result descriptor from an http response

data_type

@property
def data_type() -> VectorDataType

Return the data type

spatial_reference

@property
def spatial_reference() -> str

Return the spatial reference

columns

@property
def columns() -> dict[str, VectorColumnInfo]

Return the columns

spatial_bounds

@property
def spatial_bounds() -> BoundingBox2D | None

Return the spatial bounds

__repr__

def __repr__() -> str

Display representation of the vector result descriptor

to_api_dict

def to_api_dict() -> geoengine_api_client.TypedResultDescriptor

Convert the vector result descriptor to a dictionary

FeatureDataType Objects

class FeatureDataType(str, Enum)

Vector column data type

from_string

@staticmethod
def from_string(data_type: str) -> FeatureDataType

Create a new VectorColumnDataType from a string

to_api_enum

def to_api_enum() -> geoengine_api_client.FeatureDataType

Convert to an API enum

VectorColumnInfo Objects

@dataclass
class VectorColumnInfo()

Vector column information

from_response

@staticmethod
def from_response(
        response: geoengine_api_client.VectorColumnInfo) -> VectorColumnInfo

Create a new VectorColumnInfo from a JSON response

to_api_dict

def to_api_dict() -> geoengine_api_client.VectorColumnInfo

Convert to a dictionary

RasterBandDescriptor Objects

@dataclass(repr=False)
class RasterBandDescriptor()

A raster band descriptor

from_response

@classmethod
def from_response(
    cls, response: geoengine_api_client.RasterBandDescriptor
) -> RasterBandDescriptor

Parse an http response to a RasterBandDescriptor object

__repr__

def __repr__() -> str

Display representation of a raster band descriptor

GridIdx2D Objects

@dataclass
class GridIdx2D()

A grid index

from_response

@classmethod
def from_response(cls, response: geoengine_api_client.GridIdx2D) -> GridIdx2D

Parse an http response to a GridIdx2D object

GridBoundingBox2D Objects

@dataclass
class GridBoundingBox2D()

A grid boundingbox where lower right is inclusive index

from_response

@classmethod
def from_response(
        cls,
        response: geoengine_api_client.GridBoundingBox2D) -> GridBoundingBox2D

Parse an http response to a GridBoundingBox2D object

contains_idx

def contains_idx(idx: GridIdx2D) -> bool

Test if a GridIdx2D is contained by this

SpatialGridDefinition Objects

@dataclass
class SpatialGridDefinition()

A grid boundingbox where lower right is inclusive index

from_response

@classmethod
def from_response(
    cls, response: geoengine_api_client.SpatialGridDefinition
) -> SpatialGridDefinition

Parse an http response to a SpatialGridDefinition object

__repr__

def __repr__() -> str

Display representation of the SpatialGridDefinition

SpatialGridDescriptor Objects

@dataclass
class SpatialGridDescriptor()

A grid boundingbox where lower right is inclusive index

from_response

@classmethod
def from_response(
    cls, response: geoengine_api_client.SpatialGridDescriptor
) -> SpatialGridDescriptor

Parse an http response to a SpatialGridDefinition object

__repr__

def __repr__() -> str

Display representation of the SpatialGridDescriptor

RasterDataType Objects

class RasterDataType(str, Enum)

Raster data type enum

from_string

@staticmethod
def from_string(data_type: str) -> RasterDataType

Create a new RasterDataType from a string

from_literal

@staticmethod
def from_literal(
    data_type: Literal["U8", "U16", "U32", "U64", "I8", "I16", "I32", "I64",
                       "F32", "F64"]
) -> RasterDataType

Create a new RasterDataType from a literal

to_literal

def to_literal() -> Literal["U8", "U16", "U32", "U64", "I8", "I16", "I32",
                            "I64", "F32", "F64"]

Convert to a literal

from_api_enum

@staticmethod
def from_api_enum(
        data_type: geoengine_api_client.RasterDataType) -> RasterDataType

Create a new RasterDataType from an API enum

to_api_enum

def to_api_enum() -> geoengine_api_client.RasterDataType

Convert to an API enum

to_np_dtype

def to_np_dtype() -> np.dtype

Convert to a numpy dtype

TimeDimension Objects

class TimeDimension()

A time dimension

from_response

@classmethod
def from_response(
    cls, response: geoengine_api_client.TimeDimension
) -> RegularTimeDimension | IrregularTimeDimension

Parse a time dimension from an http response

RegularTimeDimension Objects

class RegularTimeDimension(TimeDimension)

A regular time dimension

__init__

def __init__(step: TimeStep, origin: np.datetime64 | None = None) -> None

Initialize a new RegularTimeDimension

to_api_dict

def to_api_dict() -> geoengine_api_client.TimeDimension

Convert the regular time dimension to a dictionary

from_response

@classmethod
def from_response(
        cls,
        response: geoengine_api_client.TimeDimension) -> RegularTimeDimension

Parse a regular time dimension from an http response

IrregularTimeDimension Objects

class IrregularTimeDimension(TimeDimension)

The irregular time dimension

to_api_dict

def to_api_dict() -> geoengine_api_client.TimeDimension

Convert the irregular time dimension to a dictionary

from_response

@classmethod
def from_response(cls, response: Any) -> IrregularTimeDimension

Parse an irregular time dimension from an http response

TimeDescriptor Objects

class TimeDescriptor()

A time descriptor

__init__

def __init__(dimension: TimeDimension,
             bounds: TimeInterval | None = None) -> None

Initialize a new TimeDescriptor

to_api_dict

def to_api_dict() -> geoengine_api_client.TimeDescriptor

Convert the time descriptor to a dictionary

from_response

@staticmethod
def from_response(
        response: geoengine_api_client.TimeDescriptor) -> TimeDescriptor

Parse a time descriptor from an http response

RasterResultDescriptor Objects

class RasterResultDescriptor(ResultDescriptor)

A raster result descriptor

__init__

def __init__(
        data_type: RasterDataType | Literal["U8", "U16", "U32", "U64", "I8",
                                            "I16", "I32", "I64", "F32", "F64"],
        bands: list[RasterBandDescriptor],
        spatial_reference: str,
        spatial_grid: SpatialGridDescriptor,
        time: TimeDescriptor | TimeInterval | TimeDimension | None = None
) -> None

Initialize a new RasterResultDescriptor

to_api_dict

def to_api_dict() -> geoengine_api_client.TypedResultDescriptor

Convert the raster result descriptor to a dictionary

from_response_raster

@staticmethod
def from_response_raster(
    response: geoengine_api_client.TypedRasterResultDescriptor
) -> RasterResultDescriptor

Parse a raster result descriptor from an http response

spatial_reference

@property
def spatial_reference() -> str

Return the spatial reference

__repr__

def __repr__() -> str

Display representation of the raster result descriptor

PlotResultDescriptor Objects

class PlotResultDescriptor(ResultDescriptor)

A plot result descriptor

__init__

def __init__(spatial_reference: str,
             time_bounds: TimeInterval | None = None,
             spatial_bounds: BoundingBox2D | None = None) -> None

Initialize a new PlotResultDescriptor

__repr__

def __repr__() -> str

Display representation of the plot result descriptor

from_response_plot

@staticmethod
def from_response_plot(
    response: geoengine_api_client.TypedPlotResultDescriptor
) -> PlotResultDescriptor

Create a new PlotResultDescriptor from a JSON response

spatial_reference

@property
def spatial_reference() -> str

Return the spatial reference

to_api_dict

def to_api_dict() -> geoengine_api_client.TypedResultDescriptor

Convert the plot result descriptor to a dictionary

VectorDataType Objects

class VectorDataType(str, Enum)

An enum of vector data types

from_geopandas_type_name

@classmethod
def from_geopandas_type_name(cls, name: str) -> VectorDataType

Resolve vector data type from geopandas geometry type

from_literal

@staticmethod
def from_literal(
    literal: Literal["Data", "MultiPoint", "MultiLineString", "MultiPolygon"]
) -> VectorDataType

Resolve vector data type from literal

from_api_enum

@staticmethod
def from_api_enum(
        data_type: geoengine_api_client.VectorDataType) -> VectorDataType

Resolve vector data type from API enum

from_string

@staticmethod
def from_string(string: str) -> VectorDataType

Resolve vector data type from string

TimeStepGranularity Objects

class TimeStepGranularity(Enum)

An enum of time step granularities

TimeStep Objects

@dataclass
class TimeStep()

A time step that consists of a granularity and a step size

__init__

def __init__(step: int, granularity: TimeStepGranularity | str) -> None

Initialize a new TimeStep object

from_response

@classmethod
def from_response(cls, response: geoengine_api_client.TimeStep) -> TimeStep

Parse an http response to a TimeStep object

Provenance Objects

@dataclass
class Provenance()

Provenance information as triplet of citation, license and uri

from_response

@classmethod
def from_response(cls,
                  response: geoengine_api_client.Provenance) -> Provenance

Parse an http response to a Provenance object

ProvenanceEntry Objects

@dataclass
class ProvenanceEntry()

Provenance of a dataset

from_response

@classmethod
def from_response(
        cls,
        response: geoengine_api_client.ProvenanceEntry) -> ProvenanceEntry

Parse an http response to a ProvenanceEntry object

Symbology Objects

class Symbology()

Base class for symbology

from_response

@staticmethod
def from_response(response: geoengine_api_client.Symbology) -> Symbology

Parse an http response to a Symbology object

VectorSymbology Objects

class VectorSymbology(Symbology)

A vector symbology

RasterColorizer Objects

class RasterColorizer()

Base class for raster colorizer

from_response

@classmethod
def from_response(
        cls,
        response: geoengine_api_client.RasterColorizer) -> RasterColorizer

Parse an http response to a RasterColorizer object

SingleBandRasterColorizer Objects

@dataclass
class SingleBandRasterColorizer(RasterColorizer)

A raster colorizer for a specified band

MultiBandRasterColorizer Objects

@dataclass
class MultiBandRasterColorizer(RasterColorizer)

A raster colorizer for multiple bands

RasterSymbology Objects

class RasterSymbology(Symbology)

A raster symbology

__init__

def __init__(raster_colorizer: RasterColorizer, opacity: float = 1.0) -> None

Initialize a new RasterSymbology

to_api_dict

def to_api_dict() -> geoengine_api_client.Symbology

Convert the raster symbology to a dictionary

from_response_raster

@staticmethod
def from_response_raster(
        response: geoengine_api_client.RasterSymbology) -> RasterSymbology

Parse an http response to a RasterSymbology object

__eq__

def __eq__(value)

Check if two RasterSymbologies are equal

DataId Objects

class DataId()

Base class for data ids

from_response

@classmethod
def from_response(cls, response: geoengine_api_client.DataId) -> DataId

Parse an http response to a DataId object

InternalDataId Objects

class InternalDataId(DataId)

An internal data id

from_response_internal

@classmethod
def from_response_internal(
        cls, response: geoengine_api_client.InternalDataId) -> InternalDataId

Parse an http response to a InternalDataId object

__repr__

def __repr__() -> str

Display representation of an internal data id

__eq__

def __eq__(other) -> bool

Check if two internal data ids are equal

ExternalDataId Objects

class ExternalDataId(DataId)

An external data id

from_response_external

@classmethod
def from_response_external(
        cls, response: geoengine_api_client.ExternalDataId) -> ExternalDataId

Parse an http response to a ExternalDataId object

__repr__

def __repr__() -> str

Display representation of an external data id

__eq__

def __eq__(other) -> bool

Check if two external data ids are equal

Measurement Objects

class Measurement()

Base class for measurements

from_response

@staticmethod
def from_response(response: geoengine_api_client.Measurement) -> Measurement

Parse a result descriptor from an http response

UnitlessMeasurement Objects

class UnitlessMeasurement(Measurement)

A measurement that is unitless

__str__

def __str__() -> str

String representation of a unitless measurement

__repr__

def __repr__() -> str

Display representation of a unitless measurement

ContinuousMeasurement Objects

class ContinuousMeasurement(Measurement)

A measurement that is continuous

__init__

def __init__(measurement: str, unit: str | None) -> None

Initialize a new ContiuousMeasurement

from_response_continuous

@staticmethod
def from_response_continuous(
    response: geoengine_api_client.ContinuousMeasurement
) -> ContinuousMeasurement

Initialize a new `ContiuousMeasurement from a JSON response

__str__

def __str__() -> str

String representation of a continuous measurement

__repr__

def __repr__() -> str

Display representation of a continuous measurement

ClassificationMeasurement Objects

class ClassificationMeasurement(Measurement)

A measurement that is a classification

__init__

def __init__(measurement: str, classes: dict[int, str]) -> None

Initialize a new ClassificationMeasurement

from_response_classification

@staticmethod
def from_response_classification(
    response: geoengine_api_client.ClassificationMeasurement
) -> ClassificationMeasurement

Initialize a new `ClassificationMeasurement from a JSON response

__str__

def __str__() -> str

String representation of a classification measurement

__repr__

def __repr__() -> str

Display representation of a classification measurement

GeoTransform Objects

class GeoTransform()

The GeoTransform specifies the relationship between pixel coordinates and geographic coordinates.

y_max

In Geo Engine, x_pixel_size is always positive.

x_pixel_size

In Geo Engine, y_pixel_size is always negative.

__init__

def __init__(x_min: float, y_max: float, x_pixel_size: float,
             y_pixel_size: float)

Initialize a new GeoTransform

from_response

@classmethod
def from_response(cls,
                  response: geoengine_api_client.GeoTransform) -> GeoTransform

Parse a geotransform from an HTTP JSON response

to_gdal

def to_gdal() -> tuple[float, float, float, float, float, float]

Convert to a GDAL geotransform

coord_to_pixel_ul

def coord_to_pixel_ul(x_cord: float, y_coord: float) -> GridIdx2D

Convert a coordinate to a pixel index rould towards top left

coord_to_pixel_lr

def coord_to_pixel_lr(x_cord: float, y_coord: float) -> GridIdx2D

Convert a coordinate to a pixel index ound towards lower right

pixel_ul_to_coord

def pixel_ul_to_coord(x_pixel: int, y_pixel: int) -> tuple[float, float]

Convert a pixel position into a coordinate

spatial_to_grid_bounds

def spatial_to_grid_bounds(
        bounds: SpatialPartition2D | BoundingBox2D) -> GridBoundingBox2D

Converts a BoundingBox2D or a SpatialPartition2D into a GridBoundingBox2D

grid_bounds_to_spatial_bounds

def grid_bounds_to_spatial_bounds(
        bounds: GridBoundingBox2D) -> SpatialPartition2D

Converts a GridBoundingBox2D into a SpatialPartition2D

__eq__

def __eq__(other) -> bool

Check if two geotransforms are equal