22 #region Fields and Properties
24 private readonly SlideBase _slideSource;
25 private readonly OpenSlideGTK.OpenSlideBase _openSlideSource;
26 private readonly
bool _isOpenSlide;
29 private ConcurrentDictionary<string, CachedTile> _tileCache;
30 private int _maxCacheSize;
31 private object _cacheLock =
new object();
34 private SKSurface _compositeSurface;
35 private SKCanvas _compositeCanvas;
36 private int _currentSurfaceWidth = 600;
37 private int _currentSurfaceHeight = 400;
40 private ConcurrentDictionary<string, Task<SKImage>> _pendingTileFetches;
43 public int TileSize {
get;
set; } = 256;
44 public int PrefetchRadius {
get;
set; } = 1;
45 public SKSamplingOptions Sampling {
get;
set; } = SKSamplingOptions.Default;
46 public bool EnablePrefetch {
get;
set; } =
false;
55 private class CachedTile
57 public SKImage Image {
get;
set; }
58 public DateTime LastAccessed {
get;
set; }
59 public long SizeBytes {
get;
set; }
60 public string Key {
get;
set; }
62 public CachedTile(SKImage image,
string key)
66 LastAccessed = DateTime.UtcNow;
67 SizeBytes = CalculateSize(image);
70 private long CalculateSize(SKImage image)
72 if (image ==
null)
return 0;
73 return image.Width * image.Height * 4;
85 set => Index =
new TileIndex(Index.Col, Index.Row, value);
91 get => Index.Col * 256;
94 int col = value / 256;
95 Index =
new TileIndex(col, Index.Row, Level);
101 get => Index.Row * 256;
104 int row = value / 256;
105 Index =
new TileIndex(Index.Col, row, Level);
109 public ZCT Coordinate {
get;
set; }
110 public Extent Extent {
get;
set; }
111 public TileIndex Index {
get;
set; }
113 public RectangleD Bounds
117 return new RectangleD(
120 Extent.MaxX - Extent.MinX,
121 Extent.MaxY - Extent.MinY
126 public TileInfo TileInfo
128 get =>
new TileInfo { Index = Index, Extent = Extent };
132 Extent = value.Extent;
143 public string GetCacheKey()
146 return $
"{Index.Col}_{Index.Row}_{Level}_{Coordinate.Z}_{Coordinate.C}_{Coordinate.T}";
151 #region Constructor and Initialization
158 _openSlideSource = openSlideSource ??
throw new ArgumentNullException(nameof(openSlideSource));
161 InitializeCommon(maxCacheSizeMB);
169 _slideSource = slideSource ??
throw new ArgumentNullException(nameof(slideSource));
170 _isOpenSlide =
false;
172 InitializeCommon(maxCacheSizeMB);
175 private void InitializeCommon(
int maxCacheSizeMB)
177 _maxCacheSize = maxCacheSizeMB * 1024 * 1024;
178 _tileCache =
new ConcurrentDictionary<string, CachedTile>();
179 _pendingTileFetches =
new ConcurrentDictionary<string, Task<SKImage>>();
184 #region Public Stitching Methods
185 private readonly SemaphoreSlim _renderSemaphore =
new SemaphoreSlim(1, 1);
193 int viewportWidth = 600,
194 int viewportHeight = 400)
197 int level = CalculateLevelFromResolution(resolution);
198 var tileRequests = CalculateTileRequests(origin, viewportWidth, viewportHeight, level, coordinate, resolution);
199 if (viewportWidth <= 1 || viewportHeight <= 1)
202 viewportHeight = 400;
205 using (var surface = SKSurface.Create(
new SKImageInfo(
208 SKColorType.Rgba8888,
209 SKAlphaType.Premul)))
213 Console.WriteLine(
"Failed to create SKSurface");
217 var canvas = surface.Canvas;
218 canvas.Clear(SKColors.Gray);
221 await CompositeTilesAsync(canvas, tileRequests, origin, resolution);
224 return surface.Snapshot();
234 ZCT coordinate,
double resolution,
int pxwidth,
int pxheight)
236 var tileRequests = CalculateTileRequests(
237 new PointD(region.X,region.Y),pxwidth, pxheight, level, coordinate, resolution);
239 int outputWidth = (int)Math.Ceiling(region.W);
240 int outputHeight = (int)Math.Ceiling(region.H);
242 using (var surface = SKSurface.Create(
new SKImageInfo(outputWidth, outputHeight)))
244 var canvas = surface.Canvas;
245 canvas.Clear(SKColors.Transparent);
247 foreach (var request
in tileRequests)
249 var tileImage = FetchTileSync(request);
250 if (tileImage !=
null)
252 DrawTileToCanvas(canvas,request,
new AForge.PointD(region.X,region.Y), resolution, tileImage);
256 return surface.Snapshot();
262 #region Tile Fetching and Caching
267 private async Task<SKImage> FetchTileAsync(TileRequest request, ZCT coordinate)
269 string key = request.GetCacheKey();
272 if (_tileCache.TryGetValue(key, out var cached))
return cached.Image;
275 if (_pendingTileFetches.TryGetValue(key, out var pendingTask))
return await pendingTask;
278 var fetchTask = Task.Run(async () =>
285 TileInfo tf =
new TileInfo { Index = request.Index, Extent = request.Extent };
287 data = _openSlideSource.GetTile(tf);
292 TileInfo tf =
new TileInfo { Index = request.Index, Extent = request.Extent };
294 data = _slideSource.GetTile(tf,request.Coordinate);
297 if (data ==
null || data.Length == 0)
return null;
300 var levelResolution = CalculateResolutionFromLevel(request.Index.Level);
301 var image = ConvertTileDataToSKImage(data, request);
305 var cachedTile =
new CachedTile(image, DateTime.Now.ToString());
306 _tileCache.AddOrUpdate(key, cachedTile, (k, old) => cachedTile);
312 Console.WriteLine($
"Fetch error for tile {key}: {ex.Message} + {ex.StackTrace}");
316 _pendingTileFetches.TryRemove(key, out _);
321 _pendingTileFetches[key] = fetchTask;
322 return await fetchTask;
328 private SKImage FetchTileSync(TileRequest request)
330 string cacheKey = request.GetCacheKey();
333 if (_tileCache.TryGetValue(cacheKey, out var cachedTile))
335 cachedTile.LastAccessed = DateTime.UtcNow;
336 return cachedTile.Image;
342 byte[] tileData = FetchTileDataSync(request);
343 if (tileData ==
null || tileData.Length == 0)
346 SKImage skImage = ConvertTileDataToSKImage(tileData, request);
350 AddToCache(cacheKey, skImage);
357 Console.WriteLine($
"Error fetching tile sync {cacheKey}: {ex.Message}");
365 private async Task<byte[]> FetchTileDataAsync(TileRequest request)
367 Console.WriteLine($
"\n--- Fetching tile data for Level {request.Level}, Index[{request.Index.Col},{request.Index.Row}] ---");
368 Console.WriteLine($
" Extent: ({request.Extent.MinX:F0}, {request.Extent.MinY:F0}) to ({request.Extent.MaxX:F0}, {request.Extent.MaxY:F0})");
375 byte[] tileData = _openSlideSource.GetTile(request.TileInfo);
377 if (tileData ==
null || tileData.Length == 0)
379 Console.WriteLine($
" ERROR: OpenSlide returned null/empty tile data");
383 Console.WriteLine($
" OpenSlide returned {tileData.Length} bytes");
389 var sliceInfo =
new BioLib.SliceInfo(
394 CalculateResolutionFromLevel(request.Level),
398 var origin =
new PointD(request.Extent.MinX, request.Extent.MinY);
399 var size =
new AForge.Size((
int)request.Bounds.W, (
int)request.Bounds.H);
400 TileInformation tf =
new TileInformation(request.Index, request.Extent, request.Coordinate);
401 byte[] tileData = await _slideSource.GetTileAsync(tf, request.Coordinate);
403 if (tileData ==
null || tileData.Length == 0)
405 Console.WriteLine($
" ERROR: SlideBase returned null/empty tile data");
409 Console.WriteLine($
" SlideBase returned {tileData.Length} bytes");
415 Console.WriteLine($
" EXCEPTION in FetchTileDataAsync: {ex.Message}");
416 Console.WriteLine($
" {ex.StackTrace}");
423 private byte[] FetchTileDataSync(TileRequest request)
427 var sliceInfo =
new OpenSlideGTK.SliceInfo(
432 CalculateResolutionFromLevel(request.Level)
435 return _openSlideSource.GetSlice(sliceInfo, request.Coordinate, request.Level);
439 var sliceInfo =
new BioLib.SliceInfo(
444 CalculateResolutionFromLevel(request.Level),
448 var origin =
new PointD(request.Bounds.X, request.Bounds.Y);
449 var size =
new AForge.Size((
int)request.Bounds.W, (
int)request.Bounds.H);
451 return _slideSource.GetSlice(sliceInfo, origin, size).Result;
457 #region Tile Compositing
462 private async Task CompositeTilesAsync(
464 List<TileRequest> tileRequests,
468 if (tileRequests.Count == 0)
return;
471 var tileTasks = tileRequests.Select(async req =>
473 var image = await FetchTileAsync(req, req.Coordinate);
474 return new { Request = req, Image = image };
477 var results = await Task.WhenAll(tileTasks);
479 using (var paint =
new SKPaint { IsAntialias =
false })
481 foreach (var result
in results)
483 if (result.Image ==
null)
continue;
484 DrawTileToCanvas(canvas, result.Request, origin, resolution, result.Image, paint);
491 private void DrawTileToCanvas(
494 PointD viewportOrigin,
497 SKPaint paint =
null)
499 if (tileImage ==
null)
return;
502 float destX = (float)((request.Extent.MinX - viewportOrigin.X) / resolution);
506 float destY = (float)((viewportOrigin.Y - request.Extent.MaxY) / resolution);
509 float destW = (float)(request.Extent.Width / resolution);
510 float destH = (float)(request.Extent.Height / resolution);
512 var destRect =
new SKRect(destX, destY, destX + destW, destY + destH);
516 canvas.DrawImage(tileImage, destRect, paint);
518 canvas.DrawImage(tileImage, destRect, Sampling);
523 private SKPaint CreateCompositePaint()
528 BlendMode = SKBlendMode.SrcOver
535 private SKPaint CreateTilePaint()
545 #region Tile Calculation and Management
550 private List<TileRequest> CalculateTileRequests(PointD origin,
int viewportWidth,
int viewportHeight,
int level, ZCT coordinate,
double resolution)
555 double minX = origin.X;
556 double maxX = origin.X + (viewportWidth * resolution);
560 double maxY = origin.Y;
563 double minY = origin.Y - (viewportHeight * resolution);
566 var viewportExtent =
new Extent(minX, minY, maxX, maxY);
568 IEnumerable<TileInfo> tileInfos;
571 tileInfos = _openSlideSource.Schema.GetTileInfos(viewportExtent, level);
575 tileInfos = _slideSource.Schema.GetTileInfos(viewportExtent, level);
578 var requests =
new List<TileRequest>();
579 foreach (var info
in tileInfos)
581 requests.Add(
new TileRequest(info, coordinate));
587 #region Cache Management
592 private void AddToCache(
string key, SKImage image)
594 var cachedTile =
new CachedTile(image, key);
598 _tileCache[key] = cachedTile;
601 long currentCacheSize = CalculateTotalCacheSize();
603 if (currentCacheSize > _maxCacheSize)
605 EvictLeastRecentlyUsedTiles(currentCacheSize - _maxCacheSize);
613 private void EvictLeastRecentlyUsedTiles(
long bytesToFree)
615 var sortedTiles =
new List<CachedTile>(_tileCache.Values);
616 sortedTiles.Sort((a, b) => a.LastAccessed.CompareTo(b.LastAccessed));
619 foreach (var tile
in sortedTiles)
621 if (freedBytes >= bytesToFree)
624 if (_tileCache.TryRemove(tile.Key, out var removed))
626 freedBytes += removed.SizeBytes;
627 removed.Image?.Dispose();
635 private long CalculateTotalCacheSize()
638 foreach (var tile
in _tileCache.Values)
640 total += tile.SizeBytes;
652 foreach (var tile
in _tileCache.Values)
654 tile.Image?.Dispose();
662 #region Utility Methods
668 private SKImage ConvertTileDataToSKImage(
byte[] tileData, TileRequest request)
673 using (var data = SKData.CreateCopy(tileData))
675 var image = SKImage.FromEncodedData(data);
676 if (image !=
null)
return image;
681 int width = _isOpenSlide ? _openSlideSource.Schema.GetTileWidth(request.Index.Level)
682 : _slideSource.Schema.GetTileWidth(request.Index.Level);
683 int height = _isOpenSlide ? _openSlideSource.Schema.GetTileHeight(request.Index.Level)
684 : _slideSource.Schema.GetTileHeight(request.Index.Level);
686 var info =
new SKImageInfo(width, height, SKColorType.Bgra8888, SKAlphaType.Premul);
689 var imageInfo =
new SKImageInfo(width, height, SKColorType.Rgba8888, SKAlphaType.Premul);
690 var rawData = SKData.CreateCopy(tileData);
691 var pixmap =
new SKPixmap(imageInfo, rawData.Data, imageInfo.RowBytes);
694 return SKImage.FromPixels(pixmap, (address, context) =>
701 Console.WriteLine($
"Error converting tile data: {ex.Message}");
708 private int CalculateLevelFromResolution(
double resolution)
712 return OpenSlideGTK.TileUtil.GetLevel(_openSlideSource.Schema.Resolutions, resolution);
716 return OpenSlideGTK.TileUtil.GetLevel(_slideSource.Schema.Resolutions, resolution);
723 private double CalculateResolutionFromLevel(
int level)
727 return _openSlideSource.Schema.Resolutions[level].UnitsPerPixel;
731 return _slideSource.Schema.Resolutions[level].UnitsPerPixel;
738 public void Dispose()
741 _pendingTileFetches.Clear();;