@ @

GRASS Google Summer of Code 2015

About

• ​The OSGeo GSoC 2015 main page
• ​Official GSoC 2015 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) 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/2015/CoolGRASSProjectIdea) from the possible student project page (e.g. GSoC/2015/CoolGRASSProject).

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

New easy-to-use command line interface for GRASS GIS

• GRASS GIS requires GRASS GIS Database, Location and Mapset to be set up to maintain data consistency, efficiency and security. Unfortunately, this is cumbersome when GRASS GIS is not the primary tools one is using. There are different workarounds for calling GRASS modules without starting GRASS explicitly, or running GRASS in a batch mode. However, none of these allows one to skip the database setup phase. This leads to the need for constant reimplementing of setup, import and export steps in various environments including user scripts (Bash, Python, R), QGIS Processing, gvSIG/SEXTANTE, uDig/JGrassTools and all the web/server/cloud tools which use GRASS GIS as a processing backend.
• GRASS GIS itself can make it easier for the callers (at least in most cases) by implementing an interface which would allow to use GRASS GIS modules without explicit dealing with GRASS GIS database.
• The command line call using the proposed interface would look like this:

grass run r.slope.aspect elevation=file://.../elevation.tiff aspect=file://...aspect.tiff
grass run r.lake elevation=some/file.tiff water_level=10 lake=some/new/file.tiff coordinates=100,520

• The grass command would have to parse the command line, find the files which should be maps (either using file:// or perhaps anything would work) and import/export/link them, and then call the actual command.
• The input maps could be linked (external) rather than imported (except for the cases when projection differs) which should be faster than import.
• The output maps could be be also linked (external) with projection same as input which is should be faster then export.
• Ideally this should work also with PostGIS and databases provided through GDAL/OGR.
• The GRASS GIS Database, Location and Mapset should be created on the fly and deleted afterwards (the .grassrc wouldn't be used).
• This project should also contain a ​QGIS Processing part.
  • Since QGIS Processing is one of the reasons for this interface, implementing is a crucial use case which should be tested from the very beginning a with QGIS Processing implementation, the interface would be used right away.
  • Alternatively, another project or more than one project can be in this part.
  • Title should change according to decisions made about this part.
• Proposal should discuss how advanced things such raster algebra, multi-map inputs and outputs, temporal framework, cartography and visualization tools will work.
• The system behind the interface will be inherently fragile, so it is necessary to write large amount of tests which would check different combinations of data types and projections.
• Bonus task would be to find/implement a way to run Python code easily in case grass is called from Python (grass python -c "print('...')" is a good start).
• It is expected that this would work for any g.gui.* modules too but implementing similar mechanism also for module dialogs is out of scope of this project (although some basic implementation might be quite straightforward).
• Language requirements: Python (both GRASS GIS startup scripts and QGIS Processing are in Python)
• See also #2579 and ​grass-dev QGIS Processing & GRASS (January 2015), #2424, ​Working with GRASS without starting it explicitly
• Mentor for the GRASS GIS part: Vaclav Petras
• Mentor for the QGIS part: ?
• Mentor for the <insert other OSGeo project> part: ?
• Co-mentors (e.g. PostGIS connection part): ?

Complete basic cartography suite in GRASS GIS wxGUI Map Display

• With few additions the wxGUI Map Display could cover large number of cartography needs so that users wouldn't be forced to switch to ​WxGUI Cartographic Composer or different software (Inkscape, QGIS) to create fully-featured map usable, e.g. for scientific publications. The development can happen in phases so that the easy-to-implement things, which gives greatest gain, are done first.
• first phase:
  • store legend, scale bar, north arrow and text (and others if added) in workspace
  • add units to legend (optionally also title) as parameter
  • possibility to add any image (as in animation tool), use cases: logo/watermark, workaround for overview maps
  • disable rendering when loading workspace
  • determine map window size without the need to change map display size manually
• second phase:
  • support map units in scale bar, not only meters
  • allow user to set the length of scale bar (in map units)
  • manual breaks for legend
  • legend background
  • general shapes
    • can be implemented using d.* commands (e.g. d.graph) or wxPython or both (wxPython might be easier for interactivity, d.* commands for scripting)
    • use cases: workaround missing backgroud of legend or text, manual marking special points
  • include map-display-like object
    • would be represented as image but the image would be dynamically generated
    • useful for overview maps (insets) or histograms
    • might be implemented as a standard Map Display whose saved image would be inserted as an image, perhaps image from other Map Display can be used
    • the important feature is the user does not have to create an intermediate file
• third phase:
  • implement vector legend:
    • Perhaps we can find some workaround (i.e. some easy implementation) and wrap it into a module, e.g. vector legend drawn as vector with attribute table (enables even line with border thanks to different vector layers).
    • May get complicated with (enhancements of) vector thematic mapping
  • enhance d.vect.thematic
  • make d.text, d.graph, d.erase and perhaps other existing d.* modules accessible from wxGUI
  • implement module which can parametrize workspace (similarly as g.gui.animation is doing for 3D View) and render it with different maps
    • if the implementation would be wxPython free (ideal option) then it would have to translate some wxPython/wxGUI specific things to plain d.* commands
    • this can be also implemented as a script generator (rather than workspace renderer)
    • it should work as a simple automatic map ("atlas") generator and should accept also time series as the input
• It would be great to make as much things as possible to work also in 3D Views (wxNVIZ).
• Thorough (manual) testing on different platforms is needed (by student or mentors).
• See also:
  • map decorations idea from last year
  • vector legend idea from last year
  • #2582 (implement d.vect.thematic2 addon module features in d.vect.thematic core module)
  • ​grass-dev future of thematic mapping in GRASS
  • ​grass-dev future thematic cartography in GRASS
  • slightly related color tables idea from last year
• Language requirements: Python, wxPython, (perhaps a little bit of C and OpenGL)
• Co-mentors: Anna Petrasova, Helena Mitasova, Martin Landa

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

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.

• 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.