-
Notifications
You must be signed in to change notification settings - Fork 0
Development Phase 1
This document defines the functionality that OpenLayers 3 will offer as the result of the first development phase.
Stated and anticipated future client requirements necessitate architectural considerations in Phase 1 to ensure that this functionality can be implemented later phases. Each section of the document includes an Enabling future functionality for that matter.
In Phase 1 we will make OpenLayers 3 animate
- Zoom transition
- Panning (kinetic)
- Tile displaying
- Camera movement
This requires a solid and flexible framework that makes animations possible with both the WebGL and the DOM renderers.
Animations with WebGL will be based on requestAnimationFrame loops, while, for performance reasons, animations with DOM will be based on CSS3 transitions. The animation framework should accomodate both implementations.
Related to the animation framework is the way the DOM renderer translates and scales the layers pane. The DOM renderer currently scales each tile image individually by changing the dimensions of its DOM element. For performance reasons we may instead want to apply a CSS scale transform on container elements.
We will implement the animation framework in Phase 1, as a foundation for current and future animation requirements.
In Phase 1 we will experiment with 3D features. We will work on
- Integrating with the Cesium virtual globe
- Adding "limited tilt" support (i.e. tilt with same-resolution tiles)
For 3D in general, and integration with virtual globes in particular, we need to introduce the concept of a camera. In Phase 1 we will therefore add a Camera type. The Camera will be part of the API. One requirement though is that the API remain easy for developers of "simple", 2D map applications.
OpenLayers 3 has the concept of data sources. One type only is currently supported: tile. (OpenLayers 3 currently supports the XYZ/OSM tile source family, and tiled WMS.)
In Phase 1 we will add support for the following layer type:
- WMTS
- Single Image WMS
- Image (OpenLayers 2's
OpenLayers.Layer.Image) - Vector (detailed in the following section)
To be able to rate-control, abort, prioritize tile requests, and manage resource management a Tile Queue (or Tile Manager) will be implemented. This work will be based on past experience with OpenLayers 2 and WebGLMaps.
Also, writing custom, application-specific layer/data source types should be possible. The architecture and build tool must be designed with this in mind.
In Phase 1 we will add the following vector functionality:
- Display styled points, linestrings and polygons with Canvas 2D (or SVG [*])
- Display unstyled points with WebGL
- Draw, interact with, and modify features
- Support various formats, protocols, and strategies
We will consider 2D vectors only in Phase 1.
[*] To be decided considering performance and browser compatibility.
Note: it is not yet clear whether we will have a Markers layer type as in OpenLayers 2.
OpenLayers 2 offers many vector-related features. It has a flexible architecture enabling to work with different strategies, protocols, and formats. It also provides a powerful styling framework, based on SLD.
Eventually, OpenLayers 3 will, at least, provide the same level of functionality and flexibility.
Displaying styled geometries of any type (point, linestring and polygon) with WebGL must also be possible in the future, and it must exhibit good performance. For example, sending the vector data to the GPU must not require expensive memory operations (data copies), and it must be possible to batch the drawing of multiple objects.
Also, applying styles to geometries should probably be easier than with OpenLayers 2, but without compromising on flexibility and performance.
In Phase 1 we will port the following OpenLayers 2 controls, or functionality thereof, to OpenLayers 3:
- ArgParser
- Attribution
- MousePosition
- Navigation
- PanZoomBar
- Permalink
- ScaleLine
- TouchNavigation
- Zoom
- ZoomToMaxExtent
- OverviewMap
- DrawFeature
- Geolocate
- GetFeature
- Measure
- ModifyFeature
- NavigationHistory
- SelectFeature
OpenLayers 2 includes a Panel control, for addings buttons onto a map.
Whether something similar will be be ported to OpenLayers 3 is yet to be
determined.
The control architecture will be built with the following requirements in mind:
- Controls must work with both the DOM and WebGL renderers.
- Controls can be composed of other controls.
- Writing controls must be easy.
- Working with application-specific controls should be possible.
Note: OpenLayers 3 has interactions and controls. We will need to clarify these concepts in order to implement the required functionality in a generic way.
In Phase 1 we will implement the following formats:
- WMS Capabilities
- WMTS Capabilities
- GeoJSON (implies JSON)
- KML
- WKT
- GPX
- WFTS (implies GML)
OpenLayers 2 includes an architecture to work with XML (mainly OGC), and share code between various formats. A similar architecture will be implemented in OpenLayers 3.
We will also attempt to make it possible to share formats with other open-source toolkits (Cesium, Leaflet). This may require collaboration with other communities.
- Define format architecture
- define XML format architecture
OpenLayers 3 must obviously work on mobile. Panning and zooming should be very
smooth. The common gestures for interacting with the map should be available.
For example, we will add a PinchZoom interaction (which we don't have
currently).
We will focus on supporting the iOS and Android native browsers (WebKit). See the Browser Support section below for more information.
OpenLayers 3 already includes the concept of overlays. Overlays are things/elements that can be added atop the map. This is the concept onto which popups and labels will rely. We will to continue this work, and add a popup implementation based on the overlay architecture.
In Phase 1 we will make sure the features we develop work in
- IE 9+
- FireFox 17+
- Chrome 22+
- Safari 5+
- iOS 6 and Android 4.2 native browsers
Supporting IE from version 9 makes it possible to not rely on VML at all for vector rendering. VML is an obsolete technology.
OpenLayers 3 will need to be able to leverage modern web technologies such as Filter Effects and CSS3 (3D) transforms.
OpenLayers 3 needs to have good documentations and tools.
We already generate an API doc using jsdoc3, but a lot more remains to be done for a decent API documentation. We may need to extend jsdoc3 to meet our needs.
We use Travis CI for Continuous testing and integration. We will need to update our Travis script as we go.
OpenLayers 3 has to offer easy-to-use tools for creating custom builds of the library. A convenient command line interface (CLI) will be developed. This CLI will serve as the base for a hosted build tool developed in a further phase of the project.
We will also need to organize the website and the community around two code bases (OpenLayers 2 and OpenLayers 3).
In the first phase of development we will mainly work on porting the functionality from OpenLayers 2 to OpenLayers 3. At the end of the first phase OpenLayers 3 should major features of OpenLayers 2, and should have a solid and flexible architecture making it possible, and easy enough, to add more features in the future.
In the first phase we will also work on more advanced features (e.g. Cesium integration, client-side re-projection, millions of geometries handled by WebGL, limited tilt close to the surface). The goal is twofold: assess our architecture and design choices, and show off OpenLayers 3 to the public.