jme3tools/navigation/MapModel3D.java

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package jme3tools.navigation;

import com.jme3.math.Vector3f;
import java.text.DecimalFormat;


/**
 * A representation of the actual map in terms of lat/long and x,y,z co-ordinates.
 * The Map class contains various helper methods such as methods for determining
 * the world unit positions for lat/long coordinates and vice versa. This map projection
 * does not handle screen/pixel coordinates.
 *
 * @author Benjamin Jakobus (thanks to Cormac Gebruers)
 * @version 1.0
 * @since 1.0
 */
public class MapModel3D {

    /* The number of radians per degree */
    private final static double RADIANS_PER_DEGREE = 57.2957;

    /* The number of degrees per radian */
    private final static double DEGREES_PER_RADIAN = 0.0174532925;

    /* The map's width in longitude */
    public final static int DEFAULT_MAP_WIDTH_LONGITUDE = 360;

    /* The top right hand corner of the map */
    private Position centre;

    /* The x and y co-ordinates for the viewport's centre */
    private int xCentre;
    private int zCentre;

    /* The width (in world units (wu)) of the viewport holding the map */
    private int worldWidth;

    /* The viewport height in pixels */
    private int worldHeight;

    /* The number of minutes that one pixel represents */
    private double minutesPerWorldUnit;

    /**
     * Constructor.
     *
     * @param worldWidth         The world unit width the map's area
     * @since 1.0
     */
    public MapModel3D(int worldWidth) {
        try {
            this.centre = new Position(0, 0);
        } catch (InvalidPositionException e) {
            e.printStackTrace();
        }

        this.worldWidth = worldWidth;

        // Calculate the number of minutes that one pixel represents along the longitude
        calculateMinutesPerWorldUnit(DEFAULT_MAP_WIDTH_LONGITUDE);

        // Calculate the viewport height based on its width and the number of degrees (85)
        // in our map
        worldHeight = ((int) NavCalculator.computeDMPClarkeSpheroid(0, 85) / (int) minutesPerWorldUnit) * 2;

        // Determine the map's x,y centre
        xCentre = 0;
        zCentre = 0;
//        xCentre = worldWidth / 2;
//        zCentre = worldHeight / 2;
    }

    /**
     * Returns the height of the viewport in pixels.
     *
     * @return          The height of the viewport in pixels.
     * @since 1.0
     */
    public int getWorldHeight() {
        return worldHeight;
    }

    /**
     * Calculates the number of minutes per pixels using a given
     * map width in longitude.
     *
     * @param mapWidthInLongitude               The map's with in degrees of longitude.
     * @since 1.0
     */
    public void calculateMinutesPerWorldUnit(double mapWidthInLongitude) {
        // Multiply mapWidthInLongitude by 60 to convert it to minutes.
        minutesPerWorldUnit = (mapWidthInLongitude * 60) / (double) worldWidth;
    }

    /**
     * Returns the width of the viewport in pixels.
     *
     * @return              The width of the viewport in pixels.
     * @since 1.0
     */
    public int getWorldWidth() {
        return worldWidth;
    }

    /**
     * Sets the world's desired width.
     *
     * @param viewportWidth     The world's desired width in WU.
     * @since 1.0
     */
    public void setWorldWidth(int viewportWidth) {
        this.worldWidth = viewportWidth;
    }

     /**
     * Sets the world's desired height.
     *
     * @param viewportHeight     The world's desired height in WU.
     * @since 1.0
     */
    public void setWorldHeight(int viewportHeight) {
        this.worldHeight = viewportHeight;
    }

    /**
     * Sets the map's centre.
     *
     * @param centre            The <code>Position</code> denoting the map's
     *                          desired centre.
     * @since 1.0
     */
    public void setCentre(Position centre) {
        this.centre = centre;
    }

    /**
     * Returns the number of minutes there are per WU.
     *
     * @return                  The number of minutes per WU.
     * @since 1.0
     */
    public double getMinutesPerWu() {
        return minutesPerWorldUnit;
    }

    /**
     * Returns the meters per WU.
     *
     * @return                  The meters per WU.
     * @since 1.0
     */
    public double getMetersPerWu() {
        return 1853 * minutesPerWorldUnit;
    }

    /**
     * Converts a latitude/longitude position into a WU coordinate.
     *
     * @param position          The <code>Position</code> to convert.
     * @return                  The <code>Point</code> a pixel coordinate.
     * @since 1.0
     */
    public Vector3f toWorldUnit(Position position) {
        // Get the difference between position and the centre for calculating
        // the position's longitude translation
        double distance = NavCalculator.computeLongDiff(centre.getLongitude(),
                position.getLongitude());

        // Use the difference from the centre to calculate the pixel x co-ordinate
        double distanceInPixels = (distance / minutesPerWorldUnit);

        // Use the difference in meridional parts to calculate the pixel y co-ordinate
        double dmp = NavCalculator.computeDMPClarkeSpheroid(centre.getLatitude(),
                position.getLatitude());

        int x = 0;
        int z = 0;

        if (centre.getLatitude() == position.getLatitude()) {
            z = zCentre;
        }
        if (centre.getLongitude() == position.getLongitude()) {
            x = xCentre;
        }

        // Distinguish between northern and southern hemisphere for latitude calculations
        if (centre.getLatitude() > 0 && position.getLatitude() > centre.getLatitude()) {
            // Centre is north. Position is north of centre
            z = zCentre - (int) ((dmp) / minutesPerWorldUnit);
        } else if (centre.getLatitude() > 0 && position.getLatitude() < centre.getLatitude()) {
            // Centre is north. Position is south of centre
            z = zCentre + (int) ((dmp) / minutesPerWorldUnit);
        } else if (centre.getLatitude() < 0 && position.getLatitude() > centre.getLatitude()) {
            // Centre is south. Position is north of centre
            z = zCentre - (int) ((dmp) / minutesPerWorldUnit);
        } else if (centre.getLatitude() < 0 && position.getLatitude() < centre.getLatitude()) {
            // Centre is south. Position is south of centre
            z = zCentre + (int) ((dmp) / minutesPerWorldUnit);
        } else if (centre.getLatitude() == 0 && position.getLatitude() > centre.getLatitude()) {
            // Centre is at the equator. Position is north of the equator
            z = zCentre - (int) ((dmp) / minutesPerWorldUnit);
        } else if (centre.getLatitude() == 0 && position.getLatitude() < centre.getLatitude()) {
            // Centre is at the equator. Position is south of the equator
            z = zCentre + (int) ((dmp) / minutesPerWorldUnit);
        }

        // Distinguish between western and eastern hemisphere for longitude calculations
        if (centre.getLongitude() < 0 && position.getLongitude() < centre.getLongitude()) {
            // Centre is west. Position is west of centre
            x = xCentre - (int) distanceInPixels;
        } else if (centre.getLongitude() < 0 && position.getLongitude() > centre.getLongitude()) {
            // Centre is west. Position is south of centre
            x = xCentre + (int) distanceInPixels;
        } else if (centre.getLongitude() > 0 && position.getLongitude() < centre.getLongitude()) {
            // Centre is east. Position is west of centre
            x = xCentre - (int) distanceInPixels;
        } else if (centre.getLongitude() > 0 && position.getLongitude() > centre.getLongitude()) {
            // Centre is east. Position is east of centre
            x = xCentre + (int) distanceInPixels;
        } else if (centre.getLongitude() == 0 && position.getLongitude() > centre.getLongitude()) {
            // Centre is at the equator. Position is east of centre
            x = xCentre + (int) distanceInPixels;
        } else if (centre.getLongitude() == 0 && position.getLongitude() < centre.getLongitude()) {
            // Centre is at the equator. Position is west of centre
            x = xCentre - (int) distanceInPixels;
        }

        // Distinguish between northern and southern hemisphere for longitude calculations
        return new Vector3f(x, 0, z);
    }

    /**
     * Converts a world position into a Mercator position.
     *
     * @param posVec                     <code>Vector</code> containing the world unit
     *                              coordinates that are to be converted into
     *                              longitude / latitude coordinates.
     * @return                      The resulting <code>Position</code> in degrees of
     *                              latitude and longitude.
     * @since 1.0
     */
    public Position toPosition(Vector3f posVec) {
        double lat, lon;
        Position pos = null;
        try {
            Vector3f worldCentre = toWorldUnit(new Position(0, 0));

            // Get the difference between position and the centre
            double xDistance = difference(xCentre, posVec.getX());
            double yDistance = difference(worldCentre.getZ(), posVec.getZ());
            double lonDistanceInDegrees = (xDistance * minutesPerWorldUnit) / 60;
            double mp = (yDistance * minutesPerWorldUnit);
            // If we are zoomed in past a certain point, then use linear search.
            // Otherwise use binary search
            if (getMinutesPerWu() < 0.05) {
                lat = findLat(mp, getCentre().getLatitude());
                if (lat == -1000) {
                    System.out.println("lat: " + lat);
                }
            } else {
                lat = findLat(mp, 0.0, 85.0);
            }
            lon = (posVec.getX() < xCentre ? centre.getLongitude() - lonDistanceInDegrees
                    : centre.getLongitude() + lonDistanceInDegrees);

            if (posVec.getZ() > worldCentre.getZ()) {
                lat = -1 * lat;
            }
            if (lat == -1000 || lon == -1000) {
                return pos;
            }
            pos = new Position(lat, lon);
        } catch (InvalidPositionException ipe) {
            ipe.printStackTrace();
        }
        return pos;
    }

    /**
     * Calculates difference between two points on the map in WU.
     *
     * @param a
     * @param b
     * @return difference           The difference between a and b in WU.
     * @since 1.0
     */
    private double difference(double a, double b) {
        return Math.abs(a - b);
    }

    /**
     * Defines the centre of the map in pixels.
     *
     * @param posVec             <code>Vector3f</code> object denoting the map's new centre.
     * @since 1.0
     */
    public void setCentre(Vector3f posVec) {
        try {
            Position newCentre = toPosition(posVec);
            if (newCentre != null) {
                centre = newCentre;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * Returns the WU (x,y,z) centre of the map.
     *
     * @return              <code>Vector3f</code> object marking the map's (x,y) centre.
     * @since 1.0
     */
    public Vector3f getCentreWu() {
        return new Vector3f(xCentre, 0, zCentre);
    }

    /**
     * Returns the <code>Position</code> centre of the map.
     *
     * @return              <code>Position</code> object marking the map's (lat, long)
     *                      centre.
     * @since 1.0
     */
    public Position getCentre() {
        return centre;
    }

    /**
     * Uses binary search to find the latitude of a given MP.
     *
     * @param mp                Maridian part whose latitude to determine.
     * @param low               Minimum latitude bounds.
     * @param high              Maximum latitude bounds.
     * @return                  The latitude of the MP value
     * @since 1.0
     */
    private double findLat(double mp, double low, double high) {
        DecimalFormat form = new DecimalFormat("#.####");
        mp = Math.round(mp);
        double midLat = (low + high) / 2.0;
        // ctr is used to make sure that with some
        // numbers which can't be represented exactly don't inifitely repeat
        double guessMP = NavCalculator.computeDMPClarkeSpheroid(0, (float) midLat);

        while (low <= high) {
            if (guessMP == mp) {
                return midLat;
            } else {
                if (guessMP > mp) {
                    high = midLat - 0.0001;
                } else {
                    low = midLat + 0.0001;
                }
            }

            midLat = Double.valueOf(form.format(((low + high) / 2.0)));
            guessMP = NavCalculator.computeDMPClarkeSpheroid(0, (float) midLat);
            guessMP = Math.round(guessMP);
        }
        return -1000;
    }

    /**
     * Uses linear search to find the latitude of a given MP.
     *
     * @param mp                The meridian part for which to find the latitude.
     * @param previousLat       The previous latitude. Used as a upper / lower bound.
     * @return                  The latitude of the MP value.
     * @since 1.0
     */
    private double findLat(double mp, double previousLat) {
        DecimalFormat form = new DecimalFormat("#.#####");
        mp = Double.parseDouble(form.format(mp));
        double guessMP;
        for (double lat = previousLat - 0.25; lat < previousLat + 1; lat += 0.00001) {
            guessMP = NavCalculator.computeDMPClarkeSpheroid(0, lat);
            guessMP = Double.parseDouble(form.format(guessMP));
            if (guessMP == mp || Math.abs(guessMP - mp) < 0.05) {
                return lat;
            }
        }
        return -1000;
    }
}