protected void SetTileSource(ITileSource source)
{
tileSource = source;
tileFetcher = new TileFetcher(source, memoryCache, maxRetries);
tileFetcher.DataChanged += TileFetcherDataChanged;
OnPropertyChanged("Envelope");
}
private void InitializeLayer()
{
var mxdoc = (IMxDocument)_application.Document;
_map = mxdoc.FocusMap;
_cacheDir = CacheSettings.GetCacheFolder();
_tileTimeOut = ConfigurationHelper.GetTileTimeOut();
var spatialReferences = new SpatialReferences();
_tileSource = _config.CreateTileSource();
_schema = _tileSource.Schema;
_dataSpatialReference = spatialReferences.GetSpatialReference(_schema.Srs);
_envelope = GetDefaultEnvelope();
if (_map.SpatialReference == null)
{
// zet dan de spatial ref...
_map.SpatialReference = _dataSpatialReference;
}
// If there is only one layer in the TOC zoom to this layer...
if (_map.LayerCount == 0)
{
//envelope.Expand(-0.1, -0.1, true);
_envelope.Project(_map.SpatialReference);
((IActiveView)_map).Extent = _envelope;
}
_displayFilter = new TransparencyDisplayFilterClass();
}
/// <summary>
/// New instance of Google Maps Disclaimer
/// </summary>
public GoogleMapsDisclaimer()
{
m_MathTransform = null; //Assuming WGS84
m_Font = new Font("Arial", (float)Math.Floor((11.0 * 72 / 96)));
m_Language = System.Threading.Thread.CurrentThread.CurrentCulture.Name;
m_TileSource = new BruTile.Web.GoogleTileSource(BruTile.Web.GoogleMapType.GoogleMap);
}
public static TileInfos GetTiles(IActiveView activeView, ITileSource tileSource)
{
var schema = tileSource.Schema;
var env = Projector.ProjectEnvelope(activeView.Extent, schema.Srs);
if (!env.IsEmpty)
{
Logger.Debug("Tilesource schema srs: " + schema.Srs);
Logger.Debug("Projected envelope: xmin:" + env.XMin +
", ymin:" + env.YMin +
", xmax:" + env.YMax +
", ymax:" + env.YMax
);
var mapWidth = activeView.ExportFrame.right;
var mapHeight = activeView.ExportFrame.bottom;
var resolution = env.GetMapResolution(mapWidth);
Logger.Debug("Map resolution: " + resolution);
var centerPoint = env.GetCenterPoint();
var transform = new Transform(centerPoint, resolution, mapWidth, mapHeight);
var level = Utilities.GetNearestLevel(schema.Resolutions, transform.Resolution);
Logger.Debug("Current level: " + level);
var tiles = schema.GetTilesInView(transform.Extent, level);
var ti = new TileInfos {
Level = level, Tiles = tiles.ToList()
};
return(ti);
}
return(new TileInfos());
}
private static bool IsMatch(ITileSource wmtsTileSource, string capabilityIdentifier, string preferredFormat)
{
var schema = (WmtsTileSchema)wmtsTileSource.Schema;
return(schema.Identifier.Equals(capabilityIdentifier) &&
schema.Format.Equals(preferredFormat));
}
public SimpleFileFetcher(ITileSource tileSource, FileCache filecache)
{
if (tileSource == null) throw new ArgumentNullException("tileSource");
if (filecache == null) throw new ArgumentNullException("filecache");
_tileSource = tileSource;
_fileCache = filecache;
}
private static bool EqualTileSources(ITileSource ts1, ITileSource ts2, out string message)
{
if (!ReferenceEquals(ts1, ts2))
{
if (ts1 == null)
{
message = "The reference tile source is null!";
return(false);
}
if (ts2 == null)
{
message = "One of the tile sources is null, and the other not";
return(false);
}
if (!EqualTileSchemas(ts1.Schema, ts2.Schema, out message))
{
return(false);
}
if (!EqualTileProviders(ts1.Schema, (ITileProvider)ts1, (ITileProvider)ts2, out message))
{
return(false);
}
}
message = "Tile sources seem to be equal";
return(true);
}
/// <summary>
/// New instance of Google Maps Disclaimer
/// </summary>
public GoogleMapsDisclaimer()
{
_mathTransform = null; //Assuming WGS84
_font = new Font("Arial", (float)Math.Floor((11.0 * 72 / 96)));
//_language = Thread.CurrentThread.CurrentCulture.Name;
_tileSource = new BruTile.Web.GoogleTileSource(BruTile.Web.GoogleMapType.GoogleMap);
}
/// <summary>
/// New instance of Google Maps Disclaimer
/// </summary>
public GoogleMapsDisclaimer()
{
m_MathTransform = null; //Assuming WGS84
m_Font = new Font("Arial", (float)Math.Floor((11.0 * 72 / 96)));
m_Language = System.Threading.Thread.CurrentThread.CurrentCulture.Name;
m_TileSource = new BruTile.Web.GoogleTileSource(BruTile.Web.GoogleMapType.GoogleMap);
}
// used by WMTS
public BruTileLayer(IApplication application, ITileSource tileSource)
{
LayerWeight = 110;
Cached = true;
_enumBruTileLayer = EnumBruTileLayer.WMTS;
_application = application;
var mxdoc = (IMxDocument)_application.Document;
_map = mxdoc.FocusMap;
_cacheDir = CacheSettings.GetCacheFolder();
_tileTimeOut = ConfigurationHelper.GetTileTimeOut();
var spatialReferences = new SpatialReferences();
_tileSource = tileSource;
_schema = _tileSource.Schema;
_dataSpatialReference = spatialReferences.GetSpatialReference(_schema.Srs);
_envelope = GetDefaultEnvelope();
if (_map.SpatialReference == null)
{
// zet dan de spatial ref...
_map.SpatialReference = _dataSpatialReference;
}
// If there is only one layer in the TOC zoom to this layer...
if (_map.LayerCount == 0)
{
_envelope.Project(_map.SpatialReference);
((IActiveView)_map).Extent = _envelope;
}
_displayFilter = new TransparencyDisplayFilterClass();
}
public FileFetcher(ITileSource tileSource, FileCache filecache)
{
_tileSource = tileSource;
_fileCache = filecache;
StartFetchLoop();
}
public MapControl()
{
_canvas = new Canvas
{
VerticalAlignment = VerticalAlignment.Stretch,
HorizontalAlignment = HorizontalAlignment.Stretch,
Background = new SolidColorBrush(Colors.Transparent),
};
Children.Add(_canvas);
_renderer = new Renderer(_canvas);
_tileSource = TileSource.Create(KnownTileServers.Mapnik);
CompositionTarget.Rendering += CompositionTargetRendering;
SizeChanged += MapControlSizeChanged;
MouseWheel += MapControlMouseWheel;
MouseMove += MapControlMouseMove;
MouseUp += OnMouseUp;
MouseLeave += OnMouseLeave;
ClipToBounds = true;
_fetcher = new Fetcher<Image>(_tileSource, _tileCache);
_fetcher.DataChanged += FetcherOnDataChanged;
_invalid = true;
}
public static void MethodOnThread(IAsyncResult ar)
{
CreateTileSourceCompleted callback = null;
Exception error = null;
ITileSource tileSource = null;
try
{
var args = (object[])ar.AsyncState;
callback = (CreateTileSourceCompleted)args[0];
var request = (HttpWebRequest)args[1];
var overrideUrl = (string)args[2];
var response = request.EndGetResponse(ar);
tileSource = CreateTileSource(response.GetResponseStream(), overrideUrl);
}
catch (Exception ex)
{
error = ex;
}
if (callback != null)
{
callback(tileSource, error);
}
}
private void button1_Click(object sender, EventArgs e)
{
extent.Add(double.Parse(textBox3.Text));
extent.Add(double.Parse(textBox4.Text));
extent.Add(double.Parse(textBox5.Text));
extent.Add(double.Parse(textBox2.Text));
var tile = comboBox1.SelectedItem;
if (tile == null)
{
MessageBox.Show("请选择至少一种地图");
return;
}
EnumBruTileLayer enumBruTileLayer = (EnumBruTileLayer)Enum.Parse(typeof(EnumBruTileLayer), tile.ToString());
IConfig config = ConfigHelper.GetConfig(enumBruTileLayer);
string cacheDir = CacheSettings.GetCacheFolder();
tileSource = config.CreateTileSource();
schema = tileSource.Schema;
tileProvider = (WebTileProvider)tileSource.Provider;
fileCache = CacheDirectory.GetFileCache(cacheDir, config, enumBruTileLayer);
_tiles = GetTile();
if (_tiles.ToList().Count > 0)
{
DownloadTiles();
}
}
public static async Task DrawLayerAsync(
ITileSource source,
int width,
int height,
Models.Bounds boundingBox,
SKCanvas outputCanvas,
bool isTransparent,
uint backgroundColor)
{
// TODO: check SRS support in source
if ((String.Compare(source.Configuration.Type, SourceConfiguration.TypeWms, StringComparison.OrdinalIgnoreCase) == 0) &&
(source.Configuration.Cache == null))
{
// Cascading GetMap request to WMS source as single GetMap request
var imageData = await((TileSources.HttpTileSource)source).GetWmsMapAsync(width, height, boundingBox, isTransparent, backgroundColor);
if (imageData != null)
{
WmsHelper.DrawImageUnscaledToRasterCanvas(outputCanvas, imageData);
}
}
else
{
var tileCoordinates = WmsHelper.BuildTileCoordinatesList(boundingBox, width);
var sourceTiles = await GetSourceTilesAsync(source, tileCoordinates);
if (sourceTiles.Count > 0)
{
WmsHelper.DrawWebMercatorTilesToRasterCanvas(outputCanvas, width, height, boundingBox, sourceTiles, backgroundColor, U.WebMercator.TileSize);
}
}
}
private void LoadMap()
{
Map map = new Map();
ITileSource tileSource = KnownTileSources.Create(KnownTileSource.OpenStreetMap);
TileAsyncLayer tileLayer = new TileAsyncLayer(tileSource, "Basemap");
map.BackgroundLayer.Add(tileLayer);
VectorLayer shpLayer = new VectorLayer("Points");
shpLayer.DataSource = new ShapeFile("Data/indian_points.shp", true);
shpLayer.Style.SymbolScale = 0.8f;
shpLayer.CoordinateTransformation = Wgs84toGoogleMercator; //Here it re-projects our degree decimal data to Google mercator
shpLayer.ReverseCoordinateTransformation = GoogleMercatorToWgs84;
shpLayer.SRID = 4326;
map.Layers.Add(shpLayer);
mapBox1.Map = map;
mapBox1.Map.ZoomToExtents();
mapBox1.Refresh();
}
public BackgroundLayer(ITileSource tileSource, string name, int order)
: base(tileSource)
{
Name = name;
Order = order;
CRS = tileSource.Schema.Srs;
}
public static ILayer CreateTileLayer(ITileSource tileSource, string name = null)
{
return(new TileLayer(tileSource)
{
Name = name ?? tileSource.Name
});
}
private ITileSource CreateTileSource(Source source)
{
ITileSource tileSource = null;
if (source.Tiles == null || source.Tiles.Count == 0)
{
return(null);
}
if (source.Tiles[0].StartsWith("http"))
{
tileSource = new HttpTileSource(new GlobalSphericalMercator(
source.Scheme == "tms" ? YAxis.TMS : YAxis.OSM,
minZoomLevel: source.ZoomMin ?? 0,
maxZoomLevel: source.ZoomMax ?? 30
),
source.Tiles[0], //"{s}",
source.Tiles,
name: source.Name,
attribution: new Attribution(source.Attribution)
);
}
else if (source.Tiles[0].StartsWith("mbtiles://"))
{
// We should get the tile source from someone else
tileSource = new MbTilesTileSource(new SQLiteConnectionString(source.Tiles[0].Substring(10), false),
new GlobalSphericalMercator(
source.Scheme == "tms" ? YAxis.TMS : YAxis.OSM,
minZoomLevel: source.ZoomMin ?? 0,
maxZoomLevel: source.ZoomMax ?? 14
));
}
return(tileSource);
}
public MapControl()
{
var canvas = new Canvas
{
VerticalAlignment = VerticalAlignment.Stretch,
HorizontalAlignment = HorizontalAlignment.Stretch,
Background = new SolidColorBrush(Colors.Transparent),
};
Children.Add(canvas);
_renderer = new Renderer(canvas);
_tileSource = KnownTileSources.Create();
CompositionTarget.Rendering += CompositionTargetRendering;
SizeChanged += MapControlSizeChanged;
MouseWheel += MapControlMouseWheel;
MouseMove += MapControlMouseMove;
MouseUp += OnMouseUp;
MouseLeave += OnMouseLeave;
ClipToBounds = true;
_fetcher = new Fetcher <Image>(_tileSource, _tileCache);
_fetcher.DataChanged += FetcherOnDataChanged;
_invalid = true;
}
/// <summary>
/// Create tile layer for given tile source
/// </summary>
/// <param name="source">Tile source to use for this layer</param>
/// <param name="minTiles">Minimum number of tiles to cache</param>
/// <param name="maxTiles">Maximum number of tiles to cache</param>
/// <param name="maxRetries">Unused</param>
/// <param name="dataFetchStrategy">Strategy to get list of tiles for given extent</param>
/// <param name="renderFetchStrategy"></param>
/// <param name="minExtraTiles">Number of minimum extra tiles for memory cache</param>
/// <param name="maxExtraTiles">Number of maximum extra tiles for memory cache</param>
// ReSharper disable once UnusedParameter.Local // Is public and won't break this now
public TileLayer(ITileSource source = null, int minTiles = 200, int maxTiles = 300,
IDataFetchStrategy dataFetchStrategy = null, IRenderFetchStrategy renderFetchStrategy = null,
int minExtraTiles = -1, int maxExtraTiles = -1, Func <TileInfo, Feature> fetchTileAsFeature = null)
{
MemoryCache = new MemoryCache <Feature>(minTiles, maxTiles);
Style = new VectorStyle {
Outline = { Color = Color.FromArgb(0, 0, 0, 0) }
}; // initialize with transparent outline
_tileSource = source;
if (_tileSource != null)
{
if (Attribution == null)
{
Attribution = new Hyperlink();
}
Attribution.Text = _tileSource.Attribution?.Text;
Attribution.Url = _tileSource.Attribution?.Url;
}
_envelope = _tileSource?.Schema?.Extent.ToBoundingBox();
dataFetchStrategy = dataFetchStrategy ?? new DataFetchStrategy(3);
_renderFetchStrategy = renderFetchStrategy ?? new RenderFetchStrategy();
_minExtraTiles = minExtraTiles;
_maxExtraTiles = maxExtraTiles;
_tileFetchDispatcher = new TileFetchDispatcher(MemoryCache, source.Schema, fetchTileAsFeature ?? ToFeature, dataFetchStrategy);
_tileFetchDispatcher.DataChanged += TileFetchDispatcherOnDataChanged;
_tileFetchDispatcher.PropertyChanged += TileFetchDispatcherOnPropertyChanged;
}
public void ProcessRequest(HttpContext context)
{
RuntimeManager.BindLicense(ProductCode.EngineOrDesktop);
extent = context.Request.QueryString["Extent"].Split(new[] { ',' }).Select(Convert.ToDouble).ToList();
level = double.Parse(context.Request.QueryString["level"]);
_config = ConfigHelper.GetConfig(EnumBruTileLayer.OSM);
_tileSource = _config.CreateTileSource();
_tileProvider = (WebTileProvider)_tileSource.Provider;
_cacheDir = CacheSettings.GetCacheFolder();
_fileCache = CacheDirectory.GetFileCache(_cacheDir, _config, EnumBruTileLayer.OSM);
Draw();
//using (Bitmap map = new Bitmap(@"D:\我的文件\天津师大切片解决方案\DownloadTiles\DownloadTiles\bin\Debug\p.png"))
using (Bitmap map = mosaicImage())
{
using (MemoryStream mem = new MemoryStream())
{
map.Save(mem, ImageFormat.Png);
mem.Seek(0, SeekOrigin.Begin);
context.Response.ContentType = "image/png";
mem.CopyTo(context.Response.OutputStream, 4096);
context.Response.Flush();
}
}
}
// for wmts
private static string GetCacheDirectory(ITileSource tileSource, EnumBruTileLayer layerType, string baseCacheDir)
{
var name = (tileSource is BruTile.Web.HttpTileSource ? tileSource.Name : ((WmtsTileSchema)tileSource.Schema).Layer);
string cacheDirectory = string.Format("{0}{1}{2}{3}{4}", baseCacheDir, Path.DirectorySeparatorChar, layerType, Path.DirectorySeparatorChar, name);
return(cacheDirectory);
}
public static ITileSource Build(
string urlToTileMapXml,
bool overrideTmsUrlWithUrlToTileMapXml)
{
var webRequest = (HttpWebRequest)WebRequest.Create(urlToTileMapXml);
var waitHandle = new AutoResetEvent(false);
ITileSource tileSource = null;
Exception error = null;
var state = new object[]
{
new Action <Exception>(ex =>
{
error = ex;
waitHandle.Set();
}),
new Action <ITileSource>(ts =>
{
tileSource = ts;
waitHandle.Set();
}),
webRequest,
urlToTileMapXml,
overrideTmsUrlWithUrlToTileMapXml
};
webRequest.BeginGetResponse(LoadTmsLayer, state);
waitHandle.WaitOne();
if (error != null)
{
throw error;
}
return(tileSource);
}
/// <summary>
/// Creates a fully initialized instance of <see cref="WellKnownTileSourceLayerConfiguration"/>.
/// </summary>
/// <param name="wellKnownTileSource">The tile provider to be used.</param>
/// <returns>The new <see cref="WellKnownTileSourceLayerConfiguration"/>.</returns>
/// <exception cref="NotSupportedException">Thrown when <paramref name="wellKnownTileSource"/>
/// isn't a supported member.</exception>
/// <exception cref="CannotCreateTileCacheException">Thrown when creating the file
/// cache failed.</exception>
public static WellKnownTileSourceLayerConfiguration CreateInitializedConfiguration(WellKnownTileSource wellKnownTileSource)
{
KnownTileSource knownTileSourceEquivalent = WellKnownTileSourceToKnownTileSource(wellKnownTileSource);
ITileSource tileSource = TileSourceFactory.Instance.GetKnownTileSource(knownTileSourceEquivalent);
return(new WellKnownTileSourceLayerConfiguration(knownTileSourceEquivalent, tileSource));
}
/// <summary>
/// Creates a fully initialized instance of <see cref="WmtsLayerConfiguration"/>.
/// </summary>
/// <param name="wmtsCapabilitiesUrl">The capabilities URL of the WMTS.</param>
/// <param name="capabilityIdentifier">The capability name to get tiles from.</param>
/// <param name="preferredFormat">The preferred tile image format, as MIME-type.</param>
/// <returns>The new <see cref="WmtsLayerConfiguration"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when any input argument is <c>null</c>.</exception>
/// <exception cref="ArgumentException">Thrown when <paramref name="preferredFormat"/>
/// is not an image MIME-type.</exception>
/// <exception cref="CannotFindTileSourceException">Thrown when it has become impossible
/// to create an <see cref="ITileSource"/> based on the given information (for example:
/// unable to connect to server).</exception>
/// <exception cref="CannotReceiveTilesException">Thrown when the configured <see cref="ITileSource"/>
/// does not allow for tiles to be retrieved.</exception>
/// <exception cref="CannotCreateTileCacheException">Thrown when a critical error
/// occurs when creating the tile cache.</exception>
public static WmtsLayerConfiguration CreateInitializedConfiguration(string wmtsCapabilitiesUrl, string capabilityIdentifier, string preferredFormat)
{
ValidateConfigurationParameters(wmtsCapabilitiesUrl, capabilityIdentifier, preferredFormat);
ITileSource tileSource = GetConfiguredTileSource(wmtsCapabilitiesUrl, capabilityIdentifier, preferredFormat);
return(new WmtsLayerConfiguration(wmtsCapabilitiesUrl, tileSource));
}
public VectorTileLayer(ITileSource tileSource, RenderGetStrategy renderStrategy = null)
{
_tileSource = tileSource;
_tileFetcher = new TileFetcher(_tileSource, _tileCache, 1, 4, _fetchStrategy);
_tileFetcher.DataChanged += TileFetcherOnDataChanged;
_tileFetcher.PropertyChanged += TileFetcherOnPropertyChanged;
_renderStrategy = renderStrategy ?? new RenderGetStrategy();
}
/// <summary>
/// Validates an <see cref="ITileSource"/>.
/// </summary>
/// <param name="tileSource">The source to be validated.</param>
/// <returns>Returns <paramref name="tileSource"/>.</returns>
/// <exception cref="CannotCreateTileCacheException">Thrown when <paramref name="tileSource"/>
/// doesn't contain a <see cref="WmtsTileSchema"/>.</exception>
private static ITileSource ValidateTileSource(ITileSource tileSource)
{
if (!(tileSource.Schema is WmtsTileSchema))
{
throw new CannotCreateTileCacheException(Resources.WmtsLayerConfiguration_ValidateTileSource_TileSource_must_have_WmtsTileSchema);
}
return(tileSource);
}
/// <summary>
/// Creates a new initialized instance of <see cref="WmtsLayerConfiguration"/>.
/// </summary>
/// <param name="wmtsCapabilitiesUrl">The capabilities URL of the WMTS.</param>
/// <param name="tileSource">The tile source.</param>
/// <exception cref="CannotCreateTileCacheException">Thrown when creating the file
/// cache failed.</exception>
/// <exception cref="CannotReceiveTilesException">Thrown when <paramref name="tileSource"/>
/// does not allow for tiles to be retrieved.</exception>
/// <exception cref="CannotCreateTileCacheException">Thrown when a critical error
/// occurs when creating the tile cache.</exception>
private WmtsLayerConfiguration(string wmtsCapabilitiesUrl, ITileSource tileSource)
: base(SuggestTileCachePath(ValidateTileSource(tileSource)))
{
capabilitiesUri = wmtsCapabilitiesUrl;
capabilityIdentifier = ((WmtsTileSchema)tileSource.Schema).Identifier;
preferredFormat = tileSource.Schema.Format;
InitializeFromTileSource(tileSource);
}
/// <summary>
/// Creates an instance of <see cref="WellKnownTileSourceLayerConfiguration"/>.
/// </summary>
/// <param name="knownTileSource">The built-in tile provider to be used.</param>
/// <param name="persistentCacheDirectoryPath">The directory path to the persistent tile cache.</param>
/// <exception cref="ArgumentException">Thrown when <paramref name="persistentCacheDirectoryPath"/>
/// is an invalid folder path.</exception>
/// <exception cref="NotSupportedException">Thrown when <paramref name="knownTileSource"/>
/// isn't a supported member.</exception>
/// <exception cref="CannotCreateTileCacheException">Thrown when creating the file
/// cache failed.</exception>
private WellKnownTileSourceLayerConfiguration(string persistentCacheDirectoryPath, KnownTileSource knownTileSource)
: base(persistentCacheDirectoryPath)
{
this.knownTileSource = knownTileSource;
ITileSource tileSource = TileSourceFactory.Instance.GetKnownTileSource(knownTileSource);
InitializeFromTileSource(tileSource);
}
/// <summary>
/// Creates an instance of this class
/// </summary>
/// <param name="tileSource">the source to get the tiles from</param>
/// <param name="layerName">name of the layer</param>
/// <param name="transparentColor">transparent color off</param>
/// <param name="showErrorInTile">generate an error tile if it could not be retrieved from source</param>
/// <param name="fileCache">If the layer should use a file-cache so store tiles, set this to a fileCacheProvider. Set to null to avoid filecache</param>
/// <param name="imgFormat">Set the format of the tiles to be used</param>
public TileLayer(ITileSource tileSource, string layerName, Color transparentColor, bool showErrorInTile, FileCache fileCache, ImageFormat imgFormat)
{
_source = tileSource;
LayerName = layerName;
_transparentColor = transparentColor;
_showErrorInTile = showErrorInTile;
_fileCache = fileCache;
_ImageFormat = imgFormat;
}
public TileFetcher(ITileSource tileSource, MemoryCache<Feature> memoryCache, int maxRetries = 2)
{
if (tileSource == null) throw new ArgumentException("TileProvider can not be null");
this.tileSource = tileSource;
if (memoryCache == null) throw new ArgumentException("MemoryCache can not be null");
this.memoryCache = memoryCache;
this.maxRetries = maxRetries;
}
public static BruTileLayer GetWmtsLayer(IApplication _application, ITileSource tileSource, string LayerName)
{
var brutileLayer = new BruTileLayer(_application, tileSource)
{
Name = LayerName,
Visible = true
};
return(brutileLayer);
}
private void getSampleFileFromInternetToolStripMenuItem_Click(object sender, EventArgs e)
{
var path = Path.Combine(Path.GetTempPath(), "mapbox.haiti-terrain.mbtiles");
var req = WebRequest.Create("http://a.tiles.mapbox.com/mapbox/download/haiti-terrain.mbtiles");
var success = true;
try
{
Enabled = false;
var tmpFile = Path.GetTempFileName();
using (var response = req.GetResponse())
{
using (var streamWriter = new BinaryWriter(File.OpenWrite(tmpFile)))
{
using (var stream = response.GetResponseStream())
{
var buffer = new byte[4 * 8192];
while (true)
{
var read = stream.Read(buffer, 0, buffer.Length);
if (read <= 0)
{
break;
}
streamWriter.Write(buffer, 0, read);
}
}
}
}
_source = null;
File.Copy(tmpFile, path, true);
File.Delete(tmpFile);
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
success = false;
//throw;
}
finally
{
if (success)
{
_source = new MbTilesTileSource(path);
var scale = (float)(1.1 * Math.Max(_source.Schema.Extent.Width / picMap.Width, _source.Schema.Extent.Height / picMap.Height));
_mapTransform = new MapTransform(
new PointF((float)_source.Schema.Extent.CenterX, (float)_source.Schema.Extent.CenterY),
scale, picMap.Width, picMap.Height);
RenderToBuffer();
}
Enabled = true;
}
}
public TileManager(string tileServerName, string tileServerUrl, WmsServerInfo wmsServerInfo)
{
if (tileServerName == null) throw new ArgumentNullException("tileServerName");
_tileServerUrl = tileServerUrl;
_tileServerName = tileServerName;
WmsServerInfo = wmsServerInfo;
TileCache = new FileCache(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData),
"TileCache", _tileServerName), "", new TimeSpan(30, 0, 0, 0));
_tileSource = InitializeBrutileProvider();
}
public TileFetcher(ITileSource tileSource, MemoryCache<Feature> memoryCache, int maxAttempts = DefaultMaxAttempts, int maxThreads = DefaultMaxThreads, IFetchStrategy strategy = null)
{
if (tileSource == null) throw new ArgumentException("TileProvider can not be null");
if (memoryCache == null) throw new ArgumentException("MemoryCache can not be null");
_tileSource = tileSource;
_memoryCache = memoryCache;
_maxAttempts = maxAttempts;
_maxThreads = maxThreads;
_strategy = strategy ?? new FetchStrategy();
}
public void SetTileSource(ITileSource source)
{
_tileSource = source;
_tileCache.Clear();
_fetcher.DataChanged -= FetcherOnDataChanged;
_fetcher.AbortFetch();
_fetcher = new Fetcher<Image>(_tileSource, _tileCache);
_fetcher.DataChanged += FetcherOnDataChanged;
_fetcher.ViewChanged(_viewport.Extent, _viewport.Resolution);
_invalid = true;
}
private void lbServices_SelectedIndexChanged(object sender, EventArgs e)
{
if (lbServices.SelectedItem != null)
{
var name = (String)lbServices.SelectedItem;
foreach (var tileSource in _tileSources.Where(t => t.Schema.Name == name))
{
SelectedTileSource = tileSource;
}
btnOk.Enabled = true;
}
}
/// <summary>
/// Creates an instance of this class
/// </summary>
/// <param name="tileSource">the source to get the tiles from</param>
/// <param name="layerName">name of the layer</param>
/// <param name="transparentColor">transparent color off</param>
/// <param name="showErrorInTile">generate an error tile if it could not be retrieved from source</param>
/// <remarks>If <see cref="showErrorInTile"/> is set to false, tile source keeps trying to get the tile in every request</remarks>
public TileLayer(ITileSource tileSource, string layerName, Color transparentColor, bool showErrorInTile)
{
_source = tileSource;
LayerName = layerName;
if (!transparentColor.IsEmpty)
_imageAttributes.SetColorKey(transparentColor, transparentColor);
_showErrorInTile = showErrorInTile;
#if !PocketPC
_imageAttributes.SetWrapMode(WrapMode.TileFlipXY);
#endif
}
public TileLayer(ITileSource source = null, int minTiles = 200, int maxTiles = 300, int maxRetries = TileFetcher.DefaultMaxAttempts,
int maxThreads = TileFetcher.DefaultMaxThreads, IFetchStrategy fetchStrategy = null,
IRenderGetStrategy renderFetchStrategy = null, int minExtraTiles = -1, int maxExtraTiles = -1)
{
_memoryCache = new MemoryCache<Feature>(minTiles, maxTiles);
Style = new VectorStyle { Outline = { Color = Color.FromArgb(0, 0, 0, 0) } }; // initialize with transparent outline
_maxRetries = maxRetries;
_maxThreads = maxThreads;
_fetchStrategy = fetchStrategy ?? new FetchStrategy();
_renderFetchStrategy = renderFetchStrategy ?? new RenderGetStrategy();
_minExtraTiles = minExtraTiles;
_maxExtraTiles = maxExtraTiles;
SetTileSource(source);
}
/// <summary>
/// Creates an instance of this class
/// </summary>
/// <param name="tileSource">The tile source to use</param>
/// <param name="tileCache">The tile cache to use</param>
public BruTileLayer(ITileSource tileSource, ITileCache<byte[]> tileCache)
{
TileSource = tileSource;
TileCache = tileCache;
int epsgCode;
if (int.TryParse(TileSource.Schema.Srs.Substring(5), out epsgCode))
{
_projection = new ProjectionInfo();
_projection = ProjectionInfo.FromEpsgCode(epsgCode);
}
else
_projection = KnownCoordinateSystems.Projected.World.WebMercator;
LegendItemVisible = true;
}
public void SetTileSource(ITileSource source)
{
_fetcher.DataChanged -= FetcherOnDataChanged;
_fetcher.AbortFetch();
_tileSource = source;
_viewport.CenterX = source.Schema.Extent.CenterX;
_viewport.CenterY = source.Schema.Extent.CenterY;
_viewport.UnitsPerPixel = Math.Max(source.Schema.Extent.Width / ActualWidth, source.Schema.Extent.Height / ActualHeight);
_tileCache.Clear();
_fetcher = new Fetcher<Image>(_tileSource, _tileCache);
_fetcher.DataChanged += FetcherOnDataChanged;
_fetcher.ViewChanged(_viewport.Extent, _viewport.UnitsPerPixel);
_invalid = true;
}
protected override void OnLoad(EventArgs e)
{
/* http://a.tiles.mapbox.com/mapbox/download/haiti-terrain-grey.mbtiles */
var path = Path.Combine(Path.GetTempPath(), "mapbox.haiti-terrain-grey.mbtiles");
if (File.Exists(path))
{
_source = new MbTilesTileSource(path);
var scale = (float)(1.1 * Math.Max(_source.Schema.Extent.Width / picMap.Width, _source.Schema.Extent.Height / picMap.Height));
_mapTransform = new MapTransform(
new PointF((float)_source.Schema.Extent.CenterX, (float)_source.Schema.Extent.CenterY),
scale, picMap.Width, picMap.Height);
RenderToBuffer();
}
base.OnLoad(e);
}
public ArcGISTileCompactLayer(ITileSource tileSource, string layerName, Color transparentColor, bool showErrorInTile, FileCache fileCache, ImageFormat imgFormat)
: base(tileSource,layerName,transparentColor,showErrorInTile,fileCache,imgFormat)
{
//this._imageAttributes = new ImageAttributes();
//this._bitmaps = new MemoryCache<Bitmap>(100, 200);
//this._showErrorInTile = true;
//this._source = tileSource;
//base.LayerName = layerName;
//if (!transparentColor.IsEmpty)
//{
// this._imageAttributes.SetColorKey(transparentColor, transparentColor);
//}
//this._showErrorInTile = showErrorInTile;
//this._fileCache = fileCache;
//this._ImageFormat = imgFormat;
}
private static byte[] GetTile(ITileSource tileSource, string level, int col, int row)
{
try
{
var tileInfo = new TileInfo();
var tileIndex = new TileIndex(col, row, level);
tileInfo.Index = tileIndex;
return tileSource.Provider.GetTile(tileInfo);
}
catch (WebException)
{
// intented: do nothing
return null;
}
}
public void Render(Viewport viewport, ITileSource tileSource, ITileCache<Tile<Image>> tileCache)
{
_canvas.Children.Clear();
var level = Utilities.GetNearestLevel(tileSource.Schema.Resolutions, viewport.UnitsPerPixel);
var tileInfos = tileSource.Schema.GetTileInfos(viewport.Extent, level);
foreach (var tileInfo in tileInfos)
{
var tile = tileCache.Find(tileInfo.Index);
if (tile != null)
{
_canvas.Children.Add(tile.Image);
PositionImage(tile.Image, tileInfo.Extent, viewport);
}
}
}
protected void SetTileSource(ITileSource source)
{
if (_tileSource != null)
{
_tileFetcher.AbortFetch();
_tileFetcher.DataChanged -= TileFetcherDataChanged;
_tileFetcher.PropertyChanged -= TileFetcherOnPropertyChanged;
_tileFetcher = null;
_memoryCache.Clear();
}
_tileSource = source;
if (source == null) return;
_tileFetcher = new TileFetcher(source, _memoryCache, _maxRetries, _maxThreads, _fetchStrategy);
_tileFetcher.DataChanged += TileFetcherDataChanged;
_tileFetcher.PropertyChanged += TileFetcherOnPropertyChanged;
OnPropertyChanged("Envelope");
}
public ArcGISTileCompactLayer(ITileSource tileSource, string layerName, Color transparentColor, bool showErrorInTile, string fileCacheDir)
: base(tileSource,layerName,transparentColor,showErrorInTile)
{
//this._imageAttributes = new ImageAttributes();
//this._bitmaps = new MemoryCache<Bitmap>(100, 200);
//this._showErrorInTile = true;
//this._source = tileSource;
//base.LayerName = layerName;
//if (!transparentColor.IsEmpty)
//{
// this._imageAttributes.SetColorKey(transparentColor, transparentColor);
//}
//this._showErrorInTile = showErrorInTile;
//if (!string.IsNullOrEmpty(fileCacheDir))
//{
// this._fileCache = new FileCache(fileCacheDir, "png");
// this._ImageFormat = ImageFormat.Png;
//}
}
public WmtsLayerConfiguration(string fileCacheRoot, string name, ITileSource tileSource)
:base(BruTileLayerPlugin.Settings.PermaCacheType, fileCacheRoot)
{
_fileCacheRoot = fileCacheRoot;
LegendText = name;
//var tileSources = GetTileSources(capabilitiesUri);
//var tileSource = tileSources.FirstOrDefault(ts => ts.Title.Equals(name, StringComparison.InvariantCulture));
if (tileSource == null)
throw new ArgumentException("TileSource not found", "capabilitiesUri");
TileSource = tileSource;
TileCache = CreateTileCache();
_tileFetcher = new TileFetcher(ReflectionHelper.Reflect(tileSource), BruTileLayerPlugin.Settings.MemoryCacheMinimum,
BruTileLayerPlugin.Settings.MemoryCacheMaximum, TileCache);
_initialized = true;
}
private static List<IFeature> TileIndexToFeatures(TileIndex[] tileIndexes, ITileSource tileSource)
{
var features = new List<IFeature>();
foreach (var tileIndex in tileIndexes)
{
var tileInfo = new TileInfo
{
Index = tileIndex,
Extent = TileTransform.TileToWorld(
new TileRange(tileIndex.Col, tileIndex.Row), tileIndex.Level, tileSource.Schema)
};
var feature = new Feature
{
Geometry = new Raster(new MemoryStream(
tileSource.GetTile(tileInfo)), tileInfo.Extent.ToBoundingBox())
};
features.Add(feature);
}
return features;
}
public void DoMainTask(DateTime time,string _extent,string basePath,string tileDir,string csv)
{
this.basePath = basePath;
this.csv = csv;
extent = _extent.Split(new[] { ',' }).Select(Convert.ToDouble).ToList();
_config = ConfigHelper.GetConfig(EnumBruTileLayer.OSM);
_tileSource = _config.CreateTileSource();
_tileProvider = (WebTileProvider)_tileSource.Provider;
_cacheDir = CacheSettings.GetCacheFolder(tileDir);
while (true)
{
try
{
DeleteDirectory(_cacheDir);
break;
}
catch (Exception ex)
{
LogManager.LogPath = AppDomain.CurrentDomain.BaseDirectory + "\\log\\";
LogManager.WriteLog("error", ex.Message);
}
}
_fileCache = CacheDirectory.GetFileCache(_cacheDir, _config, EnumBruTileLayer.OSM);
Draw();
var map = mosaicImage();
DirectoryInfo directory =
new DirectoryInfo(basePath + time.ToString("yyyy") + "\\" + time.ToString("yyyyMMdd") + "\\" +
time.ToString("yyyyMMddHHmm"));
if(!directory.Exists)
directory.Create();
map.Save(directory.FullName + "\\traffic.png");
CreateTrafficCsv(directory);
}
public TileProvider(ITileSource tileSource)
{
_source = tileSource;
}
public TileAsyncLayer(ITileSource tileSource, string layerName)
: base(tileSource, layerName, new Color(), true, null)
{
}
protected void SetTileSource(ITileSource source)
{
if (_tileSource != null)
{
// Is causing thread leak _tileFetcher.AbortFetch();
_tileFetcher.DataChanged -= TileFetcherDataChanged;
_tileFetcher.PropertyChanged -= TileFetcherOnPropertyChanged;
_tileFetcher = null;
_memoryCache.Clear();
}
_tileSource = source;
if (_tileSource != null)
{
Attribution.Text = _tileSource.Attribution.Text;
Attribution.Url = _tileSource.Attribution.Url;
_tileFetcher = new TileFetcher(source, _memoryCache, _maxRetries, _maxThreads, _fetchStrategy);
_tileFetcher.DataChanged += TileFetcherDataChanged;
_tileFetcher.PropertyChanged += TileFetcherOnPropertyChanged;
OnPropertyChanged(nameof(Envelope));
}
}
public TileAsyncLayer(ITileSource tileSource, string layerName, Color transparentColor, bool showErrorInTile, string fileCacheDir)
: base(tileSource, layerName, transparentColor, showErrorInTile, fileCacheDir)
{
}
/// <summary>
/// Creates an instance of this class
/// </summary>
/// <param name="tileSource">the source to get the tiles from</param>
/// <param name="layerName">name of the layer</param>
public TileLayer(ITileSource tileSource, string layerName)
: this(tileSource, layerName, new Color(), true, null)
{
}
/// <summary>
/// Creates an instance of this class
/// </summary>
/// <param name="tileSource">the source to get the tiles from</param>
/// <param name="layerName">name of the layer</param>
/// <param name="transparentColor">transparent color off</param>
/// <param name="showErrorInTile">generate an error tile if it could not be retrieved from source</param>
/// <param name="fileCache">If the layer should use a file-cache so store tiles, set this to a fileCacheProvider. Set to null to avoid filecache</param>
/// <param name="imgFormat">Set the format of the tiles to be used</param>
public TileLayer(ITileSource tileSource, string layerName, Color transparentColor, bool showErrorInTile, FileCache fileCache, ImageFormat imgFormat)
{
_source = tileSource;
LayerName = layerName;
_transparentColor = transparentColor;
_showErrorInTile = showErrorInTile;
_fileCache = fileCache;
_ImageFormat = imgFormat;
}
/// <summary>
/// Creates an instance of this class
/// </summary>
/// <param name="tileSource">the source to get the tiles from</param>
/// <param name="layerName">name of the layer</param>
/// <param name="transparentColor">transparent color off</param>
/// <param name="showErrorInTile">generate an error tile if it could not be retrieved from source</param>
/// <param name="fileCacheDir">If the layer should use a file-cache so store tiles, set this to that directory. Set to null to avoid filecache</param>
/// <remarks>If <paramref name="showErrorInTile"/> is set to false, tile source keeps trying to get the tile in every request</remarks>
public TileLayer(ITileSource tileSource, string layerName, Color transparentColor, bool showErrorInTile, string fileCacheDir)
{
_source = tileSource;
LayerName = layerName;
_transparentColor = transparentColor;
_showErrorInTile = showErrorInTile;
if (!string.IsNullOrEmpty(fileCacheDir))
{
_fileCache = new FileCache(fileCacheDir, "png");
_ImageFormat = ImageFormat.Png;
}
}
/// <summary>
///
/// </summary>
/// <param name="tileSource">The source to get the tiles from</param>
/// <param name="layerName">The name of the layer</param>
/// <param name="transparentColor">The color to be treated as transparent color</param>
/// <param name="showErrorInTile">Flag indicating that an error tile should be generated for <see cref="WebException"/>s</param>
public TileLayer(ITileSource tileSource, string layerName, Color transparentColor, bool showErrorInTile)
: this(tileSource,layerName, transparentColor, showErrorInTile,null)
{
}
public TileProvider(ITileSource tileSource, string layerName)
{
this.source = tileSource;
this.layerName = layerName;
}
