|
Prototyp und Beschreibung der Funktion gettranshelmert() (Funktion der freischaltpflichtigen Gruppe "Transformationsparameter") |
|
gettranshelmert()
Berechnen von sieben Helmert-Parametern und einer Rotationsmatrix aus
identischen Punkten in verschiedenen Bezugssystemen.
Prototyp der DLL-Funktion in C++ Syntax (Kleinschreibung beachten!):
extern "C" __declspec(dllimport) unsigned long __stdcall gettranshelmert(
double aCartQ[][3],
double aCartZ[][3],
unsigned long nCount,
unsigned short nTyp,
unsigned short nIterat,
unsigned short *nItNeed,
double aHelmert[7],
double aRotMat[][3]);
Prototyp der DLL-Funktion in Visual Objects Syntax:
_DLL function gettranshelmert(;
aCartQ as real8 ptr,; // 4 Byte
aCartZ as real8 ptr,; // 4 Byte
nCount as dword,; // 4 Byte
nTyp as word,; // 2 Byte
nIterat as word,; // 2 Byte
nItNeed ref word,; // 4 Byte
aHelmert as real8 ptr,; // 4 Byte
aRotMat as real8 ptr); // 4 Byte
as logic pascal:geodll32.gettranshelmert // 4 Byte
Die Funktion berechnet sieben Helmert-Transformationsparameter aus
identischen Punkten in unterschiedlichen Quell- und Ziel-
Koordinatenbezugssystemen. Die identischen Punkte sind als Kartesische
Koordinaten in Arrays gespeichert.
Die Helmert-Transformation ist eine Transformation für dreidimensionale
kartesische Koordinaten. Sie enthält als Paramter drei
Verschiebungsvektoren, drei Rotationswinkel und einen Maßstabsfaktor.
Die maximale Iterationstiefe für eine sehr genaue Berechnung der
Transformationsparameter wird in Abhängigkeit von der Anzahl identischer
Punkte von der Funktion automatisch eingestellt, wenn im Parameter nIterat Null
eingetragen ist. Bei Punktwolken mit plausiblen identischen Punkten durchläuft
die Funktion meist nur wenige Iterationen um die erforderliche Genauigkeit zu
erreichen und damit die Berechnung zu beenden. Wenn die automatisch
eingestellte maximale Iterationstiefe jedoch überschritten wird, bricht die
Funktion mit einer Fehlermeldung ab.
Bei kleinräumiger Ausdehnung einer Punktwolke oder bei einer geringen Anzahl
von identischen Punkten kann es vorkommen, dass die erwartete Genauigkeit mit
dem Durchlaufen der automatisch eingestellten maximalen Iterationstiefe nicht
erreicht wird. Um trotzdem ein Ergebnis zu erhalten, kann die Iterationstiefe
im Parameter nIterat vorgegeben werden. Die Funktion beendet die Berechnung
dann ohne Fehlermeldung. Im Extremfall können die auf diese Weise berechneten
Helmert-Parameter aber ungenau oder sogar falsch sein. Im Zweifelsfall sollte
dann anstelle der Funktion gettranshelmert() die Funktion gettransmolodensky()
verwendet werden. Die Molodensky-Transformation liefert auch in Extremfällen
ein brauchbares Ergebnis, das allerdings nicht die hohe Genauigkeit der
Helmert-Transformation aufweist.
Zur Kontrolle der Iterationstiefe gibt die Funktion im Parameter nItNeed die
Anzahl der tatsächlich durchlaufenen Iterationen an die aufrufende Routine
zurück.
Die Rotationen sind auch in einer Rotationsmatrix verfügbar. Dafür wird eine
Rotationsmatrix mit 3 x 3 Rotationselementen erzeugt. Alle geodätischen Tools
und Programme von KilletSoft verwenden für Helmert-Transformationen eine
vollständige Rotationsmatrix. Die Programme vieler anderer Hersteller
verwenden dagegen eine vereinfachte Rotationsmatrix, die nur für kleine
Rotationswinkel genaue Ergebnissse liefert.
Hier ist die Syntax der vollständigen Rotationsmatrix für die Transformations-
methode "Coordinate Frame Rotaion":
Cos(Ry)*Cos(Rz)
Cos(Rx)*Sin(Rz) + Sin(Rx)*Sin(Ry)*Cos(Rz)
Sin(Rx)*Sin(Rz) - Cos(Rx)*Sin(Ry)*Cos(Rz)
-Cos(Ry)*Sin(Rz)" + CRLF
Cos(Rx)*Cos(Rz) - Sin(Rx)*Sin(Ry)*Sin(Rz)
Sin(Rx)*Cos(Rz) + Cos(Rx)*Sin(Ry)*Sin(Rz)
Sin(Ry)
-Sin(Rx)*Cos(Ry)
Cos(Rx)*Cos(Ry)
Die Syntax der vereinfachten Rotationsmatrix hat diese Form:
1 Rz -Ry
-Rz 1 Rx
Ry -Rx 1
Für die anderen Transformationsmethoden (außer Molodensky) gilt die gleiche
Syntax, wobei allerdings einige Vorzeichen vertauscht sind.
Da die Funktion wegen der umfangreichen Berechnungen zeitintensiv ist, kann
mit der Funktion seteventloop() die Event-Bearbeitung während der Berechnung
durch Unterbrechung der Bearbeitungsschleife zugelassen werden.
Die Parameter werden folgendermaßen übergeben bzw. zurückgegeben:
aCartQ[][3] Kartesische Koordinaten X, Y, Z des Quell-Koordinatenbezugs-
(ref) systems in einem zweidimensionalen Array des Typs double. Die
erste Dimension zählt die in nCount übergebene Anzahl der
verfügbaren Kartesischen Koordinaten identischer Punkte im
Quellsystem. Die zweite Dimension ist 3 für die X-, Y- und
Z-Komponenten der Kartesischen Koordinaten des Quellsystems. Die
Anzahl der Koordinatentripel in den Arrays aCartQ und aCartZ
muss gleich sein. Es müssen mindestens drei Koordinatentripel
vorhanden sein. Der Aufbau des Arrays ist weiter unten
beschrieben.
aCartZ[][3] Kartesische Koordinaten X, Y, Z des Ziel-Koordinatenbezugs-
(ref) systems in einem zweidimensionalen Array des Typs double. Die
erste Dimension zählt die in nCount übergebene Anzahl der
verfügbaren Kartesischen Koordinaten identischer Punkte im
Zielsystem. Die zweite Dimension ist 3 für die X-, Y- und
Z-Komponenten der Kartesischen Koordinaten des Zielsystems. Die
Anzahl der Koordinatentripel in den Arrays aCartQ und aCartZ
muss gleich sein. Es müssen mindestens drei Koordinatentripel
vorhanden sein. Der Aufbau des Arrays ist weiter unten
beschrieben.
nCount Anzahl der verfügbaren identischen Punkte, die als Kartesische
Koordinaten in den Arrays aCartQ und aCartZ gespeichert sind.
nTyp Transformationsmethode der Helmert-Transformationsparameter.
1: Coordinate Frame Rotation
2: Position Vector Transformation
3: European Standard ISO 19111
nIterat Vorgegebene maximale Iterationstiefe für die Berechnung der
Helmert-Transformationsparameter.
nIterat = 0: Automatische Ermittlung der Iterationstiefe in
Abhängigkeit von der Anzahl der kartesischen Koordinaten.
nCount ›= 50000: nIterat = nItMax = 20
nCount ›= 10000: nIterat = nItMax = 30
nCount ›= 5000: nIterat = nItMax = 40
nCount ›= 1000 nIterat = nItMax = 50
nCount ›= 500 nIterat = nItMax = 60
nCount ›= 100 nIterat = nItMax = 70
nCount ›= 50 nIterat = nItMax = 80
nCount ›= 25 nIterat = nItMax = 90
nCount ›= 3 nIterat = nItMax = 100
nIterat ›= 5 und nIterat ‹ nItMax: Maximale Iterationstiefe
nIterat ‹ 5 oder nIterat ›= nItMax: Siehe nIterat == 0
nItNeed Für die Berechnung tatsächlich benötigte Iterationstiefe. Im
(ref out) Fehlerfall wird Null zurück gegeben.
aHelmert[7] Sieben Helmert-Parameter in einem Array mit 7 Elementen des
(ref out) Typs double.
1. Arrayelement: Verschiebung auf der X-Achse [Meter]
2. Arrayelement: Verschiebung auf der Y-Achse [Meter]
3. Arrayelement: Verschiebung auf der Z-Achse [Meter]
4. Arrayelement: Rotationswinkel um die X-Achse [Sekunden]
5. Arrayelement: Rotationswinkel um die Y-Achse [Sekunden]
6. Arrayelement: Rotationswinkel um die Z-Achse [Sekunden]
7. Arrayelement: Maßstabsfaktor [ppm]
------------------------------------
| V1 | V2 | V3 | R1 | R2 | R3 | MF |
------------------------------------
Für das Array muss Speicherplatz in der Größe 7*sizeof(double)
Bytes von der aufrufenden Routine zur Verfügung gestellt werden.
aRotMat[3][3] Rotationsmatrix der räumlichen Helmert Transformation in
(ref out) einem Array aus 3 mal 3 Elementen des Typs double. Die Syntax
der matrix ist weiter oben beschrieben.
-------------------
| w11 | w21 | w31 |
| w12 | w22 | w32 |
| w13 | w23 | w33 |
-------------------
Die Vorzeichen von w können in Abhängigkeit von der
Transformationsmethode wechseln. Für das Array muss Speicherplatz
in der Größe 3*3*sizeof(double) Bytes von der aufrufenden Routine
zur Verfügung gestellt werden.
oder
NULL Ptr Es wird keine Rotationsmatrix berechnet.
returnWert Im Fehlerfall gibt die Funktion FALSE zurück, sonst TRUE.
Die zweidimensionalen Arrays aCartQ[][3] und aCartZ[][3] sind mit Werten des
Typs double gefüllt und folgendermaßen aufgebaut:
----------------------------------------------------------------------
| K1-X | K1-Y | K1-Z | K2-X | K2-Y | K2-Z | ... | Kn-X | Kn-Y | Kn-Z |
----------------------------------------------------------------------
mit K1 -› Kn: Koordinaten 1 bis n
X: Kartesische X-Komponente
Y: Kartesische Y-Komponente
Z: Kartesische Z-Komponente
Es werden mindestens drei identische Punkte für die Berechnung benötigt.
Freischaltung:
Die Funktion ist Bestandteil der freischaltpflichtigen Funktionsgruppe
"Transformationsparameter". Sie wird zusammen mit den anderen Funktionen
der Gruppe durch die Eingabe der bei der Vertriebsfirma erworbenen
Freischaltparameter per Aufruf der Funktion setunlockcode() zur
uneingeschränkten Nutzung frei geschaltet.
Ohne Freischaltung werden maximal 25 identische Punkte verarbeitet.
|