GDI/图象编程

开发平台：

Visual C++

engine.h：源码内容

#ifndef ENGINE_H
#define ENGINE_H
/***************************************************************************/
/* RSC IDENTIFIER: GEOTRANS ENGINE
*
* ABSTRACT
*
* This component is the coordinate transformation engine for the GEOTRANS
* application. It provides an external input interface that supports the
* GEOTRANS GUIs (Motif and Windows) and the GEOTRANS file processing
* component.
*
* This component depends on the DT&CC modules: DATUM, ELLIPSOID,
* GEOCENTRIC, GEOREF, MERCATOR, TRANSVERSE MERCATOR, UTM, MGRS, POLAR
* STEREOGRAPHIC, UPS, LAMBERT, ALBERS, AZIMUTHAL EQUIDISTANT, BONNE,
* BRITISH NATIONAL GRID, CASSINI, CYLINDRICAL EQUAL AREA,ECKERT4, ECKERT6,
* EQUIDISTANT CYLINDRICAL, GNOMONIC, LOCAL CARTESIAN, MILLER, MOLLWEIDE,
* NEYS, NEW ZEALAND MAP GRID, OBLIQUE MERCATOR, ORTHOGRAPHIC, POLYCONIC,
* SINUSOIDAL, STEREOGRAPHIC, TRANSVERSE CYLINDRICAL EQUAL AREA, and VAN DER GRINTEN.
*
*
* ERROR HANDLING
*
* This component checks for error codes returned by the DT&CC modules.
* If an error code is returned, it is combined with the current
* error code using the bitwise or. This combining allows multiple error
* codes to be returned. The possible error codes are listed below.
*
*
* REUSE NOTES
*
* GEOTRANS ENGINE is intended for reuse by other applications that require
* coordinate conversions between multiple coordinate systems and/or datum
* transformations between multiple datums.
*
*
* REFERENCES
*
* Further information on GEOTRANS ENGINE can be found in the GEOTRANS ENGINE
* Reuse Manual.
*
* GEOTRANS ENGINE originated from : U.S. Army Topographic Engineering Center
* Geospatial Information Division
* 7701 Telegraph Road
* Alexandria, VA 22310-3864
*
* LICENSES
*
* None apply to this component.
*
* RESTRICTIONS
*
* GEOTRANS ENGINE has no restrictions.
*
* ENVIRONMENT
*
* GEOTRANS ENGINE was tested and certified in the following environments:
*
* 1. Solaris 2.5 with GCC, version 2.8.1
* 2. Windows 95 with MS Visual C++, version 6
*
* MODIFICATIONS
*
* Date Description
* ---- -----------
* 04-22-97 Original Code
* 09-30-99 Added support for 15 new projections
* 05-30-00 Added support for 2 new projections
* 06-30-00 Added support for 1 new projection
* 09-30-00 Added support for 4 new projections
*/
/***************************************************************************/
/*
* DEFINES
*/
/* Engine return status codes */
#define ENGINE_INPUT_WARNING 0x00000001 /* Warning returned by 1st conversion */
#define ENGINE_INPUT_ERROR 0x00000002 /* Error returned by 1st conversion */
#define ENGINE_OUTPUT_WARNING 0x00000004 /* Warning returned by 2nd conversion */
#define ENGINE_OUTPUT_ERROR 0x00000008 /* Error returned by 2nd conversion */
/* Initialization errors */
#define ENGINE_NOT_INITIALIZED 0x00000010 /* Initialize_Engine has not been called */
#define ENGINE_ELLIPSOID_ERROR 0x00000020 /* Error returned by Ellipsoid module */
#define ENGINE_DATUM_ERROR 0x00000040 /* Error returned by Datum module */
#define ENGINE_GEOID_ERROR 0x00000080 /* Error returned by Geoid module*/
/* Interface parameter errors (should never occur) */
#define ENGINE_INVALID_TYPE 0x00000100 /* Invalid coordinate system type */
#define ENGINE_INVALID_DIRECTION 0x00000200 /* Invalid direction (input or output) */
#define ENGINE_INVALID_STATE 0x00000400 /* Invalid state (interactive or file) */
/* Lookup table errors */
#define ENGINE_INVALID_INDEX_ERROR 0x00001000 /* Index is an invalid value */
#define ENGINE_INVALID_CODE_ERROR 0x00002000 /* Code was not found in table */
#define ENGINE_ELLIPSOID_OVERFLOW 0x00004000 /* Ellipsoid table overflow */
#define ENGINE_DATUM_OVERFLOW 0x00008000 /* 3-parameter datum table overflow */
/* Datum definition errors */
#define ENGINE_DATUM_SIGMA_ERROR 0x00010000 /* Standard error values must be positive
(or -1 if unknown) */
#define ENGINE_DATUM_DOMAIN_ERROR 0x00020000 /* Invalid local datum domain of validity */
/* Ellipsoid errors */
#define ENGINE_ELLIPSE_IN_USE_ERROR 0x00040000 /* Ellipsoid code is in use by a datum */
/* Datum, ellipsoid deletion error */
#define ENGINE_NOT_USERDEF_ERROR 0x00080000 /* Specified code is not user defined */
/* Input/Output conversion status codes */
#define ENGINE_ORIGIN_LAT_ERROR 0x00000001 /* Invalid Origin Latitude */
#define ENGINE_CENT_MER_ERROR 0x00000002 /* Invalid Central Meridian */
#define ENGINE_EASTING_ERROR 0x00000004 /* Invalid Easting */
#define ENGINE_NORTHING_ERROR 0x00000008 /* Invalid Northing */
#define ENGINE_RADIUS_ERROR 0x00000010 /* Point too far from center of projection */
#define ENGINE_HEMISPHERE_ERROR 0x00000020 /* Invalid Hemisphere */
#define ENGINE_SCALE_FACTOR_ERROR 0x00000040 /* Invalid Scale Factor */
#define ENGINE_LON_WARNING 0x00000080 /* Longitude too far from Central Meridian */
#define ENGINE_ORIGIN_LON_ERROR 0x00000100 /* Invalid Origin Longitude */
#define ENGINE_DATUM_WARNING 0x00000200 /* Point outside datum validity rectangle */
/* Lambert/Albers error conditions */
#define ENGINE_FIRST_STDP_ERROR 0x00000400 /* Invalid 1st Standard Parallel */
#define ENGINE_SECOND_STDP_ERROR 0x00000800 /* Invalid 2nd Standard Parallel */
#define ENGINE_FIRST_SECOND_ERROR 0x00001000 /* 1st & 2nd Standard Parallel cannot be same */
/* UTM/UPS/MGRS specific error conditions */
#define ENGINE_ZONE_ERROR 0x00002000 /* Invalid UTM Zone */
#define ENGINE_ZONE_OVERRIDE_ERROR 0x00004000 /* Invalid UTM zone Override */
/* MGRS, GEOREF, British National Grid error condition */
#define ENGINE_STRING_ERROR 0x00008000 /* Invalid MGRS, GEOREF or BNG String */
/* GEOREF specific error conditions */
#define ENGINE_STR_LON_MIN_ERROR 0x00010000 /* GEOREF string long. min. error */
#define ENGINE_STR_LAT_MIN_ERROR 0x00020000 /* GEOREF string lat. min. error */
/* Equidistant Cylindrical error condition */
#define ENGINE_STDP_ERROR 0x00040000 /* Standard parallel error */
/* Azimuthal Equidistant error condition */
#define ENGINE_PROJECTION_ERROR 0x00080000 /* Point projects into a circle of radius PI*R */
/* Oblique Mercator error conditions */
#define ENGINE_LAT1_ERROR 0x00100000 /* Invalid 1st Latitude */
#define ENGINE_LON1_ERROR 0x00200000 /* Invalid 1st Longitude */
#define ENGINE_LAT2_ERROR 0x00400000 /* Invalid 2nd Latitude */
#define ENGINE_LON2_ERROR 0x00800000 /* Invalid 2nd Longitude */
#define ENGINE_LAT1_LAT2_ERROR 0x01000000 /* 1st & 2nd Latitudes cannot be equal */
/* British National Grid error condition */
#define ENGINE_INVALID_AREA_ERROR 0x02000000 /* Coordinate outside BNG grid */
/* British National Grid, New Zealand Map Grid error condition */
#define ENGINE_ELLIPSOID_CODE_ERROR 0x04000000 /* Invalid ellipsoid */
/* Common status codes */
#define ENGINE_NO_ERROR 0x00000000 /* no error */
#define ENGINE_LAT_ERROR 0x10000000 /* Invalid Latitude */
#define ENGINE_LON_ERROR 0x20000000 /* Invalid Longitude */
#define ENGINE_A_ERROR 0x40000000 /* Invalid Ellipsoid Semi-Major Axis */
#define ENGINE_INV_F_ERROR 0x80000000 /* Invalid Inverse Flattening */
/* Symbolic constants */
#define NUMBER_COORD_SYS 32 /* Number of coordinate systems */
#define COORD_SYS_CODE_LENGTH 3 /* Length of coordinate system codes (including null) */
#define COORD_SYS_NAME_LENGTH 50 /* Max length of coordinate system names (including null) */
#define DATUM_CODE_LENGTH 7 /* Length of datum codes (including null) */
#define DATUM_NAME_LENGTH 33 /* Max length of datum names (including null) */
#define ELLIPSOID_CODE_LENGTH 3 /* Length of ellipsoid codes (including null) */
#define ELLIPSOID_NAME_LENGTH 30 /* Max length of ellipsoid names (including null) */
#define CONVERT_MSG_LENGTH 2048 /* Max length of coordinate conversion status message */
#define RETURN_MSG_LENGTH 256 /* Max length of return code status message */
/***************************************************************************/
/*
* GLOBAL DECLARATIONS
*/
/* State Enumerations */
typedef enum Input_Output
{
Input = 0,
Output = 1
} Input_or_Output;
typedef enum File_Interactive
{
File = 0,
Interactive = 1
} File_or_Interactive;
/* Coordinate Type Enumeration */
typedef enum Coordinate_Types
{
Geodetic,
GEOREF,
Geocentric,
Local_Cartesian,
MGRS,
UTM,
UPS,
Albers_Equal_Area_Conic,
Azimuthal_Equidistant,
BNG,
Bonne,
Cassini,
Cylindrical_Equal_Area,
Eckert4,
Eckert6,
Equidistant_Cylindrical,
Gnomonic,
Lambert_Conformal_Conic,
Mercator,
Miller_Cylindrical,
Mollweide,
Neys,
NZMG,
Oblique_Mercator,
Orthographic,
Polar_Stereo,
Polyconic,
Sinusoidal,
Stereographic,
Transverse_Cylindrical_Equal_Area,
Transverse_Mercator,
Van_der_Grinten
} Coordinate_Type;
/* Precision Enumeration */
typedef enum Precisions
{
Degree, /* 100000m */
Ten_Minutes, /* 10000m */
Minute, /* 1000m */
Ten_Seconds, /* 100m */
Second, /* 10m */
Tenth_of_Second, /* 1m */
Hundredth_of_Second, /* 0.1m */
Thousandth_of_Second, /* 0.01 */
Ten_Thousandth_of_Second /* 0.001m */
} Precision;
/* Heights */
typedef enum Height_Types
{
No_Height,
Ellipsoid_Height,
Geoid_or_MSL_Height
} Height_Type;
/* Datums */
typedef enum Define_Datum_Types
{
Three_Param_Datum_Type,
Seven_Param_Datum_Type,
WGS84_Datum_Type,
WGS72_Datum_Type
} Define_Datum_Type;
/* Geocentric Coordinate Tuple Definition */
typedef struct Geocentric_Tuple_Structure
{
double x; /* meters */
double y; /* meters */
double z; /* meters */
} Geocentric_Tuple;
/* Geodetic Coordinate System Definition */
typedef struct Geodetic_Structure
{
Height_Type height_type;
} Geodetic_Parameters;
/* Geodetic Coordinate Tuple Definition */
typedef struct Geodetic_Tuple_Structure
{
double longitude; /* radians */
double latitude; /* radians */
double height; /* meters */
} Geodetic_Tuple;
/* GEOREF Coordinate Tuple Definition */
typedef struct GEOREF_Tuple_Structure
{
char string[21];
} GEOREF_Tuple;
/* Albers Equal Area Conic Coordinate System Definition */
typedef struct Albers_Equal_Area_Conic_Structure
{
double origin_latitude; /* radians */
double central_meridian; /* radians */
double std_parallel_1; /* radians */
double std_parallel_2; /* radians */
double false_easting; /* meters */
double false_northing; /* meters */
} Albers_Equal_Area_Conic_Parameters;
/* Albers Equal Area Conic Coordinate Tuple Definition */
typedef struct Albers_Equal_Area_Conic_Tuple_Structure
{
double easting; /* meters */
double northing; /* meters */
} Albers_Equal_Area_Conic_Tuple;
/* Azimuthal Equidistant Coordinate System Definition */
typedef struct Azimuthal_Equidistant_Structure
{
double origin_latitude; /* radians */
double central_meridian; /* radians */
double false_easting; /* meters */
double false_northing; /* meters */
} Azimuthal_Equidistant_Parameters;
/* Azimuthal Equidistant Coordinate Tuple Definition */
typedef struct Azimuthal_Equidistant_Tuple_Structure
{
double easting; /* meters */
double northing; /* meters */
} Azimuthal_Equidistant_Tuple;
/* BNG Coordinate Tuple Definition */
typedef struct BNG_Tuple_Structure
{
char string[21];
} BNG_Tuple;
/* Bonne Coordinate System Definition */
typedef struct Bonne_Structure
{
double origin_latitude; /* radians */
double central_meridian; /* radians */
double false_easting; /* meters */
double false_northing; /* meters */
} Bonne_Parameters;
/* Bonne Coordinate Tuple Definition */
typedef struct Bonne_Tuple_Structure
{
double easting; /* meters */
double northing; /* meters */
} Bonne_Tuple;
/* Cassini Coordinate System Definition */
typedef struct Cassini_Structure
{
double origin_latitude; /* radians */
double central_meridian; /* radians */
double false_easting; /* meters */
double false_northing; /* meters */
} Cassini_Parameters;
/* Cassini Coordinate Tuple Definition */
typedef struct Cassini_Tuple_Structure
{
double easting; /* meters */
double northing; /* meters */
} Cassini_Tuple;
/* Cylindrical Equal Area Coordinate System Definition */
typedef struct Cylindrical_Equal_Area_Structure
{
double origin_latitude; /* radians */
double central_meridian; /* radians */
double false_easting; /* meters */
double false_northing; /* meters */
} Cylindrical_Equal_Area_Parameters;
/* Cylindrical Equal Area Coordinate Tuple Definition */
typedef struct Cylindrical_Equal_Area_Tuple_Structure
{
double easting; /* meters */
double northing; /* meters */
} Cylindrical_Equal_Area_Tuple;
/* Eckert IV Coordinate System Definition */
typedef struct Eckert4_Structure
{
double central_meridian; /* radians */
double false_easting; /* meters */
double false_northing; /* meters */
} Eckert4_Parameters;
/* Eckert IV Coordinate Tuple Definition */
typedef struct Eckert4_Tuple_Structure
{
double easting; /* meters */
double northing; /* meters */
} Eckert4_Tuple;
/* Eckert VI Coordinate System Definition */
typedef struct Eckert6_Structure
{
double central_meridian; /* radians */
double false_easting; /* meters */
double false_northing; /* meters */
} Eckert6_Parameters;
/* Eckert VI Coordinate Tuple Definition */
typedef struct Eckert6_Tuple_Structure
{
double easting; /* meters */
double northing; /* meters */
} Eckert6_Tuple;
/* Equidistant Cylindrical Coordinate System Definition */
typedef struct Equidistant_Cylindrical_Structure
{
double std_parallel; /* radians */
double central_meridian; /* radians */
double false_easting; /* meters */
double false_northing; /* meters */
} Equidistant_Cylindrical_Parameters;
/* Equidistant Cylindrical Coordinate Tuple Definition */
typedef struct Equidistant_Cylindrical_Tuple_Structure
{
double easting; /* meters */
double northing; /* meters */
} Equidistant_Cylindrical_Tuple;
/* Gnomonic Coordinate System Definition */
typedef struct Gnomonic_Structure
{
double origin_latitude; /* radians */
double central_meridian; /* radians */
double false_easting; /* meters */
double false_northing; /* meters */
} Gnomonic_Parameters;
/* Gnomonic Coordinate Tuple Definition */
typedef struct Gnomonic_Tuple_Structure
{
double easting; /* meters */
double northing; /* meters */
} Gnomonic_Tuple;
/* Lambert Conformal Conic System Definition */
typedef struct Lambert_Conformal_Conic_Structure
{
double origin_latitude; /* radians */
double central_meridian; /* radians */
double std_parallel_1; /* radians */
double std_parallel_2; /* radians */
double false_easting; /* meters */
double false_northing; /* meters */
} Lambert_Conformal_Conic_Parameters;
/* Lambert Conformal Conic Coordinate Tuple Definition */
typedef struct Lambert_Conformal_Conic_Tuple_Structure
{
double easting; /* meters */
double northing; /* meters */
} Lambert_Conformal_Conic_Tuple;
/* Local Cartesian Coordinate System Definition */
typedef struct Local_Cartesian_Structure
{
double origin_latitude; /* radians */
double origin_longitude; /* radians */
double origin_height; /* meters */
double orientation; /* radians clockwise from north */
} Local_Cartesian_Parameters;
/* Local Cartesian Coordinate Tuple Definition */
typedef struct Local_Cartesian_Tuple_Structure
{
double x; /* meters */
double y; /* meters */
double z; /* meters */
} Local_Cartesian_Tuple;
/* Mercator Coordinate System Definition */
typedef struct Mercator_Structure
{
double origin_latitude; /* radians */
double central_meridian; /* radians */
double scale_factor; /* unitless */
double false_easting; /* meters */
double false_northing; /* meters */
} Mercator_Parameters;
/* Mercator Coordinate Tuple Definition */
typedef struct Mercator_Tuple_Structure
{
double easting; /* meters */
double northing; /* meters */
} Mercator_Tuple;
/* MGRS Coordinate Tuple Definition */
typedef struct MGRS_Tuple_Structure
{
char string[21];
} MGRS_Tuple;
/* Miller Cylindrical Coordinate System Definition */
typedef struct Miller_Cylindrical_Structure
{
double central_meridian; /* radians */
double false_easting; /* meters */
double false_northing; /* meters */
} Miller_Cylindrical_Parameters;
/* Miller Cylindrical Coordinate Tuple Definition */
typedef struct Miller_Cylindrical_Tuple_Structure
{
double easting; /* meters */
double northing; /* meters */
} Miller_Cylindrical_Tuple;
/* Mollweide Coordinate System Definition */
typedef struct Mollweide_Structure
{
double central_meridian; /* radians */
double false_easting; /* meters */
double false_northing; /* meters */
} Mollweide_Parameters;
/* Mollweide Coordinate Tuple Definition */
typedef struct Mollweide_Tuple_Structure
{
double easting; /* meters */
double northing; /* meters */
} Mollweide_Tuple;
/* Ney's (Modified Lambert Conformal Conic) System Definition */
typedef struct Neys_Structure
{
double origin_latitude; /* radians */
double central_meridian; /* radians */
double std_parallel_1; /* radians */
double false_easting; /* meters */
double false_northing; /* meters */
} Neys_Parameters;
/* Ney's (Modified Lambert Conformal Conic) Coordinate Tuple Definition */
typedef struct Neys_Tuple_Structure
{
double easting; /* meters */
double northing; /* meters */
} Neys_Tuple;
/* New Zealand Map Grid Coordinate Tuple Definition */
typedef struct NZMG_Tuple_Structure
{
double easting; /* meters */
double northing; /* meters */
} NZMG_Tuple;
/* Oblique Mercator Coordinate System Definition */
typedef struct Oblique_Mercator_Structure
{
double origin_latitude; /* radians */
double latitude_1; /* radians */
double longitude_1; /* radians */
double latitude_2; /* radians */
double longitude_2; /* radians */
double scale_factor; /* unitless */
double false_easting; /* meters */
double false_northing; /* meters */
} Oblique_Mercator_Parameters;
/* Oblique Mercator Coordinate Tuple Definition */
typedef struct Oblique_Mercator_Tuple_Structure
{
double easting; /* meters */
double northing; /* meters */
} Oblique_Mercator_Tuple;
/* Orthographic Coordinate System Definition */
typedef struct Orthographic_Structure
{
double origin_latitude; /* radians */
double central_meridian; /* radians */
double false_easting; /* meters */
double false_northing; /* meters */
} Orthographic_Parameters;
/* Orthographic Coordinate Tuple Definition */
typedef struct Orthographic_Tuple_Structure
{
double easting; /* meters */
double northing; /* meters */
} Orthographic_Tuple;
/* Polar Stereographic Coordinate System Definition */
typedef struct Polar_Stereo_Structure
{
double latitude_of_true_scale; /* radians */
double longitude_down_from_pole; /* radians */
double false_easting; /* meters */
double false_northing; /* meters */
} Polar_Stereo_Parameters;
/* Polar Stereographic Coordinate Tuple Definition */
typedef struct Polar_Stereo_Tuple_Structure
{
double easting; /* meters */
double northing; /* meters */
} Polar_Stereo_Tuple;
/* Polyconic Coordinate System Definition */
typedef struct Polyconic_Structure
{
double origin_latitude; /* radians */
double central_meridian; /* radians */
double false_easting; /* meters */
double false_northing; /* meters */
} Polyconic_Parameters;
/* Polyconic Coordinate Tuple Definition */
typedef struct Polyconic_Tuple_Structure
{
double easting; /* meters */
double northing; /* meters */
} Polyconic_Tuple;
/* Sinusoidal Coordinate System Definition */
typedef struct Sinusoidal_Structure
{
double central_meridian; /* radians */
double false_easting; /* meters */
double false_northing; /* meters */
} Sinusoidal_Parameters;
/* Sinusoidal Coordinate Tuple Definition */
typedef struct Sinusoidal_Tuple_Structure
{
double easting; /* meters */
double northing; /* meters */
} Sinusoidal_Tuple;
/* Stereographic Coordinate System Definition */
typedef struct Stereographic_Structure
{
double origin_latitude; /* radians */
double central_meridian; /* radians */
double false_easting; /* meters */
double false_northing; /* meters */
} Stereographic_Parameters;
/* Stereographic Coordinate Tuple Definition */
typedef struct Stereographic_Tuple_Structure
{
double easting; /* meters */
double northing; /* meters */
} Stereographic_Tuple;
/* Transverse Cylindrical Equal Area Coordinate System Definition */
typedef struct Transverse_Cylindrical_Equal_Area_Structure
{
double origin_latitude; /* radians */
double central_meridian; /* radians */
double scale_factor; /* unitless */
double false_easting; /* meters */
double false_northing; /* meters */
} Transverse_Cylindrical_Equal_Area_Parameters;
/* Transverse Cylindrical Equal Area Coordinate Tuple Definition */
typedef struct Transverse_Cylindrical_Equal_Area_Tuple_Structure
{
double easting; /* meters */
double northing; /* meters */
} Transverse_Cylindrical_Equal_Area_Tuple;
/* Transverse Mercator Coordinate System Definition */
typedef struct Transverse_Mercator_Structure
{
double origin_latitude; /* radians */
double central_meridian; /* radians */
double scale_factor; /* unitless */
double false_easting; /* meters */
double false_northing; /* meters */
} Transverse_Mercator_Parameters;
/* Transverse Mercator Coordinate Tuple Definition */
typedef struct Transverse_Mercator_Tuple_Structure
{
double easting; /* meters */
double northing; /* meters */
} Transverse_Mercator_Tuple;
/* UPS Coordinate Tuple Definition */
typedef struct UPS_Tuple_Structure
{
double easting; /* meters */
double northing; /* meters */
char hemisphere; /* "N" or "S" */
} UPS_Tuple;
/* UTM Coordinate System Definition */
typedef struct UTM_Structure
{
long zone; /* 1..60 */
long override; /* 0 or 1 */
} UTM_Parameters;
/* UTM Coordinate Tuple Definition */
typedef struct UTM_Tuple_Structure
{
double easting; /* meters */
double northing; /* meters */
long zone; /* 1..60 */
char hemisphere; /* "N" or "S" */
} UTM_Tuple;
/* Van Der Grinten Coordinate System Definition */
typedef struct Van_der_Grinten_Structure
{
double central_meridian; /* radians */
double false_easting; /* meters */
double false_northing; /* meters */
} Van_der_Grinten_Parameters;
/* Van Der Grinten Coordinate Tuple Definition */
typedef struct Van_der_Grinten_Tuple_Structure
{
double easting; /* meters */
double northing; /* meters */
} Van_der_Grinten_Tuple;
/***************************************************************************/
/*
* FUNCTION PROTOTYPES
* for ENGINE.C
*/
/* ensure proper linkage to c++ programs */
#ifdef __cplusplus
extern "C" {
#endif
long Initialize_Engine();
/*
* The function Initialize_Engine sets the initial state of the engine in
* in preparation for coordinate conversion and/or datum transformation
* operations.
*/
long Get_Coordinate_System_Count ( long *Count );
/*
* Count : The number of coordinate systems supported. (output)
*
* The function Get_Coordinate_System_Count returns the number of coordinate
* systems (including projections and grids) that are supported.
*/
long Get_Coordinate_System_Index ( const char *Code,
long *Index );
/*
* Code : 2-letter coordinate system code. (input)
* Index : Index of the coordinate system with the specified code
* (output)
*
* The function Get_Coordinate_System_Index returns the index of the coordinate
* system with the specified code. If the specified Code is found,
* ENGINE_NO_ERROR is returned, otherwise ENGINE_INVALID_CODE_ERROR is
* returned.
*/
long Get_Coordinate_System_Type ( const long Index,
Coordinate_Type *System );
/*
* Index : Index of a specific coordinate system (input)
* System : Type of the coordinate system referencd by index (output)
*
* The Function Get_Coordinate_System_Type returns the type of the coordinate
* system with the specified index. If theh index is valid, ENGINE_NO_ERROR is
* returned, otherwise ENGINE_INVALID_INDEX_ERROR is returned.
*/
long Get_Coordinate_System_Name ( const long Index,
char *Name );
/*
* Index : Index of a specific coordinate system (input)
* Name : Name of the coordinate system referencd by index (output)
*
* The Function Get_Coordinate_System_Name returns the name of the coordinate
* system with the specified index. If theh index is valid, ENGINE_NO_ERROR is
* returned, otherwise ENGINE_INVALID_INDEX_ERROR is returned.
*/
long Get_Coordinate_System_Code ( const long Index,
char *Code );
/*
* Index : Index of a specific coordinate system (input)
* Code : 2-letter coordinate system code. (output)
*
* The Function Get_Coordinate_System_Code returns the 2-letter code for the
* coordinate system with the specified index. If index is valid, ENGINE_NO_ERROR
* is returned, otherwise ENGINE_INVALID_INDEX_ERROR is returned.
*/
long Set_Coordinate_System
( const File_or_Interactive State,
const Input_or_Output Direction,
const Coordinate_Type System );
/*
* The function Set_Coordinate_System sets the coordinate system for the
* specified state to the specified coordinate system type.
* State : Indicates whether the coordinate system is to be used for
* interactive or file processing (input)
* Direction : Indicates whether the coordinate system is to be used for
* input or output (input)
* System : Identifies the coordinate system to be used (input)
*/
long Get_Coordinate_System
( const File_or_Interactive State,
const Input_or_Output Direction,
Coordinate_Type *System );
/*
* The function Get_Coordinate_System returns the current coordinate system
* type for the specified state.
* State : Indicates whether the coordinate system is to be used for
* interactive or file processing (input)
* Direction : Indicates whether the coordinate system is to be used for
* input or output (input)
* System : Identifies current coordinate system type (output)
*/
long Get_Datum_Count ( long *Count );
/*
* The function Get_Datum_Count returns the number of Datums in the table
* if the table was initialized without error.
*
* Count : number of datums in the datum table (output)
*/
long Get_Datum_Index ( const char *Code,
long *Index );
/*
* The function Get_Datum_Index returns the index of the datum with the
* specified code.
*
* Code : The datum code being searched for (input)
* Index : The index of the datum in the table with the (output)
* specified code
*/
long Get_Datum_Name ( const long Index,
char *Name );
/*
* The function Get_Datum_Name returns the name of the datum referenced by
* index.
*
* Index : The index of a given datum in the datum table (input)
* Name : The datum name of the datum referenced by index (output)
*/
long Get_Datum_Code ( const long Index,
char *Code );
/*
* The function Get_Datum_Code returns the 5-letter code of the datum
* referenced by index.
*
* Index : The index of a given datum in the datum table (input)
* Code : The datum code of the datum referenced by index (output)
*/
long Get_Datum_Ellipsoid_Code ( const long Index,
char *Code );
/*
* The function Get_Datum_Ellipsoid_Code returns the 2-letter ellipsoid code
* for the ellipsoid associated with the datum referenced by index.
*
* Index : The index of a given datum in the datum table (input)
* Code : The ellisoid code for the ellipsoid associated with the (output)
* datum referenced by index
*/
long Get_Datum_Type (const long Index,
Define_Datum_Type *Type);
/*
* The function Get_Datum_Type returns the type of the datum referenced by
* index.
*
* Index : The index of a given datum in the datum table. (input)
* Type : The type of datum referenced by index. (output)
*/
long Get_Datum_Seven_Parameters (const long Index,
double *Delta_X,
double *Delta_Y,
double *Delta_Z,
double *Rx,
double *Ry,
double *Rz,
double *Scale_Factor);
/*
* The function Get_Datum_Seven_Parameters returns the seven parameters
* for the datum referenced by index.
*
* Index : The index of a given datum in the datum table. (input)
* Delta_X : X translation in meters (output)
* Delta_Y : Y translation in meters (output)
* Delta_Z : Z translation in meters (output)
* Rx : X rotation in radians (output)
* Rx : Y rotation in radians (output)
* Ry : Z rotation in radians (output)
* Scale_Factor : Scale factor (output)
*/
long Get_Datum_Three_Parameters (const long Index,
double *Delta_X,
double *Delta_Y,
double *Delta_Z);
/*
* The function Get_Datum_Three_Parameters returns the three parameters
* for the datum referenced by index.
*
* Index : The index of a given datum in the datum table. (input)
* Delta_X : X translation in meters (output)
* Delta_Y : Y translation in meters (output)
* Delta_Z : Z translation in meters (output)
*/
long Get_Datum_Errors (const long Index,
double *Sigma_X,
double *Sigma_Y,
double *Sigma_Z);
/*
* The function Get_Datum_Errors returns the standard errors in X,Y, & Z
* for the datum referenced by index.
*
* Index : The index of a given datum in the datum table (input)
* Sigma_X : Standard error in X in meters (output)
* Sigma_Y : Standard error in Y in meters (output)
* Sigma_Z : Standard error in Z in meters (output)
*/
long Get_Datum_Valid_Rectangle (const long Index,
double *South_latitude,
double *North_latitude,
double *West_longitude,
double *East_longitude);
/*
* The function Get_Datum_Valid_Rectangle returns the edges of the validity
* rectangle for the datum referenced by index.
*
* Index : The index of a given datum in the datum table (input)
* South_latitude : Southern edge of validity rectangle in radians (output)
* North_latitude : Northern edge of validity rectangle in radians (output)
* West_longitude : Western edge of validity rectangle in radians (output)
* East_longitude : Eastern edge of validity rectangle in radians (output)
*/
long Check_Datum_User_Defined ( const long Index,
long *result );
/*
* Index : Index of a given datum in the datum table (input)
* result : Indicates whether specified datum is user defined (1)
* or not (0) (output)
*
* The function Check_Datum_User_Defined checks whether or not the specified datum is
* user defined. It returns 1 if the datum is user defined, and returns
* 0 otherwise.
*/
long Check_Valid_Datum(const long Index,
double latitude,
double longitude,
long *result);
/*
* The function Check_Valid_Datum checks whether or not the specified location is within the
* validity rectangle for the specified datum. It returns zero if the specified
* location is NOT within the validity rectangle, and returns 1 otherwise.
*
* Index : The index of a given datum in the datum table (input)
* latitude : Latitude of the location to be checked in radians (input)
* longitude : Longitude of the location to be checked in radians (input)
* result : Indicates whether location is inside (1) or outside (0)
* of the validity rectangle of the specified datum (output)
*/
long Set_Datum
( const File_or_Interactive State,
const Input_or_Output Direction,
const long Index );
/*
* The function Set_Datum sets the datum for the specified state to the
* datum corresponding to the specified index.
* State : Indicates whether the datum is to be used for interactive
* or file processing (input)
* Direction : Indicates whether the datum is to be used for input or
* output (input)
* Index : Identifies the index of the datum to be used (input)
*/
long Get_Datum
( const File_or_Interactive State,
const Input_or_Output Direction,
long *Index );
/*
* The function Get_Datum returns the index of the current datum for the
* specified state.
* State : Indicates whether the datum is to be used for interactive
* or file processing (input)
* Direction : Indicates whether the datum is to be used for input or
* output (input)
* Index : Identifies the index of the current datum (input)
*/
long Define_Datum ( const char *Code,
const char *Name,
const char *Ellipsoid_Code,
double Delta_X,
double Delta_Y,
double Delta_Z,
double Sigma_X,
double Sigma_Y,
double Sigma_Z,
double South_latitude,
double North_latitude,
double West_longitude,
double East_longitude);
/*
* Code : 5-letter new datum code. (input)
* Name : Name of the new datum (input)
* Ellipsoid_Code : 2-letter code for the associated ellipsoid (input)
* Delta_X : X translation to WGS84 in meters (input)
* Delta_Y : Y translation to WGS84 in meters (input)
* Delta_Z : Z translation to WGS84 in meters (input)
* Sigma_X : Standard error in X in meters (input)
* Sigma_Y : Standard error in Y in meters (input)
* Sigma_Z : Standard error in Z in meters (input)
* South_latitude : Southern edge of validity rectangle in radians(input)
* North_latitude : Northern edge of validity rectangle in radians(input)
* West_longitude : Western edge of validity rectangle in radians (input)
* East_longitude : Eastern edge of validity rectangle in radians (input)
*
* The function Define_Datum creates a new local (3-parameter) datum with the
* specified code, name, shift values, and standard error values. If the
* datum table has not been initialized, the specified code is already in use,
* or a new version of the 3-param.dat file cannot be created, an error code
* is returned, otherwise ENGINE_NO_ERROR is returned. Note that the indexes
* of all datums in the datum table may be changed by this function.
*/
long Remove_Datum (const char *Code);
/*
* Code : 5-letter new datum code. (input)
*
* The function Remove_Datum deletes a user defined local (3-parameter) datum
* with the specified code. If the datum table has not been initialized, or
* a new version of the 3-param.dat file cannot be created, an error code is
* returned, otherwise ENGINE_NO_ERROR is returned. Note that the indexes
* of all datums in the datum table may be changed by this function.
*/
long Get_Ellipsoid_Count ( long *Count );
/*
* Count : The number of ellipsoids in the ellipsoid table. (output)
*
* The function Get_Ellipsoid_Count returns the number of ellipsoids in the
* ellipsoid table. If the ellipsoid table has been initialized without error,
* ENGINE_NO_ERROR is returned, otherwise ENGINE_NOT_INITIALIZED_ERROR
* is returned.
*/
long Get_Ellipsoid_Index ( const char *Code,
long *Index );
/*
* Code : 2-letter ellipsoid code. (input)
* Index : Index of the ellipsoid in the ellipsoid table with the
* specified code (output)
*
* The function Get_Ellipsoid_Index returns the index of the ellipsoid in
* the ellipsoid table with the specified code. If ellipsoid code is found,
* ENGINE_NO_ERROR is returned, otherwise ENGINE_INVALID_CODE_ERROR is
* returned.
*/
long Get_Ellipsoid_Name ( const long Index,
char *Name );
/*
* Index : Index of a given ellipsoid.in the ellipsoid table with the
* specified index (input)
* Name : Name of the ellipsoid referencd by index (output)
*
* The Function Get_Ellipsoid_Name returns the name of the ellipsoid in
* the ellipsoid table with the specified index. If index is valid,
* ENGINE_NO_ERROR is returned, otherwise ENGINE_INVALID_INDEX_ERROR is
* returned.
*/
long Get_Ellipsoid_Parameters ( const long Index,
double *a,
double *f );
/*
* Index : Index of a given ellipsoid in the ellipsoid table (input)
* a : Semi-major axis, in meters, of ellipsoid (output)
* f : Flattening of ellipsoid. (output)
*
* The function Get_Ellipsoid_Parameters returns the semi-major axis
* and flattening for the ellipsoid with the specified index.
*/
long Get_Ellipsoid_Code ( const long Index,
char *Code );
/*
* Index : Index of a given ellipsoid in the ellipsoid table (input)
* Code : 2-letter ellipsoid code. (output)
*
* The Function Get_Ellipsoid_Code returns the 2-letter code for the
* ellipsoid in the ellipsoid table with the specified index. If index is
* valid, ENGINE_NO_ERROR is returned, otherwise ENGINE_INVALID_INDEX_ERROR
* is returned.
*/
long Get_Ellipsoid_Eccentricity2 ( const long Index,
double *e2 );
/*
* Index : Index of a given ellipsoid in the ellipsoid table (input)
* e2 : Square of eccentricity of ellipsoid (output)
*
* The function Get_Ellipsoid_Eccentricity2 returns the square of the
* eccentricity for the ellipsoid with the specified index.
*/
long Check_Ellipsoid_User_Defined ( const long Index,
long *result );
/*
* Index : Index of a given ellipsoid in the ellipsoid table (input)
* result : Indicates whether specified ellipsoid is user defined (1)
* or not (0) (output)
*
* The function Check_Ellipsoid_User_Defined returns 1 if the ellipsoid is user
* defined. Otherwise, 0 is returned.
*/
long Define_Ellipsoid (const char* Code,
const char* Name,
double a,
double f);
/*
* Code : 2-letter ellipsoid code. (input)
* Name : Name of the new ellipsoid (input)
* a : Semi-major axis, in meters, of new ellipsoid (input)
* f : Flattening of new ellipsoid. (input)
*
* The function Define_Ellipsoid creates a new ellipsoid with the specified
* code, name, and parameters. If the ellipsoid table has not been initialized,
* the specified code is already in use, or a new version of the ellips.dat
* file cannot be created, an error code is returned, otherwise ENGINE_NO_ERROR
* is returned. Note that the indexes of all ellipsoids in the ellipsoid
* table may be changed by this function.
*/
long Remove_Ellipsoid (const char* Code);
/*
* Code : 2-letter ellipsoid code. (input)
*
* The function Remove_Ellipsoid deletes a user defined ellipsoid with
* the specified Code. If the ellipsoid table has not been created,
* the specified code is in use by a user defined datum, or a new version
* of the ellips.dat file cannot be created, an error code is returned,
* otherwise ENGINE_NO_ERROR is returned. Note that the indexes of all
* ellipsoids in the ellipsoid table may be changed by this function.
*/
void Set_Precision(Precision Precis);
/*
* The function Set_Precision sets the output precision to the specified level.
* Precis : Indicates the desired level of precision (input)
*/
void Get_Precision(Precision *Precis);
/*
* The function Get_Precision returns the current level of precision.
* Precis : Indicates the current level of precision (output)
*/
long Set_Geocentric_Coordinates
( const File_or_Interactive State,
const Input_or_Output Direction,
const Geocentric_Tuple coordinates);
/*
* The function Set_Geocentric_Coordinates sets the Geocentric coordinates
* for the specified state..
* State : Indicates whether the coordinates are to be set for
* interactive or file processing (input)
* Direction : Indicates whether the coordinates are to be set for
* input or output (input)
* coordinates : Geocentric coordinate values to be set (input)
*/
long Get_Geocentric_Coordinates
( const File_or_Interactive State,
const Input_or_Output Direction,
Geocentric_Tuple *coordinates);
/*
* The function Get_Geocentric_Coordinates returns the Geocentric coordinates
* for the specified state..
* State : Indicates whether the coordinates are to be returned for
* interactive or file processing (input)
* Direction : Indicates whether the coordinates are to be returned for
* input or output (input)
* coordinates : Geocentric coordinate values to be returned (output)
*/
long Set_Geodetic_Params
( const File_or_Interactive State,
const Input_or_Output Direction,
const Geodetic_Parameters parameters);
/*
* The function Set_Geodetic_Params sets the Geodetic coordinate system
* parameters for the specified state.
* State : Indicates whether the parameters are to be set for
* interactive or file processing (input)
* Direction : Indicates whether the parameters are to be set for
* input or output (input)
* parameters : Geodetic parameters to be set (input)
*/
long Get_Geodetic_Params
( const File_or_Interactive State,
const Input_or_Output Direction,
Geodetic_Parameters *parameters);
/*
* The function Get_Geodetic_Params returns the Geodetic coordinate system
* parameters for the specified state.
* State : Indicates whether the parameters are to be returned for
* interactive or file processing (input)
* Direction : Indicates whether the parameters are to be returned for
* input or output (input)
* parameters : Geodetic parameters to be returned (output)
*/
long Set_Geodetic_Coordinates
( const File_or_Interactive State,
const Input_or_Output Direction,
const Geodetic_Tuple coordinates);
/*
* The function Set_Geodetic_Coordinates sets the Geodetic coordinates
* for the specified state..
* State : Indicates whether the parameters are to be set for
* interactive or file processing (input)
* Direction : Indicates whether the parameters are to be set for
* input or output (input)
* coordinates : Geodetic coordinate values to be set (input)
*/
long Get_Geodetic_Coordinates
( const File_or_Interactive State,
const Input_or_Output Direction,
Geodetic_Tuple *coordinates);
/*
* The function Get_Geodetic_Coordinates returns the Geodetic coordinates
* for the specified state..
* State : Indicates whether the coordinates are to be returned for
* interactive or file processing (input)
* Direction : Indicates whether the coordinates are to be returned for
* input or output (input)
* coordinates : Geodetic coordinate values to be returned (output)
*/
long Set_GEOREF_Coordinates
( const File_or_Interactive State,
const Input_or_Output Direction,
const GEOREF_Tuple coordinates);
/*
* The function Set_GEOREF_Coordinates sets the GEOREF coordinates
* for the specified state..
* State : Indicates whether the coordinates are to be set for
* interactive or file processing (input)
* Direction : Indicates whether the coordinates are to be set for
* input or output (input)
* coordinates : GEOREF coordinate string value to be set (input)
*/
long Get_GEOREF_Coordinates
( const File_or_Interactive State,
const Input_or_Output Direction,
GEOREF_Tuple *coordinates);
/*
* The function Get_GEOREF_Coordinates returns the GEOREF coordinates
* for the specified state.
* State : Indicates whether the coordinates are to be returned for
* interactive or file processing (input)
* Direction : Indicates whether the coordinates are to be returned for
* input or output (input)
* coordinates : GEOREF coordinate string value to be returned (output)
*/
long Set_Albers_Equal_Area_Conic_Params
( const File_or_Interactive State,
const Input_or_Output Direction,
const Albers_Equal_Area_Conic_Parameters parameters);
/*
* The function Set_Albers_Equal_Area_Conic_Params sets the Albers Equal
* Area Conic projection parameters for the specified state.
* State : Indicates whether the parameters are to be set for
* interactive or file processing (input)
* Direction : Indicates whether the parameters are to be set for
* input or output (input)
* parameters : Albers Equal Area Conic projection parameters to be set
* (input)
*/
long Get_Albers_Equal_Area_Conic_Params
( const File_or_Interactive State,
const Input_or_Output Direction,
Albers_Equal_Area_Conic_Parameters *parameters);
/*
* The function Get_Albers_Equal_Area_Conic_Params returns the Albers Equal
* Area Conic projection parameters for the specified state.
* State : Indicates whether the parameters are to be returned for
* interactive or file processing (input)
* Direction : Indicates whether the parameters are to be returned for
* input or output (input)
* parameters : Albers Equal Area Conic projection parameters to be returned
* (output)
*/
long Set_Albers_Equal_Area_Conic_Coordinates
( const File_or_Interactive State,
const Input_or_Output Direction,
const Albers_Equal_Area_Conic_Tuple coordinates);
/*
* The function Set_Albers_Equal_Area_Conic_Coordinates sets the Albers Equal
* Area Conic projection coordinates for the specified state.
* State : Indicates whether the coordinates are to be set for
* interactive or file processing (input)
* Direction : Indicates whether the coordinates are to be set for
* input or output (input)
* coordinates : Albers Equal Area Conic projection coordinates to be set
* (input)
*/
long Get_Albers_Equal_Area_Conic_Coordinates
( const File_or_Interactive State,
const Input_or_Output Direction,
Albers_Equal_Area_Conic_Tuple *coordinates);
/*
* The function Get_Albers_Equal_Area_Conic_Coordinates returns the Albers Equal
* Area Conic projection coordinates for the specified state.
* State : Indicates whether the coordinates are to be returned for
* interactive or file processing (input)
* Direction : Indicates whether the coordinates are to be returned for
* input or output (input)
* coordinates : Albers Equal Area Conic projection coordinates to be returned
* (output)
*/
long Set_Azimuthal_Equidistant_Params
( const File_or_Interactive State,
const Input_or_Output Direction,
const Azimuthal_Equidistant_Parameters parameters);
/*
* The function Set_Azimuthal_Equidistant_Params sets the Azimuthal Equidistant
* projection parameters for the specified state.
* State : Indicates whether the parameters are to be set for
* interactive or file processing (input)
* Direction : Indicates whether the parameters are to be set for
* input or output (input)
* parameters : Azimuthal Equidistant projection parameters to be set
* (input)
*/
long Get_Azimuthal_Equidistant_Params
( const File_or_Interactive State,
const Input_or_Output Direction,
Azimuthal_Equidistant_Parameters *parameters);
/*
* The function Get_Azimuthal_Equidistant_Params returns the Azimuthal Equidistant
* projection parameters for the specified state.
* State : Indicates whether the parameters are to be returned for
* interactive or file processing (input)
* Direction : Indicates whether the parameters are to be returned for
* input or output (input)
* parameters : Azimuthal Equidistant projection parameters to be returned
* (output)
*/
long Set_Azimuthal_Equidistant_Coordinates
( const File_or_Interactive State,
const Input_or_Output Direction,
const Azimuthal_Equidistant_Tuple coordinates);
/*
* The function Set_Azimuthal_Equidistant_Coordinates sets the Azimuthal Equidistant
* projection coordinates for the specified state.
* State : Indicates whether the coordinates are to be set for
* interactive or file processing (input)
* Direction : Indicates whether the coordinates are to be set for
* input or output (input)
* coordinates : Azimuthal Equidistant projection coordinates to be set
* (input)
*/
long Get_Azimuthal_Equidistant_Coordinates
( const File_or_Interactive State,
const Input_or_Output Direction,
Azimuthal_Equidistant_Tuple *coordinates);
/*
* The function Get_Azimuthal_Equidistant_Coordinates returns the Azimuthal Equidistant
* projection coordinates for the specified state.
* State : Indicates whether the coordinates are to be returned for
* interactive or file processing (input)
* Direction : Indicates whether the coordinates are to be returned for
* input or output (input)
* coordinates : Azimuthal Equidistant projection coordinates to be returned
* (output)
*/
long Set_BNG_Coordinates
( const File_or_Interactive State,
const Input_or_Output Direction,
const BNG_Tuple coordinates);
/*
* The function Set_BNG_Coordinates sets the BNG coordinates
* for the specified state..
* State : Indicates whether the coordinates are to be set for
* interactive or file processing (input)
* Direction : Indicates whether the coordinates are to be set for
* input or output (input)
* coordinates : BNG coordinate string value to be set (input)
*/
long Get_BNG_Coordinates
( const File_or_Interactive State,
const Input_or_Output Direction,
BNG_Tuple *coordinates);
/*
* The function Get_BNG_Coordinates returns the BNG coordinates
* for the specified state.
* State : Indicates whether the coordinates are to be returned for
* interactive or file processing (input)
* Direction : Indicates whether the coordinates are to be returned for
* input or output (input)
* coordinates : BNG coordinate string value to be returned (output)
*/
long Set_Bonne_Params
( const File_or_Interactive State,
const Input_or_Output Direction,
const Bonne_Parameters parameters);
/*
* The function Set_Bonne_Params sets the Bonne projection parameters
* for the specified state.
* State : Indicates whether the parameters are to be set for
* interactive or file processing (input)
* Direction : Indicates whether the parameters are to be set for
* input or output (input)
* parameters : Bonne projection parameters to be set (input)
*/
long Get_Bonne_Params
( const File_or_Interactive State,
const Input_or_Output Direction,
Bonne_Parameters *parameters);
/*
* The function Get_Bonne_Params returns the Bonne projection parameters
* for the specified state.
* State : Indicates whether the parameters are to be returned for
* interactive or file processing (input)
* Direction : Indicates whether the parameters are to be returned for
* input or output (input)
* parameters : Bonne projection parameters to be returned (output)
*/
long Set_Bonne_Coordinates
( const File_or_Interactive State,
const Input_or_Output Direction,
const Bonne_Tuple coordinates);
/*
* The function Set_Bonne_Coordinates sets the Bonne projection
* coordinates for the specified state.
* State : Indicates whether the coordinates are to be set for
* interactive or file processing (input)
* Direction : Indicates whether the coordinates are to be set for
* input or output (input)
* coordinates : Bonne projection coordinates to be set (input)
*/
long Get_Bonne_Coordinates
( const File_or_Interactive State,
const Input_or_Output Direction,
Bonne_Tuple *coordinates);
/*
* The function Get_Bonne_Coordinates returns the Bonne projection
* coordinates for the specified state.
* State : Indicates whether the coordinates are to be returned for
* interactive or file processing (input)
* Direction : Indicates whether the coordinates are to be returned for
* input or output (input)
* coordinates : Bonne projection coordinates to be returned (output)
*/
long Set_Cassini_Params
( const File_or_Interactive State,
const Input_or_Output Direction,
const Cassini_Parameters parameters);
/*