BioLib.ImageJ Class Reference

Static Public Member Functions
static void	RunMacro (string file, string param)
	The function "RunMacro" runs a macro file with specified parameters using the ImageJ software.
static async void	RunString (BioImage b, string con, string param, bool headless)
	The function RunString executes an ImageJ macro script with the given parameters, either in headless mode or with a graphical interface.
static void	RunOnImage (BioImage bi, string con, int index, bool headless, bool onTab, bool bioformats, bool resultInNewTab, string outputStem=null)
	The function "RunOnImage" takes a BioImage object, a string of commands, an index, and several boolean parameters, and performs various operations on the image.
static async Task< BioImage >	RunOnPyramidalImage (BioImage b, string con, int level, bool headless, bool onTab, bool bioformats, bool resultInNewTab, bool currentViewOnly=false)
	Runs an ImageJ command on a pyramidal BioImage by processing the requested level as a single-resolution image for Fiji.
static async Task< BioImage >	RunOnAllPyramidLevels (BioImage b, string con, bool headless, bool onTab, bool bioformats, bool resultInNewTab)
	Runs an ImageJ command on every pyramid level and returns a single pyramidal BioImage assembled from the processed resolution levels.
static void	RunOnImage (BioImage b, string con, bool headless, bool onTab, bool bioformats, bool resultInNewTab)
	The function "RunOnImage" takes in a BioImage object, a string, and several boolean values as parameters and executes a specific action based on those parameters.
static void	Initialize (string path)
	The Initialize function sets the ImageJPath variable to the specified path.
static bool	SetImageJPath (string? path)

Static Public Attributes
static List< Process >	processes = new List<Process>()

Properties
static string	ImageJPath [get, set]

Member Function Documentation

Initialize()

static void BioLib.ImageJ.Initialize ( string path )

static

The Initialize function sets the ImageJPath variable to the specified path.

Parameters

path	The path parameter is a string that represents the file path where the ImageJ software is located.

        {
            SetImageJPath(path);
        }

RunMacro()

static void BioLib.ImageJ.RunMacro ( string file, string param )

static

The function "RunMacro" runs a macro file with specified parameters using the ImageJ software.

Parameters

file	The "file" parameter is a string that represents the path to the macro file that you want to run. It should include the file extension (e.g., ".ijm" for ImageJ macro files).
param	The "param" parameter is a string that represents the additional parameters or arguments that you want to pass to the macro file specified by the "file" parameter. These parameters can be used by the macro file to modify its behavior or perform specific actions.

        {
            file.Replace("/", "\\");
            Process pr = new Process();
            pr.StartInfo.FileName = ImageJPath;
            pr.StartInfo.Arguments = "-macro " + file + " " + param;
            pr.Start();
            processes.Add(pr);
        }

RunOnAllPyramidLevels()

static async Task< BioImage > BioLib.ImageJ.RunOnAllPyramidLevels ( BioImage b, string con, bool headless, bool onTab, bool bioformats, bool resultInNewTab )

static

Runs an ImageJ command on every pyramid level and returns a single pyramidal BioImage assembled from the processed resolution levels.

        {
            if (b == null)
                return null;
 
            if (!b.isPyramidal || b.Resolutions.Count == 0)
            {
                RunOnImage(b, con, headless, onTab, bioformats, resultInNewTab);
                Recorder.Record($"ImageJ.RunOnImage({b}, \"{con}\", {headless.ToString().ToLower()}, {onTab.ToString().ToLower()}, {bioformats.ToString().ToLower()}, {resultInNewTab.ToString().ToLower()});");
                return b;
            }
 
            string effectiveCommand = await TryParameterizePyramidalCommand(b, con, headless, resultInNewTab).ConfigureAwait(false);
            List<BioImage> results = new List<BioImage>();
            for (int level = 0; level < b.Resolutions.Count; level++)
            {
                ReportProgress(0, $"Processing pyramid level {level + 1}/{b.Resolutions.Count}");
                BioImage result = await RunOnPyramidalImageInternal(b, effectiveCommand, level, headless, onTab, bioformats, resultInNewTab, false, false).ConfigureAwait(false);
                if (result != null)
                    results.Add(result);
            }
 
            if (results.Count == 0)
                return null;
 
            string tempDir = Path.GetDirectoryName(Environment.ProcessPath);
            string tempFile = Path.Combine(tempDir, Guid.NewGuid().ToString("N") + "-pyr.zarr");
            ReportProgress(0, $"Saving processed pyramid ({results.Count}/{b.Resolutions.Count} levels)");
            await BioImage.SaveOMEZarr(results.ToArray(), tempFile).ConfigureAwait(false);
 
            ReportProgress(0, "Opening processed pyramid");
            BioImage pyramidal = await BioImage.OpenFileAsync(tempFile, 0, false, false).ConfigureAwait(false);
            pyramidal = ApplyProcessedResultName(b, pyramidal);
            ReportProgress(100, "Completed pyramid command");
            Recorder.Record($"ImageJ.RunOnAllPyramidLevels({b}, \"{con}\", {headless.ToString().ToLower()}, {onTab.ToString().ToLower()}, {bioformats.ToString().ToLower()}, {resultInNewTab.ToString().ToLower()});");
            return pyramidal;
        }

RunOnImage() [1/2]

static void BioLib.ImageJ.RunOnImage ( BioImage b, string con, bool headless, bool onTab, bool bioformats, bool resultInNewTab )

static

The function "RunOnImage" takes in a BioImage object, a string, and several boolean values as parameters and executes a specific action based on those parameters.

Parameters

BioImage	The BioImage parameter is an object that represents an image in a bioinformatics context. It likely contains information about the image, such as its dimensions, pixel values, and metadata.
con	The "con" parameter is a string that represents the command to be executed on the image. It could be any valid ImageJ command or macro.
headless	The "headless" parameter is a boolean value that determines whether the image processing operation should be performed in headless mode. Headless mode means that the operation will be performed without any graphical user interface (GUI) being displayed.
onTab	The "onTab" parameter determines whether the image processing should be performed on the current active tab or on a new tab. If "onTab" is set to true, the processing will be performed on the current active tab. If "onTab" is set to false, a new tab will
bioformats	The "bioformats" parameter is a boolean value that determines whether to use the Bio-Formats plugin for opening the image. If set to true, the Bio-Formats plugin will be used to open the image, allowing for support of various file formats. If set to false, the default image opening
resultInNewTab	A boolean value indicating whether the result should be displayed in a new tab or not.

        {
            if (b != null && b.isPyramidal)
            {
                RunOnAllPyramidLevels(b, con, headless, onTab, bioformats, resultInNewTab).Wait();
                return;
            }
            RunOnImage(b, con,0,headless,onTab,bioformats,resultInNewTab);
            Recorder.AddLine("ImageJ.RunOnImage(Images.GetImage(\"" + b.Filename + "\"),\"" + con + "\"," + 0 + "," + headless + "," + onTab + "," + bioformats + "," + resultInNewTab + ");",false);
        }

RunOnImage() [2/2]

static void BioLib.ImageJ.RunOnImage ( BioImage bi, string con, int index, bool headless, bool onTab, bool bioformats, bool resultInNewTab, string outputStem = null )

static

The function "RunOnImage" takes a BioImage object, a string of commands, an index, and several boolean parameters, and performs various operations on the image.

Parameters

BioImage	The BioImage object represents an image file. It contains information about the image file such as the file path, filename, and ID.
con	The "con" parameter is a string that represents the ImageJ macro code that you want to run on the image. It is passed as an argument to the "run" function in the ImageJ macro language.
index	The index parameter is used to specify the index of the image series to be processed. It is used when opening multi-series images, such as multi-channel or time-lapse images, where each series represents a different set of images. By specifying the index, you can select a specific series to be processed
headless	The "headless" parameter is a boolean value that determines whether the image processing should be performed in headless mode. Headless mode means that the processing is done without any user interface or graphical display.
onTab	The "onTab" parameter determines whether the image processing should be performed on the current tab or on a new tab. If it is set to true, the processing will be done on the current tab. If it is set to false, a new tab will be created for the processed image.
bioformats	A boolean flag indicating whether to use Bio-Formats for importing and exporting the image. If set to true, Bio-Formats will be used. If set to false, the image will be opened and saved using the default ImageJ functions.
resultInNewTab	A boolean value indicating whether the result should be displayed in a new tab or not.

Returns

The method does not return any value. It is a void method.

        {
            if (OperatingSystem.IsMacOS())
                bioformats = false;
            Console.WriteLine($"[ImageJ.RunOnImage] input={bi?.ID} index={index} headless={headless} onTab={onTab} bioformats={bioformats} resultInNewTab={resultInNewTab} outputStem={outputStem}");
            string filename = "";
            string dir = Path.GetDirectoryName(bi.file);
            dir = dir.Replace("\\", "/");
            string inputPath = dir + "/" + bi.ID;
            bool inputIsZarr = bi.ID != null && bi.ID.EndsWith(".zarr", StringComparison.OrdinalIgnoreCase);
            if (bi.ID.EndsWith(".ome.tif"))
            {
                filename = Path.GetFileNameWithoutExtension(bi.ID);
                filename = filename.Remove(filename.Length - 4, 4);
            }
            else
                filename = Path.GetFileNameWithoutExtension(bi.ID);
            string file = inputIsZarr ? inputPath : dir + "/" + filename + ".ome.tif";
            if (!bioformats && !inputIsZarr)
                file = dir + "/" + filename + ".tif";
            string outputName = string.IsNullOrWhiteSpace(outputStem) ? filename : outputStem;
            string exportPath = bioformats
                ? dir + "/" + outputName + "-temp.ome.tif"
                : dir + "/" + outputName + ".tif";
            string donepath = Path.GetDirectoryName(Environment.ProcessPath);
            donepath = donepath.Replace("\\", "/");
            string st =
            "run(\"Bio-Formats Importer\", \"open=" + file + " autoscale color_mode=Default open_all_series display_rois rois_import=[ROI manager] view=Hyperstack stack_order=XYCZT\"); " + con +
            "run(\"Bio-Formats Exporter\", \"save=" + exportPath + " export compression=Uncompressed\"); " +
            "dir = \"" + donepath + "\"" +
            "File.saveString(\"done\", dir + \"/done.txt\");";
            if (!bioformats)
                st =
                "open(getArgument); " + con +
                "saveAs(\"Tiff\",\"" + exportPath + "\"); " +
                "dir = \"" + donepath + "\"" +
                "File.saveString(\"done\", dir + \"/done.txt\");";
            Console.WriteLine($"[ImageJ.RunOnImage] inputFile={file}");
            RunString(bi,st, dir + "/" + bi.ID, headless);
            string sourcePath = bioformats ? file : inputPath;
            if (!File.Exists(sourcePath))
            {
                Console.WriteLine($"[ImageJ.RunOnImage] input file missing after run: {sourcePath}");
                return;
            }
 
            string f = ResolveExportedImagePath(exportPath);
            if (f == null)
            {
                Console.WriteLine($"[ImageJ.RunOnImage] output file not found for exportPath={exportPath}");
                return;
            }
 
            Console.WriteLine($"[ImageJ.RunOnImage] resolvedOutput={f}");
 
            string fn = Path.GetFileName(f);
            //If not in images we add it to a new tab.
            if (Images.GetImage(fn) == null)
            {
                BioImage bm = BioImage.OpenFileAsync(f, index, false, false).Result;
                Console.WriteLine($"[ImageJ.RunOnImage] opened new image {bm?.ID} filename={bm?.Filename}");
                bm.Filename = fn;
                bm.ID = fn;
                bm.file = dir + "/" + fn;
                Images.AddImage(bm);
                lastRunOutput = bm;
            }
            else
            {
                BioImage b = BioImage.OpenFileAsync(f, index, false, false).Result;
                Console.WriteLine($"[ImageJ.RunOnImage] updating existing image with {b?.ID} filename={b?.Filename}");
                b.ID = bi.ID;
                b.Filename = bi.ID;
                b.file = dir + "/" + fn;
                Images.UpdateImage(b);
                lastRunOutput = b;
            }
            //If using bioformats we delete the temp file.
            if(bioformats)
            File.Delete(f);;
            //Recorder.AddLine("ImageJ.RunOnImage(\"" + con + "\"," + headless + "," + onTab + "," + bioformats + "," + resultInNewTab + ");");
        }

RunOnPyramidalImage()

static async Task< BioImage > BioLib.ImageJ.RunOnPyramidalImage ( BioImage b, string con, int level, bool headless, bool onTab, bool bioformats, bool resultInNewTab, bool currentViewOnly = false )

static

Runs an ImageJ command on a pyramidal BioImage by processing the requested level as a single-resolution image for Fiji.

        {
            return await RunOnPyramidalImageInternal(b, con, level, headless, onTab, bioformats, resultInNewTab, true, currentViewOnly).ConfigureAwait(false);
        }

RunString()

static async void BioLib.ImageJ.RunString ( BioImage b, string con, string param, bool headless )

static

The function RunString executes an ImageJ macro script with the given parameters, either in headless mode or with a graphical interface.

Parameters

con	The "con" parameter is a string that represents the content of a file. It will be written to a temporary file and used as input for the ImageJ macro.
param	The "param" parameter is a string that represents the additional arguments or parameters that you want to pass to the ImageJ application when running the macro. These arguments can be used to customize the behavior of the macro or provide input data to it.
headless	The "headless" parameter is a boolean value that determines whether the ImageJ process should run in headless mode or not. Headless mode means that the ImageJ interface will not be displayed, and the process will run in the background without any user interaction. If the "headless" parameter

        {
            Process pr = new Process();
            pr.StartInfo.FileName = ImageJPath;
            string te = rng.Next(0, 9999999).ToString();
            string p = Path.GetDirectoryName(Environment.ProcessPath) + "/" + te;
            if (OperatingSystem.IsMacOS())
            {
                Console.WriteLine(p);
                pr.StartInfo.UseShellExecute = true;
            }
            File.WriteAllText(p, con);
            if (headless)
                pr.StartInfo.Arguments = "--headless -macro " + p + " " + param;
            else
                pr.StartInfo.Arguments = "-macro " + p + " " + param;
            pr.Start();
            string donedir = Path.GetDirectoryName(Environment.ProcessPath);
            donedir = donedir.Replace("\\", "/");
            File.Delete(Path.GetDirectoryName(Environment.ProcessPath) + "/done.txt");
            processes.Add(pr);
            do
            {
                if (File.Exists(donedir + "/done.txt"))
                {
                    do
                    {
                        try
                        {
                            File.Delete(donedir + "/done.txt");
                        }
                        catch (Exception)
                        {
 
                        }
                    } while (File.Exists(donedir + "/done.txt"));
                    pr.Kill();
                    break;
                }
            } while (!pr.HasExited);
            File.Delete(p);
        }

SetImageJPath()

static bool BioLib.ImageJ.SetImageJPath ( string? path )

static

This function creates a file chooser dialog that allows the user to select the location of the ImageJ executable

Returns

A boolean value.

        {
            if (path == null || path == "")
            {
                string st = Settings.GetSettings("ImageJPath");
                if (st != "")
                {
                    ImageJPath = Settings.GetSettings("ImageJPath");
                    return true;
                }
                return false;
            }
            else
            {
                if (Settings.GetSettings("ImageJPath") == "")
                {
                    Settings.AddSettings("ImageJPath", path);
                    Settings.Save();
                }
                ImageJPath = path;
                return true;
            }
        }

Member Data Documentation

processes

List<Process> BioLib.ImageJ.processes = new List<Process>()

static

Property Documentation

ImageJPath

string BioLib.ImageJ.ImageJPath

staticgetset

        {
            get
            {
                return imjpath;
            }
            set
            {
                imjpath = value.Replace("\\", "/");
            }
        }

---

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

• BioLib/Source/ImageJ.cs