/*
    * Trip Tracker, a real-time position tracking system for the Internet.
    * Copyright (C) 2006  Team Trip Tracker
    *
    * This program is free software; you can redistribute it and/or modify it
    * under the terms of the GNU General Public License as published by the
    * Free Software Foundation; either version 2 of the License, or (at your
    * option) any later version.
    *
   * This program is distributed in the hope that it will be useful, but
   * WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
   * General Public License for more details.
   *
   * You should have received a copy of the GNU General Public License along
   * with this program; if not, write to the Free Software Foundation, Inc.,
   * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
   */
  
  package triptracker.core;
  
  import static java.lang.Math.*;
  import java.util.Date;
  import java.util.Iterator;
  import java.util.List;
  
  /***
   * Represents a coordinate in a latitude/longitude coordinate system on a
   * given time and date. Data in a Coordinate object is immutable.
   * <p>
   * Latitude is numbered from 0 degrees to 90 degrees north and south. 0 degrees
   * is the equator, 90 degrees north is the North Pole and 90 degrees south is
   * the South Pole. The <code>Coordinate</code> class numbers latitudes from -90
   * degrees to 90 degrees where -90 degrees is the South Pole and 90 degrees is
   * the North Pole.
   * <p>
   * Longitude is numbered from 0 degrees to 180 degrees east and west. 0 degrees
   * is at Greenwich, England and they continue 180 degrees east and 180 degrees
   * west where they meet at the International Date Line in the Pacific Ocean. The
   * <code>Coordinate</code> class numbers longitude from -180 degrees to 180
   * degrees where negative degrees are west and positive degrees are east of
   * Greenwich, England at 0 degrees.
   * <p>
   * To precisely locate points on the earth's surface, degrees longitude and
   * latitude have been divided into minutes (') and seconds ("). There are 60
   * minutes in each degree and each minute is divided into 60 seconds. Seconds can
   * be further divided into tenths, hundredths, or even thousandths.
   */
  public class Coordinate {
  	/***
  	 * Earth radius.
  	 * See <a href="http://www.movable-type.co.uk/scripts/GIS-FAQ-5.1.html">
  	 * http://www.movable-type.co.uk/scripts/GIS-FAQ-5.1.html</a>
  	 * section 5.1a or
  	 * <a href="http://www.movable-type.co.uk/scripts/LatLong.html">
  	 * http://www.movable-type.co.uk/scripts/LatLong.html</a>.
  	 */
  	public static final double EARTH_RADIUS = 6366.7070194937075;
  //	public static final double EARTH_RADIUS = 6367.45;
  
  	/***
  	 * See <a href="http://www.movable-type.co.uk/scripts/LatLongVincenty.html">
  	 * http://www.movable-type.co.uk/scripts/LatLongVincenty.html</a>
  	 */
  	public static final double WGS84_A = 6378137; // meter
  	public static final double WGS84_B = 6356752.3142; // meter
  	public static final double WGS84_F = 1 / 298.257223563;
  	
  	private int coordId;
  	private final double ypos;
  	private final double xpos;
  	private final Date date;
  	
  	/***
  	 * Default constructor. Creates a coordinate with x=0 and y=0.
  	 */
  	public Coordinate() {
  		this(-1, 0, 0, null);
  	}
  	
  	/***
  	 * Creates a coordinate with the given latitude and longitude. The values of
  	 * latitude and longitude can be retrieved by calling {@link #getY()} and
  	 * {@link #getX()} respectively. 
  	 * 
  	 * @param latitude latitude from 90 degrees (north) to -90 degrees (south)
  	 * @param longitude longitude from 180 degrees (east) to -180 degrees (west)
  	 * @throws IllegalArgumentException if latitude or longitude is out of
  	 * 		range.
  	 */
  	public Coordinate(final double latitude, final double longitude) {
  		this(-1, latitude, longitude, null);
  	}
  	
  	/***
  	 * Creates a coordinate with the given latitude, longitude and date. The
  	 * values of latitude and longitude can be retrieved by calling
  	 * {@link #getY()} and {@link #getX()} respectively. 
  	 * 
 	 * @param latitude latitude from 90 degrees (north) to -90 degrees (south)
 	 * @param longitude longitude from 180 degrees (east) to -180 degrees (west)
 	 * @param date time associated with coordinate
 	 * @throws IllegalArgumentException if latitude or longitude is out of
 	 * 		range.
 	 */
 	public Coordinate(final double latitude, final double longitude,
 			final Date date) {
 		this(-1, latitude, longitude, date);
 	}
 	
 	public Coordinate(final int coordId, final double latitude,
 			final double longitude) {
 		this(coordId, latitude, longitude, null);
 	}
 
 	public Coordinate(final int coordId, final double latitude,
 			final double longitude, final Date date) {
 		// Check for invalid values.
 		if (latitude > 90 || latitude < -90) {
 			throw new IllegalArgumentException(
 					"latitude not in range -90 to 90");
 		} else if (longitude > 180 || longitude < -180) {
 			throw new IllegalArgumentException(
 					"longitude not in range -180 to 180");
 		}
 		
 		this.coordId = coordId;
 		this.ypos = latitude;
 		this.xpos = longitude;
 		this.date = date;
 	}
 
 
 	/***
 	 * Returns the latitude position of the coordinate. 
 	 * 
 	 * @return latitude position of the coordinate
 	 */
 	public double getY() {
 		return ypos;// * 100000000;
 //		UTMPoint y = llToUTM(22,ypos,xpos);
 //		return  y.getNorthing();
 	}
 	
 	/***
 	 * Returns the longitude position of the coordinate.
 	 * 
 	 * @return longitude position of the coordinate
 	 */
 	public double getX() {
 //		UTMPoint x = llToUTM(22,ypos,xpos);
 //		return x.getEasting();
 		return xpos;// * 100000000;
 	}
 
 	/***
 	 * Returns the time and date associated with the coordinate.
 	 * 
 	 * @return time and date associated with coordinate
 	 */
 	public String getDateString() {
 		if (date == null) {
 			return "";
 		} else {
 			return Utils.dateToString(date);
 		}
 	}
 	
 	// FIXME Clean up in all toString methods here.
 	/***
 	 * Returns the string representation of a latitude/longitude coordinate.
 	 * Example: 38?53'23.83"N 77?00'27.76"W
 	 * 
 	 * @return string representation of a latitude/longitude coordinate
 	 * @see java.lang.Object#toString()
 	 */
 	@Override
 	public String toString() {
 		StringBuilder str = new StringBuilder();
 		
 		// Latitude
 		str.append(ypos);
 		if (ypos < 0) {
 			str.append("S");
 		} else {
 			str.append("N");
 		}
 		
 		// Longitude
 		str.append(" " + xpos);
 		if (xpos < 0) {
 			str.append("W");
 		} else {
 			str.append("E");
 		}
 		
 		// Date
 		str.append(", " + date.toString());
 		
 		return str.toString();
 	}
 	
 	/***
 	 * Returns a string representation of the latitude
 	 * 
 	 * @return string representation of latitude
 	 */
 	public String getStringLat() {
 		StringBuilder str = new StringBuilder();
 
 		// Latitude
 		str.append(Sexagesimal.toString(ypos));
 		if (ypos < 0) 
 			str.append(" S");
 		else 
 			str.append(" N");
 		
 		return str.toString();
 	}
 	
 	/***
 	 * Returns a string representation of the longitude
 	 * 
 	 * @return string representation of longitude
 	 */
 	public String getStringLon() {
 		StringBuilder str = new StringBuilder();
 
 		// Longitude
 		str.append(Sexagesimal.toString(xpos));
 		if (xpos < 0) {
 			str.append(" W");
 		} else {
 			str.append(" E");
 		}
 		
 		return str.toString();
 	}
 	
 	/***
 	 * Converts degrees in sexagesimal format to decimal format. 
 	 * 
 	 * @param sex sexagesimal formatted angle
 	 * @return degrees in decimal format
 	 */
 	public static double sexToDec(final Sexagesimal sex) {
 		return sexToDec(sex.getDeg(), sex.getMin(), sex.getSec());
 	}
 	
 	/***
 	 * Converts degrees in sexagesimal format to decimal format. 
 	 * 
 	 * @param degrees whole degrees
 	 * @param minutes whole minutes
 	 * @param seconds whole or fractional seconds
 	 * @return degrees in decimal format
 	 */
 	public static double sexToDec(final int degrees, final int minutes,
 			final double seconds) {
 		return (degrees + ((double)minutes / 60) + (seconds / 3600));
 	}
 
 	/***
 	 * Converts degrees in decimal format to NMEA sexagesimal format.
 	 * 
 	 * @param degrees decimal degrees
 	 * @return degrees in NMEAs sexagesimal format with degrees and minutes in
 	 * 		front of the decimal separator and seconds (in 0-99) after in full
 	 * 		decimal format after.
 	 */
 	public static double decToNmea(double degrees) {
 		int deg = (int)degrees;
 		degrees = (degrees - deg) * 60;
 		
 		int min = (int)degrees;
 		degrees = degrees - min;
 		
 		return  ((deg * 100) + min + degrees);
 	}
 
 	/***
 	 * Converts degrees in decimal format to NMEA sexagesimal format. This is
 	 * the old bugged conversion.
 	 * 
 	 * @deprecated Replaced by {@link #decToNmea(double)} to correct a
 	 * 		calculation error.
 	 * @param degrees decimal degrees
 	 * @return degrees in NMEAs sexagesimal format with degrees and minutes in
 	 * 		front of the decimal separator and seconds (in 0-99) after in full
 	 * 		decimal format after.
 	 */
 	@Deprecated
 	public static double decOldToNmea(double degrees) {
 		int deg = (int)degrees;
 		degrees = (degrees - deg) * 60;
 		
 		int min = (int)degrees;
 		degrees = degrees - min;
 		
 		double sec = degrees * 60;
 
 		return  Utils.round((deg * 100) + min + (sec / 100), 4);
 	}
 
 	/***
 	 * Converts degrees in NMEA sexagesimal format to decimal format. 
 	 * 
 	 * @param degrees in NMEA sexagesimal format with degrees and minutes in
 	 * 			front of the decimal separator and seconds after
 	 * @return degrees in decimal format
 	 */
 	public static double nmeaToDec(double degrees) {
 		// Split up the value into sexagesimal format.
 		degrees = degrees / 100;		
 		int deg = (int)degrees;
 		degrees = degrees - deg;
 	
 		degrees = degrees * 100;
 		int min = (int)degrees;
 		degrees = degrees - min;
 	
 		double sec = degrees * 60;
 	
 		return sexToDec(deg, min, sec);
 	}
 
 	/***
 	 * Converts degrees in NMEA sexagesimal format to decimal format. 
 	 * 
 	 * @deprecated Replaced by {@link #nmeaToDec(double)} to correct a
 	 * 		calculation error.
 	 * @param degrees in NMEA sexagesimal format with degrees and minutes in
 	 * 		front of the decimal separator and seconds after
 	 * @return degrees in decimal format
 	 */
 	@Deprecated
 	public static double nmeaOldToDec(double degrees) {
 		// Split up the value into sexagesimal format.
 		degrees = degrees / 100;		
 		int deg = (int)degrees;
 		degrees = degrees - deg;
 	
 		degrees = degrees * 100;
 		int min = (int)degrees;
 		degrees = degrees - min;
 	
 		double sec = degrees * 100;
 	
 		return sexToDec(deg, min, sec);
 	}
 
 	/***
 	 * Returns the Haversine distance from this to another coordinate.
 	 * 
 	 * @param coord destination coordinate
 	 * @return Haversine distance
 	 * @see #haversineDist(double, double, double, double)
 	 */
 	public double haversineDist(final Coordinate coord) {
 		return haversineDist(this, coord);
 	}
 
 	/***
 	 * Returns the Haversine distance between two points.
 	 * 
 	 * @param coord1 first coordinate
 	 * @param coord2 secound coordinate
 	 * @return Haversine distance between two points
 	 * @see #haversineDist(double, double, double, double)
 	 */
 	public static double haversineDist(final Coordinate coord1,
 			final Coordinate coord2) {
 		return haversineDist(coord1.getY(), coord1.getX(),
 				coord2.getY(), coord2.getX());
 	}
 	
 	/***
 	 * Returns the Haversine distance between two points. See
 	 * <a href="http://en.wikipedia.org/wiki/Haversine_formula">Wikipedia</a> or
 	 * <a href="http://www.movable-type.co.uk/scripts/GIS-FAQ-5.1.html">
 	 * GIS-FAQ</a> for more in-depth information on the formula.
 	 * 
 	 * @param lat1 latitude of first coordinate
 	 * @param lon1 longitude of first coordinate
 	 * @param lat2 latitude of second coordinate
 	 * @param lon2 longitude of second coordinate
 	 * @return Haversine distance between the two coordinates
 	 */
 	public static double haversineDist(final double lat1, final double lon1,
 			final double lat2, final double lon2) {
 		final double la1 = toRadians(lat1);
 		final double la2 = toRadians(lat2);
 		final double lo1 = toRadians(lon1);
 		final double lo2 = toRadians(lon2);
 		
 		final double dLat = la2 - la1;
 		final double dLong = lo2 - lo1;
 
 		final double a = sin(dLat / 2) * sin(dLat / 2)
 				+ cos(la1) * cos(la2) * sin(dLong / 2) * sin(dLong / 2);
 
 		return (2 * atan2(sqrt(a), sqrt(1 - a)) * EARTH_RADIUS);
 	}
 	
 	/***
 	 * Returns the sequential Haverside distance between the coordinates. The
 	 * method takes the distance between each consecutive coordinate and adds it
 	 * together. Because of the sequencing of calculations, the order of the
 	 * coordinates in the list determines the total distance.
 	 * 
 	 * @param coords list of coordinates used for distance calculation
 	 * @return total distance between all coordinates
 	 * @see #haversineDist(double, double, double, double)
 	 */
 	public static double haversineDist(final List<Coordinate> coords) {
 		double dist = 0;
 		
 		Iterator<Coordinate> iter = coords.iterator();
 		Coordinate coord, lastCoord;
 		
 		if (iter.hasNext()) {
 			coord = iter.next();
 		} else {
 			return 0;
 		}
 		
 		while (iter.hasNext()) {
 			lastCoord = coord;
 			coord = iter.next();
 			dist += lastCoord.haversineDist(coord); 
 			
 //			dist += coord.haversineDist(coord = iter.next());
 		}
 		
 		return dist;
 	}
 	
 	/***
 	 * Returns the distance between two points according to the law of cosines.
 	 * Use of this method of distance calculation is HIGHLY DISCOURAGED as it is
 	 * unreliable for small distances because the inverse cosine is
 	 * ill-conditioned. 
 	 * 
 	 * @param coord1 first coordinate
 	 * @param coord2 secound coordinate
 	 * @return cosine distance between two points
 	 */
 	public static double cosineDist(final Coordinate coord1,
 			final Coordinate coord2) {
 		final double la1 = toRadians(coord1.getY());
 		final double la2 = toRadians(coord2.getY());
 		final double lo1 = toRadians(coord1.getX());
 		final double lo2 = toRadians(coord2.getX());
 			  
 		return (acos(sin(la1) * sin(la2)
 				+ cos(la1) * cos(la2) * cos(lo2 - lo1)) * EARTH_RADIUS);
 	}
 	
 	/***
 	 * Converts from lat/lon to a UTMpoint containting northing and easting plus
 	 * zone with zone letter
 	 * 
 	 * @param ellipsoidId ellipsoid to use (i.e. WGS84 = 22)
 	 * @param lat points latitude
 	 * @param lon points longitude
 	 * @return UTMPoint with northing/easting + zone and zone letter
 	 */
 	public static UTMPoint llToUTM(final int ellipsoidId, final double lat,
 			final double lon) {
 		final Ellipsoid ellipsoid = ReferenceEllipsoids
 				.getEllipsoid(ellipsoidId);
 		
 		final double const1 = 0.017453292519943295;
 		final double const2 = 0.99960000000000004; 
 		
 		// Getting the values from the reference ellipsoid
 		final double radius = ellipsoid.getRadius();
 		final double eccsq = ellipsoid.getEccentricity();
 
 		final double eccsq2 = eccsq * eccsq;	// Created for a "nicer" formula
 		final double eccsq3 = eccsq2 * eccsq; // Created for a "nicer" formula
 		
 		final double d12 = (lon + 180) - ((int)((lon + 180) / 360) * 360) - 180;
 		final double d13 = lat * const1;
 		
 		final int zoneNumber = decideZoneNum(d12, lat);
 		
 		final double d5 = ((zoneNumber - 1) * 6 - 180) + 3; // False easting?
 
 		final double d14 = d12 * const1;
 		final double d15 = d5 * const1;
 		
 		final double d6 = eccsq / (1 - eccsq);
 		final double d7 = radius / sqrt(1 - eccsq * sin(d13) * sin(d13));
 		final double d8 = tan(d13) * tan(d13);
 		final double d9 = d6 * cos(d13) * cos(d13);
 		final double d10 = cos(d13) * (d14 - d15);
 		final double d11 = radius
 				* ((((1 - eccsq / 4 - (3 * eccsq2) / 64 - (5 * eccsq3) / 256)
 				* d13 - ((3 * eccsq) / 8 + (3 * eccsq2) / 32
 				+ (45 * eccsq3) / 1024) * sin(2 * d13))
 				+ ((15 * eccsq2) / 256 + (45 * eccsq3) / 1024) * sin(4 * d13))
 				- ((35 * eccsq3) / 3072) * sin(6 * d13));
 		final double easting = (const2 * d7 * (d10
 				+ (((1 - d8) + d9) * pow(d10, 3)) / 6
 				+ ((((5 - 18 * d8) + d8 * d8 + 72 * d9) - 58 * d6)
 				* pow(d10, 5)) / 120) + 500000);
 		double northing = (const2 * (d11 + d7 * tan(d13) * ((d10 * d10) / 2
 				+ (((5 - d8) + 9 * d9 + 4 * d9 * d9) * pow(d10, 4)) / 24
 				+ ((((3 * d8) + d8 * d8 + 600 * d9) - 330 * d6)
 				* pow(d10, 6)) / 720)));
 		
 		if (lat < 0) {
 			northing += 1E+007;
 		}
 		return new UTMPoint(northing, easting, zoneNumber,
 				getUTMZoneLetter(lat));
 	}
 
 	/*** 
 	 * Finds the given zone's letter (most of Norway is 32<b>V</b>)
 	 * 
 	 * @param latitude decide zone letter from this value
 	 * @return zone letter.
 	 */
 	private static char getUTMZoneLetter(final double latitude) {
 		char zoneLetter = 'Z';
 		if (84 >= latitude && latitude >= 72) {
 			zoneLetter = 'X';
 		} else if (72 > latitude && latitude >= 64) {
 			zoneLetter = 'W';
 		} else if (64 > latitude && latitude >= 56) {
 			zoneLetter = 'V';
 		} else if (56 > latitude && latitude >= 48) {
 			zoneLetter = 'U';
 		} else if (48 > latitude && latitude >= 40) {
 			zoneLetter = 'T';
 		} else if (40 > latitude && latitude >= 32) {
 			zoneLetter = 'S';
 		} else if (32 > latitude && latitude >= 24) {
 			zoneLetter = 'R';
 		} else if (24 > latitude && latitude >= 16) {
 			zoneLetter = 'Q';
 		} else if (16 > latitude && latitude >= 8) {
 			zoneLetter = 'P';
 		} else if (8 > latitude && latitude >= 0) {
 			zoneLetter = 'N';
 		} else if (0 > latitude && latitude >= -8) {
 			zoneLetter = 'M';
 		} else if (-8 > latitude && latitude >= -16) {
 			zoneLetter = 'L';
 		} else if (-16 > latitude && latitude >= -24) {
 			zoneLetter = 'K';
 		} else if (-24 > latitude && latitude >= -32) {
 			zoneLetter = 'J';
 		} else if (-32 > latitude && latitude >= -40) {
 			zoneLetter = 'H';
 		} else if (-40 > latitude && latitude >= -48) {
 			zoneLetter = 'G';
 		} else if (-48 > latitude && latitude >= -56) {
 			zoneLetter = 'F';
 		} else if (-56 > latitude && latitude >= -64) {
 			zoneLetter = 'E';
 		} else if (-64 > latitude && latitude >= -72) {
 			zoneLetter = 'D';
 		} else if (-72 > latitude && latitude >= -80) {
 			zoneLetter = 'C';
 		}
 		
 		return zoneLetter;
 	}
 	
 	
 	public static Coordinate utmToLl(final int i, final UTMPoint utmpoint) {
 		return utmToLl(i, utmpoint.getNorthing(), utmpoint.getEasting(),
 				utmpoint.getZoneNumber(), utmpoint.getZoneLetter());
 	}
 
 	public static Coordinate utmToLl(final int ellipsoidId,
 			final double northing, final double easting, final int zoneNum,
 			final char zoneLetter) {
 		final double const1 = 57.295779513082323;
 		final double const2 = 0.99960000000000004;
 		
 		if (zoneNum < 0 || zoneNum > 60) {
 			return null;
 		}
 		
 		Ellipsoid ellipsoid = ReferenceEllipsoids.getEllipsoid(ellipsoidId);
 		
 		final double radius = ellipsoid.getRadius();
 		final double eccsq = ellipsoid.getEccentricity();
 		final double d4 = (1 - sqrt(1 - eccsq)) / (1 + sqrt(1 - eccsq));
 		
 		final double d4pow3 = pow(d4, 3);
 		
 		double east = easting - 500000;
 		double north = northing;
 //		final boolean flag;
 		
 		if (zoneLetter >= 'N') {
 //			flag = true;
 		} else {
 //			flag = false;
 			north -= 10000000;
 		}
 		
 		final double d11 = ((zoneNum - 1) * 6 - 180) + 3;
 		final double d3 = eccsq / (1 - eccsq);
 		final double d10 = north / const2;
 		final double d12 = d10 / (radius * (1 - eccsq / 4 - (3 * pow(eccsq, 2))
 				/ 64 - (5 * pow(eccsq, 3)) / 256));
 		final double d14 = d12 + ((3 * d4) / 2 - (27 * d4pow3) / 32)
 				* sin(2 * d12) + ((21 * d4 * d4) / 16
 				- (55 * d4 * d4 * d4 * d4) / 32)
 				* sin(4 * d12) + ((151 * d4pow3) / 96) * sin(6 * d12);
 //		final double d13 = d14 * const1;
 		final double d5 = radius / sqrt(1 - eccsq * sin(d14) * sin(d14));
 		final double d6 = tan(d14) * tan(d14);
 		final double d7 = d3 * cos(d14) * cos(d14);
 		final double d8 = (radius * (1 - eccsq)) / pow(1 - eccsq * sin(d14)
 				* sin(d14), 1.5);
 		final double d9 = east / (d5 * const2);
 		
 		double d17 = d14 - ((d5 * tan(d14)) / d8) * (((d9 * d9) / 2
 				- (((5 + 3 * d6 + 10 * d7) - 4 * d7 * d7 - 9 * d3)
 				* pow(d9, 4)) / 24)
 				+ (((61 + 90 * d6 + 298 * d7 + 45 * d6 * d6)
 				- 252 * d3 - 3 * d7 * d7) * pow(d9, 6)) / 720);
 		d17 *= const1;
 		
 		double d18 = ((d9 - ((1 + 2 * d6 + d7) * pow(d9, 3)) / 6)
 				+ (((((5 - 2 * d7) + 28 * d6) - 3 * d7 * d7)
 				+ 8 * d3 + 24 * d6 * d6) * pow(d9, 5)) / 120) / cos(d14);
 		d18 = d11 + d18 * const1;
 		
 		System.out.println("(TMP) lat " + d17 + ", lon: " + d18);
 		
 //		d17 = Coordinate.decToSexD(d17);
 //		d18 = Coordinate.decToSexD(d18);
 		
 		return new Coordinate(d17, d18);
 	}
 	
 	/***
 	 * Decides a UTM Zone Number for a given latitude and result.
 	 * 
 	 * @param result result
 	 * @param latitude latitude
 	 * @return the zonenumber
 	 */
 	public static int decideZoneNum(final double result,
 			final double latitude) {
 		
 		// Decides zone number
 		int zoneNumber = (int)((result + 180) / 6) + 1;
 		
 		if (latitude >= 56 && latitude < 64 && result >= 3 && result < 12) {
 			zoneNumber = 32;
 		}
 		
 		if (latitude >= 72 && latitude < 84) {
 			if (result >= 0 && result < 9) {
 				zoneNumber = 31;
 			} else if (result >= 9 && result < 21) {
 				zoneNumber = 33;
 			} else if (result >= 21 && result < 33) {
 				zoneNumber = 35;
 			} else if (result >= 33 && result < 42) {
 				zoneNumber = 37;
 			}
 		}
 		return zoneNumber;
 	}
 
 	/*** Returns id of coordinate */
 	public int getCoordId() {
 		return coordId;
 	}
 
 	/*** Returns date of coordinate */
 	public Date getDate() {
 		return date;
 	}
 }