Summary

No overview generated for 'MGRS.js'

/*
Author:       Patrice G. Cappelaere (Got library from Geoserver)
License:      LGPL as per: http://www.gnu.org/copyleft/lesser.html

$Id: MGRS.js 2546 2007-01-23 12:07:39Z gjvoosten $
*/


function MGRS() {
	 /**
     * UTM zones are grouped, and assigned to one of a group of 6
     * sets.
     */
    var NUM_100K_SETS = 6;

    /**
     * The column letters (for easting) of the lower left value, per
     * set.
     */
    var SET_ORIGIN_COLUMN_LETTERS = new Array('A','J','S','A','J','S');

    /**
     * The row letters (for northing) of the lower left value, per
     * set.
     */
   var SET_ORIGIN_ROW_LETTERS = new Array('A','F','A','F','A','F');

    /**
     * The column letters (for easting) of the lower left value, per
     * set,, for Bessel Ellipsoid.
     */
    var BESSEL_SET_ORIGIN_COLUMN_LETTERS = new Array( 'A', 'J',  'S', 'A', 'J', 'S' );

    /**
     * The row letters (for northing) of the lower left value, per
     * set, for Bessel Ellipsoid.
     */
    var BESSEL_SET_ORIGIN_ROW_LETTERS = new Array( 'L', 'R', 'L', 'R', 'L', 'R' );
    var SET_NORTHING_ROLLOVER = 20000000;

    /**
     * Use 5 digits for northing and easting values, for 1 meter
     * accuracy of coordinate.
     */

    var ACCURACY_1_METER = 5;

    /**
     * Use 4 digits for northing and easting values, for 10 meter
     * accuracy of coordinate.
     */
    var ACCURACY_10_METER = 4;

    /**
     * Use 3 digits for northing and easting values, for 100 meter
     * accuracy of coordinate.
     */
    var ACCURACY_100_METER = 3;

    /**
     * Use 2 digits for northing and easting values, for 1000 meter
     * accuracy of coordinate.
     */

    var ACCURACY_1000_METER = 2;
    /**
     * Use 1 digits for northing and easting values, for 10000 meter
     * accuracy of coordinate.
     */
    var ACCURACY_10000_METER = 1;

    /** The set origin column letters to use. */
    var originColumnLetters = SET_ORIGIN_COLUMN_LETTERS;

    /** The set origin row letters to use. */
    var originRowLetters = SET_ORIGIN_ROW_LETTERS;

    var A = 65;	//AsciiToNum('A');
    var I = 73;	//AsciiToNum('I');
    var O = 79;	//AsciiToNum('O');
    var V = 86;	//AsciiToNum('V');
    var Z = 90;	//AsciiToNum('Z');

    var DEBUG = false;

    /** The String holding the MGRS coordinate value. */
    var  mgrs_;
	  var lat_;
    var lon_;
    var radlat_ ;
    var radlon_ ;

 		var northing_;
    var easting_;
    var zone_number_;
    var zone_letter_;
    
		/**
		  * Conversion of lat/lon to MGRS
		  */
		this.convert = function(latitude, longitude) {
      lat_    = parseFloat(latitude);
		  lon_    = parseFloat(longitude);
		  radlat_ = degToRad(lat_);
      radlon_ = degToRad(lon_);

		  LLtoUTM();
		  return formatMGRS();
	  }

    function degToRad(deg) {
        return (deg * (Math.PI / 180.0));
    }
    
	 /**
     * Converts a set of Longitude and Latitude co-ordinates to UTM
     * given an ellipsoid
     * 
     * @param ellip an ellipsoid definition.
     * @param llpoint the coordinate to be converted
     * @param utmpoint A UTMPoint instance to put the results in. If
     *        null, a new UTMPoint will be allocated.
     * @return A UTM class instance containing the value of
     *         <code>null</code> if conversion failed. If you pass
     *         in a UTMPoint, it will be returned as well if
     *         successful.
     */
   function LLtoUTM() {
        var Lat = lat_;
        var Long = lon_;
        var a = 6378137.0;	//ellip.radius;
        var eccSquared = 0.00669438;	//ellip.eccsq;
        var k0 = 0.9996;
        var LongOrigin;
        var eccPrimeSquared;
        var N, T, C, A, M;
        var LatRad = radlat_;
        var LongRad = radlon_;
        var LongOriginRad;
        var ZoneNumber;
		// (int)
        ZoneNumber = Math.floor((Long + 180) / 6) + 1;

        //Make sure the longitude 180.00 is in Zone 60
        if (Long == 180) {
            ZoneNumber = 60;
        }

        // Special zone for Norway
        if (Lat >= 56.0 && Lat < 64.0 && Long >= 3.0 && Long < 12.0) {
            ZoneNumber = 32;
        }

        // Special zones for Svalbard
        if (Lat >= 72.0 && Lat < 84.0) {
            if (Long >= 0.0 && Long < 9.0)
                ZoneNumber = 31;
            else if (Long >= 9.0 && Long < 21.0)
                ZoneNumber = 33;
            else if (Long >= 21.0 && Long < 33.0)
                ZoneNumber = 35;
            else if (Long >= 33.0 && Long < 42.0)
                ZoneNumber = 37;
        }

        LongOrigin = (ZoneNumber - 1) * 6 - 180 + 3; //+3 puts origin
                                                     // in middle of
                                                     // zone
        LongOriginRad = degToRad(LongOrigin);

        eccPrimeSquared = (eccSquared) / (1 - eccSquared);

        N = a / Math.sqrt(1 - eccSquared * Math.sin(LatRad) * Math.sin(LatRad));
        T = Math.tan(LatRad) * Math.tan(LatRad);
        C = eccPrimeSquared * Math.cos(LatRad) * Math.cos(LatRad);
        A = Math.cos(LatRad) * (LongRad - LongOriginRad);

        M = a
                * ((1 - eccSquared / 4 - 3 * eccSquared * eccSquared / 64 - 5
                        * eccSquared * eccSquared * eccSquared / 256)
                        * LatRad
                        - (3 * eccSquared / 8 + 3 * eccSquared * eccSquared
                                / 32 + 45 * eccSquared * eccSquared
                                * eccSquared / 1024)
                        * Math.sin(2 * LatRad)
                        + (15 * eccSquared * eccSquared / 256 + 45 * eccSquared
                                * eccSquared * eccSquared / 1024)
                        * Math.sin(4 * LatRad) - (35 * eccSquared * eccSquared
                        * eccSquared / 3072)
                        * Math.sin(6 * LatRad));

        var UTMEasting = (k0
                * N
                * (A + (1 - T + C) * A * A * A / 6.0 + (5 - 18 * T + T * T
                        + 72 * C - 58 * eccPrimeSquared)
                        * A * A * A * A * A / 120.0) + 500000.0);

        var UTMNorthing =  (k0 * (M + N
                * Math.tan(LatRad)
                * (A * A / 2 + (5 - T + 9 * C + 4 * C * C) * A * A * A * A
                        / 24.0 + (61 - 58 * T + T * T + 600 * C - 330 * eccPrimeSquared)
                        * A * A * A * A * A * A / 720.0)));
        if (Lat < 0.0) {
            UTMNorthing += 10000000.0; //10000000 meter offset for
                                        // southern hemisphere
        }

        northing_ = Math.round(UTMNorthing);
        easting_ =  Math.round(UTMEasting);
        zone_number_ = ZoneNumber;
        zone_letter_ = getLetterDesignator(Lat);
    }
    
	function getLetterDesignator(lat) {
        //This is here as an error flag to show that the Latitude is
        //outside MGRS limits
        var LetterDesignator = 'Z';

        if ((84 >= lat) && (lat >= 72))
            LetterDesignator = 'X';
        else if ((72 > lat) && (lat >= 64))
            LetterDesignator = 'W';
        else if ((64 > lat) && (lat >= 56))
            LetterDesignator = 'V';
        else if ((56 > lat) && (lat >= 48))
            LetterDesignator = 'U';
        else if ((48 > lat) && (lat >= 40))
            LetterDesignator = 'T';
        else if ((40 > lat) && (lat >= 32))
            LetterDesignator = 'S';
        else if ((32 > lat) && (lat >= 24))
            LetterDesignator = 'R';
        else if ((24 > lat) && (lat >= 16))
            LetterDesignator = 'Q';
        else if ((16 > lat) && (lat >= 8))
            LetterDesignator = 'P';
        else if ((8 > lat) && (lat >= 0))
            LetterDesignator = 'N';
        else if ((0 > lat) && (lat >= -8))
            LetterDesignator = 'M';
        else if ((-8 > lat) && (lat >= -16))
            LetterDesignator = 'L';
        else if ((-16 > lat) && (lat >= -24))
            LetterDesignator = 'K';
        else if ((-24 > lat) && (lat >= -32))
            LetterDesignator = 'J';
        else if ((-32 > lat) && (lat >= -40))
            LetterDesignator = 'H';
        else if ((-40 > lat) && (lat >= -48))
            LetterDesignator = 'G';
        else if ((-48 > lat) && (lat >= -56))
            LetterDesignator = 'F';
        else if ((-56 > lat) && (lat >= -64))
            LetterDesignator = 'E';
        else if ((-64 > lat) && (lat >= -72))
            LetterDesignator = 'D';
        else if ((-72 > lat) && (lat >= -80))
            LetterDesignator = 'C';
        return LetterDesignator;
    }

	 function formatMGRS() {
		 var seasting = "" + easting_;
		 var snorthing = ""+ northing_;
		 while( snorthing.length > 6 )
			 snorthing = snorthing.substr(1,snorthing.length-1);

		 var str= zone_number_ + "" + zone_letter_ +
       get100kID(easting_, northing_, zone_number_) +
			 seasting.substr(1,4) + snorthing.substr(1,4);

		  return str;
	  }
	
	   /**
     * Get the two letter 100k designator for a given UTM easting,
     * northing and zone number value.
     */
    function get100kID( easting, northing, zone_number) {
        var setParm = get100kSetForZone(zone_number);
        var setColumn = Math.floor( easting / 100000);
        var setRow = Math.floor( northing  / 100000) % 20;
		//trace("get100kID:"+setParm+" "+setColumn+" "+setRow);
        return getLetter100kID(setColumn, setRow, setParm);
    }

	 /**
     * Given a UTM zone number, figure out the MGRS 100K set it is in.
     */
    function get100kSetForZone(i) {
        var setParm = i % NUM_100K_SETS;
        if (setParm == 0)
            setParm = NUM_100K_SETS;
		
        return setParm;
    }
    
   /**
     * Get the two-letter MGRS 100k designator given information
     * translated from the UTM northing, easting and zone number.
     * 
     * @param setColumn the column index as it relates to the MGRS
     *        100k set spreadsheet, created from the UTM easting.
     *        Values are 1-8.
     * @param setRow the row index as it relates to the MGRS 100k set
     *        spreadsheet, created from the UTM northing value. Values
     *        are from 0-19.
     * @param setParm the set block, as it relates to the MGRS 100k set
     *        spreadsheet, created from the UTM zone. Values are from
     *        1-60.
     * @return two letter MGRS 100k code.
     */

    function getLetter100kID( column, row, parm) {
		    // colOrigin and rowOrigin are the letters at the origin of the set
		    var index = parm-1;
        var colOrigin = AsciiToNum(SET_ORIGIN_COLUMN_LETTERS[index]);
        var rowOrigin = AsciiToNum(SET_ORIGIN_ROW_LETTERS[index]);

        // colInt and rowInt are the letters to build to return
        var colInt = colOrigin + column - 1;
        var rowInt = rowOrigin + row;
        var rollover = false;

		    if ( colInt > Z ) {
            colInt = colInt - Z + A - 1;
            rollover = true;
        }

		    if (colInt == I || (colOrigin < I && colInt > I)
                || ((colInt > I || colOrigin < I) && rollover)) {
            colInt++;
        }

		    if (colInt == O || (colOrigin < O && colInt > O)
                || ((colInt > O || colOrigin < O) && rollover)) {
            colInt++;

            if (colInt == I) {
                colInt++;
             }
        }

	  	   if (colInt > Z) {
            colInt = colInt - Z + A - 1;
        }

        if (rowInt > V) {
            rowInt = rowInt - V + A - 1;
            rollover = true;
        } else {
            rollover = false;
        }

        if( ((rowInt == I) || ((rowOrigin < I) && (rowInt > I)))
                || (((rowInt > I)||(rowOrigin < I)) && rollover)) {
            rowInt++;
        }

        if( ((rowInt == O) || ((rowOrigin < O) && (rowInt > O)))
                || (((rowInt > O)|| (rowOrigin < O)) && rollover)) {
            rowInt++;

            if (rowInt == I) {
                rowInt++;
            }
        }

        if (rowInt > V) {
            rowInt = rowInt - V + A - 1;
        }

        var twoLetter = NumToAscii(colInt) + "" + NumToAscii(rowInt);
        return twoLetter;
	}


	function AsciiToNum( ascii ) {
		switch( ascii ) {
			case 'A':
				return 65;
			case 'B':
				return 66;
			case 'C':
				return 67;
			case 'D':
				return 68;
			case 'E':
				return 69;
			case 'F':
				return 70;
			case 'G':
				return 71;
			case 'H':
				return 72;
			case 'I':
				return 73;
			case 'J':
				return 74;
			case 'K':
				return 75;
			case 'L':
				return 76;
			case 'M':
				return 77;
			case 'N':
				return 78;
			case 'O':
				return 79;
			case 'P':
				return 80;
			case 'Q':
				return 81;
			case 'R':
				return 82;
			case 'S':
				return 83;
			case 'T':
				return 84;
			case 'U':
				return 85;
			case 'V':
				return 86;
			case 'W':
				return 87;
			case 'X':
				return 88;
			case 'Y':
				return 89;
			case 'Z':
				return 90;
		}
	}
	
	function NumToAscii( num ) {
		switch( num ) {
			case 65:
				return 'A';
			case 66:
				return 'B';
			case 67:
				return 'C';
			case 68:
				return 'D';
			case 69:
				return 'E';
			case 70:
				return 'F';
			case 71:
				return 'G';
			case 72:
				return 'H';
			case 73:
				return 'I';
			case 74:
				return  'J';
			case 75 :
				return 'K';
			case 76:
				return 'L';
			case 77:
				return 'M';
			case 78:
				return 'N';
			case 79:
				return 'O';
			case 80:
				return 'P';
			case 81:
				return 'Q';
			case 82:
				return 'R';
			case 83:
				return 'S';
			case 84:
				return 'T';
			case 85:
				return 'U';
			case 86:
				return 'V';
			case 87:
				return 'W';
			case 88:
				return 'X';
			case 89:
				return 'Y';
			case 90:
				return 'Z';
		}
	}
}