示例#1
0
        public void TileFetcherShouldBehaveProperlyWithNoisyResponses()
        {
            // Arrange
            var schema = new GlobalSphericalMercator();
            var tileSource = new TileSource(new SometimesFailingTileProvider(), schema);
            var memoryCache = new MemoryCache<Feature>(14, 17);
            var tileFetcher = new TileFetcher(tileSource, memoryCache);
            var random = new Random(31747074);

            // Act
            for (int i = 0; i < 100; i++)
            {
                var randomLevel = "5";
                var randomCol = random.Next(schema.GetMatrixWidth(randomLevel));
                var randomRow = random.Next(schema.GetMatrixHeight(randomLevel));
                var tileRange = new TileRange(randomCol - 2, randomRow - 2, 5, 5);
                var unitsPerPixel = schema.Resolutions[randomLevel].UnitsPerPixel;
                var extent = TileTransform.TileToWorld(tileRange, randomLevel, schema);
                tileFetcher.ViewChanged(TileTransform.TileToWorld(tileRange, randomLevel, schema).ToBoundingBox(),unitsPerPixel );
                var tileInfos = schema.GetTileInfos(extent, randomLevel);
                foreach (var tileInfo in tileInfos)
                {
                    var tiles = memoryCache.Find(tileInfo.Index);

                }
            }

            // Assert
            Assert.True(memoryCache.TileCount == 0);
        }
示例#2
0
 private static Extent TileToWorldNormal(TileRange range, string levelId, ITileSchema schema)
 {
     var resolution = schema.Resolutions[levelId];
     var tileWorldUnits = resolution.UnitsPerPixel * schema.GetTileWidth(levelId);
     var minX = range.FirstCol * tileWorldUnits + schema.GetOriginX(levelId);
     var minY = range.FirstRow * tileWorldUnits + schema.GetOriginY(levelId);
     var maxX = (range.FirstCol + range.ColCount) * tileWorldUnits + schema.GetOriginX(levelId);
     var maxY = (range.FirstRow + range.RowCount) * tileWorldUnits + schema.GetOriginY(levelId);
     return new Extent(minX, minY, maxX, maxY);
 }
示例#3
0
 private static Extent TileToWorldInvertedY(TileRange range, int level, ITileSchema schema)
 {
     var resolution = schema.Resolutions[level];
     var tileWorldUnits = resolution.UnitsPerPixel * schema.Width;
     var minX = range.FirstCol * tileWorldUnits + schema.OriginX;
     var minY = -(range.FirstRow + range.RowCount) * tileWorldUnits + schema.OriginY;
     var maxX = (range.FirstCol + range.ColCount) * tileWorldUnits + schema.OriginX;
     var maxY = -(range.FirstRow) * tileWorldUnits + schema.OriginY;
     return new Extent(minX, minY, maxX, maxY);
 }
示例#4
0
 public static Extent TileToWorld(TileRange range, string levelId, ITileSchema schema)
 {
     switch (schema.YAxis)
     {
         case YAxis.TMS:
             return TileToWorldNormal(range, levelId, schema);
         case YAxis.OSM:
             return TileToWorldInvertedY(range, levelId, schema);
         default:
             throw new Exception("YAxis type was not found");
     }
 }
示例#5
0
 public static Extent TileToWorld(TileRange range, int level, ITileSchema schema)
 {
     switch (schema.Axis)
     {
         case AxisDirection.Normal:
             return TileToWorldNormal(range, level, schema);
         case AxisDirection.InvertedY:
             return TileToWorldInvertedY(range, level, schema);
         default:
             throw new Exception("Axis type was not found");
     }
 }
示例#6
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);
                    }
                }
            }
        }
示例#7
0
        public IList <TileInfo> GetTilesInView(Extent extent, int level)
        {
            IList <TileInfo> infos = new List <TileInfo>();
            TileRange        range = _axis.WorldToTile(extent, level, this);

            infos.Clear();

            for (int x = range.FirstCol; x < range.LastCol; x++)
            {
                for (int y = range.FirstRow; y < range.LastRow; y++)
                {
                    var info = new TileInfo();
                    info.Extent = _axis.TileToWorld(new TileRange(x, y), level, this);
                    info.Index  = new TileIndex(x, y, level);

                    if (WithinSchemaExtent(Extent, info.Extent))
                    {
                        infos.Add(info);
                    }
                }
            }
            return(infos);
        }
 private Extent TileToWorld(TileRange range, int level, ITileSchema schema)
 {
     Resolution resolution = schema.Resolutions[level];
     double num = resolution.UnitsPerPixel * schema.Width;
     double minX = (range.FirstCol * num) + schema.OriginX;
     double minY = (-(range.LastRow + 1) * num) + schema.OriginY;
     double maxX = ((range.LastCol + 1) * num) + schema.OriginX;
     return new Extent(minX, minY, maxX, (-range.FirstRow * num) + schema.OriginY);
 }
示例#9
0
        public Extent GetExtentOfTilesInView(Extent extent, int level)
        {
            TileRange range = _axis.WorldToTile(extent, level, this);

            return(_axis.TileToWorld(range, level, this));
        }
示例#10
0
        public Extent GetExtentOfTilesInView(Extent extent, int level)
        {
            TileRange range = WorldToTile(extent, level);

            return(TileToWorld(range, level));
        }
示例#11
0
 private Extent TileToWorld(TileRange range, int level)
 {
     double resolution = Resolutions[level];
     double tileWorldUnits = resolution * Width;
     double minX = range.FirstCol * tileWorldUnits + OriginX;
     double minY = -(range.LastRow + 1) * tileWorldUnits + OriginY;
     double maxX = (range.LastCol + 1) * tileWorldUnits + OriginX;
     double maxY = -(range.FirstRow) * tileWorldUnits + OriginY;
     return new Extent(minX, minY, maxX, maxY);
 }