SlideRenderer.cs

Go to the documentation of this file.

using AForge;
using BioImager;
using BioLib;
using BruTile;
using OpenSlideGTK;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
 
namespace BioImager
{
    public class SlideRenderer
    {
        private readonly SlideGLArea _glArea;
        private OpenSlideBase _openSlideBase;
        private SlideBase _slideBase;
        private bool _useOpenSlide;
        private HashSet<TileIndex> _uploadedTiles = new();
        private int _currentLevel = -1;
        private bool _hasPendingView;
        private PointD _pendingPyramidalOrigin;
        private int _pendingViewportWidth;
        private int _pendingViewportHeight;
        private double _pendingResolution;
        private ZCT _pendingCoordinate;
        private readonly SemaphoreSlim _renderSemaphore = new(1, 1);
        private readonly SemaphoreSlim _fetchSemaphore = new(6, 6);
        private static readonly TimeSpan RemoteTileFetchTimeout = TimeSpan.FromSeconds(60);
        private readonly HashSet<(TileIndex Index, int Version)> _pendingTileFetches = new();
        private readonly object _pendingTileFetchLock = new();
        private int _redrawQueued = 0;
        private int _contentVersion;
        private (int Z, int C, int T)? _contentCoordinate;
        private BioImage? _rgbZarr;
        private int[]? _rgbSelection;
        private BioImage? _pendingRgbZarr;
        private int[]? _pendingRgbSelection;
 
        public SlideRenderer(SlideGLArea glArea)
        {
            _glArea = glArea;
            _glArea.GLReady += OnGlReady;
        }
 
        public void SetSource(OpenSlideBase source)
        {
            if (IsSource(source)) return;
            _openSlideBase = source;
            _slideBase = null;
            _useOpenSlide = true;
            ClearCache();
        }
 
        public void SetSource(SlideBase source)
        {
            if (IsSource(source)) return;
            _slideBase = source;
            _openSlideBase = null;
            _useOpenSlide = false;
            ClearCache();
        }
 
        public bool IsSource(OpenSlideBase source)
        {
            return _useOpenSlide && ReferenceEquals(_openSlideBase, source);
        }
 
        public bool IsSource(SlideBase source)
        {
            return !_useOpenSlide && ReferenceEquals(_slideBase, source);
        }
 
        public void ClearCache()
        {
            _contentVersion++;
            _contentCoordinate = null;
            _glArea.ClearTextureCache();
            _uploadedTiles.Clear();
            _currentLevel = -1;
            lock (_pendingTileFetchLock)
            {
                _pendingTileFetches.Clear();
            }
        }
 
        public async Task UpdateViewAsync(
            PointD pyramidalOrigin,
            int viewportWidth,
            int viewportHeight,
            double resolution,
            ZCT coordinate,
            BioImage? rgbZarr = null,
            int[]? rgbSelection = null)
        {
            _pendingPyramidalOrigin = pyramidalOrigin;
            _pendingViewportWidth = viewportWidth;
            _pendingViewportHeight = viewportHeight;
            _pendingResolution = resolution;
            _pendingCoordinate = coordinate;
            _pendingRgbZarr = rgbZarr;
            _pendingRgbSelection = rgbSelection?.ToArray();
            _hasPendingView = true;
 
            if (_openSlideBase == null && _slideBase == null)
                return;
            if (viewportWidth <= 1 || viewportHeight <= 1 || resolution <= 0 || !double.IsFinite(resolution))
                return;
            if (!_glArea.IsGLReady)
                return;
            if (!_renderSemaphore.Wait(0))
            {
                return;
            }
 
            try
            {
                var schema = _useOpenSlide ? _openSlideBase.Schema : _slideBase.Schema;
                int level = TileUtil.GetLevel(schema.Resolutions, resolution);
                var levelRes = schema.Resolutions[level];
                double levelUnitsPerPixel = levelRes.UnitsPerPixel;
 
                var contentCoordinate = (coordinate.Z, coordinate.C, coordinate.T);
                if (_contentCoordinate != contentCoordinate || !ReferenceEquals(_rgbZarr, rgbZarr) ||
                    !SelectionsEqual(_rgbSelection, rgbSelection) || level != _currentLevel)
                {
                    // TileIndex alone does not distinguish planes or RGB selections.
                    ClearCache();
                    _contentCoordinate = contentCoordinate;
                    _rgbZarr = rgbZarr;
                    _rgbSelection = rgbSelection?.ToArray();
                    _currentLevel = level;
                }
                int contentVersion = _contentVersion;
 
                double minX = pyramidalOrigin.X;
                double width = viewportWidth * resolution;
                double height = viewportHeight * resolution;
                var viewportExtent = new Extent(minX, -pyramidalOrigin.Y - height, minX + width, -pyramidalOrigin.Y);
 
                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);
 
                var tileInfos = schema.GetTileInfos(fetchExtent, level).ToList();
                if (tileInfos.Count == 0)
                {
                    var lookupExtent = BioLib.ExtentEx.WorldToPixelInvertedY(fetchExtent, levelUnitsPerPixel);
                    tileInfos = schema.GetTileInfos(lookupExtent, level).ToList();
                }
                var renderInfos = new List<TileRenderInfo>();
                var pendingFetches = new List<(TileInfo Tile, Task<byte[]> FetchTask)>();
                foreach (var tileInfo in tileInfos)
                {
                    if (_glArea.HasTileTexture(tileInfo.Index))
                    {
                        renderInfos.Add(CalculateScreenPosition(
                            tileInfo,
                            pyramidalOrigin,
                            resolution,
                            level,
                            schema));
                        continue;
                    }
 
                    bool alreadyPending;
                    lock (_pendingTileFetchLock)
                    {
                        alreadyPending = !_pendingTileFetches.Add((tileInfo.Index, contentVersion));
                    }
 
                    if (!alreadyPending)
                    {
                        pendingFetches.Add((tileInfo, FetchTileAsync(tileInfo, level, coordinate, schema, rgbZarr, rgbSelection?.ToArray(), RemoteTileFetchTimeout)));
                    }
                    renderInfos.Add(CalculateScreenPosition(
                        tileInfo, pyramidalOrigin, resolution, level, schema));
                }
 
                foreach (var pending in pendingFetches)
                {
                    _ = ProcessPendingFetchAsync(
                        pending.Tile,
                        pending.FetchTask,
                        pyramidalOrigin,
                        resolution,
                        level,
                        schema,
                        contentVersion,
                        rgbZarr != null);
                }
 
                _glArea.SetTilesToRender(renderInfos);
                _glArea.RequestRedraw();
            }
            finally
            {
                _renderSemaphore.Release();
            }
        }
 
        private void OnGlReady(object sender, EventArgs e)
        {
            if (!_hasPendingView)
                return;
 
            _ = _glArea.BeginInvoke(new System.Action(async () =>
            {
                try
                {
                    await UpdateViewAsync(
                        _pendingPyramidalOrigin,
                        _pendingViewportWidth,
                        _pendingViewportHeight,
                        _pendingResolution,
                        _pendingCoordinate,
                        _pendingRgbZarr,
                        _pendingRgbSelection);
                }
                catch { }
            }));
        }
 
        private async Task<byte[]> FetchTileAsync(TileInfo tileInfo, int level, ZCT coordinate,
            ITileSchema schema, BioImage? rgbZarr, int[]? rgbSelection, TimeSpan timeout)
        {
            // Capture the source before awaiting: a tab can select another image while I/O is pending.
            var openSource = _openSlideBase;
            var slideSource = _slideBase;
            try
            {
                using var cts = new CancellationTokenSource(timeout);
                await _fetchSemaphore.WaitAsync(cts.Token);
                try
                {
                    byte[] data;
                    if (rgbZarr != null)
                    {
                        double units = schema.Resolutions[level].UnitsPerPixel;
                        int width = (int)Math.Round(tileInfo.Extent.Width / units);
                        int height = (int)Math.Round(tileInfo.Extent.Height / units);
                        data = await ZarrChannelView.ReadRgbTileAsync(rgbZarr, level,
                            tileInfo.Index.Col * schema.GetTileWidth(level),
                            tileInfo.Index.Row * schema.GetTileHeight(level),
                            width, height, coordinate, rgbSelection!).WaitAsync(cts.Token);
                        // SlideGLArea uploads BGRA; the direct Zarr reader returns RGBA.
                        for (int i = 0; i + 3 < data.Length; i += 4)
                            (data[i], data[i + 2]) = (data[i + 2], data[i]);
                    }
                    else
                    {
                        data = openSource != null
                            ? await openSource.GetTileAsync(tileInfo).WaitAsync(cts.Token)
                            : await slideSource.GetTileAsync(tileInfo, coordinate).WaitAsync(cts.Token);
                        if (data != null && rgbSelection != null &&
                            data.Length == schema.GetTileWidth(level) * schema.GetTileHeight(level) * 4)
                        {
                            data = (byte[])data.Clone();
                            for (int i = 0; i + 3 < data.Length; i += 4)
                                for (int color = 0; color < 3; color++)
                                    if (rgbSelection[color] < 0) data[i + 2 - color] = 0;
                        }
                    }
                    return data;
                }
                finally { _fetchSemaphore.Release(); }
            }
            catch (Exception ex)
            {
                System.Diagnostics.Trace.WriteLine($"Could not fetch tile {tileInfo.Index}: {ex.Message}");
                return null;
            }
        }
 
        private async Task ProcessPendingFetchAsync(
            TileInfo tile,
            Task<byte[]> fetchTask,
            PointD pyramidalOrigin,
            double resolution,
            int level,
            ITileSchema schema,
            int contentVersion,
            bool directZarr)
        {
            try
            {
                byte[] tileData = await fetchTask.ConfigureAwait(false);
                if (tileData == null || contentVersion != _contentVersion)
                    return;
 
                double units = schema.Resolutions[level].UnitsPerPixel;
                int tW = (int)Math.Round(tile.Extent.Width / units);
                int tH = (int)Math.Round(tile.Extent.Height / units);
                if (tW <= 0 || tH <= 0) return;
                if (!directZarr)
                {
                    int sourceWidth = schema.GetTileWidth(level);
                    int sourceHeight = schema.GetTileHeight(level);
                    // Edge TileInfo extents can be smaller than the padded source buffer.
                    int pixels = sourceWidth * sourceHeight;
                    int bytesPerPixel = pixels > 0 && tileData.Length % pixels == 0 ? tileData.Length / pixels : 0;
                    if ((tW != sourceWidth || tH != sourceHeight) && bytesPerPixel is >= 1 and <= 4)
                    {
                        byte[] clipped = new byte[checked(tW * tH * bytesPerPixel)];
                        int rowBytes = tW * bytesPerPixel;
                        for (int row = 0; row < tH; row++)
                            Buffer.BlockCopy(tileData, row * sourceWidth * bytesPerPixel, clipped, row * rowBytes, rowBytes);
                        tileData = clipped;
                    }
                }
 
                await RunOnUiThreadAsync(() =>
                {
                    if (contentVersion != _contentVersion) return;
                    if (_glArea.UploadTileTexture(tile.Index, tileData, tW, tH))
                    {
                        _uploadedTiles.Add(tile.Index);
                        _glArea.RequestRedraw();
                    }
                });
            }
            catch
            {
            }
            finally
            {
                lock (_pendingTileFetchLock)
                {
                    _pendingTileFetches.Remove((tile.Index, contentVersion));
                }
 
                if (Interlocked.Exchange(ref _redrawQueued, 1) == 0)
                {
                    try
                    {
                        await RunOnUiThreadAsync(() => _glArea.RequestRedraw());
                    }
                    finally
                    {
                        Interlocked.Exchange(ref _redrawQueued, 0);
                    }
                }
            }
        }
 
        private Task RunOnUiThreadAsync(System.Action action)
        {
            if (_glArea.IsDisposed)
                return Task.CompletedTask;
 
            if (_glArea.InvokeRequired)
            {
                var tcs = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
                try
                {
                    _glArea.BeginInvoke(new System.Action(() =>
                    {
                        try
                        {
                            action();
                            tcs.TrySetResult(true);
                        }
                        catch (Exception ex)
                        {
                            tcs.TrySetException(ex);
                        }
                    }));
                }
                catch (Exception ex)
                {
                    tcs.TrySetException(ex);
                }
 
                return tcs.Task;
            }
 
            action();
            return Task.CompletedTask;
        }
 
        private TileRenderInfo CalculateScreenPosition(
            TileInfo tile,
            PointD pyramidalOrigin,
            double viewResolution,
            int level,
            ITileSchema schema)
        {
            var tileExtent = tile.Extent;
            var clippedExtent = new Extent(
                Math.Max(tileExtent.MinX, schema.Extent.MinX),
                Math.Max(tileExtent.MinY, schema.Extent.MinY),
                Math.Min(tileExtent.MaxX, schema.Extent.MaxX),
                Math.Min(tileExtent.MaxY, schema.Extent.MaxY));
 
            if (clippedExtent.MaxX <= clippedExtent.MinX || clippedExtent.MaxY <= clippedExtent.MinY)
                return new TileRenderInfo(tile.Index, -9999, -9999, 0, 0);
 
            double originScreenX = pyramidalOrigin.X / viewResolution;
            double originScreenY = pyramidalOrigin.Y / viewResolution;
 
            float screenX = (float)(clippedExtent.MinX / viewResolution - originScreenX);
            float screenY = (float)(-clippedExtent.MaxY / viewResolution - originScreenY);
            float screenWidth = (float)((clippedExtent.MaxX - clippedExtent.MinX) / viewResolution);
            float screenHeight = (float)((clippedExtent.MaxY - clippedExtent.MinY) / viewResolution);
 
            return new TileRenderInfo(tile.Index, screenX, screenY, screenWidth, screenHeight);
        }
 
        private static bool SelectionsEqual(int[]? left, int[]? right) =>
            ReferenceEquals(left, right) || (left != null && right != null && left.SequenceEqual(right));
        public int CurrentLevel => _currentLevel;
        public int CachedTextureCount => _uploadedTiles.Count;
    }
}