BioLib.Fiji Class Reference

Classes
class	Macro
class	RoiDecoder
class	RoiEncoder

Static Public Member Functions
static ImagePlus	GetImagePlus (BioImage bm)
static bool	isRGB (ImagePlus image)
static int[]	getRGBPixelsFromSlice (ImageStack stack, int sliceIndex)
static BioImage	GetBioImage (ImagePlus pl, VolumeD vol, double PhysicalX, double PhysicalY, double PhysicalZ)
	Converts ImagePlus to BioImage.
static BioImage	RunImageJ (BioImage b, string file, string param)
static void	RunMacroFiji (BioImage b, string macrofile, string param)
static async Task< BioImage >	RunStringFiji (BioImage b, string con, string param, bool headless, string outputPath=null)
static async Task< BioImage >	RunOnImageFiji (BioImage b, string con, int index, bool headless, bool onTab, bool bioformats, bool resultInNewTab)
static BioImage	RunOnImageInProcess (BioImage b, string con, bool headless, bool bioformats, bool resultInNewTab, bool registerWithImages=true)
static bool	CanParameterizeInteractiveRunCommand (string con)
static bool	TryParameterizeInteractiveRunCommand (BioImage previewImage, string con, bool headless, bool resultInNewTab, out string parameterizedCommand)
static async Task< BioImage >	RunOnImage (BioImage b, string con, bool headless, bool onTab, bool useBioformats, bool resultInNewTab)
static bool	Initialize (string path)

Static Public Attributes
static List< Process >	processes = new List<Process>()
static List< Macro.Command >	Macros = new List<Macro.Command>()

Properties
static bool	Initialized [get]
static string	ImageJPath [get, set]
static string	ImageJMacroPath [get]
static bool	UseFiji [get]

Member Function Documentation

CanParameterizeInteractiveRunCommand()

static bool BioLib.Fiji.CanParameterizeInteractiveRunCommand ( string con )

static

        {
            return TryExtractBareRunCommand(con, out _);
        }

GetBioImage()

static BioImage BioLib.Fiji.GetBioImage ( ImagePlus pl, VolumeD vol, double PhysicalX, double PhysicalY, double PhysicalZ )

static

Converts ImagePlus to BioImage.

Parameters

pl
maxz
maxc
maxt
location

Returns

The BioImage represented by the ImagePlus object.

        {
            BioImage bm = new BioImage(pl.getTitle());
            ImageStack st = pl.getImageStack();
            int b = pl.getBitDepth();
            int slices = pl.getNSlices();
            int chs = pl.getNChannels();
            int frs = pl.getNFrames();
            int rgb = (int)(pl.getBytesPerPixel() * 8);
            bool isrgb = isRGB(pl);
            bm.StackOrder = BioImage.Order.ZCT;
            bm.UpdateCoords(slices, chs, frs, BioImage.Order.ZCT);
            AForge.Bitmap[] outputBuffers = new AForge.Bitmap[Math.Max(1, slices * chs * frs)];
            for (int t = 0; t < frs; t++)
            {
                for (int z = 0; z < slices; z++)
                {
                    for (int c = 0; c < chs; c++)
                    {
                        AForge.Bitmap bmp;
                        if (!isrgb)
                        {
                            if (rgb > 8)
                            {
                                bmp = new AForge.Bitmap(st.getWidth(), st.getHeight(), AForge.PixelFormat.Format16bppGrayScale);
                            }
                            else
                            {
                                bmp = new AForge.Bitmap(st.getWidth(), st.getHeight(), AForge.PixelFormat.Format8bppIndexed);
                            }
                        }
                        else
                        {
                            bmp = new AForge.Bitmap(st.getWidth(), st.getHeight(), AForge.PixelFormat.Format24bppRgb);
                        }
                        int ind = bm.GetFrameIndex(z, c, t);
                        int stackIndex = GetHyperStackSliceIndex(pl, z, c, t);
                        outputBuffers[ind] = bmp;
                        if (!isrgb)
                        {
                            for (int y = 0; y < pl.getHeight(); y++)
                            {
                                for (int x = 0; x < pl.getWidth(); x++)
                                {
                                    double d = st.getVoxel(x, y, stackIndex);
                                    if (bmp.PixelFormat == PixelFormat.Format16bppGrayScale)
                                        bmp.SetValue(x, y, (ushort)d);
                                    else if (bmp.PixelFormat == PixelFormat.Format8bppIndexed)
                                        bmp.SetValue(x, y, (byte)d);
                                }
                            }
                        }
                        else
                        {
                            ImageProcessor ip = st.getProcessor(stackIndex + 1); // ImageStack uses 1-based indexing
                            // Cast to ColorProcessor to access RGB data
                            ColorProcessor colorProcessor = (ColorProcessor)ip;
                            for (int y = 0; y < pl.getHeight(); y++)
                            {
                                for (int x = 0; x < pl.getWidth(); x++)
                                {
                                    int v = colorProcessor.getPixel(x, y);
                                    int rv = (v >> 16) & 0xFF; // Red
                                    int gv = (v >> 8) & 0xFF;  // Green
                                    int bv = v & 0xFF;         // Blue
                                    bmp.SetValue(x, y, 0, (byte)rv);
                                    bmp.SetValue(x, y, 1, (byte)gv);
                                    bmp.SetValue(x, y, 2, (byte)bv);
                                }
                            }
 
                        }
                    }
                }
            }
            bm.Buffers.AddRange(outputBuffers.Where(buf => buf != null));
            for (int t = 0; t < chs; t++)
            {
                if (isrgb)
                    bm.Channels.Add(new AForge.Channel(t, rgb, 3));
                else
                    bm.Channels.Add(new AForge.Channel(t, rgb, 1));
                if (t == 0)
                {
                    bm.rgbChannels[0] = 0;
                }
                else
                if (t == 1)
                {
                    bm.rgbChannels[1] = 1;
                }
                else
                if (t == 2)
                {
                    bm.rgbChannels[2] = 2;
                }
            }
            bm.Resolutions.Add(new Resolution(pl.getWidth(), pl.getHeight(), bm.Buffers[0].PixelFormat, PhysicalX, PhysicalY, PhysicalZ, vol.Location.X, vol.Location.Y, vol.Location.X));
            bm.Volume = vol;
            bm.littleEndian = BitConverter.IsLittleEndian;
            bm.seriesCount = 1;
            BioImage.AutoThreshold(bm, true);
            if (rgb > 8)
                bm.StackThreshold(true);
            else
                bm.StackThreshold(false);
 
            if (bm.RGBChannelCount == 4)
            {
                bm.Channels.Last().SamplesPerPixel = 4;
            }
            return bm;
        }

GetImagePlus()

static ImagePlus BioLib.Fiji.GetImagePlus ( BioImage bm )

static

        {
            ImageStack ims = new ImageStack(bm.SizeX, bm.SizeY);
            if (bm.Buffers[0].PixelFormat == AForge.PixelFormat.Format16bppGrayScale)
            {
                // Populate the stack with 16-bit images
                for (int t = 0; t < bm.SizeT; t++)
                {
                    for (int z = 0; z < bm.SizeZ; z++)
                    {
                        for (int c = 0; c < bm.SizeC; c++)
                        {
                            short[] pixels = ConvertByteArrayToShortArray(bm.Buffers[bm.GetFrameIndex(z, c, t)].Bytes, true);
                            ImageProcessor ip = new ShortProcessor(bm.SizeX, bm.SizeY, pixels, java.awt.image.ColorModel.getRGBdefault());
                            ims.addSlice("Z" + z + "C" + c + "T" + t, ip);
                        }
                    }
                }
            }
            else if (bm.Buffers[0].PixelFormat == AForge.PixelFormat.Format8bppIndexed)
            {
                // Create a grayscale IndexColorModel
                byte[] grayscale = new byte[256];
                for (int i = 0; i < 256; i++)
                {
                    grayscale[i] = (byte)i;
                }
                IndexColorModel colorModel = new IndexColorModel(8, 256, grayscale, grayscale, grayscale);
                for (int t = 0; t < bm.SizeT; t++)
                {
                    for (int z = 0; z < bm.SizeZ; z++)
                    {
                        for (int c = 0; c < bm.SizeC; c++)
                        {
                            ImageProcessor ip = new ByteProcessor(bm.SizeX, bm.SizeY, bm.Buffers[bm.GetFrameIndex(z, c, t)].Bytes, colorModel);
                            ims.addSlice("Z" + z + "C" + c + "T" + t, ip);
                        }
                    }
                }
            }
            else if (bm.Buffers[0].PixelFormat == AForge.PixelFormat.Format24bppRgb)
            {
                for (int t = 0; t < bm.SizeT; t++)
                {
                    for (int z = 0; z < bm.SizeZ; z++)
                    {
                        for (int c = 0; c < bm.SizeC; c++)
                        {
                            byte[] bts = bm.Buffers[bm.GetFrameIndex(z, c, t)].Bytes;
                            // Convert the byte array to an int array for the RGB processor
                            int[] rgbPixels = new int[bm.SizeX * bm.SizeY];
                            for (int i = 0; i < rgbPixels.Length; i++)
                            {
                                int r = bts[i * 3] & 0xFF; // Red
                                int g = bts[i * 3 + 1] & 0xFF; // Green
                                int b = bts[i * 3 + 2] & 0xFF; // Blue
                                rgbPixels[i] = (r << 16) | (g << 8) | b; // Combine into RGB int
                            }
                            // Create a ColorProcessor
                            ImageProcessor ip = new ColorProcessor(bm.SizeX, bm.SizeY, rgbPixels);
                            ims.addSlice("Z" + z + "C" + c + "T" + t, ip);
                        }
                    }
                }
            }
            else if (bm.Buffers[0].PixelFormat == AForge.PixelFormat.Format32bppArgb || bm.Buffers[0].PixelFormat == AForge.PixelFormat.Format32bppRgb)
            {
                for (int t = 0; t < bm.SizeT; t++)
                {
                    for (int z = 0; z < bm.SizeZ; z++)
                    {
                        for (int c = 0; c < bm.SizeC; c++)
                        {
                            byte[] bts = bm.Buffers[bm.GetFrameIndex(z, c, t)].Bytes;
                            // Convert the byte array to an int array for the ColorProcessor
                            int[] rgbaPixels = new int[bm.SizeX * bm.SizeY];
                            for (int i = 0; i < rgbaPixels.Length; i++)
                            {
                                int r = bts[i * 4] & 0xFF;       // Red
                                int g = bts[i * 4 + 1] & 0xFF;   // Green
                                int b = bts[i * 4 + 2] & 0xFF;   // Blue
                                int a = bts[i * 4 + 3] & 0xFF;   // Alpha
                                rgbaPixels[i] = (a << 24) | (r << 16) | (g << 8) | b; // Combine into ARGB int
                            }
                            // Create a ColorProcessor with the ARGB int array
                            ImageProcessor ip = new ColorProcessor(bm.SizeX, bm.SizeY, rgbaPixels);
                            ims.addSlice("Z" + z + "C" + c + "T" + t, ip);
                        }
                    }
                }
            }
            else if (bm.Buffers[0].PixelFormat == AForge.PixelFormat.Format48bppRgb)
            {
                bm.To16Bit();
                // Populate the stack with 16-bit images
                for (int t = 0; t < bm.SizeT; t++)
                {
                    for (int z = 0; z < bm.SizeZ; z++)
                    {
                        for (int c = 0; c < bm.SizeC; c++)
                        {
                            short[] pixels = ConvertByteArrayToShortArray(bm.Buffers[bm.GetFrameIndex(z, c, t)].Bytes, true);
                            ImageProcessor ip = new ShortProcessor(bm.SizeX, bm.SizeY, pixels, java.awt.image.ColorModel.getRGBdefault());
                            ims.addSlice("Z" + z + "C" + c + "T" + t, ip);
                        }
                    }
                }
            }
            ImagePlus imp = new ImagePlus(bm.ID, ims);
            imp.setDimensions(bm.SizeC, bm.SizeZ, bm.SizeT);
            return imp;
        }

getRGBPixelsFromSlice()

static int[] BioLib.Fiji.getRGBPixelsFromSlice ( ImageStack stack, int sliceIndex )

static

        {
            // Get the ImageProcessor for the specified slice
            ImageProcessor ip = stack.getProcessor(sliceIndex + 1); // ImageStack uses 1-based indexing
            // Cast to ColorProcessor to access RGB data
            ColorProcessor colorProcessor = (ColorProcessor)ip;
            // Get the RGB pixel data
            return (int[])colorProcessor.getPixels();
        }

Initialize()

static bool BioLib.Fiji.Initialize ( string path )

static

This function is used to initialize the path of the ImageJ.exe file

Parameters

path	The path to the ImageJ executable.

        {
            Macro.Initialize();
            ImageJPath = path;
            return true;
        }

isRGB()

static bool BioLib.Fiji.isRGB ( ImagePlus image )

static

        {
            return image.getType() == ImagePlus.COLOR_RGB;
        }

RunImageJ()

static BioImage BioLib.Fiji.RunImageJ ( BioImage b, string file, string param )

static

        {
            if (!init)
                RunMacroFiji(b, file, param);
            Console.WriteLine("RunImageJ(" + file + "," + param);
            ImagePlus ip = GetImagePlus(b);
            Console.WriteLine("Fiji.GetImagePlus(" + b.ToString() + ")");
            WindowManager.setTempCurrentImage(ip);
            Console.WriteLine("WindowManager.setTempCurrentImage(" + ip.ToString() + ")");
            IJ.runMacroFile(file, param);
            BioImage bm = GetBioImage(ip, b.Volume, b.PhysicalSizeX, b.PhysicalSizeY, b.PhysicalSizeZ);
            int i = Images.GetImageCountByName(bm.Filename);
            if (bm.Filename.EndsWith("-" + i))
                bm.Filename.Replace("-" + i, "-" + (i + 1).ToString());
            return bm;
        }

RunMacroFiji()

static void BioLib.Fiji.RunMacroFiji ( BioImage b, string macrofile, string param )

static

It runs a macro in ImageJ

Parameters

file	the path to the macro file
param	The parameter to pass to the macro.

Returns

The macro is being returned.

        {
            if (UseFiji)
            {
                Process pr = new Process();
                pr.StartInfo.FileName = ImageJPath;
                pr.StartInfo.Arguments = "-macro " + macrofile + " " + param;
                pr.Start();
                processes.Add(pr);
            }
            else
            {
                RunImageJ(b, b.file, param);
            }
            BioLib.Recorder.Record($"Fiji.RunMacroFiji({b}, \"{macrofile}\", \"{param}\");");
        }

RunOnImage()

static async Task< BioImage > BioLib.Fiji.RunOnImage ( BioImage b, string con, bool headless, bool onTab, bool useBioformats, bool resultInNewTab )

static

        {
            if (b != null && b.isPyramidal)
                return await ImageJ.RunOnAllPyramidLevels(b, con, headless, onTab, useBioformats, resultInNewTab).ConfigureAwait(false);
            BioImage bm;
            if (UseFiji || OperatingSystem.IsMacOS())
                bm = await RunOnImageFiji(b, con, 0, headless, onTab, useBioformats, resultInNewTab);
            else
            {
                bioImage = b;
                cons = con;
                indexs = 0;
                Fiji.headless = headless;
                bioformats = useBioformats;
                resultInNewTabs = resultInNewTab;
                Recorder.Record($"Fiji.RunOnImage({b}, \"{con}\", {headless.ToString().ToLower()}, {onTab.ToString().ToLower()}, {useBioformats.ToString().ToLower()}, {resultInNewTab.ToString().ToLower()});");
                return RunImageJ();
            }
            return bm;
        }

RunOnImageFiji()

static async Task< BioImage > BioLib.Fiji.RunOnImageFiji ( BioImage b, string con, int index, bool headless, bool onTab, bool bioformats, bool resultInNewTab )

static

It runs a macro on the current image, saves the result as a new image, and then opens the new image in a new tab

Parameters

con	The ImageJ macro to run on the image.
headless	Whether to run ImageJ in headless mode.
onTab	If true, the imacro will be run on tab. If false, the macro will be run on selected image.
bioformats	If true, the image is opened using the bioformats plugin. If false, the image is opened using the default imagej open command.

Returns

The image is being returned as a new tab.

        {
            if (UseFiji || OperatingSystem.IsMacOS())
            {
                string filename = "";
                string dir = Path.GetDirectoryName(b.file);
                dir = dir.Replace("\\", "/");
                if (b.ID.EndsWith(".ome.tif"))
                {
                    filename = Path.GetFileNameWithoutExtension(b.ID);
                    filename = filename.Remove(filename.Length - 4, 4);
                }
                else
                    filename = Path.GetFileNameWithoutExtension(b.ID);
                string file = dir + "/" + filename + ".ome.tif";
                string filet = dir + "/" + filename + "-temp.ome.tif";
                if (!bioformats)
                    file = dir + "/" + filename + ".tif";
                string outputFile = bioformats ? filet : filet + ".tif";
                string roiZip = ExportRoiZipForFiji(b, filename);
                string donepath = Path.GetDirectoryName(Environment.ProcessPath);
                donepath = donepath.Replace("\\", "/");
                string op = b.ID.Replace("\\", "/");
                string ex = Path.GetExtension(b.ID);
                op = op.Replace(ex, ".ome.tif");
                //if (File.Exists(file))
                //    File.Delete(file);
                BioImage cleanInput = BioImage.Copy(b, false);
                BioImage.SaveOME(cleanInput, file);
                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 +
                "roiManager(\"Show None\"); run(\"Select None\"); " +
                "run(\"Bio-Formats Exporter\", \"save=" + filet + " export compression=Uncompressed\"); " +
                "dir = \"" + donepath + "\"" +
                "File.saveString(\"done\", dir + \"/done.txt\");";
                if (!bioformats)
                    st =
                    "open(getArgument); " +
                    (!string.IsNullOrWhiteSpace(roiZip)
                        ? "roiManager(\"Reset\"); roiManager(\"Open\", \"" + roiZip.Replace("\\", "/") + "\"); roiManager(\"Show All\"); "
                        : string.Empty) +
                    con +
                    "roiManager(\"Show None\"); run(\"Select None\"); " +
                    "saveAs(\"Tiff\",\"" + outputFile + "\"); " +
                    "dir = \"" + donepath + "\"" +
                    "File.saveString(\"done\", dir + \"/done.txt\");";
 
                BioImage bm = await Fiji.RunStringFiji(b, st, "", headless, outputFile);
                if (File.Exists(file) && bioformats)
                    File.Delete(file);
                BioLib.Recorder.Record($"Fiji.RunOnImageFiji({b}, \"{con}\", {index}, {headless.ToString().ToLower()}, {onTab.ToString().ToLower()}, {bioformats.ToString().ToLower()}, {resultInNewTab.ToString().ToLower()});");
                return bm;
            }
            else
            {
                cons = con;
                indexs = index;
                Fiji.headless = headless;
                onTabs = onTab;
                Fiji.bioformats = bioformats;
                resultInNewTabs = resultInNewTab;
                bioImage = b;
                Task<BioImage> t = new Task<BioImage>(() => RunImageJ());
                t.Start();
                t.Wait();
                BioLib.Recorder.Record($"Fiji.RunOnImageFiji({b}, \"{con}\", {index}, {headless.ToString().ToLower()}, {onTab.ToString().ToLower()}, {bioformats.ToString().ToLower()}, {resultInNewTab.ToString().ToLower()});");
                return t.Result;
            }
        }

RunOnImageInProcess()

static BioImage BioLib.Fiji.RunOnImageInProcess ( BioImage b, string con, bool headless, bool bioformats, bool resultInNewTab, bool registerWithImages = true )

static

        {
            lock (imageJRunLock)
            {
                cons = con;
                indexs = 0;
                Fiji.headless = headless;
                Fiji.bioformats = bioformats;
                resultInNewTabs = resultInNewTab;
                bioImage = b;
                return RunImageJ(registerWithImages);
            }
        }

RunStringFiji()

static async Task< BioImage > BioLib.Fiji.RunStringFiji ( BioImage b, string con, string param, bool headless, string outputPath = null )

static

It runs a macro in ImageJ

Parameters

con	The macro code
param	The parameters to pass to the macro.
headless	Whether or not to run ImageJ in headless mode.

Returns

Nothing.

        {
            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);
            Console.WriteLine("Deleting temp file:" + p);
            File.Delete(p);
            string f = outputPath;
            if (string.IsNullOrWhiteSpace(f))
            {
                Console.WriteLine("Directory: " + Path.GetDirectoryName(b.file));
                Console.WriteLine("FileName: " + Path.GetFileNameWithoutExtension(b.file));
                f = Path.GetDirectoryName(b.file) + "/" + Path.GetFileNameWithoutExtension(b.file) + "-temp.ome.tif";
            }
            Console.WriteLine("Opening: " + f);
            if (File.Exists(f))
                await BioImage.OpenAsync(f, true, true, true, 0);
            Console.WriteLine("GetImage: " + f);
            BioImage bm = Images.GetImage(f);
            BioLib.Recorder.Record($"Fiji.RunStringFiji({b}, \"{con}\", \"{param}\", {headless.ToString().ToLower()});");
            return bm;
        }

TryParameterizeInteractiveRunCommand()

static bool BioLib.Fiji.TryParameterizeInteractiveRunCommand ( BioImage previewImage, string con, bool headless, bool resultInNewTab, out string parameterizedCommand )

static

        {
            parameterizedCommand = con;
            if (previewImage == null || headless || !TryExtractBareRunCommand(con, out string commandName))
                return false;
 
            lock (imageJRunLock)
            {
                ImageJRecorder recorder = ImageJRecorder.getInstance();
                bool createdRecorder = false;
                bool previousRecordInMacros = ImageJRecorder.recordInMacros;
                try
                {
                    if (recorder == null)
                    {
                        recorder = new ImageJRecorder(false);
                        createdRecorder = recorder != null;
                    }
 
                    if (recorder == null)
                        return false;
 
                    ImageJRecorder.recordInMacros = true;
                    ImageJRecorder.resetCommandOptions();
                    string previousText = recorder.getText() ?? string.Empty;
 
                    cons = con;
                    indexs = 0;
                    Fiji.headless = headless;
                    resultInNewTabs = resultInNewTab;
                    bioImage = previewImage;
                    RunImageJ(false);
 
                    string recordedText = recorder.getText() ?? string.Empty;
                    if (TryExtractRecordedRunCommand(recordedText, previousText, commandName, out parameterizedCommand))
                        return true;
 
                    string options = ImageJRecorder.getCommandOptions() ?? string.Empty;
                    if (string.IsNullOrWhiteSpace(options))
                        return false;
 
                    parameterizedCommand = BuildRunCommand(commandName, options);
                    return true;
                }
                catch (Exception e)
                {
                    Console.WriteLine($"[Fiji.TryParameterizeInteractiveRunCommand] {e.Message}");
                    parameterizedCommand = con;
                    return false;
                }
                finally
                {
                    ImageJRecorder.resetCommandOptions();
                    ImageJRecorder.recordInMacros = previousRecordInMacros;
                    if (createdRecorder && recorder != null)
                    {
                        try
                        {
                            recorder.close();
                        }
                        catch
                        {
                        }
                    }
                }
            }
        }

Member Data Documentation

Macros

List<Macro.Command> BioLib.Fiji.Macros = new List<Macro.Command>()

static

processes

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

static

Property Documentation

ImageJMacroPath

string BioLib.Fiji.ImageJMacroPath

staticget

        {
            get
            {
                if (System.Runtime.InteropServices.RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
                {
                    string p = System.IO.Path.GetDirectoryName(ImageJPath).Replace("\\", "/");
                    p = p.Replace("/Fiji.app/Contents/MacOS/", "/Fiji.app/");
                    return p;
                }
                else
                    return System.IO.Path.GetDirectoryName(ImageJPath) + "/macros/";
            }
        }

ImageJPath

string BioLib.Fiji.ImageJPath

staticgetset

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

Initialized

bool BioLib.Fiji.Initialized

staticget

{ get { return init; } private set { init = true; } }

UseFiji

bool BioLib.Fiji.UseFiji

staticget

        {
            get
            {
                if(ImageJPath.Contains("Fiji"))
                    return true;
                else
                    return false;
            }
        }

---

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

• BioLib/Source/Fiji.cs