mgrspoint.java

openmap java写的开源数字地图程序. 用applet实现,可以像google map 那样放大缩小地图.

    public int getAccuracy() {
        return accuracy;
    }

    /**
     * Set the UTM parameters from a MGRS string.
     * 
     * @param mgrsString an UPPERCASE coordinate string is expected.
     */
    protected void decode(String mgrsString) throws NumberFormatException {

        if (mgrsString == null || mgrsString.length() == 0) {
            throw new NumberFormatException("MGRSPoint coverting from nothing");
        }

        int length = mgrsString.length();

        String hunK = null;
        StringBuffer sb = new StringBuffer();
        char testChar;
        int i = 0;

        // get Zone number
        while (!Character.isLetter(testChar = mgrsString.charAt(i))) {
            if (i > 2) {
                throw new NumberFormatException("MGRSPoint bad conversion from: "
                        + mgrsString);
            }
            sb.append(testChar);
            i++;
        }

        zone_number = Integer.parseInt(sb.toString());

        if (i == 0 || i + 3 > length) {
            // A good MGRS string has to be 4-5 digits long,
            // ##AAA/#AAA at least.
            throw new NumberFormatException("MGRSPoint bad conversion from: "
                    + mgrsString);
        }

        zone_letter = mgrsString.charAt(i++);

        // Should we check the zone letter here? Why not.
        if (zone_letter <= 'A' || zone_letter == 'B' || zone_letter == 'Y'
                || zone_letter >= 'Z' || zone_letter == 'I'
                || zone_letter == 'O') {
            throw new NumberFormatException("MGRSPoint zone letter "
                    + (char) zone_letter + " not handled: " + mgrsString);
        }

        hunK = mgrsString.substring(i, i += 2);

        int set = get100kSetForZone(zone_number);

        float east100k = getEastingFromChar(hunK.charAt(0), set);
        float north100k = getNorthingFromChar(hunK.charAt(1), set);

        // We have a bug where the northing may be 2000000 too low.
        // How
        // do we know when to roll over?

        while (north100k < getMinNorthing(zone_letter)) {
            north100k += 2000000;
        }

        // calculate the char index for easting/northing separator
        int remainder = length - i;

        if (remainder % 2 != 0) {
            throw new NumberFormatException("MGRSPoint has to have an even number \nof digits after the zone letter and two 100km letters - front \nhalf for easting meters, second half for \nnorthing meters"
                    + mgrsString);
        }

        int sep = remainder / 2;

        float sepEasting = 0f;
        float sepNorthing = 0f;

        if (sep > 0) {
            if (DEBUG)
                Debug.output(" calculating e/n from " + mgrs.substring(i));
            float accuracyBonus = 100000f / (float) Math.pow(10, sep);
            if (DEBUG)
                Debug.output(" calculated accuracy bonus as  " + accuracyBonus);
            String sepEastingString = mgrsString.substring(i, i + sep);
            if (DEBUG)
                Debug.output(" parsed easting as " + sepEastingString);
            sepEasting = Float.parseFloat(sepEastingString) * accuracyBonus;
            String sepNorthingString = mgrsString.substring(i + sep);
            if (DEBUG)
                Debug.output(" parsed northing as " + sepNorthingString);
            sepNorthing = Float.parseFloat(sepNorthingString) * accuracyBonus;
        }

        easting = sepEasting + east100k;
        northing = sepNorthing + north100k;

        if (DEBUG) {
            Debug.output("Decoded " + mgrsString + " as zone number: "
                    + zone_number + ", zone letter: " + zone_letter
                    + ", easting: " + easting + ", northing: " + northing
                    + ", 100k: " + hunK);
        }
    }

    /**
     * Create the mgrs string based on the internal UTM settings,
     * using the accuracy set in the MGRSPoint.
     */
    protected void resolve() {
        resolve(accuracy);
    }

    /**
     * Create the mgrs string based on the internal UTM settings.
     * 
     * @param digitAccuracy The number of digits to use for the
     *        northing and easting numbers. 5 digits reflect a 1 meter
     *        accuracy, 4 - 10 meter, 3 - 100 meter, 2 - 1000 meter, 1 -
     *        10,000 meter.
     */
    protected void resolve(int digitAccuracy) {
        if (zone_letter == 'Z') {
            mgrs = "Latitude limit exceeded";
        } else {
            StringBuffer sb = new StringBuffer(zone_number + ""
                    + (char) zone_letter
                    + get100kID(easting, northing, zone_number));
            StringBuffer seasting = new StringBuffer(Integer.toString((int) easting));
            StringBuffer snorthing = new StringBuffer(Integer.toString((int) northing));

            if (DEBUG) {
                Debug.output(" Resolving MGRS from easting: " + seasting
                        + " derived from " + easting + ", and northing: "
                        + snorthing + " derived from " + northing);
            }

            while (digitAccuracy + 1 > seasting.length()) {
                seasting.insert(0, '0');
            }

            // We have to be careful here, the 100k values shouldn't
            // be
            // used for calculating stuff here.

            while (digitAccuracy + 1 > snorthing.length()) {
                snorthing.insert(0, '0');
            }

            while (snorthing.length() > 6) {
                snorthing.deleteCharAt(0);
            }

            if (DEBUG) {
                Debug.output(" -- modified easting: " + seasting
                        + " and northing: " + snorthing);
            }

            try {
                sb.append(seasting.substring(1, digitAccuracy + 1)
                        + snorthing.substring(1, digitAccuracy + 1));

                mgrs = sb.toString();
            } catch (IndexOutOfBoundsException ioobe) {
                mgrs = null;
            }
        }
    }

    /**
     * Given a UTM zone number, figure out the MGRS 100K set it is in.
     */
    protected int get100kSetForZone(int i) {
        int set = i % NUM_100K_SETS;
        if (set == 0)
            set = NUM_100K_SETS;
        return set;
    }

    /**
     * Provided so that extensions to this class can provide different
     * origin letters, in case of different ellipsoids. The int[]
     * represents all of the first letters in the bottom left corner
     * of each set box, as shown in an MGRS 100K box layout.
     */
    protected int[] getOriginColumnLetters() {
        return originColumnLetters;
    }

    /**
     * Provided so that extensions to this class can provide different
     * origin letters, in case of different ellipsoids. The int[]
     * represents all of the first letters in the bottom left corner
     * of each set box, as shown in an MGRS 100K box layout.
     */
    protected void setOriginColumnLetters(int[] letters) {
        originColumnLetters = letters;
    }

    /**
     * Provided so that extensions to this class can provide different
     * origin letters, in case of different ellipsoids. The int[]
     * represents all of the second letters in the bottom left corner
     * of each set box, as shown in an MGRS 100K box layout.
     */
    protected int[] getOriginRowLetters() {
        return originRowLetters;
    }

    /**
     * Provided so that extensions to this class can provide different
     * origin letters, in case of different ellipsoids. The int[]
     * represents all of the second letters in the bottom left corner
     * of each set box, as shown in an MGRS 100K box layout.
     */
    protected void setOriginRowLetters(int[] letters) {
        originRowLetters = letters;
    }

    /**
     * Get the two letter 100k designator for a given UTM easting,
     * northing and zone number value.
     */
    protected String get100kID(float easting, float northing, int zone_number) {
        int set = get100kSetForZone(zone_number);
        int setColumn = ((int) easting / 100000);
        int setRow = ((int) northing / 100000) % 20;
        return get100kID(setColumn, setRow, set);
    }

    /**
     * Given the first letter from a two-letter MGRS 100k zone, and
     * given the MGRS table set for the zone number, figure out the
     * easting value that should be added to the other, secondary
     * easting value.
     */
    protected float getEastingFromChar(char e, int set) {
        int baseCol[] = getOriginColumnLetters();
        // colOrigin is the letter at the origin of the set for the
        // column
        int curCol = baseCol[set - 1];
        float eastingValue = 100000f;
        boolean rewindMarker = false;

        while (curCol != e) {
            curCol++;
            if (curCol == I)
                curCol++;
            if (curCol == O)
                curCol++;
            if (curCol > Z) {
                if (rewindMarker) {
                    throw new NumberFormatException("Bad character: " + e);
                }
                curCol = A;
                rewindMarker = true;
            }
            eastingValue += 100000f;
        }

        if (DEBUG) {
            Debug.output("Easting value for " + (char) e + " from set: " + set
                    + ", col: " + curCol + " is " + eastingValue);
        }
        return eastingValue;
    }

    /**
     * Given the second letter from a two-letter MGRS 100k zone, and
     * given the MGRS table set for the zone number, figure out the
     * northing value that should be added to the other, secondary
     * northing value. You have to remember that Northings are
     * determined from the equator, and the vertical cycle of letters
     * mean a 2000000 additional northing meters. This happens approx.
     * every 18 degrees of latitude. This method does *NOT* count any
     * additional northings. You have to figure out how many 2000000
     * meters need to be added for the zone letter of the MGRS
     * coordinate.
     * 
     * @param n second letter of the MGRS 100k zone
     * @param set the MGRS table set number, which is dependent on the
     *        UTM zone number.
     */
    protected float getNorthingFromChar(char n, int set) {

        if (n > 'V') {
            throw new NumberFormatException("MGRSPoint given invalid Northing "
                    + n);
        }

        int baseRow[] = getOriginRowLetters();
        // rowOrigin is the letter at the origin of the set for the
        // column
        int curRow = baseRow[set - 1];
        float northingValue = 0f;
        boolean rewindMarker = false;

        while (curRow != n) {
            curRow++;
            if (curRow == I)
                curRow++;
            if (curRow == O)
                curRow++;
            // fixing a bug making whole application hang in this loop
            // when 'n' is a wrong character
            if (curRow > V) {
                if (rewindMarker) { // making sure that this loop ends
                    throw new NumberFormatException("Bad character: " + n);
                }
                curRow = A;
                rewindMarker = true;
            }
            northingValue += 100000f;
        }

        if (DEBUG) {
            Debug.output("Northing value for " + (char) n + " from set: " + set
                    + ", row: " + curRow + " is " + northingValue);
        }

        return northingValue;
    }

    /**
     * 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 set 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.
     */
    protected String get100kID(int setColumn, int setRow, int set) {

        if (DEBUG) {
            System.out.println("set (" + set + ") column = " + setColumn
                    + ", row = " + setRow);
        }

        int baseCol[] = getOriginColumnLetters();
        int baseRow[] = getOriginRowLetters();

        // colOrigin and rowOrigin are the letters at the origin of
        // the set
        int colOrigin = baseCol[set - 1];
        int rowOrigin = baseRow[set - 1];

        if (DEBUG) {
            System.out.println("starting at = " + (char) colOrigin
                    + (char) rowOrigin);
        }

        // colInt and rowInt are the letters to build to return
        int colInt = colOrigin + setColumn - 1;
        int rowInt = rowOrigin + setRow;
        boolean rollover = false;

        if (colInt > Z) {
            colInt = colInt - Z + A - 1;
            rollover = true;
            if (DEBUG)
                System.out.println("rolling over col, new value: "
                        + (char) colInt);
        }