Inheritance diagram for BioImager.BioImage:

Classes
class	ImageJDesc

class	WellPlate

Public Types
enum	ImageType

Public Member Functions
BioImage	Copy (bool rois)

BioImage	Copy ()

void	SetLabelMacroResolutions ()

double	GetLevelDownsample (int level)
	Get the downsampling factor of a given level. More...

int	LevelFromResolution (double Resolution)
	Returns the level of a given resolution. More...

double	GetUnitPerPixel (int level)
	Get Unit Per Pixel for pyramidal images. More...

void	UpdateBuffersPyramidal ()
	Updates the Buffers based on current pyramidal origin and resolution. More...

void	To8Bit ()
	Converts a 16-bit image to an 8-bit image. More...

void	To16Bit ()
	Converts the image to 16 bit. More...

void	To24Bit ()
	Converts the image to 24 bit. More...

void	To32Bit ()
	Converts the image to 32 bit. More...

void	To48Bit ()

void	RotateFlip (AForge.RotateFlipType rot)

void	Bake (int rmin, int rmax, int gmin, int gmax, int bmin, int bmax)

void	Bake (IntRange rf, IntRange gf, IntRange bf)

void	UpdateCoords ()
	It takes a list of images and assigns them to a 3D array of coordinates. More...

void	UpdateCoords (int sz, int sc, int st)

void	UpdateCoords (int sz, int sc, int st, string order)

double	ToImageSizeX (double d)

double	ToImageSizeY (double d)

double	ToImageSpaceX (double x)

double	ToImageSpaceY (double y)

PointD	ToImageSpace (PointD p)

PointD[]	ToImageSpace (List< PointD > p)

PointF[]	ToImageSpace (PointF[] p)

RectangleF	ToImageSpace (RectangleD p)

PointD	ToStageSpace (PointD p)

PointD	ToStageSpace (PointD p, int resolution)

RectangleD	ToStageSpace (RectangleD p)

PointD[]	ToStageSpace (PointD[] p)

	BioImage (string file)

BioImage[]	SplitChannels ()

Bitmap	GetImageByCoord (int z, int c, int t)

Bitmap	GetBitmap (int z, int c, int t)

int	GetIndex (int ix, int iy)

int	GetIndexRGB (int ix, int iy, int index)

ushort	GetValue (ZCTXY coord)

ushort	GetValueRGB (ZCTXY coord, int index)

ushort	GetValue (ZCT coord, int x, int y)

ushort	GetValue (int z, int c, int t, int x, int y)

ushort	GetValueRGB (ZCT coord, int x, int y, int RGBindex)

ushort	GetValueRGB (int z, int c, int t, int x, int y, int RGBindex)

void	SetValue (ZCTXY coord, ushort value)

void	SetValue (int x, int y, int ind, ushort value)

void	SetValue (int x, int y, ZCT coord, ushort value)

void	SetValueRGB (ZCTXY coord, int RGBindex, ushort value)

Bitmap	GetBitmap (ZCT coord)

Bitmap	GetFiltered (ZCT coord, IntRange r, IntRange g, IntRange b)

Bitmap	GetFiltered (int ind, IntRange r, IntRange g, IntRange b)

UnmanagedImage	GetChannelImage (int ind, short s)

Bitmap	GetEmission (ZCT coord, IntRange rf, IntRange gf, IntRange bf)

Bitmap	GetRGBBitmap (ZCT coord, IntRange rf, IntRange gf, IntRange bf)

List< ROI >	GetAnnotations (ZCT coord)

List< ROI >	GetAnnotations (int Z, int C, int T)

void	StackThreshold (bool bit16)

void	Update ()
	‍Update() is a function that calls the Update() function of the parent class More...

void	Dispose ()

override string	ToString ()

Static Public Member Functions
static BioImage	Copy (BioImage b, bool rois)

static BioImage	Copy (BioImage b)

static BioImage	CopyInfo (BioImage b, bool copyAnnotations, bool copyChannels)

static PointD	ToStageSpace (PointD p, double physicalSizeX, double physicalSizeY, double volumeX, double volumeY)

static RectangleD	ToStageSpace (RectangleD p, double physicalSizeX, double physicalSizeY, double volumeX, double volumeY)

static PointD[]	ToStageSpace (PointD[] p, double physicalSizeX, double physicalSizeY, double volumeX, double volumeY)

static BioImage	Substack (BioImage orig, int ser, int zs, int ze, int cs, int ce, int ts, int te)

static BioImage	MergeChannels (BioImage b2, BioImage b)

static BioImage	MergeChannels (string bname, string b2name)

static BioImage	MergeZ (BioImage b)

static BioImage	MergeT (BioImage b)

static BioImage[]	SplitChannels (BioImage bb)

static BioImage[]	SplitChannels (string name)

static unsafe Bitmap	GetBitmapRGB (int w, int h, PixelFormat px, byte[] bts)

static void	Initialize ()

static void	SaveFile (string file, string ID)

static void	SaveSeries (string[] IDs, string file)

static BioImage[]	OpenSeries (string file, bool tab)

static BioImage	OpenFile (string file)

static BioImage	OpenFile (string file, bool tab)

static BioImage	OpenFile (string file, int series, bool tab, bool addToImages)

static BioImage	OpenFile (string file, int series, bool tab, bool addToImages, bool tile, int tileX, int tileY, int tileSizeX, int tileSizeY)

static bool	isTiffSeries (string file)

static bool	isOME (string file)

static bool	isOMESeries (string file)

static void	SaveOME (string file, string ID)

static void	SaveOMESeries (BioImage[] bms, string f, bool planes)

static void	SaveOMESeries (string[] files, string f, bool planes)

static int	GetBands (PixelFormat format)

static void	SaveOMEPyramidal (BioImage[] bms, string file, Enums.ForeignTiffCompression compression, int compressionLevel)

static BioImage	OpenOME (string file, bool tab)

static BioImage	OpenOME (string file, int serie)

static BioImage	FilesToStack (string[] files, int sizeZ, int sizeC, int sizeT)

static BioImage	FolderToStack (string path, bool tab)

static void	OpenVips (BioImage b, int pagecount)

static Bitmap	ExtractRegionFromTiledTiff (BioImage b, int x, int y, int width, int height, int res)

static BioImage	OpenOME (string file, int serie, bool tab, bool addToImages, bool tile, int tilex, int tiley, int tileSizeX, int tileSizeY, bool useOpenSlide=true)
	The function "OpenOME" opens a bioimage file, with options to specify the series, whether to More...

static Bitmap	GetTile (BioImage b, ZCT coord, int serie, int tilex, int tiley, int tileSizeX, int tileSizeY)

static Bitmap	GetTile (BioImage b, int i, int serie, int tilex, int tiley, int tileSizeX, int tileSizeY)

static int	GetBitsPerPixel (int bt)

static int	GetBitMaxValue (int bt)

static PixelFormat	GetPixelFormat (int rgbChannelCount, int bitsPerPixel)

static PixelFormat	GetPixelFormat (int rgbChannelCount, ome.xml.model.enums.PixelType px)

static BioImage[]	OpenOMESeries (string file, bool tab, bool addToImages)

static async Task	OpenAsync (string file, bool OME, bool newtab, bool images)

static async Task	OpenAsync (string[] files, bool OME, bool tab, bool images)

static async Task	SaveAsync (string file, string id, int serie, bool ome)
	The SaveAsync function saves data to a file asynchronously. More...

static async Task	SaveSeriesAsync (BioImage[] imgs, string file, bool ome)
	The function `SaveSeriesAsync` saves a series of `BioImage` objects to a file asynchronously. More...

static async Task	SavePyramidalAsync (BioImage[] imgs, string file, Enums.ForeignTiffCompression com, int compLevel)
	The function `SavePyramidalAsync` saves an array of `BioImage` objects as a pyramidal TIFF file asynchronously. More...

static void	Open (string file)

static void	Open (string[] files)

static BioImage	ImagesToStack (string[] files, bool tab)

static void	Update (BioImage b)

static void	Save (string file, string ID)

static bool	OMESupport ()

static bool	VipsSupport (string file)

static string	OpenXML (string file)

static List< ROI >	OpenOMEROIs (string file, int series)

static string	ROIsToString (List< ROI > Annotations)

static string	ROIToString (ROI an)

static ROI	StringToROI (string sts)

static void	ExportROIsCSV (string filename, List< ROI > Annotations)

static List< ROI >	ImportROIsCSV (string filename)

static void	ExportROIFolder (string path, string filename)

static void	AutoThreshold (BioImage b, bool updateImageStats)

static void	AutoThreshold ()
	It takes the current image, and finds the best threshold value for it. More...

static void	AutoThresholdThread (BioImage b)

static int	FindFocus (BioImage im, int Channel, int Time)

static long	CalculateFocusQuality (Bitmap b)

static BioImage	operator/ (BioImage a, float b)

static BioImage	operator+ (BioImage a, float b)

static BioImage	operator- (BioImage a, float b)

static BioImage	operator/ (BioImage a, ColorS b)

static BioImage	operator* (BioImage a, ColorS b)

static BioImage	operator+ (BioImage a, ColorS b)

static BioImage	operator- (BioImage a, ColorS b)

Public Attributes
int[,,]	Coords

WellPlate	Plate = null

List< Channel >	Channels = new List<Channel>()

List< Resolution >	Resolutions = new List<Resolution>()

List< AForge.Bitmap >	Buffers = new List<AForge.Bitmap>()

List< NetVips.Image >	vipPages = new List<NetVips.Image>()

VolumeD	Volume

List< ROI >	Annotations = new List<ROI>()

string	filename = ""

string	script = ""

int[]	rgbChannels = new int[3]

int	bitsPerPixel

int	imagesPerSeries = 0

int	seriesCount = 1

double	frameInterval = 0

bool	littleEndian = false

bool	isGroup = false

long	loadTimeMS = 0

long	loadTimeTicks = 0

bool	selected = false

OpenSlideImage	openSlideImage

OpenSlideBase	openSlideBase

SlideBase	slideBase

SlideImage	slideImage

Stopwatch	watch = new Stopwatch()

string	file

bool	Loading = false

ImageReader	imRead

Tiff	tifRead

Static Public Attributes
static float	progressValue = 0

static bool	Planes = false

static string	status

static string	progFile

static LevelsLinear	filter8 = new LevelsLinear()

static LevelsLinear16bpp	filter16 = new LevelsLinear16bpp()

static Stopwatch	swatch = new Stopwatch()

static bool	OmeSupport = false

const char	NewLine = '\n'

const string	columns = "ROIID,ROINAME,TYPE,ID,SHAPEINDEX,TEXT,S,C,Z,T,X,Y,W,H,POINTS,STROKECOLOR,STROKECOLORW,FILLCOLOR,FONTSIZE\n"

Properties
ZCT	Coordinate `[get, set]`

ImageType	Type `[get, set]`

double	Resolution `[get, set]`

string	Filename `[get, set]`

int	RGBChannelCount `[get]`

Statistics	Statistics `[get, set]`

string	ID `[get, set]`

int	ImageCount `[get]`

double	PhysicalSizeX `[get]`

double	PhysicalSizeY `[get]`

double	PhysicalSizeZ `[get]`

double	StageSizeX `[get, set]`

double	StageSizeY `[get, set]`

double	StageSizeZ `[get, set]`

int	series `[get, set]`

Channel	RChannel `[get]`

Channel	GChannel `[get]`

Channel	BChannel `[get]`

int	SizeX `[get]`

int	SizeY `[get]`

int	SizeZ `[get]`

int	SizeC `[get]`

int	SizeT `[get]`

IntRange	RRange `[get]`

IntRange	GRange `[get]`

IntRange	BRange `[get]`

Bitmap	SelectedBuffer `[get]`

bool	isRGB `[get]`

bool	isTime `[get]`

bool	isSeries `[get]`

bool	isPyramidal `[get]`

static bool	Initialized `[get]`

int?	MacroResolution `[get, set]`

int?	LabelResolution `[get, set]`

AForge.Size	PyramidalSize `[get, set]`

PointD	PyramidalOrigin `[get, set]`

int	Level `[get, set]`

Detailed Description

Definition at line 1898 of file Bio.cs.

Member Enumeration Documentation

◆ ImageType

enum BioImager.BioImage.ImageType

Definition at line 1982 of file Bio.cs.

        {
            pyramidal,
            stack,
            well
        }

Constructor & Destructor Documentation

◆ BioImage()

BioImager.BioImage.BioImage ( string file )

Definition at line 3506 of file Bio.cs.

        {
            id = file;
            this.file = file;
            filename = Images.GetImageName(id);
            Coordinate = new ZCT();
            rgbChannels[0] = 0;
            rgbChannels[1] = 0;
            rgbChannels[2] = 0;
        }

Member Function Documentation

◆ AutoThreshold() [1/2]

static void BioImager.BioImage.AutoThreshold ( )

static

It takes the current image, and finds the best threshold value for it.

Definition at line 8043 of file Bio.cs.

        {
            AutoThreshold(bstats, update);
        }

References BioImager.BioImage.AutoThreshold().

Referenced by BioImager.BioImage.AutoThreshold(), BioImager.BioImage.AutoThresholdThread(), BioImager.BioImage.Bake(), BioImager.BioImage.MergeChannels(), BioImager.BioImage.MergeT(), BioImager.BioImage.MergeZ(), BioImager.BioImage.OpenFile(), BioImager.BioImage.OpenOME(), BioImager.BioImage.SplitChannels(), BioImager.BioImage.Substack(), BioImager.BioImage.To16Bit(), BioImager.BioImage.To24Bit(), BioImager.BioImage.To32Bit(), BioImager.BioImage.To48Bit(), and BioImager.BioImage.To8Bit().

◆ AutoThreshold() [2/2]

static void BioImager.BioImage.AutoThreshold	(	BioImage	b,
		bool	updateImageStats
	)

static

It takes a BioImage object, and calculates the mean histogram for each channel, and for the entire image.

The BioImage object is a class that contains a list of buffers, each of which contains a byte array of pixel data.

The function also calculates the mean histogram for each buffer, and stores it in the buffer's stats property.

The function also calculates the mean histogram for each channel, and stores it in the channel's stats property.

The function also calculates the mean histogram for the entire image, and stores it in the image's statistics property.

The mean histogram is calculated by adding up the histograms of each buffer, and then dividing by the number of buffers.

The histogram is calculated by looping through the byte array of pixel data, and incrementing the value of the histogram at the index of the pixel value.

The histogram

Parameters

BioImage	This is the image object that contains the image data.
updateImageStats	if true, the image stats will be updated.

Definition at line 7969 of file Bio.cs.

        {
            bstats = b;
            Statistics statistics = null;
            if (b.bitsPerPixel > 8)
                statistics = new Statistics(true);
            else
                statistics = new Statistics(false);
            for (int i = 0; i < b.Buffers.Count; i++)
            {
                if (b.Buffers[i].Stats == null || updateImageStats)
                    b.Buffers[i].Stats = Statistics.FromBytes(b.Buffers[i]);
                if (b.Buffers[i].RGBChannelsCount == 1)
                    statistics.AddStatistics(b.Buffers[i].Stats[0]);
                else
                {
                    for (int r = 0; r < b.Buffers[i].RGBChannelsCount; r++)
                    {
                        statistics.AddStatistics(b.Buffers[i].Stats[r]);
                    }
                }
            }
            for (int c = 0; c < b.Channels.Count; c++)
            {
                Statistics[] sts = new Statistics[b.Buffers[0].RGBChannelsCount];
                for (int i = 0; i < b.Buffers[0].RGBChannelsCount; i++)
                {
                    if (b.bitsPerPixel > 8)
                    {
                        sts[i] = new Statistics(true);
                    }
                    else
                        sts[i] = new Statistics(false);
                }
                for (int z = 0; z < b.SizeZ; z++)
                {
                    for (int t = 0; t < b.SizeT; t++)
                    {
                        int ind;
                        if (b.Channels.Count > b.SizeC)
                        {
                            ind = b.Coords[z, 0, t];
                        }
                        else
                            ind = b.Coords[z, c, t];
                        if (b.Buffers[ind].RGBChannelsCount == 1)
                            sts[0].AddStatistics(b.Buffers[ind].Stats[0]);
                        else
                        {
                            sts[0].AddStatistics(b.Buffers[ind].Stats[0]);
                            sts[1].AddStatistics(b.Buffers[ind].Stats[1]);
                            sts[2].AddStatistics(b.Buffers[ind].Stats[2]);
                            if (b.Buffers[ind].RGBChannelsCount == 4)
                                sts[3].AddStatistics(b.Buffers[ind].Stats[3]);
                        }
                    }
                }
                if (b.RGBChannelCount == 1)
                    sts[0].MeanHistogram();
                else
                {
                    sts[0].MeanHistogram();
                    sts[1].MeanHistogram();
                    sts[2].MeanHistogram();
                    if (b.Buffers[0].RGBChannelsCount == 4)
                        sts[3].MeanHistogram();
                }
                b.Channels[c].stats = sts;
            }
            statistics.MeanHistogram();
            b.statistics = statistics;
 
        }

Referenced by BioImager.BioImage.UpdateBuffersPyramidal().

◆ AutoThresholdThread()

static void BioImager.BioImage.AutoThresholdThread ( BioImage b )

static

It creates a new thread that calls the AutoThreshold function

Parameters

BioImage This is a class that holds the image data and some other information.

Definition at line 8050 of file Bio.cs.

        {
            bstats = b;
            Thread th = new Thread(AutoThreshold);
            th.Start();
        }

References BioImager.BioImage.AutoThreshold().

◆ Bake() [1/2]

void BioImager.BioImage.Bake	(	int	rmin,
		int	rmax,
		int	gmin,
		int	gmax,
		int	bmin,
		int	bmax
	)

Bake(int rmin, int rmax, int gmin, int gmax, int bmin, int bmax)

Parameters

rmin	The minimum value of the red channel.
rmax	The maximum value of the red channel.
gmin	The minimum value of the green channel.
gmax	The maximum value of the green channel.
bmin	The minimum value of the blue channel.
bmax	The maximum value of the blue channel.

Definition at line 3097 of file Bio.cs.

        {
            Bake(new IntRange(rmin, rmax), new IntRange(gmin, gmax), new IntRange(bmin, bmax));
        }

References BioImager.BioImage.Bake().

Referenced by BioImager.BioImage.Bake().

◆ Bake() [2/2]

void BioImager.BioImage.Bake	(	IntRange	rf,
		IntRange	gf,
		IntRange	bf
	)

It takes a range of values for each channel, and creates a new image with the filtered values

Parameters

IntRange
IntRange
IntRange

Definition at line 3107 of file Bio.cs.

        {
            BioImage bm = new BioImage(Images.GetImageName(ID));
            bm = CopyInfo(this, true, true);
            for (int i = 0; i < Buffers.Count; i++)
            {
                ZCT co = Buffers[i].Coordinate;
                UnmanagedImage b = GetFiltered(i, rf, gf, bf);
                Bitmap inf = new Bitmap(bm.ID, b, co, i);
                Statistics.CalcStatistics(inf);
                bm.Coords[co.Z, co.C, co.T] = i;
                bm.Buffers.Add(inf);
            }
            foreach (Channel item in bm.Channels)
            {
                for (int i = 0; i < item.range.Length; i++)
                {
                    item.range[i].Min = 0;
                    if (bm.bitsPerPixel > 8)
                        item.range[i].Max = ushort.MaxValue;
                    else
                        item.range[i].Max = 255;
                }
            }
            //We wait for threshold image statistics calculation
            do
            {
                Thread.Sleep(50);
            } while (Buffers[Buffers.Count - 1].Stats == null);
            AutoThreshold(bm, false);
            Statistics.ClearCalcBuffer();
            Images.AddImage(bm, true);
            App.tabsView.AddTab(bm);
            Recorder.AddLine("ImageView.SelectedImage.Bake(" + rf.Min + "," + rf.Max + "," + gf.Min + "," + gf.Max + "," + bf.Min + "," + bf.Max + ");");
        }

References BioImager.TabsView.AddTab(), BioImager.BioImage.AutoThreshold(), BioImager.BioImage.CopyInfo(), and BioImager.BioImage.GetFiltered().

◆ CalculateFocusQuality()

static long BioImager.BioImage.CalculateFocusQuality ( Bitmap b )

static

The function calculates the focus quality of a given bitmap image.

Parameters

Bitmap A class representing a bitmap image, which contains information about the image's size, pixel data, and color channels.

Returns: The method is returning a long value which represents the calculated focus quality of the input Bitmap image.

Definition at line 8094 of file Bio.cs.

        {
            if (b.RGBChannelsCount == 1)
            {
                long sum = 0;
                long sumOfSquaresR = 0;
                for (int y = 0; y < b.SizeY; y++)
                    for (int x = 0; x < b.SizeX; x++)
                    {
                        ColorS pixel = b.GetPixel(x, y);
                        sum += pixel.R;
                        sumOfSquaresR += pixel.R * pixel.R;
                    }
                return sumOfSquaresR * b.SizeX * b.SizeY - sum * sum;
            }
            else
            {
                long sum = 0;
                long sumOfSquares = 0;
                for (int y = 0; y < b.SizeY; y++)
                    for (int x = 0; x < b.SizeX; x++)
                    {
                        ColorS pixel = b.GetPixel(x, y);
                        int p = (pixel.R + pixel.G + pixel.B) / 3;
                        sum += p;
                        sumOfSquares += p * p;
                    }
                return sumOfSquares * b.SizeX * b.SizeY - sum * sum;
            }
        }

Referenced by BioImager.BioImage.FindFocus().

◆ Copy() [1/4]

BioImage BioImager.BioImage.Copy ( )

‍This function copies the current BioImage object and returns a new BioImage object

Returns: A copy of the BioImage object.

Definition at line 2119 of file Bio.cs.

        {
            return BioImage.Copy(this, true);
        }

References BioImager.BioImage.Copy().

Referenced by BioImager.BioImage.Copy(), and BioImager.BioImage.SplitChannels().

◆ Copy() [2/4]

static BioImage BioImager.BioImage.Copy ( BioImage b )

static

Copy a BioImage object.

Parameters

BioImage The image to copy

Returns: A copy of the BioImage object.

Definition at line 2103 of file Bio.cs.

        {
            return Copy(b, true);
        }

References BioImager.BioImage.Copy().

◆ Copy() [3/4]

static BioImage BioImager.BioImage.Copy	(	BioImage	b,
		bool	rois
	)

static

It copies the BioImage b and returns a new BioImage object.

Parameters

BioImage	The BioImage object to copy
rois	If true, the ROIs will be copied. If false, the ROIs will be ignored.

Definition at line 2063 of file Bio.cs.

        {
            BioImage bi = new BioImage(b.ID);
            if (rois)
            foreach (ROI an in b.Annotations)
            {
                bi.Annotations.Add(an);
            }
            foreach (Bitmap bf in b.Buffers)
            {
                bi.Buffers.Add(bf.Copy());
            }
            foreach (Channel c in b.Channels)
            {
                bi.Channels.Add(c);
            }
            bi.Volume = b.Volume;
            bi.Coords = b.Coords;
            bi.sizeZ = b.sizeZ;
            bi.sizeC = b.sizeC;
            bi.sizeT = b.sizeT;
            bi.series = b.series;
            bi.seriesCount = b.seriesCount;
            bi.frameInterval = b.frameInterval;
            bi.littleEndian = b.littleEndian;
            bi.isGroup = b.isGroup;
            bi.imageInfo = b.imageInfo;
            bi.bitsPerPixel = b.bitsPerPixel;
            bi.file = b.file;
            bi.filename = b.filename;
            bi.Resolutions = new List<Resolution>();
            bi.Resolutions.AddRange(b.Resolutions);
            bi.statistics = b.statistics;
            return bi;
        }

Referenced by BioImager.BioImage.Copy().

◆ Copy() [4/4]

BioImage BioImager.BioImage.Copy ( bool rois )

Copy the image and optionally the ROIs

Parameters

rois	Boolean value indicating whether to copy the ROIs or not.

Returns: A copy of the BioImage object.

Definition at line 2112 of file Bio.cs.

        {
            return BioImage.Copy(this, rois);
        }

References BioImager.BioImage.Copy().

◆ CopyInfo()

static BioImage BioImager.BioImage.CopyInfo	(	BioImage	b,
		bool	copyAnnotations,
		bool	copyChannels
	)

static

CopyInfo() copies the information from one BioImage to another

Parameters

BioImage	the image to copy
copyAnnotations	true
copyChannels	true

Returns: A new BioImage object.

Definition at line 2130 of file Bio.cs.

        {
            BioImage bi = new BioImage(b.ID);
            if (copyAnnotations)
                foreach (ROI an in b.Annotations)
                {
                    bi.Annotations.Add(an);
                }
            if (copyChannels)
                foreach (Channel c in b.Channels)
                {
                    bi.Channels.Add(c.Copy());
                }
 
            bi.Coords = b.Coords;
            bi.Volume = b.Volume;
            bi.sizeZ = b.sizeZ;
            bi.sizeC = b.sizeC;
            bi.sizeT = b.sizeT;
            bi.series = b.series;
            bi.seriesCount = b.seriesCount;
            bi.frameInterval = b.frameInterval;
            bi.littleEndian = b.littleEndian;
            bi.isGroup = b.isGroup;
            bi.imageInfo = b.imageInfo;
            bi.bitsPerPixel = b.bitsPerPixel;
            bi.Resolutions = b.Resolutions;
            bi.Coordinate = b.Coordinate;
            bi.file = b.file;
            bi.Filename = b.Filename;
            bi.ID = Images.GetImageName(b.file);
            bi.statistics = b.statistics;
            return bi;
        }

Referenced by BioImager.BioImage.Bake(), BioImager.BioImage.ImagesToStack(), BioImager.BioImage.MergeT(), BioImager.BioImage.MergeZ(), and BioImager.BioImage.Substack().

◆ Dispose()

void BioImager.BioImage.Dispose ( )

It disposes of all the buffers and channels in the image, removes the image from the Images list, and then forces the garbage collector to run

Definition at line 8126 of file Bio.cs.

        {
            for (int i = 0; i < Buffers.Count; i++)
            {
                Buffers[i].Dispose();
            }
            for (int i = 0; i < Annotations.Count; i++)
            {
                if (Annotations[i].roiMask!=null)
                Annotations[i].roiMask.Dispose();
            }
        }

◆ ExportROIFolder()

static void BioImager.BioImage.ExportROIFolder	(	string	path,
		string	filename
	)

static

ExportROIFolder(path, filename)

This function takes a folder path and a filename as input and exports all the ROIs in the folder as CSV files

Parameters

path	the path to the folder containing the OMERO ROI files
filename	the name of the file you want to export

Definition at line 7927 of file Bio.cs.

        {
            if (!OMESupport())
                return;
            string[] fs = Directory.GetFiles(path);
            int i = 0;
            foreach (string f in fs)
            {
                List<ROI> annotations = OpenOMEROIs(f, 0);
                string ff = Path.GetFileNameWithoutExtension(f);
                ExportROIsCSV(path + "//" + ff + "-" + i.ToString() + ".csv", annotations);
                i++;
            }
        }

References BioImager.BioImage.ExportROIsCSV(), BioImager.BioImage.OMESupport(), and BioImager.BioImage.OpenOMEROIs().

◆ ExportROIsCSV()

static void BioImager.BioImage.ExportROIsCSV	(	string	filename,
		List< ROI >	Annotations
	)

static

This function takes a list of ROIs and writes them to a CSV file

Parameters

filename	the name of the file to be saved
Annotations	List of ROI objects

Definition at line 7896 of file Bio.cs.

        {
            string con = columns;
            con += ROIsToString(Annotations);
            File.WriteAllText(filename, con);
        }

References BioImager.BioImage.ROIsToString().

Referenced by BioImager.BioImage.ExportROIFolder(), and BioImager.BioImage.SaveSeries().

◆ ExtractRegionFromTiledTiff()

static Bitmap BioImager.BioImage.ExtractRegionFromTiledTiff	(	BioImage	b,
		int	x,
		int	y,
		int	width,
		int	height,
		int	res
	)

static

The function ExtractRegionFromTiledTiff takes a BioImage object, coordinates, width, height, and resolution as input, and returns a Bitmap object representing the extracted region from the tiled TIFF image.

Parameters

BioImage	The BioImage object represents an image file that contains multiple pages or resolutions. It contains information about the image file, such as the file path, the number of pages, and the format of each page.
x	The x-coordinate of the top-left corner of the region to extract from the tiled TIFF image.
y	The parameter "y" represents the starting y-coordinate of the region to be extracted from the tiled TIFF image.
width	The width parameter represents the width of the region to be extracted from the tiled TIFF image.
height	The height parameter represents the height of the region to be extracted from the tiled TIFF image.
res	The parameter "res" represents the resolution level of the tiled TIFF image. It is used to specify the level of detail or zoom level at which the image is being extracted.

Returns: The method is returning a Bitmap object.

Definition at line 5812 of file Bio.cs.

        {
            try
            {
                NetVips.Image subImage = b.vipPages[res].Crop(x, y, width, height);
                if (b.vipPages[res].Format == Enums.BandFormat.Uchar)
                {
                    Bitmap bm;
                    byte[] imageData = subImage.WriteToMemory();
                    if (b.Resolutions[res].RGBChannelsCount == 3)
                        bm = new Bitmap(b.file,width, height, PixelFormat.Format24bppRgb, imageData, new ZCT(), 0, null, b.littleEndian);
                    else
                        bm = new Bitmap(b.file, width, height, PixelFormat.Format8bppIndexed, imageData, new ZCT(), 0, null, b.littleEndian);
                    return bm;
 
                }
                else if (b.vipPages[res].Format == Enums.BandFormat.Ushort)
                {
                    Bitmap bm;
                    byte[] imageData = subImage.WriteToMemory();
                    if (b.Resolutions[res].RGBChannelsCount == 3)
                        bm = new Bitmap(b.file, width, height, PixelFormat.Format48bppRgb, imageData, new ZCT(), 0, null, b.littleEndian);
                    else
                        bm = new Bitmap(b.file, width, height, PixelFormat.Format16bppGrayScale, imageData, new ZCT(), 0, null, b.littleEndian);
                    return bm;
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error: {ex.Message}");
                return null;
            }
            return null;
        }

Referenced by BioImager.BioImage.GetTile().

◆ FilesToStack()

static BioImage BioImager.BioImage.FilesToStack	(	string[]	files,
		int	sizeZ,
		int	sizeC,
		int	sizeT
	)

static

It takes a list of files, and creates a new BioImage object with the first file in the list. Then it loops through the rest of the files, adding the buffers from each file to the new BioImage object. Finally, it updates the coordinates of the new BioImage object, and adds it to the Images list

Parameters

files	an array of file paths
sizeZ	number of slices in the stack
sizeC	number of channels
sizeT	number of time points

Returns: A BioImage object.

Definition at line 5716 of file Bio.cs.

        {
            BioImage b = new BioImage(files[0]);
            for (int i = 0; i < files.Length; i++)
            {
                BioImage bb = OpenFile(files[i], false);
                b.Buffers.AddRange(bb.Buffers);
            }
            b.UpdateCoords(sizeZ, sizeC, sizeT);
            Images.AddImage(b, true);
            return b;
        }

References BioImager.BioImage.OpenFile(), and BioImager.BioImage.UpdateCoords().

◆ FindFocus()

static int BioImager.BioImage.FindFocus	(	BioImage	im,
		int	Channel,
		int	Time
	)

static

The function finds the focus of a given BioImage at a specific channel and time by calculating the focus quality of each Z-plane and returning the coordinate with the highest focus quality.

Parameters

BioImage	A BioImage object that contains the image data.
Channel	The channel of the BioImage to analyze. A BioImage can have multiple channels, each representing a different fluorescent label or imaging modality.
Time	The time point at which the focus is being calculated.

Returns: an integer value which represents the coordinate of the image with the highest focus quality in a given channel and time.

Definition at line 8067 of file Bio.cs.

        {
            long mf = 0;
            int fr = 0;
            List<double> dt = new List<double>();
            ZCT c = new ZCT(0, 0, 0);
            for (int i = 0; i < im.SizeZ; i++)
            {
                long f = CalculateFocusQuality(im.Buffers[im.Coords[i, Channel, Time]]);
                dt.Add(f);
                if (f > mf)
                {
                    mf = f;
                    fr = im.Coords[i, Channel, Time];
                }
            }
            //Plot pl = Plot.Create(dt.ToArray(), "Focus");
            //pl.Show();
            return fr;
        }

References BioImager.BioImage.CalculateFocusQuality().

◆ FolderToStack()

static BioImage BioImager.BioImage.FolderToStack	(	string	path,
		bool	tab
	)

static

It takes a folder of images and creates a stack from them

Parameters

path	the path to the folder containing the images

Returns: A BioImage object.

Definition at line 5733 of file Bio.cs.

        {
            string[] files = Directory.GetFiles(path);
            BioImage b = new BioImage(files[0]);
            int z = 0;
            int c = 0;
            int t = 0;
            BioImage bb = null;
            for (int i = 0; i < files.Length; i++)
            {
                string[] st = files[i].Split('_');
                if (st.Length > 3)
                {
                    z = int.Parse(st[1].Replace("Z", ""));
                    c = int.Parse(st[2].Replace("C", ""));
                    t = int.Parse(st[3].Replace("T", ""));
                }
                bb = OpenFile(files[i], tab);
                b.Buffers.AddRange(bb.Buffers);
            }
            if (z == 0)
            {
                /*TO DO
                ImagesToStack im = new ImagesToStack();
                if (im.ShowDialog() != DialogResult.OK)
                    return null;
                b.UpdateCoords(im.SizeZ, im.SizeC, im.SizeT);
                */
            }
            else
                b.UpdateCoords(z + 1, c + 1, t + 1);
            Images.AddImage(b, tab);
            Recorder.AddLine("BioImage.FolderToStack(\"" + path + "\");");
            return b;
        }

References BioImager.BioImage.OpenFile(), and BioImager.BioImage.UpdateCoords().

◆ GetAnnotations() [1/2]

List< ROI > BioImager.BioImage.GetAnnotations	(	int	Z,
		int	C,
		int	T
	)

This function returns a list of ROI objects that are associated with the specified Z, C, and T coordinates

Parameters

Z	The Z-stack index
C	Channel
T	Time

Returns: A list of ROI objects.

Definition at line 4456 of file Bio.cs.

        {
            List<ROI> annotations = new List<ROI>();
            foreach (ROI an in Annotations)
            {
                if (an.coord.Z == Z && an.coord.Z == Z && an.coord.C == C && an.coord.T == T)
                    annotations.Add(an);
            }
            return annotations;
        }

◆ GetAnnotations() [2/2]

List< ROI > BioImager.BioImage.GetAnnotations ( ZCT coord )

‍GetAnnotations() returns a list of ROI objects that are associated with the ZCT coordinate

passed in as a parameter

Parameters

ZCT	a 3D coordinate (Z, C, T)

Returns: A list of ROI objects.

Definition at line 4436 of file Bio.cs.

        {
            List<ROI> annotations = new List<ROI>();
            foreach (ROI an in Annotations)
            {
                if (an == null)
                    continue;
                if (an.coord == coord)
                    annotations.Add(an);
            }
            return annotations;
        }

Referenced by BioImager.BioImage.MergeChannels().

◆ GetBands()

static int BioImager.BioImage.GetBands ( PixelFormat format )

static

Definition at line 5525 of file Bio.cs.

        {
            switch (format)
            {
                case AForge.PixelFormat.Format8bppIndexed: return 1;
                case AForge.PixelFormat.Format16bppGrayScale: return 1;
                case AForge.PixelFormat.Format24bppRgb: return 3;
                case AForge.PixelFormat.Format32bppArgb:
                case AForge.PixelFormat.Format32bppPArgb:
                case AForge.PixelFormat.Format32bppRgb:
                    return 4;
                case AForge.PixelFormat.Format48bppRgb:
                    return 3;
                default:
                    throw new NotSupportedException($"Unsupported pixel format: {format}");
            }
        }

◆ GetBitmap() [1/2]

Bitmap BioImager.BioImage.GetBitmap	(	int	z,
		int	c,
		int	t
	)

"Given a z, c, t coordinate, return the bitmap at that coordinate."

The function is called by the following code:

Parameters

z	the z-stack index
c	channel
t	time

Returns: A bitmap.

Definition at line 3914 of file Bio.cs.

        {
            return Buffers[Coords[z, c, t]];
        }

◆ GetBitmap() [2/2]

Bitmap BioImager.BioImage.GetBitmap ( ZCT coord )

‍This function returns a Bitmap object from the image data stored in the OME-TIFF file

Parameters

ZCT	Z = Z-stack, C = channel, T = timepoint

Returns: A Bitmap object.

Definition at line 4138 of file Bio.cs.

        {
            return (Bitmap)GetImageByCoord(coord.Z, coord.C, coord.T);
        }

References BioImager.BioImage.GetImageByCoord().

◆ GetBitmapRGB()

static unsafe Bitmap BioImager.BioImage.GetBitmapRGB	(	int	w,
		int	h,
		PixelFormat	px,
		byte[]	bts
	)

static

It takes a byte array of RGB or RGBA data and converts it to a Bitmap

Parameters

w	width of the image
h	height of the image
PixelFormat	The pixel format of the image.
bts	the byte array of the image

Returns: A Bitmap object.

Definition at line 4270 of file Bio.cs.

        {
            if (px == PixelFormat.Format32bppArgb)
            {
                //opening a 8 bit per pixel jpg image
                Bitmap bmp = new Bitmap(w, h, PixelFormat.Format32bppArgb);
                //creating the bitmapdata and lock bits
                AForge.Rectangle rec = new AForge.Rectangle(0, 0, w, h);
                BitmapData bmd = bmp.LockBits(rec, ImageLockMode.ReadWrite, bmp.PixelFormat);
                //iterating through all the pixels in y direction
                for (int y = 0; y < h; y++)
                {
                    //getting the pixels of current row
                    byte* row = (byte*)bmd.Scan0 + (y * bmd.Stride);
                    int rowRGB = y * w * 4;
                    //iterating through all the pixels in x direction
                    for (int x = 0; x < w; x++)
                    {
                        int indexRGB = x * 4;
                        int indexRGBA = x * 4;
                        row[indexRGBA + 3] = bts[rowRGB + indexRGB + 3];//byte A
                        row[indexRGBA + 2] = bts[rowRGB + indexRGB + 2];//byte R
                        row[indexRGBA + 1] = bts[rowRGB + indexRGB + 1];//byte G
                        row[indexRGBA] = bts[rowRGB + indexRGB];//byte B
                    }
                }
                //unlocking bits and disposing image
                bmp.UnlockBits(bmd);
                return bmp;
            }
            else if (px == PixelFormat.Format24bppRgb)
            {
                //opening a 8 bit per pixel jpg image
                Bitmap bmp = new Bitmap(w, h, PixelFormat.Format32bppArgb);
                //creating the bitmapdata and lock bits
                AForge.Rectangle rec = new AForge.Rectangle(0, 0, w, h);
                BitmapData bmd = bmp.LockBits(rec, ImageLockMode.ReadWrite, bmp.PixelFormat);
                //iterating through all the pixels in y direction
                for (int y = 0; y < h; y++)
                {
                    //getting the pixels of current row
                    byte* row = (byte*)bmd.Scan0 + (y * bmd.Stride);
                    int rowRGB = y * w * 3;
                    //iterating through all the pixels in x direction
                    for (int x = 0; x < w; x++)
                    {
                        int indexRGB = x * 3;
                        int indexRGBA = x * 4;
                        row[indexRGBA + 3] = byte.MaxValue;//byte A
                        row[indexRGBA + 2] = bts[rowRGB + indexRGB + 2];//byte R
                        row[indexRGBA + 1] = bts[rowRGB + indexRGB + 1];//byte G
                        row[indexRGBA] = bts[rowRGB + indexRGB];//byte B
                    }
                }
                //unlocking bits and disposing image
                bmp.UnlockBits(bmd);
                return bmp;
            }
            else
            if (px == PixelFormat.Format48bppRgb)
            {
                //opening a 8 bit per pixel jpg image
                Bitmap bmp = new Bitmap(w, h, PixelFormat.Format32bppArgb);
                //creating the bitmapdata and lock bits
                AForge.Rectangle rec = new AForge.Rectangle(0, 0, w, h);
                BitmapData bmd = bmp.LockBits(rec, ImageLockMode.ReadWrite, bmp.PixelFormat);
                unsafe
                {
                    //iterating through all the pixels in y direction
                    for (int y = 0; y < h; y++)
                    {
                        //getting the pixels of current row
                        byte* row = (byte*)bmd.Scan0 + (y * bmd.Stride);
                        int rowRGB = y * w * 6;
                        //iterating through all the pixels in x direction
                        for (int x = 0; x < w; x++)
                        {
                            int indexRGB = x * 6;
                            int indexRGBA = x * 4;
                            int b = (int)((float)BitConverter.ToUInt16(bts, rowRGB + indexRGB) / 255);
                            int g = (int)((float)BitConverter.ToUInt16(bts, rowRGB + indexRGB + 2) / 255);
                            int r = (int)((float)BitConverter.ToUInt16(bts, rowRGB + indexRGB + 4) / 255);
                            row[indexRGBA + 3] = 255;//byte A
                            row[indexRGBA + 2] = (byte)(b);//byte R
                            row[indexRGBA + 1] = (byte)(g);//byte G
                            row[indexRGBA] = (byte)(r);//byte B
                        }
                    }
                }
                bmp.UnlockBits(bmd);
                return bmp;
            }
            else
            if (px == PixelFormat.Format8bppIndexed)
            {
                //opening a 8 bit per pixel jpg image
                Bitmap bmp = new Bitmap(w, h, PixelFormat.Format32bppArgb);
                //creating the bitmapdata and lock bits
                AForge.Rectangle rec = new AForge.Rectangle(0, 0, w, h);
                BitmapData bmd = bmp.LockBits(rec, ImageLockMode.ReadWrite, bmp.PixelFormat);
                unsafe
                {
                    //iterating through all the pixels in y direction
                    for (int y = 0; y < h; y++)
                    {
                        //getting the pixels of current row
                        byte* row = (byte*)bmd.Scan0 + (y * bmd.Stride);
                        int rowRGB = y * w;
                        //iterating through all the pixels in x direction
                        for (int x = 0; x < w; x++)
                        {
                            int indexRGB = x;
                            int indexRGBA = x * 4;
                            byte b = bts[rowRGB + indexRGB];
                            row[indexRGBA + 3] = 255;//byte A
                            row[indexRGBA + 2] = (byte)(b);//byte R
                            row[indexRGBA + 1] = (byte)(b);//byte G
                            row[indexRGBA] = (byte)(b);//byte B
                        }
                    }
                }
                bmp.UnlockBits(bmd);
                return bmp;
            }
            else
            if (px == PixelFormat.Format16bppGrayScale)
            {
                //opening a 8 bit per pixel jpg image
                Bitmap bmp = new Bitmap(w, h, PixelFormat.Format32bppArgb);
                //creating the bitmapdata and lock bits
                AForge.Rectangle rec = new AForge.Rectangle(0, 0, w, h);
                BitmapData bmd = bmp.LockBits(rec, ImageLockMode.ReadWrite, bmp.PixelFormat);
                unsafe
                {
                    //iterating through all the pixels in y direction
                    for (int y = 0; y < h; y++)
                    {
                        //getting the pixels of current row
                        byte* row = (byte*)bmd.Scan0 + (y * bmd.Stride);
                        int rowRGB = y * w * 2;
                        //iterating through all the pixels in x direction
                        for (int x = 0; x < w; x++)
                        {
                            int indexRGB = x * 2;
                            int indexRGBA = x * 4;
                            ushort b = (ushort)((float)BitConverter.ToUInt16(bts, rowRGB + indexRGB) / 255);
                            row[indexRGBA + 3] = 255;//byte A
                            row[indexRGBA + 2] = (byte)(b);//byte R
                            row[indexRGBA + 1] = (byte)(b);//byte G
                            row[indexRGBA] = (byte)(b);//byte B
                        }
                    }
                }
                bmp.UnlockBits(bmd);
                return bmp;
            }
 
            throw new NotSupportedException("Pixelformat " + px + " is not supported.");
        }

◆ GetBitMaxValue()

static int BioImager.BioImage.GetBitMaxValue ( int bt )

static

It returns the maximum value of a bit.

Parameters

bt bit depth

Returns: The maximum value of a bit.

Definition at line 6908 of file Bio.cs.

        {
            if (bt == 8)
                return 255;
            if (bt == 9)
                return 512;
            else if (bt == 10)
                return 1023;
            else if (bt == 11)
                return 2047;
            else if (bt == 12)
                return 4095;
            else if (bt == 13)
                return 8191;
            else if (bt == 14)
                return 16383;
            else if (bt == 15)
                return 32767;
            else
                return 65535;
        }

◆ GetBitsPerPixel()

static int BioImager.BioImage.GetBitsPerPixel ( int bt )

static

‍If the number is less than or equal to 255, then it's 8 bits. If it's less than or equal

to 512, then it's 9 bits. If it's less than or equal to 1023, then it's 10 bits. If it's less than or equal to 2047, then it's 11 bits. If it's less than or equal to 4095, then it's 12 bits. If it's less than or equal to 8191, then it's 13 bits. If it's less than or equal to 16383, then it's 14 bits. If it's less than or equal to 32767, then it's 15 bits. If it's less than or equal to 65535, then it's 16 bits

Parameters

bt	The number of bits per pixel.

Returns: The number of bits per pixel.

Definition at line 6882 of file Bio.cs.

        {
            if (bt <= 255)
                return 8;
            if (bt <= 512)
                return 9;
            else if (bt <= 1023)
                return 10;
            else if (bt <= 2047)
                return 11;
            else if (bt <= 4095)
                return 12;
            else if (bt <= 8191)
                return 13;
            else if (bt <= 16383)
                return 14;
            else if (bt <= 32767)
                return 15;
            else
                return 16;
        }

◆ GetChannelImage()

UnmanagedImage BioImager.BioImage.GetChannelImage	(	int	ind,
		short	s
	)

It takes an image, and returns a channel of that image

Parameters

ind	the index of the buffer
s	0, 1, 2

Definition at line 4185 of file Bio.cs.

        {
            Bitmap bf = Buffers[ind];
            if (bf.isRGB)
            {
                if (s == 0)
                    return extractR.Apply(Buffers[ind].Image);
                else
                if (s == 1)
                    return extractG.Apply(Buffers[ind].Image);
                else
                    return extractB.Apply(Buffers[ind].Image);
            }
            else
                throw new InvalidOperationException();
        }

◆ GetEmission()

Bitmap BioImager.BioImage.GetEmission	(	ZCT	coord,
		IntRange	rf,
		IntRange	gf,
		IntRange	bf
	)

‍GetEmission() returns an UnmanagedImage object that is a composite of the emission

channels

Parameters

ZCT	Z, C, T coordinates
IntRange
IntRange
IntRange

Returns: A Bitmap or an UnmanagedImage.

Definition at line 4210 of file Bio.cs.

        {
            if (RGBChannelCount == 1)
            {
                Bitmap[] bs = new Bitmap[Channels.Count];
                for (int c = 0; c < Channels.Count; c++)
                {
                    int index = Coords[coord.Z, c, coord.T];
                    bs[c] = Buffers[index];
                }
                Bitmap bm = (Bitmap)Bitmap.GetEmissionBitmap(bs, Channels.ToArray());
                return bm;
            }
            else
            {
                int index = Coords[coord.Z, coord.C, coord.T];
                return Buffers[index];
            }
        }

Referenced by BioImager.ImageView.UpdateImages().

◆ GetFiltered() [1/2]

Bitmap BioImager.BioImage.GetFiltered	(	int	ind,
		IntRange	r,
		IntRange	g,
		IntRange	b
	)

It takes an image, and returns a filtered version of that image

Parameters

ind	the index of the buffer to be filtered
IntRange
IntRange
IntRange

Returns: A filtered image.

Definition at line 4163 of file Bio.cs.

        {
            if (Buffers[ind].BitsPerPixel > 8)
            {
                BioImage.filter16.InRed = r;
                BioImage.filter16.InGreen = g;
                BioImage.filter16.InBlue = b;
                return BioImage.filter16.Apply(Buffers[ind]);
            }
            else
            {
                // set ranges
                BioImage.filter8.InRed = r;
                BioImage.filter8.InGreen = g;
                BioImage.filter8.InBlue = b;
                return BioImage.filter8.Apply(Buffers[ind]);
            }
        }

◆ GetFiltered() [2/2]

Bitmap BioImager.BioImage.GetFiltered	(	ZCT	coord,
		IntRange	r,
		IntRange	g,
		IntRange	b
	)

‍Get the image at the specified ZCT coordinate, and return a filtered version of it

Parameters

ZCT	a 3-tuple of integers (z, c, t)
IntRange
IntRange
IntRange

Returns: An UnmanagedImage object.

Definition at line 4150 of file Bio.cs.

        {
            int index = Coords[coord.Z, coord.C, coord.T];
            return GetFiltered(index, r, g, b);
        }

References BioImager.BioImage.GetFiltered().

Referenced by BioImager.BioImage.Bake(), BioImager.BioImage.GetFiltered(), and BioImager.ImageView.UpdateImages().

◆ GetImageByCoord()

Bitmap BioImager.BioImage.GetImageByCoord	(	int	z,
		int	c,
		int	t
	)

‍Get the image at the specified coordinates

Parameters

z	the z-stack index
c	channel
t	time

Returns: A Bitmap object.

Definition at line 3901 of file Bio.cs.

        {
            return Buffers[Coords[z, c, t]];
        }

Referenced by BioImager.BioImage.GetBitmap().

◆ GetIndex()

int BioImager.BioImage.GetIndex	(	int	ix,
		int	iy
	)

‍GetIndex(x,y) = (y * stridex + x) * 2

The stridex is the width of the image in bytes.

The stridey is the height of the image in bytes.

The stridex and stridey are the same for a square image.

The stridex and stridey are different for a rectangular image.

The

Parameters

ix	x coordinate of the pixel
iy	The y coordinate of the pixel

Returns: The index of the pixel in the array.

Definition at line 3948 of file Bio.cs.

        {
            if (ix > SizeX || iy > SizeY || ix < 0 || iy < 0)
                return 0;
            int stridex = SizeX;
            int x = ix;
            int y = iy;
            if (bitsPerPixel > 8)
            {
                return (y * stridex + x) * 2;
            }
            else
            {
                return (y * stridex + x);
            }
        }

◆ GetIndexRGB()

int BioImager.BioImage.GetIndexRGB	(	int	ix,
		int	iy,
		int	index
	)

‍The function returns the index of the pixel in the buffer

Parameters

ix	x coordinate of the pixel
iy	The y coordinate of the pixel
index	0 = Red, 1 = Green, 2 = Blue

Returns: The index of the pixel in the buffer.

Definition at line 3971 of file Bio.cs.

        {
            int stridex = SizeX;
            //For 16bit (2*8bit) images we multiply buffer index by 2
            int x = ix;
            int y = iy;
            if (bitsPerPixel > 8)
            {
                return (y * stridex + x) * 2 * index;
            }
            else
            {
                return (y * stridex + x) * index;
            }
        }

◆ GetLevelDownsample()

double BioImager.BioImage.GetLevelDownsample ( int level )

Get the downsampling factor of a given level.

Parameters

level The desired level.

<return> The downsampling factor for this level. </return>

Exceptions

OpenSlideException

Definition at line 2578 of file Bio.cs.

        {
            int originalWidth = Resolutions[0].SizeX; // Width of the original level
            int nextLevelWidth = Resolutions[level].SizeX; // Width of the next level (downsampled)
            return (double)originalWidth / (double)nextLevelWidth;
        }

Referenced by BioImager.BioImage.GetUnitPerPixel(), and BioImager.BioImage.LevelFromResolution().

◆ GetPixelFormat() [1/2]

static PixelFormat BioImager.BioImage.GetPixelFormat	(	int	rgbChannelCount,
		int	bitsPerPixel
	)

static

If the bits per pixel is 8, then the pixel format is either 8bppIndexed, 24bppRgb, or 32bppArgb. If the bits per pixel is 16, then the pixel format is either 16bppGrayScale or 48bppRgb

Parameters

rgbChannelCount	The number of channels in the image. For example, a grayscale image has 1 channel, a color image has 3 channels (red, green, blue).
bitsPerPixel	8 or 16

Returns: The PixelFormat of the image.

Definition at line 6938 of file Bio.cs.

        {
            if (bitsPerPixel == 8)
            {
                if (rgbChannelCount == 1)
                    return PixelFormat.Format8bppIndexed;
                else if (rgbChannelCount == 3)
                    return PixelFormat.Format24bppRgb;
                else if (rgbChannelCount == 4)
                    return PixelFormat.Format32bppArgb;
            }
            else
            {
                if (rgbChannelCount == 1)
                    return PixelFormat.Format16bppGrayScale;
                if (rgbChannelCount == 3)
                    return PixelFormat.Format48bppRgb;
            }
            throw new NotSupportedException("Not supported pixel format.");
        }

Referenced by BioImager.BioImage.OpenOME().

◆ GetPixelFormat() [2/2]

static PixelFormat BioImager.BioImage.GetPixelFormat	(	int	rgbChannelCount,
		ome.xml.model.enums.PixelType	px
	)

static

The function returns the appropriate PixelFormat based on the number of RGB channels and the pixel type.

Parameters

rgbChannelCount	The `rgbChannelCount` parameter represents the number of channels in the RGB color model. It can have a value of either 1 (for grayscale images) or 3 (for RGB color images).
px	The parameter "px" is of type ome.xml.model.enums.PixelType. It represents the pixel type of the image, such as INT8, UINT8, INT16, or UINT16.

Returns: The method returns a PixelFormat value based on the input parameters.

Definition at line 6968 of file Bio.cs.

        {
            if (rgbChannelCount == 1)
            {
                if (px == ome.xml.model.enums.PixelType.INT8 || px == ome.xml.model.enums.PixelType.UINT8)
                    return PixelFormat.Format8bppIndexed;
                else if (px == ome.xml.model.enums.PixelType.INT16 || px == ome.xml.model.enums.PixelType.UINT16)
                    return PixelFormat.Format16bppGrayScale;
            }
            else
            {
                if (px == ome.xml.model.enums.PixelType.INT8 || px == ome.xml.model.enums.PixelType.UINT8)
                    return PixelFormat.Format24bppRgb;
                else if (px == ome.xml.model.enums.PixelType.INT16 || px == ome.xml.model.enums.PixelType.UINT16)
                    return PixelFormat.Format48bppRgb;
            }
            throw new NotSupportedException("Not supported pixel format.");
        }

◆ GetRGBBitmap()

Bitmap BioImager.BioImage.GetRGBBitmap	(	ZCT	coord,
		IntRange	rf,
		IntRange	gf,
		IntRange	bf
	)

‍Get the RGB bitmap for the specified ZCT coordinate

Parameters

ZCT	Z, C, T coordinates
IntRange
IntRange
IntRange

Returns: A Bitmap object.

Definition at line 4237 of file Bio.cs.

        {
            int index = Coords[coord.Z, coord.C, coord.T];
            if (Buffers[0].RGBChannelsCount == 1)
            {
                if (Channels.Count >= 3)
                {
                    Bitmap[] bs = new Bitmap[3];
                    bs[2] = Buffers[index + RChannel.Index];
                    bs[1] = Buffers[index + GChannel.Index];
                    bs[0] = Buffers[index + BChannel.Index];
                    return Bitmap.GetRGBBitmap(bs, rf, gf, bf);
                }
                else
                {
                    Bitmap[] bs = new Bitmap[3];
                    bs[2] = Buffers[index + RChannel.Index];
                    bs[1] = Buffers[index + RChannel.Index + 1];
                    bs[0] = Buffers[index + RChannel.Index + 2];
                    return Bitmap.GetRGBBitmap(bs, rf, gf, bf);
                }
            }
            else
                return Buffers[index];
        }

Referenced by BioImager.ImageView.UpdateImages().

◆ GetTile() [1/2]

static Bitmap BioImager.BioImage.GetTile	(	BioImage	b,
		int	i,
		int	serie,
		int	tilex,
		int	tiley,
		int	tileSizeX,
		int	tileSizeY
	)

static

It reads a tile from a file, and returns a bitmap

Parameters

BioImage	This is a class that contains the image file name, the image reader, and the coordinates of the image.
i	the Z, C, T image index
serie	the series number (0-based)
tilex	the x coordinate of the tile
tiley	the y coordinate of the tile
tileSizeX	the width of the tile
tileSizeY	the height of the tile

Returns: A Bitmap object.

Definition at line 6764 of file Bio.cs.

        {
            if ((b.file.EndsWith("ome.tif") && vips) || (b.file.EndsWith(".tif") && vips))
            {
                //We can get a tile faster with libvips rather than bioformats.
                return ExtractRegionFromTiledTiff(b, tilex, tiley, tileSizeX, tileSizeY, serie);
            }
            //We check if we can open this with OpenSlide as this is faster than Bioformats with IKVM.
            if (b.openSlideImage != null)
            {
                return new Bitmap(tileSizeX, tileSizeY, AForge.PixelFormat.Format32bppArgb, b.openSlideImage.ReadRegion(serie, tilex, tiley, tileSizeX, tileSizeY), new ZCT(), "");
            }
 
            string curfile = reader.getCurrentFile();
            if (curfile == null)
            {
                b.meta = (IMetadata)((OMEXMLService)factory.getInstance(typeof(OMEXMLService))).createOMEXMLMetadata();
                reader.close();
                reader.setMetadataStore(b.meta);
                Console.WriteLine(b.file);
                reader.setId(b.file);
            }
            else
            {
                string fi = b.file.Replace("\\", "/");
                string cf = curfile.Replace("\\", "/");
                if (cf != fi)
                {
                    reader.close();
                    b.meta = (IMetadata)((OMEXMLService)factory.getInstance(typeof(OMEXMLService))).createOMEXMLMetadata();
                    reader.setMetadataStore(b.meta);
                    reader.setId(b.file);
                }
            }
            if (reader.getSeries() != serie)
                reader.setSeries(serie);
            int SizeX = reader.getSizeX();
            int SizeY = reader.getSizeY();
            bool flat = reader.hasFlattenedResolutions();
            bool littleEndian = reader.isLittleEndian();
            PixelFormat PixelFormat = b.Resolutions[serie].PixelFormat;
            if (tilex < 0)
                tilex = 0;
            if (tiley < 0)
                tiley = 0;
            if (tilex >= SizeX)
                tilex = SizeX;
            if (tiley >= SizeY)
                tiley = SizeY;
            int sx = tileSizeX;
            if (tilex + tileSizeX > SizeX)
                sx -= (tilex + tileSizeX) - (SizeX);
            int sy = tileSizeY;
            if (tiley + tileSizeY > SizeY)
                sy -= (tiley + tileSizeY) - (SizeY);
            //For some reason calling openBytes with 1x1px area causes an exception. 
            if (sx <= 1)
                return null;
            if (sy <= 1)
                return null;
            try
            {
                byte[] bytesr = reader.openBytes(i, tilex, tiley, sx, sy);
                bool interleaved = reader.isInterleaved();
                if (bm != null)
                    bm.Dispose();
                bm = new Bitmap(b.file, sx, sy, PixelFormat, bytesr, new ZCT(), i, null, littleEndian, interleaved);
                return bm;
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
                return null;
            }
        }

References BioImager.BioImage.ExtractRegionFromTiledTiff().

◆ GetTile() [2/2]

static Bitmap BioImager.BioImage.GetTile	(	BioImage	b,
		ZCT	coord,
		int	serie,
		int	tilex,
		int	tiley,
		int	tileSizeX,
		int	tileSizeY
	)

static

It reads a tile from a file, and returns a bitmap

Parameters

BioImage	This is a class that contains the image file name, the image reader, and the coordinates of the image.
ZCT	Z, C, T
serie	the series number (0-based)
tilex	the x coordinate of the tile
tiley	the y coordinate of the tile
tileSizeX	the width of the tile
tileSizeY	the height of the tile

Returns: A Bitmap object.

Definition at line 6678 of file Bio.cs.

        {
            if ((b.file.EndsWith("ome.tif") && vips) || (b.file.EndsWith(".tif") && vips))
            {
                //We can get a tile faster with libvips rather than bioformats.
                return ExtractRegionFromTiledTiff(b, tilex, tiley, tileSizeX, tileSizeY, serie);
            }
            //We check if we can open this with OpenSlide as this is faster than Bioformats with IKVM.
            if (b.openSlideImage != null)
            {
                return new Bitmap(tileSizeX, tileSizeY, AForge.PixelFormat.Format32bppArgb, b.openSlideImage.ReadRegion(serie, tilex, tiley, tileSizeX, tileSizeY), coord, "");
            }
 
            string curfile = reader.getCurrentFile();
            if (curfile == null)
            {
                b.meta = (IMetadata)((OMEXMLService)factory.getInstance(typeof(OMEXMLService))).createOMEXMLMetadata();
                reader.close();
                reader.setMetadataStore(b.meta);
                Console.WriteLine(b.file);
                reader.setId(b.file);
            }
            else
            {
                string fi = b.file.Replace("\\", "/");
                string cf = curfile.Replace("\\", "/");
                if (cf != fi)
                {
                    reader.close();
                    b.meta = (IMetadata)((OMEXMLService)factory.getInstance(typeof(OMEXMLService))).createOMEXMLMetadata();
                    reader.setMetadataStore(b.meta);
                    reader.setId(b.file);
                }
            }
            if (reader.getSeries() != serie)
                reader.setSeries(serie);
            int SizeX = reader.getSizeX();
            int SizeY = reader.getSizeY();
            bool flat = reader.hasFlattenedResolutions();
            int p = b.Coords[coord.Z, coord.C, coord.T];
            bool littleEndian = reader.isLittleEndian();
            PixelFormat PixelFormat = b.Resolutions[serie].PixelFormat;
            if (tilex < 0)
                tilex = 0;
            if (tiley < 0)
                tiley = 0;
            if (tilex >= SizeX)
                tilex = SizeX;
            if (tiley >= SizeY)
                tiley = SizeY;
            int sx = tileSizeX;
            if (tilex + tileSizeX > SizeX)
                sx -= (tilex + tileSizeX) - (SizeX);
            int sy = tileSizeY;
            if (tiley + tileSizeY > SizeY)
                sy -= (tiley + tileSizeY) - (SizeY);
            //For some reason calling openBytes with 1x1px area causes an exception. 
            if (sx <= 1)
                return null;
            if (sy <= 1)
                return null;
            try
            {
                byte[] bytesr = reader.openBytes(b.Coords[coord.Z, coord.C, coord.T], tilex, tiley, sx, sy);
                bool interleaved = reader.isInterleaved();
                bm = new Bitmap(b.file, sx, sy, PixelFormat, bytesr, coord, p, null, littleEndian, interleaved);
                return bm;
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
                return null;
            }
        }

References BioImager.BioImage.ExtractRegionFromTiledTiff().

Referenced by BioImager.BioImage.OpenFile(), BioImager.BioImage.OpenOME(), BioImager.SlideImage.ReadRegion(), and BioImager.SlideImage.TryReadRegion().

◆ GetUnitPerPixel()

double BioImager.BioImage.GetUnitPerPixel ( int level )

Get Unit Per Pixel for pyramidal images.

Parameters

level

Returns

Definition at line 2617 of file Bio.cs.

        {
            return Resolutions[0].PhysicalSizeX * GetLevelDownsample(level);
        }

References BioImager.BioImage.GetLevelDownsample().

Referenced by BioImager.ImageView.GoToImage().

◆ GetValue() [1/3]

ushort BioImager.BioImage.GetValue	(	int	z,
		int	c,
		int	t,
		int	x,
		int	y
	)

‍This function returns the value of the pixel at the specified ZCTXY coordinates

Parameters

z	The Z-plane of the image.
c	channel
t	time
x	x coordinate of the pixel
y	the y coordinate of the pixel

Returns: The value of the pixel at the given coordinates.

Definition at line 4056 of file Bio.cs.

        {
            return GetValue(new ZCTXY(z, c, t, x, y));
        }

References BioImager.BioImage.GetValue().

◆ GetValue() [2/3]

ushort BioImager.BioImage.GetValue	(	ZCT	coord,
		int	x,
		int	y
	)

‍Get the value of the pixel at the given coordinates

Parameters

ZCT	Z is the Z-plane, C is the channel, T is the timepoint
x	x coordinate of the pixel
y	The y coordinate of the pixel

Returns: The value of the pixel at the given coordinates.

Definition at line 4043 of file Bio.cs.

        {
            return GetValueRGB(new ZCTXY(coord.Z, coord.C, coord.T, x, y), 0);
        }

References BioImager.BioImage.GetValueRGB().

◆ GetValue() [3/3]

ushort BioImager.BioImage.GetValue ( ZCTXY coord )

If the coordinate is within the bounds of the image, then return the value of the pixel at that coordinate

Parameters

ZCTXY a struct that contains the X, Y, Z, C, and T coordinates of the pixel.

Returns: The value of the pixel at the given coordinate.

Definition at line 3992 of file Bio.cs.

        {
            if (coord.X < 0 || coord.Y < 0 || coord.X > SizeX || coord.Y > SizeY)
            {
                return 0;
            }
            if (isRGB)
            {
                if (coord.C == 0)
                    return GetValueRGB(coord, 0);
                else if (coord.C == 1)
                    return GetValueRGB(coord, 1);
                else if (coord.C == 2)
                    return GetValueRGB(coord, 2);
            }
            else
                return GetValueRGB(coord, 0);
            return 0;
        }

References BioImager.BioImage.GetValueRGB().

Referenced by BioImager.BioImage.GetValue(), and BioImager.BioImage.GetValueRGB().

◆ GetValueRGB() [1/3]

ushort BioImager.BioImage.GetValueRGB	(	int	z,
		int	c,
		int	t,
		int	x,
		int	y,
		int	RGBindex
	)

This function returns the value of the pixel at the specified coordinates in the specified channel, frame, and RGB index

Parameters

z	The Z-plane index
c	channel
t	time index
x	x coordinate of the pixel
y	The y coordinate of the pixel
RGBindex	0 = Red, 1 = Green, 2 = Blue

Returns: The value of the pixel at the given coordinates.

Definition at line 4089 of file Bio.cs.

        {
            return GetValueRGB(new ZCT(z, c, t), x, y, RGBindex);
        }

References BioImager.BioImage.GetValueRGB().

◆ GetValueRGB() [2/3]

ushort BioImager.BioImage.GetValueRGB	(	ZCT	coord,
		int	x,
		int	y,
		int	RGBindex
	)

‍Get the value of a pixel at a given coordinate, x, y, and RGB index

Parameters

ZCT	The ZCT coordinate of the image.
x	x coordinate of the pixel
y	the y coordinate of the pixel
RGBindex	0 = Red, 1 = Green, 2 = Blue

Returns: The value of the pixel at the given coordinates.

Definition at line 4068 of file Bio.cs.

        {
            ZCTXY c = new ZCTXY(coord.Z, coord.C, coord.T, x, y);
            if (isRGB)
            {
                return GetValueRGB(c, RGBindex);
            }
            else
                return GetValue(coord, x, y);
        }

References BioImager.BioImage.GetValue(), and BioImager.BioImage.GetValueRGB().

◆ GetValueRGB() [3/3]

ushort BioImager.BioImage.GetValueRGB	(	ZCTXY	coord,
		int	index
	)

It takes a coordinate and an index and returns the value of the pixel at that coordinate

Parameters

ZCTXY	a struct that contains the Z, C, T, X, and Y coordinates of the pixel.
index	0, 1, 2

Returns: A ushort value.

Definition at line 4017 of file Bio.cs.

        {
            int ind = 0;
            if (coord.C >= SizeC)
            {
                coord.C = 0;
            }
            ind = Coords[coord.Z, coord.C, coord.T];
            ColorS c = Buffers[ind].GetPixel(coord.X, coord.Y);
            if (index == 0)
                return c.R;
            else
            if (index == 1)
                return c.G;
            else
            if (index == 2)
                return c.B;
            throw new IndexOutOfRangeException();
        }

Referenced by BioImager.BioImage.GetValue(), and BioImager.BioImage.GetValueRGB().

◆ ImagesToStack()

static BioImage BioImager.BioImage.ImagesToStack	(	string[]	files,
		bool	tab
	)

static

It takes a list of files, opens them, and then combines them into a single BioImage object

Parameters

files an array of file paths

Returns: A BioImage object.

Definition at line 7199 of file Bio.cs.

        {
            BioImage[] bs = new BioImage[files.Length];
            int z = 0;
            int c = 0;
            int t = 0;
            for (int i = 0; i < files.Length; i++)
            {
                string str = Path.GetFileNameWithoutExtension(files[i]);
                str = str.Replace(".ome", "");
                string[] st = str.Split('_');
                if (st.Length > 3)
                {
                    z = int.Parse(st[1].Replace("Z", ""));
                    c = int.Parse(st[2].Replace("C", ""));
                    t = int.Parse(st[3].Replace("T", ""));
                }
                if (i == 0)
                    bs[0] = OpenOME(files[i], tab);
                else
                {
                    bs[i] = OpenFile(files[i], 0, tab, false);
                }
            }
            BioImage b = BioImage.CopyInfo(bs[0], true, true);
            for (int i = 0; i < files.Length; i++)
            {
                for (int bc = 0; bc < bs[i].Buffers.Count; bc++)
                {
                    b.Buffers.Add(bs[i].Buffers[bc]);
                }
            }
            b.UpdateCoords(z + 1, c + 1, t + 1);
            b.Volume = new VolumeD(bs[0].Volume.Location, new Point3D(bs[0].SizeX * bs[0].PhysicalSizeX, bs[0].SizeY * bs[0].PhysicalSizeY, (z + 1) * bs[0].PhysicalSizeZ));
            return b;
        }

References BioImager.BioImage.CopyInfo(), BioImager.BioImage.OpenFile(), BioImager.BioImage.OpenOME(), and BioImager.BioImage.UpdateCoords().

◆ ImportROIsCSV()

static List< ROI > BioImager.BioImage.ImportROIsCSV ( string filename )

static

It reads the CSV file and converts each line into a ROI object

Parameters

filename The path to the CSV file.

Returns: A list of ROI objects.

Definition at line 7907 of file Bio.cs.

        {
            List<ROI> list = new List<ROI>();
            if (!File.Exists(filename))
                return list;
            string[] sts = File.ReadAllLines(filename);
            //We start reading from line 1.
            for (int i = 1; i < sts.Length; i++)
            {
                list.Add(StringToROI(sts[i]));
            }
            return list;
        }

References BioImager.BioImage.StringToROI().

Referenced by BioImager.BioImage.OpenFile().

◆ Initialize()

static void BioImager.BioImage.Initialize ( )

static

We initialize OME on a seperate thread so the user doesn't have to wait for initialization to view images.

Definition at line 4470 of file Bio.cs.

        {
            if (!OMESupport())
                return;
            //We initialize OME on a seperate thread so the user doesn't have to wait for initialization to
            //view images. 
            System.Threading.Thread t = new System.Threading.Thread(new System.Threading.ThreadStart(InitOME));
            t.Start();
        }

References BioImager.BioImage.OMESupport().

Referenced by BioImager.App.Initialize().

◆ isOME()

static bool BioImager.BioImage.isOME ( string file )

static

If the file is a TIFF, check the ImageDescription tag for the string "OME-XML". If it's there, return true. If it's not a TIFF, return true. If it's a PNG, JPG, JPEG, or BMP, return false

Parameters

file	the path to the image file

Returns: A boolean value.

Definition at line 5105 of file Bio.cs.

        {
            if (file.EndsWith("ome.tif") || file.EndsWith("ome.tiff"))
            {
                return true;
            }
            if (file.EndsWith(".tif") || file.EndsWith(".TIF") || file.EndsWith("tiff") || file.EndsWith("TIFF"))
            {
                Tiff image = Tiff.Open(file, "r");
                string desc = "";
                FieldValue[] f = image.GetField(TiffTag.IMAGEDESCRIPTION);
                desc = f[0].ToString();
                image.Close();
                if (desc.Contains("OME-XML"))
                    return true;
                else
                    return false;
            }
            if (!(file.EndsWith("png") || file.EndsWith("PNG") || file.EndsWith("jpg") || file.EndsWith("JPG") ||
                file.EndsWith("jpeg") || file.EndsWith("JPEG") || file.EndsWith("bmp") || file.EndsWith("BMP")))
            {
                return true;
            }
            else return false;
        }

Referenced by BioImager.BioImage.isOMESeries(), and BioImager.BioImage.OpenFile().

◆ isOMESeries()

static bool BioImager.BioImage.isOMESeries ( string file )

static

‍If the file is an OME file and has more than one series, return true

Parameters

file	the file to be checked

Returns: A boolean value.

Definition at line 5135 of file Bio.cs.

        {
            if (!isOME(file))
                return false;
            ImageReader reader = new ImageReader();
            var meta = (IMetadata)((OMEXMLService)new ServiceFactory().getInstance(typeof(OMEXMLService))).createOMEXMLMetadata();
            reader.setMetadataStore((MetadataStore)meta);
            file = file.Replace("\\", "/");
            reader.setId(file);
            bool ser = false;
            if (reader.getSeriesCount() > 1)
                ser = true;
            reader.close();
            reader = null;
            return ser;
        }

References BioImager.BioImage.isOME().

◆ isTiffSeries()

static bool BioImager.BioImage.isTiffSeries ( string file )

static

‍The function checks if the image is a Tiff image and if it is, it checks if the image is a

series of images

Parameters

file	the path to the file

Returns: a boolean value.

Definition at line 5070 of file Bio.cs.

        {
            Tiff image = Tiff.Open(file, "r");
            string desc = "";
            FieldValue[] f = image.GetField(TiffTag.IMAGEDESCRIPTION);
            image.Close();
            string[] sts = desc.Split('\n');
            int index = 0;
            for (int i = 0; i < sts.Length; i++)
            {
                if (sts[i].StartsWith("-ImageInfo"))
                {
                    string val = sts[i].Substring(11);
                    val = val.Substring(0, val.IndexOf(':'));
                    int serie = int.Parse(val);
                    if (sts[i].Length > 10)
                    {
                        string cht = sts[i].Substring(sts[i].IndexOf('{'), sts[i].Length - sts[i].IndexOf('{'));
                        ImageInfo info = JsonConvert.DeserializeObject<ImageInfo>(cht);
                        if (info.Series > 1)
                            return true;
                        else
                            return false;
                    }
                }
            }
            return false;
        }

◆ LevelFromResolution()

int BioImager.BioImage.LevelFromResolution ( double Resolution )

Returns the level of a given resolution.

Parameters

Resolution

Returns

Definition at line 2589 of file Bio.cs.

        {
            int l = 0;
            double[] ds = new double[Resolutions.Count];
            for (int i = 0; i < Resolutions.Count; i++)
            {
                ds[i] = Resolutions[0].PhysicalSizeX * GetLevelDownsample(i);
            }
            for (int i = 0; i < ds.Length; i++)
            {
                if (ds[i] > Resolution)
                {
                    l = i;
                    break;
                }
            }
            if(MacroResolution.HasValue)
            {
                return MacroResolution.Value - 1;
            }
            else
            return l;
        }

References BioImager.BioImage.GetLevelDownsample().

Referenced by BioImager.SlideSourceBase.GetSlice().

◆ MergeChannels() [1/2]

static BioImage BioImager.BioImage.MergeChannels	(	BioImage	b2,
		BioImage	b
	)

static

This function takes two images and merges them together

Parameters

BioImage	The image to be merged
BioImage	The image to be merged

Returns: A new BioImage object.

Definition at line 3579 of file Bio.cs.

        {
            BioImage res = new BioImage(b2.ID);
            res.ID = Images.GetImageName(b2.ID);
            res.series = b2.series;
            res.sizeZ = b2.SizeZ;
            int cOrig = b2.SizeC;
            res.sizeC = b2.SizeC + b.SizeC;
            res.sizeT = b2.SizeT;
            res.bitsPerPixel = b2.bitsPerPixel;
            res.imageInfo = b2.imageInfo;
            res.littleEndian = b2.littleEndian;
            res.seriesCount = b2.seriesCount;
            res.imagesPerSeries = res.ImageCount / res.seriesCount;
            res.Coords = new int[res.SizeZ, res.SizeC, res.SizeT];
 
            int i = 0;
            int cc = 0;
            for (int ti = 0; ti < res.SizeT; ti++)
            {
                for (int zi = 0; zi < res.SizeZ; zi++)
                {
                    for (int ci = 0; ci < res.SizeC; ci++)
                    {
                        ZCT co = new ZCT(zi, ci, ti);
                        if (ci < cOrig)
                        {
                            //If this channel is part of the image b1 we add planes from it.
                            Bitmap copy = new Bitmap(b2.id, b2.SizeX, b2.SizeY, b2.Buffers[0].PixelFormat, b2.Buffers[i].Bytes, co, i);
                            if (b2.littleEndian)
                                copy.RotateFlip(AForge.RotateFlipType.Rotate180FlipNone);
                            res.Coords[zi, ci, ti] = i;
                            res.Buffers.Add(b2.Buffers[i]);
                            res.Buffers.Add(copy);
                            //Lets copy the ROI's from the original image.
                            List<ROI> anns = b2.GetAnnotations(zi, ci, ti);
                            if (anns.Count > 0)
                                res.Annotations.AddRange(anns);
                        }
                        else
                        {
                            //This plane is not part of b1 so we add the planes from b2 channels.
                            Bitmap copy = new Bitmap(b.id, b.SizeX, b.SizeY, b.Buffers[0].PixelFormat, b.Buffers[i].Bytes, co, i);
                            if (b2.littleEndian)
                                copy.RotateFlip(AForge.RotateFlipType.Rotate180FlipNone);
                            res.Coords[zi, ci, ti] = i;
                            res.Buffers.Add(b.Buffers[i]);
                            res.Buffers.Add(copy);
 
                            //Lets copy the ROI's from the original image.
                            List<ROI> anns = b.GetAnnotations(zi, cc, ti);
                            if (anns.Count > 0)
                                res.Annotations.AddRange(anns);
                        }
                        i++;
                    }
                }
            }
            for (int ci = 0; ci < res.SizeC; ci++)
            {
                if (ci < cOrig)
                {
                    res.Channels.Add(b2.Channels[ci].Copy());
                }
                else
                {
                    res.Channels.Add(b.Channels[cc].Copy());
                    res.Channels[cOrig + cc].Index = ci;
                    cc++;
                }
            }
            Images.AddImage(res, true);
            //We wait for threshold image statistics calculation
            do
            {
                Thread.Sleep(100);
            } while (res.Buffers[res.Buffers.Count - 1].Stats == null);
            AutoThreshold(res, false);
            if (res.bitsPerPixel > 8)
                res.StackThreshold(true);
            else
                res.StackThreshold(false);
            Recorder.AddLine("Bio.BioImage.MergeChannels(" + '"' + b.ID + '"' + "," + '"' + b2.ID + '"' + ");");
            return res;
        }

References BioImager.BioImage.AutoThreshold(), BioImager.BioImage.GetAnnotations(), and BioImager.BioImage.StackThreshold().

Referenced by BioImager.BioImage.MergeChannels().

◆ MergeChannels() [2/2]

static BioImage BioImager.BioImage.MergeChannels	(	string	bname,
		string	b2name
	)

static

MergeChannels(b, b2) takes two images, b and b2, and merges the channels of b2 into b

Parameters

bname	The name of the first image
b2name	The name of the image to merge with the first image.

Returns: A BioImage object.

Definition at line 3670 of file Bio.cs.

        {
            BioImage b = Images.GetImage(bname);
            BioImage b2 = Images.GetImage(b2name);
            return MergeChannels(b, b2);
        }

References BioImager.BioImage.MergeChannels().

◆ MergeT()

static BioImage BioImager.BioImage.MergeT ( BioImage b )

static

It takes a 3D image and merges the time dimension into a single image

Parameters

BioImage The image to be processed

Returns: A new BioImage object.

Definition at line 3726 of file Bio.cs.

        {
            BioImage bi = BioImage.CopyInfo(b, true, true);
            int ind = 0;
            for (int c = 0; c < b.SizeC; c++)
            {
                for (int z = 0; z < b.sizeZ; z++)
                {
                    Merge m = new Merge(b.Buffers[b.Coords[z, c, 0]]);
                    Bitmap bm = new Bitmap(b.SizeX, b.SizeY, b.Buffers[0].PixelFormat);
                    for (int i = 1; i < b.sizeT; i++)
                    {
                        m.OverlayImage = bm;
                        bm = m.Apply(b.Buffers[b.Coords[z, c, i]]);
                    }
                    Bitmap bf = new Bitmap(b.file, bm, new ZCT(z, c, 0), ind);
                    bi.Buffers.Add(bf);
                    Statistics.CalcStatistics(bf);
                    ind++;
                }
            }
            Images.AddImage(bi, true);
            bi.UpdateCoords(1, b.SizeC, b.SizeT);
            bi.Coordinate = new ZCT(0, 0, 0);
            //We wait for threshold image statistics calculation
            do
            {
                Thread.Sleep(100);
            } while (bi.Buffers[bi.Buffers.Count - 1].Stats == null);
            Statistics.ClearCalcBuffer();
            bi.Resolutions.Add(new Resolution(b.Buffers[0].SizeX, b.Buffers[0].SizeY, b.Buffers[0].PixelFormat, b.PhysicalSizeX, b.PhysicalSizeY, b.PhysicalSizeZ, b.StageSizeX, b.StageSizeY, b.StageSizeZ));
            AutoThreshold(bi, false);
            if (bi.bitsPerPixel > 8)
                bi.StackThreshold(true);
            else
                bi.StackThreshold(false);
            Recorder.AddLine("Bio.BioImage.MergeT(" + '"' + b.ID + '"' + ");");
            return bi;
        }

References BioImager.BioImage.AutoThreshold(), BioImager.BioImage.CopyInfo(), BioImager.BioImage.StackThreshold(), and BioImager.BioImage.UpdateCoords().

◆ MergeZ()

static BioImage BioImager.BioImage.MergeZ ( BioImage b )

static

It takes a 3D image and merges the Z-stack into a single 2D image

Parameters

BioImage The image to be merged

Returns: A new BioImage object.

Definition at line 3681 of file Bio.cs.

        {
            BioImage bi = BioImage.CopyInfo(b, true, true);
            int ind = 0;
            for (int c = 0; c < b.SizeC; c++)
            {
                for (int t = 0; t < b.sizeT; t++)
                {
                    Merge m = new Merge(b.Buffers[b.Coords[0, c, t]]);
                    Bitmap bm = new Bitmap(b.SizeX, b.SizeY, b.Buffers[0].PixelFormat);
                    for (int i = 1; i < b.sizeZ; i++)
                    {
                        m.OverlayImage = bm;
                        bm = m.Apply(b.Buffers[b.Coords[i, c, t]]);
                    }
                    Bitmap bf = new Bitmap(b.file, bm, new ZCT(0, c, t), ind);
                    bi.Buffers.Add(bf);
                    Statistics.CalcStatistics(bf);
                    ind++;
                }
            }
            Images.AddImage(bi, true);
            bi.UpdateCoords(1, b.SizeC, b.SizeT);
            bi.Coordinate = new ZCT(0, 0, 0);
            //We wait for threshold image statistics calculation
            do
            {
                Thread.Sleep(100);
            } while (bi.Buffers[bi.Buffers.Count - 1].Stats == null);
            Statistics.ClearCalcBuffer();
            bi.Resolutions.Add(new Resolution(b.Buffers[0].SizeX, b.Buffers[0].SizeY, b.Buffers[0].PixelFormat, b.PhysicalSizeX, b.PhysicalSizeY, b.PhysicalSizeZ, b.StageSizeX, b.StageSizeY, b.StageSizeZ));
 
            AutoThreshold(bi, false);
            if (bi.bitsPerPixel > 8)
                bi.StackThreshold(true);
            else
                bi.StackThreshold(false);
            Recorder.AddLine("Bio.BioImage.MergeZ(" + '"' + b.ID + '"' + ");");
            return bi;
        }

References BioImager.BioImage.AutoThreshold(), BioImager.BioImage.CopyInfo(), BioImager.BioImage.StackThreshold(), and BioImager.BioImage.UpdateCoords().

◆ OMESupport()

static bool BioImager.BioImage.OMESupport ( )

static

The function checks if the operating system is macOS and displays a message if OME images are not supported, otherwise it sets OmeSupport to true.

Returns: The method is returning a boolean value. If the operating system is MacOS and the supportDialog flag is false, it will display a message dialog and return false. Otherwise, it will set the OmeSupport flag to true and return true.

Definition at line 7268 of file Bio.cs.

        {
            bool isMacOS = RuntimeInformation.IsOSPlatform(OSPlatform.OSX);
            if (RuntimeInformation.OSArchitecture == Architecture.Arm64 && isMacOS)
            {
                if (!supportDialog)
                {
                    MessageDialog md = new MessageDialog(
                    null,
                    DialogFlags.DestroyWithParent,
                    MessageType.Info,
                    ButtonsType.Ok, "BioGTK currently doens't support OME images on Arm64 MacOS due to dependency IKVM 8.6.4 not yet supporting Mac Arm64." +
                    "On MacOS ImageJ Tiff files, LibVips supported whole-slide images, and BioGTK Tiff files are supported.");
                    md.Run();
                }
                supportDialog = true;
                return false;
            }
            else
            {
                OmeSupport = true;
                return true;
            }
        }

Referenced by BioImager.BioImage.ExportROIFolder(), BioImager.BioImage.Initialize(), BioImager.BioImage.OpenOME(), BioImager.BioImage.OpenOMEROIs(), BioImager.BioImage.SaveOME(), and BioImager.BioImage.SaveOMESeries().

◆ Open() [1/2]

static void BioImager.BioImage.Open ( string file )

static

It opens a file

Parameters

file	The file to open.

Definition at line 7180 of file Bio.cs.

        {
            OpenFile(file);
        }

References BioImager.BioImage.OpenFile().

Referenced by BioImager.BioImage.Open(), and BioImager.BioImage.OpenSeries().

◆ Open() [2/2]

static void BioImager.BioImage.Open ( string[] files )

static

It opens a file

Parameters

files The files to open.

Definition at line 7187 of file Bio.cs.

        {
            foreach (string file in files)
            {
                Open(file);
            }
        }

References BioImager.BioImage.Open().

◆ OpenAsync() [1/2]

static async Task BioImager.BioImage.OpenAsync	(	string	file,
		bool	OME,
		bool	newtab,
		bool	images
	)

static

It opens a file in a new thread.

Parameters

file	The file to open

Definition at line 7046 of file Bio.cs.

        {
            openfile = file;
            omes = OME;
            tab = newtab;
            add = images;
            await Task.Run(OpenThread);
        }

Referenced by BioImager.BioImage.OpenAsync().

◆ OpenAsync() [2/2]

static async Task BioImager.BioImage.OpenAsync	(	string[]	files,
		bool	OME,
		bool	tab,
		bool	images
	)

static

It opens a file asynchronously

Parameters

files The file(s) to open.

Definition at line 7057 of file Bio.cs.

        {
            foreach (string file in files)
            {
                await OpenAsync(file, OME, tab, images);
            }
        }

References BioImager.BioImage.OpenAsync().

◆ OpenFile() [1/4]

static BioImage BioImager.BioImage.OpenFile ( string file )

static

This function opens a file and returns a BioImage object

Parameters

file	The path to the file to open.

Returns: A BioImage object.

Definition at line 4644 of file Bio.cs.

        {
            return OpenFile(file, 0, false, true);
        }

References BioImager.BioImage.OpenFile().

Referenced by BioImager.BioImage.FilesToStack(), BioImager.BioImage.FolderToStack(), BioImager.BioImage.ImagesToStack(), BioImager.BioImage.Open(), BioImager.BioImage.OpenFile(), BioImager.BioImage.OpenSeries(), BioImager.ImageJ.RunOnImage(), and BioImager.BioImage.Update().

◆ OpenFile() [2/4]

static BioImage BioImager.BioImage.OpenFile	(	string	file,
		bool	tab
	)

static

Definition at line 4648 of file Bio.cs.

        {
            return OpenFile(file, 0, tab, true);
        }

◆ OpenFile() [3/4]

static BioImage BioImager.BioImage.OpenFile	(	string	file,
		int	series,
		bool	tab,
		bool	addToImages
	)

static

It opens a TIFF file and returns a BioImage object

Parameters

file	the file path
series	the series number of the image to open

Returns: A BioImage object.

Definition at line 4658 of file Bio.cs.

        {
            return OpenFile(file, series, tab, addToImages, false, 0, 0, 0, 0);
        }

References BioImager.BioImage.OpenFile().

◆ OpenFile() [4/4]

static BioImage BioImager.BioImage.OpenFile	(	string	file,
		int	series,
		bool	tab,
		bool	addToImages,
		bool	tile,
		int	tileX,
		int	tileY,
		int	tileSizeX,
		int	tileSizeY
	)

static

The OpenFile function in C# opens a BioImage file, reads its metadata, and loads the image data into a BioImage object.

Parameters

file	The file path of the bioimage to be opened.
series	The series parameter is an integer that specifies the series number of the image to open.
tab	The "tab" parameter is a boolean value that determines whether the BioImage should be opened in a new tab or not. If set to true, the BioImage will be opened in a new tab. If set to false, the BioImage will be opened in the current tab.
addToImages	A boolean value indicating whether the BioImage should be added to the Images collection.
tile	The "tile" parameter is a boolean value that determines whether the image should be opened as a tiled image or not. If set to true, the image will be opened as a tiled image. If set to false, the image will be opened as a regular image.
tileX	The `tileX` parameter is an integer that represents the starting X coordinate of the tile. It is used when opening a tiled image to specify the position of the tile within the image.
tileY	The `tileY` parameter is used to specify the starting Y coordinate of the tile when opening a tiled image. It determines the position of the tile within the image.
tileSizeX	The tileSizeX parameter is the width of each tile in pixels. It is used when opening a tiled TIFF image to specify the size of the tiles.
tileSizeY	The tileSizeY parameter is the height of each tile in pixels when the image is tiled.

Returns: The method is returning a BioImage object.

Definition at line 4784 of file Bio.cs.

        {
            string fs = file.Replace("\\", "/");
            vips = VipsSupport(file);
            Console.WriteLine("Opening BioImage: " + file);
            bool ome = isOME(file);
            if (ome) return OpenOME(file, series, tab, addToImages, tile, tileX, tileY, tileSizeX, tileSizeY);
            bool tiled = IsTiffTiled(file);
            Console.WriteLine("IsTiled=" + tiled.ToString());
            tile = tiled;
 
            Stopwatch st = new Stopwatch();
            st.Start();
            status = "Opening Image";
            progFile = file;
            progressValue = 0;
            BioImage b = new BioImage(file);
            if (tiled && file.EndsWith(".tif") && !file.EndsWith(".ome.tif"))
            {
                //To open this we need libvips
                vips = VipsSupport(b.file);
            }
            if(tiled)
            {
                b.type = ImageType.pyramidal;
            }
            b.series = series;
            b.file = file;
            string fn = Path.GetFileNameWithoutExtension(file);
            string dir = Path.GetDirectoryName(file);
            if (File.Exists(fn + ".csv"))
            {
                string f = dir + "//" + fn + ".csv";
                b.Annotations = BioImage.ImportROIsCSV(f);
            }
            if (file.EndsWith("tif") || file.EndsWith("tiff") || file.EndsWith("TIF") || file.EndsWith("TIFF"))
            {
                Tiff image = Tiff.Open(file, "r");
                b.tifRead = image;
                int SizeX = image.GetField(TiffTag.IMAGEWIDTH)[0].ToInt();
                int SizeY = image.GetField(TiffTag.IMAGELENGTH)[0].ToInt();
                b.bitsPerPixel = image.GetField(TiffTag.BITSPERSAMPLE)[0].ToInt();
                b.littleEndian = !image.IsBigEndian();
                int RGBChannelCount = image.GetField(TiffTag.SAMPLESPERPIXEL)[0].ToInt();
                string desc = "";
 
                FieldValue[] f = image.GetField(TiffTag.IMAGEDESCRIPTION);
                desc = f[0].ToString();
                ImageJDesc imDesc = null;
                b.sizeC = 1;
                b.sizeT = 1;
                b.sizeZ = 1;
                if (f != null && !tile)
                {
                    imDesc = new ImageJDesc();
                    desc = f[0].ToString();
                    if (desc.StartsWith("ImageJ"))
                    {
                        imDesc.SetString(desc);
                        if (imDesc.channels != 0)
                            b.sizeC = imDesc.channels;
                        else
                            b.sizeC = 1;
                        if (imDesc.slices != 0)
                            b.sizeZ = imDesc.slices;
                        else
                            b.sizeZ = 1;
                        if (imDesc.frames != 0)
                            b.sizeT = imDesc.frames;
                        else
                            b.sizeT = 1;
                        if (imDesc.finterval != 0)
                            b.frameInterval = imDesc.finterval;
                        else
                            b.frameInterval = 1;
                        if (imDesc.spacing != 0)
                            b.imageInfo.PhysicalSizeZ = imDesc.spacing;
                        else
                            b.imageInfo.PhysicalSizeZ = 1;
                    }
                }
                int stride = 0;
                PixelFormat PixelFormat;
                if (RGBChannelCount == 1)
                {
                    if (b.bitsPerPixel > 8)
                    {
                        PixelFormat = PixelFormat.Format16bppGrayScale;
                        stride = SizeX * 2;
                    }
                    else
                    {
                        PixelFormat = PixelFormat.Format8bppIndexed;
                        stride = SizeX;
                    }
                }
                else
                if (RGBChannelCount == 3)
                {
                    b.sizeC = 1;
                    if (b.bitsPerPixel > 8)
                    {
                        PixelFormat = PixelFormat.Format48bppRgb;
                        stride = SizeX * 2 * 3;
                    }
                    else
                    {
                        PixelFormat = PixelFormat.Format24bppRgb;
                        stride = SizeX * 3;
                    }
                }
                else
                {
                    PixelFormat = PixelFormat.Format32bppArgb;
                    stride = SizeX * 4;
                }
 
                string[] sts = desc.Split('\n');
                int index = 0;
                for (int i = 0; i < sts.Length; i++)
                {
                    if (sts[i].StartsWith("-Channel"))
                    {
                        string val = sts[i].Substring(9);
                        val = val.Substring(0, val.IndexOf(':'));
                        int serie = int.Parse(val);
                        if (serie == series && sts[i].Length > 7)
                        {
                            string cht = sts[i].Substring(sts[i].IndexOf('{'), sts[i].Length - sts[i].IndexOf('{'));
                            Channel.ChannelInfo info = JsonConvert.DeserializeObject<Channel.ChannelInfo>(cht);
                            Channel ch = new Channel(index, b.bitsPerPixel, info.SamplesPerPixel);
                            ch.info = info;
                            b.Channels.Add(ch);
                            if (index == 0)
                            {
                                b.rgbChannels[0] = 0;
                            }
                            else
                            if (index == 1)
                            {
                                b.rgbChannels[1] = 1;
                            }
                            else
                            if (index == 2)
                            {
                                b.rgbChannels[2] = 2;
                            }
                            index++;
                        }
                    }
                    else
                    if (sts[i].StartsWith("-ROI"))
                    {
                        string val = sts[i].Substring(5);
                        val = val.Substring(0, val.IndexOf(':'));
                        int serie = int.Parse(val);
                        if (serie == series && sts[i].Length > 7)
                        {
                            string s = sts[i].Substring(sts[i].IndexOf("ROI:") + 4, sts[i].Length - (sts[i].IndexOf("ROI:") + 4));
                            string ro = s.Substring(s.IndexOf(":") + 1, s.Length - (s.IndexOf(':') + 1));
                            ROI roi = StringToROI(ro);
                            b.Annotations.Add(roi);
                        }
                    }
                    else
                    if (sts[i].StartsWith("-ImageInfo"))
                    {
                        string val = sts[i].Substring(11);
                        val = val.Substring(0, val.IndexOf(':'));
                        int serie = int.Parse(val);
                        if (serie == series && sts[i].Length > 10)
                        {
                            string cht = sts[i].Substring(sts[i].IndexOf('{'), sts[i].Length - sts[i].IndexOf('{'));
                            b.imageInfo = JsonConvert.DeserializeObject<ImageInfo>(cht);
                        }
                    }
                }
                b.Coords = new int[b.SizeZ, b.SizeC, b.SizeT];
                if (tiled && tileSizeX == 0 && tileSizeY == 0)
                {
                    tileSizeX = 1920;
                    tileSizeY = 1080;
                }
 
                //If this is a tiff file not made by Bio we init channels based on RGBChannels.
                if (b.Channels.Count == 0)
                    b.Channels.Add(new Channel(0, b.bitsPerPixel, RGBChannelCount));
 
                //Lets check to see the channels are correctly defined in this file
                for (int ch = 0; ch < b.Channels.Count; ch++)
                {
                    if (b.Channels[ch].SamplesPerPixel != RGBChannelCount)
                    {
                        b.Channels[ch].SamplesPerPixel = RGBChannelCount;
                    }
                }
 
                b.Buffers = new List<Bitmap>();
                int pages = image.NumberOfDirectories() / b.seriesCount;
                int str = image.ScanlineSize();
                bool inter = true;
                if (stride != str)
                    inter = false;
                InitDirectoryResolution(b, image, imDesc);
                if (tiled)
                {
                    Console.WriteLine("Opening tiles.");
                    if (vips)
                        OpenVips(b, b.Resolutions.Count);
                    for (int t = 0; t < b.SizeT; t++)
                    {
                        for (int c = 0; c < b.SizeC; c++)
                        {
                            for (int z = 0; z < b.SizeZ; z++)
                            {
                                Bitmap bmp = GetTile(b, new ZCT(z, c, t), series, tileX, tileY, tileSizeX, tileSizeY);
                                b.Buffers.Add(bmp);
                                Statistics.CalcStatistics(bmp);
                            }
                        }
                    }
                    Console.WriteLine("Calculating statisitics.");
                }
                else
                {
                    for (int p = series * pages; p < (series + 1) * pages; p++)
                    {
                        image.SetDirectory((short)p);
 
                        byte[] bytes = new byte[stride * SizeY];
                        for (int im = 0, offset = 0; im < SizeY; im++)
                        {
                            image.ReadScanline(bytes, offset, im, 0);
                            offset += stride;
                        }
                        Bitmap inf = new Bitmap(file, SizeX, SizeY, b.Resolutions[series].PixelFormat, bytes, new ZCT(0, 0, 0), p, null, b.littleEndian, inter);
                        b.Buffers.Add(inf);
                        Statistics.CalcStatistics(inf);
                        progressValue = (float)p / (float)(series + 1) * pages;
                    }
                }
                image.Close();
                b.UpdateCoords();
            }
            if (b.StageSizeX == -1)
            {
                b.imageInfo.Series = 0;
                b.StageSizeX = 0;
                b.StageSizeY = 0;
                b.StageSizeZ = 0;
            }
            b.Volume = new VolumeD(new Point3D(b.StageSizeX, b.StageSizeY, b.StageSizeZ), new Point3D(b.PhysicalSizeX * b.SizeX, b.PhysicalSizeY * b.SizeY, b.PhysicalSizeZ * b.SizeZ));
 
            //If file is ome and we have OME support then check for annotation in metadata.
            if (ome && OmeSupport)
            {
                b.Annotations.AddRange(OpenOMEROIs(file, series));
            }
 
            //We wait for histogram image statistics calculation
            do
            {
                Thread.Sleep(50);
            } while (b.Buffers[b.Buffers.Count - 1].Stats == null);
            Statistics.ClearCalcBuffer();
            AutoThreshold(b, false);
            if (b.bitsPerPixel > 8)
                b.StackThreshold(true);
            else
                b.StackThreshold(false);
            Recorder.AddLine("Bio.BioImage.Open(" + '"' + file + '"' + ");");
            if (addToImages)
                Images.AddImage(b, tab);
            //pr.Close();
            //pr.Dispose();
            st.Stop();
            b.loadTimeMS = st.ElapsedMilliseconds;
            Console.WriteLine("BioImage loaded " + b.ToString());
            return b;
        }

References BioImager.BioImage.AutoThreshold(), BioImager.BioImage.GetTile(), BioImager.BioImage.ImportROIsCSV(), BioImager.BioImage.isOME(), BioImager.BioImage.OpenOME(), BioImager.BioImage.OpenOMEROIs(), BioImager.BioImage.OpenVips(), BioImager.BioImage.ImageJDesc.SetString(), BioImager.BioImage.StackThreshold(), BioImager.BioImage.StringToROI(), BioImager.BioImage.ToString(), BioImager.BioImage.UpdateCoords(), and BioImager.BioImage.VipsSupport().

◆ OpenOME() [1/3]

static BioImage BioImager.BioImage.OpenOME	(	string	file,
		bool	tab
	)

static

The function "OpenOME" opens a bioimage file in the OME format and returns the first image in the series.

Parameters

file	The "file" parameter is a string that represents the file path or name of the OME file that you want to open.
tab	The "tab" parameter is a boolean value that determines whether the image is opened in a new tab.

Returns: The method is returning a BioImage object.

Definition at line 5684 of file Bio.cs.

        {
            if (!OMESupport())
                return null;
            return OpenOMESeries(file, tab, true)[0];
        }

References BioImager.BioImage.OMESupport(), and BioImager.BioImage.OpenOMESeries().

Referenced by BioImager.BioImage.ImagesToStack(), BioImager.BioImage.OpenFile(), BioImager.BioImage.OpenOME(), BioImager.BioImage.OpenOMESeries(), and BioImager.BioImage.SaveOMESeries().

◆ OpenOME() [2/3]

static BioImage BioImager.BioImage.OpenOME	(	string	file,
		int	serie
	)

static

‍OpenOME(string file, int serie)

The first parameter is a string, the second is an integer

Parameters

file	the path to the file
serie	the image series to open

Returns: A BioImage object.

Definition at line 5698 of file Bio.cs.

        {
            if (!OMESupport())
                return null;
            Recorder.AddLine("Bio.BioImage.OpenOME(\"" + file + "\"," + serie + ");");
            return OpenOME(file, serie, true, false, false, 0, 0, 0, 0);
        }

References BioImager.BioImage.OMESupport(), and BioImager.BioImage.OpenOME().

◆ OpenOME() [3/3]

static BioImage BioImager.BioImage.OpenOME	(	string	file,
		int	serie,
		bool	tab,
		bool	addToImages,
		bool	tile,
		int	tilex,
		int	tiley,
		int	tileSizeX,
		int	tileSizeY,
		bool	useOpenSlide = `true`
	)

static

The function "OpenOME" opens a bioimage file, with options to specify the series, whether to

The function "OpenOME" opens a bioimage file, with options to specify the series, whether to display it in a tab, whether to add it to existing images, whether to tile the image, and the tile size.

Parameters

file	The file parameter is a string that represents the file path or name of the OME (Open Microscopy Environment) file that you want to open.
serie	The "serie" parameter is an integer that represents the series number of the image to be opened.
tab	The "tab" parameter is a boolean value that determines whether the image should be opened in a new tab or not. If set to true, the image will be opened in a new tab. If set to false, the image will be opened in the current tab.
addToImages	The "addToImages" parameter is a boolean value that determines whether the opened image should be added to a collection of images. If set to true, the image will be added to the collection. If set to false, the image will not be added.
tile	The "tile" parameter is a boolean value that determines whether or not to tile the images. If set to true, the images will be tiled according to the specified tilex, tiley, tileSizeX, and tileSizeY parameters. If set to false, the images will not be tiled.
tilex	The parameter "tilex" is an integer that represents the starting x-coordinate of the tile.
tiley	The parameter "tiley" is used to specify the number of tiles in the y-direction when tiling the image.
tileSizeX	The tileSizeX parameter specifies the width of each tile in pixels when tiling the images.
tileSizeY	The tileSizeY parameter is the height of each tile in pixels when tiling the images.

Definition at line 5872 of file Bio.cs.

        {
            //We wait incase OME has not initialized.
            do
            {
                Thread.Sleep(10);
            } while (!initialized);
            Console.WriteLine("OpenOME " + file);
            reader = new ImageReader();
            Progress pr = new Progress(file, "Opening OME");
            pr.Show();
            if (tileSizeX == 0)
                tileSizeX = 1920;
            if (tileSizeY == 0)
                tileSizeY = 1080;
            progressValue = 0;
            progFile = file;
            BioImage b = new BioImage(file);
            b.Type = ImageType.stack;
            b.Loading = true;
            if (b.meta == null)
                b.meta = service.createOMEXMLMetadata();
            string f = file.Replace("\\", "/");
            string cf = reader.getCurrentFile();
            if (cf != null)
                cf = cf.Replace("\\", "/");
            if (cf != f)
            {
                reader.close();
                reader.setMetadataStore(b.meta);
                try
                {
                    reader.setId(f);
                }
                catch (Exception e)
                {
                    Console.WriteLine(e.Message);
                    return null;
                }
 
                pr.Status = "Reading Metadata";
            }
 
            //status = "Reading OME Metadata.";
            reader.setSeries(serie);
            int RGBChannelCount = reader.getRGBChannelCount();
            //OME reader.getBitsPerPixel(); sometimes returns incorrect bits per pixel, like when opening ImageJ images.
            //So we check the pixel type from xml metadata and if it fails we use the readers value.
            PixelFormat PixelFormat;
            try
            {
                PixelFormat = GetPixelFormat(RGBChannelCount, b.meta.getPixelsType(serie));
            }
            catch (Exception)
            {
                PixelFormat = GetPixelFormat(RGBChannelCount, reader.getBitsPerPixel());
            }
 
            b.id = file;
            b.file = file;
            int SizeX, SizeY;
            SizeX = reader.getSizeX();
            SizeY = reader.getSizeY();
            int SizeZ = reader.getSizeZ();
            b.sizeC = reader.getSizeC();
            b.sizeZ = reader.getSizeZ();
            b.sizeT = reader.getSizeT();
            b.littleEndian = reader.isLittleEndian();
            b.seriesCount = reader.getSeriesCount();
            b.imagesPerSeries = reader.getImageCount();
            b.bitsPerPixel = reader.getBitsPerPixel();
            b.series = serie;
            string order = reader.getDimensionOrder();
 
            //Lets get the channels and initialize them
            int i = 0;
            pr.Status = "Reading Channels";
            int sumSamples = 0;
            while (true)
            {
                Channel ch = new Channel(i, b.bitsPerPixel, 1);
                bool def = false;
                try
                {
                    if (b.meta.getChannelSamplesPerPixel(serie, i) != null)
                    {
                        int s = b.meta.getChannelSamplesPerPixel(serie, i).getNumberValue().intValue();
                        ch.SamplesPerPixel = s;
                        sumSamples += s;
                        def = true;
                    }
                    if (b.meta.getChannelName(serie, i) != null)
                        ch.Name = b.meta.getChannelName(serie, i);
                    if (b.meta.getChannelAcquisitionMode(serie, i) != null)
                        ch.AcquisitionMode = b.meta.getChannelAcquisitionMode(serie, i).ToString();
                    if (b.meta.getChannelID(serie, i) != null)
                        ch.info.ID = b.meta.getChannelID(serie, i);
                    if (b.meta.getChannelFluor(serie, i) != null)
                        ch.Fluor = b.meta.getChannelFluor(serie, i);
                    if (b.meta.getChannelColor(serie, i) != null)
                    {
                        ome.xml.model.primitives.Color cc = b.meta.getChannelColor(serie, i);
                        ch.Color = Color.FromArgb(cc.getRed(), cc.getGreen(), cc.getBlue());
                    }
                    if (b.meta.getChannelIlluminationType(serie, i) != null)
                        ch.IlluminationType = b.meta.getChannelIlluminationType(serie, i).ToString();
                    if (b.meta.getChannelContrastMethod(serie, i) != null)
                        ch.ContrastMethod = b.meta.getChannelContrastMethod(serie, i).ToString();
                    if (b.meta.getChannelEmissionWavelength(serie, i) != null)
                        ch.Emission = b.meta.getChannelEmissionWavelength(serie, i).value().intValue();
                    if (b.meta.getChannelExcitationWavelength(serie, i) != null)
                        ch.Excitation = b.meta.getChannelExcitationWavelength(serie, i).value().intValue();
                    if (b.meta.getLightEmittingDiodePower(serie, i) != null)
                        ch.LightSourceIntensity = b.meta.getLightEmittingDiodePower(serie, i).value().doubleValue();
                    if (b.meta.getLightEmittingDiodeID(serie, i) != null)
                        ch.DiodeName = b.meta.getLightEmittingDiodeID(serie, i);
                    if (b.meta.getChannelLightSourceSettingsAttenuation(serie, i) != null)
                        ch.LightSourceAttenuation = b.meta.getChannelLightSourceSettingsAttenuation(serie, i).toString();
 
                }
                catch (Exception e)
                {
                    Console.WriteLine(e.Message);
                }
                //If this channel is not defined we have loaded all the channels in the file.
                if (!def)
                    break;
                else
                    b.Channels.Add(ch);
                if (i == 0)
                {
                    b.rgbChannels[0] = 0;
                }
                else
                if (i == 1)
                {
                    b.rgbChannels[1] = 1;
                }
                else
                if (i == 2)
                {
                    b.rgbChannels[2] = 2;
                }
                i++;
            }
            //If the file doens't have channels we initialize them.
            if (b.Channels.Count == 0)
            {
                b.Channels.Add(new Channel(0, b.bitsPerPixel, RGBChannelCount));
            }
 
            //Bioformats gives a size of 3 for C when saved in ImageJ as RGB. We need to correct for this as C should be 1 for RGB.
            if (RGBChannelCount >= 3)
            {
                b.sizeC = sumSamples / b.Channels[0].SamplesPerPixel;
            }
            b.Coords = new int[b.SizeZ, b.SizeC, b.SizeT];
 
            int resc = reader.getResolutionCount();
 
            try
            {
                int wells = b.meta.getWellCount(0);
                if (wells > 0)
                {
                    b.Type = ImageType.well;
                    b.Plate = new WellPlate(b);
                    tile = false;
                }
            }
            catch (Exception)
            {
 
            }
            List<Resolution> rss = new List<Resolution>();
            for (int s = 0; s < b.seriesCount; s++)
            {
                reader.setSeries(s);
                for (int r = 0; r < reader.getResolutionCount(); r++)
                {
                    Resolution res = new Resolution();
                    try
                    {
                        int rgbc = reader.getRGBChannelCount();
                        int bps = reader.getBitsPerPixel();
                        PixelFormat px;
                        try
                        {
                            px = GetPixelFormat(rgbc, b.meta.getPixelsType(r));
                        }
                        catch (Exception)
                        {
                            px = GetPixelFormat(rgbc, bps);
                        }
                        res.PixelFormat = px;
                        res.SizeX = reader.getSizeX();
                        res.SizeY = reader.getSizeY();
                        if (b.meta.getPixelsPhysicalSizeX(r) != null)
                        {
                            res.PhysicalSizeX = b.meta.getPixelsPhysicalSizeX(r).value().doubleValue();
                        }
                        else
                            res.PhysicalSizeX = (96 / 2.54) / 1000;
                        if (b.meta.getPixelsPhysicalSizeY(r) != null)
                        {
                            res.PhysicalSizeY = b.meta.getPixelsPhysicalSizeY(r).value().doubleValue();
                        }
                        else
                            res.PhysicalSizeY = (96 / 2.54) / 1000;
 
                        if (b.meta.getStageLabelX(r) != null)
                            res.StageSizeX = b.meta.getStageLabelX(r).value().doubleValue();
                        if (b.meta.getStageLabelY(r) != null)
                            res.StageSizeY = b.meta.getStageLabelY(r).value().doubleValue();
                        if (b.meta.getStageLabelZ(r) != null)
                            res.StageSizeZ = b.meta.getStageLabelZ(r).value().doubleValue();
                        else
                            res.StageSizeZ = 1;
                        if (b.meta.getPixelsPhysicalSizeZ(r) != null)
                        {
                            res.PhysicalSizeZ = b.meta.getPixelsPhysicalSizeZ(r).value().doubleValue();
                        }
                        else
                        {
                            res.PhysicalSizeZ = 1;
                        }
                    }
                    catch (Exception e)
                    {
                        Console.WriteLine("No Stage Coordinates. PhysicalSize:(" + res.PhysicalSizeX + "," + res.PhysicalSizeY + "," + res.PhysicalSizeZ + ")");
                    }
                    rss.Add(res);
                }
            }
            reader.setSeries(serie);
 
            int pyramidCount = 0;
            int pyramidResolutions = 0;
            List<Tuple<int, int>> prs = new List<Tuple<int, int>>();
            //We need to determine if this image is pyramidal or not.
            //We do this by seeing if the resolutions are downsampled or not.
            if (rss.Count > 1 && b.Type != ImageType.well)
            {
                if (rss[0].SizeX > rss[1].SizeX)
                {
                    b.Type = ImageType.pyramidal;
                    tile = true;
                    //We need to determine number of pyramids in this image and which belong to the series we are opening.
                    int? sr = null;
                    for (int r = 0; r < rss.Count - 1; r++)
                    {
                        if (rss[r].SizeX > rss[r + 1].SizeX && rss[r].PixelFormat == rss[r + 1].PixelFormat)
                        {
                            if (sr == null)
                            {
                                sr = r;
                                prs.Add(new Tuple<int, int>(r, 0));
                            }
                        }
                        else
                        {
                            if (rss[prs[prs.Count - 1].Item1].PixelFormat == rss[r].PixelFormat)
                                prs[prs.Count - 1] = new Tuple<int, int>(prs[prs.Count - 1].Item1, r);
                            sr = null;
                        }
                    }
                    pyramidCount = prs.Count;
                    for (int p = 0; p < prs.Count; p++)
                    {
                        pyramidResolutions += (prs[p].Item2 - prs[p].Item1) + 1;
                    }
 
                    if (prs[serie].Item2 == 0)
                    {
                        prs[serie] = new Tuple<int, int>(prs[serie].Item1, rss.Count);
                    }
                    for (int r = prs[serie].Item1; r < prs[serie].Item2; r++)
                    {
                        b.Resolutions.Add(rss[r]);
                    }
                }
                else
                {
                    b.Resolutions.AddRange(rss);
                }
            }
            else
                b.Resolutions.AddRange(rss);
 
            //If we have 2 resolutions that we're not added they are the label & macro resolutions so we add them to the image.
            if (rss.Count - pyramidResolutions == 2)
            {
                b.Resolutions.Add(rss[rss.Count - 2]);
                b.Resolutions.Add(rss[rss.Count - 1]);
            }
 
            b.Volume = new VolumeD(new Point3D(b.StageSizeX, b.StageSizeY, b.StageSizeZ), new Point3D(b.PhysicalSizeX * SizeX, b.PhysicalSizeY * SizeY, b.PhysicalSizeZ * SizeZ));
            pr.Status = "Reading ROIs";
            int rc = b.meta.getROICount();
            for (int im = 0; im < rc; im++)
            {
                string roiID = b.meta.getROIID(im);
                string roiName = b.meta.getROIName(im);
                ZCT co = new ZCT(0, 0, 0);
                int scount = 1;
                try
                {
                    scount = b.meta.getShapeCount(im);
                }
                catch (Exception e)
                {
                    Console.WriteLine(e.Message.ToString());
                }
                for (int sc = 0; sc < scount; sc++)
                {
                    string type = b.meta.getShapeType(im, sc);
                    ROI an = new ROI();
                    an.roiID = roiID;
                    an.roiName = roiName;
                    an.shapeIndex = sc;
                    if (type == "Point")
                    {
                        an.type = ROI.Type.Point;
                        an.id = b.meta.getPointID(im, sc);
                        double dx = b.meta.getPointX(im, sc).doubleValue();
                        double dy = b.meta.getPointY(im, sc).doubleValue();
                        an.AddPoint(b.ToStageSpace(new PointD(dx, dy)));
                        an.coord = new ZCT();
                        ome.xml.model.primitives.NonNegativeInteger nz = b.meta.getPointTheZ(im, sc);
                        if (nz != null)
                            an.coord.Z = nz.getNumberValue().intValue();
                        ome.xml.model.primitives.NonNegativeInteger nc = b.meta.getPointTheC(im, sc);
                        if (nc != null)
                            an.coord.C = nc.getNumberValue().intValue();
                        ome.xml.model.primitives.NonNegativeInteger nt = b.meta.getPointTheT(im, sc);
                        if (nt != null)
                            an.coord.T = nt.getNumberValue().intValue();
                        an.Text = b.meta.getPointText(im, sc);
                        ome.units.quantity.Length fl = b.meta.getPointFontSize(im, sc);
                        if (fl != null)
                            an.fontSize = fl.value().intValue();
                        ome.xml.model.enums.FontFamily ff = b.meta.getPointFontFamily(im, sc);
                        if (ff != null)
                            an.family = ff.name();
                        ome.xml.model.primitives.Color col = b.meta.getPointStrokeColor(im, sc);
                        if (col != null)
                            an.strokeColor = System.Drawing.Color.FromArgb(col.getAlpha(), col.getRed(), col.getGreen(), col.getBlue());
                        ome.units.quantity.Length fw = b.meta.getPointStrokeWidth(im, sc);
                        if (fw != null)
                            an.strokeWidth = (float)fw.value().floatValue();
                        ome.xml.model.primitives.Color colf = b.meta.getPointStrokeColor(im, sc);
                        if (colf != null)
                            an.fillColor = System.Drawing.Color.FromArgb(colf.getAlpha(), colf.getRed(), colf.getGreen(), colf.getBlue());
                    }
                    else
                    if (type == "Line")
                    {
                        an.type = ROI.Type.Line;
                        an.id = b.meta.getLineID(im, sc);
                        double px1 = b.meta.getLineX1(im, sc).doubleValue();
                        double py1 = b.meta.getLineY1(im, sc).doubleValue();
                        double px2 = b.meta.getLineX2(im, sc).doubleValue();
                        double py2 = b.meta.getLineY2(im, sc).doubleValue();
                        an.AddPoint(b.ToStageSpace(new PointD(px1, py1)));
                        an.AddPoint(b.ToStageSpace(new PointD(px2, py2)));
                        ome.xml.model.primitives.NonNegativeInteger nz = b.meta.getLineTheZ(im, sc);
                        if (nz != null)
                            co.Z = nz.getNumberValue().intValue();
                        ome.xml.model.primitives.NonNegativeInteger nc = b.meta.getLineTheC(im, sc);
                        if (nc != null)
                            co.C = nc.getNumberValue().intValue();
                        ome.xml.model.primitives.NonNegativeInteger nt = b.meta.getLineTheT(im, sc);
                        if (nt != null)
                            co.T = nt.getNumberValue().intValue();
                        an.coord = co;
                        an.Text = b.meta.getLineText(im, sc);
                        ome.units.quantity.Length fl = b.meta.getLineFontSize(im, sc);
                        if (fl != null)
                            an.fontSize = fl.value().intValue();
                        ome.xml.model.enums.FontFamily ff = b.meta.getLineFontFamily(im, sc);
                        if (ff != null)
                            an.family = ff.name();
                        ome.xml.model.primitives.Color col = b.meta.getLineStrokeColor(im, sc);
                        if (col != null)
                            an.strokeColor = System.Drawing.Color.FromArgb(col.getAlpha(), col.getRed(), col.getGreen(), col.getBlue());
                        ome.units.quantity.Length fw = b.meta.getLineStrokeWidth(im, sc);
                        if (fw != null)
                            an.strokeWidth = (float)fw.value().floatValue();
                        ome.xml.model.primitives.Color colf = b.meta.getLineFillColor(im, sc);
                        if (colf != null)
                            an.fillColor = System.Drawing.Color.FromArgb(colf.getAlpha(), colf.getRed(), colf.getGreen(), colf.getBlue());
                    }
                    else
                    if (type == "Rectangle")
                    {
                        an.type = ROI.Type.Rectangle;
                        an.id = b.meta.getRectangleID(im, sc);
                        double px = b.meta.getRectangleX(im, sc).doubleValue();
                        double py = b.meta.getRectangleY(im, sc).doubleValue();
                        double pw = b.meta.getRectangleWidth(im, sc).doubleValue();
                        double ph = b.meta.getRectangleHeight(im, sc).doubleValue();
                        an.Rect = b.ToStageSpace(new RectangleD(px, py, pw, ph));
                        ome.xml.model.primitives.NonNegativeInteger nz = b.meta.getRectangleTheZ(im, sc);
                        if (nz != null)
                            co.Z = nz.getNumberValue().intValue();
                        ome.xml.model.primitives.NonNegativeInteger nc = b.meta.getRectangleTheC(im, sc);
                        if (nc != null)
                            co.C = nc.getNumberValue().intValue();
                        ome.xml.model.primitives.NonNegativeInteger nt = b.meta.getRectangleTheT(im, sc);
                        if (nt != null)
                            co.T = nt.getNumberValue().intValue();
                        an.coord = co;
 
                        an.Text = b.meta.getRectangleText(im, sc);
                        ome.units.quantity.Length fl = b.meta.getRectangleFontSize(im, sc);
                        if (fl != null)
                            an.fontSize = fl.value().intValue();
                        ome.xml.model.enums.FontFamily ff = b.meta.getRectangleFontFamily(im, sc);
                        if (ff != null)
                            an.family = ff.name();
                        ome.xml.model.primitives.Color col = b.meta.getRectangleStrokeColor(im, sc);
                        if (col != null)
                            an.strokeColor = System.Drawing.Color.FromArgb(col.getAlpha(), col.getRed(), col.getGreen(), col.getBlue());
                        ome.units.quantity.Length fw = b.meta.getRectangleStrokeWidth(im, sc);
                        if (fw != null)
                            an.strokeWidth = (float)fw.value().floatValue();
                        ome.xml.model.primitives.Color colf = b.meta.getRectangleFillColor(im, sc);
                        if (colf != null)
                            an.fillColor = System.Drawing.Color.FromArgb(colf.getAlpha(), colf.getRed(), colf.getGreen(), colf.getBlue());
                        ome.xml.model.enums.FillRule fr = b.meta.getRectangleFillRule(im, sc);
                    }
                    else
                    if (type == "Ellipse")
                    {
                        an.type = ROI.Type.Ellipse;
                        an.id = b.meta.getEllipseID(im, sc);
                        double px = b.meta.getEllipseX(im, sc).doubleValue();
                        double py = b.meta.getEllipseY(im, sc).doubleValue();
                        double ew = b.meta.getEllipseRadiusX(im, sc).doubleValue();
                        double eh = b.meta.getEllipseRadiusY(im, sc).doubleValue();
                        //We convert the ellipse radius to Rectangle
                        double w = ew * 2;
                        double h = eh * 2;
                        double x = px - ew;
                        double y = py - eh;
                        an.Rect = b.ToStageSpace(new RectangleD(x, y, w, h));
                        ome.xml.model.primitives.NonNegativeInteger nz = b.meta.getEllipseTheZ(im, sc);
                        if (nz != null)
                            co.Z = nz.getNumberValue().intValue();
                        ome.xml.model.primitives.NonNegativeInteger nc = b.meta.getEllipseTheC(im, sc);
                        if (nc != null)
                            co.C = nc.getNumberValue().intValue();
                        ome.xml.model.primitives.NonNegativeInteger nt = b.meta.getEllipseTheT(im, sc);
                        if (nt != null)
                            co.T = nt.getNumberValue().intValue();
                        an.coord = co;
                        an.Text = b.meta.getEllipseText(im, sc);
                        ome.units.quantity.Length fl = b.meta.getEllipseFontSize(im, sc);
                        if (fl != null)
                            an.fontSize = fl.value().intValue();
                        ome.xml.model.enums.FontFamily ff = b.meta.getEllipseFontFamily(im, sc);
                        if (ff != null)
                            an.family = ff.name();
                        ome.xml.model.primitives.Color col = b.meta.getEllipseStrokeColor(im, sc);
                        if (col != null)
                            an.strokeColor = System.Drawing.Color.FromArgb(col.getAlpha(), col.getRed(), col.getGreen(), col.getBlue());
                        ome.units.quantity.Length fw = b.meta.getEllipseStrokeWidth(im, sc);
                        if (fw != null)
                            an.strokeWidth = (float)fw.value().floatValue();
                        ome.xml.model.primitives.Color colf = b.meta.getEllipseFillColor(im, sc);
                        if (colf != null)
                            an.fillColor = System.Drawing.Color.FromArgb(colf.getAlpha(), colf.getRed(), colf.getGreen(), colf.getBlue());
                    }
                    else
                    if (type == "Polygon")
                    {
                        an.type = ROI.Type.Polygon;
                        an.id = b.meta.getPolygonID(im, sc);
                        an.closed = true;
                        string pxs = b.meta.getPolygonPoints(im, sc);
                        PointD[] pts = an.stringToPoints(pxs);
                        pts = b.ToStageSpace(pts);
                        if (pts.Length > 100)
                        {
                            an.type = ROI.Type.Freeform;
                        }
                        an.AddPoints(pts);
                        ome.xml.model.primitives.NonNegativeInteger nz = b.meta.getPolygonTheZ(im, sc);
                        if (nz != null)
                            co.Z = nz.getNumberValue().intValue();
                        ome.xml.model.primitives.NonNegativeInteger nc = b.meta.getPolygonTheC(im, sc);
                        if (nc != null)
                            co.C = nc.getNumberValue().intValue();
                        ome.xml.model.primitives.NonNegativeInteger nt = b.meta.getPolygonTheT(im, sc);
                        if (nt != null)
                            co.T = nt.getNumberValue().intValue();
                        an.coord = co;
                        an.Text = b.meta.getPolygonText(im, sc);
                        ome.units.quantity.Length fl = b.meta.getPolygonFontSize(im, sc);
                        if (fl != null)
                            an.fontSize = fl.value().intValue();
                        ome.xml.model.enums.FontFamily ff = b.meta.getPolygonFontFamily(im, sc);
                        if (ff != null)
                            an.family = ff.name();
                        ome.xml.model.primitives.Color col = b.meta.getPolygonStrokeColor(im, sc);
                        if (col != null)
                            an.strokeColor = System.Drawing.Color.FromArgb(col.getAlpha(), col.getRed(), col.getGreen(), col.getBlue());
                        ome.units.quantity.Length fw = b.meta.getPolygonStrokeWidth(im, sc);
                        if (fw != null)
                            an.strokeWidth = (float)fw.value().floatValue();
                        ome.xml.model.primitives.Color colf = b.meta.getPolygonFillColor(im, sc);
                        if (colf != null)
                            an.fillColor = System.Drawing.Color.FromArgb(colf.getAlpha(), colf.getRed(), colf.getGreen(), colf.getBlue());
                    }
                    else
                    if (type == "Polyline")
                    {
                        an.type = ROI.Type.Polyline;
                        an.id = b.meta.getPolylineID(im, sc);
                        string pxs = b.meta.getPolylinePoints(im, sc);
                        PointD[] pts = an.stringToPoints(pxs);
                        for (int pi = 0; pi < pts.Length; pi++)
                        {
                            pts[pi] = b.ToStageSpace(pts[pi]);
                        }
                        an.AddPoints(an.stringToPoints(pxs));
                        ome.xml.model.primitives.NonNegativeInteger nz = b.meta.getPolylineTheZ(im, sc);
                        if (nz != null)
                            co.Z = nz.getNumberValue().intValue();
                        ome.xml.model.primitives.NonNegativeInteger nc = b.meta.getPolylineTheC(im, sc);
                        if (nc != null)
                            co.C = nc.getNumberValue().intValue();
                        ome.xml.model.primitives.NonNegativeInteger nt = b.meta.getPolylineTheT(im, sc);
                        if (nt != null)
                            co.T = nt.getNumberValue().intValue();
                        an.coord = co;
                        an.Text = b.meta.getPolylineText(im, sc);
                        ome.units.quantity.Length fl = b.meta.getPolylineFontSize(im, sc);
                        if (fl != null)
                            an.fontSize = fl.value().intValue();
                        ome.xml.model.enums.FontFamily ff = b.meta.getPolylineFontFamily(im, sc);
                        if (ff != null)
                            an.family = ff.name();
                        ome.xml.model.primitives.Color col = b.meta.getPolylineStrokeColor(im, sc);
                        if (col != null)
                            an.strokeColor = System.Drawing.Color.FromArgb(col.getAlpha(), col.getRed(), col.getGreen(), col.getBlue());
                        ome.units.quantity.Length fw = b.meta.getPolylineStrokeWidth(im, sc);
                        if (fw != null)
                            an.strokeWidth = (float)fw.value().floatValue();
                        ome.xml.model.primitives.Color colf = b.meta.getPolylineFillColor(im, sc);
                        if (colf != null)
                            an.fillColor = System.Drawing.Color.FromArgb(colf.getAlpha(), colf.getRed(), colf.getGreen(), colf.getBlue());
                    }
                    else
                    if (type == "Label")
                    {
                        an.type = ROI.Type.Label;
                        an.id = b.meta.getLabelID(im, sc);
 
                        ome.xml.model.primitives.NonNegativeInteger nz = b.meta.getLabelTheZ(im, sc);
                        if (nz != null)
                            co.Z = nz.getNumberValue().intValue();
                        ome.xml.model.primitives.NonNegativeInteger nc = b.meta.getLabelTheC(im, sc);
                        if (nc != null)
                            co.C = nc.getNumberValue().intValue();
                        ome.xml.model.primitives.NonNegativeInteger nt = b.meta.getLabelTheT(im, sc);
                        if (nt != null)
                            co.T = nt.getNumberValue().intValue();
                        an.coord = co;
 
                        ome.units.quantity.Length fl = b.meta.getLabelFontSize(im, sc);
                        if (fl != null)
                            an.fontSize = fl.value().intValue();
                        ome.xml.model.enums.FontFamily ff = b.meta.getLabelFontFamily(im, sc);
                        if (ff != null)
                            an.family = ff.name();
                        ome.xml.model.primitives.Color col = b.meta.getLabelStrokeColor(im, sc);
                        if (col != null)
                            an.strokeColor = System.Drawing.Color.FromArgb(col.getAlpha(), col.getRed(), col.getGreen(), col.getBlue());
                        ome.units.quantity.Length fw = b.meta.getLabelStrokeWidth(im, sc);
                        if (fw != null)
                            an.strokeWidth = (float)fw.value().floatValue();
                        ome.xml.model.primitives.Color colf = b.meta.getLabelFillColor(im, sc);
                        if (colf != null)
                            an.fillColor = System.Drawing.Color.FromArgb(colf.getAlpha(), colf.getRed(), colf.getGreen(), colf.getBlue());
                        PointD p = new PointD(b.meta.getLabelX(im, sc).doubleValue(), b.meta.getLabelY(im, sc).doubleValue());
                        an.AddPoint(b.ToStageSpace(p));
                        an.Text = b.meta.getLabelText(im, sc);
                    }
                    else
                    if (type == "Mask")
                    {
                        byte[] bts = b.meta.getMaskBinData(im, sc);
                        bool end = b.meta.getMaskBinDataBigEndian(im, sc).booleanValue();
                        an = ROI.CreateMask(co, bts, b.Resolutions[0].SizeX, b.Resolutions[0].SizeY, new PointD(b.StageSizeX, b.StageSizeY), b.PhysicalSizeX, b.PhysicalSizeY);
                        an.Text = b.meta.getMaskText(im, sc);
                        an.id = b.meta.getMaskID(im, sc);
                        ome.xml.model.primitives.NonNegativeInteger nz = b.meta.getMaskTheZ(im, sc);
                        if (nz != null)
                            co.Z = nz.getNumberValue().intValue();
                        ome.xml.model.primitives.NonNegativeInteger nc = b.meta.getMaskTheC(im, sc);
                        if (nc != null)
                            co.C = nc.getNumberValue().intValue();
                        ome.xml.model.primitives.NonNegativeInteger nt = b.meta.getMaskTheT(im, sc);
                        if (nt != null)
                            co.T = nt.getNumberValue().intValue();
                        an.coord = co;
 
                        ome.units.quantity.Length fl = b.meta.getMaskFontSize(im, sc);
                        if (fl != null)
                            an.fontSize = fl.value().intValue();
                        ome.xml.model.enums.FontFamily ff = b.meta.getMaskFontFamily(im, sc);
                        if (ff != null)
                            an.family = ff.name();
                        ome.xml.model.primitives.Color col = b.meta.getMaskStrokeColor(im, sc);
                        if (col != null)
                            an.strokeColor = System.Drawing.Color.FromArgb(col.getAlpha(), col.getRed(), col.getGreen(), col.getBlue());
                        ome.units.quantity.Length fw = b.meta.getMaskStrokeWidth(im, sc);
                        if (fw != null)
                            an.strokeWidth = (float)fw.value().floatValue();
                        ome.xml.model.primitives.Color colf = b.meta.getMaskFillColor(im, sc);
                        if (colf != null)
                            an.fillColor = System.Drawing.Color.FromArgb(colf.getAlpha(), colf.getRed(), colf.getGreen(), colf.getBlue());
                    }
                    b.Annotations.Add(an);
                }
            }
 
            List<string> serFiles = new List<string>();
            serFiles.AddRange(reader.getSeriesUsedFiles());
 
            b.Buffers = new List<Bitmap>();
            if (b.Type == ImageType.pyramidal)
                try
                {
                    string st = OpenSlideImage.DetectVendor(file);
                    if (st != null && !file.EndsWith("ome.tif") && useOpenSlide)
                    {
                        b.openSlideImage = OpenSlideImage.Open(file);
                        b.openSlideBase = (OpenSlideBase)OpenSlideGTK.SlideSourceBase.Create(file);
                    }
                    else
                    {
                        b.slideBase = new SlideBase(b, SlideImage.Open(b));
                        b.slideImage = b.slideBase.SlideImage;
                    }
                }
                catch (Exception e)
                {
                    Console.WriteLine(e.Message.ToString());
                    b.slideBase = new SlideBase(b, SlideImage.Open(b));
                    b.slideImage = b.slideBase.SlideImage;
                }
 
            // read the image data bytes
            int pages = reader.getImageCount();
            bool inter = reader.isInterleaved();
            int z = 0;
            int c = 0;
            int t = 0;
            pr.Status = "Reading Image Data";
            if (!tile)
            {
                try
                {
                    for (int p = 0; p < pages; p++)
                    {
                        Bitmap bf;
                        pr.ProgressValue = (float)p / (float)pages;
                        byte[] bytes = reader.openBytes(p);
                        bf = new Bitmap(file, SizeX, SizeY, PixelFormat, bytes, new ZCT(z, c, t), p, null, b.littleEndian, inter);
                        b.Buffers.Add(bf);
                    }
                }
                catch (Exception)
                {
                    //If we failed to read an entire plane it is likely too large so we open as pyramidal.
                    b.Type = ImageType.pyramidal;
                    try
                    {
                        string st = OpenSlideImage.DetectVendor(file);
                        if (st != null && !file.EndsWith("ome.tif") && useOpenSlide)
                        {
                            b.openSlideImage = OpenSlideImage.Open(file);
                            b.openSlideBase = (OpenSlideBase)OpenSlideGTK.SlideSourceBase.Create(file);
                        }
                        else
                        {
                            b.slideBase = new SlideBase(b, SlideImage.Open(b));
                            b.slideImage = b.slideBase.SlideImage;
                        }
                    }
                    catch (Exception e)
                    {
                        Console.WriteLine(e.Message.ToString());
                        b.slideBase = new SlideBase(b, SlideImage.Open(b));
                        b.slideImage = b.slideBase.SlideImage;
                    }
                    b.imRead = reader;
                    for (int p = 0; p < pages; p++)
                    {
                        b.Buffers.Add(GetTile(b, p, serie, tilex, tiley, tileSizeX, tileSizeY));
                        Statistics.CalcStatistics(b.Buffers.Last());
                    }
                }
 
            }
            else
            {
                b.imRead = reader;
                for (int p = 0; p < pages; p++)
                {
                    b.Buffers.Add(GetTile(b, p, serie, tilex, tiley, tileSizeX, tileSizeY));
                    Statistics.CalcStatistics(b.Buffers.Last());
                }
            }
            int pls;
            try
            {
                pls = b.meta.getPlaneCount(serie);
            }
            catch (Exception)
            {
                pls = 0;
            }
            pr.Status = "Reading Plane Data";
            if (pls == b.Buffers.Count)
                for (int bi = 0; bi < b.Buffers.Count; bi++)
                {
                    Plane pl = new Plane();
                    pl.Coordinate = new ZCT();
                    double px = 0; double py = 0; double pz = 0;
                    if (b.meta.getPlanePositionX(serie, bi) != null)
                        px = b.meta.getPlanePositionX(serie, bi).value().doubleValue();
                    if (b.meta.getPlanePositionY(serie, bi) != null)
                        py = b.meta.getPlanePositionY(serie, bi).value().doubleValue();
                    if (b.meta.getPlanePositionZ(serie, bi) != null)
                        pz = b.meta.getPlanePositionZ(serie, bi).value().doubleValue();
                    pl.Location = new AForge.Point3D(px, py, pz);
                    int cc = 0; int zc = 0; int tc = 0;
                    if (b.meta.getPlaneTheC(serie, bi) != null)
                        cc = b.meta.getPlaneTheC(serie, bi).getNumberValue().intValue();
                    if (b.meta.getPlaneTheZ(serie, bi) != null)
                        zc = b.meta.getPlaneTheZ(serie, bi).getNumberValue().intValue();
                    if (b.meta.getPlaneTheT(serie, bi) != null)
                        tc = b.meta.getPlaneTheT(serie, bi).getNumberValue().intValue();
                    pl.Coordinate = new ZCT(zc, cc, tc);
                    if (b.meta.getPlaneDeltaT(serie, bi) != null)
                        pl.Delta = b.meta.getPlaneDeltaT(serie, bi).value().doubleValue();
                    if (b.meta.getPlaneExposureTime(serie, bi) != null)
                        pl.Exposure = b.meta.getPlaneExposureTime(serie, bi).value().doubleValue();
                    b.Buffers[bi].Plane = pl;
                }
 
            b.UpdateCoords(b.SizeZ, b.SizeC, b.SizeT, order);
            //We wait for histogram image statistics calculation
            do
            {
                Thread.Sleep(50);
            } while (b.Buffers[b.Buffers.Count - 1].Stats == null);
            b.SetLabelMacroResolutions();
            Statistics.ClearCalcBuffer();
            AutoThreshold(b, true);
            if (b.bitsPerPixel > 8)
                b.StackThreshold(true);
            else
                b.StackThreshold(false);
            if (!tile)
            {
                //We use a try block to close the reader as sometimes this will cause an error.
                bool stop = false;
                do
                {
                    try
                    {
                        reader.close();
                        stop = true;
                    }
                    catch (Exception e)
                    {
                        Console.WriteLine(e.Message);
                    }
                } while (!stop);
            }
            if (addToImages)
                Images.AddImage(b, tab);
            b.Loading = false;
            pr.Hide();
            Console.WriteLine("Opening complete " + file);
            return b;
        }

References BioImager.ROI.AddPoint(), BioImager.ROI.AddPoints(), BioImager.BioImage.AutoThreshold(), BioImager.BioImage.GetPixelFormat(), BioImager.BioImage.GetTile(), BioImager.SlideImage.Open(), BioImager.BioImage.StackThreshold(), BioImager.ROI.stringToPoints(), BioImager.BioImage.ToStageSpace(), and BioImager.BioImage.UpdateCoords().

◆ OpenOMEROIs()

static List< ROI > BioImager.BioImage.OpenOMEROIs	(	string	file,
		int	series
	)

static

It reads the OME-XML file and converts the ROIs to a list of ROI objects

Parameters

file	the path to the OME-TIFF file
series	the series number of the image you want to open

Returns: A list of ROI objects.

Definition at line 7347 of file Bio.cs.

        {
            if (!OMESupport())
                return null;
            List<ROI> Annotations = new List<ROI>();
            // create OME-XML metadata store
            ServiceFactory factory = new ServiceFactory();
            OMEXMLService service = (OMEXMLService)factory.getInstance(typeof(OMEXMLService));
            loci.formats.ome.OMEXMLMetadata meta = service.createOMEXMLMetadata();
            // create format reader
            ImageReader imageReader = new ImageReader();
            imageReader.setMetadataStore(meta);
            // initialize file
            file = file.Replace("\\", "/");
            imageReader.setId(file);
            int imageCount = imageReader.getImageCount();
            int seriesCount = imageReader.getSeriesCount();
            double physicalSizeX = 0;
            double physicalSizeY = 0;
            double physicalSizeZ = 0;
            double stageSizeX = 0;
            double stageSizeY = 0;
            double stageSizeZ = 0;
            int SizeX = imageReader.getSizeX();
            int SizeY = imageReader.getSizeY();
            int SizeZ = imageReader.getSizeY();
            try
            {
                bool hasPhysical = false;
                if (meta.getPixelsPhysicalSizeX(series) != null)
                {
                    physicalSizeX = meta.getPixelsPhysicalSizeX(series).value().doubleValue();
                    hasPhysical = true;
                }
                if (meta.getPixelsPhysicalSizeY(series) != null)
                {
                    physicalSizeY = meta.getPixelsPhysicalSizeY(series).value().doubleValue();
                }
                if (meta.getPixelsPhysicalSizeZ(series) != null)
                {
                    physicalSizeZ = meta.getPixelsPhysicalSizeZ(series).value().doubleValue();
                }
                else
                {
                    physicalSizeZ = 1;
                }
                if (meta.getStageLabelX(series) != null)
                    stageSizeX = meta.getStageLabelX(series).value().doubleValue();
                if (meta.getStageLabelY(series) != null)
                    stageSizeY = meta.getStageLabelY(series).value().doubleValue();
                if (meta.getStageLabelZ(series) != null)
                    stageSizeZ = meta.getStageLabelZ(series).value().doubleValue();
                else
                    stageSizeZ = 1;
            }
            catch (Exception e)
            {
                stageSizeX = 0;
                stageSizeY = 0;
                stageSizeZ = 1;
            }
            VolumeD volume = new VolumeD(new Point3D(stageSizeX, stageSizeY, stageSizeZ), new Point3D(physicalSizeX * SizeX, physicalSizeY * SizeY, physicalSizeZ * SizeZ));
            int rc = meta.getROICount();
            for (int im = 0; im < rc; im++)
            {
                string roiID = meta.getROIID(im);
                string roiName = meta.getROIName(im);
                ZCT co = new ZCT(0, 0, 0);
                int scount = 1;
                try
                {
                    scount = meta.getShapeCount(im);
                }
                catch (Exception e)
                {
                    Console.WriteLine(e.Message.ToString());
                }
                for (int sc = 0; sc < scount; sc++)
                {
                    string type = meta.getShapeType(im, sc);
                    ROI an = new ROI();
                    an.roiID = roiID;
                    an.roiName = roiName;
                    an.shapeIndex = sc;
                    if (type == "Point")
                    {
                        an.type = ROI.Type.Point;
                        an.id = meta.getPointID(im, sc);
                        double dx = meta.getPointX(im, sc).doubleValue();
                        double dy = meta.getPointY(im, sc).doubleValue();
                        an.AddPoint(ToStageSpace(new PointD(dx, dy), physicalSizeX, physicalSizeY, volume.Location.X, volume.Location.Y));
                        an.coord = new ZCT();
                        ome.xml.model.primitives.NonNegativeInteger nz = meta.getPointTheZ(im, sc);
                        if (nz != null)
                            an.coord.Z = nz.getNumberValue().intValue();
                        ome.xml.model.primitives.NonNegativeInteger nc = meta.getPointTheC(im, sc);
                        if (nc != null)
                            an.coord.C = nc.getNumberValue().intValue();
                        ome.xml.model.primitives.NonNegativeInteger nt = meta.getPointTheT(im, sc);
                        if (nt != null)
                            an.coord.T = nt.getNumberValue().intValue();
                        an.Text = meta.getPointText(im, sc);
                        ome.units.quantity.Length fl = meta.getPointFontSize(im, sc);
                        if (fl != null)
                            an.fontSize = fl.value().intValue();
                        an.family = meta.getPointFontFamily(im, sc).name();
                        ome.xml.model.primitives.Color col = meta.getPointStrokeColor(im, sc);
                        if (col != null)
                            an.strokeColor = System.Drawing.Color.FromArgb(col.getAlpha(), col.getRed(), col.getGreen(), col.getBlue());
                        ome.units.quantity.Length fw = meta.getPointStrokeWidth(im, sc);
                        if (fw != null)
                            an.strokeWidth = (float)fw.value().floatValue();
                        ome.xml.model.primitives.Color colf = meta.getPointStrokeColor(im, sc);
                        if (colf != null)
                            an.fillColor = System.Drawing.Color.FromArgb(colf.getAlpha(), colf.getRed(), colf.getGreen(), colf.getBlue());
                    }
                    else
                    if (type == "Line")
                    {
                        an.type = ROI.Type.Line;
                        an.id = meta.getLineID(im, sc);
                        double px1 = meta.getLineX1(im, sc).doubleValue();
                        double py1 = meta.getLineY1(im, sc).doubleValue();
                        double px2 = meta.getLineX2(im, sc).doubleValue();
                        double py2 = meta.getLineY2(im, sc).doubleValue();
                        an.AddPoint(ToStageSpace(new PointD(px1, py1), physicalSizeX, physicalSizeY, volume.Location.X, volume.Location.Y));
                        an.AddPoint(ToStageSpace(new PointD(px2, py2), physicalSizeX, physicalSizeY, volume.Location.X, volume.Location.Y));
                        ome.xml.model.primitives.NonNegativeInteger nz = meta.getLineTheZ(im, sc);
                        if (nz != null)
                            co.Z = nz.getNumberValue().intValue();
                        ome.xml.model.primitives.NonNegativeInteger nc = meta.getLineTheC(im, sc);
                        if (nc != null)
                            co.C = nc.getNumberValue().intValue();
                        ome.xml.model.primitives.NonNegativeInteger nt = meta.getLineTheT(im, sc);
                        if (nt != null)
                            co.T = nt.getNumberValue().intValue();
                        an.coord = co;
                        an.Text = meta.getLineText(im, sc);
                        ome.units.quantity.Length fl = meta.getLineFontSize(im, sc);
                        if (fl != null)
                            an.fontSize = fl.value().intValue();
                        an.family = meta.getPointFontFamily(im, sc).name();
                        ome.xml.model.primitives.Color col = meta.getLineStrokeColor(im, sc);
                        if (col != null)
                            an.strokeColor = System.Drawing.Color.FromArgb(col.getAlpha(), col.getRed(), col.getGreen(), col.getBlue());
                        ome.units.quantity.Length fw = meta.getLineStrokeWidth(im, sc);
                        if (fw != null)
                            an.strokeWidth = (float)fw.value().floatValue();
                        ome.xml.model.primitives.Color colf = meta.getLineFillColor(im, sc);
                        if (colf != null)
                            an.fillColor = System.Drawing.Color.FromArgb(colf.getAlpha(), colf.getRed(), colf.getGreen(), colf.getBlue());
                    }
                    else
                    if (type == "Rectangle")
                    {
                        an.type = ROI.Type.Rectangle;
                        an.id = meta.getRectangleID(im, sc);
                        double px = meta.getRectangleX(im, sc).doubleValue();
                        double py = meta.getRectangleY(im, sc).doubleValue();
                        double pw = meta.getRectangleWidth(im, sc).doubleValue();
                        double ph = meta.getRectangleHeight(im, sc).doubleValue();
                        an.Rect = ToStageSpace(new RectangleD(px, py, pw, ph), physicalSizeX, physicalSizeY, volume.Location.X, volume.Location.Y);
                        ome.xml.model.primitives.NonNegativeInteger nz = meta.getRectangleTheZ(im, sc);
                        if (nz != null)
                            co.Z = nz.getNumberValue().intValue();
                        ome.xml.model.primitives.NonNegativeInteger nc = meta.getRectangleTheC(im, sc);
                        if (nc != null)
                            co.C = nc.getNumberValue().intValue();
                        ome.xml.model.primitives.NonNegativeInteger nt = meta.getRectangleTheT(im, sc);
                        if (nt != null)
                            co.T = nt.getNumberValue().intValue();
                        an.coord = co;
 
                        an.Text = meta.getRectangleText(im, sc);
                        ome.units.quantity.Length fl = meta.getRectangleFontSize(im, sc);
                        if (fl != null)
                            an.fontSize = fl.value().intValue();
                        an.family = meta.getPointFontFamily(im, sc).name();
                        ome.xml.model.primitives.Color col = meta.getRectangleStrokeColor(im, sc);
                        if (col != null)
                            an.strokeColor = System.Drawing.Color.FromArgb(col.getAlpha(), col.getRed(), col.getGreen(), col.getBlue());
                        ome.units.quantity.Length fw = meta.getRectangleStrokeWidth(im, sc);
                        if (fw != null)
                            an.strokeWidth = (float)fw.value().floatValue();
                        ome.xml.model.primitives.Color colf = meta.getRectangleFillColor(im, sc);
                        if (colf != null)
                            an.fillColor = System.Drawing.Color.FromArgb(colf.getAlpha(), colf.getRed(), colf.getGreen(), colf.getBlue());
                        ome.xml.model.enums.FillRule fr = meta.getRectangleFillRule(im, sc);
                    }
                    else
                    if (type == "Ellipse")
                    {
                        an.type = ROI.Type.Ellipse;
                        an.id = meta.getEllipseID(im, sc);
                        double px = meta.getEllipseX(im, sc).doubleValue();
                        double py = meta.getEllipseY(im, sc).doubleValue();
                        double ew = meta.getEllipseRadiusX(im, sc).doubleValue();
                        double eh = meta.getEllipseRadiusY(im, sc).doubleValue();
                        //We convert the ellipse radius to Rectangle
                        double w = ew * 2;
                        double h = eh * 2;
                        double x = px - ew;
                        double y = py - eh;
                        an.Rect = ToStageSpace(new RectangleD(px, py, w, h), physicalSizeX, physicalSizeY, volume.Location.X, volume.Location.Y);
                        ome.xml.model.primitives.NonNegativeInteger nz = meta.getEllipseTheZ(im, sc);
                        if (nz != null)
                            co.Z = nz.getNumberValue().intValue();
                        ome.xml.model.primitives.NonNegativeInteger nc = meta.getEllipseTheC(im, sc);
                        if (nc != null)
                            co.C = nc.getNumberValue().intValue();
                        ome.xml.model.primitives.NonNegativeInteger nt = meta.getEllipseTheT(im, sc);
                        if (nt != null)
                            co.T = nt.getNumberValue().intValue();
                        an.coord = co;
                        an.Text = meta.getEllipseText(im, sc);
                        ome.units.quantity.Length fl = meta.getEllipseFontSize(im, sc);
                        if (fl != null)
                            an.fontSize = fl.value().intValue();
                        an.family = meta.getPointFontFamily(im, sc).name();
                        ome.xml.model.primitives.Color col = meta.getEllipseStrokeColor(im, sc);
                        if (col != null)
                            an.strokeColor = System.Drawing.Color.FromArgb(col.getAlpha(), col.getRed(), col.getGreen(), col.getBlue());
                        ome.units.quantity.Length fw = meta.getEllipseStrokeWidth(im, sc);
                        if (fw != null)
                            an.strokeWidth = (float)fw.value().floatValue();
                        ome.xml.model.primitives.Color colf = meta.getEllipseFillColor(im, sc);
                        if (colf != null)
                            an.fillColor = System.Drawing.Color.FromArgb(colf.getAlpha(), colf.getRed(), colf.getGreen(), colf.getBlue());
                    }
                    else
                    if (type == "Polygon")
                    {
                        an.type = ROI.Type.Polygon;
                        an.id = meta.getPolygonID(im, sc);
                        an.closed = true;
                        string pxs = meta.getPolygonPoints(im, sc);
                        PointD[] pts = an.stringToPoints(pxs);
                        pts = ToStageSpace(pts, physicalSizeX, physicalSizeY, volume.Location.X, volume.Location.Y);
                        if (pts.Length > 100)
                        {
                            an.type = ROI.Type.Freeform;
                        }
                        an.AddPoints(pts);
                        ome.xml.model.primitives.NonNegativeInteger nz = meta.getPolygonTheZ(im, sc);
                        if (nz != null)
                            co.Z = nz.getNumberValue().intValue();
                        ome.xml.model.primitives.NonNegativeInteger nc = meta.getPolygonTheC(im, sc);
                        if (nc != null)
                            co.C = nc.getNumberValue().intValue();
                        ome.xml.model.primitives.NonNegativeInteger nt = meta.getPolygonTheT(im, sc);
                        if (nt != null)
                            co.T = nt.getNumberValue().intValue();
                        an.coord = co;
                        an.Text = meta.getPolygonText(im, sc);
                        ome.units.quantity.Length fl = meta.getPolygonFontSize(im, sc);
                        if (fl != null)
                            an.fontSize = fl.value().intValue();
                        an.family = meta.getPointFontFamily(im, sc).name();
                        ome.xml.model.primitives.Color col = meta.getPolygonStrokeColor(im, sc);
                        if (col != null)
                            an.strokeColor = System.Drawing.Color.FromArgb(col.getAlpha(), col.getRed(), col.getGreen(), col.getBlue());
                        ome.units.quantity.Length fw = meta.getPolygonStrokeWidth(im, sc);
                        if (fw != null)
                            an.strokeWidth = (float)fw.value().floatValue();
                        ome.xml.model.primitives.Color colf = meta.getPolygonFillColor(im, sc);
                        if (colf != null)
                            an.fillColor = System.Drawing.Color.FromArgb(colf.getAlpha(), colf.getRed(), colf.getGreen(), colf.getBlue());
                    }
                    else
                    if (type == "Polyline")
                    {
                        an.type = ROI.Type.Polyline;
                        an.id = meta.getPolylineID(im, sc);
                        string pxs = meta.getPolylinePoints(im, sc);
                        PointD[] pts = an.stringToPoints(pxs);
                        for (int pi = 0; pi < pts.Length; pi++)
                        {
                            pts[pi] = ToStageSpace(pts[pi], physicalSizeX, physicalSizeY, volume.Location.X, volume.Location.Y);
                        }
                        an.AddPoints(an.stringToPoints(pxs));
                        ome.xml.model.primitives.NonNegativeInteger nz = meta.getPolylineTheZ(im, sc);
                        if (nz != null)
                            co.Z = nz.getNumberValue().intValue();
                        ome.xml.model.primitives.NonNegativeInteger nc = meta.getPolylineTheC(im, sc);
                        if (nc != null)
                            co.C = nc.getNumberValue().intValue();
                        ome.xml.model.primitives.NonNegativeInteger nt = meta.getPolylineTheT(im, sc);
                        if (nt != null)
                            co.T = nt.getNumberValue().intValue();
                        an.coord = co;
                        an.Text = meta.getPolylineText(im, sc);
                        ome.units.quantity.Length fl = meta.getPolylineFontSize(im, sc);
                        if (fl != null)
                            an.fontSize = fl.value().intValue();
                        an.family = meta.getPointFontFamily(im, sc).name();
                        ome.xml.model.primitives.Color col = meta.getPolylineStrokeColor(im, sc);
                        if (col != null)
                            an.strokeColor = System.Drawing.Color.FromArgb(col.getAlpha(), col.getRed(), col.getGreen(), col.getBlue());
                        ome.units.quantity.Length fw = meta.getPolylineStrokeWidth(im, sc);
                        if (fw != null)
                            an.strokeWidth = (float)fw.value().floatValue();
                        ome.xml.model.primitives.Color colf = meta.getPolylineFillColor(im, sc);
                        if (colf != null)
                            an.fillColor = System.Drawing.Color.FromArgb(colf.getAlpha(), colf.getRed(), colf.getGreen(), colf.getBlue());
                    }
                    else
                    if (type == "Label")
                    {
                        an.type = ROI.Type.Label;
                        an.id = meta.getLabelID(im, sc);
 
                        ome.xml.model.primitives.NonNegativeInteger nz = meta.getLabelTheZ(im, sc);
                        if (nz != null)
                            co.Z = nz.getNumberValue().intValue();
                        ome.xml.model.primitives.NonNegativeInteger nc = meta.getLabelTheC(im, sc);
                        if (nc != null)
                            co.C = nc.getNumberValue().intValue();
                        ome.xml.model.primitives.NonNegativeInteger nt = meta.getLabelTheT(im, sc);
                        if (nt != null)
                            co.T = nt.getNumberValue().intValue();
                        an.coord = co;
 
                        ome.units.quantity.Length fl = meta.getLabelFontSize(im, sc);
                        if (fl != null)
                            an.fontSize = fl.value().intValue();
                        an.family = meta.getPointFontFamily(im, sc).name();
                        ome.xml.model.primitives.Color col = meta.getLabelStrokeColor(im, sc);
                        if (col != null)
                            an.strokeColor = System.Drawing.Color.FromArgb(col.getAlpha(), col.getRed(), col.getGreen(), col.getBlue());
                        ome.units.quantity.Length fw = meta.getLabelStrokeWidth(im, sc);
                        if (fw != null)
                            an.strokeWidth = (float)fw.value().floatValue();
                        ome.xml.model.primitives.Color colf = meta.getLabelFillColor(im, sc);
                        if (colf != null)
                            an.fillColor = System.Drawing.Color.FromArgb(colf.getAlpha(), colf.getRed(), colf.getGreen(), colf.getBlue());
                        PointD p = new PointD(meta.getLabelX(im, sc).doubleValue(), meta.getLabelY(im, sc).doubleValue());
                        an.AddPoint(ToStageSpace(p, physicalSizeX, physicalSizeY, volume.Location.X, volume.Location.Y));
                        an.Text = meta.getLabelText(im, sc);
                    }
                }
            }
 
            imageReader.close();
            return Annotations;
        }

References BioImager.ROI.AddPoint(), BioImager.ROI.AddPoints(), BioImager.BioImage.OMESupport(), BioImager.ROI.stringToPoints(), and BioImager.BioImage.ToStageSpace().

Referenced by BioImager.BioImage.ExportROIFolder(), and BioImager.BioImage.OpenFile().

◆ OpenOMESeries()

static BioImage[] BioImager.BioImage.OpenOMESeries	(	string	file,
		bool	tab,
		bool	addToImages
	)

static

It opens a file, checks if it's tiled, if it is, it opens it as a tiled image, if not, it opens it as a normal image

Parameters

file	the file path
tab	open in new tab
addToImages	add to images list.

Returns: An array of BioImage objects.

Definition at line 6993 of file Bio.cs.

        {
            //We wait incase OME has not initialized yet.
            if (!initialized)
                do
                {
                    Thread.Sleep(100);
                    //Application.DoEvents();
                } while (!Initialized);
            var meta = (IMetadata)((OMEXMLService)new ServiceFactory().getInstance(typeof(OMEXMLService))).createOMEXMLMetadata();
            reader.setMetadataStore((MetadataStore)meta);
            file = file.Replace("\\", "/");
            try
            {
                if (reader.getCurrentFile() != file)
                {
                    status = "Opening OME Image.";
                    file = file.Replace("\\", "/");
                    reader.setId(file);
                }
            }
            catch (Exception e)
            {
                Scripting.LogLine(e.Message);
                return null;
            }
 
            bool tile = false;
            if (reader.getOptimalTileWidth() != reader.getSizeX())
                tile = true;
            int count = reader.getSeriesCount();
            BioImage[] bs = null;
            if (tile)
            {
                bs = new BioImage[1];
                bs[0] = OpenOME(file, 0, tab, addToImages, true, 0, 0, 1920, 1080);
                Images.AddImage(bs[0], tab);
                return bs;
            }
            else
                bs = new BioImage[count];
            reader.close();
            for (int i = 0; i < count; i++)
            {
                bs[i] = OpenOME(file, i, tab, addToImages, false, 0, 0, 0, 0);
                if (bs[i] == null)
                    return null;
            }
            return bs;
        }

References BioImager.BioImage.OpenOME().

Referenced by BioImager.BioImage.OpenOME().

◆ OpenSeries()

static BioImage[] BioImager.BioImage.OpenSeries	(	string	file,
		bool	tab
	)

static

It opens a tiff file, reads the number of pages, reads the number of channels, and then reads each page into a BioImage object.

Parameters

file	the path to the file
tab	open image in new tab.

Returns: An array of BioImage objects.

Definition at line 4612 of file Bio.cs.

        {
            Tiff image = Tiff.Open(file, "r");
            int pages = image.NumberOfDirectories();
            FieldValue[] f = image.GetField(TiffTag.IMAGEDESCRIPTION);
            int sp = image.GetField(TiffTag.SAMPLESPERPIXEL)[0].ToInt();
            ImageJDesc imDesc = new ImageJDesc();
            int count = 1;
            if (f != null)
            {
                string desc = f[0].ToString();
                if (desc.StartsWith("ImageJ"))
                {
                    imDesc.SetString(desc);
                    if (imDesc.channels != 0)
                        count = imDesc.channels;
                }
            }
            int scount = (pages * sp) / count;
            BioImage[] bs = new BioImage[pages];
            image.Close();
            for (int i = 0; i < pages; i++)
            {
                bs[i] = OpenFile(file, i, tab, true);
            }
            return bs;
        }

References BioImager.BioImage.Open(), BioImager.BioImage.OpenFile(), and BioImager.BioImage.ImageJDesc.SetString().

◆ OpenVips()

static void BioImager.BioImage.OpenVips	(	BioImage	b,
		int	pagecount
	)

static

The function "OpenVips" takes a BioImage object and an integer representing the number of pages, and adds each page of the image file to the BioImage's vipPages list using the NetVips library.

Parameters

BioImage	The BioImage parameter is an object that represents a bio image. It likely contains information about the image file, such as the file path and other metadata.
pagecount	The parameter "pagecount" represents the number of pages in the TIFF file that needs to be loaded into the "vipPages" list of the "BioImage" object.

Definition at line 5778 of file Bio.cs.

        {
            try
            {
                for (int i = 0; i < pagecount; i++)
                {
                    b.vipPages.Add(NetVips.Image.Tiffload(b.file, i));
                }
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
            }
 
        }

Referenced by BioImager.BioImage.OpenFile().

◆ OpenXML()

static string BioImager.BioImage.OpenXML ( string file )

static

‍Open the file, get the image description field, and return it as a string

Parameters

file	the path to the file

Returns: The image description of the tiff file.

Definition at line 7332 of file Bio.cs.

        {
            if (!file.EndsWith(".tif"))
                return null;
            Tiff image = Tiff.Open(file, "r");
            FieldValue[] f = image.GetField(TiffTag.IMAGEDESCRIPTION);
            return f[0].ToString();
        }

◆ operator*()

static BioImage BioImager.BioImage.operator*	(	BioImage	a,
		ColorS	b
	)

static

This function takes a BioImage object and a ColorS object and returns a BioImage object

Parameters

BioImage	a class that contains a list of ColorS objects.
ColorS	a struct that contains a byte for each color channel (R, G, B, A)

Returns: A BioImage object

Definition at line 8211 of file Bio.cs.

        {
            for (int i = 0; i < a.Buffers.Count; i++)
            {
                a.Buffers[i] = a.Buffers[i] * b;
            }
            return a;
        }

◆ operator+() [1/2]

static BioImage BioImager.BioImage.operator+	(	BioImage	a,
		ColorS	b
	)

static

It takes a BioImage object and a ColorS object and adds the ColorS object to each buffer in the BioImage object

Parameters

BioImage	a class that contains a list of ColorS objects.
ColorS	a struct that contains a byte for each color channel (R, G, B, A)

Returns: A BioImage object

Definition at line 8226 of file Bio.cs.

        {
            for (int i = 0; i < a.Buffers.Count; i++)
            {
                a.Buffers[i] = a.Buffers[i] + b;
            }
            return a;
        }

◆ operator+() [2/2]

static BioImage BioImager.BioImage.operator+	(	BioImage	a,
		float	b
	)

static

This function adds a constant value to each pixel in the image

Parameters

BioImage	a class that contains a list of buffers (float[])
b	the value to add to the image

Returns: The image itself.

Definition at line 8168 of file Bio.cs.

        {
            for (int i = 0; i < a.Buffers.Count; i++)
            {
                a.Buffers[i] = a.Buffers[i] + b;
            }
            return a;
        }

◆ operator-() [1/2]

static BioImage BioImager.BioImage.operator-	(	BioImage	a,
		ColorS	b
	)

static

The function subtracts a color from each pixel in the image

Parameters

BioImage	a class that contains a list of ColorS objects.
ColorS	a struct that contains a byte for each color channel (R, G, B, A)

Returns: The image itself.

Definition at line 8240 of file Bio.cs.

        {
            for (int i = 0; i < a.Buffers.Count; i++)
            {
                a.Buffers[i] = a.Buffers[i] - b;
            }
            return a;
        }

◆ operator-() [2/2]

static BioImage BioImager.BioImage.operator-	(	BioImage	a,
		float	b
	)

static

Subtracts a scalar value from each pixel in the image

Parameters

BioImage	a class that contains a list of buffers (which are 2D arrays of floats)
b	the value to subtract from the image

Returns: The BioImage object is being returned.

Definition at line 8182 of file Bio.cs.

        {
            for (int i = 0; i < a.Buffers.Count; i++)
            {
                a.Buffers[i] = a.Buffers[i] - b;
            }
            return a;
        }

◆ operator/() [1/2]

static BioImage BioImager.BioImage.operator/	(	BioImage	a,
		ColorS	b
	)

static

This function divides each pixel in the image by the value of the color

Parameters

BioImage	a class that contains a list of ColorS objects.
ColorS	a struct that contains a byte for each color channel (R, G, B, A)

Returns: A BioImage object.

Definition at line 8197 of file Bio.cs.

        {
            for (int i = 0; i < a.Buffers.Count; i++)
            {
                a.Buffers[i] = a.Buffers[i] / b;
            }
            return a;
        }

◆ operator/() [2/2]

static BioImage BioImager.BioImage.operator/	(	BioImage	a,
		float	b
	)

static

This function divides each pixel in the image by a constant value

Parameters

BioImage	a class that contains a list of buffers (which are 2D arrays of floats)
b	the value to divide by

Returns: The image is being returned.

Definition at line 8153 of file Bio.cs.

        {
            for (int i = 0; i < a.Buffers.Count; i++)
            {
                a.Buffers[i] = a.Buffers[i] / b;
            }
            return a;
        }

◆ ROIsToString()

static string BioImager.BioImage.ROIsToString ( List< ROI > Annotations )

static

It takes a list of ROI objects and returns a string of all the ROI objects in the list

Parameters

Annotations List of ROI objects

Returns: A string of the ROI's

Definition at line 7697 of file Bio.cs.

        {
            string s = "";
            for (int i = 0; i < Annotations.Count; i++)
            {
                s += ROIToString(Annotations[i]);
            }
            return s;
        }

References BioImager.BioImage.ROIToString().

Referenced by BioImager.BioImage.ExportROIsCSV().

◆ ROIToString()

static string BioImager.BioImage.ROIToString ( ROI an )

static

This function takes an ROI object and returns a string that contains all the information about the ROI

Parameters

ROI	The ROI object

Returns: A string

Definition at line 7712 of file Bio.cs.

        {
            PointD[] points = an.GetPoints();
            string pts = "";
            for (int j = 0; j < points.Length; j++)
            {
                if (j == points.Length - 1)
                    pts += points[j].X.ToString(CultureInfo.InvariantCulture) + "," + points[j].Y.ToString(CultureInfo.InvariantCulture);
                else
                    pts += points[j].X.ToString(CultureInfo.InvariantCulture) + "," + points[j].Y.ToString(CultureInfo.InvariantCulture) + " ";
            }
            char sep = (char)34;
            string sColor = sep.ToString() + an.strokeColor.A.ToString() + ',' + an.strokeColor.R.ToString() + ',' + an.strokeColor.G.ToString() + ',' + an.strokeColor.B.ToString() + sep.ToString();
            string bColor = sep.ToString() + an.fillColor.A.ToString() + ',' + an.fillColor.R.ToString() + ',' + an.fillColor.G.ToString() + ',' + an.fillColor.B.ToString() + sep.ToString();
 
            string line = an.roiID + ',' + an.roiName + ',' + an.type.ToString() + ',' + an.id + ',' + an.shapeIndex.ToString() + ',' +
                an.Text + ',' + an.serie + ',' + an.coord.Z.ToString() + ',' + an.coord.C.ToString() + ',' + an.coord.T.ToString() + ',' + an.X.ToString(CultureInfo.InvariantCulture) + ',' + an.Y.ToString(CultureInfo.InvariantCulture) + ',' +
                an.W.ToString(CultureInfo.InvariantCulture) + ',' + an.H.ToString(CultureInfo.InvariantCulture) + ',' + sep.ToString() + pts + sep.ToString() + ',' + sColor + ',' + an.strokeWidth.ToString(CultureInfo.InvariantCulture) + ',' + bColor + ',' + an.fontSize.ToString(CultureInfo.InvariantCulture) + ',' + NewLine;
            return line;
        }

References BioImager.ROI.GetPoints().

Referenced by BioImager.ImageView.CopySelection(), BioImager.BioImage.ROIsToString(), and BioImager.BioImage.SaveSeries().

◆ RotateFlip()

void BioImager.BioImage.RotateFlip ( AForge.RotateFlipType rot )

Rotates the image by specified degrees or flips it.

Parameters

rot	The type of rotation to perform.

Definition at line 3081 of file Bio.cs.

        {
            for (int i = 0; i < Buffers.Count; i++)
            {
                Buffers[i].RotateFlip(rot);
            }
            Volume = new VolumeD(new Point3D(StageSizeX, StageSizeY, StageSizeZ), new Point3D(PhysicalSizeX * SizeX, PhysicalSizeY * SizeY, PhysicalSizeZ * SizeZ));
        }

◆ Save()

static void BioImager.BioImage.Save	(	string	file,
		string	ID
	)

static

It takes a file and an ID and saves the file to the ID

Parameters

file	The file to save the data to.
ID	The ID of the user

Definition at line 7251 of file Bio.cs.

        {
            SaveFile(file, ID);
        }

References BioImager.BioImage.SaveFile().

◆ SaveAsync()

static async Task BioImager.BioImage.SaveAsync	(	string	file,
		string	id,
		int	serie,
		bool	ome
	)

static

The SaveAsync function saves data to a file asynchronously.

Parameters

file	The file parameter is a string that represents the file path or name where the data will be saved.
id	The "id" parameter is a string that represents an identifier for the save operation. It could be used to uniquely identify the saved data or to specify a specific location or format for the saved file.
serie	The "serie" parameter is an integer that represents a series or sequence number. It is used as a parameter in the SaveAsync method.
ome	The "ome" parameter is a boolean value that determines whether or not to perform a specific action in the saving process.

Definition at line 7093 of file Bio.cs.

        {
            savefile = file;
            saveid = id;
            some = ome;
            await Task.Run(SaveThread);
        }

◆ SaveFile()

static void BioImager.BioImage.SaveFile	(	string	file,
		string	ID
	)

static

This function takes a string array of file names and a string ID and saves the files to the database

Parameters

file	The file path to the file you want to save.
ID	The ID of the series you want to save.

Definition at line 4493 of file Bio.cs.

        {
            string[] sts = new string[1];
            sts[0] = ID;
            SaveSeries(sts, file);
        }

References BioImager.BioImage.SaveSeries().

Referenced by BioImager.BioImage.Save().

◆ SaveOME()

static void BioImager.BioImage.SaveOME	(	string	file,
		string	ID
	)

static

This function takes a string array of image IDs, a file name, and a number of planes. It then saves the images to the file name

Parameters

file	the file name to save the image to
ID	The ID of the image you want to save

Definition at line 5156 of file Bio.cs.

        {
            if (!OMESupport())
                return;
            string[] sts = new string[1];
            sts[0] = ID;
            SaveOMESeries(sts, file, BioImage.Planes);
        }

References BioImager.BioImage.OMESupport(), and BioImager.BioImage.SaveOMESeries().

◆ SaveOMEPyramidal()

static void BioImager.BioImage.SaveOMEPyramidal	(	BioImage[]	bms,
		string	file,
		Enums.ForeignTiffCompression	compression,
		int	compressionLevel
	)

static

Definition at line 5542 of file Bio.cs.

        {
            if (File.Exists(file))
                File.Delete(file);
            //We need to go through the images and find the ones belonging to each resolution.
            //As well we need to determine the dimensions of the tiles.
            Dictionary<double, List<BioImage>> bis = new Dictionary<double, List<BioImage>>();
            Dictionary<double, Point3D> min = new Dictionary<double, Point3D>();
            Dictionary<double, Point3D> max = new Dictionary<double, Point3D>();
            for (int i = 0; i < bms.Length; i++)
            {
                for (int r = 0; r < bms[i].Resolutions.Count; r++)
                {
                    Resolution res = bms[i].Resolutions[r];
                    if (bis.ContainsKey(res.PhysicalSizeX))
                    {
                        bis[res.PhysicalSizeX].Add(bms[i]);
                        if (bms[i].StageSizeX < min[res.PhysicalSizeX].X || bms[i].StageSizeY < min[res.PhysicalSizeX].Y)
                        {
                            min[res.PhysicalSizeX] = bms[i].Volume.Location;
                        }
                        if (bms[i].StageSizeX > max[res.PhysicalSizeX].X || bms[i].StageSizeY > max[res.PhysicalSizeX].Y)
                        {
                            max[res.PhysicalSizeX] = bms[i].Volume.Location;
                        }
                    }
                    else
                    {
                        bis.Add(res.PhysicalSizeX, new List<BioImage>());
                        min.Add(res.PhysicalSizeX, new Point3D(double.MaxValue, double.MaxValue, double.MaxValue));
                        max.Add(res.PhysicalSizeX, new Point3D(double.MinValue, double.MinValue, double.MinValue));
                        if (bms[i].StageSizeX < min[res.PhysicalSizeX].X || bms[i].StageSizeY < min[res.PhysicalSizeX].Y)
                        {
                            min[res.PhysicalSizeX] = bms[i].Volume.Location;
                        }
                        if (bms[i].StageSizeX > max[res.PhysicalSizeX].X || bms[i].StageSizeY > max[res.PhysicalSizeX].Y)
                        {
                            max[res.PhysicalSizeX] = bms[i].Volume.Location;
                        }
                        bis[res.PhysicalSizeX].Add(bms[i]);
                    }
                }
            }
            int s = 0;
            //We determine the sizes of each resolution.
            Dictionary<double, AForge.Size> ss = new Dictionary<double, AForge.Size>();
            int minx = int.MaxValue;
            int miny = int.MaxValue;
            double last = 0;
            foreach (double px in bis.Keys)
            {
                int xs = (1 + (int)Math.Ceiling((max[px].X - min[px].X) / bis[px][0].Resolutions[0].VolumeWidth)) * bis[px][0].SizeX;
                int ys = (1 + (int)Math.Ceiling((max[px].Y - min[px].Y) / bis[px][0].Resolutions[0].VolumeHeight)) * bis[px][0].SizeY;
                if (minx > xs)
                    minx = xs;
                if (miny > ys)
                    miny = ys;
                ss.Add(px, new AForge.Size(xs, ys));
                last = px;
            }
            s = 0;
            string met = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>" +
                "<OME xmlns=\"http://www.openmicroscopy.org/Schemas/OME/2016-06\" " +
                "xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" " +
                "xsi:schemaLocation=\"http://www.openmicroscopy.org/Schemas/OME/2016-06 http://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd\">";
            NetVips.Image img = null;
            int ib = 0;
            
            foreach (double px in bis.Keys)
            {
                int c = bis[px][s].SizeC;
                if (bis[px][s].Buffers[0].isRGB)
                    c = 3;
                string endian = (bis[px][s].Buffers[0].LittleEndian).ToString().ToLower();
                met +=
                "<Image ID=\"Image:" + ib + "\">" +
                "<Pixels BigEndian=\"" + endian + "\" DimensionOrder= \"XYCZT\" ID= \"Pixels:0\" Interleaved=\"true\" " +
                "PhysicalSizeX=\"" + bis[px][s].PhysicalSizeX + "\" PhysicalSizeXUnit=\"µm\" PhysicalSizeY=\"" + bis[px][s].PhysicalSizeY + "\" PhysicalSizeYUnit=\"µm\" SignificantBits=\"" + bis[px][s].bitsPerPixel + "\" " +
                "SizeC = \"" + c + "\" SizeT = \"" + bis[px][s].SizeT + "\" SizeX =\"" + ss[px].Width +
                "\" SizeY= \"" + ss[px].Height + "\" SizeZ=\"" + bis[px][s].SizeZ;
                if (bis[px][s].bitsPerPixel > 8) met += "\" Type= \"uint16\">";
                else met += "\" Type= \"uint8\">";
                int i = 0;
                foreach (Channel ch in bis[px][s].Channels)
                {
                    met += "<Channel ID=\"Channel:" + ib + ":" + i + "\" SamplesPerPixel=\"1\"></Channel>";
                    i++;
                }
                met += "</Pixels></Image>";
                ib++;
            }
            met += "</OME>";
            foreach (double px in bis.Keys)
            {
                PixelFormat pf = bis[px][0].Buffers[0].PixelFormat;
                Bitmap level = new Bitmap(ss[px].Width, ss[px].Height, pf);
                int bands = GetBands(pf);
                if(bis[px][0].bitsPerPixel > 8)
                    img = NetVips.Image.NewFromMemory(level.Data, (ulong)level.Length, level.Width, level.Height, bands, Enums.BandFormat.Ushort);
                else
                    img = NetVips.Image.NewFromMemory(level.Data, (ulong)level.Length, level.Width, level.Height, bands, Enums.BandFormat.Uchar);
                int i = 0;
                foreach (BioImage b in bis[px])
                {
                    AForge.Size si = ss[px];
                    double xs = (-(min[px].X - bis[px][i].Volume.Location.X) / bis[px][i].Resolutions[0].VolumeWidth) * bis[px][i].SizeX;
                    double ys = (-(min[px].Y - bis[px][i].Volume.Location.Y) / bis[px][i].Resolutions[0].VolumeHeight) * bis[px][i].SizeY;
                    NetVips.Image tile;
                    if(b.bitsPerPixel > 8)
                        tile = NetVips.Image.NewFromMemory(bis[px][i].Buffers[0].Data, (ulong)bis[px][i].Buffers[0].Length, bis[px][i].Buffers[0].Width, bis[px][i].Buffers[0].Height, bands, Enums.BandFormat.Ushort);
                    else
                        tile = NetVips.Image.NewFromMemory(bis[px][i].Buffers[0].Data, (ulong)bis[px][i].Buffers[0].Length, bis[px][i].Buffers[0].Width, bis[px][i].Buffers[0].Height, bands, Enums.BandFormat.Uchar);
                    img = img.Insert(tile, (int)xs, (int)ys);
                    i++;
                };
                using var mutated = img.Mutate(mutable =>
                {
                    // Set the ImageDescription tag
                    mutable.Set(GValue.GStrType, "image-description", met);
                    mutable.Set(GValue.GIntType, "page-height", ss[last].Height);
                });
                if (bis[px][0].bitsPerPixel > 8)
                    mutated.Tiffsave(file, compression, 1, Enums.ForeignTiffPredictor.None, true, ss[px].Width, ss[px].Height, true, false, 16,
                    Enums.ForeignTiffResunit.Cm, 1000 * bis[px][0].PhysicalSizeX, 1000 * bis[px][0].PhysicalSizeY, true, null, Enums.RegionShrink.Nearest,
                    compressionLevel, true, Enums.ForeignDzDepth.One, true, false, null, null, ss[px].Height);
                else
                    mutated.Tiffsave(file, compression, 1, Enums.ForeignTiffPredictor.None, true, ss[px].Width, ss[px].Height, true, false, 8,
                    Enums.ForeignTiffResunit.Cm, 1000 * bis[px][0].PhysicalSizeX, 1000 * bis[px][0].PhysicalSizeY, true, null, Enums.RegionShrink.Nearest,
                    compressionLevel, true, Enums.ForeignDzDepth.One, true, false, null, null, ss[px].Height);
                s++;
            }
 
        }

◆ SaveOMESeries() [1/2]

static void BioImager.BioImage.SaveOMESeries	(	BioImage[]	bms,
		string	f,
		bool	planes
	)

static

This function takes a list of image files and saves them as a single OME-TIFF file

Parameters

files	an array of file paths to the images to be saved
f	the file name to save to
planes	if true, the planes will be saved as well.

Definition at line 5169 of file Bio.cs.

        {
            if (!OMESupport())
                return;
            if (File.Exists(f))
                File.Delete(f);
            loci.formats.meta.IMetadata omexml = service.createOMEXMLMetadata();
            status = "Saving OME Image Metadata.";
            for (int fi = 0; fi < bms.Length; fi++)
            {
                progFile = bms[fi].file;
                int serie = fi;
                string file = bms[fi].file;
 
                BioImage b = bms[fi];
                if (b.isPyramidal)
                {
                    b = OpenOME(b.file, b.level, false, false, true, (int)App.viewer.PyramidalOrigin.X, (int)App.viewer.PyramidalOrigin.Y, App.viewer.Width, App.viewer.Height);
                }
                // create OME-XML metadata store
 
                omexml.setImageID("Image:" + serie, serie);
                omexml.setPixelsID("Pixels:" + serie, serie);
                omexml.setPixelsInterleaved(java.lang.Boolean.TRUE, serie);
                omexml.setPixelsDimensionOrder(ome.xml.model.enums.DimensionOrder.XYCZT, serie);
                if (b.bitsPerPixel > 8)
                    omexml.setPixelsType(ome.xml.model.enums.PixelType.UINT16, serie);
                else
                    omexml.setPixelsType(ome.xml.model.enums.PixelType.UINT8, serie);
                omexml.setPixelsSizeX(new PositiveInteger(java.lang.Integer.valueOf(b.SizeX)), serie);
                omexml.setPixelsSizeY(new PositiveInteger(java.lang.Integer.valueOf(b.SizeY)), serie);
                omexml.setPixelsSizeZ(new PositiveInteger(java.lang.Integer.valueOf(b.SizeZ)), serie);
                int samples = 1;
                if (b.isRGB)
                    samples = 3;
                omexml.setPixelsSizeC(new PositiveInteger(java.lang.Integer.valueOf(b.SizeC)), serie);
                omexml.setPixelsSizeT(new PositiveInteger(java.lang.Integer.valueOf(b.SizeT)), serie);
                if (BitConverter.IsLittleEndian)
                    omexml.setPixelsBigEndian(java.lang.Boolean.FALSE, serie);
                else
                    omexml.setPixelsBigEndian(java.lang.Boolean.TRUE, serie);
                ome.units.quantity.Length p1 = new ome.units.quantity.Length(java.lang.Double.valueOf(b.PhysicalSizeX), ome.units.UNITS.MICROMETER);
                omexml.setPixelsPhysicalSizeX(p1, serie);
                ome.units.quantity.Length p2 = new ome.units.quantity.Length(java.lang.Double.valueOf(b.PhysicalSizeY), ome.units.UNITS.MICROMETER);
                omexml.setPixelsPhysicalSizeY(p2, serie);
                ome.units.quantity.Length p3 = new ome.units.quantity.Length(java.lang.Double.valueOf(b.PhysicalSizeZ), ome.units.UNITS.MICROMETER);
                omexml.setPixelsPhysicalSizeZ(p3, serie);
                ome.units.quantity.Length s1 = new ome.units.quantity.Length(java.lang.Double.valueOf(b.Volume.Location.X), ome.units.UNITS.MICROMETER);
                omexml.setStageLabelX(s1, serie);
                ome.units.quantity.Length s2 = new ome.units.quantity.Length(java.lang.Double.valueOf(b.Volume.Location.Y), ome.units.UNITS.MICROMETER);
                omexml.setStageLabelY(s2, serie);
                ome.units.quantity.Length s3 = new ome.units.quantity.Length(java.lang.Double.valueOf(b.Volume.Location.Z), ome.units.UNITS.MICROMETER);
                omexml.setStageLabelZ(s3, serie);
                omexml.setStageLabelName("StageLabel:" + serie, serie);
 
                for (int channel = 0; channel < b.Channels.Count; channel++)
                {
                    Channel c = b.Channels[channel];
                    for (int r = 0; r < c.range.Length; r++)
                    {
                        omexml.setChannelID("Channel:" + channel + ":" + serie, serie, channel + r);
                        omexml.setChannelSamplesPerPixel(new PositiveInteger(java.lang.Integer.valueOf(1)), serie, channel + r);
                        if (c.LightSourceWavelength != 0)
                        {
                            omexml.setChannelLightSourceSettingsID("LightSourceSettings:" + channel, serie, channel + r);
                            ome.units.quantity.Length lw = new ome.units.quantity.Length(java.lang.Double.valueOf(c.LightSourceWavelength), ome.units.UNITS.NANOMETER);
                            omexml.setChannelLightSourceSettingsWavelength(lw, serie, channel + r);
                            omexml.setChannelLightSourceSettingsAttenuation(PercentFraction.valueOf(c.LightSourceAttenuation), serie, channel + r);
                        }
                        omexml.setChannelName(c.Name, serie, channel + r);
                        if (c.Color != null)
                        {
                            ome.xml.model.primitives.Color col = new ome.xml.model.primitives.Color(c.Color.Value.R, c.Color.Value.G, c.Color.Value.B, c.Color.Value.A);
                            omexml.setChannelColor(col, serie, channel + r);
                        }
                        if (c.Emission != 0)
                        {
                            ome.units.quantity.Length em = new ome.units.quantity.Length(java.lang.Double.valueOf(c.Emission), ome.units.UNITS.NANOMETER);
                            omexml.setChannelEmissionWavelength(em, serie, channel + r);
                            ome.units.quantity.Length ex = new ome.units.quantity.Length(java.lang.Double.valueOf(c.Excitation), ome.units.UNITS.NANOMETER);
                            omexml.setChannelExcitationWavelength(ex, serie, channel + r);
                        }
                        /*
                        if (c.ContrastMethod != null)
                        {
                            ome.xml.model.enums.ContrastMethod cm = (ome.xml.model.enums.ContrastMethod)Enum.Parse(typeof(ome.xml.model.enums.ContrastMethod), c.ContrastMethod);
                            omexml.setChannelContrastMethod(cm, serie, channel + r);
                        }
                        if (c.IlluminationType != null)
                        {
                            ome.xml.model.enums.IlluminationType il = (ome.xml.model.enums.IlluminationType)Enum.Parse(typeof(ome.xml.model.enums.IlluminationType), c.IlluminationType.ToUpper());
                            omexml.setChannelIlluminationType(il, serie, channel + r);
                        }
                        if (c.AcquisitionMode != null)
                        {
                            ome.xml.model.enums.AcquisitionMode am = (ome.xml.model.enums.AcquisitionMode)Enum.Parse(typeof(ome.xml.model.enums.AcquisitionMode), c.AcquisitionMode.ToUpper());
                            omexml.setChannelAcquisitionMode(am, serie, channel + r);
                        }
                        */
                        omexml.setChannelFluor(c.Fluor, serie, channel + r);
                        if (c.LightSourceIntensity != 0)
                        {
                            ome.units.quantity.Power pw = new ome.units.quantity.Power(java.lang.Double.valueOf(c.LightSourceIntensity), ome.units.UNITS.VOLT);
                            omexml.setLightEmittingDiodePower(pw, serie, channel + r);
                            omexml.setLightEmittingDiodeID(c.DiodeName, serie, channel + r);
                        }
                    }
                }
 
                int i = 0;
                foreach (ROI an in b.Annotations)
                {
                    if (an.roiID == "")
                        omexml.setROIID("ROI:" + i.ToString() + ":" + serie, i);
                    else
                        omexml.setROIID(an.roiID, i);
                    omexml.setROIName(an.roiName, i);
                    if (an.type == ROI.Type.Point)
                    {
                        if (an.id != "")
                            omexml.setPointID(an.id, i, serie);
                        else
                            omexml.setPointID("Shape:" + i + ":" + serie, i, serie);
                        omexml.setPointX(java.lang.Double.valueOf(b.ToImageSpaceX(an.X)), i, serie);
                        omexml.setPointY(java.lang.Double.valueOf(b.ToImageSpaceY(an.Y)), i, serie);
                        omexml.setPointTheZ(new NonNegativeInteger(java.lang.Integer.valueOf(an.coord.Z)), i, serie);
                        omexml.setPointTheC(new NonNegativeInteger(java.lang.Integer.valueOf(an.coord.C)), i, serie);
                        omexml.setPointTheT(new NonNegativeInteger(java.lang.Integer.valueOf(an.coord.T)), i, serie);
                        if (an.Text != "")
                            omexml.setPointText(an.Text, i, serie);
                        else
                            omexml.setPointText(i.ToString(), i, serie);
                        ome.units.quantity.Length fl = new ome.units.quantity.Length(java.lang.Double.valueOf(an.fontSize), ome.units.UNITS.PIXEL);
                        omexml.setPointFontSize(fl, i, serie);
                        ome.xml.model.primitives.Color col = new ome.xml.model.primitives.Color(an.strokeColor.R, an.strokeColor.G, an.strokeColor.B, an.strokeColor.A);
                        omexml.setPointStrokeColor(col, i, serie);
                        ome.units.quantity.Length sw = new ome.units.quantity.Length(java.lang.Double.valueOf(an.strokeWidth), ome.units.UNITS.PIXEL);
                        omexml.setPointStrokeWidth(sw, i, serie);
                        ome.xml.model.primitives.Color colf = new ome.xml.model.primitives.Color(an.fillColor.R, an.fillColor.G, an.fillColor.B, an.fillColor.A);
                        omexml.setPointFillColor(colf, i, serie);
                    }
                    else
                    if (an.type == ROI.Type.Polygon || an.type == ROI.Type.Freeform)
                    {
                        if (an.id != "")
                            omexml.setPolygonID(an.id, i, serie);
                        else
                            omexml.setPolygonID("Shape:" + i + ":" + serie, i, serie);
                        omexml.setPolygonPoints(an.PointsToString(b), i, serie);
                        omexml.setPolygonTheZ(new NonNegativeInteger(java.lang.Integer.valueOf(an.coord.Z)), i, serie);
                        omexml.setPolygonTheC(new NonNegativeInteger(java.lang.Integer.valueOf(an.coord.C)), i, serie);
                        omexml.setPolygonTheT(new NonNegativeInteger(java.lang.Integer.valueOf(an.coord.T)), i, serie);
                        if (an.Text != "")
                            omexml.setPolygonText(an.Text, i, serie);
                        else
                            omexml.setPolygonText(i.ToString(), i, serie);
                        ome.units.quantity.Length fl = new ome.units.quantity.Length(java.lang.Double.valueOf(an.fontSize), ome.units.UNITS.PIXEL);
                        omexml.setPolygonFontSize(fl, i, serie);
                        ome.xml.model.primitives.Color col = new ome.xml.model.primitives.Color(an.strokeColor.R, an.strokeColor.G, an.strokeColor.B, an.strokeColor.A);
                        omexml.setPolygonStrokeColor(col, i, serie);
                        ome.units.quantity.Length sw = new ome.units.quantity.Length(java.lang.Double.valueOf(an.strokeWidth), ome.units.UNITS.PIXEL);
                        omexml.setPolygonStrokeWidth(sw, i, serie);
                        ome.xml.model.primitives.Color colf = new ome.xml.model.primitives.Color(an.fillColor.R, an.fillColor.G, an.fillColor.B, an.fillColor.A);
                        omexml.setPolygonFillColor(colf, i, serie);
                    }
                    else
                    if (an.type == ROI.Type.Rectangle)
                    {
                        if (an.id != "")
                            omexml.setRectangleID(an.id, i, serie);
                        else
                            omexml.setRectangleID("Shape:" + i + ":" + serie, i, serie);
                        omexml.setRectangleWidth(java.lang.Double.valueOf(b.ToImageSizeX(an.W)), i, serie);
                        omexml.setRectangleHeight(java.lang.Double.valueOf(b.ToImageSizeY(an.H)), i, serie);
                        omexml.setRectangleX(java.lang.Double.valueOf(b.ToImageSpaceX(an.Rect.X)), i, serie);
                        omexml.setRectangleY(java.lang.Double.valueOf(b.ToImageSpaceY(an.Rect.Y)), i, serie);
                        omexml.setRectangleTheZ(new NonNegativeInteger(java.lang.Integer.valueOf(an.coord.Z)), i, serie);
                        omexml.setRectangleTheC(new NonNegativeInteger(java.lang.Integer.valueOf(an.coord.C)), i, serie);
                        omexml.setRectangleTheT(new NonNegativeInteger(java.lang.Integer.valueOf(an.coord.T)), i, serie);
                        omexml.setRectangleText(i.ToString(), i, serie);
                        if (an.Text != "")
                            omexml.setRectangleText(an.Text, i, serie);
                        else
                            omexml.setRectangleText(i.ToString(), i, serie);
                        ome.units.quantity.Length fl = new ome.units.quantity.Length(java.lang.Double.valueOf(an.fontSize), ome.units.UNITS.PIXEL);
                        omexml.setRectangleFontSize(fl, i, serie);
                        ome.xml.model.primitives.Color col = new ome.xml.model.primitives.Color(an.strokeColor.R, an.strokeColor.G, an.strokeColor.B, an.strokeColor.A);
                        omexml.setRectangleStrokeColor(col, i, serie);
                        ome.units.quantity.Length sw = new ome.units.quantity.Length(java.lang.Double.valueOf(an.strokeWidth), ome.units.UNITS.PIXEL);
                        omexml.setRectangleStrokeWidth(sw, i, serie);
                        ome.xml.model.primitives.Color colf = new ome.xml.model.primitives.Color(an.fillColor.R, an.fillColor.G, an.fillColor.B, an.fillColor.A);
                        omexml.setRectangleFillColor(colf, i, serie);
                    }
                    else
                    if (an.type == ROI.Type.Line)
                    {
                        if (an.id != "")
                            omexml.setLineID(an.id, i, serie);
                        else
                            omexml.setLineID("Shape:" + i + ":" + serie, i, serie);
                        omexml.setLineX1(java.lang.Double.valueOf(b.ToImageSpaceX(an.GetPoint(0).X)), i, serie);
                        omexml.setLineY1(java.lang.Double.valueOf(b.ToImageSpaceY(an.GetPoint(0).Y)), i, serie);
                        omexml.setLineX2(java.lang.Double.valueOf(b.ToImageSpaceX(an.GetPoint(1).X)), i, serie);
                        omexml.setLineY2(java.lang.Double.valueOf(b.ToImageSpaceY(an.GetPoint(1).Y)), i, serie);
                        omexml.setLineTheZ(new NonNegativeInteger(java.lang.Integer.valueOf(an.coord.Z)), i, serie);
                        omexml.setLineTheC(new NonNegativeInteger(java.lang.Integer.valueOf(an.coord.C)), i, serie);
                        omexml.setLineTheT(new NonNegativeInteger(java.lang.Integer.valueOf(an.coord.T)), i, serie);
                        if (an.Text != "")
                            omexml.setLineText(an.Text, i, serie);
                        else
                            omexml.setLineText(i.ToString(), i, serie);
                        ome.units.quantity.Length fl = new ome.units.quantity.Length(java.lang.Double.valueOf(an.fontSize), ome.units.UNITS.PIXEL);
                        omexml.setLineFontSize(fl, i, serie);
                        ome.xml.model.primitives.Color col = new ome.xml.model.primitives.Color(an.strokeColor.R, an.strokeColor.G, an.strokeColor.B, an.strokeColor.A);
                        omexml.setLineStrokeColor(col, i, serie);
                        ome.units.quantity.Length sw = new ome.units.quantity.Length(java.lang.Double.valueOf(an.strokeWidth), ome.units.UNITS.PIXEL);
                        omexml.setLineStrokeWidth(sw, i, serie);
                        ome.xml.model.primitives.Color colf = new ome.xml.model.primitives.Color(an.fillColor.R, an.fillColor.G, an.fillColor.B, an.fillColor.A);
                        omexml.setLineFillColor(colf, i, serie);
                    }
                    else
                    if (an.type == ROI.Type.Ellipse)
                    {
 
                        if (an.id != "")
                            omexml.setEllipseID(an.id, i, serie);
                        else
                            omexml.setEllipseID("Shape:" + i + ":" + serie, i, serie);
                        //We need to change Rectangle to ellipse radius;
                        double w = (double)an.W / 2;
                        double h = (double)an.H / 2;
                        omexml.setEllipseRadiusX(java.lang.Double.valueOf(b.ToImageSizeX(w)), i, serie);
                        omexml.setEllipseRadiusY(java.lang.Double.valueOf(b.ToImageSizeY(h)), i, serie);
 
                        double x = an.Point.X + w;
                        double y = an.Point.Y + h;
                        omexml.setEllipseX(java.lang.Double.valueOf(b.ToImageSpaceX(x)), i, serie);
                        omexml.setEllipseY(java.lang.Double.valueOf(b.ToImageSpaceX(y)), i, serie);
                        omexml.setEllipseTheZ(new NonNegativeInteger(java.lang.Integer.valueOf(an.coord.Z)), i, serie);
                        omexml.setEllipseTheC(new NonNegativeInteger(java.lang.Integer.valueOf(an.coord.C)), i, serie);
                        omexml.setEllipseTheT(new NonNegativeInteger(java.lang.Integer.valueOf(an.coord.T)), i, serie);
                        if (an.Text != "")
                            omexml.setEllipseText(an.Text, i, serie);
                        else
                            omexml.setEllipseText(i.ToString(), i, serie);
                        ome.units.quantity.Length fl = new ome.units.quantity.Length(java.lang.Double.valueOf(an.fontSize), ome.units.UNITS.PIXEL);
                        omexml.setEllipseFontSize(fl, i, serie);
                        ome.xml.model.primitives.Color col = new ome.xml.model.primitives.Color(an.strokeColor.R, an.strokeColor.G, an.strokeColor.B, an.strokeColor.A);
                        omexml.setEllipseStrokeColor(col, i, serie);
                        ome.units.quantity.Length sw = new ome.units.quantity.Length(java.lang.Double.valueOf(an.strokeWidth), ome.units.UNITS.PIXEL);
                        omexml.setEllipseStrokeWidth(sw, i, serie);
                        ome.xml.model.primitives.Color colf = new ome.xml.model.primitives.Color(an.fillColor.R, an.fillColor.G, an.fillColor.B, an.fillColor.A);
                        omexml.setEllipseFillColor(colf, i, serie);
                    }
                    else
                    if (an.type == ROI.Type.Label)
                    {
                        if (an.id != "")
                            omexml.setLabelID(an.id, i, serie);
                        else
                            omexml.setLabelID("Shape:" + i + ":" + serie, i, serie);
                        omexml.setLabelX(java.lang.Double.valueOf(b.ToImageSpaceX(an.Rect.X)), i, serie);
                        omexml.setLabelY(java.lang.Double.valueOf(b.ToImageSpaceY(an.Rect.Y)), i, serie);
                        omexml.setLabelTheZ(new NonNegativeInteger(java.lang.Integer.valueOf(an.coord.Z)), i, serie);
                        omexml.setLabelTheC(new NonNegativeInteger(java.lang.Integer.valueOf(an.coord.C)), i, serie);
                        omexml.setLabelTheT(new NonNegativeInteger(java.lang.Integer.valueOf(an.coord.T)), i, serie);
                        omexml.setLabelText(i.ToString(), i, serie);
                        if (an.Text != "")
                            omexml.setLabelText(an.Text, i, serie);
                        else
                            omexml.setLabelText(i.ToString(), i, serie);
                        ome.units.quantity.Length fl = new ome.units.quantity.Length(java.lang.Double.valueOf(an.fontSize), ome.units.UNITS.PIXEL);
                        omexml.setLabelFontSize(fl, i, serie);
                        ome.xml.model.primitives.Color col = new ome.xml.model.primitives.Color(an.strokeColor.R, an.strokeColor.G, an.strokeColor.B, an.strokeColor.A);
                        omexml.setLabelStrokeColor(col, i, serie);
                        ome.units.quantity.Length sw = new ome.units.quantity.Length(java.lang.Double.valueOf(an.strokeWidth), ome.units.UNITS.PIXEL);
                        omexml.setLabelStrokeWidth(sw, i, serie);
                        ome.xml.model.primitives.Color colf = new ome.xml.model.primitives.Color(an.fillColor.R, an.fillColor.G, an.fillColor.B, an.fillColor.A);
                        omexml.setLabelFillColor(colf, i, serie);
                    }
                    i++;
                }
 
                if (b.Buffers[0].Plane != null && planes)
                    for (int bu = 0; bu < b.Buffers.Count; bu++)
                    {
                        //Correct order of parameters.
                        if (b.Buffers[bu].Plane.Delta != 0)
                        {
                            ome.units.quantity.Time t = new ome.units.quantity.Time(java.lang.Double.valueOf(b.Buffers[bu].Plane.Delta), ome.units.UNITS.MILLISECOND);
                            omexml.setPlaneDeltaT(t, serie, bu);
                        }
                        if (b.Buffers[bu].Plane.Exposure != 0)
                        {
                            ome.units.quantity.Time et = new ome.units.quantity.Time(java.lang.Double.valueOf(b.Buffers[bu].Plane.Exposure), ome.units.UNITS.MILLISECOND);
                            omexml.setPlaneExposureTime(et, serie, bu);
                        }
                        ome.units.quantity.Length lx = new ome.units.quantity.Length(java.lang.Double.valueOf(b.Buffers[bu].Plane.Location.X), ome.units.UNITS.MICROMETER);
                        ome.units.quantity.Length ly = new ome.units.quantity.Length(java.lang.Double.valueOf(b.Buffers[bu].Plane.Location.Y), ome.units.UNITS.MICROMETER);
                        ome.units.quantity.Length lz = new ome.units.quantity.Length(java.lang.Double.valueOf(b.Buffers[bu].Plane.Location.Z), ome.units.UNITS.MICROMETER);
                        omexml.setPlanePositionX(lx, serie, bu);
                        omexml.setPlanePositionY(ly, serie, bu);
                        omexml.setPlanePositionZ(lz, serie, bu);
                        omexml.setPlaneTheC(new NonNegativeInteger(java.lang.Integer.valueOf(b.Buffers[bu].Plane.Coordinate.C)), serie, bu);
                        omexml.setPlaneTheZ(new NonNegativeInteger(java.lang.Integer.valueOf(b.Buffers[bu].Plane.Coordinate.Z)), serie, bu);
                        omexml.setPlaneTheT(new NonNegativeInteger(java.lang.Integer.valueOf(b.Buffers[bu].Plane.Coordinate.T)), serie, bu);
 
                        omexml.setTiffDataPlaneCount(new NonNegativeInteger(java.lang.Integer.valueOf(1)), serie, bu);
                        omexml.setTiffDataIFD(new NonNegativeInteger(java.lang.Integer.valueOf(bu)), serie, bu);
                        omexml.setTiffDataFirstC(new NonNegativeInteger(java.lang.Integer.valueOf(b.Buffers[bu].Plane.Coordinate.C)), serie, bu);
                        omexml.setTiffDataFirstZ(new NonNegativeInteger(java.lang.Integer.valueOf(b.Buffers[bu].Plane.Coordinate.Z)), serie, bu);
                        omexml.setTiffDataFirstT(new NonNegativeInteger(java.lang.Integer.valueOf(b.Buffers[bu].Plane.Coordinate.T)), serie, bu);
 
                    }
 
            }
            writer.setMetadataRetrieve(omexml);
            f = f.Replace("\\", "/");
            writer.setId(f);
            status = "Saving OME Image Planes.";
            for (int i = 0; i < bms.Length; i++)
            {
                string file = bms[i].file;
                BioImage b = bms[i];
                writer.setSeries(i);
                for (int bu = 0; bu < b.Buffers.Count; bu++)
                {
                    progressValue = (float)bu / (float)b.Buffers.Count;
                    byte[] bts = b.Buffers[bu].GetSaveBytes(BitConverter.IsLittleEndian);
                    writer.saveBytes(bu, bts);
                }
            }
            bool stop = false;
            do
            {
                try
                {
                    writer.close();
                    stop = true;
                }
                catch (Exception e)
                {
                    //Scripting.LogLine(e.Message);
                }
 
            } while (!stop);
        }

References BioImager.ROI.GetPoint(), BioImager.BioImage.OMESupport(), BioImager.BioImage.OpenOME(), BioImager.ROI.PointsToString(), and BioImager.ImageView.PyramidalOrigin.

Referenced by BioImager.BioImage.SaveOME().

◆ SaveOMESeries() [2/2]

static void BioImager.BioImage.SaveOMESeries	(	string[]	files,
		string	f,
		bool	planes
	)

static

Definition at line 5516 of file Bio.cs.

        {
            BioImage[] bm = new BioImage[files.Length];
            for (int i = 0; i < files.Length; i++)
            {
                bm[i] = Images.GetImage(files[i]);
            }
            SaveOMESeries(bm,f,planes);
        }

◆ SavePyramidalAsync()

static async Task BioImager.BioImage.SavePyramidalAsync	(	BioImage[]	imgs,
		string	file,
		Enums.ForeignTiffCompression	com,
		int	compLevel
	)

static

The function SavePyramidalAsync saves an array of BioImage objects as a pyramidal TIFF file asynchronously.

Parameters

imgs	imgs is an array of BioImage objects.
file	The "file" parameter is a string that represents the file path where the pyramidal image will be saved.
com	The parameter "com" is of type Enums.ForeignTiffCompression, which is an enumeration representing different compression options for the TIFF file.
compLevel	The `compLevel` parameter is an integer that represents the compression level for the TIFF file. It is used to specify the level of compression to be applied to the image data when saving the pyramidal image. The higher the compression level, the smaller the file size but potentially lower image quality.

Definition at line 7157 of file Bio.cs.

        {
            bms = imgs;
            savefile = file;
            comp = com;
            compLev = compLevel;
            await Task.Run(SavePyramidalThread);
        }

◆ SaveSeries()

static void BioImager.BioImage.SaveSeries	(	string[]	IDs,
		string	file
	)

static

It takes a list of image IDs, and saves them as a single multi-page TIFF file.

Parameters

An	array of IDs of the images to save
The	path to the file to save to.

Definition at line 4503 of file Bio.cs.

        {
            string desc = "";
            int stride = 0;
            ImageJDesc j = new ImageJDesc();
            BioImage bi = Images.GetImage(IDs[0]);
            j.FromImage(bi);
            desc = j.GetString();
            for (int fi = 0; fi < IDs.Length; fi++)
            {
                string id = IDs[fi];
                BioImage b = Images.GetImage(id);
                string fn = Path.GetFileNameWithoutExtension(id);
                string dir = Path.GetDirectoryName(file);
                stride = b.Buffers[0].Stride;
 
                //Save ROIs to CSV file.
                if (b.Annotations.Count > 0)
                {
                    string f = dir + "//" + fn + ".csv";
                    ExportROIsCSV(f, b.Annotations);
                }
 
                //Embed ROI's to image description.
                for (int i = 0; i < b.Annotations.Count; i++)
                {
                    desc += "-ROI:" + b.series + ":" + ROIToString(b.Annotations[i]) + NewLine;
                }
                foreach (Channel c in b.Channels)
                {
                    string cj = JsonConvert.SerializeObject(c.info, Formatting.None);
                    desc += "-Channel:" + fi + ":" + cj + NewLine;
                }
                string json = JsonConvert.SerializeObject(b.imageInfo, Formatting.None);
                desc += "-ImageInfo:" + fi + ":" + json + NewLine;
            }
 
            Tiff image = Tiff.Open(file, "w");
            for (int fi = 0; fi < IDs.Length; fi++)
            {
                int im = 0;
                string id = IDs[fi];
                //Progress pr = new //Progress(file, "Saving");
                //pr.Show();
                //Application.DoEvents();
                BioImage b = Images.GetImage(id);
                int sizec = 1;
                if (!b.isRGB)
                {
                    sizec = b.SizeC;
                }
                byte[] buffer;
                for (int c = 0; c < sizec; c++)
                {
                    for (int z = 0; z < b.SizeZ; z++)
                    {
                        for (int t = 0; t < b.SizeT; t++)
                        {
                            image.SetDirectory((short)(im + (b.Buffers.Count * fi)));
                            image.SetField(TiffTag.IMAGEWIDTH, b.SizeX);
                            image.SetField(TiffTag.IMAGEDESCRIPTION, desc);
                            image.SetField(TiffTag.IMAGELENGTH, b.SizeY);
                            image.SetField(TiffTag.BITSPERSAMPLE, b.bitsPerPixel);
                            image.SetField(TiffTag.SAMPLESPERPIXEL, b.RGBChannelCount);
                            image.SetField(TiffTag.ROWSPERSTRIP, b.SizeY);
                            image.SetField(TiffTag.ORIENTATION, BitMiracle.LibTiff.Classic.Orientation.TOPLEFT);
                            image.SetField(TiffTag.PLANARCONFIG, PlanarConfig.CONTIG);
                            image.SetField(TiffTag.PHOTOMETRIC, Photometric.MINISBLACK);
                            image.SetField(TiffTag.ROWSPERSTRIP, image.DefaultStripSize(0));
                            if (b.PhysicalSizeX != -1 && b.PhysicalSizeY != -1)
                            {
                                image.SetField(TiffTag.XRESOLUTION, (b.PhysicalSizeX * b.SizeX) / ((b.PhysicalSizeX * b.SizeX) * b.PhysicalSizeX));
                                image.SetField(TiffTag.YRESOLUTION, (b.PhysicalSizeY * b.SizeY) / ((b.PhysicalSizeY * b.SizeY) * b.PhysicalSizeY));
                                image.SetField(TiffTag.RESOLUTIONUNIT, ResUnit.NONE);
                            }
                            else
                            {
                                image.SetField(TiffTag.XRESOLUTION, 100.0);
                                image.SetField(TiffTag.YRESOLUTION, 100.0);
                                image.SetField(TiffTag.RESOLUTIONUNIT, ResUnit.INCH);
                            }
                            // specify that it's a page within the multipage file
                            image.SetField(TiffTag.SUBFILETYPE, FileType.PAGE);
                            // specify the page number
                            buffer = b.Buffers[im].GetSaveBytes(true);
                            image.SetField(TiffTag.PAGENUMBER, im + (b.Buffers.Count * fi), b.Buffers.Count * IDs.Length);
                            for (int i = 0, offset = 0; i < b.SizeY; i++)
                            {
                                image.WriteScanline(buffer, offset, i, 0);
                                offset += stride;
                            }
                            image.WriteDirectory();
                            //pr.Update//ProgressF((float)im / (float)b.ImageCount);
                            //Application.DoEvents();
                            im++;
                        }
                    }
                }
                //pr.Close();
            }
            image.Dispose();
 
        }

References BioImager.BioImage.ExportROIsCSV(), BioImager.BioImage.ImageJDesc.FromImage(), BioImager.BioImage.ImageJDesc.GetString(), and BioImager.BioImage.ROIToString().

Referenced by BioImager.BioImage.SaveFile().

◆ SaveSeriesAsync()

static async Task BioImager.BioImage.SaveSeriesAsync	(	BioImage[]	imgs,
		string	file,
		bool	ome
	)

static

The function SaveSeriesAsync saves a series of BioImage objects to a file asynchronously.

Parameters

imgs	imgs is an array of BioImage objects.
file	The "file" parameter is a string that represents the file path where the series of BioImages will be saved.
ome	The "ome" parameter is a boolean flag that indicates whether the images should be saved in OME-TIFF format or not. If "ome" is set to true, the images will be saved in OME-TIFF format. If "ome" is set to false, the images will be

Definition at line 7126 of file Bio.cs.

        {
            sts.Clear();
            foreach (BioImage item in imgs)
            {
                sts.Add(item.ID);
            }
            savefile = file;
            some = ome;
            await Task.Run(SaveSeriesThread);
        }

◆ SetLabelMacroResolutions()

void BioImager.BioImage.SetLabelMacroResolutions ( )

Definition at line 2489 of file Bio.cs.

        {
            int i = 0;
            AForge.Size s = new AForge.Size(int.MaxValue, int.MaxValue);
            bool noMacro = true;
            PixelFormat pf = Resolutions[0].PixelFormat;
            foreach (Resolution res in Resolutions)
            {
                if (res.SizeX < s.Width && res.SizeY < s.Height)
                {
                    //If the pixel format changes it means this is the macro resolution.
                    if (pf != res.PixelFormat)
                    {
                        noMacro = false;
                        break;
                    }
                    pf = res.PixelFormat;
                    s = new AForge.Size(res.SizeX, res.SizeY);
                }
                else
                {
                    //If this level is bigger than the previous this is the macro resolution.
                    noMacro = false;
                    break;
                }
                i++;
            }
            if (!noMacro)
            {
                MacroResolution = i;
                LabelResolution = i + 1;
            }
  
        }

◆ SetValue() [1/3]

void BioImager.BioImage.SetValue	(	int	x,
		int	y,
		int	ind,
		ushort	value
	)

It sets the value of a pixel in a buffer

Parameters

x	The x coordinate of the pixel to set.
y	The y coordinate of the pixel to set.
ind	The index of the buffer to set the value in.
value	The value to set the pixel to.

Definition at line 4108 of file Bio.cs.

        {
            Buffers[ind].SetValue(x, y, value);
        }

◆ SetValue() [2/3]

void BioImager.BioImage.SetValue	(	int	x,
		int	y,
		ZCT	coord,
		ushort	value
	)

This function sets the value of a pixel at a given x,y coordinate in a given image plane

Parameters

x	x coordinate of the pixel
y	The y coordinate of the pixel to set.
ZCT	a struct that contains the Z, C, and T coordinates of the pixel
value	the value to set

Definition at line 4118 of file Bio.cs.

        {
            SetValue(x, y, Coords[coord.Z, coord.C, coord.T], value);
        }

References BioImager.BioImage.SetValue().

◆ SetValue() [3/3]

void BioImager.BioImage.SetValue	(	ZCTXY	coord,
		ushort	value
	)

It takes a coordinate and a value, and sets the value at that coordinate

Parameters

ZCTXY	a struct that contains the Z, C, T, X, and Y coordinates of the pixel
value	the value to be set

Definition at line 4097 of file Bio.cs.

        {
            int i = Coords[coord.Z, coord.C, coord.T];
            Buffers[i].SetValue(coord.X, coord.Y, value);
        }

Referenced by BioImager.BioImage.SetValue().

◆ SetValueRGB()

void BioImager.BioImage.SetValueRGB	(	ZCTXY	coord,
		int	RGBindex,
		ushort	value
	)

It takes a coordinate, an RGB index, and a value, and sets the value of the pixel at that coordinate to the value

Parameters

ZCTXY	a struct that contains the Z, C, T, X, and Y coordinates of the pixel
RGBindex	0 = Red, 1 = Green, 2 = Blue
value	the value to be set

Definition at line 4128 of file Bio.cs.

        {
            int ind = Coords[coord.Z, coord.C, coord.T];
            Buffers[ind].SetValueRGB(coord.X, coord.Y, RGBindex, value);
        }

◆ SplitChannels() [1/3]

BioImage[] BioImager.BioImage.SplitChannels ( )

It takes a single image and splits it into three images, one for each channel

Returns: A list of BioImages

Definition at line 3768 of file Bio.cs.

        {
            BioImage[] bms;
            if (isRGB)
            {
                bms = new BioImage[3];
                BioImage ri = new BioImage(Path.GetFileNameWithoutExtension(ID) + "-1" + Path.GetExtension(ID));
                BioImage gi = new BioImage(Path.GetFileNameWithoutExtension(ID) + "-2" + Path.GetExtension(ID));
                BioImage bi = new BioImage(Path.GetFileNameWithoutExtension(ID) + "-3" + Path.GetExtension(ID));
                ri.sizeC = 1;
                gi.sizeC = 1;
                bi.sizeC = 1;
                ri.sizeZ = SizeZ;
                gi.sizeZ = SizeZ;
                bi.sizeZ = SizeZ;
                ri.sizeT = SizeT;
                gi.sizeT = SizeT;
                bi.sizeT = SizeT;
 
                ri.Coords = new int[SizeZ, 1, SizeT];
                gi.Coords = new int[SizeZ, 1, SizeT];
                bi.Coords = new int[SizeZ, 1, SizeT];
                int ind = 0;
                for (int i = 0; i < ImageCount; i++)
                {
                    if (Buffers[i].PixelFormat == PixelFormat.Format48bppRgb)
                    {
                        //For 48bit images we need to use our own function as AForge won't give us a proper image.
                        Bitmap[] bfs = Bitmap.RGB48To16(ID, SizeX, SizeY, Buffers[i].Stride, Buffers[i].Bytes, Buffers[i].Coordinate, ind, Buffers[i].Plane);
                        ind += 3;
                        ri.Buffers.Add(bfs[0]);
                        gi.Buffers.Add(bfs[1]);
                        bi.Buffers.Add(bfs[2]);
                        Statistics.CalcStatistics(bfs[0]);
                        Statistics.CalcStatistics(bfs[1]);
                        Statistics.CalcStatistics(bfs[2]);
                        ri.Coords[Buffers[i].Coordinate.Z, Buffers[i].Coordinate.C, Buffers[i].Coordinate.T] = i;
                        gi.Coords[Buffers[i].Coordinate.Z, Buffers[i].Coordinate.C, Buffers[i].Coordinate.T] = i;
                        bi.Coords[Buffers[i].Coordinate.Z, Buffers[i].Coordinate.C, Buffers[i].Coordinate.T] = i;
                    }
                    else
                    {
 
                        Bitmap rImage = extractR.Apply(Buffers[i]);
                        Bitmap rbf = new Bitmap(ri.ID, rImage, Buffers[i].Coordinate, ind++);
                        Statistics.CalcStatistics(rbf);
                        ri.Buffers.Add(rbf);
                        ri.Coords[Buffers[i].Coordinate.Z, Buffers[i].Coordinate.C, Buffers[i].Coordinate.T] = i;
 
                        Bitmap gImage = extractG.Apply(Buffers[i]);
                        Bitmap gbf = new Bitmap(gi.ID, gImage, Buffers[i].Coordinate, ind++);
                        Statistics.CalcStatistics(gbf);
                        gi.Buffers.Add(gbf);
                        gi.Coords[Buffers[i].Coordinate.Z, Buffers[i].Coordinate.C, Buffers[i].Coordinate.T] = i;
 
                        Bitmap bImage = extractB.Apply(Buffers[i]);
                        //Clipboard.SetImage(bImage);
                        Bitmap bbf = new Bitmap(bi.ID, bImage, Buffers[i].Coordinate, ind++);
                        Statistics.CalcStatistics(bbf);
                        bi.Buffers.Add(bbf);
                        bi.Coords[Buffers[i].Coordinate.Z, Buffers[i].Coordinate.C, Buffers[i].Coordinate.T] = i;
 
                    }
                }
                //We wait for threshold image statistics calculation
                do
                {
                    Thread.Sleep(100);
                } while (bi.Buffers[bi.Buffers.Count - 1].Stats == null);
                ri.Resolutions.Add(new Resolution(Buffers[0].SizeX, Buffers[0].SizeY, Buffers[0].PixelFormat, PhysicalSizeX, PhysicalSizeY, PhysicalSizeZ, StageSizeX, StageSizeY, StageSizeZ));
                gi.Resolutions.Add(new Resolution(Buffers[0].SizeX, Buffers[0].SizeY, Buffers[0].PixelFormat, PhysicalSizeX, PhysicalSizeY, PhysicalSizeZ, StageSizeX, StageSizeY, StageSizeZ));
                bi.Resolutions.Add(new Resolution(Buffers[0].SizeX, Buffers[0].SizeY, Buffers[0].PixelFormat, PhysicalSizeX, PhysicalSizeY, PhysicalSizeZ, StageSizeX, StageSizeY, StageSizeZ));
                ri.Channels.Add(Channels[0].Copy());
                gi.Channels.Add(Channels[0].Copy());
                bi.Channels.Add(Channels[0].Copy());
                AutoThreshold(ri, false);
                AutoThreshold(gi, false);
                AutoThreshold(bi, false);
                Images.AddImage(ri, true);
                Images.AddImage(gi, true);
                Images.AddImage(bi, true);
                Statistics.ClearCalcBuffer();
                bms[0] = ri;
                bms[1] = gi;
                bms[2] = bi;
            }
            else
            {
                bms = new BioImage[SizeC];
                for (int c = 0; c < SizeC; c++)
                {
                    BioImage b = BioImage.Substack(this, 0, 0, SizeZ, c, c + 1, 0, SizeT);
                    bms[c] = b;
                }
            }
 
            Statistics.ClearCalcBuffer();
            Recorder.AddLine("Bio.BioImage.SplitChannels(" + '"' + Filename + '"' + ");");
            return bms;
        }

References BioImager.BioImage.AutoThreshold(), BioImager.BioImage.Copy(), and BioImager.BioImage.Substack().

Referenced by BioImager.BioImage.SplitChannels().

◆ SplitChannels() [2/3]

static BioImage[] BioImager.BioImage.SplitChannels ( BioImage bb )

static

‍SplitChannels splits a BioImage into its constituent channels

Parameters

BioImage The image to split

Returns: An array of BioImages

Definition at line 3873 of file Bio.cs.

        {
            return bb.SplitChannels();
        }

References BioImager.BioImage.SplitChannels().

◆ SplitChannels() [3/3]

static BioImage[] BioImager.BioImage.SplitChannels ( string name )

static

This function takes an image and splits it into its individual channels

Parameters

name	The name of the image to split.

Returns: An array of BioImage objects.

Definition at line 3882 of file Bio.cs.

        {
            return SplitChannels(Images.GetImage(name));
        }

References BioImager.BioImage.SplitChannels().

◆ StackThreshold()

void BioImager.BioImage.StackThreshold ( bool bit16 )

This function sets the minimum and maximum values of the image to the minimum and maximum values of the stack

Parameters

bit16 true = 16 bit, false = 8 bit

Definition at line 6843 of file Bio.cs.

        {
            if (bit16)
            {
                for (int ch = 0; ch < Channels.Count; ch++)
                {
                    for (int i = 0; i < Channels[ch].range.Length; i++)
                    {
                        Channels[ch].range[i].Min = (int)Channels[ch].stats[i].StackMin;
                        Channels[ch].range[i].Max = (int)Channels[ch].stats[i].StackMax;
                    }
                    Channels[ch].BitsPerPixel = 16;
                }
                bitsPerPixel = 16;
            }
            else
            {
                for (int ch = 0; ch < Channels.Count; ch++)
                {
                    for (int i = 0; i < Channels[ch].range.Length; i++)
                    {
                        Channels[ch].range[i].Min = (int)Channels[ch].stats[i].StackMin;
                        Channels[ch].range[i].Max = (int)Channels[ch].stats[i].StackMax;
                    }
                    Channels[ch].BitsPerPixel = 8;
                }
                bitsPerPixel = 8;
            }
        }

Referenced by BioImager.BioImage.MergeChannels(), BioImager.BioImage.MergeT(), BioImager.BioImage.MergeZ(), BioImager.BioImage.OpenFile(), BioImager.BioImage.OpenOME(), BioImager.BioImage.Substack(), BioImager.BioImage.To16Bit(), BioImager.BioImage.To24Bit(), BioImager.BioImage.To48Bit(), and BioImager.BioImage.UpdateBuffersPyramidal().

◆ StringToROI()

static ROI BioImager.BioImage.StringToROI ( string sts )

static

It takes a string and returns an ROI object

Parameters

sts	the string that contains the ROI data

Returns: A ROI object.

Definition at line 7737 of file Bio.cs.

        {
            //Works with either comma or tab separated values.
            if (sts.StartsWith("<?xml") || sts.StartsWith("{"))
                return null;
            ROI an = new ROI();
            string val = "";
            bool inSep = false;
            int col = 0;
            double x = 0;
            double y = 0;
            double w = 0;
            double h = 0;
            string line = sts;
            bool points = false;
            char sep = '"';
            for (int i = 0; i < line.Length; i++)
            {
                char c = line[i];
                if (c == sep)
                {
                    if (!inSep)
                    {
                        inSep = true;
                    }
                    else
                        inSep = false;
                    continue;
                }
 
                if ((c == ',' || c == '\t') && (!inSep || points))
                {
                    //ROIID,ROINAME,TYPE,ID,SHAPEINDEX,TEXT,C,Z,T,X,Y,W,H,POINTS,STROKECOLOR,STROKECOLORW,FILLCOLOR,FONTSIZE
                    if (col == 0)
                    {
                        //ROIID
                        an.roiID = val;
                    }
                    else
                    if (col == 1)
                    {
                        //ROINAME
                        an.roiName = val;
                    }
                    else
                    if (col == 2)
                    {
                        //TYPE
                        an.type = (ROI.Type)Enum.Parse(typeof(ROI.Type), val);
                        if (an.type == ROI.Type.Freeform || an.type == ROI.Type.Polygon)
                            an.closed = true;
                    }
                    else
                    if (col == 3)
                    {
                        //ID
                        an.id = val;
                    }
                    else
                    if (col == 4)
                    {
                        //SHAPEINDEX/
                        an.shapeIndex = int.Parse(val);
                    }
                    else
                    if (col == 5)
                    {
                        //TEXT/
                        an.Text = val;
                    }
                    else
                    if (col == 6)
                    {
                        an.serie = int.Parse(val);
                    }
                    else
                    if (col == 7)
                    {
                        an.coord.Z = int.Parse(val);
                    }
                    else
                    if (col == 8)
                    {
                        an.coord.C = int.Parse(val);
                    }
                    else
                    if (col == 9)
                    {
                        an.coord.T = int.Parse(val);
                    }
                    else
                    if (col == 10)
                    {
                        x = double.Parse(val, CultureInfo.InvariantCulture);
                    }
                    else
                    if (col == 11)
                    {
                        y = double.Parse(val, CultureInfo.InvariantCulture);
                    }
                    else
                    if (col == 12)
                    {
                        w = double.Parse(val, CultureInfo.InvariantCulture);
                    }
                    else
                    if (col == 13)
                    {
                        h = double.Parse(val, CultureInfo.InvariantCulture);
                    }
                    else
                    if (col == 14)
                    {
                        //POINTS
                        an.AddPoints(an.stringToPoints(val));
                        points = false;
                        an.Rect = new RectangleD(x, y, w, h);
                    }
                    else
                    if (col == 15)
                    {
                        //STROKECOLOR
                        string[] st = val.Split(',');
                        an.strokeColor = System.Drawing.Color.FromArgb(int.Parse(st[0]), int.Parse(st[1]), int.Parse(st[2]), int.Parse(st[3]));
                    }
                    else
                    if (col == 16)
                    {
                        //STROKECOLORW
                        an.strokeWidth = double.Parse(val, CultureInfo.InvariantCulture);
                    }
                    else
                    if (col == 17)
                    {
                        //FILLCOLOR
                        string[] st = val.Split(',');
                        an.fillColor = System.Drawing.Color.FromArgb(int.Parse(st[0]), int.Parse(st[1]), int.Parse(st[2]), int.Parse(st[3]));
                    }
                    else
                    if (col == 18)
                    {
                        //FONTSIZE
                        double s = double.Parse(val, CultureInfo.InvariantCulture);
                        an.fontSize = (float)s;
                        an.family = "Times New Roman";
                    }
                    col++;
                    val = "";
                }
                else
                    val += c;
            }
 
            return an;
        }

References BioImager.ROI.AddPoints(), and BioImager.ROI.stringToPoints().

Referenced by BioImager.App.AddROI(), BioImager.BioImage.ImportROIsCSV(), BioImager.BioImage.OpenFile(), and BioImager.ImageView.PasteSelection().

◆ Substack()

static BioImage BioImager.BioImage.Substack	(	BioImage	orig,
		int	ser,
		int	zs,
		int	ze,
		int	cs,
		int	ce,
		int	ts,
		int	te
	)

static

It takes a BioImage object, and returns a new BioImage object that is a subset of the original

Parameters

BioImage	the image to be processed
ser	series number
zs	starting z-plane
ze	end of z-stack
cs	channel start
ce	channel end
ts	time start
te	time end

Returns: A new BioImage object.

Definition at line 3529 of file Bio.cs.

        {
            BioImage b = CopyInfo(orig, false, false);
            b.ID = Images.GetImageName(orig.ID);
            int i = 0;
            b.Coords = new int[ze - zs, ce - cs, te - ts];
            b.sizeZ = ze - zs;
            b.sizeC = ce - cs;
            b.sizeT = te - ts;
            for (int ti = 0; ti < b.SizeT; ti++)
            {
                for (int zi = 0; zi < b.SizeZ; zi++)
                {
                    for (int ci = 0; ci < b.SizeC; ci++)
                    {
                        int ind = orig.Coords[zs + zi, cs + ci, ts + ti];
                        Bitmap bf = new Bitmap(Images.GetImageName(orig.id), orig.SizeX, orig.SizeY, orig.Buffers[0].PixelFormat, orig.Buffers[ind].Bytes, new ZCT(zi, ci, ti), i);
                        Statistics.CalcStatistics(bf);
                        b.Buffers.Add(bf);
                        b.Coords[zi, ci, ti] = i;
                        i++;
                    }
                }
            }
            for (int ci = cs; ci < ce; ci++)
            {
                b.Channels.Add(orig.Channels[ci]);
            }
            //We wait for threshold image statistics calculation
            do
            {
                Thread.Sleep(100);
            } while (b.Buffers[b.Buffers.Count - 1].Stats == null);
            Statistics.ClearCalcBuffer();
            b.Resolutions.Add(new Resolution(b.Buffers[0].SizeX, b.Buffers[0].SizeY, b.Buffers[0].PixelFormat, b.PhysicalSizeX, b.PhysicalSizeY, b.PhysicalSizeZ, b.StageSizeX, b.StageSizeY, b.StageSizeZ));
            AutoThreshold(b, false);
            if (b.bitsPerPixel > 8)
                b.StackThreshold(true);
            else
                b.StackThreshold(false);
            Images.AddImage(b, true);
            Recorder.AddLine("Bio.BioImage.Substack(" + '"' + orig.Filename + '"' + "," + ser + "," + zs + "," + ze + "," + cs + "," + ce + "," + ts + "," + te + ");");
            return b;
        }

References BioImager.BioImage.AutoThreshold(), BioImager.BioImage.CopyInfo(), and BioImager.BioImage.StackThreshold().

Referenced by BioImager.BioImage.SplitChannels().

◆ To16Bit()

void BioImager.BioImage.To16Bit ( )

Converts the image to 16 bit.

Definition at line 2760 of file Bio.cs.

        {
            if (Buffers[0].RGBChannelsCount == 4)
                To24Bit();
            if (Buffers[0].PixelFormat == PixelFormat.Format16bppGrayScale)
                return;
            bitsPerPixel = 16;
            if (Buffers[0].PixelFormat == PixelFormat.Format48bppRgb)
            {
                List<Bitmap> bfs = new List<Bitmap>();
                int index = 0;
                for (int i = 0; i < Buffers.Count; i++)
                {
                    Array.Reverse(Buffers[i].Bytes);
                    Bitmap[] bs = Bitmap.RGB48To16(ID, SizeX, SizeY, Buffers[i].Stride, Buffers[i].Bytes, Buffers[i].Coordinate, index, Buffers[i].Plane);
                    bfs.AddRange(bs);
                    index += 3;
                }
                Buffers = bfs;
                UpdateCoords(SizeZ, SizeC * 3, SizeT);
                if (Channels[0].SamplesPerPixel == 3)
                {
                    Channel c = Channels[0].Copy();
                    c.SamplesPerPixel = 1;
                    c.range = new IntRange[1];
                    Channels.Clear();
                    Channels.Add(c);
                    Channels.Add(c.Copy());
                    Channels.Add(c.Copy());
                    Channels[1].Index = 1;
                    Channels[2].Index = 2;
                }
            }
            else if (Buffers[0].PixelFormat == PixelFormat.Format8bppIndexed)
            {
                for (int i = 0; i < Buffers.Count; i++)
                {
                    Buffers[i].Image = AForge.Imaging.Image.Convert8bppTo16bpp(Buffers[i]);
                    Statistics.CalcStatistics(Buffers[i]);
                }
                for (int c = 0; c < Channels.Count; c++)
                {
                    for (int i = 0; i < Channels[c].range.Length; i++)
                    {
                        Channels[c].range[i].Min = (int)(((float)Channels[c].range[i].Min / (float)byte.MaxValue) * ushort.MaxValue);
                        Channels[c].range[i].Max = (int)(((float)Channels[c].range[i].Max / (float)byte.MaxValue) * ushort.MaxValue);
                    }
                    Channels[c].BitsPerPixel = 16;
                }
            }
            else if (Buffers[0].PixelFormat == PixelFormat.Format24bppRgb)
            {
                List<Bitmap> bfs = new List<Bitmap>();
                int index = 0;
                for (int i = 0; i < Buffers.Count; i++)
                {
                    Bitmap[] bs = Bitmap.RGB24To8(Buffers[i]);
                    Bitmap br = new Bitmap(ID, bs[2].Image, new ZCT(Buffers[i].Coordinate.Z, 0, Buffers[i].Coordinate.T), index, Buffers[i].Plane);
                    Bitmap bg = new Bitmap(ID, bs[1].Image, new ZCT(Buffers[i].Coordinate.Z, 1, Buffers[i].Coordinate.T), index + 1, Buffers[i].Plane);
                    Bitmap bb = new Bitmap(ID, bs[0].Image, new ZCT(Buffers[i].Coordinate.Z, 2, Buffers[i].Coordinate.T), index + 2, Buffers[i].Plane);
                    for (int b = 0; b < 3; b++)
                    {
                        bs[b].Dispose();
                        bs[b] = null;
                    }
                    bs = null;
                    GC.Collect();
                    br.To16Bit();
                    bg.To16Bit();
                    bb.To16Bit();
                    Statistics.CalcStatistics(br);
                    Statistics.CalcStatistics(bg);
                    Statistics.CalcStatistics(bb);
                    bfs.Add(br);
                    bfs.Add(bg);
                    bfs.Add(bb);
                    index += 3;
                }
                Buffers = bfs;
                UpdateCoords(SizeZ, 3, SizeT);
                for (int c = 0; c < Channels.Count; c++)
                {
                    for (int i = 0; i < Channels[c].range.Length; i++)
                    {
                        Channels[c].range[i].Min = (int)(((float)Channels[c].range[i].Min / (float)byte.MaxValue) * ushort.MaxValue);
                        Channels[c].range[i].Max = (int)(((float)Channels[c].range[i].Max / (float)byte.MaxValue) * ushort.MaxValue);
                    }
                    Channels[c].BitsPerPixel = 16;
                }
            }
            //We wait for threshold image statistics calculation
            do
            {
                Thread.Sleep(100);
            } while (Buffers[Buffers.Count - 1].Stats == null);
            Statistics.ClearCalcBuffer();
            AutoThreshold(this, false);
            StackThreshold(true);
            App.viewer.UpdateImages();
            App.viewer.UpdateView();
            Recorder.AddLine("Bio.Images.GetImage(" + '"' + ID + '"' + ")" + "." + "To16Bit();");
        }

References BioImager.BioImage.AutoThreshold(), BioImager.BioImage.StackThreshold(), BioImager.BioImage.To24Bit(), BioImager.BioImage.UpdateCoords(), BioImager.ImageView.UpdateImages(), and BioImager.ImageView.UpdateView().

◆ To24Bit()

void BioImager.BioImage.To24Bit ( )

Converts the image to 24 bit.

Definition at line 2863 of file Bio.cs.

        {
            if (Buffers[0].PixelFormat == PixelFormat.Format24bppRgb)
                return;
            bitsPerPixel = 8;
            if (Buffers[0].PixelFormat == PixelFormat.Format32bppArgb || Buffers[0].PixelFormat == PixelFormat.Format32bppRgb)
            {
                for (int i = 0; i < Buffers.Count; i++)
                {
                    Buffers[i] = Bitmap.To24Bit(Buffers[i]);
                    Buffers[i].SwitchRedBlue();
                }
                if (Channels.Count == 4)
                {
                    Channels.RemoveAt(0);
                }
                else
                {
                    Channels[0].SamplesPerPixel = 3;
                }
            }
            else
            if (Buffers[0].PixelFormat == PixelFormat.Format48bppRgb)
            {
                //We run 8bit so we get 24 bit rgb.
                for (int i = 0; i < Buffers.Count; i++)
                {
                    Buffers[i].Image = AForge.Imaging.Image.Convert16bppTo8bpp(Buffers[i]);
                }
            }
            else
            if (Buffers[0].PixelFormat == PixelFormat.Format16bppGrayScale || Buffers[0].PixelFormat == PixelFormat.Format8bppIndexed)
            {
                if (Buffers[0].PixelFormat == PixelFormat.Format16bppGrayScale)
                {
                    for (int i = 0; i < Buffers.Count; i++)
                    {
                        Buffers[i].Image = AForge.Imaging.Image.Convert16bppTo8bpp(Buffers[i]);
                    }
                    for (int c = 0; c < Channels.Count; c++)
                    {
                        for (int i = 0; i < Channels[c].range.Length; i++)
                        {
                            Channels[c].range[i].Min = (int)(((float)Channels[c].range[i].Min / (float)ushort.MaxValue) * byte.MaxValue);
                            Channels[c].range[i].Max = (int)(((float)Channels[c].range[i].Max / (float)ushort.MaxValue) * byte.MaxValue);
                        }
                        Channels[c].BitsPerPixel = 8;
                    }
                }
                List<Bitmap> bfs = new List<Bitmap>();
                if (Buffers.Count % 3 != 0 && Buffers.Count % 2 != 0)
                    for (int i = 0; i < Buffers.Count; i++)
                    {
                        Bitmap bs = new Bitmap(ID, SizeX, SizeY, Buffers[i].PixelFormat, Buffers[i].Bytes, new ZCT(Buffers[i].Coordinate.Z, 0, Buffers[i].Coordinate.T), i, Buffers[i].Plane);
                        Bitmap bbs = Bitmap.RGB16To48(bs);
                        bs.Dispose();
                        bs = null;
                        bfs.Add(bbs);
                    }
                else
                    for (int i = 0; i < Buffers.Count; i += Channels.Count)
                    {
                        Bitmap[] bs = new Bitmap[3];
                        bs[2] = new Bitmap(ID, SizeX, SizeY, Buffers[i].PixelFormat, Buffers[i].Bytes, new ZCT(Buffers[i].Coordinate.Z, 0, Buffers[i].Coordinate.T), i, Buffers[i].Plane);
                        bs[1] = new Bitmap(ID, SizeX, SizeY, Buffers[i + 1].PixelFormat, Buffers[i + 1].Bytes, new ZCT(Buffers[i + 1].Coordinate.Z, 0, Buffers[i + 1].Coordinate.T), i + 1, Buffers[i + 1].Plane);
                        if (Channels.Count > 2)
                            bs[0] = new Bitmap(ID, SizeX, SizeY, Buffers[i + 2].PixelFormat, Buffers[i + 2].Bytes, new ZCT(Buffers[i + 2].Coordinate.Z, 0, Buffers[i + 2].Coordinate.T), i + 2, Buffers[i + 2].Plane);
                        Bitmap bbs = Bitmap.RGB8To24(bs);
                        for (int b = 0; b < 3; b++)
                        {
                            if (bs[b] != null)
                                bs[b].Dispose();
                            bs[b] = null;
                        }
                        bfs.Add(bbs);
                    }
                Buffers = bfs;
                UpdateCoords(SizeZ, 1, SizeT);
            }
            Recorder.AddLine("Bio.Images.GetImage(" + '"' + ID + '"' + ")" + "." + "To24Bit();");
            AutoThreshold(this, true);
            StackThreshold(false);
            App.viewer.UpdateImages();
            App.viewer.UpdateView();
        }

References BioImager.BioImage.AutoThreshold(), BioImager.BioImage.StackThreshold(), BioImager.BioImage.UpdateCoords(), BioImager.ImageView.UpdateImages(), and BioImager.ImageView.UpdateView().

Referenced by BioImager.BioImage.To16Bit(), BioImager.BioImage.To32Bit(), BioImager.BioImage.To48Bit(), and BioImager.BioImage.To8Bit().

◆ To32Bit()

void BioImager.BioImage.To32Bit ( )

Converts the image to 32 bit.

Definition at line 2949 of file Bio.cs.

        {
            if (Buffers[0].PixelFormat == PixelFormat.Format32bppArgb)
                return;
            if (Buffers[0].PixelFormat != PixelFormat.Format24bppRgb)
            {
                To24Bit();
            }
            for (int i = 0; i < Buffers.Count; i++)
            {
                UnmanagedImage b = Bitmap.To32Bit(Buffers[i]);
                Buffers[i].Image = b;
            }
            AutoThreshold(this, true);
            App.viewer.UpdateImages();
            App.viewer.UpdateView();
            Recorder.AddLine("Bio.Images.GetImage(" + '"' + ID + '"' + ")" + "." + "To32Bit();");
        }

References BioImager.BioImage.AutoThreshold(), BioImager.BioImage.To24Bit(), BioImager.BioImage.To32Bit(), BioImager.ImageView.UpdateImages(), and BioImager.ImageView.UpdateView().

Referenced by BioImager.BioImage.To32Bit().

◆ To48Bit()

void BioImager.BioImage.To48Bit ( )

It converts a 16 bit image to a 48 bit image

Returns: A list of Bitmaps.

Definition at line 2970 of file Bio.cs.

        {
            if (Buffers[0].RGBChannelsCount == 4)
                To24Bit();
            if (Buffers[0].PixelFormat == PixelFormat.Format48bppRgb)
                return;
            if (Buffers[0].PixelFormat == PixelFormat.Format8bppIndexed || Buffers[0].PixelFormat == PixelFormat.Format16bppGrayScale)
            {
                if (Buffers[0].PixelFormat == PixelFormat.Format8bppIndexed)
                {
                    for (int i = 0; i < Buffers.Count; i++)
                    {
                        Buffers[i].Image = AForge.Imaging.Image.Convert8bppTo16bpp(Buffers[i]);
                    }
                }
                List<Bitmap> bfs = new List<Bitmap>();
                if (Buffers.Count % 3 != 0 && Buffers.Count % 2 != 0)
                    for (int i = 0; i < Buffers.Count; i++)
                    {
                        Bitmap bs = new Bitmap(ID, SizeX, SizeY, Buffers[i].PixelFormat, Buffers[i].Bytes, new ZCT(Buffers[i].Coordinate.Z, 0, Buffers[i].Coordinate.T), i, Buffers[i].Plane);
                        Bitmap bbs = Bitmap.RGB16To48(bs);
                        Statistics.CalcStatistics(bbs);
                        bs.Dispose();
                        bs = null;
                        bfs.Add(bbs);
                    }
                else
                    for (int i = 0; i < Buffers.Count; i += Channels.Count)
                    {
                        Bitmap[] bs = new Bitmap[3];
                        bs[0] = new Bitmap(ID, SizeX, SizeY, Buffers[i + 2].PixelFormat, Buffers[i + 2].Bytes, new ZCT(Buffers[i + 2].Coordinate.Z, 0, Buffers[i + 2].Coordinate.T), i + 2, Buffers[i + 2].Plane);
                        bs[1] = new Bitmap(ID, SizeX, SizeY, Buffers[i + 1].PixelFormat, Buffers[i + 1].Bytes, new ZCT(Buffers[i + 1].Coordinate.Z, 0, Buffers[i + 1].Coordinate.T), i + 1, Buffers[i + 1].Plane);
                        if (Channels.Count > 2)
                            bs[2] = new Bitmap(ID, SizeX, SizeY, Buffers[i].PixelFormat, Buffers[i].Bytes, new ZCT(Buffers[i].Coordinate.Z, 0, Buffers[i].Coordinate.T), i, Buffers[i].Plane);
                        Bitmap bbs = Bitmap.RGB16To48(bs);
                        for (int b = 0; b < 3; b++)
                        {
                            if (bs[b] != null)
                                bs[b].Dispose();
                            bs[b] = null;
                        }
                        Statistics.CalcStatistics(bbs);
                        bfs.Add(bbs);
                    }
                GC.Collect();
                Buffers = bfs;
                UpdateCoords(SizeZ, 1, SizeT);
                Channel c = Channels[0].Copy();
                c.SamplesPerPixel = 3;
                rgbChannels[0] = 0;
                rgbChannels[1] = 0;
                rgbChannels[2] = 0;
                Channels.Clear();
                Channels.Add(c);
            }
            else
            if (Buffers[0].PixelFormat == PixelFormat.Format24bppRgb)
            {
                for (int i = 0; i < Buffers.Count; i++)
                {
                    Buffers[i].Image = AForge.Imaging.Image.Convert8bppTo16bpp(Buffers[i]);
                    Statistics.CalcStatistics(Buffers[i]);
                }
                for (int c = 0; c < Channels.Count; c++)
                {
                    for (int i = 0; i < Channels[c].range.Length; i++)
                    {
                        Channels[c].range[i].Min = (int)(((float)Channels[c].range[i].Min / (float)byte.MaxValue) * ushort.MaxValue);
                        Channels[c].range[i].Max = (int)(((float)Channels[c].range[i].Max / (float)byte.MaxValue) * ushort.MaxValue);
                    }
                    Channels[c].BitsPerPixel = 16;
                }
            }
            else
            {
                int index = 0;
                List<Bitmap> buffers = new List<Bitmap>();
                for (int i = 0; i < Buffers.Count; i += 3)
                {
                    Bitmap[] bf = new Bitmap[3];
                    bf[0] = Buffers[i];
                    bf[1] = Buffers[i + 1];
                    bf[2] = Buffers[i + 2];
                    Bitmap inf = Bitmap.RGB16To48(bf);
                    buffers.Add(inf);
                    Statistics.CalcStatistics(inf);
                    for (int b = 0; b < 3; b++)
                    {
                        bf[b].Dispose();
                    }
                    index++;
                }
                Buffers = buffers;
                UpdateCoords(SizeZ, 1, SizeT);
            }
            //We wait for threshold image statistics calculation
            do
            {
                Thread.Sleep(50);
            } while (Buffers[Buffers.Count - 1].Stats == null);
            Statistics.ClearCalcBuffer();
            bitsPerPixel = 16;
            AutoThreshold(this, false);
            StackThreshold(true);
            App.viewer.UpdateImages();
            App.viewer.UpdateView();
            Recorder.AddLine("Bio.Images.GetImage(" + '"' + ID + '"' + ")" + "." + "To48Bit();");
        }

References BioImager.BioImage.AutoThreshold(), BioImager.BioImage.StackThreshold(), BioImager.BioImage.To24Bit(), BioImager.BioImage.UpdateCoords(), BioImager.ImageView.UpdateImages(), and BioImager.ImageView.UpdateView().

◆ To8Bit()

void BioImager.BioImage.To8Bit ( )

Converts a 16-bit image to an 8-bit image.

Definition at line 2665 of file Bio.cs.

        {
            if (Buffers[0].RGBChannelsCount == 4)
                To24Bit();
            PixelFormat px = Buffers[0].PixelFormat;
            if (px == PixelFormat.Format8bppIndexed)
                return;
            if (px == PixelFormat.Format48bppRgb)
            {
                To24Bit();
                List<AForge.Bitmap> bfs = new List<AForge.Bitmap>();
                int index = 0;
                for (int i = 0; i < Buffers.Count; i++)
                {
                    Bitmap[] bs = Bitmap.RGB24To8(Buffers[i]);
                    Bitmap br = new Bitmap(ID, bs[2], new ZCT(Buffers[i].Coordinate.Z, 0, Buffers[i].Coordinate.T), index, Buffers[i].Plane);
                    Bitmap bg = new Bitmap(ID, bs[1], new ZCT(Buffers[i].Coordinate.Z, 1, Buffers[i].Coordinate.T), index + 1, Buffers[i].Plane);
                    Bitmap bb = new Bitmap(ID, bs[0], new ZCT(Buffers[i].Coordinate.Z, 2, Buffers[i].Coordinate.T), index + 2, Buffers[i].Plane);
                    for (int b = 0; b < 3; b++)
                    {
                        bs[b].Dispose();
                    }
                    bs = null;
                    GC.Collect();
                    Statistics.CalcStatistics(br);
                    Statistics.CalcStatistics(bg);
                    Statistics.CalcStatistics(bb);
                    bfs.Add(br);
                    bfs.Add(bg);
                    bfs.Add(bb);
                    index += 3;
                }
                Buffers = bfs;
                UpdateCoords(SizeZ, 3, SizeT);
            }
            else if (px == PixelFormat.Format24bppRgb)
            {
                List<Bitmap> bfs = new List<Bitmap>();
                int index = 0;
                for (int i = 0; i < Buffers.Count; i++)
                {
                    Bitmap[] bs = Bitmap.RGB24To8(Buffers[i]);
                    Bitmap br = new Bitmap(ID, bs[2], new ZCT(Buffers[i].Coordinate.Z, 0, Buffers[i].Coordinate.T), index, Buffers[i].Plane);
                    Bitmap bg = new Bitmap(ID, bs[1], new ZCT(Buffers[i].Coordinate.Z, 1, Buffers[i].Coordinate.T), index + 1, Buffers[i].Plane);
                    Bitmap bb = new Bitmap(ID, bs[0], new ZCT(Buffers[i].Coordinate.Z, 2, Buffers[i].Coordinate.T), index + 2, Buffers[i].Plane);
                    for (int b = 0; b < 3; b++)
                    {
                        bs[b].Dispose();
                        bs[b] = null;
                    }
                    bs = null;
                    GC.Collect();
                    Statistics.CalcStatistics(br);
                    Statistics.CalcStatistics(bg);
                    Statistics.CalcStatistics(bb);
                    bfs.Add(br);
                    bfs.Add(bg);
                    bfs.Add(bb);
                    index += 3;
                }
                Buffers = bfs;
                UpdateCoords(SizeZ, 3, SizeT);
            }
            else
            {
                for (int i = 0; i < Buffers.Count; i++)
                {
                    Bitmap b = AForge.Imaging.Image.Convert16bppTo8bpp(Buffers[i]);
                    Buffers[i] = b;
                    Statistics.CalcStatistics(Buffers[i]);
                }
                for (int c = 0; c < Channels.Count; c++)
                {
                    Channels[c].BitsPerPixel = 8;
                    for (int i = 0; i < Channels[c].range.Length; i++)
                    {
                        Channels[c].range[i].Min = (int)(((float)Channels[c].range[i].Min / (float)ushort.MaxValue) * byte.MaxValue);
                        Channels[c].range[i].Max = (int)(((float)Channels[c].range[i].Max / (float)ushort.MaxValue) * byte.MaxValue);
                    }
                }
 
            }
            //We wait for threshold image statistics calculation
            do
            {
                Thread.Sleep(100);
            } while (Buffers[Buffers.Count - 1].Stats == null);
            Statistics.ClearCalcBuffer();
            AutoThreshold(this, false);
            bitsPerPixel = 8;
            App.viewer.UpdateImages();
            App.viewer.UpdateView();
            Recorder.AddLine("Bio.Table.GetImage(" + '"' + ID + '"' + ")" + "." + "To8Bit();");
        }

References BioImager.BioImage.AutoThreshold(), BioImager.BioImage.To24Bit(), BioImager.BioImage.UpdateCoords(), BioImager.ImageView.UpdateImages(), and BioImager.ImageView.UpdateView().

◆ ToImageSizeX()

double BioImager.BioImage.ToImageSizeX ( double d )

Convert a physical size to an image size

Parameters

d	the distance in microns

Returns: The value of d divided by the physicalSizeX.

Definition at line 3281 of file Bio.cs.

        {
            return d / PhysicalSizeX;
        }

◆ ToImageSizeY()

double BioImager.BioImage.ToImageSizeY ( double d )

Convert a physical size in Y direction to an image size in Y direction

Parameters

d	the distance in microns

Returns: The return value is the value of the parameter d divided by the value of the physicalSizeY field.

Definition at line 3291 of file Bio.cs.

        {
            return d / PhysicalSizeY;
        }

◆ ToImageSpace() [1/4]

PointD[] BioImager.BioImage.ToImageSpace ( List< PointD > p )

Convert a list of points from stage space to image space

Parameters

p	List of points in stage space

Returns: A PointD array.

Definition at line 3334 of file Bio.cs.

        {
            PointD[] ps = new PointD[p.Count];
            for (int i = 0; i < p.Count; i++)
            {
                PointD pp = new PointD();
                pp.X = ((p[i].X - StageSizeX) / PhysicalSizeX);
                pp.Y = ((p[i].Y - StageSizeY) / PhysicalSizeY);
                ps[i] = pp;
            }
            return ps;
        }

◆ ToImageSpace() [2/4]

PointD BioImager.BioImage.ToImageSpace ( PointD p )

Convert a point in the stage coordinate system to a point in the image coordinate system

Parameters

PointD

Returns: A PointF object.

Definition at line 3322 of file Bio.cs.

        {
            PointD pp = new PointD();
            pp.X = (float)((p.X - StageSizeX) / PhysicalSizeX);
            pp.Y = (float)((p.Y - StageSizeY) / PhysicalSizeY);
            return pp;
        }

Referenced by BioImager.ROI.PointsToString(), BioImager.Tools.ToolDown(), and BioImager.Tools.ToolUp().

◆ ToImageSpace() [3/4]

PointF[] BioImager.BioImage.ToImageSpace ( PointF[] p )

‍The function takes a list of points in the stage coordinate system and returns a list of

points in the image coordinate system

Parameters

p	the points to be converted

Returns: A PointF[]

Definition at line 3352 of file Bio.cs.

        {
            PointF[] ps = new PointF[p.Length];
            for (int i = 0; i < p.Length; i++)
            {
                PointF pp = new PointF();
                pp.X = (float)((p[i].X - StageSizeX) / PhysicalSizeX);
                pp.Y = (float)((p[i].Y - StageSizeY) / PhysicalSizeY);
                ps[i] = pp;
            }
            return ps;
        }

◆ ToImageSpace() [4/4]

RectangleF BioImager.BioImage.ToImageSpace ( RectangleD p )

‍Convert a rectangle in physical space to a rectangle in image space

Parameters

RectangleD

Returns: A RectangleF object.

Definition at line 3369 of file Bio.cs.

        {
            RectangleF r = new RectangleF();
            Point pp = new Point();
            r.X = (int)((p.X - StageSizeX) / PhysicalSizeX);
            r.Y = (int)((p.Y - StageSizeY) / PhysicalSizeY);
            r.Width = (int)(p.W / PhysicalSizeX);
            r.Height = (int)(p.H / PhysicalSizeY);
            return r;
        }

◆ ToImageSpaceX()

double BioImager.BioImage.ToImageSpaceX ( double x )

‍Convert a stage coordinate to an image coordinate

Parameters

x	the x coordinate of the point in the image

Returns: The return value is a double.

Definition at line 3300 of file Bio.cs.

        {
            if (isPyramidal)
                return x;
            return (float)((x - StageSizeX) / PhysicalSizeX);
        }

◆ ToImageSpaceY()

double BioImager.BioImage.ToImageSpaceY ( double y )

‍Convert a Y coordinate from stage space to image space

Parameters

y	the y coordinate of the point in the image

Returns: The return value is the y-coordinate of the image.

Definition at line 3311 of file Bio.cs.

        {
            if (isPyramidal)
                return y;
            return (float)((y - StageSizeY) / PhysicalSizeY);
        }

◆ ToStageSpace() [1/7]

PointD BioImager.BioImage.ToStageSpace ( PointD p )

‍This function converts a point in the image space to a point in the stage space

Parameters

PointD A class that contains an X and Y coordinate.

Returns: A PointD object.

Definition at line 3384 of file Bio.cs.

        {
            PointD pp = new PointD();
            if (isPyramidal)
            {
                pp.X = ((p.X * Resolutions[Level].PhysicalSizeX) + Volume.Location.X);
                pp.Y = ((p.Y * Resolutions[Level].PhysicalSizeY) + Volume.Location.Y);
                return pp;
            }
            else
            {
                pp.X = ((p.X * PhysicalSizeX) + Volume.Location.X);
                pp.Y = ((p.Y * PhysicalSizeY) + Volume.Location.Y);
                return pp;
            }
        }

Referenced by BioImager.ImageJ.RoiDecoder.getRoi(), BioImager.BioImage.OpenOME(), and BioImager.BioImage.OpenOMEROIs().

◆ ToStageSpace() [2/7]

static PointD BioImager.BioImage.ToStageSpace	(	PointD	p,
		double	physicalSizeX,
		double	physicalSizeY,
		double	volumeX,
		double	volumeY
	)

static

‍The function takes a point in the volume space and converts it to a point in the stage

space

Parameters

PointD	A custom class that holds an X and Y coordinate.
physicalSizeX	The width of the stage in mm
physicalSizeY	The height of the stage in mm
volumeX	The X coordinate of the top left corner of the volume in stage space.
volumeY	The Y position of the top left corner of the volume in stage space.

Returns: A PointD object.

Definition at line 3423 of file Bio.cs.

        {
            PointD pp = new PointD();
            pp.X = ((p.X * physicalSizeX) + volumeX);
            pp.Y = ((p.Y * physicalSizeY) + volumeY);
            return pp;
        }

◆ ToStageSpace() [3/7]

PointD BioImager.BioImage.ToStageSpace	(	PointD	p,
		int	resolution
	)

Convert a point in the image space to a point in the stage space

Parameters

PointD	A point in the image space
resolution	the resolution of the image (0, 1, 2, 3, 4)

Returns: A PointD object.

Definition at line 3406 of file Bio.cs.

        {
            PointD pp = new PointD();
            pp.X = ((p.X * Resolutions[resolution].PhysicalSizeX) + Volume.Location.X);
            pp.Y = ((p.Y * Resolutions[resolution].PhysicalSizeY) + Volume.Location.Y);
            return pp;
        }

◆ ToStageSpace() [4/7]

PointD[] BioImager.BioImage.ToStageSpace ( PointD[] p )

‍This function takes a list of points in the coordinate system of the image and returns a

list of points in the coordinate system of the stage

Parameters

p	The array of points to convert

Returns: A PointD[] array.

Definition at line 3470 of file Bio.cs.

        {
            PointD[] ps = new PointD[p.Length];
            for (int i = 0; i < p.Length; i++)
            {
                PointD pp = new PointD();
                pp.X = ((p[i].X * PhysicalSizeX) + Volume.Location.X);
                pp.Y = ((p[i].Y * PhysicalSizeY) + Volume.Location.Y);
                ps[i] = pp;
            }
            return ps;
        }

◆ ToStageSpace() [5/7]

static PointD[] BioImager.BioImage.ToStageSpace	(	PointD[]	p,
		double	physicalSizeX,
		double	physicalSizeY,
		double	volumeX,
		double	volumeY
	)

static

It takes a list of points, and converts them from a coordinate system where the origin is in the center of the image, to a coordinate system where the origin is in the top left corner of the image

Parameters

p	the array of points to convert
physicalSizeX	The width of the image in microns
physicalSizeY	The height of the image in microns
volumeX	The X position of the volume in stage space.
volumeY	The Y position of the top left corner of the volume in stage space.

Returns: A PointD array.

Definition at line 3493 of file Bio.cs.

        {
            PointD[] ps = new PointD[p.Length];
            for (int i = 0; i < p.Length; i++)
            {
                PointD pp = new PointD();
                pp.X = ((p[i].X * physicalSizeX) + volumeX);
                pp.Y = ((p[i].Y * physicalSizeY) + volumeY);
                ps[i] = pp;
            }
            return ps;
        }

◆ ToStageSpace() [6/7]

RectangleD BioImager.BioImage.ToStageSpace ( RectangleD p )

‍Convert a rectangle from the coordinate space of the image to the coordinate space of the

stage

Parameters

RectangleD A rectangle with double precision coordinates.

Returns: A RectangleD object.

Definition at line 3436 of file Bio.cs.

        {
            RectangleD r = new RectangleD();
            r.X = ((p.X * PhysicalSizeX) + Volume.Location.X);
            r.Y = ((p.Y * PhysicalSizeY) + Volume.Location.Y);
            r.W = (p.W * PhysicalSizeX);
            r.H = (p.H * PhysicalSizeY);
            return r;
        }

◆ ToStageSpace() [7/7]

static RectangleD BioImager.BioImage.ToStageSpace	(	RectangleD	p,
		double	physicalSizeX,
		double	physicalSizeY,
		double	volumeX,
		double	volumeY
	)

static

‍This function takes a rectangle in the coordinate space of the image and converts it to

the coordinate space of the stage

Parameters

RectangleD	A rectangle with double precision.
physicalSizeX	The width of the physical screen in pixels
physicalSizeY	The height of the stage in pixels
volumeX	The X position of the volume in stage space.
volumeY	The Y position of the top of the volume in stage space.

Returns: A RectangleD object.

Definition at line 3455 of file Bio.cs.

        {
            RectangleD r = new RectangleD();
            r.X = ((p.X * physicalSizeX) + volumeX);
            r.Y = ((p.Y * physicalSizeY) + volumeY);
            r.W = (p.W * physicalSizeX);
            r.H = (p.H * physicalSizeY);
            return r;
        }

◆ ToString()

override string BioImager.BioImage.ToString ( )

This function returns the filename of the object, and the location of the object in the 3D space

Returns: The filename, and the location of the volume.

Definition at line 8142 of file Bio.cs.

        {
            return Filename.ToString() + ", (" + Volume.Location.X + ", " + Volume.Location.Y + ", " + Volume.Location.Z + ")";
        }

Referenced by BioImager.BioImage.OpenFile().

◆ Update() [1/2]

void BioImager.BioImage.Update ( )

‍Update() is a function that calls the Update() function of the parent class

Definition at line 7243 of file Bio.cs.

        {
            Update(this);
        }

References BioImager.BioImage.Update().

Referenced by BioImager.BioImage.Update().

◆ Update() [2/2]

static void BioImager.BioImage.Update ( BioImage b )

static

The function takes a BioImage object, opens the file, and returns a updated BioImage object

Parameters

BioImage This is the class that contains the image data.

Definition at line 7238 of file Bio.cs.

        {
            b = OpenFile(b.file);
        }

References BioImager.BioImage.OpenFile().

◆ UpdateBuffersPyramidal()

void BioImager.BioImage.UpdateBuffersPyramidal ( )

Updates the Buffers based on current pyramidal origin and resolution.

Definition at line 2624 of file Bio.cs.

        {
            if (!isPyramidal)
                return;
            for (int i = 0; i < Buffers.Count; i++)
            {
                Buffers[i].Dispose();
            }
            Buffers.Clear();
            for (int i = 0; i < imagesPerSeries; i++)
            {
                if (openSlideImage != null)
                {
                    byte[] bts = openSlideBase.GetSlice(new OpenSlideGTK.SliceInfo(PyramidalOrigin.X, PyramidalOrigin.Y, PyramidalSize.Width, PyramidalSize.Height, resolution));
                    Bitmap bf = new Bitmap((int)Math.Round(OpenSlideBase.destExtent.Width), (int)Math.Round(OpenSlideBase.destExtent.Height), PixelFormat.Format24bppRgb, bts, new ZCT(), "");
                    Buffers.Add(bf);
                }
                else
                {
                start:
                    byte[] bts = slideBase.GetSlice(new SliceInfo(PyramidalOrigin.X, PyramidalOrigin.Y, PyramidalSize.Width, PyramidalSize.Height, resolution, App.viewer.GetCoordinate())).Result;
                    if (bts == null)
                    {
                        if (PyramidalOrigin.X == 0 && PyramidalOrigin.Y == 0)
                        {
                            resolution = 1;
                        }
                        pyramidalOrigin = new PointD(0, 0);
                        goto start;
                    }
                    Buffers.Add(new Bitmap((int)Math.Round(SlideBase.destExtent.Width), (int)Math.Round(SlideBase.destExtent.Height), PixelFormat.Format24bppRgb, bts, new ZCT(), ""));
                }
            }
            BioImage.AutoThreshold(this, true);
            if (bitsPerPixel > 8)
                StackThreshold(true);
            else
                StackThreshold(false);
        }

References BioImager.BioImage.AutoThreshold(), BioImager.ImageView.GetCoordinate(), and BioImager.BioImage.StackThreshold().

Referenced by BioImager.ImageView.UpdateImages().

◆ UpdateCoords() [1/3]

void BioImager.BioImage.UpdateCoords ( )

It takes a list of images and assigns them to a 3D array of coordinates.

Definition at line 3143 of file Bio.cs.

        {
            int z = 0;
            int c = 0;
            int t = 0;
            Coords = new int[SizeZ, SizeC, SizeT];
            for (int im = 0; im < Buffers.Count; im++)
            {
                ZCT co = new ZCT(z, c, t);
                Coords[co.Z, co.C, co.T] = im;
                Buffers[im].Coordinate = co;
                if (c < SizeC - 1)
                    c++;
                else
                {
                    c = 0;
                    if (z < SizeZ - 1)
                        z++;
                    else
                    {
                        z = 0;
                        if (t < SizeT - 1)
                            t++;
                        else
                            t = 0;
                    }
                }
            }
        }

Referenced by BioImager.BioImage.FilesToStack(), BioImager.BioImage.FolderToStack(), BioImager.BioImage.ImagesToStack(), BioImager.BioImage.MergeT(), BioImager.BioImage.MergeZ(), BioImager.BioImage.OpenFile(), BioImager.BioImage.OpenOME(), BioImager.BioImage.To16Bit(), BioImager.BioImage.To24Bit(), BioImager.BioImage.To48Bit(), and BioImager.BioImage.To8Bit().

◆ UpdateCoords() [2/3]

void BioImager.BioImage.UpdateCoords	(	int	sz,
		int	sc,
		int	st
	)

It takes the number of Z, C, and T planes in the image and then assigns each image buffer a coordinate in the ZCT space

Parameters

sz	size of the Z dimension
sc	number of channels
st	number of time points

Definition at line 3178 of file Bio.cs.

        {
            int z = 0;
            int c = 0;
            int t = 0;
            sizeZ = sz;
            sizeC = sc;
            sizeT = st;
            Coords = new int[sz, sc, st];
            for (int im = 0; im < Buffers.Count; im++)
            {
                ZCT co = new ZCT(z, c, t);
                Coords[co.Z, co.C, co.T] = im;
                Buffers[im].Coordinate = co;
                if (c < SizeC - 1)
                    c++;
                else
                {
                    c = 0;
                    if (z < SizeZ - 1)
                        z++;
                    else
                    {
                        z = 0;
                        if (t < SizeT - 1)
                            t++;
                        else
                            t = 0;
                    }
                }
            }
        }

◆ UpdateCoords() [3/3]

void BioImager.BioImage.UpdateCoords	(	int	sz,
		int	sc,
		int	st,
		string	order
	)

It takes a list of images and assigns them to a 3D array of coordinates

Parameters

sz	size of the Z dimension
sc	number of channels
st	number of time points
order	XYCZT or XYZCT

Definition at line 3216 of file Bio.cs.

        {
            int z = 0;
            int c = 0;
            int t = 0;
            sizeZ = sz;
            sizeC = sc;
            sizeT = st;
            Coords = new int[sz, sc, st];
            if (order == "XYCZT")
            {
                for (int im = 0; im < Buffers.Count; im++)
                {
                    ZCT co = new ZCT(z, c, t);
                    Coords[co.Z, co.C, co.T] = im;
                    Buffers[im].Coordinate = co;
                    if (c < SizeC - 1)
                        c++;
                    else
                    {
                        c = 0;
                        if (z < SizeZ - 1)
                            z++;
                        else
                        {
                            z = 0;
                            if (t < SizeT - 1)
                                t++;
                            else
                                t = 0;
                        }
                    }
                }
            }
            else if (order == "XYZCT")
            {
                for (int im = 0; im < Buffers.Count; im++)
                {
                    ZCT co = new ZCT(z, c, t);
                    Coords[co.Z, co.C, co.T] = im;
                    Buffers[im].Coordinate = co;
                    if (z < SizeZ - 1)
                        z++;
                    else
                    {
                        z = 0;
                        if (c < SizeC - 1)
                            c++;
                        else
                        {
                            c = 0;
                            if (t < SizeT - 1)
                                t++;
                            else
                                t = 0;
                        }
                    }
                }
            }
        }

◆ VipsSupport()

static bool BioImager.BioImage.VipsSupport ( string file )

static

The function checks if a given file is supported by the Vips library and returns true if it is, false otherwise.

Parameters

file	The "file" parameter is a string that represents the file path of the TIFF image that you want to load using the NetVips library.

Returns: The method is returning a boolean value. If the try block is executed successfully, it will return true. If an exception is caught, it will return false.

Definition at line 7301 of file Bio.cs.

        {
            try
            {
                netim = NetVips.Image.Tiffload(file);
            }
            catch (Exception e)
            {
                Console.WriteLine(e.ToString());
                return false;
            }
            netim.Close();
            netim.Dispose();
            return true;
        }

Referenced by BioImager.BioImage.OpenFile().

Member Data Documentation

◆ Annotations

List<ROI> BioImager.BioImage.Annotations = new List<ROI>()

Definition at line 2012 of file Bio.cs.

◆ bitsPerPixel

int BioImager.BioImage.bitsPerPixel

Definition at line 2034 of file Bio.cs.

◆ Buffers

List<AForge.Bitmap> BioImager.BioImage.Buffers = new List<AForge.Bitmap>()

Definition at line 2001 of file Bio.cs.

◆ Channels

List<Channel> BioImager.BioImage.Channels = new List<Channel>()

Definition at line 1999 of file Bio.cs.

◆ columns

const string BioImager.BioImage.columns = "ROIID,ROINAME,TYPE,ID,SHAPEINDEX,TEXT,S,C,Z,T,X,Y,W,H,POINTS,STROKECOLOR,STROKECOLORW,FILLCOLOR,FONTSIZE\n"

static

Definition at line 7325 of file Bio.cs.

◆ Coords

int [,,] BioImager.BioImage.Coords

Definition at line 1969 of file Bio.cs.

◆ file

string BioImager.BioImage.file

Definition at line 2477 of file Bio.cs.

◆ filename

string BioImager.BioImage.filename = ""

Definition at line 2013 of file Bio.cs.

◆ filter16

LevelsLinear16bpp BioImager.BioImage.filter16 = new LevelsLinear16bpp()

static

Definition at line 3889 of file Bio.cs.

◆ filter8

LevelsLinear BioImager.BioImage.filter8 = new LevelsLinear()

static

Definition at line 3888 of file Bio.cs.

◆ frameInterval

double BioImager.BioImage.frameInterval = 0

Definition at line 2037 of file Bio.cs.

◆ imagesPerSeries

int BioImager.BioImage.imagesPerSeries = 0

Definition at line 2035 of file Bio.cs.

◆ imRead

ImageReader BioImager.BioImage.imRead

Definition at line 6663 of file Bio.cs.

◆ isGroup

bool BioImager.BioImage.isGroup = false

Definition at line 2039 of file Bio.cs.

◆ littleEndian

bool BioImager.BioImage.littleEndian = false

Definition at line 2038 of file Bio.cs.

◆ Loading

bool BioImager.BioImage.Loading = false

Definition at line 4467 of file Bio.cs.

◆ loadTimeMS

long BioImager.BioImage.loadTimeMS = 0

Definition at line 2040 of file Bio.cs.

◆ loadTimeTicks

long BioImager.BioImage.loadTimeTicks = 0

Definition at line 2041 of file Bio.cs.

◆ NewLine

const char BioImager.BioImage.NewLine = '\n'

static

Definition at line 7324 of file Bio.cs.

◆ OmeSupport

bool BioImager.BioImage.OmeSupport = false

static

Definition at line 7260 of file Bio.cs.

◆ openSlideBase

OpenSlideBase BioImager.BioImage.openSlideBase

Definition at line 2406 of file Bio.cs.

◆ openSlideImage

OpenSlideImage BioImager.BioImage.openSlideImage

Definition at line 2405 of file Bio.cs.

◆ Planes

bool BioImager.BioImage.Planes = false

static

Definition at line 2409 of file Bio.cs.

◆ Plate

WellPlate BioImager.BioImage.Plate = null

Definition at line 1989 of file Bio.cs.

◆ progFile

string BioImager.BioImage.progFile

static

Definition at line 2479 of file Bio.cs.

◆ progressValue

float BioImager.BioImage.progressValue = 0

static

Definition at line 2057 of file Bio.cs.

◆ Resolutions

List<Resolution> BioImager.BioImage.Resolutions = new List<Resolution>()

Definition at line 2000 of file Bio.cs.

◆ rgbChannels

int [] BioImager.BioImage.rgbChannels = new int[3]

Definition at line 2026 of file Bio.cs.

◆ script

string BioImager.BioImage.script = ""

Definition at line 2014 of file Bio.cs.

◆ selected

bool BioImager.BioImage.selected = false

Definition at line 2042 of file Bio.cs.

◆ seriesCount

int BioImager.BioImage.seriesCount = 1

Definition at line 2036 of file Bio.cs.

◆ slideBase

SlideBase BioImager.BioImage.slideBase

Definition at line 2407 of file Bio.cs.

◆ slideImage

SlideImage BioImager.BioImage.slideImage

Definition at line 2408 of file Bio.cs.

◆ status

string BioImager.BioImage.status

static

Definition at line 2478 of file Bio.cs.

◆ swatch

Stopwatch BioImager.BioImage.swatch = new Stopwatch()

static

Definition at line 4429 of file Bio.cs.

◆ tifRead

Tiff BioImager.BioImage.tifRead

Definition at line 6664 of file Bio.cs.

◆ vipPages

List<NetVips.Image> BioImager.BioImage.vipPages = new List<NetVips.Image>()

Definition at line 2002 of file Bio.cs.

◆ Volume

VolumeD BioImager.BioImage.Volume

Definition at line 2011 of file Bio.cs.

◆ watch

Stopwatch BioImager.BioImage.watch = new Stopwatch()

Definition at line 2438 of file Bio.cs.

Property Documentation

◆ BChannel

Channel BioImager.BioImage.BChannel

get

Definition at line 2240 of file Bio.cs.

        {
            get
            {
                if (Channels[0].range.Length == 1)
                    return Channels[rgbChannels[2]];
                else
                    return Channels[0];
            }
        }

◆ BRange

IntRange BioImager.BioImage.BRange

get

Definition at line 2424 of file Bio.cs.

        {
            get
            {
                return BChannel.RangeB;
            }
        }

◆ Coordinate

ZCT BioImager.BioImage.Coordinate

getset

Definition at line 1971 of file Bio.cs.

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

◆ Filename

string BioImager.BioImage.Filename

getset

Definition at line 2015 of file Bio.cs.

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

◆ GChannel

Channel BioImager.BioImage.GChannel

get

Definition at line 2230 of file Bio.cs.

        {
            get
            {
                if (Channels[0].range.Length == 1)
                    return Channels[rgbChannels[1]];
                else
                    return Channels[0];
            }
        }

◆ GRange

IntRange BioImager.BioImage.GRange

get

Definition at line 2417 of file Bio.cs.

        {
            get
            {
                return GChannel.RangeG;
            }
        }

◆ ID

string BioImager.BioImage.ID

getset

Definition at line 2164 of file Bio.cs.

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

◆ ImageCount

int BioImager.BioImage.ImageCount

get

Definition at line 2169 of file Bio.cs.

        {
            get
            {
                return Buffers.Count;
            }
        }

◆ Initialized

bool BioImager.BioImage.Initialized

staticget

Definition at line 2480 of file Bio.cs.

        {
            get
            {
                return initialized;
            }
        }

◆ isPyramidal

bool BioImager.BioImage.isPyramidal

get

Definition at line 2469 of file Bio.cs.

        {
            get
            {
                if (Type == ImageType.pyramidal) return true;
                else return false;
            }
        }

◆ isRGB

bool BioImager.BioImage.isRGB

get

Definition at line 2439 of file Bio.cs.

        {
            get
            {
                if (RGBChannelCount == 3 || RGBChannelCount == 4)
                    return true;
                else
                    return false;
            }
        }

◆ isSeries

bool BioImager.BioImage.isSeries

get

Definition at line 2459 of file Bio.cs.

        {
            get
            {
                if (seriesCount > 1)
                    return true;
                else
                    return false;
            }
        }

◆ isTime

bool BioImager.BioImage.isTime

get

Definition at line 2449 of file Bio.cs.

        {
            get
            {
                if (SizeT > 1)
                    return true;
                else
                    return false;
            }
        }

◆ LabelResolution

int? BioImager.BioImage.LabelResolution

getset

Definition at line 2488 of file Bio.cs.

2488{ get; set; }

◆ Level

int BioImager.BioImage.Level

getset

Definition at line 2536 of file Bio.cs.

        {
            get
            {
                if (openSlideBase != null)
                    return OpenSlideGTK.TileUtil.GetLevel(openSlideBase.Schema.Resolutions, Resolution);
                else
                    if (slideBase != null)
                    return LevelFromResolution(Resolution);
                return level;
            }
            set
            {
                if (Type == ImageType.well)
                {
                    level = value;
                    reader.setId(file);
                    reader.setSeries(value);
                    // read the image data bytes
                    int pages = reader.getImageCount();
                    bool inter = reader.isInterleaved();
                    PixelFormat pf = Buffers[0].PixelFormat;
                    int w = Buffers[0].SizeX; int h = Buffers[0].SizeY;
                    Buffers.Clear();
                    for (int p = 0; p < pages; p++)
                    {
                        Bitmap bf;
                        byte[] bytes = reader.openBytes(p);
                        bf = new Bitmap(file, w, h, pf, bytes, new ZCT(), p, null, littleEndian, inter);
                        Buffers.Add(bf);
                    }
                }
            }
        }

◆ MacroResolution

int? BioImager.BioImage.MacroResolution

getset

Definition at line 2487 of file Bio.cs.

2487{ get; set; }

◆ PhysicalSizeX

double BioImager.BioImage.PhysicalSizeX

get

Definition at line 2176 of file Bio.cs.

        {
            get { return Resolutions[Level].PhysicalSizeX; }
        }

◆ PhysicalSizeY

double BioImager.BioImage.PhysicalSizeY

get

Definition at line 2180 of file Bio.cs.

        {
            get { return Resolutions[Level].PhysicalSizeY; }
        }

◆ PhysicalSizeZ

double BioImager.BioImage.PhysicalSizeZ

get

Definition at line 2184 of file Bio.cs.

        {
            get { return Resolutions[Level].PhysicalSizeZ; }
        }

◆ PyramidalOrigin

PointD BioImager.BioImage.PyramidalOrigin

getset

Definition at line 2527 of file Bio.cs.

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

◆ PyramidalSize

AForge.Size BioImager.BioImage.PyramidalSize

getset

Definition at line 2525 of file Bio.cs.

2525{ get { return s; } set { s = value; } }

◆ RChannel

Channel BioImager.BioImage.RChannel

get

Definition at line 2220 of file Bio.cs.

        {
            get
            {
                if (Channels[0].range.Length == 1)
                    return Channels[rgbChannels[0]];
                else
                    return Channels[0];
            }
        }

◆ Resolution

double BioImager.BioImage.Resolution

getset

Definition at line 2003 of file Bio.cs.

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

◆ RGBChannelCount

int BioImager.BioImage.RGBChannelCount

get

Definition at line 2027 of file Bio.cs.

        {
            get
            {
                return Buffers[0].RGBChannelsCount;
            }
        }

◆ RRange

IntRange BioImager.BioImage.RRange

get

Definition at line 2410 of file Bio.cs.

        {
            get
            {
                return RChannel.RangeR;
            }
        }

◆ SelectedBuffer

Bitmap BioImager.BioImage.SelectedBuffer

get

Definition at line 2431 of file Bio.cs.

        {
            get
            {
                return Buffers[Coords[Coordinate.Z, Coordinate.C, Coordinate.T]];
            }
        }

◆ series

int BioImager.BioImage.series

getset

Definition at line 2207 of file Bio.cs.

        {
            get
            {
                return imageInfo.Series;
            }
            set
            {
                imageInfo.Series = value;
            }
        }

◆ SizeC

int BioImager.BioImage.SizeC

get

Definition at line 2397 of file Bio.cs.

        {
            get { return sizeC; }
        }

◆ SizeT

int BioImager.BioImage.SizeT

get

Definition at line 2401 of file Bio.cs.

        {
            get { return sizeT; }
        }

◆ SizeX

int BioImager.BioImage.SizeX

get

Definition at line 2375 of file Bio.cs.

        {
            get
            {
                if (Buffers.Count > 0)
                    return Buffers[0].SizeX;
                else return 0;
            }
        }

◆ SizeY

int BioImager.BioImage.SizeY

get

Definition at line 2384 of file Bio.cs.

        {
            get
            {
                if (Buffers.Count > 0)
                    return Buffers[0].SizeY;
                else return 0;
            }
        }

◆ SizeZ

int BioImager.BioImage.SizeZ

get

Definition at line 2393 of file Bio.cs.

        {
            get { return sizeZ; }
        }

◆ StageSizeX

double BioImager.BioImage.StageSizeX

getset

Definition at line 2188 of file Bio.cs.

        {
            get
            {
                return Resolutions[Level].StageSizeX;
            }
            set { imageInfo.StageSizeX = value; }
        }

◆ StageSizeY

double BioImager.BioImage.StageSizeY

getset

Definition at line 2196 of file Bio.cs.

        {
            get { return Resolutions[Level].StageSizeY; }
            set { imageInfo.StageSizeY = value; }
        }

◆ StageSizeZ

double BioImager.BioImage.StageSizeZ

getset

Definition at line 2201 of file Bio.cs.

        {
            get { return Resolutions[Level].StageSizeZ; }
            set { imageInfo.StageSizeZ = value; }
        }

◆ Statistics

Statistics BioImager.BioImage.Statistics

getset

Definition at line 2043 of file Bio.cs.

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

◆ Type

ImageType BioImager.BioImage.Type

getset

Definition at line 1990 of file Bio.cs.

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

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

F:/repos/BioImager/BioImager/Source/Bio.cs

Classes

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Properties

Detailed Description

Member Enumeration Documentation

◆ ImageType

Constructor & Destructor Documentation

◆ BioImage()

Member Function Documentation

◆ AutoThreshold() [1/2]

◆ AutoThreshold() [2/2]

◆ AutoThresholdThread()

◆ Bake() [1/2]

◆ Bake() [2/2]

◆ CalculateFocusQuality()

◆ Copy() [1/4]

◆ Copy() [2/4]

◆ Copy() [3/4]

◆ Copy() [4/4]

◆ CopyInfo()

◆ Dispose()

◆ ExportROIFolder()

◆ ExportROIsCSV()

◆ ExtractRegionFromTiledTiff()

◆ FilesToStack()

◆ FindFocus()

◆ FolderToStack()

◆ GetAnnotations() [1/2]

◆ GetAnnotations() [2/2]

◆ GetBands()

◆ GetBitmap() [1/2]

◆ GetBitmap() [2/2]

◆ GetBitmapRGB()

◆ GetBitMaxValue()

◆ GetBitsPerPixel()

◆ GetChannelImage()

◆ GetEmission()

◆ GetFiltered() [1/2]

◆ GetFiltered() [2/2]

◆ GetImageByCoord()

◆ GetIndex()

◆ GetIndexRGB()

◆ GetLevelDownsample()

◆ GetPixelFormat() [1/2]

◆ GetPixelFormat() [2/2]

◆ GetRGBBitmap()

◆ GetTile() [1/2]

◆ GetTile() [2/2]

◆ GetUnitPerPixel()

◆ GetValue() [1/3]

◆ GetValue() [2/3]

◆ GetValue() [3/3]

◆ GetValueRGB() [1/3]

◆ GetValueRGB() [2/3]

◆ GetValueRGB() [3/3]

◆ ImagesToStack()

◆ ImportROIsCSV()

◆ Initialize()

◆ isOME()

◆ isOMESeries()

◆ isTiffSeries()

◆ LevelFromResolution()

◆ MergeChannels() [1/2]

◆ MergeChannels() [2/2]

◆ MergeT()

◆ MergeZ()

◆ OMESupport()

◆ Open() [1/2]

◆ Open() [2/2]

◆ OpenAsync() [1/2]

◆ OpenAsync() [2/2]

◆ OpenFile() [1/4]

◆ OpenFile() [2/4]

◆ OpenFile() [3/4]

◆ OpenFile() [4/4]

◆ OpenOME() [1/3]