BioLib.ROI Class Reference

Inheritance diagram for BioLib.ROI:

Classes
class	Mask
	Represents a Mask layer. More...

Public Types
enum	Type {   Rectangle , Point , Line , Polygon ,   Polyline , Freeform , Ellipse , Label ,   Mask }
enum	CoordinateSystem { pixel , micron }

Public Member Functions
void	Validate (bool convertPixelSpace=false, double physX=1, double physY=1)
bool	Contains (PointD p)
ROI	Copy ()
ROI	Copy (ZCT cord)
RectangleD	GetSelectBound (double scaleX, double scaleY)
SKBitmap	ByteArrayToBitmap (byte[] imageBytes)
PointD[]	ImagePoints (Resolution res)
	The function "ImagePoints" takes a Resolution object as input and returns an array of PointD objects that have been converted to image space using the provided resolution values.
RectangleD[]	GetSelectBoxes (double s)
RectangleD[]	GetSelectBoxes ()
PointD	GetCenter ()
double	DistanceTo (PointD point)
void	UpdatePoint (PointD p, int i)
PointD	GetPoint (int i)
PointD[]	GetPoints ()
PointF[]	GetPointsF ()
void	ConvertToMicron (double physX, double physY)
void	AddPoint (PointD p, bool convertPixelSpace=false, double physX=1, double physY=1)
void	AddPoints (PointD[] p, bool convertPixelSpace=false, double physX=1, double physY=1)
void	AddPoints (int[] xp, int[] yp, bool convertPixelSpace=false, double physX=1, double physY=1)
void	AddPoints (float[] xp, float[] yp, bool convertPixelSpace=false, double physX=1, double physY=1)
void	RemovePoints (int[] indexs)
void	ClearPoints ()
int	GetPointCount ()
PointD[]	stringToPoints (string s)
string	PointsToString (BioImage b)
void	UpdateBoundingBox ()
override string	ToString ()
void	Dispose ()

Static Public Member Functions
static ROI	CreatePoint (ZCT coord, double x, double y)
static ROI	CreateLine (ZCT coord, PointD x1, PointD x2)
static ROI	CreateRectangle (ZCT coord, double x, double y, double w, double h)
static ROI	CreateEllipse (ZCT coord, double x, double y, double w, double h)
static ROI	CreatePolygon (ZCT coord, PointD[] pts)
static ROI	CreateFreeform (ZCT coord, PointD[] pts)
static ROI	CreateMask (ZCT coord, float[] mask, int width, int height, PointD loc, double physicalX, double physicalY, bool useFloatStorage=false, bool absolutePosition=false)
static ROI	CreateMask (ZCT coord, Byte[] mask, int width, int height, PointD loc, double physicalX, double physicalY, bool absolutePosition=false, bool preserveDimensions=false)
static int	AddROIsToOMERO (long imageId, long user, BioImage b)
static java.util.List	BioPointToOmeroPoint (ROI r, BioImage b)

Public Attributes
Type	type
List< int >	selectedPoints = new List<int>()
float	fontSize = 12
Cairo.FontSlant	slant
Cairo.FontWeight	weight
string	family = "Times New Roman"
ZCT	coord
Color	strokeColor
Color	fillColor
bool	isFilled = false
string	id = ""
string	roiID = ""
string	roiName = ""
string	properties = ""
int	serie = 0
double	strokeWidth = 1
int	shapeIndex = 0
bool	closed = false
bool	subPixel = false

Static Public Attributes
static SKPaint	SelectBoxColor = new() { Style = SKPaintStyle.Stroke, Color = new SKColor(255, 0, 0) }
static float	selectBoxSize = 14f

Properties
RectangleD	BoundingBox [get, set]
double	X [get]
double	Y [get]
double	W [get]
double	H [get]
int	Resolution [get, set]
PointD	Point [get]
CoordinateSystem	CoordSpace = CoordinateSystem.micron [get, set]
List< PointD >	Points [get, set]
bool	Selected [get, set]
Mask	roiMask [get, set]
string	Text [get, set]

Member Enumeration Documentation

CoordinateSystem

enum BioLib.ROI.CoordinateSystem

        {
            pixel,
            micron
        }

Type

enum BioLib.ROI.Type

        {
            Rectangle,
            Point,
            Line,
            Polygon,
            Polyline,
            Freeform,
            Ellipse,
            Label,
            Mask
        }

Constructor & Destructor Documentation

ROI()

BioLib.ROI.ROI

(

)

        {
            coord = new ZCT(0, 0, 0);
            strokeColor = Color.Yellow;
            BoundingBox = new RectangleD(0, 0, 1, 1);
        }

Member Function Documentation

AddPoint()

void BioLib.ROI.AddPoint	(	PointD	p,
		bool	convertPixelSpace = false,
		double	physX = 1,
		double	physY = 1 )

        {
            if(Points == null)
                Points = new List<PointD>();
            Points.Add(p);
            UpdateBoundingBox();
        }

AddPoints() [1/3]

void BioLib.ROI.AddPoints	(	float[]	xp,
		float[]	yp,
		bool	convertPixelSpace = false,
		double	physX = 1,
		double	physY = 1 )

‍Adds a range of float points to the Points collection and updates the bounding box

Parameters

p	The points to add to the polygon

        {
            if (Points == null)
                Points = new List<PointD>();
            for (int i = 0; i < xp.Length; i++)
            {
                Points.Add(new PointD(xp[i], yp[i]));
            }
            UpdateBoundingBox();
        }

AddPoints() [2/3]

void BioLib.ROI.AddPoints	(	int[]	xp,
		int[]	yp,
		bool	convertPixelSpace = false,
		double	physX = 1,
		double	physY = 1 )

‍Adds a range of integer points to the Points collection and updates the bounding box

Parameters

p	The points to add to the polygon

        {
            if (Points == null)
                Points = new List<PointD>();
            for (int i = 0; i < xp.Length; i++)
            {
                Points.Add(new PointD(xp[i], yp[i]));
            }
            UpdateBoundingBox();
        }

AddPoints() [3/3]

void BioLib.ROI.AddPoints	(	PointD[]	p,
		bool	convertPixelSpace = false,
		double	physX = 1,
		double	physY = 1 )

‍Adds a range of points to the Points collection and updates the bounding box

Parameters

p	The points to add to the polygon

        {
            if (Points == null)
                Points = new List<PointD>();
            if (convertPixelSpace)
            {
                ConvertToMicron(physX, physY);
            }
            else
                Points.AddRange(p);
            UpdateBoundingBox();
        }

AddROIsToOMERO()

static int BioLib.ROI.AddROIsToOMERO ( long imageId, long user, BioImage b )

static

        {
            try
            {
                var gateway = OMERO.gateway;
                var roiService = gateway.getFacility(typeof(ROIFacility)) as ROIFacility;
                var browse = gateway.getFacility(typeof(BrowseFacility)) as BrowseFacility;
                var ctx = OMERO.sc;
                ImageData image = browse.getImage(ctx, imageId);
                int count = 0;
                ROI[] rois = b.Annotations.ToArray();
 
                foreach (ROI an in rois)
                {
                    ROIData roi = new ROIData();
                    ShapeData shape = null;
 
                    switch (an.type)
                    {
                        case ROI.Type.Point:
                            {
                                var pt = new omero.gateway.model.PointData(
                                    b.ToImageSpaceX(an.X),
                                    b.ToImageSpaceY(an.Y)
                                );
                                pt.setZ(an.coord.Z);
                                pt.setC(an.coord.C);
                                pt.setT(an.coord.T);
                                pt.setText(string.IsNullOrEmpty(an.Text) ? an.id : an.Text);
                                shape = pt;
                                break;
                            }
 
                        case ROI.Type.Rectangle:
                            {
                                var r = new RectangleData(
                                    b.ToImageSpaceX(an.BoundingBox.X),
                                    b.ToImageSpaceY(an.BoundingBox.Y),
                                    b.ToImageSizeX(an.W),
                                    b.ToImageSizeY(an.H)
                                );
                                r.setZ(an.coord.Z);
                                r.setC(an.coord.C);
                                r.setT(an.coord.T);
                                r.setText(string.IsNullOrEmpty(an.Text) ? an.id : an.Text);
                                shape = r;
                                break;
                            }
 
                        case ROI.Type.Ellipse:
                            {
                                double rx = b.ToImageSizeX(an.W / 2.0);
                                double ry = b.ToImageSizeY(an.H / 2.0);
                                double cx = b.ToImageSpaceX(an.Points[0].X + an.W / 2.0);
                                double cy = b.ToImageSpaceY(an.Points[0].Y + an.H / 2.0);
 
                                var e = new EllipseData(cx, cy, rx, ry);
                                e.setZ(an.coord.Z);
                                e.setC(an.coord.C);
                                e.setT(an.coord.T);
                                e.setText(string.IsNullOrEmpty(an.Text) ? an.id : an.Text);
                                shape = e;
                                break;
                            }
 
                        case ROI.Type.Line:
                            {
                                var l = new LineData(
                                    b.ToImageSpaceX(an.GetPoint(0).X),
                                    b.ToImageSpaceY(an.GetPoint(0).Y),
                                    b.ToImageSpaceX(an.GetPoint(1).X),
                                    b.ToImageSpaceY(an.GetPoint(1).Y)
                                );
                                l.setZ(an.coord.Z);
                                l.setC(an.coord.C);
                                l.setT(an.coord.T);
                                l.setText(string.IsNullOrEmpty(an.Text) ? an.id : an.Text);
                                shape = l;
                                break;
                            }
 
                        case ROI.Type.Polygon:
                        case ROI.Type.Freeform:
                            {
                                var pts = new List<PointD>();
                                foreach (var p in an.Points)
                                    pts.Add(new PointD(
                                        b.ToImageSpaceX(p.X),
                                        b.ToImageSpaceY(p.Y)
                                    ));
 
                                var poly = new PolygonData(BioPointToOmeroPoint(an,b));
                                poly.setZ(an.coord.Z);
                                poly.setC(an.coord.C);
                                poly.setT(an.coord.T);
                                poly.setText(string.IsNullOrEmpty(an.Text) ? an.id : an.Text);
                                shape = poly;
                                break;
                            }
 
                        case ROI.Type.Polyline:
                            {
                                var pts = new List<PointD>();
                                foreach (var p in an.Points)
                                    pts.Add(new PointD(
                                        b.ToImageSpaceX(p.X),
                                        b.ToImageSpaceY(p.Y)
                                    ));
 
                                var pl = new PolylineData(BioPointToOmeroPoint(an, b));
                                pl.setZ(an.coord.Z);
                                pl.setC(an.coord.C);
                                pl.setT(an.coord.T);
                                pl.setText(string.IsNullOrEmpty(an.Text) ? an.id : an.Text);
                                shape = pl;
                                break;
                            }
 
                        case ROI.Type.Label:
                            {
                                var t = new TextData(
                                    string.IsNullOrEmpty(an.Text) ? "Label" : an.Text,
                                    b.ToImageSpaceX(an.BoundingBox.X),
                                    b.ToImageSpaceY(an.BoundingBox.Y)
                                );
                                //t.setFontSize(new omero.model.LengthI(an.fontSize, omero.model.enums.UnitsLength.PIXEL));
                                t.setZ(an.coord.Z);
                                t.setC(an.coord.C);
                                t.setT(an.coord.T);
                                shape = t;
                                break;
                            }
 
                        case ROI.Type.Mask:
                            {
                            if (an.roiMask == null)
                                continue;
 
                            var m = new MaskData(
                                an.roiMask.X,
                                an.roiMask.Y,
                                an.roiMask.Width,
                                an.roiMask.Height,
                                an.roiMask.GetBytes()
                            );
 
                                m.setZ(an.coord.Z);
                                m.setC(an.coord.C);
                                m.setT(an.coord.T);
                                m.setText(string.IsNullOrEmpty(an.Text) ? an.id : an.Text);
                                shape = m;
                                break;
                            }
                    }
 
                    if (shape == null)
                        continue;
                    // Apply stroke/fill
                    shape.getShapeSettings().setStroke(new java.awt.Color(
                        an.strokeColor.A,
                        an.strokeColor.R,
                        an.strokeColor.G,
                        an.strokeColor.B
                    ));
 
                    shape.getShapeSettings().setFill(new java.awt.Color(
                        an.fillColor.A,
                        an.fillColor.R,
                        an.fillColor.G,
                        an.fillColor.B
                    ));
 
                    shape.getShapeSettings().setStrokeWidth(
                        new omero.model.LengthI(an.strokeWidth, omero.model.enums.UnitsLength.PIXEL)
                    );
 
                    roi.addShapeData(shape);
 
                    // ----- Save ROI to OMERO -----
                    java.util.List roiList = new java.util.ArrayList();
                    roiList.add(roi);
 
                    var saved = roiService.saveROIs(ctx, imageId, user, roiList);
                    count++;
 
                }
 
                Console.WriteLine($"Added {count} ROIs to OMERO image {imageId}");
                return count;
            }
            catch (Exception ex)
            {
                Console.WriteLine("Error adding ROIs: " + ex);
                return 0;
            }
        }

BioPointToOmeroPoint()

static java.util.List BioLib.ROI.BioPointToOmeroPoint ( ROI r, BioImage b )

static

        {
            // Create Java list, NOT C# list
            java.util.List javaPts = new java.util.ArrayList();
            foreach (var p in r.Points)
            {
                // Create Java Point2D.Double for OMERO
                var jp = new java.awt.geom.Point2D.Double(
                    b.ToImageSpaceX(p.X),
                    b.ToImageSpaceY(p.Y)
                );
                javaPts.add(jp);
            }
            return javaPts;
        }

ByteArrayToBitmap()

SKBitmap BioLib.ROI.ByteArrayToBitmap

(

byte[]

imageBytes

)

        {
            if (imageBytes == null || imageBytes.Length == 0)
                return null;
 
            using var ms = new SKMemoryStream(imageBytes);
            return SKBitmap.Decode(ms);
        }

ClearPoints()

void BioLib.ROI.ClearPoints

(

)

        {
            Points.Clear();
        }

Contains()

bool BioLib.ROI.Contains

(

PointD

p

)

        {
            return (p.X >= X &&
                    p.X <= X + W &&
                    p.Y >= Y &&
                    p.Y <= Y + H);
        }

ConvertToMicron()

void BioLib.ROI.ConvertToMicron	(	double	physX,
		double	physY )

‍Adds a point to the list of points and updates the bounding box

Parameters

PointD

        {
            List<PointD> points = new List<PointD>();
            for (int i = 0; i < Points.Count; i++)
            {
                points.Add(new PointD(Points[i].X * physX, Points[i].Y * physY));
            }
            Points = points;
        }

Copy() [1/2]

ROI BioLib.ROI.Copy

(

)

        {
            ROI copy = new ROI();
            copy.type = type;
            copy.id = id;
            copy.roiID = roiID;
            copy.roiName = roiName;
            copy.text = text;
            copy.strokeWidth = strokeWidth;
            copy.strokeColor = strokeColor;
            copy.fillColor = fillColor;
            copy.Points.AddRange(Points);
            copy.Selected = Selected;
            copy.shapeIndex = shapeIndex;
            copy.closed = closed;
            copy.family = family;
            copy.fontSize = fontSize;
            copy.slant = slant;
            copy.selectBoxs.AddRange(selectBoxs);
            copy.BoundingBox = BoundingBox;
            copy.isFilled = isFilled;
            copy.coord = coord;
            copy.selectedPoints = selectedPoints;
            if (roiMask != null)
            {
                copy.roiMask = new Mask(
                    roiMask.GetBytes(),
                    roiMask.Width,
                    roiMask.Height,
                    roiMask.PhysicalSizeX,
                    roiMask.PhysicalSizeY,
                    roiMask.X * roiMask.PhysicalSizeX,
                    roiMask.Y * roiMask.PhysicalSizeY,
                    preserveDimensions: true);
            }
 
            return copy;
        }

Copy() [2/2]

ROI BioLib.ROI.Copy

(

ZCT

cord

)

        {
            ROI copy = new ROI();
            copy.type = type;
            copy.id = id;
            copy.roiID = roiID;
            copy.roiName = roiName;
            copy.text = text;
            copy.strokeWidth = strokeWidth;
            copy.strokeColor = strokeColor;
            copy.fillColor = fillColor;
            copy.Points.AddRange(Points);
            copy.Selected = Selected;
            copy.shapeIndex = shapeIndex;
            copy.closed = closed;
            copy.family = family;
            copy.fontSize = fontSize;
            copy.slant = slant;
            copy.selectBoxs.AddRange(selectBoxs);
            copy.BoundingBox = BoundingBox;
            copy.isFilled = isFilled;
            copy.coord = cord;
            copy.selectedPoints = selectedPoints;
            if (roiMask != null)
            {
                copy.roiMask = new Mask(
                    roiMask.GetBytes(),
                    roiMask.Width,
                    roiMask.Height,
                    roiMask.PhysicalSizeX,
                    roiMask.PhysicalSizeY,
                    roiMask.X * roiMask.PhysicalSizeX,
                    roiMask.Y * roiMask.PhysicalSizeY,
                    preserveDimensions: true);
            }
            return copy;
        }

CreateEllipse()

static ROI BioLib.ROI.CreateEllipse ( ZCT coord, double x, double y, double w, double h )

static

Create an ellipse ROI at the specified ZCT coordinate with the specified width and height

Parameters

ZCT	The ZCT coordinates of the image you want to create the ROI on.
x	x-coordinate of the top-left corner of the rectangle
y	The y-coordinate of the upper-left corner of the rectangle to create.
w	width
h	height

Returns

A new ROI object.

        {
            ROI an = new ROI();
            an.coord = coord;
            an.type = Type.Ellipse;
            an.BoundingBox = new RectangleD(x, y, w, h);
            return an;
        }

CreateFreeform()

static ROI BioLib.ROI.CreateFreeform ( ZCT coord, PointD[] pts )

static

‍Create a new ROI object of type Freeform, with the specified ZCT coordinate and points

Parameters

ZCT	A class that contains the Z, C, and T coordinates of the ROI.
pts	an array of PointD objects, which are just a pair of doubles (x,y)

Returns

A new ROI object.

        {
            ROI an = new ROI();
            an.coord = coord;
            an.type = Type.Freeform;
            an.AddPoints(pts);
            an.closed = true;
            return an;
        }

CreateLine()

static ROI BioLib.ROI.CreateLine ( ZCT coord, PointD x1, PointD x2 )

static

Create a new ROI object, set its type to Line, add two points to it, and return it

Parameters

ZCT	Z is the Z-axis, C is the color channel, and T is the time frame.
PointD	X,Y
PointD	X,Y

Returns

A new ROI object.

        {
            ROI an = new ROI();
            an.Points = new List<PointD>();
            an.coord = coord;
            an.type = Type.Line;
            an.Points.Add(x1);
            an.Points.Add(x2);
            an.UpdateBoundingBox();
            return an;
        }

CreateMask() [1/2]

static ROI BioLib.ROI.CreateMask ( ZCT coord, Byte[] mask, int width, int height, PointD loc, double physicalX, double physicalY, bool absolutePosition = false, bool preserveDimensions = false )

static

        {
            ROI an = new ROI();
            an.coord = coord;
            an.type = Type.Mask;
            an.roiMask = new Mask(mask, width, height, physicalX, physicalY, loc.X, loc.Y, absolutePosition, preserveDimensions);
            an.AddPoint(loc);
            an.BoundingBox = new RectangleD(loc.X, loc.Y, width * physicalX, height * physicalY);
            return an;
        }

CreateMask() [2/2]

static ROI BioLib.ROI.CreateMask ( ZCT coord, float[] mask, int width, int height, PointD loc, double physicalX, double physicalY, bool useFloatStorage = false, bool absolutePosition = false )

static

        {
            ROI an = new ROI();
            an.coord = coord;
            an.type = Type.Mask;
            an.roiMask = new Mask(mask, width, height, physicalX, physicalY, loc.X, loc.Y, useFloatStorage, absolutePosition);
            an.AddPoint(loc);
            an.BoundingBox = new RectangleD(loc.X, loc.Y, width * physicalX, height * physicalY);
            return an;
        }

CreatePoint()

static ROI BioLib.ROI.CreatePoint ( ZCT coord, double x, double y )

static

Create a new ROI object, add a point to it, and return it

Parameters

ZCT	a class that contains the Z, C, and T coordinates of the image.
x	x coordinate of the point
y	The y coordinate of the point

Returns

A new ROI object

        {
            ROI an = new ROI();
            an.coord = coord;
            an.AddPoint(new PointD(x, y));
            an.type = Type.Point;
            an.BoundingBox = new RectangleD(x, y, selectBoxSize, selectBoxSize);
            return an;
        }

CreatePolygon()

static ROI BioLib.ROI.CreatePolygon ( ZCT coord, PointD[] pts )

static

‍Create a new ROI object of type Polygon, with the given coordinate system and points

Parameters

ZCT	The ZCT coordinate of the ROI.
pts	an array of PointD objects, which are just a pair of doubles (x,y)

Returns

A ROI object

        {
            ROI an = new ROI();
            an.coord = coord;
            an.type = Type.Polygon;
            an.Points = new List<PointD>();
            an.AddPoints(pts);
            an.closed = true;
            return an;
        }

CreateRectangle()

static ROI BioLib.ROI.CreateRectangle ( ZCT coord, double x, double y, double w, double h )

static

Create a new ROI object with a rectangle shape, and add a line to the recorder

Parameters

ZCT	The ZCT coordinates of the image you want to create the ROI on.
x	x coordinate of the top left corner of the rectangle
y	y-coordinate of the top-left corner of the rectangle
w	width
h	height

Returns

A new ROI object.

        {
            ROI an = new ROI();
            an.coord = coord;
            an.type = Type.Rectangle;
            an.BoundingBox = new RectangleD(x, y, w, h);
            return an;
        }

Dispose()

void BioLib.ROI.Dispose

(

)

        {
            if (roiMask != null)
            {
                roiMask.Dispose();
            }
        }

DistanceTo()

double BioLib.ROI.DistanceTo

(

PointD

point

)

        {
            var center = GetCenter();
            return (float)Math.Sqrt(Math.Pow(center.X - point.X, 2) + Math.Pow(center.Y - point.Y, 2));
        }

GetCenter()

PointD BioLib.ROI.GetCenter

(

)

        {
            return new PointD(BoundingBox.X + (BoundingBox.W / 2.0), BoundingBox.Y + (BoundingBox.H / 2.0));
        }

GetPoint()

PointD BioLib.ROI.GetPoint

(

int

i

)

This function returns the point at the specified index

Parameters

i	The index of the point to get.

Returns

The point at index i in the Points array.

        {
            if (i < 0 || Points.Count == 0)
                return new PointD();
            return Points[i];
        }

GetPointCount()

int BioLib.ROI.GetPointCount

(

)

This function returns the number of points in the polygon

Returns

The number of points in the list.

        {
            return Points.Count;
        }

GetPoints()

PointD[] BioLib.ROI.GetPoints

(

)

It returns an array of PointD objects

Returns

An array of PointD objects.

        {
            return Points.ToArray();
        }

GetPointsF()

PointF[] BioLib.ROI.GetPointsF

(

)

It converts a list of points to an array of points

Returns

A PointF array.

        {
            PointF[] pfs = new PointF[Points.Count];
            for (int i = 0; i < Points.Count; i++)
            {
                pfs[i].X = (float)Points[i].X;
                pfs[i].Y = (float)Points[i].Y;
            }
            return pfs;
        }

GetSelectBound()

RectangleD BioLib.ROI.GetSelectBound	(	double	scaleX,
		double	scaleY )

‍This function returns a rectangle that is the bounding box of the object, but with a border of half the scale

Parameters

scale

the scale of the image

Returns

A rectangle with the following properties:

        {
            if (type == Type.Mask)
                return BoundingBox;
            double fx = scaleX / 2;
            double fy = scaleY / 2;
            return new RectangleD(BoundingBox.X - fx, BoundingBox.Y - fy, BoundingBox.W + scaleX, BoundingBox.H + scaleY);
        }

GetSelectBoxes() [1/2]

RectangleD[] BioLib.ROI.GetSelectBoxes

(

)

It returns an array of RectangleF objects that are used to draw the selection boxes around the points of the polygon

Parameters

s	the size of the select box

Returns

A list of RectangleF objects.

        {
            double f = ROI.selectBoxSize / 2;
            selectBoxs.Clear();
            for (int i = 0; i < Points.Count; i++)
            {
                selectBoxs.Add(new RectangleD((float)(Points[i].X - f), (float)(Points[i].Y - f), (float)ROI.selectBoxSize, (float)ROI.selectBoxSize));
            }
            return selectBoxs.ToArray();
        }

GetSelectBoxes() [2/2]

RectangleD[] BioLib.ROI.GetSelectBoxes

(

double

s

)

It returns an array of RectangleF objects that are used to draw the selection boxes around the points of the polygon

Parameters

s	the size of the select box

Returns

A list of RectangleF objects.

        {
 
            double f = s / 2;
            selectBoxs.Clear();
            int c = Points.Count;
            if (type != Type.Mask)
            {
                for (int i = 0; i < c; i++)
                {
                    selectBoxs.Add(new RectangleD((float)(Points[i].X - f), (float)(Points[i].Y - f), (float)s, (float)s));
                }
            }
            return selectBoxs.ToArray();    
        }

ImagePoints()

PointD[] BioLib.ROI.ImagePoints

(

Resolution

res

)

The function "ImagePoints" takes a Resolution object as input and returns an array of PointD objects that have been converted to image space using the provided resolution values.

Parameters

Resolution

The "Resolution" parameter is an object that contains information about the resolution of an image. It typically includes properties such as the stage size (width and height), physical size (width and height), and possibly other properties related to the image resolution.

Returns

The method is returning an array of PointD objects.

        {
            if (type == Type.Rectangle || type == Type.Mask)
            {
                PointD[] pts = new PointD[4];
                pts[0] = Points[0];
                pts[1] = new PointD(Points[0].X + BoundingBox.W, Points[0].Y);
                pts[2] = new PointD(Points[0].X + BoundingBox.W, Points[0].Y + BoundingBox.H);
                pts[3] = new PointD(Points[0].X, Points[0].Y + BoundingBox.H);
                return BioImage.ToImageSpace(pts.ToList(), res.StageSizeX, res.StageSizeY, res.PhysicalSizeX, res.PhysicalSizeY);
            }
            else
                return BioImage.ToImageSpace(Points, res.StageSizeX, res.StageSizeY, res.PhysicalSizeX, res.PhysicalSizeY);
        }

PointsToString()

string BioLib.ROI.PointsToString

(

BioImage

b

)

This function takes a BioImage object and returns a string of the points in the image space

Parameters

BioImage

The image that the ROI is on

Returns

The points of the polygon in the image space.

        {
            string pts = "";
            PointD[] ps = b.ToImageSpace(Points);
            for (int j = 0; j < ps.Length; j++)
            {
                if (j == ps.Length - 1)
                    pts += ps[j].X.ToString(CultureInfo.InvariantCulture) + "," + ps[j].Y.ToString(CultureInfo.InvariantCulture);
                else
                    pts += ps[j].X.ToString(CultureInfo.InvariantCulture) + "," + ps[j].Y.ToString(CultureInfo.InvariantCulture) + " ";
            }
            return pts;
        }

RemovePoints()

void BioLib.ROI.RemovePoints

(

int[]

indexs

)

It removes points from a list of points based on an array of indexes

Parameters

indexs

an array of integers that represent the indexes of the points to be removed

        {
            List<PointD> inds = new List<PointD>();
            for (int i = 0; i < Points.Count; i++)
            {
                bool found = false;
                for (int ind = 0; ind < indexs.Length; ind++)
                {
                    if (indexs[ind] == i)
                        found = true;
                }
                if (!found)
                    inds.Add(Points[i]);
            }
            Points = inds;
            UpdateBoundingBox();
        }

stringToPoints()

PointD[] BioLib.ROI.stringToPoints

(

string

s

)

It takes a string of points and returns an array of points

Parameters

s	The string to convert to points.

Returns

A list of points.

        {
            List<PointD> pts = new List<PointD>();
            string[] ints = s.Split(' ');
            for (int i = 0; i < ints.Length; i++)
            {
                string[] sints;
                if (s.Contains("\t"))
                    sints = ints[i].Split('\t');
                else
                    sints = ints[i].Split(',');
                double x = double.Parse(sints[0], CultureInfo.InvariantCulture);
                double y = double.Parse(sints[1], CultureInfo.InvariantCulture);
                pts.Add(new PointD(x, y));
            }
            return pts.ToArray();
        }

ToString()

override string BioLib.ROI.ToString

(

)

        {
            return type + " X:" + W + " Y:" + H + " W:" + W + " H:" + H + ", ZCT:" + coord.Z + "," + coord.C + "," + coord.T + " Text: " + Text;
        }

UpdateBoundingBox()

void BioLib.ROI.UpdateBoundingBox

(

)

It takes a list of points and returns a rectangle that contains all of the points

        {
            // Safety check
            if ((Points == null || Points.Count == 0) && type != Type.Mask)
            {
                BoundingBox = new RectangleD(0, 0, 0, 0);
                return;
            }
 
            // -----------------------------
            // 1) MASK ROI MODE
            // -----------------------------
            if (type == Type.Mask && roiMask != null)
            {
                double minX = double.PositiveInfinity;
                double minY = double.PositiveInfinity;
                double maxX = double.NegativeInfinity;
                double maxY = double.NegativeInfinity;
 
                for (int y = 0; y < roiMask.Height; y++)
                {
                    for (int x = 0; x < roiMask.Width; x++)
                    {
                        if (!roiMask.IsSelected(x, y))
                            continue;
 
                        if (x < minX) minX = x;
                        if (y < minY) minY = y;
                        if (x > maxX) maxX = x;
                        if (y > maxY) maxY = y;
                    }
                }
 
                // No selected pixels
                if (double.IsInfinity(minX))
                {
                    BoundingBox = new RectangleD(0, 0, 0, 0);
                    return;
                }
 
                // Mask bounding box IN PHYSICAL COORDINATES
                double physX = (roiMask.X * roiMask.PhysicalSizeX) + minX * roiMask.PhysicalSizeX;
                double physY = (roiMask.Y * roiMask.PhysicalSizeY) + minY * roiMask.PhysicalSizeY;
 
                double physW = (maxX - minX + 1) * roiMask.PhysicalSizeX;
                double physH = (maxY - minY + 1) * roiMask.PhysicalSizeY;
 
                BoundingBox = new RectangleD(physX, physY, physW, physH);
                return;
            }
 
            // -----------------------------
            // 2) POINT-BASED ROI MODE
            // -----------------------------
            double minPX = double.PositiveInfinity;
            double minPY = double.PositiveInfinity;
            double maxPX = double.NegativeInfinity;
            double maxPY = double.NegativeInfinity;
 
            foreach (var p in Points)
            {
                if (p.X < minPX) minPX = p.X;
                if (p.Y < minPY) minPY = p.Y;
                if (p.X > maxPX) maxPX = p.X;
                if (p.Y > maxPY) maxPY = p.Y;
            }
 
            // Build bounding rectangle
            BoundingBox = new RectangleD(
                minPX,
                minPY,
                maxPX - minPX,
                maxPY - minPY
            );
        }

UpdatePoint()

void BioLib.ROI.UpdatePoint	(	PointD	p,
		int	i )

This function updates the point at the specified index

Parameters

PointD	A class that contains an X and Y coordinate.
i	The index of the point to update

        {
            if (i < Points.Count)
            {
                Points[i] = p;
            }
        }

Validate()

void BioLib.ROI.Validate	(	bool	convertPixelSpace = false,
		double	physX = 1,
		double	physY = 1 )

        {
            // Ensure pos exists
            if (pos == null)
                pos = new List<PointD>();
            else
                pos.Clear();
            if(convertPixelSpace)
            {
                ConvertToMicron(physX, physY);
            }
            switch (type)
            {
                case Type.Rectangle:
                case Type.Ellipse:
                    // 4 corners derived from the bounding box
                    pos.Add(new PointD(BoundingBox.X, BoundingBox.Y));
                    pos.Add(new PointD(BoundingBox.X + BoundingBox.W, BoundingBox.Y));
                    pos.Add(new PointD(BoundingBox.X, BoundingBox.Y + BoundingBox.H));
                    pos.Add(new PointD(BoundingBox.X + BoundingBox.W, BoundingBox.Y + BoundingBox.H));
                    break;
 
                case Type.Point:
                case Type.Label:
                    // Only the anchor point (top-left of bounding box)
                    pos.Add(new PointD(BoundingBox.X, BoundingBox.Y));
                    break;
                default:
                    // Other ROI types keep their existing point data
                    // (Freeform, Polyline, Polygon, Mask, etc.)
                    break;
            }
            
        }

Member Data Documentation

SelectBoxColor

SKPaint BioLib.ROI.SelectBoxColor = new() { Style = SKPaintStyle.Stroke, Color = new SKColor(255, 0, 0) }

static

{ Style = SKPaintStyle.Stroke, Color = new SKColor(255, 0, 0) };

Property Documentation

BoundingBox

RectangleD BioLib.ROI.BoundingBox

getset

        {
            get; set;
        }

CoordSpace

CoordinateSystem BioLib.ROI.CoordSpace = CoordinateSystem.micron

getset

{ get; set; } = CoordinateSystem.micron;

H

double BioLib.ROI.H

get

        {
            get
            {
                if (type == Type.Mask)
                {
                    return roiMask.Height * roiMask.PhysicalSizeY;
                }
                if (type == Type.Point)
                    return ROI.selectBoxSize;
                else
                    return BoundingBox.H;
            }
        }

Point

PointD BioLib.ROI.Point

get

        {
            get
            {
                if (Points.Count > 0)
                    return Points[0];
                else
                    return new PointD(X, Y);
 
            }
        }

Points

List<PointD> BioLib.ROI.Points

getset

        { 
            get 
            {
                if (pos.Count == 0)
                    Validate(false,0,0);
                return pos;
            } 
            set 
            {
                pos = value;
                UpdateBoundingBox();
            } 
        }

Resolution

int BioLib.ROI.Resolution

getset

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

roiMask

Mask BioLib.ROI.roiMask

getset

{ get; set; }

Selected

bool BioLib.ROI.Selected

getset

        {
            get { return selected; }
            set
            {
                if (roiMask != null)
                    roiMask.Selected = value;
                selected = value;
                if (!selected)
                    selectedPoints.Clear();
            }
        }

Text

string BioLib.ROI.Text

getset

        {
            get
            {
                return text;
            }
            set
            {
                text = value;
                if (type == Type.Label)
                {
                    UpdateBoundingBox();
                }
            }
        }

W

double BioLib.ROI.W

get

        {
            get
            {
                if (type == Type.Mask)
                {
                    return roiMask.Width * roiMask.PhysicalSizeX;
                }
                if (type == Type.Point)
                    return ROI.selectBoxSize;
                else
                    return BoundingBox.W;
            }
        }

X

double BioLib.ROI.X

get

        {
            get
            {
                if (type == Type.Mask)
                {
                    return roiMask.X * roiMask.PhysicalSizeX;
                }
                return BoundingBox.X;
            }
        }

Y

double BioLib.ROI.Y

get

        {
            get
            {
                if (type == Type.Mask)
                {
                    return roiMask.Y * roiMask.PhysicalSizeY;
                }
                return BoundingBox.Y;
            }
        }

---

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

• BioLib/Source/ROI.cs