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.

Definition at line 493 of file Bio.cs.

Constructor & Destructor Documentation

◆ Mask() [1/2]

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

Definition at line 545 of file Bio.cs.

            {
                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 )

Definition at line 560 of file Bio.cs.

            {
                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

Definition at line 813 of file Bio.cs.

            {
                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 ( )

Definition at line 862 of file Bio.cs.

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

◆ GetBytes()

byte[] BioLib.ROI.Mask.GetBytes ( )

Definition at line 784 of file Bio.cs.

            {
                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 )

Definition at line 643 of file Bio.cs.

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

◆ GetColoredBytes()

byte[] BioLib.ROI.Mask.GetColoredBytes ( AForge.Color col )

Definition at line 654 of file Bio.cs.

            {
                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

Definition at line 720 of file Bio.cs.

            {
                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 )

Definition at line 529 of file Bio.cs.

            {
                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 )

Definition at line 518 of file Bio.cs.

            {
                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

Definition at line 689 of file Bio.cs.

            {
                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 )

Definition at line 536 of file Bio.cs.

            {
                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

◆ cropHeight [1/2]

byte [] int int BioLib.ROI.Mask.cropHeight

static

Definition at line 689 of file Bio.cs.

◆ cropHeight [2/2]

float [] int int BioLib.ROI.Mask.cropHeight

static

Definition at line 813 of file Bio.cs.

◆ 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.

Definition at line 813 of file Bio.cs.

◆ cropWidth [1/2]

byte [] int BioLib.ROI.Mask.cropWidth

static

Definition at line 689 of file Bio.cs.

◆ cropWidth [2/2]

float [] int BioLib.ROI.Mask.cropWidth

static

Definition at line 813 of file Bio.cs.

◆ 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.

Definition at line 689 of file Bio.cs.

◆ min [1/2]

float BioLib.ROI.Mask.min = 0

Definition at line 495 of file Bio.cs.

◆ min [2/2]

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.

Definition at line 720 of file Bio.cs.

◆ startX [1/2]

byte [] int int int BioLib.ROI.Mask.startX

static

Definition at line 689 of file Bio.cs.

◆ startX [2/2]

float [] int int int BioLib.ROI.Mask.startX

static

Definition at line 813 of file Bio.cs.

Property Documentation

◆ Height

int BioLib.ROI.Mask.Height

getset

Definition at line 502 of file Bio.cs.

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

◆ PhysicalSizeX

double BioLib.ROI.Mask.PhysicalSizeX

getset

Definition at line 503 of file Bio.cs.

503{ get; set; }

◆ PhysicalSizeY

double BioLib.ROI.Mask.PhysicalSizeY

getset

Definition at line 504 of file Bio.cs.

504{ get; set; }

◆ Pixbuf

Gdk.Pixbuf BioLib.ROI.Mask.Pixbuf

get

Definition at line 574 of file Bio.cs.

            {
                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

Definition at line 501 of file Bio.cs.

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

◆ X

double BioLib.ROI.Mask.X

getset

Definition at line 499 of file Bio.cs.

499{ get; set; }

◆ Y

double BioLib.ROI.Mask.Y

getset

Definition at line 500 of file Bio.cs.

500{ get; set; }

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

BioLib/Source/Bio.cs

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Properties

Detailed Description

Constructor & Destructor Documentation

◆ Mask() [1/2]

◆ Mask() [2/2]

Member Function Documentation

◆ CropFullImageMask()

◆ Dispose()

◆ GetBytes()

◆ GetColored()

◆ GetColoredBytes()

◆ GetMinAndMax()

◆ GetValue()

◆ IsSelected()

◆ OutputAs8BitImage()

◆ SetValue()

Member Data Documentation

◆ cropHeight [1/2]

◆ cropHeight [2/2]

◆ croppedMask

◆ cropWidth [1/2]

◆ cropWidth [2/2]

◆ grayImage

◆ min [1/2]

◆ min [2/2]

◆ startX [1/2]

◆ startX [2/2]

Property Documentation

◆ Height

◆ PhysicalSizeX

◆ PhysicalSizeY

◆ Pixbuf

◆ Width

◆ X

◆ Y