[游戏开发]Unity 经纬度转空间坐标及墨卡托坐标转经纬度等

注：此案例中有用到Mapbox相关库

1. 创建由于Vector2d 结构体

原因：由于Unity中自带的Vector2是float类型，而我们需要用一个结构体来储存精度需求比较高的经纬度数据，故创建Vector2d 及double类型的来储存经纬度数据

namespace Mapbox.Utils
{
    using Mapbox.Json; //此处用到的是Mapbox的Json库
    using System;
	using System.Globalization;

	[Serializable]
	public struct Vector2d
	{
		public const double kEpsilon = 1E-05d;
		public double x;
		public double y;

		public double this[int index]
		{
			get
			{
				switch (index)
				{
					case 0:
						return this.x;
					case 1:
						return this.y;
					default:
						throw new IndexOutOfRangeException("Invalid Vector2d index!");
				}
			}
			set
			{
				switch (index)
				{
					case 0:
						this.x = value;
						break;
					case 1:
						this.y = value;
						break;
					default:
						throw new IndexOutOfRangeException("Invalid Vector2d index!");
				}
			}
		}

		[JsonIgnore]
		public Vector2d normalized
		{
			get
			{
				Vector2d vector2d = new Vector2d(this.x, this.y);
				vector2d.Normalize();
				return vector2d;
			}
		}

		[JsonIgnore]
		public double magnitude
		{
			get
			{
				return Mathd.Sqrt(this.x * this.x + this.y * this.y);
			}
		}

		[JsonIgnore]
		public double sqrMagnitude
		{
			get
			{
				return this.x * this.x + this.y * this.y;
			}
		}

		public static Vector2d zero
		{
			get
			{
				return new Vector2d(0.0d, 0.0d);
			}
		}

		public static Vector2d one
		{
			get
			{
				return new Vector2d(1d, 1d);
			}
		}

		public static Vector2d up
		{
			get
			{
				return new Vector2d(0.0d, 1d);
			}
		}

		public static Vector2d right
		{
			get
			{
				return new Vector2d(1d, 0.0d);
			}
		}

        public static Vector2d ChongMingLatLon
        {
            get
            {
                return new Vector2d(Constants.ChongMingLatitude,Constants.ChongMingLongitude);
            }
        }

		public Vector2d(double x, double y)
		{
			this.x = x;
			this.y = y;
		}

		public static Vector2d operator +(Vector2d a, Vector2d b)
		{
			return new Vector2d(a.x + b.x, a.y + b.y);
		}

		public static Vector2d operator -(Vector2d a, Vector2d b)
		{
			return new Vector2d(a.x - b.x, a.y - b.y);
		}

		public static Vector2d operator -(Vector2d a)
		{
			return new Vector2d(-a.x, -a.y);
		}

		public static Vector2d operator *(Vector2d a, double d)
		{
			return new Vector2d(a.x * d, a.y * d);
		}

		public static Vector2d operator *(float d, Vector2d a)
		{
			return new Vector2d(a.x * d, a.y * d);
		}

		public static Vector2d operator /(Vector2d a, double d)
		{
			return new Vector2d(a.x / d, a.y / d);
		}

		public static bool operator ==(Vector2d lhs, Vector2d rhs)
		{
			return Vector2d.SqrMagnitude(lhs - rhs) < 0.0 / 1.0;
		}

		public static bool operator !=(Vector2d lhs, Vector2d rhs)
		{
			return (double)Vector2d.SqrMagnitude(lhs - rhs) >= 0.0 / 1.0;
		}

		public void Set(double new_x, double new_y)
		{
			this.x = new_x;
			this.y = new_y;
		}

		public static Vector2d Lerp(Vector2d from, Vector2d to, double t)
		{
			t = Mathd.Clamp01(t);
			return new Vector2d(from.x + (to.x - from.x) * t, from.y + (to.y - from.y) * t);
		}

		public static Vector2d MoveTowards(Vector2d current, Vector2d target, double maxDistanceDelta)
		{
			Vector2d vector2 = target - current;
			double magnitude = vector2.magnitude;
			if (magnitude <= maxDistanceDelta || magnitude == 0.0d)
				return target;
			else
				return current + vector2 / magnitude * maxDistanceDelta;
		}

		public static Vector2d Scale(Vector2d a, Vector2d b)
		{
			return new Vector2d(a.x * b.x, a.y * b.y);
		}

		public void Scale(Vector2d scale)
		{
			this.x *= scale.x;
			this.y *= scale.y;
		}

		public void Normalize()
		{
			double magnitude = this.magnitude;
			if (magnitude > 9.99999974737875E-06)
				this = this / magnitude;
			else
				this = Vector2d.zero;
		}

		public override string ToString()
		{
			return string.Format(NumberFormatInfo.InvariantInfo, "{0:F5},{1:F5}", this.y, this.x);
		}

		public override int GetHashCode()
		{
			return this.x.GetHashCode() ^ this.y.GetHashCode() << 2;
		}

		public override bool Equals(object other)
		{
			if (!(other is Vector2d))
				return false;
			Vector2d vector2d = (Vector2d)other;
			if (this.x.Equals(vector2d.x))
				return this.y.Equals(vector2d.y);
			else
				return false;
		}

		public static double Dot(Vector2d lhs, Vector2d rhs)
		{
			return lhs.x * rhs.x + lhs.y * rhs.y;
		}

		public static double Angle(Vector2d from, Vector2d to)
		{
			return Mathd.Acos(Mathd.Clamp(Vector2d.Dot(from.normalized, to.normalized), -1d, 1d)) * 57.29578d;
		}

		public static double Distance(Vector2d a, Vector2d b)
		{
			return (a - b).magnitude;
		}

		public static Vector2d ClampMagnitude(Vector2d vector, double maxLength)
		{
			if (vector.sqrMagnitude > maxLength * maxLength)
				return vector.normalized * maxLength;
			else
				return vector;
		}

		public static double SqrMagnitude(Vector2d a)
		{
			return (a.x * a.x + a.y * a.y);
		}

		public double SqrMagnitude()
		{
			return (this.x * this.x + this.y * this.y);
		}

		public static Vector2d Min(Vector2d lhs, Vector2d rhs)
		{
			return new Vector2d(Mathd.Min(lhs.x, rhs.x), Mathd.Min(lhs.y, rhs.y));
		}

		public static Vector2d Max(Vector2d lhs, Vector2d rhs)
		{
			return new Vector2d(Mathd.Max(lhs.x, rhs.x), Mathd.Max(lhs.y, rhs.y));
		}

		public double[] ToArray()
		{
			double[] array =
			{
					this.x,
					this.y
				};

			return array;
		}
	}
}

RectD 结构体

namespace Mapbox.Utils
{
    /// <summary>
    /// 存放的是最小值、最大值、大小、以及中心点
    /// </summary>
    public struct RectD
    {
        public Vector2d Min { get; private set; }
        public Vector2d Max { get; private set; }
        //size is absolute width&height so Min+size != max
        public Vector2d Size { get; private set; }
        public Vector2d Center { get; private set; }
        
        public RectD(Vector2d min, Vector2d size)
        {
            Min = min;
            Max = min + size;
            Center = new Vector2d(Min.x + size.x / 2, Min.y + size.y / 2);
            Size = new Vector2d(Mathd.Abs(size.x), Mathd.Abs(size.y));
        }

        public bool Contains(Vector2d point)
        {
            bool flag = Size.x < 0.0 && point.x <= Min.x && point.x > (Min.x + Size.x) || Size.x >= 0.0 && point.x >= Min.x && point.x < (Min.x + Size.x);
            return flag && (Size.y < 0.0 && point.y <= Min.y && point.y > (Min.y + Size.y) || Size.y >= 0.0 && point.y >= Min.y && point.y < (Min.y + Size.y));
        }
    }
}

以下为坐标转换代码(此代码中包含与MapBox Tile 相关转换方法，如没有用到Tile可忽略)：

namespace Mapbox.Unity.Utilities
{
	using System;
    using Mapbox.Utils; // Vector2d 所在的库需要引用进来
	using UnityEngine;
	using System.Globalization;

    /// <summary>
    /// A set of Geo and Terrain Conversion utils.
    /// </summary>
    public static class Conversions
	{
		private const int TileSize = 256;
		/// <summary>according to https://wiki.openstreetmap.org/wiki/Zoom_levels</summary>
		private const int EarthRadius = 6378137; //no seams with globe example
		private const double InitialResolution = 2 * Math.PI * EarthRadius / TileSize;
		private const double OriginShift = 2 * Math.PI * EarthRadius / 2;
        private const double EARTH_RADIUS = 6378137.0;//地球半径

        /// <summary>
        /// Converts <see cref="T:Mapbox.Utils.Vector2d"/> struct, WGS84
        /// lat/lon to Spherical Mercator EPSG:900913 xy meters.
        /// </summary>
        /// <param name="v"> The <see cref="T:Mapbox.Utils.Vector2d"/>. </param>
        /// <returns> A <see cref="T:UnityEngine.Vector2d"/> of coordinates in meters. </returns>
        public static Vector2d LatLonToMeters(Vector2d v)
        {
            return LatLonToMeters(v.x, v.y);
        }

        /// <summary>
        /// Convert a simple string to a latitude longitude.
        /// Expects format: latitude, longitude
        /// </summary>
        /// <returns>The lat/lon as Vector2d.</returns>
        /// <param name="s">string.</param>
        public static Vector2d StringToLatLon(string s)
		{
			var latLonSplit = s.Split(',');
			if (latLonSplit.Length != 2)
			{
				throw new ArgumentException("Wrong number of arguments");
			}

			double latitude = 0;
			double longitude = 0;

			if (!double.TryParse(latLonSplit[0], NumberStyles.Any, NumberFormatInfo.InvariantInfo, out latitude))
			{
				throw new Exception(string.Format("Could not convert latitude to double: {0}", latLonSplit[0]));
			}

			if (!double.TryParse(latLonSplit[1], NumberStyles.Any, NumberFormatInfo.InvariantInfo, out longitude))
			{
				throw new Exception(string.Format("Could not convert longitude to double: {0}", latLonSplit[1]));
			}

			return new Vector2d(latitude, longitude);
		}

		/// <summary>
		/// Converts WGS84 lat/lon to Spherical Mercator EPSG:900913 xy meters.
		/// SOURCE: http://stackoverflow.com/questions/12896139/geographic-coordinates-converter.
		/// </summary>
		/// <param name="lat"> The latitude. </param>
		/// <param name="lon"> The longitude. </param>
		/// <returns> A <see cref="T:UnityEngine.Vector2d"/> of xy meters. </returns>
		public static Vector2d LatLonToMeters(double lat, double lon)
		{
			var posx = lon * OriginShift / 180;
			var posy = Math.Log(Math.Tan((90 + lat) * Math.PI / 360)) / (Math.PI / 180);
			posy = posy * OriginShift / 180;
			return new Vector2d(posx, posy);
		}

		/// <summary>
		/// Converts WGS84 lat/lon to x/y meters in reference to a center point
		/// </summary>
		/// <param name="lat"> The latitude. </param>
		/// <param name="lon"> The longitude. </param>
		/// <param name="refPoint"> A <see cref="T:UnityEngine.Vector2d"/> center point to offset resultant xy, this is usually map's center mercator</param>
		/// <param name="scale"> Scale in meters. (default scale = 1) </param>
		/// <returns> A <see cref="T:UnityEngine.Vector2d"/> xy tile ID. </returns>
		/// <example>
		/// Converts a Lat/Lon of (37.7749, 122.4194) into Unity coordinates for a map centered at (10,10) and a scale of 2.5 meters for every 1 Unity unit 
		/// <code>
		/// var worldPosition = Conversions.GeoToWorldPosition(37.7749, 122.4194, new Vector2d(10, 10), (float)2.5);
		/// // worldPosition = ( 11369163.38585, 34069138.17805 )
		/// </code>
		/// </example>
		public static Vector2d GeoToWorldPosition(double lat, double lon, Vector2d refPoint, float scale = 1)
		{
			var posx = lon * OriginShift / 180;
			var posy = Math.Log(Math.Tan((90 + lat) * Math.PI / 360)) / (Math.PI / 180);
			posy = posy * OriginShift / 180;
			return new Vector2d((posx - refPoint.x) * scale, (posy - refPoint.y) * scale);
		}

		public static Vector2d GeoToWorldPosition(Vector2d latLong, Vector2d refPoint, float scale = 1)
		{
			return GeoToWorldPosition(latLong.x, latLong.y, refPoint, scale);
		}

		public static Vector3 GeoToWorldGlobePosition(double lat, double lon, float radius)
		{
			double xPos = (radius) * Math.Cos(Mathf.Deg2Rad * lat) * Math.Cos(Mathf.Deg2Rad * lon);
			double zPos = (radius) * Math.Cos(Mathf.Deg2Rad * lat) * Math.Sin(Mathf.Deg2Rad * lon);
			double yPos = (radius) * Math.Sin(Mathf.Deg2Rad * lat);

			return new Vector3((float)xPos, (float)yPos, (float)zPos);
		}


		public static Vector3 GeoToWorldGlobePosition(Vector2d latLong, float radius)
		{
			return GeoToWorldGlobePosition(latLong.x, latLong.y, radius);
		}

		public static Vector2d GeoFromGlobePosition(Vector3 point, float radius)
		{
			float latitude = Mathf.Asin(point.y / radius);
			float longitude = Mathf.Atan2(point.z, point.x);
			return new Vector2d(latitude * Mathf.Rad2Deg, longitude * Mathf.Rad2Deg);
		}

		/// <summary>
		/// Converts Spherical Mercator EPSG:900913 in xy meters to WGS84 lat/lon. 
		/// Inverse of LatLonToMeters.
		/// </summary>
		/// <param name="m"> A <see cref="T:UnityEngine.Vector2d"/> of coordinates in meters.  </param>
		/// <returns> The <see cref="T:Mapbox.Utils.Vector2d"/> in lat/lon. </returns>

		/// <example>
		/// Converts EPSG:900913 xy meter coordinates to lat lon 
		/// <code>
		/// var worldPosition =  new Vector2d (4547675.35434,13627665.27122);
		/// var latlon = Conversions.MetersToLatLon(worldPosition);
		/// // latlon = ( 37.77490, 122.41940 )
		/// </code>
		/// </example>
		public static Vector2d MetersToLatLon(Vector2d m)
		{
			var vx = (m.x / OriginShift) * 180;
			var vy = (m.y / OriginShift) * 180;
			vy = 180 / Math.PI * (2 * Math.Atan(Math.Exp(vy * Math.PI / 180)) - Math.PI / 2);
			return new Vector2d(vy, vx);
		}

		/// <summary>
		/// Gets the xy tile ID from Spherical Mercator EPSG:900913 xy coords.
		/// </summary>
		/// <param name="m"> <see cref="T:UnityEngine.Vector2d"/> XY coords in meters. </param>
		/// <param name="zoom"> Zoom level. </param>
		/// <returns> A <see cref="T:UnityEngine.Vector2d"/> xy tile ID. </returns>
		/// 
		/// <example>
		/// Converts EPSG:900913 xy meter coordinates to web mercator tile XY coordinates at zoom 12.
		/// <code>
		/// var meterXYPosition = new Vector2d (4547675.35434,13627665.27122);
		/// var tileXY = Conversions.MetersToTile (meterXYPosition, 12);
		/// // tileXY = ( 655, 2512 )
		/// </code>
		/// </example>
		public static Vector2 MetersToTile(Vector2d m, int zoom)
		{
			var p = MetersToPixels(m, zoom);
			return PixelsToTile(p);
		}

		/// <summary>
		/// Gets the tile bounds in Spherical Mercator EPSG:900913 meters from an xy tile ID.
		/// </summary>
		/// <param name="tileCoordinate"> XY tile ID. </param>
		/// <param name="zoom"> Zoom level. </param>
		/// <returns> A <see cref="T:UnityEngine.Rect"/> in meters. </returns>
		public static RectD TileBounds(Vector2 tileCoordinate, int zoom)
		{
			var min = PixelsToMeters(new Vector2d(tileCoordinate.x * TileSize, tileCoordinate.y * TileSize), zoom);
			var max = PixelsToMeters(new Vector2d((tileCoordinate.x + 1) * TileSize, (tileCoordinate.y + 1) * TileSize), zoom);
			return new RectD(min, max - min);
		}

		public static Vector2 LatitudeLongitudeToUnityTilePosition(Vector2d coordinate, UnityTile tile, ulong layerExtent = 4096)
		{
			return LatitudeLongitudeToUnityTilePosition(coordinate, tile.CurrentZoom, tile.TileScale, layerExtent);
		}

		/// <summary>
		/// Get coordinates for a given latitude/longitude in tile-space. Useful when comparing feature geometry to lat/lon coordinates.
		/// </summary>
		/// <returns>The longitude to tile position.</returns>
		/// <param name="coordinate">Coordinate.</param>
		/// <param name="tileZoom">The zoom level of the tile.</param>
		/// <param name="tileScale">Tile scale. Optional, but recommended. Defaults to a scale of 1.</param>
		/// <param name="layerExtent">Layer extent. Optional, but recommended. Defaults to 4096, the standard for Mapbox Tiles</param>
		public static Vector2 LatitudeLongitudeToUnityTilePosition(Vector2d coordinate, int tileZoom, float tileScale, ulong layerExtent = 4096)
		{
			var coordinateTileId = Conversions.LatitudeLongitudeToTileId(
				coordinate.x, coordinate.y, tileZoom);
			var _rect = Conversions.TileBounds(coordinateTileId);

			//vectortile space point (0 - layerExtent)
			var vectorTilePoint = LatitudeLongitudeToVectorTilePosition(coordinate, tileZoom, layerExtent);

			//UnityTile space
			var unityTilePoint = new Vector2((float)(vectorTilePoint.x / layerExtent * _rect.Size.x - (_rect.Size.x / 2)) * tileScale,
			                                 (float)((layerExtent - vectorTilePoint.y) / layerExtent * _rect.Size.y - (_rect.Size.y / 2)) * tileScale);

			return unityTilePoint;
		}

		/// <summary>
		/// Gets the WGS84 longitude of the northwest corner from a tile's X position and zoom level.
		/// See: http://wiki.openstreetmap.org/wiki/Slippy_map_tilenames.
		/// </summary>
		/// <param name="x"> Tile X position. </param>
		/// <param name="zoom"> Zoom level. </param>
		/// <returns> NW Longitude. </returns>
		public static double TileXToNWLongitude(int x, int zoom)
		{
			var n = Math.Pow(2.0, zoom);
			var lon_deg = x / n * 360.0 - 180.0;
			return lon_deg;
		}

		/// <summary>
		/// Gets the WGS84 latitude of the northwest corner from a tile's Y position and zoom level.
		/// See: http://wiki.openstreetmap.org/wiki/Slippy_map_tilenames.
		/// </summary>
		/// <param name="y"> Tile Y position. </param>
		/// <param name="zoom"> Zoom level. </param>
		/// <returns> NW Latitude. </returns>
		public static double TileYToNWLatitude(int y, int zoom)
		{
			var n = Math.Pow(2.0, zoom);
			var lat_rad = Math.Atan(Math.Sinh(Math.PI * (1 - 2 * y / n)));
			var lat_deg = lat_rad * 180.0 / Math.PI;
			return lat_deg;
		}

		/// <summary>
		/// Gets the <see cref="T:Mapbox.Utils.Vector2dBounds"/> of a tile.
		/// </summary>
		/// <param name="x"> Tile X position. </param>
		/// <param name="y"> Tile Y position. </param>
		/// <param name="zoom"> Zoom level. </param>
		/// <returns> The <see cref="T:Mapbox.Utils.Vector2dBounds"/> of the tile. </returns>
		public static Vector2dBounds TileIdToBounds(int x, int y, int zoom)
		{
			var sw = new Vector2d(TileYToNWLatitude(y, zoom), TileXToNWLongitude(x + 1, zoom));
			var ne = new Vector2d(TileYToNWLatitude(y + 1, zoom), TileXToNWLongitude(x, zoom));
			return new Vector2dBounds(sw, ne);
		}

		/// <summary>
		/// Gets the WGS84 lat/lon of the center of a tile.
		/// </summary>
		/// <param name="x"> Tile X position. </param>
		/// <param name="y"> Tile Y position. </param>
		/// <param name="zoom"> Zoom level. </param>
		/// <returns>A <see cref="T:UnityEngine.Vector2d"/> of lat/lon coordinates.</returns>
		public static Vector2d TileIdToCenterLatitudeLongitude(int x, int y, int zoom)
		{
			var bb = TileIdToBounds(x, y, zoom);
			var center = bb.Center;
			return new Vector2d(center.x, center.y);
		}


		/// <summary>
		/// Gets the Web Mercator x/y of the center of a tile.
		/// </summary>
		/// <param name="x"> Tile X position. </param>
		/// <param name="y"> Tile Y position. </param>
		/// <param name="zoom"> Zoom level. </param>
		/// <returns>A <see cref="T:UnityEngine.Vector2d"/> of lat/lon coordinates.</returns>
		public static Vector2d TileIdToCenterWebMercator(int x, int y, int zoom)
		{
			double tileCnt = Math.Pow(2, zoom);
			double centerX = x + 0.5;
			double centerY = y + 0.5;

			centerX = ((centerX / tileCnt * 2) - 1) * Constants.WebMercMax;
			centerY = (1 - (centerY / tileCnt * 2)) * Constants.WebMercMax;
			return new Vector2d(centerX, centerY);
		}

		/// <summary>
		/// Gets the meters per pixels at given latitude and zoom level for a 256x256 tile.
		/// See: http://wiki.openstreetmap.org/wiki/Zoom_levels.
		/// </summary>
		/// <param name="latitude"> The latitude. </param>
		/// <param name="zoom"> Zoom level. </param>
		/// <returns> Meters per pixel. </returns>
		public static float GetTileScaleInMeters(float latitude, int zoom)
		{
			return (float)(40075016.685578d * Math.Cos(Mathf.Deg2Rad * latitude) / Math.Pow(2f, zoom + 8));
		}

		/// <summary>
		/// Gets the degrees per tile at given zoom level for Web Mercator tile.
		/// See: http://wiki.openstreetmap.org/wiki/Zoom_levels.
		/// </summary>
		/// <param name="latitude"> The latitude. </param>
		/// <param name="zoom"> Zoom level. </param>
		/// <returns> Degrees per tile. </returns>
		public static float GetTileScaleInDegrees(float latitude, int zoom)
		{
			return (float)(360.0f / Math.Pow(2f, zoom + 8));
		}

		/// <summary>
		/// Gets height from terrain-rgb adjusted for a given scale.
		/// </summary>
		/// <param name="color"> The <see cref="T:UnityEngine.Color"/>. </param>
		/// <param name="relativeScale"> Relative scale. </param>
		/// <returns> Adjusted height in meters. </returns>
		public static float GetRelativeHeightFromColor(Color color, float relativeScale)
		{
			return GetAbsoluteHeightFromColor(color) * relativeScale;
		}

		/// <summary>
		/// Specific formula for mapbox.terrain-rgb to decode height values from pixel values.
		/// See: https://www.mapbox.com/blog/terrain-rgb/.
		/// </summary>
		/// <param name="color"> The <see cref="T:UnityEngine.Color"/>. </param>
		/// <returns> Height in meters. </returns>
		public static float GetAbsoluteHeightFromColor(Color color)
		{
			return (float)(-10000 + ((color.r * 255 * 256 * 256 + color.g * 255 * 256 + color.b * 255) * 0.1));
		}

		public static float GetAbsoluteHeightFromColor32(Color32 color)
		{
			return (float)(-10000 + ((color.r * 256 * 256 + color.g * 256 + color.b) * 0.1));
		}

		public static float GetAbsoluteHeightFromColor(float r, float g, float b)
		{
			return (float)(-10000 + ((r * 256 * 256 + g * 256 + b) * 0.1));
		}

		private static double Resolution(int zoom)
		{
			return InitialResolution / Math.Pow(2, zoom);
		}

		private static Vector2d PixelsToMeters(Vector2d p, int zoom)
		{
			var res = Resolution(zoom);
			var met = new Vector2d();
			met.x = (p.x * res - OriginShift);
			met.y = -(p.y * res - OriginShift);
			return met;
		}

		private static Vector2d MetersToPixels(Vector2d m, int zoom)
		{
			var res = Resolution(zoom);
			var pix = new Vector2d(((m.x + OriginShift) / res), ((-m.y + OriginShift) / res));
			return pix;
		}

		private static Vector2 PixelsToTile(Vector2d p)
		{
			var t = new Vector2((int)Math.Ceiling(p.x / (double)TileSize) - 1, (int)Math.Ceiling(p.y / (double)TileSize) - 1);
			return t;
		}



        /// <summary>
        /// 经纬度转空间坐标点(2D地图加载完成之后)
        /// </summary>
        /// <param name="centerLatLon">经纬度</param>
        /// <returns>墨卡托(空间)坐标点</returns>
        public static Vector3 LatLonToWorldPosition(Vector2d centerLatLon)
        {

            //撒的点的经纬度转换为墨卡托空间坐标点(空间坐标点)    撒点的转换问题 先转化为墨卡托坐标点然后进行位置偏移运算
            //转换经纬度坐标为空间墨卡托坐标
            Vector2d centerMetersLatLon = LatLonToMeters(centerLatLon);
            //Debug.Log("墨卡托坐标X轴：" + centerMetersLatLon.x + "墨卡托坐标Y轴：" + centerMetersLatLon.y);

            //Debug.Log("AbstractMap X轴：" + AbstractMap.Instance.CenterMercator.x + "AbstractMap Y轴" + AbstractMap.Instance.CenterMercator.y);
            //和设定的中心点位置进行对比，得到相对偏移位置
            var offsetX = (float)(centerMetersLatLon.x - AbstractMap.Instance.CenterMercator.x);
            var offsetY = (float)(centerMetersLatLon.y - AbstractMap.Instance.CenterMercator.y);

            //Debug.Log("偏移的X轴位置：" + offsetX + "偏移的Y轴位置：" + offsetY);
            //Debug.Log("MapBox的世界相对坐标的值：" + (double)AbstractMap.Instance.WorldRelativeScale);
            //现实计算: U3D 比例尺  直接使用MapBox的世界相对缩放的值
            var px = (float)offsetX /** 0.02044166*/* AbstractMap.Instance.WorldRelativeScale;
            var pz = (float)offsetY /** 0.02044166*/* AbstractMap.Instance.WorldRelativeScale;

            return new Vector3(px, 0, pz);
        }

        /// <summary>
        /// 将地图空间中的位置转换为经纬度(2D地图加载完成之后)
        /// </summary>
        /// <param name="realworldPoint">空间中的点</param>
        /// <returns>空间中点的经纬度</returns>
        public static Vector2d WorldPosToLatLonPosition(Vector3 realworldPoint)
        {
            return AbstractMap.Instance.WorldToGeoPosition(realworldPoint);
        }

        /// <summary>
        /// 经纬度转空间坐标点(2D地图加载完成之后) 进行了缩放值计算的
        /// </summary>
        /// <param name="centerLatLon">经纬度</param>
        /// <returns>墨卡托(空间)坐标点</returns>
        public static Vector3 CenterLatLonToPosition(Vector2d centerLatLon)
        {
            //撒的点的经纬度转换为墨卡托空间坐标点(空间坐标点)    撒点的转换问题 先转化为墨卡托坐标点然后进行位置偏移运算
            //转换经纬度坐标为空间墨卡托坐标
            Vector2d centerMetersLatLon = LatLonToMeters(centerLatLon);
            //Debug.Log("墨卡托坐标X轴：" + centerMetersLatLon.x + "墨卡托坐标Y轴：" + centerMetersLatLon.y);

            //Debug.Log("AbstractMap X轴：" + AbstractMap.Instance.CenterMercator.x + "AbstractMap Y轴" + AbstractMap.Instance.CenterMercator.y);
            //和设定的中心点位置进行对比，得到相对偏移位置
            var offsetX = (float)(centerMetersLatLon.x - AbstractMap.Instance.CenterMercator.x);
            var offsetY = (float)(centerMetersLatLon.y - AbstractMap.Instance.CenterMercator.y);

            //Debug.Log("偏移的X轴位置：" + offsetX + "偏移的Y轴位置：" + offsetY);
            //Debug.Log("MapBox的世界相对坐标的值：" + (double)AbstractMap.Instance.WorldRelativeScale);
            //现实计算: U3D 比例尺  直接使用MapBox的世界相对缩放的值
            var px = (float)offsetX /** 0.02044166*/* AbstractMap.Instance.WorldRelativeScale;
            var pz = (float)offsetY /** 0.02044166*/* AbstractMap.Instance.WorldRelativeScale;

            //Debug.Log("在世界坐标系中的X和Z值 PX：" + px + "PZ："+ pz);

            //return new Vector3(px, 0, pz);
           // Debug.Log("值：" + Mathf.Abs(AbstractMap.Instance.Zoom - AbstractMap.Instance.AbsoluteZoom) >= 1);
            //if (Mathf.Abs(AbstractMap.Instance.Zoom - AbstractMap.Instance.AbsoluteZoom) >= 1)
            //{
            //    var worldx = px / (AbstractMap.Instance.transform.localScale.x/2);
            //    var worldz = pz / (AbstractMap.Instance.transform.localScale.z/2);
            //    return new Vector3(px, 0, pz);
            //}
            //Debug.Log("PX:" + px + "PZ:" + pz);
            //Debug.Log("当前2D地图的缩放值：" + AbstractMap.Instance.transform.localScale);
            var worldPx = px * AbstractMap.Instance.transform.localScale.x;
            var worldPz = pz * AbstractMap.Instance.transform.localScale.z;
            //Debug.Log("改变前的值。。。。。worldPx:" + worldPx +"  其中Abstract的值和AbsMap的值：" + AbstractZoom + "地图缩放层级的值：" + AbstractMap.Instance.AbsoluteZoom);

            //if (AbstractZoom != AbstractMap.Instance.AbsoluteZoom)
            //{
            //    AbstractZoom = AbstractMap.Instance.AbsoluteZoom;
            //    worldPx = worldPx * 2f;
            //    worldPz = worldPz * 2f;
            //    Debug.Log("改变后的值worldPx:" + worldPx);
            //}

            //Debug.Log("当前经纬度转空间坐标点：" + worldPx + "当前的经纬度Z值：" + worldPz);

            return new Vector3(worldPx, 0, worldPz);
        }

        /// <summary>
        /// MapBox里面的经纬度转空间坐标点的方法
        /// </summary>
        /// <param name="centerlatLon">经纬度</param>
        /// <returns>空间坐标点</returns>
        public static Vector3 LatLonToPositionWorld(Vector2d centerlatLon)
        {
            return AbstractMap.Instance.GeoToWorldPosition(centerlatLon);
        }

        /// <summary>
        /// 地图2D瓦片更新
        /// </summary>
        public static void UpdateMap(Vector2d latLon, float zoom)
        {
            AbstractMap.Instance.UpdateMap(latLon,zoom);
        }

        /// <summary>
        /// 将地图空间中的位置转换为经纬度(2D地图加载完成之后)
        /// </summary>
        /// <param name="realworldPoint">空间中的点</param>
        /// <returns>空间中点的经纬度</returns>
        public static Vector2d WorldToGeoPosition(Vector3 realworldPoint)
        {
            float scale = AbstractMap.Instance.transform.localScale.x;
            Vector3 worldPoint = new Vector3(realworldPoint.x*scale,realworldPoint.y*scale,realworldPoint.z*scale);
            //return AbstractMap.Instance.WorldToGeoPosition(realworldPoint);
            return AbstractMap.Instance.WorldToGeoPosition(worldPoint);
        }

        /// <summary>
        /// 计算两个经纬度之间的距离(单位为米)
        /// </summary>
        /// <param name="longitude1">当前点的经度</param>
        /// <param name="latitude1">当前点的纬度</param>
        /// <param name="longitude2">下一个点的经度</param>
        /// <param name="latitude2">下一个点的纬度</param>
        /// <returns>返回的是两个点之间的距离</returns>
        public static double GetDistance(double longitude1, double latitude1,
                double longitude2, double latitude2)
        {

            double Lat1 = rad(latitude1);
            double Lat2 = rad(latitude2);
            double a = Lat1 - Lat2;
            double b = rad(longitude1) - rad(longitude2);
            double s = 2 * Math.Asin(Math.Sqrt(Math.Pow(Math.Sin(a / 2), 2)
                    + Math.Cos(Lat1) * Math.Cos(Lat2)
                    * Math.Pow(Math.Sin(b / 2), 2)));
            s = s * EARTH_RADIUS;
            s = Math.Round(s * 10000) / 10000;
            return s;
        }

        private static double rad(double d)
        {
            return d * Math.PI / 180.0;
        }
    }
}