Prototype and description of the function gettransresidualcoord()

(Function of the unlock requiring group "Transformation Parameter")

 

gettransresidualcoord()
Korrection of a cartesian coordinate with Residual Gaps Distribution by Natural
Neighbour Interpolation.

Prototype of the DLL function in C++ syntax (attend lower case!):
extern "C" __declspec(dllimport) unsigned long __stdcall gettransresidualcoord(
     double aCartP[][3],
     double aResid[][3],
     unsigned long nCount,
     double aCartQ[3],
     double aCartZ[3]);

Prototype of the DLL function in Visual Objects syntax:
_DLL function gettransresidualcoord(;
     aCartP as real8 ptr,;                     // 4 Byte
     aResid as real8 ptr,;                     // 4 Byte
     nCount as dword,;                         // 4 Byte
     aCartQ as real8 ptr,;                     // 4 Byte
     aCartZ as real8 ptr);                     // 4 Byte
as logic pascal:geodll32.gettransresidualcoord // 4 Byte


The function corrects a cartesian coordinate contained in aCartQ using the
identical points of the target reference system contained in aCartP and the
gaps contained in aResid. The correction is performed using the Residual Gaps
Distribution by Natural Neighbour Interpolation. The weighting of the gaps
decreases in square with the distance of the points from the coordinate to be
corrected. The corrected result is returned as cartesian coordinate in aCartZ.

The gaps first need to be calculated with the function gettransresiduals().

Since the function due to the extensive calculations is time-consuming, the
event handling during the calculation by interrupting the processing loop can
be are allowed bei calling the function seteventloop().

The parameters are passed and/or returned as follows:
aCartP[][3] Cartesian coordinates X, Y, Z of the target Coordinate Reference
(ref)       System in a two-dimensional array of the type double. The first
            dimension counts the number of available cartesian coordinates of
            identical points in the target system passed in nCount. The second
            dimension counts three for the X, Y and Z components of the
            cartesian coordinates of the target system. The number of elements
            in the arrays aCartP and aResid must be identical. The structure of
            the array is described below.

aResid[][3] Previously determined gaps in a two-dimensional array of the type
(ref)       double for the X, Y and Z components of the gaps in meters. The
            structure of the array is described below.

nCount      Number of available identical points of the target system in the
            array aCartP and of the gaps in the array aResid.

aCartQ[3]   Cartesian coordinate X, Y, Z to be corrected. The array contains
(ref)       the three X, Y and Z components of the Cartesian coordinate to be
            corrected.
            -------------
            | X | Y | Z |
            -------------

aCartZ[3]   Cartesian coordinate X, Y, Z, which has been corrected. The three
(ref out)   X, Y and Z components of the corrected cartesian coordinate are
            inserted into the array.
            For the array, memory of the size 3*sizeof(double) bytes must be
            provided by the calling routine.
            -------------
            | X | Y | Z |
            -------------

returnVal   In case of an error the function returns FALSE, otherwise TRUE.


The two dimensional arrays aCartP[][3] and aResid[][3] are filled with values
of type double and are structured as follows:
----------------------------------------------------------------------
| C1-X | C1-Y | C1-Z | C2-X | C2-Y | C2-Z | ... | Cn-X | Cn-Y | Cn-Z |
----------------------------------------------------------------------
with C1 -› Cn: Coordinates or Residuals 1 to n
X:             X component
Y:             Y component
Z:             Z component


Unlocking:
This function is a component of the unlock requiring function group
"Transformation parameter". It is unlocked for unrestricted use together
with other functions of the group by passing the unlock parameters, acquired
from the software distribution company, trough the function setunlockcode().
Without unlocking at most 25 identical points can be processed.