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)
	Mask (byte[] fts, int width, int height, double physX, double physY, double x, double y)
Gdk.Pixbuf	GetColored (AForge.Color col, byte alpha, bool forceUpdate=false)
byte[]	GetColoredBytes (AForge.Color col)
byte[]	GetBytes ()
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 )

            {
                this.width = width;
                this.height = height;
                X = x; Y = y;
                PhysicalSizeX = physX;
                PhysicalSizeY = physY;
                mask = fts;
                byte[] bt = GetBytesCropped();
                mask = new float[bt.Length];
                for (int i = 0; i < bt.Length; i++)
                {
                    mask[i] = (float)bt[i];
                }
            }

Mask() [2/2]

BioLib.ROI.Mask.Mask	(	byte[]	fts,
		int	width,
		int	height,
		double	physX,
		double	physY,
		double	x,
		double	y )

            {
                this.width = width;
                this.height = height;
                this.X = x / physX;
                this.Y = y / physY;
                PhysicalSizeX = physX;
                PhysicalSizeY = physY;
                mask = new float[fts.Length];
                for (int i = 0; i < fts.Length; i++)
                {
                    mask[i] = (float)fts[i];
                }
            }

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

GetBytes()

byte[] BioLib.ROI.Mask.GetBytes

(

)

            {
                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)mask[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];
                for (int y = 0; y < height; y++)
                {
                    for (int x = 0; x < width; x++)
                    {
                        int ind = y * width + x;
 
                        if (ind < mask.Length)
                        {
                            float value = mask[ind];
                            if (value > 0)
                            {
                                pixelData[ind] = (byte)value;
                            }
                        }
                    }
                }
                return pixelData;
            }

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 > mask.Length)
                    throw new ArgumentException("Point " + x + "," + y + " is outside the mask.");
                return mask[ind];
            }

IsSelected()

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

            {
                int ind = y * width + x;
                if (ind >= mask.Length)
                    return false;
                if (mask[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 > mask.Length)
                    throw new ArgumentException("Point " + x + "," + y + " is outside the mask.");
                mask[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];
                        for (int y = 0; y < height; y++)
                        {
                            for (int x = 0; x < width; x++)
                            {
                                int ind = y * width + x;
                                if (mask[ind] > 0)
                                {
                                    pixelData[4 * ind] = (byte)(mask[ind] / 255);// Blue
                                    pixelData[4 * ind + 1] = (byte)(mask[ind] / 255);// Green
                                    pixelData[4 * ind + 2] = (byte)(mask[ind] / 255);// 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