Code Monkey home page Code Monkey logo

ogcapi-movingfeatures's Introduction

OGC API - Moving Features

This GitHub repository contains the OGC API - Moving Features for providing query and access to geospatial data and services, especially movement data.

The OGC API - Moving Features Standard is part of the OGC API suite of standards. OGC API Standards define modular API building blocks to spatially enable Web APIs in a consistent way. OpenAPI is used to define the reusable API building blocks.

Overview of OGC API - Moving Features - Part 1: Core

The summary of the OGC API โ€“ MovingFeatures โ€“ Part 1:Core is described in the below table.

URL Path Supported HTTP(s) Methods
/collections/{c_id} GET,DELETE,PUT
/collections/{c_id}/items GET,POST
/collections/{c_id}/items/{mf_id} GET,DELETE
/collections/{c_id}/items/{mf_id}/tgsequence GET,POST
/collections/{c_id}/items/{mf_id}/tgsequence/{tg_id} DELETE
/collections/{c_id}/items/{mf_id}/tgsequence/{tg_query} GET
/collections/{c_id}/items/{mf_id}/tproperties GET,POST
/collections/{c_id}/items/{mf_id}/tproperties/{tp_name} GET,POST,DELETE
MovingFeatures Collection Catalog
GET /collections    

Retrieve catalogs of a moving features collection.

POST /collections

Register metadata about a collection of moving features.

GET /collections/{collectionId}

Access metadata about the collection with id {collectionId}.

DELETE /collections/{collectionId}

The collection catalog with id {collectionId} and including metadata and moving features SHOULD be deleted.

PUT /collections/{collectionId}

Replace metadata about the collection with id {collectionId}.

MovingFeatures
MovingFeature
GET /collections/{collectionId}/items

Retrieve the moving feature collection to access the static information of the moving feature by simple filtering and a limit.

POST /collections/{collectionId}/items

Insert a set of moving features or a moving feature into a collection with id {collectionId}.

GET /collections/{collectionId}/items/{mFeatureId}

Access the static data of the moving feature with id {mFeatureId}. The static data of a moving feature is not included temporal geometries and temporal properties.

DELETE /collections/{collectionId}/items/{mFeatureId}

Delete a single moving feature with id {mFeatureId}.

TemporalGeometrySequence
GET /collections/{collectionId}/items/{mFeatureId}/tgsequence

Retrieve the movement data of the single moving feature with id {mFeatureId}.

POST /collections/{collectionId}/items/{mFeatureId}/tgsequence

Add movement data into the moving feature with id {mFeatureId}.

DELETE /collections/{collectionId}/items/{mFeatureId}/tgsequence/{tGeometryId}

Delete a single temporal geometry with id {tGeometryId}.

TemporalProperties
GET /collections/{collectionId}/items/{mFeatureId}/tproperties

Retrieve the static information of the temporal property data that included a single moving feature with id {mFeatureId}. The static data of a temporal property is not included temporal values (property values).

POST /collections/{collectionId}/items/{mFeatureId}/tproperties

Add temporal property data into a moving feature with id {mFeatureId}.

GET /collections/{collectionId}/items/{mFeatureId}/tproperties/{tPropertyName}

Retrieve temporal values with a specified name {tPropertyName} of temporal property.

POST /collections/{collectionId}/items/{mFeatureId}/tproperties/{tPropertyName}

Add more temporal values data into a temporal property with id {tPropertyName}.

DELETE /collections/{collectionId}/items/{mFeatureId}/tproperties/{tPropertyName}

Delete a single temporal property with id {tPropertyName}.

Building the Standard document

git clone https://github.com/opengeospatial/ogcapi-movingfeatures.git

cd ogcapi-movingfeatures

docker run -v "$(pwd)":/metanorma -v ${HOME}/.fontist/fonts/:/config/fonts  metanorma/metanorma  metanorma compile --agree-to-terms -t ogc -x html,pdf standard/document.adoc

Using the Standard

A draft of the OGC API - Moving Features - Part 1: Core Standard is available:

Those who want to just see the endpoints and responses can explore the generic OpenAPI definition on Swagger:

There have been several implementations of the Draft Standard, though they are against different versions of the evolving draft:

Contributing

The contributor understands that any contributions, if accepted by the OGC Membership, shall be incorporated into OGC API - Moving Features Standards documents and that all copyright and intellectual property shall be vested to the OGC.

The OGC's Moving Features Standards Working Group (SWG) is the group at OGC responsible for the stewardship of the Standard, but is working to do as much work in public as possible.

Pull Requests from contributors are welcomed. However, please note that by sending a Pull Request or Commit to this GitHub repository, you are agreeing to the terms in the Observer Agreement https://portal.ogc.org/files/?artifact_id=92169

ogcapi-movingfeatures's People

Contributors

bradh avatar desruisseaux avatar ghobona avatar jerstlouis avatar mahmsakr avatar taehoonk avatar

Stargazers

 avatar  avatar  avatar  avatar  avatar  avatar

Watchers

 avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar

ogcapi-movingfeatures's Issues

Conformance with API-Features

In a perfect world API-Moving Features would be an extension of API-Features. However, this may be an unacceptable constraint on the API-Moving Features standard. Is there a balance we can strike between conformance with API-Features and going our own way?

Moving Features are also Sensor Observations

Moving Features are often the result of sensor observations. As we build out the Moving Features API we should also look at SensorThing and Sensor Observation Service for guidance.

Scales within orientations

It seems odd that an orientations property contains a scales property, as well as an angles property.
Possibly they could be separated into scales and angles directly, each with a second array level?

Retrieving temporal geometries for multiple features

Is there any mechanism to retrieve the temporal geometry for multiple features in a single API call?

I believe this is an important use case to efficiently stream the position of a large number of rapidly moving objects e.g., a satellite constellation or drone swarms.

Collecting the use-cases related to moving features

At the beginning step of the OGC MovingFeautres API (shortly MF-API) design, we would like to collect as many different use cases as possible to extract the basic resources and necessary functionality of the MF-API.

For examples,

Dear contributors, please share your knowledge about features or use cases you think are necessary to the MF-API in the below comments.

Retrieving temporal geometries and properties together

Would there be any mechanism with which one could request both temporal geometries and properties through the same API calls, like both static geometry and properties are retrieved with OGC API - Features at /items?

The orientations (angles / scales) could be considered a special type of properties already returned with the feature geometry (points).

Clarify the relationship with OGC API - Connected Systems

https://github.com/opengeospatial/connected-systems/tree/master/api/part1/standard

From @alexrobin :

The API is an extension of OGC API - Features for handling dynamic data and will be presented in detail at the next TC.
The Connected Systems SWG will meet for the first time in Frascati. (4:10 PM on Monday, February 20)

There will also be presentations in the Autonomy, Sensors, Things, Robots and Observations DWG (ASTRO DWG, previously SWE DWG) dealing with spacecraft and UxS telemetry which includes pose information. (10:20 AM on Monday, February 20)

We have been dealing with dynamic pose information for years with the SWE standards (we have worked with spaceborne and UxS use cases all along) and this new API is a modern approach to it. GeoPose now formalizes the pose data model and we'll be able to encode and stream the corresponding data using various encodings (json, xml, binary). In general, Pose is a specific type of observation about a feature so IMHO it should be recognized as such.

Inconsistency in OpenAPI version referenced

Clause 3 of the draft version of OGC API - Moving Features - Part 1: Core 1.0.0 currently normatively references OpenAPI 3.1.0, however it is also designed to be an extension of OGC API - Features - Part 1: Core 1.0.1 which references OpenAPI 3.0.3.

For consistency, OGC API - Moving Features - Part 1: Core should also reference OpenAPI 3.0.3.

Past, Current, Predicted trajectories

I am wondering how OGC API - Moving Features can enable streaming the current position of a moving object, as well as its past actual trajectory and predicted future trajectory.
Am I correct in understanding (from the overview page), that the relevant resource would be:

GET /collections/{collectionId}/items/{mFeatureId}/tgeometries

Retrieve the movement data of the single moving feature with id mFeatureId.

Is there a mechanism (e.g., a property) that could be used to distinguish between actual historic temporal geometry/properties, current geometry/properties, and predicted geometry/properties?

As a related use case, consider the following ISS tracking positions (not including orientation, but i this case it is easy to deduct the orientation based on the direction of movement):

{
    "sat": 25544,
    "tRef": 1674280079,
    "orbitData": [
        { "t": 1674280020, "ln": 143.511, "lt": 17.213, "h": 419, "v": 7.662, "s": true },
        { "t": 1674280080, "ln": 145.941, "lt": 20.143, "h": 419, "v": 7.662, "s": true }
    ]
}

(from https://www.astroviewer.net/iss/ws/orbit.php?sat=25544)

Replace mentions of "OGC APIs"

There is a request from the OAB for clearer use of terminology regarding OGC API Standards.

The detail of the Issue is documented at opengeospatial/ogcapi-common#336

This GitHub Issue may be closed once the relevant edits have been made to relevant OGC API Standards documents.

`datetime` parameter with temporal geometry / properties

Could the datetime parameter be supported for the temporal geometry and temporal properties requests?

  • GET /collections/{collectionId}/items/{mFeatureId}/tgeometries
  • GET /collections/{collectionId}/items/{mFeatureId}/tproperties

This would allow to request these for a time interval of interest.

A related use case would be to request these for only the past or predicted future (related to #25).

Consider making finer-grained conformance classes

Requirement class http://www.opengis.net/spec/ogcapi-movingfeatures-1/1.0/req/movingfeatures is fairly large, and potentially involves data types and functionality that not all implementations will need.

For example, where the OGC API for Moving Features is a facade over an existing system, it may not be desirable to allow anything other than "query" (i.e. GET). The create/replace/update/delete operations are required by the conformance class, but may not be desired (or implementable) on the system.

Even if there is support for making changes, the underlying data model may not be suited to DELETE of a single geometry on the MF.

(I'm still trying to get all of the operations clear, but it looks like support for MF Prism is also required, even though the underlying data might only be easily represented in Trajectory).

Suggest breaking out at least the simple "GET me a moving point" functionality, and ideally each logical block of functionality that can be meaningfully implemented on top of that.

Convert to metanorma asciidoc

This is the checklist for converting the document to metanorma asciidoc. The changes will be made in a feature branch called metanorma, and then merged once all of the steps have been completed.

  • Modify index document
  • Convert the abstract
  • Convert the keywords
  • Convert the security considerations
  • Convert the submitting organizations
  • Convert the submitters list
  • Convert body of document
  • Convert the bibliography
  • Convert the references
  • Convert the terms and definitions
  • Convert all tables
  • Convert all figures
  • Convert all requirements classes
  • Convert all requirements
  • Convert all conformance classes
  • Convert all conformance tests
  • Check all captions
  • Check all cross-references

GeoPose as a representation of OGC API - Moving Features temporal geometry

The basic conceptual model / capabilities seems to overlap between OGC API - Moving Features (overview / draft) and GeoPose:

  • MF coordinates / GP position (or parameters latitude / longitude in Advanced encoding)
  • MF datetimes / GP validTime (in advanced encoding only? -- see #70)
  • MF orientations .angles / GP angles / quaternion

Could a GeoPose sequence possibly be supported as a representation for the OGC API - Moving Features temporal geometries response, providing the position, time and orientation along a sequence (see also opengeospatial/GeoPose#73)?

(also asked in GeoPose: opengeospatial/GeoPose#71)

base property used to refer to 3D models

The base property is oddly named as a reference to a 3D model. Could that be something like model?

However, it is not clear how referencing a 3D model is within scope of this Moving Features API.
Could a separate API or conformance class perhaps add this capability?

The ability to reference 3D models from point geometry is also something being considered for OGC API - 3D GeoVolumes, with a /models/{modelId} end-point, where the content-type can be negotiated using an Accept: header, rather than being available in a single format (OGC API Web Guideline Principle 9).

MobilityDB

This issue provides a forum to evaluate and discuss MobilityDB for potential relevance to this API.

Recommend Projects

  • React photo React

    A declarative, efficient, and flexible JavaScript library for building user interfaces.

  • Vue.js photo Vue.js

    ๐Ÿ–– Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.

  • Typescript photo Typescript

    TypeScript is a superset of JavaScript that compiles to clean JavaScript output.

  • TensorFlow photo TensorFlow

    An Open Source Machine Learning Framework for Everyone

  • Django photo Django

    The Web framework for perfectionists with deadlines.

  • D3 photo D3

    Bring data to life with SVG, Canvas and HTML. ๐Ÿ“Š๐Ÿ“ˆ๐ŸŽ‰

Recommend Topics

  • javascript

    JavaScript (JS) is a lightweight interpreted programming language with first-class functions.

  • web

    Some thing interesting about web. New door for the world.

  • server

    A server is a program made to process requests and deliver data to clients.

  • Machine learning

    Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.

  • Game

    Some thing interesting about game, make everyone happy.

Recommend Org

  • Facebook photo Facebook

    We are working to build community through open source technology. NB: members must have two-factor auth.

  • Microsoft photo Microsoft

    Open source projects and samples from Microsoft.

  • Google photo Google

    Google โค๏ธ Open Source for everyone.

  • D3 photo D3

    Data-Driven Documents codes.