BioLib.SlideSourceBase Class Reference

Inheritance diagram for BioLib.SlideSourceBase:

Public Member Functions
bool	HasTile (TileInfo tile, ZCT coord)
async Task	FetchTilesAsync (List< BruTile.TileInfo > tiles, int level, ZCT coordinate, PointD PyramidalOrigin, AForge.Size PyramidalSize)
	Fetches tiles in priority order: center viewport first, then edges. Ensures visible content appears before prefetch content.
async Task< byte[]>	GetSlice (SliceInfo sliceInfo, PointD PyramidalOrign, AForge.Size PyramidalSize)
	Get slice.
byte[]	Get8BitBytes (Image< L8 > image)
byte[]	GetRgb24Bytes (Image< Rgb24 > image)
byte[]	Get16Bytes (Image< L16 > image)
IReadOnlyDictionary< string, byte[]>	GetExternImages ()
	Extern image.
void	Dispose ()
async Task< byte[]>	GetTileAsync (TileInformation tileInfo, ZCT coord)
async Task< byte[]>	GetTileAsync (BruTile.TileInfo tileInfo, ZCT coord)
Public Member Functions inherited from BioLib.ISliceProvider
Public Member Functions inherited from BioLib.ISlideExternInfo

Static Public Member Functions
static ISlideSource	Create (BioImage source, SlideImage im, bool enableCache=true)

Public Attributes
TileCache	cache = null
Stitch	stitch = new Stitch()

Static Public Attributes
static Extent	destExtent
static Extent	sourceExtent
static double	curUnitsPerPixel = 1
static bool	UseVips = true

Protected Member Functions
virtual void	Dispose (bool disposing)

Properties
static bool	UseRealResolution = true [get, set]
double	MinUnitsPerPixel [get, protected set]
	um/pixel
static bool	UseGPU [get, set]
SlideImage	Image [get, set]
ITileSchema	Schema [get, protected set]
string	Name [get, protected set]
Attribution	Attribution [get, protected set]
IReadOnlyDictionary< string, object >	ExternInfo [get, protected set]
	Extern info.
string	Source [get, protected set]
	File path.
Properties inherited from BioLib.ISliceProvider
Properties inherited from BioLib.ISlideExternInfo

Member Function Documentation

Create()

static ISlideSource BioLib.SlideSourceBase.Create ( BioImage source, SlideImage im, bool enableCache = true )

static

        {
 
            var ext = Path.GetExtension(source.file).ToUpper();
            try
            {
                if (keyValuePairs.TryGetValue(ext, out var factory) && factory != null)
                    return factory.Invoke(source.file, enableCache);
 
                if (!string.IsNullOrEmpty(SlideBase.DetectVendor(source.file)))
                {
                    SlideBase b = new SlideBase(source, im, enableCache);
 
                }
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
            }
            return null;
        }

Dispose() [1/2]

void BioLib.SlideSourceBase.Dispose

(

)

        {
            Dispose(disposing: true);
            GC.SuppressFinalize(this);
        }

Dispose() [2/2]

virtual void BioLib.SlideSourceBase.Dispose ( bool disposing )

protectedvirtual

        {
            if (!disposedValue)
            {
                if (disposing)
                {
                    //_bgraCache.Dispose();
                }
                disposedValue = true;
            }
        }

FetchTilesAsync()

async Task BioLib.SlideSourceBase.FetchTilesAsync	(	List< BruTile.TileInfo >	tiles,
		int	level,
		ZCT	coordinate,
		PointD	PyramidalOrigin,
		AForge.Size	PyramidalSize )

Fetches tiles in priority order: center viewport first, then edges. Ensures visible content appears before prefetch content.

        {
            if (tiles == null)
                return;
            // --------------------------------------------------------------------
            // 1. Calculate viewport center (base-resolution coordinates)
            // --------------------------------------------------------------------
            double centerX = PyramidalOrigin.X + (PyramidalSize.Width * 0.5);
            double centerY = PyramidalOrigin.Y + (PyramidalSize.Height * 0.5);
 
            // --------------------------------------------------------------------
            // 2. Sort tiles by squared distance (avoid sqrt)
            // --------------------------------------------------------------------
            var prioritizedTiles = tiles
                .OrderBy(tile =>
                {
                    double dx = tile.Extent.CenterX - centerX;
                    double dy = tile.Extent.CenterY - centerY;
                    return (dx * dx) + (dy * dy);
                })
                .ToList();
 
            // --------------------------------------------------------------------
            // 3. Fetch tiles in batches
            // --------------------------------------------------------------------
            int batchSize = GetOptimalBatchSize(PyramidalOrigin, PyramidalSize);
 
            for (int i = 0; i < prioritizedTiles.Count; i += batchSize)
            {
                var batch = prioritizedTiles.Skip(i).Take(batchSize).ToList();
 
                // Parallel fetch within batch
                byte[][] results = await Task.WhenAll(
                    batch.Select(tile => FetchSingleTileAsync(tile, level, coordinate))
                );
 
                // ----------------------------------------------------------------
                // 4. Insert into appropriate cache
                // ----------------------------------------------------------------
                for (int j = 0; j < batch.Count; j++)
                {
                    var tile = batch[j];
                    var data = results[j];
 
                    if (data == null)
                        continue;
                    var info = new Info(
                        coordinate,
                        tile.Index,
                        this.Schema.Extent,
                        level
                    );
                    TileInformation tf = new TileInformation(tile.Index, tile.Extent, coord);
                    if (cache == null)
                        cache = new TileCache(this);
                    if(!cache.HasTile(tf))
                        cache.AddTile(tf, data);
                    TileInfo t = new TileInfo();
                    t.Extent = tile.Extent;
                    t.Index = tile.Index;
                    stitch.AddTile(new Stitch.GpuTile(t,data));
                }
            }
        }

Get16Bytes()

byte[] BioLib.SlideSourceBase.Get16Bytes

(

Image< L16 >

image

)

        {
            int width = image.Width;
            int height = image.Height;
            byte[] bytes = new byte[width * height * 2];
 
            int byteIndex = 0;
            for (int y = 0; y < height; y++)
            {
                for (int x = 0; x < width; x++)
                {
                    L16 pixel = image[x, y];
                    byte[] bts = BitConverter.GetBytes(pixel.PackedValue);
                    bytes[byteIndex++] = bts[0];
                    bytes[byteIndex++] = bts[1];
                }
            }
 
            return bytes;
        }

Get8BitBytes()

byte[] BioLib.SlideSourceBase.Get8BitBytes

(

Image< L8 >

image

)

        {
            int width = image.Width;
            int height = image.Height;
            byte[] rgbBytes = new byte[width * height]; // 3 bytes per pixel (RGB)
 
            int byteIndex = 0;
            for (int y = 0; y < height; y++)
            {
                for (int x = 0; x < width; x++)
                {
                    L8 pixel = image[x, y];
                    rgbBytes[byteIndex++] = pixel.PackedValue;
                }
            }
 
            return rgbBytes;
        }

GetExternImages()

IReadOnlyDictionary< string, byte[]> BioLib.SlideSourceBase.GetExternImages ( )

abstract

Extern image.

Returns

Implements BioLib.ISlideExternInfo.

GetRgb24Bytes()

byte[] BioLib.SlideSourceBase.GetRgb24Bytes

(

Image< Rgb24 >

image

)

        {
            int width = image.Width;
            int height = image.Height;
            byte[] rgbBytes = new byte[width * height * 3]; // 3 bytes per pixel (RGB)
 
            int byteIndex = 0;
            for (int y = 0; y < height; y++)
            {
                for (int x = 0; x < width; x++)
                {
                    Rgb24 pixel = image[x, y];
                    rgbBytes[byteIndex++] = pixel.B;
                    rgbBytes[byteIndex++] = pixel.G;
                    rgbBytes[byteIndex++] = pixel.R;
                }
            }
 
            return rgbBytes;
        }

GetSlice()

async Task< byte[]> BioLib.SlideSourceBase.GetSlice	(	SliceInfo	sliceInfo,
		PointD	PyramidalOrigin,
		AForge.Size	PyramidalSize )

Get slice.

Parameters

sliceInfo

Slice info

Returns

Implements BioLib.ISliceProvider.

        {
            if (cache == null)
                cache = new TileCache(this);
            var curLevel = Image.BioImage.LevelFromResolution(sliceInfo.Resolution);
            var curUnitsPerPixel = Schema.Resolutions[curLevel].UnitsPerPixel;
 
            var tileInfos = Schema.GetTileInfos(sliceInfo.Extent, curLevel);
            if (tileInfos.Count() == 0)
            {
                tileInfos = Schema.GetTileInfos(sliceInfo.Extent.PixelToWorldInvertedY(curUnitsPerPixel), curLevel);
            }
            await FetchTilesAsync(tileInfos.ToList(), curLevel, sliceInfo.Coordinate, PyramidalOrign, PyramidalSize);
 
            var srcPixelExtent = sliceInfo.Extent.WorldToPixelInvertedY(curUnitsPerPixel);
            var dstPixelExtent = sliceInfo.Extent.WorldToPixelInvertedY(sliceInfo.Resolution);
            var dstPixelHeight = sliceInfo.Parame.DstPixelHeight > 0 ? sliceInfo.Parame.DstPixelHeight : dstPixelExtent.Height;
            var dstPixelWidth = sliceInfo.Parame.DstPixelWidth > 0 ? sliceInfo.Parame.DstPixelWidth : dstPixelExtent.Width;
            destExtent = new Extent(0, 0, dstPixelWidth, dstPixelHeight);
            sourceExtent = srcPixelExtent;
            if (UseGPU)
            {
                try
                {
                    if (stitch == null)
                    {
                        Console.WriteLine("GPU stitching not initialized - falling back to CPU");
                        UseGPU = false;
                    }
                    else if (tileInfos.Count() > 0)
                    {
                        // Get standard tile dimensions from schema
                        var schemaTileWidth = Schema.Resolutions[curLevel].TileWidth;
                        var schemaTileHeight = Schema.Resolutions[curLevel].TileHeight;
 
                        // Upload tiles to GPU stitch before rendering
                        foreach (BruTile.TileInfo t in tileInfos)
                        {
                            if (!stitch.HasTile(t))
                            {
                                TileInformation tf = new TileInformation(t.Index, t.Extent, sliceInfo.Coordinate);
                                byte[] tileData = await cache.GetTile(tf);
                                if (tileData != null)
                                {
                                    // Calculate actual tile dimensions (edge tiles may be smaller)
                                    var curTileWidth = (int)(t.Extent.MaxX > Schema.Extent.Width
                                        ? schemaTileWidth - (t.Extent.MaxX - Schema.Extent.Width) / curUnitsPerPixel
                                        : schemaTileWidth);
                                    var curTileHeight = (int)(-t.Extent.MinY > Schema.Extent.Height
                                        ? schemaTileHeight - (-t.Extent.MinY - Schema.Extent.Height) / curUnitsPerPixel
                                        : schemaTileHeight);
 
                                    // Validate dimensions against actual data
                                    int expectedSize = curTileWidth * curTileHeight * 4;
                                    if (tileData.Length != expectedSize)
                                    {
                                        // Fallback: derive from data length assuming RGBA
                                        int pixelCount = tileData.Length / 4;
                                        if (pixelCount == schemaTileWidth * schemaTileHeight)
                                        {
                                            curTileWidth = schemaTileWidth;
                                            curTileHeight = schemaTileHeight;
                                        }
                                        else
                                        {
                                            // Try to find matching dimensions
                                            curTileWidth = schemaTileWidth;
                                            curTileHeight = pixelCount / schemaTileWidth;
                                            if (curTileWidth * curTileHeight != pixelCount)
                                            {
                                                // Square fallback
                                                curTileWidth = (int)Math.Sqrt(pixelCount);
                                                curTileHeight = curTileWidth;
                                            }
                                        }
                                    }
 
                                    var gpuTile = new Stitch.GpuTile(t, tileData);
                                    stitch.AddTile(gpuTile);
                                }
                            }
                        }
                    }
                }
                catch (Exception e)
                {
                    Console.WriteLine(e.Message.ToString());
                    UseVips = true;
                    UseGPU = false;
                }
            }
            else
            if (UseVips)
            {
                try
                {
                    List<Tuple<Extent, byte[]>> tiles = new List<Tuple<Extent, byte[]>>();
                    foreach (BruTile.TileInfo t in tileInfos)
                    {
                        TileInformation tf = new TileInformation(t.Index, t.Extent, sliceInfo.Coordinate);
                        byte[] c = await cache.GetTile(tf);
                        if (c != null)
                            tiles.Add(Tuple.Create(t.Extent.WorldToPixelInvertedY(curUnitsPerPixel), c));
                    }
                    NetVips.Image im = null;
                    if (Image.BioImage.Resolutions[curLevel].PixelFormat == PixelFormat.Format16bppGrayScale)
                        im = ImageUtil.JoinVips16(tiles, srcPixelExtent, new Extent(0, 0, dstPixelWidth, dstPixelHeight));
                    else if (Image.BioImage.Resolutions[curLevel].PixelFormat == PixelFormat.Format24bppRgb)
                        im = ImageUtil.JoinVipsRGB24(tiles, srcPixelExtent, new Extent(0, 0, dstPixelWidth, dstPixelHeight));
                    return im.WriteToMemory();
                }
                catch (Exception e)
                {
                    UseVips = false;
                    Console.WriteLine("Failed to use LibVips please install Libvips for your platform.");
                    Console.WriteLine(e.Message);
                }
            }
            try
            {
                Image im = null;
                List<Tuple<Extent, byte[]>> tiles = new List<Tuple<Extent, byte[]>>();
                foreach (BruTile.TileInfo t in tileInfos)
                {
                    TileInformation tf = new TileInformation(t.Index, t.Extent, sliceInfo.Coordinate);
                    byte[] c = await cache.GetTile(tf);
                    if (c != null)
                        tiles.Add(Tuple.Create(t.Extent.WorldToPixelInvertedY(curUnitsPerPixel), c));
                }
                if (this.Image.BioImage.Resolutions[curLevel].PixelFormat == PixelFormat.Format16bppGrayScale)
                {
                    im = ImageUtil.Join16(tiles, srcPixelExtent, new Extent(0, 0, dstPixelWidth, dstPixelHeight));
                    byte[] bts = Get16Bytes((Image<L16>)im);
                    im.Dispose();
                    return bts;
                }
                else if (this.Image.BioImage.Resolutions[curLevel].PixelFormat == PixelFormat.Format24bppRgb)
                {
                    im = ImageUtil.JoinRGB24(tiles, srcPixelExtent, new Extent(0, 0, dstPixelWidth, dstPixelHeight));
                    byte[] bts = GetRgb24Bytes((Image<Rgb24>)im);
                    im.Dispose();
                    return bts;
                }
                else if (this.Image.BioImage.Resolutions[curLevel].PixelFormat == PixelFormat.Format8bppIndexed)
                {
                    im = ImageUtil.Join8Bit(tiles, srcPixelExtent, new Extent(0, 0, dstPixelWidth, dstPixelHeight));
                    byte[] bts = Get8BitBytes((Image<L8>)im);
                    im.Dispose();
                    return bts;
                }
            }
            catch (Exception er)
            {
                Console.WriteLine(er.Message);
                return null;
            }
            return null;
        }

GetTileAsync() [1/2]

async Task< byte[]> BioLib.SlideSourceBase.GetTileAsync	(	BruTile.TileInfo	tileInfo,
		ZCT	coord )

        {
            if (tileInfo == null)
                return null;
            if (cache == null)
                cache = new TileCache(this);
            if(cache.HasTile(new TileInformation(tileInfo.Index,tileInfo.Extent,coord)))
            {
                return await cache.GetTile(new TileInformation(tileInfo.Index, tileInfo.Extent, coord));
            }
            var r = Schema.Resolutions[tileInfo.Index.Level].UnitsPerPixel;
            var tileWidth = Schema.Resolutions[tileInfo.Index.Level].TileWidth;
            var tileHeight = Schema.Resolutions[tileInfo.Index.Level].TileHeight;
            var curLevelOffsetXPixel = tileInfo.Extent.MinX / Schema.Resolutions[tileInfo.Index.Level].UnitsPerPixel;
            var curLevelOffsetYPixel = -tileInfo.Extent.MaxY / Schema.Resolutions[tileInfo.Index.Level].UnitsPerPixel;
            var curTileWidth = (int)(tileInfo.Extent.MaxX > Schema.Extent.Width ? tileWidth - (tileInfo.Extent.MaxX - Schema.Extent.Width) / r : tileWidth);
            var curTileHeight = (int)(-tileInfo.Extent.MinY > Schema.Extent.Height ? tileHeight - (-tileInfo.Extent.MinY - Schema.Extent.Height) / r : tileHeight);
 
            var bgraData = await Image.ReadRegionAsync(tileInfo.Index.Level, (long)curLevelOffsetXPixel, (long)curLevelOffsetYPixel, curTileWidth, curTileHeight, new ZCT());
            cache.AddTile(new TileInformation(tileInfo.Index, tileInfo.Extent, coord), bgraData);
            return bgraData;
        }

GetTileAsync() [2/2]

async Task< byte[]> BioLib.SlideSourceBase.GetTileAsync	(	TileInformation	tileInfo,
		ZCT	coord )

        {
            if (tileInfo == null)
                return null;
            if (cache.HasTile(new TileInformation(tileInfo.Index, tileInfo.Extent, coord)))
            {
                return await cache.GetTile(new TileInformation(tileInfo.Index, tileInfo.Extent, coord));
            }
            var r = Schema.Resolutions[tileInfo.Index.Level].UnitsPerPixel;
            var tileWidth = Schema.Resolutions[tileInfo.Index.Level].TileWidth;
            var tileHeight = Schema.Resolutions[tileInfo.Index.Level].TileHeight;
            var curLevelOffsetXPixel = tileInfo.Extent.MinX / Schema.Resolutions[tileInfo.Index.Level].UnitsPerPixel;
            var curLevelOffsetYPixel = -tileInfo.Extent.MaxY / Schema.Resolutions[tileInfo.Index.Level].UnitsPerPixel;
            var curTileWidth = (int)(tileInfo.Extent.MaxX > Schema.Extent.Width ? tileWidth - (tileInfo.Extent.MaxX - Schema.Extent.Width) / r : tileWidth);
            var curTileHeight = (int)(-tileInfo.Extent.MinY > Schema.Extent.Height ? tileHeight - (-tileInfo.Extent.MinY - Schema.Extent.Height) / r : tileHeight);
            var bgraData = await Image.ReadRegionAsync(tileInfo.Index.Level, (long)curLevelOffsetXPixel, (long)curLevelOffsetYPixel, curTileWidth, curTileHeight, tileInfo.Coordinate);
            cache.AddTile(new TileInformation(tileInfo.Index, tileInfo.Extent, coord), bgraData);
            return bgraData;
        }

HasTile()

bool BioLib.SlideSourceBase.HasTile	(	TileInfo	tile,
		ZCT	coord )

        {
            if (cache.GetTile(new TileInformation(tile.Index, tile.Extent, coord)) != null)
                return true;
            else
                return false;
        }

Property Documentation

Attribution

Attribution BioLib.SlideSourceBase.Attribution

getprotected set

{ get; protected set; }

ExternInfo

IReadOnlyDictionary<string, object> BioLib.SlideSourceBase.ExternInfo

getprotected set

Extern info.

Implements BioLib.ISlideExternInfo.

{ get; protected set; }

Image

SlideImage BioLib.SlideSourceBase.Image

getset

{ get; set; }

MinUnitsPerPixel

double BioLib.SlideSourceBase.MinUnitsPerPixel

getprotected set

um/pixel

Implements BioLib.ISliceProvider.

{ get; protected set; }

Name

string BioLib.SlideSourceBase.Name

getprotected set

{ get; protected set; }

Schema

ITileSchema BioLib.SlideSourceBase.Schema

getprotected set

{ get; protected set; }

Source

string BioLib.SlideSourceBase.Source

getprotected set

File path.

Implements BioLib.ISlideExternInfo.

{ get; protected set; }

UseGPU

bool BioLib.SlideSourceBase.UseGPU

staticgetset

        {
            get
            {
                if (OperatingSystem.IsMacOS())
                    return false;
                else
                    return true;
            }
            set;
        }

UseRealResolution

bool BioLib.SlideSourceBase.UseRealResolution = true

staticgetset

{ get; set; } = true;

---

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

• BioLib/Source/Bio/ISlideSource.cs