1r.mapcalc(1) Grass User's Manual r.mapcalc(1)
2
6 r.mapcalc - Raster map calculator.
7
9 raster, algebra
10
12 r.mapcalc
13 r.mapcalc --help
14 r.mapcalc [-sl] [expression=string] [region=string] [file=name]
15 [seed=integer] [--overwrite] [--help] [--verbose] [--quiet]
16 [--ui]
17 Flags:
19 -s
20 Generate random seed (result is non-deterministic)
21 -l
23 List input and output maps
24 --overwrite
26 Allow output files to overwrite existing files
27 --help
29 Print usage summary
30 --verbose
32 Verbose module output
33 --quiet
35 Quiet module output
36 --ui
38 Force launching GUI dialog
39 Parameters:
41 expression=string
42 Expression to evaluate
43 region=string
45 The computational region that should be used.
46 - current uses the current region of the mapset.
47 - intersect computes the intersection region between
48 all input maps and uses the smallest resolution
49 - union computes the union extent of all map regions
50 and uses the smallest resolution
51 Options: current, intersect, union
52 Default: current
53 file=name
55 File containing expression(s) to evaluate
56 seed=integer
58 Seed for rand() function
59
61 r.mapcalc performs arithmetic on raster map layers. New raster map
62 layers can be created which are arithmetic expressions involving exist‐
63 ing raster map layers, integer or floating point constants, and func‐
64 tions.
65 Program use
67 r.mapcalc expression have the form:
68 result = expression
70 where result is the name of a raster map layer to contain the result of
72 the calculation and expression is any legal arithmetic expression
73 involving existing raster map layers (except result itself), integer or
74 floating point constants, and functions known to the calculator.
75 Parentheses are allowed in the expression and may be nested to any
76 depth. result will be created in the user’s current mapset.
77 As expression= is the first option, it is the default. This means that
79 passing an expression on the command line is possible as long as the
80 expression is quoted and a space is included before the first = sign.
81 Example (’foo’ is the resulting map):
82 r.mapcalc "foo = 1"
83 or:
84 r.mapcalc ’foo = 1’
85 An unquoted expression (i.e. split over multiple arguments) won’t work,
86 nor will omitting the space before the = sign:
87 r.mapcalc ’foo=1’
88 Sorry, <foo> is not a valid parameter
89 To read command from the file, use file= explicitly, e.g.:
90 r.mapcalc file=file
91 or:
92 r.mapcalc file=- < file
93 or:
94 r.mapcalc file=- <<EOF
95 foo = 1
96 EOF
97 The formula entered to r.mapcalc by the user is recorded both in the
99 result map title (which appears in the category file for result) and in
100 the history file for result.
101 Some characters have special meaning to the command shell. If the user
103 is entering input to r.mapcalc on the command line, expressions should
104 be enclosed within single quotes. See NOTES, below.
105 Computational regions in r.mapcalc
107 By default r.mapcalc uses the current region as computational region
108 that was set with g.region for processing. Sometimes it is necessary
109 to use a region that is derived from the raster maps in the expression
110 to set the computational region. This is of high importance for mod‐
111 ules that use r.mapcalc internally to process time series of satellite
112 images that all have different spatial extents. A module that requires
113 this feature is t.rast.algebra. The region option of r.mapcalc was
114 implemented to address this requirement. It allows computing and using
115 a region based on all raster maps in an expression. Three modes are
116 supported:
117 · Setting the region parameter to current will result in the use
119 of the current region as computational region. This is the
120 default. The current region can be set with g.region.
121 · The parameter union will force r.mapcalc to compute the dis‐
123 joint union of all regions from raster maps specified in the
124 expression. This computed region will then be used as computa‐
125 tional region at runtime. The region of the mapset will not be
126 modified. The smallest spatial resolution of all raster maps
127 will be used for processing.
128 · The parameter intersect will force r.mapcalc to compute the
130 intersection of all regions from raster maps specified in the
131 expression. This computed region will then be used as computa‐
132 tional region at runtime. The region of the mapset will not be
133 modified. The smallest spatial resolution of all raster maps
134 will be used for processing.
135 Operators and order of precedence
137 The following operators are supported:
138 Operator Meaning Type Precedence
139 --------------------------------------------------------------
140 - negation Arithmetic 12
141 ~ one’s complement Bitwise 12
142 ! not Logical 12
143 ^ exponentiation Arithmetic 11
144 % modulus Arithmetic 10
145 / division Arithmetic 10
146 * multiplication Arithmetic 10
147 + addition Arithmetic 9
148 - subtraction Arithmetic 9
149 << left shift Bitwise 8
150 >> right shift Bitwise 8
151 >>> right shift (unsigned) Bitwise 8
152 > greater than Logical 7
153 >= greater than or equal Logical 7
154 < less than Logical 7
155 <= less than or equal Logical 7
156 == equal Logical 6
157 != not equal Logical 6
158 & bitwise and Bitwise 5
159 | bitwise or Bitwise 4
160 && logical and Logical 3
161 &&& logical and[1] Logical 3
162 || logical or Logical 2
163 ||| logical or[1] Logical 2
164 ?: conditional Logical 1
165 (modulus is the remainder upon division)
166 [1] The &&& and ||| operators handle null values differently to other
168 operators. See the section entitled NULL support below for more
169 details.
170 The operators are applied from left to right, with those of higher
172 precedence applied before those with lower precedence. Division by 0
173 and modulus by 0 are acceptable and give a NULL result. The logical
174 operators give a 1 result if the comparison is true, 0 otherwise.
175 Raster map layer names
177 Anything in the expression which is not a number, operator, or function
178 name is taken to be a raster map layer name. Examples:
179 elevation
181 x3
182 3d.his
183 Most GRASS raster map layers meet this naming convention. However, if
185 a raster map layer has a name which conflicts with the above rule, it
186 should be quoted. For example, the expression
187 x = a-b
189 would be interpreted as: x equals a minus b, whereas
191 x = "a-b"
193 would be interpreted as: x equals the raster map layer named a-b
195 Also
197 x = 3107
199 would create x filled with the number 3107, while
201 x = "3107"
203 would copy the raster map layer 3107 to the raster map layer x.
205 Quotes are not required unless the raster map layer names look like
207 numbers or contain operators, OR unless the program is run non-interac‐
208 tively. Examples given here assume the program is run interactively.
209 See NOTES, below.
210 r.mapcalc will look for the raster map layers according to the user’s
212 current mapset search path. It is possible to override the search path
213 and specify the mapset from which to select the raster map layer. This
214 is done by specifying the raster map layer name in the form:
215 name@mapset
217 For example, the following is a legal expression:
219 result = x@PERMANENT / y@SOILS
221 The mapset specified does not have to be in the mapset search path.
223 (This method of overriding the mapset search path is common to all
224 GRASS commands, not just r.mapcalc.)
225 The neighborhood modifier
227 Maps and images are data base files stored in raster format, i.e.,
228 two-dimensional matrices of integer values. In r.mapcalc, maps may be
229 followed by a neighborhood modifier that specifies a relative offset
230 from the current cell being evaluated. The format is map[r,c], where r
231 is the row offset and c is the column offset. For example, map[1,2]
232 refers to the cell one row below and two columns to the right of the
233 current cell, map[-2,-1] refers to the cell two rows above and one col‐
234 umn to the left of the current cell, and map[0,1] refers to the cell
235 one column to the right of the current cell. This syntax permits the
236 development of neighborhood-type filters within a single map or across
237 multiple maps.
238 Raster map layer values from the category file
240 Sometimes it is desirable to use a value associated with a category’s
241 label instead of the category value itself. If a raster map layer name
242 is preceded by the @ operator, then the labels in the category file for
243 the raster map layer are used in the expression instead of the category
244 value.
245 For example, suppose that the raster map layer soil.ph (representing
247 soil pH values) has a category file with labels as follows:
248 cat label
250 ------------------
251 0 no data
252 1 1.4
253 2 2.4
254 3 3.5
255 4 5.8
256 5 7.2
257 6 8.8
258 7 9.4
259 Then the expression:
261 result = @soils.ph
263 would produce a result with category values 0, 1.4, 2.4, 3.5, 5.8, 7.2,
265 8.8 and 9.4.
266 Note that this operator may only be applied to raster map layers and
268 produces a floating point value in the expression. Therefore, the cat‐
269 egory label must start with a valid number. If the category label is
270 integer, it will be represented by a floating point number. I the cate‐
271 gory label does not start with a number or is missing, it will be rep‐
272 resented by NULL (no data) in the resulting raster map.
273 Grey scale equivalents and color separates
275 It is often helpful to manipulate the colors assigned to map cate‐
276 gories. This is particularly useful when the spectral properties of
277 cells have meaning (as with imagery data), or when the map category
278 values represent real quantities (as when category values reflect true
279 elevation values). Map color manipulation can also aid visual recogni‐
280 tion, and map printing.
281 The # operator can be used to either convert map category values to
283 their grey scale equivalents or to extract the red, green, or blue com‐
284 ponents of a raster map layer into separate raster map layers.
285 result = #map
287 converts each category value in map to a value in the range 0-255 which
289 represents the grey scale level implied by the color for the category.
290 If the map has a grey scale color table, then the grey level is what
291 #map evaluates to. Otherwise, it is computed as:
292 0.10 * red + 0.81 * green + 0.01 * blue
294 Alternatively, you can use:
296 result = y#map
298 to use the NTSC weightings:
300 0.30 * red + 0.59 * green + 0.11 * blue
302 Or, you can use:
304 result = i#map
306 to use equal weightings:
308 0.33 * red + 0.33 * green + 0.33 * blue
310 The # operator has three other forms: r#map, g#map, b#map. These
312 extract the red, green, or blue components in the named raster map,
313 respectively. The GRASS shell script r.blend extracts each of these
314 components from two raster map layers, and combines them by a
315 user-specified percentage. These forms allow color separates to be
316 made. For example, to extract the red component from map and store it
317 in the new 0-255 map layer red, the user could type:
318 red = r#map
320 To assign this map grey colors type:
322 r.colors map=red color=rules
324 black
325 white
326 To assign this map red colors type:
328 r.colors map=red color=rules
330 black
331 red
332 Functions
334 The functions currently supported are listed in the table below. The
335 type of the result is indicated in the last column. F means that the
336 functions always results in a floating point value, I means that the
337 function gives an integer result, and * indicates that the result is
338 float if any of the arguments to the function are floating point values
339 and integer if all arguments are integer.
340 function description type
342 ---------------------------------------------------------------------------
343 abs(x) return absolute value of x *
344 acos(x) inverse cosine of x (result is in degrees) F
345 asin(x) inverse sine of x (result is in degrees) F
346 atan(x) inverse tangent of x (result is in degrees) F
347 atan(x,y) inverse tangent of y/x (result is in degrees) F
348 ceil(x) the smallest integral value not less than x *
349 cos(x) cosine of x (x is in degrees) F
350 double(x) convert x to double-precision floating point F
351 eval([x,y,...,]z) evaluate values of listed expr, pass results to z
352 exp(x) exponential function of x F
353 exp(x,y) x to the power y F
354 float(x) convert x to single-precision floating point F
355 floor(x) the largest integral value not greater than x *
356 graph(x,x1,y1[x2,y2..]) convert the x to a y based on points in a graph F
357 graph2(x,x1[,x2,..],y1[,y2..])
358 alternative form of graph() F
359 if decision options: *
360 if(x) 1 if x not zero, 0 otherwise
361 if(x,a) a if x not zero, 0 otherwise
362 if(x,a,b) a if x not zero, b otherwise
363 if(x,a,b,c) a if x > 0, b if x is zero, c if x < 0
364 int(x) convert x to integer [ truncates ] I
365 isnull(x) check if x = NULL
366 log(x) natural log of x F
367 log(x,b) log of x base b F
368 max(x,y[,z...]) largest value of those listed *
369 median(x,y[,z...]) median value of those listed *
370 min(x,y[,z...]) smallest value of those listed *
371 mode(x,y[,z...]) mode value of those listed *
372 nmax(x,y[,z...]) largest value of those listed, excluding NULLs *
373 nmedian(x,y[,z...]) median value of those listed, excluding NULLs *
374 nmin(x,y[,z...]) smallest value of those listed, excluding NULLs *
375 nmode(x,y[,z...]) mode value of those listed, excluding NULLs *
376 not(x) 1 if x is zero, 0 otherwise
377 pow(x,y) x to the power y *
378 rand(a,b) random value x : a <= x < b *
379 round(x) round x to nearest integer I
380 round(x,y) round x to nearest multiple of y
381 round(x,y,z) round x to nearest y*i+z for some integer i
382 sin(x) sine of x (x is in degrees) F
383 sqrt(x) square root of x F
384 tan(x) tangent of x (x is in degrees) F
385 xor(x,y) exclusive-or (XOR) of x and y I
386 Internal variables:
387 row() current row of moving window I
388 col() current col of moving window I
389 nrows() number of rows in computation region I
390 ncols() number of columns in computation region I
391 x() current x-coordinate of moving window F
392 y() current y-coordinate of moving window F
393 ewres() current east-west resolution F
394 nsres() current north-south resolution F
395 area() area of current cell in square meters F
396 null() NULL value
397 Note, that the row() and col() indexing starts with 1.
398 Floating point values in the expression
400 Floating point numbers are allowed in the expression. A floating point
401 number is a number which contains a decimal point:
402 2.3 12.0 12. .81
403 Floating point values in the expression are handled in a special way.
404 With arithmetic and logical operators, if either operand is float, the
405 other is converted to float and the result of the operation is float.
406 This means, in particular that division of integers results in a (trun‐
407 cated) integer, while division of floats results in an accurate float‐
408 ing point value. With functions of type * (see table above), the
409 result is float if any argument is float, integer otherwise.
410 Note: If you calculate with integer numbers, the resulting map will be
412 integer. If you want to get a float result, add the decimal point to
413 integer number(s).
414 If you want floating point division, at least one of the arguments has
416 to be a floating point value. Multiplying one of them by 1.0 will pro‐
417 duce a floating-point result, as will using float():
418 r.mapcalc "ndvi = float(lsat.4 - lsat.3) / (lsat.4 + lsat.3)"
419 NULL support
421 · Division by zero should result in NULL.
422 · Modulus by zero should result in NULL.
424 · NULL-values in any arithmetic or logical operation should
426 result in NULL. (however, &&& and ||| are treated specially, as
427 described below).
428 · The &&& and ||| operators observe the following axioms even
430 when x is NULL:
431 x &&& false == false
432 false &&& x == false
433 x ||| true == true
434 true ||| x == true
435 · NULL-values in function arguments should result in NULL (how‐
437 ever, if(), eval() and isnull() are treated specially, as
438 described below).
439 · The eval() function always returns its last argument
441 · The situation for if() is:
443 if(x)
444 NULL if x is NULL; 0 if x is zero; 1 otherwise
445 if(x,a)
446 NULL if x is NULL; a if x is non-zero; 0 otherwise
447 if(x,a,b)
448 NULL if x is NULL; a if x is non-zero; b otherwise
449 if(x,n,z,p)
450 NULL if x is NULL; n if x is negative;
451 z if x is zero; p if x is positive
452 · The (new) function isnull(x) returns: 1 if x is NULL; 0 other‐
454 wise. The (new) function null() (which has no arguments)
455 returns an integer NULL.
456 · Non-NULL, but invalid, arguments to functions should result in
458 NULL.
459 Examples:
460 log(-2)
461 sqrt(-2)
462 pow(a,b) where a is negative and b is not an integer
463 NULL support: Please note that any math performed with NULL cells
465 always results in a NULL value for these cells. If you want to replace
466 a NULL cell on-the-fly, use the isnull() test function in a if-state‐
467 ment.
468 Example: The users wants the NULL-valued cells to be treated like
470 zeros. To add maps A and B (where B contains NULLs) to get a map C the
471 user can use a construction like:
472 C = A + if(isnull(B),0,B)
474 NULL and conditions:
476 For the one argument form:
478 if(x) = NULL if x is NULL
479 if(x) = 0 if x = 0
480 if(x) = 1 otherwise (i.e. x is neither NULL nor 0).
481 For the two argument form:
483 if(x,a) = NULL if x is NULL
484 if(x,a) = 0 if x = 0
485 if(x,a) = a otherwise (i.e. x is neither NULL nor 0).
486 For the three argument form:
488 if(x,a,b) = NULL if x is NULL
489 if(x,a,b) = b if x = 0
490 if(x,a,b) = a otherwise (i.e. x is neither NULL nor 0).
491 For the four argument form:
493 if(x,a,b,c) = NULL if x is NULL
494 if(x,a,b,c) = a if x > 0
495 if(x,a,b,c) = b if x = 0
496 if(x,a,b,c) = c if x < 0
497 More generally, all operators and most functions return NULL if *any*
498 of their arguments are NULL.
499 The functions if(), isnull() and eval() are exceptions.
500 The function isnull() returns 1 if its argument is NULL and 0 other‐
501 wise. If the user wants the opposite, the ! operator, e.g.
502 "!isnull(x)" must be used.
503 All forms of if() return NULL if the first argument is NULL. The 2, 3
505 and 4 argument forms of if() return NULL if the "selected" argument is
506 NULL, e.g.:
507 if(0,a,b) = b regardless of whether a is NULL
508 if(1,a,b) = a regardless of whether b is NULL
509 eval() always returns its last argument, so it only returns NULL if the
510 last argument is NULL.
511 Note: The user cannot test for NULL using the == operator, as that
513 returns NULL if either or both arguments are NULL, i.e. if x and y are
514 both NULL, then "x == y" and "x != y" are both NULL rather than 1 and 0
515 respectively.
516 The behaviour makes sense if the user considers NULL as representing an
517 unknown quantity. E.g. if x and y are both unknown, then the values of
518 "x == y" and "x != y" are also unknown; if they both have unknown val‐
519 ues, the user doesn’t know whether or not they both have the same
520 value.
521
523 Usage from command line
524 Extra care must be taken if the expression is given on the command
525 line. Some characters have special meaning to the UNIX shell. These
526 include, among others:
527 * ( ) > & |
528 It is advisable to put single quotes around the expression; e.g.:
530 ’result = elevation * 2’
531 Without the quotes, the *, which has special meaning to the UNIX shell,
532 would be altered and r.mapcalc would see something other than the *.
533 Multiple computations
535 In general, it’s preferable to do as much as possible in each r.mapcalc
536 command. E.g. rather than:
537 r.mapcalc "$GIS_OPT_OUTPUT.r = r#$GIS_OPT_FIRST * .$GIS_OPT_PERCENT + (1.0 - .$GIS_OPT_PERCENT) * r#$GIS_OPT_SECOND"
538 r.mapcalc "$GIS_OPT_OUTPUT.g = g#$GIS_OPT_FIRST * .$GIS_OPT_PERCENT + (1.0 - .$GIS_OPT_PERCENT) * g#$GIS_OPT_SECOND"
539 r.mapcalc "$GIS_OPT_OUTPUT.b = b#$GIS_OPT_FIRST * .$GIS_OPT_PERCENT + (1.0 - .$GIS_OPT_PERCENT) * b#$GIS_OPT_SECOND"
540 use:
542 r.mapcalc <<EOF
543 $GIS_OPT_OUTPUT.r = r#$GIS_OPT_FIRST * .$GIS_OPT_PERCENT + (1.0 - .$GIS_OPT_PERCENT) * r#$GIS_OPT_SECOND
544 $GIS_OPT_OUTPUT.g = g#$GIS_OPT_FIRST * .$GIS_OPT_PERCENT + (1.0 - .$GIS_OPT_PERCENT) * g#$GIS_OPT_SECOND
545 $GIS_OPT_OUTPUT.b = b#$GIS_OPT_FIRST * .$GIS_OPT_PERCENT + (1.0 - .$GIS_OPT_PERCENT) * b#$GIS_OPT_SECOND
546 EOF
547 as the latter will read each input map only once.
549 Backwards compatibility
551 For the backwards compatibility with GRASS 6, if no options are given,
552 it manufactures file=- (which reads from stdin), so you can continue to
553 use e.g.:
554 r.mapcalc < file
555 or:
556 r.mapcalc <<EOF
557 foo = 1
558 EOF
559 But unless you need compatibility with previous GRASS GIS versions, use
560 file= explicitly, as stated above.
561 When the map name contains uppercase letter(s) or a dot which are not
563 allowed to be in module option names, the r.mapcalc command will be
564 valid also without quotes:
565 r.mapcalc elevation_A=1
566 r.mapcalc elevation.1=1
567 However, this syntax is not recommended as quotes as stated above more
568 safe. Using quotes is both backwards compatible and valid in future.
569 Interactive input in command line
571 For formulas that the user enters from standard input (rather than from
572 the command line), a line continuation feature now exists. If the user
573 adds a backslash to the end of an input line, r.mapcalc assumes that
574 the formula being entered by the user continues on to the next input
575 line. There is no limit to the possible number of input lines or to
576 the length of a formula.
577 If the r.mapcalc formula entered by the user is very long, the map
579 title will contain only some of it, but most (if not all) of the for‐
580 mula will be placed into the history file for the result map.
581 Raster MASK handling
583 r.mapcalc follows the common GRASS behavior of raster MASK handling, so
584 the MASK is only applied when reading an existing GRASS raster map.
585 This implies that, for example, the command:
586 r.mapcalc "elevation_exaggerated = elevation * 3"
587 create a map respecting the masked pixels if MASK is active.
588 However, when creating a map which is not based on any map, e.g. a map
590 from a constant:
591 r.mapcalc "base_height = 200.0"
592 the created raster map is limited only by a computation region but it
593 is not affected by an active MASK. This is expected because, as men‐
594 tioned above, MASK is only applied when reading, not when writing a
595 raster map.
596 If also in this case the MASK should be applied, an if() statement
598 including the MASK should be used, e.g.:
599 r.mapcalc "base_height = if(MASK, 200.0, null())"
600 When testing MASK related expressions keep in mind that when MASK is
601 active you don’t see data in masked areas even if they are not NULL.
602 See r.mask for details.
603 eval function
605 If the output of the computation should be only one map but the expres‐
606 sion is so complex that it is better to split it to several expres‐
607 sions, the eval function can be used:
608 r.mapcalc << EOF
609 eval(elev_200 = elevation - 200, \
610 elev_5 = 5 * elevation, \
611 elev_p = pow(elev_5, 2))
612 elevation_result = (0.5 * elev_200) + 0.8 * elev_p
613 EOF
614 This example uses unix-like << EOF syntax to provide input to r.map‐
615 calc.
616 Note that the temporary variables (maps) are not created and thus it
618 does not matter whether they exists or not. In the example above, if
619 map elev_200 exists it will not be overwritten and no error will be
620 generated. The reason is that the name elev_200 now denotes the tempo‐
621 rary variable (map) and not the existing map. The following parts of
622 the expression will use the temporary elev_200 and the existing
623 elev_200 will be left intact and will not be used. If a user want to
624 use the existing map, the name of the temporary variable (map) must be
625 changed.
626 Using the same map for input and output results
628 A map cannot be used both as an input and as an output as in this
629 invalid expression oldmap = oldmap + 1, instead a subsequent rename
630 using g.rename is needed when the same name is desired:
631 r.mapcalc "newmap = oldmap + 1"
632 g.rename raster=newmap,oldmap
633 Random number generator initialization
635 The pseudo-random number generator used by the rand() function can be
636 initialised to a specific value using the seed option. This can be
637 used to replicate a previous calculation.
638 Alternatively, it can be initialised from the system time and the PID
640 using the -r flag. This should result in a different seed being used
641 each time.
642 In either case, the seed will be written to the map’s history, and can
644 be seen using r.info.
645 If you want other people to be able to verify your results, it’s
647 preferable to use the seed option to supply a seed which is either
648 specified in the script or generated from a determenistic process such
649 as a pseudo-random number generator given an explicit seed.
650 Note that the rand() function will generate a fatal error if neither
652 the seed option nor the -s flag are given.
653
655 To compute the average of two raster map layers a and b:
656 ave = (a + b)/2
657 To form a weighted average:
659 ave = (5*a + 3*b)/8.0
660 To produce a binary representation of the raster map layer a so that
662 category 0 remains 0 and all other categories become 1:
663 mapmask = a != 0
664 This could also be accomplished by:
665 mapmask = if(a)
666 To mask raster map layer b by raster map layer a:
668 result = if(a,b)
669 To change all values below 5 to NULL:
671 newmap = if(map<5, null(), 5)
672 To create a map with random values in a defined range (needs either the
674 usage of -s flag or the seed parameter). The precision of the input
675 values determines the output precision (the resulting raster map type):
676 # write result as integer map (CELL)
677 random_int = rand(-100,100)
678 # write result as double precision floating point map (DCELL)
679 random_dcell = rand(-100.0,100.0)
680 # write result as single precision floating point map (FCELL)
681 random_fcell = float(rand(-100.0,100.0))
682 The graph() function allows users to specify a x-y conversion using
684 pairs of x,y coordinates. In some situations a transformation from one
685 value to another is not easily established mathematically, but can be
686 represented by a 2-D graph and then linearly interpolated. The graph()
687 function provides the opportunity to accomplish this. An x-axis value
688 is provided to the graph function along with the associated graph rep‐
689 resented by a series of x,y pairs. The x values must be monotonically
690 increasing (each larger than or equal to the previous). The graph
691 function linearly interpolates between pairs. Any x value lower the
692 lowest x value (i.e. first) will have the associated y value returned.
693 Any x value higher than the last will similarly have the associated y
694 value returned. Consider the request:
695 newmap = graph(map, 1,10, 2,25, 3,50)
696 X (map) values supplied and y (newmap) values returned:
697 0, 10
698 1, 10
699 1.5, 17.5
700 2.9, 47.5
701 4, 50
702 100, 50
703
705 The result variable on the left hand side of the equation should not
706 appear in the expression on the right hand side.
707 mymap = if( mymap > 0, mymap, 0)
708 Any maps generated by a r.mapcalc command only exist after the entire
710 command has completed. All maps are generated concurrently, row-by-row
711 (i.e. there is an implicit "for row in rows {...}" around the entire
712 expression). Thus the #, @, and [ ] operators cannot be used on a map
713 generated within same r.mapcalc command run. Consequently, the follow‐
714 ing (strikethrough code) does not work:
715 newmap = oldmap * 3.14
716 othermap = newmap[-1, 0] / newmap[1, 0]
717 Continuation lines must end with a \ and have no trailing white space
719 (blanks or tabs). If the user does leave white space at the end of con‐
720 tinuation lines, the error messages produced by r.mapcalc will be mean‐
721 ingless and the equation will not work as the user intended. This is
722 particularly important for the eval() function.
723 Currently, there is no comment mechanism in r.mapcalc. Perhaps adding
725 a capability that would cause the entire line to be ignored when the
726 user inserted a # at the start of a line as if it were not present,
727 would do the trick.
728 The function should require the user to type "end" or "exit" instead of
730 simply a blank line. This would make separation of multiple scripts
731 separable by white space.
732 r.mapcalc does not print a warning in case of operations on NULL cells.
734 It is left to the user to utilize the isnull() function.
735
737 g.region, r.bitpattern, r.blend, r.colors, r.fillnulls, r.mapcalc.sim‐
738 ple
739
741 r.mapcalc: An Algebra for GIS and Image Processing, by Michael Shapiro
742 and Jim Westervelt, U.S. Army Construction Engineering Research Labora‐
743 tory (March/1991).
744 Performing Map Calculations on GRASS Data: r.mapcalc Program Tutorial,
746 by Marji Larson, Michael Shapiro and Scott Tweddale, U.S. Army Con‐
747 struction Engineering Research Laboratory (December 1991)
748 Grey scale conversion is based on the C.I.E. x,y,z system where y rep‐
750 resents luminance. See "Fundamentals of Digital Image Processing," by
751 Anil K. Jain (Prentice Hall, NJ, 1989; p 67).
752
754 Michael Shapiro, U.S.Army Construction Engineering Research Laboratory
755 Glynn Clements
757
759 Available at: r.mapcalc source code (history)
760 Main index | Raster index | Topics index | Keywords index | Graphical
762 index | Full index
763 © 2003-2019 GRASS Development Team, GRASS GIS 7.8.2 Reference Manual
765GRASS 7.8.2 r.mapcalc(1)