@ @

GRASS Google Summer of Code 2018

About

• ​The OSGeo GSoC 2017 main page
• ​Official GSoC page at Google

Ideas

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, 2016, 2017) 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).

OSS-Fuzz - Continuous Fuzzing for Open Source Software for GRASS GIS

To get rid of cryptic bugs, implement Fuzz testing which is a well-known technique for uncovering various kinds of programming errors in software. Many of these detectable errors (e.g. buffer overflow) can have serious security implications.

Already used in ​GDAL fizz

• Requirements: C and/or Python
• Mentor: ...

Implement a series of image fusion algorithms in GRASS GIS

GRASS GIS currently has the G7:i.pansharpen module in core and G7A:i.fusion.hpf as addon. Many other image fusion / pansharpening algorithms exist, and having several of these available in GRASS GIS would be very helpful. These could be implemented as a series of i.fusion.* modules.

Examples of existing fusion algorithms:

• Bayesian fusion algorithms (e.g ​R-FUSE - see also ​Matlab code)
• ​Super-resolving multiresolution images with band-independant geometry of multispectral pixels

• Requirements: C and/or Python
• Mentor: Moritz Lennert

Enhance 3D rendering capabilities

Current 3D rendering capabilities in GRASS GIS (called NVIZ) are quite powerful, but many important features are missing. The current implementation is rather old and needs to be updated with more recent technologies. The following points (fixes and new features) should be addressed:

• re-implement off-screen rendering (see m.nviz.image) using current OpenGL technologies (e.g. framebuffers) to work reliably on all platforms/hardware
• fix rendering raster and vector data with transparency
• faster rendering of point clouds
• implement text rendering (for scale bars for example)
• review and fix problems with current rendering of 3D vectors
• possible new features would include volume rendering (ray casting for example), so far we can visualize only isosurfaces or slices of 3D rasters
• adding axes

• Requirements: C, OpenGL
• Mentor: Anna Petrasova
• Co-mentor: Vaclav Petras

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: Vaclav Petras
• Co-mentor: Luca Delucchi
• Potential co-mentors: Massimo Di Stefano, Pietro Zambelli

Integration of PDAL into GRASS GIS

• Fully replace LibLAS.
• Expose the rich PDAL functionality.
• Share code with modules such as v.in.lidar (libLAS-based) and r.in.xyz 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: Vaclav Petras
• Co-mentors: Doug Newcomb (non-coding part)
• Accepted: wiki:GSoC/2017/IntegrationOfPDALintoGRASSGIS

Benchmarking framework for GRASS GIS

• A set of functions/modules to test performance of GRASS GIS modules based on different inputs.
• Examples of such benchmarks.
• Sharing of interface and code with the existing testing framework needs to be addressed.
• See also ​https://github.com/jachym/grass-performace and wiki:GSoC/2014/TestingFrameworkForGRASS
• Mentor: Vaclav Petras
• Potential co-mentors: Soeren Gebbert, Jachym Cepicky

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.
• Potential mentors: Vaclav Petras, Anna Petrasova

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
• A good test for potential students to accompany / follow your application: solve at least one or two of the issues in #3310
• Mentor: ?
• Co-mentor: Vaclav Petras (coding part)
• Co-mentor: Moritz Lennert

Module to create quadtree tiling

• Module or set of modules like v.mkgrid which would generate tiles based on dividing space using the 2D or 3D information of vector features using the quadtree and k-tree (already in the library for working with points).
• This idea needs extending.

Tools for generating unit tests from examples in the manual

During GSoC 2014 GRASS got a framework for unit test. In order to increase the application of the framework (and thus test coverage) and make it more easily accessible for less experienced developers (e.g. AddOn authors), tools that allow to automatically generate (at least basic) unit tests from examples for module usage in the manual page would be very helpful. Such tools would also come in handy for adding test coverage for the general functionality of modules which were written before the test framework arrived.

• Language requirements: Python
• Mentor: Vaclav Petras
• Co-mentor: Soeren Gebbert

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 in 2016 (wiki:GSoC/2016/PyQtGUI). This project should move it several steps further.

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
• Mentor: Anna Petrasova
• Co-mentor: Vaclav Petras

Integration of v.profile into GUI profiling tool

Current GUI profile tool supports creation of profiles of raster maps. It serves as a visualisation frontend to r.profile. Sometimes it is necessary to integrate into profile information on some objects (river, road, observation point etc.) that are provided as vector objects. Such functionality is provided by v.profile add-on (planned to be moved from add-ons to main modules), still any visualisation tool is lacking. Thus as a part of SOC existing profiling tool could be extended to include also vector profiling capabilities. This SOC requires basic knowledge of Python and will provide introduction into wxPython program development.

• Integration of v.profile (addon module) should provide support of:
  • displaying vector points as symbols by their Z coordinate / attribute value OR on a selected raster profile line
  • displaying vector line crossing places as vertical lines
  • displaying labels next to symbols or at X axis
• This can be extended by integrating also v.profile.points which is a different way of profiling vector maps.
• Requirements: Python, wxPython
• Mentor: ?
• Co-mentors: Māris Nartišs, Vaclav Petras (v.profile.points part)

Add CMake build system for GRASS GIS

This idea will allow to have a cross-platform build of grass on all major platforms (GNU/Linux, *BSD, Windows and OSX) students must have a advanced knowledge of writing cmake scripts and also should have access other oses: OSX, Linux and Windows (atleast a VM instance to do testing is required)

• Keep autoconf until cmake build becomes stable (atleast two releases ?)
• Requirements: CMake
• Mentor: Rashad Kanavath
• Co-mentors: ??

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:
  • See links appropriate for you at ​http://grass.osgeo.org/development/how-to-start/.
  • If you get stuck with the setup, feel free to consult the ​grass-user mailing list.
  • Familiarize yourself with wiki:Submitting rules.
• 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. You should start even before you apply to GSoC.
• Also note that fixing existing bugs and/or implementing enhancements will be a part of student evaluation.

• Every year GRASS GIS hopes to participate and participates 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.