BioImager.Microscope Class Reference

Public Types
enum	Actions {   StageUp , StageRight , StageDown , StageLeft ,   StageFieldUp , StageFieldRight , StageFieldDown , StageFieldLeft ,   FocusUp , FocusDown , TL , RL ,   TakeImage , TakeImageStack , Acquisition , Locate }

Static Public Member Functions
static void	Initialize ()
static void	CalibrateXYZ (int calibMode)
static Point3D	GetPosition ()
static void	SetPosition (Point3D p)
static void	SetPosition (PointD p)
static void	OpenRL ()
	If the shutter is closed, open it.
static void	OpenTL ()
	If the shutter is closed, open it.
static void	CloseRL ()
	If the shutter is open, then close it.
static void	CloseTL ()
	If the shutter is open, then we close it.
static void	SetTL (uint tl)
static void	SetRL (uint tr)
static int	GetTL ()
static int	GetRL ()
static int	GetShutterPosition (string shutter)
	Gets the current position of a named shutter.
static void	SetShutterPosition (string shutter, int state)
	Sets the current position of a named shutter.
static void	MoveUp (double d)
static void	MoveRight (double d)
static void	MoveDown (double d)
static void	MoveLeft (double d)
static void	MoveFieldUp ()
	Move the field up by the height of the view.
static void	MoveFieldRight ()
	Move the field right by the width of the view.
static void	MoveFieldDown ()
	Move the field down by one unit.
static void	MoveFieldLeft ()
	Move the field left by the width of the viewport.
static void	SetFocus (double d)
static double	GetFocus ()
static string	GetFolder ()
static void	SetFolder (string fol)
static BioImage	TakeImage ()
static BioImage	TakeImage (bool save, bool addToImages, bool newTab)
static BioImage	TakeImageStack ()
static void	Watcher ()
	the textbox, sets the watcher's path to that folder, and enables the watcher.
static BioImage	TakeImageStack (double UpperLimit, double LowerLimit, double interval)
static BioImage[]	TakeTiles (int width, int height, bool save=true, bool addToImages=true, bool newTab=false)
static RectangleD	GetObjectiveViewRectangle ()
static RectangleD	GetViewRectangle (bool update)
static void	Close ()

Static Public Attributes
static bool	redraw = false
static Focus	Focus = null
static Stage	Stage = null
static Objectives	Objectives = null
static TLShutter	TLShutter = null
static RLShutter	RLShutter = null
static HXPShutter	HXPShutter = null
static LightSource	TLHalogen = null
static LightSource	RLHalogen = null
static LightSource	HXP = null
static FilterWheel	TLFilterWheel = null
static FilterWheel	RLFilterWheel = null
static FilterWheel	FilterWheel = new FilterWheel()
static double	UpperLimit
static double	LowerLimit
static double	fInterVal
static object	CmdSetMode = null
static bool	initialized = false
static bool	ArrowKeysEnabled = true
static Point3D	defaultPos = new Point3D(30000, 30000, 23900)
static object	root = null
static StringBuilder	dllVersion = new StringBuilder()
static SDK	sdk
static int	sessionID = -1
static string	userRx = ""
static PointD	viewSize
static PMicroscope	pMicroscope = null
static int	ImageCount = 0

Properties
static Objectives.Objective	Objective [get]

Detailed Description

Definition at line 786 of file Microscope.cs.

Member Enumeration Documentation

Actions

enum BioImager.Microscope.Actions

Enumerator
StageUp
StageRight
StageDown
StageLeft
StageFieldUp
StageFieldRight
StageFieldDown
StageFieldLeft
FocusUp
FocusDown
TL
RL
TakeImage
TakeImageStack
Acquisition
Locate

Definition at line 789 of file Microscope.cs.

        {
            StageUp,
            StageRight,
            StageDown,
            StageLeft,
            StageFieldUp,
            StageFieldRight,
            StageFieldDown,
            StageFieldLeft,
            FocusUp,
            FocusDown,
            TL,
            RL,
            TakeImage,
            TakeImageStack,
            Acquisition,
            Locate,
        }

Member Function Documentation

CalibrateXYZ()

static void BioImager.Microscope.CalibrateXYZ ( int calibMode )

static

It checks to see if the stage and focus are calibrated on the lower limit and if not, it calibrates them

Parameters

calibMode

"OnLowerLimit"

Definition at line 994 of file Microscope.cs.

        {
            if (Properties.Settings.Default.LibPath.Contains("MTB"))
            {
                BioImager.MicroscopeConsole.RunCommand(
                    new BioImager.MicroscopeConsole.Command(BioImager.MicroscopeConsole.Command.Type.SetCalibration, new double[] { calibMode }));
                //We check to see if focus & stage are correctly calibrated on lower limit and perform calibration if necessary
                PointD cur = Stage.GetPosition(true);
                double z = Focus.GetFocus();
                //After calibration we return to the position before calibration.
                SetPosition(cur);
                Focus.SetFocus(z);
            }
        }

Close()

static void BioImager.Microscope.Close ( )

static

Definition at line 1596 of file Microscope.cs.

        {
            PMicroscope.Stop();
        }

CloseRL()

static void BioImager.Microscope.CloseRL ( )

static

If the shutter is open, then close it.

Definition at line 1058 of file Microscope.cs.

        {
            //If shutter is open then we close it.
            if (RLShutter.GetPosition() == 0)
                RLShutter.SetPosition(1);
        }

CloseTL()

static void BioImager.Microscope.CloseTL ( )

static

If the shutter is open, then we close it.

Definition at line 1066 of file Microscope.cs.

        {
            //If shutter is open then we close it.
            if (TLShutter.GetPosition() == 0)
                TLShutter.SetPosition(1);
        }

GetFocus()

static double BioImager.Microscope.GetFocus ( )

static

It returns the current focus of the z-axis.

Returns

The focus of the z-axis.

Definition at line 1184 of file Microscope.cs.

        {
            return Focus.GetFocus();
        }

GetFolder()

static string BioImager.Microscope.GetFolder ( )

static

If the folder is not set, prompt the user to select a folder. If the user selects a folder, set the folder to the selected folder. If the user does not select a folder, return null. If the folder is set, return the folder.

Returns

The folder path.

Definition at line 1195 of file Microscope.cs.

        {
            object o = Recordings.GetProperty(Automation.Action.ValueType.ValuePattern, "GetFolder");
            string s = null;
            if (o != null)
                s = o.ToString();
            if (s == null && folder == "")
            {
                FolderBrowserDialog fs = new FolderBrowserDialog();
                fs.Description = "Select Imaging Folder";
                if (fs.ShowDialog() != DialogResult.OK)
                {
                    fs.Dispose();
                    return null;
                }
                else
                {
                    fs.Dispose();
                    Properties.Settings.Default.ImagingPath = fs.SelectedPath;
                    return fs.SelectedPath;
                }
            }
            else
            {
                folder = Properties.Settings.Default.ImagingPath;
                return folder;
            }
        }

GetObjectiveViewRectangle()

static RectangleD BioImager.Microscope.GetObjectiveViewRectangle ( )

static

It returns a rectangle that represents the viewable area of the current objective

Returns

A rectangle with the dimensions of the viewport.

Definition at line 1563 of file Microscope.cs.

        {
            Objectives.Objective o = Objectives.GetObjective();
            PointD d = Stage.GetPosition(false);
            return new RectangleD(d.X, d.Y, o.ViewWidth, o.ViewHeight);
        }

GetPosition()

static Point3D BioImager.Microscope.GetPosition ( )

static

Get the current stage position and focus position, and return a Point3D object containing the stage position and focus position

Returns

A Point3D object.

Definition at line 1014 of file Microscope.cs.

        {
            PointD p = Stage.GetPosition(false);
            double f = Focus.GetFocus();
            return new Point3D(p.X, p.Y, f);
        }

GetRL()

static int BioImager.Microscope.GetRL ( )

static

GetRL() returns the position of the RLShutter object.

Returns

The position of the RLShutter.

Definition at line 1100 of file Microscope.cs.

        {
            return RLShutter.GetPosition();
        }

GetShutterPosition()

static int BioImager.Microscope.GetShutterPosition ( string shutter )

static

Gets the current position of a named shutter.

Parameters

shutter

Name of the shutter.

Returns

Position of the named shutter

Definition at line 1109 of file Microscope.cs.

        {
            return MicroManager.Shutters.GetPosition(shutter);
        }

GetTL()

static int BioImager.Microscope.GetTL ( )

static

It returns the position of the TLShutter object

Returns

The position of the shutter.

Definition at line 1092 of file Microscope.cs.

        {
            return TLShutter.GetPosition();
        }

GetViewRectangle()

static RectangleD BioImager.Microscope.GetViewRectangle ( bool update )

static

If the microscope is in PMicroscope mode, return the PMicroscope rectangle, otherwise return the stage rectangle

Parameters

update

Boolean value that determines whether the view rectangle should be updated or not.

Returns

A rectangle with the dimensions of the viewport.

Definition at line 1576 of file Microscope.cs.

        {
            if (update)
            {
                PointD d = Stage.GetPosition(false);
                return new RectangleD(d.X, d.Y, viewSize.X, viewSize.Y);
            }
            else
            {
                if(Properties.Settings.Default.PMicroscope)
                {
                    return new RectangleD(PMicroscope.location.X, PMicroscope.location.Y, viewSize.X, viewSize.Y);
                }
                else
                {
                    PointD d = Stage.GetPosition(false);
                    return new RectangleD(d.X, d.Y, viewSize.X, viewSize.Y);
                }
            }
        }

Initialize()

static void BioImager.Microscope.Initialize ( )

static

The function initializes the microscope and the imaging library

Returns

The return value is an object.

Definition at line 847 of file Microscope.cs.

        {
            if (initialized)
                return;
            int err;
            folder = Properties.Settings.Default.ImagingPath;
            if (Properties.Settings.Default.PMicroscope)
            {
                pMicroscope = new PMicroscope();
                pMicroscope.Initialize();
                bool b = pMicroscope.SetPosition(new Point3D(100, 100, 100));
                Point3D p;
                bool res = pMicroscope.GetPosition3D(out p, false);
                bool bb = pMicroscope.TakeImage(Application.StartupPath + "\\Image");
                Objectives = new Objectives(6);
                Stage = new Stage();
                Focus = new Focus();
            }
            else
            if (Properties.Settings.Default.PycroManager)
            {
                //First we determine which MMConfig file we are using. There is currently no way of doing this programmatically. So we will ask the user.
                if (Properties.Settings.Default.MMConfig == "")
                {
                    OpenFileDialog fl = new OpenFileDialog();
                    fl.Filter = "Config Files (*.cfg)|*.cfg";
                    fl.InitialDirectory = Properties.Settings.Default.AppPath;
                    MessageBox.Show("Micro-Manager current configuration file not set please select the current configuration.");
                    fl.Title = "Set Current Config File (Shown in MicroManager GUI)";
                    if (fl.ShowDialog() != DialogResult.OK)
                        Application.Exit();
                    Properties.Settings.Default.MMConfig = fl.FileName;
                }
                MicroManager.Initialize(Properties.Settings.Default.MMConfig);
                Objectives = new Objectives(7);
                for (int i = 0; i < MicroManager.Objectives.List.Count; i++)
                {
                    Objectives.List[MicroManager.Objectives.List[i].Index].Name = MicroManager.Objectives.List[i].Name;
                }
                Stage = new Stage();
                Focus = new Focus();
            }
            else
            if (Properties.Settings.Default.AppPath == "")
            {
                OpenFileDialog fl = new OpenFileDialog();
                MessageBox.Show("Imaging application path is not set. Please set executable location.");
                fl.Title = "Set imaging application location.";
                if (fl.ShowDialog() != DialogResult.OK)
                    Application.Exit();
                Properties.Settings.Default.AppPath = fl.FileName;
                fl.Dispose();
            }
            else
            if (Properties.Settings.Default.LibPath == "")
            {
                OpenFileDialog fl = new OpenFileDialog();
                MessageBox.Show("Imaging library path is not set. Please set imaging library.");
                fl.Title = "Set imaging library location.";
                if (fl.ShowDialog() != DialogResult.OK)
                    Application.Exit();
                Properties.Settings.Default.LibPath = fl.FileName;
                fl.Dispose();
            }
            if (Properties.Settings.Default.LibPath.Contains("MTB"))
            {
                TLFilterWheel = new FilterWheel();
                RLFilterWheel = new FilterWheel();
                Stage = new Stage();
                Focus = new Focus();
                Objectives = new Objectives(7);
                TLShutter = new TLShutter();
                RLShutter = new RLShutter();
                HXPShutter = new HXPShutter();
                TLHalogen = new LightSource();
                RLHalogen = new LightSource();
                HXP = new LightSource();
                Point3D.SetLimits(Stage.minX, Stage.maxX, Stage.minY, Stage.maxY, Focus.lowerLimit, Focus.upperLimit);
                PointD.SetLimits(Stage.minX, Stage.maxX, Stage.minY, Stage.maxY);
                //We calibrate the stage and focus, so that images are taken always with same calibration
                CalibrateXYZ(0);
            }
            else if (Properties.Settings.Default.LibPath.Contains("Prio"))
            {
                sdk = new SDK();
                /* get the version number of the dll */
                if ((err = sdk.GetVersion(dllVersion)) != Prior.PRIOR_OK)
                {
                    MessageBox.Show("Error getting Prior SDK version (" + err.ToString() + ")");
                    return;
                }
 
                /* SDK must be initialised before any real use
                 */
                if ((err = sdk.Initialise()) != Prior.PRIOR_OK)
                {
                    MessageBox.Show("Error initialising Prior SDK (" + err.ToString() + ")");
                    return;
                }
 
                /* create a session in the DLL, this gives us one controller and currently an ODS and SL160 robot loader. 
                 * Multiple connections allow control of multiple stage/loaders but is outside the brief for this demo
                 */
                if ((sessionID = sdk.OpenSession()) < 0)
                {
                    MessageBox.Show("Error (" + sessionID.ToString() + ") Creating session in SDK " + dllVersion);
                    return;
                }
                int open = 0;
                try
                {
                    for (int port = 0; port < 10; port++)
                    {
                        //specify path name or PriorSDK.log is written to working directory
                        //priorSDK.Cmd(sessionID, "dll.log.on",  ref userRx);
                        /* my controller identifies on COM1, yours will probably be different.
                         */
                        /* try to connect to the ps3 */
                        open = sdk.Cmd(sessionID, "controller.connect " + port.ToString(), ref userRx, false);
                    }
                }
                catch (Exception)
                {
 
                }
                
                if (open != Prior.PRIOR_OK)
                {
                    MessageBox.Show("Error (" + open.ToString() + ")  connecting to stage controller ", "",
                        MessageBoxButtons.OK, MessageBoxIcon.Error);
                    return;
                }
                err = sdk.Cmd(sessionID, "controller.stage.hostdirection.set 1 1", ref userRx);
                Objectives = new Objectives(sdk.GetNosePiecePositions());
                Stage = new Stage();
                Focus = new Focus();
            }
 
            RectangleD rec = GetObjectiveViewRectangle();
            viewSize = new PointD(rec.W, rec.H);
            Watcher();
            initialized = true;
        }

MoveDown()

static void BioImager.Microscope.MoveDown ( double d )

static

Move the stage down by the specified amount

Parameters

d	The distance to move the stage down.

Definition at line 1141 of file Microscope.cs.

        {
            Stage.MoveDown(d);
        }

MoveFieldDown()

static void BioImager.Microscope.MoveFieldDown ( )

static

Move the field down by one unit.

Definition at line 1164 of file Microscope.cs.

        {
            Stage.MoveDown(viewSize.Y);
        }

MoveFieldLeft()

static void BioImager.Microscope.MoveFieldLeft ( )

static

Move the field left by the width of the viewport.

Definition at line 1169 of file Microscope.cs.

        {
            Stage.MoveLeft(viewSize.X);
        }

MoveFieldRight()

static void BioImager.Microscope.MoveFieldRight ( )

static

Move the field right by the width of the view.

Definition at line 1159 of file Microscope.cs.

        {
            Stage.MoveRight(viewSize.X);
        }

MoveFieldUp()

static void BioImager.Microscope.MoveFieldUp ( )

static

Move the field up by the height of the view.

Definition at line 1154 of file Microscope.cs.

        {
            Stage.MoveUp(viewSize.Y);
        }

MoveLeft()

static void BioImager.Microscope.MoveLeft ( double d )

static

Move the stage left by the specified distance

Parameters

d	The distance to move the stage in mm.

Definition at line 1149 of file Microscope.cs.

        {
            Stage.MoveLeft(d);
        }

MoveRight()

static void BioImager.Microscope.MoveRight ( double d )

static

MoveRight(double d) moves the stage right by d

Parameters

d	The distance to move the stage in millimeters.

Definition at line 1133 of file Microscope.cs.

        {
            Stage.MoveRight(d);
        }

MoveUp()

static void BioImager.Microscope.MoveUp ( double d )

static

Move the stage up by a distance of d

Parameters

d	The distance to move the stage up.

Definition at line 1125 of file Microscope.cs.

        {
            Stage.MoveUp(d);
        }

OpenRL()

static void BioImager.Microscope.OpenRL ( )

static

If the shutter is closed, open it.

Definition at line 1041 of file Microscope.cs.

        {
            //If shutter is closed we open it.
            if (RLShutter.GetPosition() == 0)
                RLShutter.SetPosition(1);
        }

OpenTL()

static void BioImager.Microscope.OpenTL ( )

static

If the shutter is closed, open it.

Definition at line 1050 of file Microscope.cs.

        {
            //If shutter is closed we open it.
            if (TLShutter.GetPosition() == 0)
                TLShutter.SetPosition(1);
        }

SetFocus()

static void BioImager.Microscope.SetFocus ( double d )

static

‍The function SetFocus is a static function that takes a double as a parameter and calls the static function SetFocus on the class Focus with the parameter d

Parameters

d	The double value to set the focus to.

Definition at line 1177 of file Microscope.cs.

        {
            Focus.SetFocus(d);
        }

SetFolder()

static void BioImager.Microscope.SetFolder ( string fol )

static

If the folder doesn't exist, create it. If the property exists, set it. Set the folder variable to the folder. Set the ImagingPath property to the folder. Save the settings

Parameters

fol	the folder to save the images to

Definition at line 1227 of file Microscope.cs.

        {
            if (!Directory.Exists(fol))
                Directory.CreateDirectory(fol);
            if(Automation.Properties.ContainsKey("SetFolder"))
                Automation.SetProperty("SetFolder",fol);
            folder = fol;
            Properties.Settings.Default.ImagingPath = folder;
            Properties.Settings.Default.Save();
        }

SetPosition() [1/2]

static void BioImager.Microscope.SetPosition ( Point3D p )

static

It sets the position of the stage and focus to the values in the Point3D object

Parameters

Point3D

a class that contains 3 doubles, X, Y, and Z.

Definition at line 1025 of file Microscope.cs.

        {
            Stage.SetPosition(p.X,p.Y);
            Focus.SetFocus(p.Z);
            Microscope.redraw = true;
        }

SetPosition() [2/2]

static void BioImager.Microscope.SetPosition ( PointD p )

static

SetPosition(PointD p) sets the position of the stage to the PointD p

Parameters

PointD

a class that contains an X and Y coordinate

Definition at line 1035 of file Microscope.cs.

        {
            Stage.SetPosition(p.X, p.Y);
            Microscope.redraw = true;
        }

SetRL()

static void BioImager.Microscope.SetRL ( uint tr )

static

Set the position of the RLShutter to the value of tr

Parameters

tr	The position of the shutter.

Definition at line 1084 of file Microscope.cs.

        {
            RLShutter.SetPosition((short)tr);
        }

SetShutterPosition()

static void BioImager.Microscope.SetShutterPosition ( string shutter, int state )

static

Sets the current position of a named shutter.

Parameters

shutter

Name of the shutter.

Returns

Position of the named shutter

Definition at line 1118 of file Microscope.cs.

        {
            MicroManager.Shutters.SetPosition(shutter, state);
        }

SetTL()

static void BioImager.Microscope.SetTL ( uint tl )

static

This function sets the position of the TL shutter to the value of the variable tl

Parameters

tl	the position of the shutter

Definition at line 1076 of file Microscope.cs.

        {
            TLShutter.SetPosition((short)tl);
        }

TakeImage() [1/2]

static BioImage BioImager.Microscope.TakeImage ( )

static

It takes an image from the camera and saves it to a file

Returns

The image is being returned.

Definition at line 1241 of file Microscope.cs.

        {
            return TakeImage(true,true,false);
        }

TakeImage() [2/2]

static BioImage BioImager.Microscope.TakeImage ( bool save, bool addToImages, bool newTab )

static

Definition at line 1246 of file Microscope.cs.

        {
            if (Properties.Settings.Default.SimulateCamera && !Properties.Settings.Default.PMicroscope)
            {
                folder = GetFolder();
                BioImage b = MicroscopeSetup.simImage.Copy();
                Point3D p = GetPosition();
                b.Volume.Location = new Point3D(p.X,p.Y,p.Z);
                RectangleD view = Microscope.GetViewRectangle(true);
                b.Resolutions[0] = new Resolution(b.SizeX, b.SizeY, b.Buffers[0].PixelFormat,view.W / b.SizeX, view.H / b.SizeY, b.PhysicalSizeZ,p.X,p.Y,p.Z);
                b.Volume.Location = p;
                b.Volume.Width = view.W;
                b.Volume.Height = view.H;
                string file;
                if (folder == "" || folder == null)
                    file = Properties.Settings.Default.ImageName + (ImageCount++) + ".ome.tif";
                else
                    file = folder + "/" + Properties.Settings.Default.ImageName + (ImageCount++) + ".ome.tif";
                b.ID = file;
                b.file = file;
                if (addToImages)
                {
                    Images.AddImage(b);
                    App.tabsView.AddTab(b);
                }
                if(save)
                BioImage.SaveOME(file, b.ID);
                return b;
            }
            else if (Properties.Settings.Default.PMicroscope)
            {
                folder = GetFolder();
                string file;
                if (folder == "" || folder == null)
                    file = Properties.Settings.Default.ImageName + (ImageCount++).ToString();
                else
                    file = folder + "/" + Properties.Settings.Default.ImageName + (ImageCount++);
                pMicroscope.TakeImage(file);
                byte[] bts = File.ReadAllBytes(file);
                int w, h;
                PixelFormat px;
                Enum.TryParse<PixelFormat>(Properties.Settings.Default.PCameraFormat, out px);
                pMicroscope.GetSize(out w, out h);
                Bitmap bf = new Bitmap(file, w, h, px, bts, new ZCT(0, 0, 0), 0);
                bf.Stats = Statistics.FromBytes(bf);
                BioImage bm = new BioImage(file + ".ome.tif");
                bm.Buffers.Add(bf);
                //Set the physical size based on objective view
                RectangleD rec = GetViewRectangle(false);
                Point3D p = Microscope.GetPosition();
                Resolution res = new Resolution(w,h,px,rec.W / bm.SizeX,rec.H / bm.SizeY,1, p.X,p.Y,p.Z);
                bm.Volume.Location = p;
                bm.Volume.Width = rec.W;
                bm.Volume.Height = rec.H;
                bm.UpdateCoords(1, 1, 1);
                bm.Resolutions.Add(res);
                for (int c = 0; c < bf.RGBChannelsCount; c++)
                {
                    bm.Channels.Add(new Channel(c, bf.BitsPerPixel, bf.RGBChannelsCount));
                }
                BioImage.AutoThreshold(bm, false);
                if (!imagingStack)
                {
                    if (addToImages)
                    {
                        Images.AddImage(bm);
                        App.tabsView.AddTab(bm);
                    }
                    if (save)
                    BioImage.SaveAsync(file + ".ome.tif", bm.ID,0,true);
                    if (bm.bitsPerPixel > 8)
                        bm.StackThreshold(true);
                    else
                        bm.StackThreshold(false);
                }
                else
                    bi.Buffers.Add(bm.Buffers[0]);
                //We delete the temporary file created by camera.
                File.Delete(file);
                currentImage = bm;
                return bi;
            }
            else if (Properties.Settings.Default.PycroManager)
            {
                folder = GetFolder();
                string file;
                if (folder == "" || folder == null)
                    file = Properties.Settings.Default.ImageName + (ImageCount++).ToString();
                else
                    file = folder + "/" + Properties.Settings.Default.ImageName + (ImageCount++);
                BioImage bm = MicroManager.TakeImage(file);
 
                if (!imagingStack)
                {
                    if (addToImages)
                    {
                        Images.AddImage(bm);
                        App.tabsView.AddTab(bm);
                    }
                    if (save)
                        BioImage.SaveAsync(file + ".ome.tif", bm.ID,0,true);
                }
                else
                {
                    bi.Buffers.AddRange(bm.Buffers);
                }
                currentImage = bm;
                if (bi == null)
                    return bm;
                else
                    return bi;
            }
            else
            {
                if (Function.Functions.ContainsKey("TakeImage"))
                {
                    App.imager.PerformFunction(Function.Functions["TakeImage"]);
                    return null;
                }
                else
                {
                    MessageBox.Show("Go to Microscope Setup to set 'TakeImage' function eg. a Button shortcut or GUI recording. Or set camera simulation on & set Camera image.", "Function 'TakeImage' not defined.");
                    return null;
                }
            }
        }

TakeImageStack() [1/2]

static BioImage BioImager.Microscope.TakeImageStack ( )

static

This function takes a stack of images from the camera and returns a BioImage object

Returns

A BioImage object.

Definition at line 1375 of file Microscope.cs.

        {
            return TakeImageStack(UpperLimit, LowerLimit, fInterVal);
        }

TakeImageStack() [2/2]

static BioImage BioImager.Microscope.TakeImageStack ( double UpperLimit, double LowerLimit, double interval )

static

It takes an image stack from the microscope and adds it to the viewer.

The function is called from the main thread and it's purpose is to take an image stack from the microscope and add it to the viewer.

Parameters

UpperLimit	The upper limit of the stack
LowerLimit	The lowest focus position
interval	The interval between each image.

Returns

A BioImage object.

Definition at line 1447 of file Microscope.cs.

        {
            imagingStack = true;
            //We start the locking wait loop
            WaitLocking();
            bi = new BioImage(Properties.Settings.Default.ImageName);
            watcher.Path = GetFolder();
            Focus.SetFocus(UpperLimit);
            double d = UpperLimit - LowerLimit;
            double dd = d / interval;
            for (int i = 0; i < dd; i++)
            {
                TakeImage();
                //If this is the last image we don't need to move the focus. 
                if (i < dd)
                    Focus.SetFocus(Focus.GetFocus() - fInterVal);
                Application.DoEvents();
            }
            //If we are using the imaging application to take images we need to add them to the viewer as the filesystemwatcher
            //can't add them due to thread access violation
            if (!Properties.Settings.Default.PMicroscope)
            {
                //First we wait till all the images are loaded
                do
                {
                    Thread.Sleep(100);
                    Application.DoEvents();
                } while (bi.Buffers.Count < (int)dd);
            }
            
            bi.UpdateCoords(bi.Buffers.Count, 1, 1);
            for (int c = 0; c < bi.Buffers[0].RGBChannelsCount; c++)
            {
                bi.Channels.Add(new Channel(c, bi.bitsPerPixel, bi.Buffers[c].RGBChannelsCount));
            }
            //Set the physical size based on objective view
            RectangleD rec = GetObjectiveViewRectangle();
            /*
            bi.StageSizeX = rec.X;
            bi.StageSizeY = rec.Y;
            bi.StageSizeZ = UpperLimit;
            */
            bi.Resolutions.Add(new Resolution(bi.SizeX, bi.SizeY, bi.Buffers[0].PixelFormat,
                rec.W / bi.SizeX, rec.H / bi.SizeY, (UpperLimit - LowerLimit) / bi.SizeZ, rec.X,rec.Y,UpperLimit));
            bi.Volume = new VolumeD(new Point3D(bi.StageSizeX, bi.StageSizeY, bi.StageSizeZ),new Point3D(bi.SizeX * bi.PhysicalSizeX, bi.SizeY * bi.PhysicalSizeY, bi.StageSizeZ * bi.PhysicalSizeZ));
            BioImage.AutoThreshold(bi, false);
            if (bi.bitsPerPixel > 8)
                bi.StackThreshold(true);
            else
                bi.StackThreshold(false);
            Images.AddImage(bi);
            App.tabsView.AddTab(bi);
            imagingStack = false;
            currentImage = bi;
            images.Clear();
            locked.Clear();
            ImageCount = 0;
            return bi;
        }

TakeTiles()

static BioImage[] BioImager.Microscope.TakeTiles ( int width, int height, bool save = true, bool addToImages = true, bool newTab = false )

static

It takes a number of images in a grid pattern

Parameters

width	The number of tiles in the x direction
height	The number of fields to take in the y direction

Definition at line 1510 of file Microscope.cs.

        {
            List<BioImage> ims = new List<BioImage>();
            imagingStack = false;
            bool leftright = false;
            if (Properties.Settings.Default.PMicroscope)
            {
                Point3D p = Microscope.GetPosition();
                //We ensure that the cached position is same as actual position
                Microscope.SetPosition(p);
            }
            for (int y = 0; y < height; y++)
            {
                if (y != 0)
                {
                    Microscope.MoveFieldDown();
                }
                leftright = !leftright;
                ims.Add(Microscope.TakeImage(save, addToImages, newTab));
                for (int x = 0; x < width - 1; x++)
                {
                    if (leftright)
                    {
                        Microscope.MoveFieldRight();
                    }
                    else
                    {
                        Microscope.MoveFieldLeft();
                    }
                    ims.Add(Microscope.TakeImage(save,addToImages,newTab));
                }
            }
            //If we are using the imaging application to take images we need to add them to the viewer as the filesystemwatcher
            //can't add them due to thread access violation
            if(!Properties.Settings.Default.PMicroscope)
            {
                //First we wait till all the images are loaded
                do
                {
                    Application.DoEvents();
                } while (images.Count < width * height);
                for (int i = 0; i < images.Count; i++)
                {
                    App.viewer.AddImage(images[i]);
                }
                images.Clear();
            }
            imagingStack = false;
            return ims.ToArray();
        }

Watcher()

static void BioImager.Microscope.Watcher ( )

static

the textbox, sets the watcher's path to that folder, and enables the watcher.

This function is called when the user clicks the "Start" button. It gets the folder path from

Definition at line 1382 of file Microscope.cs.

        {
            string s = GetFolder();
            watcher.Created += fileSystemWatcher1_Created;
            watcher.Path = s;
            watcher.BeginInit();
            watcher.EnableRaisingEvents = true;
            watcher.EndInit();
        }

Member Data Documentation

ArrowKeysEnabled

bool BioImager.Microscope.ArrowKeysEnabled = true

static

Definition at line 824 of file Microscope.cs.

CmdSetMode

object BioImager.Microscope.CmdSetMode = null

static

Definition at line 822 of file Microscope.cs.

defaultPos

Point3D BioImager.Microscope.defaultPos = new Point3D(30000, 30000, 23900)

static

Definition at line 825 of file Microscope.cs.

dllVersion

StringBuilder BioImager.Microscope.dllVersion = new StringBuilder()

static

Definition at line 827 of file Microscope.cs.

FilterWheel

FilterWheel BioImager.Microscope.FilterWheel = new FilterWheel()

static

Definition at line 820 of file Microscope.cs.

fInterVal

double BioImager.Microscope.fInterVal

static

Definition at line 821 of file Microscope.cs.

Focus

Focus BioImager.Microscope.Focus = null

static

Definition at line 809 of file Microscope.cs.

HXP

LightSource BioImager.Microscope.HXP = null

static

Definition at line 817 of file Microscope.cs.

HXPShutter

HXPShutter BioImager.Microscope.HXPShutter = null

static

Definition at line 814 of file Microscope.cs.

ImageCount

int BioImager.Microscope.ImageCount = 0

static

Definition at line 834 of file Microscope.cs.

initialized

bool BioImager.Microscope.initialized = false

static

Definition at line 823 of file Microscope.cs.

LowerLimit

double BioImager.Microscope.LowerLimit

static

Definition at line 821 of file Microscope.cs.

Objectives

Objectives BioImager.Microscope.Objectives = null

static

Definition at line 811 of file Microscope.cs.

pMicroscope

PMicroscope BioImager.Microscope.pMicroscope = null

static

Definition at line 832 of file Microscope.cs.

redraw

bool BioImager.Microscope.redraw = false

static

Definition at line 808 of file Microscope.cs.

RLFilterWheel

FilterWheel BioImager.Microscope.RLFilterWheel = null

static

Definition at line 819 of file Microscope.cs.

RLHalogen

LightSource BioImager.Microscope.RLHalogen = null

static

Definition at line 816 of file Microscope.cs.

RLShutter

RLShutter BioImager.Microscope.RLShutter = null

static

Definition at line 813 of file Microscope.cs.

root

object BioImager.Microscope.root = null

static

Definition at line 826 of file Microscope.cs.

sdk

SDK BioImager.Microscope.sdk

static

Definition at line 828 of file Microscope.cs.

sessionID

int BioImager.Microscope.sessionID = -1

static

Definition at line 829 of file Microscope.cs.

Stage

Stage BioImager.Microscope.Stage = null

static

Definition at line 810 of file Microscope.cs.

TLFilterWheel

FilterWheel BioImager.Microscope.TLFilterWheel = null

static

Definition at line 818 of file Microscope.cs.

TLHalogen

LightSource BioImager.Microscope.TLHalogen = null

static

Definition at line 815 of file Microscope.cs.

TLShutter

TLShutter BioImager.Microscope.TLShutter = null

static

Definition at line 812 of file Microscope.cs.

UpperLimit

double BioImager.Microscope.UpperLimit

static

Definition at line 821 of file Microscope.cs.

userRx

string BioImager.Microscope.userRx = ""

static

Definition at line 830 of file Microscope.cs.

viewSize

PointD BioImager.Microscope.viewSize

static

Definition at line 831 of file Microscope.cs.

Property Documentation

Objective

Objectives.Objective BioImager.Microscope.Objective

staticget

Definition at line 836 of file Microscope.cs.

        {
            get
            {
                return Objectives.GetObjective();
            }
        }

---

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

• BioImager/Source/Microscope.cs