GRASS startup program
grass [
-h |
-help |
--help] [
-v |
--version] |
[
-c |
-c geofile |
-c EPSG:code[:datum_trans]] |
-e |
-f |
[
--text |
--gtext |
--gui] |
--config |
[
--tmp-location |
--tmp-mapset]
[[[
<GISDBASE>/]
<LOCATION>/]
<MAPSET>]
[
--exec EXECUTABLE]
- -h | -help | --help
- Prints a brief usage message and exits
- -v | --version
- Prints the version of GRASS and exits
- -c
- Creates new GRASS unprojected location in specified GISDBASE
- -c geofile
- Creates new GRASS projected location in specified GISDBASE based on georeferenced file
- -c EPSG:code
- Creates new GRASS projected location in specified GISDBASE with given EPSG code
- -c EPSG:code:datum_trans
- Creates new GRASS projected location in specified GISDBASE with given EPSG code and datum transform parameters
- -e
- Exit after creation of location 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-location
- Run using a temporary location 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
location 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)
- LOCATION
- Initial location directory which is a subdirectory of GISDBASE
- MAPSET
- Initial mapset directory which is a subdirectory of LOCATION
Note: These parameters must be specified in one of the
following ways:
MAPSET
LOCATION/MAPSET
GISDBASE/LOCATION/MAPSET
This command is used to launch GRASS GIS. It will parse the command
line arguments and then initialize GRASS for the user. Since GRASS
modules require a specific environment, this program must be called
before any other GRASS module can run. The command line arguments are
optional and provide the user with a method to indicate the desired
user interface, as well as the desired mapset to work on.
The startup program will remember both the desired user interface
and mapset. Thus, the next time the user runs GRASS, typing
grass (without any options) will start GRASS with the
previous settings for the user interface and mapset selected.
If you specify a graphical user interface (--gui)
the grass program will try to verify that the system you
specified exists and that you can access it successfully. If any of
these checks fail then grass will automatically switch back
to the text user interface mode.
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., Tue Mar 31 20:34:57 2020 +0200)
- 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.2.0dev)
The GRASS GIS project provides several free sample geospatial datasets
as ready-to-use locations. They are available to download at
https://grass.osgeo.org/download/sample-data/.
The "North Carolina data set" is a modern package of geospatial data from
North Carolina (USA), and it includes raster, vector, LiDAR and satellite
data. This is the most extensively used data set in the documentation and
the examples throughout the user manual pages are based upon it.
A number of environment variables are available at GRASS startup to
assist with automation and customization. Most users will not need to
bother with these.
In addition to these shell environment variables GRASS maintains a
number of GIS environment variables in the $HOME/.grass8/rc
file. User changes to this file will be read during the next startup
of GRASS. If this file becomes corrupted the user may edit it by hand
or remove it to start afresh. See the list
of implemented GRASS variables
for more information. The rest of this help page will only consider
shell environment variables.
Note that you will need to set these variables using the
appropriate method required for the UNIX shell that you use (e.g. in a
Bash shell you must export the variables for them to
propagate).
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.
- Command line argument
- Environment variable GRASS_GUI
- Value set in $HOME/.grass8/rc (GUI)
- 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.
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.
The following are some examples of how you could start GRASS
- grass
- Start GRASS using the default user interface. The user will be
prompted to choose the appropriate location and mapset.
- grass --gui
- Start GRASS using the graphical user interface. The user will be
prompted to choose the appropriate location and mapset.
- grass --text
- Start GRASS using the text-based user interface. Appropriate
location and mapset must be set by environmental variables (see
examples below) otherwise taken from the last GRASS session.
- grass --gtext
- Start GRASS using the text-based user interface. The user will be
prompted to choose the appropriate location and mapset.
- grass $HOME/grassdata/spearfish70/user1
- Start GRASS using the default user interface and automatically
launch into the given mapset, bypassing the mapset selection menu.
- grass --gui -
- Start GRASS using the graphical user interface and try to
obtain the location and mapset from environment variables.
- grass -c EPSG:4326 $HOME/grassdata/mylocation
- Creates a new GRASS location with EPSG code 4326 (latitude-longitude, WGS84)
in the specified GISDBASE
- grass -c EPSG:5514:3 $HOME/grassdata/mylocation
- Creates a new GRASS location with EPSG code 5514 (S-JTSK / Krovak
East North - SJTSK) with datum transformation parameters used in
Czech Republic in the specified GISDBASE
- grass -c XY $HOME/grassdata/gnomonic --exec g.proj -c proj4='+proj=gnom +lat_0=90 +lon_0=-50'
- Creates a new GRASS location from PROJ definition string
(here: gnomonic)
in the specified GISDBASE
- grass -c myvector.shp $HOME/grassdata/mylocation
- Creates a new GRASS location based on georeferenced Shapefile
- grass -c myraster.tif $HOME/grassdata/mylocation
- Creates a new GRASS location based on georeferenced GeoTIFF file
Creating a new Location 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
Execution of shell and Python scripts instead of single commands
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)
Using temporary location
Creating a new temporary location based on a georeferenced file's
projection coordinate reference system (CRS) and simultaneously starting
computation in a shell script:
grass --tmp-location elevation.tiff --exec test.sh
The same, but using an EPSG code and a Python script:
grass --tmp-location EPSG:3358 --exec test.py
Finally, for special cases, we can create an XY location without any CRS:
grass --tmp-location XY --exec test.py
Temporary location 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 location:
grass --tmp-location EPSG:3358 --exec g.proj -p
A temporary XY location with single command is useful, e.g. to show
help text of a module:
grass --tmp-location XY --exec r.neighbors --help
Using temporary mapset
A single command can be executed, e.g., to examine properties of a
location (here using the NC SPM sample location):
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.
Troubleshooting
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.
If you start GRASS using the
wxGUI
interface you must have a
python command in your $PATH
variable. That is, the command must be named
python and not something like
python3.6. Rarely some
Python installations do not create a
python command. In these
cases you can override
python by GRASS_PYTHON environmental
variable.
Furthermore, if you have more than one version of Python installed,
make sure that the version you want to use with GRASS is set by
GRASS_PYTHON environmental variable.
List of
GRASS environment variables
GRASS GIS Web site
GRASS GIS User Wiki
GRASS GIS Bug Tracker
GRASS GIS 8 Programmer's Manual
Justin Hickey
Markus Neteler
Hamish Bowman
Martin Landa, Czech Technical University in Prague, Czech Republic
Main index |
Topics index |
Keywords index |
Graphical index |
Full index
© 2003-2023
GRASS Development Team,
GRASS GIS 8.3.dev Reference Manual