Version 15 (modified by wenzeslaus, 4 years ago) (diff)

remove student name, may be misleading

Grasslogo vector small.png @ 500px-GSoC2016Logo.jpg​ @ OSGeo 220pix.png

GRASS Google Summer of Code 2017



Post your ideas here or to the grass-dev mailing list if you want to discuss them more. To edit this wiki, you need to login with an OSGeo Userid; read also some help for using trac.

If you are a student you can suggest an new idea or pick up an existing one in any case write about it to grass-dev mailing list.

You are invited as well to have a close look at (and re-suggest!) ideas from previous years (2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2014, 2016) which have not yet been implemented. You can also look at accepted GRASS GSoC projects from previous years for an idea of scope.

Include "GRASS GIS" in the title of our idea to easily distinguish ideas and projects inside OSGeo.

Some bigger ideas may have their own pages, so you can link them here. The pages can be either independent if the page already exists (e.g. wxGUIDevelopment/SingleWindow), or more preferably subpages of this page if the idea is (re-)developed for this GSoC. In the later case, use the word "idea" in the page name to distinguish the idea page (e.g. GSoC/2017/CoolGRASSProjectIdea) from the possible student project page (e.g. GSoC/2017/CoolGRASSProject).

Additional functionality for running GRASS GIS modules in Jupyter Notebook

  • Start of GRASS GIS inside a script or a notebook is currently too cumbersome.
  • Maps do not allow panning and other interactions.
  • Examples how to use Jupyter Notebooks with GRASS GIS are missing. These examples need to be integrated into GRASS GIS, OSGeo (OSGeo-Live) and (interactive) Jupyer documentation.
  • Requirements: Basic knowledge of GRASS GIS scripting and IPython/Jupyter Notebooks, Python, JavaScript
  • Mentor: ?
  • Co-mentor: Vaclav Petras

Integration of PDAL into GRASS GIS

  • Fully replace LibLAS.
  • Expose the rich PDAL functionality.
  • Share code with modules such as (libLAS-based) and for easy future maintenance.
  • Optional (depending on time) or as a separate topic: v.external and @PDAL pseudo-mapset for point clouds
  • Requirements: C, C++
  • Mentor: ?
  • Co-mentors: Vaclav Petras, Doug Newcomb

Benchmarking framework for GRASS GIS

GRASS GIS as a post-processing part of WebODM

  • Integrate GRASS GIS into WebODM for post-processing of point clouds and orthophotos.
  • This will require development in the are of GRASS GIS command line (and/or Python) interface for standalone applications. These improvements need to be integrated into GRASS GIS for maintenance and re-usability purposes. enhancement

OpenStreetMap is a powerfull dataset. A module to import these data is needed. Until now a script, called, exists, but it is able to import data only from a PostgreSQL database after using osm2pgsql to convert OSM format to PostgreSQL/PostGIS. This project has to implement the capabilities to import directly the .osm or .pbf format. It should use different backend to import the data, the different options could be:

  • Language requirements: Python, C
  • Co-mentors: Luca Delucchi, Pietro Zambelli

Additional GUI tools for image analysis

GRASS GIS has a series of modules that provide the tools necessary for pixel-based and object-based image analysis. However, some steps in the process still require some rather complicated maneuvers. A series of new GUI modules would be very useful to make the experience more user friendly.

  • One task would be the development of GUI modules that allow to attribute class values to either vector polygons or raster areas.
    • For the vector case, this would be a generalized GUI to update values in the attribute table without having to enter vector digitizing mode. The module should allow a mechanism of defining the columns that need to be updated to then create a GUI form containing only those columns.
    • For the raster case, it would mean a system where the user can click on a raster, get the pixel value and then associate a class value to that pixel value. The result should be written to a text file.
  • Another task would be the development of a GUI ruleset generator. Ruleset based classification (object-based or not) means that the user defines a series of rules based on different input bands and pseudo-bands (and for object-based analysis also shape and context indicators). Based on these rules, the system then attributes each pixel/object to a class. Currently this is possible by writing the ruleset as an r.mapcalc input file, using nested if(x,a, b) function calls, or (when vector based) as a series of v.db.update calls. This system quickly gets difficult to read and prone to syntax errors as soon as the number of rules increases. The GUI tool should therefore provide a means to easily select attributes and define rules linked to these attributes. It should then translate these rules to either r.mapcalc calls (raster) or v.db.update calls (vector).
  • This project will require the ability to quickly gain working knowledge of the wxPython GUI code base. Examples exist within the existing code to help with this.
  • Language requirements: Python, wxPython
  • Mentor: ?
  • With support from: Moritz Lennert (with limited time available, though)

SOS tools

Sensor Observation Service is a OGC standard increasing its diffusion worldwide, the idea is to create a series of modules to get data from SOS server. The modules should use OWSLib to get in touch with the server and parse the responses, probably also some improvements should be done in this library to work correctly with all the servers. All the modules should give to the user the capabilities to get info about the sensors and filter the results for: sensors, range of dates and observedProperty

The modules to develop are:

  • able to create a GRASS GIS vector with or without the observations values.
  • able to create a GRASS GIS raster for each queried day
  • able to create a space time vector dataset
  • able to create a space time raster dataset, probably for this could be used and later use a new module (to be developed in this project) to convert space time vector dataset into space time raster dataset or the module
  • Language requirements: Python
  • Mentor: Luca Delucchi

Mapnik rendering engine for GRASS GIS

  • Mapnik is a powerful rendering engine written in C++ with Python bindings.
  • The project tend to add Mapnik engine as alternative backend to WxGUI Cartographic Composer
  • The implementation will have most of the capabilities of actual WxGUI Cartographic Composer
  • The plugin will be able to create different format of images (PNG, PDF, etc)
  • The plugin will be able to export XML Mapnik file
  • A similar implementation is quantumnik
  • Language requirements: Python
  • Mentor: Luca Delucchi
  • Co-Mentor: Martin Landa

Generalized GUI code for Qt-based GUI

  • wxPython/wxWidgets uses native system libraries for rendering, however there is in fact a lot of platform-dependent behavior and high instability of some features
  • Qt is used more and more, QGIS uses Qt
  • the current GUI code (wxGUI) often lacks proper design and is hard to maintain, addition of new features requires hacks or refactoring
  • a new fresh implementation of GUI is need
  • this new implementation should use proper GUI code design so that relevant parts of the code can be used with the new Qt GUI but also with the current wxPython GUI
    • this is necessary to avoid duplication of the GUI code and spending the resources on maintaining two code bases (except for the Qt- and wxPython-specific parts)
    • this will also show that the logic is actually from the graphical representation
    • this avoids dropping wxGUI at the point when the new doesn't have all the features of the new one
    • in this was separated parts of the GUI can be implemented in Qt separately
  • Mentors: Martin Landa, Anna Petrasova, Vaclav Petras
  • Similar project accepted: wiki:GSoC/2016/PyQtGUI

GRASS GIS 3D viewer NVIZ module independent of the main GUI

  • GRASS GIS 6 has a Tcl/Tk interface to NVIZ, a GRASS GIS 3D visualization library, and the interface is a standalone application in GRASS GIS environment. This has its disadvantages and thus wxGUI in GRASS GIS 6 and GRASS GIS 7 contains in fully integrated 3D view which is using NVIZ library as a backend. However, this also has its disadvantages and ideal solution is to have both.
  • The existing examples are g.gui.iclass, g.gui.animation and g.gui.vdigit which is closest to proposed g.gui.nviz because it is also integrated into wxGUI Map Display.
  • The implementation should use/reuse/refactor the existing code and all current functionality should be preserved (comparisons with the original version should be done throughout the whole development period).
  • The command line interface should be similar to m.nviz.image module but should also accept wxGUI workspace file.
  • Some refactoring will be needed to uncouple GUI controls (now part of Layer Manager) and the rendering
    • rule of thumb is that the new code should work even without GUI controls, e.g. as API, and the rendering should be possible not only in the wxPython window but also using m.nviz.image module
    • usage in g.gui.animation could be considered too
    • having a Python API might be quite advantageous for scripting (although m.nviz.image solves most of the problems)
  • This would bring benefit to QGIS Processing which is using the standalone Tcl/Tk NVIZ with GRASS GIS 6, so this project should be (co-)mentored by mentors from both GRASS GIS and QGIS projects.
  • Language requirements: Python, wxPython, (C and OpenGL shouldn't be necessary)
  • Other requirements: basic software design patterns and GUI programming experience

GRASS GIS Locations created from public data

The organisation of data in Location and Mapsets in the GRASS GIS database is often one of the biggest problems for GRASS novices (see also discussion here: The reasons can be that GIS novices and users of some other GIS software (which often tries to hide projection complexity), are not used to solving projection issues, or are not used to centralized organization of their data. However it is also one of the big strength of GRASS GIS esp. in a multi-user environment. This project aims at automatized organization of open, real world data in a GRASS GIS database which can be provided for download. This database will serve as an example for clever organization of spatial data in GRASS GIS and therewith illustrate this feature to new users and help understanding it`s concept. At the same time it provides ready to use real world data (which sometimes comes formats targeted at proprietary software) so that starting working with GRASS becomes more efficient.

  • There are some datasets freely available such as OSM, US government data or some INSPIRE (see also:
  • The task of the student would be to write scripts which can run on a server and create GRASS Locations which will be made available for download.
  • Additional metadata must be generated too such as web pages and XMLs with links to provide access to these datasets.
  • This project should also prepare an infrastructure, so that in the future users can contribute their country-specific scripts.
  • Finally, the project would involve writing of a GUI interface integrated into wxGUI start/welcome screen which would offer download of the location.
  • This can be also combined with the standardized GRASS GIS Sample Dataset. Maps would get standardized names and one would for example select different area to focus on, e.g. script would be able to download data for the whole USA with focus on North Carolina (creating maps according to the standardized sample dataset) but user can change it to focus on California (semantics and extent of maps would be the same).
  • Scripts should be usable as standalone scripts when downloaded separately (so user can download some fresh data or can import into an existing GRASS Location or create a new Mapset). Compatibility with the OSGeo Live sampler DVD would be a major bonus.
  • Original metadata should be preserved, distributed with the data and used to create a description in the download side and in the GUI.
  • Requirements on student:
    • Basic knowledge of GRASS scripting, wxPython, HTML/XML, and UNIX is needed. Some (again basic) understanding of downloading and online protocols will be necessary for data acquisition.
    • Deep knowledge of GRASS GIS is not necessary.
    • The student must be prepared to work with many different data sources and perhaps contact people from community to get suggestion where and how to get the data.
    • Language requirements: Bourne shell scripting, Python (Python would the the primary tool used)
  • Mentor: ?
  • Co-mentor: ?

Tips for students

  • If you have your own ideas we encourage you to propose them. Explain them on the grass-dev mailing list.
  • If you like some idea here or from previous yeas, write about it on grass-dev mailing list and any ideas of your own which could improve it.
  • Follow some good practices in your ideas and proposals:
    • Stress why the project would be useful.
    • Show that you know how you will proceed. That is, make sure that you can demonstrate that the proposal is feasible in the given time frame.
    • Be specific in the implementation (or at least as specific as you can).
    • Explain what the final product will look like and how it will work. Perhaps you can add some drawings or mock-ups. (here in a wiki page)
    • Explain how the idea relates to existing GRASS GIS functions, features, and needs.
    • Do not include steps such as "install GRASS", "compile GRASS libraries (on my machine)", "read about the API". You should do this before applying to GSoC.
  • Compile GRASS GIS 7 (trunk) from source and prepare environment for development:
  • Prove your worth by being active on the GRASS mailing lists (grass-user, grass-dev), fix some bugs, and/or implement some (smaller) features, or write some (simpler) GRASS module, and post it to mailing list. There's no better way to demonstrate your willingness and abilities.
  • GRASS GIS hopes to participate in GSoC as part of the OSGeo Foundation's GSoC program umbrella. See the official OSGeo template for application details and other important information at the OSGeo GSoc Ideas page.