Bio.SlideBase Class Reference

Inheritance diagram for Bio.SlideBase:

Public Member Functions
	SlideBase (BioImage source, SlideImage im, bool enableCache=true)
override IReadOnlyDictionary< string, byte[]>	GetExternImages ()
	Extern image.
byte[]	GetTile (TileInfo tileInfo)
Public Member Functions inherited from Bio.SlideSourceBase
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 string	DetectVendor (string source)
static byte[]	ConvertRgbaToRgb (byte[] rgbaArray)
Static Public Member Functions inherited from Bio.SlideSourceBase
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
readonly SlideImage	SlideImage
Public Attributes inherited from Bio.SlideSourceBase
TileCache	cache = null

Protected Member Functions
void	InitResolutions (IDictionary< int, BruTile.Resolution > resolutions, int tileWidth, int tileHeight)
override void	Dispose (bool disposing)
virtual void	Dispose (bool disposing)

Additional Inherited Members
Static Public Attributes inherited from Bio.SlideSourceBase
static Extent	destExtent
static Extent	sourceExtent
static double	curUnitsPerPixel = 1
static bool	UseVips = true
Properties inherited from Bio.SlideSourceBase
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.

Constructor & Destructor Documentation

SlideBase()

Bio.SlideBase.SlideBase ( BioImage  source, SlideImage  im, bool  enableCache = true  )

inline

        {
            Source = source.file;
            SlideImage = im;
            Image = im;
            double minUnitsPerPixel;
            if (source.PhysicalSizeX < source.PhysicalSizeY) minUnitsPerPixel = source.PhysicalSizeX; else minUnitsPerPixel = source.PhysicalSizeY;
            MinUnitsPerPixel = UseRealResolution ? minUnitsPerPixel : 1;
            if (MinUnitsPerPixel <= 0) MinUnitsPerPixel = 1;
            var height = SlideImage.Dimensions.Height;
            var width = SlideImage.Dimensions.Width;
            //ExternInfo = GetInfo();
            Schema = new TileSchema
            {
                YAxis = YAxis.OSM,
                Format = "jpg",
                Extent = new Extent(0, -height, width, 0),
                OriginX = 0,
                OriginY = 0,
            };
            InitResolutions(Schema.Resolutions, 256, 256);
        }

Member Function Documentation

ConvertRgbaToRgb()

static byte[] Bio.SlideBase.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];     // B
                rgbArray[j + 1] = rgbaArray[i + 1]; // G
                rgbArray[j + 2] = rgbaArray[i + 2]; // R
            }
 
            return rgbArray;
        }

DetectVendor()

static string Bio.SlideBase.DetectVendor ( string  source )

inlinestatic

        {
            return SlideImage.DetectVendor(source);
        }

Dispose()

override void Bio.SlideBase.Dispose ( bool  disposing )

inlineprotectedvirtual

Reimplemented from Bio.SlideSourceBase.

        {
            if (!disposedValue)
            {
                if (disposing)
                {
                    SlideImage.Dispose();
                }
                disposedValue = true;
            }
            base.Dispose(disposing);
        }

GetExternImages()

override IReadOnlyDictionary< string, byte[]> Bio.SlideBase.GetExternImages ( )

inlinevirtual

Extern image.

Returns

Implements Bio.SlideSourceBase.

        {
            throw new NotImplementedException();
            /*
            Dictionary<string, byte[]> images = new Dictionary<string, byte[]>();
            var r = Math.Max(Schema.Extent.Height, Schema.Extent.Width) / 512;
            images.Add("preview", GetSlice(new SliceInfo { Extent = Schema.Extent, Resolution = r }));
            foreach (var item in SlideImage.GetAssociatedImages())
            {
                var dim = item.Value.Dimensions;
                images.Add(item.Key, ImageUtil.GetJpeg(item.Value.Data, 4, 4 * (int)dim.Width, (int)dim.Width, (int)dim.Height));
            }
            return images;
            */
        }

GetTile()

byte[] Bio.SlideBase.GetTile ( TileInfo  tileInfo )

inline

        {
            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 / MinUnitsPerPixel;
            var curLevelOffsetYPixel = -tileInfo.Extent.MaxY / MinUnitsPerPixel;
            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 = SlideImage.ReadRegion(tileInfo.Index.Level, (long)curLevelOffsetXPixel, (long)curLevelOffsetYPixel, curTileWidth, curTileHeight);
            //We check to see if the data is valid.
            if (bgraData.Length != curTileWidth * curTileHeight * 4)
                return null;
            byte[] bm = ConvertRgbaToRgb(bgraData);
            return bm;
        }

InitResolutions()

void Bio.SlideBase.InitResolutions ( IDictionary< int, BruTile::Resolution >  resolutions, int  tileWidth, int  tileHeight  )

inlineprotected

        {
            for (int i = 0; i < SlideImage.LevelCount; i++)
            {
                /*
                bool useInternalWidth = int.TryParse(ExternInfo.TryGetValue($"openslide.level[{i}].tile-width", out var _w) ? (string)_w : null, out var w) && w >= tileWidth;
                bool useInternalHeight = int.TryParse(ExternInfo.TryGetValue($"openslide.level[{i}].tile-height", out var _h) ? (string)_h : null, out var h) && h >= tileHeight;
 
                bool useInternalSize = useInternalHeight && useInternalWidth;
                var tw = useInternalSize ? w : tileWidth;
                var th = useInternalSize ? h : tileHeight;
                resolutions.Add(i, new Resolution(i, MinUnitsPerPixel * SlideImage.GetLevelDownsample(i), tw, th));
                */
                resolutions.Add(i, new BruTile.Resolution(i, SlideImage.BioImage.GetUnitPerPixel(i), tileWidth, tileHeight));
            }
        }

Member Data Documentation

SlideImage

readonly SlideImage Bio.SlideBase.SlideImage

---

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

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