Google Summer of Code/2012/Project Ideas
Jump to navigation
Jump to search
This page lists a number of ideas for potential Google Summer of Code Projects. For ideas from previous years see Category:Google Summer of Code ideas
Its primary purpose is to help to give potential applicants ideas that they can build on to turn into applications for the programme. Members of the community are encouraged to identify ideas for projects here, and whether they would be willing to act as a mentor for a student attempting the project.
Students can base their application on one of these ideas, or on an idea of their own if they prefer.
Processes
If you are thinking of applying for GSoC, please see our Google_Summer_of_Code/Processes page which describes the way that we manage GSoC within OSM, so you know what we expect of students and Mentors.
Types of Projects
We have historically struggled to come up with suitably challenging yet achievable project ideas based on the core OSM infrastructure in the past, so the projects that have been selected have tended to be smaller projects based on using OSM data. There has also been a tendency for applicants to propose to start new projects rather than build on previous work.
For this year's Google Summer of Code, it is proposed that we adopt the following order of preference for projects:
- Development of existing OSM infrastructure (main web site, database, editors or rendering tool chain).
- Development of existing OSM related projects (routers, renderers, mobile apps etc.).
- Creation of new OSM related projects (provided the proposed application is new / novel).
It is highly unlikely that we will accept a project to create a new application where a similar one already exists (e.g. android based navigation tool - we would much prefer to see a proposal to develop an existing tool and add new features / user interface style etc.).
Format of Project Ideas
Each project idea should copy and edit the following template:
| You type | {{GSoC idea
|title=Example - JOSM Plugin to do xxxx
|suggestor=OSM User name or email of person making suggestion (so we can contact them if necessary)
|summary=Summary of Project Idea (a few sentences)
|skills=Skills Required to succeed with the project
|mentors=OSM User names or emails of Possible Mentors
|notes=Additional explanatory notes
|comments=brief comments
}}
| |
|---|---|---|
| You get |
|
Project Ideas
Development of Existing OSM Infrastructure
Main Web Site / API Database
|
Suggested By
Summary
An addition to the API which lets clients watch the map for updates matching an expression they specify, which may include tags, areas, or object IDs. Updates are either sent to the client as they occur or made available in an RSS feed of recent updates.
Skills
Ruby, Ruby on Rails, Python, C++
Possible Mentors
Notes
This will build on the work of projects like OWL and Changepipe.
Comments
It would be great if the area you chose could be an administrative boundary, like country or state. The problem would be choosing which administrative boundaries and which expressions would generate too much feeds. If you gave Russia's boundary and highway=residential, that would generate too much updates. Janko 16:04, 9 March 2012 (UTC)
|
|
Suggested By
CycleStreets
Summary
If OSM wants to be used in a mainstream context routinely on websites, blogs etc wherever a map is shown, it needs to provide a wide range of embeddable widgets, code examples and blog plugins that can easily be dropped in. Although these are supposedly easy to code, in practice this takes time and effort; what is really needed is a range of preset tools that provide for the 90%-cases of 'Just showing where something is'. A point-and-click interface to create these would massively improve uptake.
Skills
HTML/Javascript development, design, good eye for reusable code. Shouldn't require enormous skills, but needs to have real flair.
Possible Mentors
? [Not CycleStreets]
Notes
There are a whole range of widgets that could be done, e.g.
Comments
brief comments
|
|
|
Suggested By
"warren" (osm) - jeff@publiclaboratory.org
Summary
The REST API currently supports XML responses but many JavaScript systems would be better served by JSON, which is also slightly more efficient. More JavaScript/HTML5 code is emerging and this is likely to support such efforts. A "cache=true" parameter could also offer access to a day-old or week-old memcached version of the data, reducing the load for clients who know they will be pulling down a lot of data; this could even be a default. The JSON implementation is near complete with the exception of tests.
Skills
Rails/Ruby, familiarity with JSON encoding in Ruby, Rails tests
Possible Mentors
warren
Notes
This work was begun on an older fork of the rails port here: https://github.com/jywarren/openstreetmap-website/commit/68be5a3f62c4b39f80a62a414b473a20b136e3dd, which could be brought up to date.
Comments
Elements of that might also already be found in a branch of cgi-map ( https://github.com/zerebubuth/openstreetmap-cgimap/tree/content-types )
|
|
Suggested By
sabas88
Summary
Intelligent feature finder (street, POI)
Skills
server-side languages
Possible Mentors
OSM User names or emails of Possible Mentors
Notes
Nominatim currently fails in various common usecases involving missing words and miss-spellings. Either replace or (preferably) improve the current service to handle partial queries and erroneously spelled ones.
|
Editors
|
Suggested By
robotnic
Summary
An Editor that enables the User to do micromapping based on "width" and "offset" property [1].
Skills
HTML, JavaScript, map library
Possible Mentors
None yet
Notes
Comments
It would be worth developing this based on a previous GSoC project that did a lot of the ground work (like authentication and data transfer). See [2] - main thing to develop would be the user interface. Grahamjones 21:13, 5 March 2012 (UTC)
Advancing HTML editors is a great idea, but focusing on micromapping with lane relations in particular is not. This is not an established data model for lanes - in fact several alternative tagging styles (such as tag-based lanes) seem to have better chances to be accepted than relation-based lanes. Reviving a proposal that has been used only 80 times worldwide in its 5 years of existence is not an appropriate task for a GSoC student imo. Certainly there are other, more basic features missing from HTML editors? --Tordanik 10:46, 8 March 2012 (UTC)
|
|
Suggested By
Summary
Android currently lacks a robust simple editor. Mapzen is discontinued and does not work, Vespucci is not very active and not so easy.
Skills
Android, OSM API
Possible Mentors
Notes
Comments
Would it be worth making a general javascript editor so it would be cross platform? You can make it look like a native Android or IOS application with something like phoneGap. Could base it on a previous GSoC project [3]. Grahamjones 21:13, 5 March 2012 (UTC)
I've been working on something along the similar lines of to Mapzen here Yuvipanda 10:56, 9 March 2012 (UTC)
|
|
Suggested By
Summary
This project proposal is to create a piece of software to support mappers in adding maxspeed=* values. With this, a mapper would use a front facing video camera and record a stream of video,
together with a GPS trace while driving/cycling/walking along. The software would then retrospectively analyse this video and detect speed limit signs.
Skills
Interest in computer vision and a research like project. Java for for the JOSM plugin part, possibly C/C++ for the algorithmic part.
Possible Mentors
Notes
Routing is quickly becoming an important usecase for OSM data, with many hobby and commercial routers starting to use OSM data for routing. So far the tagging of route related attributes is lagging behind somewhat compared to other taggings. One such attribute where OSM lags behind commercial : data sets is maxspeed tagging. When looking at MapDust, one can see that there are a large number of bug reports mentioning missing speed limits indicating that it is an important property for users.
The basic system would require to train a computer vision algorithm to detect speed limit singes in the video stream and the recognize the value of the limit. It would furthermore correlate the video frame with the GPS trace to determine the position of the speed limit. It would then present the information in a way to make it easy for the mapper to verify its correctness and copy it over into OSM. To make it as useful as possible, it should be implemented as e.g. a JOSM plugin. This project was already proposed for 2011, but was not funded.
|
|
Suggested By
Summary
A JOSM plugin which communicates with the Snapshot Server to download data which can then be merged (conflated) with the OSM database.
Skills
Java, potentially Ruby on Rails
Possible Mentors
Notes
A similar interface which interacts with the Snapshot Server is the Potlatch 2 merging tool. In JOSM, this plugin will display what projects are available from a list of Snapshot Servers, download data, then allow the conflation of these features with the OSM database. Depending on the progress made with this core task, further work could be involved in enhancing the JOSM conflation plugin or the Snapshot Server.
|
|
Suggested By
Summary
JOSM has a validation feature which checks for many common mistakes and gives the user an opportunity to correct them. Potlatch 2 has no such feature, and thus beginning users especially have a tendency to make easily correctable mistakes that can go unnoticed for some time, degrading data quality.
Skills
ActionScript 3
Possible Mentors
None yet
Notes
A framework must be designed to allow new arbitrary validation checks to be added, and a GUI must be designed to present the findings of the validation check in an easily understood manner, allowing users to quickly correct valid problems.
|
|
Suggested By
Summary
JOSM plugin (can be made as independent server combined with interface plugin) or completely standalone software- This software would take multiple gps traces determine which belong to the same way and would average them to determine actual shape of the road. This should be more precise than currently use estimation just by looking and guessing where the centreline is.
Skills
data processing, machine learning, programming in language of choice
Possible Mentors
None yet
Notes
Additional explanatory notes
|
Rendering Toolchain
|
Suggested By
Summary
For rendering purposes we need to import OSM data into PostGIS and keep it up to date (incremental updates). Currently osm2pgsql is the only tool which is able to do these updates and multipolygon processing. However the current implementation of osm2pgsql does not have a clean design and suffers from far to many hardcoded elements. A compatible reimplementation would be the way to go. Support of other output targets (SQLite, Shapefiles, etc.) would also be desirable.
Skills
Python (Imposm) or C++ (Osmium) programming
Possible Mentors
Oliver Tonnhofer (Imposm), agreed to mentor,
Notes
Imposm is a database import tool including multithreaded parsing, geometry building, filtering and PostGIS writing. Main effort would be on implementing diff support. Hstore support is still missing. osm2pgsql behaviour would be a so-called "mapping" configuration.
Osmium includes parsing with diff support, geometry building and has a different cache structure. A database interface needs to be built from scratch.
Comments
|
|
Suggested By
Summary
Easy to use rendering interface for on-demand rendering of limited (city sized) areas based on custom defined rules. Can integrate existing tools.
Skills
knowledge of rendering toolchain, programming in language of choice
Possible Mentors
None yet
Notes
Advanced computer user (without previous knowledge of GIS or OSM) should get first rendered maps (maybe with predefined rules) under one hour.
Comments
I am not sure exactly what is envisaged by this idea - is it a web service or a desktop application? I am working on a web application at the moment to create different types of pdf outputs [4], development implementation at [5] - is this the sort of thing you had in mind or something different? Grahamjones 20:44, 16 March 2012 (UTC)
|
Development of an Existing OSM Related Project
Routers
NB CycleStreets projects: See main update page on CycleStreets website. The CycleStreets code is in the process of being open-sourced (see blog post]) and clearly this would have to be done in time for the start of the programme. All the apps are now done and the router is next.
|
Suggested By
cyclestreets
Summary
Users improve the routes served by CycleStreets by making changes to OpenStreetMap data. They say this is 'hugely satisfying', even though they currently have to wait about 2 days for the changes to filter through our current processing. Making changes appear immediately in the routing is a great way to improve the service offered by CycleStreets, and to encourage more involvement in mapping and improving the quality of the routing, because it makes the feedback cycle much more rapid. Much more obviously, it can help us respond immediately to news of road works, road closures or heavy congestion. See main update page on CycleStreets website
Skills
Routing development, importing, network analysis
Possible Mentors
cyclestreets
Notes
The challenges for this project include these separate modules, each of which will benefit CycleStreets on its own:
|
{{GSoC idea
|title=CycleStreets 2: Less wiggly routes
|suggestor=cyclestreets
|summary=The shortest path algorithm used by CycleStreets considers the cost of using a street; it currently does not take into account the cost of moving from one street to another. Through a grid of streets this results in many left and right turns, rather than following the full length of the streets with only a single turn. See main update page on CycleStreets website
|skills=C++, Compression/efficiency structures. (We can provide knowledge of how cyclists behave in terms of actual modelling.)
|mentors=cyclestreets
|notes=Fixing this will result in more straightforward routes that should be easier to follow. The stages are:
- Respect the turn restrictions that are already expressed in the OpenStreetMap data
- Introduce a small additional cost of doing any turn - this will help with basic route straightening
- Take into account the differing costs of turning left versus turning right, including consideration of the road types
- Sticking to a designated cycle route by having a significant cost for turning away from the route.
|comments=The source code for this application has not been released as open source yet (23 March), so I would recommend that students interested in working on routing look at one of the open source OSM routers for their project. Grahamjones 20:16, 23 March 2012 (UTC)
}}
|
Suggested By
cyclestreets
Summary
The codebase of CycleStreets has been developed over the last 5 years and is in a traditional PHP class -based structure. It uses many established design patterns such as a front controller pattern, a central application resource, common data formats, etc. Amongst some of the legacy issues is that text is embedded throughout the application as hard-coded strings. We have received enquiries now from people in at least 13 countries for international versions of the system. Although a key constraint is server resources (if these were to be powered on central server hosting), another key barrier is putting in place internationalisation of the codebase such that strings are all in one place. See main update page on CycleStreets website
Skills
Refactoring, PHP, Internationalisation
Possible Mentors
cyclestreets
Notes
There are also other things that could have internationalisation applied to beyond strings.
|
|
Suggested By
OSM User name or email of person making suggestion (so we can contact them if necessary)
Summary
Cyclescape is an ambitious project to provide cycle campaign groups around the UK and their members with a toolkit for easy discussion and resolution of campaigning issues. It aims to make it easier for people to get involved, get up to speed on any issue facing cyclists, and discover best practices and case studies from around the UK. Geography is at the heart of the system. Although currently based on cycling, the codebase would be equally suited to other kinds of communities of interest for which geography can be applied to dealing with campaigning on real-world problems around our towns and cities. See main update page on CycleStreets website
Skills
Ruby on Rails, A strong grasp of usability
Possible Mentors
cyclestreets
Notes
There are a variety of areas of the codebase which could be worked on. For instance:
Comments
Not sure how to turn this idea into an OSM based project proposal? Grahamjones 20:16, 23 March 2012 (UTC)
|
|
Suggested By
cyclestreets
Summary
CycleStreets currently offers cycle routing in the UK & Ireland from a single server (plus resilience servers). This is about 1% of the planet. The databases that support this total 6GB. A few other areas have been added for initial testing. See main update page on CycleStreets website
Skills
C++, efficiency and scaling
Possible Mentors
cyclestreets
Notes
Scaling up to cover the whole world involves a number of appealing challenges:
|
|
Suggested By
cyclestreets
Summary
The key value that CycleStreets adds comes from how it converts tagging from the OpenStreetMap source data into a costed routing network. A shortest-cost algorithm searches that network for routes. Currently the conversion uses inference rules start with the most significant data, which comes from the highway tag to give an initial costing. The costs are tuned up or down by analysing other tags that describe the street. They may indicate whether for instance it lies on a signed cycle route, has traffic calming or a range of other attributes that affect how pleasant or not it is to ride. All of that information is boiled down to a single cost which is used by the algorithm to choose a route. From our feedback we know that users often need to understand why the given route has been suggested over one they already know about. See main update page on CycleStreets website
Skills
C++, efficiency, usability
Possible Mentors
cyclestreets
Notes
The steps involved are:
|
Renderers
|
Suggested By
robotnic
Summary
Some people are not able to use online maps because they can't read the small fonts on the map. The result of this project should be a slippy map with big fonts.
Skills
Map styling, HTML, JavaScript
Possible Mentors
Notes
|
|
Suggested By
Framstag
Summary
Libosmscout is a C++ library for routing and offline map rendering (see http://libosmscout.sf.net). While routing and rendering already works, there a number of things that could be improved: See below list of possible tasks. See also the features page for current status and things that could be improved or added. Contact me for details.
Skills
C++
Possible Mentors
Notes
|
|
Suggested By
Summary
A map shall be rendered from a given city that can be used to play a game. Possible games are: "Scotland Yard", "Zug um Zug", "Deutschlandreise" and many more. One project shall only cover one game.
Skills
Programming a renderer for OpenStreetMap data.
Possible Mentors
Notes
|
|
Suggested By
Summary
A renderer shall be programmed that shows changes to the map stylesheet immediately.
Skills
Programming a renderer for OpenStreetMap data.
Possible Mentors
Notes
Comments
Is this different to tileMill? Or are you thinking of developing tilemill so that you have a more graphical interface to select line colours etc? We might need to expand this a bit to help students turn this into a proposal. Grahamjones
|
|
Suggested By
Geonick
Summary
Kothic JS is a JavaScript map vector rendering engine using HTML5 Canvas. Extend browser library as well as server-side queuing/caching.
Skills
JavaScript, web programming, Python
Possible Mentors
Notes
Make easier way of generating JS tiles (tirex integration), enrich visual abilities, add interactivity. See Kothic JS project page
Comments
none.
|
Mobile Applications
|
Suggested By
Summary
It should be application using most of the OSM Components, should be able to provide all the basic functionality like displaying map both online and offline and vector maps with navigation and routing. e.g. A application like google maps or iPhoto. It should be totally free in cost and as of use of freedom without any adds.
Skills
Android Mobile Applications Development
Possible Mentors
Notes
There are large number of applications available using OSM data but may be only for their own purpose, most of the users never aware of all the applications and at some extent these applications asks users to pay for the complete functionality. So making this application as default of OSM can increase the usability of OSM on mobiles specially on Android.
Comments
* The CycleStreets Android app has clearly done some of this but more could be added; the codebase would be a useful start. - CycleStreets
|
|
Suggested By
Summary
The NeoMap App is an Android app (open source) which displays OpenStreetMap (Mapnik) tiles. It has the usual navigational functionality like zoom/pitch, pan, center to GPS. It's using OpenGL which makes it easy to rotate even in 3D. The app downloads and caches OpenStreetMap tiles locally for offline use. It can overlay raster maps - called "NeoMaps" which are downloaded from a plattform. These NeoMaps are either own (private) or shared to the public. The main issues to be enhanced are: take 'georeferenced' notes (for later OSM editing), measure distance, do name search, display map scale (based on DPI), get DPI of Smartphone automatically, support OpenGL 2.0, better layer handling, cooperate with GPS tracking apps, etc. Up to now it's not planned to become a route planner or an editor.
Skills
Java, Computational Geometry
Possible Mentors
User:Geonick (see [6])
Notes
Comments
There's already one student from Geonick interested in this proposal.
|
|
Suggested By
cyclestreets
Summary
The CycleStreets iPhone app is currently a journey planner rather than a full satnav. A full vector-based 3D mode could be added, to reduce download sizes and add greater functionality.
Skills
Objective-C, design
Possible Mentors
cyclestreets + an iOS developer
Notes
The source is on GitHub.
|
Data processing
|
Suggested By
Summary
OGR (part of GDAL) is the most commonly used vector feature library, however it does not support reading or writing OpenStreetMap XML data. While there currently exists many ways for users to convert OSM data to other formats, such as Osmium and others, none have the ease of use or widespread adoption and familiarity as OGR.
Skills
C++
Possible Mentors
Notes
The focus should be on a full-featured read-only implementation, allowing those outside of the OSM community to quickly and easily use OSM data in other GIS applications. There will be some challenges, considering that the OSM data model is significantly different than the Simple Feature model employed by OGR, however there is a simple mapping between the two for the most common cases. Another issue is that OSM has a free-form tagging scheme while OGR expects a fixed set of fields for all objects in the layer, however initially this set can simply be the union of all keys for all objects (for more flexible and powerful tools users should seek other solutions such as Osmium).
References
|
|
Suggested By
Summary
Many mobile applications can (or could) record GPS tracklogs, and these can be uploaded to OSM. This idea is about an independent internet service which could receive large amounts of automatically submitted tracklogs, optionally uploading them to OSM (if the owner permits) but mainly try to use mathematical/statistical methods to average the overlapping traces, generate roads from them, possibly guessing road attributes from speed and other factors, not forgetting to watch the age of the logs processed. The result could be presented as guesstimated (current or historical) roads as JOSM layer for further processing, or as a slippy map for use as a background layer for JOSM/other editors to help mapping.
Skills
Possible Mentors
None yet
Notes
Many companies which generate tracklogs (by hundreds a day) suggested that they may offer anonymised logs in quite large amounts which may or may not be unfeasible to upload directly to OSM servers. Some applications could submit logs automagically (OSMand comes first to mind) but it would result quite large amounts of overlapping traces either. It should be noted that the data should be published under compatible free license(s), best multilicensed by cc-by-sa and odbl.
|
Editing Coordination
|
Suggested By
Summary
The Tasking Manager is used by the Humanitarian OpenStreetMap Team to coordinate volunteers in mapping areas effected by disaster. It could be made better by adding more social aspects to the tool, that way volunteers could discuss tasks and help each other. For example right now there is not an easy way to ask questions about tasks and the validation step could allow more interaction.
Skills
Python
Possible Mentors
Notes
The website for the tasking manager and the Github repo.
|
Creation of a new OSM Related Project
GPS
|
Suggested By
Summary
It shall be possible to reach an accuracy that helps to detect for sure on which side of the rode the GPS device is located. An app and a server component shall be created to collect data by crowdsourcing. The user shall enter on with side of the road he/she is walking and the WLANs in reach shall be detected, saved and uploaded to the server. The goal is to enable blind persons to walk with GPS device. The street data shall be taken from OpenStreetMap.
Skills
Programming an app on a mobile device, programming a server component (can be different persons)
Possible Mentors
Notes
Comments
|
Friend Finder (Social Media Application Using OSM Data)
|
Suggested By
Summary
As Popular application named Latitude used by Google is getting popular these days. So we can also have an application for Android Devices (For the time) to have a position based tracking of friends that are added by user. This application will use the latest OSM and data and get sync. at regular intervals. This application will use enhanced features of Shortest route routing along with the additional features like Plotting of raw data formed by tracking by user(Later on Phase).
Skills
Possible Mentors
None yet
Notes
Comments
|
Anomalies Detection Engine
|
Suggested By
Summary
With more and more people editting, the chance of errors and mistakes (as well as vandalism) becomes larger. For example, deleting a whole bunch of POIs are your first edit, or disrupting a route relation by mistake. It is important for data consistency that those mistakes are detected early.
This GSoc idea is all about creating an (automated) engine that can spot mistakes. In order to do this you could use some machine learning techniques with parameters being: the age of the user, the number of edits, what happens in a changeset etc. The goal of this tool is to have an engine that is ready to use and as output has a list of "suspect" changesets that can easily be reviewing (and possible reverted). Deliverables include: the detection engine, a list of parameters for the engine, and a GUI viewing the detected anomalies. Documentation is required as well. Extra points for an extensible framework for detection parameters.
Skills
For the engine: one or more programming languages (as preference, python, PHP and/or C). For the GUI: HTML and JavaScript (though no need to be great at designing).
Possible Mentors
Notes
|