| /MKLiveView/v1.0/GMap.NET.Core/GMap.NET.MapProviders/ArcGIS/ArcGIS_DarbAE_Q2_2011_NAVTQ_Eng_V5_MapProvider.cs |
|---|
| 0,0 → 1,86 |
| |
| namespace GMap.NET.MapProviders |
| { |
| using System; |
| using GMap.NET.Projections; |
| /// <summary> |
| /// ArcGIS_DarbAE_Q2_2011_NAVTQ_Eng_V5_Map provider, |
| /// http://www.darb.ae/ArcGIS/rest/services/BaseMaps/Q2_2011_NAVTQ_Eng_V5/MapServer |
| /// </summary> |
| public class ArcGIS_DarbAE_Q2_2011_NAVTQ_Eng_V5_MapProvider : GMapProvider |
| { |
| public static readonly ArcGIS_DarbAE_Q2_2011_NAVTQ_Eng_V5_MapProvider Instance; |
| ArcGIS_DarbAE_Q2_2011_NAVTQ_Eng_V5_MapProvider() |
| { |
| MaxZoom = 12; |
| Area = RectLatLng.FromLTRB(49.8846923723311, 28.0188609585523, 58.2247031977662, 21.154115956732); |
| Copyright = string.Format("©{0} ESRI - Map data ©{0} ArcGIS", DateTime.Today.Year); |
| } |
| static ArcGIS_DarbAE_Q2_2011_NAVTQ_Eng_V5_MapProvider() |
| { |
| Instance = new ArcGIS_DarbAE_Q2_2011_NAVTQ_Eng_V5_MapProvider(); |
| } |
| #region GMapProvider Members |
| readonly Guid id = new Guid("E03CFEDF-9277-49B3-9912-D805347F934B"); |
| public override Guid Id |
| { |
| get |
| { |
| return id; |
| } |
| } |
| readonly string name = "ArcGIS_DarbAE_Q2_2011_NAVTQ_Eng_V5_MapProvider"; |
| public override string Name |
| { |
| get |
| { |
| return name; |
| } |
| } |
| public override PureProjection Projection |
| { |
| get |
| { |
| return PlateCarreeProjectionDarbAe.Instance; |
| } |
| } |
| GMapProvider[] overlays; |
| public override GMapProvider[] Overlays |
| { |
| get |
| { |
| if(overlays == null) |
| { |
| overlays = new GMapProvider[] { this }; |
| } |
| return overlays; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| string url = MakeTileImageUrl(pos, zoom); |
| return GetTileImageUsingHttp(url); |
| } |
| #endregion |
| string MakeTileImageUrl(GPoint pos, int zoom) |
| { |
| // http://www.darb.ae/ArcGIS/rest/services/BaseMaps/Q2_2011_NAVTQ_Eng_V5/MapServer/tile/0/121/144 |
| return string.Format(UrlFormat, zoom, pos.Y, pos.X); |
| } |
| static readonly string UrlFormat = "http://www.darb.ae/ArcGIS/rest/services/BaseMaps/Q2_2011_NAVTQ_Eng_V5/MapServer/tile/{0}/{1}/{2}"; |
| } |
| } |
| /MKLiveView/v1.0/GMap.NET.Core/GMap.NET.MapProviders/ArcGIS/ArcGIS_Imagery_World_2D_MapProvider.cs |
|---|
| 0,0 → 1,60 |
| |
| namespace GMap.NET.MapProviders |
| { |
| using System; |
| /// <summary> |
| /// ArcGIS_Imagery_World_2D_Map provider, http://server.arcgisonline.com |
| /// </summary> |
| public class ArcGIS_Imagery_World_2D_MapProvider : ArcGISMapPlateCarreeProviderBase |
| { |
| public static readonly ArcGIS_Imagery_World_2D_MapProvider Instance; |
| ArcGIS_Imagery_World_2D_MapProvider() |
| { |
| } |
| static ArcGIS_Imagery_World_2D_MapProvider() |
| { |
| Instance = new ArcGIS_Imagery_World_2D_MapProvider(); |
| } |
| #region GMapProvider Members |
| readonly Guid id = new Guid("FF7ADDAD-F155-41DB-BC42-CC6FD97C8B9D"); |
| public override Guid Id |
| { |
| get |
| { |
| return id; |
| } |
| } |
| readonly string name = "ArcGIS_Imagery_World_2D_Map"; |
| public override string Name |
| { |
| get |
| { |
| return name; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| string url = MakeTileImageUrl(pos, zoom, LanguageStr); |
| return GetTileImageUsingHttp(url); |
| } |
| #endregion |
| string MakeTileImageUrl(GPoint pos, int zoom, string language) |
| { |
| // http://server.arcgisonline.com/ArcGIS/rest/services/ESRI_Imagery_World_2D/MapServer/tile/1/0/1.jpg |
| return string.Format(UrlFormat, zoom, pos.Y, pos.X); |
| } |
| static readonly string UrlFormat = "http://server.arcgisonline.com/ArcGIS/rest/services/ESRI_Imagery_World_2D/MapServer/tile/{0}/{1}/{2}"; |
| } |
| } |
| /MKLiveView/v1.0/GMap.NET.Core/GMap.NET.MapProviders/ArcGIS/ArcGIS_ShadedRelief_World_2D_MapProvider.cs |
|---|
| 0,0 → 1,60 |
| |
| namespace GMap.NET.MapProviders |
| { |
| using System; |
| /// <summary> |
| /// ArcGIS_ShadedRelief_World_2D_Map provider, http://server.arcgisonline.com |
| /// </summary> |
| public class ArcGIS_ShadedRelief_World_2D_MapProvider : ArcGISMapPlateCarreeProviderBase |
| { |
| public static readonly ArcGIS_ShadedRelief_World_2D_MapProvider Instance; |
| ArcGIS_ShadedRelief_World_2D_MapProvider() |
| { |
| } |
| static ArcGIS_ShadedRelief_World_2D_MapProvider() |
| { |
| Instance = new ArcGIS_ShadedRelief_World_2D_MapProvider(); |
| } |
| #region GMapProvider Members |
| readonly Guid id = new Guid("A8995FA4-D9D8-415B-87D0-51A7E53A90D4"); |
| public override Guid Id |
| { |
| get |
| { |
| return id; |
| } |
| } |
| readonly string name = "ArcGIS_ShadedRelief_World_2D_Map"; |
| public override string Name |
| { |
| get |
| { |
| return name; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| string url = MakeTileImageUrl(pos, zoom, LanguageStr); |
| return GetTileImageUsingHttp(url); |
| } |
| #endregion |
| string MakeTileImageUrl(GPoint pos, int zoom, string language) |
| { |
| // http://server.arcgisonline.com/ArcGIS/rest/services/ESRI_ShadedRelief_World_2D/MapServer/tile/1/0/1.jpg |
| return string.Format(UrlFormat, zoom, pos.Y, pos.X); |
| } |
| static readonly string UrlFormat = "http://server.arcgisonline.com/ArcGIS/rest/services/ESRI_ShadedRelief_World_2D/MapServer/tile/{0}/{1}/{2}"; |
| } |
| } |
| /MKLiveView/v1.0/GMap.NET.Core/GMap.NET.MapProviders/ArcGIS/ArcGIS_StreetMap_World_2D_MapProvider.cs |
|---|
| 0,0 → 1,166 |
| |
| namespace GMap.NET.MapProviders |
| { |
| using System; |
| using GMap.NET.Projections; |
| public abstract class ArcGISMapPlateCarreeProviderBase : GMapProvider |
| { |
| public ArcGISMapPlateCarreeProviderBase() |
| { |
| Copyright = string.Format("©{0} ESRI - Map data ©{0} ArcGIS", DateTime.Today.Year); |
| } |
| #region GMapProvider Members |
| public override Guid Id |
| { |
| get |
| { |
| throw new NotImplementedException(); |
| } |
| } |
| public override string Name |
| { |
| get |
| { |
| throw new NotImplementedException(); |
| } |
| } |
| public override PureProjection Projection |
| { |
| get |
| { |
| return PlateCarreeProjection.Instance; |
| } |
| } |
| GMapProvider[] overlays; |
| public override GMapProvider[] Overlays |
| { |
| get |
| { |
| if(overlays == null) |
| { |
| overlays = new GMapProvider[] { this }; |
| } |
| return overlays; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| throw new NotImplementedException(); |
| } |
| #endregion |
| } |
| public abstract class ArcGISMapMercatorProviderBase : GMapProvider |
| { |
| public ArcGISMapMercatorProviderBase() |
| { |
| MaxZoom = null; |
| Copyright = string.Format("©{0} ESRI - Map data ©{0} ArcGIS", DateTime.Today.Year); |
| } |
| #region GMapProvider Members |
| public override Guid Id |
| { |
| get |
| { |
| throw new NotImplementedException(); |
| } |
| } |
| public override string Name |
| { |
| get |
| { |
| throw new NotImplementedException(); |
| } |
| } |
| public override PureProjection Projection |
| { |
| get |
| { |
| return MercatorProjection.Instance; |
| } |
| } |
| GMapProvider[] overlays; |
| public override GMapProvider[] Overlays |
| { |
| get |
| { |
| if(overlays == null) |
| { |
| overlays = new GMapProvider[] { this }; |
| } |
| return overlays; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| throw new NotImplementedException(); |
| } |
| #endregion |
| } |
| /// <summary> |
| /// ArcGIS_StreetMap_World_2D_Map provider, http://server.arcgisonline.com |
| /// </summary> |
| public class ArcGIS_StreetMap_World_2D_MapProvider : ArcGISMapPlateCarreeProviderBase |
| { |
| public static readonly ArcGIS_StreetMap_World_2D_MapProvider Instance; |
| ArcGIS_StreetMap_World_2D_MapProvider() |
| { |
| } |
| static ArcGIS_StreetMap_World_2D_MapProvider() |
| { |
| Instance = new ArcGIS_StreetMap_World_2D_MapProvider(); |
| } |
| #region GMapProvider Members |
| readonly Guid id = new Guid("00BF56D4-4B48-4939-9B11-575BBBE4A718"); |
| public override Guid Id |
| { |
| get |
| { |
| return id; |
| } |
| } |
| readonly string name = "ArcGIS_StreetMap_World_2D_Map"; |
| public override string Name |
| { |
| get |
| { |
| return name; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| string url = MakeTileImageUrl(pos, zoom, LanguageStr); |
| return GetTileImageUsingHttp(url); |
| } |
| #endregion |
| string MakeTileImageUrl(GPoint pos, int zoom, string language) |
| { |
| // http://server.arcgisonline.com/ArcGIS/rest/services/ESRI_StreetMap_World_2D/MapServer/tile/0/0/0.jpg |
| return string.Format(UrlFormat, zoom, pos.Y, pos.X); |
| } |
| static readonly string UrlFormat = "http://server.arcgisonline.com/ArcGIS/rest/services/ESRI_StreetMap_World_2D/MapServer/tile/{0}/{1}/{2}"; |
| } |
| } |
| /MKLiveView/v1.0/GMap.NET.Core/GMap.NET.MapProviders/ArcGIS/ArcGIS_Topo_US_2D_MapProvider.cs |
|---|
| 0,0 → 1,60 |
| |
| namespace GMap.NET.MapProviders |
| { |
| using System; |
| /// <summary> |
| /// ArcGIS_Topo_US_2D_Map provider, http://server.arcgisonline.com |
| /// </summary> |
| public class ArcGIS_Topo_US_2D_MapProvider : ArcGISMapPlateCarreeProviderBase |
| { |
| public static readonly ArcGIS_Topo_US_2D_MapProvider Instance; |
| ArcGIS_Topo_US_2D_MapProvider() |
| { |
| } |
| static ArcGIS_Topo_US_2D_MapProvider() |
| { |
| Instance = new ArcGIS_Topo_US_2D_MapProvider(); |
| } |
| #region GMapProvider Members |
| readonly Guid id = new Guid("7652CC72-5C92-40F5-B572-B8FEAA728F6D"); |
| public override Guid Id |
| { |
| get |
| { |
| return id; |
| } |
| } |
| readonly string name = "ArcGIS_Topo_US_2D_Map"; |
| public override string Name |
| { |
| get |
| { |
| return name; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| string url = MakeTileImageUrl(pos, zoom, LanguageStr); |
| return GetTileImageUsingHttp(url); |
| } |
| #endregion |
| string MakeTileImageUrl(GPoint pos, int zoom, string language) |
| { |
| // http://server.arcgisonline.com/ArcGIS/rest/services/NGS_Topo_US_2D/MapServer/tile/4/3/15 |
| return string.Format(UrlFormat, zoom, pos.Y, pos.X); |
| } |
| static readonly string UrlFormat = "http://server.arcgisonline.com/ArcGIS/rest/services/NGS_Topo_US_2D/MapServer/tile/{0}/{1}/{2}"; |
| } |
| } |
| /MKLiveView/v1.0/GMap.NET.Core/GMap.NET.MapProviders/ArcGIS/ArcGIS_World_Physical_MapProvider.cs |
|---|
| 0,0 → 1,60 |
| |
| namespace GMap.NET.MapProviders |
| { |
| using System; |
| /// <summary> |
| /// ArcGIS_World_Physical_Map provider, http://server.arcgisonline.com |
| /// </summary> |
| public class ArcGIS_World_Physical_MapProvider : ArcGISMapMercatorProviderBase |
| { |
| public static readonly ArcGIS_World_Physical_MapProvider Instance; |
| ArcGIS_World_Physical_MapProvider() |
| { |
| } |
| static ArcGIS_World_Physical_MapProvider() |
| { |
| Instance = new ArcGIS_World_Physical_MapProvider(); |
| } |
| #region GMapProvider Members |
| readonly Guid id = new Guid("0C0E73E3-5EA6-4F08-901C-AE85BCB1BFC8"); |
| public override Guid Id |
| { |
| get |
| { |
| return id; |
| } |
| } |
| readonly string name = "ArcGIS_World_Physical_Map"; |
| public override string Name |
| { |
| get |
| { |
| return name; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| string url = MakeTileImageUrl(pos, zoom, LanguageStr); |
| return GetTileImageUsingHttp(url); |
| } |
| #endregion |
| string MakeTileImageUrl(GPoint pos, int zoom, string language) |
| { |
| // http://services.arcgisonline.com/ArcGIS/rest/services/World_Physical_Map/MapServer/tile/2/0/2.jpg |
| return string.Format(UrlFormat, zoom, pos.Y, pos.X); |
| } |
| static readonly string UrlFormat = "http://server.arcgisonline.com/ArcGIS/rest/services/World_Physical_Map/MapServer/tile/{0}/{1}/{2}"; |
| } |
| } |
| /MKLiveView/v1.0/GMap.NET.Core/GMap.NET.MapProviders/ArcGIS/ArcGIS_World_Shaded_Relief_MapProvider.cs |
|---|
| 0,0 → 1,60 |
| |
| namespace GMap.NET.MapProviders |
| { |
| using System; |
| /// <summary> |
| /// ArcGIS_World_Shaded_Relief_Map provider, http://server.arcgisonline.com |
| /// </summary> |
| public class ArcGIS_World_Shaded_Relief_MapProvider : ArcGISMapMercatorProviderBase |
| { |
| public static readonly ArcGIS_World_Shaded_Relief_MapProvider Instance; |
| ArcGIS_World_Shaded_Relief_MapProvider() |
| { |
| } |
| static ArcGIS_World_Shaded_Relief_MapProvider() |
| { |
| Instance = new ArcGIS_World_Shaded_Relief_MapProvider(); |
| } |
| #region GMapProvider Members |
| readonly Guid id = new Guid("2E821FEF-8EA1-458A-BC82-4F699F4DEE79"); |
| public override Guid Id |
| { |
| get |
| { |
| return id; |
| } |
| } |
| readonly string name = "ArcGIS_World_Shaded_Relief_Map"; |
| public override string Name |
| { |
| get |
| { |
| return name; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| string url = MakeTileImageUrl(pos, zoom, LanguageStr); |
| return GetTileImageUsingHttp(url); |
| } |
| #endregion |
| string MakeTileImageUrl(GPoint pos, int zoom, string language) |
| { |
| // http://services.arcgisonline.com/ArcGIS/rest/services/World_Shaded_Relief/MapServer/tile/0/0/0jpg |
| return string.Format(UrlFormat, zoom, pos.Y, pos.X); |
| } |
| static readonly string UrlFormat = "http://server.arcgisonline.com/ArcGIS/rest/services/World_Shaded_Relief/MapServer/tile/{0}/{1}/{2}"; |
| } |
| } |
| /MKLiveView/v1.0/GMap.NET.Core/GMap.NET.MapProviders/ArcGIS/ArcGIS_World_Street_MapProvider.cs |
|---|
| 0,0 → 1,60 |
| |
| namespace GMap.NET.MapProviders |
| { |
| using System; |
| /// <summary> |
| /// ArcGIS_World_Street_Map provider, http://server.arcgisonline.com |
| /// </summary> |
| public class ArcGIS_World_Street_MapProvider : ArcGISMapMercatorProviderBase |
| { |
| public static readonly ArcGIS_World_Street_MapProvider Instance; |
| ArcGIS_World_Street_MapProvider() |
| { |
| } |
| static ArcGIS_World_Street_MapProvider() |
| { |
| Instance = new ArcGIS_World_Street_MapProvider(); |
| } |
| #region GMapProvider Members |
| readonly Guid id = new Guid("E1FACDF6-E535-4D69-A49F-12B623A467A9"); |
| public override Guid Id |
| { |
| get |
| { |
| return id; |
| } |
| } |
| readonly string name = "ArcGIS_World_Street_Map"; |
| public override string Name |
| { |
| get |
| { |
| return name; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| string url = MakeTileImageUrl(pos, zoom, LanguageStr); |
| return GetTileImageUsingHttp(url); |
| } |
| #endregion |
| string MakeTileImageUrl(GPoint pos, int zoom, string language) |
| { |
| // http://services.arcgisonline.com/ArcGIS/rest/services/World_Street_Map/MapServer/tile/0/0/0jpg |
| return string.Format(UrlFormat, zoom, pos.Y, pos.X); |
| } |
| static readonly string UrlFormat = "http://server.arcgisonline.com/ArcGIS/rest/services/World_Street_Map/MapServer/tile/{0}/{1}/{2}"; |
| } |
| } |
| /MKLiveView/v1.0/GMap.NET.Core/GMap.NET.MapProviders/ArcGIS/ArcGIS_World_Terrain_Base_MapProvider.cs |
|---|
| 0,0 → 1,60 |
| |
| namespace GMap.NET.MapProviders |
| { |
| using System; |
| /// <summary> |
| /// ArcGIS_World_Terrain_Base_Map provider, http://server.arcgisonline.com |
| /// </summary> |
| public class ArcGIS_World_Terrain_Base_MapProvider : ArcGISMapMercatorProviderBase |
| { |
| public static readonly ArcGIS_World_Terrain_Base_MapProvider Instance; |
| ArcGIS_World_Terrain_Base_MapProvider() |
| { |
| } |
| static ArcGIS_World_Terrain_Base_MapProvider() |
| { |
| Instance = new ArcGIS_World_Terrain_Base_MapProvider(); |
| } |
| #region GMapProvider Members |
| readonly Guid id = new Guid("927F175B-5200-4D95-A99B-1C87C93099DA"); |
| public override Guid Id |
| { |
| get |
| { |
| return id; |
| } |
| } |
| readonly string name = "ArcGIS_World_Terrain_Base_Map"; |
| public override string Name |
| { |
| get |
| { |
| return name; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| string url = MakeTileImageUrl(pos, zoom, LanguageStr); |
| return GetTileImageUsingHttp(url); |
| } |
| #endregion |
| string MakeTileImageUrl(GPoint pos, int zoom, string language) |
| { |
| // http://services.arcgisonline.com/ArcGIS/rest/services/World_Terrain_Base/MapServer/tile/0/0/0jpg |
| return string.Format(UrlFormat, zoom, pos.Y, pos.X); |
| } |
| static readonly string UrlFormat = "http://server.arcgisonline.com/ArcGIS/rest/services/World_Terrain_Base/MapServer/tile/{0}/{1}/{2}"; |
| } |
| } |
| /MKLiveView/v1.0/GMap.NET.Core/GMap.NET.MapProviders/ArcGIS/ArcGIS_World_Topo_MapProvider.cs |
|---|
| 0,0 → 1,60 |
| |
| namespace GMap.NET.MapProviders |
| { |
| using System; |
| /// <summary> |
| /// ArcGIS_World_Topo_Map provider, http://server.arcgisonline.com |
| /// </summary> |
| public class ArcGIS_World_Topo_MapProvider : ArcGISMapMercatorProviderBase |
| { |
| public static readonly ArcGIS_World_Topo_MapProvider Instance; |
| ArcGIS_World_Topo_MapProvider() |
| { |
| } |
| static ArcGIS_World_Topo_MapProvider() |
| { |
| Instance = new ArcGIS_World_Topo_MapProvider(); |
| } |
| #region GMapProvider Members |
| readonly Guid id = new Guid("E0354A49-7447-4C9A-814F-A68565ED834B"); |
| public override Guid Id |
| { |
| get |
| { |
| return id; |
| } |
| } |
| readonly string name = "ArcGIS_World_Topo_Map"; |
| public override string Name |
| { |
| get |
| { |
| return name; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| string url = MakeTileImageUrl(pos, zoom, LanguageStr); |
| return GetTileImageUsingHttp(url); |
| } |
| #endregion |
| string MakeTileImageUrl(GPoint pos, int zoom, string language) |
| { |
| // http://services.arcgisonline.com/ArcGIS/rest/services/World_Topo_Map/MapServer/tile/0/0/0jpg |
| return string.Format(UrlFormat, zoom, pos.Y, pos.X); |
| } |
| static readonly string UrlFormat = "http://server.arcgisonline.com/ArcGIS/rest/services/World_Topo_Map/MapServer/tile/{0}/{1}/{2}"; |
| } |
| } |
| /MKLiveView/v1.0/GMap.NET.Core/GMap.NET.MapProviders/Bing/BingHybridMapProvider.cs |
|---|
| 0,0 → 1,85 |
| |
| namespace GMap.NET.MapProviders |
| { |
| using System; |
| /// <summary> |
| /// BingHybridMap provider |
| /// </summary> |
| public class BingHybridMapProvider : BingMapProviderBase |
| { |
| public static readonly BingHybridMapProvider Instance; |
| BingHybridMapProvider() |
| { |
| } |
| static BingHybridMapProvider() |
| { |
| Instance = new BingHybridMapProvider(); |
| } |
| #region GMapProvider Members |
| readonly Guid id = new Guid("94E2FCB4-CAAC-45EA-A1F9-8147C4B14970"); |
| public override Guid Id |
| { |
| get |
| { |
| return id; |
| } |
| } |
| readonly string name = "BingHybridMap"; |
| public override string Name |
| { |
| get |
| { |
| return name; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| string url = MakeTileImageUrl(pos, zoom, LanguageStr); |
| return GetTileImageUsingHttp(url); |
| } |
| public override void OnInitialized() |
| { |
| base.OnInitialized(); |
| if(!DisableDynamicTileUrlFormat) |
| { |
| //UrlFormat[AerialWithLabels]: http://ecn.{subdomain}.tiles.virtualearth.net/tiles/h{quadkey}.jpeg?g=3179&mkt={culture} |
| UrlDynamicFormat = GetTileUrl("AerialWithLabels"); |
| if(!string.IsNullOrEmpty(UrlDynamicFormat)) |
| { |
| UrlDynamicFormat = UrlDynamicFormat.Replace("{subdomain}", "t{0}").Replace("{quadkey}", "{1}").Replace("{culture}", "{2}"); |
| } |
| } |
| } |
| #endregion |
| string MakeTileImageUrl(GPoint pos, int zoom, string language) |
| { |
| string key = TileXYToQuadKey(pos.X, pos.Y, zoom); |
| if(!DisableDynamicTileUrlFormat && !string.IsNullOrEmpty(UrlDynamicFormat)) |
| { |
| return string.Format(UrlDynamicFormat, GetServerNum(pos, 4), key, language); |
| } |
| return string.Format(UrlFormat, GetServerNum(pos, 4), key, Version, language, ForceSessionIdOnTileAccess ? "&key=" + SessionId : string.Empty); |
| } |
| string UrlDynamicFormat = string.Empty; |
| // http://ecn.dynamic.t3.tiles.virtualearth.net/comp/CompositionHandler/12030012020203?mkt=en-us&it=A,G,L&n=z |
| static readonly string UrlFormat = "http://ecn.t{0}.tiles.virtualearth.net/tiles/h{1}.jpeg?g={2}&mkt={3}&n=z{4}"; |
| } |
| } |
| /MKLiveView/v1.0/GMap.NET.Core/GMap.NET.MapProviders/Bing/BingMapProvider.cs |
|---|
| 0,0 → 1,779 |
| |
| namespace GMap.NET.MapProviders |
| { |
| using System; |
| using System.Collections.Generic; |
| using System.Diagnostics; |
| using System.Globalization; |
| using System.Net; |
| using System.Text; |
| using System.Text.RegularExpressions; |
| using System.Threading; |
| using System.Xml; |
| using GMap.NET.Internals; |
| using GMap.NET.Projections; |
| public abstract class BingMapProviderBase : GMapProvider, RoutingProvider, GeocodingProvider |
| { |
| public BingMapProviderBase() |
| { |
| MaxZoom = null; |
| RefererUrl = "http://www.bing.com/maps/"; |
| Copyright = string.Format("©{0} Microsoft Corporation, ©{0} NAVTEQ, ©{0} Image courtesy of NASA", DateTime.Today.Year); |
| } |
| public string Version = "4810"; |
| /// <summary> |
| /// Bing Maps Customer Identification. |
| /// | |
| /// FOR LEGAL AND COMMERCIAL USAGE SET YOUR OWN REGISTERED KEY |
| /// | |
| /// http://msdn.microsoft.com/en-us/library/ff428642.aspx |
| /// </summary> |
| public string ClientKey = string.Empty; |
| internal string SessionId = string.Empty; |
| /// <summary> |
| /// set true to append SessionId on requesting tiles |
| /// </summary> |
| public bool ForceSessionIdOnTileAccess = false; |
| /// <summary> |
| /// set true to avoid using dynamic tile url format |
| /// </summary> |
| public bool DisableDynamicTileUrlFormat = false; |
| /// <summary> |
| /// Converts tile XY coordinates into a QuadKey at a specified level of detail. |
| /// </summary> |
| /// <param name="tileX">Tile X coordinate.</param> |
| /// <param name="tileY">Tile Y coordinate.</param> |
| /// <param name="levelOfDetail">Level of detail, from 1 (lowest detail) |
| /// to 23 (highest detail).</param> |
| /// <returns>A string containing the QuadKey.</returns> |
| internal string TileXYToQuadKey(long tileX, long tileY, int levelOfDetail) |
| { |
| StringBuilder quadKey = new StringBuilder(); |
| for(int i = levelOfDetail; i > 0; i--) |
| { |
| char digit = '0'; |
| int mask = 1 << (i - 1); |
| if((tileX & mask) != 0) |
| { |
| digit++; |
| } |
| if((tileY & mask) != 0) |
| { |
| digit++; |
| digit++; |
| } |
| quadKey.Append(digit); |
| } |
| return quadKey.ToString(); |
| } |
| /// <summary> |
| /// Converts a QuadKey into tile XY coordinates. |
| /// </summary> |
| /// <param name="quadKey">QuadKey of the tile.</param> |
| /// <param name="tileX">Output parameter receiving the tile X coordinate.</param> |
| /// <param name="tileY">Output parameter receiving the tile Y coordinate.</param> |
| /// <param name="levelOfDetail">Output parameter receiving the level of detail.</param> |
| internal void QuadKeyToTileXY(string quadKey, out int tileX, out int tileY, out int levelOfDetail) |
| { |
| tileX = tileY = 0; |
| levelOfDetail = quadKey.Length; |
| for(int i = levelOfDetail; i > 0; i--) |
| { |
| int mask = 1 << (i - 1); |
| switch(quadKey[levelOfDetail - i]) |
| { |
| case '0': |
| break; |
| case '1': |
| tileX |= mask; |
| break; |
| case '2': |
| tileY |= mask; |
| break; |
| case '3': |
| tileX |= mask; |
| tileY |= mask; |
| break; |
| default: |
| throw new ArgumentException("Invalid QuadKey digit sequence."); |
| } |
| } |
| } |
| #region GMapProvider Members |
| public override Guid Id |
| { |
| get |
| { |
| throw new NotImplementedException(); |
| } |
| } |
| public override string Name |
| { |
| get |
| { |
| throw new NotImplementedException(); |
| } |
| } |
| public override PureProjection Projection |
| { |
| get |
| { |
| return MercatorProjection.Instance; |
| } |
| } |
| GMapProvider[] overlays; |
| public override GMapProvider[] Overlays |
| { |
| get |
| { |
| if(overlays == null) |
| { |
| overlays = new GMapProvider[] { this }; |
| } |
| return overlays; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| throw new NotImplementedException(); |
| } |
| #endregion |
| public bool TryCorrectVersion = true; |
| /// <summary> |
| /// set false to use your own key. |
| /// FOR LEGAL AND COMMERCIAL USAGE SET YOUR OWN REGISTERED KEY |
| /// http://msdn.microsoft.com/en-us/library/ff428642.aspx |
| /// </summary> |
| public bool TryGetDefaultKey = true; |
| static bool init = false; |
| public override void OnInitialized() |
| { |
| if(!init) |
| { |
| try |
| { |
| var key = ClientKey; |
| // to avoid registration stuff, default key |
| if(TryGetDefaultKey && string.IsNullOrEmpty(ClientKey)) |
| { |
| //old: Vx8dmDflxzT02jJUG8bEjMU07Xr9QWRpPTeRuAZTC1uZFQdDCvK/jUbHKdyHEWj4LvccTPoKofDHtzHsWu/0xuo5u2Y9rj88 |
| key = Stuff.GString("Jq7FrGTyaYqcrvv9ugBKv4OVSKnmzpigqZtdvtcDdgZexmOZ2RugOexFSmVzTAhOWiHrdhFoNCoySnNF3MyyIOo5u2Y9rj88"); |
| } |
| #region -- try get sesion key -- |
| if(!string.IsNullOrEmpty(key)) |
| { |
| string keyResponse = GMaps.Instance.UseUrlCache ? Cache.Instance.GetContent("BingLoggingServiceV1" + key, CacheType.UrlCache, TimeSpan.FromHours(8)) : string.Empty; |
| if(string.IsNullOrEmpty(keyResponse)) |
| { |
| // Bing Maps WPF Control |
| // http://dev.virtualearth.net/webservices/v1/LoggingService/LoggingService.svc/Log?entry=0&auth={0}&fmt=1&type=3&group=MapControl&name=WPF&version=1.0.0.0&session=00000000-0000-0000-0000-000000000000&mkt=en-US |
| keyResponse = GetContentUsingHttp(string.Format("http://dev.virtualearth.net/webservices/v1/LoggingService/LoggingService.svc/Log?entry=0&fmt=1&type=3&group=MapControl&name=AJAX&mkt=en-us&auth={0}&jsonp=microsoftMapsNetworkCallback", key)); |
| if(!string.IsNullOrEmpty(keyResponse) && keyResponse.Contains("ValidCredentials")) |
| { |
| if(GMaps.Instance.UseUrlCache) |
| { |
| Cache.Instance.SaveContent("BingLoggingServiceV1" + key, CacheType.UrlCache, keyResponse); |
| } |
| } |
| } |
| if(!string.IsNullOrEmpty(keyResponse) && keyResponse.Contains("sessionId") && keyResponse.Contains("ValidCredentials")) |
| { |
| // microsoftMapsNetworkCallback({"sessionId" : "xxx", "authenticationResultCode" : "ValidCredentials"}) |
| SessionId = keyResponse.Split(',')[0].Split(':')[1].Replace("\"", string.Empty).Replace(" ", string.Empty); |
| Debug.WriteLine("GMapProviders.BingMap.SessionId: " + SessionId); |
| } |
| else |
| { |
| Debug.WriteLine("BingLoggingServiceV1: " + keyResponse); |
| } |
| } |
| #endregion |
| // supporting old road |
| if(TryCorrectVersion && DisableDynamicTileUrlFormat) |
| { |
| #region -- get the version -- |
| string url = @"http://www.bing.com/maps"; |
| string html = GMaps.Instance.UseUrlCache ? Cache.Instance.GetContent(url, CacheType.UrlCache, TimeSpan.FromDays(7)) : string.Empty; |
| if(string.IsNullOrEmpty(html)) |
| { |
| html = GetContentUsingHttp(url); |
| if(!string.IsNullOrEmpty(html)) |
| { |
| if(GMaps.Instance.UseUrlCache) |
| { |
| Cache.Instance.SaveContent(url, CacheType.UrlCache, html); |
| } |
| } |
| } |
| if(!string.IsNullOrEmpty(html)) |
| { |
| #region -- match versions -- |
| Regex reg = new Regex("tilegeneration:(\\d*)", RegexOptions.IgnoreCase); |
| Match mat = reg.Match(html); |
| if(mat.Success) |
| { |
| GroupCollection gc = mat.Groups; |
| int count = gc.Count; |
| if(count == 2) |
| { |
| string ver = gc[1].Value; |
| string old = GMapProviders.BingMap.Version; |
| if(ver != old) |
| { |
| GMapProviders.BingMap.Version = ver; |
| GMapProviders.BingSatelliteMap.Version = ver; |
| GMapProviders.BingHybridMap.Version = ver; |
| #if DEBUG |
| Debug.WriteLine("GMapProviders.BingMap.Version: " + ver + ", old: " + old + ", consider updating source"); |
| if(Debugger.IsAttached) |
| { |
| Thread.Sleep(5555); |
| } |
| #endif |
| } |
| else |
| { |
| Debug.WriteLine("GMapProviders.BingMap.Version: " + ver + ", OK"); |
| } |
| } |
| } |
| #endregion |
| } |
| #endregion |
| } |
| init = true; // try it only once |
| } |
| catch(Exception ex) |
| { |
| Debug.WriteLine("TryCorrectBingVersions failed: " + ex); |
| } |
| } |
| } |
| protected override bool CheckTileImageHttpResponse(WebResponse response) |
| { |
| var pass = base.CheckTileImageHttpResponse(response); |
| if(pass) |
| { |
| var tileInfo = response.Headers.Get("X-VE-Tile-Info"); |
| if(tileInfo != null) |
| { |
| return !tileInfo.Equals("no-tile"); |
| } |
| } |
| return pass; |
| } |
| internal string GetTileUrl(string imageryType) |
| { |
| //Retrieve map tile URL from the Imagery Metadata service: http://msdn.microsoft.com/en-us/library/ff701716.aspx |
| //This ensures that the current tile URL is always used. |
| //This will prevent the app from breaking when the map tiles change. |
| string ret = string.Empty; |
| if(!string.IsNullOrEmpty(SessionId)) |
| { |
| try |
| { |
| string url = "http://dev.virtualearth.net/REST/V1/Imagery/Metadata/" + imageryType + "?output=xml&key=" + SessionId; |
| string r = GMaps.Instance.UseUrlCache ? Cache.Instance.GetContent("GetTileUrl" + imageryType, CacheType.UrlCache, TimeSpan.FromDays(7)) : string.Empty; |
| bool cache = false; |
| if(string.IsNullOrEmpty(r)) |
| { |
| r = GetContentUsingHttp(url); |
| cache = true; |
| } |
| if(!string.IsNullOrEmpty(r)) |
| { |
| XmlDocument doc = new XmlDocument(); |
| doc.LoadXml(r); |
| XmlNode xn = doc["Response"]; |
| string statuscode = xn["StatusCode"].InnerText; |
| if(string.Compare(statuscode, "200", true) == 0) |
| { |
| xn = xn["ResourceSets"]["ResourceSet"]["Resources"]; |
| XmlNodeList xnl = xn.ChildNodes; |
| foreach(XmlNode xno in xnl) |
| { |
| XmlNode imageUrl = xno["ImageUrl"]; |
| if(imageUrl != null && !string.IsNullOrEmpty(imageUrl.InnerText)) |
| { |
| if(cache && GMaps.Instance.UseUrlCache) |
| { |
| Cache.Instance.SaveContent("GetTileUrl" + imageryType, CacheType.UrlCache, r); |
| } |
| var baseTileUrl = imageUrl.InnerText; |
| if(baseTileUrl.Contains("{key}") || baseTileUrl.Contains("{token}")) |
| { |
| baseTileUrl.Replace("{key}", SessionId).Replace("{token}", SessionId); |
| } |
| else if(ForceSessionIdOnTileAccess) |
| { |
| // haven't seen anyone doing that, yet? ;/ |
| baseTileUrl += "&key=" + SessionId; |
| } |
| Debug.WriteLine("GetTileUrl, UrlFormat[" + imageryType + "]: " + baseTileUrl); |
| ret = baseTileUrl; |
| break; |
| } |
| } |
| } |
| } |
| } |
| catch(Exception ex) |
| { |
| Debug.WriteLine("GetTileUrl: Error getting Bing Maps tile URL - " + ex); |
| } |
| } |
| return ret; |
| } |
| #region RoutingProvider |
| public MapRoute GetRoute(PointLatLng start, PointLatLng end, bool avoidHighways, bool walkingMode, int Zoom) |
| { |
| string tooltip; |
| int numLevels; |
| int zoomFactor; |
| MapRoute ret = null; |
| List<PointLatLng> points = GetRoutePoints(MakeRouteUrl(start, end, LanguageStr, avoidHighways, walkingMode), Zoom, out tooltip, out numLevels, out zoomFactor); |
| if(points != null) |
| { |
| ret = new MapRoute(points, tooltip); |
| } |
| return ret; |
| } |
| public MapRoute GetRoute(string start, string end, bool avoidHighways, bool walkingMode, int Zoom) |
| { |
| string tooltip; |
| int numLevels; |
| int zoomFactor; |
| MapRoute ret = null; |
| List<PointLatLng> points = GetRoutePoints(MakeRouteUrl(start, end, LanguageStr, avoidHighways, walkingMode), Zoom, out tooltip, out numLevels, out zoomFactor); |
| if(points != null) |
| { |
| ret = new MapRoute(points, tooltip); |
| } |
| return ret; |
| } |
| string MakeRouteUrl(string start, string end, string language, bool avoidHighways, bool walkingMode) |
| { |
| string addition = avoidHighways ? "&avoid=highways" : string.Empty; |
| string mode = walkingMode ? "Walking" : "Driving"; |
| return string.Format(CultureInfo.InvariantCulture, RouteUrlFormatPointQueries, mode, start, end, addition, SessionId); |
| } |
| string MakeRouteUrl(PointLatLng start, PointLatLng end, string language, bool avoidHighways, bool walkingMode) |
| { |
| string addition = avoidHighways ? "&avoid=highways" : string.Empty; |
| string mode = walkingMode ? "Walking" : "Driving"; |
| return string.Format(CultureInfo.InvariantCulture, RouteUrlFormatPointLatLng, mode, start.Lat, start.Lng, end.Lat, end.Lng, addition, SessionId); |
| } |
| List<PointLatLng> GetRoutePoints(string url, int zoom, out string tooltipHtml, out int numLevel, out int zoomFactor) |
| { |
| List<PointLatLng> points = null; |
| tooltipHtml = string.Empty; |
| numLevel = -1; |
| zoomFactor = -1; |
| try |
| { |
| string route = GMaps.Instance.UseRouteCache ? Cache.Instance.GetContent(url, CacheType.RouteCache) : string.Empty; |
| if(string.IsNullOrEmpty(route)) |
| { |
| route = GetContentUsingHttp(url); |
| if(!string.IsNullOrEmpty(route)) |
| { |
| if(GMaps.Instance.UseRouteCache) |
| { |
| Cache.Instance.SaveContent(url, CacheType.RouteCache, route); |
| } |
| } |
| } |
| // parse values |
| if(!string.IsNullOrEmpty(route)) |
| { |
| #region -- title -- |
| int tooltipEnd = 0; |
| { |
| int x = route.IndexOf("<RoutePath><Line>") + 17; |
| if(x >= 17) |
| { |
| tooltipEnd = route.IndexOf("</Line></RoutePath>", x + 1); |
| if(tooltipEnd > 0) |
| { |
| int l = tooltipEnd - x; |
| if(l > 0) |
| { |
| //tooltipHtml = route.Substring(x, l).Replace(@"\x26#160;", " "); |
| tooltipHtml = route.Substring(x, l); |
| } |
| } |
| } |
| } |
| #endregion |
| #region -- points -- |
| XmlDocument doc = new XmlDocument(); |
| doc.LoadXml(route); |
| XmlNode xn = doc["Response"]; |
| string statuscode = xn["StatusCode"].InnerText; |
| switch(statuscode) |
| { |
| case "200": |
| { |
| xn = xn["ResourceSets"]["ResourceSet"]["Resources"]["Route"]["RoutePath"]["Line"]; |
| XmlNodeList xnl = xn.ChildNodes; |
| if(xnl.Count > 0) |
| { |
| points = new List<PointLatLng>(); |
| foreach(XmlNode xno in xnl) |
| { |
| XmlNode latitude = xno["Latitude"]; |
| XmlNode longitude = xno["Longitude"]; |
| points.Add(new PointLatLng(double.Parse(latitude.InnerText, CultureInfo.InvariantCulture), |
| double.Parse(longitude.InnerText, CultureInfo.InvariantCulture))); |
| } |
| } |
| break; |
| } |
| // no status implementation on routes yet although when introduced these are the codes. Exception will be catched. |
| case "400": |
| throw new Exception("Bad Request, The request contained an error."); |
| case "401": |
| throw new Exception("Unauthorized, Access was denied. You may have entered your credentials incorrectly, or you might not have access to the requested resource or operation."); |
| case "403": |
| throw new Exception("Forbidden, The request is for something forbidden. Authorization will not help."); |
| case "404": |
| throw new Exception("Not Found, The requested resource was not found."); |
| case "500": |
| throw new Exception("Internal Server Error, Your request could not be completed because there was a problem with the service."); |
| case "501": |
| throw new Exception("Service Unavailable, There's a problem with the service right now. Please try again later."); |
| default: |
| points = null; |
| break; // unknown, for possible future error codes |
| } |
| #endregion |
| } |
| } |
| catch(Exception ex) |
| { |
| points = null; |
| Debug.WriteLine("GetRoutePoints: " + ex); |
| } |
| return points; |
| } |
| // example : http://dev.virtualearth.net/REST/V1/Routes/Driving?o=xml&wp.0=44.979035,-93.26493&wp.1=44.943828508257866,-93.09332862496376&optmz=distance&rpo=Points&key=[PROVIDEYOUROWNKEY!!] |
| static readonly string RouteUrlFormatPointLatLng = "http://dev.virtualearth.net/REST/V1/Routes/{0}?o=xml&wp.0={1},{2}&wp.1={3},{4}{5}&optmz=distance&rpo=Points&key={6}"; |
| static readonly string RouteUrlFormatPointQueries = "http://dev.virtualearth.net/REST/V1/Routes/{0}?o=xml&wp.0={1}&wp.1={2}{3}&optmz=distance&rpo=Points&key={4}"; |
| #endregion RoutingProvider |
| #region GeocodingProvider |
| public GeoCoderStatusCode GetPoints(string keywords, out List<PointLatLng> pointList) |
| { |
| //Escape keywords to better handle special characters. |
| return GetLatLngFromGeocoderUrl(MakeGeocoderUrl("q=" + Uri.EscapeDataString(keywords)), out pointList); |
| } |
| public PointLatLng? GetPoint(string keywords, out GeoCoderStatusCode status) |
| { |
| List<PointLatLng> pointList; |
| status = GetPoints(keywords, out pointList); |
| return pointList != null && pointList.Count > 0 ? pointList[0] : (PointLatLng?)null; |
| } |
| public GeoCoderStatusCode GetPoints(Placemark placemark, out List<PointLatLng> pointList) |
| { |
| return GetLatLngFromGeocoderUrl(MakeGeocoderDetailedUrl(placemark), out pointList); |
| } |
| public PointLatLng? GetPoint(Placemark placemark, out GeoCoderStatusCode status) |
| { |
| List<PointLatLng> pointList; |
| status = GetLatLngFromGeocoderUrl(MakeGeocoderDetailedUrl(placemark), out pointList); |
| return pointList != null && pointList.Count > 0 ? pointList[0] : (PointLatLng?)null; |
| } |
| string MakeGeocoderDetailedUrl(Placemark placemark) |
| { |
| string parameters = string.Empty; |
| if(!AddFieldIfNotEmpty(ref parameters, "countryRegion", placemark.CountryNameCode)) |
| AddFieldIfNotEmpty(ref parameters, "countryRegion", placemark.CountryName); |
| AddFieldIfNotEmpty(ref parameters, "adminDistrict", placemark.DistrictName); |
| AddFieldIfNotEmpty(ref parameters, "locality", placemark.LocalityName); |
| AddFieldIfNotEmpty(ref parameters, "postalCode", placemark.PostalCodeNumber); |
| if(!string.IsNullOrEmpty(placemark.HouseNo)) |
| AddFieldIfNotEmpty(ref parameters, "addressLine", placemark.ThoroughfareName + " " + placemark.HouseNo); |
| else |
| AddFieldIfNotEmpty(ref parameters, "addressLine", placemark.ThoroughfareName); |
| return MakeGeocoderUrl(parameters); |
| } |
| bool AddFieldIfNotEmpty(ref string Input, string FieldName, string Value) |
| { |
| if(!string.IsNullOrEmpty(Value)) |
| { |
| if(string.IsNullOrEmpty(Input)) |
| Input = string.Empty; |
| else |
| Input = Input + "&"; |
| Input = Input + FieldName + "=" + Value; |
| return true; |
| } |
| return false; |
| } |
| public GeoCoderStatusCode GetPlacemarks(PointLatLng location, out List<Placemark> placemarkList) |
| { |
| // http://msdn.microsoft.com/en-us/library/ff701713.aspx |
| throw new NotImplementedException(); |
| } |
| public Placemark? GetPlacemark(PointLatLng location, out GeoCoderStatusCode status) |
| { |
| // http://msdn.microsoft.com/en-us/library/ff701713.aspx |
| throw new NotImplementedException(); |
| } |
| string MakeGeocoderUrl(string keywords) |
| { |
| return string.Format(CultureInfo.InvariantCulture, GeocoderUrlFormat, keywords, SessionId); |
| } |
| GeoCoderStatusCode GetLatLngFromGeocoderUrl(string url, out List<PointLatLng> pointList) |
| { |
| var status = GeoCoderStatusCode.Unknow; |
| pointList = null; |
| try |
| { |
| string geo = GMaps.Instance.UseGeocoderCache ? Cache.Instance.GetContent(url, CacheType.GeocoderCache) : string.Empty; |
| bool cache = false; |
| if(string.IsNullOrEmpty(geo)) |
| { |
| geo = GetContentUsingHttp(url); |
| if(!string.IsNullOrEmpty(geo)) |
| { |
| cache = true; |
| } |
| } |
| status = GeoCoderStatusCode.Unknow; |
| if(!string.IsNullOrEmpty(geo)) |
| { |
| if(geo.StartsWith("<?xml") && geo.Contains("<Response")) |
| { |
| XmlDocument doc = new XmlDocument(); |
| doc.LoadXml(geo); |
| XmlNode xn = doc["Response"]; |
| string statuscode = xn["StatusCode"].InnerText; |
| switch(statuscode) |
| { |
| case "200": |
| { |
| pointList = new List<PointLatLng>(); |
| xn = xn["ResourceSets"]["ResourceSet"]["Resources"]; |
| XmlNodeList xnl = xn.ChildNodes; |
| foreach(XmlNode xno in xnl) |
| { |
| XmlNode latitude = xno["Point"]["Latitude"]; |
| XmlNode longitude = xno["Point"]["Longitude"]; |
| pointList.Add(new PointLatLng(Double.Parse(latitude.InnerText, CultureInfo.InvariantCulture), |
| Double.Parse(longitude.InnerText, CultureInfo.InvariantCulture))); |
| } |
| if(pointList.Count > 0) |
| { |
| status = GeoCoderStatusCode.G_GEO_SUCCESS; |
| if(cache && GMaps.Instance.UseGeocoderCache) |
| { |
| Cache.Instance.SaveContent(url, CacheType.GeocoderCache, geo); |
| } |
| break; |
| } |
| status = GeoCoderStatusCode.G_GEO_UNKNOWN_ADDRESS; |
| break; |
| } |
| case "400": |
| status = GeoCoderStatusCode.G_GEO_BAD_REQUEST; |
| break; // bad request, The request contained an error. |
| case "401": |
| status = GeoCoderStatusCode.G_GEO_BAD_KEY; |
| break; // Unauthorized, Access was denied. You may have entered your credentials incorrectly, or you might not have access to the requested resource or operation. |
| case "403": |
| status = GeoCoderStatusCode.G_GEO_BAD_REQUEST; |
| break; // Forbidden, The request is for something forbidden. Authorization will not help. |
| case "404": |
| status = GeoCoderStatusCode.G_GEO_UNKNOWN_ADDRESS; |
| break; // Not Found, The requested resource was not found. |
| case "500": |
| status = GeoCoderStatusCode.G_GEO_SERVER_ERROR; |
| break; // Internal Server Error, Your request could not be completed because there was a problem with the service. |
| case "501": |
| status = GeoCoderStatusCode.Unknow; |
| break; // Service Unavailable, There's a problem with the service right now. Please try again later. |
| default: |
| status = GeoCoderStatusCode.Unknow; |
| break; // unknown, for possible future error codes |
| } |
| } |
| } |
| } |
| catch(Exception ex) |
| { |
| status = GeoCoderStatusCode.ExceptionInCode; |
| Debug.WriteLine("GetLatLngFromGeocoderUrl: " + ex); |
| } |
| return status; |
| } |
| // http://dev.virtualearth.net/REST/v1/Locations/1%20Microsoft%20Way%20Redmond%20WA%2098052?o=xml&key=BingMapsKey |
| static readonly string GeocoderUrlFormat = "http://dev.virtualearth.net/REST/v1/Locations?{0}&o=xml&key={1}"; |
| #endregion GeocodingProvider |
| } |
| /// <summary> |
| /// BingMapProvider provider |
| /// </summary> |
| public class BingMapProvider : BingMapProviderBase |
| { |
| public static readonly BingMapProvider Instance; |
| BingMapProvider() |
| { |
| } |
| static BingMapProvider() |
| { |
| Instance = new BingMapProvider(); |
| } |
| #region GMapProvider Members |
| readonly Guid id = new Guid("D0CEB371-F10A-4E12-A2C1-DF617D6674A8"); |
| public override Guid Id |
| { |
| get |
| { |
| return id; |
| } |
| } |
| readonly string name = "BingMap"; |
| public override string Name |
| { |
| get |
| { |
| return name; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| string url = MakeTileImageUrl(pos, zoom, LanguageStr); |
| return GetTileImageUsingHttp(url); |
| } |
| public override void OnInitialized() |
| { |
| base.OnInitialized(); |
| if(!DisableDynamicTileUrlFormat) |
| { |
| //UrlFormat[Road]: http://ecn.{subdomain}.tiles.virtualearth.net/tiles/r{quadkey}.jpeg?g=3179&mkt={culture}&shading=hill |
| UrlDynamicFormat = GetTileUrl("Road"); |
| if(!string.IsNullOrEmpty(UrlDynamicFormat)) |
| { |
| UrlDynamicFormat = UrlDynamicFormat.Replace("{subdomain}", "t{0}").Replace("{quadkey}", "{1}").Replace("{culture}", "{2}"); |
| } |
| } |
| } |
| #endregion |
| string MakeTileImageUrl(GPoint pos, int zoom, string language) |
| { |
| string key = TileXYToQuadKey(pos.X, pos.Y, zoom); |
| if(!DisableDynamicTileUrlFormat && !string.IsNullOrEmpty(UrlDynamicFormat)) |
| { |
| return string.Format(UrlDynamicFormat, GetServerNum(pos, 4), key, language); |
| } |
| return string.Format(UrlFormat, GetServerNum(pos, 4), key, Version, language, ForceSessionIdOnTileAccess ? "&key=" + SessionId : string.Empty); |
| } |
| string UrlDynamicFormat = string.Empty; |
| // http://ecn.t0.tiles.virtualearth.net/tiles/r120030?g=875&mkt=en-us&lbl=l1&stl=h&shading=hill&n=z |
| static readonly string UrlFormat = "http://ecn.t{0}.tiles.virtualearth.net/tiles/r{1}?g={2}&mkt={3}&lbl=l1&stl=h&shading=hill&n=z{4}"; |
| } |
| } |
| /MKLiveView/v1.0/GMap.NET.Core/GMap.NET.MapProviders/Bing/BingSatelliteMapProvider.cs |
|---|
| 0,0 → 1,85 |
| |
| namespace GMap.NET.MapProviders |
| { |
| using System; |
| /// <summary> |
| /// BingSatelliteMapProvider provider |
| /// </summary> |
| public class BingSatelliteMapProvider : BingMapProviderBase |
| { |
| public static readonly BingSatelliteMapProvider Instance; |
| BingSatelliteMapProvider() |
| { |
| } |
| static BingSatelliteMapProvider() |
| { |
| Instance = new BingSatelliteMapProvider(); |
| } |
| #region GMapProvider Members |
| readonly Guid id = new Guid("3AC742DD-966B-4CFB-B67D-33E7F82F2D37"); |
| public override Guid Id |
| { |
| get |
| { |
| return id; |
| } |
| } |
| readonly string name = "BingSatelliteMap"; |
| public override string Name |
| { |
| get |
| { |
| return name; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| string url = MakeTileImageUrl(pos, zoom, LanguageStr); |
| return GetTileImageUsingHttp(url); |
| } |
| public override void OnInitialized() |
| { |
| base.OnInitialized(); |
| if(!DisableDynamicTileUrlFormat) |
| { |
| //UrlFormat[Aerial]: http://ecn.{subdomain}.tiles.virtualearth.net/tiles/a{quadkey}.jpeg?g=3179 |
| UrlDynamicFormat = GetTileUrl("Aerial"); |
| if(!string.IsNullOrEmpty(UrlDynamicFormat)) |
| { |
| UrlDynamicFormat = UrlDynamicFormat.Replace("{subdomain}", "t{0}").Replace("{quadkey}", "{1}"); |
| } |
| } |
| } |
| #endregion |
| string MakeTileImageUrl(GPoint pos, int zoom, string language) |
| { |
| string key = TileXYToQuadKey(pos.X, pos.Y, zoom); |
| if(!DisableDynamicTileUrlFormat && !string.IsNullOrEmpty(UrlDynamicFormat)) |
| { |
| return string.Format(UrlDynamicFormat, GetServerNum(pos, 4), key); |
| } |
| return string.Format(UrlFormat, GetServerNum(pos, 4), key, Version, language, ForceSessionIdOnTileAccess ? "&key=" + SessionId : string.Empty); |
| } |
| string UrlDynamicFormat = string.Empty; |
| // http://ecn.t1.tiles.virtualearth.net/tiles/a12030003131321231.jpeg?g=875&mkt=en-us&n=z |
| static readonly string UrlFormat = "http://ecn.t{0}.tiles.virtualearth.net/tiles/a{1}.jpeg?g={2}&mkt={3}&n=z{4}"; |
| } |
| } |
| /MKLiveView/v1.0/GMap.NET.Core/GMap.NET.MapProviders/Czech/CzechGeographicMapProvider.cs |
|---|
| 0,0 → 1,59 |
| namespace GMap.NET.MapProviders |
| { |
| using System; |
| /// <summary> |
| /// CzechTuristMap provider, http://www.mapy.cz/ |
| /// </summary> |
| public class CzechGeographicMapProvider : CzechMapProviderBase |
| { |
| public static readonly CzechGeographicMapProvider Instance; |
| CzechGeographicMapProvider() |
| { |
| } |
| static CzechGeographicMapProvider() |
| { |
| Instance = new CzechGeographicMapProvider(); |
| } |
| #region GMapProvider Members |
| readonly Guid id = new Guid("50EC9FCC-E4D7-4F53-8700-2D1DB73A1D48"); |
| public override Guid Id |
| { |
| get |
| { |
| return id; |
| } |
| } |
| readonly string name = "CzechGeographicMap"; |
| public override string Name |
| { |
| get |
| { |
| return name; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| string url = MakeTileImageUrl(pos, zoom, LanguageStr); |
| return GetTileImageUsingHttp(url); |
| } |
| #endregion |
| string MakeTileImageUrl(GPoint pos, int zoom, string language) |
| { |
| // http://m3.mapserver.mapy.czzemepis-m/14-8802-5528 |
| return string.Format(UrlFormat, GetServerNum(pos, 3) + 1, zoom, pos.X, pos.Y); |
| } |
| static readonly string UrlFormat = "http://m{0}.mapserver.mapy.cz/zemepis-m/{1}-{2}-{3}"; |
| } |
| } |
| /MKLiveView/v1.0/GMap.NET.Core/GMap.NET.MapProviders/Czech/CzechHistoryMapProvider.cs |
|---|
| 0,0 → 1,74 |
| |
| namespace GMap.NET.MapProviders |
| { |
| using System; |
| /// <summary> |
| /// CzechHistoryMap provider, http://www.mapy.cz/ |
| /// </summary> |
| public class CzechHistoryMapProvider : CzechMapProviderBase |
| { |
| public static readonly CzechHistoryMapProvider Instance; |
| CzechHistoryMapProvider() |
| { |
| MaxZoom = 15; |
| } |
| static CzechHistoryMapProvider() |
| { |
| Instance = new CzechHistoryMapProvider(); |
| } |
| #region GMapProvider Members |
| readonly Guid id = new Guid("CD44C19D-5EED-4623-B367-FB39FDC55B8F"); |
| public override Guid Id |
| { |
| get |
| { |
| return id; |
| } |
| } |
| readonly string name = "CzechHistoryMap"; |
| public override string Name |
| { |
| get |
| { |
| return name; |
| } |
| } |
| GMapProvider[] overlays; |
| public override GMapProvider[] Overlays |
| { |
| get |
| { |
| if(overlays == null) |
| { |
| overlays = new GMapProvider[] { this, CzechHybridMapProvider.Instance }; |
| } |
| return overlays; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| string url = MakeTileImageUrl(pos, zoom, LanguageStr); |
| return GetTileImageUsingHttp(url); |
| } |
| #endregion |
| string MakeTileImageUrl(GPoint pos, int zoom, string language) |
| { |
| // http://m3.mapserver.mapy.cz/army2-m/14-8802-5528 |
| return string.Format(UrlFormat, GetServerNum(pos, 3) + 1, zoom, pos.X, pos.Y); |
| } |
| static readonly string UrlFormat = "http://m{0}.mapserver.mapy.cz/army2-m/{1}-{2}-{3}"; |
| } |
| } |
| /MKLiveView/v1.0/GMap.NET.Core/GMap.NET.MapProviders/Czech/CzechHybridMapProvider.cs |
|---|
| 0,0 → 1,73 |
| |
| namespace GMap.NET.MapProviders |
| { |
| using System; |
| /// <summary> |
| /// CzechHybridMap provider, http://www.mapy.cz/ |
| /// </summary> |
| public class CzechHybridMapProvider : CzechMapProviderBase |
| { |
| public static readonly CzechHybridMapProvider Instance; |
| CzechHybridMapProvider() |
| { |
| } |
| static CzechHybridMapProvider() |
| { |
| Instance = new CzechHybridMapProvider(); |
| } |
| #region GMapProvider Members |
| readonly Guid id = new Guid("7540CE5B-F634-41E9-B23E-A6E0A97526FD"); |
| public override Guid Id |
| { |
| get |
| { |
| return id; |
| } |
| } |
| readonly string name = "CzechHybridMap"; |
| public override string Name |
| { |
| get |
| { |
| return name; |
| } |
| } |
| GMapProvider[] overlays; |
| public override GMapProvider[] Overlays |
| { |
| get |
| { |
| if(overlays == null) |
| { |
| overlays = new GMapProvider[] { CzechSatelliteMapProvider.Instance, this }; |
| } |
| return overlays; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| string url = MakeTileImageUrl(pos, zoom, LanguageStr); |
| return GetTileImageUsingHttp(url); |
| } |
| #endregion |
| string MakeTileImageUrl(GPoint pos, int zoom, string language) |
| { |
| // http://m3.mapserver.mapy.cz/hybrid-m/14-8802-5528 |
| return string.Format(UrlFormat, GetServerNum(pos, 3) + 1, zoom, pos.X, pos.Y); |
| } |
| static readonly string UrlFormat = "http://m{0}.mapserver.mapy.cz/hybrid-m/{1}-{2}-{3}"; |
| } |
| } |
| /MKLiveView/v1.0/GMap.NET.Core/GMap.NET.MapProviders/Czech/CzechMapProvider.cs |
|---|
| 0,0 → 1,115 |
| |
| namespace GMap.NET.MapProviders |
| { |
| using System; |
| using GMap.NET.Projections; |
| public abstract class CzechMapProviderBase : GMapProvider |
| { |
| public CzechMapProviderBase() |
| { |
| RefererUrl = "http://www.mapy.cz/"; |
| Area = new RectLatLng(51.2024819920053, 11.8401353319027, 7.22833716731277, 2.78312271922872); |
| } |
| #region GMapProvider Members |
| public override Guid Id |
| { |
| get |
| { |
| throw new NotImplementedException(); |
| } |
| } |
| public override string Name |
| { |
| get |
| { |
| throw new NotImplementedException(); |
| } |
| } |
| public override PureProjection Projection |
| { |
| get |
| { |
| return MercatorProjection.Instance; |
| } |
| } |
| GMapProvider[] overlays; |
| public override GMapProvider[] Overlays |
| { |
| get |
| { |
| if(overlays == null) |
| { |
| overlays = new GMapProvider[] { this }; |
| } |
| return overlays; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| throw new NotImplementedException(); |
| } |
| #endregion |
| } |
| /// <summary> |
| /// CzechMap provider, http://www.mapy.cz/ |
| /// </summary> |
| public class CzechMapProvider : CzechMapProviderBase |
| { |
| public static readonly CzechMapProvider Instance; |
| CzechMapProvider() |
| { |
| } |
| static CzechMapProvider() |
| { |
| Instance = new CzechMapProvider(); |
| } |
| #region GMapProvider Members |
| readonly Guid id = new Guid("13AB92EF-8C3B-4FAC-B2CD-2594C05F8BFC"); |
| public override Guid Id |
| { |
| get |
| { |
| return id; |
| } |
| } |
| readonly string name = "CzechMap"; |
| public override string Name |
| { |
| get |
| { |
| return name; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| string url = MakeTileImageUrl(pos, zoom, LanguageStr); |
| return GetTileImageUsingHttp(url); |
| } |
| #endregion |
| string MakeTileImageUrl(GPoint pos, int zoom, string language) |
| { |
| // ['base-m','ophoto-m','turist-m','army2-m'] |
| // http://m3.mapserver.mapy.cz/base-m/14-8802-5528 |
| return string.Format(UrlFormat, GetServerNum(pos, 3) + 1, zoom, pos.X, pos.Y); |
| } |
| static readonly string UrlFormat = "http://m{0}.mapserver.mapy.cz/base-m/{1}-{2}-{3}"; |
| } |
| } |
| /MKLiveView/v1.0/GMap.NET.Core/GMap.NET.MapProviders/Czech/CzechSatelliteMapProvider.cs |
|---|
| 0,0 → 1,60 |
| |
| namespace GMap.NET.MapProviders |
| { |
| using System; |
| /// <summary> |
| /// CzechSatelliteMap provider, http://www.mapy.cz/ |
| /// </summary> |
| public class CzechSatelliteMapProvider : CzechMapProviderBase |
| { |
| public static readonly CzechSatelliteMapProvider Instance; |
| CzechSatelliteMapProvider() |
| { |
| } |
| static CzechSatelliteMapProvider() |
| { |
| Instance = new CzechSatelliteMapProvider(); |
| } |
| #region GMapProvider Members |
| readonly Guid id = new Guid("30F433DB-BBF5-463D-9AB5-76383483B605"); |
| public override Guid Id |
| { |
| get |
| { |
| return id; |
| } |
| } |
| readonly string name = "CzechSatelliteMap"; |
| public override string Name |
| { |
| get |
| { |
| return name; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| string url = MakeTileImageUrl(pos, zoom, LanguageStr); |
| return GetTileImageUsingHttp(url); |
| } |
| #endregion |
| string MakeTileImageUrl(GPoint pos, int zoom, string language) |
| { |
| // http://m3.mapserver.mapy.cz/ophoto-m/14-8802-5528 |
| return string.Format(UrlFormat, GetServerNum(pos, 3) + 1, zoom, pos.X, pos.Y); |
| } |
| static readonly string UrlFormat = "http://m{0}.mapserver.mapy.cz/ophoto-m/{1}-{2}-{3}"; |
| } |
| } |
| /MKLiveView/v1.0/GMap.NET.Core/GMap.NET.MapProviders/Czech/CzechTuristMapProvider.cs |
|---|
| 0,0 → 1,60 |
| |
| namespace GMap.NET.MapProviders |
| { |
| using System; |
| /// <summary> |
| /// CzechTuristMap provider, http://www.mapy.cz/ |
| /// </summary> |
| public class CzechTuristMapProvider : CzechMapProviderBase |
| { |
| public static readonly CzechTuristMapProvider Instance; |
| CzechTuristMapProvider() |
| { |
| } |
| static CzechTuristMapProvider() |
| { |
| Instance = new CzechTuristMapProvider(); |
| } |
| #region GMapProvider Members |
| readonly Guid id = new Guid("102A54BE-3894-439B-9C1F-CA6FF2EA1FE9"); |
| public override Guid Id |
| { |
| get |
| { |
| return id; |
| } |
| } |
| readonly string name = "CzechTuristMap"; |
| public override string Name |
| { |
| get |
| { |
| return name; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| string url = MakeTileImageUrl(pos, zoom, LanguageStr); |
| return GetTileImageUsingHttp(url); |
| } |
| #endregion |
| string MakeTileImageUrl(GPoint pos, int zoom, string language) |
| { |
| // http://m3.mapserver.mapy.cz/wtourist-m/14-8802-5528 |
| return string.Format(UrlFormat, GetServerNum(pos, 3) + 1, zoom, pos.X, pos.Y); |
| } |
| static readonly string UrlFormat = "http://m{0}.mapserver.mapy.cz/wturist-m/{1}-{2}-{3}"; |
| } |
| } |
| /MKLiveView/v1.0/GMap.NET.Core/GMap.NET.MapProviders/Czech/CzechTuristWinterMapProvider.cs |
|---|
| 0,0 → 1,60 |
| |
| namespace GMap.NET.MapProviders |
| { |
| using System; |
| /// <summary> |
| /// CzechTuristMap provider, http://www.mapy.cz/ |
| /// </summary> |
| public class CzechTuristWinterMapProvider : CzechMapProviderBase |
| { |
| public static readonly CzechTuristWinterMapProvider Instance; |
| CzechTuristWinterMapProvider() |
| { |
| } |
| static CzechTuristWinterMapProvider() |
| { |
| Instance = new CzechTuristWinterMapProvider(); |
| } |
| #region GMapProvider Members |
| readonly Guid id = new Guid("F7B7FC9E-BDC2-4A9D-A1D3-A6BEC8FE0EB2"); |
| public override Guid Id |
| { |
| get |
| { |
| return id; |
| } |
| } |
| readonly string name = "CzechTuristWinterMap"; |
| public override string Name |
| { |
| get |
| { |
| return name; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| string url = MakeTileImageUrl(pos, zoom, LanguageStr); |
| return GetTileImageUsingHttp(url); |
| } |
| #endregion |
| string MakeTileImageUrl(GPoint pos, int zoom, string language) |
| { |
| // http://m3.mapserver.mapy.cz/wturist_winter-m/14-8802-5528 |
| return string.Format(UrlFormat, GetServerNum(pos, 3) + 1, zoom, pos.X, pos.Y); |
| } |
| static readonly string UrlFormat = "http://m{0}.mapserver.mapy.cz/wturist_winter-m/{1}-{2}-{3}"; |
| } |
| } |
| /MKLiveView/v1.0/GMap.NET.Core/GMap.NET.MapProviders/CzechOld/CzechHistoryMapProvider.cs |
|---|
| 0,0 → 1,76 |
| |
| namespace GMap.NET.MapProviders |
| { |
| using System; |
| /// <summary> |
| /// CzechHistoryMap provider, http://www.mapy.cz/ |
| /// </summary> |
| public class CzechHistoryMapProviderOld : CzechMapProviderBaseOld |
| { |
| public static readonly CzechHistoryMapProviderOld Instance; |
| CzechHistoryMapProviderOld() |
| { |
| } |
| static CzechHistoryMapProviderOld() |
| { |
| Instance = new CzechHistoryMapProviderOld(); |
| } |
| #region GMapProvider Members |
| readonly Guid id = new Guid("C666AAF4-9D27-418F-97CB-7F0D8CC44544"); |
| public override Guid Id |
| { |
| get |
| { |
| return id; |
| } |
| } |
| readonly string name = "CzechHistoryOldMap"; |
| public override string Name |
| { |
| get |
| { |
| return name; |
| } |
| } |
| GMapProvider[] overlays; |
| public override GMapProvider[] Overlays |
| { |
| get |
| { |
| if(overlays == null) |
| { |
| overlays = new GMapProvider[] { this, CzechHybridMapProviderOld.Instance }; |
| } |
| return overlays; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| string url = MakeTileImageUrl(pos, zoom, LanguageStr); |
| return GetTileImageUsingHttp(url); |
| } |
| #endregion |
| string MakeTileImageUrl(GPoint pos, int zoom, string language) |
| { |
| // http://m4.mapserver.mapy.cz/army2/9_7d00000_8080000 |
| long xx = pos.X << (28 - zoom); |
| long yy = ((((long)Math.Pow(2.0, (double)zoom)) - 1) - pos.Y) << (28 - zoom); |
| return string.Format(UrlFormat, GetServerNum(pos, 3) + 1, zoom, xx, yy); |
| } |
| static readonly string UrlFormat = "http://m{0}.mapserver.mapy.cz/army2/{1}_{2:x7}_{3:x7}"; |
| } |
| } |
| /MKLiveView/v1.0/GMap.NET.Core/GMap.NET.MapProviders/CzechOld/CzechHybridMapProvider.cs |
|---|
| 0,0 → 1,76 |
| |
| namespace GMap.NET.MapProviders |
| { |
| using System; |
| /// <summary> |
| /// CzechHybridMap provider, http://www.mapy.cz/ |
| /// </summary> |
| public class CzechHybridMapProviderOld : CzechMapProviderBaseOld |
| { |
| public static readonly CzechHybridMapProviderOld Instance; |
| CzechHybridMapProviderOld() |
| { |
| } |
| static CzechHybridMapProviderOld() |
| { |
| Instance = new CzechHybridMapProviderOld(); |
| } |
| #region GMapProvider Members |
| readonly Guid id = new Guid("F785D98E-DD1D-46FD-8BC1-1AAB69604980"); |
| public override Guid Id |
| { |
| get |
| { |
| return id; |
| } |
| } |
| readonly string name = "CzechHybridOldMap"; |
| public override string Name |
| { |
| get |
| { |
| return name; |
| } |
| } |
| GMapProvider[] overlays; |
| public override GMapProvider[] Overlays |
| { |
| get |
| { |
| if(overlays == null) |
| { |
| overlays = new GMapProvider[] { CzechSatelliteMapProviderOld.Instance, this }; |
| } |
| return overlays; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| string url = MakeTileImageUrl(pos, zoom, LanguageStr); |
| return GetTileImageUsingHttp(url); |
| } |
| #endregion |
| string MakeTileImageUrl(GPoint pos, int zoom, string language) |
| { |
| // http://m2.mapserver.mapy.cz/hybrid/9_7d00000_7b80000 |
| long xx = pos.X << (28 - zoom); |
| long yy = ((((long)Math.Pow(2.0, (double)zoom)) - 1) - pos.Y) << (28 - zoom); |
| return string.Format(UrlFormat, GetServerNum(pos, 3) + 1, zoom, xx, yy); |
| } |
| static readonly string UrlFormat = "http://m{0}.mapserver.mapy.cz/hybrid/{1}_{2:x7}_{3:x7}"; |
| } |
| } |
| /MKLiveView/v1.0/GMap.NET.Core/GMap.NET.MapProviders/CzechOld/CzechMapProvider.cs |
|---|
| 0,0 → 1,118 |
| |
| namespace GMap.NET.MapProviders |
| { |
| using System; |
| using GMap.NET.Projections; |
| public abstract class CzechMapProviderBaseOld : GMapProvider |
| { |
| public CzechMapProviderBaseOld() |
| { |
| RefererUrl = "http://www.mapy.cz/"; |
| Area = new RectLatLng(51.2024819920053, 11.8401353319027, 7.22833716731277, 2.78312271922872); |
| } |
| #region GMapProvider Members |
| public override Guid Id |
| { |
| get |
| { |
| throw new NotImplementedException(); |
| } |
| } |
| public override string Name |
| { |
| get |
| { |
| throw new NotImplementedException(); |
| } |
| } |
| public override PureProjection Projection |
| { |
| get |
| { |
| return MapyCZProjection.Instance; |
| } |
| } |
| GMapProvider[] overlays; |
| public override GMapProvider[] Overlays |
| { |
| get |
| { |
| if(overlays == null) |
| { |
| overlays = new GMapProvider[] { this }; |
| } |
| return overlays; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| throw new NotImplementedException(); |
| } |
| #endregion |
| } |
| /// <summary> |
| /// CzechMap provider, http://www.mapy.cz/ |
| /// </summary> |
| public class CzechMapProviderOld : CzechMapProviderBaseOld |
| { |
| public static readonly CzechMapProviderOld Instance; |
| CzechMapProviderOld() |
| { |
| } |
| static CzechMapProviderOld() |
| { |
| Instance = new CzechMapProviderOld(); |
| } |
| #region GMapProvider Members |
| readonly Guid id = new Guid("6A1AF99A-84C6-4EF6-91A5-77B9D03257C2"); |
| public override Guid Id |
| { |
| get |
| { |
| return id; |
| } |
| } |
| readonly string name = "CzechOldMap"; |
| public override string Name |
| { |
| get |
| { |
| return name; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| string url = MakeTileImageUrl(pos, zoom, LanguageStr); |
| return GetTileImageUsingHttp(url); |
| } |
| #endregion |
| string MakeTileImageUrl(GPoint pos, int zoom, string language) |
| { |
| // ['base','ophoto','turist','army2'] |
| // http://m1.mapserver.mapy.cz/base-n/3_8000000_8000000 |
| long xx = pos.X << (28 - zoom); |
| long yy = ((((long)Math.Pow(2.0, (double)zoom)) - 1) - pos.Y) << (28 - zoom); |
| return string.Format(UrlFormat, GetServerNum(pos, 3) + 1, zoom, xx, yy); |
| } |
| static readonly string UrlFormat = "http://m{0}.mapserver.mapy.cz/base-n/{1}_{2:x7}_{3:x7}"; |
| } |
| } |
| /MKLiveView/v1.0/GMap.NET.Core/GMap.NET.MapProviders/CzechOld/CzechSatelliteMapProvider.cs |
|---|
| 0,0 → 1,63 |
| |
| namespace GMap.NET.MapProviders |
| { |
| using System; |
| /// <summary> |
| /// CzechSatelliteMap provider, http://www.mapy.cz/ |
| /// </summary> |
| public class CzechSatelliteMapProviderOld : CzechMapProviderBaseOld |
| { |
| public static readonly CzechSatelliteMapProviderOld Instance; |
| CzechSatelliteMapProviderOld() |
| { |
| } |
| static CzechSatelliteMapProviderOld() |
| { |
| Instance = new CzechSatelliteMapProviderOld(); |
| } |
| #region GMapProvider Members |
| readonly Guid id = new Guid("7846D655-5F9C-4042-8652-60B6BF629C3C"); |
| public override Guid Id |
| { |
| get |
| { |
| return id; |
| } |
| } |
| readonly string name = "CzechSatelliteOldMap"; |
| public override string Name |
| { |
| get |
| { |
| return name; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| string url = MakeTileImageUrl(pos, zoom, LanguageStr); |
| return GetTileImageUsingHttp(url); |
| } |
| #endregion |
| string MakeTileImageUrl(GPoint pos, int zoom, string language) |
| { |
| //http://m3.mapserver.mapy.cz/ophoto/9_7a80000_7a80000 |
| long xx = pos.X << (28 - zoom); |
| long yy = ((((long)Math.Pow(2.0, (double)zoom)) - 1) - pos.Y) << (28 - zoom); |
| return string.Format(UrlFormat, GetServerNum(pos, 3) + 1, zoom, xx, yy); |
| } |
| static readonly string UrlFormat = "http://m{0}.mapserver.mapy.cz/ophoto/{1}_{2:x7}_{3:x7}"; |
| } |
| } |
| /MKLiveView/v1.0/GMap.NET.Core/GMap.NET.MapProviders/CzechOld/CzechTuristMapProvider.cs |
|---|
| 0,0 → 1,63 |
| |
| namespace GMap.NET.MapProviders |
| { |
| using System; |
| /// <summary> |
| /// CzechTuristMap provider, http://www.mapy.cz/ |
| /// </summary> |
| public class CzechTuristMapProviderOld : CzechMapProviderBaseOld |
| { |
| public static readonly CzechTuristMapProviderOld Instance; |
| CzechTuristMapProviderOld() |
| { |
| } |
| static CzechTuristMapProviderOld() |
| { |
| Instance = new CzechTuristMapProviderOld(); |
| } |
| #region GMapProvider Members |
| readonly Guid id = new Guid("B923C81D-880C-42EB-88AB-AF8FE42B564D"); |
| public override Guid Id |
| { |
| get |
| { |
| return id; |
| } |
| } |
| readonly string name = "CzechTuristOldMap"; |
| public override string Name |
| { |
| get |
| { |
| return name; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| string url = MakeTileImageUrl(pos, zoom, LanguageStr); |
| return GetTileImageUsingHttp(url); |
| } |
| #endregion |
| string MakeTileImageUrl(GPoint pos, int zoom, string language) |
| { |
| // http://m1.mapserver.mapy.cz/turist/3_8000000_8000000 |
| long xx = pos.X << (28 - zoom); |
| long yy = ((((long)Math.Pow(2.0, (double)zoom)) - 1) - pos.Y) << (28 - zoom); |
| return string.Format(UrlFormat, GetServerNum(pos, 3) + 1, zoom, xx, yy); |
| } |
| static readonly string UrlFormat = "http://m{0}.mapserver.mapy.cz/turist/{1}_{2:x7}_{3:x7}"; |
| } |
| } |
| /MKLiveView/v1.0/GMap.NET.Core/GMap.NET.MapProviders/Etc/CloudMadeMapProvider.cs |
|---|
| 0,0 → 1,561 |
| |
| namespace GMap.NET.MapProviders |
| { |
| using System; |
| using GMap.NET.Projections; |
| using System.Globalization; |
| using GMap.NET.Internals; |
| using System.Collections.Generic; |
| using System.Xml; |
| using System.Diagnostics; |
| public abstract class CloudMadeMapProviderBase : GMapProvider, RoutingProvider, DirectionsProvider |
| { |
| public readonly string ServerLetters = "abc"; |
| public readonly string DoubleResolutionString = "@2x"; |
| public bool DoubleResolution = true; |
| public string Key; |
| public int StyleID; |
| public string Version = "0.3"; |
| public CloudMadeMapProviderBase() |
| { |
| MaxZoom = null; |
| } |
| #region GMapProvider Members |
| public override Guid Id |
| { |
| get |
| { |
| throw new NotImplementedException(); |
| } |
| } |
| public override string Name |
| { |
| get |
| { |
| throw new NotImplementedException(); |
| } |
| } |
| public override PureProjection Projection |
| { |
| get |
| { |
| return MercatorProjection.Instance; |
| } |
| } |
| GMapProvider[] overlays; |
| public override GMapProvider[] Overlays |
| { |
| get |
| { |
| if(overlays == null) |
| { |
| overlays = new GMapProvider[] { this }; |
| } |
| return overlays; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| throw new NotImplementedException(); |
| } |
| #endregion |
| #region RoutingProvider Members |
| public MapRoute GetRoute(PointLatLng start, PointLatLng end, bool avoidHighways, bool walkingMode, int Zoom) |
| { |
| List<PointLatLng> points = GetRoutePoints(MakeRoutingUrl(start, end, walkingMode ? TravelTypeFoot : TravelTypeMotorCar, LanguageStr, "km")); |
| MapRoute route = points != null ? new MapRoute(points, walkingMode ? WalkingStr : DrivingStr) : null; |
| return route; |
| } |
| /// <summary> |
| /// NotImplemented |
| /// </summary> |
| /// <param name="start"></param> |
| /// <param name="end"></param> |
| /// <param name="avoidHighways"></param> |
| /// <param name="walkingMode"></param> |
| /// <param name="Zoom"></param> |
| /// <returns></returns> |
| public MapRoute GetRoute(string start, string end, bool avoidHighways, bool walkingMode, int Zoom) |
| { |
| throw new NotImplementedException(); |
| } |
| #region -- internals -- |
| string MakeRoutingUrl(PointLatLng start, PointLatLng end, string travelType, string language, string units) |
| { |
| // http://developers.cloudmade.com/projects/routing-http-api/examples/ |
| // http://routes.cloudmade.com/YOUR-API-KEY-GOES-HERE/api/0.3/start_point,[[transit_point1,...,transit_pointN]],end_point/route_type[/route_type_modifier].output_format[?lang=(en|de)][&units=(km|miles)] |
| return string.Format(CultureInfo.InvariantCulture, UrlFormat, Key, Version, start.Lat, start.Lng, end.Lat, end.Lng, travelType, language, units); |
| } |
| List<PointLatLng> GetRoutePoints(string url) |
| { |
| List<PointLatLng> points = null; |
| try |
| { |
| string route = GMaps.Instance.UseRouteCache ? Cache.Instance.GetContent(url, CacheType.RouteCache) : string.Empty; |
| if(string.IsNullOrEmpty(route)) |
| { |
| route = GetContentUsingHttp(url); |
| if(!string.IsNullOrEmpty(route)) |
| { |
| if(GMaps.Instance.UseRouteCache) |
| { |
| Cache.Instance.SaveContent(url, CacheType.RouteCache, route); |
| } |
| } |
| } |
| #region -- gpx response -- |
| //<?xml version="1.0" encoding="UTF-8"?> |
| //<gpx creator="" version="1.1" xmlns="http://www.topografix.com/GPX/1/1" |
| // xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" |
| // xsi:schemaLocation="http://www.topografix.com/GPX/1/1 gpx.xsd "> |
| // <extensions> |
| // <distance>293</distance> |
| // <time>34</time> |
| // <start>Perckhoevelaan</start> |
| // <end>Goudenregenlaan</end> |
| // </extensions> |
| // <wpt lat="51.17702" lon="4.39630" /> |
| // <wpt lat="51.17656" lon="4.39655" /> |
| // <wpt lat="51.17639" lon="4.39670" /> |
| // <wpt lat="51.17612" lon="4.39696" /> |
| // <wpt lat="51.17640" lon="4.39767" /> |
| // <wpt lat="51.17668" lon="4.39828" /> |
| // <wpt lat="51.17628" lon="4.39874" /> |
| // <wpt lat="51.17618" lon="4.39888" /> |
| // <rte> |
| // <rtept lat="51.17702" lon="4.39630"> |
| // <desc>Head south on Perckhoevelaan, 0.1 km</desc> |
| // <extensions> |
| // <distance>111</distance> |
| // <time>13</time> |
| // <offset>0</offset> |
| // <distance-text>0.1 km</distance-text> |
| // <direction>S</direction> |
| // <azimuth>160.6</azimuth> |
| // </extensions> |
| // </rtept> |
| // <rtept lat="51.17612" lon="4.39696"> |
| // <desc>Turn left at Laarstraat, 0.1 km</desc> |
| // <extensions> |
| // <distance>112</distance> |
| // <time>13</time> |
| // <offset>3</offset> |
| // <distance-text>0.1 km</distance-text> |
| // <direction>NE</direction> |
| // <azimuth>58.1</azimuth> |
| // <turn>TL</turn> |
| // <turn-angle>269.0</turn-angle> |
| // </extensions> |
| // </rtept> |
| // <rtept lat="51.17668" lon="4.39828"> |
| // <desc>Turn right at Goudenregenlaan, 70 m</desc> |
| // <extensions> |
| // <distance>70</distance> |
| // <time>8</time> |
| // <offset>5</offset> |
| // <distance-text>70 m</distance-text> |
| // <direction>SE</direction> |
| // <azimuth>143.4</azimuth> |
| // <turn>TR</turn> |
| // <turn-angle>89.8</turn-angle> |
| // </extensions> |
| // </rtept> |
| // </rte> |
| //</gpx> |
| #endregion |
| if(!string.IsNullOrEmpty(route)) |
| { |
| XmlDocument xmldoc = new XmlDocument(); |
| xmldoc.LoadXml(route); |
| System.Xml.XmlNamespaceManager xmlnsManager = new System.Xml.XmlNamespaceManager(xmldoc.NameTable); |
| xmlnsManager.AddNamespace("sm", "http://www.topografix.com/GPX/1/1"); |
| XmlNodeList wpts = xmldoc.SelectNodes("/sm:gpx/sm:wpt", xmlnsManager); |
| if(wpts != null && wpts.Count > 0) |
| { |
| points = new List<PointLatLng>(); |
| foreach(XmlNode w in wpts) |
| { |
| double lat = double.Parse(w.Attributes["lat"].InnerText, CultureInfo.InvariantCulture); |
| double lng = double.Parse(w.Attributes["lon"].InnerText, CultureInfo.InvariantCulture); |
| points.Add(new PointLatLng(lat, lng)); |
| } |
| } |
| } |
| } |
| catch(Exception ex) |
| { |
| Debug.WriteLine("GetRoutePoints: " + ex); |
| } |
| return points; |
| } |
| static readonly string UrlFormat = "http://routes.cloudmade.com/{0}/api/{1}/{2},{3},{4},{5}/{6}.gpx?lang={7}&units={8}"; |
| static readonly string TravelTypeFoot = "foot"; |
| static readonly string TravelTypeMotorCar = "car"; |
| static readonly string WalkingStr = "Walking"; |
| static readonly string DrivingStr = "Driving"; |
| #endregion |
| #endregion |
| #region DirectionsProvider Members |
| public DirectionsStatusCode GetDirections(out GDirections direction, PointLatLng start, PointLatLng end, bool avoidHighways, bool avoidTolls, bool walkingMode, bool sensor, bool metric) |
| { |
| return GetDirectionsUrl(MakeRoutingUrl(start, end, walkingMode ? TravelTypeFoot : TravelTypeMotorCar, LanguageStr, metric ? "km" : "miles"), out direction); |
| } |
| /// <summary> |
| /// NotImplemented |
| /// </summary> |
| /// <param name="direction"></param> |
| /// <param name="start"></param> |
| /// <param name="end"></param> |
| /// <param name="avoidHighways"></param> |
| /// <param name="avoidTolls"></param> |
| /// <param name="walkingMode"></param> |
| /// <param name="sensor"></param> |
| /// <param name="metric"></param> |
| /// <returns></returns> |
| public DirectionsStatusCode GetDirections(out GDirections direction, string start, string end, bool avoidHighways, bool avoidTolls, bool walkingMode, bool sensor, bool metric) |
| { |
| throw new NotImplementedException(); |
| } |
| /// <summary> |
| /// NotImplemented |
| /// </summary> |
| /// <param name="status"></param> |
| /// <param name="start"></param> |
| /// <param name="end"></param> |
| /// <param name="avoidHighways"></param> |
| /// <param name="avoidTolls"></param> |
| /// <param name="walkingMode"></param> |
| /// <param name="sensor"></param> |
| /// <param name="metric"></param> |
| /// <returns></returns> |
| public IEnumerable<GDirections> GetDirections(out DirectionsStatusCode status, string start, string end, bool avoidHighways, bool avoidTolls, bool walkingMode, bool sensor, bool metric) |
| { |
| throw new NotImplementedException(); |
| } |
| /// <summary> |
| /// NotImplemented |
| /// </summary> |
| /// <param name="status"></param> |
| /// <param name="start"></param> |
| /// <param name="end"></param> |
| /// <param name="avoidHighways"></param> |
| /// <param name="avoidTolls"></param> |
| /// <param name="walkingMode"></param> |
| /// <param name="sensor"></param> |
| /// <param name="metric"></param> |
| /// <returns></returns> |
| public IEnumerable<GDirections> GetDirections(out DirectionsStatusCode status, PointLatLng start, PointLatLng end, bool avoidHighways, bool avoidTolls, bool walkingMode, bool sensor, bool metric) |
| { |
| throw new NotImplementedException(); |
| } |
| /// <summary> |
| /// NotImplemented |
| /// </summary> |
| /// <param name="direction"></param> |
| /// <param name="start"></param> |
| /// <param name="wayPoints"></param> |
| /// <param name="avoidHighways"></param> |
| /// <param name="avoidTolls"></param> |
| /// <param name="walkingMode"></param> |
| /// <param name="sensor"></param> |
| /// <param name="metric"></param> |
| /// <returns></returns> |
| public DirectionsStatusCode GetDirections(out GDirections direction, PointLatLng start, IEnumerable<PointLatLng> wayPoints, PointLatLng end, bool avoidHighways, bool avoidTolls, bool walkingMode, bool sensor, bool metric) |
| { |
| throw new NotImplementedException(); |
| } |
| /// <summary> |
| /// NotImplemented |
| /// </summary> |
| /// <param name="direction"></param> |
| /// <param name="start"></param> |
| /// <param name="wayPoints"></param> |
| /// <param name="avoidHighways"></param> |
| /// <param name="avoidTolls"></param> |
| /// <param name="walkingMode"></param> |
| /// <param name="sensor"></param> |
| /// <param name="metric"></param> |
| /// <returns></returns> |
| public DirectionsStatusCode GetDirections(out GDirections direction, string start, IEnumerable<string> wayPoints, string end, bool avoidHighways, bool avoidTolls, bool walkingMode, bool sensor, bool metric) |
| { |
| throw new NotImplementedException(); |
| } |
| #region -- internals -- |
| DirectionsStatusCode GetDirectionsUrl(string url, out GDirections direction) |
| { |
| DirectionsStatusCode ret = DirectionsStatusCode.UNKNOWN_ERROR; |
| direction = null; |
| try |
| { |
| string route = GMaps.Instance.UseRouteCache ? Cache.Instance.GetContent(url, CacheType.DirectionsCache) : string.Empty; |
| if(string.IsNullOrEmpty(route)) |
| { |
| route = GetContentUsingHttp(url); |
| if(!string.IsNullOrEmpty(route)) |
| { |
| if(GMaps.Instance.UseRouteCache) |
| { |
| Cache.Instance.SaveContent(url, CacheType.DirectionsCache, route); |
| } |
| } |
| } |
| #region -- gpx response -- |
| //<?xml version="1.0" encoding="UTF-8"?> |
| //<gpx creator="" version="1.1" xmlns="http://www.topografix.com/GPX/1/1" |
| // xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" |
| // xsi:schemaLocation="http://www.topografix.com/GPX/1/1 gpx.xsd "> |
| // <extensions> |
| // <distance>293</distance> |
| // <time>34</time> |
| // <start>Perckhoevelaan</start> |
| // <end>Goudenregenlaan</end> |
| // </extensions> |
| // <wpt lat="51.17702" lon="4.39630" /> |
| // <wpt lat="51.17656" lon="4.39655" /> |
| // <wpt lat="51.17639" lon="4.39670" /> |
| // <wpt lat="51.17612" lon="4.39696" /> |
| // <wpt lat="51.17640" lon="4.39767" /> |
| // <wpt lat="51.17668" lon="4.39828" /> |
| // <wpt lat="51.17628" lon="4.39874" /> |
| // <wpt lat="51.17618" lon="4.39888" /> |
| // <rte> |
| // <rtept lat="51.17702" lon="4.39630"> |
| // <desc>Head south on Perckhoevelaan, 0.1 km</desc> |
| // <extensions> |
| // <distance>111</distance> |
| // <time>13</time> |
| // <offset>0</offset> |
| // <distance-text>0.1 km</distance-text> |
| // <direction>S</direction> |
| // <azimuth>160.6</azimuth> |
| // </extensions> |
| // </rtept> |
| // <rtept lat="51.17612" lon="4.39696"> |
| // <desc>Turn left at Laarstraat, 0.1 km</desc> |
| // <extensions> |
| // <distance>112</distance> |
| // <time>13</time> |
| // <offset>3</offset> |
| // <distance-text>0.1 km</distance-text> |
| // <direction>NE</direction> |
| // <azimuth>58.1</azimuth> |
| // <turn>TL</turn> |
| // <turn-angle>269.0</turn-angle> |
| // </extensions> |
| // </rtept> |
| // <rtept lat="51.17668" lon="4.39828"> |
| // <desc>Turn right at Goudenregenlaan, 70 m</desc> |
| // <extensions> |
| // <distance>70</distance> |
| // <time>8</time> |
| // <offset>5</offset> |
| // <distance-text>70 m</distance-text> |
| // <direction>SE</direction> |
| // <azimuth>143.4</azimuth> |
| // <turn>TR</turn> |
| // <turn-angle>89.8</turn-angle> |
| // </extensions> |
| // </rtept> |
| // </rte> |
| //</gpx> |
| #endregion |
| if(!string.IsNullOrEmpty(route)) |
| { |
| XmlDocument xmldoc = new XmlDocument(); |
| xmldoc.LoadXml(route); |
| System.Xml.XmlNamespaceManager xmlnsManager = new System.Xml.XmlNamespaceManager(xmldoc.NameTable); |
| xmlnsManager.AddNamespace("sm", "http://www.topografix.com/GPX/1/1"); |
| XmlNodeList wpts = xmldoc.SelectNodes("/sm:gpx/sm:wpt", xmlnsManager); |
| if(wpts != null && wpts.Count > 0) |
| { |
| ret = DirectionsStatusCode.OK; |
| direction = new GDirections(); |
| direction.Route = new List<PointLatLng>(); |
| foreach(XmlNode w in wpts) |
| { |
| double lat = double.Parse(w.Attributes["lat"].InnerText, CultureInfo.InvariantCulture); |
| double lng = double.Parse(w.Attributes["lon"].InnerText, CultureInfo.InvariantCulture); |
| direction.Route.Add(new PointLatLng(lat, lng)); |
| } |
| if(direction.Route.Count > 0) |
| { |
| direction.StartLocation = direction.Route[0]; |
| direction.EndLocation = direction.Route[direction.Route.Count - 1]; |
| } |
| XmlNode n = xmldoc.SelectSingleNode("/sm:gpx/sm:metadata/sm:copyright/sm:license", xmlnsManager); |
| if(n != null) |
| { |
| direction.Copyrights = n.InnerText; |
| } |
| n = xmldoc.SelectSingleNode("/sm:gpx/sm:extensions/sm:distance", xmlnsManager); |
| if(n != null) |
| { |
| direction.Distance = n.InnerText + "m"; |
| } |
| n = xmldoc.SelectSingleNode("/sm:gpx/sm:extensions/sm:time", xmlnsManager); |
| if(n != null) |
| { |
| direction.Duration = n.InnerText + "s"; |
| } |
| n = xmldoc.SelectSingleNode("/sm:gpx/sm:extensions/sm:start", xmlnsManager); |
| if(n != null) |
| { |
| direction.StartAddress = n.InnerText; |
| } |
| n = xmldoc.SelectSingleNode("/sm:gpx/sm:extensions/sm:end", xmlnsManager); |
| if(n != null) |
| { |
| direction.EndAddress = n.InnerText; |
| } |
| wpts = xmldoc.SelectNodes("/sm:gpx/sm:rte/sm:rtept", xmlnsManager); |
| if(wpts != null && wpts.Count > 0) |
| { |
| direction.Steps = new List<GDirectionStep>(); |
| foreach(XmlNode w in wpts) |
| { |
| GDirectionStep step = new GDirectionStep(); |
| double lat = double.Parse(w.Attributes["lat"].InnerText, CultureInfo.InvariantCulture); |
| double lng = double.Parse(w.Attributes["lon"].InnerText, CultureInfo.InvariantCulture); |
| step.StartLocation = new PointLatLng(lat, lng); |
| XmlNode nn = w.SelectSingleNode("sm:desc", xmlnsManager); |
| if(nn != null) |
| { |
| step.HtmlInstructions = nn.InnerText; |
| } |
| nn = w.SelectSingleNode("sm:extensions/sm:distance-text", xmlnsManager); |
| if(nn != null) |
| { |
| step.Distance = nn.InnerText; |
| } |
| nn = w.SelectSingleNode("sm:extensions/sm:time", xmlnsManager); |
| if(nn != null) |
| { |
| step.Duration = nn.InnerText + "s"; |
| } |
| direction.Steps.Add(step); |
| } |
| } |
| } |
| } |
| } |
| catch(Exception ex) |
| { |
| ret = DirectionsStatusCode.ExceptionInCode; |
| direction = null; |
| Debug.WriteLine("GetDirectionsUrl: " + ex); |
| } |
| return ret; |
| } |
| #endregion |
| #endregion |
| } |
| /// <summary> |
| /// CloudMadeMap demo provider, http://maps.cloudmade.com/ |
| /// </summary> |
| public class CloudMadeMapProvider : CloudMadeMapProviderBase |
| { |
| public static readonly CloudMadeMapProvider Instance; |
| CloudMadeMapProvider() |
| { |
| Key = "5937c2bd907f4f4a92d8980a7c666ac0"; // demo key of CloudMade |
| StyleID = 45363; // grab your style here http://maps.cloudmade.com/?styleId=45363 |
| } |
| static CloudMadeMapProvider() |
| { |
| Instance = new CloudMadeMapProvider(); |
| } |
| #region GMapProvider Members |
| readonly Guid id = new Guid("00403A36-725F-4BC4-934F-BFC1C164D003"); |
| public override Guid Id |
| { |
| get |
| { |
| return id; |
| } |
| } |
| readonly string name = "CloudMade, Demo"; |
| public override string Name |
| { |
| get |
| { |
| return name; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| string url = MakeTileImageUrl(pos, zoom, LanguageStr); |
| return GetTileImageUsingHttp(url); |
| } |
| #endregion |
| string MakeTileImageUrl(GPoint pos, int zoom, string language) |
| { |
| return string.Format(UrlFormat, ServerLetters[GetServerNum(pos, 3)], Key, StyleID, (DoubleResolution ? DoubleResolutionString : string.Empty), zoom, pos.X, pos.Y); |
| } |
| static readonly string UrlFormat = "http://{0}.tile.cloudmade.com/{1}/{2}{3}/256/{4}/{5}/{6}.png"; |
| } |
| } |
| /MKLiveView/v1.0/GMap.NET.Core/GMap.NET.MapProviders/Etc/LatviaMapProvider.cs |
|---|
| 0,0 → 1,119 |
| |
| namespace GMap.NET.MapProviders |
| { |
| using System; |
| using GMap.NET.Projections; |
| public abstract class LatviaMapProviderBase : GMapProvider |
| { |
| public LatviaMapProviderBase() |
| { |
| RefererUrl = "http://www.ikarte.lv/default.aspx?lang=en"; |
| Copyright = string.Format("©{0} Hnit-Baltic - Map data ©{0} LR Valsts zemes dieniests, SIA Envirotech", DateTime.Today.Year); |
| MaxZoom = 11; |
| Area = new RectLatLng(58.0794870805093, 20.3286067123543, 7.90883164336887, 2.506129113082); |
| } |
| #region GMapProvider Members |
| public override Guid Id |
| { |
| get |
| { |
| throw new NotImplementedException(); |
| } |
| } |
| public override string Name |
| { |
| get |
| { |
| throw new NotImplementedException(); |
| } |
| } |
| public override PureProjection Projection |
| { |
| get |
| { |
| return LKS92Projection.Instance; |
| } |
| } |
| GMapProvider[] overlays; |
| public override GMapProvider[] Overlays |
| { |
| get |
| { |
| if(overlays == null) |
| { |
| overlays = new GMapProvider[] { this }; |
| } |
| return overlays; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| throw new NotImplementedException(); |
| } |
| #endregion |
| } |
| /// <summary> |
| /// LatviaMap provider, http://www.ikarte.lv/ |
| /// </summary> |
| public class LatviaMapProvider : LatviaMapProviderBase |
| { |
| public static readonly LatviaMapProvider Instance; |
| LatviaMapProvider() |
| { |
| } |
| static LatviaMapProvider() |
| { |
| Instance = new LatviaMapProvider(); |
| } |
| #region GMapProvider Members |
| readonly Guid id = new Guid("2A21CBB1-D37C-458D-905E-05F19536EF1F"); |
| public override Guid Id |
| { |
| get |
| { |
| return id; |
| } |
| } |
| readonly string name = "LatviaMap"; |
| public override string Name |
| { |
| get |
| { |
| return name; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| string url = MakeTileImageUrl(pos, zoom, LanguageStr); |
| return GetTileImageUsingHttp(url); |
| } |
| #endregion |
| string MakeTileImageUrl(GPoint pos, int zoom, string language) |
| { |
| // http://www.maps.lt/cache/ikartelv/map/_alllayers/L03/R00000037/C00000053.png |
| // http://www.maps.lt/arcgiscache/ikartelv/map/_alllayers/L02/R0000001c/C0000002a.png |
| // http://services.maps.lt/mapsk_services/rest/services/ikartelv/MapServer/tile/5/271/416.png?cl=ikrlv |
| return string.Format(UrlFormat, zoom, pos.Y, pos.X); |
| } |
| static readonly string UrlFormat = "http://services.maps.lt/mapsk_services/rest/services/ikartelv/MapServer/tile/{0}/{1}/{2}.png?cl=ikrlv"; |
| //static readonly string UrlFormat = "http://www.maps.lt/arcgiscache/ikartelv/map/_alllayers/L{0:00}/R{1:x8}/C{2:x8}.png"; |
| } |
| } |
| /MKLiveView/v1.0/GMap.NET.Core/GMap.NET.MapProviders/Etc/MapBenderWMSProvider.cs |
|---|
| 0,0 → 1,92 |
| |
| namespace GMap.NET.MapProviders |
| { |
| using System; |
| using GMap.NET.Projections; |
| using System.Globalization; |
| /// <summary> |
| /// MapBender provider, WMS demo http://www.mapbender.org/ |
| /// </summary> |
| public class MapBenderWMSProvider : GMapProvider |
| { |
| public static readonly MapBenderWMSProvider Instance; |
| MapBenderWMSProvider() |
| { |
| } |
| static MapBenderWMSProvider() |
| { |
| Instance = new MapBenderWMSProvider(); |
| } |
| #region GMapProvider Members |
| readonly Guid id = new Guid("45742F8D-B552-4CAF-89AE-F20951BBDB2B"); |
| public override Guid Id |
| { |
| get |
| { |
| return id; |
| } |
| } |
| readonly string name = "MapBender, WMS demo"; |
| public override string Name |
| { |
| get |
| { |
| return name; |
| } |
| } |
| GMapProvider[] overlays; |
| public override GMapProvider[] Overlays |
| { |
| get |
| { |
| if(overlays == null) |
| { |
| overlays = new GMapProvider[] { this }; |
| } |
| return overlays; |
| } |
| } |
| public override PureProjection Projection |
| { |
| get |
| { |
| return MercatorProjection.Instance; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| string url = MakeTileImageUrl(pos, zoom, LanguageStr); |
| return GetTileImageUsingHttp(url); |
| } |
| #endregion |
| string MakeTileImageUrl(GPoint pos, int zoom, string language) |
| { |
| var px1 = Projection.FromTileXYToPixel(pos); |
| var px2 = px1; |
| px1.Offset(0, Projection.TileSize.Height); |
| PointLatLng p1 = Projection.FromPixelToLatLng(px1, zoom); |
| px2.Offset(Projection.TileSize.Width, 0); |
| PointLatLng p2 = Projection.FromPixelToLatLng(px2, zoom); |
| var ret = string.Format(CultureInfo.InvariantCulture, UrlFormat, p1.Lng, p1.Lat, p2.Lng, p2.Lat, Projection.TileSize.Width, Projection.TileSize.Height); |
| return ret; |
| } |
| static readonly string UrlFormat = "http://mapbender.wheregroup.com/cgi-bin/mapserv?map=/data/umn/osm/osm_basic.map&VERSION=1.1.1&REQUEST=GetMap&SERVICE=WMS&LAYERS=OSM_Basic&styles=&bbox={0},{1},{2},{3}&width={4}&height={5}&srs=EPSG:4326&format=image/png"; |
| } |
| } |
| /MKLiveView/v1.0/GMap.NET.Core/GMap.NET.MapProviders/Etc/SpainMapProvider.cs |
|---|
| 0,0 → 1,93 |
| |
| namespace GMap.NET.MapProviders |
| { |
| using System; |
| using GMap.NET.Projections; |
| /// <summary> |
| /// SpainMap provider, http://sigpac.mapa.es/fega/visor/ |
| /// </summary> |
| public class SpainMapProvider : GMapProvider |
| { |
| public static readonly SpainMapProvider Instance; |
| SpainMapProvider() |
| { |
| Copyright = string.Format("©{0} SIGPAC", DateTime.Today.Year); |
| MinZoom = 5; |
| Area = new RectLatLng(43.8741381814747, -9.700927734375, 14.34814453125, 7.8605775962932); |
| } |
| static SpainMapProvider() |
| { |
| Instance = new SpainMapProvider(); |
| } |
| readonly string[] levels = |
| { |
| "0", "1", "2", "3", "4", |
| "MTNSIGPAC", |
| "MTN2000", "MTN2000", "MTN2000", "MTN2000", "MTN2000", |
| "MTN200", "MTN200", "MTN200", |
| "MTN25", "MTN25", |
| "ORTOFOTOS","ORTOFOTOS","ORTOFOTOS","ORTOFOTOS" |
| }; |
| #region GMapProvider Members |
| readonly Guid id = new Guid("7B70ABB0-1265-4D34-9442-F0788F4F689F"); |
| public override Guid Id |
| { |
| get |
| { |
| return id; |
| } |
| } |
| readonly string name = "SpainMap"; |
| public override string Name |
| { |
| get |
| { |
| return name; |
| } |
| } |
| GMapProvider[] overlays; |
| public override GMapProvider[] Overlays |
| { |
| get |
| { |
| if(overlays == null) |
| { |
| overlays = new GMapProvider[] { this }; |
| } |
| return overlays; |
| } |
| } |
| public override PureProjection Projection |
| { |
| get |
| { |
| return MercatorProjection.Instance; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| string url = MakeTileImageUrl(pos, zoom, LanguageStr); |
| return GetTileImageUsingHttp(url); |
| } |
| #endregion |
| string MakeTileImageUrl(GPoint pos, int zoom, string language) |
| { |
| return string.Format(UrlFormat, levels[zoom], zoom, pos.X, ((2 << zoom - 1) - pos.Y - 1)); |
| } |
| static readonly string UrlFormat = "http://sigpac.mapa.es/kmlserver/raster/{0}@3785/{1}.{2}.{3}.img"; |
| } |
| } |
| /MKLiveView/v1.0/GMap.NET.Core/GMap.NET.MapProviders/Etc/SwedenMapProvider.cs |
|---|
| 0,0 → 1,385 |
| |
| namespace GMap.NET.MapProviders |
| { |
| using System; |
| using GMap.NET.Projections; |
| public abstract class SwedenMapProviderBase : GMapProvider |
| { |
| public SwedenMapProviderBase() |
| { |
| RefererUrl = "https://kso.etjanster.lantmateriet.se/?lang=en"; |
| Copyright = string.Format("©{0} Lantmäteriet", DateTime.Today.Year); |
| MaxZoom = 11; |
| //Area = new RectLatLng(58.0794870805093, 20.3286067123543, 7.90883164336887, 2.506129113082); |
| } |
| #region GMapProvider Members |
| public override Guid Id |
| { |
| get |
| { |
| throw new NotImplementedException(); |
| } |
| } |
| public override string Name |
| { |
| get |
| { |
| throw new NotImplementedException(); |
| } |
| } |
| public override PureProjection Projection |
| { |
| get |
| { |
| return SWEREF99_TMProjection.Instance; |
| } |
| } |
| GMapProvider[] overlays; |
| public override GMapProvider[] Overlays |
| { |
| get |
| { |
| if(overlays == null) |
| { |
| overlays = new GMapProvider[] { this }; |
| } |
| return overlays; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| throw new NotImplementedException(); |
| } |
| #endregion |
| } |
| /// <summary> |
| /// SwedenMap provider, https://kso.etjanster.lantmateriet.se/?lang=en# |
| /// </summary> |
| public class SwedenMapProvider : SwedenMapProviderBase |
| { |
| public static readonly SwedenMapProvider Instance; |
| SwedenMapProvider() |
| { |
| } |
| static SwedenMapProvider() |
| { |
| Instance = new SwedenMapProvider(); |
| } |
| #region GMapProvider Members |
| readonly Guid id = new Guid("40890A96-6E82-4FA7-90A3-73D66B974F63"); |
| public override Guid Id |
| { |
| get |
| { |
| return id; |
| } |
| } |
| readonly string name = "SwedenMap"; |
| public override string Name |
| { |
| get |
| { |
| return name; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| string url = MakeTileImageUrl(pos, zoom, LanguageStr); |
| return GetTileImageUsingHttp(url); |
| } |
| #endregion |
| string MakeTileImageUrl(GPoint pos, int zoom, string language) |
| { |
| // https://kso.etjanster.lantmateriet.se/karta/topowebb/v1/wmts?SERVICE=WMTS&REQUEST=GetTile&VERSION=1.0.0&LAYER=topowebb&STYLE=default&TILEMATRIXSET=3006&TILEMATRIX=2&TILEROW=6&TILECOL=7&FORMAT=image%2Fpng |
| return string.Format(UrlFormat, zoom, pos.Y, pos.X); |
| } |
| static readonly string UrlFormat = "http://kso.etjanster.lantmateriet.se/karta/topowebb/v1/wmts?SERVICE=WMTS&REQUEST=GetTile&VERSION=1.0.0&LAYER=topowebb&STYLE=default&TILEMATRIXSET=3006&TILEMATRIX={0}&TILEROW={1}&TILECOL={2}&FORMAT=image%2Fpng"; |
| } |
| } |
| /* |
| https://kso.etjanster.lantmateriet.se/?lang=en# |
| { |
| "analytics" : { |
| "account" : "UA-47513746-2" |
| }, |
| "ortofotoServiceUrl" : "https://services-ver.lantmateriet.se/distribution/produkter/metabild/v1/ortofoto", |
| "metadata" : { |
| "password" : "wllZIV50DH2b", |
| "username" : "lant0181" |
| }, |
| "minFastighetUrl" : "https://etjanster.lantmateriet.se/nyaminfastighet/?mode=TEXT&module=sercxi-minafastigheter-module", |
| "enableKartvaljare" : false, |
| "frwebburl" : "https://etjanster.lantmateriet.se/frwebb/protect/index.jsp?information=FRW019&query=", |
| "previewServiceUrl" : "https://services-ver.lantmateriet.se/distribution/produkter/tumnagel/v1/", |
| "minaFastighetsArendenUrl" : "https://etjanster.lantmateriet.se/minafastighetsarenden", |
| "flygbildServiceUrl" : "https://services-ver.lantmateriet.se/distribution/produkter/metabild/v1/flygbild" |
| } |
| PROJCS["SWEREF99 TM", |
| GEOGCS["SWEREF99", |
| DATUM["SWEREF99", |
| SPHEROID["GRS 1980",6378137,298.257222101, |
| AUTHORITY["EPSG","7019"]], |
| TOWGS84[0,0,0,0,0,0,0], |
| AUTHORITY["EPSG","6619"]], |
| PRIMEM["Greenwich",0, |
| AUTHORITY["EPSG","8901"]], |
| UNIT["degree",0.01745329251994328, |
| AUTHORITY["EPSG","9122"]], |
| AUTHORITY["EPSG","4619"]], |
| UNIT["metre",1, |
| AUTHORITY["EPSG","9001"]], |
| PROJECTION["Transverse_Mercator"], |
| PARAMETER["latitude_of_origin",0], |
| PARAMETER["central_meridian",15], |
| PARAMETER["scale_factor",0.9996], |
| PARAMETER["false_easting",500000], |
| PARAMETER["false_northing",0], |
| AUTHORITY["EPSG","3006"], |
| AXIS["y",EAST], |
| AXIS["x",NORTH]] |
| { |
| "defaultLayer" : "topowebbwmts", |
| "extent" : { |
| "left" : -1200000, |
| "bottom" : 4700000, |
| "right" : 2600000, |
| "top" : 8500000 |
| }, |
| "projection" : "EPSG:3006", |
| "units" : "m", |
| "allOverlays" : true, |
| "resolutions" : [4096.0, 2048.0, 1024.0, 512.0, 256.0, 128.0, 64.0, 32.0, 16.0, 8.0, 4.0, 2.0, 1.0, 0.5, 0.25, 0.15, 0.1, 0.05, 0.01], |
| "initPosition" : { |
| "n" : 6607899, |
| "e" : 564931, |
| "zoom" : 2 |
| }, |
| "layers" : [{ |
| "id" : "topowebbhydrografi", |
| "protocol" : "WMS", |
| "url" : ["https://kso.etjanster.lantmateriet.se/karta/topowebb-skikt/wms/v1.1"], |
| "exceptions" : "application/vnd.ogc.se_xml", |
| "format" : "image/png", |
| "layers" : "hydrografi", |
| "name" : "Hydrografi", |
| "fullmap" : "false", |
| "enabled" : "true", |
| "sheetFamily" : "", |
| "maxResolution" : 0.0, |
| "minResolution" : 0.0, |
| "visible" : "true", |
| "tileSize" : 512, |
| "maxScale" : 0, |
| "minScale" : 0, |
| "removeLayer" : "false", |
| "styles" : [] |
| }, { |
| "id" : "orto", |
| "protocol" : "WMS", |
| "url" : ["https://kso.etjanster.lantmateriet.se/karta/ortofoto/wms/v1"], |
| "exceptions" : "application/vnd.ogc.se_xml", |
| "format" : "image/png", |
| "layers" : "orto", |
| "name" : "Ortofoton 0.5 m/pixel", |
| "fullmap" : "true", |
| "enabled" : "true", |
| "sheetFamily" : "", |
| "maxResolution" : 0.0, |
| "minResolution" : 0.0, |
| "visible" : "true", |
| "tileSize" : 512, |
| "maxScale" : 0, |
| "minScale" : 0, |
| "removeLayer" : "false", |
| "styles" : [] |
| }, { |
| "id" : "topowebbwmts", |
| "protocol" : "WMTS", |
| "url" : ["https://kso.etjanster.lantmateriet.se/karta/topowebb/v1/wmts"], |
| "exceptions" : "application/vnd.ogc.se_xml", |
| "format" : "image/png", |
| "layers" : "topowebb", |
| "name" : "Topografisk webbkarta (cache)", |
| "fullmap" : "true", |
| "enabled" : "true", |
| "sheetFamily" : "", |
| "maxResolution" : 4096.0, |
| "minResolution" : 0.5, |
| "visible" : "false", |
| "tileSize" : 512, |
| "maxScale" : 0, |
| "minScale" : 0, |
| "removeLayer" : "false", |
| "styles" : [] |
| }, { |
| "id" : "topowebbwms", |
| "protocol" : "WMS", |
| "url" : ["https://kso.etjanster.lantmateriet.se/karta/topowebb/wms/v1"], |
| "exceptions" : "application/vnd.ogc.se_xml", |
| "format" : "image/png", |
| "layers" : "topowebbkartan", |
| "name" : "Topografisk webbkarta", |
| "fullmap" : "true", |
| "enabled" : "true", |
| "sheetFamily" : "", |
| "maxResolution" : 0.0, |
| "minResolution" : 0.0, |
| "visible" : "true", |
| "tileSize" : 512, |
| "maxScale" : 0, |
| "minScale" : 0, |
| "removeLayer" : "false", |
| "styles" : [] |
| }, { |
| "id" : "terrangskuggning", |
| "protocol" : "WMS", |
| "url" : ["https://kso.etjanster.lantmateriet.se/karta/hojdmodell/wms/v1"], |
| "exceptions" : "application/vnd.ogc.se_xml", |
| "format" : "image/png", |
| "layers" : "terrangskuggning", |
| "name" : "Terrängskuggning", |
| "fullmap" : "false", |
| "enabled" : "true", |
| "sheetFamily" : "", |
| "maxResolution" : 0.0, |
| "minResolution" : 0.0, |
| "visible" : "false", |
| "tileSize" : 2048, |
| "maxScale" : 0, |
| "minScale" : 0, |
| "removeLayer" : "false", |
| "styles" : [] |
| }, { |
| "id" : "terrangkartan", |
| "protocol" : "WMS", |
| "url" : ["https://kso.etjanster.lantmateriet.se/karta/allmannakartor/wms/v1"], |
| "exceptions" : "application/vnd.ogc.se_xml", |
| "format" : "image/png", |
| "layers" : "terrangkartan", |
| "name" : "Terrängkartan", |
| "fullmap" : "true", |
| "enabled" : "true", |
| "sheetFamily" : "SE50", |
| "maxResolution" : 0.0, |
| "minResolution" : 0.0, |
| "visible" : "false", |
| "tileSize" : 512, |
| "maxScale" : 0, |
| "minScale" : 0, |
| "removeLayer" : "false", |
| "styles" : [] |
| }, { |
| "id" : "fjallkartan", |
| "protocol" : "WMS", |
| "url" : ["https://kso.etjanster.lantmateriet.se/karta/allmannakartor/wms/v1"], |
| "exceptions" : "application/vnd.ogc.se_xml", |
| "format" : "image/png", |
| "layers" : "fjallkartan", |
| "name" : "Fjällkartan 1:100 000", |
| "fullmap" : "false", |
| "enabled" : "true", |
| "sheetFamily" : "SE100FJ", |
| "maxResolution" : 0.0, |
| "minResolution" : 0.0, |
| "visible" : "false", |
| "tileSize" : 512, |
| "maxScale" : 0, |
| "minScale" : 0, |
| "removeLayer" : "false", |
| "styles" : [] |
| }, { |
| "id" : "vagkartan", |
| "protocol" : "WMS", |
| "url" : ["https://kso.etjanster.lantmateriet.se/karta/allmannakartor/wms/v1"], |
| "exceptions" : "application/vnd.ogc.se_xml", |
| "format" : "image/png", |
| "layers" : "vagkartan", |
| "name" : "Vägkartan", |
| "fullmap" : "true", |
| "enabled" : "true", |
| "sheetFamily" : "", |
| "maxResolution" : 0.0, |
| "minResolution" : 0.0, |
| "visible" : "false", |
| "tileSize" : 512, |
| "maxScale" : 0, |
| "minScale" : 0, |
| "removeLayer" : "false", |
| "styles" : [] |
| }, { |
| "id" : "oversiktskartan", |
| "protocol" : "WMS", |
| "url" : ["https://kso.etjanster.lantmateriet.se/karta/geodata-intern/wms/v1"], |
| "exceptions" : "application/vnd.ogc.se_xml", |
| "format" : "image/png", |
| "layers" : "oversiktskartan", |
| "name" : "Översiktskartan", |
| "fullmap" : "true", |
| "enabled" : "true", |
| "sheetFamily" : "SE250", |
| "maxResolution" : 0.0, |
| "minResolution" : 0.0, |
| "visible" : "false", |
| "tileSize" : 512, |
| "maxScale" : 0, |
| "minScale" : 0, |
| "removeLayer" : "false", |
| "styles" : [] |
| }, { |
| "id" : "sverigekartan", |
| "protocol" : "WMS", |
| "url" : ["https://kso.etjanster.lantmateriet.se/karta/allmannakartor/wms/v1"], |
| "exceptions" : "application/vnd.ogc.se_xml", |
| "format" : "image/png", |
| "layers" : "sverigekartan", |
| "name" : "Sverigekartan", |
| "fullmap" : "true", |
| "enabled" : "true", |
| "sheetFamily" : "", |
| "maxResolution" : 0.0, |
| "minResolution" : 0.0, |
| "visible" : "false", |
| "tileSize" : 512, |
| "maxScale" : 0, |
| "minScale" : 0, |
| "removeLayer" : "false", |
| "styles" : [] |
| } |
| ], |
| "profiles" : "[]", |
| "touchProfiles" : "[]", |
| "noAuthProfiles" : "[{'value':'default_background_noauth','text':'Topografisk','optgroup':'Standard'},{'value':'default_orto_noauth','text':'Ortofoto','optgroup':'Standard'},{'value':'default_terrangkartan_noauth','text':'Terrängkartan','optgroup':'Standard'},{'value':'default_fjallkartan_noauth','text':'Fjällkartan','optgroup':'Standard'},{'value':'default_vagkartan_noauth','text':'Vägkartan','optgroup':'Standard'},{'value':'default_sverigekartan_noauth','text':'Sverigekartan','optgroup':'Standard'},{'value':'default_terrangskuggning_noauth','text':'Terrängskuggning','optgroup':'Standard'}]", |
| "profileDescriptions" : { |
| "default_background" : "{'layers':[{'id':'topowebbwmts','index':0,'group':'','enabled':true,'visible':true,'style':'default','opacity':1.0}],'version':4}", |
| "default_terrangkartan_noauth" : "{'layers':[{'id':'terrangkartan','index':0,'group':'','enabled':true,'visible':true,'style':'default','opacity':1.0}],'version':4}", |
| "default_vagkartan_noauth" : "{'layers':[{'id':'vagkartan','index':0,'group':'','enabled':true,'visible':true,'style':'default','opacity':1.0}],'version':4}", |
| "default_orto_noauth" : "{'layers':[{'id':'orto025','index':0,'group':'','enabled':true,'visible':true,'style':'default','opacity':1.0},{'id':'orto','index':1,'group':'','enabled':true,'visible':true,'style':'default','opacity':1.0}],'version':4}", |
| "default_fjallkartan_noauth" : "{'layers':[{'id':'fjallkartan','index':0,'group':'','enabled':true,'visible':true,'style':'default','opacity':1.0}],'version':4}", |
| "default_sverigekartan_noauth" : "{'layers':[{'id':'sverigekartan','index':0,'group':'','enabled':true,'visible':true,'style':'default','opacity':1.0}],'version':4}", |
| "default_terrangskuggning_noauth" : "{'layers':[{'id':'topowebbhydrografi','index':0,'group':'','enabled':true,'visible':true,'style':'default','opacity':1.0},{'id':'terrangskuggning','index':1,'group':'','enabled':true,'visible':true,'style':'default','opacity':1.0}],'version':4}", |
| "default_background_noauth" : "{'layers':[{'id':'topowebbwmts','index':0,'group':'','enabled':true,'visible':true,'style':'default','opacity':1.0}],'version':4}" |
| } |
| } |
| */ |
| /MKLiveView/v1.0/GMap.NET.Core/GMap.NET.MapProviders/Etc/TurkeyMapProvider.cs |
|---|
| 0,0 → 1,99 |
| |
| namespace GMap.NET.MapProviders |
| { |
| using System; |
| using GMap.NET.Projections; |
| /// <summary> |
| /// TurkeyMap provider, http://maps.pergo.com.tr/ |
| /// </summary> |
| public class TurkeyMapProvider : GMapProvider |
| { |
| public static readonly TurkeyMapProvider Instance; |
| TurkeyMapProvider() |
| { |
| Copyright = string.Format("©{0} Pergo - Map data ©{0} Fideltus Advanced Technology", DateTime.Today.Year); |
| Area = new RectLatLng(42.5830078125, 25.48828125, 19.05029296875, 6.83349609375); |
| InvertedAxisY = true; |
| } |
| static TurkeyMapProvider() |
| { |
| Instance = new TurkeyMapProvider(); |
| } |
| #region GMapProvider Members |
| readonly Guid id = new Guid("EDE895BD-756D-4BE4-8D03-D54DD8856F1D"); |
| public override Guid Id |
| { |
| get |
| { |
| return id; |
| } |
| } |
| readonly string name = "TurkeyMap"; |
| public override string Name |
| { |
| get |
| { |
| return name; |
| } |
| } |
| GMapProvider[] overlays; |
| public override GMapProvider[] Overlays |
| { |
| get |
| { |
| if(overlays == null) |
| { |
| overlays = new GMapProvider[] { this }; |
| } |
| return overlays; |
| } |
| } |
| public override PureProjection Projection |
| { |
| get |
| { |
| return MercatorProjection.Instance; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| string url = MakeTileImageUrl(pos, zoom, LanguageStr); |
| return GetTileImageUsingHttp(url); |
| } |
| #endregion |
| string MakeTileImageUrl(GPoint pos, int zoom, string language) |
| { |
| // http://{domain}/{layerName}/{zoomLevel}/{first3LetterOfTileX}/{second3LetterOfTileX}/{third3LetterOfTileX}/{first3LetterOfTileY}/{second3LetterOfTileY}/{third3LetterOfTileXY}.png |
| // http://map3.pergo.com.tr/tile/00/000/000/001/000/000/000.png |
| // That means: Zoom Level: 0 TileX: 1 TileY: 0 |
| // http://domain/tile/14/000/019/371/000/011/825.png |
| // That means: Zoom Level: 14 TileX: 19371 TileY:11825 |
| // updated version |
| // http://map1.pergo.com.tr/publish/tile/tile9913/06/000/000/038/000/000/039.png |
| string x = pos.X.ToString(Zeros).Insert(3, Slash).Insert(7, Slash); // - 000/000/001 |
| string y = pos.Y.ToString(Zeros).Insert(3, Slash).Insert(7, Slash); // - 000/000/000 |
| return string.Format(UrlFormat, GetServerNum(pos, 3), zoom, x, y); |
| } |
| static readonly string Zeros = "000000000"; |
| static readonly string Slash = "/"; |
| static readonly string UrlFormat = "http://map{0}.pergo.com.tr/publish/tile/tile9913/{1:00}/{2}/{3}.png"; |
| } |
| } |
| /MKLiveView/v1.0/GMap.NET.Core/GMap.NET.MapProviders/Etc/WikiMapiaMapProvider.cs |
|---|
| 0,0 → 1,127 |
| |
| namespace GMap.NET.MapProviders |
| { |
| using System; |
| using GMap.NET.Projections; |
| public abstract class WikiMapiaMapProviderBase : GMapProvider |
| { |
| public WikiMapiaMapProviderBase() |
| { |
| MaxZoom = 22; |
| RefererUrl = "http://wikimapia.org/"; |
| Copyright = string.Format("© WikiMapia.org - Map data ©{0} WikiMapia", DateTime.Today.Year); |
| } |
| #region GMapProvider Members |
| public override Guid Id |
| { |
| get |
| { |
| throw new NotImplementedException(); |
| } |
| } |
| public override string Name |
| { |
| get |
| { |
| throw new NotImplementedException(); |
| } |
| } |
| public override PureProjection Projection |
| { |
| get |
| { |
| return MercatorProjection.Instance; |
| } |
| } |
| public override GMapProvider[] Overlays |
| { |
| get |
| { |
| throw new NotImplementedException(); |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| throw new NotImplementedException(); |
| } |
| #endregion |
| public static int GetServerNum(GPoint pos) |
| { |
| return (int)(pos.X % 4 + (pos.Y % 4) * 4); |
| } |
| } |
| /// <summary> |
| /// WikiMapiaMap provider, http://wikimapia.org/ |
| /// </summary> |
| public class WikiMapiaMapProvider : WikiMapiaMapProviderBase |
| { |
| public static readonly WikiMapiaMapProvider Instance; |
| WikiMapiaMapProvider() |
| { |
| } |
| static WikiMapiaMapProvider() |
| { |
| Instance = new WikiMapiaMapProvider(); |
| } |
| #region GMapProvider Members |
| readonly Guid id = new Guid("7974022B-1AA6-41F1-8D01-F49940E4B48C"); |
| public override Guid Id |
| { |
| get |
| { |
| return id; |
| } |
| } |
| readonly string name = "WikiMapiaMap"; |
| public override string Name |
| { |
| get |
| { |
| return name; |
| } |
| } |
| GMapProvider[] overlays; |
| public override GMapProvider[] Overlays |
| { |
| get |
| { |
| if(overlays == null) |
| { |
| overlays = new GMapProvider[] { this }; |
| } |
| return overlays; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| string url = MakeTileImageUrl(pos, zoom, string.Empty); |
| return GetTileImageUsingHttp(url); |
| } |
| #endregion |
| string MakeTileImageUrl(GPoint pos, int zoom, string language) |
| { |
| return string.Format(UrlFormat, GetServerNum(pos), pos.X, pos.Y, zoom); |
| } |
| static readonly string UrlFormat = "http://i{0}.wikimapia.org/?x={1}&y={2}&zoom={3}"; |
| } |
| } |
| /MKLiveView/v1.0/GMap.NET.Core/GMap.NET.MapProviders/GMapProvider.cs |
|---|
| 0,0 → 1,703 |
| |
| namespace GMap.NET.MapProviders |
| { |
| using System; |
| using System.Collections.Generic; |
| using System.Diagnostics; |
| using System.IO; |
| using System.Net; |
| using GMap.NET.Internals; |
| using GMap.NET.Projections; |
| using System.Text; |
| using System.Security.Cryptography; |
| /// <summary> |
| /// providers that are already build in |
| /// </summary> |
| public class GMapProviders |
| { |
| static GMapProviders() |
| { |
| list = new List<GMapProvider>(); |
| Type type = typeof(GMapProviders); |
| foreach (var p in type.GetFields()) |
| { |
| var v = p.GetValue(null) as GMapProvider; // static classes cannot be instanced, so use null... |
| if (v != null) |
| { |
| list.Add(v); |
| } |
| } |
| Hash = new Dictionary<Guid, GMapProvider>(); |
| foreach (var p in list) |
| { |
| Hash.Add(p.Id, p); |
| } |
| DbHash = new Dictionary<int, GMapProvider>(); |
| foreach (var p in list) |
| { |
| DbHash.Add(p.DbId, p); |
| } |
| } |
| GMapProviders() |
| { |
| } |
| public static readonly EmptyProvider EmptyProvider = EmptyProvider.Instance; |
| public static readonly OpenStreetMapProvider OpenStreetMap = OpenStreetMapProvider.Instance; |
| public static readonly OpenStreet4UMapProvider OpenStreet4UMap = OpenStreet4UMapProvider.Instance; |
| public static readonly OpenCycleMapProvider OpenCycleMap = OpenCycleMapProvider.Instance; |
| public static readonly OpenCycleLandscapeMapProvider OpenCycleLandscapeMap = OpenCycleLandscapeMapProvider.Instance; |
| public static readonly OpenCycleTransportMapProvider OpenCycleTransportMap = OpenCycleTransportMapProvider.Instance; |
| public static readonly OpenStreetMapQuestProvider OpenStreetMapQuest = OpenStreetMapQuestProvider.Instance; |
| public static readonly OpenStreetMapQuestSatteliteProvider OpenStreetMapQuestSattelite = OpenStreetMapQuestSatteliteProvider.Instance; |
| public static readonly OpenStreetMapQuestHybridProvider OpenStreetMapQuestHybrid = OpenStreetMapQuestHybridProvider.Instance; |
| public static readonly OpenSeaMapHybridProvider OpenSeaMapHybrid = OpenSeaMapHybridProvider.Instance; |
| #if OpenStreetOsm |
| public static readonly OpenStreetOsmProvider OpenStreetOsm = OpenStreetOsmProvider.Instance; |
| #endif |
| #if OpenStreetMapSurfer |
| public static readonly OpenStreetMapSurferProvider OpenStreetMapSurfer = OpenStreetMapSurferProvider.Instance; |
| public static readonly OpenStreetMapSurferTerrainProvider OpenStreetMapSurferTerrain = OpenStreetMapSurferTerrainProvider.Instance; |
| #endif |
| public static readonly WikiMapiaMapProvider WikiMapiaMap = WikiMapiaMapProvider.Instance; |
| public static readonly BingMapProvider BingMap = BingMapProvider.Instance; |
| public static readonly BingSatelliteMapProvider BingSatelliteMap = BingSatelliteMapProvider.Instance; |
| public static readonly BingHybridMapProvider BingHybridMap = BingHybridMapProvider.Instance; |
| public static readonly YahooMapProvider YahooMap = YahooMapProvider.Instance; |
| public static readonly YahooSatelliteMapProvider YahooSatelliteMap = YahooSatelliteMapProvider.Instance; |
| public static readonly YahooHybridMapProvider YahooHybridMap = YahooHybridMapProvider.Instance; |
| public static readonly GoogleMapProvider GoogleMap = GoogleMapProvider.Instance; |
| public static readonly GoogleSatelliteMapProvider GoogleSatelliteMap = GoogleSatelliteMapProvider.Instance; |
| public static readonly GoogleHybridMapProvider GoogleHybridMap = GoogleHybridMapProvider.Instance; |
| public static readonly GoogleTerrainMapProvider GoogleTerrainMap = GoogleTerrainMapProvider.Instance; |
| public static readonly GoogleChinaMapProvider GoogleChinaMap = GoogleChinaMapProvider.Instance; |
| public static readonly GoogleChinaSatelliteMapProvider GoogleChinaSatelliteMap = GoogleChinaSatelliteMapProvider.Instance; |
| public static readonly GoogleChinaHybridMapProvider GoogleChinaHybridMap = GoogleChinaHybridMapProvider.Instance; |
| public static readonly GoogleChinaTerrainMapProvider GoogleChinaTerrainMap = GoogleChinaTerrainMapProvider.Instance; |
| public static readonly GoogleKoreaMapProvider GoogleKoreaMap = GoogleKoreaMapProvider.Instance; |
| public static readonly GoogleKoreaSatelliteMapProvider GoogleKoreaSatelliteMap = GoogleKoreaSatelliteMapProvider.Instance; |
| public static readonly GoogleKoreaHybridMapProvider GoogleKoreaHybridMap = GoogleKoreaHybridMapProvider.Instance; |
| public static readonly NearMapProvider NearMap = NearMapProvider.Instance; |
| public static readonly NearSatelliteMapProvider NearSatelliteMap = NearSatelliteMapProvider.Instance; |
| public static readonly NearHybridMapProvider NearHybridMap = NearHybridMapProvider.Instance; |
| public static readonly OviMapProvider OviMap = OviMapProvider.Instance; |
| public static readonly OviSatelliteMapProvider OviSatelliteMap = OviSatelliteMapProvider.Instance; |
| public static readonly OviHybridMapProvider OviHybridMap = OviHybridMapProvider.Instance; |
| public static readonly OviTerrainMapProvider OviTerrainMap = OviTerrainMapProvider.Instance; |
| public static readonly YandexMapProvider YandexMap = YandexMapProvider.Instance; |
| public static readonly YandexSatelliteMapProvider YandexSatelliteMap = YandexSatelliteMapProvider.Instance; |
| public static readonly YandexHybridMapProvider YandexHybridMap = YandexHybridMapProvider.Instance; |
| public static readonly LithuaniaMapProvider LithuaniaMap = LithuaniaMapProvider.Instance; |
| public static readonly LithuaniaReliefMapProvider LithuaniaReliefMap = LithuaniaReliefMapProvider.Instance; |
| public static readonly Lithuania3dMapProvider Lithuania3dMap = Lithuania3dMapProvider.Instance; |
| public static readonly LithuaniaOrtoFotoMapProvider LithuaniaOrtoFotoMap = LithuaniaOrtoFotoMapProvider.Instance; |
| public static readonly LithuaniaOrtoFotoOldMapProvider LithuaniaOrtoFotoOldMap = LithuaniaOrtoFotoOldMapProvider.Instance; |
| public static readonly LithuaniaHybridMapProvider LithuaniaHybridMap = LithuaniaHybridMapProvider.Instance; |
| public static readonly LithuaniaHybridOldMapProvider LithuaniaHybridOldMap = LithuaniaHybridOldMapProvider.Instance; |
| public static readonly LithuaniaTOP50 LithuaniaTOP50Map = LithuaniaTOP50.Instance; |
| public static readonly LatviaMapProvider LatviaMap = LatviaMapProvider.Instance; |
| public static readonly MapBenderWMSProvider MapBenderWMSdemoMap = MapBenderWMSProvider.Instance; |
| public static readonly TurkeyMapProvider TurkeyMap = TurkeyMapProvider.Instance; |
| public static readonly CloudMadeMapProvider CloudMadeMap = CloudMadeMapProvider.Instance; |
| public static readonly SpainMapProvider SpainMap = SpainMapProvider.Instance; |
| public static readonly CzechMapProviderOld CzechOldMap = CzechMapProviderOld.Instance; |
| public static readonly CzechSatelliteMapProviderOld CzechSatelliteOldMap = CzechSatelliteMapProviderOld.Instance; |
| public static readonly CzechHybridMapProviderOld CzechHybridOldMap = CzechHybridMapProviderOld.Instance; |
| public static readonly CzechTuristMapProviderOld CzechTuristOldMap = CzechTuristMapProviderOld.Instance; |
| public static readonly CzechHistoryMapProviderOld CzechHistoryOldMap = CzechHistoryMapProviderOld.Instance; |
| public static readonly CzechMapProvider CzechMap = CzechMapProvider.Instance; |
| public static readonly CzechSatelliteMapProvider CzechSatelliteMap = CzechSatelliteMapProvider.Instance; |
| public static readonly CzechHybridMapProvider CzechHybridMap = CzechHybridMapProvider.Instance; |
| public static readonly CzechTuristMapProvider CzechTuristMap = CzechTuristMapProvider.Instance; |
| public static readonly CzechTuristWinterMapProvider CzechTuristWinterMap = CzechTuristWinterMapProvider.Instance; |
| public static readonly CzechHistoryMapProvider CzechHistoryMap = CzechHistoryMapProvider.Instance; |
| public static readonly CzechGeographicMapProvider CzechGeographicMap = CzechGeographicMapProvider.Instance; |
| public static readonly ArcGIS_Imagery_World_2D_MapProvider ArcGIS_Imagery_World_2D_Map = ArcGIS_Imagery_World_2D_MapProvider.Instance; |
| public static readonly ArcGIS_ShadedRelief_World_2D_MapProvider ArcGIS_ShadedRelief_World_2D_Map = ArcGIS_ShadedRelief_World_2D_MapProvider.Instance; |
| public static readonly ArcGIS_StreetMap_World_2D_MapProvider ArcGIS_StreetMap_World_2D_Map = ArcGIS_StreetMap_World_2D_MapProvider.Instance; |
| public static readonly ArcGIS_Topo_US_2D_MapProvider ArcGIS_Topo_US_2D_Map = ArcGIS_Topo_US_2D_MapProvider.Instance; |
| public static readonly ArcGIS_World_Physical_MapProvider ArcGIS_World_Physical_Map = ArcGIS_World_Physical_MapProvider.Instance; |
| public static readonly ArcGIS_World_Shaded_Relief_MapProvider ArcGIS_World_Shaded_Relief_Map = ArcGIS_World_Shaded_Relief_MapProvider.Instance; |
| public static readonly ArcGIS_World_Street_MapProvider ArcGIS_World_Street_Map = ArcGIS_World_Street_MapProvider.Instance; |
| public static readonly ArcGIS_World_Terrain_Base_MapProvider ArcGIS_World_Terrain_Base_Map = ArcGIS_World_Terrain_Base_MapProvider.Instance; |
| public static readonly ArcGIS_World_Topo_MapProvider ArcGIS_World_Topo_Map = ArcGIS_World_Topo_MapProvider.Instance; |
| public static readonly ArcGIS_DarbAE_Q2_2011_NAVTQ_Eng_V5_MapProvider ArcGIS_DarbAE_Q2_2011_NAVTQ_Eng_V5_Map = ArcGIS_DarbAE_Q2_2011_NAVTQ_Eng_V5_MapProvider.Instance; |
| public static readonly SwedenMapProvider SwedenMap = SwedenMapProvider.Instance; |
| static List<GMapProvider> list; |
| /// <summary> |
| /// get all instances of the supported providers |
| /// </summary> |
| public static List<GMapProvider> List |
| { |
| get |
| { |
| return list; |
| } |
| } |
| static Dictionary<Guid, GMapProvider> Hash; |
| public static GMapProvider TryGetProvider(Guid id) |
| { |
| GMapProvider ret; |
| if (Hash.TryGetValue(id, out ret)) |
| { |
| return ret; |
| } |
| return null; |
| } |
| static Dictionary<int, GMapProvider> DbHash; |
| public static GMapProvider TryGetProvider(int DbId) |
| { |
| GMapProvider ret; |
| if (DbHash.TryGetValue(DbId, out ret)) |
| { |
| return ret; |
| } |
| return null; |
| } |
| } |
| /// <summary> |
| /// base class for each map provider |
| /// </summary> |
| public abstract class GMapProvider |
| { |
| /// <summary> |
| /// unique provider id |
| /// </summary> |
| public abstract Guid Id |
| { |
| get; |
| } |
| /// <summary> |
| /// provider name |
| /// </summary> |
| public abstract string Name |
| { |
| get; |
| } |
| /// <summary> |
| /// provider projection |
| /// </summary> |
| public abstract PureProjection Projection |
| { |
| get; |
| } |
| /// <summary> |
| /// provider overlays |
| /// </summary> |
| public abstract GMapProvider[] Overlays |
| { |
| get; |
| } |
| /// <summary> |
| /// gets tile image using implmented provider |
| /// </summary> |
| /// <param name="pos"></param> |
| /// <param name="zoom"></param> |
| /// <returns></returns> |
| public abstract PureImage GetTileImage(GPoint pos, int zoom); |
| static readonly List<GMapProvider> MapProviders = new List<GMapProvider>(); |
| protected GMapProvider() |
| { |
| using (var HashProvider = new SHA1CryptoServiceProvider()) |
| { |
| DbId = Math.Abs(BitConverter.ToInt32(HashProvider.ComputeHash(Id.ToByteArray()), 0)); |
| } |
| if (MapProviders.Exists(p => p.Id == Id || p.DbId == DbId)) |
| { |
| throw new Exception("such provider id already exsists, try regenerate your provider guid..."); |
| } |
| MapProviders.Add(this); |
| } |
| static GMapProvider() |
| { |
| WebProxy = EmptyWebProxy.Instance; |
| } |
| bool isInitialized = false; |
| /// <summary> |
| /// was provider initialized |
| /// </summary> |
| public bool IsInitialized |
| { |
| get |
| { |
| return isInitialized; |
| } |
| internal set |
| { |
| isInitialized = value; |
| } |
| } |
| /// <summary> |
| /// called before first use |
| /// </summary> |
| public virtual void OnInitialized() |
| { |
| // nice place to detect current provider version |
| } |
| /// <summary> |
| /// id for database, a hash of provider guid |
| /// </summary> |
| public readonly int DbId; |
| /// <summary> |
| /// area of map |
| /// </summary> |
| public RectLatLng? Area; |
| /// <summary> |
| /// minimum level of zoom |
| /// </summary> |
| public int MinZoom; |
| /// <summary> |
| /// maximum level of zoom |
| /// </summary> |
| public int? MaxZoom = 17; |
| /// <summary> |
| /// proxy for net access |
| /// </summary> |
| public static IWebProxy WebProxy; |
| /// <summary> |
| /// Connect trough a SOCKS 4/5 proxy server |
| /// </summary> |
| public static bool IsSocksProxy = false; |
| /// <summary> |
| /// NetworkCredential for tile http access |
| /// </summary> |
| public static ICredentials Credential; |
| /// <summary> |
| /// Gets or sets the value of the User-agent HTTP header. |
| /// It's pseudo-randomized to avoid blockages... |
| /// </summary> |
| public static string UserAgent = string.Format("Mozilla/5.0 (Windows NT 6.1; WOW64; rv:{0}.0) Gecko/{2}{3:00}{4:00} Firefox/{0}.0.{1}", Stuff.random.Next(3, 14), Stuff.random.Next(1, 10), Stuff.random.Next(DateTime.Today.Year - 4, DateTime.Today.Year), Stuff.random.Next(12), Stuff.random.Next(30)); |
| /// <summary> |
| /// timeout for provider connections |
| /// </summary> |
| #if !PocketPC |
| public static int TimeoutMs = 5 * 1000; |
| #else |
| public static int TimeoutMs = 44 * 1000; |
| #endif |
| /// <summary> |
| /// Gets or sets the value of the Referer HTTP header. |
| /// </summary> |
| public string RefererUrl = string.Empty; |
| public string Copyright = string.Empty; |
| /// <summary> |
| /// true if tile origin at BottomLeft, WMS-C |
| /// </summary> |
| public bool InvertedAxisY = false; |
| static string languageStr = "en"; |
| public static string LanguageStr |
| { |
| get |
| { |
| return languageStr; |
| } |
| } |
| static LanguageType language = LanguageType.English; |
| /// <summary> |
| /// map language |
| /// </summary> |
| public static LanguageType Language |
| { |
| get |
| { |
| return language; |
| } |
| set |
| { |
| language = value; |
| languageStr = Stuff.EnumToString(Language); |
| } |
| } |
| /// <summary> |
| /// to bypass the cache, set to true |
| /// </summary> |
| public bool BypassCache = false; |
| /// <summary> |
| /// internal proxy for image managment |
| /// </summary> |
| internal static PureImageProxy TileImageProxy; |
| static readonly string requestAccept = "*/*"; |
| static readonly string responseContentType = "image"; |
| protected virtual bool CheckTileImageHttpResponse(WebResponse response) |
| { |
| //Debug.WriteLine(response.StatusCode + "/" + response.StatusDescription + "/" + response.ContentType + " -> " + response.ResponseUri); |
| return response.ContentType.Contains(responseContentType); |
| } |
| string Authorization = string.Empty; |
| /// <summary> |
| /// http://blog.kowalczyk.info/article/at3/Forcing-basic-http-authentication-for-HttpWebReq.html |
| /// </summary> |
| /// <param name="userName"></param> |
| /// <param name="userPassword"></param> |
| public void ForceBasicHttpAuthentication(string userName, string userPassword) |
| { |
| Authorization = "Basic " + Convert.ToBase64String(Encoding.UTF8.GetBytes(userName + ":" + userPassword)); |
| } |
| protected PureImage GetTileImageUsingHttp(string url) |
| { |
| PureImage ret = null; |
| #if !PocketPC |
| WebRequest request = IsSocksProxy ? SocksHttpWebRequest.Create(url) : WebRequest.Create(url); |
| #else |
| WebRequest request = WebRequest.Create(url); |
| #endif |
| if (WebProxy != null) |
| { |
| request.Proxy = WebProxy; |
| } |
| if (Credential != null) |
| { |
| request.PreAuthenticate = true; |
| request.Credentials = Credential; |
| } |
| if(!string.IsNullOrEmpty(Authorization)) |
| { |
| request.Headers.Set("Authorization", Authorization); |
| } |
| if (request is HttpWebRequest) |
| { |
| var r = request as HttpWebRequest; |
| r.UserAgent = UserAgent; |
| r.ReadWriteTimeout = TimeoutMs * 6; |
| r.Accept = requestAccept; |
| r.Referer = RefererUrl; |
| r.Timeout = TimeoutMs; |
| } |
| #if !PocketPC |
| else if (request is SocksHttpWebRequest) |
| { |
| var r = request as SocksHttpWebRequest; |
| if (!string.IsNullOrEmpty(UserAgent)) |
| { |
| r.Headers.Add("User-Agent", UserAgent); |
| } |
| if (!string.IsNullOrEmpty(requestAccept)) |
| { |
| r.Headers.Add("Accept", requestAccept); |
| } |
| if (!string.IsNullOrEmpty(RefererUrl)) |
| { |
| r.Headers.Add("Referer", RefererUrl); |
| } |
| } |
| #endif |
| using (var response = request.GetResponse()) |
| { |
| if (CheckTileImageHttpResponse(response)) |
| { |
| using (Stream responseStream = response.GetResponseStream()) |
| { |
| MemoryStream data = Stuff.CopyStream(responseStream, false); |
| Debug.WriteLine("Response[" + data.Length + " bytes]: " + url); |
| if (data.Length > 0) |
| { |
| ret = TileImageProxy.FromStream(data); |
| if (ret != null) |
| { |
| ret.Data = data; |
| ret.Data.Position = 0; |
| } |
| else |
| { |
| data.Dispose(); |
| } |
| } |
| data = null; |
| } |
| } |
| else |
| { |
| Debug.WriteLine("CheckTileImageHttpResponse[false]: " + url); |
| } |
| #if PocketPC |
| request.Abort(); |
| #endif |
| response.Close(); |
| } |
| return ret; |
| } |
| protected string GetContentUsingHttp(string url) |
| { |
| string ret = string.Empty; |
| #if !PocketPC |
| WebRequest request = IsSocksProxy ? SocksHttpWebRequest.Create(url) : WebRequest.Create(url); |
| #else |
| WebRequest request = WebRequest.Create(url); |
| #endif |
| if (WebProxy != null) |
| { |
| request.Proxy = WebProxy; |
| } |
| if (Credential != null) |
| { |
| request.PreAuthenticate = true; |
| request.Credentials = Credential; |
| } |
| if(!string.IsNullOrEmpty(Authorization)) |
| { |
| request.Headers.Set("Authorization", Authorization); |
| } |
| if (request is HttpWebRequest) |
| { |
| var r = request as HttpWebRequest; |
| r.UserAgent = UserAgent; |
| r.ReadWriteTimeout = TimeoutMs * 6; |
| r.Accept = requestAccept; |
| r.Referer = RefererUrl; |
| r.Timeout = TimeoutMs; |
| } |
| #if !PocketPC |
| else if (request is SocksHttpWebRequest) |
| { |
| var r = request as SocksHttpWebRequest; |
| if (!string.IsNullOrEmpty(UserAgent)) |
| { |
| r.Headers.Add("User-Agent", UserAgent); |
| } |
| if (!string.IsNullOrEmpty(requestAccept)) |
| { |
| r.Headers.Add("Accept", requestAccept); |
| } |
| if (!string.IsNullOrEmpty(RefererUrl)) |
| { |
| r.Headers.Add("Referer", RefererUrl); |
| } |
| } |
| #endif |
| using (var response = request.GetResponse()) |
| { |
| using (Stream responseStream = response.GetResponseStream()) |
| { |
| using (StreamReader read = new StreamReader(responseStream, Encoding.UTF8)) |
| { |
| ret = read.ReadToEnd(); |
| } |
| } |
| #if PocketPC |
| request.Abort(); |
| #endif |
| response.Close(); |
| } |
| return ret; |
| } |
| #if !PocketPC |
| /// <summary> |
| /// use at your own risk, storing tiles in files is slow and hard on the file system |
| /// </summary> |
| /// <param name="fileName"></param> |
| /// <returns></returns> |
| protected virtual PureImage GetTileImageFromFile(string fileName) |
| { |
| return GetTileImageFromArray(File.ReadAllBytes(fileName)); |
| } |
| #endif |
| protected virtual PureImage GetTileImageFromArray(byte [] data) |
| { |
| return TileImageProxy.FromArray(data); |
| } |
| protected static int GetServerNum(GPoint pos, int max) |
| { |
| return (int)(pos.X + 2 * pos.Y) % max; |
| } |
| public override int GetHashCode() |
| { |
| return (int)DbId; |
| } |
| public override bool Equals(object obj) |
| { |
| if (obj is GMapProvider) |
| { |
| return Id.Equals((obj as GMapProvider).Id); |
| } |
| return false; |
| } |
| public override string ToString() |
| { |
| return Name; |
| } |
| } |
| /// <summary> |
| /// represents empty provider |
| /// </summary> |
| public class EmptyProvider : GMapProvider |
| { |
| public static readonly EmptyProvider Instance; |
| EmptyProvider() |
| { |
| MaxZoom = null; |
| } |
| static EmptyProvider() |
| { |
| Instance = new EmptyProvider(); |
| } |
| #region GMapProvider Members |
| public override Guid Id |
| { |
| get |
| { |
| return Guid.Empty; |
| } |
| } |
| readonly string name = "None"; |
| public override string Name |
| { |
| get |
| { |
| return name; |
| } |
| } |
| readonly MercatorProjection projection = MercatorProjection.Instance; |
| public override PureProjection Projection |
| { |
| get |
| { |
| return projection; |
| } |
| } |
| public override GMapProvider[] Overlays |
| { |
| get |
| { |
| return null; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| return null; |
| } |
| #endregion |
| } |
| public sealed class EmptyWebProxy : IWebProxy |
| { |
| public static readonly EmptyWebProxy Instance = new EmptyWebProxy(); |
| private ICredentials m_credentials; |
| public ICredentials Credentials |
| { |
| get |
| { |
| return this.m_credentials; |
| } |
| set |
| { |
| this.m_credentials = value; |
| } |
| } |
| public Uri GetProxy(Uri uri) |
| { |
| return uri; |
| } |
| public bool IsBypassed(Uri uri) |
| { |
| return true; |
| } |
| } |
| } |
| /MKLiveView/v1.0/GMap.NET.Core/GMap.NET.MapProviders/Google/China/GoogleChinaHybridMapProvider.cs |
|---|
| 0,0 → 1,81 |
| |
| namespace GMap.NET.MapProviders |
| { |
| using System; |
| /// <summary> |
| /// GoogleChinaHybridMap provider |
| /// </summary> |
| public class GoogleChinaHybridMapProvider : GoogleMapProviderBase |
| { |
| public static readonly GoogleChinaHybridMapProvider Instance; |
| GoogleChinaHybridMapProvider() |
| { |
| RefererUrl = string.Format("http://ditu.{0}/", ServerChina); |
| } |
| static GoogleChinaHybridMapProvider() |
| { |
| Instance = new GoogleChinaHybridMapProvider(); |
| } |
| public string Version = "h@298"; |
| #region GMapProvider Members |
| readonly Guid id = new Guid("B8A2A78D-1C49-45D0-8F03-9B95C83116B7"); |
| public override Guid Id |
| { |
| get |
| { |
| return id; |
| } |
| } |
| readonly string name = "GoogleChinaHybridMap"; |
| public override string Name |
| { |
| get |
| { |
| return name; |
| } |
| } |
| GMapProvider[] overlays; |
| public override GMapProvider[] Overlays |
| { |
| get |
| { |
| if(overlays == null) |
| { |
| overlays = new GMapProvider[] { GoogleChinaSatelliteMapProvider.Instance, this }; |
| } |
| return overlays; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| string url = MakeTileImageUrl(pos, zoom, LanguageStr); |
| return GetTileImageUsingHttp(url); |
| } |
| #endregion |
| string MakeTileImageUrl(GPoint pos, int zoom, string language) |
| { |
| string sec1 = string.Empty; // after &x=... |
| string sec2 = string.Empty; // after &zoom=... |
| GetSecureWords(pos, out sec1, out sec2); |
| return string.Format(UrlFormat, UrlFormatServer, GetServerNum(pos, 4), UrlFormatRequest, Version, ChinaLanguage, pos.X, sec1, pos.Y, zoom, sec2, ServerChina); |
| } |
| static readonly string ChinaLanguage = "zh-CN"; |
| static readonly string UrlFormatServer = "mt"; |
| static readonly string UrlFormatRequest = "vt"; |
| static readonly string UrlFormat = "http://{0}{1}.{10}/{2}/imgtp=png32&lyrs={3}&hl={4}&gl=cn&x={5}{6}&y={7}&z={8}&s={9}"; |
| } |
| } |
| /MKLiveView/v1.0/GMap.NET.Core/GMap.NET.MapProviders/Google/China/GoogleChinaMapProvider.cs |
|---|
| 0,0 → 1,68 |
| |
| namespace GMap.NET.MapProviders |
| { |
| using System; |
| /// <summary> |
| /// GoogleChinaMap provider |
| /// </summary> |
| public class GoogleChinaMapProvider : GoogleMapProviderBase |
| { |
| public static readonly GoogleChinaMapProvider Instance; |
| GoogleChinaMapProvider() |
| { |
| RefererUrl = string.Format("http://ditu.{0}/", ServerChina); |
| } |
| static GoogleChinaMapProvider() |
| { |
| Instance = new GoogleChinaMapProvider(); |
| } |
| public string Version = "m@298"; |
| #region GMapProvider Members |
| readonly Guid id = new Guid("1213F763-64EE-4AB6-A14A-D84D6BCC3426"); |
| public override Guid Id |
| { |
| get |
| { |
| return id; |
| } |
| } |
| readonly string name = "GoogleChinaMap"; |
| public override string Name |
| { |
| get |
| { |
| return name; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| string url = MakeTileImageUrl(pos, zoom, LanguageStr); |
| return GetTileImageUsingHttp(url); |
| } |
| #endregion |
| string MakeTileImageUrl(GPoint pos, int zoom, string language) |
| { |
| string sec1 = string.Empty; // after &x=... |
| string sec2 = string.Empty; // after &zoom=... |
| GetSecureWords(pos, out sec1, out sec2); |
| return string.Format(UrlFormat, UrlFormatServer, GetServerNum(pos, 4), UrlFormatRequest, Version, ChinaLanguage, pos.X, sec1, pos.Y, zoom, sec2, ServerChina); |
| } |
| static readonly string ChinaLanguage = "zh-CN"; |
| static readonly string UrlFormatServer = "mt"; |
| static readonly string UrlFormatRequest = "vt"; |
| static readonly string UrlFormat = "http://{0}{1}.{10}/{2}/lyrs={3}&hl={4}&gl=cn&x={5}{6}&y={7}&z={8}&s={9}"; |
| } |
| } |
| /MKLiveView/v1.0/GMap.NET.Core/GMap.NET.MapProviders/Google/China/GoogleChinaSatelliteMapProvider.cs |
|---|
| 0,0 → 1,67 |
| |
| namespace GMap.NET.MapProviders |
| { |
| using System; |
| /// <summary> |
| /// GoogleChinaSatelliteMap provider |
| /// </summary> |
| public class GoogleChinaSatelliteMapProvider : GoogleMapProviderBase |
| { |
| public static readonly GoogleChinaSatelliteMapProvider Instance; |
| GoogleChinaSatelliteMapProvider() |
| { |
| RefererUrl = string.Format("http://ditu.{0}/", ServerChina); |
| } |
| static GoogleChinaSatelliteMapProvider() |
| { |
| Instance = new GoogleChinaSatelliteMapProvider(); |
| } |
| public string Version = "s@170"; |
| #region GMapProvider Members |
| readonly Guid id = new Guid("543009AC-3379-4893-B580-DBE6372B1753"); |
| public override Guid Id |
| { |
| get |
| { |
| return id; |
| } |
| } |
| readonly string name = "GoogleChinaSatelliteMap"; |
| public override string Name |
| { |
| get |
| { |
| return name; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| string url = MakeTileImageUrl(pos, zoom, LanguageStr); |
| return GetTileImageUsingHttp(url); |
| } |
| #endregion |
| string MakeTileImageUrl(GPoint pos, int zoom, string language) |
| { |
| string sec1 = string.Empty; // after &x=... |
| string sec2 = string.Empty; // after &zoom=... |
| GetSecureWords(pos, out sec1, out sec2); |
| return string.Format(UrlFormat, UrlFormatServer, GetServerNum(pos, 4), UrlFormatRequest, Version, pos.X, sec1, pos.Y, zoom, sec2, ServerChina); |
| } |
| static readonly string UrlFormatServer = "mt"; |
| static readonly string UrlFormatRequest = "vt"; |
| static readonly string UrlFormat = "http://{0}{1}.{9}/{2}/lyrs={3}&gl=cn&x={4}{5}&y={6}&z={7}&s={8}"; |
| } |
| } |
| /MKLiveView/v1.0/GMap.NET.Core/GMap.NET.MapProviders/Google/China/GoogleChinaTerrainMapProvider.cs |
|---|
| 0,0 → 1,68 |
| |
| namespace GMap.NET.MapProviders |
| { |
| using System; |
| /// <summary> |
| /// GoogleChinaTerrainMap provider |
| /// </summary> |
| public class GoogleChinaTerrainMapProvider : GoogleMapProviderBase |
| { |
| public static readonly GoogleChinaTerrainMapProvider Instance; |
| GoogleChinaTerrainMapProvider() |
| { |
| RefererUrl = string.Format("http://ditu.{0}/", ServerChina); |
| } |
| static GoogleChinaTerrainMapProvider() |
| { |
| Instance = new GoogleChinaTerrainMapProvider(); |
| } |
| public string Version = "t@132,r@298"; |
| #region GMapProvider Members |
| readonly Guid id = new Guid("831EC3CC-B044-4097-B4B7-FC9D9F6D2CFC"); |
| public override Guid Id |
| { |
| get |
| { |
| return id; |
| } |
| } |
| readonly string name = "GoogleChinaTerrainMap"; |
| public override string Name |
| { |
| get |
| { |
| return name; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| string url = MakeTileImageUrl(pos, zoom, LanguageStr); |
| return GetTileImageUsingHttp(url); |
| } |
| #endregion |
| string MakeTileImageUrl(GPoint pos, int zoom, string language) |
| { |
| string sec1 = string.Empty; // after &x=... |
| string sec2 = string.Empty; // after &zoom=... |
| GetSecureWords(pos, out sec1, out sec2); |
| return string.Format(UrlFormat, UrlFormatServer, GetServerNum(pos, 4), UrlFormatRequest, Version, ChinaLanguage, pos.X, sec1, pos.Y, zoom, sec2, ServerChina); |
| } |
| static readonly string ChinaLanguage = "zh-CN"; |
| static readonly string UrlFormatServer = "mt"; |
| static readonly string UrlFormatRequest = "vt"; |
| static readonly string UrlFormat = "http://{0}{1}.{10}/{2}/lyrs={3}&hl={4}&gl=cn&x={5}{6}&y={7}&z={8}&s={9}"; |
| } |
| } |
| /MKLiveView/v1.0/GMap.NET.Core/GMap.NET.MapProviders/Google/GoogleHybridMapProvider.cs |
|---|
| 0,0 → 1,79 |
| |
| namespace GMap.NET.MapProviders |
| { |
| using System; |
| /// <summary> |
| /// GoogleHybridMap provider |
| /// </summary> |
| public class GoogleHybridMapProvider : GoogleMapProviderBase |
| { |
| public static readonly GoogleHybridMapProvider Instance; |
| GoogleHybridMapProvider() |
| { |
| } |
| static GoogleHybridMapProvider() |
| { |
| Instance = new GoogleHybridMapProvider(); |
| } |
| public string Version = "h@365000000"; //"h@333000000"; |
| #region GMapProvider Members |
| readonly Guid id = new Guid("B076C255-6D12-4466-AAE0-4A73D20A7E6A"); |
| public override Guid Id |
| { |
| get |
| { |
| return id; |
| } |
| } |
| readonly string name = "GoogleHybridMap"; |
| public override string Name |
| { |
| get |
| { |
| return name; |
| } |
| } |
| GMapProvider[] overlays; |
| public override GMapProvider[] Overlays |
| { |
| get |
| { |
| if(overlays == null) |
| { |
| overlays = new GMapProvider[] { GoogleSatelliteMapProvider.Instance, this }; |
| } |
| return overlays; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| string url = MakeTileImageUrl(pos, zoom, LanguageStr); |
| return GetTileImageUsingHttp(url); |
| } |
| #endregion |
| string MakeTileImageUrl(GPoint pos, int zoom, string language) |
| { |
| string sec1 = string.Empty; // after &x=... |
| string sec2 = string.Empty; // after &zoom=... |
| GetSecureWords(pos, out sec1, out sec2); |
| return string.Format(UrlFormat, UrlFormatServer, GetServerNum(pos, 4), UrlFormatRequest, Version, language, pos.X, sec1, pos.Y, zoom, sec2, Server); |
| } |
| static readonly string UrlFormatServer = "mt"; |
| static readonly string UrlFormatRequest = "vt"; |
| static readonly string UrlFormat = "http://{0}{1}.{10}/maps/{2}/lyrs={3}&hl={4}&x={5}{6}&y={7}&z={8}&s={9}"; |
| } |
| } |
| /MKLiveView/v1.0/GMap.NET.Core/GMap.NET.MapProviders/Google/GoogleMapProvider.cs |
|---|
| 0,0 → 1,2191 |
| |
| namespace GMap.NET.MapProviders |
| { |
| using System; |
| using GMap.NET.Projections; |
| using System.Security.Cryptography; |
| using System.Diagnostics; |
| using System.Net; |
| using System.IO; |
| using System.Text.RegularExpressions; |
| using System.Threading; |
| using GMap.NET.Internals; |
| using System.Collections.Generic; |
| using System.Globalization; |
| using System.Xml; |
| using System.Text; |
| #if PocketPC |
| using OpenNETCF.Security.Cryptography; |
| #endif |
| public abstract class GoogleMapProviderBase : GMapProvider, RoutingProvider, GeocodingProvider, DirectionsProvider |
| { |
| public GoogleMapProviderBase() |
| { |
| MaxZoom = null; |
| RefererUrl = string.Format("http://maps.{0}/", Server); |
| Copyright = string.Format("©{0} Google - Map data ©{0} Tele Atlas, Imagery ©{0} TerraMetrics", DateTime.Today.Year); |
| } |
| public readonly string ServerAPIs /* ;}~~ */ = Stuff.GString(/*{^_^}*/"9gERyvblybF8iMuCt/LD6w=="/*d{'_'}b*/); |
| public readonly string Server /* ;}~~~~ */ = Stuff.GString(/*{^_^}*/"gosr2U13BoS+bXaIxt6XWg=="/*d{'_'}b*/); |
| public readonly string ServerChina /* ;}~ */ = Stuff.GString(/*{^_^}*/"gosr2U13BoTEJoJJuO25gQ=="/*d{'_'}b*/); |
| public readonly string ServerKorea /* ;}~~ */ = Stuff.GString(/*{^_^}*/"8ZVBOEsBinzi+zmP7y7pPA=="/*d{'_'}b*/); |
| public readonly string ServerKoreaKr /* ;}~ */ = Stuff.GString(/*{^_^}*/"gosr2U13BoQyz1gkC4QLfg=="/*d{'_'}b*/); |
| public string SecureWord = "Galileo"; |
| /// <summary> |
| /// Your application's API key, obtained from the Google Developers Console. |
| /// This key identifies your application for purposes of quota management. |
| /// Must provide either API key or Maps for Work credentials. |
| /// </summary> |
| public string ApiKey = string.Empty; |
| #region GMapProvider Members |
| public override Guid Id |
| { |
| get |
| { |
| throw new NotImplementedException(); |
| } |
| } |
| public override string Name |
| { |
| get |
| { |
| throw new NotImplementedException(); |
| } |
| } |
| public override PureProjection Projection |
| { |
| get |
| { |
| return MercatorProjection.Instance; |
| } |
| } |
| GMapProvider [] overlays; |
| public override GMapProvider [] Overlays |
| { |
| get |
| { |
| if (overlays == null) |
| { |
| overlays = new GMapProvider [] { this }; |
| } |
| return overlays; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| throw new NotImplementedException(); |
| } |
| #endregion |
| public bool TryCorrectVersion = true; |
| static bool init = false; |
| public override void OnInitialized() |
| { |
| if (!init && TryCorrectVersion) |
| { |
| string url = string.Format("https://maps.{0}/maps/api/js?client=google-maps-lite&libraries=search&language=en&region=", ServerAPIs); |
| try |
| { |
| string html = GMaps.Instance.UseUrlCache ? Cache.Instance.GetContent(url, CacheType.UrlCache, TimeSpan.FromHours(8)) : string.Empty; |
| if (string.IsNullOrEmpty(html)) |
| { |
| html = GetContentUsingHttp(url); |
| if (!string.IsNullOrEmpty(html)) |
| { |
| if (GMaps.Instance.UseUrlCache) |
| { |
| Cache.Instance.SaveContent(url, CacheType.UrlCache, html); |
| } |
| } |
| } |
| if (!string.IsNullOrEmpty(html)) |
| { |
| #region -- match versions -- |
| Regex reg = new Regex(string.Format(@"https?://mts?\d.{0}/maps/vt\?lyrs=m@(\d*)", Server), RegexOptions.IgnoreCase); |
| Match mat = reg.Match(html); |
| if (mat.Success) |
| { |
| GroupCollection gc = mat.Groups; |
| int count = gc.Count; |
| if (count > 0) |
| { |
| string ver = string.Format("m@{0}", gc [1].Value); |
| string old = GMapProviders.GoogleMap.Version; |
| GMapProviders.GoogleMap.Version = ver; |
| GMapProviders.GoogleChinaMap.Version = ver; |
| string verh = string.Format("h@{0}", gc [1].Value); |
| string oldh = GMapProviders.GoogleHybridMap.Version; |
| GMapProviders.GoogleHybridMap.Version = verh; |
| GMapProviders.GoogleChinaHybridMap.Version = verh; |
| #if DEBUG |
| Debug.WriteLine("GMapProviders.GoogleMap.Version: " + ver + ", " + (ver == old ? "OK" : "old: " + old + ", consider updating source")); |
| Debug.WriteLine("GMapProviders.GoogleHybridMap.Version: " + verh + ", " + (verh == oldh ? "OK" : "old: " + oldh + ", consider updating source")); |
| if (Debugger.IsAttached && ver != old) |
| { |
| Thread.Sleep(1111); |
| } |
| #endif |
| } |
| } |
| reg = new Regex(string.Format(@"https?://khms?\d.{0}/kh\?v=(\d*)", Server), RegexOptions.IgnoreCase); |
| mat = reg.Match(html); |
| if (mat.Success) |
| { |
| GroupCollection gc = mat.Groups; |
| int count = gc.Count; |
| if (count > 0) |
| { |
| string ver = gc [1].Value; |
| string old = GMapProviders.GoogleSatelliteMap.Version; |
| GMapProviders.GoogleSatelliteMap.Version = ver; |
| GMapProviders.GoogleKoreaSatelliteMap.Version = ver; |
| GMapProviders.GoogleChinaSatelliteMap.Version = "s@" + ver; |
| #if DEBUG |
| Debug.WriteLine("GMapProviders.GoogleSatelliteMap.Version: " + ver + ", " + (ver == old ? "OK" : "old: " + old + ", consider updating source")); |
| if (Debugger.IsAttached && ver != old) |
| { |
| Thread.Sleep(1111); |
| } |
| #endif |
| } |
| } |
| reg = new Regex(string.Format(@"https?://mts?\d.{0}/maps/vt\?lyrs=t@(\d*),r@(\d*)", Server), RegexOptions.IgnoreCase); |
| mat = reg.Match(html); |
| if (mat.Success) |
| { |
| GroupCollection gc = mat.Groups; |
| int count = gc.Count; |
| if (count > 1) |
| { |
| string ver = string.Format("t@{0},r@{1}", gc [1].Value, gc [2].Value); |
| string old = GMapProviders.GoogleTerrainMap.Version; |
| GMapProviders.GoogleTerrainMap.Version = ver; |
| GMapProviders.GoogleChinaTerrainMap.Version = ver; |
| #if DEBUG |
| Debug.WriteLine("GMapProviders.GoogleTerrainMap.Version: " + ver + ", " + (ver == old ? "OK" : "old: " + old + ", consider updating source")); |
| if (Debugger.IsAttached && ver != old) |
| { |
| Thread.Sleep(1111); |
| } |
| #endif |
| } |
| } |
| #endregion |
| } |
| init = true; // try it only once |
| } |
| catch (Exception ex) |
| { |
| Debug.WriteLine("TryCorrectGoogleVersions failed: " + ex.ToString()); |
| } |
| } |
| } |
| internal void GetSecureWords(GPoint pos, out string sec1, out string sec2) |
| { |
| sec1 = string.Empty; // after &x=... |
| sec2 = string.Empty; // after &zoom=... |
| int seclen = (int)((pos.X * 3) + pos.Y) % 8; |
| sec2 = SecureWord.Substring(0, seclen); |
| if (pos.Y >= 10000 && pos.Y < 100000) |
| { |
| sec1 = Sec1; |
| } |
| } |
| static readonly string Sec1 = "&s="; |
| #region RoutingProvider Members |
| public MapRoute GetRoute(PointLatLng start, PointLatLng end, bool avoidHighways, bool walkingMode, int Zoom) |
| { |
| string tooltip; |
| int numLevels; |
| int zoomFactor; |
| MapRoute ret = null; |
| List<PointLatLng> points = GetRoutePoints(MakeRouteUrl(start, end, LanguageStr, avoidHighways, walkingMode), Zoom, out tooltip, out numLevels, out zoomFactor); |
| if (points != null) |
| { |
| ret = new MapRoute(points, tooltip); |
| } |
| return ret; |
| } |
| public MapRoute GetRoute(string start, string end, bool avoidHighways, bool walkingMode, int Zoom) |
| { |
| string tooltip; |
| int numLevels; |
| int zoomFactor; |
| MapRoute ret = null; |
| List<PointLatLng> points = GetRoutePoints(MakeRouteUrl(start, end, LanguageStr, avoidHighways, walkingMode), Zoom, out tooltip, out numLevels, out zoomFactor); |
| if (points != null) |
| { |
| ret = new MapRoute(points, tooltip); |
| } |
| return ret; |
| } |
| #region -- internals -- |
| string MakeRouteUrl(PointLatLng start, PointLatLng end, string language, bool avoidHighways, bool walkingMode) |
| { |
| string opt = walkingMode ? WalkingStr : (avoidHighways ? RouteWithoutHighwaysStr : RouteStr); |
| return string.Format(CultureInfo.InvariantCulture, RouteUrlFormatPointLatLng, language, opt, start.Lat, start.Lng, end.Lat, end.Lng, Server); |
| } |
| string MakeRouteUrl(string start, string end, string language, bool avoidHighways, bool walkingMode) |
| { |
| string opt = walkingMode ? WalkingStr : (avoidHighways ? RouteWithoutHighwaysStr : RouteStr); |
| return string.Format(RouteUrlFormatStr, language, opt, start.Replace(' ', '+'), end.Replace(' ', '+'), Server); |
| } |
| List<PointLatLng> GetRoutePoints(string url, int zoom, out string tooltipHtml, out int numLevel, out int zoomFactor) |
| { |
| List<PointLatLng> points = null; |
| tooltipHtml = string.Empty; |
| numLevel = -1; |
| zoomFactor = -1; |
| try |
| { |
| string route = GMaps.Instance.UseRouteCache ? Cache.Instance.GetContent(url, CacheType.RouteCache) : string.Empty; |
| if (string.IsNullOrEmpty(route)) |
| { |
| route = GetContentUsingHttp(url); |
| if (!string.IsNullOrEmpty(route)) |
| { |
| if (GMaps.Instance.UseRouteCache) |
| { |
| Cache.Instance.SaveContent(url, CacheType.RouteCache, route); |
| } |
| } |
| } |
| // parse values |
| if (!string.IsNullOrEmpty(route)) |
| { |
| //{ |
| //tooltipHtml:" (300\x26#160;km / 2 valandos 59 min.)", |
| //polylines: |
| //[{ |
| // id:"route0", |
| // points:"cy~rIcvp`ClJ~v@jHpu@N|BB~A?tA_@`J@nAJrB|AhEf@h@~@^pANh@Mr@a@`@_@x@cBPk@ZiBHeDQ{C]wAc@mAqCeEoA_C{@_Cy@iDoEaW}AsJcJ}t@iWowB{C_Vyw@gvGyTyjBu@gHwDoZ{W_zBsX}~BiA_MmAyOcAwOs@yNy@eTk@mVUmTE}PJ_W`@cVd@cQ`@}KjA_V`AeOn@oItAkOdAaKfBaOhDiVbD}RpBuKtEkTtP}q@fr@ypCfCmK|CmNvEqVvCuQ`BgLnAmJ`CgTpA_N~@sLlBwYh@yLp@cSj@e]zFkzKHaVViSf@wZjFwqBt@{Wr@qS`AaUjAgStBkYrEwe@xIuw@`Gmj@rFok@~BkYtCy_@|KccBvBgZjC}[tD__@pDaYjB_MpBuLhGi[fC}KfFcSnEkObFgOrFkOzEoLt[ys@tJeUlIsSbKqXtFiPfKi]rG_W|CiNhDkPfDuQlDoShEuXrEy[nOgiAxF{`@|DoVzFk[fDwPlXupA~CoPfDuQxGcd@l@yEdH{r@xDam@`AiWz@mYtAq~@p@uqAfAqx@|@kZxA}^lBq\\|Be\\lAaO~Dm`@|Gsj@tS_~AhCyUrCeZrByWv@uLlUiyDpA}NdHkn@pGmb@LkAtAoIjDqR`I{`@`BcH|I_b@zJcd@lKig@\\_CbBaIlJ}g@lIoj@pAuJtFoh@~Eqs@hDmv@h@qOfF{jBn@gSxCio@dAuQn@gIVoBjAiOlCqWbCiT`PekAzKiu@~EgYfIya@fA{ExGwWnDkMdHiU|G}R`HgQhRsa@hW}g@jVsg@|a@cbAbJkUxKoYxLa_@`IiZzHu[`DoOXsBhBuJbCwNdBaL`EkYvAwM`CeVtEwj@nDqj@BkAnB{YpGgeAn@eJ`CmYvEid@tBkQpGkd@rE}UxB}JdJo_@nDcNfSan@nS}j@lCeIvDsMbC{J|CyNbAwFfCgPz@uGvBiSdD}`@rFon@nKaqAxDmc@xBuT|Fqc@nC_PrEcUtC_MpFcT`GqQxJmXfXwq@jQgh@hBeGhG_U|BaK|G}[nRikAzIam@tDsYfE}^v@_MbAwKn@oIr@yLrBub@jAoa@b@sRdDmjBx@aZdA}XnAqVpAgTlAqPn@oGvFye@dCeRzGwb@xT_}A`BcPrAoOvCad@jAmXv@eV`BieA~@a[fBg_@`CiZ~A_OhHqk@hHcn@tEwe@rDub@nBoW~@sN|BeZnAgMvDm\\hFs^hSigArFaY`Gc\\`C}OhD}YfByQdAaNbAkOtOu~Cn@wKz@uLfCeY|CkW~B}OhCmO|AcI~A_IvDoPpEyPdImWrDuKnL_YjI{Ptl@qfAle@u|@xI}PbImQvFwMbGgOxFkOpdAosCdD_KxGsU|E}RxFcXhCwNjDwTvBiPfBqOrAyMfBcTxAaVhAwVrCy_Al@iPt@_OtA}Q`AuJ`AgIzAkK`EoUtBsJhCaKxCaKdDaKhQeg@jGiRfGaSrFyR`HsWvL}f@xp@grC`Sq|@pEsVdAoGjF{XlkAgwHxHgj@|Jex@fg@qlEjQs{AdHwh@zDkVhEkVzI_e@v}AgzHpK_l@tE}YtEy[rC}TpFme@jg@cpEbF{d@~BoXfBqUbAyOx@yN|Ao]bAo[tIazC`@iLb@aJ~AkWbBgRdBgPjA{IdCePlAmHfBmJdCiL~CuM|DoNxhDezKdDkLvBoInFqVbCuMxBqNnAeJ~CwXdBoSb^crElFsl@`Dy[zDu^xBiRzc@aaE|Fsd@vCkShDmTpG}^lD}QzDoR|zAcdHvIob@dKoj@jDmSlKiq@xVacBhEqXnBqL|Ga^zJke@`y@ktD~Mop@tP}_AdOg`AtCiQxCyOlDkPfDoN`GiTfGkRjEwLvEsL|HkQtEkJdE{HrwAkaCrT{a@rpDiuHtE_KvLuV|{AwaDzAqCb@mAf{Ac`D~FqL~y@_fBlNmZbGaNtF}Mpn@s~AlYss@dFgK|DoGhBoCrDuE~AcBtGaGnByAnDwBnCwAfDwAnFaBjGkA~[{E`iEkn@pQaDvIwBnIiCl\\qLn}J{pDhMcGrFcDhGeEvoDehC|AsArCwChBaC`C_EzC_HbBcFd@uB`@qAn@gDdB}Kz@}Hn@iPjByx@jDcvAj@}RDsEn@yTv@a]VcPtEamFBcHT_LNkEdAiShDsi@`GudAbFgx@`@iKdP}yFhBgs@p@yRjCo_AJwCXeEb@uEz@_H|@yEnBqHrCiIpAmE`o@qhBxC_IjIuVdIcXh{AgmG`i@_{BfCuLrhAssGfFeXxbBklInCsN|_AoiGpGs_@pl@w}Czy@_kEvG{]h}@ieFbQehAdHye@lPagA|Eu\\tAmI|CwWjn@mwGj@eH|]azFl@kPjAqd@jJe|DlD}vAxAeh@@eBvVk}JzIkqDfE_aBfA{YbBk[zp@e}LhAaObCeUlAuIzAeJrb@q`CjCcOnAaIpBwOtBkTjDsg@~AiPvBwOlAcH|AkIlCkLlYudApDoN`BgHhBaJvAeIvAqJbAuHrBqQbAsLx@oL`MwrCXkFr@uJh@{FhBsOvXwoB|EqVdBmHxC}KtCcJtDgKjDoIxE}JdHcMdCuDdIoKlmB}|BjJuMfFgIlE{HlEyIdEeJ~FaOvCgInCuI`EmN`J}]rEsP`EuMzCoIxGwPpi@cnAhGgPzCiJvFmRrEwQbDyOtCoPbDwTxDq\\rAsK`BgLhB{KxBoLfCgLjDqKdBqEfEkJtSy^`EcJnDuJjAwDrCeK\\}AjCaNr@qEjAaJtNaqAdCqQ`BsItS}bAbQs{@|Kor@xBmKz}@}uDze@{zAjk@}fBjTsq@r@uCd@aDFyCIwCWcCY}Aq_@w|A{AwF_DyHgHwOgu@m_BSb@nFhL", |
| // levels:"B?@?????@?@???A???@?@????@??@????????@????@???A????@????@??@???@??@???A???@??@???A??@???@????A??@???@??@????@??@???@????@???@??A@?@???@????A????@??@?@???@???????@??@?@????@????@?A??@???@????@??@?A??????@???????@??A???@??@???@??@????@??@?@?????@?@?A?@????@???@??@??@????@?@??@?@??@??????@???@?@????@???B???@??@??????@??@???A?????@????@???A??@??????@??@??A?@???@???@??A????@???@???@????A????@@??A???@???@??@??A????@??????@??@???@???B????@?@????????@????@????A?????@????@??A???@???@???B???@?????@???@????@????@???A???????@??A@??@?@??@@?????A?@@????????@??@?A????@?????@???@???@???@???@?@?A???@??@?@??@???@?????@???A??@???????@????@???@????@????@@???A????@?@??@?B", |
| // numLevels:4, |
| // zoomFactor:16 |
| //}] |
| //} |
| #region -- title -- |
| int tooltipEnd = 0; |
| { |
| int x = route.IndexOf("tooltipHtml:") + 13; |
| if (x >= 13) |
| { |
| tooltipEnd = route.IndexOf("\"", x + 1); |
| if (tooltipEnd > 0) |
| { |
| int l = tooltipEnd - x; |
| if (l > 0) |
| { |
| tooltipHtml = route.Substring(x, l).Replace(@"\x26#160;", " "); |
| } |
| } |
| } |
| } |
| #endregion |
| #region -- points -- |
| int pointsEnd = 0; |
| { |
| int x = route.IndexOf("points:", tooltipEnd >= 0 ? tooltipEnd : 0) + 8; |
| if (x >= 8) |
| { |
| pointsEnd = route.IndexOf("\"", x + 1); |
| if (pointsEnd > 0) |
| { |
| int l = pointsEnd - x; |
| if (l > 0) |
| { |
| /* |
| while(l % 5 != 0) |
| { |
| l--; |
| } |
| */ |
| points = new List<PointLatLng>(); |
| DecodePointsInto(points, route.Substring(x, l)); |
| } |
| } |
| } |
| } |
| #endregion |
| #region -- levels -- |
| string levels = string.Empty; |
| int levelsEnd = 0; |
| { |
| int x = route.IndexOf("levels:", pointsEnd >= 0 ? pointsEnd : 0) + 8; |
| if (x >= 8) |
| { |
| levelsEnd = route.IndexOf("\"", x + 1); |
| if (levelsEnd > 0) |
| { |
| int l = levelsEnd - x; |
| if (l > 0) |
| { |
| levels = route.Substring(x, l); |
| } |
| } |
| } |
| } |
| #endregion |
| #region -- numLevel -- |
| int numLevelsEnd = 0; |
| { |
| int x = route.IndexOf("numLevels:", levelsEnd >= 0 ? levelsEnd : 0) + 10; |
| if (x >= 10) |
| { |
| numLevelsEnd = route.IndexOf(",", x); |
| if (numLevelsEnd > 0) |
| { |
| int l = numLevelsEnd - x; |
| if (l > 0) |
| { |
| numLevel = int.Parse(route.Substring(x, l)); |
| } |
| } |
| } |
| } |
| #endregion |
| #region -- zoomFactor -- |
| { |
| int x = route.IndexOf("zoomFactor:", numLevelsEnd >= 0 ? numLevelsEnd : 0) + 11; |
| if (x >= 11) |
| { |
| int end = route.IndexOf("}", x); |
| if (end > 0) |
| { |
| int l = end - x; |
| if (l > 0) |
| { |
| zoomFactor = int.Parse(route.Substring(x, l)); |
| } |
| } |
| } |
| } |
| #endregion |
| #region -- trim point overload -- |
| if (points != null && numLevel > 0 && !string.IsNullOrEmpty(levels)) |
| { |
| if (points.Count - levels.Length > 0) |
| { |
| points.RemoveRange(levels.Length, points.Count - levels.Length); |
| } |
| //http://facstaff.unca.edu/mcmcclur/GoogleMaps/EncodePolyline/description.html |
| // |
| string allZlevels = "TSRPONMLKJIHGFEDCBA@?"; |
| if (numLevel > allZlevels.Length) |
| { |
| numLevel = allZlevels.Length; |
| } |
| // used letters in levels string |
| string pLevels = allZlevels.Substring(allZlevels.Length - numLevel); |
| // remove useless points at zoom |
| { |
| List<PointLatLng> removedPoints = new List<PointLatLng>(); |
| for (int i = 0; i < levels.Length; i++) |
| { |
| int zi = pLevels.IndexOf(levels [i]); |
| if (zi > 0) |
| { |
| if (zi * numLevel > zoom) |
| { |
| removedPoints.Add(points [i]); |
| } |
| } |
| } |
| foreach (var v in removedPoints) |
| { |
| points.Remove(v); |
| } |
| removedPoints.Clear(); |
| removedPoints = null; |
| } |
| } |
| #endregion |
| } |
| } |
| catch (Exception ex) |
| { |
| points = null; |
| Debug.WriteLine("GetRoutePoints: " + ex); |
| } |
| return points; |
| } |
| static readonly string RouteUrlFormatPointLatLng = "http://maps.{6}/maps?f=q&output=dragdir&doflg=p&hl={0}{1}&q=&saddr=@{2},{3}&daddr=@{4},{5}"; |
| static readonly string RouteUrlFormatStr = "http://maps.{4}/maps?f=q&output=dragdir&doflg=p&hl={0}{1}&q=&saddr=@{2}&daddr=@{3}"; |
| static readonly string WalkingStr = "&mra=ls&dirflg=w"; |
| static readonly string RouteWithoutHighwaysStr = "&mra=ls&dirflg=dh"; |
| static readonly string RouteStr = "&mra=ls&dirflg=d"; |
| #endregion |
| #endregion |
| #region GeocodingProvider Members |
| public GeoCoderStatusCode GetPoints(string keywords, out List<PointLatLng> pointList) |
| { |
| return GetLatLngFromGeocoderUrl(MakeGeocoderUrl(keywords, LanguageStr), out pointList); |
| } |
| public PointLatLng? GetPoint(string keywords, out GeoCoderStatusCode status) |
| { |
| List<PointLatLng> pointList; |
| status = GetPoints(keywords, out pointList); |
| return pointList != null && pointList.Count > 0 ? pointList [0] : (PointLatLng?)null; |
| } |
| /// <summary> |
| /// NotImplemented |
| /// </summary> |
| /// <param name="placemark"></param> |
| /// <param name="pointList"></param> |
| /// <returns></returns> |
| public GeoCoderStatusCode GetPoints(Placemark placemark, out List<PointLatLng> pointList) |
| { |
| throw new NotImplementedException("use GetPoints(string keywords..."); |
| } |
| /// <summary> |
| /// NotImplemented |
| /// </summary> |
| /// <param name="placemark"></param> |
| /// <param name="status"></param> |
| /// <returns></returns> |
| public PointLatLng? GetPoint(Placemark placemark, out GeoCoderStatusCode status) |
| { |
| throw new NotImplementedException("use GetPoint(string keywords..."); |
| } |
| public GeoCoderStatusCode GetPlacemarks(PointLatLng location, out List<Placemark> placemarkList) |
| { |
| return GetPlacemarkFromReverseGeocoderUrl(MakeReverseGeocoderUrl(location, LanguageStr), out placemarkList); |
| } |
| public Placemark? GetPlacemark(PointLatLng location, out GeoCoderStatusCode status) |
| { |
| List<Placemark> pointList; |
| status = GetPlacemarks(location, out pointList); |
| return pointList != null && pointList.Count > 0 ? pointList [0] : (Placemark?)null; |
| } |
| #region -- internals -- |
| // The Coogle Geocoding API: http://tinyurl.com/cdlj889 |
| string MakeGeocoderUrl(string keywords, string language) |
| { |
| return string.Format(CultureInfo.InvariantCulture, GeocoderUrlFormat, ServerAPIs, Uri.EscapeDataString(keywords).Replace(' ', '+'), language); |
| } |
| string MakeReverseGeocoderUrl(PointLatLng pt, string language) |
| { |
| return string.Format(CultureInfo.InvariantCulture, ReverseGeocoderUrlFormat, ServerAPIs, pt.Lat, pt.Lng, language); |
| } |
| GeoCoderStatusCode GetLatLngFromGeocoderUrl(string url, out List<PointLatLng> pointList) |
| { |
| var status = GeoCoderStatusCode.Unknow; |
| pointList = null; |
| try |
| { |
| string geo = GMaps.Instance.UseGeocoderCache ? Cache.Instance.GetContent(url, CacheType.GeocoderCache) : string.Empty; |
| bool cache = false; |
| if (string.IsNullOrEmpty(geo)) |
| { |
| string urls = url; |
| // Must provide either API key or Maps for Work credentials. |
| if (!string.IsNullOrEmpty(ClientId)) |
| { |
| urls = GetSignedUri(url); |
| } |
| else if (!string.IsNullOrEmpty(ApiKey)) |
| { |
| urls += "&key=" + ApiKey; |
| } |
| geo = GetContentUsingHttp(urls); |
| if (!string.IsNullOrEmpty(geo)) |
| { |
| cache = true; |
| } |
| } |
| if (!string.IsNullOrEmpty(geo)) |
| { |
| if (geo.StartsWith("<?xml")) |
| { |
| #region -- xml response -- |
| //<?xml version="1.0" encoding="UTF-8"?> |
| //<GeocodeResponse> |
| // <status>OK</status> |
| // <result> |
| // <type>locality</type> |
| // <type>political</type> |
| // <formatted_address>Vilnius, Lithuania</formatted_address> |
| // <address_component> |
| // <long_name>Vilnius</long_name> |
| // <short_name>Vilnius</short_name> |
| // <type>locality</type> |
| // <type>political</type> |
| // </address_component> |
| // <address_component> |
| // <long_name>Vilniaus miesto savivaldyb??</long_name> |
| // <short_name>Vilniaus m. sav.</short_name> |
| // <type>administrative_area_level_2</type> |
| // <type>political</type> |
| // </address_component> |
| // <address_component> |
| // <long_name>Vilnius County</long_name> |
| // <short_name>Vilnius County</short_name> |
| // <type>administrative_area_level_1</type> |
| // <type>political</type> |
| // </address_component> |
| // <address_component> |
| // <long_name>Lithuania</long_name> |
| // <short_name>LT</short_name> |
| // <type>country</type> |
| // <type>political</type> |
| // </address_component> |
| // <geometry> |
| // <location> |
| // <lat>54.6871555</lat> |
| // <lng>25.2796514</lng> |
| // </location> |
| // <location_type>APPROXIMATE</location_type> |
| // <viewport> |
| // <southwest> |
| // <lat>54.5677980</lat> |
| // <lng>25.0243760</lng> |
| // </southwest> |
| // <northeast> |
| // <lat>54.8325440</lat> |
| // <lng>25.4814883</lng> |
| // </northeast> |
| // </viewport> |
| // <bounds> |
| // <southwest> |
| // <lat>54.5677980</lat> |
| // <lng>25.0243760</lng> |
| // </southwest> |
| // <northeast> |
| // <lat>54.8325440</lat> |
| // <lng>25.4814883</lng> |
| // </northeast> |
| // </bounds> |
| // </geometry> |
| // </result> |
| // <result> |
| // <type>airport</type> |
| // <type>transit_station</type> |
| // <type>establishment</type> |
| // <formatted_address>Vilnius International Airport (VNO), 10A, Vilnius, Lithuania</formatted_address> |
| // <address_component> |
| // <long_name>Vilnius International Airport</long_name> |
| // <short_name>Vilnius International Airport</short_name> |
| // <type>establishment</type> |
| // </address_component> |
| // <address_component> |
| // <long_name>10A</long_name> |
| // <short_name>10A</short_name> |
| // <type>street_number</type> |
| // </address_component> |
| // <address_component> |
| // <long_name>Vilnius</long_name> |
| // <short_name>Vilnius</short_name> |
| // <type>locality</type> |
| // <type>political</type> |
| // </address_component> |
| // <address_component> |
| // <long_name>Vilniaus miesto savivaldyb??</long_name> |
| // <short_name>Vilniaus m. sav.</short_name> |
| // <type>administrative_area_level_2</type> |
| // <type>political</type> |
| // </address_component> |
| // <address_component> |
| // <long_name>Vilnius County</long_name> |
| // <short_name>Vilnius County</short_name> |
| // <type>administrative_area_level_1</type> |
| // <type>political</type> |
| // </address_component> |
| // <address_component> |
| // <long_name>Lithuania</long_name> |
| // <short_name>LT</short_name> |
| // <type>country</type> |
| // <type>political</type> |
| // </address_component> |
| // <geometry> |
| // <location> |
| // <lat>54.6369440</lat> |
| // <lng>25.2877780</lng> |
| // </location> |
| // <location_type>APPROXIMATE</location_type> |
| // <viewport> |
| // <southwest> |
| // <lat>54.6158331</lat> |
| // <lng>25.2723832</lng> |
| // </southwest> |
| // <northeast> |
| // <lat>54.6538331</lat> |
| // <lng>25.3034219</lng> |
| // </northeast> |
| // </viewport> |
| // <bounds> |
| // <southwest> |
| // <lat>54.6158331</lat> |
| // <lng>25.2723832</lng> |
| // </southwest> |
| // <northeast> |
| // <lat>54.6538331</lat> |
| // <lng>25.3034219</lng> |
| // </northeast> |
| // </bounds> |
| // </geometry> |
| // </result> |
| //</GeocodeResponse> |
| #endregion |
| XmlDocument doc = new XmlDocument(); |
| doc.LoadXml(geo); |
| XmlNode nn = doc.SelectSingleNode("//status"); |
| if (nn != null) |
| { |
| if (nn.InnerText != "OK") |
| { |
| Debug.WriteLine("GetLatLngFromGeocoderUrl: " + nn.InnerText); |
| } |
| else |
| { |
| status = GeoCoderStatusCode.G_GEO_SUCCESS; |
| if (cache && GMaps.Instance.UseGeocoderCache) |
| { |
| Cache.Instance.SaveContent(url, CacheType.GeocoderCache, geo); |
| } |
| pointList = new List<PointLatLng>(); |
| XmlNodeList l = doc.SelectNodes("//result"); |
| if (l != null) |
| { |
| foreach (XmlNode n in l) |
| { |
| nn = n.SelectSingleNode("geometry/location/lat"); |
| if (nn != null) |
| { |
| double lat = double.Parse(nn.InnerText, CultureInfo.InvariantCulture); |
| nn = n.SelectSingleNode("geometry/location/lng"); |
| if (nn != null) |
| { |
| double lng = double.Parse(nn.InnerText, CultureInfo.InvariantCulture); |
| pointList.Add(new PointLatLng(lat, lng)); |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| catch (Exception ex) |
| { |
| status = GeoCoderStatusCode.ExceptionInCode; |
| Debug.WriteLine("GetLatLngFromGeocoderUrl: " + ex); |
| } |
| return status; |
| } |
| GeoCoderStatusCode GetPlacemarkFromReverseGeocoderUrl(string url, out List<Placemark> placemarkList) |
| { |
| GeoCoderStatusCode status = GeoCoderStatusCode.Unknow; |
| placemarkList = null; |
| try |
| { |
| string reverse = GMaps.Instance.UsePlacemarkCache ? Cache.Instance.GetContent(url, CacheType.PlacemarkCache) : string.Empty; |
| bool cache = false; |
| if (string.IsNullOrEmpty(reverse)) |
| { |
| string urls = url; |
| // Must provide either API key or Maps for Work credentials. |
| if (!string.IsNullOrEmpty(ClientId)) |
| { |
| urls = GetSignedUri(url); |
| } |
| else if (!string.IsNullOrEmpty(ApiKey)) |
| { |
| urls += "&key=" + ApiKey; |
| } |
| reverse = GetContentUsingHttp(urls); |
| if (!string.IsNullOrEmpty(reverse)) |
| { |
| cache = true; |
| } |
| } |
| if (!string.IsNullOrEmpty(reverse)) |
| { |
| if (reverse.StartsWith("<?xml")) |
| { |
| #region -- xml response -- |
| //<?xml version="1.0" encoding="UTF-8"?> |
| //<GeocodeResponse> |
| // <status>OK</status> |
| // <result> |
| // <type>street_address</type> |
| // <formatted_address>Tuskul??n?? gatv?? 2, Vilnius 09213, Lithuania</formatted_address> |
| // <address_component> |
| // <long_name>2</long_name> |
| // <short_name>2</short_name> |
| // <type>street_number</type> |
| // </address_component> |
| // <address_component> |
| // <long_name>Tuskul??n?? gatv??</long_name> |
| // <short_name>Tuskul??n?? g.</short_name> |
| // <type>route</type> |
| // </address_component> |
| // <address_component> |
| // <long_name>Vilnius</long_name> |
| // <short_name>Vilnius</short_name> |
| // <type>locality</type> |
| // <type>political</type> |
| // </address_component> |
| // <address_component> |
| // <long_name>Vilniaus miesto savivaldyb??</long_name> |
| // <short_name>Vilniaus m. sav.</short_name> |
| // <type>administrative_area_level_2</type> |
| // <type>political</type> |
| // </address_component> |
| // <address_component> |
| // <long_name>Vilnius County</long_name> |
| // <short_name>Vilnius County</short_name> |
| // <type>administrative_area_level_1</type> |
| // <type>political</type> |
| // </address_component> |
| // <address_component> |
| // <long_name>Lithuania</long_name> |
| // <short_name>LT</short_name> |
| // <type>country</type> |
| // <type>political</type> |
| // </address_component> |
| // <address_component> |
| // <long_name>09213</long_name> |
| // <short_name>09213</short_name> |
| // <type>postal_code</type> |
| // </address_component> |
| // <geometry> |
| // <location> |
| // <lat>54.6963339</lat> |
| // <lng>25.2968939</lng> |
| // </location> |
| // <location_type>ROOFTOP</location_type> |
| // <viewport> |
| // <southwest> |
| // <lat>54.6949849</lat> |
| // <lng>25.2955449</lng> |
| // </southwest> |
| // <northeast> |
| // <lat>54.6976829</lat> |
| // <lng>25.2982429</lng> |
| // </northeast> |
| // </viewport> |
| // </geometry> |
| // </result> |
| // <result> |
| // <type>postal_code</type> |
| // <formatted_address>Vilnius 09213, Lithuania</formatted_address> |
| // <address_component> |
| // <long_name>09213</long_name> |
| // <short_name>09213</short_name> |
| // <type>postal_code</type> |
| // </address_component> |
| // <address_component> |
| // <long_name>Vilnius</long_name> |
| // <short_name>Vilnius</short_name> |
| // <type>locality</type> |
| // <type>political</type> |
| // </address_component> |
| // <address_component> |
| // <long_name>Vilniaus miesto savivaldyb??</long_name> |
| // <short_name>Vilniaus m. sav.</short_name> |
| // <type>administrative_area_level_2</type> |
| // <type>political</type> |
| // </address_component> |
| // <address_component> |
| // <long_name>Vilnius County</long_name> |
| // <short_name>Vilnius County</short_name> |
| // <type>administrative_area_level_1</type> |
| // <type>political</type> |
| // </address_component> |
| // <address_component> |
| // <long_name>Lithuania</long_name> |
| // <short_name>LT</short_name> |
| // <type>country</type> |
| // <type>political</type> |
| // </address_component> |
| // <geometry> |
| // <location> |
| // <lat>54.6963032</lat> |
| // <lng>25.2967390</lng> |
| // </location> |
| // <location_type>APPROXIMATE</location_type> |
| // <viewport> |
| // <southwest> |
| // <lat>54.6950889</lat> |
| // <lng>25.2958851</lng> |
| // </southwest> |
| // <northeast> |
| // <lat>54.6977869</lat> |
| // <lng>25.2985830</lng> |
| // </northeast> |
| // </viewport> |
| // <bounds> |
| // <southwest> |
| // <lat>54.6956179</lat> |
| // <lng>25.2958871</lng> |
| // </southwest> |
| // <northeast> |
| // <lat>54.6972579</lat> |
| // <lng>25.2985810</lng> |
| // </northeast> |
| // </bounds> |
| // </geometry> |
| // </result> |
| // <result> |
| // <type>neighborhood</type> |
| // <type>political</type> |
| // <formatted_address>??irm??nai, Vilnius, Lithuania</formatted_address> |
| // <address_component> |
| // <long_name>??irm??nai</long_name> |
| // <short_name>??irm??nai</short_name> |
| // <type>neighborhood</type> |
| // <type>political</type> |
| // </address_component> |
| // <address_component> |
| // <long_name>Vilnius</long_name> |
| // <short_name>Vilnius</short_name> |
| // <type>locality</type> |
| // <type>political</type> |
| // </address_component> |
| // <address_component> |
| // <long_name>Vilniaus miesto savivaldyb??</long_name> |
| // <short_name>Vilniaus m. sav.</short_name> |
| // <type>administrative_area_level_2</type> |
| // <type>political</type> |
| // </address_component> |
| // <address_component> |
| // <long_name>Vilnius County</long_name> |
| // <short_name>Vilnius County</short_name> |
| // <type>administrative_area_level_1</type> |
| // <type>political</type> |
| // </address_component> |
| // <address_component> |
| // <long_name>Lithuania</long_name> |
| // <short_name>LT</short_name> |
| // <type>country</type> |
| // <type>political</type> |
| // </address_component> |
| // <geometry> |
| // <location> |
| // <lat>54.7117424</lat> |
| // <lng>25.2974345</lng> |
| // </location> |
| // <location_type>APPROXIMATE</location_type> |
| // <viewport> |
| // <southwest> |
| // <lat>54.6888939</lat> |
| // <lng>25.2838700</lng> |
| // </southwest> |
| // <northeast> |
| // <lat>54.7304441</lat> |
| // <lng>25.3133630</lng> |
| // </northeast> |
| // </viewport> |
| // <bounds> |
| // <southwest> |
| // <lat>54.6888939</lat> |
| // <lng>25.2838700</lng> |
| // </southwest> |
| // <northeast> |
| // <lat>54.7304441</lat> |
| // <lng>25.3133630</lng> |
| // </northeast> |
| // </bounds> |
| // </geometry> |
| // </result> |
| // <result> |
| // <type>administrative_area_level_3</type> |
| // <type>political</type> |
| // <formatted_address>??irm??n?? seni??nija, Lithuania</formatted_address> |
| // <address_component> |
| // <long_name>??irm??n?? seni??nija</long_name> |
| // <short_name>??irm??n?? sen.</short_name> |
| // <type>administrative_area_level_3</type> |
| // <type>political</type> |
| // </address_component> |
| // <address_component> |
| // <long_name>Vilniaus miesto savivaldyb??</long_name> |
| // <short_name>Vilniaus m. sav.</short_name> |
| // <type>administrative_area_level_2</type> |
| // <type>political</type> |
| // </address_component> |
| // <address_component> |
| // <long_name>Vilnius County</long_name> |
| // <short_name>Vilnius County</short_name> |
| // <type>administrative_area_level_1</type> |
| // <type>political</type> |
| // </address_component> |
| // <address_component> |
| // <long_name>Lithuania</long_name> |
| // <short_name>LT</short_name> |
| // <type>country</type> |
| // <type>political</type> |
| // </address_component> |
| // <geometry> |
| // <location> |
| // <lat>54.7117424</lat> |
| // <lng>25.2974345</lng> |
| // </location> |
| // <location_type>APPROXIMATE</location_type> |
| // <viewport> |
| // <southwest> |
| // <lat>54.6892135</lat> |
| // <lng>25.2837150</lng> |
| // </southwest> |
| // <northeast> |
| // <lat>54.7305878</lat> |
| // <lng>25.3135630</lng> |
| // </northeast> |
| // </viewport> |
| // <bounds> |
| // <southwest> |
| // <lat>54.6892135</lat> |
| // <lng>25.2837150</lng> |
| // </southwest> |
| // <northeast> |
| // <lat>54.7305878</lat> |
| // <lng>25.3135630</lng> |
| // </northeast> |
| // </bounds> |
| // </geometry> |
| // </result> |
| // <result> |
| // <type>locality</type> |
| // <type>political</type> |
| // <formatted_address>Vilnius, Lithuania</formatted_address> |
| // <address_component> |
| // <long_name>Vilnius</long_name> |
| // <short_name>Vilnius</short_name> |
| // <type>locality</type> |
| // <type>political</type> |
| // </address_component> |
| // <address_component> |
| // <long_name>Vilniaus miesto savivaldyb??</long_name> |
| // <short_name>Vilniaus m. sav.</short_name> |
| // <type>administrative_area_level_2</type> |
| // <type>political</type> |
| // </address_component> |
| // <address_component> |
| // <long_name>Vilnius County</long_name> |
| // <short_name>Vilnius County</short_name> |
| // <type>administrative_area_level_1</type> |
| // <type>political</type> |
| // </address_component> |
| // <address_component> |
| // <long_name>Lithuania</long_name> |
| // <short_name>LT</short_name> |
| // <type>country</type> |
| // <type>political</type> |
| // </address_component> |
| // <geometry> |
| // <location> |
| // <lat>54.6871555</lat> |
| // <lng>25.2796514</lng> |
| // </location> |
| // <location_type>APPROXIMATE</location_type> |
| // <viewport> |
| // <southwest> |
| // <lat>54.5677980</lat> |
| // <lng>25.0243760</lng> |
| // </southwest> |
| // <northeast> |
| // <lat>54.8325440</lat> |
| // <lng>25.4814883</lng> |
| // </northeast> |
| // </viewport> |
| // <bounds> |
| // <southwest> |
| // <lat>54.5677980</lat> |
| // <lng>25.0243760</lng> |
| // </southwest> |
| // <northeast> |
| // <lat>54.8325440</lat> |
| // <lng>25.4814883</lng> |
| // </northeast> |
| // </bounds> |
| // </geometry> |
| // </result> |
| // <result> |
| // <type>administrative_area_level_2</type> |
| // <type>political</type> |
| // <formatted_address>Vilniaus miesto savivaldyb??, Lithuania</formatted_address> |
| // <address_component> |
| // <long_name>Vilniaus miesto savivaldyb??</long_name> |
| // <short_name>Vilniaus m. sav.</short_name> |
| // <type>administrative_area_level_2</type> |
| // <type>political</type> |
| // </address_component> |
| // <address_component> |
| // <long_name>Vilnius County</long_name> |
| // <short_name>Vilnius County</short_name> |
| // <type>administrative_area_level_1</type> |
| // <type>political</type> |
| // </address_component> |
| // <address_component> |
| // <long_name>Lithuania</long_name> |
| // <short_name>LT</short_name> |
| // <type>country</type> |
| // <type>political</type> |
| // </address_component> |
| // <geometry> |
| // <location> |
| // <lat>54.6759715</lat> |
| // <lng>25.2867413</lng> |
| // </location> |
| // <location_type>APPROXIMATE</location_type> |
| // <viewport> |
| // <southwest> |
| // <lat>54.5677980</lat> |
| // <lng>25.0243760</lng> |
| // </southwest> |
| // <northeast> |
| // <lat>54.8325440</lat> |
| // <lng>25.4814883</lng> |
| // </northeast> |
| // </viewport> |
| // <bounds> |
| // <southwest> |
| // <lat>54.5677980</lat> |
| // <lng>25.0243760</lng> |
| // </southwest> |
| // <northeast> |
| // <lat>54.8325440</lat> |
| // <lng>25.4814883</lng> |
| // </northeast> |
| // </bounds> |
| // </geometry> |
| // </result> |
| // <result> |
| // <type>administrative_area_level_1</type> |
| // <type>political</type> |
| // <formatted_address>Vilnius County, Lithuania</formatted_address> |
| // <address_component> |
| // <long_name>Vilnius County</long_name> |
| // <short_name>Vilnius County</short_name> |
| // <type>administrative_area_level_1</type> |
| // <type>political</type> |
| // </address_component> |
| // <address_component> |
| // <long_name>Lithuania</long_name> |
| // <short_name>LT</short_name> |
| // <type>country</type> |
| // <type>political</type> |
| // </address_component> |
| // <geometry> |
| // <location> |
| // <lat>54.8086502</lat> |
| // <lng>25.2182138</lng> |
| // </location> |
| // <location_type>APPROXIMATE</location_type> |
| // <viewport> |
| // <southwest> |
| // <lat>54.1276599</lat> |
| // <lng>24.3863751</lng> |
| // </southwest> |
| // <northeast> |
| // <lat>55.5174369</lat> |
| // <lng>26.7602130</lng> |
| // </northeast> |
| // </viewport> |
| // <bounds> |
| // <southwest> |
| // <lat>54.1276599</lat> |
| // <lng>24.3863751</lng> |
| // </southwest> |
| // <northeast> |
| // <lat>55.5174369</lat> |
| // <lng>26.7602130</lng> |
| // </northeast> |
| // </bounds> |
| // </geometry> |
| // </result> |
| // <result> |
| // <type>country</type> |
| // <type>political</type> |
| // <formatted_address>Lithuania</formatted_address> |
| // <address_component> |
| // <long_name>Lithuania</long_name> |
| // <short_name>LT</short_name> |
| // <type>country</type> |
| // <type>political</type> |
| // </address_component> |
| // <geometry> |
| // <location> |
| // <lat>55.1694380</lat> |
| // <lng>23.8812750</lng> |
| // </location> |
| // <location_type>APPROXIMATE</location_type> |
| // <viewport> |
| // <southwest> |
| // <lat>53.8968787</lat> |
| // <lng>20.9543679</lng> |
| // </southwest> |
| // <northeast> |
| // <lat>56.4503209</lat> |
| // <lng>26.8355913</lng> |
| // </northeast> |
| // </viewport> |
| // <bounds> |
| // <southwest> |
| // <lat>53.8968787</lat> |
| // <lng>20.9543679</lng> |
| // </southwest> |
| // <northeast> |
| // <lat>56.4503209</lat> |
| // <lng>26.8355913</lng> |
| // </northeast> |
| // </bounds> |
| // </geometry> |
| // </result> |
| //</GeocodeResponse> |
| #endregion |
| XmlDocument doc = new XmlDocument(); |
| doc.LoadXml(reverse); |
| XmlNode nn = doc.SelectSingleNode("//status"); |
| if (nn != null) |
| { |
| if (nn.InnerText != "OK") |
| { |
| Debug.WriteLine("GetPlacemarkFromReverseGeocoderUrl: " + nn.InnerText); |
| } |
| else |
| { |
| status = GeoCoderStatusCode.G_GEO_SUCCESS; |
| if (cache && GMaps.Instance.UsePlacemarkCache) |
| { |
| Cache.Instance.SaveContent(url, CacheType.PlacemarkCache, reverse); |
| } |
| placemarkList = new List<Placemark>(); |
| #region -- placemarks -- |
| XmlNodeList l = doc.SelectNodes("//result"); |
| if (l != null) |
| { |
| foreach (XmlNode n in l) |
| { |
| Debug.WriteLine("---------------------"); |
| nn = n.SelectSingleNode("formatted_address"); |
| if (nn != null) |
| { |
| var ret = new Placemark(nn.InnerText); |
| Debug.WriteLine("formatted_address: [" + nn.InnerText + "]"); |
| nn = n.SelectSingleNode("type"); |
| if (nn != null) |
| { |
| Debug.WriteLine("type: " + nn.InnerText); |
| } |
| // TODO: fill Placemark details |
| XmlNodeList acl = n.SelectNodes("address_component"); |
| foreach (XmlNode ac in acl) |
| { |
| nn = ac.SelectSingleNode("type"); |
| if (nn != null) |
| { |
| var type = nn.InnerText; |
| Debug.Write(" - [" + type + "], "); |
| nn = ac.SelectSingleNode("long_name"); |
| if (nn != null) |
| { |
| Debug.WriteLine("long_name: [" + nn.InnerText + "]"); |
| switch (type) |
| { |
| case "street_address": |
| { |
| ret.StreetNumber = nn.InnerText; |
| } |
| break; |
| case "route": |
| { |
| ret.ThoroughfareName = nn.InnerText; |
| } |
| break; |
| case "postal_code": |
| { |
| ret.PostalCodeNumber = nn.InnerText; |
| } |
| break; |
| case "country": |
| { |
| ret.CountryName = nn.InnerText; |
| } |
| break; |
| case "locality": |
| { |
| ret.LocalityName = nn.InnerText; |
| } |
| break; |
| case "administrative_area_level_2": |
| { |
| ret.DistrictName = nn.InnerText; |
| } |
| break; |
| case "administrative_area_level_1": |
| { |
| ret.AdministrativeAreaName = nn.InnerText; |
| } |
| break; |
| case "administrative_area_level_3": |
| { |
| ret.SubAdministrativeAreaName = nn.InnerText; |
| } |
| break; |
| case "neighborhood": |
| { |
| ret.Neighborhood = nn.InnerText; |
| } |
| break; |
| } |
| } |
| } |
| } |
| placemarkList.Add(ret); |
| } |
| } |
| } |
| #endregion |
| } |
| } |
| #endregion |
| } |
| } |
| } |
| catch (Exception ex) |
| { |
| status = GeoCoderStatusCode.ExceptionInCode; |
| placemarkList = null; |
| Debug.WriteLine("GetPlacemarkReverseGeocoderUrl: " + ex.ToString()); |
| } |
| return status; |
| } |
| static readonly string ReverseGeocoderUrlFormat = "http://maps.{0}/maps/api/geocode/xml?latlng={1},{2}&language={3}&sensor=false"; |
| static readonly string GeocoderUrlFormat = "http://maps.{0}/maps/api/geocode/xml?address={1}&language={2}&sensor=false"; |
| #endregion |
| #region DirectionsProvider Members |
| public DirectionsStatusCode GetDirections(out GDirections direction, PointLatLng start, PointLatLng end, bool avoidHighways, bool avoidTolls, bool walkingMode, bool sensor, bool metric) |
| { |
| return GetDirectionsUrl(MakeDirectionsUrl(start, end, LanguageStr, avoidHighways, avoidTolls, walkingMode, sensor, metric), out direction); |
| } |
| public DirectionsStatusCode GetDirections(out GDirections direction, string start, string end, bool avoidHighways, bool avoidTolls, bool walkingMode, bool sensor, bool metric) |
| { |
| return GetDirectionsUrl(MakeDirectionsUrl(start, end, LanguageStr, avoidHighways, avoidTolls, walkingMode, sensor, metric), out direction); |
| } |
| /// <summary> |
| /// NotImplemented |
| /// </summary> |
| /// <param name="status"></param> |
| /// <param name="start"></param> |
| /// <param name="end"></param> |
| /// <param name="avoidHighways"></param> |
| /// <param name="avoidTolls"></param> |
| /// <param name="walkingMode"></param> |
| /// <param name="sensor"></param> |
| /// <param name="metric"></param> |
| /// <returns></returns> |
| public IEnumerable<GDirections> GetDirections(out DirectionsStatusCode status, string start, string end, bool avoidHighways, bool avoidTolls, bool walkingMode, bool sensor, bool metric) |
| { |
| // TODO: add alternative directions |
| throw new NotImplementedException(); |
| } |
| /// <summary> |
| /// NotImplemented |
| /// </summary> |
| /// <param name="status"></param> |
| /// <param name="start"></param> |
| /// <param name="end"></param> |
| /// <param name="avoidHighways"></param> |
| /// <param name="avoidTolls"></param> |
| /// <param name="walkingMode"></param> |
| /// <param name="sensor"></param> |
| /// <param name="metric"></param> |
| /// <returns></returns> |
| public IEnumerable<GDirections> GetDirections(out DirectionsStatusCode status, PointLatLng start, PointLatLng end, bool avoidHighways, bool avoidTolls, bool walkingMode, bool sensor, bool metric) |
| { |
| // TODO: add alternative directions |
| throw new NotImplementedException(); |
| } |
| public DirectionsStatusCode GetDirections(out GDirections direction, PointLatLng start, IEnumerable<PointLatLng> wayPoints, PointLatLng end, bool avoidHighways, bool avoidTolls, bool walkingMode, bool sensor, bool metric) |
| { |
| return GetDirectionsUrl(MakeDirectionsUrl(start, wayPoints, end, LanguageStr, avoidHighways, avoidTolls, walkingMode, sensor, metric), out direction); |
| } |
| public DirectionsStatusCode GetDirections(out GDirections direction, string start, IEnumerable<string> wayPoints, string end, bool avoidHighways, bool avoidTolls, bool walkingMode, bool sensor, bool metric) |
| { |
| return GetDirectionsUrl(MakeDirectionsUrl(start, wayPoints, end, LanguageStr, avoidHighways, avoidTolls, walkingMode, sensor, metric), out direction); |
| } |
| #region -- internals -- |
| // The Coogle Directions API: http://tinyurl.com/6vv4cac |
| string MakeDirectionsUrl(PointLatLng start, PointLatLng end, string language, bool avoidHighways, bool avoidTolls, bool walkingMode, bool sensor, bool metric) |
| { |
| string av = (avoidHighways ? "&avoid=highways" : string.Empty) + (avoidTolls ? "&avoid=tolls" : string.Empty); // 6 |
| string mt = "&units=" + (metric ? "metric" : "imperial"); // 7 |
| string wk = "&mode=" + (walkingMode ? "walking" : "driving"); // 8 |
| return string.Format(CultureInfo.InvariantCulture, DirectionUrlFormatPoint, start.Lat, start.Lng, end.Lat, end.Lng, sensor.ToString().ToLower(), language, av, mt, wk, ServerAPIs); |
| } |
| string MakeDirectionsUrl(string start, string end, string language, bool avoidHighways, bool walkingMode, bool avoidTolls, bool sensor, bool metric) |
| { |
| string av = (avoidHighways ? "&avoid=highways" : string.Empty) + (avoidTolls ? "&avoid=tolls" : string.Empty); // 4 |
| string mt = "&units=" + (metric ? "metric" : "imperial"); // 5 |
| string wk = "&mode=" + (walkingMode ? "walking" : "driving"); // 6 |
| return string.Format(DirectionUrlFormatStr, start.Replace(' ', '+'), end.Replace(' ', '+'), sensor.ToString().ToLower(), language, av, mt, wk, ServerAPIs); |
| } |
| string MakeDirectionsUrl(PointLatLng start, IEnumerable<PointLatLng> wayPoints, PointLatLng end, string language, bool avoidHighways, bool avoidTolls, bool walkingMode, bool sensor, bool metric) |
| { |
| string av = (avoidHighways ? "&avoid=highways" : string.Empty) + (avoidTolls ? "&avoid=tolls" : string.Empty); // 6 |
| string mt = "&units=" + (metric ? "metric" : "imperial"); // 7 |
| string wk = "&mode=" + (walkingMode ? "walking" : "driving"); // 8 |
| string wpLatLng = string.Empty; |
| int i = 0; |
| foreach (var wp in wayPoints) |
| { |
| wpLatLng += string.Format(CultureInfo.InvariantCulture, i++ == 0 ? "{0},{1}" : "|{0},{1}", wp.Lat, wp.Lng); |
| } |
| return string.Format(CultureInfo.InvariantCulture, DirectionUrlFormatWaypoint, start.Lat, start.Lng, wpLatLng, sensor.ToString().ToLower(), language, av, mt, wk, ServerAPIs, end.Lat, end.Lng); |
| } |
| string MakeDirectionsUrl(string start, IEnumerable<string> wayPoints, string end, string language, bool avoidHighways, bool avoidTolls, bool walkingMode, bool sensor, bool metric) |
| { |
| string av = (avoidHighways ? "&avoid=highways" : string.Empty) + (avoidTolls ? "&avoid=tolls" : string.Empty); // 6 |
| string mt = "&units=" + (metric ? "metric" : "imperial"); // 7 |
| string wk = "&mode=" + (walkingMode ? "walking" : "driving"); // 8 |
| string wpLatLng = string.Empty; |
| int i = 0; |
| foreach (var wp in wayPoints) |
| { |
| wpLatLng += string.Format(CultureInfo.InvariantCulture, i++ == 0 ? "{0}" : "|{0}", wp.Replace(' ', '+')); |
| } |
| return string.Format(CultureInfo.InvariantCulture, DirectionUrlFormatWaypointStr, start.Replace(' ', '+'), wpLatLng, sensor.ToString().ToLower(), language, av, mt, wk, ServerAPIs, end.Replace(' ', '+')); |
| } |
| DirectionsStatusCode GetDirectionsUrl(string url, out GDirections direction) |
| { |
| DirectionsStatusCode ret = DirectionsStatusCode.UNKNOWN_ERROR; |
| direction = null; |
| try |
| { |
| string kml = GMaps.Instance.UseDirectionsCache ? Cache.Instance.GetContent(url, CacheType.DirectionsCache) : string.Empty; |
| bool cache = false; |
| if (string.IsNullOrEmpty(kml)) |
| { |
| string urls = url; |
| // Must provide either API key or Maps for Work credentials. |
| if (!string.IsNullOrEmpty(ClientId)) |
| { |
| urls = GetSignedUri(url); |
| } |
| else if (!string.IsNullOrEmpty(ApiKey)) |
| { |
| urls += "&key=" + ApiKey; |
| } |
| kml = GetContentUsingHttp(urls); |
| if (!string.IsNullOrEmpty(kml)) |
| { |
| cache = true; |
| } |
| } |
| if (!string.IsNullOrEmpty(kml)) |
| { |
| #region -- kml response -- |
| //<?xml version="1.0" encoding="UTF-8"?> |
| //<DirectionsResponse> |
| // <status>OK</status> |
| // <route> |
| // <summary>A1/E85</summary> |
| // <leg> |
| // <step> |
| // <travel_mode>DRIVING</travel_mode> |
| // <start_location> |
| // <lat>54.6893800</lat> |
| // <lng>25.2800500</lng> |
| // </start_location> |
| // <end_location> |
| // <lat>54.6907800</lat> |
| // <lng>25.2798000</lng> |
| // </end_location> |
| // <polyline> |
| // <points>soxlIiohyCYLkCJ}@Vs@?</points> |
| // </polyline> |
| // <duration> |
| // <value>32</value> |
| // <text>1 min</text> |
| // </duration> |
| // <html_instructions>Head <b>north</b> on <b>Vilniaus gatvė</b> toward <b>Tilto gatvė</b></html_instructions> |
| // <distance> |
| // <value>157</value> |
| // <text>0.2 km</text> |
| // </distance> |
| // </step> |
| // <step> |
| // <travel_mode>DRIVING</travel_mode> |
| // <start_location> |
| // <lat>54.6907800</lat> |
| // <lng>25.2798000</lng> |
| // </start_location> |
| // <end_location> |
| // <lat>54.6942500</lat> |
| // <lng>25.2621300</lng> |
| // </end_location> |
| // <polyline> |
| // <points>kxxlIwmhyCmApUF`@GvAYpD{@dGcCjIoIvOuAhDwAtEa@vBUnDAhB?~AThDRxAh@hBtAdC</points> |
| // </polyline> |
| // <duration> |
| // <value>133</value> |
| // <text>2 mins</text> |
| // </duration> |
| // <html_instructions>Turn <b>left</b> onto <b>A. Goštauto gatvė</b></html_instructions> |
| // <distance> |
| // <value>1326</value> |
| // <text>1.3 km</text> |
| // </distance> |
| // </step> |
| // <step> |
| // <travel_mode>DRIVING</travel_mode> |
| // <start_location> |
| // <lat>54.6942500</lat> |
| // <lng>25.2621300</lng> |
| // </start_location> |
| // <end_location> |
| // <lat>54.6681200</lat> |
| // <lng>25.2377500</lng> |
| // </end_location> |
| // <polyline> |
| // <points>anylIi_eyC`AwD~@oBLKr@K`U|FdF|@`J^~E[j@Lh@\hB~Bn@tBZhBLrC?zIJ~DzA~OVrELlG^lDdAtDh@hAfApA`EzCvAp@jUpIpAl@bBpAdBpBxA|BdLpV`BxClAbBhBlBbChBpBhAdAXjBHlE_@t@?|@Lt@X</points> |
| // </polyline> |
| // <duration> |
| // <value>277</value> |
| // <text>5 mins</text> |
| // </duration> |
| // <html_instructions>Turn <b>left</b> to merge onto <b>Geležinio Vilko gatvė</b></html_instructions> |
| // <distance> |
| // <value>3806</value> |
| // <text>3.8 km</text> |
| // </distance> |
| // </step> |
| // <step> |
| // <travel_mode>DRIVING</travel_mode> |
| // <start_location> |
| // <lat>54.6681200</lat> |
| // <lng>25.2377500</lng> |
| // </start_location> |
| // <end_location> |
| // <lat>54.6584100</lat> |
| // <lng>25.1411300</lng> |
| // </end_location> |
| // <polyline> |
| // <points>wjtlI}f`yC~FhBlFr@jD|A~EbC~VjNxBbBdA`BnvA|zCba@l`Bt@tDTbBJpBBfBMvDaAzF}bBjiF{HnXiHxZ</points> |
| // </polyline> |
| // <duration> |
| // <value>539</value> |
| // <text>9 mins</text> |
| // </duration> |
| // <html_instructions>Continue onto <b>Savanorių prospektas</b></html_instructions> |
| // <distance> |
| // <value>8465</value> |
| // <text>8.5 km</text> |
| // </distance> |
| // </step> |
| // <step> |
| // <travel_mode>DRIVING</travel_mode> |
| // <start_location> |
| // <lat>54.6584100</lat> |
| // <lng>25.1411300</lng> |
| // </start_location> |
| // <end_location> |
| // <lat>54.9358200</lat> |
| // <lng>23.9260000</lng> |
| // </end_location> |
| // <polyline> |
| // <points>anrlIakmxCiq@|qCuBbLcK~n@wUrkAcPnw@gCnPoQt}AoB`MuAdHmAdFoCtJqClImBxE{DrIkQ|ZcEvIkDzIcDhKyBxJ{EdXuCtS_G`g@mF|\eF`WyDhOiE~NiErMaGpOoj@ppAoE|K_EzKeDtKkEnOsLnd@mDzLgI~U{FrNsEvJoEtI_FpI{J`O_EjFooBf_C{GdJ_FjIsH`OoFhMwH`UcDtL{CzMeDlQmAzHuU~bBiArIwApNaBfWaLfiCoBpYsDf\qChR_FlVqEpQ_ZbfA}CfN{A~HwCtRiAfKmBlVwBx[gBfRcBxMaLdp@sXrzAaE~UqCzRyC`[_q@z|LgC|e@m@vNqp@b}WuLraFo@jPaS~bDmJryAeo@v|G}CnWsm@~`EoKvo@kv@lkEkqBrlKwBvLkNj|@cu@`~EgCnNuiBpcJakAx|GyB`KqdC~fKoIfYicAxtCiDrLu@hDyBjQm@xKoGdxBmQhoGuUn|Dc@nJ[`OW|VaEn|Ee@`X</points> |
| // </polyline> |
| // <duration> |
| // <value>3506</value> |
| // <text>58 mins</text> |
| // </duration> |
| // <html_instructions>Continue onto <b>A1/E85</b></html_instructions> |
| // <distance> |
| // <value>85824</value> |
| // <text>85.8 km</text> |
| // </distance> |
| // </step> |
| // <step> |
| // <travel_mode>DRIVING</travel_mode> |
| // <start_location> |
| // <lat>54.9358200</lat> |
| // <lng>23.9260000</lng> |
| // </start_location> |
| // <end_location> |
| // <lat>54.9376500</lat> |
| // <lng>23.9195600</lng> |
| // </end_location> |
| // <polyline> |
| // <points>{shnIo``qCQ^MnD[lBgA`DqBdEu@xB}@zJCjB</points> |
| // </polyline> |
| // <duration> |
| // <value>39</value> |
| // <text>1 min</text> |
| // </duration> |
| // <html_instructions>Take the exit toward <b>Senamiestis/Aleksotas</b></html_instructions> |
| // <distance> |
| // <value>476</value> |
| // <text>0.5 km</text> |
| // </distance> |
| // </step> |
| // <step> |
| // <travel_mode>DRIVING</travel_mode> |
| // <start_location> |
| // <lat>54.9376500</lat> |
| // <lng>23.9195600</lng> |
| // </start_location> |
| // <end_location> |
| // <lat>54.9361300</lat> |
| // <lng>23.9189700</lng> |
| // </end_location> |
| // <polyline> |
| // <points>i_inIgx~pCnHtB</points> |
| // </polyline> |
| // <duration> |
| // <value>28</value> |
| // <text>1 min</text> |
| // </duration> |
| // <html_instructions>Turn <b>left</b> onto <b>Kleboniškio gatvė</b></html_instructions> |
| // <distance> |
| // <value>173</value> |
| // <text>0.2 km</text> |
| // </distance> |
| // </step> |
| // <step> |
| // <travel_mode>DRIVING</travel_mode> |
| // <start_location> |
| // <lat>54.9361300</lat> |
| // <lng>23.9189700</lng> |
| // </start_location> |
| // <end_location> |
| // <lat>54.9018900</lat> |
| // <lng>23.8937000</lng> |
| // </end_location> |
| // <polyline> |
| // <points>yuhnIqt~pCvAb@JLrOvExSdHvDdAv`@pIpHnAdl@hLdB`@nDvAtEjDdCvCjLzOvAzBhC`GpHfRbQd^`JpMPt@ClA</points> |
| // </polyline> |
| // <duration> |
| // <value>412</value> |
| // <text>7 mins</text> |
| // </duration> |
| // <html_instructions>Continue onto <b>Jonavos gatvė</b></html_instructions> |
| // <distance> |
| // <value>4302</value> |
| // <text>4.3 km</text> |
| // </distance> |
| // </step> |
| // <step> |
| // <travel_mode>DRIVING</travel_mode> |
| // <start_location> |
| // <lat>54.9018900</lat> |
| // <lng>23.8937000</lng> |
| // </start_location> |
| // <end_location> |
| // <lat>54.8985600</lat> |
| // <lng>23.8933400</lng> |
| // </end_location> |
| // <polyline> |
| // <points>y_bnIsvypCMf@FnARlAf@zAl@^v@EZ_@pAe@x@k@xBPpA@pAQNSf@oB</points> |
| // </polyline> |
| // <duration> |
| // <value>69</value> |
| // <text>1 min</text> |
| // </duration> |
| // <html_instructions>At the roundabout, take the <b>3rd</b> exit and stay on <b>Jonavos gatvė</b></html_instructions> |
| // <distance> |
| // <value>478</value> |
| // <text>0.5 km</text> |
| // </distance> |
| // </step> |
| // <step> |
| // <travel_mode>DRIVING</travel_mode> |
| // <start_location> |
| // <lat>54.8985600</lat> |
| // <lng>23.8933400</lng> |
| // </start_location> |
| // <end_location> |
| // <lat>54.8968500</lat> |
| // <lng>23.8930000</lng> |
| // </end_location> |
| // <polyline> |
| // <points>_kanIktypCbEx@pCH</points> |
| // </polyline> |
| // <duration> |
| // <value>38</value> |
| // <text>1 min</text> |
| // </duration> |
| // <html_instructions>Turn <b>right</b> onto <b>A. Mapu gatvė</b><div style="font-size:0.9em">Destination will be on the right</div></html_instructions> |
| // <distance> |
| // <value>192</value> |
| // <text>0.2 km</text> |
| // </distance> |
| // </step> |
| // <duration> |
| // <value>5073</value> |
| // <text>1 hour 25 mins</text> |
| // </duration> |
| // <distance> |
| // <value>105199</value> |
| // <text>105 km</text> |
| // </distance> |
| // <start_location> |
| // <lat>54.6893800</lat> |
| // <lng>25.2800500</lng> |
| // </start_location> |
| // <end_location> |
| // <lat>54.8968500</lat> |
| // <lng>23.8930000</lng> |
| // </end_location> |
| // <start_address>Vilnius, Lithuania</start_address> |
| // <end_address>Kaunas, Lithuania</end_address> |
| // </leg> |
| // <copyrights>Map data ©2011 Tele Atlas</copyrights> |
| // <overview_polyline> |
| // <points>soxlIiohyCYL}Fb@mApUF`@GvAYpD{@dGcCjIoIvOwBpFy@xC]jBSxCC~E^~Er@lCtAdC`AwD~@oB`AW`U|FdF|@`J^~E[tAj@hB~BjA~ELrCJzOzA~Od@`N^lDdAtDt@xAjAnApDlCbXbKpAl@bBpAdBpBxA|BdLpV`BxCvDpEbChBpBhAdAXjBHbG_@|@LtHbClFr@jK`F~VjNxBbB`@h@rwAt|Cba@l`BjAxGNxEMvDaAzF}bBjiFcFbQ_y@|gD{CxMeBnJcK~n@wh@dkCkAlIoQt}AeEfV}EzQqClImBxE{DrIkQ|ZcEvIkDzIcDhKyBxJ{EdXuCtS_G`g@mF|\eF`WyDhOiE~NiErMaGpOoj@ppAoE|K_EzKeDtKmXzbAgI~U{FrNsEvJoLfT{J`O_EjFooBf_C{GdJkLtSwI`SyClI}CrJcDtL{CzMeDlQcXzlBiArIwApNaBfWaLfiCoBpYsDf\qChR_FlVqEpQ_ZbfAyFfXwCtRiAfKeFfs@gBfRcBxMaLdp@sXrzAaE~UqCzRyC`[_q@z|LuDtu@qp@b}WuLraFo@jPo^r}Faq@pfHaBtMsm@~`EoKvo@kv@lkEcuBjzKkNj|@cu@`~EgCnNuiBpcJakAx|GyB`KqdC~fKoIfYidAbwCoD|MeAbHcA|Im@xK}YnhKyV~gEs@~f@aEn|Ee@`XQ^MnD[lBoF`N}@zJCjBfKxCJLdj@bQv`@pIpHnAdl@hLdB`@nDvAtEjDdCvCbOvSzLhZbQd^`JpMPt@QtBFnAz@hDl@^j@?f@e@pAe@x@k@xBPfCEf@Uj@wBbEx@pCH</points> |
| // </overview_polyline> |
| // <bounds> |
| // <southwest> |
| // <lat>54.6389500</lat> |
| // <lng>23.8920900</lng> |
| // </southwest> |
| // <northeast> |
| // <lat>54.9376500</lat> |
| // <lng>25.2800500</lng> |
| // </northeast> |
| // </bounds> |
| // </route> |
| //</DirectionsResponse> |
| #endregion |
| XmlDocument doc = new XmlDocument(); |
| doc.LoadXml(kml); |
| XmlNode nn = doc.SelectSingleNode("/DirectionsResponse/status"); |
| if (nn != null) |
| { |
| ret = (DirectionsStatusCode)Enum.Parse(typeof(DirectionsStatusCode), nn.InnerText, false); |
| if (ret == DirectionsStatusCode.OK) |
| { |
| if (cache && GMaps.Instance.UseDirectionsCache) |
| { |
| Cache.Instance.SaveContent(url, CacheType.DirectionsCache, kml); |
| } |
| direction = new GDirections(); |
| nn = doc.SelectSingleNode("/DirectionsResponse/route/summary"); |
| if (nn != null) |
| { |
| direction.Summary = nn.InnerText; |
| Debug.WriteLine("summary: " + direction.Summary); |
| } |
| nn = doc.SelectSingleNode("/DirectionsResponse/route/leg/duration"); |
| if (nn != null) |
| { |
| var t = nn.SelectSingleNode("text"); |
| if (t != null) |
| { |
| direction.Duration = t.InnerText; |
| Debug.WriteLine("duration: " + direction.Duration); |
| } |
| t = nn.SelectSingleNode("value"); |
| if (t != null) |
| { |
| if (!string.IsNullOrEmpty(t.InnerText)) |
| { |
| direction.DurationValue = uint.Parse(t.InnerText); |
| Debug.WriteLine("value: " + direction.DurationValue); |
| } |
| } |
| } |
| nn = doc.SelectSingleNode("/DirectionsResponse/route/leg/distance"); |
| if (nn != null) |
| { |
| var t = nn.SelectSingleNode("text"); |
| if (t != null) |
| { |
| direction.Distance = t.InnerText; |
| Debug.WriteLine("distance: " + direction.Distance); |
| } |
| t = nn.SelectSingleNode("value"); |
| if (t != null) |
| { |
| if (!string.IsNullOrEmpty(t.InnerText)) |
| { |
| direction.DistanceValue = uint.Parse(t.InnerText); |
| Debug.WriteLine("value: " + direction.DistanceValue); |
| } |
| } |
| } |
| nn = doc.SelectSingleNode("/DirectionsResponse/route/leg/start_location"); |
| if (nn != null) |
| { |
| var pt = nn.SelectSingleNode("lat"); |
| if (pt != null) |
| { |
| direction.StartLocation.Lat = double.Parse(pt.InnerText, CultureInfo.InvariantCulture); |
| } |
| pt = nn.SelectSingleNode("lng"); |
| if (pt != null) |
| { |
| direction.StartLocation.Lng = double.Parse(pt.InnerText, CultureInfo.InvariantCulture); |
| } |
| } |
| nn = doc.SelectSingleNode("/DirectionsResponse/route/leg/end_location"); |
| if (nn != null) |
| { |
| var pt = nn.SelectSingleNode("lat"); |
| if (pt != null) |
| { |
| direction.EndLocation.Lat = double.Parse(pt.InnerText, CultureInfo.InvariantCulture); |
| } |
| pt = nn.SelectSingleNode("lng"); |
| if (pt != null) |
| { |
| direction.EndLocation.Lng = double.Parse(pt.InnerText, CultureInfo.InvariantCulture); |
| } |
| } |
| nn = doc.SelectSingleNode("/DirectionsResponse/route/leg/start_address"); |
| if (nn != null) |
| { |
| direction.StartAddress = nn.InnerText; |
| Debug.WriteLine("start_address: " + direction.StartAddress); |
| } |
| nn = doc.SelectSingleNode("/DirectionsResponse/route/leg/end_address"); |
| if (nn != null) |
| { |
| direction.EndAddress = nn.InnerText; |
| Debug.WriteLine("end_address: " + direction.EndAddress); |
| } |
| nn = doc.SelectSingleNode("/DirectionsResponse/route/copyrights"); |
| if (nn != null) |
| { |
| direction.Copyrights = nn.InnerText; |
| Debug.WriteLine("copyrights: " + direction.Copyrights); |
| } |
| nn = doc.SelectSingleNode("/DirectionsResponse/route/overview_polyline/points"); |
| if (nn != null) |
| { |
| direction.Route = new List<PointLatLng>(); |
| DecodePointsInto(direction.Route, nn.InnerText); |
| } |
| XmlNodeList steps = doc.SelectNodes("/DirectionsResponse/route/leg/step"); |
| if (steps != null) |
| { |
| if (steps.Count > 0) |
| { |
| direction.Steps = new List<GDirectionStep>(); |
| } |
| foreach (XmlNode s in steps) |
| { |
| GDirectionStep step = new GDirectionStep(); |
| Debug.WriteLine("----------------------"); |
| nn = s.SelectSingleNode("travel_mode"); |
| if (nn != null) |
| { |
| step.TravelMode = nn.InnerText; |
| Debug.WriteLine("travel_mode: " + step.TravelMode); |
| } |
| nn = s.SelectSingleNode("start_location"); |
| if (nn != null) |
| { |
| var pt = nn.SelectSingleNode("lat"); |
| if (pt != null) |
| { |
| step.StartLocation.Lat = double.Parse(pt.InnerText, CultureInfo.InvariantCulture); |
| } |
| pt = nn.SelectSingleNode("lng"); |
| if (pt != null) |
| { |
| step.StartLocation.Lng = double.Parse(pt.InnerText, CultureInfo.InvariantCulture); |
| } |
| } |
| nn = s.SelectSingleNode("end_location"); |
| if (nn != null) |
| { |
| var pt = nn.SelectSingleNode("lat"); |
| if (pt != null) |
| { |
| step.EndLocation.Lat = double.Parse(pt.InnerText, CultureInfo.InvariantCulture); |
| } |
| pt = nn.SelectSingleNode("lng"); |
| if (pt != null) |
| { |
| step.EndLocation.Lng = double.Parse(pt.InnerText, CultureInfo.InvariantCulture); |
| } |
| } |
| nn = s.SelectSingleNode("duration"); |
| if (nn != null) |
| { |
| nn = nn.SelectSingleNode("text"); |
| if (nn != null) |
| { |
| step.Duration = nn.InnerText; |
| Debug.WriteLine("duration: " + step.Duration); |
| } |
| } |
| nn = s.SelectSingleNode("distance"); |
| if (nn != null) |
| { |
| nn = nn.SelectSingleNode("text"); |
| if (nn != null) |
| { |
| step.Distance = nn.InnerText; |
| Debug.WriteLine("distance: " + step.Distance); |
| } |
| } |
| nn = s.SelectSingleNode("html_instructions"); |
| if (nn != null) |
| { |
| step.HtmlInstructions = nn.InnerText; |
| Debug.WriteLine("html_instructions: " + step.HtmlInstructions); |
| } |
| nn = s.SelectSingleNode("polyline"); |
| if (nn != null) |
| { |
| nn = nn.SelectSingleNode("points"); |
| if (nn != null) |
| { |
| step.Points = new List<PointLatLng>(); |
| DecodePointsInto(step.Points, nn.InnerText); |
| } |
| } |
| direction.Steps.Add(step); |
| } |
| } |
| } |
| } |
| } |
| } |
| catch (Exception ex) |
| { |
| direction = null; |
| ret = DirectionsStatusCode.ExceptionInCode; |
| Debug.WriteLine("GetDirectionsUrl: " + ex); |
| } |
| return ret; |
| } |
| static void DecodePointsInto(List<PointLatLng> path, string encodedPath) |
| { |
| // https://github.com/googlemaps/google-maps-services-java/blob/master/src/main/java/com/google/maps/internal/PolylineEncoding.java |
| int len = encodedPath.Length; |
| int index = 0; |
| int lat = 0; |
| int lng = 0; |
| while (index < len) |
| { |
| int result = 1; |
| int shift = 0; |
| int b; |
| do |
| { |
| b = encodedPath[index++] - 63 - 1; |
| result += b << shift; |
| shift += 5; |
| } while (b >= 0x1f && index < len); |
| lat += (result & 1) != 0 ? ~(result >> 1) : (result >> 1); |
| result = 1; |
| shift = 0; |
| if (index < len) |
| { |
| do |
| { |
| b = encodedPath[index++] - 63 - 1; |
| result += b << shift; |
| shift += 5; |
| } while (b >= 0x1f && index < len); |
| lng += (result & 1) != 0 ? ~(result >> 1) : (result >> 1); |
| } |
| path.Add(new PointLatLng(lat * 1e-5, lng * 1e-5)); |
| } |
| } |
| static readonly string DirectionUrlFormatStr = "http://maps.{7}/maps/api/directions/xml?origin={0}&destination={1}&sensor={2}&language={3}{4}{5}{6}"; |
| static readonly string DirectionUrlFormatPoint = "http://maps.{9}/maps/api/directions/xml?origin={0},{1}&destination={2},{3}&sensor={4}&language={5}{6}{7}{8}"; |
| static readonly string DirectionUrlFormatWaypoint = "http://maps.{8}/maps/api/directions/xml?origin={0},{1}&waypoints={2}&destination={9},{10}&sensor={3}&language={4}{5}{6}{7}"; |
| static readonly string DirectionUrlFormatWaypointStr = "http://maps.{7}/maps/api/directions/xml?origin={0}&waypoints={1}&destination={8}&sensor={2}&language={3}{4}{5}{6}"; |
| #endregion |
| #endregion |
| #region -- Maps API for Work -- |
| /// <summary> |
| /// https://developers.google.com/maps/documentation/business/webservices/auth#how_do_i_get_my_signing_key |
| /// To access the special features of the Google Maps API for Work you must provide a client ID |
| /// when accessing any of the API libraries or services. |
| /// When registering for Google Google Maps API for Work you will receive this client ID from Enterprise Support. |
| /// All client IDs begin with a gme- prefix. Your client ID is passed as the value of the client parameter. |
| /// Generally, you should store your private key someplace safe and read them into your code |
| /// </summary> |
| /// <param name="clientId"></param> |
| /// <param name="privateKey"></param> |
| public void SetEnterpriseCredentials(string clientId, string privateKey) |
| { |
| privateKey = privateKey.Replace("-", "+").Replace("_", "/"); |
| _privateKeyBytes = Convert.FromBase64String(privateKey); |
| _clientId = clientId; |
| } |
| private byte[] _privateKeyBytes; |
| private string _clientId = string.Empty; |
| /// <summary> |
| /// Your client ID. To access the special features of the Google Maps API for Work |
| /// you must provide a client ID when accessing any of the API libraries or services. |
| /// When registering for Google Google Maps API for Work you will receive this client ID |
| /// from Enterprise Support. All client IDs begin with a gme- prefix. |
| /// </summary> |
| public string ClientId |
| { |
| get |
| { |
| return _clientId; |
| } |
| } |
| string GetSignedUri(Uri uri) |
| { |
| var builder = new UriBuilder(uri); |
| builder.Query = builder.Query.Substring(1) + "&client=" + _clientId; |
| uri = builder.Uri; |
| string signature = GetSignature(uri); |
| return uri.Scheme + "://" + uri.Host + uri.LocalPath + uri.Query + "&signature=" + signature; |
| } |
| string GetSignedUri(string url) |
| { |
| return GetSignedUri(new Uri(url)); |
| } |
| string GetSignature(Uri uri) |
| { |
| byte[] encodedPathQuery = Encoding.ASCII.GetBytes(uri.LocalPath + uri.Query); |
| var hashAlgorithm = new HMACSHA1(_privateKeyBytes); |
| byte[] hashed = hashAlgorithm.ComputeHash(encodedPathQuery); |
| return Convert.ToBase64String(hashed).Replace("+", "-").Replace("/", "_"); |
| } |
| #endregion |
| } |
| /// <summary> |
| /// GoogleMap provider |
| /// </summary> |
| public class GoogleMapProvider : GoogleMapProviderBase |
| { |
| public static readonly GoogleMapProvider Instance; |
| GoogleMapProvider() |
| { |
| } |
| static GoogleMapProvider() |
| { |
| Instance = new GoogleMapProvider(); |
| } |
| public string Version = "m@365000000"; //"m@333000000"; |
| #region GMapProvider Members |
| readonly Guid id = new Guid("D7287DA0-A7FF-405F-8166-B6BAF26D066C"); |
| public override Guid Id |
| { |
| get |
| { |
| return id; |
| } |
| } |
| readonly string name = "GoogleMap"; |
| public override string Name |
| { |
| get |
| { |
| return name; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| string url = MakeTileImageUrl(pos, zoom, LanguageStr); |
| return GetTileImageUsingHttp(url); |
| } |
| #endregion |
| string MakeTileImageUrl(GPoint pos, int zoom, string language) |
| { |
| string sec1 = string.Empty; // after &x=... |
| string sec2 = string.Empty; // after &zoom=... |
| GetSecureWords(pos, out sec1, out sec2); |
| return string.Format(UrlFormat, UrlFormatServer, GetServerNum(pos, 4), UrlFormatRequest, Version, language, pos.X, sec1, pos.Y, zoom, sec2, Server); |
| } |
| static readonly string UrlFormatServer = "mt"; |
| static readonly string UrlFormatRequest = "vt"; |
| static readonly string UrlFormat = "http://{0}{1}.{10}/maps/{2}/lyrs={3}&hl={4}&x={5}{6}&y={7}&z={8}&s={9}"; |
| } |
| } |
| /MKLiveView/v1.0/GMap.NET.Core/GMap.NET.MapProviders/Google/GoogleSatelliteMapProvider.cs |
|---|
| 0,0 → 1,66 |
| |
| namespace GMap.NET.MapProviders |
| { |
| using System; |
| /// <summary> |
| /// GoogleSatelliteMap provider |
| /// </summary> |
| public class GoogleSatelliteMapProvider : GoogleMapProviderBase |
| { |
| public static readonly GoogleSatelliteMapProvider Instance; |
| GoogleSatelliteMapProvider() |
| { |
| } |
| static GoogleSatelliteMapProvider() |
| { |
| Instance = new GoogleSatelliteMapProvider(); |
| } |
| public string Version = "701";//"192"; |
| #region GMapProvider Members |
| readonly Guid id = new Guid("9CB89D76-67E9-47CF-8137-B9EE9FC46388"); |
| public override Guid Id |
| { |
| get |
| { |
| return id; |
| } |
| } |
| readonly string name = "GoogleSatelliteMap"; |
| public override string Name |
| { |
| get |
| { |
| return name; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| string url = MakeTileImageUrl(pos, zoom, LanguageStr); |
| return GetTileImageUsingHttp(url); |
| } |
| #endregion |
| string MakeTileImageUrl(GPoint pos, int zoom, string language) |
| { |
| string sec1 = string.Empty; // after &x=... |
| string sec2 = string.Empty; // after &zoom=... |
| GetSecureWords(pos, out sec1, out sec2); |
| return string.Format(UrlFormat, UrlFormatServer, GetServerNum(pos, 4), UrlFormatRequest, Version, language, pos.X, sec1, pos.Y, zoom, sec2, Server); |
| } |
| static readonly string UrlFormatServer = "khm"; |
| static readonly string UrlFormatRequest = "kh"; |
| static readonly string UrlFormat = "http://{0}{1}.{10}/{2}/v={3}&hl={4}&x={5}{6}&y={7}&z={8}&s={9}"; |
| } |
| } |
| /MKLiveView/v1.0/GMap.NET.Core/GMap.NET.MapProviders/Google/GoogleTerrainMapProvider.cs |
|---|
| 0,0 → 1,66 |
| |
| namespace GMap.NET.MapProviders |
| { |
| using System; |
| /// <summary> |
| /// GoogleTerrainMap provider |
| /// </summary> |
| public class GoogleTerrainMapProvider : GoogleMapProviderBase |
| { |
| public static readonly GoogleTerrainMapProvider Instance; |
| GoogleTerrainMapProvider() |
| { |
| } |
| static GoogleTerrainMapProvider() |
| { |
| Instance = new GoogleTerrainMapProvider(); |
| } |
| public string Version = "t@365,r@365000000"; // "t@132,r@333000000"; |
| #region GMapProvider Members |
| readonly Guid id = new Guid("A42EDF2E-63C5-4967-9DBF-4EFB3AF7BC11"); |
| public override Guid Id |
| { |
| get |
| { |
| return id; |
| } |
| } |
| readonly string name = "GoogleTerrainMap"; |
| public override string Name |
| { |
| get |
| { |
| return name; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| string url = MakeTileImageUrl(pos, zoom, LanguageStr); |
| return GetTileImageUsingHttp(url); |
| } |
| #endregion |
| string MakeTileImageUrl(GPoint pos, int zoom, string language) |
| { |
| string sec1 = string.Empty; // after &x=... |
| string sec2 = string.Empty; // after &zoom=... |
| GetSecureWords(pos, out sec1, out sec2); |
| return string.Format(UrlFormat, UrlFormatServer, GetServerNum(pos, 4), UrlFormatRequest, Version, language, pos.X, sec1, pos.Y, zoom, sec2, Server); |
| } |
| static readonly string UrlFormatServer = "mt"; |
| static readonly string UrlFormatRequest = "vt"; |
| static readonly string UrlFormat = "http://{0}{1}.{10}/maps/{2}/lyrs={3}&hl={4}&x={5}{6}&y={7}&z={8}&s={9}"; |
| } |
| } |
| /MKLiveView/v1.0/GMap.NET.Core/GMap.NET.MapProviders/Google/Korea/GoogleKoreaHybridMapProvider.cs |
|---|
| 0,0 → 1,79 |
| |
| namespace GMap.NET.MapProviders |
| { |
| using System; |
| /// <summary> |
| /// GoogleKoreaHybridMap provider |
| /// </summary> |
| public class GoogleKoreaHybridMapProvider : GoogleMapProviderBase |
| { |
| public static readonly GoogleKoreaHybridMapProvider Instance; |
| GoogleKoreaHybridMapProvider() |
| { |
| } |
| static GoogleKoreaHybridMapProvider() |
| { |
| Instance = new GoogleKoreaHybridMapProvider(); |
| } |
| public string Version = "kr1t.12"; |
| #region GMapProvider Members |
| readonly Guid id = new Guid("41A91842-04BC-442B-9AC8-042156238A5B"); |
| public override Guid Id |
| { |
| get |
| { |
| return id; |
| } |
| } |
| readonly string name = "GoogleKoreaHybridMap"; |
| public override string Name |
| { |
| get |
| { |
| return name; |
| } |
| } |
| GMapProvider[] overlays; |
| public override GMapProvider[] Overlays |
| { |
| get |
| { |
| if(overlays == null) |
| { |
| overlays = new GMapProvider[] { GoogleKoreaSatelliteMapProvider.Instance, this }; |
| } |
| return overlays; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| string url = MakeTileImageUrl(pos, zoom, LanguageStr); |
| return GetTileImageUsingHttp(url); |
| } |
| #endregion |
| string MakeTileImageUrl(GPoint pos, int zoom, string language) |
| { |
| string sec1 = string.Empty; |
| string sec2 = string.Empty; |
| GetSecureWords(pos, out sec1, out sec2); |
| return string.Format(UrlFormat, UrlFormatServer, GetServerNum(pos, 4), UrlFormatRequest, Version, language, pos.X, sec1, pos.Y, zoom, sec2, ServerKorea); |
| } |
| static readonly string UrlFormatServer = "mt"; |
| static readonly string UrlFormatRequest = "mt"; |
| static readonly string UrlFormat = "http://{0}{1}.{10}/{2}/v={3}&hl={4}&x={5}{6}&y={7}&z={8}&s={9}"; |
| } |
| } |
| /MKLiveView/v1.0/GMap.NET.Core/GMap.NET.MapProviders/Google/Korea/GoogleKoreaMapProvider.cs |
|---|
| 0,0 → 1,67 |
| |
| namespace GMap.NET.MapProviders |
| { |
| using System; |
| /// <summary> |
| /// GoogleKoreaMap provider |
| /// </summary> |
| public class GoogleKoreaMapProvider : GoogleMapProviderBase |
| { |
| public static readonly GoogleKoreaMapProvider Instance; |
| GoogleKoreaMapProvider() |
| { |
| Area = new RectLatLng(38.6597777307125, 125.738525390625, 4.02099609375, 4.42072406219614); |
| } |
| static GoogleKoreaMapProvider() |
| { |
| Instance = new GoogleKoreaMapProvider(); |
| } |
| public string Version = "kr1.12"; |
| #region GMapProvider Members |
| readonly Guid id = new Guid("0079D360-CB1B-4986-93D5-AD299C8E20E6"); |
| public override Guid Id |
| { |
| get |
| { |
| return id; |
| } |
| } |
| readonly string name = "GoogleKoreaMap"; |
| public override string Name |
| { |
| get |
| { |
| return name; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| string url = MakeTileImageUrl(pos, zoom, LanguageStr); |
| return GetTileImageUsingHttp(url); |
| } |
| #endregion |
| string MakeTileImageUrl(GPoint pos, int zoom, string language) |
| { |
| string sec1 = string.Empty; |
| string sec2 = string.Empty; |
| GetSecureWords(pos, out sec1, out sec2); |
| return string.Format(UrlFormat, UrlFormatServer, GetServerNum(pos, 4), UrlFormatRequest, Version, language, pos.X, sec1, pos.Y, zoom, sec2, ServerKorea); |
| } |
| static readonly string UrlFormatServer = "mt"; |
| static readonly string UrlFormatRequest = "mt"; |
| static readonly string UrlFormat = "http://{0}{1}.{10}/{2}/v={3}&hl={4}&x={5}{6}&y={7}&z={8}&s={9}"; |
| } |
| } |
| /MKLiveView/v1.0/GMap.NET.Core/GMap.NET.MapProviders/Google/Korea/GoogleKoreaSatelliteMapProvider.cs |
|---|
| 0,0 → 1,66 |
| |
| namespace GMap.NET.MapProviders |
| { |
| using System; |
| /// <summary> |
| /// GoogleKoreaSatelliteMap provider |
| /// </summary> |
| public class GoogleKoreaSatelliteMapProvider : GoogleMapProviderBase |
| { |
| public static readonly GoogleKoreaSatelliteMapProvider Instance; |
| GoogleKoreaSatelliteMapProvider() |
| { |
| } |
| static GoogleKoreaSatelliteMapProvider() |
| { |
| Instance = new GoogleKoreaSatelliteMapProvider(); |
| } |
| public string Version = "170"; |
| #region GMapProvider Members |
| readonly Guid id = new Guid("70370941-D70C-4123-BE4A-AEE6754047F5"); |
| public override Guid Id |
| { |
| get |
| { |
| return id; |
| } |
| } |
| readonly string name = "GoogleKoreaSatelliteMap"; |
| public override string Name |
| { |
| get |
| { |
| return name; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| string url = MakeTileImageUrl(pos, zoom, LanguageStr); |
| return GetTileImageUsingHttp(url); |
| } |
| #endregion |
| string MakeTileImageUrl(GPoint pos, int zoom, string language) |
| { |
| string sec1 = string.Empty; |
| string sec2 = string.Empty; |
| GetSecureWords(pos, out sec1, out sec2); |
| return string.Format(UrlFormat, UrlFormatServer, GetServerNum(pos, 4), UrlFormatRequest, Version, language, pos.X, sec1, pos.Y, zoom, sec2, ServerKoreaKr); |
| } |
| static readonly string UrlFormatServer = "khm"; |
| static readonly string UrlFormatRequest = "kh"; |
| static readonly string UrlFormat = "http://{0}{1}.{10}/{2}/v={3}&hl={4}&x={5}{6}&y={7}&z={8}&s={9}"; |
| } |
| } |
| /MKLiveView/v1.0/GMap.NET.Core/GMap.NET.MapProviders/Lithuania/Lithuania3dMapProvider.cs |
|---|
| 0,0 → 1,65 |
| |
| namespace GMap.NET.MapProviders |
| { |
| using System; |
| /// <summary> |
| /// Lithuania3dMap (2.5d) provider |
| /// </summary> |
| public class Lithuania3dMapProvider : LithuaniaMapProviderBase |
| { |
| public static readonly Lithuania3dMapProvider Instance; |
| Lithuania3dMapProvider() |
| { |
| } |
| static Lithuania3dMapProvider() |
| { |
| Instance = new Lithuania3dMapProvider(); |
| } |
| #region GMapProvider Members |
| readonly Guid id = new Guid("CCC5B65F-C8BC-47CE-B39D-5E262E6BF083"); |
| public override Guid Id |
| { |
| get |
| { |
| return id; |
| } |
| } |
| readonly string name = "Lithuania 2.5d Map"; |
| public override string Name |
| { |
| get |
| { |
| return name; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| string url = MakeTileImageUrl(pos, zoom, LanguageStr); |
| return GetTileImageUsingHttp(url); |
| } |
| #endregion |
| string MakeTileImageUrl(GPoint pos, int zoom, string language) |
| { |
| // http://dc1.maps.lt/cache/mapslt_25d_vkkp/map/_alllayers/L01/R00007194/C0000a481.png |
| int z = zoom; |
| if(zoom >= 10) |
| { |
| z -= 10; |
| } |
| return string.Format(UrlFormat, z, pos.Y, pos.X); |
| } |
| static readonly string UrlFormat = "http://dc1.maps.lt/cache/mapslt_25d_vkkp/map/_alllayers/L{0:00}/R{1:x8}/C{2:x8}.png"; |
| } |
| } |
| /MKLiveView/v1.0/GMap.NET.Core/GMap.NET.MapProviders/Lithuania/LithuaniaHybridMapProvider.cs |
|---|
| 0,0 → 1,73 |
| |
| namespace GMap.NET.MapProviders |
| { |
| using System; |
| /// <summary> |
| /// LithuaniaHybridMap provider |
| /// </summary> |
| public class LithuaniaHybridMapProvider : LithuaniaMapProviderBase |
| { |
| public static readonly LithuaniaHybridMapProvider Instance; |
| LithuaniaHybridMapProvider() |
| { |
| } |
| static LithuaniaHybridMapProvider() |
| { |
| Instance = new LithuaniaHybridMapProvider(); |
| } |
| #region GMapProvider Members |
| readonly Guid id = new Guid("279AB0E0-4704-4AA6-86AD-87D13B1F8975"); |
| public override Guid Id |
| { |
| get |
| { |
| return id; |
| } |
| } |
| readonly string name = "LithuaniaHybridMap"; |
| public override string Name |
| { |
| get |
| { |
| return name; |
| } |
| } |
| GMapProvider[] overlays; |
| public override GMapProvider[] Overlays |
| { |
| get |
| { |
| if(overlays == null) |
| { |
| overlays = new GMapProvider[] { LithuaniaOrtoFotoMapProvider.Instance, this }; |
| } |
| return overlays; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| string url = MakeTileImageUrl(pos, zoom, LanguageStr); |
| return GetTileImageUsingHttp(url); |
| } |
| #endregion |
| string MakeTileImageUrl(GPoint pos, int zoom, string language) |
| { |
| // http://dc5.maps.lt/cache/mapslt_ortofoto_overlay/map/_alllayers/L09/R000016b1/C000020e1.jpg |
| return string.Format(UrlFormat, zoom, pos.Y, pos.X); |
| } |
| internal static readonly string UrlFormat = "http://dc5.maps.lt/cache/mapslt_ortofoto_overlay/map/_alllayers/L{0:00}/R{1:x8}/C{2:x8}.png"; |
| } |
| } |
| /MKLiveView/v1.0/GMap.NET.Core/GMap.NET.MapProviders/Lithuania/LithuaniaHybridOldMapProvider.cs |
|---|
| 0,0 → 1,57 |
| |
| namespace GMap.NET.MapProviders |
| { |
| using System; |
| /// <summary> |
| /// LithuaniaHybridOldMap, from 2010 data, provider |
| /// </summary> |
| public class LithuaniaHybridOldMapProvider : LithuaniaMapProviderBase |
| { |
| public static readonly LithuaniaHybridOldMapProvider Instance; |
| LithuaniaHybridOldMapProvider() |
| { |
| } |
| static LithuaniaHybridOldMapProvider() |
| { |
| Instance = new LithuaniaHybridOldMapProvider(); |
| } |
| #region GMapProvider Members |
| readonly Guid id = new Guid("35C5C685-E868-4AC7-97BE-10A9A37A81B5"); |
| public override Guid Id |
| { |
| get |
| { |
| return id; |
| } |
| } |
| readonly string name = "LithuaniaHybridMapOld"; |
| public override string Name |
| { |
| get |
| { |
| return name; |
| } |
| } |
| GMapProvider[] overlays; |
| public override GMapProvider[] Overlays |
| { |
| get |
| { |
| if(overlays == null) |
| { |
| overlays = new GMapProvider[] { LithuaniaOrtoFotoOldMapProvider.Instance, LithuaniaHybridMapProvider.Instance }; |
| } |
| return overlays; |
| } |
| } |
| #endregion |
| } |
| } |
| /MKLiveView/v1.0/GMap.NET.Core/GMap.NET.MapProviders/Lithuania/LithuaniaMapProvider.cs |
|---|
| 0,0 → 1,116 |
| |
| namespace GMap.NET.MapProviders |
| { |
| using System; |
| using GMap.NET.Projections; |
| public abstract class LithuaniaMapProviderBase : GMapProvider |
| { |
| public LithuaniaMapProviderBase() |
| { |
| RefererUrl = "http://www.maps.lt/map/"; |
| Copyright = string.Format("©{0} Hnit-Baltic - Map data ©{0} ESRI", DateTime.Today.Year); |
| MaxZoom = 12; |
| Area = new RectLatLng(56.431489960361, 20.8962105239809, 5.8924169643369, 2.58940626652217); |
| } |
| #region GMapProvider Members |
| public override Guid Id |
| { |
| get |
| { |
| throw new NotImplementedException(); |
| } |
| } |
| public override string Name |
| { |
| get |
| { |
| throw new NotImplementedException(); |
| } |
| } |
| public override PureProjection Projection |
| { |
| get |
| { |
| return LKS94Projection.Instance; |
| } |
| } |
| GMapProvider[] overlays; |
| public override GMapProvider[] Overlays |
| { |
| get |
| { |
| if(overlays == null) |
| { |
| overlays = new GMapProvider[] { this }; |
| } |
| return overlays; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| throw new NotImplementedException(); |
| } |
| #endregion |
| } |
| /// <summary> |
| /// LithuaniaMap provider, http://www.maps.lt/map/ |
| /// </summary> |
| public class LithuaniaMapProvider : LithuaniaMapProviderBase |
| { |
| public static readonly LithuaniaMapProvider Instance; |
| LithuaniaMapProvider() |
| { |
| } |
| static LithuaniaMapProvider() |
| { |
| Instance = new LithuaniaMapProvider(); |
| } |
| #region GMapProvider Members |
| readonly Guid id = new Guid("5859079F-1B5E-484B-B05C-41CE664D8A93"); |
| public override Guid Id |
| { |
| get |
| { |
| return id; |
| } |
| } |
| readonly string name = "LithuaniaMap"; |
| public override string Name |
| { |
| get |
| { |
| return name; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| string url = MakeTileImageUrl(pos, zoom, LanguageStr); |
| return GetTileImageUsingHttp(url); |
| } |
| #endregion |
| string MakeTileImageUrl(GPoint pos, int zoom, string language) |
| { |
| // http://dc5.maps.lt/cache/mapslt/map/_alllayers/L08/R00000912/C00000d25.png |
| return string.Format(UrlFormat, zoom, pos.Y, pos.X); |
| } |
| static readonly string UrlFormat = "http://dc5.maps.lt/cache/mapslt/map/_alllayers/L{0:00}/R{1:x8}/C{2:x8}.png"; |
| } |
| } |
| /MKLiveView/v1.0/GMap.NET.Core/GMap.NET.MapProviders/Lithuania/LithuaniaOrtoFotoMapProvider.cs |
|---|
| 0,0 → 1,60 |
| |
| namespace GMap.NET.MapProviders |
| { |
| using System; |
| /// <summary> |
| /// LithuaniaOrtoFotoMap provider |
| /// </summary> |
| public class LithuaniaOrtoFotoMapProvider : LithuaniaMapProviderBase |
| { |
| public static readonly LithuaniaOrtoFotoMapProvider Instance; |
| LithuaniaOrtoFotoMapProvider() |
| { |
| } |
| static LithuaniaOrtoFotoMapProvider() |
| { |
| Instance = new LithuaniaOrtoFotoMapProvider(); |
| } |
| #region GMapProvider Members |
| readonly Guid id = new Guid("043FF9EF-612C-411F-943C-32C787A88D6A"); |
| public override Guid Id |
| { |
| get |
| { |
| return id; |
| } |
| } |
| readonly string name = "LithuaniaOrtoFotoMap"; |
| public override string Name |
| { |
| get |
| { |
| return name; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| string url = MakeTileImageUrl(pos, zoom, LanguageStr); |
| return GetTileImageUsingHttp(url); |
| } |
| #endregion |
| string MakeTileImageUrl(GPoint pos, int zoom, string language) |
| { |
| // http://dc5.maps.lt/cache/mapslt_ortofoto/map/_alllayers/L08/R00000914/C00000d28.jpg |
| return string.Format(UrlFormat, zoom, pos.Y, pos.X); |
| } |
| static readonly string UrlFormat = "http://dc5.maps.lt/cache/mapslt_ortofoto/map/_alllayers/L{0:00}/R{1:x8}/C{2:x8}.jpg"; |
| } |
| } |
| /MKLiveView/v1.0/GMap.NET.Core/GMap.NET.MapProviders/Lithuania/LithuaniaOrtoFotoOldMapProvider.cs |
|---|
| 0,0 → 1,60 |
| |
| namespace GMap.NET.MapProviders |
| { |
| using System; |
| /// <summary> |
| /// LithuaniaOrtoFotoNewMap, from 2010 data, provider |
| /// </summary> |
| public class LithuaniaOrtoFotoOldMapProvider : LithuaniaMapProviderBase |
| { |
| public static readonly LithuaniaOrtoFotoOldMapProvider Instance; |
| LithuaniaOrtoFotoOldMapProvider() |
| { |
| } |
| static LithuaniaOrtoFotoOldMapProvider() |
| { |
| Instance = new LithuaniaOrtoFotoOldMapProvider(); |
| } |
| #region GMapProvider Members |
| readonly Guid id = new Guid("C37A148E-0A7D-4123-BE4E-D0D3603BE46B"); |
| public override Guid Id |
| { |
| get |
| { |
| return id; |
| } |
| } |
| readonly string name = "LithuaniaOrtoFotoMapOld"; |
| public override string Name |
| { |
| get |
| { |
| return name; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| string url = MakeTileImageUrl(pos, zoom, LanguageStr); |
| return GetTileImageUsingHttp(url); |
| } |
| #endregion |
| string MakeTileImageUrl(GPoint pos, int zoom, string language) |
| { |
| // http://dc1.maps.lt/cache/mapslt_ortofoto_2010/map/_alllayers/L09/R000016b1/C000020e2.jpg |
| return string.Format(UrlFormat, zoom, pos.Y, pos.X); |
| } |
| static readonly string UrlFormat = "http://dc1.maps.lt/cache/mapslt_ortofoto_2010/map/_alllayers/L{0:00}/R{1:x8}/C{2:x8}.jpg"; |
| } |
| } |
| /MKLiveView/v1.0/GMap.NET.Core/GMap.NET.MapProviders/Lithuania/LithuaniaReliefMapProvider.cs |
|---|
| 0,0 → 1,70 |
| |
| namespace GMap.NET.MapProviders |
| { |
| using System; |
| using GMap.NET.Projections; |
| /// <summary> |
| /// LithuaniaReliefMap provider, http://www.maps.lt/map/ |
| /// </summary> |
| public class LithuaniaReliefMapProvider : LithuaniaMapProviderBase |
| { |
| public static readonly LithuaniaReliefMapProvider Instance; |
| LithuaniaReliefMapProvider() |
| { |
| } |
| static LithuaniaReliefMapProvider() |
| { |
| Instance = new LithuaniaReliefMapProvider(); |
| } |
| #region GMapProvider Members |
| readonly Guid id = new Guid("85F89205-1062-4F10-B536-90CD8B2F1B7D"); |
| public override Guid Id |
| { |
| get |
| { |
| return id; |
| } |
| } |
| readonly string name = "LithuaniaReliefMap"; |
| public override string Name |
| { |
| get |
| { |
| return name; |
| } |
| } |
| public override PureProjection Projection |
| { |
| get |
| { |
| return LKS94rProjection.Instance; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| string url = MakeTileImageUrl(pos, zoom, LanguageStr); |
| return GetTileImageUsingHttp(url); |
| } |
| #endregion |
| string MakeTileImageUrl(GPoint pos, int zoom, string language) |
| { |
| // http://dc5.maps.lt/cache/mapslt_relief_vector/map/_alllayers/L09/R00001892/C000020df.jpg |
| return string.Format(UrlFormat, zoom, pos.Y, pos.X); |
| } |
| static readonly string UrlFormat = "http://dc5.maps.lt/cache/mapslt_relief_vector/map/_alllayers/L{0:00}/R{1:x8}/C{2:x8}.png"; |
| } |
| } |
| /MKLiveView/v1.0/GMap.NET.Core/GMap.NET.MapProviders/Lithuania/LithuaniaTOP50.cs |
|---|
| 0,0 → 1,67 |
| |
| namespace GMap.NET.MapProviders |
| { |
| using System; |
| using GMap.NET.Projections; |
| public class LithuaniaTOP50 : GMapProvider |
| { |
| public static readonly LithuaniaTOP50 Instance; |
| LithuaniaTOP50() |
| { |
| MaxZoom = 15; |
| } |
| static LithuaniaTOP50() |
| { |
| Instance = new LithuaniaTOP50(); |
| } |
| #region GMapProvider Members |
| Guid id = new Guid("2920B1AF-6D57-4895-9A21-D5837CBF1049"); |
| public override Guid Id |
| { |
| get |
| { |
| return id; |
| } |
| } |
| public override string Name |
| { |
| get |
| { |
| return "LithuaniaTOP50"; |
| } |
| } |
| public override PureProjection Projection |
| { |
| get |
| { |
| return MercatorProjection.Instance; |
| } |
| } |
| GMapProvider[] overlays; |
| public override GMapProvider[] Overlays |
| { |
| get |
| { |
| if (overlays == null) |
| { |
| overlays = new GMapProvider[] { this }; |
| } |
| return overlays; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| return null; |
| } |
| #endregion |
| } |
| } |
| /MKLiveView/v1.0/GMap.NET.Core/GMap.NET.MapProviders/NearMap/NearHybridMapProvider.cs |
|---|
| 0,0 → 1,74 |
| |
| namespace GMap.NET.MapProviders |
| { |
| using System; |
| /// <summary> |
| /// NearHybridMap provider - http://www.nearmap.com/ |
| /// </summary> |
| public class NearHybridMapProvider : NearMapProviderBase |
| { |
| public static readonly NearHybridMapProvider Instance; |
| NearHybridMapProvider() |
| { |
| } |
| static NearHybridMapProvider() |
| { |
| Instance = new NearHybridMapProvider(); |
| } |
| #region GMapProvider Members |
| readonly Guid id = new Guid("4BF8819A-635D-4A94-8DC7-94C0E0F04BFD"); |
| public override Guid Id |
| { |
| get |
| { |
| return id; |
| } |
| } |
| readonly string name = "NearHybridMap"; |
| public override string Name |
| { |
| get |
| { |
| return name; |
| } |
| } |
| GMapProvider[] overlays; |
| public override GMapProvider[] Overlays |
| { |
| get |
| { |
| if(overlays == null) |
| { |
| overlays = new GMapProvider[] { NearSatelliteMapProvider.Instance, this }; |
| } |
| return overlays; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| string url = MakeTileImageUrl(pos, zoom, LanguageStr); |
| return GetTileImageUsingHttp(url); |
| } |
| #endregion |
| string MakeTileImageUrl(GPoint pos, int zoom, string language) |
| { |
| // http://web1.nearmap.com/maps/hl=en&x=37&y=19&z=6&nml=MapT&nmg=1&s=2KbhmZZ |
| // http://web1.nearmap.com/maps/hl=en&x=36&y=19&z=6&nml=MapT&nmg=1&s=2YKWhQi |
| return string.Format(UrlFormat, GetServerNum(pos, 3), pos.X, pos.Y, zoom); |
| } |
| static readonly string UrlFormat = "http://web{0}.nearmap.com/maps/hl=en&x={1}&y={2}&z={3}&nml=MapT&nmg=1"; |
| } |
| } |
| /MKLiveView/v1.0/GMap.NET.Core/GMap.NET.MapProviders/NearMap/NearMapProvider.cs |
|---|
| 0,0 → 1,184 |
| |
| namespace GMap.NET.MapProviders |
| { |
| using System; |
| using GMap.NET.Projections; |
| using System.Net; |
| using System.Text; |
| /// <summary> |
| /// http://en.wikipedia.org/wiki/NearMap |
| /// nearmap originally allowed personal use of images for free for non-enterprise users. |
| /// However this free access ended in December 2012, when the company modified its business model to user-pay |
| /// </summary> |
| public abstract class NearMapProviderBase : GMapProvider |
| { |
| public NearMapProviderBase() |
| { |
| // credentials doesn't work ;/ |
| //Credential = new NetworkCredential("greatmaps", "greatmaps"); |
| //try ForceBasicHttpAuthentication(...); |
| } |
| #region GMapProvider Members |
| public override Guid Id |
| { |
| get |
| { |
| throw new NotImplementedException(); |
| } |
| } |
| public override string Name |
| { |
| get |
| { |
| throw new NotImplementedException(); |
| } |
| } |
| public override PureProjection Projection |
| { |
| get |
| { |
| return MercatorProjection.Instance; |
| } |
| } |
| GMapProvider[] overlays; |
| public override GMapProvider[] Overlays |
| { |
| get |
| { |
| if(overlays == null) |
| { |
| overlays = new GMapProvider[] { this }; |
| } |
| return overlays; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| throw new NotImplementedException(); |
| } |
| #endregion |
| public new static int GetServerNum(GPoint pos, int max) |
| { |
| // var hostNum=((opts.nodes!==0)?((tileCoords.x&2)%opts.nodes):0)+opts.nodeStart; |
| return (int)(pos.X & 2) % max; |
| } |
| static readonly string SecureStr = "Vk52edzNRYKbGjF8Ur0WhmQlZs4wgipDETyL1oOMXIAvqtxJBuf7H36acCnS9P"; |
| public string GetSafeString(GPoint pos) |
| { |
| #region -- source -- |
| /* |
| TileLayer.prototype.differenceEngine=function(s,a) |
| { |
| var offset=0,result="",alen=a.length,v,p; |
| for(var i=0; i<alen; i++) |
| { |
| v=parseInt(a.charAt(i),10); |
| if(!isNaN(v)) |
| { |
| offset+=v; |
| p=s.charAt(offset%s.length); |
| result+=p |
| } |
| } |
| return result |
| }; |
| TileLayer.prototype.getSafeString=function(x,y,nmd) |
| { |
| var arg=x.toString()+y.toString()+((3*x)+y).toString(); |
| if(nmd) |
| { |
| arg+=nmd |
| } |
| return this.differenceEngine(TileLayer._substring,arg) |
| }; |
| */ |
| #endregion |
| var arg = pos.X.ToString() + pos.Y.ToString() + ((3 * pos.X) + pos.Y).ToString(); |
| string ret = "&s="; |
| int offset = 0; |
| for(int i = 0; i < arg.Length; i++) |
| { |
| offset += int.Parse(arg[i].ToString()); |
| ret += SecureStr[offset % SecureStr.Length]; |
| } |
| return ret; |
| } |
| } |
| /// <summary> |
| /// NearMap provider - http://www.nearmap.com/ |
| /// </summary> |
| public class NearMapProvider : NearMapProviderBase |
| { |
| public static readonly NearMapProvider Instance; |
| NearMapProvider() |
| { |
| RefererUrl = "http://www.nearmap.com/"; |
| } |
| static NearMapProvider() |
| { |
| Instance = new NearMapProvider(); |
| } |
| #region GMapProvider Members |
| readonly Guid id = new Guid("E33803DF-22CB-4FFA-B8E3-15383ED9969D"); |
| public override Guid Id |
| { |
| get |
| { |
| return id; |
| } |
| } |
| readonly string name = "NearMap"; |
| public override string Name |
| { |
| get |
| { |
| return name; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| string url = MakeTileImageUrl(pos, zoom, LanguageStr); |
| return GetTileImageUsingHttp(url); |
| } |
| #endregion |
| string MakeTileImageUrl(GPoint pos, int zoom, string language) |
| { |
| // http://web1.nearmap.com/maps/hl=en&x=18681&y=10415&z=15&nml=Map_&nmg=1&s=kY8lZssipLIJ7c5 |
| // http://web1.nearmap.com/kh/v=nm&hl=en&x=20&y=8&z=5&nml=Map_&s=55KUZ |
| //http://maps.au.nearmap.com/api/0/authentication/checkticket?nmf=json&return200=true&callback=jQuery110206126813754172529_1431499242400&_=1431499242401 |
| //jQuery110206126813754172529_1431499242400({"IncidentId":null,"AccountContext":{"AccountId":"account2574457","Username":"demo"},"Result":{"Ticket":{"Ticket":"1637726D061CB8B8A28BC98064443C96FB07008C16531B2F5100F98B9EBFE69C4083C88C920D3BF4C0768A27ADE9ECADF324A380DBF80C3C0982DC83374FE8EBF0F70868735351FC7","Expires":"\/Date(1432103400000)\/","CookieName":"nearmap_web3_app"},"Status":"Ok","Username":"demo","AccountId":"account2574457"}}) |
| // http://web1.au.nearmap.com/maps/hl=en&x=1855837&y=1265913&z=21&nml=V&httpauth=false&version=2 |
| // http://web2.au.nearmap.com/maps/hl=en&x=231977&y=158238&z=18&nml=Dem&httpauth=false&version=2 |
| return string.Format(UrlFormat, GetServerNum(pos, 3), pos.X, pos.Y, zoom, GetSafeString(pos)); |
| } |
| static readonly string UrlFormat = "http://web{0}.nearmap.com/kh/v=nm&hl=en&x={1}&y={2}&z={3}&nml=Map_{4}"; |
| } |
| } |
| /MKLiveView/v1.0/GMap.NET.Core/GMap.NET.MapProviders/NearMap/NearSatelliteMapProvider.cs |
|---|
| 0,0 → 1,63 |
| |
| namespace GMap.NET.MapProviders |
| { |
| using System; |
| /// <summary> |
| /// NearSatelliteMap provider - http://www.nearmap.com/ |
| /// </summary> |
| public class NearSatelliteMapProvider : NearMapProviderBase |
| { |
| public static readonly NearSatelliteMapProvider Instance; |
| NearSatelliteMapProvider() |
| { |
| } |
| static NearSatelliteMapProvider() |
| { |
| Instance = new NearSatelliteMapProvider(); |
| } |
| #region GMapProvider Members |
| readonly Guid id = new Guid("56D00148-05B7-408D-8F7A-8D7250FF8121"); |
| public override Guid Id |
| { |
| get |
| { |
| return id; |
| } |
| } |
| readonly string name = "NearSatelliteMap"; |
| public override string Name |
| { |
| get |
| { |
| return name; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| string url = MakeTileImageUrl(pos, zoom, LanguageStr); |
| return GetTileImageUsingHttp(url); |
| } |
| #endregion |
| string MakeTileImageUrl(GPoint pos, int zoom, string language) |
| { |
| // http://web2.nearmap.com/maps/hl=en&x=14&y=8&z=5&nml=Vert&s=kdj00 |
| // http://web2.nearmap.com/maps/hl=en&x=6&y=4&z=4&nml=Vert |
| // http://web2.nearmap.com/maps/hl=en&x=3&y=1&z=3&nml=Vert&s=2edd |
| // http://web0.nearmap.com/maps/hl=en&x=69&y=39&z=7&nml=Vert&s=z80wiTM |
| return string.Format(UrlFormat, GetServerNum(pos, 4), pos.X, pos.Y, zoom, GetSafeString(pos)); |
| } |
| static readonly string UrlFormat = "http://web{0}.nearmap.com/maps/hl=en&x={1}&y={2}&z={3}&nml=Vert{4}"; |
| } |
| } |
| /MKLiveView/v1.0/GMap.NET.Core/GMap.NET.MapProviders/OpenStreetMap/OpenCycleLandscapeMapProvider.cs |
|---|
| 0,0 → 1,74 |
| |
| namespace GMap.NET.MapProviders |
| { |
| using System; |
| /// <summary> |
| /// OpenCycleMap Landscape provider - http://www.opencyclemap.org |
| /// </summary> |
| public class OpenCycleLandscapeMapProvider : OpenStreetMapProviderBase |
| { |
| public static readonly OpenCycleLandscapeMapProvider Instance; |
| OpenCycleLandscapeMapProvider() |
| { |
| RefererUrl = "http://www.opencyclemap.org/"; |
| } |
| static OpenCycleLandscapeMapProvider() |
| { |
| Instance = new OpenCycleLandscapeMapProvider(); |
| } |
| #region GMapProvider Members |
| readonly Guid id = new Guid("BDBAA939-6597-4D87-8F4F-261C49E35F56"); |
| public override Guid Id |
| { |
| get |
| { |
| return id; |
| } |
| } |
| readonly string name = "OpenCycleLandscapeMap"; |
| public override string Name |
| { |
| get |
| { |
| return name; |
| } |
| } |
| GMapProvider[] overlays; |
| public override GMapProvider[] Overlays |
| { |
| get |
| { |
| if(overlays == null) |
| { |
| overlays = new GMapProvider[] { this }; |
| } |
| return overlays; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| string url = MakeTileImageUrl(pos, zoom, string.Empty); |
| return GetTileImageUsingHttp(url); |
| } |
| #endregion |
| string MakeTileImageUrl(GPoint pos, int zoom, string language) |
| { |
| char letter = ServerLetters[GMapProvider.GetServerNum(pos, 3)]; |
| return string.Format(UrlFormat, letter, zoom, pos.X, pos.Y); |
| } |
| static readonly string UrlFormat = "http://{0}.tile3.opencyclemap.org/landscape/{1}/{2}/{3}.png"; |
| } |
| } |
| /MKLiveView/v1.0/GMap.NET.Core/GMap.NET.MapProviders/OpenStreetMap/OpenCycleMapProvider.cs |
|---|
| 0,0 → 1,73 |
| |
| namespace GMap.NET.MapProviders |
| { |
| using System; |
| /// <summary> |
| /// OpenCycleMap provider - http://www.opencyclemap.org |
| /// </summary> |
| public class OpenCycleMapProvider : OpenStreetMapProviderBase |
| { |
| public static readonly OpenCycleMapProvider Instance; |
| OpenCycleMapProvider() |
| { |
| RefererUrl = "http://www.opencyclemap.org/"; |
| } |
| static OpenCycleMapProvider() |
| { |
| Instance = new OpenCycleMapProvider(); |
| } |
| #region GMapProvider Members |
| readonly Guid id = new Guid("D7E1826E-EE1E-4441-9F15-7C2DE0FE0B0A"); |
| public override Guid Id |
| { |
| get |
| { |
| return id; |
| } |
| } |
| readonly string name = "OpenCycleMap"; |
| public override string Name |
| { |
| get |
| { |
| return name; |
| } |
| } |
| GMapProvider[] overlays; |
| public override GMapProvider[] Overlays |
| { |
| get |
| { |
| if(overlays == null) |
| { |
| overlays = new GMapProvider[] { this }; |
| } |
| return overlays; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| string url = MakeTileImageUrl(pos, zoom, string.Empty); |
| return GetTileImageUsingHttp(url); |
| } |
| #endregion |
| string MakeTileImageUrl(GPoint pos, int zoom, string language) |
| { |
| char letter = ServerLetters[GMapProvider.GetServerNum(pos, 3)]; |
| return string.Format(UrlFormat, letter, zoom, pos.X, pos.Y); |
| } |
| static readonly string UrlFormat = "http://{0}.tile.opencyclemap.org/cycle/{1}/{2}/{3}.png"; |
| } |
| } |
| /MKLiveView/v1.0/GMap.NET.Core/GMap.NET.MapProviders/OpenStreetMap/OpenCycleTransportMapProvider.cs |
|---|
| 0,0 → 1,73 |
| |
| namespace GMap.NET.MapProviders |
| { |
| using System; |
| /// <summary> |
| /// OpenCycleMap Transport provider - http://www.opencyclemap.org |
| /// </summary> |
| public class OpenCycleTransportMapProvider : OpenStreetMapProviderBase |
| { |
| public static readonly OpenCycleTransportMapProvider Instance; |
| OpenCycleTransportMapProvider() |
| { |
| RefererUrl = "http://www.opencyclemap.org/"; |
| } |
| static OpenCycleTransportMapProvider() |
| { |
| Instance = new OpenCycleTransportMapProvider(); |
| } |
| #region GMapProvider Members |
| readonly Guid id = new Guid("AF66DF88-AD25-43A9-8F82-56FCA49A748A"); |
| public override Guid Id |
| { |
| get |
| { |
| return id; |
| } |
| } |
| readonly string name = "OpenCycleTransportMap"; |
| public override string Name |
| { |
| get |
| { |
| return name; |
| } |
| } |
| GMapProvider[] overlays; |
| public override GMapProvider[] Overlays |
| { |
| get |
| { |
| if(overlays == null) |
| { |
| overlays = new GMapProvider[] { this }; |
| } |
| return overlays; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| string url = MakeTileImageUrl(pos, zoom, string.Empty); |
| return GetTileImageUsingHttp(url); |
| } |
| #endregion |
| string MakeTileImageUrl(GPoint pos, int zoom, string language) |
| { |
| char letter = ServerLetters[GMapProvider.GetServerNum(pos, 3)]; |
| return string.Format(UrlFormat, letter, zoom, pos.X, pos.Y); |
| } |
| static readonly string UrlFormat = "http://{0}.tile2.opencyclemap.org/transport/{1}/{2}/{3}.png"; |
| } |
| } |
| /MKLiveView/v1.0/GMap.NET.Core/GMap.NET.MapProviders/OpenStreetMap/OpenSeaMapHybridProvider.cs |
|---|
| 0,0 → 1,72 |
| |
| namespace GMap.NET.MapProviders |
| { |
| using System; |
| /// <summary> |
| /// OpenSeaMapHybrid provider - http://openseamap.org |
| /// </summary> |
| public class OpenSeaMapHybridProvider : OpenStreetMapProviderBase |
| { |
| public static readonly OpenSeaMapHybridProvider Instance; |
| OpenSeaMapHybridProvider() |
| { |
| RefererUrl = "http://openseamap.org/"; |
| } |
| static OpenSeaMapHybridProvider() |
| { |
| Instance = new OpenSeaMapHybridProvider(); |
| } |
| #region GMapProvider Members |
| readonly Guid id = new Guid("FAACDE73-4B90-4AE6-BB4A-ADE4F3545592"); |
| public override Guid Id |
| { |
| get |
| { |
| return id; |
| } |
| } |
| readonly string name = "OpenSeaMapHybrid"; |
| public override string Name |
| { |
| get |
| { |
| return name; |
| } |
| } |
| GMapProvider[] overlays; |
| public override GMapProvider[] Overlays |
| { |
| get |
| { |
| if(overlays == null) |
| { |
| overlays = new GMapProvider[] { OpenStreetMapProvider.Instance, this }; |
| } |
| return overlays; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| string url = MakeTileImageUrl(pos, zoom, string.Empty); |
| return GetTileImageUsingHttp(url); |
| } |
| #endregion |
| string MakeTileImageUrl(GPoint pos, int zoom, string language) |
| { |
| return string.Format(UrlFormat, zoom, pos.X, pos.Y); |
| } |
| static readonly string UrlFormat = "http://tiles.openseamap.org/seamark/{0}/{1}/{2}.png"; |
| } |
| } |
| /MKLiveView/v1.0/GMap.NET.Core/GMap.NET.MapProviders/OpenStreetMap/OpenStreet4UMapProvider.cs |
|---|
| 0,0 → 1,79 |
| |
| namespace GMap.NET.MapProviders |
| { |
| using System; |
| /// <summary> |
| /// OpenStreet4UMap provider |
| /// http://www.4umaps.eu |
| /// |
| /// 4UMaps are topographic outdoor maps based on OpenStreetmap data. |
| /// The map contains everything you need for any kind of back country activity like hiking, |
| /// mountain biking, cycling, climbing etc. 4UMaps has elevation lines, hill shading, |
| /// peak height and name, streets, ways, tracks and trails, as well as springs, supermarkets, |
| /// restaurants, hotels, shelters etc. |
| /// </summary> |
| public class OpenStreet4UMapProvider : OpenStreetMapProviderBase |
| { |
| public static readonly OpenStreet4UMapProvider Instance; |
| OpenStreet4UMapProvider() |
| { |
| RefererUrl = "http://www.4umaps.eu/map.htm"; |
| Copyright = string.Format("© 4UMaps.eu, © OpenStreetMap - Map data ©{0} OpenStreetMap", DateTime.Today.Year); |
| } |
| static OpenStreet4UMapProvider() |
| { |
| Instance = new OpenStreet4UMapProvider(); |
| } |
| #region GMapProvider Members |
| readonly Guid id = new Guid("3E3D919E-9814-4978-B430-6AAB2C1E41B2"); |
| public override Guid Id |
| { |
| get |
| { |
| return id; |
| } |
| } |
| readonly string name = "OpenStreet4UMap"; |
| public override string Name |
| { |
| get |
| { |
| return name; |
| } |
| } |
| GMapProvider[] overlays; |
| public override GMapProvider[] Overlays |
| { |
| get |
| { |
| if(overlays == null) |
| { |
| overlays = new GMapProvider[] { this }; |
| } |
| return overlays; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| string url = MakeTileImageUrl(pos, zoom); |
| return GetTileImageUsingHttp(url); |
| } |
| #endregion |
| string MakeTileImageUrl(GPoint pos, int zoom) |
| { |
| return string.Format(UrlFormat, zoom, pos.X, pos.Y); |
| } |
| static readonly string UrlFormat = "http://4umaps.eu/{0}/{1}/{2}.png"; |
| } |
| } |
| /MKLiveView/v1.0/GMap.NET.Core/GMap.NET.MapProviders/OpenStreetMap/OpenStreetMapProvider.cs |
|---|
| 0,0 → 1,547 |
| namespace GMap.NET.MapProviders |
| { |
| using System; |
| using System.Collections.Generic; |
| using System.Diagnostics; |
| using System.Globalization; |
| using System.Xml; |
| using GMap.NET.Internals; |
| using GMap.NET.Projections; |
| public abstract class OpenStreetMapProviderBase : GMapProvider, RoutingProvider, GeocodingProvider |
| { |
| public OpenStreetMapProviderBase() |
| { |
| MaxZoom = null; |
| RefererUrl = "http://www.openstreetmap.org/"; |
| Copyright = string.Format("© OpenStreetMap - Map data ©{0} OpenStreetMap", DateTime.Today.Year); |
| } |
| public readonly string ServerLetters = "abc"; |
| public int MinExpectedRank = 0; |
| #region GMapProvider Members |
| public override Guid Id |
| { |
| get |
| { |
| throw new NotImplementedException(); |
| } |
| } |
| public override string Name |
| { |
| get |
| { |
| throw new NotImplementedException(); |
| } |
| } |
| public override PureProjection Projection |
| { |
| get |
| { |
| return MercatorProjection.Instance; |
| } |
| } |
| public override GMapProvider[] Overlays |
| { |
| get |
| { |
| throw new NotImplementedException(); |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| throw new NotImplementedException(); |
| } |
| #endregion |
| #region GMapRoutingProvider Members |
| public MapRoute GetRoute(PointLatLng start, PointLatLng end, bool avoidHighways, bool walkingMode, int Zoom) |
| { |
| List<PointLatLng> points = GetRoutePoints(MakeRoutingUrl(start, end, walkingMode ? TravelTypeFoot : TravelTypeMotorCar)); |
| MapRoute route = points != null ? new MapRoute(points, walkingMode ? WalkingStr : DrivingStr) : null; |
| return route; |
| } |
| /// <summary> |
| /// NotImplemented |
| /// </summary> |
| /// <param name="start"></param> |
| /// <param name="end"></param> |
| /// <param name="avoidHighways"></param> |
| /// <param name="walkingMode"></param> |
| /// <param name="Zoom"></param> |
| /// <returns></returns> |
| public MapRoute GetRoute(string start, string end, bool avoidHighways, bool walkingMode, int Zoom) |
| { |
| throw new NotImplementedException("use GetRoute(PointLatLng start, PointLatLng end..."); |
| } |
| #region -- internals -- |
| string MakeRoutingUrl(PointLatLng start, PointLatLng end, string travelType) |
| { |
| return string.Format(CultureInfo.InvariantCulture, RoutingUrlFormat, start.Lat, start.Lng, end.Lat, end.Lng, travelType); |
| } |
| List<PointLatLng> GetRoutePoints(string url) |
| { |
| List<PointLatLng> points = null; |
| try |
| { |
| string route = GMaps.Instance.UseRouteCache ? Cache.Instance.GetContent(url, CacheType.RouteCache) : string.Empty; |
| if(string.IsNullOrEmpty(route)) |
| { |
| route = GetContentUsingHttp(url); |
| if(!string.IsNullOrEmpty(route)) |
| { |
| if(GMaps.Instance.UseRouteCache) |
| { |
| Cache.Instance.SaveContent(url, CacheType.RouteCache, route); |
| } |
| } |
| } |
| if(!string.IsNullOrEmpty(route)) |
| { |
| XmlDocument xmldoc = new XmlDocument(); |
| xmldoc.LoadXml(route); |
| System.Xml.XmlNamespaceManager xmlnsManager = new System.Xml.XmlNamespaceManager(xmldoc.NameTable); |
| xmlnsManager.AddNamespace("sm", "http://earth.google.com/kml/2.0"); |
| ///Folder/Placemark/LineString/coordinates |
| var coordNode = xmldoc.SelectSingleNode("/sm:kml/sm:Document/sm:Folder/sm:Placemark/sm:LineString/sm:coordinates", xmlnsManager); |
| string[] coordinates = coordNode.InnerText.Split('\n'); |
| if(coordinates.Length > 0) |
| { |
| points = new List<PointLatLng>(); |
| foreach(string coordinate in coordinates) |
| { |
| if(coordinate != string.Empty) |
| { |
| string[] XY = coordinate.Split(','); |
| if(XY.Length == 2) |
| { |
| double lat = double.Parse(XY[1], CultureInfo.InvariantCulture); |
| double lng = double.Parse(XY[0], CultureInfo.InvariantCulture); |
| points.Add(new PointLatLng(lat, lng)); |
| } |
| } |
| } |
| } |
| } |
| } |
| catch(Exception ex) |
| { |
| Debug.WriteLine("GetRoutePoints: " + ex); |
| } |
| return points; |
| } |
| static readonly string RoutingUrlFormat = "http://www.yournavigation.org/api/1.0/gosmore.php?format=kml&flat={0}&flon={1}&tlat={2}&tlon={3}&v={4}&fast=1&layer=mapnik"; |
| static readonly string TravelTypeFoot = "foot"; |
| static readonly string TravelTypeMotorCar = "motorcar"; |
| static readonly string WalkingStr = "Walking"; |
| static readonly string DrivingStr = "Driving"; |
| #endregion |
| #endregion |
| #region GeocodingProvider Members |
| public GeoCoderStatusCode GetPoints(string keywords, out List<PointLatLng> pointList) |
| { |
| // http://nominatim.openstreetmap.org/search?q=lithuania,vilnius&format=xml |
| #region -- response -- |
| //<searchresults timestamp="Wed, 01 Feb 12 09:46:00 -0500" attribution="Data Copyright OpenStreetMap Contributors, Some Rights Reserved. CC-BY-SA 2.0." querystring="lithuania,vilnius" polygon="false" exclude_place_ids="29446018,53849547,8831058,29614806" more_url="http://open.mapquestapi.com/nominatim/v1/search?format=xml&exclude_place_ids=29446018,53849547,8831058,29614806&accept-language=en&q=lithuania%2Cvilnius"> |
| //<place place_id="29446018" osm_type="way" osm_id="24598347" place_rank="30" boundingbox="54.6868133544922,54.6879043579102,25.2885360717773,25.2898139953613" lat="54.6873633486028" lon="25.289199818878" display_name="National Museum of Lithuania, 1, Arsenalo g., Senamiesčio seniūnija, YAHOO-HIRES-20080313, Vilnius County, Šalčininkų rajonas, Vilniaus apskritis, 01513, Lithuania" class="tourism" type="museum" icon="http://open.mapquestapi.com/nominatim/v1/images/mapicons/tourist_museum.p.20.png"/> |
| //<place place_id="53849547" osm_type="way" osm_id="55469274" place_rank="30" boundingbox="54.6896553039551,54.690486907959,25.2675743103027,25.2692089080811" lat="54.6900227236882" lon="25.2683589759401" display_name="Ministry of Foreign Affairs of the Republic of Lithuania, 2, J. Tumo Vaižganto g., Naujamiesčio seniūnija, Vilnius, Vilnius County, Vilniaus m. savivaldybė, Vilniaus apskritis, LT-01104, Lithuania" class="amenity" type="public_building"/> |
| //<place place_id="8831058" osm_type="node" osm_id="836234960" place_rank="30" boundingbox="54.6670935059,54.6870973206,25.2638857269,25.2838876343" lat="54.677095" lon="25.2738876" display_name="Railway Museum of Lithuania, 15, Mindaugo g., Senamiesčio seniūnija, Vilnius, Vilnius County, Vilniaus m. savivaldybė, Vilniaus apskritis, 03215, Lithuania" class="tourism" type="museum" icon="http://open.mapquestapi.com/nominatim/v1/images/mapicons/tourist_museum.p.20.png"/> |
| //<place place_id="29614806" osm_type="way" osm_id="24845629" place_rank="30" boundingbox="54.6904983520508,54.6920852661133,25.2606296539307,25.2628803253174" lat="54.6913385159005" lon="25.2617684209873" display_name="Seimas (Parliament) of the Republic of Lithuania, 53, Gedimino pr., Naujamiesčio seniūnija, Vilnius, Vilnius County, Vilniaus m. savivaldybė, Vilniaus apskritis, LT-01111, Lithuania" class="amenity" type="public_building"/> |
| //</searchresults> |
| #endregion |
| return GetLatLngFromGeocoderUrl(MakeGeocoderUrl(keywords), out pointList); |
| } |
| public PointLatLng? GetPoint(string keywords, out GeoCoderStatusCode status) |
| { |
| List<PointLatLng> pointList; |
| status = GetPoints(keywords, out pointList); |
| return pointList != null && pointList.Count > 0 ? pointList[0] : (PointLatLng?) null; |
| } |
| public GeoCoderStatusCode GetPoints(Placemark placemark, out List<PointLatLng> pointList) |
| { |
| // http://nominatim.openstreetmap.org/search?street=&city=vilnius&county=&state=&country=lithuania&postalcode=&format=xml |
| #region -- response -- |
| //<searchresults timestamp="Thu, 29 Nov 12 08:38:23 +0000" attribution="Data © OpenStreetMap contributors, ODbL 1.0. http://www.openstreetmap.org/copyright" querystring="vilnius, lithuania" polygon="false" exclude_place_ids="98093941" more_url="http://nominatim.openstreetmap.org/search?format=xml&exclude_place_ids=98093941&accept-language=de-de,de;q=0.8,en-us;q=0.5,en;q=0.3&q=vilnius%2C+lithuania"> |
| //<place place_id="98093941" osm_type="relation" osm_id="1529146" place_rank="16" boundingbox="54.5693359375,54.8323097229004,25.0250644683838,25.4815216064453" lat="54.6843135" lon="25.2853984" display_name="Vilnius, Vilniaus m. savivaldybė, Distrikt Vilnius, Litauen" class="boundary" type="administrative" icon="http://nominatim.openstreetmap.org/images/mapicons/poi_boundary_administrative.p.20.png"/> |
| //</searchresults> |
| #endregion |
| return GetLatLngFromGeocoderUrl(MakeDetailedGeocoderUrl(placemark), out pointList); |
| } |
| public PointLatLng? GetPoint(Placemark placemark, out GeoCoderStatusCode status) |
| { |
| List<PointLatLng> pointList; |
| status = GetPoints(placemark, out pointList); |
| return pointList != null && pointList.Count > 0 ? pointList[0] : (PointLatLng?) null; |
| } |
| public GeoCoderStatusCode GetPlacemarks(PointLatLng location, out List<Placemark> placemarkList) |
| { |
| throw new NotImplementedException("use GetPlacemark"); |
| } |
| public Placemark? GetPlacemark(PointLatLng location, out GeoCoderStatusCode status) |
| { |
| //http://nominatim.openstreetmap.org/reverse?format=xml&lat=52.5487429714954&lon=-1.81602098644987&zoom=18&addressdetails=1 |
| #region -- response -- |
| /* |
| <reversegeocode timestamp="Wed, 01 Feb 12 09:51:11 -0500" attribution="Data Copyright OpenStreetMap Contributors, Some Rights Reserved. CC-BY-SA 2.0." querystring="format=xml&lat=52.5487429714954&lon=-1.81602098644987&zoom=18&addressdetails=1"> |
| <result place_id="2061235282" osm_type="way" osm_id="90394420" lat="52.5487800131654" lon="-1.81626922291265"> |
| 137, Pilkington Avenue, Castle Vale, City of Birmingham, West Midlands, England, B72 1LH, United Kingdom |
| </result> |
| <addressparts> |
| <house_number> |
| 137 |
| </house_number> |
| <road> |
| Pilkington Avenue |
| </road> |
| <suburb> |
| Castle Vale |
| </suburb> |
| <city> |
| City of Birmingham |
| </city> |
| <county> |
| West Midlands |
| </county> |
| <state_district> |
| West Midlands |
| </state_district> |
| <state> |
| England |
| </state> |
| <postcode> |
| B72 1LH |
| </postcode> |
| <country> |
| United Kingdom |
| </country> |
| <country_code> |
| gb |
| </country_code> |
| </addressparts> |
| </reversegeocode> |
| */ |
| #endregion |
| return GetPlacemarkFromReverseGeocoderUrl(MakeReverseGeocoderUrl(location), out status); |
| } |
| #region -- internals -- |
| string MakeGeocoderUrl(string keywords) |
| { |
| return string.Format(GeocoderUrlFormat, keywords.Replace(' ', '+')); |
| } |
| string MakeDetailedGeocoderUrl(Placemark placemark) |
| { |
| var street = String.Join(" ", new[] { placemark.HouseNo, placemark.ThoroughfareName }).Trim(); |
| return string.Format(GeocoderDetailedUrlFormat, |
| street.Replace(' ', '+'), |
| placemark.LocalityName.Replace(' ', '+'), |
| placemark.SubAdministrativeAreaName.Replace(' ', '+'), |
| placemark.AdministrativeAreaName.Replace(' ', '+'), |
| placemark.CountryName.Replace(' ', '+'), |
| placemark.PostalCodeNumber.Replace(' ', '+')); |
| } |
| string MakeReverseGeocoderUrl(PointLatLng pt) |
| { |
| return string.Format(CultureInfo.InvariantCulture, ReverseGeocoderUrlFormat, pt.Lat, pt.Lng); |
| } |
| GeoCoderStatusCode GetLatLngFromGeocoderUrl(string url, out List<PointLatLng> pointList) |
| { |
| var status = GeoCoderStatusCode.Unknow; |
| pointList = null; |
| try |
| { |
| string geo = GMaps.Instance.UseGeocoderCache ? Cache.Instance.GetContent(url, CacheType.GeocoderCache) : string.Empty; |
| bool cache = false; |
| if(string.IsNullOrEmpty(geo)) |
| { |
| geo = GetContentUsingHttp(url); |
| if(!string.IsNullOrEmpty(geo)) |
| { |
| cache = true; |
| } |
| } |
| if(!string.IsNullOrEmpty(geo)) |
| { |
| if(geo.StartsWith("<?xml") && geo.Contains("<place")) |
| { |
| if(cache && GMaps.Instance.UseGeocoderCache) |
| { |
| Cache.Instance.SaveContent(url, CacheType.GeocoderCache, geo); |
| } |
| XmlDocument doc = new XmlDocument(); |
| doc.LoadXml(geo); |
| { |
| XmlNodeList l = doc.SelectNodes("/searchresults/place"); |
| if(l != null) |
| { |
| pointList = new List<PointLatLng>(); |
| foreach(XmlNode n in l) |
| { |
| var nn = n.Attributes["place_rank"]; |
| int rank = 0; |
| #if !PocketPC |
| if (nn != null && Int32.TryParse(nn.Value, out rank)) |
| { |
| #else |
| if(nn != null && !string.IsNullOrEmpty(nn.Value)) |
| { |
| rank = int.Parse(nn.Value, NumberStyles.Integer, CultureInfo.InvariantCulture); |
| #endif |
| if(rank < MinExpectedRank) |
| continue; |
| } |
| nn = n.Attributes["lat"]; |
| if(nn != null) |
| { |
| double lat = double.Parse(nn.Value, CultureInfo.InvariantCulture); |
| nn = n.Attributes["lon"]; |
| if(nn != null) |
| { |
| double lng = double.Parse(nn.Value, CultureInfo.InvariantCulture); |
| pointList.Add(new PointLatLng(lat, lng)); |
| } |
| } |
| } |
| status = GeoCoderStatusCode.G_GEO_SUCCESS; |
| } |
| } |
| } |
| } |
| } |
| catch(Exception ex) |
| { |
| status = GeoCoderStatusCode.ExceptionInCode; |
| Debug.WriteLine("GetLatLngFromGeocoderUrl: " + ex); |
| } |
| return status; |
| } |
| Placemark? GetPlacemarkFromReverseGeocoderUrl(string url, out GeoCoderStatusCode status) |
| { |
| status = GeoCoderStatusCode.Unknow; |
| Placemark? ret = null; |
| try |
| { |
| string geo = GMaps.Instance.UsePlacemarkCache ? Cache.Instance.GetContent(url, CacheType.PlacemarkCache) : string.Empty; |
| bool cache = false; |
| if(string.IsNullOrEmpty(geo)) |
| { |
| geo = GetContentUsingHttp(url); |
| if(!string.IsNullOrEmpty(geo)) |
| { |
| cache = true; |
| } |
| } |
| if(!string.IsNullOrEmpty(geo)) |
| { |
| if(geo.StartsWith("<?xml") && geo.Contains("<result")) |
| { |
| if(cache && GMaps.Instance.UsePlacemarkCache) |
| { |
| Cache.Instance.SaveContent(url, CacheType.PlacemarkCache, geo); |
| } |
| XmlDocument doc = new XmlDocument(); |
| doc.LoadXml(geo); |
| { |
| XmlNode r = doc.SelectSingleNode("/reversegeocode/result"); |
| if(r != null) |
| { |
| var p = new Placemark(r.InnerText); |
| XmlNode ad = doc.SelectSingleNode("/reversegeocode/addressparts"); |
| if(ad != null) |
| { |
| var vl = ad.SelectSingleNode("country"); |
| if(vl != null) |
| { |
| p.CountryName = vl.InnerText; |
| } |
| vl = ad.SelectSingleNode("country_code"); |
| if(vl != null) |
| { |
| p.CountryNameCode = vl.InnerText; |
| } |
| vl = ad.SelectSingleNode("postcode"); |
| if(vl != null) |
| { |
| p.PostalCodeNumber = vl.InnerText; |
| } |
| vl = ad.SelectSingleNode("state"); |
| if(vl != null) |
| { |
| p.AdministrativeAreaName = vl.InnerText; |
| } |
| vl = ad.SelectSingleNode("region"); |
| if(vl != null) |
| { |
| p.SubAdministrativeAreaName = vl.InnerText; |
| } |
| vl = ad.SelectSingleNode("suburb"); |
| if(vl != null) |
| { |
| p.LocalityName = vl.InnerText; |
| } |
| vl = ad.SelectSingleNode("road"); |
| if(vl != null) |
| { |
| p.ThoroughfareName = vl.InnerText; |
| } |
| } |
| ret = p; |
| status = GeoCoderStatusCode.G_GEO_SUCCESS; |
| } |
| } |
| } |
| } |
| } |
| catch(Exception ex) |
| { |
| ret = null; |
| status = GeoCoderStatusCode.ExceptionInCode; |
| Debug.WriteLine("GetPlacemarkFromReverseGeocoderUrl: " + ex); |
| } |
| return ret; |
| } |
| static readonly string ReverseGeocoderUrlFormat = "http://nominatim.openstreetmap.org/reverse?format=xml&lat={0}&lon={1}&zoom=18&addressdetails=1"; |
| static readonly string GeocoderUrlFormat = "http://nominatim.openstreetmap.org/search?q={0}&format=xml"; |
| static readonly string GeocoderDetailedUrlFormat = "http://nominatim.openstreetmap.org/search?street={0}&city={1}&county={2}&state={3}&country={4}&postalcode={5}&format=xml"; |
| #endregion |
| #endregion |
| } |
| /// <summary> |
| /// OpenStreetMap provider - http://www.openstreetmap.org/ |
| /// </summary> |
| public class OpenStreetMapProvider : OpenStreetMapProviderBase |
| { |
| public static readonly OpenStreetMapProvider Instance; |
| OpenStreetMapProvider() |
| { |
| } |
| static OpenStreetMapProvider() |
| { |
| Instance = new OpenStreetMapProvider(); |
| } |
| #region GMapProvider Members |
| readonly Guid id = new Guid("0521335C-92EC-47A8-98A5-6FD333DDA9C0"); |
| public override Guid Id |
| { |
| get |
| { |
| return id; |
| } |
| } |
| readonly string name = "OpenStreetMap"; |
| public override string Name |
| { |
| get |
| { |
| return name; |
| } |
| } |
| GMapProvider[] overlays; |
| public override GMapProvider[] Overlays |
| { |
| get |
| { |
| if(overlays == null) |
| { |
| overlays = new GMapProvider[] { this }; |
| } |
| return overlays; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| string url = MakeTileImageUrl(pos, zoom, string.Empty); |
| return GetTileImageUsingHttp(url); |
| } |
| #endregion |
| string MakeTileImageUrl(GPoint pos, int zoom, string language) |
| { |
| char letter = ServerLetters[GetServerNum(pos, 3)]; |
| return string.Format(UrlFormat, letter, zoom, pos.X, pos.Y); |
| } |
| static readonly string UrlFormat = "http://{0}.tile.openstreetmap.org/{1}/{2}/{3}.png"; |
| } |
| } |
| /MKLiveView/v1.0/GMap.NET.Core/GMap.NET.MapProviders/OpenStreetMap/OpenStreetMapQuestHybridProvider.cs |
|---|
| 0,0 → 1,72 |
| |
| namespace GMap.NET.MapProviders |
| { |
| using System; |
| /// <summary> |
| /// OpenStreetMapQuestHybrid provider - http://wiki.openstreetmap.org/wiki/MapQuest |
| /// </summary> |
| public class OpenStreetMapQuestHybridProvider : OpenStreetMapProviderBase |
| { |
| public static readonly OpenStreetMapQuestHybridProvider Instance; |
| OpenStreetMapQuestHybridProvider() |
| { |
| Copyright = string.Format("© MapQuest - Map data ©{0} MapQuest, OpenStreetMap", DateTime.Today.Year); |
| } |
| static OpenStreetMapQuestHybridProvider() |
| { |
| Instance = new OpenStreetMapQuestHybridProvider(); |
| } |
| #region GMapProvider Members |
| readonly Guid id = new Guid("95E05027-F846-4429-AB7A-9445ABEEFA2A"); |
| public override Guid Id |
| { |
| get |
| { |
| return id; |
| } |
| } |
| readonly string name = "OpenStreetMapQuestHybrid"; |
| public override string Name |
| { |
| get |
| { |
| return name; |
| } |
| } |
| GMapProvider[] overlays; |
| public override GMapProvider[] Overlays |
| { |
| get |
| { |
| if(overlays == null) |
| { |
| overlays = new GMapProvider[] { OpenStreetMapQuestSatteliteProvider.Instance, this }; |
| } |
| return overlays; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| string url = MakeTileImageUrl(pos, zoom, string.Empty); |
| return GetTileImageUsingHttp(url); |
| } |
| #endregion |
| string MakeTileImageUrl(GPoint pos, int zoom, string language) |
| { |
| return string.Format(UrlFormat, GetServerNum(pos, 3) + 1, zoom, pos.X, pos.Y); |
| } |
| static readonly string UrlFormat = "http://otile{0}.mqcdn.com/tiles/1.0.0/hyb/{1}/{2}/{3}.png"; |
| } |
| } |
| /MKLiveView/v1.0/GMap.NET.Core/GMap.NET.MapProviders/OpenStreetMap/OpenStreetMapQuestProvider.cs |
|---|
| 0,0 → 1,72 |
| |
| namespace GMap.NET.MapProviders |
| { |
| using System; |
| /// <summary> |
| /// OpenStreetMapQuest provider - http://wiki.openstreetmap.org/wiki/MapQuest |
| /// </summary> |
| public class OpenStreetMapQuestProvider : OpenStreetMapProviderBase |
| { |
| public static readonly OpenStreetMapQuestProvider Instance; |
| OpenStreetMapQuestProvider() |
| { |
| Copyright = string.Format("© MapQuest - Map data ©{0} MapQuest, OpenStreetMap", DateTime.Today.Year); |
| } |
| static OpenStreetMapQuestProvider() |
| { |
| Instance = new OpenStreetMapQuestProvider(); |
| } |
| #region GMapProvider Members |
| readonly Guid id = new Guid("D0A12840-973A-448B-B9C2-89B8A07DFF0F"); |
| public override Guid Id |
| { |
| get |
| { |
| return id; |
| } |
| } |
| readonly string name = "OpenStreetMapQuest"; |
| public override string Name |
| { |
| get |
| { |
| return name; |
| } |
| } |
| GMapProvider[] overlays; |
| public override GMapProvider[] Overlays |
| { |
| get |
| { |
| if(overlays == null) |
| { |
| overlays = new GMapProvider[] { this }; |
| } |
| return overlays; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| string url = MakeTileImageUrl(pos, zoom, string.Empty); |
| return GetTileImageUsingHttp(url); |
| } |
| #endregion |
| string MakeTileImageUrl(GPoint pos, int zoom, string language) |
| { |
| return string.Format(UrlFormat, GetServerNum(pos, 3) + 1, zoom, pos.X, pos.Y); |
| } |
| static readonly string UrlFormat = "http://otile{0}.mqcdn.com/tiles/1.0.0/osm/{1}/{2}/{3}.png"; |
| } |
| } |
| /MKLiveView/v1.0/GMap.NET.Core/GMap.NET.MapProviders/OpenStreetMap/OpenStreetMapQuestSatteliteProvider.cs |
|---|
| 0,0 → 1,72 |
| |
| namespace GMap.NET.MapProviders |
| { |
| using System; |
| /// <summary> |
| /// OpenStreetMapQuestSattelite provider - http://wiki.openstreetmap.org/wiki/MapQuest |
| /// </summary> |
| public class OpenStreetMapQuestSatteliteProvider : OpenStreetMapProviderBase |
| { |
| public static readonly OpenStreetMapQuestSatteliteProvider Instance; |
| OpenStreetMapQuestSatteliteProvider() |
| { |
| Copyright = string.Format("© MapQuest - Map data ©{0} MapQuest, OpenStreetMap", DateTime.Today.Year); |
| } |
| static OpenStreetMapQuestSatteliteProvider() |
| { |
| Instance = new OpenStreetMapQuestSatteliteProvider(); |
| } |
| #region GMapProvider Members |
| readonly Guid id = new Guid("E590D3B1-37F4-442B-9395-ADB035627F67"); |
| public override Guid Id |
| { |
| get |
| { |
| return id; |
| } |
| } |
| readonly string name = "OpenStreetMapQuestSattelite"; |
| public override string Name |
| { |
| get |
| { |
| return name; |
| } |
| } |
| GMapProvider[] overlays; |
| public override GMapProvider[] Overlays |
| { |
| get |
| { |
| if(overlays == null) |
| { |
| overlays = new GMapProvider[] { this }; |
| } |
| return overlays; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| string url = MakeTileImageUrl(pos, zoom, string.Empty); |
| return GetTileImageUsingHttp(url); |
| } |
| #endregion |
| string MakeTileImageUrl(GPoint pos, int zoom, string language) |
| { |
| return string.Format(UrlFormat, GetServerNum(pos, 3) + 1, zoom, pos.X, pos.Y); |
| } |
| static readonly string UrlFormat = "http://otile{0}.mqcdn.com/tiles/1.0.0/sat/{1}/{2}/{3}.jpg"; |
| } |
| } |
| /MKLiveView/v1.0/GMap.NET.Core/GMap.NET.MapProviders/OpenStreetMap/OpenStreetMapSurferProvider.cs |
|---|
| 0,0 → 1,78 |
| |
| namespace GMap.NET.MapProviders |
| { |
| using System; |
| #if OpenStreetMapSurfer |
| /// <summary> |
| /// OpenStreetMapSurfer provider |
| /// http://wiki.openstreetmap.org/wiki/MapSurfer.Net |
| /// |
| /// Since May 2011 the service http://www.mapsurfer.net is unavailable due |
| /// to hosting problems. |
| /// </summary> |
| public class OpenStreetMapSurferProvider : OpenStreetMapProviderBase |
| { |
| public static readonly OpenStreetMapSurferProvider Instance; |
| OpenStreetMapSurferProvider() |
| { |
| RefererUrl = "http://www.mapsurfer.net/"; |
| } |
| static OpenStreetMapSurferProvider() |
| { |
| Instance = new OpenStreetMapSurferProvider(); |
| } |
| #region GMapProvider Members |
| readonly Guid id = new Guid("6282888B-2F01-4029-9CD8-0CFFCB043995"); |
| public override Guid Id |
| { |
| get |
| { |
| return id; |
| } |
| } |
| readonly string name = "OpenStreetMapSurfer"; |
| public override string Name |
| { |
| get |
| { |
| return name; |
| } |
| } |
| GMapProvider[] overlays; |
| public override GMapProvider[] Overlays |
| { |
| get |
| { |
| if(overlays == null) |
| { |
| overlays = new GMapProvider[] { this }; |
| } |
| return overlays; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| string url = MakeTileImageUrl(pos, zoom, string.Empty); |
| return GetTileImageUsingHttp(url); |
| } |
| #endregion |
| string MakeTileImageUrl(GPoint pos, int zoom, string language) |
| { |
| return string.Format(UrlFormat, pos.X, pos.Y, zoom); |
| } |
| static readonly string UrlFormat = "http://tiles1.mapsurfer.net/tms_r.ashx?x={0}&y={1}&z={2}"; |
| } |
| #endif |
| } |
| /MKLiveView/v1.0/GMap.NET.Core/GMap.NET.MapProviders/OpenStreetMap/OpenStreetMapSurferTerrainProvider.cs |
|---|
| 0,0 → 1,74 |
| |
| namespace GMap.NET.MapProviders |
| { |
| using System; |
| #if OpenStreetMapSurfer |
| /// <summary> |
| /// OpenStreetMapSurferTerrain provider |
| /// </summary> |
| public class OpenStreetMapSurferTerrainProvider : OpenStreetMapProviderBase |
| { |
| public static readonly OpenStreetMapSurferTerrainProvider Instance; |
| OpenStreetMapSurferTerrainProvider() |
| { |
| RefererUrl = "http://www.mapsurfer.net/"; |
| } |
| static OpenStreetMapSurferTerrainProvider() |
| { |
| Instance = new OpenStreetMapSurferTerrainProvider(); |
| } |
| #region GMapProvider Members |
| readonly Guid id = new Guid("E87954A4-1852-4B64-95FA-24E512E4B021"); |
| public override Guid Id |
| { |
| get |
| { |
| return id; |
| } |
| } |
| readonly string name = "OpenStreetMapSurferTerrain"; |
| public override string Name |
| { |
| get |
| { |
| return name; |
| } |
| } |
| GMapProvider[] overlays; |
| public override GMapProvider[] Overlays |
| { |
| get |
| { |
| if(overlays == null) |
| { |
| overlays = new GMapProvider[] { this }; |
| } |
| return overlays; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| string url = MakeTileImageUrl(pos, zoom, string.Empty); |
| return GetTileImageUsingHttp(url); |
| } |
| #endregion |
| string MakeTileImageUrl(GPoint pos, int zoom, string language) |
| { |
| return string.Format(UrlFormat, pos.X, pos.Y, zoom); |
| } |
| static readonly string UrlFormat = "http://tiles2.mapsurfer.net/tms_t.ashx?x={0}&y={1}&z={2}"; |
| } |
| #endif |
| } |
| /MKLiveView/v1.0/GMap.NET.Core/GMap.NET.MapProviders/OpenStreetMap/OpenStreetOsmProvider.cs |
|---|
| 0,0 → 1,80 |
| |
| namespace GMap.NET.MapProviders |
| { |
| using System; |
| #if OpenStreetOsm |
| /// <summary> |
| /// OpenStreetOsm provider |
| /// http://wiki.openstreetmap.org/wiki/Osmarender |
| /// |
| /// Osmarender is a rule-based rendering tool for generating SVG images |
| /// of OSM data. Note that Osmarender has not been actively maintained |
| /// since March 2012 and was discontinued as a main Slippy Map layer on |
| /// openstreetmap.org around that time. |
| /// </summary> |
| public class OpenStreetOsmProvider : OpenStreetMapProviderBase |
| { |
| public static readonly OpenStreetOsmProvider Instance; |
| OpenStreetOsmProvider() |
| { |
| } |
| static OpenStreetOsmProvider() |
| { |
| Instance = new OpenStreetOsmProvider(); |
| } |
| #region GMapProvider Members |
| readonly Guid id = new Guid("07EF8CBC-A91D-4B2F-8B2D-70DBE384EF18"); |
| public override Guid Id |
| { |
| get |
| { |
| return id; |
| } |
| } |
| readonly string name = "OpenStreetOsm"; |
| public override string Name |
| { |
| get |
| { |
| return name; |
| } |
| } |
| GMapProvider[] overlays; |
| public override GMapProvider[] Overlays |
| { |
| get |
| { |
| if(overlays == null) |
| { |
| overlays = new GMapProvider[] { this }; |
| } |
| return overlays; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| string url = MakeTileImageUrl(pos, zoom, string.Empty); |
| return GetTileImageUsingHttp(url); |
| } |
| #endregion |
| string MakeTileImageUrl(GPoint pos, int zoom, string language) |
| { |
| char letter = ServerLetters[GMapProvider.GetServerNum(pos, 3)]; |
| return string.Format(UrlFormat, letter, zoom, pos.X, pos.Y); |
| } |
| static readonly string UrlFormat = "http://{0}.tah.openstreetmap.org/Tiles/tile/{1}/{2}/{3}.png"; |
| } |
| #endif |
| } |
| /MKLiveView/v1.0/GMap.NET.Core/GMap.NET.MapProviders/Ovi/OviHybridMapProvider.cs |
|---|
| 0,0 → 1,60 |
| |
| namespace GMap.NET.MapProviders |
| { |
| using System; |
| /// <summary> |
| /// OviHybridMap provider |
| /// </summary> |
| public class OviHybridMapProvider : OviMapProviderBase |
| { |
| public static readonly OviHybridMapProvider Instance; |
| OviHybridMapProvider() |
| { |
| } |
| static OviHybridMapProvider() |
| { |
| Instance = new OviHybridMapProvider(); |
| } |
| #region GMapProvider Members |
| readonly Guid id = new Guid("B85A8FD2-40F4-40EE-9B45-491AA45D86C1"); |
| public override Guid Id |
| { |
| get |
| { |
| return id; |
| } |
| } |
| readonly string name = "OviHybridMap"; |
| public override string Name |
| { |
| get |
| { |
| return name; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| string url = MakeTileImageUrl(pos, zoom, LanguageStr); |
| return GetTileImageUsingHttp(url); |
| } |
| #endregion |
| string MakeTileImageUrl(GPoint pos, int zoom, string language) |
| { |
| // http://c.maptile.maps.svc.ovi.com/maptiler/v2/maptile/newest/hybrid.day/12/2316/1277/256/png8 |
| return string.Format(UrlFormat, UrlServerLetters[GetServerNum(pos, 4)], zoom, pos.X, pos.Y); |
| } |
| static readonly string UrlFormat = "http://{0}.maptile.maps.svc.ovi.com/maptiler/v2/maptile/newest/hybrid.day/{1}/{2}/{3}/256/png8"; |
| } |
| } |
| /MKLiveView/v1.0/GMap.NET.Core/GMap.NET.MapProviders/Ovi/OviMapProvider.cs |
|---|
| 0,0 → 1,117 |
| |
| namespace GMap.NET.MapProviders |
| { |
| using System; |
| using GMap.NET.Projections; |
| public abstract class OviMapProviderBase : GMapProvider |
| { |
| public OviMapProviderBase() |
| { |
| MaxZoom = null; |
| RefererUrl = "http://maps.ovi.com/"; |
| Copyright = string.Format("©{0} OVI Nokia - Map data ©{0} NAVTEQ, Imagery ©{0} DigitalGlobe", DateTime.Today.Year); |
| } |
| #region GMapProvider Members |
| public override Guid Id |
| { |
| get |
| { |
| throw new NotImplementedException(); |
| } |
| } |
| public override string Name |
| { |
| get |
| { |
| throw new NotImplementedException(); |
| } |
| } |
| public override PureProjection Projection |
| { |
| get |
| { |
| return MercatorProjection.Instance; |
| } |
| } |
| GMapProvider[] overlays; |
| public override GMapProvider[] Overlays |
| { |
| get |
| { |
| if(overlays == null) |
| { |
| overlays = new GMapProvider[] { this }; |
| } |
| return overlays; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| throw new NotImplementedException(); |
| } |
| #endregion |
| protected static readonly string UrlServerLetters = "bcde"; |
| } |
| /// <summary> |
| /// OviMap provider |
| /// </summary> |
| public class OviMapProvider : OviMapProviderBase |
| { |
| public static readonly OviMapProvider Instance; |
| OviMapProvider() |
| { |
| } |
| static OviMapProvider() |
| { |
| Instance = new OviMapProvider(); |
| } |
| #region GMapProvider Members |
| readonly Guid id = new Guid("30DC1083-AC4D-4471-A232-D8A67AC9373A"); |
| public override Guid Id |
| { |
| get |
| { |
| return id; |
| } |
| } |
| readonly string name = "OviMap"; |
| public override string Name |
| { |
| get |
| { |
| return name; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| string url = MakeTileImageUrl(pos, zoom, LanguageStr); |
| return GetTileImageUsingHttp(url); |
| } |
| #endregion |
| string MakeTileImageUrl(GPoint pos, int zoom, string language) |
| { |
| // http://c.maptile.maps.svc.ovi.com/maptiler/v2/maptile/newest/normal.day/12/2321/1276/256/png8 |
| return string.Format(UrlFormat, UrlServerLetters[GetServerNum(pos, 4)], zoom, pos.X, pos.Y); |
| } |
| static readonly string UrlFormat = "http://{0}.maptile.maps.svc.ovi.com/maptiler/v2/maptile/newest/normal.day/{1}/{2}/{3}/256/png8"; |
| } |
| } |
| /MKLiveView/v1.0/GMap.NET.Core/GMap.NET.MapProviders/Ovi/OviSatelliteMapProvider.cs |
|---|
| 0,0 → 1,60 |
| |
| namespace GMap.NET.MapProviders |
| { |
| using System; |
| /// <summary> |
| /// OviSatelliteMap provider |
| /// </summary> |
| public class OviSatelliteMapProvider : OviMapProviderBase |
| { |
| public static readonly OviSatelliteMapProvider Instance; |
| OviSatelliteMapProvider() |
| { |
| } |
| static OviSatelliteMapProvider() |
| { |
| Instance = new OviSatelliteMapProvider(); |
| } |
| #region GMapProvider Members |
| readonly Guid id = new Guid("6696CE12-7694-4073-BC48-79EE849F2563"); |
| public override Guid Id |
| { |
| get |
| { |
| return id; |
| } |
| } |
| readonly string name = "OviSatelliteMap"; |
| public override string Name |
| { |
| get |
| { |
| return name; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| string url = MakeTileImageUrl(pos, zoom, LanguageStr); |
| return GetTileImageUsingHttp(url); |
| } |
| #endregion |
| string MakeTileImageUrl(GPoint pos, int zoom, string language) |
| { |
| // http://b.maptile.maps.svc.ovi.com/maptiler/v2/maptile/newest/satellite.day/12/2313/1275/256/png8 |
| return string.Format(UrlFormat, UrlServerLetters[GetServerNum(pos, 4)], zoom, pos.X, pos.Y); |
| } |
| static readonly string UrlFormat = "http://{0}.maptile.maps.svc.ovi.com/maptiler/v2/maptile/newest/satellite.day/{1}/{2}/{3}/256/png8"; |
| } |
| } |
| /MKLiveView/v1.0/GMap.NET.Core/GMap.NET.MapProviders/Ovi/OviTerrainMapProvider.cs |
|---|
| 0,0 → 1,60 |
| |
| namespace GMap.NET.MapProviders |
| { |
| using System; |
| /// <summary> |
| /// OviTerrainMap provider |
| /// </summary> |
| public class OviTerrainMapProvider : OviMapProviderBase |
| { |
| public static readonly OviTerrainMapProvider Instance; |
| OviTerrainMapProvider() |
| { |
| } |
| static OviTerrainMapProvider() |
| { |
| Instance = new OviTerrainMapProvider(); |
| } |
| #region GMapProvider Members |
| readonly Guid id = new Guid("7267339C-445E-4E61-B8B8-82D0B7AAACC5"); |
| public override Guid Id |
| { |
| get |
| { |
| return id; |
| } |
| } |
| readonly string name = "OviTerrainMap"; |
| public override string Name |
| { |
| get |
| { |
| return name; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| string url = MakeTileImageUrl(pos, zoom, LanguageStr); |
| return GetTileImageUsingHttp(url); |
| } |
| #endregion |
| string MakeTileImageUrl(GPoint pos, int zoom, string language) |
| { |
| // http://d.maptile.maps.svc.ovi.com/maptiler/v2/maptile/newest/terrain.day/12/2317/1277/256/png8 |
| return string.Format(UrlFormat, UrlServerLetters[GetServerNum(pos, 4)], zoom, pos.X, pos.Y); |
| } |
| static readonly string UrlFormat = "http://{0}.maptile.maps.svc.ovi.com/maptiler/v2/maptile/newest/terrain.day/{1}/{2}/{3}/256/png8"; |
| } |
| } |
| /MKLiveView/v1.0/GMap.NET.Core/GMap.NET.MapProviders/Yahoo/YahooHybridMapProvider.cs |
|---|
| 0,0 → 1,75 |
| |
| namespace GMap.NET.MapProviders |
| { |
| using System; |
| /// <summary> |
| /// YahooHybridMap provider |
| /// </summary> |
| public class YahooHybridMapProvider : YahooMapProviderBase |
| { |
| public static readonly YahooHybridMapProvider Instance; |
| YahooHybridMapProvider() |
| { |
| } |
| static YahooHybridMapProvider() |
| { |
| Instance = new YahooHybridMapProvider(); |
| } |
| public string Version = "4.3"; |
| #region GMapProvider Members |
| readonly Guid id = new Guid("A084E0DB-F9A6-45C1-BC2F-791E1F4E958E"); |
| public override Guid Id |
| { |
| get |
| { |
| return id; |
| } |
| } |
| readonly string name = "YahooHybridMap"; |
| public override string Name |
| { |
| get |
| { |
| return name; |
| } |
| } |
| GMapProvider[] overlays; |
| public override GMapProvider[] Overlays |
| { |
| get |
| { |
| if(overlays == null) |
| { |
| overlays = new GMapProvider[] { YahooSatelliteMapProvider.Instance, this }; |
| } |
| return overlays; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| string url = MakeTileImageUrl(pos, zoom, LanguageStr); |
| return GetTileImageUsingHttp(url); |
| } |
| #endregion |
| string MakeTileImageUrl(GPoint pos, int zoom, string language) |
| { |
| // http://maps1.yimg.com/hx/tl?b=1&v=4.3&t=h&.intl=en&x=14&y=5&z=7&r=1 |
| return string.Format(UrlFormat, ((GetServerNum(pos, 2)) + 1), Version, language, pos.X, (((1 << zoom) >> 1) - 1 - pos.Y), (zoom + 1)); |
| } |
| static readonly string UrlFormat = "http://maps{0}.yimg.com/hx/tl?v={1}&t=h&.intl={2}&x={3}&y={4}&z={5}&r=1"; |
| } |
| } |
| /MKLiveView/v1.0/GMap.NET.Core/GMap.NET.MapProviders/Yahoo/YahooMapProvider.cs |
|---|
| 0,0 → 1,427 |
| namespace GMap.NET.MapProviders |
| { |
| using System; |
| using System.Collections.Generic; |
| using System.Diagnostics; |
| using System.Globalization; |
| using System.Xml; |
| using GMap.NET.Internals; |
| using GMap.NET.Projections; |
| public abstract class YahooMapProviderBase : GMapProvider, GeocodingProvider |
| { |
| public YahooMapProviderBase() |
| { |
| RefererUrl = "http://maps.yahoo.com/"; |
| Copyright = string.Format("© Yahoo! Inc. - Map data & Imagery ©{0} NAVTEQ", DateTime.Today.Year); |
| } |
| public string AppId = string.Empty; |
| public int MinExpectedQuality = 39; |
| #region GMapProvider Members |
| public override Guid Id |
| { |
| get |
| { |
| throw new NotImplementedException(); |
| } |
| } |
| public override string Name |
| { |
| get |
| { |
| throw new NotImplementedException(); |
| } |
| } |
| public override PureProjection Projection |
| { |
| get |
| { |
| return MercatorProjection.Instance; |
| } |
| } |
| GMapProvider[] overlays; |
| public override GMapProvider[] Overlays |
| { |
| get |
| { |
| if(overlays == null) |
| { |
| overlays = new GMapProvider[] { this }; |
| } |
| return overlays; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| throw new NotImplementedException(); |
| } |
| #endregion |
| #region GeocodingProvider Members |
| public GeoCoderStatusCode GetPoints(string keywords, out List<PointLatLng> pointList) |
| { |
| // http://where.yahooapis.com/geocode?q=lithuania,vilnius&appid=1234&flags=CG&gflags=QL&locale=LT-lt |
| #region -- response -- |
| //<ResultSet version="1.0"><Error>0</Error><ErrorMessage>No error</ErrorMessage><Locale>LT-lt</Locale><Quality>40</Quality><Found>1</Found><Result><quality>40</quality><latitude>54.689850</latitude><longitude>25.269260</longitude><offsetlat>54.689850</offsetlat><offsetlon>25.269260</offsetlon><radius>46100</radius></Result></ResultSet> |
| #endregion |
| return GetLatLngFromGeocoderUrl(MakeGeocoderUrl(keywords), out pointList); |
| } |
| public PointLatLng? GetPoint(string keywords, out GeoCoderStatusCode status) |
| { |
| List<PointLatLng> pointList; |
| status = GetPoints(keywords, out pointList); |
| return pointList != null && pointList.Count > 0 ? pointList[0] : (PointLatLng?)null; |
| } |
| public GeoCoderStatusCode GetPoints(Placemark placemark, out List<PointLatLng> pointList) |
| { |
| // http://where.yahooapis.com/geocode?country=LT&state=Vilniaus+Apskritis&county=Vilniaus+Miesto+Savivaldybe&city=Vilnius&neighborhood=Naujamiestis&postal=01108&street=J.+Tumo-Vaizganto+Gatve&house=2&appid=1234&flags=CG&gflags=QL&locale=LT-lt |
| #region -- response -- |
| //<ResultSet version="1.0"><Error>0</Error><ErrorMessage>No error</ErrorMessage><Locale>LT-lt</Locale><Quality>19</Quality><Found>1</Found><Result><quality>87</quality><latitude>54.690181</latitude><longitude>25.269483</longitude><offsetlat>54.690227</offsetlat><offsetlon>25.269278</offsetlon><radius>500</radius></Result></ResultSet> |
| #endregion |
| return GetLatLngFromGeocoderUrl(MakeGeocoderDetailedUrl(placemark), out pointList); |
| } |
| public PointLatLng? GetPoint(Placemark placemark, out GeoCoderStatusCode status) |
| { |
| List<PointLatLng> pointList; |
| status = GetPoints(placemark, out pointList); |
| return pointList != null && pointList.Count > 0 ? pointList[0] : (PointLatLng?)null; |
| } |
| public GeoCoderStatusCode GetPlacemarks(PointLatLng location, out List<Placemark> placemarkList) |
| { |
| // http://where.yahooapis.com/geocode?q=54.689850,25.269260&appid=1234&flags=G&gflags=QRL&locale=LT-lt |
| #region -- response -- |
| //<ResultSet version="1.0"><Error>0</Error><ErrorMessage>No error</ErrorMessage><Locale>LT-lt</Locale><Quality>99</Quality><Found>1</Found><Result><quality>99</quality><latitude>54.689850</latitude><longitude>25.269260</longitude><offsetlat>54.689850</offsetlat><offsetlon>25.269260</offsetlon><radius>500</radius><name>54.689850,25.269260</name><line1>2 J. Tumo-Vaizganto Gatve</line1><line2>01108 Naujamiestis</line2><line3/><line4>Lietuvos Respublika</line4><house>2</house><street>J. Tumo-Vaizganto Gatve</street><xstreet/><unittype/><unit/><postal>01108</postal><level4>Naujamiestis</level4><level3>Vilnius</level3><level2>Vilniaus Miesto Savivaldybe</level2><level1>Vilniaus Apskritis</level1><level0>Lietuvos Respublika</level0><level0code>LT</level0code><level1code/><level2code/><hash/><woeid>12758362</woeid><woetype>11</woetype><uzip>01108</uzip></Result></ResultSet> |
| #endregion |
| return GetPlacemarksFromReverseGeocoderUrl(MakeReverseGeocoderUrl(location), out placemarkList); |
| } |
| public Placemark ? GetPlacemark(PointLatLng location, out GeoCoderStatusCode status) |
| { |
| List<Placemark> placemarkList; |
| status = GetPlacemarks(location, out placemarkList); |
| return placemarkList != null && placemarkList.Count > 0 ? placemarkList[0] : (Placemark?)null; |
| } |
| #region -- internals -- |
| string MakeGeocoderUrl(string keywords) |
| { |
| return string.Format(CultureInfo.InvariantCulture, GeocoderUrlFormat, keywords.Replace(' ', '+'), AppId, !string.IsNullOrEmpty(LanguageStr) ? "&locale=" + LanguageStr : ""); |
| } |
| string MakeGeocoderDetailedUrl(Placemark placemark) |
| { |
| return string.Format(GeocoderDetailedUrlFormat, |
| PrepareUrlString(placemark.CountryName), |
| PrepareUrlString(placemark.AdministrativeAreaName), |
| PrepareUrlString(placemark.SubAdministrativeAreaName), |
| PrepareUrlString(placemark.LocalityName), |
| PrepareUrlString(placemark.DistrictName), |
| PrepareUrlString(placemark.PostalCodeNumber), |
| PrepareUrlString(placemark.ThoroughfareName), |
| PrepareUrlString(placemark.HouseNo), |
| AppId, |
| !string.IsNullOrEmpty(LanguageStr) ? "&locale=" + LanguageStr : string.Empty); |
| } |
| string MakeReverseGeocoderUrl(PointLatLng pt) |
| { |
| return string.Format(CultureInfo.InvariantCulture, ReverseGeocoderUrlFormat, pt.Lat, pt.Lng, AppId, !string.IsNullOrEmpty(LanguageStr) ? "&locale=" + LanguageStr : ""); |
| } |
| string PrepareUrlString(string str) |
| { |
| if (str == null) return string.Empty; |
| return str.Replace(' ', '+'); |
| } |
| GeoCoderStatusCode GetLatLngFromGeocoderUrl(string url, out List<PointLatLng> pointList) |
| { |
| var status = GeoCoderStatusCode.Unknow; |
| pointList = null; |
| try |
| { |
| string geo = GMaps.Instance.UseGeocoderCache ? Cache.Instance.GetContent(url, CacheType.GeocoderCache) : string.Empty; |
| bool cache = false; |
| if (string.IsNullOrEmpty(geo)) |
| { |
| geo = GetContentUsingHttp(url); |
| if (!string.IsNullOrEmpty(geo)) |
| { |
| cache = true; |
| } |
| } |
| if (!string.IsNullOrEmpty(geo)) |
| { |
| if (geo.StartsWith("<?xml") && geo.Contains("<Result")) |
| { |
| if (cache && GMaps.Instance.UseGeocoderCache) |
| { |
| Cache.Instance.SaveContent(url, CacheType.GeocoderCache, geo); |
| } |
| XmlDocument doc = new XmlDocument(); |
| doc.LoadXml(geo); |
| { |
| XmlNodeList l = doc.SelectNodes("/ResultSet/Result"); |
| if (l != null) |
| { |
| pointList = new List<PointLatLng>(); |
| foreach (XmlNode n in l) |
| { |
| var nn = n.SelectSingleNode("quality"); |
| if (nn != null) |
| { |
| var quality = int.Parse(nn.InnerText); |
| if (quality < MinExpectedQuality) continue; |
| nn = n.SelectSingleNode("latitude"); |
| if (nn != null) |
| { |
| double lat = double.Parse(nn.InnerText, CultureInfo.InvariantCulture); |
| nn = n.SelectSingleNode("longitude"); |
| if (nn != null) |
| { |
| double lng = double.Parse(nn.InnerText, CultureInfo.InvariantCulture); |
| pointList.Add(new PointLatLng(lat, lng)); |
| } |
| } |
| } |
| } |
| status = GeoCoderStatusCode.G_GEO_SUCCESS; |
| } |
| } |
| } |
| } |
| } |
| catch (Exception ex) |
| { |
| status = GeoCoderStatusCode.ExceptionInCode; |
| Debug.WriteLine("GetLatLngFromGeocoderUrl: " + ex); |
| } |
| return status; |
| } |
| GeoCoderStatusCode GetPlacemarksFromReverseGeocoderUrl(string url, out List<Placemark> placemarkList) |
| { |
| var status = GeoCoderStatusCode.Unknow; |
| placemarkList = null; |
| try |
| { |
| string geo = GMaps.Instance.UsePlacemarkCache ? Cache.Instance.GetContent(url, CacheType.PlacemarkCache) : string.Empty; |
| bool cache = false; |
| if (string.IsNullOrEmpty(geo)) |
| { |
| geo = GetContentUsingHttp(url); |
| if (!string.IsNullOrEmpty(geo)) |
| { |
| cache = true; |
| } |
| } |
| if (!string.IsNullOrEmpty(geo)) |
| { |
| if (geo.StartsWith("<?xml") && geo.Contains("<ResultSet")) |
| { |
| if (cache && GMaps.Instance.UsePlacemarkCache) |
| { |
| Cache.Instance.SaveContent(url, CacheType.PlacemarkCache, geo); |
| } |
| XmlDocument doc = new XmlDocument(); |
| doc.LoadXml(geo); |
| { |
| XmlNodeList l = doc.SelectNodes("/ResultSet/Result"); |
| if (l != null) |
| { |
| placemarkList = new List<Placemark>(); |
| foreach (XmlNode n in l) |
| { |
| var vl = n.SelectSingleNode("name"); |
| if (vl == null) continue; |
| Placemark placemark = new Placemark(vl.InnerText); |
| vl = n.SelectSingleNode("level0"); |
| if (vl != null) |
| { |
| placemark.CountryName = vl.InnerText; |
| } |
| vl = n.SelectSingleNode("level0code"); |
| if (vl != null) |
| { |
| placemark.CountryNameCode = vl.InnerText; |
| } |
| vl = n.SelectSingleNode("postal"); |
| if (vl != null) |
| { |
| placemark.PostalCodeNumber = vl.InnerText; |
| } |
| vl = n.SelectSingleNode("level1"); |
| if (vl != null) |
| { |
| placemark.AdministrativeAreaName = vl.InnerText; |
| } |
| vl = n.SelectSingleNode("level2"); |
| if (vl != null) |
| { |
| placemark.SubAdministrativeAreaName = vl.InnerText; |
| } |
| vl = n.SelectSingleNode("level3"); |
| if (vl != null) |
| { |
| placemark.LocalityName = vl.InnerText; |
| } |
| vl = n.SelectSingleNode("level4"); |
| if (vl != null) |
| { |
| placemark.DistrictName = vl.InnerText; |
| } |
| vl = n.SelectSingleNode("street"); |
| if (vl != null) |
| { |
| placemark.ThoroughfareName = vl.InnerText; |
| } |
| vl = n.SelectSingleNode("house"); |
| if (vl != null) |
| { |
| placemark.HouseNo = vl.InnerText; |
| } |
| vl = n.SelectSingleNode("radius"); |
| if (vl != null) |
| { |
| placemark.Accuracy = int.Parse(vl.InnerText); |
| } |
| placemarkList.Add(placemark); |
| } |
| status = GeoCoderStatusCode.G_GEO_SUCCESS; |
| } |
| } |
| } |
| } |
| } |
| catch (Exception ex) |
| { |
| status = GeoCoderStatusCode.ExceptionInCode; |
| Debug.WriteLine("GetPlacemarkFromReverseGeocoderUrl: " + ex); |
| } |
| return status; |
| } |
| static readonly string ReverseGeocoderUrlFormat = "http://where.yahooapis.com/geocode?q={0},{1}&appid={2}&flags=G&gflags=QRL{3}"; |
| static readonly string GeocoderUrlFormat = "http://where.yahooapis.com/geocode?q={0}&appid={1}&flags=CG&gflags=QL{2}"; |
| static readonly string GeocoderDetailedUrlFormat = "http://where.yahooapis.com/geocode?country={0}&state={1}&county={2}&city={3}&neighborhood={4}&postal={5}&street={6}&house={7}&appid={8}&flags=CG&gflags=QL{9}"; |
| #endregion |
| #endregion |
| } |
| /// <summary> |
| /// YahooMap provider |
| /// </summary> |
| public class YahooMapProvider : YahooMapProviderBase |
| { |
| public static readonly YahooMapProvider Instance; |
| YahooMapProvider() |
| { |
| } |
| static YahooMapProvider() |
| { |
| Instance = new YahooMapProvider(); |
| } |
| public string Version = "2.1"; |
| #region GMapProvider Members |
| readonly Guid id = new Guid("65DB032C-6869-49B0-A7FC-3AE41A26AF4D"); |
| public override Guid Id |
| { |
| get |
| { |
| return id; |
| } |
| } |
| readonly string name = "YahooMap"; |
| public override string Name |
| { |
| get |
| { |
| return name; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| string url = MakeTileImageUrl(pos, zoom, LanguageStr); |
| return GetTileImageUsingHttp(url); |
| } |
| #endregion |
| string MakeTileImageUrl(GPoint pos, int zoom, string language) |
| { |
| // http://maps1.yimg.com/hx/tl?b=1&v=4.3&.intl=en&x=12&y=7&z=7&r=1 |
| // http://2.base.maps.api.here.com/maptile/2.1/maptile/newest/normal.day/11/1169/652/256/png8?lg=EN&token=TrLJuXVK62IQk0vuXFzaig%3D%3D&app_id=eAdkWGYRoc4RfxVo0Z4B |
| // https://4.aerial.maps.api.here.com/maptile/2.1/maptile/newest/hybrid.day/11/1167/652/256/jpg?lg=ENG&token=TrLJuXVK62IQk0vuXFzaig%3D%3D&requestid=yahoo.prod&app_id=eAdkWGYRoc4RfxVo0Z4B |
| // https://4.aerial.maps.api.here.com/maptile/2.1/maptile/newest/satellite.day/13/4671/2604/256/jpg?lg=ENG&token=TrLJuXVK62IQk0vuXFzaig%3D%3D&requestid=yahoo.prod&app_id=eAdkWGYRoc4RfxVo0Z4B |
| return string.Format(UrlFormat, ((GetServerNum(pos, 2)) + 1), Version, zoom, pos.X, pos.Y, language, rnd1, rnd2); |
| } |
| string rnd1 = Guid.NewGuid().ToString("N").Substring(0, 28); |
| string rnd2 = Guid.NewGuid().ToString("N").Substring(0, 20); |
| //static readonly string UrlFormat = "http://maps{0}.yimg.com/hx/tl?v={1}&.intl={2}&x={3}&y={4}&z={5}&r=1"; |
| static readonly string UrlFormat = "http://{0}.base.maps.api.here.com/maptile/{1}/maptile/newest/normal.day/{2}/{3}/{4}/256/png8?lg={5}&token={6}&requestid=yahoo.prod&app_id={7}"; |
| } |
| } |
| /MKLiveView/v1.0/GMap.NET.Core/GMap.NET.MapProviders/Yahoo/YahooSatelliteMapProvider.cs |
|---|
| 0,0 → 1,62 |
| |
| namespace GMap.NET.MapProviders |
| { |
| using System; |
| /// <summary> |
| /// YahooSatelliteMap provider |
| /// </summary> |
| public class YahooSatelliteMapProvider : YahooMapProviderBase |
| { |
| public static readonly YahooSatelliteMapProvider Instance; |
| YahooSatelliteMapProvider() |
| { |
| } |
| static YahooSatelliteMapProvider() |
| { |
| Instance = new YahooSatelliteMapProvider(); |
| } |
| public string Version = "1.9"; |
| #region GMapProvider Members |
| readonly Guid id = new Guid("55D71878-913F-4320-B5B6-B4167A3F148F"); |
| public override Guid Id |
| { |
| get |
| { |
| return id; |
| } |
| } |
| readonly string name = "YahooSatelliteMap"; |
| public override string Name |
| { |
| get |
| { |
| return name; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| string url = MakeTileImageUrl(pos, zoom, LanguageStr); |
| return GetTileImageUsingHttp(url); |
| } |
| #endregion |
| string MakeTileImageUrl(GPoint pos, int zoom, string language) |
| { |
| // http://maps3.yimg.com/ae/ximg?v=1.9&t=a&s=256&.intl=en&x=15&y=7&z=7&r=1 |
| return string.Format(UrlFormat, ((GetServerNum(pos, 2)) + 1), Version, language, pos.X, (((1 << zoom) >> 1) - 1 - pos.Y), (zoom + 1)); |
| } |
| static readonly string UrlFormat = "http://maps{0}.yimg.com/ae/ximg?v={1}&t=a&s=256&.intl={2}&x={3}&y={4}&z={5}&r=1"; |
| } |
| } |
| /MKLiveView/v1.0/GMap.NET.Core/GMap.NET.MapProviders/Yandex/YandexHybridMapProvider.cs |
|---|
| 0,0 → 1,72 |
| |
| namespace GMap.NET.MapProviders |
| { |
| using System; |
| /// <summary> |
| /// YandexHybridMap provider |
| /// </summary> |
| public class YandexHybridMapProvider : YandexMapProviderBase |
| { |
| public static readonly YandexHybridMapProvider Instance; |
| YandexHybridMapProvider() |
| { |
| } |
| static YandexHybridMapProvider() |
| { |
| Instance = new YandexHybridMapProvider(); |
| } |
| #region GMapProvider Members |
| readonly Guid id = new Guid("78A3830F-5EE3-432C-A32E-91B7AF6BBCB9"); |
| public override Guid Id |
| { |
| get |
| { |
| return id; |
| } |
| } |
| readonly string name = "YandexHybridMap"; |
| public override string Name |
| { |
| get |
| { |
| return name; |
| } |
| } |
| GMapProvider[] overlays; |
| public override GMapProvider[] Overlays |
| { |
| get |
| { |
| if(overlays == null) |
| { |
| overlays = new GMapProvider[] { YandexSatelliteMapProvider.Instance, this }; |
| } |
| return overlays; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| string url = MakeTileImageUrl(pos, zoom, LanguageStr); |
| return GetTileImageUsingHttp(url); |
| } |
| #endregion |
| string MakeTileImageUrl(GPoint pos, int zoom, string language) |
| { |
| return string.Format(UrlFormat, UrlServer, GetServerNum(pos, 4) + 1, Version, pos.X, pos.Y, zoom, language, Server); |
| } |
| static readonly string UrlServer = "vec"; |
| static readonly string UrlFormat = "http://{0}0{1}.{7}/tiles?l=skl&v={2}&x={3}&y={4}&z={5}&lang={6}"; |
| } |
| } |
| /MKLiveView/v1.0/GMap.NET.Core/GMap.NET.MapProviders/Yandex/YandexMapProvider.cs |
|---|
| 0,0 → 1,115 |
| |
| namespace GMap.NET.MapProviders |
| { |
| using System; |
| using GMap.NET.Projections; |
| using GMap.NET.Internals; |
| public abstract class YandexMapProviderBase : GMapProvider |
| { |
| #region GMapProvider Members |
| public override Guid Id |
| { |
| get |
| { |
| throw new NotImplementedException(); |
| } |
| } |
| public override string Name |
| { |
| get |
| { |
| throw new NotImplementedException(); |
| } |
| } |
| public override PureProjection Projection |
| { |
| get |
| { |
| return MercatorProjectionYandex.Instance; |
| } |
| } |
| GMapProvider[] overlays; |
| public override GMapProvider[] Overlays |
| { |
| get |
| { |
| if(overlays == null) |
| { |
| overlays = new GMapProvider[] { this }; |
| } |
| return overlays; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| throw new NotImplementedException(); |
| } |
| #endregion |
| protected string Version = "4.6.9"; |
| public readonly string Server /*d{'_'}b*/ = /*{^_^}*/ Stuff.GString /*{"_"}*/ (/* ;}~ */"MECxW6okUK3Ir7a9ue/vIA=="/* ;}~ */); |
| public readonly string ServerRu /*d{'_'}b*/ = /*{^_^}*/ Stuff.GString /*{"_"}*/ (/* ;}~ */"MECxW6okUK0FRlRPbF0BQg=="/* ;}~ */); |
| public readonly string ServerCom /*d{'_'}b*/ = /*{^_^}*/ Stuff.GString/*{"_"}*/ (/* ;}~ */"MECxW6okUK2JNHOW5AuimA=="/* ;}~ */); |
| } |
| /// <summary> |
| /// YenduxMap provider |
| /// </summary> |
| public class YandexMapProvider : YandexMapProviderBase |
| { |
| public static readonly YandexMapProvider Instance; |
| YandexMapProvider() |
| { |
| RefererUrl = "http://" + ServerCom + "/"; |
| } |
| static YandexMapProvider() |
| { |
| Instance = new YandexMapProvider(); |
| } |
| #region GMapProvider Members |
| readonly Guid id = new Guid("82DC969D-0491-40F3-8C21-4D90B67F47EB"); |
| public override Guid Id |
| { |
| get |
| { |
| return id; |
| } |
| } |
| readonly string name = "YandexMap"; |
| public override string Name |
| { |
| get |
| { |
| return name; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| string url = MakeTileImageUrl(pos, zoom, LanguageStr); |
| return GetTileImageUsingHttp(url); |
| } |
| #endregion |
| string MakeTileImageUrl(GPoint pos, int zoom, string language) |
| { |
| return string.Format(UrlFormat, UrlServer, GetServerNum(pos, 4) + 1, Version, pos.X, pos.Y, zoom, language, Server); |
| } |
| static readonly string UrlServer = "vec"; |
| static readonly string UrlFormat = "http://{0}0{1}.{7}/tiles?l=map&v={2}&x={3}&y={4}&z={5}&lang={6}"; |
| } |
| } |
| /MKLiveView/v1.0/GMap.NET.Core/GMap.NET.MapProviders/Yandex/YandexSatelliteMapProvider.cs |
|---|
| 0,0 → 1,61 |
| |
| namespace GMap.NET.MapProviders |
| { |
| using System; |
| /// <summary> |
| /// YandexSatelliteMap provider |
| /// </summary> |
| public class YandexSatelliteMapProvider : YandexMapProviderBase |
| { |
| public static readonly YandexSatelliteMapProvider Instance; |
| YandexSatelliteMapProvider() |
| { |
| } |
| static YandexSatelliteMapProvider() |
| { |
| Instance = new YandexSatelliteMapProvider(); |
| } |
| public new string Version = "3.135.0"; |
| #region GMapProvider Members |
| readonly Guid id = new Guid("2D4CE763-0F91-40B2-A511-13EF428237AD"); |
| public override Guid Id |
| { |
| get |
| { |
| return id; |
| } |
| } |
| readonly string name = "YandexSatelliteMap"; |
| public override string Name |
| { |
| get |
| { |
| return name; |
| } |
| } |
| public override PureImage GetTileImage(GPoint pos, int zoom) |
| { |
| string url = MakeTileImageUrl(pos, zoom, LanguageStr); |
| return GetTileImageUsingHttp(url); |
| } |
| #endregion |
| string MakeTileImageUrl(GPoint pos, int zoom, string language) |
| { |
| return string.Format(UrlFormat, UrlServer, GetServerNum(pos, 4) + 1, Version, pos.X, pos.Y, zoom, language, Server); |
| } |
| static readonly string UrlServer = "sat"; |
| static readonly string UrlFormat = "http://{0}0{1}.{7}/tiles?l=sat&v={2}&x={3}&y={4}&z={5}&lang={6}"; |
| } |
| } |