Version 26 (modified by bitner, 5 years ago)

--

  1. Summer Of Code
    1. Ideas
      1. Applications
        1. Web-based Configuration
        2. Application Toolkit
        3. Improved Editing Application
        4. KML WYSIWYG
        5. Style Editing
      2. Library Improvements
        1. Remote Data Management Improvements
        2. Vector rendering improvements
        3. Improved Vector Feature Selection
        4. Memory Management
        5. Client Side Topological Operations
    2. Mentors
    3. Projects with no specific mentors
      1. OpenLayers iPhone Development
      2. Maps for Enterprise Applications

Summer Of Code

Google's SoC program allows for students to receive a stipend for developing open source software under the tutelage of a mentor from the project. Most of these projects require reasonably significant Javascript knowledge to be successful, but no specific GIS knowledge. Here are some Google Summer of Code evelopment ideas:

Ideas

Applications

Web-based Configuration

An application to develop a map based on the loading of layer information from remote data sources would allow for users who are not familiar with WMS and similar standards to configure a map. This would allow for more GIS-style usage, where a map is built based on a set of dialogs and choices based on a remote layer. Some work in this area has been started: The "OWS Manager" project by Lorenzo, and the "OLON" (OpenLayers Object Notation) for serializing and loading information into a map.

The student would become familiar with:

  • Standards for describing datasets, like WMS, WFS, TMS capabilities documents
  • Ways of serializing information about OpenLayers state

Willing to Mentor:

  • Christopher Schmidt
  • Lorenzo Becchi (ominoverde)

Application Toolkit

Various efforts are underway to combine client-side application frameworks with OpenLayers. MapFish and GeoExt couple OpenLayers with the Ext JS. These efforts could be combined to provide a common front-end toolkit for building map related applications. The project would focus on developing modular application components with no specific server-side dependencies. The goal of the project would be to develop a library that facilitates quick application development with richly interactive map related components.

The student would gain skills in:

  • Using application building libraries (Ext JS) for real world applications
  • How to use the OpenLayers library in an application framework

Ideal for a student with:

  • Skills developing web applications
  • Experience with Ext JS or another similar library
  • A desire to learn about web mapping applications

Willing to Mentor:

  • Tim Schaub
  • David Bitner

Improved Editing Application

Editing GIS data usually means working with a schema, fixed attributes, etc. Additionally, users expect to simply be able to deploy an 'application' rather than needing to write a lot of custom code to deploy an editing interface. Create a generalized editing application which has support for reading from a schema (either via some remote request, or defined locally) to determine attributes, and using that schema to build a UI for editing the attributes of various features. The end result of this would be a product which is suitable for deployment against a specific remote-server with minimal configuration of application level setup: simply set up the server information, and possibly the schema (if the server can't deliver it) and no additional code is necessary.

This would teach the student about:

  • How OpenLayers works with remote data sources
  • How the vector editing tools need to interact with each other
  • How web-based editing happens via the specific protocol supported.

Willing to Mentor:

  • Christopher Schmidt
  • Tim Schaub

KML WYSIWYG

KML has essentially become the "HTML of the GeoWeb"... but unlike HTML, there are relatively few tools for crafting KML in a GUI-like interface. Unlike HTML, geographic information is hard to visualize as text, so a UI for building this information is even more important than in the case of HTML. Create an OpenLayers-based KML generation tool, which allows users to do something akin to WYSIWYG development of KML information, including styling, name/description fields, etc. The end result should be a KML file which can be serialized from the information -- this will most likely be a specialized KML serializer, built on top of Format.KML, with the additional serialization of styles, descriptions, etc. that might otherwise not be included in the KML.

This would teach the student about:

  • The KML Format and how it is used on the web
  • How the KML format is used in OpenLayers
  • How to build a UI for allowing user-centric development of interesting geographic-based information.

Willing to Mentor:

  • Christopher Schmidt

Style Editing

One of the biggest difficulties with developing cartography in open source tools is the lack of support for any tools to build cartographic styles. Web-based mapping is especially suffers in this regard, since web mapping typically requires significantly more cartographic development to support the many scales of visualization. One of the best ways to improve this is via in-browser cartographic development, using standards like SLD to describe styles, and then passing these styles up to a server for rendering. This project could be to build a browser-based styling engine to develop high-quality cartographic representations in a standards oriented way. It is likely that some level of vector-based rendering would be useful as a first pass, allowing the user of the application a highly interactive styling approach which can then be confirmed with a round trip to the server.

This would teach the student about:

  • The way that OpenLayers does styling of its vector features
  • Standards for generating style information (SLD)
  • The way to interact with remote servers to request styled layers
  • The aspects of styling which are important to users, and how to build a good UI around them.

Willing to Mentor:

  • Christopher Schmidt
  • Tim Schaub
  • Steven Ottens

Library Improvements

Remote Data Management Improvements

Improve the way that OpenLayers interacts with remote datasources by writing code to abstract protocols away from the application level, allowing for the use of any number of different protocols for managing remote data.

Willing to Mentor:

  • Christopher Schmidt
  • Tim Schaub

Vector rendering improvements

Support for text in vector rendering?

Good for a student who is interested in:

  • SVG / VML-based in-browser rendering
  • Improved support for in-browser vector visualization

Willing to Mentor:

  • Christopher Schmidt
  • Tim Schaub

Improved Vector Feature Selection

Currently, we depend on browser-based DOM elements for feature selection. Due to technical limitations in browsers, this drastically limits our support for selecting features from multiple layers at once. Recently, support for determining intersecting features has been added, which can be used to improve our feature selection. Additionally, feature selection based on selecting an area, selecting features using modifiers (Shift, ctrl, etc.) and so on are beneficial. A student could add this support to OpenLayers to improve our general capabilities for interacting with layered vector features.

The student would:

  • Learn about the way that OpenLayers Control and event handling works
  • Add support for a new way of interacting with features
  • Solve a long-standing bug/feature request which has limited a number of deployments of OpenLayers

Willing to Mentor:

  • Christopher Schmidt
  • Tim Schaub

Memory Management

Due to quirks in the way that browsers handle memory management, it is necessary in Javascript to carefully clean up references in Javascript to DOM objects and vice versa. Currently, OpenLayers has a framework for doing this, but the way it is done is not always sufficient to ensure that the memory leaks are properly cleaned up.

It should be possible, using tools like  Drip, and other memory leak finding tools, to explore the different OpenLayers classes looking for memory leaks. It is likely that the end result of this would be to make OpenLayers more robust, and usable for longer sustainted periods of time.

The student would:

  • Get a good overview of OpenLayers coding practices without requiring too much in the way of understanding of Javascript ahead of time
  • Be developing a more robust baseline application profile for use of OpenLayers in a broader variety of situations.
  • End up with a good solid baseline knowledge of a wide swath of the OpenLayers codebase.

Willing to Mentor:

  • Christopher Schmidt
  • Tim Schaub
  • Erik Uzureau

Client Side Topological Operations

Develop a library for use with OpenLayers which supports client-side topological operations (Buffering, convex hull, centroid, simplification, etc.). This library would allow for more complex GIS-related tasks to be performed entirely in the browser. This would be an ideal project for a student who is more well versed in mathematical topological operations and interested in using them in a browser.

The student would learn:

  • How geometries are represented in OpenLayers
  • How to write Javascript code that acts on these geometries to perform topological operations.

Willing to Mentor:

  • Christopher Schmidt
  • Tim Schaub

Mentors

Mentors should have a strong knowledge of Javascript, sound knowledge of OpenLayers, and be interested in helping to teach a student the 'ropes' of OpenLayers development. Mentors should expect to spend an average of 5 hours per week mentoring a student for the duration of the summer of code period (late May to end of August).

  • Chris Schmidt
  • Attila Csipa
  • Tim Schaub
  • Erik Uzureau
  • Steven Ottens

Projects with no specific mentors

The following projects don't have specific mentors associated with them, and may not be appropriate for Summer of Code applicants as is. The "questions" section should be answered before these are integrated back into the list.

OpenLayers iPhone Development

The iPhone SDK may present a way to create an OpenLayers-based native iPHone app which takes advantage of aspects of the iPhone like multitouch. With that in mind, it's possible that investigating OpenLayers development on this platform could be valuable, similar to the current 'native' Google Maps app.

Questions:

  • Is this really an OpenLayers thing, or an entirely seperate project?

Maps for Enterprise Applications

Create a Java framework which will use custom jsp tags to simplify the use of open layers in web applications, these tags will go to java through Ajax, based on a configurable value by Spring framework. This is an idea of how to make it simple for the developers creating web applications, since all they need to do is specify events in the tag and use them in small custom templates. JSP/JSF/Struts page will have TLD tags allowing you to place the tags within the page The tag will generate all javascripts for the map based on velocity templates. All the configuration, extent, WMS servers, etc is done through Spring framework.

The student would become familiar with:

  • How to plug Openlayers in his/her web application

Questions:

  • How is this directly "OpenLayers development"? We don't have anything like a place to put Java code at this time, and I don't anticipate changing that.

More information is given in Gallery  http://trac.openlayers.org/wiki/Gallery under Back - end chapter.