BioImager.SlideSourceBase Class Reference

Inheritance diagram for BioImager.SlideSourceBase:

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

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

Public Attributes
TileCache	cache = null

Static Public Attributes
static byte[]	LastSlice
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 More...
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. More...
string	Source [get, protected set]
	File path. More...
Properties inherited from BioImager.ISliceProvider
double	MinUnitsPerPixel [get]
	um/pixel More...
Properties inherited from BioImager.ISlideExternInfo
string	Source [get]
	File path. More...
IReadOnlyDictionary< string, object >	ExternInfo [get]
	Extern info. More...

Detailed Description

Definition at line 122 of file ISlideSource.cs.

Member Function Documentation

ConvertRgbaToRgb()

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

static

Definition at line 318 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 BioImager.SlideSourceBase.Create ( BioImage  source, SlideImage  im, bool  enableCache = true  )

static

Definition at line 140 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 BioImager.SlideSourceBase.Dispose

(

)

Definition at line 276 of file ISlideSource.cs.

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

Dispose() [2/2]

virtual void BioImager.SlideSourceBase.Dispose ( bool  disposing )

protectedvirtual

Definition at line 259 of file ISlideSource.cs.

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

GetExternImages()

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

pure virtual

Extern image.

Returns

Implements BioImager.ISlideExternInfo.

Implemented in BioImager.SlideBase.

GetRgb24Bytes()

byte[] BioImager.SlideSourceBase.GetRgb24Bytes

(

Image< Rgb24 >

image

)

Definition at line 221 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.R;
                    rgbBytes[byteIndex++] = pixel.G;
                    rgbBytes[byteIndex++] = pixel.B;
                }
            }
 
            return rgbBytes;
        }

GetSlice()

async Task< byte[]> BioImager.SlideSourceBase.GetSlice

(

SliceInfo

sliceInfo

)

Get slice.

Parameters

sliceInfo

Slice info

Returns

Implements BioImager.ISliceProvider.

Definition at line 169 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 = 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 = OpenSlideGTK.ImageUtil.JoinVips(tiles, srcPixelExtent, new Extent(0, 0, dstPixelWidth, dstPixelHeight));
                    LastSlice = im.WriteToMemory();
                    return LastSlice;
                }
                catch (Exception e)
                {
                    UseVips = false;
                    Console.WriteLine("Failed to use LibVips please install Libvips for your platform.");
                    Console.WriteLine(e.Message);
                }
            }
            try
            {
                Image<Rgb24> im = OpenSlideGTK.ImageUtil.Join(tiles, srcPixelExtent, new Extent(0, 0, dstPixelWidth, dstPixelHeight));
                LastSlice = GetRgb24Bytes(im);
                im.Dispose();
            }
            catch (Exception er)
            {
                Console.WriteLine(er.Message);
                return null;
            }
            return LastSlice;
        }

References BioImager.SliceInfo.Extent, BioImager.ImageView.GetCoordinate(), BioImager.BioImage.LevelFromResolution(), and BioImager.SliceInfo.Resolution.

GetTileAsync() [1/2]

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

(

BruTile.TileInfo

tileInfo

)

Definition at line 300 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());
            //We check to see if the data is valid.
            if (bgraData.Length != curTileWidth * curTileHeight * 4)
                return null;
            byte[] bm = ConvertRgbaToRgb(bgraData);
            return bm;
        }

GetTileAsync() [2/2]

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

(

TileInformation

tileInfo

)

Definition at line 282 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);
            //We check to see if the data is valid.
            if (bgraData.Length != curTileWidth * curTileHeight * 4)
                return null;
            byte[] bm = ConvertRgbaToRgb(bgraData);
            return bm;
        }

Resister()

static void BioImager.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 134 of file ISlideSource.cs.

        {
            keyValuePairs.Add(extensionUpper, factory);
        }

Member Data Documentation

cache

TileCache BioImager.SlideSourceBase.cache = null

Definition at line 168 of file ISlideSource.cs.

curUnitsPerPixel

double BioImager.SlideSourceBase.curUnitsPerPixel = 1

static

Definition at line 166 of file ISlideSource.cs.

destExtent

Extent BioImager.SlideSourceBase.destExtent

static

Definition at line 164 of file ISlideSource.cs.

LastSlice

byte [] BioImager.SlideSourceBase.LastSlice

static

Definition at line 163 of file ISlideSource.cs.

sourceExtent

Extent BioImager.SlideSourceBase.sourceExtent

static

Definition at line 165 of file ISlideSource.cs.

UseVips

bool BioImager.SlideSourceBase.UseVips = true

static

Definition at line 167 of file ISlideSource.cs.

Property Documentation

Attribution

Attribution BioImager.SlideSourceBase.Attribution

getprotected set

Definition at line 248 of file ISlideSource.cs.

{ get; protected set; }

ExternInfo

IReadOnlyDictionary<string, object> BioImager.SlideSourceBase.ExternInfo

getprotected set

Extern info.

Implements BioImager.ISlideExternInfo.

Definition at line 250 of file ISlideSource.cs.

{ get; protected set; }

Image

SlideImage BioImager.SlideSourceBase.Image

getset

Definition at line 242 of file ISlideSource.cs.

{ get; set; }

MinUnitsPerPixel

double BioImager.SlideSourceBase.MinUnitsPerPixel

getprotected set

um/pixel

Implements BioImager.ISliceProvider.

Definition at line 162 of file ISlideSource.cs.

{ get; protected set; }

Name

string BioImager.SlideSourceBase.Name

getprotected set

Definition at line 246 of file ISlideSource.cs.

{ get; protected set; }

Schema

ITileSchema BioImager.SlideSourceBase.Schema

getprotected set

Definition at line 244 of file ISlideSource.cs.

{ get; protected set; }

Source

string BioImager.SlideSourceBase.Source

getprotected set

File path.

Implements BioImager.ISlideExternInfo.

Definition at line 252 of file ISlideSource.cs.

{ get; protected set; }

UseRealResolution

bool BioImager.SlideSourceBase.UseRealResolution = true

staticgetset

Definition at line 125 of file ISlideSource.cs.

{ get; set; } = true;

---

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

• F:/repos/BioImager/BioImager/Source/Bio/ISlideSource.cs