Bio.SlideSourceBase Class Reference

Inheritance diagram for Bio.SlideSourceBase:

Public Member Functions
async Task< byte[]>	GetSlice (SliceInfo sliceInfo)
	Get slice.
byte[]	GetRgb24Bytes (Image< Rgb24 > image)
byte[]	Get16Bytes (Image< L16 > image)
abstract IReadOnlyDictionary< string, byte[]>	GetExternImages ()
	Extern image.
void	Dispose ()
async Task< byte[]>	GetTileAsync (TileInformation tileInfo)
async Task< byte[]>	GetTileAsync (BruTile.TileInfo tileInfo)
Task< byte[]>	GetSlice (SliceInfo sliceInfo)
	Get slice.
IReadOnlyDictionary< string, byte[]>	GetExternImages ()
	Extern image.

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 Bio.ISliceProvider
double	MinUnitsPerPixel [get]
	um/pixel
Properties inherited from Bio.ISlideExternInfo
string	Source [get]
	File path.
IReadOnlyDictionary< string, object >	ExternInfo [get]
	Extern info.

Member Function Documentation

ConvertRgbaToRgb()

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

inlinestatic

        {
            // 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 Bio.SlideSourceBase.Create ( BioImage  source, SlideImage  im, bool  enableCache = true  )

inlinestatic

        {
            
            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 Bio.SlideSourceBase.Dispose ( )

inline

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

Dispose() [2/2]

virtual void Bio.SlideSourceBase.Dispose ( bool  disposing )

inlineprotectedvirtual

Reimplemented in Bio.SlideBase.

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

Get16Bytes()

byte[] Bio.SlideSourceBase.Get16Bytes ( Image< L16 >  image )

inline

        {
            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;
        }

GetExternImages()

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

pure virtual

Extern image.

Returns

Implements Bio.ISlideExternInfo.

Implemented in Bio.SlideBase.

GetRgb24Bytes()

byte[] Bio.SlideSourceBase.GetRgb24Bytes ( Image< Rgb24 >  image )

inline

        {
            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[]> Bio.SlideSourceBase.GetSlice ( SliceInfo  sliceInfo )

inline

Get slice.

Parameters

sliceInfo

Slice info

Returns

Implements Bio.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);
            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 = App.viewer.GetCoordinate();
                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;
                }
            }
            catch (Exception er)
            {
                Console.WriteLine(er.Message);
                return null;
            }
            return null;
        }

GetTileAsync() [1/2]

async Task< byte[]> Bio.SlideSourceBase.GetTileAsync ( BruTile::TileInfo  tileInfo )

inline

        {
            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[]> Bio.SlideSourceBase.GetTileAsync ( TileInformation  tileInfo )

inline

        {
            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 Bio.SlideSourceBase.Resister ( string  extensionUpper, Func< string, bool, ISlideSource >  factory  )

inlinestatic

resister decode for Specific format

Parameters

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

        {
            keyValuePairs.Add(extensionUpper, factory);
        }

Member Data Documentation

cache

TileCache Bio.SlideSourceBase.cache = null

curUnitsPerPixel

double Bio.SlideSourceBase.curUnitsPerPixel = 1

static

destExtent

Extent Bio.SlideSourceBase.destExtent

static

sourceExtent

Extent Bio.SlideSourceBase.sourceExtent

static

UseVips

bool Bio.SlideSourceBase.UseVips = true

static

Property Documentation

Attribution

Attribution Bio.SlideSourceBase.Attribution

getprotected set

{ get; protected set; }

ExternInfo

IReadOnlyDictionary<string, object> Bio.SlideSourceBase.ExternInfo

getprotected set

Extern info.

Implements Bio.ISlideExternInfo.

{ get; protected set; }

Image

SlideImage Bio.SlideSourceBase.Image

getset

{ get; set; }

MinUnitsPerPixel

double Bio.SlideSourceBase.MinUnitsPerPixel

getprotected set

um/pixel

Implements Bio.ISliceProvider.

{ get; protected set; }

Name

string Bio.SlideSourceBase.Name

getprotected set

{ get; protected set; }

Schema

ITileSchema Bio.SlideSourceBase.Schema

getprotected set

{ get; protected set; }

Source

string Bio.SlideSourceBase.Source

getprotected set

File path.

Implements Bio.ISlideExternInfo.

{ get; protected set; }

UseRealResolution

bool Bio.SlideSourceBase.UseRealResolution = true

staticgetset

{ get; set; } = true;

---

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

• D:/Kari/repos/BioGTK/Source/Bio/ISlideSource.cs