var a = 6378.137;
var e = 0.0818192;
var k0 = 0.9996;
var e2 = e * e; //e的平方
var e4 = e2 * e2; //e的4次方
var e6 = e4 * e2; //e的6次方
var E0 = 500;
var N0 = 0;

/**经纬度转XY的方法
 *String lon经度
 *String lat纬度 
 */
export function gps2xybiandianzhan(yuandianjd, yuandianwd, lon, lat) {
	// var yuandianjd = Dell_JZGGA.getYuandianjd(); //原点的经度
	// var yuandianwd = Dell_JZGGA.getYuandianwd(); //原点的纬度
	var xy = run_gps2xyurt(yuandianwd, yuandianjd, lat, lon);
	return xy;
}
/**将实时经纬度转为XY坐标输出
 *@param 原点纬度lat0
 * @param 原点经度lon0
 * @param lat 时时纬度
 * @param lon 时时经度
 */
function run_gps2xyurt(lat0, lon0, lat, lon) {
	var realxy = new Array(2).join(',').split(',');
	var xycs = initiize_ublox_zeropoint(lat0, lon0, 0);
	var x0 = xycs[0];
	var y0 = xycs[1];
	var c = xycs[2];
	var s = xycs[3];

	var xy = new Array(2).join(',').split(',');
	var x = ubloxraw2xy(lat, lon)[0] - x0;
	var y = ubloxraw2xy(lat, lon)[1] - y0;
	xy[0] = c * x - s * y;
	xy[1] = s * x + c * y;

	var x1 = xy[1] * 100;
	var y1 = xy[0] * 100;

	realxy[0] = x1;
	realxy[1] = y1;
	return realxy;
}
/**初始化原点位置和方向
 * 输出原点以米为单位的xy坐标, cos值, sin值*/
function initiize_ublox_zeropoint(lat, lon, th) {
	var xycs = new Array(4).join(',').split(',');
	xycs[0] = ubloxraw2xy(lat, lon)[0];
	xycs[1] = ubloxraw2xy(lat, lon)[1];
	var th1 = th * Math.PI / 180; //x轴与正北方向夹角th(单位是度)
	xycs[2] = Math.cos(th1);
	xycs[3] = Math.sin(th1);
	return xycs;
}
/**输入ublox的度分经纬度，输出xy,单位米*/
function ubloxraw2xy(lat, lon) {
	var xy = new Array(3).join(',').split(',');
	var lond = ublox_dm2d(lon);
	var latd = ublox_dm2d(lat);
	var dxy = utm(latd, lond);
	xy[0] = dxy[0] * 1000;
	xy[1] = dxy[1] * 1000;
	xy[2] = dxy[2];
	return xy;

}
/**将度分格式数据转为度格式输出*/
function ublox_dm2d(ddmm_dot_m) {
	var d0 = Math.floor(ddmm_dot_m / 100);
	var d = d0 + (ddmm_dot_m - d0 * 100) / 60;
	return d;
}
/**通过经纬度获取XY坐标*/
function utm(lat, lon) {
	var dxy = new Array(3).join(',').split(',');

	var zonenum1 = lon / 6;
	//floor是地板的意思，表示向下取整
	if (zonenum1 > 0) {
		zonenum1 = Math.floor(zonenum1);
	} else { //向上取整
		zonenum1 = Math.ceil(zonenum1); //向上取整
	}

	var Zonenum = zonenum1 + 31;

	var lambda0 = ((Zonenum - 1) * 6 - 180 + 3) * (Math.PI) / 180;

	var phi = lat * (Math.PI) / 180;

	var lambda = lon * (Math.PI) / 180;

	var v = 1 / Math.sqrt((1 - e2 * Math.pow(Math.sin(phi), 2)));

	var A = (lambda - lambda0) * Math.cos(phi);
	var A2 = A * A;
	var A3 = A2 * A;
	var A4 = A3 * A;
	var A5 = A4 * A;
	var A6 = A5 * A;

	var T = Math.tan(phi) * Math.tan(phi);
	var T2 = T * T;

	var C = e2 * Math.cos(phi) * Math.cos(phi) / (1 - e2);
	var C2 = C * C;

	var s = (1 - e2 / 4 - 3 * e4 / 64 - 5 * e6 / 256) * phi -
		(3 * e2 / 8 + 3 * e4 / 32 + 45 * e6 / 1024) * Math.sin(2 * phi) +
		(15 * e4 / 256 + 45 * e6 / 1024) * Math.sin(4 * phi) - 35 * e6 / 3072 * Math.sin(6 * phi);

	dxy[0] = E0 + k0 * a * v * (A + (1 - T + C) * A3 / 6 + (5 - 18 * T + T2) * A5 / 120);

	dxy[1] = N0 + k0 * a * (s + v * Math.tan(phi) * (A2 / 2 + (5 - T + 9 * C + 4 * C2) * A4 / 24 + (61 - 58 * T + T2) *
		A6 / 720));
	dxy[2] = Zonenum;
	return dxy;
}

/** 
 * 判断点是否在多边形内 
 * @param point 检测点 
 * @param pts   多边形的顶点集合 
 * @return 点在多边形内返回true,否则返回false 
 */
export function inPoly(point, pts) {
	var N = pts.length;
	var boundOrVertex = true; //如果点位于多边形的顶点或边上，也算做点在多边形内，直接返回true  
	var intersectCount = 0;
	var precision = 2e-10; //浮点类型计算时候与0比较时候的容差  
	var p1, p2;
	var p = point; //当前点  

	p1 = pts[0];
	for (var i = 1; i <= N; ++i) {
		if (p == p1) {
			return boundOrVertex;
		}
		p2 = pts[i % N];
		if (p.x < Math.min(p1.x, p2.x) || p.x > Math.max(p1.x, p2.x)) {
			p1 = p2;
			continue;
		}

		if (p.x > Math.min(p1.x, p2.x) && p.x < Math.max(p1.x, p2.x)) {
			if (p.y <= Math.max(p1.y, p2.y)) {
				if (p1.x == p2.x && p.y >= Math.min(p1.y, p2.y)) {
					return boundOrVertex;
				}

				if (p1.y == p2.y) {
					if (p1.y == p.y) {
						return boundOrVertex;
					} else {
						++intersectCount;
					}
				} else {
					var xinters = (p.x - p1.x) * (p2.y - p1.y) / (p2.x - p1.x) + p1.y;
					if (Math.abs(p.y - xinters) < precision) {
						return boundOrVertex;
					}

					if (p.y < xinters) {
						++intersectCount;
					}
				}
			}
		} else {
			if (p.x == p2.x && p.y <= p2.y) {
				var p3 = pts[(i + 1) % N];
				if (p.x >= Math.min(p1.x, p3.x) && p.x <= Math.max(p1.x, p3.x)) {
					++intersectCount;
				} else {
					intersectCount += 2;
				}
			}
		}
		p1 = p2;
	}

	if (intersectCount % 2 == 0) {
		return false;
	} else {
		return true;
	}

}