GSoC Project Ideas 2012

From OpenStreetMap Wiki
Jump to: navigation, search

Introduction

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:

  1. Development of existing OSM infrastructure (main web site, database, editors or rendering tool chain).
  2. Development of existing OSM related projects (routers, renderers, mobile apps etc.).
  3. 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
Example - JOSM Plugin to do xxxx
Suggested By
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 Required
Skills Required to succeed with the project
Possible Mentors
OSM User names or emails of Possible Mentors
Notes
Additional explanatory notes
Comments
brief comments

Project Ideas

Development of Existing OSM Infrastructure

Main Web Site / API Database

Update Monitoring API
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 Required
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)
Lots of OSM widgets / OSM widget constructor
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 Required
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.
  • Simple map with a marker
  • Known-route shown with markers
  • 'Directions to here' (perhaps with a choice of provider as a simple setting)
  • Routing panel
  • All the above then wrapped as plugins for Wordpress, Drupal, .net-based stuff, etc, etc.
  • Choice of map providers as a simple setting.
Cloudmade's new Leaflet.js would be a good base as it is very lightweight.
Comments
brief comments

|

Implement JSON REST API in OSM Rails port (openstreetmap-website)
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 Required
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 )
Nominatim (or alternative)
Suggested By
sabas88
Summary
Intelligent feature finder (street, POI)
Skills Required
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.
Comments

Editors

HTML Based Micromapping Editor
Suggested By
robotnic
Summary
An Editor that enables the User to do micromapping based on "width" and "offset" property [1].
Skills Required
HTML, JavaScript, map library
Possible Mentors
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)


Improve / Create Simple Android OSM editor
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 Required
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)
Video based speed limit detector
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 Required
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.
Comments
Collaborative data merging with JOSM
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 Required
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.
Comments
Validation feature for Potlatch 2
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 Required
ActionScript 3
Possible Mentors
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.
Comments


Plugin or standalone software for interpolation of multiple gps traces
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 Required
data processing, machine learning, programming in language of choice
Possible Mentors
Notes
Additional explanatory notes
Comments

Rendering Toolchain

Rendering Database import tool (osm2pgsql successor)
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 Required
Python (Imposm) or C++ (Osmium) programming
Possible Mentors
Oliver Tonnhofer (Imposm), agreed to mentor, Jochen Topf (Osmium)
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
This could be based on either Osmium or Imposm. Both are a good choice. --emka 16:32, 9 March 2012 (UTC)
Easy renderer
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 Required
knowledge of rendering toolchain, programming in language of choice
Possible Mentors
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)
I meant a desktop application, but a web service would be fine as well. Something as Maperitive, but more user friendly (UI for rendering rules, some more predefined styles...). Actually Maperitive would suffice my definition, but some competition can only help. By existing tools inegration I meant that it does not have to start from scratch. LM 1 01:10, 17 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.

CycleStreets 1: Live routing (immediacy)
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 Required
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:
  • Making available a replicated up-to-date planet database
  • Devising changeset processing that can dynamically update our routing network to offer live routing in a developer edition of the site
  • A similar module that can be used by our routing compression technology
  • Incorporating the compressed network changes dynamically in the C++ routing module to offer live routing updates on the main site
Comments

{{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) }}

CycleStreets 3: Internationalisation
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 Required
Refactoring, PHP, Internationalisation
Possible Mentors
cyclestreets
Notes
There are also other things that could have internationalisation applied to beyond strings.
Comments
CycleStreets 4: Cyclescape
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 Required
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:
  • Usability improvements
  • Generalisation to other areas of interest (e.g. equestrian/pedestrian interests)
  • Methods of connecting issues together geographically
  • Assignment of new contextual layers using OSM data (CycleStreets has an API that could be developed further)
  • We hope in the longer term to use it to add accessibility analysis and other tools based on OSM data.
Comments
Not sure how to turn this idea into an OSM based project proposal? Grahamjones 20:16, 23 March 2012 (UTC)
CycleStreets 5: Scale up to whole planet with cycle routes
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 Required
C++, efficiency and scaling
Possible Mentors
cyclestreets
Notes
Scaling up to cover the whole world involves a number of appealing challenges:
  • Scale up to cover Europe first - about 10 times increase in the current data size
  • Consider using multiple servers and whether to fragment the routing system
  • Finding a way to allow groups from other countries to control and manage the routing system - particularly in the handling of feedback
Although other engines are starting to see cycle routing added, it is our aim to have very detailed levels of routing beyond things like "A cycle lane must be good" - routing which genuinely 'thinks like a cyclist'.
Comments
CycleStreets 6: Why-routing - 'why has the router chosen that route?'
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 Required
C++, efficiency, usability
Possible Mentors
cyclestreets
Notes
The steps involved are:
  • Clearer explanation on our website about how the routing system works in general
  • Demonstrating how the routing cost of a street has been derived from the OpenStreetMap tags
  • Compare the cost of one route with another
  • Allow users to replan routes by avoiding marked streets
Comments

Renderers

Map for visually handicapped
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 Required
Map styling, HTML, JavaScript
Possible Mentors
Notes
Comments
Enhancement of libosmscout
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.
  • Improve import speed: Import performance is crucial for importing larger regions like countries or bigger. Task would be to analyse and improve import speed by improving used algorithms, integrate multi-threading for CPU bound tasks or similar.
  • Improve routing speed: Routing speed is crucial for routing on devices with low memory and processing power (like mobiles). Task would be to either improve the existing algorithm (A*), improve the underlying routing graph by applying optimizations on it or by integration a new routing algorithm (like contraction hierachies).
  • Improve routing description quality: Routing is not only performance. The quality of the routing description is also important. libosmscout uses a plugin interface to aggregate additional description information. Task would be to analyse and improve existing plugins, (optionally) enhance the existing routing data (if necessary) and use the existing plugin interface to add new plugins that add further information.
  • Rendering speed: Current rendering speed on desktop is about 50-250ms for a 800x480 tile depending on zoom level. For mobiles this is possibly not fast enough. Task is to reduce the amount of rendered data, improve access to existing drawing backends or write new backends to have faster access to rendering hardware.
  • Rendering quality: libosmscout uses a style sheet driven rendering engine: Task is to design and implement a new style sheet syntax that allows more fine graned use of the existing rendering features and to enhance the existing styles with new styles to improve the look of the map. A new, improved style using the new features should also be the result.
  • Improve overall performance: libosmscout internally uses osm ids to order objects. However osm ids with close values do not necessarily be placed near by. This leads to lot of scattered loading in libosmscout. Task is to implement a import step that reorderes data and gives them new ids so that objects with close by ids and file data location are also close on the resulting map. This should reduce the number of blocks loaded from disk and increase overall speed.
Skills Required
C++
Possible Mentors
Notes
Comments
Games based on OSM data
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 Required
Programming a renderer for OpenStreetMap data.
Possible Mentors
Notes
Comments


WYSIWYG Map Renderer
Suggested By
Summary
A renderer shall be programmed that shows changes to the map stylesheet immediately.
Skills Required
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


Extend Kothic JS (JavaScript map vector rendering engine)
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 Required
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

OSM Application for Android
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 Required
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
  • The "official" part is very unlikely to happen - OSM has never adopted any app as the "official" tool for a platform. Just focus on doing a good job. --Tordanik 23:35, 9 March 2012 (UTC) (deleted "official from the title - Grahamjones 19:39, 12 March 2012 (UTC)).
  • This is a very general project idea. To turn it into a successful project proposal, the applicant will need to:
    • Review existing mobile applications.
    • Identify a gap - what do you want to do that is not done by an existing application? A proposal to write another tool that is similar to an existing one is unlikely to be successful.
    • Is the intention to target a specific platform or make a multi-platform application (a multi platform one is a good idea because otherwise you end up trying to maintain different applications for different platforms).
    • Decide how to do it - is the proposal to develop an existing application, or start from scratch? (A big hint - I will look MUCH more favourably on a proposal to improve an existing application than start from scratch - a problem with GSoC is the relatively limited time - starting from scratch means you will spend most of the time getting the basics working, rather than concentrating on the user interface - it would be far better to start with existing code that does 80% of what you want and develop it - far more likely to get a finished 'product' at the end of the project. There are previous GSoC projects that have done a lot of the ground work, which could be developed too.
    • Grahamjones 19:39, 12 March 2012 (UTC)
  • OsmAnd has a nice and extensive set of features now. A GSoC project can help for instance in making the renderer available for other applications, or can improve the offline routing algorithm, or make it easily extensible with plugins (to act it as a framework for more specialized uses. --Sarchittuorg 19:52, 16 March 2012 (UTC)
  • OpenTripPlanner for Android is an open-source mobile client that can interface with any OpenTripPlanner server via a RESTful API for multimodal (bike/transit/walk) trip planning. OpenTripPlanner for Android uses osmdroid to display OSM map tiles to the mobile user, and OpenTripPlanner server uses OSM data for bike/walk navigation. OTP for Android code could definitely serve as a base for a GSoC OSM/Android project, as it is licensed under Apache 2.0. --Barbeau
Offline Map Viewer App with Notes - Enhancing NeoMap App for Android
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 Required
Java, Computational Geometry
Possible Mentors
Notes
Comments
There's already one student from Geonick interested in this proposal.


CycleStreets 7: Addition of full vector 3D mode to iOS app
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 Required
Objective-C, design
Possible Mentors
cyclestreets + an iOS developer
Notes
The source is on GitHub.
Comments

Data processing

OpenStreetMap XML driver for OGR
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 Required
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

Comments


Automated GPS tracklog aggregation
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 Required
Possible Mentors
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.
Comments

Editing Coordination

Make the Tasking Manager More Social
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 Required
Python
Possible Mentors
Notes
The website for the tasking manager and the Github repo.
Comments

Creation of a new OSM Related Project

GPS

Improve GPS accuracy by crowdsourcing of visible WLAN access points
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 Required
Programming an app on a mobile device, programming a server component (can be different persons)
Possible Mentors
Notes
Comments
1) WiGLE maintains a database for years now; 2) The accuracy doesn't feel very reliable (you can check); 3) The privacy concerns may render the project unusable, even forbidden in many countries (and the authors liable) --grin 08:39, 14 March 2012 (UTC)


Friend Finder (Social Media Application Using OSM Data)

Android Application to have complete tracking record of Friends 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 Required
Possible Mentors
None yet
Notes
Comments
OsmAnd recently added support for live tracking by periodically hitting a configurable web service with your current location. Might be usable for something like this - ToeBee 04:10, 22 March 2012 (UTC)

Anomalies Detection Engine

An engine that detects anomalies in edits/changesets
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 Required
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
Comments