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++; } }