BioGTK.SlideRenderer Class Reference

Public Member Functions
	SlideRenderer (SlideGLArea glArea)
void	SetSource (OpenSlideBase source)
void	SetSource (SlideBase source)
void	ClearCache (bool resetLevel=true)
void	InvalidateRenderState ()
	Marks all in-flight tile work as stale. Call this before changing threshold/range state so old tiles cannot overwrite the current view.
async Task	UpdateViewAsync (PointD pyramidalOrigin, int viewportWidth, int viewportHeight, double resolution, ZCT coordinate)

Properties
bool	LastRenderSkipped [get]
int	CurrentLevel [get]
int	CachedTextureCount [get]

Detailed Description

Definition at line 13 of file SlideRenderer.cs.

Constructor & Destructor Documentation

SlideRenderer()

BioGTK.SlideRenderer.SlideRenderer

(

SlideGLArea

glArea

)

Definition at line 47 of file SlideRenderer.cs.

        {
            _glArea = glArea;
        }

Member Function Documentation

ClearCache()

void BioGTK.SlideRenderer.ClearCache

(

bool

resetLevel = true

)

Definition at line 88 of file SlideRenderer.cs.

        {
            // Clearing the visible tile cache must also invalidate any in-flight
            // fetches. Otherwise an old Z/C/T request can finish after the
            // coordinate changes and repopulate the GPU cache with stale tiles.
            Interlocked.Increment(ref _renderStateVersion);
 
            _glArea.ClearTextureCache();
            _uploadedTiles.Clear();
            _uploadedTileInfos.Clear();
            if (resetLevel)
                _currentLevel = -1;
            _tileCache?.Clear();
            _openTileCache?.cache.cacheMap.Clear();
 
            _slideBase?.cache?.Clear();
            _openSlideBase?.cache?.cache.cacheMap.Clear();
            _displayRangeSeedLevel = -1;
 
            lock (_pendingLevelSwitchLock)
            {
                _pendingLevelRenderInfos = null;
                _pendingLevel = -1;
                _pendingPreviousLevel = -1;
            }
 
            lock (_pendingTileFetchLock)
            {
                _pendingTileFetches.Clear();
            }
        }

InvalidateRenderState()

void BioGTK.SlideRenderer.InvalidateRenderState

(

)

Marks all in-flight tile work as stale. Call this before changing threshold/range state so old tiles cannot overwrite the current view.

Definition at line 124 of file SlideRenderer.cs.

        {
            Interlocked.Increment(ref _renderStateVersion);
        }

SetSource() [1/2]

void BioGTK.SlideRenderer.SetSource

(

OpenSlideBase

source

)

Definition at line 70 of file SlideRenderer.cs.

        {
            _openSlideBase = source;
            _slideBase = null;
            _useOpenSlide = true;
            _openTileCache = new OpenSlideGTK.TileCache(source, 200);
            ClearCache();
        }

SetSource() [2/2]

void BioGTK.SlideRenderer.SetSource

(

SlideBase

source

)

Definition at line 79 of file SlideRenderer.cs.

        {
            _slideBase = source;
            _openSlideBase = null;
            _useOpenSlide = false;
            _tileCache = new BioLib.TileCache(source, 200);
            ClearCache();
        }

UpdateViewAsync()

async Task BioGTK.SlideRenderer.UpdateViewAsync	(	PointD	pyramidalOrigin,
		int	viewportWidth,
		int	viewportHeight,
		double	resolution,
		ZCT	coordinate )

Definition at line 129 of file SlideRenderer.cs.

        {
            if (_openSlideBase == null && _slideBase == null)
                return;
            if (viewportWidth <= 1 && viewportHeight <= 1)
                return;
 
            // Only allow one render pass at a time. Without this gate, rapid pan
            // events can pile up overlapping async tile fetches and keep large
            // byte[] buffers alive until every stale render finishes.
            if (!_renderSemaphore.Wait(0))
            {
                LastRenderSkipped = true;
                return;
            }
 
            LastRenderSkipped = false;
 
            try
            {
                int renderVersion = _renderStateVersion;
                using var tileFetchCts = new CancellationTokenSource(RemoteTileFetchTimeout);
 
            var schema = _useOpenSlide ? _openSlideBase.Schema : _slideBase.Schema;
 
            int level = TileUtil.GetLevel(schema.Resolutions, resolution);
            var levelRes = schema.Resolutions[level];
            double levelUnitsPerPixel = levelRes.UnitsPerPixel;
 
            await EnsureGlobalDisplayRangeAsync(coordinate, renderVersion, level).ConfigureAwait(false);
 
            bool levelChanged = level != _currentLevel;
 
            // Keep renderer-side bookkeeping scoped to the current viewport.
            // The GL area already owns the actual texture cache; these collections
            // are only used for the current render pass and should not accumulate
            // every tile ever seen while panning.
            _uploadedTiles.Clear();
            _uploadedTileInfos.Clear();
 
            double originX = pyramidalOrigin.X;
            double originY = pyramidalOrigin.Y;
            double minX = originX;
            double width = viewportWidth * resolution;
            double height = viewportHeight * resolution;
            // BioLib pyramids use OSM-style inverted Y coordinates. Keep the
            // renderer in the same convention rather than trying to infer a
            // positive-down variant from the schema bounds.
            var viewportExtent = new Extent(minX, -originY - height, minX + width, -originY);
 
            // Keep the GL scissor aligned with the actual image boundary so
            // edge tiles don't leak padded black pixels outside the image.
            double imageMinX = schema.Extent.MinX;
            double imageMaxX = schema.Extent.MaxX;
            double imageMinY = schema.Extent.MinY;
            double imageMaxY = schema.Extent.MaxY;
            _glArea.ImageScreenX = (float)((imageMinX - pyramidalOrigin.X) / resolution);
            _glArea.ImageScreenY = (float)((-imageMaxY - pyramidalOrigin.Y) / resolution);
            _glArea.ImageScreenW = (float)((imageMaxX - imageMinX) / resolution);
            _glArea.ImageScreenH = (float)((imageMaxY - imageMinY) / resolution);
 
            // Prefetch one tile beyond each viewport edge so partially visible
            // edge tiles are available without overfetching an arbitrary 2x area.
            double tileMarginX = levelRes.TileWidth * levelUnitsPerPixel;
            double tileMarginY = levelRes.TileHeight * levelUnitsPerPixel;
            var fetchExtent = new Extent(
                viewportExtent.MinX - tileMarginX,
                viewportExtent.MinY - tileMarginY,
                viewportExtent.MaxX + tileMarginX,
                viewportExtent.MaxY + tileMarginY);
 
            List<TileInfo> tileInfos;
            List<TileInfo> fallbackInfos;
            if (_useOpenSlide)
            {
                // OpenSlide schemas use their historical pixel-space lookup path.
                var lookupExtent = BioLib.ExtentEx.WorldToPixelInvertedY(fetchExtent, levelUnitsPerPixel);
                tileInfos = schema.GetTileInfos(lookupExtent, level).ToList();
                fallbackInfos = schema.GetTileInfos(fetchExtent, level).ToList();
 
                if (fallbackInfos.Count > 0)
                {
                    var seen = new HashSet<TileIndex>(tileInfos.Select(t => t.Index));
                    foreach (var info in fallbackInfos)
                    {
                        if (seen.Add(info.Index))
                            tileInfos.Add(info);
                    }
                }
            }
            else
            {
                // BioLib/Zarr SlideBase schemas already use the same inverted-Y
                // world convention as BioLib's slice path. Keep lookups in that
                // space so translated datasets stay aligned with the tile schema.
                tileInfos = schema.GetTileInfos(fetchExtent, level).ToList();
                fallbackInfos = new List<TileInfo>();
 
                if (tileInfos.Count == 0)
                {
                    var pixelToWorldExtent = BioLib.ExtentEx.PixelToWorldInvertedY(fetchExtent, levelUnitsPerPixel);
                    fallbackInfos = schema.GetTileInfos(pixelToWorldExtent, level).ToList();
 
                    if (fallbackInfos.Count == 0)
                    {
                        var worldToPixelExtent = BioLib.ExtentEx.WorldToPixelInvertedY(fetchExtent, levelUnitsPerPixel);
                        fallbackInfos = schema.GetTileInfos(worldToPixelExtent, level).ToList();
                    }
 
                    if (fallbackInfos.Count > 0)
                        tileInfos = fallbackInfos;
                }
            }
 
            var renderInfos = new List<TileRenderInfo>();
            var pendingFetches = new List<(TileInfo Tile, Task<byte[]> FetchTask)>();
            foreach (var tileInfo in tileInfos)
            {
                if (renderVersion != _renderStateVersion)
                    return;
 
                var fetchTileInfo = tileInfo;
                var renderTileInfo = tileInfo;
 
                var renderInfo = CalculateScreenPosition(
                    renderTileInfo,
                    pyramidalOrigin,
                    resolution,
                    level,
                    schema);
                renderInfos.Add(renderInfo);
 
                if (!_glArea.HasTileTexture(fetchTileInfo.Index))
                {
                    bool alreadyPending;
                    lock (_pendingTileFetchLock)
                    {
                        alreadyPending = !_pendingTileFetches.Add(fetchTileInfo.Index);
                    }
 
                    if (!alreadyPending)
                        pendingFetches.Add((fetchTileInfo, FetchTileAsync(fetchTileInfo, level, coordinate, tileFetchCts.Token)));
                }
            }
 
            if (pendingFetches.Count > 0)
            {
                foreach (var pending in pendingFetches)
                    _ = ProcessPendingFetchAsync(pending.Tile, pending.FetchTask, tileFetchCts.Token, renderVersion, pyramidalOrigin, resolution, level, schema);
            }
 
            if (renderVersion != _renderStateVersion)
                return;
 
            bool hasRenderableTexture = renderInfos.Any(tile => _glArea.HasTileTexture(tile.Index));
            if (levelChanged)
            {
                if (hasRenderableTexture)
                {
                    bool canSwapNow = renderInfos.All(tile => _glArea.HasTileTexture(tile.Index));
                    if (canSwapNow)
                    {
                        _glArea.PreservePreviousFrameWhileIncomplete = false;
                        _glArea.ReleaseLevelTextures(_currentLevel);
                        _currentLevel = level;
                        lock (_pendingLevelSwitchLock)
                        {
                            _pendingLevelRenderInfos = null;
                            _pendingLevel = -1;
                            _pendingPreviousLevel = -1;
                        }
                    }
                    else
                    {
                        _glArea.PreservePreviousFrameWhileIncomplete = true;
                        lock (_pendingLevelSwitchLock)
                        {
                            _pendingLevelRenderInfos = new List<TileRenderInfo>(renderInfos);
                            _pendingLevel = level;
                            _pendingPreviousLevel = _currentLevel;
                        }
                        return;
                    }
                }
                else
                {
                    _glArea.PreservePreviousFrameWhileIncomplete = true;
                    lock (_pendingLevelSwitchLock)
                    {
                        _pendingLevelRenderInfos = new List<TileRenderInfo>(renderInfos);
                        _pendingLevel = level;
                        _pendingPreviousLevel = _currentLevel;
                    }
                    return;
                }
            }
 
            if (renderVersion != _renderStateVersion)
                return;
 
            await RunOnGtkThreadAsync(() =>
            {
                _glArea.SetTilesToRender(renderInfos);
                _glArea.RequestRedraw();
            });
            }
            finally
            {
                _renderSemaphore.Release();
 
                if (LastRenderSkipped)
                {
                    LastRenderSkipped = false;
                    Gtk.Application.Invoke((s, a) => App.viewer?.RequestDeferredRender());
                }
            }
        }

Property Documentation

CachedTextureCount

int BioGTK.SlideRenderer.CachedTextureCount

get

Definition at line 791 of file SlideRenderer.cs.

CurrentLevel

int BioGTK.SlideRenderer.CurrentLevel

get

Definition at line 790 of file SlideRenderer.cs.

LastRenderSkipped

bool BioGTK.SlideRenderer.LastRenderSkipped

get

Definition at line 36 of file SlideRenderer.cs.

{ get; private set; }

---

The documentation for this class was generated from the following file:

• BioGTK/BioGTK/Source/SlideRenderer.cs