BioLib.SlideSourceBase Class Reference

Inheritance diagram for BioLib.SlideSourceBase:

Public Member Functions
async Task< byte[]>	GetSlice (SliceInfo sliceInfo)
	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)
async Task< byte[]>	GetTileAsync (BruTile.TileInfo tileInfo)
Public Member Functions inherited from BioLib.ISliceProvider
Public Member Functions inherited from BioLib.ISlideExternInfo

Static Public Member Functions
static void	Resister (string extensionUpper, Func< string, bool, ISlideSource > factory)
	resister decode for Specific format
static ISlideSource	Create (BioImage source, SlideImage im, bool enableCache=true)
static byte[]	ConvertRgbaToRgb (byte[] rgbaArray)

Public Attributes
TileCache	cache = null

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
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

Detailed Description

Definition at line 135 of file ISlideSource.cs.

Member Function Documentation

ConvertRgbaToRgb()

static byte[] BioLib.SlideSourceBase.ConvertRgbaToRgb ( byte[] rgbaArray )

static

Definition at line 384 of file ISlideSource.cs.

        {
            // Initialize a new byte array for RGB24 format
            byte[] rgbArray = new byte[(rgbaArray.Length / 4) * 3];
 
            for (int i = 0, j = 0; i < rgbaArray.Length; i += 4, j += 3)
            {
                // Copy the R, G, B values, skip the A value
                rgbArray[j] = rgbaArray[i + 2];     // B
                rgbArray[j + 1] = rgbaArray[i + 1]; // G
                rgbArray[j + 2] = rgbaArray[i]; // R
            }
 
            return rgbArray;
        }

Create()

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

static

Definition at line 153 of file ISlideSource.cs.

        {
            
            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

(

)

Definition at line 348 of file ISlideSource.cs.

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

Dispose() [2/2]

virtual void BioLib.SlideSourceBase.Dispose ( bool disposing )

protectedvirtual

Definition at line 331 of file ISlideSource.cs.

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

Get16Bytes()

byte[] BioLib.SlideSourceBase.Get16Bytes

(

Image< L16 >

image

)

Definition at line 293 of file ISlideSource.cs.

        {
            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

)

Definition at line 255 of file ISlideSource.cs.

        {
            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

)

Definition at line 273 of file ISlideSource.cs.

        {
            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

)

Get slice.

Parameters

sliceInfo

Slice info

Returns

Implements BioLib.ISliceProvider.

Definition at line 181 of file ISlideSource.cs.

        {
            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);
            List<Tuple<Extent, byte[]>> tiles = new List<Tuple<Extent, byte[]>>();
            foreach (BruTile.TileInfo t in tileInfos)
            {
                TileInformation tf = new TileInformation();
                tf.Extent = t.Extent;
                tf.Coordinate = sliceInfo.Coordinate;
                tf.Index = t.Index;
                byte[] c = await cache.GetTile(tf);
                if(c!=null)
                tiles.Add(Tuple.Create(t.Extent.WorldToPixelInvertedY(curUnitsPerPixel), c));
            }
            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 (UseVips)
            {
                try
                {
                    NetVips.Image im = null;
                    if (this.Image.BioImage.Resolutions[curLevel].PixelFormat == PixelFormat.Format16bppGrayScale)
                        im = ImageUtil.JoinVips16(tiles, srcPixelExtent, new Extent(0, 0, dstPixelWidth, dstPixelHeight));
                    else if(this.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;
                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

)

Definition at line 369 of file ISlideSource.cs.

        {
            if (tileInfo == null)
                return null;
            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());
            return bgraData;
        }

GetTileAsync() [2/2]

async Task< byte[]> BioLib.SlideSourceBase.GetTileAsync

(

TileInformation

tileInfo

)

Definition at line 354 of file ISlideSource.cs.

        {
            if (tileInfo == null)
                return null;
            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);
            return bgraData;
        }

Resister()

static void BioLib.SlideSourceBase.Resister ( string extensionUpper, Func< string, bool, ISlideSource > factory )

static

resister decode for Specific format

Parameters

extensionUpper	dot and extension upper
factory	file path,enable cache,decoder

Definition at line 147 of file ISlideSource.cs.

        {
            keyValuePairs.Add(extensionUpper, factory);
        }

Member Data Documentation

cache

TileCache BioLib.SlideSourceBase.cache = null

Definition at line 180 of file ISlideSource.cs.

curUnitsPerPixel

double BioLib.SlideSourceBase.curUnitsPerPixel = 1

static

Definition at line 178 of file ISlideSource.cs.

destExtent

Extent BioLib.SlideSourceBase.destExtent

static

Definition at line 176 of file ISlideSource.cs.

sourceExtent

Extent BioLib.SlideSourceBase.sourceExtent

static

Definition at line 177 of file ISlideSource.cs.

UseVips

bool BioLib.SlideSourceBase.UseVips = true

static

Definition at line 179 of file ISlideSource.cs.

Property Documentation

Attribution

Attribution BioLib.SlideSourceBase.Attribution

getprotected set

Definition at line 320 of file ISlideSource.cs.

{ get; protected set; }

ExternInfo

IReadOnlyDictionary<string, object> BioLib.SlideSourceBase.ExternInfo

getprotected set

Extern info.

Implements BioLib.ISlideExternInfo.

Definition at line 322 of file ISlideSource.cs.

{ get; protected set; }

Image

SlideImage BioLib.SlideSourceBase.Image

getset

Definition at line 314 of file ISlideSource.cs.

{ get; set; }

MinUnitsPerPixel

double BioLib.SlideSourceBase.MinUnitsPerPixel

getprotected set

um/pixel

Implements BioLib.ISliceProvider.

Definition at line 175 of file ISlideSource.cs.

{ get; protected set; }

Name

string BioLib.SlideSourceBase.Name

getprotected set

Definition at line 318 of file ISlideSource.cs.

{ get; protected set; }

Schema

ITileSchema BioLib.SlideSourceBase.Schema

getprotected set

Definition at line 316 of file ISlideSource.cs.

{ get; protected set; }

Source

string BioLib.SlideSourceBase.Source

getprotected set

File path.

Implements BioLib.ISlideExternInfo.

Definition at line 324 of file ISlideSource.cs.

{ get; protected set; }

UseRealResolution

bool BioLib.SlideSourceBase.UseRealResolution = true

staticgetset

Definition at line 138 of file ISlideSource.cs.

{ get; set; } = true;

---

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

• BioLib/Source/Bio/ISlideSource.cs