public void WmsGetCapabilitiesUrl()
{
// note: Not sure if this test makes much sense anymore now I
// changed it to use local resources. Perhaps this one should
// just be removed since the above test covers the url
// generating logic.
// arrange
var fileName = "wms-capabilities-gdimv_dtk.xml";
var version = "1.3.0";
var serviceTitle = "GDI MV DTK WMS";
using (var stream = File.OpenRead(Path.Combine(Paths.AssemblyDirectory, "Resources", "Wms", fileName)))
{
// arrange, act
WmsCapabilities cap = null;
Assert.DoesNotThrow(() => cap = new WmsCapabilities(XDocument.Load(stream)));
// assert
Assert.That(cap, Is.Not.Null);
Console.WriteLine($"{cap.Service.Title} (WMS {cap.Version.VersionString})");
if (!string.IsNullOrWhiteSpace(serviceTitle))
{
Assert.That(cap.Service.Title, Is.EqualTo(serviceTitle));
}
if (!string.IsNullOrWhiteSpace(version))
{
Assert.That(cap.Version.VersionString, Is.EqualTo(version));
}
}
}
private void ShowServerDetails(WmsCapabilities capabilities)
{
tbServerTitle.Text = capabilities.Service.Title;
tbServerAbstract.Text = capabilities.Service.Abstract;
tbServerOnlineResource.Text = capabilities.Service.OnlineResource.Href;
tbServerAccessConstraints.Text = capabilities.Service.AccessConstraints;
}
public static IEnumerable <ITileSource> CreateFromWmscCapabilties(Uri uri)
{
var wmsCapabilities = new WmsCapabilities(uri.ToString());
return(ParseVendorSpecificCapabilitiesNode(
(XElement)wmsCapabilities.Capability.ExtendedCapabilities[XName.Get("VendorSpecificCapabilities")],
wmsCapabilities.Capability.Request.GetCapabilities.DCPType[0].Http.Get.OnlineResource));
}
/// <summary>
/// Initializes a new instance of the <see cref="WmsInfo"/> class.
/// </summary>
/// <param name="serverUrl">Url of the WMS server.</param>
/// <param name="wmsCapabilities">The WmsCapabilities.</param>
/// <param name="layer">The layer.</param>
/// <param name="customParameters">The custom parameters.</param>
/// <param name="crs">The Crs.</param>
/// <param name="projectionInfo">The CrsProjectionInfo.</param>
/// <param name="style">The style.</param>
/// <param name="credentials">Credentials for authentication.</param>
public WmsInfo(string serverUrl, WmsCapabilities wmsCapabilities, Layer layer, Dictionary <string, string> customParameters, string crs, ProjectionInfo projectionInfo, string style, NetworkCredential credentials)
{
Credentials = credentials;
CustomParameters = customParameters;
Crs = crs;
CrsProjectionInfo = projectionInfo;
Style = style;
Layer = layer;
WmsCapabilities = wmsCapabilities;
ServerUrl = serverUrl;
}
private static string GetFormat(this WmsCapabilities capabilities)
{
var list = capabilities.Capability.Request.GetMap.Format;
if (list.Count > 2)
{
return(list[2]);
}
return(list.FirstOrDefault());
}
/// <summary>
/// Displays capabilities (list of layers for the server).
/// </summary>
private void DisplayServerCapabilities(WmsCapabilities capabilities)
{
var server = View.Server;
if (server != null)
{
Model.Capabilities = capabilities;
View.UpdateCapabilities();
AppConfig.Instance.WmsLastServer = server.Url;
}
}
public void WmsCapabilitiesForLizardTech()
{
// arrange
using (var stream = File.OpenRead(Path.Combine("Resources", "Wms", "LizardtechWmsCapabilities_1_1_1.xml")))
{
// act
var wmsCapabilities = new WmsCapabilities(XDocument.Load(stream));
// assert
Assert.AreEqual(12, wmsCapabilities.Capability.Layer.ChildLayers.Count);
}
}
private bool GetCapabilities(string url, out WmsCapabilities wmsCapabilities)
{
wmsCapabilities = null;
try
{
Uri uri = null;
try
{
uri = new Uri(url);
}
catch (System.Exception e)
{
Debug.LogException(e);
}
if (uri != null)
{
wmsCapabilities = new WmsCapabilities(uri);
}
}
catch (System.Exception e)
{
// ArgumentException, ArgumentNullException, WmsParsingException
Debug.LogException(e);
}
if (wmsCapabilities != null)
{
var cap = wmsCapabilities.Capability;
var service = wmsCapabilities.Service;
string updateSequence = wmsCapabilities.UpdateSequence;
var serviceExceptionReport = wmsCapabilities.ServiceExceptionReport;
WmsVersion version = wmsCapabilities.Version;
Debug.LogFormat("Service: [Title: {0}], [Abstract: {1}], [LayerLimit: {2}]", string.IsNullOrEmpty(service.Title) ? "<none>" : service.Title, string.IsNullOrEmpty(service.Abstract) ? "<none>" : service.Abstract, service.LayerLimit != null ? service.LayerLimit.ToString() : "<none>");
if (serviceExceptionReport != null)
{
Debug.Assert(serviceExceptionReport.ServiceExceptions.Count != 0);
Debug.LogErrorFormat("serviceExceptionReport contains {0} exceptions", serviceExceptionReport.ServiceExceptions.Count);
foreach (var serviceException in serviceExceptionReport.ServiceExceptions)
{
Debug.LogErrorFormat("serviceException: code {0} locator {1} value {2}", serviceException.Code, serviceException.Locator, serviceException.Value);
}
}
if (VerboseLogging)
{
WalkLayers(cap.Layer, PrintLayer);
var ec = cap.ExtendedCapabilities;
PrintExtendedCaps(ref ec);
}
}
return(wmsCapabilities != null);
}
public void WmsCapabilitiesForNrcsSoilWms()
{
// arrange
using (var stream = File.OpenRead(Path.Combine("Resources", "Wms", "NrcsSoilWmsCapabilities_1_1_1.xml")))
{
// act
var wmsCapabilities = new WmsCapabilities(XDocument.Load(stream));
// assert
Assert.True(wmsCapabilities.Service.Name == ServiceName.WMS);
}
}
public void WmsCapabilities_WhenInitializedWithWmsC_ShouldInitializeAllTileLayers()
{
// arrange
using (var stream = File.OpenRead(Path.Combine("Resources", @"WmsCCapabilities_1_1_1.xml")))
{
// act
var capabilities = new WmsCapabilities(stream);
// assert
Assert.NotNull(capabilities.Version);
Assert.AreEqual(54, capabilities.Capability.Layer.ChildLayers.Count);
}
}
public WMSServerParameters(WmsInfo data)
{
InitializeComponent();
WmsInfo = data;
if (WmsInfo == null)
{
return;
}
_wmsCapabilities = WmsInfo.WmsCapabilities;
tbServerUrl.Text = WmsInfo.ServerUrl;
if (WmsInfo.Credentials != null)
{
tbLogin.Text = WmsInfo.Credentials.UserName;
tbPassword.Text = WmsInfo.Credentials.Password;
}
ShowServerDetails(_wmsCapabilities);
InitLayers(_wmsCapabilities);
// Select layer
tvLayers.SelectedNode = FindNodeByLayer(tvLayers.Nodes, WmsInfo.Layer);
if (tvLayers.SelectedNode != null)
{
tvLayers.SelectedNode.EnsureVisible();
}
tvLayers.Select();
tvLayers.Focus();
// Select CRS
lbCRS.SelectedItem = WmsInfo.CRS;
// Select Style
for (int i = 0; i < lbStyles.Items.Count; i++)
{
var style = (StyleWrapper)lbStyles.Items[i];
if (style.Style.Name == WmsInfo.Style)
{
lbStyles.SelectedIndex = i;
break;
}
}
// Show custom parameters
if (WmsInfo.CustomParameters != null)
{
tbCustomParameters.Text = string.Join(Environment.NewLine,
WmsInfo.CustomParameters.Select(d => string.Format("{0}={1}", d.Key, d.Value)));
}
}
public void WmsCapabilitiesWithXmlnsAttribute()
{
using (var stream = File.OpenRead(Path.Combine("Resources", "Wms", "WmsCapabilities_1_3_0_withXmlns.xml")))
{
// act
var capabilities = new WmsCapabilities(stream);
// assert
Assert.NotNull(capabilities);
Assert.NotNull(capabilities.Version);
Assert.AreEqual("1 Million Scale WMS Layers from the National Atlas of the United States", capabilities.Capability.Layer.Title);
Assert.AreEqual(19, capabilities.Capability.Layer.ChildLayers.Count);
}
}
public void WmsCapabilities_WhenParsed_ShouldSetCorrectGetMapUrl()
{
// arrange
using (var stream = File.OpenRead(Path.Combine("Resources", @"BgrGroundwaterWhyMapCapabilities_1_1_1.xml")))
{
const string expectedUrl = "http://www.bgr.de/Service/groundwater/whymap/?";
// act
var capabilities = new WmsCapabilities(stream);
// assert
Assert.True(expectedUrl == capabilities.Capability.Request.GetMap.DCPType[0].Http.Get.OnlineResource.Href);
}
}
public void WmsCapabilities_WhenCreatedWithValidCapabilitiesV111Document_ShouldInitializeCorrectly()
{
// arrange
using (var stream = File.OpenRead(Path.Combine("Resources", @"FrioCountyTXMapsWmsCapabilities_1_1_1.xml")))
{
// act
var capabilities = new WmsCapabilities(stream);
// assert
Assert.NotNull(capabilities.Version);
Assert.AreEqual("Frio County TX Maps", capabilities.Capability.Layer.Title);
Assert.AreEqual(13, capabilities.Capability.Layer.ChildLayers.Count);
}
}
public static IEnumerable <ITileSource> CreateFromWmscCapabilties(Uri uri)
{
var wmsCapabilities = new WmsCapabilities(uri);
var cap = wmsCapabilities.Capability;
var ec = cap.ExtendedCapabilities;
if (!ec.TryGetValue(XName.Get("VendorSpecificCapabilities"), out var vsc))
{
throw new WmsParsingException("Node 'VendorSpecificCapabilities' not found in wms capabilty document");
}
return(ParseVendorSpecificCapabilitiesNode(
(XElement)vsc, cap.Request.GetCapabilities.DCPType[0].Http.Get.OnlineResource));
}
public static IEnumerable <ITileSource> CreateFromWmscCapabilties(XDocument document)
{
var wmsCapabilities = new WmsCapabilities(document);
if (!wmsCapabilities.Capability.ExtendedCapabilities.ContainsKey(XName.Get("VendorSpecificCapabilities")))
{
throw new System.Exception("VendorSpecificCapabilities node is missing from WMS capabilities (This is probably an ordinary WMS)");
}
var vendorSpecificNode = (XElement)wmsCapabilities.Capability.ExtendedCapabilities[XName.Get("VendorSpecificCapabilities")];
return(ParseVendorSpecificCapabilitiesNode(vendorSpecificNode,
wmsCapabilities.Capability.Request.GetCapabilities.DCPType[0].Http.Get.OnlineResource));
}
public void WmsCapabilities_WhenCreatedWithCapabilitiesWithMultipleRootLayers_ShouldInitializeCorrectly()
{
// arrange
using (var stream = File.OpenRead(Path.Combine("Resources", @"MultiTopLayersCapabilities_1_3_0.xml")))
{
// act
var capabilities = new WmsCapabilities(stream);
// assert
Assert.NotNull(capabilities.Version);
Assert.AreEqual("Root Layer", capabilities.Capability.Layer.Title);
Assert.AreEqual(4, capabilities.Capability.Layer.ChildLayers.Count);
}
}
public void WmsCapabilitiesWhenInitializedWithWmsCShouldInitializeAllTileLayers()
{
// arrange
var fileName = "WmsCCapabilities_1_1_1.xml";
using (var stream = File.OpenRead(Path.Combine(Paths.AssemblyDirectory, "Resources", "Wmsc", fileName)))
{
// act
var capabilities = new WmsCapabilities(stream);
// assert
Assert.NotNull(capabilities.Version);
Assert.AreEqual(54, capabilities.Capability.Layer.ChildLayers.Count);
}
}
public void WmsValidateGetCapabilitiesRequest(string url, Type exception, bool expected)
{
// arrange
var valid = !expected;
var uri = new Uri(url);
// act
if (exception != null)
{
Assert.Throws <ArgumentException>(() => valid = WmsCapabilities.ValidateGetCapabilitiesRequest(uri.Query));
return;
}
Assert.DoesNotThrow(() => valid = WmsCapabilities.ValidateGetCapabilitiesRequest(uri.Query));
//assert
Assert.That(valid, Is.EqualTo(expected));
}
private void BtnGetCapabilitiesClick(object sender, EventArgs e)
{
var serverUrl = tbServerUrl.Text;
if (string.IsNullOrWhiteSpace(serverUrl))
{
return;
}
serverUrl = PrepareUri(serverUrl);
var noCapabilities = serverUrl.IndexOf("Request=GetCapabilities", StringComparison.OrdinalIgnoreCase) < 0;
var noService = serverUrl.IndexOf("SERVICE=WMS", StringComparison.OrdinalIgnoreCase) < 0;
if (noCapabilities)
{
serverUrl += "Request=GetCapabilities&";
}
if (noService)
{
serverUrl += "SERVICE=WMS&";
}
WmsCapabilities capabilities;
try
{
var myRequest = WebRequest.Create(serverUrl);
myRequest.Credentials = GetUserCredentials();
using (var myResponse = myRequest.GetResponse())
using (var stream = myResponse.GetResponseStream())
capabilities = new WmsCapabilities(stream);
}
catch (Exception ex)
{
MessageBox.Show(string.Format(Resources.UnableToReadCapabilities, ex.Message));
return;
}
WmsInfo = null;
_wmsCapabilities = capabilities;
ShowServerDetails(capabilities);
InitLayers(capabilities);
}
public void GetData(string url, string desiredLayer, string desiredFormat, GeographicBounds bounds, out Dictionary <BruTile.TileInfo, byte[]> tiles)
{
WmsCapabilities wmsCapabilities = null;
ITileSource tileSource = null;
tiles = null;
string baseUrl = url + "?SERVICE=WMS";
string capUrl = baseUrl + "&REQUEST=GetCapabilities";
if (GetCapabilities(capUrl, out wmsCapabilities))
{
var version = wmsCapabilities.Version;
//string firstLayer = wmsCapabilities.Capability.Layer.ChildLayers[0].Name;
var formats = wmsCapabilities.Capability.Request.GetMap.Format;
if (VerboseLogging)
{
PrintFormats(ref formats, true);
}
bool found = false;
foreach (string format in formats)
{
if (format.ToLower().EndsWith(desiredFormat))
{
found = true;
break;
}
}
if (found && GetMap(baseUrl, version.VersionString, desiredLayer, bounds, desiredFormat, out tileSource))
{
string levelId = "0"; // desired zoom level
Extent extent = new Extent(bounds.MinimumCoordinates.Longitude, bounds.MinimumCoordinates.Latitude, bounds.MaximumCoordinates.Longitude, bounds.MaximumCoordinates.Latitude);
Process(tileSource, extent, out tiles, levelId);
}
else
{
Console.WriteLine("GetMap failed.");
}
}
else
{
Console.WriteLine("GetCapabilities failed.");
}
}
public void WmsCapabilitiesChildInheritsCrsFromParentLayer()
{
// arrange
var fileName = "wms_topplus_web_open.xml";
using (var stream = File.OpenRead(Path.Combine(Paths.AssemblyDirectory, "Resources", "Wms", fileName)))
{
// act
var wmsCapabilities = new WmsCapabilities(XDocument.Load(stream));
// assert
Assert.AreEqual(16, wmsCapabilities.Capability.Layer.ChildLayers.Count);
foreach (var layerChildLayer in wmsCapabilities.Capability.Layer.ChildLayers)
{
Assert.True(layerChildLayer.CRS.Count > 0);
}
}
}
/// <summary>
/// Displayes and cached the results of GetCapabilities request.
/// </summary>
private void ProcessWmsCapabilitiesResults(Task <Stream> task)
{
var server = SelectedServer;
string msg = "WMS server GetCapabilities request failed: " + Environment.NewLine;
try
{
using (var stream = task.Result)
{
WmsCapabilities capabilities;
if (WmsCapabilitiesCache.Save(server.Url, stream))
{
// ConnectStream returned by WebResponse doesn't support seek operation,
// so we can't read it twice, therefore on successful saving to the disk
// we are rereading it from file
capabilities = WmsCapabilitiesCache.Load(server.Url);
}
else
{
capabilities = new WmsCapabilities(stream);
}
DisplayServerCapabilities(capabilities);
}
}
catch (AggregateException ex)
{
MessageService.Current.Warn(msg + ex.InnerException.Message);
}
catch (Exception ex)
{
Logger.Current.Warn(msg + server.Name, ex);
}
finally
{
View.HideHourglass();
}
}
private void btnGetCapabilities_Click(object sender, EventArgs e)
{
var serverUrl = tbServerUrl.Text;
if (String.IsNullOrWhiteSpace(serverUrl))
{
return;
}
if (serverUrl.IndexOf("Request=GetCapabilities", StringComparison.OrdinalIgnoreCase) < 0)
{
serverUrl = serverUrl + "&Request=GetCapabilities";
}
if (serverUrl.IndexOf("SERVICE=WMS", StringComparison.OrdinalIgnoreCase) < 0)
{
serverUrl = serverUrl + "&SERVICE=WMS";
}
WmsCapabilities capabilities;
try
{
var myRequest = WebRequest.Create(serverUrl);
myRequest.Credentials = GetUserCredentials();
using (var myResponse = myRequest.GetResponse())
using (var stream = myResponse.GetResponseStream())
capabilities = new WmsCapabilities(stream);
}
catch (Exception ex)
{
MessageBox.Show("Unable to read capabilities: " + ex.Message);
return;
}
WmsInfo = null;
_wmsCapabilities = capabilities;
ShowServerDetails(capabilities);
InitLayers(capabilities);
}
/// <summary>
/// Creates MapWinGIS WMS provider based GetCapabilities definition and layers selected by user.
/// </summary>
public static WmsSource CreateWmsLayer(this WmsCapabilities capabilities, IEnumerable <Layer> layers, string serverUrl, ISpatialReference mapProjection)
{
var layersArray = layers as Layer[] ?? layers.ToArray();
var layer = layersArray.FirstOrDefault();
if (layer == null)
{
return(null);
}
// First try the layer, as a fallback, use the bounding box defined in the capabilities
var box = layer.ChooseBoundingBox(mapProjection) ?? capabilities.Capability.Layer.ChooseBoundingBox(mapProjection);
if (box == null)
{
MessageService.Current.Info("Failed to determine bounds of the layer.");
return(null);
}
var epsg = -1;
if (!ParseEpsg(box.CRS, ref epsg))
{
MessageService.Current.Info("Failed to determine coordinate system for the layer.");
return(null);
}
var provider = new WmsSource("WMS provider")
{
Layers = GetLayers(layersArray),
Epsg = epsg,
BoundingBox = new Envelope(box.MinX, box.MaxX, box.MinY, box.MaxY),
BaseUrl = serverUrl,
Format = capabilities.GetFormat()
};
return(provider);
}
private void InitLayers(WmsCapabilities capabilities)
{
tvLayers.Nodes.Clear();
FillTree(tvLayers.Nodes, capabilities.Capability.Layer);
tvLayers.ExpandAll();
}
protected void Application_Start(object sender, EventArgs e)
{
Database.SetInitializer <SharpMapContext>(new DropCreateDatabaseIfModelChanges <SharpMapContext>());
using (var _ctx = new SharpMapContext())
{
var caps = _ctx.Capabilities.FirstOrDefault();
if (caps == null)
{
/*create default*/
caps = new WmsCapabilities
{
Title = "SharpMap Demo Server",
Abstract = "This is an example SharpMap server",
};
caps.Keywords = "SharpMap,WMS";
_ctx.Capabilities.Add(caps);
}
WMSServer.m_Capabilities = new SharpMap.Web.Wms.Capabilities.WmsServiceDescription
{
Abstract = caps.Abstract,
AccessConstraints = caps.AccessConstraints,
Fees = caps.Fees,
Keywords = caps.Keywords.Split(','),
LayerLimit = caps.LayerLimit,
MaxHeight = caps.MaxHeight,
MaxWidth = caps.MaxWidth,
OnlineResource = caps.OnlineResource,
Title = caps.Title
};
if (_ctx.Users.Count() == 0)
{
_ctx.Users.Add(new User {
UserName = "******", Password = "******"
});
}
if (_ctx.Layers.Count() == 0)
{
/*add default layer*/
_ctx.Layers.Add(new SharpMapServer.Model.WmsLayer()
{
Name = "States", Description = "Demo data over US States", Provider = "Shapefile", DataSource = "states.shp"
});
}
WMSServer.m_Map = new SharpMap.Map();
foreach (var l in _ctx.Layers)
{
switch (l.Provider)
{
case "Shapefile":
VectorLayer lay = new VectorLayer(l.Name);
string ds = l.DataSource;
if (!Path.IsPathRooted(ds))
{
ds = Server.MapPath(ds);
}
lay.DataSource = new SharpMap.Data.Providers.ShapeFile(ds);
WMSServer.m_Map.Layers.Add(lay);
break;
}
}
_ctx.SaveChanges();
}
}
void Start()
{
WmsCapabilities wmsCapabilities = null;
ITileSource tileSource = null;
var containersList = new List <Container>();
Service.ParseName = false;
// capabilities documentation
// http://www.opengis.net/wms?service=wms&version=1.3&request=GetCapabilities
// http://schemas.opengis.net/wms/1.3.0/capabilities_1_3_0.xsd
// TEMP: url and desired layer should be rolled into a struct
const string url = "http://tgs.cognitics.net:80/geoserver/wms";
const string desiredLayer = "Base:CDB Elevation_Terrain_Primary"; // this comes down as an option from capabilities query, so a UI would be preferable but we're just hardcoding elevation for now
{
string baseUrl = url + "?SERVICE=WMS";
string capUrl = baseUrl + "&REQUEST=GetCapabilities";
if (GetCapabilities(capUrl, out wmsCapabilities))
{
var version = wmsCapabilities.Version;
//string firstLayer = wmsCapabilities.Capability.Layer.ChildLayers[0].Name;
var formats = wmsCapabilities.Capability.Request.GetMap.Format;
PrintFormats(ref formats, true);
string compatibleFormat = null;
foreach (string format in formats)
{
if (format.ToLower().EndsWith("png") || format.ToLower().EndsWith("jpg") || format.ToLower().EndsWith("jpeg"))
{
compatibleFormat = format;
break;
}
}
if (GetMap(baseUrl, version.VersionString, desiredLayer, 0, 18, compatibleFormat, out tileSource))
{
string levelId = "0"; // desired zoom level
containersList.Add(new Container()
{
name = tileSource.Name, textures = Process(tileSource, levelId)
});
}
else
{
Debug.LogError("GetMap failed.");
}
}
else
{
Debug.LogError("GetCapabilities failed.");
}
}
/*
* // resource.sgu.se/service/wms/130/brunnar?
* // SERVICE=WMS&VERSION=1.3&REQUEST=GetCapabilities&TILED=true
* {
* //var res = new List<ITileSource>(WmscTileSource.CreateFromWmscCapabilties(uri));
* const string url = "http://resource.sgu.se/service/wms/130/brunnar?service=wms&version=1.3&request=GetCapabilities&TILED=true";
* GetCapabilities(url, out wmsCapabilities);
* }
*
* // another WMS
* {
* const string url = "http://geodata.nationaalgeoregister.nl/ahn25m/wms?service=wms";
* var schema = new WkstNederlandSchema {Format = "image/jpeg"};
* schema.Validate();
* var request = new WmscRequest(new Uri(url), schema,
* layers: new[] { "ahn25m" }.ToList(),
* styles: new string[0].ToList());
* var provider = new HttpTileProvider(request);
* string levelId = "0";
* tileSource = new TileSource(provider, schema);
* containersList.Add(new Container() { name = tileSource.Name, textures = Process(tileSource, request, levelId) });
* }
*
* // OpenStreetMap
* tileSource = new HttpTileSource(new GlobalSphericalMercator(0, 18),
* "http://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png",
* new[] { "a", "b", "c" }, "OSM", name: "OpenStreetMap Source");
* containersList.Add(new Container() { name = tileSource.Name, textures = Process(tileSource) });
*
* // Google Map
* tileSource = CreateGoogleTileSource("http://mt{s}.google.com/vt/lyrs=m@130&hl=en&x={x}&y={y}&z={z}", "Google Map Source");
* containersList.Add(new Container() { name = tileSource.Name, textures = Process(tileSource) });
*
* // Google Terrain
* tileSource = CreateGoogleTileSource("http://mt{s}.google.com/vt/lyrs=t@125,r@130&hl=en&x={x}&y={y}&z={z}", "Google Terrain Source");
* containersList.Add(new Container() { name = tileSource.Name, textures = Process(tileSource) });
*
* // Here Maps
* tileSource = new HttpTileSource(new GlobalSphericalMercator(0, 18),
* "https://{s}.base.maps.cit.api.here.com/maptile/2.1/maptile/newest/normal.day/{z}/{x}/{y}/256/png8?app_id=xWVIueSv6JL0aJ5xqTxb&app_code=djPZyynKsbTjIUDOBcHZ2g",
* new[] { "1", "2", "3", "4" }, name: "Here Maps Source");
* containersList.Add(new Container() { name = tileSource.Name, textures = Process(tileSource) });
*
* // BruTile known sources
* foreach (var knownTileSource in Enum.GetValues(typeof(KnownTileSource)).Cast<KnownTileSource>())
* {
* tileSource = KnownTileSources.Create(knownTileSource);
* containersList.Add(new Container() { name = knownTileSource.ToString(), textures = Process(tileSource) });
* }
*/
containers = containersList.ToArray();
}
private static string GetFormat(this WmsCapabilities capabilities)
{
return(capabilities.Capability.Request.GetMap.Format.DefaultIfEmpty("image/png").FirstOrDefault());
}
