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)
{
//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);
}
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 static void SelectRecursive(IDictionary <TileIndex, Tile <T> > selection, ITileCache <Tile <T> > cache, ITileSchema schema, Extent extent, int level)
{
if (level < 0)
{
return;
}
var tiles = schema.GetTilesInView(extent, level);
foreach (TileInfo tileInfo in tiles)
{
var tile = cache.Find(tileInfo.Index);
if (tile == null)
{
SelectRecursive(selection, cache, schema, tileInfo.Extent.Intersect(extent), level - 1);
}
else
{
selection[tileInfo.Index] = tile;
// If a tile is still semi transparent then select the higher level to show underneath the
// semi transparent one.
if (IsSemiTransparent(tile))
{
SelectRecursive(selection, cache, schema, tileInfo.Extent.Intersect(extent), level - 1);
}
}
}
}
public static void GetRecursive(IDictionary <TileIndex, IFeature> resultTiles, ITileSchema schema, MemoryCache <Feature> cache, Extent extent, int level)
{
if (level < 0)
{
return;
}
var tiles = schema.GetTilesInView(extent, level);
foreach (TileInfo tileInfo in tiles)
{
var feature = cache.Find(tileInfo.Index);
if (feature == null)
{
GetRecursive(resultTiles, schema, cache, tileInfo.Extent.Intersect(extent), level - 1);
}
else
{
resultTiles[tileInfo.Index] = feature;
if (!IsFullyShown(feature))
{
GetRecursive(resultTiles, schema, cache, tileInfo.Extent.Intersect(extent), level - 1);
}
}
}
}
private void Form1_Load(object sender, EventArgs e)
{
MapTransform mapTransform = new MapTransform(new PointF(0, 0), 50000f, this.Width, this.Height);
// 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.
ITileSchema schema = CreateTileSchema();
int level = Utilities.GetNearestLevel(schema.Resolutions, mapTransform.Resolution);
IList <TileInfo> infos = schema.GetTilesInView(mapTransform.Extent, level);
IRequest requestBuilder = new TmsRequest(new Uri("http://a.tile.openstreetmap.org"), "png");
Graphics graphics = Graphics.FromImage(buffer);
foreach (TileInfo info in infos)
{
Uri url = requestBuilder.GetUri(info);
byte[] bytes = RequestHelper.FetchImage(url);
Bitmap bitmap = new Bitmap(new MemoryStream(bytes));
RectangleF extent = mapTransform.WorldToMap(info.Extent.MinX, info.Extent.MinY, info.Extent.MaxX, info.Extent.MaxY);
extent = DrawTile(schema, graphics, bitmap, extent);
}
this.Invalidate();
}
private static void DrawRecursive(WriteableBitmap targetBitmap, ITileSchema schema, IViewport viewport, MemoryCache <Feature> memoryCache, Extent extent, int level, double opacity)
{
var tileInfos = schema.GetTilesInView(extent, level);
foreach (TileInfo tile in tileInfos)
{
var feature = memoryCache.Find(tile.Index);
if (feature == null)
{
if (level > 0)
{
DrawRecursive(targetBitmap, schema, viewport, memoryCache, tile.Extent.Intersect(extent), level - 1, opacity);
}
}
else
{
if (!feature.RenderedGeometry.Keys.Contains(new VectorStyle()))
{
var image = ((IRaster)feature.Geometry).Data;
var bitmap = LoadBitmap(image);
Rect dest = WorldToView(tile.Extent, viewport);
DrawImage(targetBitmap, bitmap, dest, tile, memoryCache, opacity);
feature.RenderedGeometry[new VectorStyle()] = bitmap;
}
else // position
{
var bitmap = (WriteableBitmap)feature.RenderedGeometry[new VectorStyle()];
Rect dest = WorldToView(tile.Extent, viewport);
DrawImage(targetBitmap, bitmap, dest, tile, memoryCache, opacity);
}
}
}
}
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.GetTilesInView(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 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);
}
}
}
}
/// <summary>
/// Renders the layer
/// </summary>
/// <param name="g">Graphics object reference</param>
/// <param name="map">Map which is rendered</param>
public override void OnRender(System.Drawing.Graphics g, IMap map)
{
MapTransform mapTransform = new MapTransform(new PointF((float)Map.Center.X, (float)Map.Center.Y), (float)Map.PixelSize, Map.Image.Width, Map.Image.Height);
int level = BruTile.Utilities.GetNearestLevel(schema.Resolutions, Map.PixelSize);
IList <TileInfo> tileInfos = schema.GetTilesInView(mapTransform.Extent, level);
IRequest requestBuilder = new TmsRequest(new Uri("http://a.tile.openstreetmap.org"), "png");
var graphics = Graphics.FromImage(Image);
//log.DebugFormat("Downloading tiles:");
foreach (var tileInfo in tileInfos)
{
var bytes = cache.Find(tileInfo.Index);
if (bytes == default(byte[]))
{
try
{
//log.DebugFormat("row: {0}, column: {1}, level: {2}", tileInfo.Index.Row, tileInfo.Index.Col, tileInfo.Index.Level);
var url = requestBuilder.GetUri(tileInfo);
bytes = FetchImage(url);
cache.Add(tileInfo.Index, bytes);
}
catch (WebException e)
{
//log once per 45 seconds max
if ((DateTime.Now - lastErrorLogged) > TimeSpan.FromSeconds(45))
{
log.Error("Can't fetch tiles from the server", e);
lastErrorLogged = DateTime.Now;
}
}
}
else
{
//log.DebugFormat("row: {0}, column: {1}, level: {2} (cached)", tileInfo.Index.Row, tileInfo.Index.Col, tileInfo.Index.Level);
}
if (bytes == null)
{
continue;
}
using (var bitmap = new Bitmap(new MemoryStream(bytes)))
{
var rectangle = mapTransform.WorldToMap(tileInfo.Extent.MinX, tileInfo.Extent.MinY,
tileInfo.Extent.MaxX, tileInfo.Extent.MaxY);
DrawTile(schema, graphics, bitmap, rectangle);
}
}
}
/// <summary>
/// Renders the layer
/// </summary>
/// <param name="g">Graphics object reference</param>
/// <param name="map">Map which is rendered</param>
public override void OnRender(System.Drawing.Graphics g, Map map)
{
MapTransform mapTransform = new MapTransform(new PointF((float)Map.Center.X, (float)Map.Center.Y), (float)Map.PixelSize, Map.Image.Width, Map.Image.Height);
int level = BruTile.Utilities.GetNearestLevel(schema.Resolutions, Map.PixelSize);
IList <TileInfo> tileInfos = schema.GetTilesInView(mapTransform.Extent, level);
IRequest requestBuilder = new BingRequest(BingRequest.UrlBing, string.Empty, MapType.Hybrid);
var graphics = Graphics.FromImage(Image);
// log.DebugFormat("Downloading tiles:");
foreach (var tileInfo in tileInfos)
{
var bytes = cache.Find(tileInfo.Index);
if (bytes == default(byte[]))
{
try
{
// log.DebugFormat("row: {0}, column: {1}, level: {2}", tileInfo.Index.Row, tileInfo.Index.Col, tileInfo.Index.Level);
var url = requestBuilder.GetUri(tileInfo);
bytes = RequestHelper.FetchImage(url);
cache.Add(tileInfo.Index, bytes);
}
catch (WebException e)
{
log.Error("Can't fetch tiles from the server", e);
}
}
else
{
log.DebugFormat("row: {0}, column: {1}, level: {2} (cached)", tileInfo.Index.Row, tileInfo.Index.Col, tileInfo.Index.Level);
}
if (bytes == null)
{
continue;
}
using (var bitmap = new Bitmap(new MemoryStream(bytes)))
{
var rectangle = mapTransform.WorldToMap(tileInfo.Extent.MinX, tileInfo.Extent.MinY,
tileInfo.Extent.MaxX, tileInfo.Extent.MaxY);
DrawTile(schema, graphics, bitmap, rectangle);
}
}
}
public IList <IFeature> GetFeatures(BoundingBox box, double resolution, ITileSchema schema, ITileCache <Feature> memoryCache)
{
var tiles = schema.GetTilesInView(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 List <TileInfo> GetTile()
{
Extent exten = new Extent(extent[0], extent[2], extent[1], extent[3]);
int level1 = int.Parse(levelTextBox1.Text);
int level2 = int.Parse(levelTextBox2.Text);
List <TileInfo> alltiles = new List <TileInfo>();
for (; level1 <= level2; level1++)
{
var tiles = schema.GetTilesInView(exten, level1.ToString());
if (tiles.Count() > 0)
{
alltiles.AddRange(tiles);
}
}
return(alltiles);
}
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 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.GetTilesInView(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 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)
{
//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, 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);
}
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 IList <TileInfo> GetTilesWanted(ITileSchema schema, Extent extent, string levelId)
{
return(schema.GetTilesInView(extent, (levelId)).ToList());
}
public IList<TileInfo> GetTilesWanted(ITileSchema schema, Extent extent, string levelId)
{
return schema.GetTilesInView(extent, (levelId)).ToList();
}
public static void GetRecursive(IDictionary<TileIndex, IFeature> resultTiles, ITileSchema schema, MemoryCache<Feature> cache, Extent extent, int level)
{
if (level < 0) return;
var tiles = schema.GetTilesInView(extent, level);
foreach (TileInfo tileInfo in tiles)
{
var feature = cache.Find(tileInfo.Index);
if (feature == null)
{
GetRecursive(resultTiles, schema, cache, tileInfo.Extent.Intersect(extent), level - 1);
}
else
{
resultTiles[tileInfo.Index] = feature;
if (!IsFullyShown(feature))
{
GetRecursive(resultTiles, schema, cache, tileInfo.Extent.Intersect(extent), level - 1);
}
}
}
}
private static void DrawRecursive(WriteableBitmap targetBitmap, ITileSchema schema, IViewport viewport, MemoryCache<Feature> memoryCache, Extent extent, int level, double opacity)
{
var tileInfos = schema.GetTilesInView(extent, level);
foreach (TileInfo tile in tileInfos)
{
var feature = memoryCache.Find(tile.Index);
if (feature == null)
{
if (level > 0) DrawRecursive(targetBitmap, schema, viewport, memoryCache, tile.Extent.Intersect(extent), level - 1, opacity);
}
else
{
if (!feature.RenderedGeometry.Keys.Contains(new VectorStyle()))
{
var image = ((IRaster)feature.Geometry).Data;
var bitmap = LoadBitmap(image);
Rect dest = WorldToView(tile.Extent, viewport);
DrawImage(targetBitmap, bitmap, dest, tile, memoryCache, opacity);
feature.RenderedGeometry[new VectorStyle()] = bitmap;
}
else // position
{
var bitmap = (WriteableBitmap)feature.RenderedGeometry[new VectorStyle()];
Rect dest = WorldToView(tile.Extent, viewport);
DrawImage(targetBitmap, bitmap, dest, tile, memoryCache, opacity);
}
}
}
}
