This is a proposal for a new package 'org.opengis.display' which will replace the old GO-1 package and provide interfaces for viewing geographic data.

This project will begin in coming days if no feedback is send.

The goals of the new package - org.opengis.display

The Display package builds on the old GO-1 package which is present in the last formal GeoAPI release, 2.0. Go-1 is a great specification in that it handles many of the important pieces of information necessary for a viewing platform such as MathTransforms, canvas, and graphics.

However, the GO-1 specification is no longer supported. Since work last took place on this package, the specifications on which it was built have evolved. Overall, the package needs to be fixed if it is to be useful. At the OGC meeting in Paris in the summer of 2007, it was aggreed by the ad-hoc GeoAPI working group that the package would be deprecated.

The new package org.opengis.display will take over the role of the old org.opengis.go* packages. This new package will be "cleaned" version of GO-1 specification we will propose to OGC as a new GO-1 version.
See : GO-1 Specification

The Display package will inherit and refactor the old GO-1 interfaces. This refractoring has the main goal to :

1. Split Canvas in 2 interfaces :
   • Canvas : which is the definition of the maparea and transformation to use for rendering
   • Renderer : which is an interface to set the big lines of what is a renderer that handle graphics
2. Remove relations to refererencing
3. Remove relations to styles

This package should provide a basic interface as a basis against which one could make any kind of renderer.

Step 1 - Moving the current org.opengis.display package

As a preliminary step the current org.opengis.display package which contains a few classes will be moved to the org.opengis.go.display package since they are closely related. This will preserve the history of of the earlier work, closely related with the go effort, which is now abandoned. The move would free up the org.opengis.display namespace for a new package.

This package has not been used since a long time, it was experimental and has been abandoned. The current package's structure is so close to the go-1 interfaces that we can move it inside go-1 without breaking anything.

This step is preliminary to an eventual removal of these classes completely from GeoAPI, as explained below.

Step 2 - Create a new org.opengis.display package

This will hold the new interfaces.

Step 3 - Copying classes from the current org.opengis.go.display package

I will then copy some of the existing org.opengis.go.display classes in the display package
and start building on those.

This refractoring effort will consist of:

• Split Canvas interface in two (Canvas and Renderer) in order to separate concerns related to the Canvas itself (size, geographic location of center) and the concerns related to rendering (managing Graphics object, which are often renderer-implementation dependent). This is an issue raised by a team working on a 3D renderer engine.

• Removing the relation to styles. This will allow for different solutions to styling which may depend on the particular renderering system.

• Rename a few CRS-related methods for consistency with naming in referencing packages (e.g. getObjectiveCoordinateReferenceSystem --> getObjectiveCRS).

• Replace a few String by InternationalString (e.g. getTitle()).

• Remove some methods that doesn't seem to be used (e.g. getUID()).

Those changes will follow the same idea as GO-1 and won't impose any limitation to the possible rendering solution.

4 - Delete go-1 package

These are effectively abandoned, this move has been approved by the OGC ad-hoc group on geoapi, and the removal has been planned for a long time.

This is the last step, deleting org.opengis.go* package. this will clean geoapi by removing an old unused package.

Near Future - Real world implementations

We actually intend to use the New display interfaces (which will no be GO-1 anymore) for 3 renderers :

• A Java2D implementation.
• An OpenGL 2D on which work has already started and first results are visible.
• An OpenGL 3D ,improved version of the openGL2D renderer.

This project will start soon and will end when a satisfying result will be reatch.(I believe it will last 3 weeks maximum )

New implementation details

Global organization

• Canvas : this interface hold the informations related to the Area to render. This interface define the base needed informations : ObjectiveCRS, DisplayCRS, related MathTransforms and the CenterPoint of the renderedArea.
  For exemple a Carthesian 2D display canvas should extend this class with some more informations like : height, width, scale, rotation, pixel size ...etc...
  We have keeped only those informations in the Canvas to enable :
  • Multiple Renderers using the same canvas
  • Saving the canvas for futur use
  • easely switching between canvas
• CanvasState : This is an immutable object with all getters. This object is actually a snapshot of the canvas at time T. It has been made this way to preserve relation between each value at time T. This also enable concurrent access to the datas.
• CanvasController : All setters are in this class.
• Renderer : A Renderer works with a Canvas and a collection of graphic objects. With those informations and Data it is able to make a correct Rendered Image
• Graphic : A Graphic is an object that can be renderer by the renderer. This class is very abstract so that any API or conception can be used.
  For exemple :
  • A Web Java2D Renderer with no possible edition will only use one poor graphic object for a MapContext and no cache system.
  • A Desktop OpenGL3D Renderer that handle edition will use one rich graphic object for each feature in each MapLayer and a file cache system.

Interfaces details

Canvas

Renderer

Graphics