r.mapcalcgrass - Интернет в облаке

ПРОГРАММА:

ИМЯ

r.mapcalc - Калькулятор растровой карты.

КЛЮЧЕВЫЕ СЛОВА

растр, алгебра

СИНТАКСИС

r.mapcalc
r.mapcalc --Помогите
r.mapcalc [-s] [выражение=string] [файл=имя] [семя=целое] [-затирать]
[-помощь] [-подробный] [-тихий] [-ui]

Флаги:
-s
Сгенерировать случайное начальное число (результат недетерминированный)

- перезаписать
Разрешить выходным файлам перезаписывать существующие файлы

--Помогите
Распечатать сводку использования

--подробный
Подробный вывод модуля

--тихий
Тихий выход модуля

--уи
Принудительный запуск диалогового окна GUI

Параметры:
выражение=string
Выражение для оценки

файл=имя
Файл, содержащий выражения для оценки

семя=целое
Семя для функции rand ()

ОПИСАНИЕ

r.mapcalc выполняет арифметические операции со слоями растровой карты. Можно создавать новые слои растровой карты.
которые являются арифметическими выражениями, включающими существующие слои растровой карты, целые или плавающие
точечные константы и функции.

Программа использование
r.mapcalc выражение имеет вид:

результат = выражение

в котором результат это имя слоя растровой карты, в котором будет содержаться результат расчета.
и выражение любое допустимое арифметическое выражение, включающее существующие слои растровой карты
(Кроме результат сам), целочисленные константы или константы с плавающей запятой и функции, известные
калькулятор. Скобки разрешены в выражении и могут иметь любую глубину вложенности.
результат будет создан в текущем наборе карт пользователя.

As выражение = это первый вариант, он установлен по умолчанию. Это означает, что передача
выражение в командной строке возможно, если выражение заключено в кавычки и пробел
включается перед первым = подписать. Пример (результирующая карта - 'foo'):
r.mapcalc "foo = 1"
или:
r.mapcalc 'foo = 1'
Выражение без кавычек (т. Е. Разделенное на несколько аргументов) не будет работать и не будет пропускать
пробел перед знаком =:
r.mapcalc 'foo = 1'
Извините, не допустимый параметр
Чтобы прочитать команду из файла, явно используйте file =, например:
r.mapcalc file = файл
или:
r.mapcalc file = - <файл
или:
r.mapcalc файл = - <
фу = 1
EOF

Формула, введенная в r.mapcalc пользователем записывается как в результат название карты
(который отображается в файле категории для результат) и в файле истории для результат.

Некоторые символы имеют особое значение для командной оболочки. Если пользователь вводит ввод
в r.mapcalc в командной строке выражения следует заключать в одинарные кавычки.
См. ПРИМЕЧАНИЯ ниже.

Операторы и заказ of старшинство
Поддерживаются следующие операторы:
Оператор Значение Приоритет типа
-------------------------------------------------- ------------
- Арифметика отрицания 12
~ одно дополнение Побитовое 12
! не логический 12
^ Арифметика возведения в степень 11
% модуля Арифметика 10
/ деление Арифметика 10
* Арифметика умножения 10
+ сложение Арифметика 9
- Арифметика вычитания 9
<< сдвиг влево Побитовое 8
>> сдвиг вправо Побитовое 8
>>> Сдвиг вправо (без знака) Побитовое 8
> больше логического 7
> = больше или равно Логическое 7
<меньше логического 7
<= меньше или равно Логическое 7
== равно логическое 6
! = не равно Логическое 6
& побитовый и побитовый 5
| побитовый или побитовый 4
&& логический и логический 3
&&& логическое и [1] логическое 3
|| логический или логический 2
||| логическое или [1] логическое 2
?: условное логическое 1
(модуль - остаток от деления)

[1] &&& и ||| операторы обрабатывают нулевые значения иначе, чем другие операторы. Увидеть
раздел под названием NULL, поддержка ниже для более подробной информации.

Операторы применяются слева направо, с более высоким приоритетом.
перед теми, у кого более низкий приоритет. Деление на 0 и модуль на 0 приемлемы и
дать результат NULL. Логические операторы дают результат 1, если сравнение верно, 0
в противном случае.

Растр карта слой имена
Все, что в выражении не является числом, именем оператора или функции, переносится в
быть именем слоя растровой карты. Примеры:

высота
x3
3d. Его

Этому соглашению об именах соответствует большинство слоев растровых карт GRASS. Однако, если слой растровой карты
имеет имя, которое противоречит приведенному выше правилу, оно должно быть заключено в кавычки. Например,
выражение

х = ab

будет интерпретироваться как: x равно минус b, тогда как

x = "ab"

будет интерпретироваться как: x равно слою растровой карты с именем ab

Также

х = 3107

создаст x заполнен числом 3107, а

х = "3107"

скопирует слой растровой карты 3107 в слой растровой карты x.

Кавычки не требуются, если имена слоев растровой карты не выглядят как числа или не содержат
операторы ИЛИ, если программа не запускается в неинтерактивном режиме. Приведенные здесь примеры предполагают
программа запускается в интерактивном режиме. См. ПРИМЕЧАНИЯ ниже.

r.mapcalc будет искать слои растровой карты в соответствии с текущим набором карт пользователя
путь поиска. Можно переопределить путь поиска и указать набор карт, из которого
для выбора слоя растровой карты. Это делается путем указания имени слоя растровой карты в
форма:

имя @ mapset

Например, следующее является допустимым выражением:

результат = x @ ПОСТОЯННЫЙ / y @ ПОЧВЫ

Указанный набор карт не обязательно должен быть в пути поиска набора карт. (Этот метод
переопределение пути поиска набора карт является общим для всех команд GRASS, а не только r.mapcalc.)

В окрестности изменение
Карты и изображения - это файлы базы данных, хранящиеся в растровом формате, т. Е. В двухмерном формате.
матрицы целочисленных значений. В r.mapcalc, за картами может следовать окрестности изменение
который указывает относительное смещение от текущей оцениваемой ячейки. Формат
карта [r, c], Где r это смещение строки и c это смещение столбца. Например, карта [1,2]
относится к ячейке на одну строку ниже и два столбца справа от текущей ячейки,
карта [-2, -1] относится к ячейке двумя строками выше и одним столбцом слева от текущего
ячейка и карта [0,1] относится к ячейке на один столбец справа от текущей ячейки. Этот
синтаксис позволяет разрабатывать фильтры типа окрестности в пределах одной карты или
несколько карт.

Растр карта слой ценности к Каталог файл
Иногда желательно использовать значение, связанное с категорией этикетка вместо
само значение категории. Если перед именем слоя растровой карты стоит @ оператор, то
метки в файле категории для слоя растровой карты используются в выражении вместо
значение категории.

Например, предположим, что слой растровой карты почва.ph (представляющий значения pH почвы) имеет
файл категории со следующими метками:

кошка этикетка
------------------
0 нет данных
1 1.4
2 2.4
3 3.5
4 5.8
5 7.2
6 8.8
7 9.4

Тогда выражение:

результат = @ soils.ph

даст результат со значениями категории 0, 1.4, 2.4, 3.5, 5.8, 7.2, 8.8 и 9.4.

Обратите внимание, что этот оператор может применяться только к слоям растровой карты и дает плавающий
значение точки в выражении. Следовательно, метка категории должна начинаться с действительного
количество. Если метка категории целочисленная, она будет представлена ​​плавающей точкой.
количество. Если метка категории не начинается с цифры или отсутствует, она будет
представлен NULL (нет данных) в результирующей растровой карте.

серый лестница эквиваленты и цвет разъединяет
Часто бывает полезно изменить цвета, назначенные категориям карт. Это
особенно полезно, когда спектральные свойства клеток имеют значение (как в случае с изображениями
данные), или когда значения категорий карты представляют реальные количества (например, когда значения категорий
отражают истинные значения высоты). Изменение цвета карты также может помочь визуальному распознаванию,
и печать карт.

Оператор # может использоваться для преобразования значений категорий карты в их шкалу серого.
эквиваленты или для извлечения красного, зеленого или синего компонентов слоя растровой карты в
отдельные слои растровой карты.

результат = # карта

преобразует значение каждой категории в карта до значения в диапазоне 0–255, которое представляет
уровень серой шкалы, подразумеваемый цветом для категории. Если карта имеет цвет серой шкалы
table, то уровень серого - это то, что оценивает #map. В противном случае он рассчитывается как:

0.10 * красный + 0.81 * зеленый + 0.01 * синий

В качестве альтернативы вы можете использовать:

результат = y # карта

для использования весов NTSC:

0.30 * красный + 0.59 * зеленый + 0.11 * синий

Или вы можете использовать:

результат = i # карта

использовать равные веса:

0.33 * красный + 0.33 * зеленый + 0.33 * синий

У оператора # есть еще три формы: r # map, g # map, b # map. Они извлекают красный, зеленый,
или синие компоненты в названной растровой карте соответственно. Скрипт оболочки GRASS р. смесь
извлекает каждый из этих компонентов из двух слоев растровой карты и объединяет их
указанный пользователем процент. Эти формы позволяют делать цветовые разделения. Например, чтобы
извлеките красный компонент из карта и сохраните его в новом слое карты 0-255 red, Пользователь
может напечатать:

красный = r # карта

Чтобы присвоить этой карте серые цвета, введите:

r.colors map = красный цвет = правила
черный цвет
белый

Чтобы присвоить этой карте красный цвет, введите:

r.colors map = красный цвет = правила
черный цвет
red

функции
Поддерживаемые в настоящее время функции перечислены в таблице ниже. Тип результата
указан в последнем столбце. F означает, что функции всегда приводят к плавающему
балльная стоимость, I означает, что функция дает целочисленный результат, а * указывает на то, что
результатом будет число с плавающей запятой, если какой-либо из аргументов функции является значениями с плавающей запятой и
целое число, если все аргументы целые.

тип описания функции
-------------------------------------------------- -------------------------
abs (x) возвращает абсолютное значение x *
acos (x) обратный косинус x (результат в градусах) F
asin (x) обратный синус x (результат в градусах) F
atan (x) арктангенс x (результат в градусах) F
atan (x, y) арктангенс от y / x (результат в градусах) F
cos (x) косинус x (x в градусах) F
double (x) преобразовать x в числа с плавающей запятой двойной точности F
eval ([x, y, ...,] z) оценивает значения перечисленных expr, передает результаты в z
exp (x) экспоненциальная функция от x F
exp (x, y) x в степени y F
float (x) конвертирует x в числа с плавающей запятой одинарной точности F
graph (x, x1, y1 [x2, y2 ..]) преобразует x в ay на основе точек в графе F
graph2(x,x1[,x2,..],y1[,y2..])
альтернативная форма графа () F
если варианты решения: *
if (x) 1, если x не ноль, 0 в противном случае
if (x, a) a, если x не ноль, 0 в противном случае
if (x, a, b) a, если x не равен нулю, b иначе
if (x, a, b, c) a, если x> 0, b, если x равен нулю, c, если x <0
int (x) преобразовать x в целое число [усекает] I
isnull (x) проверяет, если x = NULL
log (x) натуральный логарифм x F
log (x, b) журнал x base b F
max (x, y [, z ...]) наибольшее значение из перечисленных *
median (x, y [, z ...]) среднее значение перечисленных *
min (x, y [, z ...]) наименьшее значение из перечисленных *
mode (x, y [, z ...]) значение режима из перечисленных *
nmax (x, y [, z ...]) наибольшее значение из перечисленных, исключая NULL *
nmedian (x, y [, z ...]) медианное значение перечисленных, исключая NULL *
nmin (x, y [, z ...]) наименьшее значение из перечисленных, исключая NULL *
nmode (x, y [, z ...]) значение режима из перечисленных, исключая NULL *
not (x) 1, если x равен нулю, 0 в противном случае
pow (x, y) x в степень y *
rand (a, b) случайное значение x: a <= x <b *
round (x) округлить x до ближайшего целого I
round (x, y) округлить x до ближайшего кратного y
round (x, y, z) округлить x до ближайшего y * i + z для некоторого целого числа i
sin (x) синус x (x в градусах) F
sqrt (x) квадратный корень из x F
tan (x) касательная к x (x в градусах) F
xor (x, y) исключающее ИЛИ (XOR) x и y I
Внутренние переменные:
row () текущая строка движущегося окна
col () текущий столбец движущегося окна
x () текущая координата x движущегося окна
y () текущая координата y движущегося окна
ewres () текущее разрешение восток-запад
nsres () текущее разрешение север-юг
null () значение NULL
Обратите внимание, что индексирование row () и col () начинается с 1.

Плавающий точка ценности in выражение
В выражении разрешены числа с плавающей запятой. Число с плавающей запятой - это число
который содержит десятичную точку:
2.3 12.0 12. 81
Значения с плавающей запятой в выражении обрабатываются особым образом. С арифметикой и
логические операторы, если один из операндов имеет значение с плавающей запятой, другой преобразуется в число с плавающей запятой, а
результат операции - float. Это означает, в частности, что деление целых чисел
приводит к (усеченному) целому числу, а деление чисел с плавающей запятой дает точное число с плавающей запятой.
балльная стоимость. Для функций типа * (см. Таблицу выше) результат будет float, если таковой имеется.
аргумент - число с плавающей запятой, в противном случае - целое число.

Примечание. Если вы рассчитываете с целыми числами, результирующая карта будет целочисленной. если ты
хотите получить результат с плавающей запятой, добавьте десятичную точку к целому числу (ам).

Если вы хотите деление с плавающей запятой, по крайней мере, один из аргументов должен быть плавающим.
балльная стоимость. Умножение одного из них на 1.0 даст результат с плавающей запятой, как и
используя float ():
r.mapcalc "ndvi = float (lsat.4 - lsat.3) / (lsat.4 + lsat.3)"

NULL, поддержка
· Деление на ноль должно приводить к NULL.

· Модуль на ноль должен приводить к NULL.

· NULL-значения в любой арифметической или логической операции должны приводить к NULL.
(однако, &&& и ||| обрабатываются особым образом, как описано ниже).

· Символы &&& и ||| операторы соблюдают следующие аксиомы, даже если x равен NULL:
х &&& ложь == ложь
ложь &&& x == ложь
х ||| правда == правда
правда ||| х == истина

· NULL-значения в аргументах функции должны приводить к NULL (однако, if (), eval () и
isnull () обрабатываются особым образом, как описано ниже).

· Функция eval () всегда возвращает свой последний аргумент

· Ситуация для if () такова:
если (х)
NULL, если x равен NULL; 0, если x равен нулю; 1 иначе
если (х, а)
NULL, если x равен NULL; a, если x не равно нулю; 0 иначе
если (x, a, b)
NULL, если x равен NULL; a, если x не равно нулю; б в противном случае
если (x, n, z, p)
NULL, если x равен NULL; n, если x отрицательный;
z, если x равен нулю; p, если x положительный

· (Новая) функция isnull (x) возвращает: 1, если x равен NULL; 0 в противном случае. Новый)
функция null () (не имеющая аргументов) возвращает целое число NULL.

· Ненулевые, но недопустимые аргументы функций должны приводить к NULL.
Примеры:
журнал (-2)
sqrt (-2)
pow (a, b), где a отрицательно, а b не является целым числом

Поддержка NULL: обратите внимание, что любая математика, выполняемая с ячейками NULL, всегда приводит к NULL
значение для этих ячеек. Если вы хотите заменить пустую ячейку на лету, используйте isnull ()
тестовая функция в if-выражении.

Пример: пользователи хотят, чтобы ячейки со значением NULL обрабатывались как нули. Чтобы добавить карты A и
B (где B содержит NULL), чтобы получить карту C, пользователь может использовать такую ​​конструкцию:

C = A +, если (isnull (B), 0, B)

NULL, и Условия:

Для формы с одним аргументом:
if (x) = NULL, если x равен NULL
if (x) = 0 if x = 0
if (x) = 1 в противном случае (т.е. x не является ни NULL, ни 0).

Для формы с двумя аргументами:
if (x, a) = NULL, если x равен NULL
if (x, a) = 0 if x = 0
if (x, a) = a в противном случае (т.е. x не равен ни NULL, ни 0).

Для формы с тремя аргументами:
if (x, a, b) = NULL, если x равен NULL
if (x, a, b) = b, если x = 0
if (x, a, b) = a в противном случае (т.е. x не равен ни NULL, ни 0).

Для формы с четырьмя аргументами:
if (x, a, b, c) = NULL, если x равен NULL
if (x, a, b, c) = a, если x> 0
if (x, a, b, c) = b, если x = 0
if (x, a, b, c) = c, если x <0
В более общем смысле, все операторы и большинство функций возвращают NULL, если * любой * из их аргументов
равны NULL.
Функции if (), isnull () и eval () являются исключениями.
Функция isnull () возвращает 1, если ее аргумент равен NULL, и 0 в противном случае. Если пользователь
хочет обратного, символ! необходимо использовать оператор, например, "! isnull (x)".

Все формы if () возвращают NULL, если первый аргумент равен NULL. Формы аргументов 2, 3 и 4
if () вернет NULL, если аргумент selected - NULL, например:
if (0, a, b) = b независимо от того, является ли a NULL
if (1, a, b) = a независимо от того, является ли b NULL
eval () всегда возвращает свой последний аргумент, поэтому он возвращает NULL, только если последний аргумент равен
НОЛЬ.

Внимание: Пользователь не может проверить значение NULL с помощью оператора ==, так как он возвращает NULL, если
или оба аргумента равны NULL, т.е. если x и y оба равны NULL, то «x == y» и «x! = y» равны
оба NULL, а не 1 и 0 соответственно.
Такое поведение имеет смысл, если пользователь рассматривает NULL как представление неизвестной величины.
Например, если x и y оба неизвестны, то значения «x == y» и «x! = Y» также будут
неизвестный; если они оба имеют неизвестные значения, пользователь не знает, оба ли они
имеют одинаковую ценность.

ПРИМЕЧАНИЯ

Применение к команду линия
Следует проявлять особую осторожность, если выражение задается в командной строке. Некоторые персонажи
имеют особое значение для оболочки UNIX. К ним, среди прочего, относятся:
* ()> & |

Желательно заключать выражение в одинарные кавычки; например:
'результат = высота * 2'
Без кавычек *, имеющий особое значение для оболочки UNIX, был бы изменен.
и r.mapcalc увидит что-то другое, кроме *.

Многочисленные расчеты
В общем, желательно делать как можно больше в каждой команде r.mapcalc. Например
скорее, чем:
r.mapcalc "$ GIS_OPT_OUTPUT.r = r # $ GIS_OPT_FIRST *. $ GIS_OPT_PERCENT + (1.0 -. $ GIS_OPT_PERCENT) * r # $ GIS_OPT_SECOND"
r.mapcalc "$ GIS_OPT_OUTPUT.g = g # $ GIS_OPT_FIRST *. $ GIS_OPT_PERCENT + (1.0 -. $ GIS_OPT_PERCENT) * g # $ GIS_OPT_SECOND"
r.mapcalc "$ GIS_OPT_OUTPUT.b = b # $ GIS_OPT_FIRST *. $ GIS_OPT_PERCENT + (1.0 -. $ GIS_OPT_PERCENT) * b # $ GIS_OPT_SECOND"

использование:
r.mapcalc <
$ GIS_OPT_OUTPUT.r = r # $ GIS_OPT_FIRST *. $ GIS_OPT_PERCENT + (1.0 -. $ GIS_OPT_PERCENT) * r # $ GIS_OPT_SECOND
$ GIS_OPT_OUTPUT.g = g # $ GIS_OPT_FIRST *. $ GIS_OPT_PERCENT + (1.0 -. $ GIS_OPT_PERCENT) * g # $ GIS_OPT_SECOND
$ GIS_OPT_OUTPUT.b = b # $ GIS_OPT_FIRST *. $ GIS_OPT_PERCENT + (1.0 -. $ GIS_OPT_PERCENT) * b # $ GIS_OPT_SECOND
EOF

поскольку последний будет читать каждую входную карту только один раз.

Назад совместимость
Для обратной совместимости с GRASS 6, если не указаны опции, он производит
file = - (который читает из stdin), поэтому вы можете продолжать использовать, например:
r.mapcalc <файл
или:
r.mapcalc <
фу = 1
EOF
Но если вам не нужна совместимость с предыдущими версиями GRASS GIS, используйте явно file =,
как указано выше.

Когда название карты содержит заглавные буквы или точки, использование которых запрещено.
имена опций модуля, r.mapcalc команда будет действительна и без кавычек:
r.mapcalc elevation_A = 1
r.mapcalc elevation.1 = 1
Однако этот синтаксис не рекомендуется использовать в кавычках, поскольку это более безопасно. Использование цитат
имеет обратную совместимость и действует в будущем.

Интерактивное вход in команду линия
Для формул, которые пользователь вводит из стандартного ввода (а не из командной строки),
теперь существует функция продолжения линии. Если пользователь добавляет обратную косую черту в конец
строка ввода, r.mapcalc предполагает, что формула, вводимая пользователем, продолжает
следующая строка ввода. Нет ограничений на возможное количество входных строк или
длина формулы.

Если же линия индикатора r.mapcalc формула, введенная пользователем, очень длинная, заголовок карты будет содержать только
некоторые из них, но большая часть (если не все) формулы будет помещена в файл истории для
результат карта.

Когда пользователь вводит ввод в r.mapcalc не интерактивно в командной строке, программа
не будет предупреждать пользователя не перезаписывать существующие слои карты. Поэтому пользователям следует принимать
позаботьтесь о присвоении программным выходам имен растровых карт, которые еще не существуют в их текущих
наборы карт.

Растр МАСКА обращение
r.mapcalc следует обычному поведению GRASS при обработке растровой МАСКИ, поэтому МАСКА только
применяется при чтении существующей растровой карты GRASS. Это означает, например, что
команда:
r.mapcalc "elevation_exaggerated = высота * 3"
создать карту с учетом замаскированных пикселей, если МАСКА активна.

Однако при создании карты, которая не основана на какой-либо карте, например, карта из константы:
r.mapcalc "base_height = 200.0"
созданная растровая карта ограничена только областью вычислений, но не зависит от
активная МАСКА. Это ожидается, потому что, как упоминалось выше, МАСКА применяется только тогда, когда
чтение, а не при написании растровой карты.

Если также и в этом случае должна применяться МАСКА, оператор if (), включающий МАСКУ
следует использовать, например:
r.mapcalc "base_height = if (МАСКА, 200.0, null ())"
При тестировании выражений, связанных с МАСКОЙ, имейте в виду, что когда МАСКА активна, вы не видите
данные в замаскированных областях, даже если они не равны NULL. Видеть р.маска для получения информации.

Eval функция
Если результатом вычисления должна быть только одна карта, но выражение настолько сложное
что лучше разбить его на несколько выражений, можно использовать функцию eval:
r.mapcalc << EOF
eval (elev_200 = высота - 200, \
elev_5 = 5 * высота, \
elev_p = pow (elev_5, 2))
elevation_result = (0.5 * высота_200) + 0.8 * высота_p
EOF
В этом примере используется unix-подобный синтаксис << EOF для ввода данных в r.mapcalc.

Обратите внимание, что временные переменные (карты) не создаются, поэтому это не имеет значения.
существуют они или нет. В приведенном выше примере, если существует карта elev_200, она не будет
перезаписывается, и никаких ошибок генерироваться не будет. Причина в том, что теперь название elev_200
обозначает временную переменную (карту), а не существующую карту. Следующие части
выражение будет использовать временное значение elev_200, а существующее значение elev_200 останется нетронутым
и не будет использоваться. Если пользователь хочет использовать существующую карту, имя временного
переменная (карта) должна быть изменена.

Случайно номер генератор инициализация
Генератор псевдослучайных чисел, используемый функцией rand (), может быть инициализирован как
конкретное значение с использованием семя вариант. Это можно использовать для воспроизведения предыдущего
расчет.

В качестве альтернативы его можно инициализировать из системного времени и PID с помощью -r флаг.
Это должно привести к тому, что каждый раз будет использоваться другое семя.

В любом случае семя будет записано в историю карты, и его можно будет увидеть с помощью
р.инфо.

Если вы хотите, чтобы другие люди могли проверить ваши результаты, предпочтительнее использовать
семя возможность предоставить начальное значение, которое либо указано в сценарии, либо сгенерировано из
детерменистический процесс, такой как генератор псевдослучайных чисел с явным начальным значением.

Обратите внимание, что функция rand () вызовет фатальную ошибку, если ни один из семя вариант ни
-s флаг даны.

ПРИМЕРЫ

Чтобы вычислить среднее значение двух слоев растровой карты a и b:
пр = (а + б) / 2
Чтобы сформировать средневзвешенное значение:
ср = (5 * a + 3 * b) /8.0
Для создания двоичного представления слоя растровой карты a так что категория 0 остается 0
а все остальные категории становятся 1:
маска = а! = 0
Этого также можно добиться с помощью:
маска = если (а)
Чтобы замаскировать слой растровой карты b по слою растровой карты a:
результат = если (a, b)
Чтобы изменить все значения ниже 5 на NULL:
newmap = if (карта <5, null (), 5)
Функция graph () позволяет пользователям указывать преобразование xy, используя пары x, y.
координаты. В некоторых ситуациях преобразование одного значения в другое нелегко.
установлен математически, но может быть представлен двухмерным графиком, а затем линейно
интерполированный. Функция graph () предоставляет возможность сделать это. Ось x
значение предоставляется функции графика вместе со связанным графиком, представленным
серия пар x, y. Значения x должны монотонно увеличиваться (каждое больше или
равно предыдущему). Функция графика линейно интерполирует пары. Любой x
значение ниже наименьшего значения x (т.е. первого) будет возвращено связанное значение y.
Любое значение x выше, чем последнее, аналогичным образом будет возвращать связанное значение y.
Рассмотрим запрос:
newmap = graph (карта, 1,10, 2,25, 3,50)
Поставляемые значения X (map) и возвращаемые значения y (newmap):
0, 10
1, 10
1.5, 17.5
2.9, 47.5
4, 50
100, 50

KNOWN ВОПРОСЫ

Строки продолжения должны заканчиваться \ и иметь нет конечный пробел (пробелы или табуляторы). Если
пользователь оставляет пробелы в конце строк продолжения, сообщения об ошибках
производства r.mapcalc будет бессмысленным, и уравнение не будет работать, поскольку пользователь
предназначены. Это особенно важно для функции eval ().

В настоящее время в r.mapcalc. Возможно добавление возможности, которая
приведет к тому, что вся строка будет проигнорирована, когда пользователь вставит # в начале
линия, как будто ее нет, сделает свое дело.

Функция должна требовать, чтобы пользователь набрал «конец» или «выход», а не просто пустое поле.
линия. Это сделало бы разделение нескольких скриптов разделяемым пробелом.

r.mapcalc не выводит предупреждение в случае операций с NULL ячейками. Это оставлено на усмотрение
пользователю использовать функцию isnull ().

Используйте r.mapcalcgrass онлайн с помощью сервисов onworks.net