Script




Mit diesem Dialog können Scripte ausgeführt werden, die der Pascal Notation entsprechen. Im oberen  Bereich wird der Script eingegeben und im unteren Bereich kommen die Ausgaben.

(C)alc wird der Script ausgeführt.
(L)oad wird ein Script geladen
(S)ave wird ein Script gespeichert.
(C)lose wird der Dialog geschlossen und der Script gespeichert.

Demos:
T1 Eingabe von Koordinaten
T2 Errechnen von Koordinaten
T3 Einlesen von Werten
T4 OziExplorer Karte positionieren
T5 Waypoint Liste erzeugen und speichern oder im OziExplorer anzeigen
T6 Koordinaten Transformationen UTM GG WGS84
T7 Komplex Script mit if
T8 Quersummen
T9 Trigometrie
T10 Trunc und Round
T11 Waypoint Liste speichern und laden CVS
T12 IV Römische Ziffern
T13 WGS84 nach XYZ konvertieren, Schwerpunkt der Waypoint Liste
T14 Distanzberechung
T15 Verschneidung zweier Orthodrome auf der Kugel
T16 Verschneidung zweier Orthodrome auf der Kugel (ganz einfach)
T17 Koordinaten Transformation einer Liste (TestPunkte.csv)  aus dem Original (TestPunkteOriginal.csv) Quelle: CRSeu.
T18 Strecken schneiden
T19 Schneiden von Linie und Kreis
T20 Umwandlung von Ascii und Alpha
T21 Zahlen Basis Umwandlungen
T22 Ausgezeichnete Punkte im Dreieck

Calculation
function GMMMM(G, M1, M2, M3, M4: real): real;
Beispiel
function Distance(lat1, lon1, lat2, lon2: real): real;
Wird auf dem WGS84 Ellipsoid berechnet nach dem Vincenty Algorithmus.
function XYDistance(X1, Y1, X2, Y2: real): real;
function ToRad(val: real): real;
function ToDeg(val: real): real;
function Round(val: real): integer;
function Trunc(val: real): integer;
function Frac(val: real): real;
function Sqrt(val: real): real;
function Sqr(val: real): real;
function abs(val: real): real;
function ln(val: real): real;
function exp(val: real): real;
function
power(A,B: real): real;
function Random(val: real): real;
Quersummen
function WGS84sum(val: real): integer;
function qsum(val: integer): integer;
QuerSUMme
function iqsum(val: integer): integer;
Iterative QuerSUMme
function aqs(val: integer): integer;
Alternierende QuerSumme
function iaqs(val: integer): integer;
Iteriernde Alternierende QuerSumme
Trigometrie
function sin(val: real): real;
function cos(val: real): real;
function tan(val: real): real;
function arcsin(val: real): real;
function arccos(val: real): real;
function arctan(val: real): real;
function arctan2(dy, dx: real): real;

Calculation with Coordinates
function Bogenschnitt(Lat1, Lon1, Lat2, Lon2, s1, s2: real; var Lat3, Lon3, Lat4, Lon4: real): boolean;
Bogenschnitt
function XYBogenschnitt(X1,Y1, X2, Y2, s1, s2: real; var X3, Y3, X4, Y4: real): boolean;
function KreisLinie(Lat1, Lon1, Lat2, Lon2, s, a: real; var Lat3, Lon3, Lat4, Lon4: real): boolean;
Bogenschnitt
function XYKreisLinie(X1,Y1, X2, Y2, s, a: real; var X3, Y3, X4, Y4: real): boolean;
procedure KreuzPeilung(lat1, lon1, a1, lat2, lon2, a2: real; var lat, lon: real);
kreuzpeilung
function KreuzStrecken(lat1, lon1, lat2, lon2, lat3, lon3, lat4, lon4: real; var lat5, lon5: real): boolean;
Berechnet den Kreuzungspunkt zweier Strecken.
procedure CircumCircle(lat1, lon1, lat2, lon2, lat3, lon3: real; var Lat4, Lon4: real); 
CircumCircle
procedure XYCircumCircle(X1,Y1,X2,Y2, X3,Y3: real; var X4, X4: real); 
Projection
function CalcProjection(Lat1, Lon1, Lat2, Lon2: real; var s, a: real): boolean;
Projektion
procedure MakeProjection(Lat1,Lon1, s, a: real; var Lat2, Lon2: real);
Projection
procedure MidPointAngle(lat1, lon1, lat2, lon2, Angle: real; var lat3, lon3: real);
MidPoint
procedure Orthodrome(LatA, LonA, LatB, LonB, LatC, LonC, LatD, LonD: realvar  LatP, LonP, LatQ, LonQ: real; var Inside: integer);
Verschneidet zwei Orthodrome definiert durch (LatA, LonA, LatB, LonB) und (LatC, LonC, LatD, LonD). Die beiden Ergebnispunkte sind in LatP, LonP und LatQ, LonQ. Inside gibt an ob 1: P zwischen A..B liegt oder Q zwischen A..B.
procedure Max3Point(lat1, lon1, lat2, lon2, lat3, lon3: real; var Lat4, Lon4, Lat5, Lon5, Lat6, Lon6: real);
procedure XYMax3Point(X1,Y1, X2, Y2, X3, Y3: real; var X4, X4, X5, X5, X6, X6: real);
Max3Point
Umzeichnet ein mit einem Maximal großen Dreieck, so dass die Punkte auf den seiten liegen.
procedure Lot(lat1, lon1, lat2, lon2, lat3, lon3: real; var Lat, Lon: real);
procedure XY_Lot(x1, y1, x2, y2, x3, y3: real; var x, y: real);
P3 wird auf die Line P1-P2 senkrecht abgebildet.
procedure Spiegel(lat1, lon1, lat2, lon2, lat3, lon3: real; var Lat, Lon: real);
procedure XY_Spiegel(x1, y1, x2, y2, x3, y3: real; var x, y: real);
P3 wird über die Line P1-P2 gespiegelt.

Ausgezeichnete Punkte im Dreieck Wikki
procedure Schwerpunkt(lat1, lon1, lat2, lon2, lat3, lon3: real; var Slat, Slon: real);
procedure XY_Schwerpunkt(x1, y1, x2, y2, x3, y3: real; var SX, SY: real);
(X2) Berechnet den Schwerpunkt.
procedure HoehenSchnittPunkt(lat1, lon1, lat2, lon2, lat3, lon3: real; var Hlat, Hlon: real);
procedure XY_HoehenSchnittPunkt(x1, y1, x2, y2, x3, y3: real; var Hx, Hy: real);
(X4) Berechnet den HoehenSchnittPunkt.
procedure LemoinePunkt(lat1, lon1, lat2, lon2, lat3, lon3: real; var Llat, Llon: real);
procedure XY_LemoinePunkt(x1, y1, x2, y2, x3, y3: real; var Lx, Ly: real);
(X6) Berechnet den Lemoine Punkt (Greber)
procedure NapoleonPunkt(lat1, lon1, lat2, lon2, lat3, lon3: real; var Nlat, Nlon: real);
procedure XY_NapoleonPunkt(x1, y1, x2, y2, x3, y3: real; var Nx, Nx: real);
(X17) Berechnet den Napoleon Punkt.
procedure FeuerbachPunkt(lat1, lon1, lat2, lon2, lat3, lon3: real; var Flat, Flon: real);
procedure XY_FeuerbachPunkt(x1, y1, x2, y2, x3, y3: real; var Fx, Fy: real);
Berechnet den Feuerbach Punkt.
procedure SpiekerPunkt(lat1, lon1, lat2, lon2, lat3, lon3: real; var Slat, Slon: real);
procedure XY_SpiekerPunkt(x1, y1, x2, y2, x3, y3: real; var Sx, Sy: real);
(X10) Berechnet den Spieker Punkt.
procedure GergonnePunkt(lat1, lon1, lat2, lon2, lat3, lon3: real; var Glat, Glon: real);
procedure XY_GergonnePunkt(x1, y1, x2, y2, x3, y3: real; var Gy, Gx: real);
(X7) Berechnet den Gergonne Punkt.
Punkte auf den Seiten
procedure HalbeWinkelPunkte(lat1, lon1, lat2, lon2, lat3, lon3: real; var Wlat1,WFlon1, Wlat2, Wlon2, Wlat3, Wlon3: real);
procedure XY_HalbeWinkelPunkte(x1, y1, x2, y2, x3, y3: real; var Wx1, Wy1, Wx2, Wy2, Wx3, Wy3: real);
Berechnet die halbewinkel Punkte auf den Seiten. Schnittpunkte der Winkelhalbierende mit der Seite.
procedure HalbeSteitenPunkte(lat1, lon1, lat2, lon2, lat3, lon3: real; var Slat1, Slon1, Slat2, Slon2, Slat3, Slon3: real);
procedure XY_HalbeSteitenPunkte(x1, y1, x2, y2, x3, y3: real; var Sx1, Sy1, Sx2, Sy2, Sx3, Sy3: real);
Berechnet die halbeseiten Punkte auf den Seiten. Schnittpunkte der Seitenhalbierende mit der Seite.
procedure HoehenPunkte(lat1, lon1, lat2, lon2, lat3, lon3: real; var Mlat1, Mlon1, Mlat2, Mlon2, Mlat3, Mlon3: real);
procedure XY_HoehenPunkte(x1, y1, x2, y2, x3, y3: real; var Mx1, My1, Mx2, My2, Mx3, My3: real);
Berechnet die Höhen Punkte auf den Seiten. 
procedure SymmedianPunkte(lat1, lon1, lat2, lon2, lat3, lon3: real; var Mlat1, Mlon1, Mlat2, Mlon2, Mlat3, Mlon3: real);
procedure XY_SymmedianPunkte(x1, y1, x2, y2, x3, y3: real; var Mx1, My1, Mx2, My2, Mx3, My3: real);
Berechnet die Symmedian Punkte aud den Seiten. Schnittpunkte der Symmedian mit der Seite.
Kreise
procedure InnenKreis(lat1, lon1, lat2, lon2, lat3, lon3: real; var Ilat, Ilon, IR: real);
procedure XY_InnenKreis(x1, y1, x2, y2, x3, y3: real; var IX, IY, IR: real);
(X1) Berechnet den Innenkreis eines Dreiecks.
procedure UmKreis(lat1, lon1, lat2, lon2, lat3, lon3: real; var Ulat, Ulon, UR: real);
procedure XY_UmKreis(x1, y1, x2, y2, x3, y3: real; var UX, UY, UR: real);
(X3) Berechnet den Umkreis eines Dreiecks. (entspricht CircumCircle)
procedure FeuerbachKreis(lat1, lon1, lat2, lon2, lat3, lon3: real; var Flat, Flon, FR: real);
procedure XY_FeuerbachKreis(x1, y1, x2, y2, x3, y3: real; var FX, FY, FR: real);
(X5) Berechnet den Feuerbachkreis.
procedure AnKreise(lat1, lon1, lat2, lon2, lat3, lon3: real; var Alat1, Alon1, AR1, Alat2, Alon2, AR2, Alat3, Alon3, AR3: real);
procedure XY_Ankreise(x1, y1, x2, y2, x3, y3: real; var Ax1, Ay1, AR1, Ax2, Ay2, AR2, Ax3, Ay3, AR3: real);
Berechnet die Ankreise.

Transformation
WGS84 <> Universal Transverse Mercator
procedure SetUtmXZone(AUtmXZone: integer);
Alle mit WGS84toUTM erzeugten Koordinaten liegen in der AUtmXZone. Damit sind Zonen übergreifende Berechnungen möglich.
procedure ClearUtmXZone;
WGS84toGK erzeugt Koordinaten  in der passende Zone die zu lon passt.
procedure WGS84toUTM(lat, lon: real; var utmxZone: integer; var utmYZone: char; var easting, northing: real);
procedure UTMtoWGS84(utmxZone: integer; utmYZone: char; easting, northing: real; var lat, lon: real);
WGS84 <> Gauß Krüger
function MKZ(lon: real): integer;
Berechnet die Zone zu lon.
procedure SetGKZone(AGKZone: integer);
Alle mit WGS84toGK erzeugten Koordinaten liegen in der AGKZone. Damit sind Zonen übergreifende Berechnungen möglich.
procedure ClearGKZone;
WGS84toGK erzeugt Koordinaten  in der passende Zone die zu lon passt.
procedure WGS84toGK(lat, lon: realvar x, y: real);
procedure GKtoWGS84(rw, hw: real; var lat, lon: real);
WGS84 <> Swiss Grid
procedure WGS84toCH(lat, lon: real; var xCH, yCH: real);
procedure CHtoWGS84(xCH, yCH: real; var lat, lon: real);
WGS84 <> RijksDriehoeks
procedure WGS84toRD(lat, lon: real; var xRD, yRD: real);
procedure RDtoWGS84(xRD, yRD: real; var lat, lon: real);
WGS84 <> X,Y,Z
procedure WGS84toXYZ(lat, lon, H: real; var X,Y,Z: real);
Berechnet die karthesischen Koordinaten im WGS84 Ellepsoid.
procedure XYZtoWGS84(X,Y,Z: real; var lat, lon, H: real);
Führt die karthesischen Koordinaten zurück nach WGS84.
Sphere <> X,Y,Z
procedure SphereToXYZ(Lat, Lon, R: real; var x, y, z: real);
Wie WGS84toXYZ nur auf der Kugel
procedure XYZtoSphere(x, y, z, r: real; var Lat, Lon: real);
Wie XYZtoWGS84 nur auf der Kugel

OziExplorer
procedure OziMove(lat, lon: real);

Waypointlist
procedure WptsClear;
Alle Punkte löschen
Beispiel
procedure WptsAdd(Lat, Lon: real [; Name: string[; Number: integer]]);
Einen Punkt hinzufügen, der Name ist optional
WptsAdd(Lat, Lon, 'PX', i);
function WptsCount: integer;
Anzel der Punkte in der Liste
function WptsLat(i: integer): real;
Breite des iten Punktes
function WptsLon(i: integer): real;
Länge des iten Pubktes
procedure WptsCenter(var Lat, Lon, H: real);
Berechnet den Schwerpnunkt der Liste. Dazu werden die Punkte in X,Y,Z umgewandelt und das Centrum in 3D berechnet. Dieser Punkt wird dann wieder auf die Oberfläche abgebildet.
procedure WptsArea(var Lat, Lon, Area: real);
Berechnet den Schwerpunkt und Größer einer Fläche die durch die Punktfolge aufgespannt wird.
procedure WptsTranfereOzi;
Alle Punkte zum OziExplore transferieren
procedure WptsSaveOzi(FileName: string);
Speicherin in eine OzieExplorer Wpt-Datei
procedure WptsSaveCsv(FileName: string);
Speichern in eine Comma Seperated Values Datei
procedure WptsSaveGGpx(FileName: string);
Speichern in eine Garmin GPX Datei
procedure WptsLoadOzi(FileName: string);
Laden einer OziExplorer Wpt-Datei 
procedure WptsLoadCvs(FileName: string);
Laden einer Comma Seperated Values Datei
procedure WptsLoadGGpx(FileName: string);
Laden einer Garmin GPX Datei
procedure WptsLoadNMEA(FileName: string);
Laden einer NMEA Log Datei. $GPGGA, $GPRMC, $GPGLL, $GPWPL, $GPBWC, $GPRMB, $PMGNTRK


read()
read(x);
  • x: real
    49.456 
    49 20.45
    N 49°20.45
    49 20 60
  • x: integer
    −2.147.483.648 .. +2.147.483.647

write()
write(x);
  • x: real
    write
    (x:l:d) 
  • x: integer
    write(x:l)

l: Stellen gesamt
d: kommastellen
write( Fuc(i: integer));
schreibt  das Ergebnis Facultät von I.
write( WGS84(Lat, Lon: real));
schreibt die Koordinaten in Geocaching Format (4 Nachkommastellen).
write( WptsName(i: integer));
Gibt den Namen eines Waypoints aus
write( DezToRoman(i: integer));
write( DezimalToBasis(Definition: string; Value: real));

String Umwandlungen
function RomanToDez(Romans: string): integer;
Beispiel
function As(Ascii: string): real;
nimmt nur das erste Zeichen
Beispiel
function Al(Alpha: string): real;
Wandelt einen String zur Basis 27 um. [ ], A, ..., Z
AL('A')=1
AL('A_A')=((1 * 27 + 0)*27+1)=730
Beispiel
function SumA1(Alpha: string): real;
SumA1('AAA')=3
function BasisToDezimal(Definition: string; Value: string): real;
Wandelt eine Zahl zu einer fast beliebigen Basisdefinition um.
Die Definiton ist ein String bei der das erste Zeichen für die 0 steht und jedes weiter Zeichendan für 1, 2, ... Die länge der Definition ist dann die Basis.
'01' binear
'0123456789' oder '0..9' dezimal
'0123456789ABCDEF' oder '0..9A..Z' hexadezimal
Beispiel

miscellany
function IsPocketPC: boolean;
function IsWindowsPC: boolean;