r.mapcalcgrass: en línea en la nube

PROGRAMA:

NOMBRE

r.mapcalc - Calculadora de mapa de trama.

PALABRAS CLAVE

raster, álgebra

SINOPSIS

r.mapcalc
r.mapcalc --ayuda
r.mapcalc [-s] [expresión=cadena] [presentar=nombre ] [dispersores =entero] [-exagerar]
[-ayuda] [-verboso] [-tranquilo] [-ui]

Banderas
-s
Generar semilla aleatoria (el resultado no es determinista)

--Sobrescribir
Permitir que los archivos de salida sobrescriban los archivos existentes

--ayuda
Resumen de uso de impresión

--verboso
Salida del módulo detallado

--tranquilo
Salida de módulo silencioso

--ui
Forzar el inicio del cuadro de diálogo GUI

parámetros:
expresión=cadena
Expresión para evaluar

presentar=nombre
Archivo que contiene expresiones para evaluar

dispersores =entero
Función semilla para rand ()

DESCRIPCIÓN

r.mapcalc realiza operaciones aritméticas en capas de mapas ráster. Se pueden crear nuevas capas de mapas ráster
que son expresiones aritméticas que involucran capas de mapa ráster existentes, enteras o flotantes
constantes puntuales y funciones.

Perdida de Peso use
r.mapcalc expresión tiene la forma:

resultado = expresión

donde resultado es el nombre de una capa de mapa ráster para contener el resultado del cálculo
y expresión es cualquier expresión aritmética legal que involucre capas de mapa ráster existentes
(excepto resultado sí mismo), constantes enteras o de coma flotante, y funciones conocidas por el
calculadora. Los paréntesis están permitidos en la expresión y se pueden anidar a cualquier profundidad.
resultado se creará en el conjunto de mapas actual del usuario.

As expresión = es la primera opción, es la predeterminada. Esto significa que pasar un
expresión en la línea de comando es posible siempre que la expresión esté entre comillas y un espacio
se incluye antes de la primera = firmar. Ejemplo ('foo' es el mapa resultante):
r.mapcalc "foo = 1"
o bien:
r.mapcalc 'foo = 1'
Una expresión sin comillas (es decir, dividida en varios argumentos) no funcionará, ni se omitirá
el espacio antes del signo =:
r.mapcalc 'foo = 1'
Perdón, no es un parámetro válido
Para leer el comando del archivo, use file = explícitamente, por ejemplo:
r.mapcalc archivo = archivo
o bien:
r.mapcalc archivo = - <archivo
o bien:
archivo r.mapcalc = - <
fo = 1
EOF

La fórmula ingresada a r.mapcalc por el usuario se registra tanto en el resultado título del mapa
(que aparece en el archivo de categoría para resultado) y en el archivo histórico de resultado.

Algunos caracteres tienen un significado especial para el shell de comandos. Si el usuario está ingresando una entrada
a r.mapcalc en la línea de comando, las expresiones deben incluirse entre comillas simples.
Consulte las NOTAS a continuación.

telecomunicaciones y solicite of precedencia
Se admiten los siguientes operadores:
Operador Significado Tipo Precedencia
-------------------------------------------------- ------------
- Aritmética de negación 12
~ complemento de uno Bitwise 12
! no lógico 12
^ Aritmética de exponenciación 11
% módulo Aritmética 10
/ división Aritmética 10
* multiplicación aritmética 10
+ suma Aritmética 9
- Aritmética de resta 9
<< desplazamiento a la izquierda 8 bit a bit
>> desplazamiento a la derecha Bitwise 8
>>> desplazamiento a la derecha (sin firmar) Bit a bit 8
> mayor que Logical 7
> = mayor o igual a 7 lógico
<menor que Logical 7
<= menor o igual a 7 lógico
== igual a 6 lógico
! = no es igual a 6 lógico
& bit a bit y bit a bit 5
| bit a bit o bit a bit 4
&& lógico y lógico 3
&&& lógico y [1] lógico 3
|| lógico o lógico 2
||| lógico o [1] lógico 2
?: condicional Lógico 1
(el módulo es el resto de la división)

[1] El &&& y ||| los operadores manejan los valores nulos de manera diferente a otros operadores. Ver el
sección titulada NULL SOPORTE a continuación para más detalles.

Los operadores se aplican de izquierda a derecha, con los de mayor precedencia aplicados
antes que aquellos con menor precedencia. La división por 0 y el módulo por 0 son aceptables y
dar un resultado NULO. Los operadores lógicos dan un resultado de 1 si la comparación es verdadera, 0
de otra manera.

Raster mapa . nombres
Cualquier cosa en la expresión que no sea un número, operador o nombre de función se lleva a
ser un nombre de capa de mapa ráster. Ejemplos:

elevación
x3
3d. Su

La mayoría de las capas de mapas ráster de GRASS cumplen con esta convención de nomenclatura. Sin embargo, si una capa de mapa ráster
tiene un nombre que entra en conflicto con la regla anterior, debe citarse. Por ejemplo, el
expresión

x = ab

se interpretaría como: x es igual a a menos b, mientras que

x = "ab"

se interpretaría como: x es igual a la capa de mapa ráster llamada ab

También

x = 3107

crearía x lleno con el número 3107, mientras

x = "3107"

copiaría la capa del mapa ráster 3107 a la capa del mapa ráster x.

Las cotizaciones no son necesarias a menos que los nombres de la capa del mapa ráster parezcan números o contengan
operadores, O a menos que el programa se ejecute de forma no interactiva. Los ejemplos dados aquí suponen
El programa se ejecuta de forma interactiva. Consulte las NOTAS a continuación.

r.mapcalc buscará las capas del mapa ráster de acuerdo con el conjunto de mapas actual del usuario
ruta de búsqueda. Es posible anular la ruta de búsqueda y especificar el conjunto de mapas desde el que
para seleccionar la capa del mapa ráster. Esto se hace especificando el nombre de la capa del mapa ráster en
la forma:

nombre @ mapset

Por ejemplo, la siguiente es una expresión legal:

resultado = x @ PERMANENTE / y @ SUELOS

El conjunto de mapas especificado no tiene que estar en la ruta de búsqueda del conjunto de mapas. (Este método de
anular la ruta de búsqueda del conjunto de mapas es común a todos los comandos de GRASS, no solo r.mapcalc.)

La barrio modificador
Los mapas y las imágenes son archivos de base de datos almacenados en formato ráster, es decir, bidimensionales.
matrices de valores enteros. En r.mapcalc, los mapas pueden ir seguidos de un barrio modificador
que especifica un desplazamiento relativo de la celda actual que se está evaluando. El formato es
mapa [r, c], donde el r es el desplazamiento de fila y c es el desplazamiento de la columna. Por ejemplo, mapa [1,2]
se refiere a la celda una fila debajo y dos columnas a la derecha de la celda actual,
mapa [-2, -1] se refiere a la celda dos filas arriba y una columna a la izquierda de la actual
celda, y mapa [0,1] se refiere a la celda una columna a la derecha de la celda actual. Esta
La sintaxis permite el desarrollo de filtros de tipo vecindario dentro de un solo mapa o en
múltiples mapas.

Raster mapa . valores desde los categoría presentar
A veces es deseable utilizar un valor asociado con el valor de una categoría. Etiqueta en vez de
valor de la categoría en sí. Si el nombre de una capa de mapa ráster está precedido por @ operador, entonces el
Las etiquetas en el archivo de categoría para la capa de mapa ráster se utilizan en la expresión en lugar de
el valor de la categoría.

Por ejemplo, suponga que la capa de mapa ráster suelo.ph (que representa los valores de pH del suelo) tiene un
archivo de categoría con etiquetas de la siguiente manera:

etiqueta de gato
------------------
0 sin datos
1 1.4
2 2.4
3 3.5
4 5.8
5 7.2
6 8.8
7 9.4

Entonces la expresión:

resultado = @ suelos.ph

produciría un resultado con valores de categoría 0, 1.4, 2.4, 3.5, 5.8, 7.2, 8.8 y 9.4.

Tenga en cuenta que este operador solo se puede aplicar a capas de mapas ráster y produce una
valor en puntos en la expresión. Por lo tanto, la etiqueta de la categoría debe comenzar con un
número. Si la etiqueta de la categoría es un número entero, estará representada por un punto flotante
número. Si la etiqueta de la categoría no comienza con un número o falta, será
representado por NULL (sin datos) en el mapa ráster resultante.

Gris escala equivalentes y Color coordinados
A menudo es útil manipular los colores asignados a las categorías de mapas. Esto es
particularmente útil cuando las propiedades espectrales de las células tienen significado (como con las imágenes
datos), o cuando los valores de la categoría del mapa representan cantidades reales (como cuando los valores de la categoría
reflejan valores de elevación reales). La manipulación del color del mapa también puede ayudar al reconocimiento visual,
e impresión de mapas.

El operador # se puede utilizar para convertir los valores de la categoría del mapa a su escala de grises
equivalentes o para extraer los componentes rojo, verde o azul de una capa de mapa ráster en
capas de mapa ráster separadas.

resultado = #mapa

convierte cada valor de categoría en mapa a un valor en el rango 0-255 que representa el
nivel de escala de grises implícito en el color de la categoría. Si el mapa tiene un color de escala de grises
tabla, entonces el nivel de gris es lo que #map evalúa. De lo contrario, se calcula como:

0.10 * rojo + 0.81 * verde + 0.01 * azul

Alternativamente, puede utilizar:

resultado = y # mapa

para utilizar las ponderaciones NTSC:

0.30 * rojo + 0.59 * verde + 0.11 * azul

O puede usar:

resultado = i # mapa

utilizar ponderaciones iguales:

0.33 * rojo + 0.33 * verde + 0.33 * azul

El operador # tiene otras tres formas: r # map, g # map, b # map. Estos extraen el rojo, verde,
o componentes azules en el mapa ráster con nombre, respectivamente. El script de shell de GRASS r.blend
extrae cada uno de estos componentes de dos capas de mapa ráster y los combina mediante un
porcentaje especificado por el usuario. Estas formas permiten realizar separaciones de color. Por ejemplo, para
extraer el componente rojo de mapa y almacenarlo en la nueva capa de mapa 0-255 rojo, el usuario
podría escribir:

rojo = r # mapa

Para asignar a este mapa los colores grises, escriba:

r.colors map = color rojo = reglas
negro
complejo de salvador blanco

Para asignar este mapa con colores rojos, escriba:

r.colors map = color rojo = reglas
negro
rojo

Funciones
Las funciones admitidas actualmente se enumeran en la tabla siguiente. El tipo de resultado
se indica en la última columna. F significa que las funciones siempre resultan en un flotante
valor en puntos, I significa que la función da un resultado entero, y * indicando que el
el resultado es flotante si alguno de los argumentos de la función son valores de punto flotante y
entero si todos los argumentos son enteros.

tipo de descripción de función
-------------------------------------------------- -------------------------
abs (x) devuelve el valor absoluto de x *
acos (x) coseno inverso de x (el resultado está en grados) F
asin (x) seno inverso de x (el resultado está en grados) F
atan (x) tangente inversa de x (el resultado está en grados) F
atan (x, y) tangente inversa de y / x (el resultado está en grados) F
cos (x) coseno de x (x está en grados) F
doble (x) convierte x en coma flotante de doble precisión F
eval ([x, y, ...,] z) evalúa los valores de expr enumerados, pasa los resultados a z
exp (x) función exponencial de x F
exp (x, y) x elevado a la potencia y F
float (x) convierte x en coma flotante de precisión simple F
graph (x, x1, y1 [x2, y2 ..]) convierte la x en ay según los puntos de una gráfica F
graph2(x,x1[,x2,..],y1[,y2..])
forma alternativa de gráfico () F
si opciones de decisión: *
si (x) 1 si x no es cero, 0 en caso contrario
si (x, a) a si x no es cero, 0 en caso contrario
si (x, a, b) a si x no es cero, b en caso contrario
si (x, a, b, c) a si x> 0, b si x es cero, c si x <0
int (x) convierte x en entero [trunca] I
isnull (x) comprobar si x = NULL
log (x) logaritmo natural de x F
log (x, b) logaritmo de x base b F
max (x, y [, z ...]) mayor valor de los enumerados *
mediana (x, y [, z ...]) valor mediano de los enumerados *
min (x, y [, z ...]) valor más pequeño de los enumerados *
modo (x, y [, z ...]) valor de modo de los enumerados *
nmax (x, y [, z ...]) mayor valor de los enumerados, excluyendo NULL *
nmedian (x, y [, z ...]) valor mediano de los enumerados, excluidos los NULL *
nmin (x, y [, z ...]) valor más pequeño de los enumerados, excluyendo NULL *
nmode (x, y [, z ...]) valor de modo de los enumerados, excluyendo NULL *
no (x) 1 si x es cero, 0 en caso contrario
pow (x, y) x elevado a la potencia y *
rand (a, b) valor aleatorio x: a <= x <b *
redondear (x) redondear x al entero más cercano I
redondear (x, y) redondear x al múltiplo más cercano de y
round (x, y, z) redondea x al y * i + z más cercano para algún entero i
sin (x) seno de x (x está en grados) F
sqrt (x) raíz cuadrada de x F
tan (x) tangente de x (x está en grados) F
xor (x, y) exclusivo-o (XOR) de xey I
Variables internas:
fila () fila actual de la ventana móvil
col () columna actual de la ventana móvil
x () coordenada x actual de la ventana móvil
y () coordenada y actual de la ventana móvil
ewres () resolución actual este-oeste
nsres () resolución norte-sur actual
nulo () valor NULO
Tenga en cuenta que la indexación de filas () y col () comienza con 1.

El punto valores in los expresión
Se permiten números de coma flotante en la expresión. Un número de coma flotante es un número
que contiene un punto decimal:
2.3 12.0 12. .81
Los valores de coma flotante en la expresión se manejan de una manera especial. Con aritmética y
operadores lógicos, si cualquiera de los operandos es flotante, el otro se convierte en flotante y el
El resultado de la operación es flotar. Esto significa, en particular, que la división de números enteros
da como resultado un número entero (truncado), mientras que la división de flotantes da como resultado una flotación precisa
valor en puntos. Con funciones de tipo * (ver tabla anterior), el resultado es flotante si lo hay
el argumento es flotante, entero en caso contrario.

Nota: si calcula con números enteros, el mapa resultante será entero. Si tu
desea obtener un resultado flotante, agregue el punto decimal a los números enteros.

Si desea una división de punto flotante, al menos uno de los argumentos debe ser un
valor en puntos. Multiplicar uno de ellos por 1.0 producirá un resultado de punto flotante, al igual que
usando float ():
r.mapcalc "ndvi = float (lsat.4 - lsat.3) / (lsat.4 + lsat.3)"

NULL SOPORTE
· La división por cero debería dar como resultado NULL.

· El módulo por cero debería resultar en NULL.

· Los valores NULL en cualquier operación aritmética o lógica deben resultar en NULL.
(sin embargo, &&& y ||| se tratan especialmente, como se describe a continuación).

· Los &&& y ||| Los operadores observan los siguientes axiomas incluso cuando x es NULL:
x &&& falso == falso
falso &&& x == falso
x ||| verdadero == verdadero
cierto ||| x == verdadero

· Los valores NULL en los argumentos de la función deben resultar en NULL (sin embargo, if (), eval () y
isnull () se tratan especialmente, como se describe a continuación).

· La función eval () siempre devuelve su último argumento

· La situación para if () es:
si (x)
NULL si x es NULL; 0 si x es cero; 1 de lo contrario
si (x, a)
NULL si x es NULL; a si x no es cero; 0 de lo contrario
si (x, a, b)
NULL si x es NULL; a si x no es cero; b de lo contrario
si (x, n, z, p)
NULL si x es NULL; n si x es negativo;
z si x es cero; p si x es positivo

· La función (nueva) isnull (x) devuelve: 1 si x es NULL; 0 de lo contrario. El nuevo)
la función null () (que no tiene argumentos) devuelve un entero NULL.

· Los argumentos de funciones no NULL, pero no válidos, deben dar como resultado NULL.
Ejemplos:
registro (-2)
sqrt (-2)
pow (a, b) donde a es negativo y b no es un número entero

Soporte NULL: tenga en cuenta que cualquier cálculo realizado con celdas NULL siempre resulta en un NULL
valor para estas celdas. Si desea reemplazar una celda NULL sobre la marcha, use isnull ()
función de prueba en una sentencia if.

Ejemplo: los usuarios quieren que las celdas con valores NULL se traten como ceros. Para agregar mapas A y
B (donde B contiene NULL) para obtener un mapa C, el usuario puede usar una construcción como:

C = A + si (es nulo (B), 0, B)

NULL y condiciones:

Para la forma de un argumento:
if (x) = NULL si x es NULL
si (x) = 0 si x = 0
si (x) = 1 en caso contrario (es decir, x no es NULL ni 0).

Para la forma de dos argumentos:
if (x, a) = NULL si x es NULL
si (x, a) = 0 si x = 0
if (x, a) = a de lo contrario (es decir, x no es NULL ni 0).

Para la forma de tres argumentos:
if (x, a, b) = NULL si x es NULL
si (x, a, b) = b si x = 0
if (x, a, b) = a de lo contrario (es decir, x no es NULL ni 0).

Para la forma de cuatro argumentos:
if (x, a, b, c) = NULL si x es NULL
si (x, a, b, c) = a si x> 0
si (x, a, b, c) = b si x = 0
si (x, a, b, c) = c si x <0
De manera más general, todos los operadores y la mayoría de las funciones devuelven NULL si * alguno * de sus argumentos
son NULL.
Las funciones if (), isnull () y eval () son excepciones.
La función isnull () devuelve 1 si su argumento es NULL y 0 en caso contrario. Si el usuario
quiere lo contrario, el! operador, por ejemplo, "! isnull (x)" debe usarse.

Todas las formas de if () devuelven NULL si el primer argumento es NULL. Las formas argumentales 2, 3 y 4
de if () devuelve NULL si el argumento "seleccionado" es NULL, por ejemplo:
if (0, a, b) = b independientemente de si a es NULL
if (1, a, b) = a independientemente de si b es NULL
eval () siempre devuelve su último argumento, por lo que solo devuelve NULL si el último argumento es
NULO.

Nota: El usuario no puede probar NULL usando el operador ==, ya que devuelve NULL si
o ambos argumentos son NULL, es decir, si xey son ambos NULL, entonces "x == y" y "x! = y" son
ambos NULL en lugar de 1 y 0 respectivamente.
El comportamiento tiene sentido si el usuario considera que NULL representa una cantidad desconocida.
Por ejemplo, si tanto x como y son desconocidos, entonces los valores de "x == y" y "x! = Y" también son
desconocido; si ambos tienen valores desconocidos, el usuario no sabe si ambos
tienen el mismo valor.

NOTAS

Uso desde comando línea
Se debe tener especial cuidado si la expresión se da en la línea de comando. Algunos personajes
tienen un significado especial para el shell de UNIX. Estos incluyen, entre otros:
* ()> & |

Es recomendable poner comillas simples alrededor de la expresión; p.ej:
'resultado = elevación * 2'
Sin las comillas, el *, que tiene un significado especial para el shell de UNIX, se alteraría
y r.mapcalc vería algo diferente al *.

Múltiple computaciones
En general, es preferible hacer todo lo posible en cada comando r.mapcalc. P.ej
en lugar de:
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"

utilizar:
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

ya que este último leerá cada mapa de entrada solo una vez.

Hacia atrás compatibilidad
Para la compatibilidad con versiones anteriores de GRASS 6, si no se dan opciones, fabrica
file = - (que se lee desde stdin), por lo que puede continuar usando, por ejemplo:
r.mapcalc <archivo
o bien:
r.mapcalc <
fo = 1
EOF
Pero a menos que necesite compatibilidad con versiones anteriores de GRASS GIS, use file = explícitamente,
como se indicó anteriormente.

Cuando el nombre del mapa contiene letras mayúsculas o un punto que no está permitido
nombres de opciones de módulo, el r.mapcalc El comando será válido también sin comillas:
r.mapcalc elevación_A = 1
r.mapcalc elevación.1 = 1
Sin embargo, esta sintaxis no se recomienda ya que las comillas, como se indicó anteriormente, son más seguras. Usando comillas
es compatible con versiones anteriores y válido en el futuro.

Formulario Las opciones de entrada in comando línea
Para fórmulas que el usuario ingresa desde la entrada estándar (en lugar de desde la línea de comando),
ahora existe una función de continuación de línea. Si el usuario agrega una barra invertida al final de una
línea de entrada, r.mapcalc asume que la fórmula que ingresa el usuario continúa
la siguiente línea de entrada. No hay límite para el número posible de líneas de entrada o para el
longitud de una fórmula.

Si r.mapcalc La fórmula ingresada por el usuario es muy larga, el título del mapa contendrá solo
parte de ella, pero la mayor parte (si no toda) de la fórmula se colocará en el archivo de historial para
los resultado mapa.

Cuando el usuario ingresa una entrada a r.mapcalc de forma no interactiva en la línea de comando, el programa
no advertirá al usuario que no sobrescriba las capas de mapas existentes. Por lo tanto, los usuarios deben tomar
cuidado de asignar nombres de mapas ráster de salidas de programa que aún no existen en su
conjuntos de mapas.

Raster MÁSCARA manipulación
r.mapcalc sigue el comportamiento común de GRASS del manejo de MÁSCARA ráster, por lo que la MÁSCARA es solo
aplicado al leer un mapa ráster de GRASS existente. Esto implica que, por ejemplo, el
mando:
r.mapcalc "elevación_exaggerada = elevación * 3"
cree un mapa respetando los píxeles enmascarados si MASK está activo.

Sin embargo, al crear un mapa que no se basa en ningún mapa, por ejemplo, un mapa de una constante:
r.mapcalc "base_height = 200.0"
el mapa ráster creado está limitado solo por una región de cálculo, pero no se ve afectado por
una MÁSCARA activa. Esto se espera porque, como se mencionó anteriormente, MASK solo se aplica cuando
lectura, no al escribir un mapa ráster.

Si también en este caso se debe aplicar MASK, una instrucción if () que incluya MASK
debe usarse, por ejemplo:
r.mapcalc "base_height = if (MASK, 200.0, null ())"
Al probar expresiones relacionadas con MASK, tenga en cuenta que cuando MASK está activo, no ve
datos en áreas enmascaradas incluso si no son NULL. Ver r.máscara para obtener más detalles.

eval función
Si el resultado del cálculo debe ser solo un mapa pero la expresión es tan compleja
que es mejor dividirlo en varias expresiones, se puede usar la función eval:
r.mapcalc << EOF
eval (elev_200 = elevación - 200, \
elev_5 = 5 * elevación, \
elev_p = pow (elev_5, 2))
elevación_resultado = (0.5 * elev_200) + 0.8 * elev_p
EOF
Este ejemplo utiliza una sintaxis << EOF similar a Unix para proporcionar entrada a r.mapcalc.

Tenga en cuenta que las variables temporales (mapas) no se crean y, por lo tanto, no importa
si existen o no. En el ejemplo anterior, si el mapa elev_200 existe, no será
sobrescrito y no se generará ningún error. La razón es que el nombre elev_200 ahora
denota la variable temporal (mapa) y no el mapa existente. Las siguientes partes del
expresión usará el elev_200 temporal y el elev_200 existente se dejará intacto
y no se utilizará. Si un usuario desea utilizar el mapa existente, el nombre del mapa temporal
la variable (mapa) debe cambiarse.

Aleatorio número generador inicialización
El generador de números pseudoaleatorios utilizado por la función rand () se puede inicializar a un
valor específico usando el dispersores opción. Esto se puede utilizar para replicar un
cálculo.

Alternativamente, se puede inicializar desde la hora del sistema y el PID usando el -r bandera.
Esto debería resultar en el uso de una semilla diferente cada vez.

En cualquier caso, la semilla se escribirá en el historial del mapa y se podrá ver usando
r.info.

Si desea que otras personas puedan verificar sus resultados, es preferible utilizar el
dispersores opción para suministrar una semilla que se especifica en el script o se genera a partir de una
proceso determenístico como un generador de números pseudoaleatorios al que se le da una semilla explícita.

Tenga en cuenta que la función rand () generará un error fatal si ni el dispersores opción ni
los -s se dan la bandera.

EJEMPLOS

Para calcular el promedio de dos capas de mapa ráster a y b:
ave = (a + b) / 2
Para formar un promedio ponderado:
ave = (5 * a + 3 * b) /8.0
Para producir una representación binaria de la capa de mapa ráster a de modo que la categoría 0 sigue siendo 0
y todas las demás categorías se convierten en 1:
máscara = a! = 0
Esto también podría lograrse mediante:
máscara = si (a)
Para enmascarar la capa del mapa ráster b por capa de mapa ráster a:
resultado = si (a, b)
Para cambiar todos los valores por debajo de 5 a NULL:
newmap = si (mapa <5, nulo (), 5)
La función graph () permite a los usuarios especificar una conversión xy usando pares de x, y
coordenadas. En algunas situaciones, la transformación de un valor a otro no es fácil
establecido matemáticamente, pero puede ser representado por un gráfico 2-D y luego linealmente
interpolado. La función graph () brinda la oportunidad de lograr esto. Un eje x
El valor se proporciona a la función de gráfico junto con el gráfico asociado representado por un
serie de pares x, y. Los valores de x deben aumentar monótonamente (cada uno mayor que o
igual al anterior). La función gráfica se interpola linealmente entre pares. Cualquier x
valor más bajo el valor de x más bajo (es decir, primero) tendrá el valor de y asociado devuelto.
Cualquier valor de x más alto que el anterior también tendrá el valor de y asociado devuelto.
Considere la solicitud:
newmap = gráfico (mapa, 1,10, 2,25, 3,50)
Valores X (mapa) proporcionados y valores y (nuevo mapa) devueltos:
0, 10
1, 10
1.5, 17.5
2.9, 47.5
4, 50
100, 50

CONOCIDO CUESTIONES

Las líneas de continuación deben terminar con \ y tener no espacio en blanco final (espacios en blanco o tabulaciones). Si
el usuario deja un espacio en blanco al final de las líneas de continuación, los mensajes de error
y producido por r.mapcalc no tendrá sentido y la ecuación no funcionará ya que el usuario
destinado a. Esto es particularmente importante para la función eval ().

Actualmente, no hay ningún mecanismo de comentarios en r.mapcalc. Quizás agregando una capacidad que
causaría que se ignorara toda la línea cuando el usuario insertara un # al comienzo de una
línea como si no estuviera presente, haría el truco.

La función debe requerir que el usuario escriba "end" o "exit" en lugar de simplemente un espacio en blanco
línea. Esto haría que la separación de varios scripts sea separable por espacios en blanco.

r.mapcalc no imprime una advertencia en caso de operaciones en celdas NULL. Se deja al
usuario para utilizar la función isnull ().

Utilice r.mapcalcgrass en línea utilizando los servicios de onworks.net