BioGTK.ROI Class Reference

Inheritance diagram for BioGTK.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
ROI	Copy ()
ROI	Copy (ZCT cord)
RectangleD	GetSelectBound (double scaleX, double scaleY)
	ROI ()
RectangleD[]	GetSelectBoxes (double s)
void	UpdatePoint (PointD p, int i)
PointD	GetPoint (int i)
PointD[]	GetPoints ()
PointF[]	GetPointsF ()
void	AddPoint (PointD p)
void	AddPoints (PointD[] p)
void	AddPoints (int[] xp, int[] yp)
void	AddPoints (float[] xp, float[] yp)
void	RemovePoints (int[] indexs)
void	ClearPoints ()
int	GetPointCount ()
PointD[]	stringToPoints (string s)
string	PointsToString (BioImage b)
void	UpdateBoundingBox ()
void	Dispose ()
override string	ToString ()

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)
static ROI	CreateMask (ZCT coord, byte[] mask, int width, int height, PointD loc, double physicalX, double physicalY)

Public Attributes
Type	type
List< int >	selectedPoints = new List<int>()
RectangleD	BoundingBox
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 float	selectBoxSize = 8f

Properties
PointD	Point [get, set]
RectangleD	Rect [get, set]
double	X [get, set]
double	Y [get, set]
double	W [get, set]
double	H [get, set]
int	Resolution [get, set]
List< PointD >	PointsD [get]
PointD[]	PointsImage [get]
bool	Selected [get, set]
Mask	roiMask [get, set]
string	Text [get, set]

Member Enumeration Documentation

CoordinateSystem

enum BioGTK.ROI.CoordinateSystem

Enumerator
pixel
micron

        {
            pixel,
            micron
        }

Type

enum BioGTK.ROI.Type

Enumerator
Rectangle
Point
Line
Polygon
Polyline
Freeform
Ellipse
Label
Mask

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

Constructor & Destructor Documentation

ROI()

BioGTK.ROI.ROI ( )

inline

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

Member Function Documentation

AddPoint()

void BioGTK.ROI.AddPoint ( PointD  p )

inline

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

Parameters

PointD

        {
            Points.Add(p);
            UpdateBoundingBox();
        }

AddPoints() [1/3]

void BioGTK.ROI.AddPoints ( float[]  xp, float[]  yp  )

inline

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

Parameters

p	The points to add to the polygon

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

AddPoints() [2/3]

void BioGTK.ROI.AddPoints ( int[]  xp, int[]  yp  )

inline

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

Parameters

p	The points to add to the polygon

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

AddPoints() [3/3]

void BioGTK.ROI.AddPoints ( PointD[]  p )

inline

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

Parameters

p	The points to add to the polygon

        {
            Points.AddRange(p);
            UpdateBoundingBox();
        }

ClearPoints()

void BioGTK.ROI.ClearPoints ( )

inline

        {
            Points.Clear();
        }

Copy() [1/2]

ROI BioGTK.ROI.Copy ( )

inline

        {
            ROI copy = new ROI();
            copy.id = id;
            copy.roiID = roiID;
            copy.roiName = roiName;
            copy.text = text;
            copy.strokeWidth = strokeWidth;
            copy.strokeColor = strokeColor;
            copy.fillColor = fillColor;
            copy.Points = Points;
            copy.Selected = Selected;
            copy.shapeIndex = shapeIndex;
            copy.closed = closed;
            copy.family = family;
            copy.fontSize = fontSize;
            copy.slant = slant;
            copy.selectBoxs = selectBoxs;
            copy.BoundingBox = BoundingBox;
            copy.isFilled = isFilled;
            copy.coord = coord;
            copy.selectedPoints = selectedPoints;
 
            return copy;
        }

Copy() [2/2]

ROI BioGTK.ROI.Copy ( ZCT  cord )

inline

        {
            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;
            return copy;
        }

CreateEllipse()

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

inlinestatic

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.Rect = new RectangleD(x, y, w, h);
            Recorder.AddLine("ROI.CreateEllipse(new ZCT(" + coord.Z + "," + coord.C + "," + coord.T + "), new RectangleD(" + x + "," + y + "," + w + "," + h + ");");
            return an;
        }

CreateFreeform()

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

inlinestatic

‍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 BioGTK.ROI.CreateLine ( ZCT  coord, PointD  x1, PointD  x2  )

inlinestatic

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.coord = coord;
            an.type = Type.Line;
            an.AddPoint(x1);
            an.AddPoint(x2);
            Recorder.AddLine("ROI.CreateLine(new ZCT(" + coord.Z + "," + coord.C + "," + coord.T + "), new PointD(" + x1.X + "," + x1.Y + "), new PointD(" + x2.X + "," + x2.Y + "));");
            return an;
        }

CreateMask() [1/2]

static ROI BioGTK.ROI.CreateMask ( ZCT  coord, byte[]  mask, int  width, int  height, PointD  loc, double  physicalX, double  physicalY  )

inlinestatic

        {
            ROI an = new ROI();
            an.coord = coord;
            an.type = Type.Mask;
            an.roiMask = new Mask(mask, width, height, physicalX, physicalY);
            an.AddPoint(loc);
            return an;
        }

CreateMask() [2/2]

static ROI BioGTK.ROI.CreateMask ( ZCT  coord, float[]  mask, int  width, int  height, PointD  loc, double  physicalX, double  physicalY  )

inlinestatic

        {
            ROI an = new ROI();
            an.coord = coord;
            an.type = Type.Mask;
            an.roiMask = new Mask(mask, width, height,physicalX,physicalY);
            an.AddPoint(loc);
            return an;
        }

CreatePoint()

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

inlinestatic

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;
            Recorder.AddLine("ROI.CreatePoint(new ZCT(" + coord.Z + "," + coord.C + "," + coord.T + "), " + x + "," + y + ");");
            return an;
        }

CreatePolygon()

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

inlinestatic

‍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.AddPoints(pts);
            an.closed = true;
            return an;
        }

CreateRectangle()

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

inlinestatic

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.Rect = new RectangleD(x, y, w, h);
            Recorder.AddLine("ROI.CreateRectangle(new ZCT(" + coord.Z + "," + coord.C + "," + coord.T + "), new RectangleD(" + x + "," + y + "," + w + "," + h + ");");
            return an;
        }

Dispose()

void BioGTK.ROI.Dispose ( )

inline

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

GetPoint()

PointD BioGTK.ROI.GetPoint ( int  i )

inline

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.

        {
            return Points[i];
        }

GetPointCount()

int BioGTK.ROI.GetPointCount ( )

inline

This function returns the number of points in the polygon

Returns

The number of points in the list.

        {
            return Points.Count;
        }

GetPoints()

PointD[] BioGTK.ROI.GetPoints ( )

inline

It returns an array of PointD objects

Returns

An array of PointD objects.

        {
            return Points.ToArray();
        }

GetPointsF()

PointF[] BioGTK.ROI.GetPointsF ( )

inline

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 BioGTK.ROI.GetSelectBound ( double  scaleX, double  scaleY  )

inline

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

RectangleD[] BioGTK.ROI.GetSelectBoxes ( double  s )

inline

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();
            for (int i = 0; i < Points.Count; i++)
            {
                selectBoxs.Add(new RectangleD((float)(Points[i].X - f), (float)(Points[i].Y - f), (float)s, (float)s));
            }
            return selectBoxs.ToArray();
        }

PointsToString()

string BioGTK.ROI.PointsToString ( BioImage  b )

inline

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 BioGTK.ROI.RemovePoints ( int[]  indexs )

inline

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[] BioGTK.ROI.stringToPoints ( string  s )

inline

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 BioGTK.ROI.ToString ( )

inline

        {
            double w = Math.Round(W, 2, MidpointRounding.ToZero);
            double h = Math.Round(H, 2, MidpointRounding.ToZero);
            double x = Math.Round(Point.X, 2, MidpointRounding.ToZero);
            double y = Math.Round(Point.Y, 2, MidpointRounding.ToZero);
            return type.ToString() + ", " + Text + " (" + w + ", " + h + ") " + " (" + x + ", " + y + ") " + coord.ToString();
        }

UpdateBoundingBox()

void BioGTK.ROI.UpdateBoundingBox ( )

inline

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

        {
            if(type == Type.Mask)
            {
                double minx = double.MaxValue;
                double miny = double.MaxValue;
                double maxx = double.MinValue;
                double maxy = double.MinValue;
                for (int y = 0; y < roiMask.Height; y++)
                {
                    for (int x = 0; x < roiMask.Width; x++)
                    {
                        if (roiMask.IsSelected(x, y))
                        {
                            if (minx > x)
                                minx = x;
                            if (miny > y)
                                miny = y;
                            if (maxx < x)
                                maxx = x;
                            if (maxy < y)
                                maxy = y;
                        }
                    }
                }
                BoundingBox = new RectangleD(PointsD[0].X + (minx * roiMask.PhysicalSizeX), PointsD[0].Y + (miny * roiMask.PhysicalSizeY),
                    (maxx - minx) * roiMask.PhysicalSizeX, (maxy - miny) * roiMask.PhysicalSizeY);
                return;
            }
            PointD min = new PointD(double.MaxValue, double.MaxValue);
            PointD max = new PointD(double.MinValue, double.MinValue);
            foreach (PointD p in Points)
            {
                if (min.X > p.X)
                    min.X = p.X;
                if (min.Y > p.Y)
                    min.Y = p.Y;
 
                if (max.X < p.X)
                    max.X = p.X;
                if (max.Y < p.Y)
                    max.Y = p.Y;
            }
            RectangleD r = new RectangleD();
            r.X = min.X;
            r.Y = min.Y;
            r.W = max.X - min.X;
            r.H = max.Y - min.Y;
            if (r.W == 0)
                r.W = 1;
            if (r.H == 0)
                r.H = 1;
            BoundingBox = r;
        }

UpdatePoint()

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

inline

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;
            }
            UpdateBoundingBox();
        }

Member Data Documentation

BoundingBox

RectangleD BioGTK.ROI.BoundingBox

closed

bool BioGTK.ROI.closed = false

coord

ZCT BioGTK.ROI.coord

family

string BioGTK.ROI.family = "Times New Roman"

fillColor

Color BioGTK.ROI.fillColor

fontSize

float BioGTK.ROI.fontSize = 12

id

string BioGTK.ROI.id = ""

isFilled

bool BioGTK.ROI.isFilled = false

properties

string BioGTK.ROI.properties = ""

roiID

string BioGTK.ROI.roiID = ""

roiName

string BioGTK.ROI.roiName = ""

selectBoxSize

float BioGTK.ROI.selectBoxSize = 8f

static

selectedPoints

List<int> BioGTK.ROI.selectedPoints = new List<int>()

serie

int BioGTK.ROI.serie = 0

shapeIndex

int BioGTK.ROI.shapeIndex = 0

slant

Cairo.FontSlant BioGTK.ROI.slant

strokeColor

Color BioGTK.ROI.strokeColor

strokeWidth

double BioGTK.ROI.strokeWidth = 1

subPixel

bool BioGTK.ROI.subPixel = false

type

Type BioGTK.ROI.type

weight

Cairo.FontWeight BioGTK.ROI.weight

Property Documentation

H

double BioGTK.ROI.H

getset

        {
            get
            {
                if (type == Type.Point)
                    return strokeWidth;
                else
                    return BoundingBox.H;
            }
            set
            {
                Rect = new RectangleD(X, Y, W, value);
                Recorder.AddLine("App.AddROI(" + BioImage.ROIToString(this) + ");");
            }
        }

Point

PointD BioGTK.ROI.Point

getset

        {
            get
            {
                return Points[0];
            }
            set
            {
                UpdatePoint(value, 0);
                UpdateBoundingBox();
            }
        }

PointsD

List<PointD> BioGTK.ROI.PointsD

get

        {
            get
            {
                return Points;
            }
        }

PointsImage

PointD [] BioGTK.ROI.PointsImage

get

        {
            get
            {
                return ImageView.SelectedImage.ToImageSpace(PointsD);
            }
        }

Rect

RectangleD BioGTK.ROI.Rect

getset

        {
            get
            {
                if (Points.Count == 0)
                    return new RectangleD(0, 0, 0, 0);
                if (type == Type.Line || type == Type.Polyline || type == Type.Polygon || type == Type.Freeform || type == Type.Label)
                    return BoundingBox;
                if (type == Type.Rectangle || type == Type.Ellipse)
                    return new RectangleD(Points[0].X, Points[0].Y, Points[1].X - Points[0].X, Points[2].Y - Points[0].Y);
                else
                    return new RectangleD(Points[0].X, Points[0].Y, 1, 1);
            }
            set
            {
                if (type == Type.Line || type == Type.Polyline || type == Type.Polygon || type == Type.Freeform)
                {
                    BoundingBox = value;
                }
                else
                if (Points.Count < 4 && (type == Type.Rectangle || type == Type.Ellipse))
                {
                    AddPoint(new PointD(value.X, value.Y));
                    AddPoint(new PointD(value.X + value.W, value.Y));
                    AddPoint(new PointD(value.X, value.Y + value.H));
                    AddPoint(new PointD(value.X + value.W, value.Y + value.H));
                }
                else
                if (type == Type.Rectangle || type == Type.Ellipse)
                {
                    Points[0] = new PointD(value.X, value.Y);
                    Points[1] = new PointD(value.X + value.W, value.Y);
                    Points[2] = new PointD(value.X, value.Y + value.H);
                    Points[3] = new PointD(value.X + value.W, value.Y + value.H);
                }
                UpdateBoundingBox();
            }
        }

Resolution

int BioGTK.ROI.Resolution

getset

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

roiMask

Mask BioGTK.ROI.roiMask

getset

{ get; set; }

Selected

bool BioGTK.ROI.Selected

getset

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

Text

string BioGTK.ROI.Text

getset

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

W

double BioGTK.ROI.W

getset

        {
            get
            {
                if (type == Type.Point)
                    return strokeWidth;
                else
                    return BoundingBox.W;
            }
            set
            {
                Rect = new RectangleD(X, Y, value, H);
                Recorder.AddLine("App.AddROI(" + BioImage.ROIToString(this) + ");");
            }
        }

X

double BioGTK.ROI.X

getset

        {
            get
            {
                return Point.X;
            }
            set
            {
                Rect = new RectangleD(value, Y, W, H);
                Recorder.AddLine("App.AddROI(" + BioImage.ROIToString(this) + ");");
            }
        }

Y

double BioGTK.ROI.Y

getset

        {
            get
            {
                return Point.Y;
            }
            set
            {
                Rect = new RectangleD(X, value, W, H);
                Recorder.AddLine("App.AddROI(" + BioImage.ROIToString(this) + ");");
            }
        }

---

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

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