UNCLASSIFIED

GeographicTranslator
 All Classes Namespaces Functions Enumerations
DatumLibraryImplementation.h
1 // CLASSIFICATION: UNCLASSIFIED
2 
3 #ifndef DatumLibraryImplementation_H
4 #define DatumLibraryImplementation_H
5 
6 /***************************************************************************/
7 /* RSC IDENTIFIER: Datum Library
8  *
9  * ABSTRACT
10  *
11  * This component provides datum shifts for a large collection of local
12  * datums, WGS72, and WGS84. A particular datum can be accessed by using its
13  * standard 5-letter code to find its index in the datum table. The index
14  * can then be used to retrieve the name, type, ellipsoid code, and datum
15  * shift parameters, and to perform shifts to or from that datum.
16  *
17  * By sequentially retrieving all of the datum codes and/or names, a menu
18  * of the available datums can be constructed. The index values resulting
19  * from selections from this menu can then be used to access the parameters
20  * of the selected datum, or to perform datum shifts involving that datum.
21  *
22  * This component supports both 3-parameter local datums, for which only X,
23  * Y, and Z translations relative to WGS 84 have been defined, and
24  * 7-parameter local datums, for which X, Y, and Z rotations, and a scale
25  * factor, are also defined. It also includes entries for WGS 84 (with an
26  * index of 0), and WGS 72 (with an index of 1), but no shift parameter
27  * values are defined for these.
28  *
29  * This component provides datum shift functions for both geocentric and
30  * geodetic coordinates. WGS84 is used as an intermediate state when
31  * shifting from one local datum to another. When geodetic coordinates are
32  * given Molodensky's method is used, except near the poles where the 3-step
33  * step method is used instead. Specific algorithms are used for shifting
34  * between WGS72 and WGS84.
35  *
36  * This component depends on two data files, named 3_param.dat and
37  * 7_param.dat, which contain the datum parameter values. Copies of these
38  * files must be located in the directory specified by the value of the
39  * environment variable "MSPCCS_DATA", if defined, or else in the current
40  * directory whenever a program containing this component is executed.
41  *
42  * Additional datums can be added to these files, either manually or using
43  * the Create_Datum function. However, if a large number of datums are
44  * added, the datum table array sizes in this component will have to be
45  * increased.
46  *
47  * This component depends on two other components: the Ellipsoid component
48  * for access to ellipsoid parameters; and the Geocentric component for
49  * conversions between geodetic and geocentric coordinates.
50  *
51  * ERROR HANDLING
52  *
53  * This component checks for input file errors and input parameter errors.
54  * If an invalid value is found, the error code is combined with the current
55  * error code using the bitwise or. This combining allows multiple error
56  * codes to be returned. The possible error codes are:
57  *
58  * DATUM_NO_ERROR : No errors occurred in function
59  * DATUM_NOT_INITIALIZED_ERROR : Datum module has not been initialized
60  * DATUM_7PARAM_FILE_OPEN_ERROR : 7 parameter file opening error
61  * DATUM_7PARAM_FILE_PARSING_ERROR : 7 parameter file structure error
62  * DATUM_7PARAM_OVERFLOW_ERROR : 7 parameter table overflow
63  * DATUM_3PARAM_FILE_OPEN_ERROR : 3 parameter file opening error
64  * DATUM_3PARAM_FILE_PARSING_ERROR : 3 parameter file structure error
65  * DATUM_3PARAM_OVERFLOW_ERROR : 3 parameter table overflow
66  * DATUM_INVALID_INDEX_ERROR : Index out of valid range (less than one
67  * or more than Number_of_Datums)
68  * DATUM_INVALID_SRC_INDEX_ERROR : Source datum index invalid
69  * DATUM_INVALID_DEST_INDEX_ERROR : Destination datum index invalid
70  * DATUM_INVALID_CODE_ERROR : Datum code not found in table
71  * DATUM_LAT_ERROR : Latitude out of valid range (-90 to 90)
72  * DATUM_LON_ERROR : Longitude out of valid range (-180 to
73  * 360)
74  * DATUM_SIGMA_ERROR : Standard error values must be positive
75  * (or -1 if unknown)
76  * DATUM_DOMAIN_ERROR : Domain of validity not well defined
77  * DATUM_ELLIPSE_ERROR : Error in ellipsoid module
78  * DATUM_NOT_USERDEF_ERROR : Datum code is not user defined - cannot
79  * be deleted
80  *
81  *
82  * REUSE NOTES
83  *
84  * Datum is intended for reuse by any application that needs access to
85  * datum shift parameters relative to WGS 84.
86  *
87  *
88  * REFERENCES
89  *
90  * Further information on Datum can be found in the Reuse Manual.
91  *
92  * Datum originated from : U.S. Army Topographic Engineering Center (USATEC)
93  * Geospatial Information Division (GID)
94  * 7701 Telegraph Road
95  * Alexandria, VA 22310-3864
96  *
97  * LICENSES
98  *
99  * None apply to this component.
100  *
101  * RESTRICTIONS
102  *
103  * Datum has no restrictions.
104  *
105  * ENVIRONMENT
106  *
107  * Datum was tested and certified in the following environments:
108  *
109  * 1. Solaris 2.5 with GCC 2.8.1
110  * 2. MS Windows 95 with MS Visual C++ 6
111  *
112  * MODIFICATIONS
113  *
114  * Date Description
115  * ---- -----------
116  * 03/30/97 Original Code
117  * 05/28/99 Added user-definable datums (for JMTK)
118  * Added datum domain of validity checking (for JMTK)
119  * Added datum shift accuracy calculation (for JMTK)
120  * 06/27/06 Moved data files to data directory
121  * 03-14-07 Original C++ Code
122  * 05/26/10 S. Gillis, BAEts26674, Added Validate Datum to the API
123  * in MSP Geotrans 3.0
124  * 08/13/12 S. Gillis, MSP_00029654, Added lat/lon to define7ParamDatum
125  */
126 
127 
128 #include <vector>
129 #include "DatumType.h"
130 #include "DtccApi.h"
131 
132 
133 namespace MSP
134 {
135  class CCSThreadMutex;
136  namespace CCS
137  {
138  class Accuracy;
139  class Datum;
140  class EllipsoidLibraryImplementation;
141  class CartesianCoordinates;
142  class GeodeticCoordinates;
143 
144 
145  class MSP_DTCC_API DatumLibraryImplementation
146  {
147  friend class DatumLibraryImplementationCleaner;
148 
149  public:
150 
151  /* The function getInstance returns an instance of the DatumLibraryImplementation
152  */
153 
154  static DatumLibraryImplementation* getInstance();
155 
156 
157  /*
158  * The function removeInstance removes this DatumLibraryImplementation instance from the
159  * total number of instances.
160  */
161 
162  static void removeInstance();
163 
164 
166 
167 
168  /*
169  * The function define3ParamDatum creates a new local (3-parameter) datum with the
170  * specified code, name, and axes. If the datum table has not been initialized,
171  * the specified code is already in use, or a new version of the 3-param.dat
172  * file cannot be created, an exception is thrown.
173  * Note that the indexes of all datums in the datum table may be
174  * changed by this function.
175  *
176  * code : 5-letter new datum code. (input)
177  * name : Name of the new datum (input)
178  * ellipsoidCode : 2-letter code for the associated ellipsoid (input)
179  * deltaX : X translation to WGS84 in meters (input)
180  * deltaY : Y translation to WGS84 in meters (input)
181  * deltaZ : Z translation to WGS84 in meters (input)
182  * sigmaX : Standard error in X in meters (input)
183  * sigmaY : Standard error in Y in meters (input)
184  * sigmaZ : Standard error in Z in meters (input)
185  * westLongitude : Western edge of validity rectangle in radians (input)
186  * eastLongitude : Eastern edge of validity rectangle in radians (input)
187  * southLatitude : Southern edge of validity rectangle in radians(input)
188  * northLatitude : Northern edge of validity rectangle in radians(input)
189  */
190 
191  void define3ParamDatum( const char *code, const char *name, const char *ellipsoidCode,
192  double deltaX, double deltaY, double deltaZ,
193  double sigmaX, double sigmaY, double sigmaZ,
194  double westLongitude, double eastLongitude, double southLatitude, double northLatitude );
195 
196 
197  /*
198  * The function define7ParamDatum creates a new local (7-parameter) datum with the
199  * specified code, name, and axes. If the datum table has not been initialized,
200  * the specified code is already in use, or a new version of the 7-param.dat
201  * file cannot be created, an exception is thrown.
202  * Note that the indexes of all datums in the datum table may be
203  * changed by this function.
204  *
205  * code : 5-letter new datum code. (input)
206  * name : Name of the new datum (input)
207  * ellipsoidCode : 2-letter code for the associated ellipsoid (input)
208  * deltaX : X translation to WGS84 in meters (input)
209  * deltaY : Y translation to WGS84 in meters (input)
210  * deltaZ : Z translation to WGS84 in meters (input)
211  * rotationX : X rotation to WGS84 in arc seconds (input)
212  * rotationY : Y rotation to WGS84 in arc seconds (input)
213  * rotationZ : Z rotation to WGS84 in arc seconds (input)
214  * scale : Scale factor (input)
215  * westLongitude : Western edge of validity rectangle in radians (input)
216  * eastLongitude : Eastern edge of validity rectangle in radians (input)
217  * southLatitude : Southern edge of validity rectangle in radians(input)
218  * northLatitude : Northern edge of validity rectangle in radians(input)
219  */
220 
221  void define7ParamDatum( const char *code, const char *name, const char *ellipsoidCode,
222  double deltaX, double deltaY, double deltaZ,
223  double rotationX, double rotationY, double rotationZ,
224  double scale, double westLongitude,
225  double eastLongitude, double southLatitude,
226  double northLatitude);
227 
228  /*
229  * The function removeDatum deletes a local (3-parameter) datum with the
230  * specified code. If the datum table has not been initialized or a new
231  * version of the 3-param.dat file cannot be created, an exception is thrown.
232  * Note that the indexes of all datums
233  * in the datum table may be changed by this function.
234  *
235  * code : 5-letter datum code. (input)
236  *
237  */
238 
239  void removeDatum( const char* code );
240 
241 
242  /*
243  * The function datumCount returns the number of Datums in the table
244  * if the table was initialized without error.
245  *
246  * count : number of datums in the datum table (output)
247  */
248 
249  void datumCount( long *count );
250 
251 
252  /*
253  * The function datumIndex returns the index of the datum with the
254  * specified code.
255  *
256  * code : The datum code being searched for. (input)
257  * index : The index of the datum in the table with the (output)
258  * specified code.
259  */
260 
261  void datumIndex( const char *code, long *index );
262 
263 
264  /*
265  * The function datumCode returns the 5-letter code of the datum
266  * referenced by index.
267  *
268  * index : The index of a given datum in the datum table. (input)
269  * code : The datum Code of the datum referenced by Index. (output)
270  */
271 
272  void datumCode( const long index, char *code );
273 
274 
275  /*
276  * The function datumName returns the name of the datum referenced by
277  * index.
278  *
279  * index : The index of a given datum in the datum table. (input)
280  * name : The datum Name of the datum referenced by Index. (output)
281  */
282 
283  void datumName( const long index, char *name );
284 
285 
286  /*
287  * The function datumEllipsoidCode returns the 2-letter ellipsoid code
288  * for the ellipsoid associated with the datum referenced by index.
289  *
290  * index : The index of a given datum in the datum table. (input)
291  * code : The ellipsoid code for the ellipsoid associated with (output)
292  * the datum referenced by index.
293  */
294 
295  void datumEllipsoidCode( const long index, char *code );
296 
297 
298  /*
299  * The function datumStandardErrors returns the standard errors in X,Y, & Z
300  * for the datum referenced by index.
301  *
302  * index : The index of a given datum in the datum table (input)
303  * sigma_X : Standard error in X in meters (output)
304  * sigma_Y : Standard error in Y in meters (output)
305  * sigma_Z : Standard error in Z in meters (output)
306  */
307 
308  void datumStandardErrors( const long index, double *sigmaX, double *sigmaY, double *sigmaZ );
309 
310 
311  /*
312  * The function datumSevenParameters returns parameter values,
313  * used only by a seven parameter datum,
314  * for the datum referenced by index.
315  *
316  * index : The index of a given datum in the datum table. (input)
317  * rotationX : X rotation in radians (output)
318  * rotationY : Y rotation in radians (output)
319  * rotationZ : Z rotation in radians (output)
320  * scaleFactor : Scale factor (output)
321  */
322 
323  void datumSevenParameters( const long index, double *rotationX, double *rotationY, double *rotationZ, double *scaleFactor);
324 
325 
326  /*
327  * The function datumTranslationValues returns the translation values
328  * for the datum referenced by index.
329  *
330  * index : The index of a given datum in the datum table. (input)
331  * deltaX : X translation in meters (output)
332  * deltaY : Y translation in meters (output)
333  * deltaZ : Z translation in meters (output)
334  */
335 
336  void datumTranslationValues( const long index, double *deltaX, double *deltaY, double *deltaZ );
337 
338 
339  /*
340  * The function datumShiftError returns the 90% horizontal (circular), vertical (linear), and
341  * spherical errors for a shift from the specified source datum to the
342  * specified destination datum at the specified location.
343  *
344  * sourceIndex : Index of source datum (input)
345  * targetIndex : Index of destination datum (input)
346  * latitude : Latitude of point being converted in radians (input)
347  * longitude : Longitude of point being converted in radians (input)
348  * circularError90 : Combined 90% circular horizontal error in meters (output)
349  * linearError90 : Combined 90% linear vertical error in meters (output)
350  * sphericalError90 : Combined 90% spherical error in meters (output)
351  */
352 
353  Accuracy* datumShiftError( const long sourceIndex, const long targetIndex,
354  double longitude, double latitude, Accuracy* sourceAccuracy );
355 
356 
357  /*
358  * The function datumUserDefined checks whether or not the specified datum is
359  * user defined. It returns 1 if the datum is user defined, and returns
360  * 0 otherwise. If index is valid DATUM_NO_ERROR is returned, otherwise
361  * DATUM_INVALID_INDEX_ERROR is returned.
362  *
363  * index : Index of a given datum in the datum table (input)
364  * result : Indicates whether specified datum is user defined (1)
365  * or not (0) (output)
366  */
367 
368  void datumUserDefined( const long index, long *result );
369 
370 
371  /*
372  * The function datumUsesEllipsoid returns 1 if the ellipsoid is in use by a
373  * user defined datum. Otherwise, 0 is returned.
374  *
375  * ellipsoidCode : The ellipsoid code being searched for. (input)
376  */
377 
378  bool datumUsesEllipsoid( const char *ellipsoidCode );
379 
380 
381  /*
382  * The function datumValidRectangle returns the edges of the validity
383  * rectangle for the datum referenced by index.
384  *
385  * index : The index of a given datum in the datum table (input)
386  * westLongitude : Western edge of validity rectangle in radians (output)
387  * eastLongitude : Eastern edge of validity rectangle in radians (output)
388  * southLatitude : Southern edge of validity rectangle in radians (output)
389  * northLatitude : Northern edge of validity rectangle in radians (output)
390  *
391  */
392 
393  void datumValidRectangle( const long index, double *westLongitude, double *eastLongitude, double *southLatitude, double *northLatitude );
394 
395 
396  /*
397  * The function geocentricDatumShift shifts a geocentric coordinate (X, Y, Z in meters) relative
398  * to the source datum to geocentric coordinate (X, Y, Z in meters) relative
399  * to the destination datum.
400  *
401  * sourceIndex : Index of source datum (input)
402  * sourceX : X coordinate relative to source datum (input)
403  * sourceY : Y coordinate relative to source datum (input)
404  * sourceZ : Z coordinate relative to source datum (input)
405  * targetIndex : Index of destination datum (input)
406  * targetX : X coordinate relative to destination datum (output)
407  * targetY : Y coordinate relative to destination datum (output)
408  * targetZ : Z coordinate relative to destination datum (output)
409  *
410  */
411 
412  CartesianCoordinates* geocentricDatumShift( const long sourceIndex, const double sourceX, const double sourceY, const double sourceZ,
413  const long targetIndex );
414 
415 
416  /*
417  * The function geocentricShiftFromWGS84 shifts a geocentric coordinate (X, Y, Z in meters) relative
418  * to WGS84 to a geocentric coordinate (X, Y, Z in meters) relative to the
419  * local datum referenced by index.
420  *
421  * WGS84X : X coordinate relative to WGS84 (input)
422  * WGS84Y : Y coordinate relative to WGS84 (input)
423  * WGS84Z : Z coordinate relative to WGS84 (input)
424  * targetIndex : Index of destination datum (input)
425  * targetX : X coordinate relative to the destination datum (output)
426  * targetY : Y coordinate relative to the destination datum (output)
427  * targetZ : Z coordinate relative to the destination datum (output)
428  */
429 
430  CartesianCoordinates* geocentricShiftFromWGS84( const double WGS84X, const double WGS84Y, const double WGS84Z, const long targetIndex );
431 
432 
433  /*
434  * The function geocentricShiftToWGS84 shifts a geocentric coordinate (X, Y, Z in meters) relative
435  * to the datum referenced by index to a geocentric coordinate (X, Y, Z in
436  * meters) relative to WGS84.
437  *
438  * sourceIndex : Index of source datum (input)
439  * sourceX : X coordinate relative to the source datum (input)
440  * sourceY : Y coordinate relative to the source datum (input)
441  * sourceZ : Z coordinate relative to the source datum (input)
442  * WGS84X : X coordinate relative to WGS84 (output)
443  * WGS84Y : Y coordinate relative to WGS84 (output)
444  * WGS84Z : Z coordinate relative to WGS84 (output)
445  */
446 
447  CartesianCoordinates* geocentricShiftToWGS84( const long sourceIndex, const double sourceX, const double sourceY, const double sourceZ );
448 
449 
450  /*
451  * The function geodeticDatumShift shifts geodetic coordinates (latitude, longitude in radians
452  * and height in meters) relative to the source datum to geodetic coordinates
453  * (latitude, longitude in radians and height in meters) relative to the
454  * destination datum.
455  *
456  * sourceIndex : Index of source datum (input)
457  * sourceLongitude : Longitude in radians relative to source datum (input)
458  * sourceLatitude : Latitude in radians relative to source datum (input)
459  * sourceHeight : Height in meters relative to source datum (input)
460  * targetIndex : Index of destination datum (input)
461  * targetLongitude : Longitude in radians relative to destination datum (output)
462  * targetLatitude : Latitude in radians relative to destination datum (output)
463  * targetHeight : Height in meters relative to destination datum (output)
464  */
465 
466  GeodeticCoordinates* geodeticDatumShift( const long sourceIndex, const GeodeticCoordinates* sourceCoordinates,
467  const long targetIndex );
468 
469 
470  /*
471  * The function geodeticShiftFromWGS84 shifts geodetic coordinates relative to WGS84
472  * to geodetic coordinates relative to a given local datum.
473  *
474  * WGS84Longitude : Longitude in radians relative to WGS84 (input)
475  * WGS84Latitude : Latitude in radians relative to WGS84 (input)
476  * WGS84Height : Height in meters relative to WGS84 (input)
477  * targetIndex : Index of destination datum (input)
478  * targetLongitude : Longitude in radians relative to destination datum (output)
479  * targetLatitude : Latitude in radians relative to destination datum (output)
480  * targetHeight : Height in meters relative to destination datum (output)
481  *
482  */
483 
484  GeodeticCoordinates* geodeticShiftFromWGS84( const GeodeticCoordinates* sourceCoordinates,
485  const long targetIndex );
486 
487 
488  /*
489  * The function geodeticShiftToWGS84 shifts geodetic coordinates relative to a given source datum
490  * to geodetic coordinates relative to WGS84.
491  *
492  * sourceIndex : Index of source datum (input)
493  * sourceLongitude : Longitude in radians relative to source datum (input)
494  * sourceLatitude : Latitude in radians relative to source datum (input)
495  * sourceHeight : Height in meters relative to source datum (input)
496  * WGS84Longitude : Longitude in radians relative to WGS84 (output)
497  * WGS84Latitude : Latitude in radians relative to WGS84 (output)
498  * WGS84Height : Height in meters relative to WGS84 (output)
499  *
500  */
501 
502  GeodeticCoordinates* geodeticShiftToWGS84( const long sourceIndex, const GeodeticCoordinates* sourceCoordinates );
503 
504 
505  /*
506  * The function retrieveDatumType returns the type of the datum referenced by
507  * index.
508  *
509  * index : The index of a given datum in the datum table. (input)
510  * datumType : The type of datum referenced by index. (output)
511  *
512  */
513 
514  void retrieveDatumType( const long index, DatumType::Enum *datumType );
515 
516 
517  /*
518  * The function validDatum checks whether or not the specified location is within the
519  * validity rectangle for the specified datum. It returns zero if the specified
520  * location is NOT within the validity rectangle, and returns 1 otherwise.
521  *
522  * index : The index of a given datum in the datum table (input)
523  * latitude : Latitude of the location to be checked in radians (input)
524  * longitude : Longitude of the location to be checked in radians (input)
525  * result : Indicates whether location is inside (1) or outside (0)
526  * of the validity rectangle of the specified datum (output)
527  */
528 
529  void validDatum( const long index, double longitude, double latitude, long *result );
530 
531 
532  /*
533  * The function setEllipsoidLibrary sets the ellipsoid library information
534  * which is needed to create datums and calculate datum shifts.
535  *
536  * __ellipsoidLibrary : Ellipsoid library (input)
537  *
538  */
539 
540  void setEllipsoidLibraryImplementation( EllipsoidLibraryImplementation* __ellipsoidLibraryImplementation );
541 
542 
543  protected:
544 
545  /*
546  * The constructor creates an empty list to store the datum information
547  * contained in two external files, 3_param.dat and 7_param.dat.
548  */
549 
551 
552 
554 
555 
557 
558 
559  private:
560 
561  static MSP::CCSThreadMutex mutex;
562  static DatumLibraryImplementation* instance;
563  static int instanceCount;
564 
565  std::vector<Datum*> datumList;
566 
567  EllipsoidLibraryImplementation* _ellipsoidLibraryImplementation;
568 
569  long datum3ParamCount;
570  long datum7ParamCount;
571 
572 
573  /*
574  * The function loadDatums creates the datum table from two external
575  * files. If an error occurs, the initialization stops and an error code is
576  * returned. This function must be called before any of the other functions
577  * in this component.
578  */
579 
580  void loadDatums();
581 
582 
583  /*
584  * The function write3ParamFile writes the 3 parameter datums in the datum list
585  * to the 3_param.dat file.
586  */
587 
588  void write3ParamFile();
589 
590 
591  /*
592  * The function write7ParamFile writes the 7 parameter datums in the datum list
593  * to the 7_param.dat file.
594  */
595 
596  void write7ParamFile();
597 
598  /*
599  * The function geodeticShiftWGS84ToWGS72 shifts a geodetic coordinate (latitude, longitude in radians
600  * and height in meters) relative to WGS84 to a geodetic coordinate
601  * (latitude, longitude in radians and height in meters) relative to WGS72.
602  *
603  * WGS84Longitude : Longitude in radians relative to WGS84 (input)
604  * WGS84Latitude : Latitude in radians relative to WGS84 (input)
605  * WGS84Height : Height in meters relative to WGS84 (input)
606  * WGS72Longitude : Longitude in radians relative to WGS72 (output)
607  * WGS72Latitude : Latitude in radians relative to WGS72 (output)
608  * WGS72Height : Height in meters relative to WGS72 (output)
609  */
610 
611  GeodeticCoordinates* geodeticShiftWGS84ToWGS72( const double WGS84Longitude, const double WGS84Latitude, const double WGS84Height );
612 
613 
614  /*
615  * The function geodeticShiftWGS72ToWGS84 shifts a geodetic coordinate (latitude, longitude in radians
616  * and height in meters) relative to WGS72 to a geodetic coordinate
617  * (latitude, longitude in radians and height in meters) relative to WGS84.
618  *
619  * WGS72Longitude : Longitude in radians relative to WGS72 (input)
620  * WGS72Latitude : Latitude in radians relative to WGS72 (input)
621  * WGS72Height : Height in meters relative to WGS72 (input)
622  * WGS84Longitude : Longitude in radians relative to WGS84 (output)
623  * WGS84Latitude : Latitude in radians relative to WGS84 (output)
624  * WGS84Height : Height in meters relative to WGS84 (output)
625  */
626 
627  GeodeticCoordinates* geodeticShiftWGS72ToWGS84( const double WGS72Longitude, const double WGS72Latitude, const double WGS72Height );
628 
629 
630  /*
631  * The function geocentricShiftWGS84ToWGS72 shifts a geocentric coordinate (X, Y, Z in meters) relative
632  * to WGS84 to a geocentric coordinate (X, Y, Z in meters) relative to WGS72.
633  *
634  * X_WGS84 : X coordinate relative to WGS84 (input)
635  * Y_WGS84 : Y coordinate relative to WGS84 (input)
636  * Z_WGS84 : Z coordinate relative to WGS84 (input)
637  * X : X coordinate relative to WGS72 (output)
638  * Y : Y coordinate relative to WGS72 (output)
639  * Z : Z coordinate relative to WGS72 (output)
640  */
641 
642  CartesianCoordinates* geocentricShiftWGS84ToWGS72( const double X_WGS84, const double Y_WGS84, const double Z_WGS84 );
643 
644 
645  /*
646  * The function geocentricShiftWGS72ToWGS84 shifts a geocentric coordinate (X, Y, Z in meters) relative
647  * to WGS72 to a geocentric coordinate (X, Y, Z in meters) relative to WGS84.
648  *
649  * X : X coordinate relative to WGS72 (input)
650  * Y : Y coordinate relative to WGS72 (input)
651  * Z : Z coordinate relative to WGS72 (input)
652  * X_WGS84 : X coordinate relative to WGS84 (output)
653  * Y_WGS84 : Y coordinate relative to WGS84 (output)
654  * Z_WGS84 : Z coordinate relative to WGS84 (output)
655  */
656 
657  CartesianCoordinates* geocentricShiftWGS72ToWGS84( const double X, const double Y, const double Z );
658 
659 
660  /*
661  * Delete the singleton.
662  */
663 
664  static void deleteInstance();
665  };
666  }
667 }
668 
669 #endif
670 
671 
672 // CLASSIFICATION: UNCLASSIFIED