public bool PutTileToCache(RawTile key, MemoryStream data)
{
string quadkey = BingMapTileSystem.TileXYToQuadKey(key.TileXY, key.Level);
if (QuadKeyList.Contains(quadkey))
{
return(false);
}
string path = string.Format("{0}/{1}.png", directory, quadkey);
FileStream fs = File.OpenWrite(path);
data.CopyTo(fs);
fs.Flush();
fs.Close();
QuadKeyList.Add(quadkey);
infofile.Element("TileSet").Add(new XElement("Tile")
{
Value = quadkey
});
try
{
using (FileStream fsInfo = File.OpenWrite(infoFilePath))
{
infofile.Save(fsInfo);
}
}
catch (Exception e)
{
//Debug.WriteLine("Error in PutTileToCache: " + e.ToString());
}
return(true);
}
internal void RemoveOverload()
{
fCacheLock.AcquireWriterLock();
try {
while (MemoryCacheSize > MemoryCacheCapacity)
{
if (fTileCache.Keys.Count > 0 && fQueue.Count > 0)
{
RawTile first = fQueue.Dequeue();
try {
var m = fTileCache[first];
fTileCache.Remove(first);
fMemoryCacheSize -= m.Length;
} catch (Exception ex) {
Debug.WriteLine("RemoveMemoryOverload: " + ex);
}
}
else
{
break;
}
}
} finally {
fCacheLock.ReleaseWriterLock();
}
}
public void AddTileToMemoryCache(RawTile tile, byte[] data)
{
if (data != null)
{
kiberCacheLock.AcquireWriterLock();
try
{
if (!TilesInMemory.ContainsKey(tile))
{
TilesInMemory.Add(tile, data);
}
}
finally
{
kiberCacheLock.ReleaseWriterLock();
}
}
#if DEBUG
else
{
Debug.WriteLine("adding empty data to MemoryCache ;} ");
if (Debugger.IsAttached)
{
Debugger.Break();
}
}
#endif
}
public TileVisual(IEnumerable <ImageSource> src, RawTile tile)
{
Opacity = 0;
Tile = tile;
Source = new ObservableCollection <ImageSource>(src);
Source.CollectionChanged += new System.Collections.Specialized.NotifyCollectionChangedEventHandler(Source_CollectionChanged);
this.Loaded += new RoutedEventHandler(ImageVisual_Loaded);
this.Unloaded += new RoutedEventHandler(ImageVisual_Unloaded);
}
public override MemoryStream GetTileFromServer(RawTile key)
{
if ((mode & AccessMode.Server) != AccessMode.Server)
{
return(null);
}
MemoryStream ms = null;
string url = MakeImageUrl(key, LanguageStr);
try
{
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url);
if (Proxy != null)
{
request.Proxy = Proxy;
request.PreAuthenticate = true;
}
else
{
request.Proxy = WebRequest.DefaultWebProxy;
}
request.UserAgent = UserAgent;
request.Timeout = Timeout;
request.ReadWriteTimeout = Timeout * 6;
request.KeepAlive = true;
request.Referer = "http://www.bing.com/maps/";
using (HttpWebResponse response = request.GetResponse() as HttpWebResponse)
{
ms = Stuff.CopyStream(response.GetResponseStream(), false);
if (ms != null)
{
if ((mode & AccessMode.DBCache) == AccessMode.DBCache)
{
dbCache.PutTileToCache(key, ms);
}
else
{
TileMemoryCache.Instance.Add(key, ms);
}
}
response.Close();
//GC.Collect();
}
}
catch (Exception ex)
{
ms = null;
Debug.WriteLine("Error in GetTileFromServer: " + ex.ToString());
}
return(ms);
}
internal byte[] GetTileFromMemoryCache(RawTile tile)
{
fCacheLock.AcquireReaderLock();
try {
byte[] ret;
if (fTileCache.TryGetValue(tile, out ret))
{
return(ret);
}
} finally {
fCacheLock.ReleaseReaderLock();
}
return(null);
}
// ...
internal byte[] GetTileFromMemoryCache(RawTile tile)
{
kiberCacheLock.AcquireReaderLock();
try {
byte[] ret = null;
if (TilesInMemory.TryGetValue(tile, out ret))
{
return(ret);
}
}
finally {
kiberCacheLock.ReleaseReaderLock();
}
return(null);
}
void AddTileToMemoryCache(RawTile tile, MemoryStream data)
{
kiberCacheLock.AcquireWriterLock();
try
{
if (!TilesInMemory.ContainsKey(tile))
{
TilesInMemory.Add(tile, Stuff.CopyStream(data, true));
}
}
finally
{
kiberCacheLock.ReleaseWriterLock();
}
}
public MemoryStream GetTileFromCache(RawTile key)
{
string quadkey = BingMapTileSystem.TileXYToQuadKey(key.TileXY, key.Level);
if (!QuadKeyList.Contains(quadkey))
{
return(null);
}
string path = string.Format("{0}/{1}.png", directory, quadkey);
FileStream fs = File.OpenRead(path);
MemoryStream ms = new MemoryStream();
fs.CopyTo(ms);
fs.Dispose();
fs.Close();
return(ms);
}
internal void AddTileToMemoryCache(RawTile tile, byte[] data)
{
if (data != null)
{
fCacheLock.AcquireWriterLock();
try {
if (!fTileCache.ContainsKey(tile))
{
fQueue.Enqueue(tile);
fTileCache.Add(tile, data);
fMemoryCacheSize += data.Length;
}
} finally {
fCacheLock.ReleaseWriterLock();
}
}
}
private string MakeImageUrl(RawTile tile, string language)
{
string key = BingMapTileSystem.TileXYToQuadKey(tile.TileXY, tile.Level);
switch (tile.Type)
{
case MapType.BingMap:
return(string.Format("http://ecn.t{0}.tiles.virtualearth.net/tiles/r{1}.png?g={2}&mkt={3}{4}",
GetServerNum(tile.TileXY, 4), key, VersionBingMaps, language, !string.IsNullOrEmpty(BingMapsClientToken) ? "&token=" + BingMapsClientToken : string.Empty));
case MapType.BingSatellite:
return(string.Format("http://ecn.t{0}.tiles.virtualearth.net/tiles/a{1}.jpeg?g={2}&mkt={3}{4}",
GetServerNum(tile.TileXY, 4), key, VersionBingMaps, language, !string.IsNullOrEmpty(BingMapsClientToken) ? "&token=" + BingMapsClientToken : string.Empty));
case MapType.BingHybrid:
return(string.Format("http://ecn.t{0}.tiles.virtualearth.net/tiles/h{1}.jpeg?g={2}&mkt={3}{4}",
GetServerNum(tile.TileXY, 4), key, VersionBingMaps, language, !string.IsNullOrEmpty(BingMapsClientToken) ? "&token=" + BingMapsClientToken : string.Empty));
case MapType.BingMapChinese:
return(string.Format("http://r2.tiles.ditu.live.com/tiles/r{0}.png?g=41", key));
}
return(null);
}
public CacheQueueItem(RawTile tile, byte[] img)
{
Tile = tile;
Img = img;
}
/// <summary>
/// gets image from tile server
/// </summary>
/// <param name="provider"></param>
/// <param name="pos"></param>
/// <param name="zoom"></param>
/// <returns></returns>
public PureImage GetImageFrom(GMapProvider provider, GPoint pos, int zoom, out Exception result)
{
PureImage ret = null;
result = null;
try
{
var rtile = new RawTile(provider.DbId, pos, zoom);
// let't check memmory first
if (UseMemoryCache)
{
var m = MemoryCache.GetTileFromMemoryCache(rtile);
if (m != null)
{
if (GMapProvider.TileImageProxy != null)
{
ret = GMapProvider.TileImageProxy.FromArray(m);
if (ret == null)
{
#if DEBUG
Debug.WriteLine("Image disposed in MemoryCache o.O, should never happen ;} " + new RawTile(provider.DbId, pos, zoom));
if (Debugger.IsAttached)
{
Debugger.Break();
}
#endif
m = null;
}
}
}
}
if (ret == null)
{
if (Mode != AccessMode.ServerOnly && !provider.BypassCache)
{
if (PrimaryCache != null)
{
// hold writer for 5s
if (cacheOnIdleRead)
{
Interlocked.Exchange(ref readingCache, 5);
}
ret = PrimaryCache.GetImageFromCache(provider.DbId, pos, zoom);
if (ret != null)
{
if (UseMemoryCache)
{
MemoryCache.AddTileToMemoryCache(rtile, ret.Data.GetBuffer());
}
return(ret);
}
}
if (SecondaryCache != null)
{
// hold writer for 5s
if (cacheOnIdleRead)
{
Interlocked.Exchange(ref readingCache, 5);
}
ret = SecondaryCache.GetImageFromCache(provider.DbId, pos, zoom);
if (ret != null)
{
if (UseMemoryCache)
{
MemoryCache.AddTileToMemoryCache(rtile, ret.Data.GetBuffer());
}
EnqueueCacheTask(new CacheQueueItem(rtile, ret.Data.GetBuffer(), CacheUsage.First));
return(ret);
}
}
}
if (Mode != AccessMode.CacheOnly)
{
ret = provider.GetTileImage(pos, zoom);
{
// Enqueue Cache
if (ret != null)
{
if (UseMemoryCache)
{
MemoryCache.AddTileToMemoryCache(rtile, ret.Data.GetBuffer());
}
if (Mode != AccessMode.ServerOnly && !provider.BypassCache)
{
EnqueueCacheTask(new CacheQueueItem(rtile, ret.Data.GetBuffer(), CacheUsage.Both));
}
}
}
}
else
{
result = noDataException;
}
}
}
catch (Exception ex)
{
result = ex;
ret = null;
Debug.WriteLine("GetImageFrom: " + ex.ToString());
}
return(ret);
}
public CacheQueueItem(RawTile tile, byte[] Img, CacheUsage cacheType)
{
this.Tile = tile;
this.Img = Img;
this.CacheType = cacheType;
}
// ...
internal byte[] GetTileFromMemoryCache(RawTile tile)
{
kiberCacheLock.AcquireReaderLock();
try
{
if (TilesInMemory.TryGetValue(tile, out byte[] ret))
public CacheQueueItem(RawTile tile, byte[] img, CacheUsage cacheType)
{
Tile = tile;
this.Img = img;
CacheType = cacheType;
}
public override void OnUpdateMap(MapArea viewarea)
{
Stopwatch watch = Stopwatch.StartNew();
PointInt topleftTileXY = BingMapTileSystem.PixelXYToTileXY(viewarea.Area.TopLeft);
PointInt bottomrightTileXY = BingMapTileSystem.PixelXYToTileXY(viewarea.Area.BottomRight);
topleftTileXY.Offset(-2, -2);
bottomrightTileXY.Offset(2, 2);
if (topleftTileXY.X < 0)
{
topleftTileXY.X = 0;
}
if (topleftTileXY.Y < 0)
{
topleftTileXY.Y = 0;
}
int len = 1 << viewarea.Level;
if (bottomrightTileXY.X >= len)
{
bottomrightTileXY.X = len - 1;
}
if (bottomrightTileXY.Y >= len)
{
bottomrightTileXY.Y = len - 1;
}
List <PointInt> pointlist = new List <PointInt>();
for (int i = topleftTileXY.X; i <= bottomrightTileXY.X; i++)
{
for (int j = topleftTileXY.Y; j <= bottomrightTileXY.Y; j++)
{
pointlist.Add(new PointInt(i, j));
}
}
List <RawTile> toBeDel = new List <RawTile>();
foreach (RawTile tile in tileViewDict.Keys)
{
if (tile.Level == viewarea.Level)
{
pointlist.Remove(tile.TileXY);
}
RectInt tilerect = new RectInt(
(tile.TileXY.X - 1) * TileLength, (tile.TileXY.Y - 1) * TileLength, TileLength * 2, TileLength * 2);
if (tile.Level != viewarea.Level)// || !tilerect.HasIntersectsWith(viewarea.Area))
{
toBeDel.Add(tile);
}
}
foreach (RawTile tile in toBeDel)
{
tileViewDict.Remove(tile);
}
foreach (PointInt p in pointlist)
{
RawTile tileKey = new RawTile(this.MapType, p, viewarea.Level);
tileViewDict.Add(tileKey, null);
tileLoadManager.LoadTileAsync(tileKey);
}
watch.Stop();
//Debug.Write(" GetTiles: " + watch.Elapsed.TotalMilliseconds);
}
void CompositionTargetEx_FrameUpdating(object sender, RenderingEventArgs e)
{
if (update)
{
_frameCounterUpdate++;
update = false;
#region -- add image --
for (int x = 0; x < TilesSize.Width; x++)
{
for (int y = 0; y < TilesSize.Height; y++)
{
var rawTile = new RawTile(MapType.GoogleHybrid, new GPoint(x, y), ZoomStep);
var rectTilePx = new Rect(x * Projection.TileSize.Width, y * Projection.TileSize.Height, Projection.TileSize.Width, Projection.TileSize.Height);
TileVisual image = null;
if (!images.TryGetValue(rawTile, out image))
{
var layers = GMaps.Instance.GetAllLayersOfType(rawTile.Type);
ImageSource[] imgs = new ImageSource[layers.Length];
// get tiles
for (int i = 0; i < layers.Length; i++)
{
Exception ex;
var res = GMaps.Instance.GetImageFrom(layers[i], rawTile.Pos, rawTile.Zoom, out ex) as WindowsPresentationImage;
if (res != null)
{
imgs[i] = res.Img;
}
}
// combine visual
image = new TileVisual(imgs, rawTile);
images.Add(rawTile, image);
Canvas.SetZIndex(image, -1);
}
bool ri = (region.IntersectsWith(new GRect((int)(rectTilePx.X + renderOffset.X), (int)(rectTilePx.Y + renderOffset.Y), (int)rectTilePx.Width, (int)rectTilePx.Height)));
if (TilesLayer.Children.Contains(image))
{
if (ri)
{
image.MoveTo(Math.Round(rectTilePx.X) + 0.6 + renderOffset.X, Math.Round(rectTilePx.Y) + 0.6 + renderOffset.Y);
}
else
{
TilesLayer.Children.Remove(image);
}
}
else
{
if (ri)
{
image.MoveTo(Math.Round(rectTilePx.X) + 0.6 + renderOffset.X, Math.Round(rectTilePx.Y) + 0.6 + renderOffset.Y);
BeginAnimateOpacity(image);
{
TilesLayer.Children.Add(image);
}
}
}
//break;
}
//break;
}
count = TilesLayer.Children.Count;
#endregion
}
if (_stopwatch.ElapsedMilliseconds >= 1000)
{
_stopwatch.Stop();
perfInfo.Text = "FPS: " + (ushort)(_frameCounter / _stopwatch.Elapsed.TotalSeconds) + " | " + (ushort)(_frameCounterUpdate / _stopwatch.Elapsed.TotalSeconds) + " | " + count + " tiles";
_frameCounter = 0;
_frameCounterUpdate = 0;
_stopwatch.Reset();
_stopwatch.Start();
}
else
{
_frameCounter++;
}
}
