Example #1
0
 public DataChangedEventArgs(Exception error, bool cancelled, TileInfo tileInfo, string layerName)
 {
     Error = error;
     Cancelled = cancelled;
     TileInfo = tileInfo;
     LayerName = layerName;
 }
Example #2
0
        public Uri GetUri(TileInfo info)
        {
            var x = info.Index.Col;
            var y = info.Index.Row;
            var zoomLevel = Convert.ToInt32(info.Index.Level);

            string url = string.Empty;

            int serverNum = ((GetServerNum(x, y, 2)) + 1);
            int posY = (((1 << zoomLevel) >> 1) - 1 - y);
            int zoom = zoomLevel + 1;

            switch (_mapType)
            {
                case YahooMapType.Normal:
                {
                    url = string.Format(normalURL, serverNum, x, posY, zoom);
                }
                    break;
                case YahooMapType.Satellite:
                {
                    url = string.Format(sateliteURL, serverNum, x, posY, zoom);
                }
                    break;
                case YahooMapType.Hybrid:
                {
                    url = string.Format(hybridURL, serverNum, x, posY, zoom);
                }
                    break;
            }

            return new Uri(url);
        }
Example #3
0
 public FetchTileCompletedEventArgs(Exception error, bool cancelled, TileInfo tileInfo, byte[] image)
 {
     Error = error;
     Cancelled = cancelled;
     TileInfo = tileInfo;
     Image = image;
 }
Example #4
0
        public byte[] GetTile(TileInfo tileInfo)
        {
            byte[] bytes = null;

            bytes = fileCache.Find(tileInfo.Index);
            if (bytes == null) throw new FileNotFoundException("The tile was not found at it's expected location");
            return bytes;
        }
        public byte[] GetTile(TileInfo tileInfo)
        {
            byte[] bufferTile = this._fileCache.Find(tileInfo.Index);
            if (bufferTile == null)
            {
            long rowIndex = (tileInfo.Index.Row / packetSize) * packetSize;
            long colIndex = (tileInfo.Index.Col / packetSize) * packetSize;
            string filepath = string.Format(@"{0}\L{1:d2}\R{2:x4}C{3:x4}", this.url,int.Parse(tileInfo.Index.LevelId), rowIndex, colIndex);
            string bundlxFilename = string.Format("{0}.bundlx", filepath);
            string bundleFilename = string.Format("{0}.bundle", filepath);

            if (!File.Exists(bundlxFilename) || !File.Exists(bundleFilename))
                return null;

            try
            {
                long offsetX = getBundlxOffset(int.Parse( tileInfo.Index.LevelId), tileInfo.Index.Row, tileInfo.Index.Col, packetSize);
                byte[] idxData = new byte[5];
                using (Stream bundlx = System.IO.File.OpenRead(bundlxFilename))
                {
                    bundlx.Seek(offsetX, SeekOrigin.Begin);
                    bundlx.Read(idxData, 0, 5);
                }

                var bundleOffset = ((idxData[4] & 0xFF) << 32) | ((idxData[3] & 0xFF) << 24) |
                    ((idxData[2] & 0xFF) << 16) | ((idxData[1] & 0xFF) << 8) | ((idxData[0] & 0xFF));

                using (Stream bundle = System.IO.File.OpenRead(bundleFilename))
                {
                    bundle.Seek(bundleOffset, SeekOrigin.Begin);
                    byte[] buffer = new byte[4];
                    bundle.Read(buffer, 0, 4);
                    int recordLen = ((buffer[3] & 0xFF) << 24) | ((buffer[2] & 0xFF) << 16) | ((buffer[1] & 0xFF) << 8) | ((buffer[0] & 0xFF));
                    byte[] imgData = new byte[recordLen];
                    bundle.Read(imgData, 0, recordLen);
                    bufferTile = imgData;
                }
            }
            catch
            {
                return null;
            }

            //    StringBuilder builder = new StringBuilder();
            //    builder.AppendFormat(CultureInfo.InvariantCulture, @"{0}\{1}\{2}\{3}.{4}", new object[] { this.url, LevelToHex(tileInfo.Index.LevelId), RowToHex(tileInfo.Index.Row), ColumnToHex(tileInfo.Index.Col), this._format });
            //    if (File.Exists(builder.ToString()))
            //    {
            //        FileStream stream = File.OpenRead(builder.ToString());
            //        buffer = new byte[stream.Length];
            //        stream.Read(buffer, 0, buffer.Length);
            //    }
            if (bufferTile != null)
            {
                this._fileCache.Add(tileInfo.Index, bufferTile);
            }
            }
            return bufferTile;
        }
Example #6
0
 public byte[] GetTile(TileInfo tileInfo)
 {
     using (var cn = new SQLiteConnection(_content.ConnectionString).OpenAndReturn())
     {
         var cmd = new SQLiteCommand(_selectSql, cn);
         cmd.Parameters.AddRange(new object[] { int.Parse(tileInfo.Index.Level), tileInfo.Index.Col, tileInfo.Index.Row });
         return (byte[]) cmd.ExecuteScalar();
     }
 }
        public byte[] GetTile(TileInfo tileInfo)
        {
            if (_random.NextDouble() < 0.5)
            {
                if (_random.NextDouble() < 0.5)
                    throw new Exception("this provider sometimes fails");
                return null; // This means the tile is not available in the source
            }

            System.Threading.Thread.Sleep(10);
            return new byte[0];
        }
        private void Fetch(TileInfo tileInfo)
        {
            try
            {
                var data = _tileSource.Provider.GetTile(tileInfo);
                _fileCache.Add(tileInfo.Index, data);

                _fileCache.AddWorldFile(tileInfo, _tileSource.Schema.GetTileHeight("0"), _tileSource.Schema.GetTileHeight("0"),
                    _tileSource.Schema.Format);
            }
            catch (Exception)
            {
            }
        }
Example #9
0
        private static byte[] GetTile(ITileSource tileSource, string level, int col, int row)
        {
            try
            {
                var tileInfo = new TileInfo();
                var tileIndex = new TileIndex(col, row, level);
                tileInfo.Index = tileIndex;

                return tileSource.Provider.GetTile(tileInfo);
            }
            catch (WebException)
            {
                // intented: do nothing
                return null;
            }
        }
 public byte[] GetTile(TileInfo tileInfo)
 {
     byte[] buffer = this._fileCache.Find(tileInfo.Index);
     if (buffer == null)
     {
     StringBuilder builder = new StringBuilder();
     builder.AppendFormat(CultureInfo.InvariantCulture, @"{0}\{1}\{2}\{3}.{4}", new object[] { this.url, LevelToHex(tileInfo.Index.LevelId), RowToHex(tileInfo.Index.Row), ColumnToHex(tileInfo.Index.Col), this._format });
     if (File.Exists(builder.ToString()))
     {
         FileStream stream = File.OpenRead(builder.ToString());
         buffer = new byte[stream.Length];
         stream.Read(buffer, 0, buffer.Length);
     }
     if (buffer != null)
     {
         this._fileCache.Add(tileInfo.Index, buffer);
     }
     }
     return buffer;
 }
Example #11
0
        public IEnumerable<TileInfo> GetTilesInView(Extent extent, int level)
        {
            TileRange range = TileTransform.WorldToTile(extent, level, this);

            for (int x = range.FirstCol; x < range.FirstCol + range.ColCount; x++)
            {
                for (int y = range.FirstRow; y < range.FirstRow + range.RowCount; y++)
                {
                    var info = new TileInfo
                        {
                            Extent = TileTransform.TileToWorld(new TileRange(x, y), level, this),
                            Index = new TileIndex(x, y, level)
                        };

                    if (WithinSchemaExtent(Extent, info.Extent))
                    {
                        yield return info;
                    }
                }
            }
        }
Example #12
0
        private static List<IFeature> TileIndexToFeatures(TileIndex[] tileIndexes, ITileSource tileSource)
        {
            var features = new List<IFeature>();
            foreach (var tileIndex in tileIndexes)
            {
                var tileInfo = new TileInfo
                {
                    Index = tileIndex,
                    Extent = TileTransform.TileToWorld(
                        new TileRange(tileIndex.Col, tileIndex.Row), tileIndex.Level, tileSource.Schema)
                };

                var feature = new Feature
                {
                    Geometry = new Raster(new MemoryStream(
                        tileSource.GetTile(tileInfo)), tileInfo.Extent.ToBoundingBox())
                };

                features.Add(feature);
            }
            return features;
        }
        public static void AddWorldFile(this FileCache fileCache, TileInfo tileInfo, int width, int height, string format)
        {
            var fileName = fileCache.GetFileName(tileInfo.Index);
            var fi = new FileInfo(fileName);

            var tfwFile = fileName.Replace(fi.Extension, "." + GetWorldFile(format));

            var extent = tileInfo.Extent;

            using (var sw = new StreamWriter(tfwFile))
            {
                var resX = (extent.MaxX - extent.MinX) / width;
                var resY = (extent.MaxY - extent.MinY) / height;
                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();
            }
        }
Example #14
0
 private void StartFetchOnThread(TileInfo info)
 {
     var fetchOnThread = new FetchOnThread(tileSource.Provider, info, LocalFetchCompleted);
     ThreadPool.QueueUserWorkItem(fetchOnThread.FetchTile);
 }
Example #15
0
        private void FetchTile(TileInfo info)
        {
            //first a number of checks
            if (tilesInProgress.Contains(info.Index)) return;
            if (retries.Keys.Contains(info.Index) && retries[info.Index] >= maxRetries) return;
            if (memoryCache.Find(info.Index) != null) return;

            //now we can go for the request.
            lock (tilesInProgress) { tilesInProgress.Add(info.Index); }
            if (!retries.Keys.Contains(info.Index)) retries.Add(info.Index, 0);
            else retries[info.Index]++;
            threadCount++;
            StartFetchOnThread(info);
        }
Example #16
0
 public byte[] GetTile(TileInfo tileInfo)
 {
     return _dictionary[tileInfo.Index];
 }
 private void CreateRaster(TileInfo tile, string name)
 {
     var schema = _tileSource.Schema;
     var fi = new FileInfo(name);
     var tfwFile = name.Replace(fi.Extension, "." + WorldFileWriter.GetWorldFile(schema.Format));
     WorldFileWriter.WriteWorldFile(tfwFile, tile.Extent, schema);
 }
Example #18
0
 protected Image GetImageFromFileCache(TileInfo info)
 {
     MemoryStream ms = new MemoryStream(_fileCache.Find(info.Index));
     Image img = Image.FromStream(ms);
     ms.Dispose();
     return img;
 }
Example #19
0
        private static void DrawImage(WriteableBitmap targetBitmap, WriteableBitmap bitmap, Rect dest, TileInfo tile, MemoryCache<Feature> memoryCache, double opacity)
        {
            try
            {
                //todo: look at GDI rendering to deal with clipping
                                var destRounded = RoundToPixel(dest);
                var sourceRect = new Rect(0, 0, 256, 256);

                opacity = 1; // hack, opacity not supported 
                // Create the opacity color which sets the transparencey of the blitted image.
                var color = Color.FromArgb((byte)Convert.ToInt32(255 * opacity), 255, 255, 255);
                //todo: rethink opacity. There is opacity at layer level, and could be at tile level.

                targetBitmap.Blit(destRounded, bitmap, sourceRect, color, WriteableBitmapExtensions.BlendMode.Alpha);
                //!!!targetBitmap.DrawRectangle((int)destRounded.Left, (int)destRounded.Top, (int)destRounded.Right, (int)destRounded.Bottom, Colors.Red);
            }
            catch (Exception ex)
            {
                // todo report error
                Console.WriteLine(ex.Message);
                memoryCache.Remove(tile.Index);
            }
        }
Example #20
0
 /// <summary>
 /// Function to get a tile image from the <see cref="FileCache"/>.
 /// </summary>
 /// <param name="info">The tile info</param>
 /// <returns>The tile-image, if already cached</returns>
 protected Image GetImageFromFileCache(TileInfo info)
 {
     using (var ms = new MemoryStream(_fileCache.Find(info.Index)))
     {
         return Image.FromStream(ms);
     }
 }
Example #21
0
 public FetchOnThread(ITileProvider tileProvider, TileInfo tileInfo, FetchTileCompletedEventHandler fetchTileCompleted)
 {
     _tileProvider = tileProvider;
     _tileInfo = tileInfo;
     _fetchTileCompleted = fetchTileCompleted;
 }
Example #22
0
 public FetchOnThread(FileTileProvider tileProvider, TileInfo tileInfo, FetchTileCompletedEventHandler fetchTileCompleted)
 {
     this.tileProvider = tileProvider;
     this.tileInfo = tileInfo;
     this.fetchTileCompleted = fetchTileCompleted;
 }
Example #23
0
 public DataChangedEventArgs(Exception error, bool cancelled, TileInfo tileInfo)
     : this(error, cancelled, tileInfo, string.Empty) {}
Example #24
0
 public byte[] GetTile(TileInfo tileInfo)
 {
     return null;
 }
Example #25
0
 public byte[] GetTile(TileInfo tileInfo)
 {
     return Provider.GetTile(tileInfo);
 }
Example #26
0
 /// <summary>
 /// Method to add a tile image to the <see cref="FileCache"/>
 /// </summary>
 /// <param name="tileInfo">The tile info</param>
 /// <param name="bitmap">The tile image</param>
 protected void AddImageToFileCache(TileInfo tileInfo, Bitmap bitmap)
 {
     using (var ms = new MemoryStream())
     {
         bitmap.Save(ms, _ImageFormat);
         ms.Seek(0, SeekOrigin.Begin);
         var data = new byte[ms.Length];
         ms.Read(data, 0, data.Length);
         _fileCache.Add(tileInfo.Index, data);
     }
 }
 // Methods
 public ArcGISTileSchema(string FilePath)
 {
     Resolution resolution2;
     this.url = @"C:\arcgisserver\arcgiscache\GZMap\Layers\conf.xml";
     this.url = FilePath;
     XmlDocument document = new XmlDocument();
     document.Load(this.url);
     XmlNode documentElement = document.DocumentElement;
     XmlNodeList elementsByTagName = document.GetElementsByTagName("LODInfo");
     List<LODInfo> list2 = new List<LODInfo>();
     foreach (XmlNode node2 in elementsByTagName)
     {
     string innerText = node2["LevelID"].InnerText;
     string str2 = node2["Scale"].InnerText;
     string str3 = node2["Resolution"].InnerText;
     LODInfo item = new LODInfo();
     item.LevelID = Convert.ToInt32(innerText);
     item.Scale = Convert.ToDouble(str2);
     item.Resolution = Convert.ToDouble(str3);
     list2.Add(item);
     }
     foreach (LODInfo info2 in list2)
     {
     resolution2 = new Resolution();
     Resolution resolution = resolution2;
     resolution.Id = info2.LevelID.ToString();
     resolution.UnitsPerPixel = info2.Resolution;
     base.Resolutions.Add(resolution);
     }
     base.Height = 0x100;
     base.Width = 0x100;
     base.Extent = new Extent(-180.0, -90.0, 180.0, 90.0);
     XmlNodeList list3 = document.GetElementsByTagName("SpatialReference");
     base.OriginX = Convert.ToDouble(list3[0]["XOrigin"].InnerText);
     base.OriginY = Convert.ToDouble(list3[0]["YOrigin"].InnerText);
     list3 = document.GetElementsByTagName("TileCols");
     base.Width = Convert.ToInt32(list3[0].InnerText);
     list3 = document.GetElementsByTagName("TileRows");
     base.Height = Convert.ToInt32(list3[0].InnerText);
     base.Axis = AxisDirection.InvertedY;
     list3 = document.GetElementsByTagName("TileOrigin");
     base.OriginX = Convert.ToDouble(list3[0].FirstChild.InnerText);
     base.OriginY = Convert.ToDouble(list3[0].LastChild.InnerText);
     base.Name = "ArcGISTileCache";
     base.Format = "png";
     base.Srs = "UnKnown";
     DirectoryInfo info3 = new DirectoryInfo(Path.GetDirectoryName(FilePath) + @"\_alllayers\L00");
     BoundingBox box = null;
     foreach (DirectoryInfo info4 in info3.GetDirectories())
     {
     int row = RowToHex(info4.Name);
     int level = 0;
     foreach (FileInfo info5 in info4.GetFiles())
     {
         if (info5.FullName.EndsWith(base.Format))
         {
             BoundingBox box2;
             int col = ColumnToHex(info5.Name);
             TileInfo info6 = new TileInfo();
             info6.Extent = this.TileToWorld(new TileRange(col, row), level, this);
             resolution2 = base.Resolutions[level];
             info6.Index = new TileIndex(col, row, resolution2.Id);
             try
             {
                 box2 = new BoundingBox(info6.Extent.MinX, info6.Extent.MinY, info6.Extent.MaxX, info6.Extent.MaxY);
             }
             catch (Exception)
             {
                 box2 = new BoundingBox(-180.0, -90.0, 180.0, 90.0);
             }
             if (box2 != null)
             {
                 box = (box == null) ? box2 : box.Join(box2);
             }
         }
     }
     }
     if (box != null)
     {
     base.Extent = new Extent(box.Min.X, box.Min.Y, box.Max.X, box.Max.Y);
     }
 }
Example #28
0
 /// <summary>
 /// Generates a URI at which to get the data for a tile.
 /// </summary>
 /// <param name="info">Information about a tile.</param>
 /// <returns>The URI at which to get the data for the specified tile.</returns>
 public Uri GetUri(TileInfo info)
 {
     return new Uri(_fixedUrl + string.Format("&BBOX={0}", info.Extent));
 }
Example #29
0
 private void OnMapNewTileAvaliable(TileInfo tileInfo, Bitmap bitmap)
 {
     if (this.MapNewTileAvaliable != null)
     {
         BoundingBox bb = new BoundingBox(tileInfo.Extent.MinX, tileInfo.Extent.MinY, tileInfo.Extent.MaxX, tileInfo.Extent.MaxY);
         this.MapNewTileAvaliable(this, bb, bitmap, _source.Schema.Width, _source.Schema.Height, _imageAttributes);
     }
 }
Example #30
0
 /// <summary>
 /// Gets the actual image content of the tile as byte array
 /// </summary>
 public byte[] GetTile(TileInfo tileInfo)
 {
     return(_provider.GetTile(tileInfo));
 }
Example #31
0
        private void FetchTile(TileInfo info, Retries retries)
        {
            if (retries.ReachedMax(info.Index)) return;
            
            lock (_tilesInProgress)
            {
                if (_tilesInProgress.Contains(info.Index)) return;
                _tilesInProgress.Add(info.Index);
            }

            retries.PlusOne(info.Index);
            _threadCount++;

            StartFetchOnThread(info);
        }