/*************************************************************************** * * Project: MGRS Converter * Purpose: Geotrans code for MGRS translation (slightly adapted) * Author: Unknown (NIMA) * *************************************************************************** *************************************************************************** * RSC IDENTIFIER: MGRS * * ABSTRACT * * This component converts between geodetic coordinates (latitude and * longitude) and Military Grid Reference System (MGRS) coordinates. * * ERROR HANDLING * * This component checks parameters for valid values. If an invalid value * is found, the error code 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: * * MGRS_NO_ERROR : No errors occurred in function * MGRS_LAT_ERROR : Latitude outside of valid range * (-90 to 90 degrees) * MGRS_LON_ERROR : Longitude outside of valid range * (-180 to 360 degrees) * MGRS_STR_ERROR : An MGRS string error: string too long, * too short, or badly formed * MGRS_PRECISION_ERROR : The precision must be between 0 and 5 * inclusive. * MGRS_A_ERROR : Semi-major axis less than or equal to zero * MGRS_INV_F_ERROR : Inverse flattening outside of valid range * (250 to 350) * MGRS_EASTING_ERROR : Easting outside of valid range * (100,000 to 900,000 meters for UTM) * (0 to 4,000,000 meters for UPS) * MGRS_NORTHING_ERROR : Northing outside of valid range * (0 to 10,000,000 meters for UTM) * (0 to 4,000,000 meters for UPS) * MGRS_ZONE_ERROR : Zone outside of valid range (1 to 60) * MGRS_HEMISPHERE_ERROR : Invalid hemisphere ('N' or 'S') * * REUSE NOTES * * MGRS is intended for reuse by any application that does conversions * between geodetic coordinates and MGRS coordinates. * * REFERENCES * * Further information on MGRS can be found in the Reuse Manual. * * MGRS 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 * * * ENVIRONMENT * * MGRS 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 * ---- ----------- * 16-11-94 Original Code * 15-09-99 Reengineered upper layers * 02-05-03 Corrected latitude band bug in GRID_UTM * 08-20-03 Reengineered lower layers */ /***************************************************************************/ /* * INCLUDES */ #include #include #include #include #include "mgrs.h" /* * ctype.h - Standard C character handling library * math.h - Standard C math library * stdio.h - Standard C input/output library * string.h - Standard C string handling library * ups.h - Universal Polar Stereographic (UPS) projection * utm.h - Universal Transverse Mercator (UTM) projection * mgrs.h - function prototype error checking */ /***************************************************************************/ /* * GLOBAL DECLARATIONS */ #define DEG_TO_RAD 0.017453292519943296 /* PI/180 */ #define RAD_TO_DEG 57.29577951308232088 /* 180/PI */ #define LETTER_A 0 /* ARRAY INDEX FOR LETTER A */ #define LETTER_B 1 /* ARRAY INDEX FOR LETTER B */ #define LETTER_C 2 /* ARRAY INDEX FOR LETTER C */ #define LETTER_D 3 /* ARRAY INDEX FOR LETTER D */ #define LETTER_E 4 /* ARRAY INDEX FOR LETTER E */ #define LETTER_F 5 /* ARRAY INDEX FOR LETTER E */ #define LETTER_G 6 /* ARRAY INDEX FOR LETTER H */ #define LETTER_H 7 /* ARRAY INDEX FOR LETTER H */ #define LETTER_I 8 /* ARRAY INDEX FOR LETTER I */ #define LETTER_J 9 /* ARRAY INDEX FOR LETTER J */ #define LETTER_K 10 /* ARRAY INDEX FOR LETTER J */ #define LETTER_L 11 /* ARRAY INDEX FOR LETTER L */ #define LETTER_M 12 /* ARRAY INDEX FOR LETTER M */ #define LETTER_N 13 /* ARRAY INDEX FOR LETTER N */ #define LETTER_O 14 /* ARRAY INDEX FOR LETTER O */ #define LETTER_P 15 /* ARRAY INDEX FOR LETTER P */ #define LETTER_Q 16 /* ARRAY INDEX FOR LETTER Q */ #define LETTER_R 17 /* ARRAY INDEX FOR LETTER R */ #define LETTER_S 18 /* ARRAY INDEX FOR LETTER S */ #define LETTER_T 19 /* ARRAY INDEX FOR LETTER S */ #define LETTER_U 20 /* ARRAY INDEX FOR LETTER U */ #define LETTER_V 21 /* ARRAY INDEX FOR LETTER V */ #define LETTER_W 22 /* ARRAY INDEX FOR LETTER W */ #define LETTER_X 23 /* ARRAY INDEX FOR LETTER X */ #define LETTER_Y 24 /* ARRAY INDEX FOR LETTER Y */ #define LETTER_Z 25 /* ARRAY INDEX FOR LETTER Z */ #define MGRS_LETTERS 3 /* NUMBER OF LETTERS IN MGRS */ #define ONEHT 100000.e0 /* ONE HUNDRED THOUSAND */ #define TWOMIL 2000000.e0 /* TWO MILLION */ #define TRUE 1 /* CONSTANT VALUE FOR TRUE VALUE */ #define FALSE 0 /* CONSTANT VALUE FOR FALSE VALUE */ #define PI_OVER_2 (M_PI / 2.0e0) #define MIN_EASTING 100000 #define MAX_EASTING 900000 #define MIN_NORTHING 0 #define MAX_NORTHING 10000000 #define MAX_PRECISION 5 /* Maximum precision of easting & northing */ #define MIN_UTM_LAT ((-80 * M_PI) / 180.0) /* -80 degrees in radians */ #define MAX_UTM_LAT ((84 * M_PI) / 180.0) /* 84 degrees in radians */ #define MIN_EAST_NORTH 0 #define MAX_EAST_NORTH 4000000 /* Ellipsoid parameters, default to WGS 84 */ static const double MGRS_a = 6378137.0; /* Semi-major axis of ellipsoid in meters */ static const double MGRS_f = 1 / 298.257223563; /* Flattening of ellipsoid */ #ifdef unused static const double MGRS_recpf = 298.257223563; #endif static const char MGRS_Ellipsoid_Code[3] = {'W', 'E', 0}; /* * CLARKE_1866 : Ellipsoid code for CLARKE_1866 * CLARKE_1880 : Ellipsoid code for CLARKE_1880 * BESSEL_1841 : Ellipsoid code for BESSEL_1841 * BESSEL_1841_NAMIBIA : Ellipsoid code for BESSEL 1841 (NAMIBIA) */ static const char *const CLARKE_1866 = "CC"; static const char *const CLARKE_1880 = "CD"; static const char *const BESSEL_1841 = "BR"; static const char *const BESSEL_1841_NAMIBIA = "BN"; typedef struct Latitude_Band_Value { /* cppcheck-suppress unusedStructMember */ long letter; /* letter representing latitude band */ double min_northing; /* minimum northing for latitude band */ /* cppcheck-suppress unusedStructMember */ double north; /* upper latitude for latitude band */ /* cppcheck-suppress unusedStructMember */ double south; /* lower latitude for latitude band */ } Latitude_Band; static const Latitude_Band Latitude_Band_Table[20] = { {LETTER_C, 1100000.0, -72.0, -80.5}, {LETTER_D, 2000000.0, -64.0, -72.0}, {LETTER_E, 2800000.0, -56.0, -64.0}, {LETTER_F, 3700000.0, -48.0, -56.0}, {LETTER_G, 4600000.0, -40.0, -48.0}, {LETTER_H, 5500000.0, -32.0, -40.0}, {LETTER_J, 6400000.0, -24.0, -32.0}, {LETTER_K, 7300000.0, -16.0, -24.0}, {LETTER_L, 8200000.0, -8.0, -16.0}, {LETTER_M, 9100000.0, 0.0, -8.0}, {LETTER_N, 0.0, 8.0, 0.0}, {LETTER_P, 800000.0, 16.0, 8.0}, {LETTER_Q, 1700000.0, 24.0, 16.0}, {LETTER_R, 2600000.0, 32.0, 24.0}, {LETTER_S, 3500000.0, 40.0, 32.0}, {LETTER_T, 4400000.0, 48.0, 40.0}, {LETTER_U, 5300000.0, 56.0, 48.0}, {LETTER_V, 6200000.0, 64.0, 56.0}, {LETTER_W, 7000000.0, 72.0, 64.0}, {LETTER_X, 7900000.0, 84.5, 72.0}}; typedef struct UPS_Constant_Value { /* cppcheck-suppress unusedStructMember */ long letter; /* letter representing latitude band */ long ltr2_low_value; /* 2nd letter range - high number */ long ltr2_high_value; /* 2nd letter range - low number */ long ltr3_high_value; /* 3rd letter range - high number (UPS) */ double false_easting; /* False easting based on 2nd letter */ double false_northing; /* False northing based on 3rd letter */ } UPS_Constant; static const UPS_Constant UPS_Constant_Table[4] = { {LETTER_A, LETTER_J, LETTER_Z, LETTER_Z, 800000.0, 800000.0}, {LETTER_B, LETTER_A, LETTER_R, LETTER_Z, 2000000.0, 800000.0}, {LETTER_Y, LETTER_J, LETTER_Z, LETTER_P, 800000.0, 1300000.0}, {LETTER_Z, LETTER_A, LETTER_J, LETTER_P, 2000000.0, 1300000.0}}; /***************************************************************************/ /* * FUNCTIONS */ static long Get_Latitude_Band_Min_Northing(long letter, double *min_northing) /* * The function Get_Latitude_Band_Min_Northing receives a latitude band letter * and uses the Latitude_Band_Table to determine the minimum northing for that * latitude band letter. * * letter : Latitude band letter (input) * min_northing : Minimum northing for that letter (output) */ { /* Get_Latitude_Band_Min_Northing */ long error_code = MGRS_NO_ERROR; if ((letter >= LETTER_C) && (letter <= LETTER_H)) *min_northing = Latitude_Band_Table[letter - 2].min_northing; else if ((letter >= LETTER_J) && (letter <= LETTER_N)) *min_northing = Latitude_Band_Table[letter - 3].min_northing; else if ((letter >= LETTER_P) && (letter <= LETTER_X)) *min_northing = Latitude_Band_Table[letter - 4].min_northing; else error_code |= MGRS_STRING_ERROR; return error_code; } /* Get_Latitude_Band_Min_Northing */ #ifdef unused static long Get_Latitude_Range(long letter, double *north, double *south) /* * The function Get_Latitude_Range receives a latitude band letter * and uses the Latitude_Band_Table to determine the latitude band * boundaries for that latitude band letter. * * letter : Latitude band letter (input) * north : Northern latitude boundary for that letter (output) * north : Southern latitude boundary for that letter (output) */ { /* Get_Latitude_Range */ long error_code = MGRS_NO_ERROR; if ((letter >= LETTER_C) && (letter <= LETTER_H)) { *north = Latitude_Band_Table[letter - 2].north * DEG_TO_RAD; *south = Latitude_Band_Table[letter - 2].south * DEG_TO_RAD; } else if ((letter >= LETTER_J) && (letter <= LETTER_N)) { *north = Latitude_Band_Table[letter - 3].north * DEG_TO_RAD; *south = Latitude_Band_Table[letter - 3].south * DEG_TO_RAD; } else if ((letter >= LETTER_P) && (letter <= LETTER_X)) { *north = Latitude_Band_Table[letter - 4].north * DEG_TO_RAD; *south = Latitude_Band_Table[letter - 4].south * DEG_TO_RAD; } else error_code |= MGRS_STRING_ERROR; return error_code; } /* Get_Latitude_Range */ #endif #ifdef unusued static long Get_Latitude_Letter(double latitude, int *letter) /* * The function Get_Latitude_Letter receives a latitude value * and uses the Latitude_Band_Table to determine the latitude band * letter for that latitude. * * latitude : Latitude (input) * letter : Latitude band letter (output) */ { /* Get_Latitude_Letter */ double temp = 0.0; long error_code = MGRS_NO_ERROR; double lat_deg = latitude * RAD_TO_DEG; if (lat_deg >= 72 && lat_deg < 84.5) *letter = LETTER_X; else if (lat_deg > -80.5 && lat_deg < 72) { temp = ((latitude + (80.0 * DEG_TO_RAD)) / (8.0 * DEG_TO_RAD)) + 1.0e-12; *letter = Latitude_Band_Table[(int)temp].letter; } else error_code |= MGRS_LAT_ERROR; return error_code; } /* Get_Latitude_Letter */ #endif #ifdef unused static long Check_Zone(char *MGRS, long *zone_exists) /* * The function Check_Zone receives an MGRS coordinate string. * If a zone is given, TRUE is returned. Otherwise, FALSE * is returned. * * MGRS : MGRS coordinate string (input) * zone_exists : TRUE if a zone is given, * FALSE if a zone is not given (output) */ { /* Check_Zone */ int i = 0; int j = 0; int num_digits = 0; long error_code = MGRS_NO_ERROR; /* skip any leading blanks */ while (MGRS[i] == ' ') i++; j = i; while (isdigit((unsigned char)MGRS[i])) i++; num_digits = i - j; if (num_digits <= 2) if (num_digits > 0) *zone_exists = TRUE; else *zone_exists = FALSE; else error_code |= MGRS_STRING_ERROR; return error_code; } /* Check_Zone */ #endif static long Round_MGRS(double value) /* * The function Round_MGRS rounds the input value to the * nearest integer, using the standard engineering rule. * The rounded integer value is then returned. * * value : Value to be rounded (input) */ { /* Round_MGRS */ double ivalue; long ival; double fraction = modf(value, &ivalue); ival = (long)(ivalue); if ((fraction > 0.5) || ((fraction == 0.5) && (ival % 2 == 1))) ival++; return (ival); } /* Round_MGRS */ static long Make_MGRS_String(char *MGRS, long Zone, int Letters[MGRS_LETTERS], double Easting, double Northing, long Precision) /* * The function Make_MGRS_String constructs an MGRS string * from its component parts. * * MGRS : MGRS coordinate string (output) * Zone : UTM Zone (input) * Letters : MGRS coordinate string letters (input) * Easting : Easting value (input) * Northing : Northing value (input) * Precision : Precision level of MGRS string (input) */ { /* Make_MGRS_String */ long i; long j; double divisor; long east; long north; char alphabet[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"; long error_code = MGRS_NO_ERROR; i = 0; if (Zone) i = sprintf(MGRS + i, "%2.2ld", Zone); else memcpy(MGRS, " ", 2); // 2 spaces for (j = 0; j < 3; j++) MGRS[i++] = alphabet[Letters[j]]; divisor = pow(10.0, (5 - Precision)); Easting = fmod(Easting, 100000.0); if (Easting >= 99999.5) Easting = 99999.0; east = (long)(Easting / divisor); i += sprintf(MGRS + i, "%*.*ld", (int)Precision, (int)Precision, east); Northing = fmod(Northing, 100000.0); if (Northing >= 99999.5) Northing = 99999.0; north = (long)(Northing / divisor); /*i += */ sprintf(MGRS + i, "%*.*ld", (int)Precision, (int)Precision, north); return (error_code); } /* Make_MGRS_String */ static long Break_MGRS_String(char *MGRS, long *Zone, long Letters[MGRS_LETTERS], double *Easting, double *Northing, long *Precision) /* * The function Break_MGRS_String breaks down an MGRS * coordinate string into its component parts. * * MGRS : MGRS coordinate string (input) * Zone : UTM Zone (output) * Letters : MGRS coordinate string letters (output) * Easting : Easting value (output) * Northing : Northing value (output) * Precision : Precision level of MGRS string (output) */ { /* Break_MGRS_String */ long num_digits; long num_letters; long i = 0; long j = 0; long error_code = MGRS_NO_ERROR; while (MGRS[i] == ' ') i++; /* skip any leading blanks */ j = i; while (isdigit((unsigned char)MGRS[i])) i++; num_digits = i - j; if (num_digits <= 2) if (num_digits > 0) { char zone_string[3]; /* get zone */ strncpy(zone_string, MGRS + j, 2); zone_string[2] = 0; sscanf(zone_string, "%ld", Zone); if ((*Zone < 1) || (*Zone > 60)) error_code |= MGRS_STRING_ERROR; } else *Zone = 0; else error_code |= MGRS_STRING_ERROR; j = i; while (isalpha((unsigned char)MGRS[i])) i++; num_letters = i - j; if (num_letters == 3) { /* get letters */ Letters[0] = (toupper((unsigned char)MGRS[j]) - (long)'A'); if ((Letters[0] == LETTER_I) || (Letters[0] == LETTER_O)) error_code |= MGRS_STRING_ERROR; Letters[1] = (toupper((unsigned char)MGRS[j + 1]) - (long)'A'); if ((Letters[1] == LETTER_I) || (Letters[1] == LETTER_O)) error_code |= MGRS_STRING_ERROR; Letters[2] = (toupper((unsigned char)MGRS[j + 2]) - (long)'A'); if ((Letters[2] == LETTER_I) || (Letters[2] == LETTER_O)) error_code |= MGRS_STRING_ERROR; } else error_code |= MGRS_STRING_ERROR; j = i; while (isdigit((unsigned char)MGRS[i])) i++; num_digits = i - j; if ((num_digits <= 10) && (num_digits % 2 == 0)) { long n; char east_string[6]; char north_string[6]; long east; long north; double multiplier; /* get easting & northing */ n = num_digits / 2; *Precision = n; if (n > 0) { strncpy(east_string, MGRS + j, n); east_string[n] = 0; sscanf(east_string, "%ld", &east); strncpy(north_string, MGRS + j + n, n); north_string[n] = 0; sscanf(north_string, "%ld", &north); multiplier = pow(10.0, 5 - n); *Easting = east * multiplier; *Northing = north * multiplier; } else { *Easting = 0.0; *Northing = 0.0; } } else error_code |= MGRS_STRING_ERROR; return (error_code); } /* Break_MGRS_String */ static void Get_Grid_Values(long zone, long *ltr2_low_value, long *ltr2_high_value, double *false_northing) /* * The function Get_Grid_Values sets the letter range used for * the 2nd letter in the MGRS coordinate string, based on the set * number of the utm zone. It also sets the false northing using a * value of A for the second letter of the grid square, based on * the grid pattern and set number of the utm zone. * * zone : Zone number (input) * ltr2_low_value : 2nd letter low number (output) * ltr2_high_value : 2nd letter high number (output) * false_northing : False northing (output) */ { /* BEGIN Get_Grid_Values */ long set_number; /* Set number (1-6) based on UTM zone number */ long aa_pattern; /* Pattern based on ellipsoid code */ set_number = zone % 6; if (!set_number) set_number = 6; if (!strcmp(MGRS_Ellipsoid_Code, CLARKE_1866) || !strcmp(MGRS_Ellipsoid_Code, CLARKE_1880) || !strcmp(MGRS_Ellipsoid_Code, BESSEL_1841) || !strcmp(MGRS_Ellipsoid_Code, BESSEL_1841_NAMIBIA)) aa_pattern = FALSE; else aa_pattern = TRUE; if ((set_number == 1) || (set_number == 4)) { *ltr2_low_value = LETTER_A; *ltr2_high_value = LETTER_H; } else if ((set_number == 2) || (set_number == 5)) { *ltr2_low_value = LETTER_J; *ltr2_high_value = LETTER_R; } else if ((set_number == 3) || (set_number == 6)) { *ltr2_low_value = LETTER_S; *ltr2_high_value = LETTER_Z; } /* False northing at A for second letter of grid square */ if (aa_pattern) { if ((set_number % 2) == 0) *false_northing = 1500000.0; else *false_northing = 0.0; } else { if ((set_number % 2) == 0) *false_northing = 500000.0; else *false_northing = 1000000.00; } } /* END OF Get_Grid_Values */ #ifdef unused static long UTM_To_MGRS(long Zone, double Latitude, double Easting, double Northing, long Precision, char *MGRS) /* * The function UTM_To_MGRS calculates an MGRS coordinate string * based on the zone, latitude, easting and northing. * * Zone : Zone number (input) * Latitude : Latitude in radians (input) * Easting : Easting (input) * Northing : Northing (input) * Precision : Precision (input) * MGRS : MGRS coordinate string (output) */ { /* BEGIN UTM_To_MGRS */ double false_northing; /* False northing for 3rd letter */ double grid_easting; /* Easting used to derive 2nd letter of MGRS */ double grid_northing; /* Northing used to derive 3rd letter of MGRS */ long ltr2_low_value; /* 2nd letter range - low number */ long ltr2_high_value; /* 2nd letter range - high number */ int letters[MGRS_LETTERS]; /* Number location of 3 letters in alphabet */ double divisor; long error_code = MGRS_NO_ERROR; /* Round easting and northing values */ divisor = pow(10.0, (5 - Precision)); Easting = Round_MGRS(Easting / divisor) * divisor; Northing = Round_MGRS(Northing / divisor) * divisor; Get_Grid_Values(Zone, <r2_low_value, <r2_high_value, &false_northing); error_code = Get_Latitude_Letter(Latitude, &letters[0]); if (!error_code) { grid_northing = Northing; if (grid_northing == 1.e7) grid_northing = grid_northing - 1.0; while (grid_northing >= TWOMIL) { grid_northing = grid_northing - TWOMIL; } grid_northing = grid_northing - false_northing; if (grid_northing < 0.0) grid_northing = grid_northing + TWOMIL; letters[2] = (long)(grid_northing / ONEHT); if (letters[2] > LETTER_H) letters[2] = letters[2] + 1; if (letters[2] > LETTER_N) letters[2] = letters[2] + 1; grid_easting = Easting; if (((letters[0] == LETTER_V) && (Zone == 31)) && (grid_easting == 500000.0)) grid_easting = grid_easting - 1.0; /* SUBTRACT 1 METER */ letters[1] = ltr2_low_value + ((long)(grid_easting / ONEHT) - 1); if ((ltr2_low_value == LETTER_J) && (letters[1] > LETTER_N)) letters[1] = letters[1] + 1; Make_MGRS_String(MGRS, Zone, letters, Easting, Northing, Precision); } return error_code; } /* END UTM_To_MGRS */ #endif #ifdef unused long Set_MGRS_Parameters(double a, double f, char *Ellipsoid_Code) /* * The function SET_MGRS_PARAMETERS receives the ellipsoid parameters and sets * the corresponding state variables. If any errors occur, the error code(s) * are returned by the function, otherwise MGRS_NO_ERROR is returned. * * a : Semi-major axis of ellipsoid in meters (input) * f : Flattening of ellipsoid (input) * Ellipsoid_Code : 2-letter code for ellipsoid (input) */ { /* Set_MGRS_Parameters */ double inv_f = 1 / f; long Error_Code = MGRS_NO_ERROR; if (a <= 0.0) { /* Semi-major axis must be greater than zero */ Error_Code |= MGRS_A_ERROR; } if ((inv_f < 250) || (inv_f > 350)) { /* Inverse flattening must be between 250 and 350 */ Error_Code |= MGRS_INV_F_ERROR; } if (!Error_Code) { /* no errors */ MGRS_a = a; MGRS_f = f; MGRS_recpf = inv_f; strncpy(MGRS_Ellipsoid_Code, Ellipsoid_Code, sizeof(MGRS_Ellipsoid_Code)); MGRS_Ellipsoid_Code[sizeof(MGRS_Ellipsoid_Code) - 1] = '\0'; } return (Error_Code); } /* Set_MGRS_Parameters */ #endif void Get_MGRS_Parameters(double *a, double *f, char *Ellipsoid_Code) /* * The function Get_MGRS_Parameters returns the current ellipsoid * parameters. * * a : Semi-major axis of ellipsoid, in meters (output) * f : Flattening of ellipsoid (output) * Ellipsoid_Code : 2-letter code for ellipsoid (output) */ { /* Get_MGRS_Parameters */ *a = MGRS_a; *f = MGRS_f; strcpy(Ellipsoid_Code, MGRS_Ellipsoid_Code); return; } /* Get_MGRS_Parameters */ #ifndef GDAL_COMPILATION long Convert_UTM_To_MGRS(long Zone, char Hemisphere, double Easting, double Northing, long Precision, char *MGRS) /* * The function Convert_UTM_To_MGRS converts UTM (zone, easting, and * northing) coordinates to an MGRS coordinate string, according to the * current ellipsoid parameters. If any errors occur, the error code(s) * are returned by the function, otherwise MGRS_NO_ERROR is returned. * * Zone : UTM zone (input) * Hemisphere : North or South hemisphere (input) * Easting : Easting (X) in meters (input) * Northing : Northing (Y) in meters (input) * Precision : Precision level of MGRS string (input) * MGRS : MGRS coordinate string (output) */ { /* Convert_UTM_To_MGRS */ double latitude; /* Latitude of UTM point */ double longitude; /* Longitude of UTM point */ /*long temp_error = MGRS_NO_ERROR; */ long error_code = MGRS_NO_ERROR; if ((Zone < 1) || (Zone > 60)) error_code |= MGRS_ZONE_ERROR; if ((Hemisphere != 'S') && (Hemisphere != 'N')) error_code |= MGRS_HEMISPHERE_ERROR; if ((Easting < MIN_EASTING) || (Easting > MAX_EASTING)) error_code |= MGRS_EASTING_ERROR; if ((Northing < MIN_NORTHING) || (Northing > MAX_NORTHING)) error_code |= MGRS_NORTHING_ERROR; if ((Precision < 0) || (Precision > MAX_PRECISION)) error_code |= MGRS_PRECISION_ERROR; if (!error_code) { Set_UTM_Parameters(MGRS_a, MGRS_f, 0); /*temp_error =*/Convert_UTM_To_Geodetic( Zone, Hemisphere, Easting, Northing, &latitude, &longitude); /* Special check for rounding to (truncated) eastern edge of zone 31V */ if ((Zone == 31) && (latitude >= 56.0 * DEG_TO_RAD) && (latitude < 64.0 * DEG_TO_RAD) && (longitude >= 3.0 * DEG_TO_RAD)) { /* Reconvert to UTM zone 32 */ Set_UTM_Parameters(MGRS_a, MGRS_f, 32); /*temp_error =*/Convert_Geodetic_To_UTM( latitude, longitude, &Zone, &Hemisphere, &Easting, &Northing); } error_code = UTM_To_MGRS(Zone, latitude, Easting, Northing, Precision, MGRS); } return (error_code); } /* Convert_UTM_To_MGRS */ #endif long Convert_MGRS_To_UTM(char *MGRS, long *Zone, char *Hemisphere, double *Easting, double *Northing) /* * The function Convert_MGRS_To_UTM converts an MGRS coordinate string * to UTM projection (zone, hemisphere, easting and northing) coordinates * according to the current ellipsoid parameters. If any errors occur, * the error code(s) are returned by the function, otherwise UTM_NO_ERROR * is returned. * * MGRS : MGRS coordinate string (input) * Zone : UTM zone (output) * Hemisphere : North or South hemisphere (output) * Easting : Easting (X) in meters (output) * Northing : Northing (Y) in meters (output) */ { /* Convert_MGRS_To_UTM */ double scaled_min_northing; double min_northing; long ltr2_low_value = 0; long ltr2_high_value = 0; double false_northing; double grid_easting; /* Easting for 100,000 meter grid square */ double grid_northing; /* Northing for 100,000 meter grid square */ long letters[MGRS_LETTERS]; long in_precision; #ifndef GDAL_COMPILATION double upper_lat_limit; /* North latitude limits based on 1st letter */ double lower_lat_limit; /* South latitude limits based on 1st letter */ double latitude = 0.0; double longitude = 0.0; double divisor = 1.0; #endif long error_code = MGRS_NO_ERROR; error_code = Break_MGRS_String(MGRS, Zone, letters, Easting, Northing, &in_precision); if (!*Zone) error_code |= MGRS_STRING_ERROR; else { if (!error_code) { if ((letters[0] == LETTER_X) && ((*Zone == 32) || (*Zone == 34) || (*Zone == 36))) error_code |= MGRS_STRING_ERROR; else { if (letters[0] < LETTER_N) *Hemisphere = 'S'; else *Hemisphere = 'N'; Get_Grid_Values(*Zone, <r2_low_value, <r2_high_value, &false_northing); /* Check that the second letter of the MGRS string is within * the range of valid second letter values * Also check that the third letter is valid */ if ((letters[1] < ltr2_low_value) || (letters[1] > ltr2_high_value) || (letters[2] > LETTER_V)) error_code |= MGRS_STRING_ERROR; if (!error_code) { grid_northing = (double)(letters[2]) * ONEHT + false_northing; grid_easting = (double)((letters[1]) - ltr2_low_value + 1) * ONEHT; if ((ltr2_low_value == LETTER_J) && (letters[1] > LETTER_O)) grid_easting = grid_easting - ONEHT; if (letters[2] > LETTER_O) grid_northing = grid_northing - ONEHT; if (letters[2] > LETTER_I) grid_northing = grid_northing - ONEHT; if (grid_northing >= TWOMIL) grid_northing = grid_northing - TWOMIL; error_code = Get_Latitude_Band_Min_Northing(letters[0], &min_northing); if (!error_code) { scaled_min_northing = min_northing; while (scaled_min_northing >= TWOMIL) { scaled_min_northing = scaled_min_northing - TWOMIL; } grid_northing = grid_northing - scaled_min_northing; if (grid_northing < 0.0) grid_northing = grid_northing + TWOMIL; grid_northing = min_northing + grid_northing; *Easting = grid_easting + *Easting; *Northing = grid_northing + *Northing; #ifndef GDAL_COMPILATION /* check that point is within Zone Letter bounds */ error_code = Set_UTM_Parameters(MGRS_a, MGRS_f, *Zone); if (!error_code) { error_code = Convert_UTM_To_Geodetic( *Zone, *Hemisphere, *Easting, *Northing, &latitude, &longitude); if (!error_code) { divisor = pow(10.0, in_precision); error_code = Get_Latitude_Range( letters[0], &upper_lat_limit, &lower_lat_limit); if (!error_code) { if (!(((lower_lat_limit - DEG_TO_RAD / divisor) <= latitude) && (latitude <= (upper_lat_limit + DEG_TO_RAD / divisor)))) error_code |= MGRS_LAT_ERROR; } } } #endif /* notdef */ } } } } } return (error_code); } /* Convert_MGRS_To_UTM */ long Convert_UPS_To_MGRS(char Hemisphere, double Easting, double Northing, long Precision, char *MGRS) /* * The function Convert_UPS_To_MGRS converts UPS (hemisphere, easting, * and northing) coordinates to an MGRS coordinate string according to * the current ellipsoid parameters. If any errors occur, the error * code(s) are returned by the function, otherwise UPS_NO_ERROR is * returned. * * Hemisphere : Hemisphere either 'N' or 'S' (input) * Easting : Easting/X in meters (input) * Northing : Northing/Y in meters (input) * Precision : Precision level of MGRS string (input) * MGRS : MGRS coordinate string (output) */ { /* Convert_UPS_To_MGRS */ double false_easting; /* False easting for 2nd letter */ double false_northing; /* False northing for 3rd letter */ double grid_easting; /* Easting used to derive 2nd letter of MGRS */ double grid_northing; /* Northing used to derive 3rd letter of MGRS */ long ltr2_low_value; /* 2nd letter range - low number */ int letters[MGRS_LETTERS] = { 0}; /* Number location of 3 letters in alphabet */ double divisor; int l_index = 0; long error_code = MGRS_NO_ERROR; if ((Hemisphere != 'N') && (Hemisphere != 'S')) error_code |= MGRS_HEMISPHERE_ERROR; if ((Easting < MIN_EAST_NORTH) || (Easting > MAX_EAST_NORTH)) error_code |= MGRS_EASTING_ERROR; if ((Northing < MIN_EAST_NORTH) || (Northing > MAX_EAST_NORTH)) error_code |= MGRS_NORTHING_ERROR; if ((Precision < 0) || (Precision > MAX_PRECISION)) error_code |= MGRS_PRECISION_ERROR; if (!error_code) { divisor = pow(10.0, (5 - Precision)); Easting = Round_MGRS(Easting / divisor) * divisor; Northing = Round_MGRS(Northing / divisor) * divisor; if (Hemisphere == 'N') { if (Easting >= TWOMIL) letters[0] = LETTER_Z; else letters[0] = LETTER_Y; l_index = letters[0] - 22; ltr2_low_value = UPS_Constant_Table[l_index].ltr2_low_value; false_easting = UPS_Constant_Table[l_index].false_easting; false_northing = UPS_Constant_Table[l_index].false_northing; } else { if (Easting >= TWOMIL) letters[0] = LETTER_B; else letters[0] = LETTER_A; ltr2_low_value = UPS_Constant_Table[letters[0]].ltr2_low_value; false_easting = UPS_Constant_Table[letters[0]].false_easting; false_northing = UPS_Constant_Table[letters[0]].false_northing; } grid_northing = Northing; grid_northing = grid_northing - false_northing; letters[2] = (int)(grid_northing / ONEHT); if (letters[2] > LETTER_H) letters[2] = letters[2] + 1; if (letters[2] > LETTER_N) letters[2] = letters[2] + 1; grid_easting = Easting; grid_easting = grid_easting - false_easting; letters[1] = (int)(ltr2_low_value + ((long)(grid_easting / ONEHT))); if (Easting < TWOMIL) { if (letters[1] > LETTER_L) letters[1] = letters[1] + 3; if (letters[1] > LETTER_U) letters[1] = letters[1] + 2; } else { if (letters[1] > LETTER_C) letters[1] = letters[1] + 2; if (letters[1] > LETTER_H) letters[1] = letters[1] + 1; if (letters[1] > LETTER_L) letters[1] = letters[1] + 3; } Make_MGRS_String(MGRS, 0, letters, Easting, Northing, Precision); } return (error_code); } /* Convert_UPS_To_MGRS */ long Convert_MGRS_To_UPS(char *MGRS, char *Hemisphere, double *Easting, double *Northing) /* * The function Convert_MGRS_To_UPS converts an MGRS coordinate string * to UPS (hemisphere, easting, and northing) coordinates, according * to the current ellipsoid parameters. If any errors occur, the error * code(s) are returned by the function, otherwise UPS_NO_ERROR is returned. * * MGRS : MGRS coordinate string (input) * Hemisphere : Hemisphere either 'N' or 'S' (output) * Easting : Easting/X in meters (output) * Northing : Northing/Y in meters (output) */ { /* Convert_MGRS_To_UPS */ long ltr2_high_value; /* 2nd letter range - high number */ long ltr3_high_value; /* 3rd letter range - high number (UPS) */ long ltr2_low_value; /* 2nd letter range - low number */ double false_easting; /* False easting for 2nd letter */ double false_northing; /* False northing for 3rd letter */ double grid_easting; /* easting for 100,000 meter grid square */ double grid_northing; /* northing for 100,000 meter grid square */ long zone = 0; long letters[MGRS_LETTERS]; long in_precision; int l_index = 0; long error_code = MGRS_NO_ERROR; error_code = Break_MGRS_String(MGRS, &zone, letters, Easting, Northing, &in_precision); if (zone) error_code |= MGRS_STRING_ERROR; else { if (!error_code) { if (letters[0] >= LETTER_Y) { *Hemisphere = 'N'; l_index = (int)(letters[0] - 22); ltr2_low_value = UPS_Constant_Table[l_index].ltr2_low_value; ltr2_high_value = UPS_Constant_Table[l_index].ltr2_high_value; ltr3_high_value = UPS_Constant_Table[l_index].ltr3_high_value; false_easting = UPS_Constant_Table[l_index].false_easting; false_northing = UPS_Constant_Table[l_index].false_northing; } else { *Hemisphere = 'S'; ltr2_low_value = UPS_Constant_Table[letters[0]].ltr2_low_value; ltr2_high_value = UPS_Constant_Table[letters[0]].ltr2_high_value; ltr3_high_value = UPS_Constant_Table[letters[0]].ltr3_high_value; false_easting = UPS_Constant_Table[letters[0]].false_easting; false_northing = UPS_Constant_Table[letters[0]].false_northing; } /* Check that the second letter of the MGRS string is within * the range of valid second letter values * Also check that the third letter is valid */ if ((letters[1] < ltr2_low_value) || (letters[1] > ltr2_high_value) || ((letters[1] == LETTER_D) || (letters[1] == LETTER_E) || (letters[1] == LETTER_M) || (letters[1] == LETTER_N) || (letters[1] == LETTER_V) || (letters[1] == LETTER_W)) || (letters[2] > ltr3_high_value)) error_code = MGRS_STRING_ERROR; if (!error_code) { grid_northing = (double)letters[2] * ONEHT + false_northing; if (letters[2] > LETTER_I) grid_northing = grid_northing - ONEHT; if (letters[2] > LETTER_O) grid_northing = grid_northing - ONEHT; grid_easting = (double)((letters[1]) - ltr2_low_value) * ONEHT + false_easting; if (ltr2_low_value != LETTER_A) { if (letters[1] > LETTER_L) grid_easting = grid_easting - 300000.0; if (letters[1] > LETTER_U) grid_easting = grid_easting - 200000.0; } else { if (letters[1] > LETTER_C) grid_easting = grid_easting - 200000.0; if (letters[1] > LETTER_I) grid_easting = grid_easting - ONEHT; if (letters[1] > LETTER_L) grid_easting = grid_easting - 300000.0; } *Easting = grid_easting + *Easting; *Northing = grid_northing + *Northing; } } } return (error_code); } /* Convert_MGRS_To_UPS */