You are here: Wiki>Projects Web>GSoC>GSoC2020ProjectIdeas (25 Mar 2020, ArneDeWall)Edit Attach

Project Ideas for Google Summer of Code at 52°North in 2020

The is the ideas page for the Google Summer of Code 2020. If you are an interested student please don't hesitate to contact mentors directly or discuss your own ideas on the mailing lists.

To add your idea, please use the project template at the end of the page or add a minimalistic sentence in the "coarse ideas" list - but add your signature in any case. Thanks!

Information for Students

General information: GSoCForStudents - please read before asking questions!

52°North is an open organisation with several "communities" on specific topics. The list of ideas below was created by the community leaders and code managers of different projects organized within these communities. The "Draft Ideas" section contains ideas still under discussion between mentors and org admins, or incomplete ideas, so please get in touch before starting the code challenge.

Beyond our ideas, we welcome your ideas for projects related to our communities and encourage you to get in touch with the communities on the respective mailing lists to discuss your own project ideas.

How do I choose a project?

Some of the software projects are available pre-built on the OSGeo Live demo, including project overviews and tutorials where you can try everything out. Download the ISO from If you have not found an idea that interests you on this ideas page, there are other organisations with great topics on geospatial technologies, and everything related to "geo" really is the best in our opinion. So check out the ideas pages of like minded projects: OSGeo, OpenStreetMap.

Challenge yourself with one or more of the coding challenges - you will best realize if a software interests you when you have some hands-on experience with it. And that is the most important part: you must really find the project interesting.

Ready ideas

Angular WPS Client library

Explanation: The Web Processing Service (WPS) JavaScript library written in JavaScript was first released in 2014. However, the wps-js library does not fully support all WPS features and typings for TypeScript -based Clients like Angular are missing. Hence, a new TypeScript -based Angular WPS Module is needed for the future. Some concepts from the JavaScript -based wps-js library can be taken over, while others need to be updated and additional missing WPS features need to be implemented.

Further Reading: JavaScript-based WPS library on GitHub , OGC WPS 2.0 Interface Standard (Document 14-065) and Web Processing Service (Document 05-007r7)

Required Skills: Angular 7 or 8, TypeScript, optional: experiences with OGC Web Processing Services

Expected results: The Angular WPS Client library reliably works with WPS 1.0.0 and 2.0.0 servers, supports XML POST Binding Extensions and Dismiss Extension, and comprehensively provides TypeScript typings for WPS responses and their properties.

Code challenge: Create a basic Angular 7(8) project module with a WPS library service. The service should provide a WPS constructor consuming URL and VERSION of a WPS server. A Method for sending a GetCapabilities -request should be implemented and it's return should be a 'capabilities' TypeScript class. The capabilities object should contain (at least) the array of processes, where each process is a TypeScript class containing 'identifier', 'jobControlOptions', and 'outputTransmission' as Strings (or Arrays of Strings).

You can test your implementation with a demo wps supporting both versions (1.0.0 and 2.0.0) at

Community and Code License: MIT License

Mentors: [Benjamin Pross (]

WPS Client for R

Explanation: Various processing functionalities are exposed as public or internal Web Processing Services (OGC WPS) that wrap complex models or simply standardize approaches. Directly assessing these WPS via a simple R interface from inside R (nicely linked with state of the art spatial and spatio-temporal data structures) would ease the (re-) use of WPS for a wider community and allow to outsource typical operations. The project shall not only focus on the WPS R Client, but also on a shiny extensions/application, that nicely integrates the building blocks to elevate the WPS R Client to a modern and versatile web application.

Expected results: An R package available from CRAN that allows easy access to WPS functionality in an R-like fashion and (possibly as separate R package) a shiny extension/application

Code challenge: Community and Code License: Geoprocessing and Spatio-Temporal Data Science. Apache Software License, Version 2.

Mentors: Benedikt Gräler (, Benjamin Pross (

Improvement of the Car Selection Process in the enviroCar Android App

Explanation: One essential configuration in the enviroCar Android app is the selection of the drivers vehicle type. In the current app, users have to manually fill out a form with essential informations of the vehicle such as the type of fuel, the engine displacement, and the year of construction. This process, however, is prone to errors since the user has the flexibility to create artificial types of cars with arbitrary attributes. In addition, some information such as a coarse categorization of the car is missing, which can be a very important information for some analytics. In the meantime, the enviroCar team has created a data set with a list of manufacturers and types of motor vehicles (see this webservice), which can act as the foundation for improving this selection process. By having this predefined set of vehicles with all necessary information about the vehicle attached, the selection process can be significantly simplified and the global database unified.

The aim of this project is to fundamentally revamp the car selection process in the enviroCar app. The new car selection should be based on the predefined vehicle list and their attributes (note: we will provide a sqlite database during the project and not during the coding challenge; the intention is to ship this database in the final apk!!!). This includes new and shiny UI elements for the selection with some good user experience and an overall integration into the app. To also make this selection available offline, we intend to make an sqlite based offline implementation and deliver the informations of vehicles with the build apk. In the same run, the database layer of the app should be fundamentally revised. The current version is still based on sqlbrite, which has been deprecated and Android Room has become the de facto standard for modern sqlite implementations on Android.

Required Skills: Very good in Android software development in Java; experience in Test-Driven-Development; knowledge of modern development paradigms and frameworks for Android (RxJava2, Dagger2, Otto, Android Room, etc.). Good command of UI/UX development for Android. Familiarity with up to date Android components.

Expected results: A revamped car selection process based on the predefined list of manufacturers and vehicle types (we will provide a sqlite database for that); a shiny and intuitive selection process of vehicles; an additional database layer based on sqlite and Android Room for loading information for manufacturers and car types. Reimplementing the existing database layer for tracks based Android Room; Implement tests for all database entities and queries (try to stick to a TDD)

Code Challenge: Checkout the current enviroCar-app and make a first mockup implementation of the selection process. You can fetch some static data from this REST-API (it is not necessarily required to write a complete DAO layer for that. You can also hardcode it). The implementation doesn’t need to be complete. It should show your skills in Android design (important - this is the challenge)and should provide us a first glimpse on the general usability you intend to realize. Just design a stunning new attempt for the car selection process and prove your skills in designing modern UI components that follow novel design standards. If it feels like a user interface not being part of the app, then you are doing something wrong! Convince us!

For the Submission: Please provide a google doc for explaining your approach and of course a link to the fork of the repository.

Community and Code License: GPLv3

Mentor: Arne de Wall (

Animated Map Visualization of enviroCar Data with

Explanation: enviroCar is an open platform for collecting and analyzing floating car data (xFCD). The collected data consists of GPS positions enriched with additional sensor information by utilizing the vehicle’s internal diagnostic capabilities. All data that has been collected and uploaded to the enviroCar server is freely published under the Open Database License (ODbL). The general aim of the enviroCar project is to provide an citizen science platform with many possibilities to analyze the data.

With this project we intend to extend the visualization capabilities with an additional based dashboard for time-based animation., which is developed by Uber, provides a “WebGL2-powered framework for the visual exploratory data analysis of large datasets”. The idea of the project is to take a certain data set from the enviroCar platform (e.g. for a city such as Mönchengladbach or Münster in Germany) and to visually animate how this dataset has grown or certain statistics have changed over the time. This could be, for instance, an animated time lapse of all tracks collected during a certain period (e.g. 2 Weeks) or aggregated statistics for a certain grid. With this project, we would like to provide citizens who have participated in a Citizen Science campaign of cities with a visual tool that allows them to inspect the collected amount of data.

Required Skills: Very good JavaScript (or TypeScript) skills including experience in React; experience with different web developing tools such as webpack; good understanding of different geospatial visualization methods (must have); experience with is a huge plus!

Excepted Results: A based animation of enviroCar tracks.

Code Challenge: Create an initial project based on react and Download some enviroCar data from the enviroCar API and create a first visualization layer. Make the visualization colorful based on the attached attributes that the enviroCar data provides. Don't make a visualization for single tracks but rather create a visualization for multiple tracks (e.g. for a fixed city or an arbitrary bbox).

Mentor: Arne de Wall (

Binary Encoding for enviroCar

Explanation: The current data format in communication with the enviroCar server is based on JSON. However, this exchange format is not the most efficient choice. Especially for very long journeys, this encoding tracks tends towards very long serialization times and exchange sizes, contrary to the general strategy in handling mobile devices.

In recent years, a lot of different binary-based serialization frameworks raised that allow a platform- and language-neutral way of encoding structured data for use in communication protocols. These frameworks allow memory efficient serialization under high speed that significantly outperform traditional encodings such as XML or JSON. Some examples include protocol buffers (aka. protobuf) developed by Google, FlatBuffers, Apache Avro, Messagepack.

The aim of this project is to implement an additional binary encoding for the enviroCar ecosystem. In general, this requires requires adaptations to the serialization layer of the enviroCar Server and the enviroCar Android app. Adaptations to other components such as the enviroCar WebApp are optional and not required.

Required Skills: Android and Java software development, experience in building RESTful services, understanding of Maven&Gradle build management tools, experience in protobuf, Jersey

Expected Results: Definition and Implementation of an binary encoding for the enviroCar API. This includes corresponding schemas and a proper integration in both the enviroCar mobile app and the enviroCar Server. The implementation of tests is a matter of course.

Code Challenge: Setup a local instance of the enviroCar Server and complete the implementation with a binary encoding for a single element from the enviroCar API of your choice (e.g. Measurement). An restricted dump of the MongoDB database containing some test data can be found here. In addition, write some tests and provide a Postman collection for testing along with the packaged .war file of the server.

Mentor: Arne de Wall (, [Christian Autermann]

Combining Helgoland with Shiny and R

Explanation: Helgoland is a product from of the 52°North software suite acting as a web-based fronted to an OGC sensor observation service (SOS). As such, Helgoland comprises different views and selection operations on the sensor data stored in the SOS. This includes a map view/selection, list selection and time series plots and table views. Shiny Apps can bundle a lot of R's analysis capabilieties in handy web applications. The aim of this projet is to merge these two tools to add direct analysis capabilities to the Helgoland SOS viewer.

Required skills: Java Script; R, i.e. Shiny extensions

Expected results: a full feature Shiny integration with 52°North's Helgoland SOS viewer

Code challenge: Providing a shiny application interacting with some SOS instance and performing a set of analysis tasks where the time series selection is based on the Helgoland client.

Community and Code License: Spatio-Temporal Data Science Community, Apache Software License, Version 2

Mentors: Ben Gräler (, Jan Schulte (, Simon Jirka (

enviroCar Trajectories in R

Explanation: Currently, several R packages exist that deal with trajectory data in R. Some deal mainly with the data structure of trajectories while others provide access to trajectory data sets and a couple of packages is designed for the analysis of trajectory data. This GSoC project aims at unifying this landscape and adapting to recent developments in the spatial/spatio-temporal data handling in R (i.e. sf). The R package shall provide generic classes, methods and tools for handling and analyzing large-scale trajectory data with R. Data from the enviroCar API will be taken as example data.

Required skills: R (i.e. package design), some background in computational geometry and/or (geo-)statistics.

Expected results: Classes and methods for handling trajectories in R, building on recent developments in the spatial/spatio-temporal data handling in R (i.e. sf). Low-level manipulation will involve selection, aggregation (to a lower spatial and/or temporal resolution), sampling, simple (linear) interpolation and visualisation (animation, space-time cubes, projections, ...). Analysis methods will include computation of several attributes (speed, direction); computing distances between trajectories; package should be ready for submission to CRAN.

Code challenge: Provide a R package with a trajectories data structure that extends sf. The package shall be capable of quickly importing a set of enviroCar trajectories from the enviroCar server. Furthermore, the package shall provide functions to compute meaningful distance measures between single tracks. Provide proper documentation (clean CRAN checks).

Community and Code License: Spatio-Temporal Data Science Community, needs to be determined (maybe GPLv3)

Mentors: Ben Gräler (, Arne de Wall (

UI for the Arctic Sea settings API (Faroe)

Explanation: The faroe API of the Arctic Sea framework lets you set the properties for OGC services (e.g. Service Identification and -Provider, see this Capabilities document: Capabilities). The settings are stored in JSON files. This project should create a Web-frontend to create, read, update and delete (CRUD) the JSON settings. The frontend should be written in JavaScript. Also, a REST API will be needed on top of the faroe API. The UI should be easily extensible (for example see the properties for the javaPS Well-known text (WKT) parser) and customizable, e.g. with customer logos.

As an optional extension, Faroe could be extended to run as a standalone service. It should offer an API (e.g. based on WebSockets) to subscribe to setting changes and provide a implementation of SettingsService that uses a remote instance of Faroe for configuration.

Required skills: software development skills in Java and JavaScript

Expected results: UI components and a REST API for the faroe settings API

Code challenge: We expect the basic components (JavaScript UI, REST API) to be there to have a good starting point for the project. A simple form to set one or more service settings via a rudimentary REST API.

Community and Code License: Cross-community project. Apache Software License, Version 2.

Mentors: Christian Autermann (, Benjamin Pross (, Carsten Hollmann (

.NET WPS Client 2.0 for ArcGIS Pro

Explanation: The goal of this project is to enhance the WPS Client for ArcGIS Pro that was implemented during GSoC 2019.

Further reading: wps .NET library, WPS client for ArcGIS Pro, Java-based WPS Client for ArcGIS on GitHub, ArcGIS Pro SDK Community Samples WPS 2.0 Interface Standard

Required skills: .NET software development, Experience with ArcObjects .NET, experience with OGC Web Services_ and understanding of geospatial concepts is strongly recommended.

Required software: ArcGIS Pro. Please try to obtain a free trial version to complete the code challenge. Successful applicants can be provided with a research license, if needed. Check here for a free trial: ArcGIS Pro Free Trial

Expected results: New version of the WPS Client for ArcGIS Pro with improved user experience.

Code Challenge: Set up the WPS client for ArcGIS Pro and get to know the code. Think about ways to improve the client and share your ideas with Benjamin.

You can test your implementation with a demo wps supporting both versions (1.0.0 and 2.0.0) at

Community and Code License: Geoprocessing Community, Apache Software License, Version 2

Mentor: Benjamin Pross (

[PLEASE DO NOT APPLY FOR THIS ANYMORE] Python Analytics Toolbox for enviroCar

Explanation: enviroCar is an open platform for collecting and analyzing floating car data (xFCD). The collected data consists of GPS position enriched with additional sensor information by utilizing the vehicle’s internal diagnostic capabilities. All data that has been collected and uploaded to the enviroCar server is freely published under the Open Database License (ODbL). The general aim of the enviroCar project is to provide an citizen science platform with many possibilities to analyze the data.

Python has become a trending topic for data science in recent years. Especially Jupyter notebooks are powerful tools that have become very popular to data scientists in recent years. While enviroCar already provides many possibilities to analyze the data (e.g. in the enviroCar mobile App, WebApp, processing services, R package, etc.), a simple integration into Jupyter notebooks is not yet possible. The course of the enviroCar platform in this year, however, is to extend the analytical capabilities of the platform and a python toolbox is one of the focuses.

This project aims to initialize a python toolbox for accessing, processing and visualizing enviroCar data. The toolbox should be able to request data from the enviroCar API, store it in python specific data structures such as numpy or pandas, provide profound possibilities for processing the data and plotting (e.g. matplotlib, seaborn, etc.) or visualizing it on a map (e.g. ipyleaflet, bokeh). Beside the basic functionalities, the main focus of the toolbox is to is to include several algorithms for trajectory analyzes. This can include possibilities for spatio-temporal aggregation of tracks, finding and clustering tracks based on similarity, resampling of tracks, snapping trajectories onto OpenStreetMap road segments (MapMatching), detecting HotSpots, and many more. Another possible part could be to use the reticulate R interface to Python in order make the algorithms available in python.

We expect from students a solid understanding in dealing with spatial data, or even better with spatio-temporal trajectory data. Advanced understanding in the area of computational geometry is helpful here. Proposals for this project are expected to cover concrete ideas for the core of the implementation and also a concrete plan which advanced algorithms will be implemented, which tools or libraries you want to use to achieve your goals, and a proper evaluation of your results (e.g. MapMatching accuracy on trajectory data).

Required Skills: Good Python 3 programming skills (especially OOP), very good experience in data science typical python libraries (e.g. numpy, (geo-)pandas, matplotlib, seaborn, etc.), experience with Jupyter Notebooks; Experience in the field of computational geometry required. (We consider this project to be challenging)

Excepted Results: Python Toolbox for enviroCar that allows to request data from the enviroCar API, stores the data in python typical data structures, and that provides some basic plotting and visualization capabilities. In addition to that, the toolbox should also provide advanced means of (pre-)processing tracks such as MapMatching, similarity measurements or different ways of spatial/temporal aggregation.

An additional R intergration via reticulate is a nice-to-have and depends on the proposal of the student.

Code Challenge: Write a single jupyter notebook that requests data from the enviroCar REST API and visualizes the data on a map and within graphs. Perform various analyses based on single and multiple tracks that make sense to you. You are free to use any python package you like. Try to exemplify in your notebook on how you want to deal with the enviroCar data during GSoC. Make first attempts on how you want to structure the final python package. Add markdown describing your ideas in more detail.

Mentor: Arne de Wall (, Benedikt Gräler
Topic revision: r10 - 25 Mar 2020, ArneDeWall
Legal Notice | Privacy Statement

This site is powered by FoswikiCopyright © by the contributing authors. All material on this collaboration platform is the property of the contributing authors.
Ideas, requests, problems regarding Wiki? Send feedback