Gaußsche Trapezformel

Mit Hilfe der gaußschen Trapezformel (nach Carl Friedrich Gauß) ist es möglich, die Fläche zwischen mehreren auf eine Messungslinie bezogenen/koordinierten Punkten, also beispielsweise die Fläche eines einfachen Polygons, zu berechnen. Durch die Zerlegung der gesuchten Fläche in einzelne auf die Messungslinie bezogenen Trapeze erfolgt die Berechnung.

Formel

Wortformel:

Die doppelte Fläche entspricht der Summe des aktuellen Rechtswertes und des darauf folgenden, multipliziert mit der Differenz aus aktuellem Hochwert und folgendem Hochwert.

$2A=\sum _{i=1}^{n}(y_{i}+y_{i+1})(x_{i}-x_{i+1})$

oder:

Die doppelte Fläche entspricht der Summe des aktuellen Hochwertes und des darauf folgenden, multipliziert mit der Differenz aus folgendem Rechtswert und aktuellem Rechtswert.

$2A=\sum _{i=1}^{n}(x_{i}+x_{i+1})(y_{i+1}-y_{i})$

Bei beiden Formeln gilt: Die Indizes, die größer als sind, müssen immer modulo betrachtet werden, d.h. mit $x_{n+1}$ ist $x_{1}$ und mit $y_{n+1}$ ist y_1 gemeint; oder allgemein formuliert, es muss jeder Index durch $[(j-1){\bmod {n}}]+1$ ersetzt werden. Dabei sind (x_i, y_i) , $i=1\dotsc n$ , $n\in \mathbb {N}$ , die Koordinaten der $n\geq 3$ verschiedenen (nicht kollinearen) Eckpunkte des Polygons in einem kartesischen Koordinatensystem.

Wenn die Punkte in der Drehrichtung des Koordinatensystems durchlaufen werden, ist der berechnete Flächeninhalt positiv, sonst negativ.

Speziell für polygonale Flächen mit Gitterpunkten als Ecken lässt sich der Satz von Pick anwenden. Andere Flächen lassen sich in der Regel problemlos durch Polygone approximieren, so dass man leicht an einen Näherungswert kommen kann.

Programmierung

Formel-Darstellung

Insbesondere für die Programmierung ist die folgende Darstellung der gaußschen Trapezformel besonders geeignet, da sich zum Speichern der Koordinaten Arrays anbieten, die Indizierung von Arrays bei vielen Programmiersprachen ohnehin bei null beginnt und die Modulo-Funktion somit besonders elegant zum Einsatz kommen kann. Die Modulo-Funktion ist hier nötig, um sogenannte Off-by-one-Fehler bei der Array-Indizierung auszuschließen. Dabei sind (x_i, y_i) , $i=0\dotsc n-1$ , $n\in \mathbb {N}$ , die Koordinaten der $n\geq 3$ Eckpunkte des Polygons.

$A={\frac {1}{2}}\left|\sum _{i=0}^{n-1}(y_{i}+y_{i+1{\bmod {n}}})(x_{i}-x_{i+1{\bmod {n}}})\right|$

Programmcode

Der folgende Programmcode soll eine beispielhafte Implementierung – hier in der Programmiersprache Java – zeigen:

public double berechnePolygonFlaeche(double[] x, double[] y) {
  if ((x == null) || (y == null)) return 0.0;  // auf leere Argumente testen
  int n = Math.min(x.length, y.length);        // Anzahl der Ecken des Polygons
  if (n < 3) return 0.0;                       // ein Polygon hat mindestens drei Eckpunkte
  double a = 0.0;                              // Variable fuer Flaeche des Polygons
  for (int i = 0; i < n; i++) {                // Schleife zwecks Summenbildung
    a += (y[i] + y[(i+1) % n]) * (x[i] - x[(i+1) % n]);
  }
  return Math.abs(a / 2.0);                    // Flaecheninhalt zurueckliefern
}

Die Koordinaten der Eckpunkte sind dabei in den beiden Arrays x und y gespeichert. Für das Beispiel-5-Eck $((7,0),(8,7),(4,9),(1,6),(1,2))$ , das einen Flächeninhalt von 45 hat, können diese Arrays z.B. wie folgt initialisiert werden:

double[] x = {7.0, 8.0, 4.0, 1.0, 1.0};        // beispielhafte x-Koordinaten des Polygons
double[] y = {0.0, 7.0, 9.0, 6.0, 2.0};        // beispielhafte y-Koordinaten des Polygons

Beispiel

Polygonfläche

Die Fläche des rechtsstehenden Bildes soll mit der Trapezformel berechnet werden. Es wird ein geodätisches Koordinatensystem verwendet, in dem der positive Drehsinn dem Uhrzeigersinn entspricht. Um einen positiven Flächeninhalt zu erhalten, müssen daher die Punkte im Uhrzeigersinn durchlaufen werden.

Die Dokumentation des Rechenweges kann auf unterschiedliche Art und Weise geschehen. Zur Vereinfachung dieser Schreibweise dienen z.B. innerhalb des Vermessungswesens vorgefertigte Vordrucke.

Zerlegt man die auf dem Bild zu sehende Einzelfläche in die vier Teilflächen $A_{\text{I}}$ , $A_{\text{II}}$ , $A_{\text{III}}$ und $A_{\text{IV}}$ , so erhält man folgende Formel:

$A=-A_{\text{I}}+A_{\text{II}}+A_{\text{III}}-A_{\text{IV}}$

Somit ist

$2A=-(y_{2}+y_{1})(x_{2}-x_{1})+(y_{2}+y_{3})(x_{2}-x_{3})+(y_{3}+y_{4})(x_{3}-x_{4})-(y_{1}+y_{4})(x_{1}-x_{4})$ .

Durch geringe Umformungen erhält man daraus

$2A=(y_{1}+y_{2})(x_{1}-x_{2})+(y_{2}+y_{3})(x_{2}-x_{3})+(y_{3}+y_{4})(x_{3}-x_{4})+(y_{4}+y_{1})(x_{4}-x_{1})$ .

Dieses Ergebnis entspricht der oben angegebenen Trapezformel.

Dreiecksformel

Herleitung

Die gaußsche Dreiecksformel ergibt sich durch das Ausklammern und Umstellen der gaußschen Trapezformel. Die Indizes, die kleiner als 1 oder größer als sind, müssen auch hier wieder modulo betrachtet werden, d.h. mit $x_{0}$ ist $x_{n}$ , mit $x_{n+1}$ ist $x_{1}$ , mit $y_{0}$ ist y_n und mit $y_{n+1}$ ist y_1 gemeint; oder allgemein formuliert, es muss jeder Index durch $[(j-1){\bmod {n}}]+1$ bzw. $[(n+j-1){\bmod {n}}]+1$ , wenn man etwaigen Problemen (z.B. in der Programmierung) infolge negativer modulo-Argumente aus dem Weg gehen möchte, ersetzt werden.

${\begin{aligned}2A&=\sum _{i=1}^{n}(y_{i}+y_{i+1})(x_{i}-x_{i+1})\\&=\sum _{i=1}^{n}{\bigl (}y_{i}(x_{i}-x_{i+1})+y_{i+1}(x_{i}-x_{i+1}){\bigr )}\\&=\sum _{i=1}^{n}{\bigl (}y_{i}x_{i}-y_{i}x_{i+1}+y_{i+1}x_{i}-y_{i+1}x_{i+1}{\bigr )}\\&=\sum _{i=1}^{n}{\bigl (}-y_{i}x_{i+1}+y_{i+1}x_{i}{\bigr )}+\underbrace {\sum _{i=1}^{n}{\bigl (}y_{i}x_{i}-y_{i+1}x_{i+1}{\bigr )}} _{\begin{array}{c}=0{\text{,}}\\{\text{da }}\sum _{i=1}^{n}y_{i}x_{i}=\sum _{i=1}^{n}y_{i+1}x_{i+1}{\text{,}}\\{\text{weil }}x_{n+1}{\mathrel {\hat {=}}}x_{1}{\text{ und }}y_{n+1}{\mathrel {\hat {=}}}y_{1}\end{array}}\\&=\sum _{i=1}^{n}{\bigl (}y_{i+1}x_{i}-y_{i}x_{i+1}{\bigr )}\\&=\sum _{i=1}^{n}y_{i+1}x_{i}-\sum _{i=1}^{n}y_{i}x_{i+1}\\&=\underbrace {\sum _{i=2}^{n+1}y_{i}x_{i-1}} _{\begin{array}{c}=\sum _{i=1}^{n}y_{i}x_{i-1}{\text{,}}\\{\text{weil }}y_{n+1}{\mathrel {\hat {=}}}y_{1}{\text{ und }}x_{0}{\mathrel {\hat {=}}}x_{n}\end{array}}-\sum _{i=1}^{n}y_{i}x_{i+1}\\&=\sum _{i=1}^{n}y_{i}x_{i-1}-\sum _{i=1}^{n}y_{i}x_{i+1}\\&=\sum _{i=1}^{n}{\bigl (}y_{i}x_{i-1}-y_{i}x_{i+1}{\bigr )}\\&=\sum _{i=1}^{n}y_{i}(x_{i-1}-x_{i+1})\end{aligned}}$

Analog lässt sich

$2 A=\sum_{i=1}^n (x_i + x_{i+1})(y_{i+1}-y_i)$

$2 A=\sum_{i=1}^n x_i(y_{i+1}-y_{i-1})$

umformen.

Zusammenfassung

In Worten lautet die gaußsche Dreiecksformel:

Die doppelte Fläche entspricht dem Produkt aus dem aktuellen Rechtswert und der Differenz aus vorherigem Hochwert und folgendem Hochwert.

$2A=\sum _{i=1}^{n}y_{i}(x_{i-1}-x_{i+1})$ , wobei gilt: mit $x_{0}$ ist $x_{n}$ und mit $x_{n+1}$ ist $x_{1}$ gemeint

Oder:

Die doppelte Fläche entspricht dem Produkt aus dem aktuellen Hochwert und der Differenz aus folgendem Rechtswert und vorherigem Rechtswert.

$2 A=\sum_{i=1}^n x_i(y_{i+1}-y_{i-1})$ , wobei gilt: mit $y_{0}$ ist y_n und mit $y_{n+1}$ ist y_1 gemeint

Anwendung

Zur Flächenbestimmung im Gauß-Krüger-Koordinatensystem muss die Flächenverzerrung abhängig vom Abstand zum Hauptmeridian berücksichtigt werden.

Formel zur Berücksichtigung der Flächenverzerrung: $r = \frac{F\cdot y^2}{R^2}$

= Flächenreduktion (m²)
= Ausgangsfläche (m²)
= Abstand zum Hauptmeridian (m)
= Erdradius (6.383.000 m)

Basierend auf einem Artikel in:

Wikipedia.de