public WMSStyle LayerStyleByName(string name)
{
string[] p = name.Split('|');
if (p.Length != 2)
{
return(null);
}
WMSLayer layer = LayerByName(name);
if (layer == null)
{
return(null);
}
foreach (WMSStyle style in layer.Styles)
{
if (style.Name == p[1])
{
return(style);
}
}
return(null);
}
private static void parseWMSLayer(XmlNode layerXmlNode, ref List <WMSLayer> layers, WMSLayer parentLayer)
{
if (layerXmlNode != null)
{
WMSLayer layer = new WMSLayer();
layer.title = layerXmlNode.SelectSingleNode("Title").InnerText;
if (layerXmlNode.SelectSingleNode("Name") != null)
{
layer.name = layerXmlNode.SelectSingleNode("Name").InnerText;
}
else
{
layer.name = "";
}
layer.boundingBoxes = parseWMSBoundingBoxes(layerXmlNode.SelectNodes("BoundingBox"));
layer.parentLayer = parentLayer;
if (layerXmlNode.SelectSingleNode("Name") != null)
{
layers.Add(layer);
}
parseWMSLayers(layerXmlNode.SelectNodes("Layer"), ref layers, layer);
}
}
public static WMSZoomBuilder GetBuilderFromURI(string uri, WMSCatalogBuilder provider, WorldWindow worldWindow, WMSServerBuilder wmsserver)
{
string strServer = "";
string strLayer = "";
int pixelsize = 1024;
try
{
ParseURI(uri, ref strServer, ref strLayer, ref pixelsize);
WMSList oServer = provider.FindServer(strServer);
foreach (WMSLayer layer in oServer.Layers)
{
WMSLayer result = FindLayer(strLayer, layer);
if (result != null)
{
WMSZoomBuilder zoomBuilder = wmsserver.FindLayerBuilder(result);
if (zoomBuilder != null)
{
zoomBuilder.ImagePixelSize = pixelsize;
return(zoomBuilder);
}
}
}
}
catch
{
}
return(null);
}
public WMSZoomBuilder(WMSLayer layer, string cachePath, WorldWindow worldWindow, IBuilder parent)
{
m_wmsLayer = layer;
m_WorldWindow = worldWindow;
m_strCacheRoot = cachePath;
m_Parent = parent;
m_oWorld = m_WorldWindow.CurrentWorld;
m_strName = layer.Title;
}
internal WMSLayerModelNode(DappleModel oModel, WMSLayer oData)
: base(oModel)
{
m_oData = oData;
m_oBounds = new GeographicBoundingBox((double)m_oData.North, (double)m_oData.South, (double)m_oData.West, (double)m_oData.East);
m_oViewLegend = new ToolStripMenuItem("View Legend...", IconKeys.ImageList.Images[IconKeys.ViewLegendMenuItem], new EventHandler(c_miViewLegend_Click));
MarkLoaded();
}
/// <summary>
/// Returns a layer for the basemap according to that chosen by the user and saved in settings. If offline and an associated mbtiles file is present, the mbtiles layer is returned.
/// </summary>
/// <returns></returns>
public static MapLayer GetBaseMap()
{
var dirPath = Path.Combine(App.TileLocation, "mbtiles");
var BL = Preferences.Get("BaseLayer", "swisstopo_pixelkarte");
bool noInternet = MapModel.IsAppDisconnected();
var wmtsLayer = WMSLayer.CreatePixelkarteWMTSTileLayer();
if (BL == "osm")
{
wmtsLayer = OpenStreetMap.CreateTileLayer();
}
else if (BL == "swissimage")
{
wmtsLayer = WMSLayer.CreateSwissimageWMTSTileLayer();
}
var baseLayer = new MapLayer(true, 0, wmtsLayer);
if (noInternet)
{
var filename = "swisstopo_pixelkarte.mbtiles";
if (BL == "osm")
{
filename = "osm.mbtiles";
}
else if (BL == "swissimage")
{
filename = "swissimage.mbtiles";
}
foreach (var file in System.IO.Directory.GetFiles(dirPath))
{
if (file.EndsWith(filename))
{
var offlineLayer = WMSLayer.CreateOfflineLayer(file) as TileLayer;
baseLayer = new MapLayer(true, 0, offlineLayer);
return(baseLayer);
}
}
}
return(baseLayer);
}
public static WMSLayer FindLayer(string layerName, WMSLayer list)
{
foreach (WMSLayer layer in list.ChildLayers)
{
if (layer.ChildLayers != null && layer.ChildLayers.Length > 0)
{
WMSLayer result = FindLayer(layerName, layer);
if (result != null)
{
return(result);
}
}
if (layer.Name == layerName)
{
return(layer);
}
}
return(null);
}
public static void saveMaps(Extent extent, double resolution)
{
//Get the online layers
var layers = GetLayersForMap(App.CurrentProjectId);
//Create an array for adding the layers into in an ordered fashion
var mapLayersTemp = new MapLayer[layers.Count];
//Add online wms layers
var layerStack = layers.OrderBy(o => o.order).ToList();
foreach (var layer in layerStack)
{
string filePath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData), "");
var files = Directory.GetFiles(filePath);
FileStream destination = File.Create(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments), "mbtiles/new.mbtiles"));
using (var sourceStream = File.Open(filePath, FileMode.Open, FileAccess.Read))
{
sourceStream.CopyTo(destination);
}
//Now add the layers in their correct order
var layerNo = Math.Max(layers.Count - layer.order, 0);
var tileSource = WMSLayer.CreateTileSource(layer.url, layer.wmsLayer, "EPSG:3857");
var tileInfos = tileSource.Schema.GetTileInfos(extent, resolution);
// 3) Fetch the tiles from the service
Console.WriteLine("Show tile info");
foreach (var tileInfo in tileInfos)
{
var tile = tileSource.GetTile(tileInfo);
Console.WriteLine(
$"Layer: {layer.title}, " +
$"tile col: {tileInfo.Index.Col}, " +
$"tile row: {tileInfo.Index.Row}, " +
$"tile level: {tileInfo.Index.Level} , " +
$"tile size {tile.Length}");
}
}
}
internal static WMSLayer GetLayer(String strDesiredLayerName, WMSLayer[] oSearchRoot)
{
if (oSearchRoot == null)
{
return(null);
}
foreach (WMSLayer iter in oSearchRoot)
{
if (iter.Name != null && iter.Name.Equals(strDesiredLayerName))
{
return(iter);
}
WMSLayer result = GetLayer(strDesiredLayerName, iter.ChildLayers);
if (result != null)
{
return(result);
}
}
return(null);
}
private void AddCascadingLayers(Version_1_3_0.Layer layer, string parentName)
{
if (layer == null)
{
return;
}
if (layer.Layer1 != null)
{
parentName = String.IsNullOrEmpty(parentName) ? layer.Title : parentName + "/" + layer.Title;
for (int i = 0; i < layer.Layer1.Length; i++)
{
AddCascadingLayers(layer.Layer1[i], parentName);
}
}
else
{
string title = String.IsNullOrEmpty(parentName) ? layer.Title : parentName + "/" + layer.Title;
WMSLayer wmslayer = new WMSLayer(layer.Name, title);
if (layer.Style != null && layer.Style.Length > 0)
{
for (int s = 0; s < layer.Style.Length; s++)
{
wmslayer.Styles.Add(new WMSStyle(layer.Style[s].Name, layer.Style[s].Title));
}
}
if (layer.MinScaleDenominator > 0.0)
{
wmslayer.MinScale = layer.MinScaleDenominator;
}
if (layer.MaxScaleDenominator > 0.0)
{
wmslayer.MaxScale = layer.MaxScaleDenominator;
}
_layers.Add(wmslayer);
}
}
internal WMSQuadLayerBuilder(WMSLayer layer, WorldWindow worldWindow, WMSServerBuilder server, IBuilder parent)
: base(layer.Title, worldWindow, parent)
{
m_Server = server;
m_wmsLayer = layer;
distAboveSurface = 0;
m_hBoundary = new GeographicBoundingBox((double)layer.North, (double)layer.South, (double)layer.West, (double)layer.East);
// Determine the needed levels (function of tile size and resolution, for which we just use ~5 meters because it is not available with WMS)
double dRes = 5.0 / 100000.0;
if (dRes > 0)
{
double dTileSize = LevelZeroTileSize;
m_iLevels = 1;
while (dTileSize / Convert.ToDouble(TextureSizePixels) > dRes / 4.0)
{
m_iLevels++;
dTileSize /= 2;
}
}
}
internal WMSFolderModelNode(DappleModel oModel, WMSLayer oData)
: base(oModel)
{
m_oData = oData;
foreach (WMSLayer oLayer in m_oData.ChildLayers)
{
if (oLayer.ChildLayers == null)
{
AddChildSilently(new WMSLayerModelNode(m_oModel, oLayer));
}
else
{
AddChildSilently(new WMSFolderModelNode(m_oModel, oLayer));
}
}
if (oData.Name != null)
{
AddChildSilently(new WMSLayerModelNode(m_oModel, oData));
}
MarkLoaded();
}
/// <summary>
/// Creates a dictionary of the offline layers available at the file path
/// </summary>
/// <param name="dirPath"></param>
/// <returns>Dictionary of offline layers</returns>
public static Dictionary <string, ILayer> GetOfflineLayers(string dirPath)
{
//Create a dictionary of all the offline files available
var offlineLayers = new Dictionary <string, ILayer>();
foreach (var file in System.IO.Directory.GetFiles(dirPath))
{
if (file.EndsWith(".mbtiles"))
{
try
{
var offlineLayer = WMSLayer.CreateOfflineLayer(file);
if (!offlineLayers.Keys.Contains(offlineLayer.Name))
{
offlineLayers.Add(offlineLayer.Name, offlineLayer);
}
}
catch
{
}
}
}
return(offlineLayers);
}
//Mapserver layers
public ObservableCollection <MapLayer> MakeArrayOfLayers()
{
int i = 0;
//Add mbtiles layers
var dirPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments), "mbtiles");
//Create directory if it doesn't exist
if (!File.Exists(dirPath))
{
Directory.CreateDirectory(dirPath);
}
//Create a dictionary of all the offline files available
var offlineLayers = new Dictionary <string, ILayer>();
foreach (var file in System.IO.Directory.GetFiles(dirPath))
{
if (file.EndsWith(".mbtiles"))
{
var offlineLayer = WMSLayer.CreateOfflineLayer(file);
offlineLayers.Add(offlineLayer.Name, offlineLayer);
}
}
//Get the online layers
var layers = GetLayersForMap(App.CurrentProjectId);
//Create an array for adding the layers into in an ordered fashion
var mapLayersTemp = new MapLayer[layers.Count];
//Add online wms layers
var layerStack = layers.OrderBy(o => o.order).ToList();
foreach (var layer in layerStack)
{
//Now add the layers in their correct order
try
{
var layerNo = Math.Max(layers.Count - layer.order, 0);
var layerWms = WMSLayer.CreateWMSLayer(layer.url, layer.wmsLayer, "EPSG:3857", layer.title);
layerWms.Opacity = layer.opacity;
layerWms.Enabled = layer.visible;
if (Connectivity.NetworkAccess != NetworkAccess.Internet && offlineLayers.Keys.Contains(layerWms.Name))
{
//If no internet, check for saved tiles
ILayer offlineLayer;
offlineLayers.TryGetValue(layerWms.Name, out offlineLayer);
if (offlineLayer != null)
{
var WmsLayer = new MapLayer(true, 0, offlineLayer);
WmsLayer.Opacity = layerWms.Opacity;
WmsLayer.Enabled = layerWms.Enabled;
WmsLayer.LayerZ = layer.order;
WmsLayer.Name = layer.title;
mapLayersTemp.SetValue(WmsLayer, layerNo);
i++;
}
}
else
{
//If internet, read directly from WMS
if (layerWms != null)
{
var WmsLayer = new MapLayer(true, 0, layerWms);
WmsLayer.Opacity = layerWms.Opacity;
WmsLayer.Enabled = layerWms.Enabled;
WmsLayer.LayerZ = layer.order;
WmsLayer.Name = layer.title;
mapLayersTemp.SetValue(WmsLayer, layerNo);
i++;
}
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
var mapLayersTempList = mapLayersTemp.ToList().GetRange(0, i);
return(new ObservableCollection <MapLayer>(mapLayersTempList as List <MapLayer>));
}
/// <summary>
/// Save each of the map layers on-screen (the extent is provided by the screen edges) to an mbtiles file
/// </summary>
/// <param name="extent"></param>
public static async void saveMaps(Extent extent)
{
var basemap = Preferences.Get("BaseLayer", "swisstopo_pixelkarte"); //Check which basemap
var cancel = false;
MessagingCenter.Subscribe <Application>(App.Current, "CancelMapSave", (sender) =>
{
//Listen for tile save updates and update the count
cancel = true;
});
//Get the online layers
var layers = GetLayersForMap(App.CurrentProjectId);
//Create an array for adding the layers into in an ordered fashion
var mapLayersTemp = new MapLayer[layers.Count];
//Add online wms layers
var layerStack = layers.OrderBy(o => o.order).ToList();
//Calculate number of tiles
var noOfLayers = 0;
//Calculate number of tiles
long noOfTiles = 0;
foreach (var layer in layerStack)
{
if (layer.visible)
{
var tileSource = WMSLayer.CreateTileSource(layer.url, layer.wmsLayer, "EPSG:3857");
foreach (var zoomScale in tileSource.Schema.Resolutions)
{
var tileInfos = tileSource.Schema.GetTileInfos(extent, zoomScale.Value.UnitsPerPixel);
noOfTiles = noOfTiles + tileInfos.Count();
}
noOfLayers++;
}
}
if (basemap == "swisstopo_pixelkarte")
{
string swisstopoDbpath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments), "mbtiles/swisstopo.mbtiles");
TileLayer swisstopo = WMSLayer.CreatePixelkarteWMTSTileLayer();
foreach (var zoomScale in swisstopo.TileSource.Schema.Resolutions)
{
var stTileInfos = swisstopo.TileSource.Schema.GetTileInfos(extent, zoomScale.Value.UnitsPerPixel);
noOfTiles = noOfTiles + stTileInfos.Count();
}
}
else if (basemap == "swissimage")
{
string swisstopoDbpath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments), "mbtiles/swissimage.mbtiles");
TileLayer swisstopo = WMSLayer.CreateSwissimageWMTSTileLayer();
foreach (var zoomScale in swisstopo.TileSource.Schema.Resolutions)
{
var stTileInfos = swisstopo.TileSource.Schema.GetTileInfos(extent, zoomScale.Value.UnitsPerPixel);
noOfTiles = noOfTiles + stTileInfos.Count();
}
}
else
{
string osmDbpath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments), "mbtiles/osm.mbtiles");
TileLayer osm = OpenStreetMap.CreateTileLayer();
foreach (var zoomScale in osm.TileSource.Schema.Resolutions)
{
var osmTileInfos = osm.TileSource.Schema.GetTileInfos(extent, zoomScale.Value.UnitsPerPixel);
noOfTiles = noOfTiles + osmTileInfos.Count();
}
}
Console.WriteLine(noOfTiles + " tiles in " + (noOfLayers + 1) + " layers");
//Save tiles
long tilesSaved = 0;
MessagingCenter.Subscribe <Application>(App.Current, "TileSavedInternal", (sender) =>
{
//Listen for tile save updates and update the count
var message = tilesSaved + " von " + noOfTiles + " Kacheln aus " + (noOfLayers + 1) + " Ebenen gespeichert";
if (noOfLayers == 0)
{
message = tilesSaved + " von " + noOfTiles + " Kacheln aus " + (noOfLayers + 1) + " Ebene gespeichert";
}
Console.WriteLine(message);
MessagingCenter.Send <Application, string>(App.Current, "TileSaved", message);
if (tilesSaved >= noOfTiles - 5 || cancel)
{
MessagingCenter.Send <Application, string>(App.Current, "TileSaved", String.Empty);
MessagingCenter.Unsubscribe <Application>(App.Current, "TileSavedInternal");
MapModel.MakeArrayOfLayers();
}
});
var tasks = new List <Task>(); // Each layer has to be saved in a single thread due to database access, but we can save layers concurrently
foreach (var layer in layerStack)
{
if (cancel)
{
break;
}
if (layer.visible)
{
var layerNo = Math.Max(layers.Count - layer.order, 0);
var tileSource = WMSLayer.CreateTileSource(layer.url, layer.wmsLayer, "EPSG:3857");
string dbpath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments), "mbtiles/" + layer.title + ".mbtiles");
//extent = tileSource.Schema.Extent;
var layerTask = Task.Run(async() =>
{
//Create the database
Mbtiles.CreateMbTiles(dbpath, layer, tileSource);
//Populate the database
foreach (var zoomScale in tileSource.Schema.Resolutions)
{
if (cancel)
{
break;
}
await Task.Run(async() =>
{
var tileInfos = tileSource.Schema.GetTileInfos(extent, zoomScale.Value.UnitsPerPixel);
foreach (var tileInfo in tileInfos)
{
if (cancel)
{
break;
}
await Task.Run(() =>
{
tilesSaved++;
saveTile(tileSource, tileInfo, dbpath, layer);
});
}
});
}
Console.WriteLine("Saving of 1 layer complete");
});
tasks.Add(layerTask);
}
}
//Swisstopo layer
var task = Task.Run(async() =>
{
string baselayerDbsavepath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments), "mbtiles/swisstopo_pixelkarte.mbtiles");
TileLayer baselayer = WMSLayer.CreatePixelkarteWMTSTileLayer();
//Create the database
var baseLayer = new BioDivCollectorXamarin.Models.DatabaseModel.Layer();
baseLayer.title = "swisstopo pixelkarte";
if (basemap == "osm") //OSM case
{
baselayerDbsavepath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments), "mbtiles/osm.mbtiles");
baselayer = OpenStreetMap.CreateTileLayer();
//Create the database
baseLayer = new BioDivCollectorXamarin.Models.DatabaseModel.Layer();
baseLayer.title = "osm";
}
else if (basemap == "swissimage") //Swissimage case
{
baselayerDbsavepath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments), "mbtiles/swissimage.mbtiles");
baselayer = WMSLayer.CreateSwissimageWMTSTileLayer();
//Create the database
baseLayer = new BioDivCollectorXamarin.Models.DatabaseModel.Layer();
baseLayer.title = "swissimage";
}
Mbtiles.CreateMbTiles(baselayerDbsavepath, baseLayer, baselayer.TileSource);
//Populate the database
foreach (var zoomScale in baselayer.TileSource.Schema.Resolutions)
{
if (cancel)
{
break;
}
await Task.Run(async() =>
{
var baseLayerTileInfos = baselayer.TileSource.Schema.GetTileInfos(extent, zoomScale.Value.UnitsPerPixel);
foreach (var tileInfo in baseLayerTileInfos)
{
if (cancel)
{
break;
}
await Task.Run(() =>
{
tilesSaved++;
saveTile(baselayer.TileSource, tileInfo, baselayerDbsavepath, baseLayer);
});
}
});
}
Console.WriteLine("Baselayer saved");
});
tasks.Add(task);
await Task.WhenAll(tasks);
}
/// <summary>
/// Create an array of map layers: either mbtiles layers if offline and the mbtiles file exists, or direct links to the map servers
/// </summary>
/// <returns>An observable collection of map layers</returns>
public static ObservableCollection <MapLayer> MakeArrayOfLayers()
{
int i = 0;
//Add mbtiles layers
var dirPath = Path.Combine(App.TileLocation, "mbtiles");
//Create directory if it doesn't exist
if (!File.Exists(dirPath))
{
Directory.CreateDirectory(dirPath);
}
//Get the offline layers
var offlineLayers = GetOfflineLayers(dirPath);
//Get the online layers
var layers = GetLayersForMap(App.CurrentProjectId);
//Create an array for adding the layers into in an ordered fashion
var mapLayersTemp = new MapLayer[layers.Count];
//Add online wms layers
var layerStack = layers.OrderBy(o => o.order).ToList();
bool noInternet = MapModel.IsAppDisconnected();
foreach (var layer in layerStack)
{
//Now add the layers in their correct order
try
{
var layerNo = Math.Max(layers.Count - layer.order, 0);
bool offlineLayerExists = offlineLayers.Keys.Contains(layer.title);
if (noInternet && offlineLayerExists)
{
//If no internet, check for saved tiles
ILayer offlineLayer;
offlineLayers.TryGetValue(layer.title, out offlineLayer);
if (offlineLayer != null)
{
offlineLayer.Opacity = layer.opacity;
offlineLayer.Enabled = layer.visible;
var WmsLayer = new MapLayer(true, 0, offlineLayer);
WmsLayer.Opacity = layer.opacity;
WmsLayer.Enabled = layer.visible;
WmsLayer.LayerZ = layer.order;
WmsLayer.Name = layer.title;
mapLayersTemp.SetValue(WmsLayer, layerNo);
var path = dirPath + "/" + layer.title;
FileInfo fi = new FileInfo(dirPath + "/" + layer.title + ".mbtiles");
if (fi != null)
{
WmsLayer.LocalStorage = fi.Length;
}
else
{
WmsLayer.LocalStorage = 0;
}
i++;
}
}
else
{
//If internet, read directly from WMS
var layerWms = WMSLayer.CreateWMSLayer(layer.url, layer.wmsLayer, "EPSG:3857", layer.title);
layerWms.Opacity = layer.opacity;
layerWms.Enabled = layer.visible;
if (layerWms != null)
{
var WmsLayer = new MapLayer(true, 0, layerWms);
WmsLayer.Opacity = layer.opacity;
WmsLayer.Enabled = layer.visible;
WmsLayer.LayerZ = layer.order;
WmsLayer.Name = layer.title;
mapLayersTemp.SetValue(WmsLayer, layerNo);
if (offlineLayerExists)
{
var path = dirPath + "/" + layer.title;
FileInfo fi = new FileInfo(dirPath + "/" + layer.title + ".mbtiles");
if (fi != null)
{
WmsLayer.LocalStorage = fi.Length;
}
else
{
WmsLayer.LocalStorage = 0;
}
}
i++;
}
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
var mapLayersTempList = mapLayersTemp.ToList().GetRange(0, i);
return(new ObservableCollection <MapLayer>(mapLayersTempList as List <MapLayer>));
}
private static void parseWMSLayers(XmlNodeList layersNodes, ref List <WMSLayer> layers, WMSLayer parentLayer)
{
if (layersNodes.Count > 0)
{
foreach (XmlNode layerNode in layersNodes)
{
parseWMSLayer(layerNode, ref layers, parentLayer);
}
}
}
public CapabilitiesHelper(object capabilities)
{
_caps = capabilities;
if (_caps is Version_1_1_1.WMT_MS_Capabilities)
{
Version_1_1_1.WMT_MS_Capabilities caps = (Version_1_1_1.WMT_MS_Capabilities)_caps;
#region GetMap
if (caps.Capability.Request.GetMap != null &&
caps.Capability.Request.GetMap.DCPType != null &&
caps.Capability.Request.GetMap.DCPType.Length > 0)
{
foreach (object http in caps.Capability.Request.GetMap.DCPType[0].HTTP)
{
if (http is Version_1_1_1.Get)
{
_getMapOnlineResource = ((Version_1_1_1.Get)http).OnlineResource.href;
}
}
}
if (caps.Capability.Request.GetMap != null)
{
_imageFormats = caps.Capability.Request.GetMap.Format;
}
#endregion
#region GetFeatureInfo
if (caps.Capability.Request.GetFeatureInfo != null &&
caps.Capability.Request.GetFeatureInfo.DCPType != null &&
caps.Capability.Request.GetFeatureInfo.DCPType.Length > 0)
{
foreach (object http in caps.Capability.Request.GetFeatureInfo.DCPType[0].HTTP)
{
if (http is Version_1_1_1.Get)
{
_getFeatureInfoOnlineResource = ((Version_1_1_1.Get)http).OnlineResource.href;
}
}
}
if (caps.Capability.Request.GetFeatureInfo != null)
{
_getFeatureInfoFormats = caps.Capability.Request.GetFeatureInfo.Format;
}
#endregion
#region GetLegendGraphic
if (caps.Capability.Request.GetLegendGraphic != null &&
caps.Capability.Request.GetLegendGraphic.DCPType != null &&
caps.Capability.Request.GetLegendGraphic.DCPType.Length > 0)
{
foreach (object http in caps.Capability.Request.GetLegendGraphic.DCPType[0].HTTP)
{
if (http is Version_1_1_1.Get)
{
_getLegendGraphicOnlineResource = ((Version_1_1_1.Get)http).OnlineResource.href;
}
}
}
#endregion
#region Layers
for (int i = 0; i < caps.Capability.Layer.Layer1.Length; i++)
{
Version_1_1_1.Layer layer = caps.Capability.Layer.Layer1[i];
WMSLayer wmslayer = new WMSLayer(layer.Name, layer.Title);
if (layer.Style != null && layer.Style.Length > 0)
{
for (int s = 0; s < layer.Style.Length; s++)
{
wmslayer.Styles.Add(new WMSStyle(layer.Style[s].Name, layer.Style[s].Title));
}
}
if (layer.ScaleHint != null)
{
try { wmslayer.MinScale = double.Parse(layer.ScaleHint.min.Replace(",", "."), Nhi) * 2004.4; }
catch { }
try { wmslayer.MaxScale = double.Parse(layer.ScaleHint.max.Replace(",", "."), Nhi) * 2004.4; }
catch { }
}
_layers.Add(wmslayer);
}
#endregion
}
else if (_caps is Version_1_3_0.WMS_Capabilities)
{
Version_1_3_0.WMS_Capabilities caps = (Version_1_3_0.WMS_Capabilities)_caps;
#region GetMap
if (caps.Capability.Request.GetMap.DCPType.Length > 0)
{
_getMapOnlineResource = caps.Capability.Request.GetMap.DCPType[0].HTTP.Get.OnlineResource.href;
}
_imageFormats = caps.Capability.Request.GetMap.Format;
#endregion
#region GetFeatureInfo
if (caps.Capability.Request.GetMap.DCPType.Length > 0)
{
_getFeatureInfoOnlineResource = caps.Capability.Request.GetFeatureInfo.DCPType[0].HTTP.Get.OnlineResource.href;
}
_getFeatureInfoFormats = caps.Capability.Request.GetFeatureInfo.Format;
#endregion
#region Layers
for (int l = 0; l < caps.Capability.Layer.Length; l++)
{
AddCascadingLayers(caps.Capability.Layer[l], String.Empty);
}
#endregion
}
}
