grass.1grass - Man Page

-h | -help | --help

Prints a brief usage message and exits

-v | --version

Prints the version of GRASS and exits

-c XY

Creates new GRASS project (location) without coordinate reference system in specified GISDBASE

-c geofile

Creates new GRASS project in specified GISDBASE with coordinate reference system based on georeferenced file

-c EPSG:code

Creates new GRASS project in specified GISDBASE with coordinate reference system defined by EPSG code

-c EPSG:code:datum_trans

Creates new GRASS project in specified GISDBASE with coordinate reference system defined by EPSG code and datum transform parameters

-e

Exit after creation of project or mapset. Only with -c flag

-f

Forces removal of .gislock if exists (use with care!). Only with --text flag

--text

Indicates that Text-based User Interface should be used (skip welcome screen)

--gtext

Indicates that Text-based User Interface should be used (show welcome screen)

--gui

Indicates that Graphical User Interface (wxGUI) should be used

--config

Prints GRASS configuration parameters (options: arch, build, compiler, date, path, python_path, revision, svn_revision, version)

--exec EXECUTABLE

Execute GRASS module or script. The provided executable will be executed in a GRASS GIS non-interactive session.

--tmp-project

Run using a temporary project which is created based on the given coordinate reference system and deleted at the end of the execution (use with the --exec flag). The active mapset will be the PERMANENT mapset.

--tmp-mapset

Run using a temporary mapset which is created in the specified project and deleted at the end of the execution (use with the --exec flag).

GISDBASE

Initial database directory which should be a fully qualified path (e.g., /usr/local/share/grassdata)

PROJECT

Initial project directory which is a subdirectory of GISDBASE (project was previously called location)

MAPSET

Initial mapset directory which is a subdirectory of PROJECT Note: These parameters must be specified in one of the following ways:

    MAPSET
    PROJECT/MAPSET
    GISDBASE/PROJECT/MAPSET

The --exec flag can run an executable on path, GRASS module, or a script. All are executed as a subprocess and any additional arguments are passed to it. A script needs to be specified by full or relative path and on unix-likes systems, the script file must have its executable bit set. Calling the interpreter (e.g., python) and providing the script as a parameter is possible, too. When it is finished GRASS will automatically exit using the return code given by the subprocess. Although the execution itself is non-interactive (no GUI or shell), the subprocess itself can be interactive if that is what the user requires.

The flag --config option prints GRASS GIS configuration and version parameters, with the options:

• arch: system architecture (e.g., x86_64-pc-linux-gnu)
• build: (e.g., ./configure --with-cxx --enable-largefile --with-proj [...])
• compiler: (e.g., gcc)
• date: (e.g., 2024-04-10T11:44:54+00:00)
• path: (e.g., /usr/lib64/grass)
• python_path: (e.g., /usr/lib64/grass/etc/python)
• revision: (e.g., 745ee7ec9)
• svn_revision: (e.g., 062bffc8)
• version: (e.g., 8.4.0)

The grass program will check for the existence of an environment variable called GRASS_GUI which indicates the type of user interface for GRASS to use. If this variable is not set when grass is run, then it will be created and then saved in the $HOME/.grass8/rc file for the next time GRASS is run. It can be set to text, gtext or gui.

There is an order of precedence in the way grass determines the user interface to use. The following is the hierarchy from highest precedence to lowest.

1. Command line argument
2. Environment variable GRASS_GUI
3. Value set in $HOME/.grass8/rc (GUI)
4. Default value - gui

If you choose to use wxGUI interface, then the GRASS_PYTHON environment variable can be used to override your system default python command.

Suppose for example your system has Python 3.6 installed and you install a personal version of the Python 3.8 binaries under $HOME/bin. You can use the above variables to have GRASS use the Python 3.8 binaries instead.

   GRASS_PYTHON=python3.8

This environment variable allows the user to extend the GRASS program search paths to include locally developed/installed GRASS modules or user scripts.

   GRASS_ADDON_PATH=/usr/mytools
   GRASS_ADDON_PATH=/usr/mytools:/usr/local/othertools

In this example above path(s) would be added to the standard GRASS path environment.

This environment variable allows the user to extend the GRASS program search paths to include locally installed (see g.extension for details) GRASS Addon modules which are not distributed with the standard GRASS release.

   GRASS_ADDON_BASE=/usr/grass-addons

In this example above path would be added to the standard GRASS path environment.

If not defined by user, this variable is set by GRASS startup program to $HOME/.grass8/addons on GNU/Linux and %APPDATA%\Roaming\GRASS8\addons on MS Windows.

The GRASS_HTML_BROWSER environment variable allows the user to set the HTML web browser to use for displaying help pages.

Creating a new project based on a geodata file’s projection (-c) and exit (-e) immediately:

grass -c elevation.tiff -e /path/to/grassdata/test1/

Linking external raster data to PERMANENT Mapset:

grass /path/to/grassdata/test1/PERMANENT/ --exec r.external input=basins.tiff output=basins
grass /path/to/grassdata/test1/PERMANENT/ --exec r.external input=elevation.tiff output=elevation

Get statistics for one raster map:

grass /path/to/grassdata/test1/PERMANENT/ --exec r.univar map=elevation

Compare the rasters visually:

grass /path/to/grassdata/test1/PERMANENT/ --exec g.gui.mapswipe first=elevation second=basins

A sequence of commands can be bundled in a script and executed using the exec interface.

Shell script example: the command to execute a shell script might be:

grass /path/to/grassdata/test1/PERMANENT/ --exec sh test.sh

A very simple bash script ("test.sh") may look like this:

#!/bin/bash
g.region -p
g.list type=raster
r.info elevation

Python script example: the command to execute a Python script might be:

grass /path/to/grassdata/test1/PERMANENT/ --exec python test.py

A very simple Python script ("test.py") may look like this:

#!/usr/bin/env python3
# import GRASS Python bindings (see also pygrass)
import grass.script as gs
gs.message(’Current GRASS GIS environment:’)
print(gs.gisenv())
gs.message(’Available raster maps:’)
for raster in gs.list_strings(type=’raster’):
    print(raster)
gs.message(’Available vector maps:’)
for vector in gs.list_strings(type=’vector’):
    print(vector)

Creating a new temporary project based on a georeferenced file’s coordinate reference system (CRS) and simultaneously starting computation in a shell script:

grass --tmp-project elevation.tiff --exec test.sh

The same, but using an EPSG code and a Python script:

grass --tmp-project EPSG:3358 --exec test.py

Finally, for special cases, we can create an XY project without any CRS:

grass --tmp-project XY --exec test.py

Temporary project is automatically deleted after computation, so the script is expected to export, link or otherwise preserve the output data before ending.

A single command can be also executed, e.g. to examine properties of the temporary project:

grass --tmp-project EPSG:3358 --exec g.proj -p

A temporary XY project with single command is useful, e.g. to show help text of a module:

grass --tmp-project XY --exec r.neighbors --help

A single command can be executed, e.g., to examine properties of a project (here using the NC SPM sample dataset):

grass --tmp-mapset /path/to/grassdata/nc_spm_08/ --exec g.proj -p

Computation in a Python script can be executed in the same way:

grass --tmp-mapset /path/to/grassdata/nc_spm_08/ --exec processing.py

Additional parameters are just passed to the script, so we can run the script with different sets of parameters (here 5, 8 and 3, 9) in different temporary mapsets which is good for parallel processing.

grass --tmp-mapset /path/to/grassdata/nc_spm_08/ --exec processing.py 5 8
grass --tmp-mapset /path/to/grassdata/nc_spm_08/ --exec processing.py 3 9

The same applies to Bash scripts (and other scripts supported on you platform):

grass --tmp-mapset /path/to/grassdata/nc_spm_08/ --exec processing.sh 5 8

The temporary mapset is automatically deleted after computation, so the script is expected to export, link or otherwise preserve the output data before ending.

Importantly, to avoid an "[Errno 8] Exec format error" there must be a shebang line at the top of the script (like #!/bin/sh, #!/bin/bash, or #!/usr/bin/env python3) indicating which interpreter to be used for the script. The script file must have its executable bit set.