BioLib.ROI.Mask Class Reference

Represents a Mask layer. More...

Inheritance diagram for BioLib.ROI.Mask:

Public Member Functions
bool	IsSelected (int x, int y)
float	GetValue (int x, int y)
void	SetValue (int x, int y, float val)
	Mask (float[] fts, int width, int height, double physX, double physY, double x, double y, bool useFloatStorage=false, bool absolutePosition=false)
	Mask (byte[] fts, int width, int height, double physX, double physY, double x, double y, bool absolutePosition=false, bool preserveDimensions=false)
Gdk.Pixbuf	GetColored (AForge.Color col, byte alpha, bool forceUpdate=false)
byte[]	GetColoredBytes (AForge.Color col)
byte[]	GetBytesCropped ()
byte[]	GetBytesCropped (int imageWidth, int imageHeight, out int cropWidth, out int cropHeight, out int startX, out int startY)
byte[]	GetBytesCropped (out int cropWidth, out int cropHeight, out int startX, out int startY)
byte[]	GetBytes ()
byte[]	GetBytesLegacy ()
byte[]	GetFullImageBytes (int fullWidth, int fullHeight)
void	Dispose ()

Static Public Member Functions
static byte[] int int int int startY	OutputAs8BitImage (float[] fullMask, int imageWidth, int imageHeight, float threshold=0.0f)
static float float max	GetMinAndMax (float[] floatArray)
static float[] int int int int startY	CropFullImageMask (float[] fullMask, int imageWidth, int imageHeight, float threshold=0.0f)

Public Attributes
float	min = 0

Static Public Attributes
static byte[]	grayImage
	Crops a mask based on non-zero values and converts it to an 8-bit grayscale image.
static byte[] int	cropWidth
static byte[] int int	cropHeight
static byte[] int int int	startX
static float	min
	Gets the minimum and maximum values from a float array.
static float[]	croppedMask
	Crops the smallest rectangular region containing all "white" pixels (values above a threshold) from a full image mask.
static float[] int	cropWidth
static float[] int int	cropHeight
static float[] int int int	startX

Properties
double	X [get, set]
double	Y [get, set]
int	Width [get, set]
int	Height [get, set]
double	PhysicalSizeX [get, set]
double	PhysicalSizeY [get, set]
Gdk.Pixbuf	Pixbuf [get]

Detailed Description

Represents a Mask layer.

Constructor & Destructor Documentation

Mask() [1/2]

BioLib.ROI.Mask.Mask	(	float[]	fts,
		int	width,
		int	height,
		double	physX,
		double	physY,
		double	x,
		double	y,
		bool	useFloatStorage = false,
		bool	absolutePosition = false )

            {
                this.width = width;
                this.height = height;
                X = x; Y = y;
                PhysicalSizeX = physX;
                PhysicalSizeY = physY;
                if (useFloatStorage)
                {
                    var cropResult = CropFullImageMask(fts, width, height, 0.0f);
                    mask = cropResult.croppedMask;
                    X = cropResult.startX;
                    Y = cropResult.startY;
                    this.width = cropResult.cropWidth;
                    this.height = cropResult.cropHeight;
                }
                else
                {
                    byte[] bt = ConvertFloatMaskToBytesCropped(fts, width, height, out int cropWidth, out int cropHeight, out int startX, out int startY);
                    maskBytes = bt;
                    X = absolutePosition ? (x / physX) : startX;
                    Y = absolutePosition ? (y / physY) : startY;
                    this.width = cropWidth;
                    this.height = cropHeight;
                }
            }

Mask() [2/2]

BioLib.ROI.Mask.Mask	(	byte[]	fts,
		int	width,
		int	height,
		double	physX,
		double	physY,
		double	x,
		double	y,
		bool	absolutePosition = false,
		bool	preserveDimensions = false )

            {
                PhysicalSizeX = physX;
                PhysicalSizeY = physY;
                if (preserveDimensions)
                {
                    maskBytes = fts ?? Array.Empty<byte>();
                    this.width = width;
                    this.height = height;
                    this.X = x / physX;
                    this.Y = y / physY;
                }
                else
                {
                    maskBytes = CropByteMask(fts, width, height, out int cropWidth, out int cropHeight, out int startX, out int startY);
                    this.width = cropWidth;
                    this.height = cropHeight;
                    if (absolutePosition)
                    {
                        this.X = x / physX;
                        this.Y = y / physY;
                    }
                    else
                    {
                        this.X = (x / physX) + startX;
                        this.Y = (y / physY) + startY;
                    }
                }
            }

Member Function Documentation

CropFullImageMask()

static float[] int int int int startY BioLib.ROI.Mask.CropFullImageMask ( float[] fullMask, int imageWidth, int imageHeight, float threshold = 0::0f )

static

            {
                if (fullMask == null || fullMask.Length != imageWidth * imageHeight)
                    throw new ArgumentException("Invalid mask dimensions or null mask.");
 
                // Initialize bounding box values
                int minX = imageWidth, minY = imageHeight, maxX = -1, maxY = -1;
 
                // Find the bounding box of "white" pixels
                for (int y = 0; y < imageHeight; y++)
                {
                    for (int x = 0; x < imageWidth; x++)
                    {
                        int index = y * imageWidth + x;
                        if (fullMask[index] > threshold) // Pixel exceeds threshold, considered "white"
                        {
                            minX = Math.Min(minX, x);
                            minY = Math.Min(minY, y);
                            maxX = Math.Max(maxX, x);
                            maxY = Math.Max(maxY, y);
                        }
                    }
                }
 
                // Handle cases where no white pixels are found
                if (minX > maxX || minY > maxY)
                    return (Array.Empty<float>(), 0, 0, 0, 0); // Return an empty mask
 
                // Calculate the cropped region dimensions
                int cropWidth = maxX - minX + 1;
                int cropHeight = maxY - minY + 1;
 
                // Extract the cropped region
                float[] croppedMask = new float[cropWidth * cropHeight];
                for (int y = 0; y < cropHeight; y++)
                {
                    for (int x = 0; x < cropWidth; x++)
                    {
                        int sourceIndex = (minY + y) * imageWidth + (minX + x);
                        int targetIndex = y * cropWidth + x;
 
                        croppedMask[targetIndex] = fullMask[sourceIndex];
                    }
                }
 
                return (croppedMask, cropWidth, cropHeight, minX, minY);
            }

Dispose()

void BioLib.ROI.Mask.Dispose

(

)

            {
                if (pixbuf != null)
                    pixbuf.Dispose();
                if (colored != null)
                    colored.Dispose();
                mask = null;
                maskBytes = null;
            }

GetBytes()

byte[] BioLib.ROI.Mask.GetBytes

(

)

            {
                if (maskBytes != null)
                    return (byte[])maskBytes.Clone();
 
                if (mask == null)
                    return Array.Empty<byte>();
 
                return ConvertFloatMaskToBytes(mask);
            }

GetBytesCropped() [1/3]

byte[] BioLib.ROI.Mask.GetBytesCropped

(

)

            {
                return GetBytesCropped(out _, out _, out _, out _);
            }

GetBytesCropped() [2/3]

byte[] BioLib.ROI.Mask.GetBytesCropped	(	int	imageWidth,
		int	imageHeight,
		out int	cropWidth,
		out int	cropHeight,
		out int	startX,
		out int	startY )

            {
                if (maskBytes != null)
                {
                    // If this mask buffer still represents a full-size image mask,
                    // crop it down before serializing so the payload stays compact
                    // and the ROI position is preserved by the saved metadata.
                    if (imageWidth > 0 && imageHeight > 0 && maskBytes.Length == imageWidth * imageHeight && width == imageWidth && height == imageHeight)
                        return CropByteMask(maskBytes, imageWidth, imageHeight, out cropWidth, out cropHeight, out startX, out startY);
 
                    cropWidth = this.Width;
                    cropHeight = this.Height;
                    startX = 0;
                    startY = 0;
                    return (byte[])maskBytes.Clone();
                }
 
                return GetBytesCropped(out cropWidth, out cropHeight, out startX, out startY);
            }

GetBytesCropped() [3/3]

byte[] BioLib.ROI.Mask.GetBytesCropped	(	out int	cropWidth,
		out int	cropHeight,
		out int	startX,
		out int	startY )

            {
                if (maskBytes != null)
                {
                    cropWidth = this.Width;
                    cropHeight = this.Height;
                    startX = 0;
                    startY = 0;
                    return (byte[])maskBytes.Clone();
                }
 
                if (mask == null)
                {
                    cropWidth = width;
                    cropHeight = height;
                    startX = (int)Math.Round(X);
                    startY = (int)Math.Round(Y);
                    return Array.Empty<byte>();
                }
 
                // Crop the mask using a threshold of 0
                var floatCropResult = CropFullImageMask(mask, this.Width, this.Height, 0.0f);
                float[] croppedMask = floatCropResult.croppedMask;
 
                cropWidth = floatCropResult.cropWidth;
                cropHeight = floatCropResult.cropHeight;
                startX = floatCropResult.startX;
                startY = floatCropResult.startY;
 
                // Handle empty mask case
                if (croppedMask == null || croppedMask.Length == 0)
                    return Array.Empty<byte>();
 
                // Get the minimum and maximum values of the mask for normalization
                var (min, max) = GetMinAndMax(croppedMask);
                min = 0;
                // Prepare the byte array for the normalized output
                byte[] bytes = new byte[cropWidth * cropHeight];
 
                // If the crop is a binary mask (all positive values identical),
                // preserve the mask instead of collapsing it to an empty output.
                if (Math.Abs(max - min) < float.Epsilon)
                {
                    for (int y = 0; y < cropHeight; y++)
                    {
                        for (int x = 0; x < cropWidth; x++)
                        {
                            int index = y * cropWidth + x;
                            if (croppedMask[index] > 0)
                                bytes[index] = 255;
                        }
                    }
                    return bytes;
                }
 
                // Normalize float values and convert to byte
                for (int y = 0; y < cropHeight; y++)
                {
                    for (int x = 0; x < cropWidth; x++)
                    {
                        int index = y * cropWidth + x; // 1D index for the mask
                        if (croppedMask[index] > 0)
                        {
                            // Normalize the value: (value - min) / (max - min) * 255
                            float normalized = (croppedMask[index] - min) / (max - min);
                            bytes[index] = (byte)(normalized * 255);
                        }
                    }
                }
                return bytes;
            }

GetBytesLegacy()

byte[] BioLib.ROI.Mask.GetBytesLegacy

(

)

            {
                byte[] rgbaBytes = new byte[width * height];
                for (int y = 0; y < Height; y++)
                {
                    for (int x = 0; x < Width; x++)
                    {
                        int index = y * Width + x; // 1D index for the mask
                        // Set RGBA channels
                        rgbaBytes[index] = (byte)GetMaskValue(index);
                    }
                }
                return rgbaBytes;
            }

GetColored()

Gdk.Pixbuf BioLib.ROI.Mask.GetColored	(	AForge.Color	col,
		byte	alpha,
		bool	forceUpdate = false )

            {
                if (updateColored || forceUpdate)
                {
                    UpdateColored(col, alpha);
                    return colored;
                }
                else
                    return colored;
            }

GetColoredBytes()

byte[] BioLib.ROI.Mask.GetColoredBytes

(

AForge.Color

col

)

            {
                byte[] pixelData = new byte[width * height];
                byte[] values = GetBytes();
                for (int y = 0; y < height; y++)
                {
                    for (int x = 0; x < width; x++)
                    {
                        int ind = y * width + x;
 
                        if (ind < values.Length)
                        {
                            float value = values[ind];
                            if (value > 0)
                            {
                                pixelData[ind] = values[ind];
                            }
                        }
                    }
                }
                return pixelData;
            }

GetFullImageBytes()

byte[] BioLib.ROI.Mask.GetFullImageBytes	(	int	fullWidth,
		int	fullHeight )

            {
                byte[] cropped = GetBytes();
                if (cropped == null || cropped.Length == 0 || fullWidth <= 0 || fullHeight <= 0)
                    return Array.Empty<byte>();
 
                int cropWidth = Width;
                int cropHeight = Height;
                if (cropWidth <= 0 || cropHeight <= 0)
                    return Array.Empty<byte>();
 
                if (cropped.Length == (long)fullWidth * fullHeight &&
                    (int)Math.Round(X) == 0 &&
                    (int)Math.Round(Y) == 0 &&
                    cropWidth == fullWidth &&
                    cropHeight == fullHeight)
                {
                    return cropped;
                }
 
                byte[] full = new byte[fullWidth * fullHeight];
                int offsetX = (int)Math.Round(X);
                int offsetY = (int)Math.Round(Y);
 
                for (int row = 0; row < cropHeight; row++)
                {
                    int destY = offsetY + row;
                    if (destY < 0 || destY >= fullHeight)
                        continue;
 
                    int sourceIndex = row * cropWidth;
                    int destX = offsetX;
                    int copyWidth = cropWidth;
 
                    if (destX < 0)
                    {
                        sourceIndex -= destX;
                        copyWidth += destX;
                        destX = 0;
                    }
 
                    if (destX >= fullWidth || copyWidth <= 0)
                        continue;
 
                    if (destX + copyWidth > fullWidth)
                        copyWidth = fullWidth - destX;
 
                    if (sourceIndex < 0 || sourceIndex + copyWidth > cropped.Length)
                        continue;
 
                    Buffer.BlockCopy(cropped, sourceIndex, full, destY * fullWidth + destX, copyWidth);
                }
 
                return full;
            }

GetMinAndMax()

static float float max BioLib.ROI.Mask.GetMinAndMax ( float[] floatArray )

static

            {
                if (floatArray == null || floatArray.Length == 0)
                    throw new ArgumentException("Input array must not be null or empty.");
 
                float min = floatArray[0];
                float max = floatArray[0];
 
                foreach (float value in floatArray)
                {
                    if (value < min)
                    {
                        min = value;
                    }
                    if (value > max)
                    {
                        max = value;
                    }
                }
 
                return (min, max);
            }

GetValue()

float BioLib.ROI.Mask.GetValue	(	int	x,
		int	y )

            {
                int ind = y * width + x;
                if (ind > MaskLength)
                    throw new ArgumentException("Point " + x + "," + y + " is outside the mask.");
                return GetMaskValue(ind);
            }

IsSelected()

bool BioLib.ROI.Mask.IsSelected	(	int	x,
		int	y )

            {
                int ind = y * width + x;
                if (ind >= MaskLength)
                    return false;
                if (GetMaskValue(ind) > min)
                {
                    return true;
                }
                return false;
            }

OutputAs8BitImage()

static byte[] int int int int startY BioLib.ROI.Mask.OutputAs8BitImage ( float[] fullMask, int imageWidth, int imageHeight, float threshold = 0::0f )

static

            {
                if (fullMask == null || fullMask.Length != imageWidth * imageHeight)
                    throw new ArgumentException("Invalid mask dimensions or null mask.");
 
                // Crop the mask using the threshold
                var cropResult = CropFullImageMask(fullMask, imageWidth, imageHeight, threshold);
                float[] croppedMask = cropResult.croppedMask;
 
                // Handle empty crop
                if (croppedMask == null || croppedMask.Length == 0)
                    return (Array.Empty<byte>(), 0, 0, 0, 0);
 
                int cropWidth = cropResult.cropWidth;
                int cropHeight = cropResult.cropHeight;
 
                // Normalize and convert to 8-bit grayscale
                byte[] grayImage = new byte[cropWidth * cropHeight];
                for (int i = 0; i < croppedMask.Length; i++)
                {
                    grayImage[i] = (byte)(Math.Clamp(croppedMask[i], 0.0f, 1.0f) * 255);
                }
 
                return (grayImage, cropWidth, cropHeight, cropResult.startX, cropResult.startY);
            }

SetValue()

void BioLib.ROI.Mask.SetValue	(	int	x,
		int	y,
		float	val )

            {
                int ind = y * width + x;
                if (ind > MaskLength)
                    throw new ArgumentException("Point " + x + "," + y + " is outside the mask.");
                SetMaskValue(ind, val);
                updatePixbuf = true;
                updateColored = true;
            }

Member Data Documentation

croppedMask

float [] BioLib.ROI.Mask.croppedMask

static

Crops the smallest rectangular region containing all "white" pixels (values above a threshold) from a full image mask.

Parameters

fullMask	The input float array representing the entire image mask.
imageWidth	The width of the full image.
imageHeight	The height of the full image.
threshold	The threshold to consider a pixel as "white".

Returns

A tuple containing:

• Cropped float array mask.
• Crop width.
• Crop height.
• Starting X and Y coordinates of the crop in the original image.

grayImage

byte [] BioLib.ROI.Mask.grayImage

static

Crops a mask based on non-zero values and converts it to an 8-bit grayscale image.

Parameters

fullMask	The input float array representing the full image mask.
imageWidth	The width of the full image.
imageHeight	The height of the full image.
threshold	The threshold to consider a pixel as part of the crop.

Returns

A tuple containing:

• 8-bit grayscale byte array.
• Width and height of the cropped region.
• Starting X and Y coordinates of the crop in the original image.

min

float BioLib.ROI.Mask.min

static

Gets the minimum and maximum values from a float array.

Parameters

floatArray

The input float array.

Returns

A tuple containing the minimum and maximum values.

Property Documentation

Height

int BioLib.ROI.Mask.Height

getset

{ get { return height; } set { height = value; } }

PhysicalSizeX

double BioLib.ROI.Mask.PhysicalSizeX

getset

{ get; set; }

PhysicalSizeY

double BioLib.ROI.Mask.PhysicalSizeY

getset

{ get; set; }

Pixbuf

Gdk.Pixbuf BioLib.ROI.Mask.Pixbuf

get

            {
                get
                {
                    if (updatePixbuf)
                    {
                        if (pixbuf != null)
                            pixbuf.Dispose();
                        byte[] pixelData = new byte[width * height * 4];
                        byte[] values = GetBytes();
                        for (int y = 0; y < height; y++)
                        {
                            for (int x = 0; x < width; x++)
                            {
                                int ind = y * width + x;
                                if (ind < values.Length && values[ind] > 0)
                                {
                                    pixelData[4 * ind] = values[ind];// Blue
                                    pixelData[4 * ind + 1] = values[ind];// Green
                                    pixelData[4 * ind + 2] = values[ind];// Red
                                    pixelData[4 * ind + 3] = 125;// Alpha
                                }
                                else
                                    pixelData[4 * ind + 3] = 0;
                            }
                        }
                        pixbuf = new Gdk.Pixbuf(pixelData, true, 8, width, height, width * 4);
                        updatePixbuf = false;
                        return pixbuf;
                    }
                    else
                        return pixbuf;
                }
            }

Width

int BioLib.ROI.Mask.Width

getset

{ get { return width; } set { width = value; } }

X

double BioLib.ROI.Mask.X

getset

{ get; set; }

Y

double BioLib.ROI.Mask.Y

getset

{ get; set; }

---

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

• BioLib/Source/ROI.cs