Beispiel #1
0
        protected override string CreateRequestUriCore(TileIndex index)
        {
            int    y   = MapTileProvider.GetSideTilesCount(index.Level) - 1 - index.Y;
            string uri = String.Format(UriFormat, index.X, y, (18 - index.Level));

            return(uri);
        }
        protected override string CreateRequestUriCore(TileIndex index)
        {
            int z     = (int)index.Level;
            int shift = MapTileProvider.GetSideTilesCount(z) / 2;
            int x     = index.X + shift;
            int y     = MapTileProvider.GetSideTilesCount(z) - 1 - index.Y - shift;

            char   serverIdx = (char)('a' + CurrentServer);
            string uri       = "";

            switch (renderer)
            {
            case OpenStreetMapRenderer.Mapnik:
                uri = "tile.openstreetmap.org";
                break;

            case OpenStreetMapRenderer.Osmarenderer:
                uri = "tah.openstreetmap.org/Tiles/tile";
                break;

            case OpenStreetMapRenderer.CycleMap:
                uri = "andy.sandbox.cloudmade.com/tiles/cycle";
                break;

            case OpenStreetMapRenderer.NoName:
                uri = "tile.cloudmade.com/fd093e52f0965d46bb1c6c6281022199/3/256";
                break;

            default:
                break;
            }

            return(string.Format(UriFormat, z.ToString(), x.ToString(), y.ToString(), serverIdx.ToString(), uri));
        }
        protected override string CreateRequestUri(TileIndex index)
        {
            int z = index.Level;
            int x = index.X;
            int y = MapTileProvider.GetSideTilesNum(z) - 1 - index.Y;

            return(String.Format(UriFormat, z, x, y));
        }
 public BitmapSource this[TileIndex id]
 {
     get
     {
         id = MapTileProvider.NormalizeIndex(id);
         return(typeof(T).IsAssignableFrom(typeof(BitmapSource)) ? (BitmapSource)(object)GetTile(id) : null);
     }
 }
        protected override string CreateRequestUriCore(TileIndex index)
        {
            var    level = (int)index.Level;
            var    y     = MapTileProvider.GetSideTilesCount(level) / 2 - index.Y - 1;
            var    x     = MapTileProvider.GetSideTilesCount(level) / 2 + index.X;
            string uri   = String.Format(UriFormat, CurrentServer, x, y, level);

            return(uri);
        }
Beispiel #6
0
        protected override string CreateRequestUriCore(TileIndex index)
        {
            int    x   = index.X;
            int    y   = MapTileProvider.GetSideTilesCount(index.Level) - 1 - index.Y;
            int    z   = (int)index.Level;
            string uri = String.Format(UriFormat, x, y, z);

            return(uri);
        }
Beispiel #7
0
        protected override string CreateRequestUriCore(TileIndex index)
        {
            int x = index.X;
            int y = index.Y - MapTileProvider.GetSideTilesCount(index.Level) / 2;
            int z = (int)(index.Level + 1);

            string uri = String.Format(UriFormat, x, y, z, CurrentServer);

            return(uri);
        }
        public bool TryParse(string fileName, out TileIndex index)
        {
            string name = fileName.Substring(0, fileName.IndexOf('.'));

            int x     = 0;
            int y     = 0;
            int level = 0;

            foreach (char ch in name)
            {
                switch (ch)
                {
                case '0':
                    break;

                case '1':
                    x++;
                    break;

                case '2':
                    y++;
                    break;

                case '3':
                    x++;
                    y++;
                    break;

                default:
                    index = new TileIndex();
                    return(false);
                }

                level++;
                x *= 2;
                y *= 2;
            }

            y     = MapTileProvider.GetSideTilesCount(level) - y;
            index = new TileIndex(x, y, level);

            return(true);
        }
        public T GetTile(TileIndex id)
        {
            object result;

            id = MapTileProvider.NormalizeIndex(id);

            T img = null;

            if (cache.TryGetValue(id, out result))
            {
                img = result as T;
                if (img != null)
                {
                }
                else
                {
                    WeakReference reference = result as WeakReference;
                    if (reference != null && reference.IsAlive)
                    {
                        img = reference.Target as T;
                        // changing weak reference to strong
                        cache[id] = img;
                    }
                }

                // update access time
                if (img != null)
                {
                    accessTime      = Environment.TickCount;
                    accessTimes[id] = accessTime;
                }
                else
                {
                    Debug.WriteLine("Cache miss due to GC.");

                    cache.Remove(id);
                    accessTimes.Remove(id);
                }
            }

            return(img);
        }
        public sealed override bool Contains(TileIndex id)
        {
            id = MapTileProvider.NormalizeIndex(id);

            object img;

            if (cache.TryGetValue(id, out img))
            {
                if (img is T)
                {
                    return(true);
                }
                else
                {
                    WeakReference reference = img as WeakReference;
                    return(reference.IsAlive);
                }
            }

            return(false);
        }
Beispiel #11
0
        public override void BeginLoadImage(TileIndex id)
        {
            DataRect firstLevel = DataRect.Create(-1.7, -1.3, 0.8, 1.2);

            double width = firstLevel.Width / MapTileProvider.GetSideTilesCount(id.Level);
            double xmin  = firstLevel.XMin + (id.X + MapTileProvider.GetSideTilesCount(id.Level) / 2) * width;

            double height = firstLevel.Height / MapTileProvider.GetSideTilesCount(id.Level);
            double ymin   = firstLevel.YMin + (MapTileProvider.GetSideTilesCount(id.Level) / 2 - id.Y - 1) * height;

            DataRect tileBounds = new DataRect(xmin, ymin, width, height);

            if (tasks.Count == 0)
            {
                CreateTask(id, tileBounds);
            }
            else
            {
                tasks.Push(new TaskInfo {
                    ID = id, TileBounds = tileBounds
                });
            }
        }