r3.mapcalcgrass - En ligne dans le Cloud

PROGRAMME:

Nom

r3.mapcalc - Calculatrice de carte raster.

MOTS-CLÉS

raster, algèbre

SYNOPSIS

r3.mapcalc
r3.mapcalc --Aidez-moi
r3.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

r3.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é
r3.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 votre 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) :
r3.mapcalc "foo = 1"
ou à l'adresse suivante :
r3.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 = :
r3.mapcalc 'foo=1'
Désolé, n'est pas un paramètre valide
Si aucune option n'est donnée, il fabrique "file=-" (qui lit à partir de stdin), vous pouvez donc
continuer à utiliser, par exemple :
r3.mapcalc < fichier
ou à l'adresse suivante :
r3.mapcalc <
toto = 1
EOF
Mais à moins que vous n'ayez besoin d'une compatibilité avec les versions précédentes, utilisez file= explicitement, par exemple :
r3.mapcalc fichier=fichier
ou à l'adresse suivante :
fichier r3.mapcalc=- <
toto = 1
EOF

La formule saisie pour r3.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
à r3.mapcalc sur la ligne de commande, les expressions doivent être entourées de guillemets simples.
Voir REMARQUES ci-dessous.

Les opérateurs et votre 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 Support 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.

3D Grille 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 grille 3D. Exemples:

le volume
x3
3d.son

La plupart des couches de cartes raster et des grilles 3D GRASS respectent cette convention de dénomination. Cependant, si une 3D
grid 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 grille 3D nommée ab

Aussi

x = 3107

créerait x rempli du nombre 3107, tandis que

x = "3107"

copierait la grille 3D 3107 à la grille 3D x.

Les guillemets ne sont pas obligatoires à moins que les noms de grille 3D ressemblent à des nombres ou contiennent des opérateurs,
OU à moins que le programme ne soit exécuté de manière non interactive. Les exemples donnés ici supposent que le programme est
exécuter de manière interactive. Voir REMARQUES ci-dessous.

r3.mapcalc recherchera les grilles 3D en fonction du chemin de recherche de l'ensemble de cartes actuel de l'utilisateur.
Il est possible de remplacer le chemin de recherche et de spécifier le jeu de cartes à partir duquel sélectionner le
Grille 3D. Cela se fait en spécifiant le nom de la grille 3D sous 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 r3.mapcalc.)

Notre quartier modificateur
Les grilles 3D sont des fichiers de base de données stockés au format voxel, c'est-à-dire des matrices tridimensionnelles de
valeurs flottantes/doubles. Dans r3.mapcalc, les grilles 3D 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,d], Où r est le décalage de ligne, c est le décalage de la colonne et d est le décalage de profondeur.
Par exemple, carte[1,2,3] fait référence à la cellule une ligne en dessous, deux colonnes à droite et 3
niveaux inférieurs à la cellule actuelle, carte[-3,-2,-1] fait référence à la cellule trois rangées au-dessus, deux
colonnes à gauche et un niveau en dessous de la cellule actuelle, et carte[0,1,0] se réfère à la
cellule une colonne à droite de la cellule actuelle. Cette syntaxe permet le développement de
filtres de type voisinage dans une seule grille 3D ou sur plusieurs grilles 3D.

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
profondeur() renvoie la profondeur actuelle
x() coordonnée x actuelle de la fenêtre en mouvement
y() coordonnée y actuelle de la fenêtre mobile
z() renvoie la valeur z actuelle
ewres() résolution actuelle est-ouest
nsres() résolution nord-sud actuelle
tbres() résolution actuelle de haut en bas
null() valeur NULL
Notez que l'indexation row(), col() et depth() 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() :
r3.mapcalc "ratio = float(sol.4 - sol.3) / sol.3)"

NULL Support
· 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 votre 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.

Notes: 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 de 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 = volume * 2'
Sans les guillemets, le *, qui a une signification particulière pour le shell UNIX, serait modifié
et votre r3.mapcalc verrait autre chose que le *.

Multiple calculs
En général, il est préférable de faire autant que possible dans chaque commande r3.mapcalc en utilisant
entrée multiligne.

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 :
r3.mapcalc < fichier
ou à l'adresse suivante :
r3.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 r3.mapcalc la commande sera valide aussi sans guillemets :
r3.mapcalc volume_A=1
r3.mapcalc volume.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, r3.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 r3.mapcalc formule saisie par l'utilisateur est très longue, le titre de la carte contiendra
seulement une partie, mais la plupart (sinon la totalité) de la formule sera placée dans le fichier historique
pour résultat carte

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

3D GRID MASQUE manipulation
r3.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:
r3.mapcalc "volume_amplifié = volume * 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 :
r3.mapcalc "volume_const = 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 :
r3.mapcalc "volume_const = 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.

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 grilles 3D a et votre 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 grille 3D a de sorte que la catégorie 0 reste 0 et tous les autres
les catégories deviennent 1 :
masque = un != 0
Cela pourrait également être accompli par:
masque = si(a)
Pour masquer la grille 3D b par grille 3D 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 r3.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 r3.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.

r3.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 r3.mapcalcgrass en ligne en utilisant les services onworks.net