r.mapcalcgrass - Online in der Cloud

PROGRAMM:

NAME/FUNKTION

r.mapcalc - Rasterkartenrechner.

SCHLÜSSELWÖRTER

Raster, Algebra

ZUSAMMENFASSUNG

r.mapcalc
r.mapcalc --help
r.mapcalc [-s] [Ausdruck=Schnur] [Datei=Name] [Samen=ganze Zahl] [--überschreiben]
[--Hilfe] [--ausführlich] [--ruhig] [--ui]

Flaggen:
-s
Zufalls-Seed generieren (Ergebnis ist nicht deterministisch)

--überschreiben
Ausgabedateien erlauben, vorhandene Dateien zu überschreiben

--help
Nutzungszusammenfassung drucken

- ausführlich
Ausführliche Modulausgabe

--ruhig
Leiser Modulausgang

--ui
Starten des GUI-Dialogs erzwingen

Parameter:
Ausdruck=Schnur
Ausdruck zu bewerten

Datei=Name
Datei mit zu bewertenden Ausdrücken

Samen=ganze Zahl
Seed für rand()-Funktion

BESCHREIBUNG

r.mapcalc Führt Arithmetik auf Rasterkarten-Layern durch. Neue Rasterkartenebenen können erstellt werden
das sind arithmetische Ausdrücke mit vorhandenen Rasterkartenebenen, ganzzahlig oder schwebend
Punktkonstanten und Funktionen.

Programm -
r.mapcalc Ausdruck hat die Form:

Folge = Ausdruck

woher Folge ist der Name einer Rasterkartenebene, die das Ergebnis der Berechnung enthält
und Ausdruck ist ein zulässiger arithmetischer Ausdruck, der vorhandene Rasterkarten-Layer einbezieht
(außer Folge selbst), ganzzahlige oder Gleitkommakonstanten und Funktionen, die den
Taschenrechner. Klammern sind im Ausdruck erlaubt und können beliebig tief verschachtelt werden.
Folge wird im aktuellen Mapset des Benutzers erstellt.

As Ausdruck= ist die erste Option, es ist die Standardeinstellung. Dies bedeutet, dass die Übergabe an
Ausdruck auf der Kommandozeile ist möglich, solange der Ausdruck in Anführungszeichen und ein Leerzeichen steht
ist vor dem ersten enthalten = Unterschrift. Beispiel ('foo' ist die resultierende Karte):
r.mapcalc "foo = 1"
oder:
r.mapcalc 'foo = 1'
Ein Ausdruck ohne Anführungszeichen (dh auf mehrere Argumente aufgeteilt) funktioniert nicht, ebenso wenig wie das Weglassen
das Leerzeichen vor dem = Zeichen:
r.mapcalc 'foo=1'
Es tut uns leid, ist kein gültiger Parameter
Um den Befehl aus der Datei zu lesen, verwenden Sie explizit file=, zB:
r.mapcalc file=Datei
oder:
r.mapcalc-Datei=- < Datei
oder:
r.mapcalc-Datei=- <
foo = 1
EOF

Die eingegebene Formel zu r.mapcalc durch den Benutzer wird sowohl im Folge Kartentitel
(die in der Kategoriedatei für . erscheint Folge) und in der Verlaufsdatei für Folge.

Einige Zeichen haben eine besondere Bedeutung für die Befehlsshell. Wenn der Benutzer eine Eingabe eingibt
zu r.mapcalc In der Befehlszeile sollten Ausdrücke in einfache Anführungszeichen eingeschlossen werden.
Siehe ANMERKUNGEN unten.

Betreiber und Auftrag of Vorrang
Die folgenden Operatoren werden unterstützt:
Operator Bedeutung Typpriorität
-------------------------------------------------- ------------
- Negation Arithmetik 12
~ Einerkomplement Bitwise 12
! nicht logisch 12
^ Potenzierung Arithmetik 11
%-Modul Arithmetik 10
/ Division Arithmetik 10
* Multiplikation Arithmetik 10
+ Zusatz Arithmetik 9
- Subtraktion Arithmetik 9
<< links verschieben Bitweise 8
>> Rechtsverschiebung Bitweise 8
>>> Rechtsverschiebung (unsigned) Bitweise 8
> größer als logisch 7
>= größer oder gleich Logisch 7
< weniger als logisch 7
<= kleiner oder gleich Logisch 7
== gleich Logisch 6
!= ungleich Logisch 6
& bitweise und bitweise 5
| bitweise oder bitweise 4
&& logisch und logisch 3
&&& logisch und[1] logisch 3
|| logisch oder logisch 2
||| logisch oder[1] logisch 2
?: bedingte logische 1
(Modul ist der Rest bei der Division)

[1] Das &&& und ||| Operatoren behandeln Nullwerte anders als andere Operatoren. Siehe die
Abschnitt mit dem Titel NULL Support unten für weitere Details.

Die Operatoren werden von links nach rechts angewendet, wobei diejenigen mit höherer Priorität angewendet werden
vor denen mit niedrigerer Priorität. Division durch 0 und Modul durch 0 sind akzeptabel und
ein NULL-Ergebnis geben. Die logischen Operatoren ergeben ein Ergebnis von 1 wenn der Vergleich wahr ist, 0
Andernfalls.

Raster Karte Schicht Namen
Alles in dem Ausdruck, das keine Zahl, kein Operator oder kein Funktionsname ist, wird übernommen
ein Rasterkarten-Layer-Name sein. Beispiele:

Höhe
x3
3d.sein

Die meisten GRASS-Rasterkarten-Layer erfüllen diese Namenskonvention. Wenn jedoch eine Rasterkartenebene
einen Namen hat, der der obigen Regel widerspricht, sollte er in Anführungszeichen gesetzt werden. Zum Beispiel die
Ausdruck

x = ab

würde interpretiert werden als: x gleich a minus b, wohingegen

x = "ab"

würde interpretiert werden als: x entspricht der Rasterkartenebene namens ab

Lese ebenfalls:

x = 3107

würde erschaffen x gefüllt mit der Nummer 3107, während

x = "3107"

würde die Rasterkartenebene kopieren 3107 zur Rasterkartenebene x.

Anführungszeichen sind nicht erforderlich, es sei denn, die Namen der Rasterkarten-Layer sehen wie Zahlen aus oder enthalten
Operatoren ODER, es sei denn, das Programm wird nicht interaktiv ausgeführt. Die hier aufgeführten Beispiele gehen davon aus, dass
Programm wird interaktiv ausgeführt. Siehe ANMERKUNGEN unten.

r.mapcalc sucht nach den Rasterkarten-Layern gemäß dem aktuellen Kartensatz des Benutzers
Suchpfad. Es ist möglich, den Suchpfad zu überschreiben und das Mapset anzugeben, aus dem
um die Rasterkartenebene auszuwählen. Dies erfolgt durch Angabe des Rasterkarten-Layer-Namens in
die Form:

name@mapset

Folgendes ist beispielsweise ein legaler Ausdruck:

Ergebnis = x@PERMANENT / y@BODEN

Das angegebene Mapset muss sich nicht im Mapset-Suchpfad befinden. (Diese Methode von
Das Überschreiben des Mapset-Suchpfads ist allen GRASS-Befehlen gemeinsam, nicht nur r.mapcalc.)

Die Gegend Modifikator
Karten und Bilder sind im Rasterformat gespeicherte Datenbankdateien, dh zweidimensional
Matrizen ganzzahliger Werte. In r.mapcalc, auf Karten kann ein a . folgen Gegend Modifikator
die einen relativen Offset von der aktuell ausgewerteten Zelle angibt. Das Format ist
Karte[r,c], Wobei r ist der Zeilenversatz und c ist der Spalten-Offset. Zum Beispiel, Karte[1,2]
bezieht sich auf die Zelle eine Zeile darunter und zwei Spalten rechts von der aktuellen Zelle,
Karte[-2,-1] bezieht sich auf die Zelle zwei Zeilen darüber und eine Spalte links vom Strom
Zelle, und Karte[0,1] bezieht sich auf die Zelle eine Spalte rechts von der aktuellen Zelle. Dies
Syntax ermöglicht die Entwicklung von nachbarschaftsartigen Filtern innerhalb einer einzelnen Karte oder über
mehrere Karten.

Raster Karte Schicht Werte für Kategorie Datei
Manchmal ist es wünschenswert, einen Wert zu verwenden, der mit den einer Kategorie verknüpft ist Etikette anstatt der
Kategoriewert selbst. Wenn einem Rasterkarten-Layer-Namen das vorangestellt ist @ Betreiber, dann die
Beschriftungen in der Kategoriedatei für die Rasterkartenebene werden im Ausdruck anstelle von verwendet
der Kategoriewert.

Angenommen, der Rasterkarten-Layer Boden.ph (für den pH-Wert des Bodens) hat a
Kategoriedatei mit Labels wie folgt:

Katzenetikett
------------------
0 keine Daten
1 1.4
2 2.4
3 3.5
4 5.8
5 7.2
6 8.8
7 9.4

Dann der Ausdruck:

Ergebnis = @soils.ph

würde ein Ergebnis mit den Kategoriewerten 0, 1.4, 2.4, 3.5, 5.8, 7.2, 8.8 und 9.4 ergeben.

Beachten Sie, dass dieser Operator nur auf Rasterkarten-Layer angewendet werden kann und ein schwebendes . erzeugt
Punktwert im Ausdruck. Daher muss das Kategorielabel mit einem gültigen . beginnen
Nummer. Wenn die Kategoriebezeichnung ganzzahlig ist, wird sie durch einen Gleitkommawert dargestellt
Nummer. Wenn die Kategoriebezeichnung nicht mit einer Zahl beginnt oder fehlt, wird sie
dargestellt durch NULL (keine Daten) in der resultierenden Rasterkarte.

Grau Treppe Äquivalente und Farbe trennt sich
Es ist oft hilfreich, die den Kartenkategorien zugewiesenen Farben zu ändern. Das ist
besonders nützlich, wenn die spektralen Eigenschaften von Zellen eine Bedeutung haben (wie bei Bildern
Daten) oder wenn die Kartenkategoriewerte reale Mengen darstellen (wie wenn Kategoriewerte
spiegeln wahre Höhenwerte wider). Die Manipulation der Kartenfarbe kann auch die visuelle Erkennung unterstützen,
und Kartendruck.

Der Operator # kann verwendet werden, um entweder Kartenkategoriewerte in ihre Graustufen umzuwandeln
Äquivalente oder zum Extrahieren der roten, grünen oder blauen Komponenten einer Rasterkartenebene in
separate Rasterkartenebenen.

Ergebnis = #map

wandelt jeden Kategoriewert in . um Karte auf einen Wert im Bereich 0-255, der die
Graustufenstufe, die durch die Farbe für die Kategorie impliziert wird. Wenn die Karte eine Graustufenfarbe hat
Tabelle, dann ist die Graustufe das, was #map auswertet. Andernfalls wird es wie folgt berechnet:

0.10 * Rot + 0.81 * Grün + 0.01 * Blau

Alternativ können Sie verwenden:

Ergebnis = y#map

um die NTSC-Gewichtungen zu verwenden:

0.30 * Rot + 0.59 * Grün + 0.11 * Blau

Oder Sie können Folgendes verwenden:

Ergebnis = i#map

gleiche Gewichtungen verwenden:

0.33 * Rot + 0.33 * Grün + 0.33 * Blau

Der Operator # hat drei weitere Formen: r#map, g#map, b#map. Diese extrahieren die roten, grünen,
bzw. blaue Komponenten in der benannten Rasterkarte. Das GRASS-Shell-Skript r.blend
extrahiert jede dieser Komponenten aus zwei Rasterkarten-Layern und kombiniert sie durch a
vom Benutzer angegebener Prozentsatz. Diese Formen ermöglichen die Herstellung von Farbseparationen. Zum Beispiel zu
extrahiere die rote Komponente aus Karte und speichern Sie es in der neuen 0-255-Kartenebene roten, der Benutzer
könnte eingeben:

rot = r#map

Um dieser Karte graue Farben zuzuweisen, geben Sie Folgendes ein:

r.colors map=rot color=Regeln
Schwarz
Weiß

Um dieser Karte rote Farben zuzuweisen, geben Sie Folgendes ein:

r.colors map=rot color=Regeln
Schwarz
roten

Funktionen
Die derzeit unterstützten Funktionen sind in der folgenden Tabelle aufgeführt. Die Art des Ergebnisses
ist in der letzten Spalte angegeben. F bedeutet, dass die Funktionen immer ein Floating ergeben
Punktwert, I bedeutet, dass die Funktion ein ganzzahliges Ergebnis liefert, und * zeigt an, dass die
result ist float, wenn eines der Argumente der Funktion Gleitkommawerte sind und
integer, wenn alle Argumente ganzzahlig sind.

Funktionsbeschreibungstyp
-------------------------------------------------- -------------------------
abs(x) absoluten Wert von x zurückgeben *
acos(x) inverser Kosinus von x (Ergebnis ist in Grad) F
asin(x) inverser Sinus von x (Ergebnis ist in Grad) F
atan(x) inverser Tangens von x (Ergebnis in Grad) F
atan(x,y) inverser Tangens von y/x (Ergebnis in Grad) F
cos(x) Kosinus von x (x ist in Grad) F
double(x) wandelt x in Gleitkomma F . mit doppelter Genauigkeit um
eval([x,y,...,]z) Werte der aufgelisteten expr auswerten, Ergebnisse an z . übergeben
exp(x) Exponentialfunktion von x F
exp(x,y) x hoch y F
float(x) konvertiert x in Gleitkomma mit einfacher Genauigkeit F
graph(x,x1,y1[x2,y2..]) konvertiert das x in ay basierend auf Punkten in einem Graphen F
graph2(x,x1[,x2,..],y1[,y2..])
alternative Form des Graphen() F
falls Entscheidungsoptionen: *
if(x) 1 wenn x nicht Null, sonst 0
if(x,a) a wenn x nicht Null, sonst 0
if(x,a,b) a falls x nicht null, b sonst
if(x,a,b,c) a wenn x > 0, b wenn x Null ist, c wenn x < 0
int(x) x in eine ganze Zahl umwandeln [ schneidet ] I
isnull(x) prüfe ob x = NULL
log(x) natürlicher Logarithmus von x F
log(x,b) log von x zur Basis b F
max(x,y[,z...]) größter Wert der aufgelisteten *
median(x,y[,z...]) Medianwert der aufgelisteten *
min(x,y[,z...]) kleinster Wert der aufgelisteten *
mode(x,y[,z...]) Moduswert der aufgelisteten *
nmax(x,y[,z...]) größter Wert der aufgelisteten, ausgenommen NULLs *
nmedian(x,y[,z...]) Medianwert der aufgelisteten, ausgenommen NULLs *
nmin(x,y[,z...]) kleinster Wert der aufgelisteten, ausgenommen NULLs *
nmode(x,y[,z...]) Moduswert der aufgelisteten, ausgenommen NULLs *
not(x) 1 wenn x null ist, sonst 0
pow(x,y) x hoch y *
rand(a,b) Zufallswert x : a <= x < b *
round(x) runden x auf die nächste ganze Zahl I
round(x,y) runde x auf das nächste Vielfache von y
round(x,y,z) runde x auf das nächste y*i+z für eine ganze Zahl i
sin(x) Sinus von x (x ist in Grad) F
sqrt(x) Quadratwurzel von x F
tan(x) Tangente von x (x ist in Grad) F
xor(x,y) Exklusiv-Oder (XOR) von x und y I
Interne Variablen:
row() aktuelle Zeile des sich bewegenden Fensters
col() aktuelle Spalte des sich bewegenden Fensters
x() aktuelle x-Koordinate des sich bewegenden Fensters
y() aktuelle y-Koordinate des sich bewegenden Fensters
ewres() aktuelle Ost-West-Auflösung
nsres() aktuelle Nord-Süd-Auflösung
null() NULL-Wert
Beachten Sie, dass die Indexierung von row() und col() mit 1 beginnt.

Concurrent Lizenzen Punkt Werte in Ausdruck
Gleitkommazahlen sind im Ausdruck erlaubt. Eine Gleitkommazahl ist eine Zahl
die einen Dezimalpunkt enthält:
2.3 12.0 12. .81
Gleitkommawerte im Ausdruck werden auf besondere Weise behandelt. Mit Arithmetik und
logische Operatoren, wenn einer der Operanden float ist, wird der andere in float umgewandelt und die
Ergebnis der Operation ist Float. Dies bedeutet insbesondere, dass die Division von ganzen Zahlen
ergibt eine (abgeschnittene) ganze Zahl, während die Division von Gleitkommazahlen zu einer genauen Gleitkommazahl führt
Punktwert. Bei Funktionen vom Typ * (siehe Tabelle oben) ist das Ergebnis, falls vorhanden, float
Argument ist float, sonst Integer.

Hinweis: Wenn Sie mit ganzzahligen Zahlen rechnen, ist die resultierende Karte ganzzahlig. wenn du
ein Gleitkomma-Ergebnis erhalten möchten, fügen Sie den Dezimalpunkt zu ganzzahligen Zahlen hinzu.

Wenn Sie eine Gleitkommadivision wünschen, muss mindestens eines der Argumente eine Gleitkommazahl sein
Punktwert. Die Multiplikation einer davon mit 1.0 ergibt ein Gleitkomma-Ergebnis, ebenso wie
mit float():
r.mapcalc "ndvi = float(lsat.4 - lsat.3) / (lsat.4 + lsat.3)"

NULL Support
· Division durch Null sollte NULL ergeben.

· Modulus durch Null sollte NULL ergeben.

· NULL-Werte in jeder arithmetischen oder logischen Operation sollten NULL ergeben.
(Allerdings werden &&& und ||| speziell behandelt, wie unten beschrieben).

· Die &&& und ||| Operatoren beachten die folgenden Axiome, auch wenn x NULL ist:
x &&& falsch == falsch
falsch &&& x == falsch
x ||| wahr == wahr
wahr ||| x == wahr

· NULL-Werte in Funktionsargumenten sollten NULL ergeben (jedoch if(), eval() und
isnull() werden speziell behandelt, wie unten beschrieben).

· Die Funktion eval() gibt immer ihr letztes Argument zurück

· Die Situation für if() ist:
wenn(x)
NULL, wenn x NULL ist; 0, wenn x null ist; 1 sonst
wenn(x,a)
NULL, wenn x NULL ist; a wenn x nicht Null ist; 0 sonst
wenn(x,a,b)
NULL, wenn x NULL ist; a wenn x nicht Null ist; b sonst
wenn(x,n,z,p)
NULL, wenn x NULL ist; n wenn x negativ ist;
z wenn x null ist; p wenn x positiv ist

· Die (neue) Funktion isnull(x) gibt zurück: 1 wenn x NULL ist; 0 sonst. Das neue)
Funktion null() (die keine Argumente hat) gibt eine ganze Zahl NULL zurück.

· Nicht-NULL, aber ungültige Argumente für Funktionen sollten NULL ergeben.
Beispiele:
log(-2)
Quadrat (-2)
pow(a,b) wobei a negativ und b keine ganze Zahl ist

NULL-Unterstützung: Bitte beachten Sie, dass jede Mathematik, die mit NULL-Zellen durchgeführt wird, immer zu NULL führt
Wert für diese Zellen. Wenn Sie eine NULL-Zelle on-the-fly ersetzen möchten, verwenden Sie isnull()
Testfunktion in einer if-Anweisung.

Beispiel: Der Benutzer möchte, dass die NULL-wertigen Zellen wie Nullen behandelt werden. So fügen Sie Karten A und . hinzu
B (wobei B NULLs enthält), um eine Karte C zu erhalten, kann der Benutzer eine Konstruktion verwenden wie:

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

NULL und Voraussetzungen:

Für die Ein-Argument-Form:
if(x) = NULL wenn x NULL ist
wenn(x) = 0 wenn x = 0
if(x) = 1 andernfalls (dh x ist weder NULL noch 0).

Für die Zwei-Argument-Form:
if(x,a) = NULL wenn x NULL ist
if(x,a) = 0 wenn x = 0
if(x,a) = a sonst (dh x ist weder NULL noch 0).

Für die Drei-Argument-Form:
if(x,a,b) = NULL wenn x NULL ist
if(x,a,b) = b wenn x = 0
if(x,a,b) = a sonst (dh x ist weder NULL noch 0).

Für die Vier-Argument-Form:
if(x,a,b,c) = NULL wenn x NULL ist
if(x,a,b,c) = a wenn x > 0
if(x,a,b,c) = b wenn x = 0
if(x,a,b,c) = c falls x < 0
Allgemeiner ausgedrückt, alle Operatoren und die meisten Funktionen geben NULL zurück, wenn *eines* ihrer Argumente
sind NULL.
Ausnahmen sind die Funktionen if(), isnull() und eval().
Die Funktion isnull() gibt 1 zurück, wenn ihr Argument NULL ist, andernfalls 0. Wenn der Benutzer
will das gegenteil, das ! Operator, zB "!isnull(x)" muss verwendet werden.

Alle Formen von if() geben NULL zurück, wenn das erste Argument NULL ist. Die 2, 3 und 4 Argumentformen
of if() gibt NULL zurück, wenn das "selected"-Argument NULL ist, zB:
if(0,a,b) = b unabhängig davon, ob a NULL ist
if(1,a,b) = a unabhängig davon, ob b NULL ist
eval() gibt immer sein letztes Argument zurück, also gibt es nur NULL zurück, wenn das letzte Argument . ist
NULL.

Note: Der Benutzer kann nicht mit dem Operator == auf NULL testen, da dieser NULL zurückgibt, wenn entweder
oder beide Argumente sind NULL, dh wenn x und y beide NULL sind, dann sind "x == y" und "x != y"
beide NULL statt 1 bzw. 0.
Das Verhalten ist sinnvoll, wenn der Benutzer NULL als eine unbekannte Größe ansieht.
Wenn zB x und y beide unbekannt sind, dann sind auch die Werte von "x == y" und "x != y"
Unbekannt; wenn beide unbekannte Werte haben, weiß der Benutzer nicht, ob sie beide haben oder nicht
den gleichen Wert haben.

ANMERKUNG

Anwendungsbereich für Befehl Linie
Besondere Vorsicht ist geboten, wenn der Ausdruck in der Befehlszeile angegeben wird. Einige Charaktere
haben eine besondere Bedeutung für die UNIX-Shell. Dazu zählen unter anderem:
* ( ) > & |

Es ist ratsam, den Ausdruck in einfache Anführungszeichen zu setzen; z.B:
'Ergebnis = Höhe * 2'
Ohne die Anführungszeichen würde das *, das für die UNIX-Shell eine besondere Bedeutung hat, geändert werden
und r.mapcalc würde etwas anderes als das * sehen.

Mehrere Berechnungen
Im Allgemeinen ist es vorzuziehen, in jedem r.mapcalc-Befehl so viel wie möglich zu tun. Z.B
lieber als:
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"

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

da letztere jede Input-Map nur einmal lesen wird.

Rückwärts Kompatibilität
Für die Abwärtskompatibilität mit GRASS 6, wenn keine Optionen angegeben sind, stellt es her
file=- (liest von stdin), sodass Sie z. B. weiterhin verwenden können:
r.mapcalc < Datei
oder:
r.mapcalc <
foo = 1
EOF
Wenn Sie jedoch keine Kompatibilität mit früheren GRASS GIS-Versionen benötigen, verwenden Sie file= explizit,
wie oben erwähnt.

Wenn der Kartenname Großbuchstaben oder einen Punkt enthält, der nicht verwendet werden darf
Moduloptionsnamen, die r.mapcalc Befehl ist auch ohne Anführungszeichen gültig:
r.mapcalc Höhe_A=1
r.mapcalc Höhe.1=1
Diese Syntax wird jedoch nicht als Anführungszeichen empfohlen, wie oben angegeben sicherer. Zitate verwenden
ist sowohl abwärtskompatibel als auch in Zukunft gültig.

Interaktives Benutzererlebnis Varianten des Eingangssignals: in Befehl Linie
Für Formeln, die der Benutzer über die Standardeingabe (und nicht über die Befehlszeile) eingibt,
eine Linienfortsetzungsfunktion ist jetzt vorhanden. Wenn der Benutzer einen umgekehrten Schrägstrich am Ende eines
Eingabezeile, r.mapcalc geht davon aus, dass die vom Benutzer eingegebene Formel weiterhin
die nächste Eingabezeile. Es gibt keine Begrenzung für die mögliche Anzahl der Eingabezeilen oder die
Länge einer Formel.

Besitzt das r.mapcalc Die vom Benutzer eingegebene Formel ist sehr lang, der Kartentitel enthält nur
einige davon, aber die meisten (wenn nicht alle) der Formeln werden in die Verlaufsdatei für
Folge Karte.

Wenn der Benutzer eine Eingabe in r.mapcalc nicht interaktiv auf der Befehlszeile, das Programm
warnt den Benutzer nicht, vorhandene Kartenebenen nicht zu überschreiben. Benutzer sollten daher nehmen
achten Sie darauf, den Programmausgaben Rasterkartennamen zuzuweisen, die in ihrer aktuellen Version noch nicht vorhanden sind
Kartensätze.

Raster MASKE Umgang
r.mapcalc folgt dem allgemeinen GRASS-Verhalten der Raster-MASK-Behandlung, daher ist die MASK nur
beim Lesen einer vorhandenen GRASS-Rasterkarte angewendet. Dies impliziert, dass zum Beispiel die
Befehl:
r.mapcalc "elevation_exaggerated = Höhe * 3"
Erstellen Sie eine Karte, die die maskierten Pixel berücksichtigt, wenn MASK aktiv ist.

Wenn Sie jedoch eine Karte erstellen, die nicht auf einer Karte basiert, z. B. eine Karte aus einer Konstanten:
r.mapcalc "base_height = 200.0"
die erstellte Rasterkarte ist nur durch einen Berechnungsbereich begrenzt, wird aber nicht beeinflusst von
eine aktive MASKE. Dies wird erwartet, da MASK, wie oben erwähnt, nur angewendet wird, wenn
Lesen, nicht beim Schreiben einer Rasterkarte.

Soll auch in diesem Fall die MASK angewendet werden, wird eine if()-Anweisung mit der MASK
verwendet werden, zB:
r.mapcalc "base_height = if(MASK, 200.0, null())"
Denken Sie beim Testen von MASK-bezogenen Ausdrücken daran, dass Sie nicht sehen, wenn MASK aktiv ist
Daten in maskierten Bereichen, auch wenn sie nicht NULL sind. Sehen r.maske .

eval Funktion
Wenn die Ausgabe der Berechnung nur eine Karte sein soll, der Ausdruck jedoch so komplex ist
dass es besser ist, es auf mehrere Ausdrücke aufzuteilen, kann die eval-Funktion verwendet werden:
r.mapcalc << EOF
eval(elev_200 = Höhe - 200,
elev_5 = 5 * Höhe,
elev_p = pow(elev_5, 2))
Elevation_result = (0.5 * Elev_200) + 0.8 * Elev_p
EOF
In diesem Beispiel wird eine unixähnliche << EOF-Syntax verwendet, um Eingaben für . bereitzustellen r.mapcalc.

Beachten Sie, dass die temporären Variablen (Maps) nicht erstellt werden und daher keine Rolle spielt
ob sie existieren oder nicht. Im obigen Beispiel ist die Karte elev_200 nicht vorhanden, wenn sie vorhanden ist
überschrieben und es wird kein Fehler generiert. Der Grund ist, dass der Name elev_200 jetzt
bezeichnet die temporäre Variable (map) und nicht die vorhandene Map. Die folgenden Teile des
Ausdruck verwendet das temporäre elev_200 und das vorhandene elev_200 bleibt intakt
und wird nicht verwendet. Wenn ein Benutzer die vorhandene Karte verwenden möchte, wird der Name des temporären
Variable (Map) muss geändert werden.

Zufällig Anzahl Generator Initialisierung
Der von der Funktion rand() verwendete Pseudo-Zufallszahlengenerator kann auf a . initialisiert werden
spezifischer Wert mit dem Samen Möglichkeit. Dies kann verwendet werden, um ein vorheriges zu replizieren
Berechnung.

Alternativ kann es aus der Systemzeit und der PID mit der initialisiert werden -r Flagge.
Dies sollte dazu führen, dass jedes Mal ein anderer Samen verwendet wird.

In beiden Fällen wird der Seed in den Verlauf der Karte geschrieben und kann mit angezeigt werden
r.info.

Wenn Sie möchten, dass andere Ihre Ergebnisse überprüfen können, verwenden Sie am besten die
Samen Option zum Bereitstellen eines Seeds, der entweder im Skript angegeben oder aus einem generiert wird
ein deterministischer Prozess wie ein Pseudo-Zufallszahlengenerator mit einem expliziten Startwert.

Beachten Sie, dass die Funktion rand() einen schwerwiegenden Fehler erzeugt, wenn weder die Samen Option noch
-s Flagge gegeben.

Beispiele:

So berechnen Sie den Durchschnitt von zwei Rasterkarten-Layern a und b:
ave = (a + b)/2
Um einen gewichteten Durchschnitt zu bilden:
Durchschnitt = (5*a + 3*b)/8.0
So erstellen Sie eine binäre Darstellung der Rasterkartenebene a damit Kategorie 0 0 bleibt
und alle anderen Kategorien werden 1:
Maske = a != 0
Dies könnte auch erreicht werden durch:
Maske = wenn(a)
So maskieren Sie die Rasterkartenebene b nach Rasterkartenebene a:
Ergebnis = wenn(a,b)
Um alle Werte unter 5 in NULL zu ändern:
newmap = if(map<5, null(), 5)
Mit der Funktion graph() können Benutzer eine xy-Umwandlung mit Paaren von x,y . angeben
Koordinaten. In manchen Situationen ist eine Transformation von einem Wert in einen anderen nicht einfach
mathematisch etabliert, kann aber durch einen 2D-Graphen und dann linear dargestellt werden
interpoliert. Die Funktion graph() bietet die Möglichkeit, dies zu erreichen. Eine x-Achse
Der Wert wird der Graphfunktion zusammen mit dem zugehörigen Graphen bereitgestellt, der durch a . dargestellt wird
Reihe von XY-Paaren. Die x-Werte müssen monoton steigend sein (jeweils größer als oder
gleich dem vorherigen). Die Graphfunktion interpoliert linear zwischen Paaren. Beliebiges x
Wert niedriger der niedrigste x-Wert (dh der erste) wird den zugehörigen y-Wert zurückgegeben.
Bei jedem x-Wert, der höher als der letzte ist, wird in ähnlicher Weise der zugehörige y-Wert zurückgegeben.
Betrachten Sie die Anfrage:
newmap = graph(map, 1,10, 2,25, 3,50)
Angegebene X-Werte (map) und zurückgegebene y-Werte (newmap):
0, 10
1, 10
1.5, 17.5
2.9, 47.5
4, 50
100, 50

BEKANNT PROBLEME

Fortsetzungszeilen müssen mit einem \ enden und haben nicht nachgestellte Leerzeichen (Leerzeichen oder Tabulatoren). Wenn
der Benutzer lässt am Ende von Fortsetzungszeilen Leerzeichen, die Fehlermeldungen
hergestellt von r.mapcalc ist bedeutungslos und die Gleichung funktioniert nicht als Benutzer
vorgesehen. Dies ist besonders wichtig für die Funktion eval().

Derzeit gibt es keinen Kommentarmechanismus in r.mapcalc. Vielleicht eine Funktion hinzufügen, die
würde dazu führen, dass die gesamte Zeile ignoriert wird, wenn der Benutzer ein # am Anfang von a einfügt
Linie, als ob sie nicht vorhanden wäre, würde den Zweck erfüllen.

Die Funktion sollte erfordern, dass der Benutzer "Ende" oder "Exit" eingibt, anstatt einfach ein Leerzeichen
Leitung. Dies würde die Trennung mehrerer Skripte durch Leerzeichen trennbar machen.

r.mapcalc gibt keine Warnung aus, wenn Operationen auf NULL-Zellen ausgeführt werden. Es bleibt dem
Benutzer die Funktion isnull() verwenden.

Verwenden Sie r.mapcalcgrass online mit den onworks.net-Diensten