r.mapcalcgrass - En ligne dans le Cloud

PROGRAMME:

Nom

r.mapcalc - Calculatrice de carte raster.

MOTS-CLÉS

raster, algèbre

SYNOPSIS

r.mapcalc
r.mapcalc --Aidez-moi
r.mapcalc [-s] [expression=un magnifique] [filet=prénom] [seed=entier] [--écraser]
[--vous aider] [--verbeux] [--calme] [--ui]

Drapeaux:
-s
Générer une graine aléatoire (le résultat est non déterministe)

--écraser
Autoriser les fichiers de sortie à écraser les fichiers existants

--Aidez-moi
Imprimer le récapitulatif d'utilisation

--verbeux
Sortie du module verbeux

--silencieux
Sortie module silencieuse

--interface utilisateur
Forcer le lancement de la boîte de dialogue GUI

Paramètres:
expression=un magnifique
Expression à évaluer

filet=prénom
Fichier contenant expression(s) à évaluer

seed=entier
Seed pour la fonction rand()

DESCRIPTION

r.mapcalc effectue des opérations arithmétiques sur les couches de carte raster. De nouvelles couches de carte raster peuvent être créées
qui sont des expressions arithmétiques impliquant des couches de carte raster existantes, entières ou flottantes
constantes ponctuelles et fonctions.

Programme utilisé
r.mapcalc expression ont la forme :

résultat = expression

où résultat est le nom d'une couche de carte raster pour contenir le résultat du calcul
et expression est une expression arithmétique légale impliquant des couches de carte raster existantes
(sauf résultat lui-même), les constantes entières ou à virgule flottante et les fonctions connues du
calculatrice. Les parenthèses sont autorisées dans l'expression et peuvent être imbriquées à n'importe quelle profondeur.
résultat sera créé dans le jeu de cartes actuel de l'utilisateur.

As expressions= est la première option, c'est la valeur par défaut. Cela signifie que passer un
l'expression sur la ligne de commande est possible tant que l'expression est entre guillemets et un espace
est inclus avant le premier = signe. Exemple ("foo" est la carte résultante) :
r.mapcalc "foo = 1"
ou à l'adresse suivante :
r.mapcalc 'foo = 1'
Une expression sans guillemets (c'est-à-dire divisée sur plusieurs arguments) ne fonctionnera pas, pas plus que l'omission
l'espace avant le signe = :
r.mapcalc 'foo=1'
Désolé, n'est pas un paramètre valide
Pour lire la commande à partir du fichier, utilisez file= explicitement, par exemple :
r.mapcalc fichier=fichier
ou à l'adresse suivante :
r.mapcalc fichier=- < fichier
ou à l'adresse suivante :
fichier r.mapcalc=- <
toto = 1
EOF

La formule saisie pour r.mapcalc par l'utilisateur est enregistré à la fois dans le résultat titre de la carte
(qui apparaît dans le fichier de catégorie pour résultat) et dans le fichier historique de résultat.

Certains caractères ont une signification particulière pour le shell de commande. Si l'utilisateur saisit une entrée
à r.mapcalc sur la ligne de commande, les expressions doivent être entourées de guillemets simples.
Voir REMARQUES ci-dessous.

Les opérateurs et de commander of priorité
Les opérateurs suivants sont pris en charge :
Opérateur Signification Type Priorité
-------------------------------------------------- ------------
- arithmétique de négation 12
~ son complément Bitwise 12
! pas logique 12
^ exponentiation Arithmétique 11
% module Arithmétique 10
/ division Arithmétique 10
* multiplication arithmétique 10
+ addition arithmétique 9
- soustraction arithmétique 9
<< décalage à gauche 8 bits
>> décalage vers la droite 8 bits
>>> décalage vers la droite (non signé) Bitwise 8
> supérieur à Logique 7
>= supérieur ou égal Logique 7
< inférieur à Logique 7
<= inférieur ou égal Logique 7
== égal Logique 6
!= différent de Logique 6
& au niveau du bit et au niveau du bit 5
| au niveau du bit ou au niveau du bit 4
&& logique et logique 3
&&& logique et[1] logique 3
|| logique ou Logique 2
||| logique ou[1] Logique 2
?: conditionnel Logique 1
(le module est le reste lors de la division)

[1] Les &&& et ||| les opérateurs gèrent les valeurs nulles différemment des autres opérateurs. Voir le
rubrique intitulée NULL soutenez ci-dessous pour plus de détails.

Les opérateurs sont appliqués de gauche à droite, avec ceux de priorité plus élevée appliqués
avant ceux de moindre préséance. La division par 0 et le module par 0 sont acceptables et
donner un résultat NULL. Les opérateurs logiques donnent un résultat 1 si la comparaison est vraie, 0
autrement.

Raster plan couche noms
Tout élément de l'expression qui n'est pas un nombre, un opérateur ou un nom de fonction est pris en compte
être un nom de couche de carte raster. Exemples:

élévation
x3
3d.son

La plupart des couches de carte raster GRASS respectent cette convention de nommage. Cependant, si une couche de carte raster
a un nom qui est en conflit avec la règle ci-dessus, il doit être cité. Par exemple, le
expression

x = ab

serait interprété comme : x est égal à a moins b, alors que

x = "ab"

serait interprété comme : x est égal à la couche de carte raster nommée ab

Aussi

x = 3107

créerait x rempli du nombre 3107, tandis que

x = "3107"

copierait la couche de carte raster 3107 à la couche de carte raster x.

Les guillemets ne sont pas requis, sauf si les noms des couches de carte raster ressemblent à des nombres ou contiennent
opérateurs, OU à moins que le programme ne soit exécuté de manière non interactive. Les exemples donnés ici supposent que
programme est exécuté de manière interactive. Voir REMARQUES ci-dessous.

r.mapcalc recherchera les couches de carte raster en fonction du jeu de cartes actuel de l'utilisateur
chemin de recherche. Il est possible de remplacer le chemin de recherche et de spécifier le jeu de cartes à partir duquel
pour sélectionner la couche de carte raster. Cela se fait en spécifiant le nom de la couche de carte raster dans
la forme:

nom@jeu de cartes

Par exemple, ce qui suit est une expression légale :

résultat = x@PERMANENT / y@SOL

L'ensemble de cartes spécifié n'a pas besoin d'être dans le chemin de recherche de l'ensemble de cartes. (Cette méthode de
le remplacement du chemin de recherche de l'ensemble de cartes est commun à toutes les commandes GRASS, pas seulement r.mapcalc.)

Le manuel de formation quartier modificateur
Les cartes et les images sont des fichiers de base de données stockés au format raster, c'est-à-dire en deux dimensions.
matrices de valeurs entières. Dans r.mapcalc, les cartes peuvent être suivies d'un quartier modificateur
qui spécifie un décalage relatif par rapport à la cellule en cours d'évaluation. Le format est
carte[r,c], Où r est le décalage de ligne et c est le décalage de la colonne. Par exemple, carte[1,2]
fait référence à la cellule une ligne en dessous et deux colonnes à droite de la cellule actuelle,
carte[-2,-1] fait référence à la cellule deux rangées au-dessus et une colonne à gauche de l'actuel
cellule, et carte[0,1] fait référence à la cellule une colonne à droite de la cellule actuelle. Cette
la syntaxe permet le développement de filtres de type voisinage au sein d'une même carte ou à travers
plusieurs cartes.

Raster plan couche valeurs grâce au le category filet
Parfois, il est souhaitable d'utiliser une valeur associée à une catégorie étiquette à la place du
valeur de la catégorie elle-même. Si un nom de couche de carte raster est précédé du @ opérateur, puis le
les étiquettes dans le fichier de catégorie pour la couche de carte raster sont utilisées dans l'expression au lieu de
la valeur de la catégorie.

Par exemple, supposons que la couche de carte raster sol.ph (représentant les valeurs de pH du sol) a un
fichier de catégorie avec les étiquettes comme suit :

étiquette de chat
------------------
0 pas de données
1 1.4
2 2.4
3 3.5
4 5.8
5 7.2
6 8.8
7 9.4

Puis l'expression :

résultat = @sols.ph

produirait un résultat avec les valeurs de catégorie 0, 1.4, 2.4, 3.5, 5.8, 7.2, 8.8 et 9.4.

Notez que cet opérateur ne peut être appliqué qu'aux couches de carte raster et produit un
valeur en points dans l'expression. Par conséquent, l'étiquette de catégorie doit commencer par un
numéro. Si le libellé de la catégorie est un entier, il sera représenté par une virgule flottante
numéro. Si l'étiquette de la catégorie ne commence pas par un chiffre ou est manquante, elle sera
représenté par NULL (pas de données) dans la carte raster résultante.

Gris en échelon équivalents et couleur sépare
Il est souvent utile de manipuler les couleurs attribuées aux catégories de carte. C'est
particulièrement utile lorsque les propriétés spectrales des cellules ont un sens (comme avec l'imagerie
données), ou lorsque les valeurs de catégorie de carte représentent des quantités réelles (comme lorsque les valeurs de catégorie
reflètent les vraies valeurs d'altitude). La manipulation des couleurs de la carte peut également faciliter la reconnaissance visuelle,
et l'impression de cartes.

L'opérateur # peut être utilisé pour convertir les valeurs de catégorie de carte en leur échelle de gris
équivalents ou pour extraire les composants rouge, vert ou bleu d'une couche de carte raster dans
couches de carte raster distinctes.

résultat = #carte

convertit chaque valeur de catégorie en plan à une valeur comprise entre 0 et 255 qui représente le
niveau d'échelle de gris impliqué par la couleur de la catégorie. Si la carte a une couleur d'échelle de gris
table, alors le niveau de gris est ce à quoi #map évalue. Sinon, il est calculé comme :

0.10 * rouge + 0.81 * vert + 0.01 * bleu

Alternativement, vous pouvez utiliser:

résultat = y#map

pour utiliser les pondérations NTSC :

0.30 * rouge + 0.59 * vert + 0.11 * bleu

Ou, vous pouvez utiliser :

résultat = i#map

pour utiliser des pondérations égales :

0.33 * rouge + 0.33 * vert + 0.33 * bleu

L'opérateur # a trois autres formes : r#map, g#map, b#map. Ceux-ci extraient le rouge, le vert,
ou des composants bleus dans la carte raster nommée, respectivement. Le script shell GRASS r.mélange
extrait chacun de ces composants de deux couches de carte raster et les combine par un
pourcentage spécifié par l'utilisateur. Ces formes permettent de faire des séparations de couleur. Par exemple, pour
extraire le composant rouge de plan et stockez-le dans la nouvelle couche de carte 0-255 rouge, l'utilisateur
pourrait taper :

rouge = r#carte

Pour attribuer à cette carte des couleurs de gris, tapez :

r.colors map=couleur rouge=règles
noir
blanc

Pour attribuer à cette carte les couleurs rouges, tapez :

r.colors map=couleur rouge=règles
noir
rouge

Les fonctions
Les fonctions actuellement prises en charge sont répertoriées dans le tableau ci-dessous. Le type de résultat
est indiqué dans la dernière colonne. F signifie que les fonctions aboutissent toujours à un flottant
valeur en points, I signifie que la fonction donne un résultat entier, et * indique que le
le résultat est flottant si l'un des arguments de la fonction est une valeur à virgule flottante et
entier si tous les arguments sont entiers.

type de description de fonction
-------------------------------------------------- -------------------------
abs(x) renvoie la valeur absolue de x *
acos(x) cosinus inverse de x (le résultat est en degrés) F
asin(x) sinus inverse de x (le résultat est en degrés) F
atan(x) tangente inverse de x (le résultat est en degrés) F
atan(x,y) tangente inverse de y/x (le résultat est en degrés) F
cos(x) cosinus de x (x est en degrés) F
double(x) convertit x en virgule flottante double précision F
eval([x,y,...,]z) évalue les valeurs de expr listées, transmet les résultats à z
exp(x) fonction exponentielle de x F
exp(x,y) x à la puissance y F
float(x) convertit x en virgule flottante simple précision F
graph(x,x1,y1[x2,y2..]) convertit le x en y en fonction des points d'un graphe F
graph2(x,x1[,x2,..],y1[,y2..])
forme alternative de graphe() F
si options de décision : *
if(x) 1 si x non nul, 0 sinon
if(x,a) a si x non nul, 0 sinon
if(x,a,b) a si x non nul, b sinon
if(x,a,b,c) a si x > 0, b si x est nul, c si x < 0
int(x) convertit x en entier [ tronque ] I
isnull(x) vérifie si x = NULL
log(x) log naturel de x F
log(x,b) log de x base b F
max(x,y[,z...]) plus grande valeur de ceux répertoriés *
median(x,y[,z...]) valeur médiane de ceux répertoriés *
min(x,y[,z...]) plus petite valeur parmi celles répertoriées *
mode(x,y[,z...]) valeur de mode de ceux répertoriés *
nmax(x,y[,z...]) plus grande valeur de celles répertoriées, à l'exclusion des valeurs NULL *
nmedian(x,y[,z...]) valeur médiane de ceux répertoriés, à l'exclusion des valeurs NULL *
nmin(x,y[,z...]) plus petite valeur de celles répertoriées, à l'exclusion des valeurs NULL *
nmode(x,y[,z...]) valeur de mode de ceux répertoriés, à l'exclusion des valeurs NULL *
not(x) 1 si x vaut zéro, 0 sinon
pow(x,y) x à la puissance y *
rand(a,b) valeur aléatoire x : a <= x < b *
arrondir(x) arrondir x à l'entier le plus proche I
arrondir(x,y) arrondir x au multiple de y le plus proche
arrondir(x,y,z) arrondir x au plus proche y*i+z pour un entier i
sin(x) sinus de x (x est en degrés) F
sqrt(x) racine carrée de x F
tan(x) tangente de x (x est en degrés) F
xor(x,y) ou exclusif (XOR) de x et y I
Variables internes :
row() ligne actuelle de la fenêtre mobile
col() col actuel de la fenêtre en mouvement
x() coordonnée x actuelle de la fenêtre en mouvement
y() coordonnée y actuelle de la fenêtre mobile
ewres() résolution actuelle est-ouest
nsres() résolution nord-sud actuelle
null() valeur NULL
Notez que l'indexation row() et col() commence par 1.

Flottant point valeurs in le expression
Les nombres à virgule flottante sont autorisés dans l'expression. Un nombre à virgule flottante est un nombre
qui contient un point décimal :
2.3 12.0 12. .81
Les valeurs à virgule flottante dans l'expression sont gérées d'une manière spéciale. Avec l'arithmétique et
opérateurs logiques, si l'un des opérandes est flottant, l'autre est converti en flottant et le
le résultat de l'opération est float. Cela signifie, en particulier que la division des nombres entiers
donne un entier (tronqué), tandis que la division des flottants donne un flottant précis
valeur en points. Avec les fonctions de type * (voir tableau ci-dessus), le résultat est float s'il y en a
l'argument est flottant, entier sinon.

Remarque : Si vous calculez avec des nombres entiers, la carte résultante sera un nombre entier. Si tu
voulez obtenir un résultat flottant, ajoutez la virgule décimale au(x) nombre(s) entier(s).

Si vous voulez une division en virgule flottante, au moins un des arguments doit être un flottant
valeur en points. Multiplier l'un d'eux par 1.0 produira un résultat à virgule flottante, tout comme
en utilisant float() :
r.mapcalc "ndvi = float(lsat.4 - lsat.3) / (lsat.4 + lsat.3)"

NULL soutenez
· La division par zéro doit donner NULL.

· Le module de zéro devrait donner NULL.

· Les valeurs NULL dans toute opération arithmétique ou logique doivent aboutir à NULL.
(cependant, &&& et ||| sont traités spécialement, comme décrit ci-dessous).

· Le &&& et ||| les opérateurs observent les axiomes suivants même lorsque x est NULL :
x &&& faux == faux
faux &&& x == faux
x ||| vrai == vrai
vrai ||| x == vrai

· Les valeurs NULL dans les arguments de fonction doivent donner NULL (cependant, if(), eval() et
isnull() sont traités spécialement, comme décrit ci-dessous).

· La fonction eval() renvoie toujours son dernier argument

· La situation pour if() est :
si(x)
NULL si x est NULL ; 0 si x vaut zéro ; 1 sinon
si(x,a)
NULL si x est NULL ; a si x est non nul ; 0 sinon
si(x,a,b)
NULL si x est NULL ; a si x est non nul ; b sinon
si(x,n,z,p)
NULL si x est NULL ; n si x est négatif ;
z si x vaut zéro ; p si x est positif

· La (nouvelle) fonction isnull(x) renvoie : 1 si x est NULL ; 0 sinon. Le nouveau)
la fonction null() (qui n'a pas d'arguments) renvoie un entier NULL.

· Les arguments non NULL, mais non valides, des fonctions doivent avoir pour résultat NULL.
Exemples :
bûche(-2)
carré(-2)
pow(a,b) où a est négatif et b n'est pas un entier

Prise en charge NULL : veuillez noter que tout calcul effectué avec des cellules NULL aboutit toujours à un NULL
valeur pour ces cellules. Si vous souhaitez remplacer une cellule NULL à la volée, utilisez le isnull()
fonction de test dans une instruction if.

Exemple : Les utilisateurs souhaitent que les cellules de valeur NULL soient traitées comme des zéros. Pour ajouter des cartes A et
B (où B contient des valeurs NULL) pour obtenir une carte C, l'utilisateur peut utiliser une construction telle que :

C = A + si(isnull(B),0,B)

NULL et conditions:

Pour la forme à un argument :
if(x) = NULL si x est NULL
si (x) = 0 si x = 0
if(x) = 1 sinon (c'est-à-dire que x n'est ni NULL ni 0).

Pour la forme à deux arguments :
if(x,a) = NULL si x est NULL
si(x,a) = 0 si x = 0
if(x,a) = a sinon (c'est-à-dire que x n'est ni NULL ni 0).

Pour la forme à trois arguments :
if(x,a,b) = NULL si x est NULL
si(x,a,b) = b si x = 0
if(x,a,b) = a sinon (c'est-à-dire que x n'est ni NULL ni 0).

Pour la forme à quatre arguments :
if(x,a,b,c) = NULL si x est 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
Plus généralement, tous les opérateurs et la plupart des fonctions renvoient NULL si *n'importe lequel* de leurs arguments
sont NULL.
Les fonctions if(), isnull() et eval() sont des exceptions.
La fonction isnull() renvoie 1 si son argument est NULL et 0 sinon. Si l'utilisateur
veut le contraire, le ! L'opérateur, par exemple "!isnull(x)" doit être utilisé.

Toutes les formes de if() renvoient NULL si le premier argument est NULL. Les formes d'arguments 2, 3 et 4
of if() renvoie NULL si l'argument "selected" est NULL, par exemple :
if(0,a,b) = b indépendamment du fait que a soit NULL
if(1,a,b) = a, que b soit NULL ou non
eval() renvoie toujours son dernier argument, il ne renvoie donc NULL que si le dernier argument est
NUL.

Note: L'utilisateur ne peut pas tester NULL à l'aide de l'opérateur ==, car cela renvoie NULL si l'un ou l'autre
ou les deux arguments sont NULL, c'est-à-dire si x et y sont tous les deux NULL, alors "x == y" et "x != y" sont
les deux NULL plutôt que 1 et 0 respectivement.
Le comportement est logique si l'utilisateur considère NULL comme représentant une quantité inconnue.
Par exemple, si x et y sont tous deux inconnus, alors les valeurs de "x == y" et "x != y" sont également
inconnu; s'ils ont tous les deux des valeurs inconnues, l'utilisateur ne sait pas s'ils ont tous les deux
ont la même valeur.

NOTES

Utilisation grâce au commander en ligne
Des précautions supplémentaires doivent être prises si l'expression est donnée sur la ligne de commande. Certains personnages
ont une signification particulière pour le shell UNIX. Il s'agit, entre autres :
* ( ) > & |

Il est conseillé de mettre des guillemets simples autour de l'expression ; par exemple:
'résultat = élévation * 2'
Sans les guillemets, le *, qui a une signification particulière pour le shell UNIX, serait modifié
et r.mapcalc verrait autre chose que le *.

Multiple calculs
En général, il est préférable d'en faire autant que possible dans chaque commande r.mapcalc. Par exemple
plutôt que:
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"

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

car ce dernier ne lira chaque carte d'entrée qu'une seule fois.

En arrière compatibilité
Pour la rétrocompatibilité avec GRASS 6, si aucune option n'est donnée, il fabrique
file=- (qui lit à partir de stdin), vous pouvez donc continuer à utiliser, par exemple :
r.mapcalc < fichier
ou à l'adresse suivante :
r.mapcalc <
toto = 1
EOF
Mais à moins que vous n'ayez besoin d'une compatibilité avec les versions précédentes de GRASS GIS, utilisez file= explicitement,
Comme indiqué ci-dessus.

Lorsque le nom de la carte contient des lettres majuscules ou un point qui ne sont pas autorisés à être
les noms d'option de module, le r.mapcalc la commande sera valide aussi sans guillemets :
r.mapcalc altitude_A=1
r.mapcalc élévation.1=1
Cependant, cette syntaxe n'est pas recommandée car les guillemets comme indiqué ci-dessus sont plus sûrs. Utiliser des guillemets
est à la fois rétrocompatible et valable à l'avenir.

interactif contribution in commander en ligne
Pour les formules que l'utilisateur saisit à partir d'une entrée standard (plutôt qu'à partir de la ligne de commande),
une fonction de continuation de ligne existe maintenant. Si l'utilisateur ajoute une barre oblique inverse à la fin d'un
ligne d'entrée, r.mapcalc suppose que la formule saisie par l'utilisateur se poursuit jusqu'à
la ligne d'entrée suivante. Il n'y a pas de limite au nombre possible de lignes d'entrée ou au
longueur d'une formule.

Si la r.mapcalc formule saisie par l'utilisateur est très longue, le titre de la carte ne contiendra que
une partie, mais la plupart (sinon la totalité) de la formule sera placée dans le fichier historique pour
le résultat carte

Lorsque l'utilisateur saisit une entrée dans r.mapcalc de manière non interactive sur la ligne de commande, le programme
n'avertit pas l'utilisateur de ne pas écraser les couches de carte existantes. Les utilisateurs doivent donc prendre
prendre soin d'attribuer aux sorties du programme des noms de carte raster qui n'existent pas encore dans leur
jeux de cartes.

Raster MASQUE manipulation
r.mapcalc suit le comportement commun de GRASS de la gestion raster MASK, donc le MASK est seulement
appliqué lors de la lecture d'une carte raster GRASS existante. Cela implique que, par exemple, le
commander:
r.mapcalc "élévation_exagérée = élévation * 3"
créer une carte respectant les pixels masqués si MASK est actif.

Cependant, lors de la création d'une carte qui n'est basée sur aucune carte, par exemple une carte à partir d'une constante :
r.mapcalc "base_height = 200.0"
la carte raster créée n'est limitée que par une région de calcul mais elle n'est pas affectée par
un MASQUE actif. Ceci est normal car, comme mentionné ci-dessus, MASK n'est appliqué que lorsque
lecture, pas lors de l'écriture d'une carte raster.

Si également dans ce cas le MASK doit être appliqué, une instruction if() incluant le MASK
doit être utilisé, par exemple :
r.mapcalc "base_height = if(MASK, 200.0, null())"
Lorsque vous testez des expressions liées à MASK, gardez à l'esprit que lorsque MASK est actif, vous ne voyez pas
les données dans les zones masquées même si elles ne sont pas NULL. Voir r.masque pour en savoir plus.

eval fonction
Si la sortie du calcul ne doit être qu'une seule carte mais que l'expression est si complexe
qu'il vaut mieux le scinder en plusieurs expressions, la fonction eval peut être utilisée :
r.mapcalc << EOF
eval(elev_200 = élévation - 200, \
elev_5 = 5 * élévation, \
elev_p = pow(elev_5, 2))
altitude_result = (0.5 * elev_200) + 0.8 * elev_p
EOF
Cet exemple utilise la syntaxe << EOF de type Unix pour fournir une entrée à r.mapcalc.

Notez que les variables temporaires (maps) ne sont pas créées et donc peu importe
qu'elles existent ou non. Dans l'exemple ci-dessus, si la carte elev_200 existe, elle ne sera pas
écrasé et aucune erreur ne sera générée. La raison en est que le nom elev_200 maintenant
désigne la variable temporaire (map) et non la map existante. Les parties suivantes du
l'expression utilisera le elev_200 temporaire et le elev_200 existant sera laissé intact
et ne sera pas utilisé. Si un utilisateur souhaite utiliser la carte existante, le nom de la carte temporaire
variable (carte) doit être modifiée.

« Aléatoire » nombre générateur initialisation
Le générateur de nombres pseudo-aléatoires utilisé par la fonction rand() peut être initialisé à un
valeur spécifique en utilisant le seed option. Cela peut être utilisé pour reproduire un précédent
calcul.

Alternativement, il peut être initialisé à partir de l'heure système et du PID en utilisant le -r drapeau.
Cela devrait entraîner l'utilisation d'une graine différente à chaque fois.

Dans les deux cas, la graine sera écrite dans l'historique de la carte et peut être vue en utilisant
r.info.

Si vous souhaitez que d'autres personnes puissent vérifier vos résultats, il est préférable d'utiliser le
seed option pour fournir une graine qui est soit spécifiée dans le script, soit générée à partir d'un
processus déterministe tel qu'un générateur de nombres pseudo-aléatoires étant donné une graine explicite.

Notez que la fonction rand() générera une erreur fatale si ni le seed option ni
le -s drapeau sont donnés.

EXEMPLES

Pour calculer la moyenne de deux couches de carte raster a et b:
moy = (a + b)/2
Pour former une moyenne pondérée :
moy = (5*a + 3*b)/8.0
Pour produire une représentation binaire de la couche de carte raster a de sorte que la catégorie 0 reste 0
et toutes les autres catégories deviennent 1 :
masque = un != 0
Cela pourrait également être accompli par:
masque = si(a)
Pour masquer la couche de carte raster b par couche de carte raster a:
résultat = si(a,b)
Pour changer toutes les valeurs inférieures à 5 en NULL :
newmap = if(map<5, null(), 5)
La fonction graph() permet aux utilisateurs de spécifier une conversion xy en utilisant des paires de x,y
coordonnées. Dans certaines situations, une transformation d'une valeur à une autre n'est pas facile
établi mathématiquement, mais peut être représenté par un graphique 2D puis linéairement
interpolé. La fonction graph() offre la possibilité d'accomplir cela. Un axe x
valeur est fournie à la fonction graphique avec le graphique associé représenté par un
série de paires x,y. Les valeurs de x doivent augmenter de façon monotone (chacune supérieure ou
égal au précédent). La fonction graphique interpole linéairement entre les paires. Tout x
valeur inférieure la valeur x la plus basse (c'est-à-dire la première) aura la valeur y associée renvoyée.
Toute valeur x supérieure à la dernière aura de la même manière la valeur y associée renvoyée.
Considérez la demande :
nouvelle carte = graphique (carte, 1,10, 2,25, 3,50)
Valeurs X (map) fournies et valeurs y (newmap) renvoyées :
0, 10
1, 10
1.5, 17.5
2.9, 47.5
4, 50
100, 50

CONNUE QUESTIONS

Les lignes de continuation doivent se terminer par un \ et avoir aucune espace blanc de fin (espaces ou tabulations). Si
l'utilisateur laisse un espace blanc à la fin des lignes de continuation, les messages d'erreur
produit par r.mapcalc n'aura aucun sens et l'équation ne fonctionnera pas tant que l'utilisateur
destiné. Ceci est particulièrement important pour la fonction eval().

Actuellement, il n'y a pas de mécanisme de commentaire dans r.mapcalc. Peut-être en ajoutant une capacité qui
entraînerait l'ignorance de la ligne entière lorsque l'utilisateur insère un # au début d'un
ligne comme si elle n'était pas présente, ferait l'affaire.

La fonction devrait exiger que l'utilisateur tape "end" ou "exit" au lieu d'un simple espace
ligne. Cela rendrait la séparation de plusieurs scripts séparables par un espace blanc.

r.mapcalc n'imprime pas d'avertissement en cas d'opérations sur des cellules NULL. Il est laissé au
à l'utilisateur d'utiliser la fonction isnull().

Utilisez r.mapcalcgrass en ligne en utilisant les services onworks.net