/// <returns>单位:米</returns>
public static int 测量两点间间距(M经纬度 点1, M经纬度 点2)
{
if (点1.类型 != 点2.类型)
{
点1 = HGPS坐标转换.转原始坐标(点1);
点2 = HGPS坐标转换.转原始坐标(点2);
}
return((int)(GMapProviders.EmptyProvider.Projection.GetDistance(new GMap.NET.PointLatLng(点1.纬度, 点1.经度),
new GMap.NET.PointLatLng(点2.纬度, 点2.经度)) * 1000));
//var latRadians1 = __纬度1 * (Math.PI / 180);
//var latRadians2 = __纬度2 * (Math.PI / 180);
//var latRadians = latRadians1 - latRadians2;
//var lngRadians = __经度1 * (Math.PI / 180) - __经度2 * (Math.PI / 180);
//var f = 2 * Math.Asin(Math.Sqrt(Math.Pow(Math.Sin(latRadians / 2), 2) + Math.Cos(latRadians1) * Math.Cos(latRadians2) * Math.Pow(Math.Sin(lngRadians / 2), 2)));
//return f * 6378137;
//double dLat1InRad = p1.Lat * (Math.PI / 180);
//double dLong1InRad = p1.Lng * (Math.PI / 180);
//double dLat2InRad = p2.Lat * (Math.PI / 180);
//double dLong2InRad = p2.Lng * (Math.PI / 180);
//double dLongitude = dLong2InRad - dLong1InRad;
//double dLatitude = dLat2InRad - dLat1InRad;
//double a = Math.Pow(Math.Sin(dLatitude / 2), 2) + Math.Cos(dLat1InRad) * Math.Cos(dLat2InRad) * Math.Pow(Math.Sin(dLongitude / 2), 2);
//double c = 2 * Math.Atan2(Math.Sqrt(a), Math.Sqrt(1 - a));
//double dDistance = (Axis / 1000.0) * c;
//return dDistance;
}
public static M经纬度 地址编码(string __位置, string __城市 = null)
{
string __url = "";
string __返回值 = "";
if (string.IsNullOrEmpty(__城市))
{
__url = "http://api.map.baidu.com/geocoder/v2/?ak={0}&output=json&address={1}";
__返回值 = Web服务请求(string.Format(__url, _ak, HttpUtility.UrlEncode(__位置)));
}
else
{
__url = "http://api.map.baidu.com/geocoder/v2/?ak={0}&output=json&address={1}&city={2}";
__返回值 = Web服务请求(string.Format(__url, _ak, HttpUtility.UrlEncode(__位置), __城市));
}
var __JS序列化器 = new JavaScriptSerializer();
var __结果 = __JS序列化器.Deserialize <M地址编码结果>(__返回值);
if (__结果.status != 0)
{
return(null);
}
var __百度坐标 = new M经纬度(__结果.result.location.lng, __结果.result.location.lat)
{
类型 = E坐标类型.百度
};
return(HGPS坐标转换.百度坐标转谷歌坐标(__百度坐标));
}
public static bool 判断点在多边形内(M经纬度 点, List <M经纬度> 多边形)
{
if (多边形.Any(q => q.类型 != 点.类型))
{
多边形 = 多边形.Select(HGPS坐标转换.转原始坐标).ToList();
}
return(判断点在多边形内(new PointF((float)点.经度, (float)点.纬度), 多边形.Select(q => new PointF((float)q.经度, (float)q.纬度)).ToArray()));
}
/// <param name="__半径">单位:米</param>
/// <param name="__绑定对象">暂不支持</param>
public UInt64 添加圆(M经纬度 __圆心, int __半径, M区域绘制参数 __绘制参数, object __绑定对象 = null, string __图层名称 = null)
{
return(添加圆(__圆心, __半径, new Pen(__绘制参数.边框颜色)
{
Width = __绘制参数.边框宽度
}, new SolidBrush(__绘制参数.填充颜色), __绑定对象 != null, __绑定对象,
__图层名称));
}
public static M经纬度 百度坐标转原始坐标(M经纬度 百度坐标)
{
var __gps84 = H坐标转换.bd09_To_Gps84(百度坐标.纬度, 百度坐标.经度);
return(new M经纬度(__gps84.Lng, __gps84.Lat)
{
类型 = E坐标类型.设备
});
}
public static M经纬度 百度坐标转谷歌坐标(M经纬度 百度坐标)
{
var __gcj = H坐标转换.bd09_To_Gcj02(百度坐标.纬度, 百度坐标.经度);
return(new M经纬度(__gcj.Lng, __gcj.Lat)
{
类型 = E坐标类型.谷歌
});
}
public static M经纬度 谷歌坐标转百度坐标(M经纬度 谷歌坐标)
{
var __bd = H坐标转换.gcj02_To_Bd09(谷歌坐标.纬度, 谷歌坐标.经度);
return(new M经纬度(__bd.Lng, __bd.Lat)
{
类型 = E坐标类型.百度
});
}
public M经纬度 纠偏(M经纬度 __原始坐标)
{
var __temp = GPS转换(__原始坐标);
return(new M经纬度(__temp.Lng, __temp.Lat)
{
类型 = E坐标类型.谷歌
});
}
public static M经纬度 原始坐标转谷歌坐标(M经纬度 原始坐标)
{
var __gcj = H坐标转换.gps84_To_Gcj02(原始坐标.纬度, 原始坐标.经度);
return(new M经纬度(__gcj.Lng, __gcj.Lat)
{
类型 = E坐标类型.谷歌
});
}
public UInt64 添加点(M经纬度 __点, Image __图片, string __标题 = null, object __绑定对象 = null, string __图层名称 = null, E标题显示方式 __标题显示方式 = E标题显示方式.OnMouseOver, bool __图标偏移 = false)
{
if (this.InvokeRequired)
{
var __信号量 = this.BeginInvoke(new Func <M经纬度, Image, string, object, string, E标题显示方式, bool, UInt64>(添加点), __点, __图片, __标题, __绑定对象, __图层名称, __标题显示方式, __图标偏移);
__信号量.AsyncWaitHandle.WaitOne();
return((UInt64)this.EndInvoke(__信号量));
}
return(添加点(获取图层(__图层名称), __点, __图片, __标题, __绑定对象 != null || __标题 != null, __绑定对象, __标题显示方式, __图标偏移));
}
public static M经纬度 谷歌坐标转原始坐标(M经纬度 谷歌坐标)
{
var __bd = H坐标转换.gcj02_To_Bd09(谷歌坐标.纬度, 谷歌坐标.经度);
var __gps84 = H坐标转换.bd09_To_Gps84(__bd.Lat, __bd.Lng);
return(new M经纬度(__gps84.Lng, __gps84.Lat)
{
类型 = E坐标类型.设备
});
}
public UInt64 添加点(M经纬度 __点, M点绘制参数 __绘制参数, object __绑定对象 = null, string __图层名称 = null)
{
if (this.InvokeRequired)
{
var __信号量 = this.BeginInvoke(new Func <M经纬度, M点绘制参数, object, string, UInt64>(添加点), __点, __绘制参数, __绑定对象, __图层名称);
__信号量.AsyncWaitHandle.WaitOne();
return((UInt64)this.EndInvoke(__信号量));
}
return(添加点(获取图层(__图层名称), __点, __绘制参数.图片, __绘制参数.标题, __绑定对象 != null || __绘制参数.标题 != null, __绑定对象, __绘制参数.标题显示方式, __绘制参数.偏移));
}
public void 定位(M经纬度 __点)
{
if (this.InvokeRequired)
{
this.BeginInvoke(new Action <M经纬度>(定位), __点);
return;
}
this.out地图控件.Position = GPS转换(__点);
}
/// <param name="半径">单位:米</param>
public static bool 判断点在圆形内(M经纬度 点, M经纬度 圆心, int 半径)
{
if (点.类型 != 圆心.类型)
{
点 = HGPS坐标转换.转原始坐标(点);
圆心 = HGPS坐标转换.转原始坐标(圆心);
}
var __间距 = 测量两点间间距(点, 圆心);
return(__间距 <= 半径);
}
public static M经纬度 谷歌坐标转百度坐标(M经纬度 谷歌坐标)
{
double __百度经度;
double __百度纬度;
谷歌坐标转百度坐标(谷歌坐标.纬度, 谷歌坐标.经度, out __百度纬度, out __百度经度);
return(new M经纬度(__百度经度, __百度纬度)
{
类型 = E坐标类型.百度
});
}
public static M经纬度 原始坐标转谷歌坐标(M经纬度 原始坐标)
{
double __谷歌经度;
double __谷歌纬度;
原始坐标转谷歌坐标(原始坐标.纬度, 原始坐标.经度, out __谷歌纬度, out __谷歌经度);
return(new M经纬度(__谷歌经度, __谷歌纬度)
{
类型 = E坐标类型.谷歌
});
}
public UInt64 添加矩形(M经纬度 __左上角点, M经纬度 __右下角点, Pen __边框画笔, Brush __填充笔刷, bool __允许交互, object __绑定对象 = null, string __图层名称 = null)
{
var __点列表 = new List <M经纬度> {
__左上角点,
__左上角点.偏移(__右下角点.经度 - __左上角点.经度, 0),
__右下角点,
__右下角点.偏移(__左上角点.经度 - __右下角点.经度, 0),
};
return(添加多边形(__点列表, __边框画笔, __填充笔刷, __允许交互, __绑定对象, __图层名称));
}
public UInt64 添加矩形(M经纬度 __左上角点, M经纬度 __右下角点, M区域绘制参数 __绘制参数, object __绑定对象 = null, string __图层名称 = null)
{
var __点列表 = new List <M经纬度> {
__左上角点,
__左上角点.偏移(__右下角点.经度 - __左上角点.经度, 0),
__右下角点,
__右下角点.偏移(__左上角点.经度 - __右下角点.经度, 0),
};
return(添加多边形(__点列表, __绘制参数, __绑定对象, __图层名称));
}
public void 初始化地图参数(E地图源 __地图源, M经纬度 __中心位置, int __最小层级, int __最大层级)
{
this.最小层级 = __最小层级;
this.最大层级 = __最大层级;
设置层级范围(this.最小层级, this.最大层级);
this.当前层级 = __最小层级 + (__最大层级 - __最小层级) / 2;
this.do缩放.设置当前级别(this.当前层级);
this.out地图控件.Position = GPS转换(__中心位置);
this.当前地图源 = __地图源;
//this.out地图控件.BoundsOfMap = new RectLatLng(_地图初始中心, new SizeLatLng(0.2, 0.2)); //限定地图移动范围
}
public static List <M线路> 查询公交线路(M经纬度 __起点, M经纬度 __终点, string __城市, E驾车路线选择策略 __策略, out List <M地址> __可能起点, out List <M地址> __可能终点)
{
__起点 = 转换成百度坐标(__起点);
__终点 = 转换成百度坐标(__终点);
string __url = "http://api.map.baidu.com/direction/v1?mode=transit&output=xml&ak={0}&origin={1}&destination={2}®ion={3}&tactics={4}";
string __返回值 = "";
__返回值 = Web服务请求(string.Format(__url, _ak, HttpUtility.UrlEncode(string.Format("{1},{0}", __起点.经度, __起点.纬度)), HttpUtility.UrlEncode(string.Format("{1},{0}", __终点.经度, __终点.纬度)), HttpUtility.UrlEncode(__城市), (int)__策略));
var __XML文档 = XDocument.Load(new StringReader(__返回值));
var __根节点 = __XML文档.Root;
var __status = __根节点.XPathSelectElement("./status").Value;
if (__status != "0")
{
throw new Exception(__根节点.XPathSelectElement("./message").Value);
}
var __type = __根节点.XPathSelectElement("./type").Value;
var __结果 = new List <M线路>();
if (__type == "2")
{
foreach (XElement __节点 in __根节点.XPathSelectElements("./result/routes/scheme"))
{
var __距离 = int.Parse(__节点.XPathSelectElement("./distance").Value);
var __时间 = int.Parse(__节点.XPathSelectElement("./duration").Value) / 60;
var __线路 = new M线路(string.Format("距离: {0}, 耗时: {1}", __距离, __时间));
__线路.距离 = __距离;
foreach (XElement __二级节点 in __节点.XPathSelectElements("./steps/info"))
{
var __起点经度 = double.Parse(__二级节点.XPathSelectElement("./stepOriginLocation/lng").Value);
var __起点纬度 = double.Parse(__二级节点.XPathSelectElement("./stepOriginLocation/lat").Value);
var __说明 = __二级节点.XPathSelectElement("./stepInstruction").Value;
__线路.点集合.Add(转换成谷歌坐标(new M经纬度(__起点经度, __起点纬度)
{
类型 = E坐标类型.百度
}));
__线路.步骤说明.Add(过滤字符串(__说明));
}
var __最后一个节点 = __节点.XPathSelectElements("./steps/info").Last();
var __终点经度 = double.Parse(__最后一个节点.XPathSelectElement("./stepDestinationLocation/lng").Value);
var __终点纬度 = double.Parse(__最后一个节点.XPathSelectElement("./stepDestinationLocation/lat").Value);
__线路.点集合.Add(转换成谷歌坐标(new M经纬度(__终点经度, __终点纬度)
{
类型 = E坐标类型.百度
}));
__结果.Add(__线路);
}
__可能起点 = null;
__可能终点 = null;
return(__结果);
}
throw new NotImplementedException();
}
/// <param name="半径">单位:米</param>
public static bool 判断圆重叠(M经纬度 圆心1, int 半径1, M经纬度 圆心2, int 半径2)
{
if (圆心1.类型 != 圆心2.类型)
{
圆心1 = HGPS坐标转换.转原始坐标(圆心1);
圆心2 = HGPS坐标转换.转原始坐标(圆心2);
}
var __间距 = 测量两点间间距(圆心1, 圆心2);
return(__间距 <= (半径1 + 半径2));
}
private static M经纬度 转换成谷歌坐标(M经纬度 __原经纬度)
{
M经纬度 __结果 = __原经纬度;
if (__原经纬度.类型 == E坐标类型.百度)
{
__结果 = HGPS坐标转换.百度坐标转谷歌坐标(__原经纬度);
}
else if (__原经纬度.类型 == E坐标类型.设备)
{
__结果 = HGPS坐标转换.原始坐标转谷歌坐标(__原经纬度);
}
return(__结果);
}
public static string 逆地址编码(M经纬度 __位置)
{
var __url = "http://api.map.baidu.com/geocoder/v2/?ak={0}&output=json&location={1},{2}&pois=0&coordtype={3}";
var __坐标 = 转换成百度坐标(__位置);
//目前支持的坐标类型包括：bd09ll（百度经纬度坐标）、gcj02ll（国测局经纬度坐标）、wgs84ll（ GPS经纬度）
var __返回值 = Web服务请求(string.Format(__url, _ak, __坐标.纬度, __坐标.经度, __位置.类型 == E坐标类型.百度 ? "bd09ll" : "wgs84ll"));
var __JS序列化器 = new JavaScriptSerializer();
var __结果 = __JS序列化器.Deserialize <M逆地址编码结果>(__返回值);
if (__结果.status != 0)
{
return(null);
}
return(__结果.result.formatted_address);
}
public static M经纬度 转原始坐标(M经纬度 __坐标)
{
switch (__坐标.类型)
{
case E坐标类型.设备:
return(__坐标);
case E坐标类型.谷歌:
return(谷歌坐标转原始坐标(__坐标));
case E坐标类型.百度:
return(百度坐标转原始坐标(__坐标));
default:
throw new ArgumentOutOfRangeException();
}
}
public static M线路 查询驾车线路(M经纬度 __起点, M经纬度 __终点, string __起点城市, string __终点城市, E驾车路线选择策略 __策略, out List <M地址> __可能起点, out List <M地址> __可能终点)
{
__起点 = 转换成百度坐标(__起点);
__终点 = 转换成百度坐标(__终点);
string __url = "http://api.map.baidu.com/direction/v1?mode=driving&output=xml&ak={0}&origin={1}&destination={2}&origin_region={3}&destination_region={4}&tactics={5}";
string __返回值 = "";
__返回值 = Web服务请求(string.Format(__url, _ak, HttpUtility.UrlEncode(string.Format("{1},{0}", __起点.经度, __起点.纬度)), HttpUtility.UrlEncode(string.Format("{1},{0}", __终点.经度, __终点.纬度)), HttpUtility.UrlEncode(__起点城市), HttpUtility.UrlEncode(__终点城市), (int)__策略));
var __XML文档 = XDocument.Load(new StringReader(__返回值));
var __根节点 = __XML文档.Root;
var __status = __根节点.XPathSelectElement("./status").Value;
if (__status != "0")
{
throw new Exception(__根节点.XPathSelectElement("./message").Value);
}
var __type = __根节点.XPathSelectElement("./type").Value;
if (__type == "2")
{
var __结果 = new M线路(string.Format("{0}->{1}", __起点, __终点));
foreach (XElement __节点 in __根节点.XPathSelectElements("./result/routes/steps/content"))
{
var __点 = __节点.Element("path").Value;
var __说明 = __节点.Element("instructions").Value;
__结果.点集合.Add(转换成谷歌坐标(new M经纬度(double.Parse(__点.Split(',')[0]), double.Parse(__点.Split(',')[1]))
{
类型 = E坐标类型.百度
}));
__结果.步骤说明.Add(过滤字符串(__说明));
}
__结果.距离 = int.Parse(__根节点.XPathSelectElement("./result/routes/distance").Value);
var __备注 = new StringBuilder();
__备注.AppendFormat("耗时: {0}分钟", (int.Parse(__根节点.XPathSelectElement("./result/routes/duration").Value)) / 60).AppendLine();
__备注.AppendFormat("白天打车费用: {0}元", __根节点.XPathSelectElements("./result/taxi/detail/total_price").First().Value).AppendLine();
__备注.AppendFormat("夜间打车费用: {0}元", __根节点.XPathSelectElements("./result/taxi/detail/total_price").Last().Value).AppendLine();
__结果.备注 = __备注.ToString();
__可能起点 = null;
__可能终点 = null;
return(__结果);
}
throw new NotImplementedException();
}
/// <param name="__半径">单位:mi</param>
/// <returns></returns>
public static List <Tuple <M经纬度, string> > 区域检索(string __关键字, M经纬度 __圆心, int __半径)
{
__圆心 = 转换成百度坐标(__圆心);
__关键字 = __关键字.Replace(" ", "$");
string __url = "http://api.map.baidu.com/place/v2/search?&output=json&ak={0}&q={1}&location={2},{3}&radius={4}";
string __返回值 = Web服务请求(string.Format(__url, _ak, HttpUtility.UrlEncode(__关键字), __圆心.纬度, __圆心.经度, __半径));
var __JS序列化器 = new JavaScriptSerializer();
var __结果 = __JS序列化器.Deserialize <M区域检索结果>(__返回值);
if (__结果.status != 0)
{
throw new Exception(__结果.message);
}
return(__结果.results.Select(q => new Tuple <M经纬度, string>(转换成谷歌坐标(new M经纬度(q.location.lng, q.location.lat)
{
类型 = E坐标类型.百度
}),
string.Format("{0}\n\r{1}\n\r{2}", q.name, q.address, q.telephone))).ToList());
}
private UInt64 添加点(GMapOverlay __图层, M经纬度 __点, Image __图片, string __标题 = null, bool __允许交互 = true, object __绑定对象 = null, E标题显示方式 __标题显示方式 = E标题显示方式.OnMouseOver, bool __图标偏移 = true)
{
var __GPS = GPS转换(__点);
//GMapMarker __图标 = new GMarkerGoogle(__GPS, GMarkerGoogleType.blue_small);
GMapMarker __图标 = new GMarkerGoogle(__GPS, __图片);
__图标.ToolTipText = __标题;
__图标.ToolTipMode = (MarkerTooltipMode)(int)__标题显示方式;
__图标.Tag = __绑定对象;
if (__图标偏移)
{
__图标.Offset = new Point(-__图片.Width / 2 + 1, -__图片.Height + 1);
}
__图标.IsHitTestVisible = __允许交互;
__图层.Markers.Add(__图标);
var __标识 = _所有覆盖物[__图层].标识++;
_所有覆盖物[__图层].点集[__标识] = __图标;
return(__标识);
}
public UInt64 添加圆(M经纬度 __圆心, int __半径, Pen __边框画笔, Brush __填充笔刷, bool __允许交互, object __绑定对象 = null, string __图层名称 = null)
{
if (this.InvokeRequired)
{
var __信号量 = this.BeginInvoke(new Func <M经纬度, int, Pen, Brush, bool, object, string, UInt64>(添加圆), __圆心, __半径, __边框画笔, __填充笔刷, __允许交互, __绑定对象, __图层名称);
__信号量.AsyncWaitHandle.WaitOne();
return((UInt64)this.EndInvoke(__信号量));
}
var __图层 = 获取图层(__图层名称);
var __覆盖范围 = new GMapMarkerCircle(GPS转换(__圆心), __边框画笔, __填充笔刷, __允许交互)
{
Radius = __半径, IsFilled = __填充笔刷 != null
};
__图层.Markers.Add(__覆盖范围);
var __标识 = _所有覆盖物[__图层].标识++;
_所有覆盖物[__图层].点集[__标识] = __覆盖范围;
return(__标识);
}
public static bool 判断点在矩形内(M经纬度 点, List <M经纬度> 多边形)
{
if (多边形.Any(q => q.类型 != 点.类型))
{
多边形 = 多边形.Select(HGPS坐标转换.转原始坐标).ToList();
}
double __最小经度 = 180;
double __最大经度 = -180;
double __最小纬度 = 90;
double __最大纬度 = -90;
多边形.ForEach(q =>
{
__最小经度 = Math.Min(__最小经度, q.经度);
__最大经度 = Math.Max(__最大经度, q.经度);
__最小纬度 = Math.Min(__最小纬度, q.纬度);
__最大纬度 = Math.Max(__最大纬度, q.纬度);
});
return(点.经度 >= __最小经度 && 点.经度 <= __最大经度 && 点.纬度 >= __最小纬度 && 点.纬度 <= __最大纬度);
}
private PointLatLng GPS转换(M经纬度 __GPS, bool __纠偏 = true)
{
double __标准经度 = __GPS.经度;
double __标准纬度 = __GPS.纬度;
if (__纠偏 && __GPS.类型 == E坐标类型.设备)
{
if (当前地图源 == E地图源.谷歌2D图 || 当前地图源 == E地图源.谷歌混合图)
{
//double __谷歌坐标经度;
//double __谷歌坐标纬度;
//HGPS坐标转换.原始坐标转谷歌坐标(__标准纬度, __标准经度, out __谷歌坐标纬度, out __谷歌坐标经度);
//return new PointLatLng(__谷歌坐标纬度, __谷歌坐标经度);
return(H坐标转换.gps84_To_Gcj02(__标准纬度, __标准经度));
}
if (当前地图源 == E地图源.百度2D图 || 当前地图源 == E地图源.百度混合图)
{
return(H坐标转换.gps84_To_Bd09(__标准纬度, __标准经度));
}
}
return(new PointLatLng(__标准纬度, __标准经度));
}
