private static void GetRecursive(IDictionary<TileIndex, IFeature> resultTiles, ITileSchema schema,
ITileCache<Feature> cache, Extent extent, IList<KeyValuePair<string, Resolution>> resolutions, int resolutionIndex)
{
if (resolutionIndex < 0 || resolutionIndex >= resolutions.Count)
return;
var tiles = schema.GetTileInfos(extent, resolutions[resolutionIndex].Key);
foreach (var tileInfo in tiles)
{
var feature = cache.Find(tileInfo.Index);
if (feature == null)
{
// only continue the recursive search if this tile is within the extent
if (tileInfo.Extent.Intersects(extent))
{
GetRecursive(resultTiles, schema, cache, tileInfo.Extent.Intersect(extent), resolutions, resolutionIndex - 1);
}
}
else
{
resultTiles[tileInfo.Index] = feature;
}
}
}
private static void RenderTile(WriteableBitmap bitmap, ITileSchema schema, IViewport viewport, MemoryCache<Feature> memoryCache)
{
int level = BruTile.Utilities.GetNearestLevel(schema.Resolutions, viewport.Resolution);
var tiles = schema.GetTilesInView(viewport.Extent.ToExtent(), level);
foreach (TileInfo tile in tiles)
{
var p = NativeCache.Find(tile.Index);
if (p != null)
{
bitmap.Render(p, null);
continue;
}
var image = memoryCache.Find(tile.Index);
if (image != null)
{
Rect dest = WorldToView(tile.Extent, viewport);
dest = GeometryRenderer.RoundToPixel(dest);
//See here the clumsy way to write a bitmap in SL/WPF
var path = new System.Windows.Shapes.Path();
path.Data = new RectangleGeometry { Rect = dest };
var bitmapImage = new BitmapImage();
bitmapImage.SetSource(((IRaster)image.Geometry).Data);
path.Fill = new ImageBrush { ImageSource = bitmapImage };
path.CacheMode = new BitmapCache();
bitmap.Render(path, null);
}
}
}
public BingLayer()
{
// Here we use a tile schema that is defined in code. There are a few predefined
// tile schemas in the BruTile.dll. In the usual case the schema should be parsed
// from a tile service description.
schema = new BingSchema();
if (cache == null)
{
// Cache = new MemoryCache<byte[]>(1000, 100000);
var localSettingsDirectoryPath = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
var assembly = Assembly.GetEntryAssembly();
if (assembly == null)
{
cache = new MemoryCache<byte[]>(1000, 100000);
}
else
{
var assemblyInfo = AssemblyUtils.GetAssemblyInfo(assembly);
var cacheDirectoryPath = Path.Combine(Path.Combine(Path.Combine(localSettingsDirectoryPath, assemblyInfo.Company), assemblyInfo.Product), "cache_bing");
cache = new FileCache(cacheDirectoryPath, "jpg");
}
}
}
private static void DrawRecursive(Graphics graphics, ITileSchema schema, IViewport viewport,
MemoryCache<Feature> cache, Extent extent, int level)
{
var tileInfos = schema.GetTilesInView(extent, level);
foreach (TileInfo info in tileInfos)
{
var feature = cache.Find(info.Index);
if (feature == null)
{
if (level > 0) DrawRecursive(graphics, schema, viewport, cache, info.Extent.Intersect(extent), level - 1);
}
else
{
var image = ((IRaster)feature.Geometry).Data;
RectangleF dest = WorldToView(info.Extent, viewport);
dest = RoundToPixel(dest);
RectangleF clip = WorldToView(extent, viewport);
clip = RoundToPixel(clip);
if (!Contains(clip, dest))
{
clip = Intersect(clip, dest);
if (clip.IsEmpty) continue;
DrawImage(graphics, new Bitmap(image), dest, clip);
}
else
{
//Not using a clip at all sometimes performs better than using screenwide clip.
DrawImage(graphics, new Bitmap(image), dest);
}
}
}
}
public HttpTileSource(ITileSchema tileSchema, IRequest request, string name = null,
IPersistentCache<byte[]> persistentCache = null, Func<Uri, byte[]> tileFetcher = null)
{
_provider = new HttpTileProvider(request, persistentCache, tileFetcher);
_tileSchema = tileSchema;
Name = name ?? string.Empty;
}
private static WmscRequest CreateWmsRequest(ITileSchema schema)
{
const string url = "http://geoserver.nl/world/mapserv.cgi?map=world/world.map&VERSION=1.1.1";
return new WmscRequest(new Uri(url), schema,
new List<string>(new[] {"world"}), new List<string>(),
new Dictionary<string, string>());
}
public IList<IFeature> GetFeatures(BoundingBox box, double resolution, ITileSchema schema, ITileCache<Feature> memoryCache)
{
var dictionary = new Dictionary<TileIndex, IFeature>();
var levelId = BruTile.Utilities.GetNearestLevel(schema.Resolutions, resolution);
GetRecursive(dictionary, schema, memoryCache, box.ToExtent(), levelId);
var sortedFeatures = dictionary.OrderByDescending(t => schema.Resolutions[t.Key.Level].UnitsPerPixel);
return sortedFeatures.ToDictionary(pair => pair.Key, pair => pair.Value).Values.ToList();
}
private static IRequest GetRequestBuilder(ITileSchema schema)
{
const string url = "http://geoserver.nl/tiles/tilecache.aspx?";
var parameters = new Dictionary<string, string>();
var request = new WmscRequest(new Uri(url), schema,
new List<string>(new[] { "world_GM" }), new List<string>(), parameters);
return request;
}
public WmscRequest(Uri baseUrl, ITileSchema schema, IList<string> layers, IList<string> styles, IDictionary<string, string> customParameters, string version = null)
{
_baseUrl = baseUrl;
_customParameters = customParameters;
_layers = layers;
_schema = schema;
_styles = styles;
_version = version;
}
private static TileRange WorldToTileInvertedY(Extent extent, int level, ITileSchema schema)
{
var resolution = schema.Resolutions[level];
var tileWorldUnits = resolution.UnitsPerPixel * schema.Width;
var firstCol = (int)Math.Floor((extent.MinX - schema.OriginX) / tileWorldUnits);
var firstRow = (int)Math.Floor((-extent.MaxY + schema.OriginY) / tileWorldUnits);
var lastCol = (int)Math.Ceiling((extent.MaxX - schema.OriginX) / tileWorldUnits);
var lastRow = (int)Math.Ceiling((-extent.MinY + schema.OriginY) / tileWorldUnits);
return new TileRange(firstCol, firstRow, lastCol - firstCol, lastRow - firstRow);
}
private static Extent TileToWorldInvertedY(TileRange range, int level, ITileSchema schema)
{
var resolution = schema.Resolutions[level];
var tileWorldUnits = resolution.UnitsPerPixel * schema.Width;
var minX = range.FirstCol * tileWorldUnits + schema.OriginX;
var minY = -(range.FirstRow + range.RowCount) * tileWorldUnits + schema.OriginY;
var maxX = (range.FirstCol + range.ColCount) * tileWorldUnits + schema.OriginX;
var maxY = -(range.FirstRow) * tileWorldUnits + schema.OriginY;
return new Extent(minX, minY, maxX, maxY);
}
private static Extent TileToWorldNormal(TileRange range, string levelId, ITileSchema schema)
{
var resolution = schema.Resolutions[levelId];
var tileWorldUnits = resolution.UnitsPerPixel * schema.GetTileWidth(levelId);
var minX = range.FirstCol * tileWorldUnits + schema.GetOriginX(levelId);
var minY = range.FirstRow * tileWorldUnits + schema.GetOriginY(levelId);
var maxX = (range.FirstCol + range.ColCount) * tileWorldUnits + schema.GetOriginX(levelId);
var maxY = (range.FirstRow + range.RowCount) * tileWorldUnits + schema.GetOriginY(levelId);
return new Extent(minX, minY, maxX, maxY);
}
private static TileRange WorldToTileNormal(Extent extent, string levelId, ITileSchema schema)
{
var resolution = schema.Resolutions[levelId];
var tileWorldUnits = resolution.UnitsPerPixel * schema.GetTileWidth(levelId);
var firstCol = (int)Math.Floor((extent.MinX - schema.GetOriginX(levelId)) / tileWorldUnits);
var firstRow = (int)Math.Floor((extent.MinY - schema.GetOriginY(levelId)) / tileWorldUnits);
var lastCol = (int)Math.Ceiling((extent.MaxX - schema.GetOriginX(levelId)) / tileWorldUnits);
var lastRow = (int)Math.Ceiling((extent.MaxY - schema.GetOriginY(levelId)) / tileWorldUnits);
return new TileRange(firstCol, firstRow, lastCol - firstCol, lastRow - firstRow);
}
public ArcGisTileSource(
string baseUrl,
ITileSchema schema,
IPersistentCache<byte[]> persistentCache = null,
Func<Uri, byte[]> fetchTile = null)
: base(new WebTileProvider(CreateArcGISRequest(baseUrl), persistentCache, fetchTile),
schema)
{
BaseUrl = baseUrl;
}
public int GetTileCount(ITileSchema schema)
{
var result = 0;
foreach (var resolution in schema.Resolutions)
{
result += resolution.Value.MatrixHeight*resolution.Value.MatrixWidth;
}
return result;
}
public ArcGisTileSource(
string baseUrl,
ITileSchema schema,
IPersistentCache<byte[]> persistentCache = null,
Func<Uri, HttpWebRequest> webRequestFactory = null)
: base(
new WebTileProvider(CreateArcGISRequest(baseUrl), persistentCache, webRequestFactory),
schema)
{
BaseUrl = baseUrl;
}
public static Extent TileToWorld(TileRange range, int level, ITileSchema schema)
{
switch (schema.Axis)
{
case AxisDirection.Normal:
return TileToWorldNormal(range, level, schema);
case AxisDirection.InvertedY:
return TileToWorldInvertedY(range, level, schema);
default:
throw new Exception("Axis type was not found");
}
}
public static Extent TileToWorld(TileRange range, string levelId, ITileSchema schema)
{
switch (schema.YAxis)
{
case YAxis.TMS:
return TileToWorldNormal(range, levelId, schema);
case YAxis.OSM:
return TileToWorldInvertedY(range, levelId, schema);
default:
throw new Exception("YAxis type was not found");
}
}
public static TileRange WorldToTile(Extent extent, int level, ITileSchema schema)
{
switch (schema.Axis)
{
case AxisDirection.Normal:
return WorldToTileNormal(extent, level, schema);
case AxisDirection.InvertedY:
return WorldToTileInvertedY(extent, level, schema);
default:
throw new Exception("Axis type was not found");
}
}
public static TileRange WorldToTile(Extent extent, string levelId, ITileSchema schema)
{
switch (schema.YAxis)
{
case YAxis.TMS:
return WorldToTileNormal(extent, levelId, schema);
case YAxis.OSM:
return WorldToTileInvertedY(extent, levelId, schema);
default:
throw new Exception("YAxis type was not found");
}
}
public IList<IFeature> GetFeatures(BoundingBox box, double resolution, ITileSchema schema, ITileCache<Feature> memoryCache)
{
var tiles = schema.GetTileInfos(box.ToExtent(), resolution);
var result = new List<IFeature>();
foreach (var tileInfo in tiles)
{
var feature = memoryCache.Find(tileInfo.Index);
if (feature != null)
{
result.Add(feature);
}
}
return result;
}
private static RectangleF DrawTile(ITileSchema schema, Graphics graphics, Bitmap bitmap, RectangleF extent)
{
// For drawing on WinForms there are two things to take into account
// to prevent seams between tiles.
// 1) The WrapMode should be set to TileFlipXY. This is related
// to how pixels are rounded by GDI+
ImageAttributes imageAttributes = new ImageAttributes();
imageAttributes.SetWrapMode(WrapMode.TileFlipXY);
// 2) The rectangle should be rounded to actual pixels.
Rectangle roundedExtent = RoundToPixel(extent);
graphics.DrawImage(bitmap, roundedExtent, 0, 0, schema.Width, schema.Height, GraphicsUnit.Pixel, imageAttributes);
return(extent);
}
public static void WriteWorldFile(string f, Extent extent, ITileSchema schema)
{
using (var sw = new StreamWriter(f))
{
var resX = (extent.MaxX - extent.MinX) / schema.GetTileWidth("0");
var resY = (extent.MaxY - extent.MinY) / schema.GetTileHeight("0");
sw.WriteLine(resX.ToString(CultureInfo.InvariantCulture));
sw.WriteLine("0");
sw.WriteLine("0");
sw.WriteLine((resY * -1).ToString(CultureInfo.InvariantCulture));
sw.WriteLine(extent.MinX.ToString(CultureInfo.InvariantCulture));
sw.WriteLine(extent.MaxY.ToString(CultureInfo.InvariantCulture));
sw.Close();
}
}
public static void GetRecursive(IDictionary<TileIndex, IFeature> resultTiles, ITileSchema schema,
ITileCache<Feature> cache, Extent extent, string levelId)
{
// to improve performance, convert the resolutions to a list so they can be walked up by
// simply decrementing an index when the level index needs to change
var resolutions = schema.Resolutions.OrderByDescending(pair => pair.Value.UnitsPerPixel).ToList();
for (int i = 0; i < resolutions.Count; i++)
{
if (levelId == resolutions[i].Key)
{
GetRecursive(resultTiles, schema, cache, extent, resolutions, i);
break;
}
}
}
public MbTilesTileSource(SQLiteConnectionString connectionString, ITileSchema schema = null, MbTilesType type = MbTilesType.None)
{
_connectionString = connectionString;
var connection = new SQLiteConnectionWithLock(connectionString, SQLiteOpenFlags.ReadOnly);
using (connection.Lock())
{
Type = type == MbTilesType.None ? ReadType(connection) : type;
var schemaFromDatabase = ReadSchemaFromDatabase(connection);
Schema = schema ?? schemaFromDatabase;
// the tile range should be based on the tiles actually present.
var zoomLevelsFromDatabase = schemaFromDatabase.Resolutions.Select(r => r.Key);
_tileRange = ReadZoomLevelsFromTilesTable(connection, zoomLevelsFromDatabase);
}
}
public IList <IFeature> GetFeatures(BoundingBox extent, double resolution, ITileSchema schema, ITileCache <Feature> memoryCache)
{
var tiles = schema.GetTileInfos(extent.ToExtent(), resolution);
var result = new List <IFeature>();
foreach (var tileInfo in tiles)
{
var feature = memoryCache.Find(tileInfo.Index);
if (feature != null)
{
result.Add(feature);
}
}
return(result);
}
internal MbTilesCache(SQLiteConnectionString connectionString, ITileSchema schema = null, MbTilesType type = MbTilesType.None)
{
if (_connectionPool == null)
{
throw new InvalidOperationException("You must assign a platform prior to using MbTilesCache by calling MbTilesTileSource.SetPlatform()");
}
_connectionString = connectionString;
var connection = _connectionPool.GetConnection(connectionString);
using (connection.Lock())
{
_type = type == MbTilesType.None ? ReadType(connection) : type;
if (schema == null)
{
// Format (if defined)
_format = ReadFormat(connection);
// Extent
_extent = ReadExtent(connection);
if (HasMapTable(connection))
{
// it is possible to override the schema by definining it in a 'map' table.
// This method depends on reading tiles from an 'images' table, which
// is not part of the MBTiles spec
// Declared zoom levels
var declaredZoomLevels = ReadZoomLevels(connection, out _tileRange);
// Create schema
_schema = new GlobalMercator(_format.ToString(), declaredZoomLevels);
}
else
{
// this is actually the most regular case:
_schema = new GlobalSphericalMercator();
}
}
else
{
_schema = schema;
}
}
}
public IList <TileInfo> GetTilesWanted(ITileSchema schema, Extent extent, string levelId)
{
var tileInfos = new List <TileInfo>();
// Iterating through all levels from current to zero. If lower levels are
// not available the renderer can fall back on higher level tiles.
var resolution = schema.Resolutions[levelId].UnitsPerPixel;
var levels = schema.Resolutions.Where(k => k.Value.UnitsPerPixel >= resolution).OrderBy(x => x.Value.UnitsPerPixel).ToList();
foreach (var level in levels)
{
var tileInfosForLevel = schema.GetTileInfos(extent, level.Key).OrderBy(
t => Algorithms.Distance(extent.CenterX, extent.CenterY, t.Extent.CenterX, t.Extent.CenterY));
tileInfos.AddRange(tileInfosForLevel);
}
return(tileInfos);
}
private void SafeSchema(ITileSchema schema)
{
_axis = schema.YAxis;
_minX = schema.Extent.MinX;
_maxX = schema.Extent.MaxX;
_minY = schema.Extent.MinY;
_maxY = schema.Extent.MaxY;
_format = schema.Format;
_height = schema.GetTileHeight(String.Empty);
_width = schema.GetTileWidth(String.Empty);
_schemaName = schema.Name;
_originX = schema.GetOriginX(String.Empty);
_originY = schema.GetOriginY(String.Empty);
_srs = schema.Srs;
_resolutions = new Dictionary <string, Resolution>();
foreach (var resolution in schema.Resolutions)
{
_resolutions.Add(resolution.Key, resolution.Value);
}
}
public IList<TileInfo> GetTilesWanted(ITileSchema schema, Extent extent, int level)
{
IList<TileInfo> infos = new List<TileInfo>();
// Iterating through all levels from current to zero. If lower levels are
// not availeble the renderer can fall back on higher level tiles.
var levels = schema.Resolutions.Keys.Where(k => k <= level).OrderByDescending(x => x);
foreach (var lvl in levels)
{
var infosOfLevel = schema.GetTilesInView(extent, lvl);
infosOfLevel = SortByPriority(infosOfLevel, extent.CenterX, extent.CenterY);
foreach (TileInfo info in infosOfLevel)
{
if ((info.Index.Row >= 0) && (info.Index.Col >= 0)) infos.Add(info);
}
}
return infos;
}
public BingLayer()
{
// Here we use a tile schema that is defined in code. There are a few predefined
// tile schemas in the BruTile.dll. In the usual case the schema should be parsed
// from a tile service description.
schema = new BingSchema();
if (cache == null)
{
//no cache so mem
if (CacheLocation == null)
{
cache = new MemoryCache <byte[]>(1000, 100000);
}
else
{
cache = new FileCache(CacheLocation, "jpg");
}
}
}
public BingLayer()
{
// Here we use a tile schema that is defined in code. There are a few predefined
// tile schemas in the BruTile.dll. In the usual case the schema should be parsed
// from a tile service description.
schema = new BingSchema();
if (cache == null)
{
//no cache so mem
if (CacheLocation == null)
{
cache = new MemoryCache<byte[]>(1000, 100000);
}
else
{
cache = new FileCache(CacheLocation, "jpg");
}
}
}
public OpenStreetMapLayer()
{
// Here we use a tile schema that is defined in code. There are a few predefined
// tile schemas in the BruTile.dll. In the usual case the schema should be parsed
// from a tile service description.
schema = CreateTileSchema();
if (cache == null)
{
if (CacheLocation == null)
{
cache = new MemoryCache <byte[]>(1000, 100000);
}
else
{
var cacheDirectoryPath = CacheLocation;
cache = new FileCache(cacheDirectoryPath, "png");
}
}
}
private void button2_Click(object sender, EventArgs e)
{
var tile = comboBox1.SelectedItem;
if (tile == null)
{
MessageBox.Show("请选择至少一种地图");
return;
}
EnumBruTileLayer enumBruTileLayer = (EnumBruTileLayer)Enum.Parse(typeof(EnumBruTileLayer), tile.ToString());
IConfig config = ConfigHelper.GetConfig(enumBruTileLayer);
tileSource = config.CreateTileSource();
schema = tileSource.Schema;
var env = Projector.ProjectEnvelope(view.Extent, schema.Srs);
textBox3.Text = env.XMin.ToString();
textBox4.Text = env.XMax.ToString();
textBox5.Text = env.YMin.ToString();
textBox2.Text = env.YMax.ToString();
}
public IList<TileInfo> GetTilesWanted(ITileSchema schema, Extent extent, string levelId)
{
var infos = new List<TileInfo>();
// Iterating through all levels from current to zero. If lower levels are
// not available the renderer can fall back on higher level tiles.
var resolution = schema.Resolutions[levelId].UnitsPerPixel;
var levels = schema.Resolutions.Where(k => k.Value.UnitsPerPixel >= resolution).OrderBy(x => x.Value.UnitsPerPixel).ToList();
foreach (var level in levels)
{
var tileInfos = schema.GetTileInfos(extent, level.Key).OrderBy(
t => Algorithms.Distance(extent.CenterX, extent.CenterY, t.Extent.CenterX, t.Extent.CenterY));
foreach (TileInfo info in tileInfos.Where(info => (info.Index.Row >= 0) && (info.Index.Col >= 0)))
{
infos.Add(info);
}
}
return infos;
}
private static void DrawRecursive(Graphics graphics, ITileSchema schema, IViewport viewport,
MemoryCache <Feature> cache, Extent extent, int level)
{
var tileInfos = schema.GetTilesInView(extent, level);
foreach (TileInfo info in tileInfos)
{
var feature = cache.Find(info.Index);
if (feature == null)
{
if (level > 0)
{
DrawRecursive(graphics, schema, viewport, cache, info.Extent.Intersect(extent), level - 1);
}
}
else
{
var image = ((IRaster)feature.Geometry).Data;
RectangleF dest = WorldToView(info.Extent, viewport);
dest = RoundToPixel(dest);
RectangleF clip = WorldToView(extent, viewport);
clip = RoundToPixel(clip);
if (!Contains(clip, dest))
{
clip = Intersect(clip, dest);
if (clip.IsEmpty)
{
continue;
}
DrawImage(graphics, new Bitmap(image), dest, clip);
}
else
{
//Not using a clip at all sometimes performs better than using screenwide clip.
DrawImage(graphics, new Bitmap(image), dest);
}
}
}
}
public SharpMapTileProvider(ITileSchema schema, ITileCache <byte[]> cache, params ILayer[] layers)
{
if (schema == null)
{
throw new ArgumentNullException("schema");
}
if (layers == null)
{
throw new ArgumentNullException("layers");
}
this.Schema = schema;
this.cache = cache ?? new NullCache();
LayerCollection collection = new LayerCollection();
foreach (ILayer layer in layers)
{
collection.Add(layer);
}
this.layers = collection;
}
public IList<TileInfo> GetTilesWanted(ITileSchema schema, Extent extent, string levelId)
{
IList<TileInfo> infos = new List<TileInfo>();
// Iterating through all levels from current to zero. If lower levels are
// not availeble the renderer can fall back on higher level tiles.
var unitsPerPixel = schema.Resolutions[levelId].UnitsPerPixel;
var levels = schema.Resolutions.Where(k => unitsPerPixel <= k.Value.UnitsPerPixel).OrderByDescending(x => x.Value.UnitsPerPixel);
//var levelCount = levels.Count();
foreach (var level in levels)
{
var tileInfos = schema.GetTileInfos(extent, level.Key);
tileInfos = SortByPriority(tileInfos, extent.CenterX, extent.CenterY);
//var count = infosOfLevel.Count();
foreach (var info in tileInfos)
{
if ((info.Index.Row >= 0) && (info.Index.Col >= 0)) infos.Add(info);
}
}
return infos;
}
public IList<TileInfo> GetTilesWanted(ITileSchema schema, Extent extent, int level)
{
//line below only works properly of this instance is always called with the the resolutions. Think of something better
if (preFetchLayers == null) preFetchLayers = GetPreFetchLevels(0, schema.Resolutions.Count - 1);
IList<TileInfo> infos = new List<TileInfo>();
// Iterating through all levels from current to zero. If lower levels are
// not availeble the renderer can fall back on higher level tiles.
while (level >= 0)
{
////////if (!preFetchLayers.Contains(level)) continue;
var infosOfLevel = schema.GetTilesInView(extent, level);
infosOfLevel = PrioritizeTiles(infosOfLevel, extent.CenterX, extent.CenterY);
foreach (TileInfo info in infosOfLevel)
{
if ((info.Index.Row >= 0) && (info.Index.Col >= 0)) infos.Add(info);
}
level--;
}
return infos;
}
public IList<TileInfo> GetTilesWanted(ITileSchema schema, Extent extent, string levelId)
{
IList<TileInfo> infos = new List<TileInfo>();
// Iterating through all levels from current to zero. If lower levels are
// not availeble the renderer can fall back on higher level tiles.
var resolution = schema.Resolutions[levelId].UnitsPerPixel;
var levels = schema.Resolutions.Where(k => resolution <= k.Value.UnitsPerPixel).OrderByDescending(x => x.Value.UnitsPerPixel);
//var levelCount = levels.Count();
foreach (var level in levels)
{
var tileInfos = schema.GetTilesInView(extent, level.Key);
tileInfos = SortByPriority(tileInfos, extent.CenterX, extent.CenterY);
//var count = infosOfLevel.Count();
foreach (var info in tileInfos)
{
if ((info.Index.Row >= 0) && (info.Index.Col >= 0)) infos.Add(info);
}
}
return infos;
}
public IList <TileInfo> GetTilesWanted(ITileSchema schema, Extent extent, int level)
{
IList <TileInfo> infos = new List <TileInfo>();
// Iterating through all levels from current to zero. If lower levels are
// not availeble the renderer can fall back on higher level tiles.
var levels = schema.Resolutions.Keys.Where(k => k <= level).OrderByDescending(x => x);
foreach (var lvl in levels)
{
var infosOfLevel = schema.GetTilesInView(extent, lvl);
infosOfLevel = SortByPriority(infosOfLevel, extent.CenterX, extent.CenterY);
foreach (TileInfo info in infosOfLevel)
{
if ((info.Index.Row >= 0) && (info.Index.Col >= 0))
{
infos.Add(info);
}
}
}
return(infos);
}
internal static IEnumerable <TileInfo> GetTileInfos(ITileSchema schema, Extent extent, string levelId)
{
// todo: move this method elsewhere.
var range = TileTransform.WorldToTile(extent, levelId, schema);
// todo: use a method to get tilerange for full schema and intersect with requested tilerange.
var startX = Math.Max(range.FirstCol, schema.GetMatrixFirstCol(levelId));
var stopX = Math.Min(range.FirstCol + range.ColCount, schema.GetMatrixFirstCol(levelId) + schema.GetMatrixWidth(levelId));
var startY = Math.Max(range.FirstRow, schema.GetMatrixFirstRow(levelId));
var stopY = Math.Min(range.FirstRow + range.RowCount, schema.GetMatrixFirstRow(levelId) + schema.GetMatrixHeight(levelId));
for (var x = startX; x < stopX; x++)
{
for (var y = startY; y < stopY; y++)
{
yield return(new TileInfo
{
Extent = TileTransform.TileToWorld(new TileRange(x, y), levelId, schema),
Index = new TileIndex(x, y, levelId)
});
}
}
}
public MbTilesTileSource(SQLiteConnectionString connectionString, ITileSchema schema = null, MbTilesType type = MbTilesType.None, bool tileRangeOptimization = true)
{
_connectionString = connectionString;
if (tileRangeOptimization || schema == null)
{
using (var connection = new SQLiteConnectionWithLock(connectionString))
using (connection.Lock())
{
Type = type == MbTilesType.None ? ReadType(connection) : type;
var schemaFromDatabase = ReadSchemaFromDatabase(connection);
Schema = schema ?? schemaFromDatabase;
// Read other stuff
Version = ReadString(connection, "version");
Attribution = new Attribution(ReadString(connection, "attribution"));
Description = ReadString(connection, "description");
Name = ReadString(connection, "name");
Json = ReadString(connection, "json");
Compression = ReadString(connection, "compression");
var zoomMin = ReadInt(connection, "minzoom");
ZoomMin = zoomMin < 0 ? 0 : zoomMin;
var zoomMax = ReadInt(connection, "maxzoom");
ZoomMax = zoomMax < 0 ? int.MaxValue : zoomMax;
// the tile range should be based on the tiles actually present.
var zoomLevelsFromDatabase = schemaFromDatabase.Resolutions.Select(r => r.Key);
_tileRange = ReadZoomLevelsFromTilesTable(connection, zoomLevelsFromDatabase);
}
}
else
{
Schema = schema;
_tileRange = null;
}
}
public OpenStreetMapLayer()
{
// Here we use a tile schema that is defined in code. There are a few predefined
// tile schemas in the BruTile.dll. In the usual case the schema should be parsed
// from a tile service description.
schema = CreateTileSchema();
if (cache == null)
{
var localSettingsDirectoryPath = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
var assembly = Assembly.GetEntryAssembly();
if (assembly == null)
{
cache = new MemoryCache <byte[]>(1000, 100000);
}
else
{
var assemblyInfo = AssemblyUtils.GetAssemblyInfo(assembly);
var cacheDirectoryPath = Path.Combine(Path.Combine(Path.Combine(
localSettingsDirectoryPath, assemblyInfo.Company), assemblyInfo.Product), "cache_open_street_map");
cache = new FileCache(cacheDirectoryPath, "png");
}
}
}
private static void RenderTile(WriteableBitmap bitmap, ITileSchema schema, IViewport viewport, MemoryCache <Feature> memoryCache)
{
int level = BruTile.Utilities.GetNearestLevel(schema.Resolutions, viewport.Resolution);
var tiles = schema.GetTilesInView(viewport.Extent.ToExtent(), level);
foreach (TileInfo tile in tiles)
{
var p = NativeCache.Find(tile.Index);
if (p != null)
{
bitmap.Render(p, null);
continue;
}
var image = memoryCache.Find(tile.Index);
if (image != null)
{
Rect dest = WorldToView(tile.Extent, viewport);
dest = GeometryRenderer.RoundToPixel(dest);
//See here the clumsy way to write a bitmap in SL/WPF
var path = new System.Windows.Shapes.Path();
path.Data = new RectangleGeometry {
Rect = dest
};
var bitmapImage = new BitmapImage();
bitmapImage.SetSource(((IRaster)image.Geometry).Data);
path.Fill = new ImageBrush {
ImageSource = bitmapImage
};
path.CacheMode = new BitmapCache();
bitmap.Render(path, null);
}
}
}
private static bool EqualTileProviders(ITileSchema schema, ITileProvider tp1, ITileProvider tp2, out string message)
{
if (!ReferenceEquals(tp1, tp2))
{
if (tp1 == null)
{
message = "The reference tile provider is null!";
return(false);
}
if (tp2 == null)
{
message = "One of the tile providers is null, and the other not";
return(false);
}
if (tp1.GetType() != tp2.GetType())
{
message = "Tile providers are of different type";
return(false);
}
var keys = schema.Resolutions.Keys.ToArray();
var minkey = GetIndex(keys[0]);
var maxKey = GetIndex(keys[keys.Length - 1]);
var prefix = GetPrefix(keys[0]);
for (var i = 0; i < 3; i++)
{
TileInfo ti = null;
try
{
ti = RandomTileInfo(prefix + "{0}", minkey, Math.Min(maxKey, 12));
var req1 = tp1 as IRequest;
var req2 = tp2 as IRequest;
if (req1 != null && req2 != null)
{
if (req1.GetUri(ti) != req2.GetUri(ti))
{
message = "Request builders produce different uris for the same request";
return(false);
}
}
else
{
var t1 = tp1.GetTile(ti);
var t2 = tp2.GetTile(ti);
if (!TilesEqual(t1, t2))
{
message = "Request builders produce different results for same tile request";
return(false);
}
}
}
catch (TimeoutException ex)
{
System.Diagnostics.Trace.WriteLine(string.Format(
"TileInfo({4}): {0}, {1}, {2}\n{3}",
ti.Index.Level, ti.Index.Col, ti.Index.Row, ex.Message, i));
}
catch (WebException ex)
{
if (ti == null)
{
System.Diagnostics.Trace.WriteLine("No tile info!");
}
else
{
System.Diagnostics.Trace.WriteLine(string.Format(
"TileInfo({5}): {0}, {1}, {2}\n{3}\n{4}",
ti.Index.Level, ti.Index.Col, ti.Index.Row,
ex.Message, ex.Response.ResponseUri, i));
}
}
}
}
message = "Tile providers appear to be equal";
return(true);
}
public HttpTileSourceTDT(ITileSchema tileSchema, string urlFormatter, IEnumerable <string> serverNodes = null,
string apiKey = null, string name = null, IPersistentCache <byte[]> persistentCache = null,
Func <Uri, byte[]> tileFetcher = null, Attribution attribution = null)
: this(tileSchema, new BasicRequestTDT(urlFormatter, serverNodes, apiKey), name, persistentCache, tileFetcher, attribution)
{
}
public MbTilesProvider(SQLiteConnection connection, ITileSchema schema = null, MbTilesType type = MbTilesType.None)
{
_cache = new MbTilesCache(connection, schema, type);
}
private WmscTileSource(ITileSchema tileSchema, ITileProvider tileProvider)
: base(tileProvider, tileSchema)
{
}
public OpenStreetMapLayer()
{
// Here we use a tile schema that is defined in code. There are a few predefined
// tile schemas in the BruTile.dll. In the usual case the schema should be parsed
// from a tile service description.
schema = CreateTileSchema();
if (cache == null)
{
if (CacheLocation == null)
{
cache = new MemoryCache<byte[]>(1000, 100000);
}
else
{
var cacheDirectoryPath = CacheLocation;
cache = new FileCache(cacheDirectoryPath, "png");
}
}
}
public IList <TileInfo> Get(ITileSchema schema, Extent extent, int level)
{
return(schema.GetTileInfos(extent, level).OrderBy(
t => Algorithms.Distance(extent.CenterX, extent.CenterY, t.Extent.CenterX, t.Extent.CenterY)).ToList());
}
private static void GetRecursive(IDictionary <TileIndex, IFeature> resultTiles, ITileSchema schema,
ITileCache <Feature> cache, Extent extent, IList <KeyValuePair <string, Resolution> > resolutions, int resolutionIndex)
{
if (resolutionIndex < 0 || resolutionIndex >= resolutions.Count)
{
return;
}
var tiles = schema.GetTileInfos(extent, resolutions[resolutionIndex].Key);
foreach (var tileInfo in tiles)
{
var feature = cache.Find(tileInfo.Index);
if (feature == null)
{
// only continue the recursive search if this tile is within the extent
if (tileInfo.Extent.Intersects(extent))
{
GetRecursive(resultTiles, schema, cache, tileInfo.Extent.Intersect(extent), resolutions, resolutionIndex - 1);
}
}
else
{
resultTiles[tileInfo.Index] = feature;
}
}
}
public static void GetRecursive(IDictionary <TileIndex, IFeature> resultTiles, ITileSchema schema,
ITileCache <Feature> cache, Extent extent, string levelId)
{
// to improve performance, convert the resolutions to a list so they can be walked up by
// simply decrementing an index when the level index needs to change
var resolutions = schema.Resolutions.OrderByDescending(pair => pair.Value.UnitsPerPixel).ToList();
for (int i = 0; i < resolutions.Count; i++)
{
if (levelId == resolutions[i].Key)
{
GetRecursive(resultTiles, schema, cache, extent, resolutions, i);
break;
}
}
}
private static bool TryInitializeViewport(ref Viewport viewport, double actualWidth, double actualHeight, ITileSchema schema)
{
if (double.IsNaN(actualWidth))
{
return(false);
}
if (actualWidth <= 0)
{
return(false);
}
var nearestLevel = Utilities.GetNearestLevel(schema.Resolutions, schema.Extent.Width / actualWidth);
viewport = new Viewport
{
Width = actualWidth,
Height = actualHeight,
UnitsPerPixel = schema.Resolutions[nearestLevel].UnitsPerPixel,
Center = new Samples.Common.Geometries.Point(schema.Extent.CenterX, schema.Extent.CenterY)
};
return(true);
}
private static WmscRequest CreateWmsRequest(ITileSchema schema)
{
const string url = "http://geoserver.nl/world/mapserv.cgi?map=world/world.map&VERSION=1.1.1";
return(new WmscRequest(new Uri(url), schema, new[] { "world" }.ToList(), new string[0].ToList()));
}
public TmsTileSource(Uri serviceUri, ITileSchema tileSchema, IPersistentCache <byte[]> persistentCache = null,
Func <Uri, byte[]> fetchTile = null) :
base(new WebTileProvider(new TmsRequest(serviceUri, tileSchema.Format), persistentCache,
fetchTile), tileSchema)
{
}
public TmsTileSource(string serviceUrl, ITileSchema tileSchema)
: this(new Uri(serviceUrl), tileSchema)
{
}
private static bool EqualTileSchemas(ITileSchema ts1, ITileSchema ts2, out string message)
{
if (ts1.Name != ts2.Name)
{
message = "Names don't match";
return(false);
}
if (ts1.Srs != ts2.Srs)
{
message = "Srs' don't match";
return(false);
}
if (ts1.Format != ts2.Format)
{
message = "Formats don't match";
return(false);
}
if (ts1.Extent != ts2.Extent)
{
message = "Extents don't match";
return(false);
}
var tts1 = ts1 as TileSchema;
var tts2 = ts2 as TileSchema;
if (tts1 != null && tts2 != null)
{
if (tts1.Resolutions.Count != tts2.Resolutions.Count)
{
message = "Number of resolutions don't match";
return(false);
}
if (tts1.OriginX != tts2.OriginX)
{
message = "OriginX' don't match";
return(false);
}
if (tts1.OriginY != tts2.OriginY)
{
message = "OriginYs don't match";
return(false);
}
foreach (var res1 in tts1.Resolutions.Values)
{
var res2 = tts2.Resolutions[res1.Id];
if (tts1.GetTileHeight(res1.Id) != tts2.GetTileHeight(res2.Id))
{
message = "Heights don't match";
return(false);
}
if (tts1.GetTileWidth(res1.Id) != tts2.GetTileWidth(res2.Id))
{
message = "Widths don't match";
return(false);
}
}
}
var wts1 = ts1 as WmtsTileSchema;
var wts2 = ts2 as WmtsTileSchema;
if (wts1 != null && wts2 != null)
{
if (wts1.Abstract != wts2.Abstract)
{
message = "Abstracts don't match";
return(false);
}
if (wts1.Style != wts2.Style)
{
message = "Styles don't match";
return(false);
}
if (wts1.Identifier != wts2.Identifier)
{
message = "Identifiers don't match";
return(false);
}
if (wts1.SupportedSRS.ToString() != wts2.SupportedSRS.ToString())
{
message = "SupportedSRS' don't match";
return(false);
}
}
if (ts1.Resolutions.Count != ts2.Resolutions.Count)
{
message = "Number of resolutions doesn't match";
return(false);
}
foreach (var key in ts1.Resolutions.Keys)
{
var r1 = ts1.Resolutions[key];
var r2 = ts2.Resolutions[key];
//!!! compare other resultion parameters.
if (r1.Id != r2.Id || r1.UnitsPerPixel != r2.UnitsPerPixel)
{
message = string.Format("Resolution doesn't match at index {0}", key);
return(false);
}
}
message = "Schemas are equal!";
return(true);
}
/// <summary>
/// Creates an instance of this class
/// </summary>
/// <param name="tileProvider">The tile provider</param>
/// <param name="tileSchema">The tile schema</param>
public TileSource(ITileProvider tileProvider, ITileSchema tileSchema)
{
_provider = tileProvider;
Schema = tileSchema;
}
private static RectangleF DrawTile(ITileSchema schema, Graphics graphics, Bitmap bitmap, RectangleF extent)
{
// For drawing on WinForms there are two things to take into account
// to prevent seams between tiles.
// 1) The WrapMode should be set to TileFlipXY. This is related
// to how pixels are rounded by GDI+
ImageAttributes imageAttributes = new ImageAttributes();
imageAttributes.SetWrapMode(WrapMode.TileFlipXY);
// 2) The rectangle should be rounded to actual pixels.
Rectangle roundedExtent = RoundToPixel(extent);
graphics.DrawImage(bitmap, roundedExtent, 0, 0, schema.Width, schema.Height, GraphicsUnit.Pixel, imageAttributes);
return extent;
}
