//随机生成十六进制颜色
function randomHexColor() {
	var hex = Math.floor(Math.random() * 16777216).toString(16); //生成ffffff以内16进制数
	while (hex.length < 6) { //while循环判断hex位数，少于6位前面加0凑够6位
		hex = '0' + hex;
	}
	return '#' + hex; //返回‘#'开头16进制颜色
}
Array.prototype.getRandomItem = function() {
	return this[Math.floor(Math.random() * this.length)];
};

//字符串数据转数字字符串
function stringToNumber(stringInput) {
	var stringArray = stringInput.split(",");
	var numberArrayOutput = new Array();
	for (var i = 0; i < stringArray.length; i++) {
		numberArrayOutput.push(Number(stringArray[i]));
	}
	return numberArrayOutput;
}

//截取字符串，返回经度数值，cj添加,mty改为判断
function substringLon(str) {
	var lon,
		lon1,
		lon2;
	if (str.toString().substring(0, 1) !== '1') {
		lon1 = str.toString().substring(0, 2);
		lon2 = str.toString().substring(2);
	} else {
		lon1 = str.toString().substring(0, 3);
		lon2 = str.toString().substring(3);
	}
	if(str.indexOf('.')==-1){
		lon = Number(lon1 + "." + lon2);
	}else{
		lon = Number(lon1 + lon2);
	}
	return lon;
}

//截取字符串，返回纬度数值，cj添加
function substringLat(str) {
	var lat1 = str.toString().substring(0, 2);
	var lat2 = str.toString().substring(2);
	var lat;
	if(str.indexOf('.')==-1){
		lat = Number(lat1 + "." + lat2);
	}else{
		lat = Number(lat1 + lat2);
	}
	return lat;
}

//定义一些常量
var x_PI = 3.14159265358979324 * 3000.0 / 180.0;
var PI = 3.1415926535897932384626;
var a = 6378245.0;
var ee = 0.00669342162296594323;

//将WGS84坐标系，转换成百度坐标体系
function wgs84tobd09(lon, lat) {
	var gcj02poi1 = wgs84togcj02(lon, lat);
	var baidupoi1 = gcj02tobd09(gcj02poi1[0], gcj02poi1[1]);
	return baidupoi1;
}
//将百度坐标体系，转换成WGS84坐标系
function bd09towgs84(lon, lat) {
	var gcj02poi1 = bd09togcj02(lon, lat);
	var wgs84poi1 = gcj02towgs84(gcj02poi1[0], gcj02poi1[1]);
	return wgs84poi1;
}
/**
 * 百度坐标系 (BD-09) 与 火星坐标系 (GCJ-02)的转换
 * 即 百度 转 谷歌、高德
 * @param bd_lon
 * @param bd_lat
 * @returns {*[]}
 */
function bd09togcj02(bd_lon, bd_lat) {
	var x_pi = 3.14159265358979324 * 3000.0 / 180.0;
	var x = bd_lon - 0.0065;
	var y = bd_lat - 0.006;
	var z = Math.sqrt(x * x + y * y) - 0.00002 * Math.sin(y * x_pi);
	var theta = Math.atan2(y, x) - 0.000003 * Math.cos(x * x_pi);
	var gg_lng = z * Math.cos(theta);
	var gg_lat = z * Math.sin(theta);
	return [ gg_lng, gg_lat ];
}
/**
 * GCJ02 转换为 WGS84
 * @param lng
 * @param lat
 * @returns {*[]}
 */
function gcj02towgs84(lng, lat) {
	if (out_of_china(lng, lat)) {
		return [ lng, lat ];
	} else {
		var dlat = transformlat(lng - 105.0, lat - 35.0);
		var dlng = transformlng(lng - 105.0, lat - 35.0);
		var radlat = lat / 180.0 * PI;
		var magic = Math.sin(radlat);
		magic = 1 - ee * magic * magic;
		var sqrtmagic = Math.sqrt(magic);
		dlat = (dlat * 180.0) / ((a * (1 - ee)) / (magic * sqrtmagic) * PI);
		dlng = (dlng * 180.0) / (a / sqrtmagic * Math.cos(radlat) * PI);
		mglat = lat + dlat;
		mglng = lng + dlng;
		return [ lng * 2 - mglng, lat * 2 - mglat ];
	}
}
//WGS84转GCj02
function wgs84togcj02(lng, lat) {
	if (out_of_china(lng, lat)) {
		return [ lng, lat ];
	} else {
		var dlat = transformlat(lng - 105.0, lat - 35.0);
		var dlng = transformlng(lng - 105.0, lat - 35.0);
		var radlat = lat / 180.0 * PI;
		var magic = Math.sin(radlat);
		magic = 1 - ee * magic * magic;
		var sqrtmagic = Math.sqrt(magic);
		dlat = (dlat * 180.0) / ((a * (1 - ee)) / (magic * sqrtmagic) * PI);
		dlng = (dlng * 180.0) / (a / sqrtmagic * Math.cos(radlat) * PI);
		var mglat = lat + dlat;
		var mglng = lng + dlng;
		return [ mglng, mglat ];
	}
}
/**
* 火星坐标系 (GCJ-02) 与百度坐标系 (BD-09) 的转换
* 即谷歌、高德 转 百度
* @param lng
* @param lat
* @returns {*[]}
*/
function gcj02tobd09(lng, lat) {
	var z = Math.sqrt(lng * lng + lat * lat) + 0.00002 * Math.sin(lat * x_PI);
	var theta = Math.atan2(lat, lng) + 0.000003 * Math.cos(lng * x_PI);
	var bd_lng = z * Math.cos(theta) + 0.0065;
	var bd_lat = z * Math.sin(theta) + 0.006;
	return [ bd_lng, bd_lat ]
}
/**
 * 判断是否在国内，不在国内则不做偏移
 * @param lng
 * @param lat
 * @returns {boolean}
 */
function out_of_china(lng, lat) {
	return (lng < 72.004 || lng > 137.8347) || ((lat < 0.8293 || lat > 55.8271) || false);
}
function transformlat(lng, lat) {
	var ret = -100.0 + 2.0 * lng + 3.0 * lat + 0.2 * lat * lat + 0.1 * lng * lat + 0.2 * Math.sqrt(Math.abs(lng));
	ret += (20.0 * Math.sin(6.0 * lng * PI) + 20.0 * Math.sin(2.0 * lng * PI)) * 2.0 / 3.0;
	ret += (20.0 * Math.sin(lat * PI) + 40.0 * Math.sin(lat / 3.0 * PI)) * 2.0 / 3.0;
	ret += (160.0 * Math.sin(lat / 12.0 * PI) + 320 * Math.sin(lat * PI / 30.0)) * 2.0 / 3.0;
	return ret
}
function transformlng(lng, lat) {
	var ret = 300.0 + lng + 2.0 * lat + 0.1 * lng * lng + 0.1 * lng * lat + 0.1 * Math.sqrt(Math.abs(lng));
	ret += (20.0 * Math.sin(6.0 * lng * PI) + 20.0 * Math.sin(2.0 * lng * PI)) * 2.0 / 3.0;
	ret += (20.0 * Math.sin(lng * PI) + 40.0 * Math.sin(lng / 3.0 * PI)) * 2.0 / 3.0;
	ret += (150.0 * Math.sin(lng / 12.0 * PI) + 300.0 * Math.sin(lng / 30.0 * PI)) * 2.0 / 3.0;
	return ret
}

/**
* approx distance between two points on earth ellipsoid
* @param {Object} lat1
* @param {Object} lng1
* @param {Object} lat2
* @param {Object} lng2
*/
var EARTH_RADIUS = 6378137.0; //单位M
var PI = Math.PI;
function getRad(d) {
	return d * PI / 180.0;
}
function getFlatternDistance(lng1, lat1, lng2, lat2) {
	var f = getRad((lat1 + lat2) / 2);
	var g = getRad((lat1 - lat2) / 2);
	var l = getRad((lng1 - lng2) / 2);

	var sg = Math.sin(g);
	var sl = Math.sin(l);
	var sf = Math.sin(f);

	var s,
		c,
		w,
		r,
		d,
		h1,
		h2;
	var a = EARTH_RADIUS;
	var fl = 1 / 298.257;

	sg = sg * sg;
	sl = sl * sl;
	sf = sf * sf;

	s = sg * (1 - sl) + (1 - sf) * sl;
	c = (1 - sg) * (1 - sl) + sf * sl;

	w = Math.atan(Math.sqrt(s / c));
	r = Math.sqrt(s * c) / w;
	d = 2 * w * a;
	h1 = (3 * r - 1) / 2 / c;
	h2 = (3 * r + 1) / 2 / s;

	return d * (1 + fl * (h1 * sf * (1 - sg) - h2 * (1 - sf) * sg));
}

/** 
 *  判断一个点是否在多边形内部 
 *  @param points 多边形坐标集合 
 *  @param testPoint 需检测点坐标 
 *  返回true为真，false为假 
 *  */
function insidePolygon(points, testPoint) {
	var x = testPoint[0],
		y = testPoint[1];
	var inside = false;
	for (var i = 0, j = points.length - 1; i < points.length; j = i++) {
		var xi = points[i][0],
			yi = points[i][1];
		var xj = points[j][0],
			yj = points[j][1];

		var intersect = ((yi > y) != (yj > y))
			&& (x < (xj - xi) * (y - yi) / (yj - yi) + xi);
		if (intersect)
			inside = !inside;
	}
	return inside;
}

/**
 * 将秒转换为 分:秒
 * s int 秒数
*/
function s_to_hs(s) {
	//计算分钟
	//算法：将秒数除以60，然后下舍入，既得到分钟数
	var h;
	h = Math.floor(s / 60);
	//计算秒
	//算法：取得秒%60的余数，既得到秒数
	s = s % 60;
	//将变量转换为字符串
	h += '';
	s += '';
	//如果只有一位数，前面增加一个0
	h = (h.length == 1) ? '0' + h : h;
	s = (s.length == 1) ? '0' + s : s;
	return h + ':' + s;
}

//判断点是否在另一平面图中
//点: { x: xxx, y: xxx }
//线: [{ x: xxx, y: xxx }, { x: xxx, y: xxx }]
//面: [{ x: xxx, y: xxx }, { x: xxx, y: xxx }, { x: xxx, y: xxx }...]
function isPointInPolygon(point, polygon) {
	//下述代码来源：http://paulbourke.net/geometry/insidepoly/，进行了部分修改
	//基本思想是利用射线法，计算射线与多边形各边的交点，如果是偶数，则点在多边形外，否则
	//在多边形内。还会考虑一些特殊情况，如点在多边形顶点上，点在多边形边上等特殊情况。

	var N = polygon.length;
	var boundOrVertex = true; //如果点位于多边形的顶点或边上，也算做点在多边形内，直接返回true
	var intersectCount = 0; //cross points count of x 
	var precision = 2e-10; //浮点类型计算时候与0比较时候的容差
	var p1,
		p2; //neighbour bound vertices
	var p = point; //测试点

	p1 = polygon[0]; //left vertex        
	for (var i = 1; i <= N; ++i) { //check all rays            
		if (p.x == p1.x && p.y == p1.y) {
			return boundOrVertex; //p is an vertex
		}

		p2 = polygon[i % N]; //right vertex            
		if (p.y < Math.min(p1.y, p2.y) || p.y > Math.max(p1.y, p2.y)) { //ray is outside of our interests                
			p1 = p2;
			continue; //next ray left point
		}

		if (p.y > Math.min(p1.y, p2.y) && p.y < Math.max(p1.y, p2.y)) { //ray is crossing over by the algorithm (common part of)
			if (p.x <= Math.max(p1.x, p2.x)) { //x is before of ray                    
				if (p1.y == p2.y && p.x >= Math.min(p1.x, p2.x)) { //overlies on a horizontal ray
					return boundOrVertex;
				}

				if (p1.x == p2.x) { //ray is vertical                        
					if (p1.x == p.x) { //overlies on a vertical ray
						return boundOrVertex;
					} else { //before ray
						++intersectCount;
					}
				} else { //cross point on the left side                        
					var xinters = (p.y - p1.y) * (p2.x - p1.x) / (p2.y - p1.y) + p1.x; //cross point of x                        
					if (Math.abs(p.x - xinters) < precision) { //overlies on a ray
						return boundOrVertex;
					}

					if (p.x < xinters) { //before ray
						++intersectCount;
					}
				}
			}
		} else { //special case when ray is crossing through the vertex                
			if (p.y == p2.y && p.x <= p2.x) { //p crossing over p2                    
				var p3 = polygon[(i + 1) % N]; //next vertex                    
				if (p.y >= Math.min(p1.y, p3.y) && p.y <= Math.max(p1.y, p3.y)) { //p.y lies between p1.y & p3.y
					++intersectCount;
				} else {
					intersectCount += 2;
				}
			}
		}
		p1 = p2; //next ray left point
	}

	if (intersectCount % 2 == 0) { //偶数在多边形外
		return false;
	} else { //奇数在多边形内
		return true;
	}
}

//判断两多变形是否存在点与区域的包含关系(A的点在B的区域内或B的点在A的区域内)
function isPointInPolygonBidirectional(plyA, plyB) {
	let [a, b] = [ false, false ];
	a = plyA.some(item => isPointInPolygon(item, plyB));
	if (!a) {
		b = plyB.some(item => isPointInPolygon(item, plyA));
	}
	return a || b;
}

//根据两点坐标计算方位角
function azimuthtwopoi(x1,y1,x2,y2){
	var result;
	var a = Math.abs(Math.atan((y2-y1)/(x2-x1)))*180/Math.PI;
	if((x2-x1)<0){
		if((y2-y1)>0){
			result = a + 270;
		}else{
			result = 90 - a + 180;
		}
	}else{
		if((y2-y1)>0){
			result = 90 - a;
		}else{
			result = a + 90;
		}
	}
	return result;
}
//获取立方体中心点、方位角、边线长度
function fixtoboxvertex(floorPoiStrArr){
	var oriLonArr = [], oriLatArr = [];
	for (var i = 0; i < 12; i=i+3) {
		oriLonArr.push(Number(floorPoiStrArr[i]));
		oriLatArr.push(Number(floorPoiStrArr[i+1]));
	}
	oriLonArr.push(Number(floorPoiStrArr[0]));
	oriLatArr.push(Number(floorPoiStrArr[1]));
	var sumLon = 0, sumLat = 0;
	var heading = [], distance = [];
	for (var i = 0; i < oriLonArr.length-1; i++) {
		sumLon += oriLonArr[i];
		sumLat += oriLatArr[i];
		heading.push(azimuthtwopoi(oriLonArr[i],oriLatArr[i],oriLonArr[i+1],oriLatArr[i+1])); 
		distance.push(getFlatternDistance(oriLonArr[i],oriLatArr[i],oriLonArr[i+1],oriLatArr[i+1])); 
	}
	var centerLon = sumLon/4;
	var centerLat = sumLat/4;
	return {centerLon, centerLat, heading, distance};
}