示例#1
0
 public TileRecord(
     Canvas layerCanvas,
     TilePyramidDescriptor tilePyramidDescriptor,
     TileId tileId)
 {
     tilePyramidCanvas          = layerCanvas;
     this.tilePyramidDescriptor = tilePyramidDescriptor;
     this.tileId          = tileId;
     visible              = false;
     WillNeverBeAvailable = false;
 }
示例#2
0
        public RasterTileSource(long logicalFinestLodWidth, long logicalFinestLodHeight, int tileWidth, int tileHeight, int logicalMinimumLevelOfDetail, RasterTileDownloader rasterTileDownloader, TileWrap tileWrap, int log2DuplicatePyramidCount, bool useGlobalMemoryCache = true)
        {
            if (logicalFinestLodWidth <= 0L)
            {
                throw new ArgumentOutOfRangeException(nameof(logicalFinestLodWidth));
            }
            if (logicalFinestLodHeight <= 0L)
            {
                throw new ArgumentOutOfRangeException(nameof(logicalFinestLodHeight));
            }
            if (tileWidth <= 0)
            {
                throw new ArgumentOutOfRangeException(nameof(tileWidth));
            }
            if (tileHeight <= 0)
            {
                throw new ArgumentOutOfRangeException(nameof(tileHeight));
            }
            if (rasterTileDownloader is null)
            {
                throw new ArgumentNullException(nameof(rasterTileDownloader));
            }
            if (tileWrap == TileWrap.None)
            {
                throw new ArgumentException("tileWrap must horizontal, vertical, or both.");
            }
            if (log2DuplicatePyramidCount < 1)
            {
                throw new ArgumentOutOfRangeException(nameof(log2DuplicatePyramidCount));
            }
            finestLodWidth       = logicalFinestLodWidth << log2DuplicatePyramidCount;
            finestLodHeight      = logicalFinestLodHeight << log2DuplicatePyramidCount;
            this.tileWidth       = tileWidth;
            this.tileHeight      = tileHeight;
            minimumLevelOfDetail = logicalMinimumLevelOfDetail + log2DuplicatePyramidCount;
            var logicalTilePyramidDescriptor = new TilePyramidDescriptor(logicalFinestLodWidth, logicalFinestLodHeight, logicalMinimumLevelOfDetail, tileWidth, tileHeight);

            tileIdTransform = tileId =>
            {
                var lod = tileId.LevelOfDetail - log2DuplicatePyramidCount;
                var detailWidthInTiles  = logicalTilePyramidDescriptor.GetLevelOfDetailWidthInTiles(lod);
                var detailHeightInTiles = logicalTilePyramidDescriptor.GetLevelOfDetailHeightInTiles(lod);
                return(new TileId(tileId.LevelOfDetail - log2DuplicatePyramidCount, tileWrap == TileWrap.Horizontal || tileWrap == TileWrap.Both ? tileId.X % detailWidthInTiles : tileId.X, tileWrap == TileWrap.Vertical || tileWrap == TileWrap.Both ? tileId.Y % detailHeightInTiles : tileId.Y));
            };
            transform = VectorMath.TranslationMatrix3D(tileWrap == TileWrap.Horizontal || tileWrap == TileWrap.Both ? -finestLodWidth / 2L : 0.0, tileWrap == TileWrap.Vertical || tileWrap == TileWrap.Both ? -finestLodHeight / 2L : 0.0, 0.0) * VectorMath.ScalingMatrix3D(1 << log2DuplicatePyramidCount, 1 << log2DuplicatePyramidCount, 1.0);
            ConstructCommon(rasterTileDownloader, useGlobalMemoryCache);
        }
        public TilePyramid(
            TilePyramidDescriptor tilePyramidDescriptor,
            TileSource tileSource,
            Canvas parentCanvas)
        {
            if (tilePyramidDescriptor is null)
            {
                throw new ArgumentNullException(nameof(tilePyramidDescriptor));
            }
            if (tileSource is null)
            {
                throw new ArgumentNullException(nameof(tileSource));
            }
            if (parentCanvas is null)
            {
                throw new ArgumentNullException(nameof(parentCanvas));
            }
            if (tilePyramidDescriptor.FinestLevelWidth != tileSource.FinestLodWidth || tilePyramidDescriptor.FinestLevelHeight != tileSource.FinestLodHeight)
            {
                throw new ArgumentException("Tile pyramid descriptor and tile source sizes must match.");
            }
            TilePyramidDescriptor         = tilePyramidDescriptor;
            this.parentCanvas             = parentCanvas;
            TileSource                    = tileSource;
            TileSource.NewTilesAvailable += new EventHandler(TileSource_NewTilesAvailable);
            var canvas = new Canvas
            {
                HorizontalAlignment = HorizontalAlignment.Stretch,
                VerticalAlignment   = VerticalAlignment.Stretch,
                UseLayoutRounding   = false,
                IsHitTestVisible    = false,
                Tag = "TilePyramidCanvas"
            };

            tilePyramidCanvas = canvas;
            Canvas.SetLeft(tilePyramidCanvas, 0.0);
            Canvas.SetTop(tilePyramidCanvas, 0.0);
            this.parentCanvas.Children.Add(tilePyramidCanvas);
            ChooseLevelOfDetailSettings = DownloadFinestNLevelsOfDetailNeeded(3, true, true);
            levelOfDetailSettings       = new List <LevelOfDetailSettings?>(tileSource.MaximumLevelOfDetail);
            for (var index = 0; index <= tileSource.MaximumLevelOfDetail; ++index)
            {
                levelOfDetailSettings.Add(new LevelOfDetailSettings?(new LevelOfDetailSettings(false, 0.0, new int?())));
            }
            coverageMap = new TilePyramidCoverageMap(tileSource.MinimumLevelOfDetail, tileSource.MaximumLevelOfDetail);
        }
 public RasterTileCache(TilePyramidDescriptor tilePyramidDescriptor, RasterTileDownloader rasterTileDownloader, TransformTileId transformTileId, bool useGlobalMemoryCache)
 {
     this.tilePyramidDescriptor = tilePyramidDescriptor;
     this.rasterTileDownloader  = rasterTileDownloader;
     this.transformTileId       = transformTileId;
     this.useGlobalMemoryCache  = useGlobalMemoryCache;
     rasterTileCacheId          = nextRasterTileCacheId++;
     if (this.transformTileId is null)
     {
         this.transformTileId = tileId => tileId;
     }
     if (useGlobalMemoryCache)
     {
         return;
     }
     rasterTileCacheValues         = new Dictionary <TileId, RasterTileCacheValue>();
     relevantTransformedTileIds    = new HashSet <TileId>();
     rasterTileCacheValuesToRemove = new List <TileId>();
 }
        public void Initialize(
            TilePyramidDescriptor tilePyramid,
            ref Matrix3D renderableToViewportTransform,
            Point2D viewportSize,
            TileId visibleTileId)
        {
            VisibleTileId        = visibleTileId;
            viewportCenter       = 0.5 * viewportSize;
            bucketRadiusInterval = 0.5 * Math.Sqrt(viewportSize.X * viewportSize.X + viewportSize.Y * viewportSize.Y) / 5.0 - 1.0;
            lod = visibleTileId.LevelOfDetail;
            tileWidthAtFinestLod  = tilePyramid.TileWidth * (1 << tilePyramid.FinestLevelOfDetail - lod);
            tileHeightAtFinestLod = tilePyramid.TileHeight * (1 << tilePyramid.FinestLevelOfDetail - lod);
            vTL0 = VectorMath.Transform(renderableToViewportTransform, new Point4D(tileWidthAtFinestLod * visibleTileId.X, tileHeightAtFinestLod * visibleTileId.Y, 0.0, 1.0));
            var point4D1 = VectorMath.Transform(renderableToViewportTransform, new Point4D(tileWidthAtFinestLod * (visibleTileId.X + 1L), tileHeightAtFinestLod * visibleTileId.Y, 0.0, 1.0));
            var point4D2 = VectorMath.Transform(renderableToViewportTransform, new Point4D(tileWidthAtFinestLod * visibleTileId.X, tileHeightAtFinestLod * (visibleTileId.Y + 1L), 0.0, 1.0));

            vR = point4D1 - vTL0;
            vD = point4D2 - vTL0;
        }
示例#6
0
 private void ConstructCommon(RasterTileDownloader rasterTileDownloader, bool useGlobalMemoryCache)
 {
     tilePyramidDescriptor = new TilePyramidDescriptor(finestLodWidth, finestLodHeight, minimumLevelOfDetail, tileWidth, tileHeight);
     maximumLevelOfDetail  = tilePyramidDescriptor.FinestLevelOfDetail;
     if (minimumLevelOfDetail < 0 || minimumLevelOfDetail > maximumLevelOfDetail)
     {
         throw new ArgumentException("minimumLevelOfDetail must be in range [0, finest level of detail].");
     }
     rasterTileImageCache = new RasterTileCache(tilePyramidDescriptor, rasterTileDownloader, tileIdTransform, useGlobalMemoryCache);
     rasterTileImageCache.NewTilesAvailable += (sender, e) =>
     {
         if (NewTilesAvailable is null)
         {
             return;
         }
         NewTilesAvailable(this, EventArgs.Empty);
     };
     TileFadeInDuration = new TimeSpan?(TimeSpan.FromMilliseconds(300.0));
 }