Bioimage Analysis Wiki

This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong.
====== Python + ImageJ, Fiji Cookbook ======

This page was last edited at: ~~LASTMOD~~

For learning image processing using Fiji and Jython scripting, go to excellent tutorials written by Albert Cardona, such as [[https://www.ini.uzh.ch/~acardona/fiji-tutorial/ | here in his website]] or [[https://imagej.net/Jython_Scripting | here in ImageJ.net]]. The former is in a tutorial style so if you want to learn how to do scripting using Jython, that's the place where you go. Recently, there is a very good tutorial page for real beginners: [[https://learning.rc.virginia.edu/notes/fiji-scripting/|here (UVA Research Computing Learning Portal).]]  

This page is like a cookbook: there are no details about how to do programming, but more centered on how to use Classes built in ImageJ and its plugins. This is because the style how each algorithm is implemented is not consistent (they are written by 1000 different people!) so it takes a while to figure out how to use them when we are writing a bioimage analysis workflow. Examples below show how they are actually used in Jython scripts, to save our time for reading the source code of each. 

Other resources: 

[[https://jython.readthedocs.io/en/latest/|The Jython book "The Definitive Guide to Jython"]]: it's saying that the book is a version from 2009, but the latest commit is in Oct. 2018. 
===== Jython Interpreter =====
A way to run jython script from jython interpreter, interactively.
<code python>
#simply do
>>> execfile('path/to/script.py')

#if you want to have global variables returned, then
>>> paras = {} 
>>> execfile('path/to/script.py', paras)
>>> print paras
# ... you will see that the objects retained in global variable
# as dictionary key-value pair. You could then get for example
>>> imp_returned = paras['imp']
</code>

Of course you could do this by clicking 'run' for scripts opened in script editor as well, but in this way, you could still interact with the objects created by the execfile.

===== Singed/Unsigned value conversions =====

Java normally uses signed values but images are generally not signed (for 8 bit, 16 bit images). For this reason, when you work with images as an single array, there will be some need for conversion between signed value to unsigned value, and vice versa. In Jython, one could use functions in [[http://www.jython.org/docs/library/struct.html|struct]]. Below is an example of converting an 8-bit pixel array extracted from a image to unsigned 8-bit values.  

<code python linenums:1>
from ij import IJ
import struct

def s2u8bit(v):
    return struct.unpack("B", struct.pack("b", v))[0]
 
imp = IJ.getImage()
signedpix = imp.getProcessor().getPixels()
 
pix = map(s2u8bit,signedpix)
 
#check that the conversion worked. 
# this example was made for binary image, to print only values 255  
for j in range(len(pix)):
        curval = pix[j]
        #curval = s2u8bit(curval)
        if curval is 0:
            print '--'
        else:
            print curval
</code>

===== Singed/Unsigned value conversions with bitwise & operator =====

Here is another example of going back and forth between signed and unsigned values. The scripts load "blobs.gif" example image from NIH server, then replaces pixels with values between 50 and 200 to 0. A kind of density slicing workflow.  

<code python linenums:1>
from ij import IJ
import jarray

imp = IJ.openImage("http://imagej.nih.gov/ij/images/blobs.gif")
imp.show()

# ImageProcessor.getPixels() returns an array of signed pixel values
signedpix = imp.getProcessor().getPixels()

# converting signed pixel values to unsigned using bitwise operation. 
# & 0xff : 8bit
# & 0xffff : 16bit
# & 0xffffffff : 32bit 
unsignedpix = map(lambda p: p & 0xff, signedpix)

# replace pixels with value more than 50 and less than 200 to 0. 
replaced_unsignedpix = map(lambda p: p if (p < 200) and (p > 50) else 0, unsignedpix)

# convert signed pixel values to unsigned. 
replaced_signedpix = map(lambda p: (p - 256) if p > 127 else p, replaced_unsignedpix)

# python array to java array. 
jreplaced_signedpix = jarray.array(replaced_signedpix, 'b')

imp.getProcessor().setPixels(jreplaced_signedpix)
imp.updateAndDraw()
</code>

Same processing could be also done by replacing L7 to L23 by
<code python linenums:1>
for j in range(imp.getHeight()):

</code>

===== ImageJ2 / SciJava =====

==== Running a script from another script ====

<code python>
#@ ScriptService scriptService

fullscript = "#@ String A_STRING\n" + \
"#@ Boolean (label='An Option', value=true) OPTION"

scriptmodule = scriptService.run(".py", fullscript, True).get()
scriptInputmaps = scriptmodule.getInputs()

print scriptmodule.getOutputs()
print scriptInputmaps
# how can we know the dialog was Canceled?
print scriptmodule.isInputResolved('A_STRING')
</code>

===== Data IO =====

==== Getting path to a file interactively ====

<code python linenums:1>
from ij.io import OpenDialog
op = OpenDialog("Choose Track Data...", "")
print op.getDirectory()+ op.getFileName()
</code>

==== Getting the directory where the curently opened image is stored ====
<code python:1>
from ij import IJ

imp = IJ.getImage()
print imp.getOriginalFileInfo().directory
</code>

... can also be done by ''%%IJ.getDirectory("image")%%'', but with this IJ method, one cannot specify target ImagePlus object. See also the [[https://github.com/imagej/imagej1/blob/master/ij/IJ.java#L1652-L1663|source code of IJ.getDirectory]]

Be careful not to mix with the usage of ''%%getFileInfo%%''. This does not hold directory information. 


==== Regular Expression to get meta information from file name ====


Here is an example, using re package. To construct pattern, several web services are available such as:

http://www.pythonregex.com/ \\
or\\
https://regex101.com/

 
<code python linenums:1>
import re

filename = '/Volumes/data/0076-14--2006-01-23/data/--W00088--P00001--Z00000--T00000--nucleus-dapi.tif'
#filename = '--W00088--P00001--Z00000--T00000--nucleus-dapi.tif'
pattern = re.compile('(.*)--W(.*)--P(.*)--Z(.*)--T(.*)--(.*)\.(.*)')
res = re.search(pattern, filename)
basename = res.group(1)
spot = res.group(2)
position = res.group(3)
zpos = res.group(4)
tpos = res.group(5)
imgtype = res.group(6)
filetype = res.group(7)
print 'prefix', basename
print 'spot', spot
print 'position', position
</code>

==== Loading Image from File system.  ====

Four ways to open image
<code python linenums:1>
from ij import IJ, ImagePlus
from ij.io import Opener

srcpath = '/tt/img.tif'

# uisng constructor
imp1 = ImagePlus(srcpath)

# using IJ static method
imp2 = IJ.openImage(srcpath)

# Using Opener class
imp3 = Opener().openImage(srcpath)

# using LOCI BioFormats
from loci.plugins import BF
# returned is an array of ImagePlus, in many cases just one imp.  
imps = BF.openImagePlus(src)
imp4 = imps[0] 
</code>

==== Retrieving Image Properties ====

To know image pixel resolution, TiffDecoder class is useful as it does not load image data. For big images this is important since getting image properties would be much faster. 

<code python linenums:1>
from ij.io import TiffDecoder

# using 'mitosis (5d)' sample image. 
directory = '/tmp/examples/'
filename = 'mitosis.tif'
td = TiffDecoder(directory, filename)
imginfos = td.getTiffInfo()
print 'Resolution: ', imginfos[0].unit, '/ pixel' 
print 'x resoluition:', imginfos[0].pixelWidth
print 'y resoluition:', imginfos[0].pixelHeight

# to print various image parameters
print imginfos[0].description
print '---'
# to print imgage optional info
print imginfos[0].info
</code>
==== Path operations ====

To extract file name and file name without extension,  
<code python linenums:1>
import os 
srcpath = '/Users/miura/tmp/data.csv'
filename = os.path.basename(srcpath)
print filename #prints data.csv

parentdirectory = os.path.dirname(srcpath)
print parentdirectory #prints /Users/miura/tmp

print os.path.join(parentdirectory, filename) #prints same as srcpath

#above is enough to join directory and file name,
# but if you specifically want to use path separator of the os
print os.sep 

#filename without extension
print os.path.splitext(filename)[0] #prints /Users/miura/tmp/data
</code>

Alternatively, one could use File class in Java. 
<code python linenums:1>
from java.io import File
imgpath = 'Z:\\20_23h_firstSample\\20h_shifted.tif'
ff = File(imgpath)
print ff.getParent()
print ff.getName()
</code>

Fiji comes with ApacheIO library, and can be used quite conveniently for disintegrating file paths. See [[https://commons.apache.org/proper/commons-io/javadocs/api-release/org/apache/commons/io/FilenameUtils.html|Javadoc]] for many other convenient methods. 
<code python linenums:1>
from org.apache.commons.io import FilenameUtils

srcpath = '/Users/miura/tmp/data.csv'


baseName = FilenameUtils.getBaseName(srcpath)
print "Basename: ", baseName

ext = FilenameUtils.getExtension(srcpath)
print "Extension: ", ext

filename = FilenameUtils.getName(srcpath)
print "File name: ", filename

pathWOext = FilenameUtils.removeExtension(srcpath)
print "Fullpath without ext: ", pathWOext

# outputs
#
# Basename:  data
# Extension:  csv
# File name:  data.csv
# Fullpath without ext:  /Users/miura/tmp/data
</code>



==== Loading a textfile as String ====

<code python linenums:1>
path = "/Users/miura/data.txt"
with open(inpath, 'r') as myfile:
  data = myfile.read()
print data
</code>

==== Saving String as a textfile ====

<code python linenums:1>
with open("/Users/miura/Downloads/testOutput.txt", "w") as text_file:
    text_file.write("The first line\nAnother line")    
text_file.close()
</code>
==== Loading CSV file ====

<code python linenums:1>
from ij import IJ
from util.opencsv import CSVReader
from java.io import FileReader

def readCSV(filepath):
   reader = CSVReader(FileReader(filepath), ",")
   ls = reader.readAll()
   for item in ls:
   	  IJ.log(item[4])

filepath = '/Users/miura/test.csv'
readCSV(filepath)
</code>

WIth purely pythonic way:
<code python linenums:1>
import csv

filepath = '/Users/miura/Dropbox/ToDo/Pavel/data.txt'
f = open(filepath, 'rb')
data = csv.reader(f, delimiter=' ')
for row in data:
	print(len(row))
	print ', '.join(row)
</code>
In this case, imported array is python array. to convert this to Java array, use
<code python linenums:1>
from jarray import array
javaarray = array(pythonarray, 'type')
</code>
see [[http://www.jython.org/archive/21/docs/jarray.html|here]] for more details.

==== Saving CSV file (data table) ====

Uses opencsv library, which is preinstalled in Fiji. 
 
<code python linenums:1>
from util.opencsv import CSVWriter
from java.io import FileWriter
from java.lang.reflect import Array
from java.lang import String, Class
 
writer = CSVWriter(FileWriter("c:/temp/testcsv.csv"), ',')
data = Array.newInstance(Class.forName("java.lang.String"), 3)
#String[] entries = "first#second#third".split("#");
data[0] = str(11)
data[1] = str(23)
data[2] = str(5555)
writer.writeNext(data)
writer.close()
</code>

This could be rewritten in a bit more simple way using jarray module. 

<code python linenums:1>
from util.opencsv import CSVWriter
from java.io import FileWriter
from java.lang import String
from jarray import array as jarr
 
writer = CSVWriter(FileWriter("/Users/miura/Desktop/eggs1.csv"), ',')
header = ['x', 'y', 'z']
jheader = jarr(header, String)
data = [11,23,5555]
datas = map(str, data)
jdata = jarr(datas, String)
writer.writeNext(jheader)
writer.writeNext(jdata)
writer.close()
</code>

... or purely in pythonic way using csv module. This example is very simple since it does not use Java array at all. If you need to use the array for some other purpose in Java classes, python array must be converted. 
<code python linenums:1>
import csv

f = open('/Users/miura/Desktop/eggs2.csv', 'wb')
writer = csv.writer(f)
writer.writerow(['does this work'])
writer.writerow(['Spam', 'Lovely Spam', 'Wonderful Spam'])
#can chop down more
writer.writerows(['Spam', 'Lovely Spam', 'Wonderful Spam'])
f.close()
</code>

... a bit more realistic, writing numerical data. 
<code python linenums:1>
'''
writing data to a csv file. 
'''
import os, csv

# prepare test data to wirte to a csv file
data1 = range(10)
data2 = [x * x for x in data1]
data3 = [pow(x, 3) for x in data1]
print data3

# prepare path
root = "/Users/miura/Desktop"
filename = "testdata.csv"
fullpath = os.path.join(root, filename)
print fullpath

# open the file first (if its not there, newly created)
f = open(fullpath, 'wb')

# create csv writer
writer = csv.writer(f)

# for loop to write each row
for i in range(len(data1)):
	row = [data1[i], data2[i], data3[i]]
	writer.writerow(row)

#writer.writerows([data1, data2, data3])

# close the file. 
f.close()
</code>
==== Accessing multiple files to load image sequences ====

A simple way is to use glob package (file not loaded in this example).
<code python linenums:1>
import glob, os
from ij.io import DirectoryChooser 

srcDir = DirectoryChooser("Choose!").getDirectory()
for filename in glob.glob(os.path.join(srcDir, "*.tif")):
print(os.path.basename(filename))
</code>

Here is a cool script written by Christian Tischer for loading image series using file prefix as dictionary keys. 
<code python linenums:1>
from ij import IJ
from ij.io import DirectoryChooser 
import os

def run():
   srcDir = DirectoryChooser("Choose!").getDirectory()
   IJ.log("directory: "+srcDir)
   theIndex = {}
   for root, directories, filenames in os.walk(srcDir):
      for filename in filenames:
         if not filename.endswith(".tif"):
            continue
         #IJ.log(filename)
         treatment, well, position, z, time, channel = filename.split("--")
         identifier = treatment + '--' + well + '--' + position
         theIndex[identifier] = theIndex.get(identifier, []) + [time]
         #IJ.log("identifier: "+identifier)
         #IJ.log("time: "+time)

   print(theIndex.keys())

   for index in theIndex.keys():
      print(index)
      cmd = "Image Sequence..."
      options = "open="+srcDir+"  or="+index+".*--gfp.tif sort"	
      IJ.run(cmd, options)
      
run()
</code>

==== Accessing tiff stack via Virtual Stack class ====


<code python linenums:1>
from ij.io import OpenDialog
from ij.io import TiffDecoder
from ij.plugin import FileInfoVirtualStack
 
od = OpenDialog("stack", "")
td = TiffDecoder(od.getDirectory(), od.getFileName())
info = td.getTiffInfo()
fi = info[0]
print fi.nImages
vs = FileInfoVirtualStack(fi, False)
for i in range(1,fi.nImages):
    ip = vs.getProcessor(i)
    print i
</code>

==== Viewing tiff stack as Virtual Stack ====

A bit of modification of above code allows you to view a stack as a virtual stack. Since FileInfoVirtualStack is an extended class of ImageStack, a ImagePlus can be directly created. 

<code python linenums:1>
from ij.io import OpenDialog
from ij.io import TiffDecoder
from ij.plugin import FileInfoVirtualStack
from ij import ImagePlus
 
od = OpenDialog("stack", "")
td = TiffDecoder(od.getDirectory(), od.getFileName())
info = td.getTiffInfo()
fi = info[0]
print fi.nImages
vs = FileInfoVirtualStack(fi, False)
imp = ImagePlus("testVirtual", vs)
imp.show()
</code>

==== Saving Hyperstack as Separate 2D files ====

If you have let's say a 5D hyperstack and you want to save them as separate 2D tiff files with each file name having file_c00_t0001_z_0000.tif and so on, here is an example script. 

<code python linenums:1>
from ij import IJ
import os

savepath = IJ.getDirectory("")
imp = IJ.getImage()
ssize = imp.getStackSize()
titleext = imp.getTitle()
title = os.path.splitext(titleext)[0]
dimA = imp.getDimensions()
for c in range(dimA[2]):
	for z in range(dimA[3]):
		for t in range(dimA[4]):
			imp.setPosition(c+1, z+1, t+1)
			print c, z, t
			numberedtitle = \
			title + "_c" + IJ.pad(c, 2) + \
			"_z" + IJ.pad(z, 4) + \
			"_t" + IJ.pad(t, 4) + ".tif"
			stackindex = imp.getStackIndex(c + 1, z + 1, t + 1)
			aframe = ImagePlus(numberedtitle, imp.getStack().getProcessor(stackindex))
			IJ.saveAs(aframe, "TIFF", savepath + numberedtitle)
			IJ.log("saved:" + numberedtitle)
</code>

==== Loading Separate Image Files as a Hyperstack ====

This is an expaple of using regular expression to match file names, and to collect images as a ImagePlus array then convert it to a Hyperstack. 

https://gist.github.com/miura/6453158

<code python linenums:1>
import os
import re
from ij import IJ
from ij.io import Opener
from ij.plugin import Concatenator
from jarray import array
 
srcpath = IJ.getFilePath('Choose the first file')
filename = os.path.basename(srcpath)
srcDir = os.path.dirname(srcpath)
 
#chosefile = '20130711_R1_GR001_B1_L2.lsm'
#pattern = re.compile('(.*)_R(.*)_GR(.*)_B(.*)_L(.*)\.lsm')
pattern = re.compile('(.*)_R(.*)_GR(.*)_B(.*)_L(.*)\.(.*)')
 
res = re.search(pattern, filename)
 
basename = res.group(1)
repetition = res.group(2)
grouprepetition = res.group(3)
block = res.group(4)
location = res.group(5)
extension = res.group(6)
 
GRlist = []
for root, directories, filenames in os.walk(srcDir):
	for filename in filenames:
		match = re.search(pattern, filename)
		if match is not None:
			#print filename, match.group(3)
			GRlist.append(match.group(3))
 
print srcDir
print 'files: ', len(GRlist)
 
GRlist = sorted(GRlist)
timeseries = []
 
for timepoint in GRlist:
	thisfile = basename + '_R' + repetition + '_GR' + timepoint + '_B' + block + '_L' + location + '.' + extension
	print thisfile
	imp = Opener.openUsingBioFormats(os.path.join(srcDir, thisfile))
	imp.setOpenAsHyperStack(False)
	timeseries.append(imp)
 
newname = basename + '_R' + repetition + '_B' + block + '_L' + location + '.' + extension
calib = timeseries[0].getCalibration()
dimA = timeseries[0].getDimensions()
jaimp = array(timeseries, ImagePlus)
ccc = Concatenator()
#allimp = ccc.concatenateHyperstacks(jaimp, newname, False)
allimp = ccc.concatenate(jaimp, False)
allimp.setDimensions(dimA[2], dimA[3], len(GRlist))
allimp.setCalibration(calib)
allimp.setOpenAsHyperStack(True)
allimp.show()
</code>

==== Wait until a file is created ====

There are cases that you need to wait till a file is created. Below two lines does this waiting task. 

<code python linenums:1>
while not os.path.exists(filepath):
   time.sleep(1)
</code>


==== Downloading a CSV file from Internet and save locally ====

Using IJ method. 

<code python linenums:1>
from ij import IJ
from java.io import PrintWriter
content = IJ.openUrlAsString('http://cmci.info/imgdata/tenFrameResults.csv')
out = PrintWriter('/Users/miura/tmp/test1.csv')
out.print(content)
out.close()
</code>

Only in Java
<code python linenums:1>
from ij import IJ
from ij.io import Opener
from java.io import File, FileOutputStream
from java.net import URL
from java.lang import Long
from java.nio.channels import Channels


websitecsv = URL("http://cmci.info/imgdata/tenFrameResults.csv")
csvchannel  = Channels.newChannel(websitecsv.openStream())

ff = File("/Users/miura/tmp/test.csv")
if not ff.exists():
   ff.createNewFile()
fos = FileOutputStream(ff)
fos.getChannel().transferFrom(csvchannel, 0, Long.MAX_VALUE)
fos.close()
IJ.log("done")
</code>

==== Creating JSON object ====

JSON object can be directly created from Java Maps. 
Here, we use TreeMap to keep the ordering of Map elements. 

<code python>
from java.util import TreeMap
from org.json import JSONObject

amap = TreeMap()
amap.put("red", 0.6)
amap.put("green", 1)
amap.put("blue", 0.3)
jo = JSONObject(amap)
print str(jo)
</code>

This code yields:
<code>
{"blue":0.3,"green":1,"red":0.6}
</code>

==== Generating Time Stamp String ====

<code python>
from java.util import Date
from java.text import SimpleDateFormat

timeStamp = SimpleDateFormat("yyyy.MM.dd.HH.mm.ss").format(Date())
print timeStamp
</code>

===== Arrays (Lists) =====

"Array" is called "List" in python. When using list in jython, we should be very very careful whether an array (or list) is Java array or Python list: they both are set of numbers, but they sometimes require conversion. This happens especially when you want to use array in the argument of certain Java methods. 

We first start with Python list (or for me is "python array"):  
==== Appending Elements to a List ====

Two ways to append an element to a list. 
<code:py>
a = []
a.append(1)
a.append(2)
print a
# [1, 2]

b = []
b = b + [1]
b = b + [2]
print b
# [1, 2]
#... can be also written like
b = []
b += [1]
b += [2]
print b
# [1, 2]

</code>
==== Concatenate lists ====
<code python linenums:1>
a = [1, 2, 3]
b = [4, 5, 6]
a = a + b
print a
</code>
will prints 
<code>
[1, 2, 3, 4, 5, 6]
</code>
in the console.

==== Remove redundant elements in an Array ====

<code python linenums:1>
a=[1,2,3,4,5,5] 
a=list(set(a))
a.sort()
print a
</code>

==== ImagePlus Array ====

Some arguments ask for an array of specific type. Since Python array is not java array, {{http://onlamp.com/pub/a/python/2002/04/11/jythontips.html?page=2|one should generate a Java array}}. For this, you could use jarray package. 
<code python linenums:1>
import jarray

ja = jarray.array([0, 1, 2, 3], 'i')
</code>
The second argument specifies the type. 

|z	| boolean|
|c	| char|
|b	| byte|
|h	| short|
|i	| int|
|l	| long|
|f	| float|
|d	| double|

What if you want to make a java array of a specific class? You could then name the class as the second argument. For example, 
<code python linenums:1>
import jarray
from ij import IJ
from ij.plugin RGBStackMerge

imp1 = IJ.openImage(path1)
imp2 = IJ.openImage(path2)
imgarray = jarray.array([imp1, imp2], ImagePlus)
colorimp = RGBStackMerge().mergeHyperstacks(imgarray, False) 
</code>

==== Converting Java array types ====

Sometimes we need to convert the type of Java array e.g. double[] to int[]. For this, there is no magic trick and need to run a loop. Below is a code fragment. 

<code:py> 
from ij.process import StackStatistics
import jarray

stackstats = StackStatistics(imp)
histD = stackstats.histogram()
hist = jarray.zeros(len(histD), 'i')
for i in range(len(histD)):
    hist[i] = int(histD[i])
</code>

==== Combined Sort of Lists ====

<code python linenums:1>
from operator import itemgetter
ll = [1, 2, 3, 4]
ll2 = [5, 7, 8, 6]
aa = sorted(zip(ll, ll2), key=itemgetter(1), reverse=True)
print aa
ll, ll2 = zip(*aa)
print list(ll)
print list(ll2)
# in one line
# ll, ll2 = (list(t) for t in zip(*sorted(zip(ll, ll2))))
</code>

... results in:

<code>
[(3, 8), (2, 7), (4, 6), (1, 5)]
(3, 2, 4, 1)
(8, 7, 6, 5)
</code>

==== Looping Two Arrays Simultaneously ====

Python fo-looping is pretty flexible. 

<code python linenums:1>
a = [1, 2, 3, 4]
b = [10, 20, 30, 40]

for aa, bb in zip(a, b):
	c = aa + bb
	print c
</code>

zip command creates a list of tuples from elements of arrays a and b.

==== Using Java8 Stream ====

Stream-related syntax introduced from Java8 is useful for writing clear codes, but cannot be directly used in Jython. Below is a way to use StreamAPI, by introducing Jython classes implementing the Consumer interface. I took this idea from [[https://stackoverflow.com/questions/45417732/jython-function-to-java-consumer|here]]. For the Java Stream API, this page is useful: [[https://www.baeldung.com/java-8-streams|The Java 8 Stream API Tutorial]]

<code python>
from java.util.Arrays import asList
from java.util.function import Predicate, Consumer, Function
from java.util.stream import Collectors
from java.util import Arrays


class jc(Consumer):
    def __init__(self, fn):
        self.accept=fn

class jf(Function):
    def __init__(self, fn):
        self.apply = fn

class jp(Predicate):
    def __init__(self, fn):
        self.test = fn
        
def jprint(x):
	print x

tt = ["a", "b", "c"]
c = Arrays.stream(tt).count()
print c

print "forEach printing"
Arrays.stream(tt).forEach(jc(lambda x: jprint("="+x)))

print "forEach printing parallelly"
Arrays.stream(tt).parallel().forEach(jc(lambda x: jprint("="+x)))

print "has b?", Arrays.stream(tt).anyMatch(jp(lambda x: x=="b"))
print "has z?", Arrays.stream(tt).anyMatch(jp(lambda x: x=="z"))

# convert to Java List<>
jtt = Arrays.asList(tt)

jtt.stream().forEach(jc(lambda x: jprint("+"+x)))
</code>
===== Event Listener =====

An example of implementing KeyListener, written by Christoph Schiklenk.
This script loads a tab-delimited text file, show it in a results-table style that accepts key-press down event and loads the data in the currently selected row. 
 
<code python linenums:1>
from java.awt.event import KeyEvent, KeyAdapter
from os.path import basename, splitext

path = "/Users/miura/Desktop/tmp/val_p1_c2.tsv"
filename = splitext(basename(path))[0]

# imp will be something like a global variable. accessible from 
# funcitons. 
imp = IJ.getImage()

def doSomething(imp, keyEvent):
   """ A function to react to key being pressed on an image canvas. """
   IJ.log("clicked keyCode " + str(keyEvent.getKeyCode()) + " on image " +
str(imp.getTitle()))
   # Prevent further propagation of the key event:
   keyEvent.consume()

class ListenToKey(KeyAdapter):
   def keyPressed(this, event):
      eventSrc = event.getSource()
      tp = eventSrc.getParent() #panel is the parent, canvas being component. 
      print eventSrc
      print tp
      print "selected line:", tp.getSelectionEnd()
      print "...", tp.getLine(tp.getSelectionEnd()) 
      
      #imp = event.getSource()
      doSomething(imp, event)

# - - - M A I N - - -

listener = ListenToKey()

txtfile = open(path)
tw = TextWindow("Results_" + filename, txtfile.readlines(1)[0], "", 300,
700)

for line in txtfile.readlines():
   frame, dist, volChI, volChII = line.split("\t")
   tw.append(str(frame) + "\t" + str(dist) + "\t" + str(volChI) + "\t" +
str(volChII))

tw.getTextPanel().addKeyListener(listener)

</code>

===== GUI: wait for user =====

To pause the script processing and wait for the user input (e.g. creating amanual ROI), use WaitForUserDialog class. 

<code python>
from ij.gui import WaitForUserDialog

print("start")
wud = WaitForUserDialog("test: wait for user", "Click OK if you are done with your manual work")
print("waiting...")
wud.show()
print("done")
</code>

===== HashMap =====

==== Python ====

Maps are called Dictionary in Python. 

To split a dictionary to key lists and value lists:
<code python linenums:1>
results = {'mean': 10.0, 'sd': 3.3}
headers = results.keys()
values = results.values()
print headers
print values
</code>

==== Java ====

Getting the max number of keys, in case if the key is integer. 
<code python linenums:1>
from java.util import HashMap, Collections

tt = HashMap()
tt.put(1, "1")
tt.put(200, "2")
tt.put(2, "2")

print Collections.max(tt.keySet())
</code>
===== ImageProcessor related =====
==== Canvas Resizing ====
The code below grabs currently active 2D image and creates another image with additional 100 pixels at the bottom. 
<code python>
from ij import IJ, ImagePlus
from ij.plugin import CanvasResizer

ip = IJ.getImage().getProcessor()
cd = CanvasResizer()
bigip = cd.expandImage(ip, ip.getWidth(), ip.getHeight() + 100, 0, 0)
ImagePlus("resized", bigip).show()
</code>

==== Type Conversion ====
In all cases shown below the image will be overwritten. 
If you do not want that, Duplicate image fist by

<code>
imp2 = imp.duplicate()
</code>

or

<code python linenums:1>
from ij.plugin import Duplicator
imp2 = Duplicator().run(imp)
</code>

=== to RGB ===

<code python linenums:1>
from ij import IJ
from ij.process import ImageConverter
imp = IJ.getImage()
ImageConverter(imp).convertToRGB() 
</code>

=== to 8bit grayscale ===

<code python linenums:1>
from ij import IJ
from ij.process import ImageConverter
imp = IJ.getImage()
ImageConverter(imp).convertToGray8() 
</code>

==== Channel Splitter ====

[Image > Color > Split Channels]

<code python linenums:1>
from ij import IJ
from ij.plugin import ChannelSplitter
imp = IJ.getImage()
imps = ChannelSplitter.split(imp)
imps[0].show() # Channel 1
imps[1].show() # Channel 2
</code>

==== Channel Merge ====

[Image > Color > Merge Channels...]

<code python linenums:1>
from ij import ImagePlus
from ij.plugin import RGBStackMerge, RGBStackConverter

impc1 = ImagePlus("path/to/image.tif")
impc2 = ImagePlus("path/to/image.tif")

mergeimp = RGBStackMerge.mergeChannels([impc2, None, impc1, None, None, None, None], True)

# convert the composite image to the RGB image
RGBStackConverter.convertToRGB(mergeimp)

mergeimp.show()
</code>
==== Z projection ====
<code python linenums:1>
# example script for z projection
# extracts first time point from a 4D stack and do maximum intensity Z-projection
from ij import IJ
from ij.plugin import ZProjector
from emblcmci import Extractfrom4D

def maxZprojection(stackimp):
	zp = ZProjector(stackimp)
	zp.setMethod(ZProjector.MAX_METHOD)
	zp.doProjection()
	zpimp = zp.getProjection()
	return zpimp

imp = IJ.getImage()
e4d = Extractfrom4D()
e4d.setGstarttimepoint(1)
IJ.log("current time point" + str(1))
aframe = e4d.coreheadless(imp, 3)
outimp = maxZprojection(aframe)
outimp.show()
</code>

Another example with the map function

<code python>
# splits multichannel-zstack hyperstack and apply zprojection
from ij import IJ
from ij.plugin import ZProjector
from ij.plugin import ChannelSplitter

def sumzp( imp ):
	zp = ZProjector(imp)
	zp.setMethod(ZProjector.SUM_METHOD)
	zp.doProjection() 
	zpimp = zp.getProjection()
	return zpimp

imp = IJ.getImage()
imps = ChannelSplitter.split( imp )
zpimps = map(sumzp, imps)
zpimps[0].show()
</code>


==== Threshold to create a mask (Binary) ====

=== Single Threshold Value ===
With single threshold value, pixels lower than or equal to the value will be 0 and otherwise 255. 

<code python>
# an example with a threshold value of 125. 
from ij import IJ
imp = IJ.getImage()
imp.getProcessor().threshold(125)
imp.updateAndDraw()
</code>

=== Lower and Upper Threshold Value ===

With lower and upper threshold values, there is no really direct way but to convert the thresholded area to a selection (ROI), apply ROI to the image then convert it to a mask. 

There is also a lower way by evaluating pixel by pixel, but this should be obvious. 

<code python linenums:1>
# an example with lower and upper threshold values, 100 and 125.
from ij import IJ, ImagePlus
from ij.process import ImageProcessor
from ij.plugin.filter import ThresholdToSelection
 
imp = IJ.getImage()
imp.getProcessor().setThreshold(100, 125, ImageProcessor.NO_LUT_UPDATE)
roi = ThresholdToSelection.run(imp)
imp.setRoi(roi)
maskimp = ImagePlus("Mask", imp.getMask())
maskimp.show()
</code>

=== Stack to Mask by a threshold value ===

Here is an example script to create a mask from an 8-bit stack using intensity thresholding. 
The threshold value is derived by the Otsu algorithm using the full stack histogram. 

<code>
from ij import IJ, ImagePlus, ImageStack
from ij.plugin import ChannelSplitter
from ij.process import StackStatistics
from fiji.threshold import Auto_Threshold

#imp = IJ.openImage("http://imagej.nih.gov/ij/images/confocal-series.zip")
imp = IJ.getImage()
imps = ChannelSplitter.split( imp )
imp1 = imps[0] 
imp1bin = imp1.duplicate()

# get auto threshold value
stats = StackStatistics(imp1bin)
histdouble = stats.histogram()

# need this conversion from double to int
histint = map(lambda x:int(x), histdouble)
th = Auto_Threshold.Otsu(histint)

for i in range(imp1bin.getStackSize()):
	ip = imp1bin.getStack().getProcessor( i + 1)
	ip.threshold(th)
	
IJ.run(imp1bin, "Grays", "");
imp1bin.show()	
</code>

To do this by accessing the pixel array of the stack, here is the way. It takes a longer time than above, so this is just to show the technique to process by pixel values using float processor pixel array object. 

<code python>

from ij import IJ, ImagePlus, ImageStack
from ij.plugin import ChannelSplitter
from ij.process import StackStatistics
from ij.process import FloatProcessor
from fiji.threshold import Auto_Threshold
import jarray

imp = IJ.openImage("http://imagej.nih.gov/ij/images/confocal-series.zip")
#imp = IJ.getImage()
imps = ChannelSplitter.split( imp )
imp1 = imps[0] 
ww = imp1.getWidth()
hh = imp1.getHeight()
binstack = ImageStack( ww, hh)

# get auto threshold value
stats = StackStatistics(imp1)
histdouble = stats.histogram()
histint = map(lambda x:int(x), histdouble)
th = Auto_Threshold.Otsu(histint)

for i in range(imp1.getStackSize()):
	slicepixA = imp1.getStack().duplicate().convertToFloat().getPixels(i + 1)
#	pixmin = reduce(min, slicepixA)
#	pixmax = reduce(max, slicepixA)
#	print "pixvalue range:", pixmin, " - " ,pixmax
	slicepixA = map(lambda x: 0.0 if x<th else 255.0, slicepixA)
	fp = FloatProcessor( ww, hh, slicepixA, None)
	bp = fp.convertToByteProcessor()
	binstack.addSlice(str(i+1), bp)

binimp = ImagePlus("bin", binstack)
binimp.show()	
</code>


==== ROI manager ====

Removing all ROIs from the ROI manager.
<code python linenums:1>
rm = RoiManager.getInstance()
ht = rm.getList()
ht.removeAll()
</code>

which is equivalent to 
<code python linenums:1>
rm = RoiManager.getInstance()
rm.runCommand('reset')
</code>

Loading image silently and do multiple measurements for all ROIs, without showing the RoiManager associated dialog. In other words,  the silent version of macro command:
<code>
roiManager("Multi Measure")
</code>

<code python linenums:1>
# loading an image from the imagej site
# if you want to load an image from local, replace the URL with a file path
imp = ImagePlus('http://imagej.nih.gov/ij/images/boats.gif') 

# uncomment the following line if you want to see the image
#imp.show() 

# RoiManager should be present
rm = RoiManager.getInstance()

ip = imp.getProcessor()
#rm.setVisible(False) 

# Instead of multimeasure command in RoiManager, get an array of ROIs.
ra = rm.getRoisAsArray()

# loop through ROI array and do measurements. 
# here is only listing mean intensity of ROIs
# if you want more, see 
# http://rsbweb.nih.gov/ij/developer/api/ij/process/ImageStatistics.html
for r in ra:
	ip.setRoi(r)
	istats = ip.getStatistics()
	print istats.mean
</code>

=== Saving All ROIs as a single zip file ===

<code py>
import os, jarray
from ij.plugins.frame.RoiManager

outdir = "/Users/miura/Downloads"
roizipname = "myROIs.zip"
roizippath = os.path.join(outdir, roizipname)
rm = RoiManager.getInstance()
if rm.getCount() > 0:
    roiindex = jarray.array(range(0, rm.getCount()), 'i')
    rm.setSelectedIndexes(roiindex)
    rm.runCommand('Save', roizippath)
</code>

==== Union of multiple ROIs ====

For combining multiple ROIs, {{http://rsbweb.nih.gov/ij/developer/api/ij/gui/ShapeRoi.html|ShapeRoi}} class is useful. 

<code python linenums:1>
from ij.gui import ShaprRoi
sr1 = ShapeRoi(roi1)
sr2 = ShapeRoi(roi2)
sr3 = sr1.or(sr2)
</code> 
sr3 is then a combination of ROIs roi1 and roi2. In similar way, there are AND, XOR, NOT and so on, logical operations. 

==== Mask to selection (Binary to Selection) ====

[Edit > Selection > Create Selection]

Suppose that the active image is a black and white binary image, and to create a selection from black pixels and store the resulted ROI in the RoiManager, do the following. 

<code python linenums:1>
from ij.plugin.filter import ThresholdToSelection
from ij.plugin.frame import RoiManager

rm = RoiManager()
segimp = IJ.getImage()
segimp.getProcessor().setThreshold(0, 0, ImageProcessor.NO_LUT_UPDATE)
boundroi = ThresholdToSelection.run(segimp)
rm.addRoi(boundroi)
</code>

==== Adding Overlay in 3D Stack (ROI to Overlay) ====

<code:py>
from ij import IJ
from ij.gui import OvalRoi, Overlay

imp = IJ.getImage()
roi = OvalRoi(170, 160, 22, 22)
roi.setPosition(19)

ol = Overlay()
ol.add(roi)
imp.setOverlay(ol)
ol.setStrokeWidth(2) 
</code>

==== Export ROIs in RoiManager to a SVG file ====

To export ROIs as a vector drawing for use in other applications (e.g. PDF, Adobe Illustrator), one way is to export them in **SVG format**. This file format is nothing more than text (XML), so it's pretty good for programmatically using it to export ImageJ ROIs. Johannes Schindeline [[http://imagej.1557.x6.nabble.com/export-ROI-as-svg-td5005069.html| once even suggested]] to export ROIs using ImageJ Macro by directly writing texts in SVG format. 

The code below uses a free library called jfreeSVG from Jfreechart group. This is a separate package not included in jfreechart so [[http://www.jfree.org/jfreesvg/ |it should be downloaded]] and installed in Fiji (jfreechart is included in Fiji package). [[http://www.jfree.org/jfreesvg/javadoc/|Javadoc for jfreeSVG is here]]. 

For more details about SVG format, [[https://www.w3.org/TR/SVG/paths.html|see here]].

<code python linenums:1>
import sys
from java.awt import Color
from java.io import File
from ij import IJ
from ij.gui import ShapeRoi
from ij.plugin.frame import RoiManager
from org.jfree.graphics2d.svg import SVGGraphics2D, SVGUtils

imp = IJ.getImage()
rm = RoiManager.getInstance()
if rm is None:
	print 'None'
	sys.exit()  

# convert ROIs in RoiManager to an array of shapeRois
jrois = rm.getRoisAsArray()
srois = [ShapeRoi(jroi) for jroi in jrois]

# http://www.jfree.org/jfreesvg/javadoc/
g2 = SVGGraphics2D(imp.getWidth(), imp.getHeight())
g2.setPaint(Color.BLACK)
px = 0.0
py = 0.0
for sroi in srois:
	g2.translate(px*-1, py*-1)
	px = sroi.getBounds().x
	py = sroi.getBounds().y
	g2.translate(px, py)   
	g2.draw(sroi.getShape())
	
se = g2.getSVGElement()

# writing the file
path = "/Users/miura/tmp/testsvg3.svg"
SVGUtils.writeToSVG(File(path), se)
</code>

One problematic aspect of ROIs are that they could be various, such as lines, rectangles, ovals and polygons. In SVG these different types of ROIs should be treated as different shapes (use different tags). jfreeSVG allows to draw various shapes just by passing java.awt.Shape object, so we do not have to deal with different ROI types in ImageJ and can be moderately generic: IJ ROIs can be converted to IJ ShapeRoi object, which can then be directly converted to java.awt.Shape class.  

There are other IJ plugins implementing SVG access. I tried [[http://b.nanes.org/slideset/apidocs/edu/emory/cellbio/ijbat/dm/write/IJ1ROIsToSVGFileWriter.html |  IJ1ROIsToSVGFileWriter]], a class in plugin [[http://b.nanes.org/slideset/ | Slide Set]]. It works for simple ROIs like Rect. ROIs, but for polygons it returns out of memory errors. 

There is also plugin [[https://grr.gred-clermont.fr/labmirouse/software/ | ScienFig]] which should have some SVG export methods implemented but have not looked at it in depth. 

==== Automatic Brightness/Contrast Button ====
In the legacy "Brightness/Contrast" GUI, there is a button labeled "Auto" which calculates the minimum and the maximum pixel values for enhancing contrast of the current image (the GUI then updates the LUT accordingly). Following are the steps how these values are found out. 

  - get the number of total pixel number (pixelCount)
  - set the limit of pixel number. (limit = pixelCount/10)
  - set the threshold value. (threshold = pixelCount/5000)
  - get an array of pixel intensity histogram of the current image. 
  - then there are two independent loops, one for finding the lower and another for finding the upper value. 
    - lower value finder: loop starts from histogram[0] and increments. For every pixel intensity, 
      - if the count exceeds "limit", then count becomes 0
      - if the count is larger than "threshold", then that value is the minimum. 
    - higher value finder: loop starts from histogram[255] and decrements. For every pixel intensity, 
      - if the count exceeds "limit", then count becomes 0
      - if the count is larger than "threshold", then that value is the maximum. 

Explanation in human language: this algorithm first determines two values "limit" and "Threshold". 

"Threshold" is the parameter that actually sets the min and the max of the contrast curve for the automatic enhancement. Starting from the lowest pixel value (0) or the highest value (255), the algorithm determines the number of pixels with that pixel value. If the number exceeds 0.02% of total pixel number, then that pixel value becomes wither the min or the max for enhancing the contrast. For this decision to ignore background pixels, the algorithm also needs to have another decision determining the background pixel value. 

"limit" actually is a fixed number for each image to decide which of black (0) or white (255) is the background. If the number of pixels with current pixel value is more than 10% of total pixel number, then that value is considered to be the background of the image. For example, when the number of pixels with the value of 0 is 15%, then pixels with 0 values are background. In the next step, if pixels with the value of 1 are still over 10% like 11%, then pixels with values <= 1 are background. When the background is white, then similar decision takes place in the second loop. 

The Jython script shown below is the re-written version based on original Java code. You could see the Java code of method "autoadjust"  [[https://github.com/imagej/imagej1/blob/master/ij/plugin/frame/ContrastAdjuster.java#L780-L829|in the git repo]], line 780-829. 

<code python linenums:1>
# rewriting "Auto contrast adjustment" button of "Brightness/Contrast" 
# Kota Miura
# 20120515

autoThreshold = 0
AUTO_THRESHOLD = 5000

imp = IJ.getImage()
cal = imp.getCalibration()
imp.setCalibration(None)
stats = imp.getStatistics() # get uncalibrated stats
imp.setCalibration(cal)
limit = int(stats.pixelCount/10)
histogram = stats.histogram #int[]
if autoThreshold<10:
	autoThreshold = AUTO_THRESHOLD
else:
	autoThreshold /= 2
threshold = int(stats.pixelCount/autoThreshold)	#int
print "pixelCount", stats.pixelCount
print "threshold", threshold
print "limit", limit
i = -1
found = False
count = 0 # int
while True:
   i += 1
   count = histogram[i]
   if count>limit:
      count = 0
   found = count> threshold
   if found or i>=255:
#   if 0 not in (!found, i<255) :
      break
hmin = i #int
i = 256
while True:
   i -= 1
   count = histogram[i]
   if count>limit:
      count = 0
   found = count> threshold
   if found or i<1:
#   if 0 not in (!found, i<255) :
      break
hmax = i #int

print "minimum", hmin
print "maximum", hmax
</code>

Lines 17-18 seems to be not accessed at all, and seems to be not required. 

Here is the same written in ImageJ macro language.
<code>
 AUTO_THRESHOLD = 5000;
 getRawStatistics(pixcount);
 limit = pixcount/10;
 threshold = pixcount/AUTO_THRESHOLD;
 nBins = 256;
 getHistogram(values, histA, nBins);
 i = -1;
 found = false;
 do {
         counts = histA[++i];
         if (counts > limit) counts = 0;
         found = counts > threshold;
 }while ((!found) && (i < histA.length-1))
 hmin = values[i];
 
 i = histA.length;
 do {
         counts = histA[--i];
         if (counts > limit) counts = 0; 
         found = counts > threshold;
 } while ((!found) && (i > 0))
 hmax = values[i];

 setMinAndMax(hmin, hmax);
 print(hmin, hmax);
</code>

==== Counting number of pixels with a specific value in a stack ====

In the example below, the code counts pixels with a value of 100.
[[http://www.secnetix.de/olli/Python/list_comprehensions.hawk |List comprehensions ]] are a bit cryptic, but by getting use to it, it avoids looping. 
<code python linenums:1>
from ij import IJ

imp = IJ.getImage()
pixval = 100
count = 0
ips = [imp.getStack().getProcessor(i + 1).getPixels() for i in range(imp.getStackSize())]
ipl = [p for pvals in ips for p in pvals]
count = len(filter(lambda x: x==pixval, ipl))
print "pixval=", pixval, " count:", count
</code>

==== RGB (Color) Image, Enhance Contrast each channel ====

To separately set min/max displayed pixel values, add the 3rd argument in setMinAndMax methods of ImageProcessor (in fact, this will be ColorProcessor). 

<code python linenums:1>
from ij import IJ

imp = IJ.getImage()
stk = imp.getStack()
for i in range(stk.getSize()):
	ip = stk.getProcessor(i + 1)
	# red channel = 4
	ip.setMinAndMax(46, 301, 4)
	# green channel = 2
	ip.setMinAndMax(29, 80, 2)
	# blue channel = 1
	ip.setMinAndMax(29, 80, 1)
imp.updateAndDraw()
</code>


==== Translation of 3D image using ImgLib2 ====

Translation of image using ImgLib2 affine transform, taking "flybrain" sample image as an example. A work of Christian Tischer with advices from Stephan Saalfeld. 

<code python linenums:1>
from ij import IJ, ImagePlus, Prefs
from net.imglib2.img.imageplus import ImagePlusImgs
from net.imglib2.view import Views
from net.imglib2.realtransform import RealViews, Translation3D
from net.imglib2.interpolation.randomaccess import NLinearInterpolatorFactory
from net.imglib2.img.display.imagej import ImageJFunctions

# get fly brain sample image
imp = ImagePlus(Prefs.getImagesURL() + "flybrain.zip")

# display the image before translation
imp.show()

# convert ImagePlus to Img
img = ImagePlusImgs.from(imp) # any different to the method above?
print img

# prepare image for translation using interpolation: padding 
extended = Views.extendBorder(img) 
# prepare image for translation using interpolation: interpolate the image to get continuous image
interpolant = Views.interpolate(extended, NLinearInterpolatorFactory()) 

# translation parameters
dx=100; dy=50; dz=0;
# construct Translation3D object
transform = Translation3D(dx, dy, dz)
# transformation
transformed = RealViews.affine(interpolant, transform)
# crop transformed image with the interval of original image
cropped = Views.interval(transformed, img)

# display the image after translation in ImageJ1 frame work. 
ImageJFunctions.show(cropped)
</code>
===== Filters =====

==== Binary ====

With binary operations, it's important to explicitly set if the background is dark or light. In GUI this could be set by [Process > Binary > Options...] and check 'Black background'. Within scripts, you could do the same by 

<code python linenums:1>
from ij import Prefs
Prefs.blackBackground = True
</code>

For those under [Process > Binary]:
<code python linenums:1>
from ij.plugin.filter import Binary

imp = IJ.getImage()
ip = imp.getProcessor()
binner = Binary()
binner.setup("fill", None)
binner.run(ip)
binner.setup("erode", None)
binner.run(ip)
binner.run(ip)
binner.setup("dilate", None)
binner.run(ip)
binner.run(ip)
</code>

See the source:
  * [[https://github.com/fiji/imagej1/blob/master/ij/plugin/filter/Binary.java|github]]

==== Rank Filters ====

[Process > Filters > Minimum], with radius 20. 

<code python linenums:1>
from ij.plugin.filter import RankFilters

imp = IJ.getImage()
imp2 = imp.duplicate()
rf = RankFilters()
rf.rank(imp2.getProcessor(), 20, RankFilters.MIN)
imp2.show()
</code>

==== Gaussian Blur ====

For a radius of 2.0, following does the blurring same as GUI Gaussian Blur.

<code python linenums:1>
from ij.plugin.filter import GaussianBlur
radius = 2.0
accuracy = 0.01
GaussianBlur().blurGaussian( imp2.getProcessor(), radius, radius, accuracy)
</code>

As this works only with single 2D image, for-looping is required to process all frames / slices in a stack. For example:
<code python linenums:1>
from ij.plugin.filter import GaussianBlur
radius = 10.0
accuracy = 0.01
for i in range(imp2.getStackSize()):
	GaussianBlur().blurGaussian(imp2.getStack().getProcessor(i+1), radius, radius, accuracy)
</code>

For more explanation about this processing, see [[http://rsbweb.nih.gov/ij/developer/api/ij/plugin/filter/GaussianBlur.html|the explanation in javadoc]].

==== Background Subtraction (Rolling Ball) ====

Menu item [Process > Subtract Background]

<code python>
from ij import IJ
from ij.plugin.filter import BackgroundSubtracter

imp = IJ.getImage()

ip = imp.getProcessor()
radius = 50.0
createBackground = False
lightBackground = False
useParaboloid = False
doPresmooth = False
correctCorners = False

bs = BackgroundSubtracter()
bs.rollingBallBackground(ip, radius, createBackground, lightBackground, useParaboloid, doPresmooth, correctCorners)
imp.updateAndDraw()
</code>

If the image is in RGB, then use a different method (rollingBallBrightnessBackground).

For more explanation about this processing, see [[https://imagej.nih.gov/ij/developer/api/ij/ij/plugin/filter/BackgroundSubtracter.html|the explanation in javadoc]].
==== ImageCalculator ====

Combined use of erosion and Image Calculator to extract contour from binary image. 

<code python linenums:1>
from ij import IJ
from ij.plugin.filter import Binary
from ij.plugin import ImageCalculator
from ij.plugin import Duplicator

imp = IJ.getImage()
imp2 = Duplicator().run(imp)
eroder = Binary()
eroder.setup("erode", None)
eroder.run(imp2.getProcessor())
ImageCalculator().run("Subtract", imp, imp2)
</code>

The last line first argument should be added with more options to create a new image and / or to process stack. Below is an example to process all frames / slices in a stack and also create a new ImagePlus. 

<code python linenums:1>
imp3 = ImageCalculator().run("Subtract create stack", imp, imp2)
</code>

==== Watershed ====

<code python linenums:1>
from ij.plugin.filter import EDM

ip = IJ.getImage().getProcessor()
edm = EDM()
if ip.isBinary is False:
	IJ.log("8-bit binary image (0 and 255) required.")
else:
	edm.setup("watershed", None)
	edm.run(ip)
</code>

Source:
  * [[https://github.com/fiji/imagej1/blob/master/ij/plugin/filter/EDM.java|github]]


==== Find Maxima (+ RGB Merge) ====

Find Maxima has watershed based segmentation capability. This example segments images and then merges the segmented binary on top of the original image. 

<code python linenums:1>
from ij.plugin import RGBStackMerge
from ij import ImagePlus, IJ
from ij.process import ImageProcessor
from ij.plugin.filter import MaximumFinder
from jarray import array
from ij import Prefs
from ij.plugin.filter import Binary

imp = IJ.getImage()
ip = imp.getProcessor()
segip = MaximumFinder().findMaxima( ip, 10, ImageProcessor.NO_THRESHOLD, MaximumFinder.SEGMENTED , False, False)
segip.invert()
segimp = ImagePlus("seg", segip)
segimp.show()
mergeimp = RGBStackMerge.mergeChannels(array([segimp, None, None, imp, None, None, None], ImagePlus), True)
mergeimp.show()
</code>

==== Filter 3D ====

[Process > Filters > Median 3D…]

Command recorder would log 

<code>
IJ.run(imp, "Median 3D...", "x=4 y=4 z=4") 
</code>

This is OK, but to use the class in behind directly, below is the code written by Tiago Ferreira (see this [[http://imagej.1557.x6.nabble.com/Applying-Median-3D-filter-on-an-image-in-eclipse-Jython-td5008632.html|link]]). 

<code python linenums:1>
from ij import IJ 
from ij import ImagePlus 
from ij.plugin import Filters3D 

# 1. get image 
get = IJ.openImage("http://imagej.net/images/clown.jpg"); 

# 2. get the image stack within the ImagePlus 
stack = get.getStack() 

# 3. Instantiate plugin [1] 
f3d = Filters3D() 

# 4. Retrieve filtered stack 
newStack = f3d.filter(stack, f3d.MEDIAN, 4.0, 4.0, 4.0) 

# 5. Construct an ImagePlus from the stack 
newImage = ImagePlus("Filtered Clown", newStack); 

# 6. Display result 
newImage.show() 
</code>
===== Analysis =====

==== Descriptive statistics ====

For calculating descriptive statistics, one way is to use apache commons math library. 
Below is an elementary example, but more could be done: for more, see [[http://commons.apache.org/proper/commons-math/userguide/stat.html|here]]
<code python linenums:1>
from org.apache.commons.math3.stat.descriptive import DescriptiveStatistics as DSS

rt = ResultsTable.getResultsTable()
area = rt.getColumnAsDoubles(rt.getColumnIndex("Area"))
print "Mean",dss.getMean()
print "Meadian",dss.getPercentile(50)
print dss
</code>

Weka has basic statistics classes under [[http://weka.sourceforge.net/doc.dev/weka/experiment/package-summary.html|weka.experiment]](especially the Class [[http://weka.sourceforge.net/doc.dev/weka/experiment/Stats.html| e.g. Stats]]), but I have not used them. I think I need weka textbook for the use of this rich resource.
 
JfreeChart also has statistics classes. See [[http://www.jfree.org/jfreechart/api/javadoc/org/jfree/data/statistics/package-frame.html|here]]. An example of detecting outliers is shown in below. 
==== Particle Analysis ====

An example of applying particle analysis to a stack. 

<code python linenums:1>
from ij import IJ, ImagePlus
from ij.plugin.filter import ParticleAnalyzer as PA
from ij.measure import ResultsTable

imp = IJ.getImage()

MAXSIZE = 10000;
MINSIZE = 100;
options = PA.SHOW_ROI_MASKS \
	+ PA.EXCLUDE_EDGE_PARTICLES \
	+ PA.INCLUDE_HOLES \
	+ PA.SHOW_RESULTS \
rt = ResultsTable()
p = PA(options, PA.AREA + PA.STACK_POSITION, rt, MINSIZE, MAXSIZE)
p.setHideOutputImage(True)
stk = ImageStack(imp.getWidth(), imp.getHeight())

for i in range(imp.getStackSize()):
	imp.setSliceWithoutUpdate(i + 1)
	p.analyze(imp)
	mmap = p.getOutputImage()
	stk.addSlice(mmap.getProcessor())

ImagePlus("tt", stk).show()
</code>

==== Detect Outliers ====

Outlier detection based on jfree library. 

<code python linenums:1>
from org.jfree.data.statistics import BoxAndWhiskerCalculator
#http://www.jfree.org/jfreechart/api/javadoc/org/jfree/data/statistics/BoxAndWhiskerCalculator.html
from java.util import ArrayList, Arrays

class InstBWC(BoxAndWhiskerCalculator):
    def __init__(self):
        pass
rt = ResultsTable.getResultsTable()
yposA = rt.getColumn(rt.getColumnIndex('x'))
xposA = rt.getColumn(rt.getColumnIndex('y'))
zposA = rt.getColumn(rt.getColumnIndex('z'))
m0A = rt.getColumn(rt.getColumnIndex('m0'))
scoreA = rt.getColumn(rt.getColumnIndex('NPscore'))

m0list = ArrayList(Arrays.asList(scoreA.tolist()))
print m0list.size()

#bwc = BoxAndWhiskerCalculator()
bwc = InstBWC()
ans = bwc.calculateBoxAndWhiskerStatistics(m0list)

#http://www.jfree.org/jfreechart/api/javadoc/org/jfree/data/statistics/BoxAndWhiskerItem.html

print ans.toString()
print ans.getOutliers()
</code>

==== Curve Fitting ====

Curve fitting using ImageJ CurveFitter class.

<code python linenums:1>
from ij.measure import CurveFitter
import jarray

#creat example data arrays
xa = [1, 2, 3, 4]
ya = [3, 3.5, 4, 4.5]

#convert to java array
jxa = jarray.array(xa, 'd')
jya = jarray.array(ya, 'd')

#construct a CurveFitter instance
cf = CurveFitter(jxa, jya)
 
#actual fitting
#fit models: see http://rsb.info.nih.gov/ij/developer/api/constant-values.html#ij.measure.CurveFitter.STRAIGHT_LINE
cf.doFit(CurveFitter.STRAIGHT_LINE)
 
#print out fitted parameters.
print cf.getParams()[0], cf.getParams()[1]
</code>
===== 3D Viewer =====

==== Rotating, Zooming ====

Grab currently opened 3Dviewer (Image3DUniverse instance) and control the rotation and zooming. There seems to be several ways possible, and using ij3d.behaviors.ViewPlatformTransformer seems to be convenient. 
<code python linenums:1>
from ij3d import Image3DUniverse as i3d
from javax.vecmath import Vector3d as v3d
import sys
from javax.media.j3d import Transform3D
from ij3d.behaviors import ViewPlatformTransformer
import time

univs = i3d.universes
if univs.size() is 0:
   print 'no 3D viewer on desktop!'
   sys.exit(1)
univ = univs.get(0)

vtf = ViewPlatformTransformer(univ, univ)
x1z1 = v3d(1, 0, 1)
univ.rotateToPositiveXY()
vtf.zoomTo(1000)
for zm in range(1,3000, 10):
	vtf.zoomTo(zm)
	vtf.rotate(x1z1, 0.03)
	time.sleep(0.01)

for zm in range(3000, 1000, -10):
	vtf.zoomTo(zm)
	vtf.rotate(x1z1, 0.03)
	time.sleep(0.01)
</code>

==== Accessing Time Line in 4D ====

Controlling animations of time series movie. 
<code python linenums:1>
from ij3d import Image3DUniverse as i3d
import sys
 
univs = i3d.universes
if univs.size() is 0:
   print 'no 3D viewer on desktop!'
   sys.exit(1)
univ = univs.get(0)
tl = univ.getTimeline()
tl.first()
frames = tl.size()
for i in range(frames):
	try:
		Thread.sleep(50)
	except InterruptedException, e:
		print 'wait error'
	tl.next()
</code>

==== Combined application with movie saving ====

Combination of aboves + saving snapshots as a stack. 
<code python linenums:1>
# movie making, using 4D stacks and 3D viewer
from ij3d import Image3DUniverse as i3d
from javax.vecmath import Vector3d as v3d
import sys
from javax.media.j3d import Transform3D
from ij3d.behaviors import ViewPlatformTransformer
import time
 
univs = i3d.universes
if univs.size() is 0:
   print 'no 3D viewer on desktop!'
   sys.exit(1)
univ = univs.get(0)

vtf = ViewPlatformTransformer(univ, univ)
x1z1 = v3d(1, 0, 1)

tl = univ.getTimeline()
tl.first()
frames = tl.size()
rad = 0
#win = univ.getWindow()
imp = univ.takeSnapshot()
stk = ImageStack(imp.width, imp.height)
stk.addSlice(imp.getProcessor())
while rad < 4:
	for i in range(frames):
		time.sleep(0.05)
		vtf.rotate(x1z1, 0.04)
		rad += 0.03
		stk.addSlice(univ.takeSnapshot().getProcessor())
		time.sleep(0.05)
		tl.next()
	tl.first()

ImagePlus('movie', stk).show()
</code>

==== Visualizing XYZ positions listed in Results table in 3Dviewer ====

I often need to visualize 3D distribution of XYZ coordiantes listed in the results table in 3D viewer. Below is an example of using results from ParticleTracker 2D/3D being plotted in the 3D viewer. 

For using this with orther plugins such as ObjectCounter 3D, column header names need to be replaced. 
 
<code python linenums:1>
from javax.vecmath import Point3f, Color3f
from java.util import ArrayList
from ij3d import Image3DUniverse
from customnode import CustomPointMesh

rt = ResultsTable.getResultsTable()
yposA = rt.getColumn(rt.getColumnIndex('x'))
xposA = rt.getColumn(rt.getColumnIndex('y'))
zposA = rt.getColumn(rt.getColumnIndex('z'))

mesh = ArrayList()
for i in range(len(xposA)):
	mesh.add(Point3f(xposA[i], yposA[i], zposA[i]))

univ = Image3DUniverse()
univ.showAttribute(Image3DUniverse.ATTRIBUTE_COORD_SYSTEM, False)
univ.show()

cm = CustomPointMesh(mesh)
cm.setColor(Color3f(0, 1, 0))
univ.addCustomMesh(cm, "points")
cm.setPointSize(3)
</code>
===== Plugin: LOCI BioFormats =====

==== Importing CZI file ====

<code python linenums:1>
from loci.plugins import BF
from loci.plugins.in import ImporterOptions

filepath = "/path/to/image/my.czi"

# Options for Bioformats plugin, includeing the image path
options = ImporterOptions()
options.setOpenAllSeries(True)
options.setShowOMEXML(False)
options.setStitchTiles(False)
options.setId(filepath)
    
fullimps = BF.openImagePlus(options)

#fullimps now holds multiple images contained within the czi file. 
# open the first one. 
fullimps[0].show()
</code>

If you do not want to open all images (called sereies) in multi-image CZI files, replace 
<code>
open.setOpenAllSeries(True) 
</code>
with 
<code>
options.setSeriesOn(seriesIndex, True)
</code>
with "sereiesIndex" being the seriesID e.g. 1 or 2 or 3 ... 

See here for more on metadata parsing and so on: [[https://gist.github.com/ctrueden/6282856|bio-formats.py]]

==== Count the number of image data set in a CZI file ====

For just knowing the number of images contained in a CZI file, you do not need to load full image (then it's faster). 

<code python linenums:1>
from loci.formats import ImageReader

r = ImageReader()
filepath = '/to/my.czi'
r.setId( filepath )
print r.getSeriesCount()
</code>

==== Replacing OME-TIFF XML ====

<code python linenums:1>
from loci.formats.tiff import TiffParser
from loci.formats.tiff import TiffSaver
from loci.common import DataTools
from loci.common import RandomAccessInputStream
from loci.common import RandomAccessOutputStream
 
filepath = '/Users/miura/Desktop/test.ome.tif'
 
# test reading out (no new lines)
comment = TiffParser(filepath).getComment()
print comment
 
# replacing OME-XML
xmlpath = '/Users/miura/Desktop/ometest.xml'
newComment = DataTools.readFile(xmlpath)
filein = RandomAccessInputStream(filepath)
fileout = RandomAccessOutputStream(filepath)
saver = TiffSaver(fileout, filepath)
saver.overwriteComment(filein, newComment)
filein.close()
fileout.close()
</code>

If you are accessing from commandline, use "TiffComment" Bioformat Tool. For example, 
<code shell>
tiffcomment test.ome.tif | xmlindent
</code>
outputs xml in your console. More on the udage of command line tools for dealing with OME-XML could be found [[http://www.openmicroscopy.org/site/support/ome-model/ome-tiff/tools.html|here]].

===== Plugin: FeatureJ =====

FeatureJ uses its own abstract class representing image data (imagescience.image.Image). For this, you first need to wrap ImagePlus object as Image object and do the processing. 

==== Laplacian ====

<code python linenums:1>
from ij import IJ
from imagescience.image import Image as FJimage
from imagescience.feature import Laplacian

imp = IJ.getImage()
fjimg = FJimage.wrap(imp)
fjimglap = Laplacian().run(fjimg, 1.0)
imp2 = fjimglap.imageplus()
imp2.show()
</code>
===== Plugin: Extended Depth of Field (Easy mode) =====

Usage of a plugin {{http://bigwww.epfl.ch/demo/edf/|Extended Depth of Field (Easy mode)}} from script. 
<code python linenums:1>

import jarray
from edfgui import BasicDialog

imp = IJ.getImage()
'''
here need to check conditions of the image, it should not be less than 
- 4 pixel width
- 4 pixel height
- 2 slices
'''
imagesize = jarray.array([imp.getHeight(), imp.getHeight()], 'i')
color = imp.getType() == ImagePlus.COLOR_RGB
dl = BasicDialog(imagesize, color, False)
#  "quality='1' topology='0' show-view='on' show-topology='off'"
quality = 1
topology = 0
showview = True
showtopology= False
dl.parameters.setQualitySettings(quality)
dl.parameters.setTopologySettings(topology)
dl.parameters.show3dView = showview 
dl.parameters.showTopology = showtopology
dl.process()

</code>
===== Plugin: Using Find Connected Regions =====

[[http://fiji.sc/Find_Connected_Regions|Find Connected Regions]] is a plugin that outputs connected regions as pixel-value-labeled image of connected regions. This function is similar to "Particle Analysis" and selecting "count masks" as output, but with a bit more capability in settings with less outputs (meaning less complex), and does even 3D connected components. Here is an example function. 

<code>
def getNucLabels(segimp):
  fcrresults = FCR().run(segimp, True, True, True, True, True, False, False, 100, 600, 100, True)
  allregionimp =  fcrresults.allRegions
  perRegionlist = fcrresults.perRegion
  infolist =  fcrresults.regionInfo
  return allregionimp, perRegionlist, infolist
</code>

Returned values in the above example are:
  * allregionimp ... a single image with labels for each region. Psudo color image. 
  * perRegionlist ... a list of binary label images, one slice per label. 
  * infolist ... a list of region infos. 

Arguments for the run method are many, and here is what they are:
<codes>
run(
ij.ImagePlus imagePlus, 
boolean diagonal, 
boolean imagePerRegion, 
boolean imageAllRegions, 
boolean showResults, 
boolean mustHaveSameValue, 
boolean startFromPointROI, 
boolean autoSubtract, 
double valuesOverDouble, 
double minimumPointsInRegionDouble, 
int stopAfterNumberOfRegions, 
boolean noUI) 
</code>
More details of each of these setting parameters are available [[http://www.longair.net/edinburgh/imagej/find-connected-regions/|here]].
[[https://github.com/fiji/fiji/blob/master/src-plugins/VIB-lib/src/main/java/util/FindConnectedRegions.java|The source code is FindConnectedRegions.java within VIB.jar and could be accessed is here]], which is a bit hidden as the plugin class (Find_Connected_Regions.java, in VIB_.jar) is a wrapper. 

Some interesting discussions could be found in [[https://groups.google.com/forum/?fromgroups=#!topic/fiji-devel/Kkd4X3b7pZw|this fiji-dev thread]].

Javadoc

  * [[http://fiji.sc/javadoc/util/FindConnectedRegions.html|util.FindConnectedRegions]]
===== Plugin: Anisotropic Diffusion =====

<code python linenums:1>
from anisotropic_diffusion import Anisotropic_Diffusion_2D as AD
def aniso2D(imp):
	ad = AD()
	ad.setNumOfIterations(20)
	ad.setSmoothings(10)
	ad.setSaveSteps(20)
	ad.setLimiterMinimalVariations(0.40) 
	ad.setLimiterMaximalVariations(0.90)
	ad.setTimeSteps(20)
	ad.setEdgeThreshold(10.0)
	ad.setup("",imp)
	adimp = ad.runTD(imp.getProcessor())
	return adimp

imagepath = '/Volumes/D/20130305/l5c1-128.tif'
imp = IJ.openImage(imagepath)
adimp = aniso2D(imp)
adimp.show()
</code>

===== Plugin: Advanced Weka Segmentation =====

==== Adding Eamples from ROI ====


Training and get Probability image using ROI set as examples (labels).
<code python linenums:1>
from trainableSegmentation import WekaSegmentation
from ij.plugin.frame import RoiManager
from ij import IJ
from ij.io import FileSaver

imp = IJ.openImage('http://imagej.nih.gov/ij/images/blobs.gif') #blobs

weka = WekaSegmentation()
weka.setTrainingImage(imp)

rm = RoiManager(True) 
rm.runCommand('Open', '/Users/miura/Desktop/tmp/RoiSetc1.zip')
roitable =rm.getROIs()
keys = roitable.keys()
for key in keys:
	weka.addExample(0, roitable.get(key), 1)

rm2 = RoiManager(True) 
rm2.runCommand('Open', '/Users/miura/Desktop/tmp/RoiSetc2.zip')
roitable =rm2.getROIs()
keys = roitable.keys()
for key in keys:
	weka.addExample(1, roitable.get(key), 1)

if weka.trainClassifier():
	weka.applyClassifier(True)
	classifiedImage = weka.getClassifiedImage()
	classifiedImage.show()
</code>

==== Merging ARFF data files ====

<code python>
import weka.core.Version
from weka.core import Instances
from weka.core.converters import ConverterUtils

print weka.core.Version().toString()
pp = '/ARFFdata/'
data1path = pp+ 'data1.arff'
data2path = pp+ 'data2.arff'

data1 = ConverterUtils.DataSource.read(data1path)
data2 = ConverterUtils.DataSource.read(data2path)
print "data1: ", data1.size()
print "data2: ", data2.size()

for i in range(data2.size()):
	data1.add(data2.get(i))

dataMerged = data1
print "Merged: ", dataMerged.size()

# if data1 and data2 have the same size, the line below can be used. 
#dataMerged = Instances.mergeInstances(data1, data2)

dataMargedPath = pp + "dataMerged.arff"

ConverterUtils.DataSink.write(dataMargedPath, dataMerged )
</code>

==== Merging ARFF data files in another way, train and apply classifier ====

<code python>
from trainableSegmentation import WekaSegmentation
from ij import IJ

# == merging

pp = '/ARFFdata/'
data1path = pp+ 'data1.arff'
data2path = pp+ 'data2.arff'

ws = WekaSegmentation()
data1 = ws.readDataFromARFF(data1path)
data2 = ws.readDataFromARFF(data2path)
ws.mergeDataInPlace(data1, data2) #this concatenates data2 to data2
dataBalanced = WekaSegmentation.balanceTrainingData(data1) #optional: can balance the classes
ws.setLoadedTrainingData(dataBalanced)

dataOutpath = pp+ 'dataBalanced.arff'
ws.writeDataToARFF(dataBalanced, dataOutpath)

# == now train and apply a classifier to an image

if ws.trainClassifier():
	imp = IJ.getImage()
	classifiedImage = ws.applyClassifier(imp, 0, True)
	classifiedImage.show()

</code>

===== Plugin: CLAHE =====

Fiji plugin for local contrast enhancements. 

<code python linenums:1>
from mpicbg.ij.clahe import Flat, FastFlat

def stackCLAHE2(imp):
  for i in range(imp.getStackSize()):
    imp.setSlice(i+1)
    Flat.getInstance().run(imp, 49, 256, 3.0, None) # slow, as this will be more precise. 
    #Flat.getFastInstance().run(imp, 49, 256, 3.0, None, False) # FastFlat will be faster and less acculate.
    

imp = IJ.getImage()
stackCLAHE2(imp)
</code>

Javadoc
  * [[http://jenkins.imagej.net/job/Saalfeld-MPICBG-Maven/javadoc/mpicbg/ij/clahe/Flat.html|mpicbg.ij.clahe.Flat]]

In case if you need to use "fast but not precise" method, use the class
  * [[http://jenkins.imagej.net/job/Saalfeld-MPICBG-Maven/javadoc/mpicbg/ij/clahe/FastFlat.html|mpicbg.ij.clahe.FastFlat]]. 
===== Plugin: Gray Morphology =====

Here is an example of grayscale eroding. 

<code python linenums:1>
from mmorpho import StructureElement
from mmorpho import MorphoProcessor

imp = IJ.getImage()
se = StructureElement(StructureElement.CIRCLE, 0, 10.0, StructureElement.OFFSET0)
morph = MorphoProcessor(se)
morph.erode(imp.getProcessor())
imp.updateAndDraw()
</code>

For other operations, see Javadoc
  * [[http://fiji.sc/javadoc/mmorpho/MorphoProcessor.html|MorphoProcessor]]
  * [[http://fiji.sc/javadoc/mmorpho/StructureElement.html|StructureElement]]

===== Plugin: Shape Smoothing =====

Shape smoothing by reducing the number of Fourier descriptors. 
The plugin page is [[http://imagej.net/Shape_Smoothing|here]].
The github page is [[https://github.com/thorstenwagner/ij-shape-smoothing/|here]].

<code python>
from ij import IJ
from de.biomedical_imaging.ij.shapeSmoothing import ShapeSmoothingUtil

# https://github.com/thorstenwagner/ij-shape-smoothing/blob/master/src/main/java/de/biomedical_imaging/ij/shapeSmoothing/ShapeSmoothingUtil.java

imp = IJ.getImage()
ss = ShapeSmoothingUtil()
ss.setBlackBackground(True)
# Relative proportion FDs (%) 
thresholdValue = 2
# FD in % or absolute number
thresholdIsPercentual = True
# If True, a table, containing all FDs, will be shown after processing
doOutputDescriptors = False

ss.fourierFilter(imp.getProcessor(), thresholdValue, thresholdIsPercentual, doOutputDescriptors)
</code>

===== Plugin: Auto Threshold =====

This example uses automatic threshoulder class in Fiji. THere is also a way to use original imageJ thresholder. See [[http://cmci.embl.de/documents/120206pyip_cooking/python_imagej_cookbook#threshold_to_create_a_mask_binary|here]]. 

<code python linenums:1>
from fiji.threshold import Auto_Threshold

imp = IJ.getImage()
hist = imp.getProcessor().getHistogram()
lowTH = Auto_Threshold.Otsu(hist)
print lowTH

# if you want to convert to mask, then
imp.getProcessor().threshold(lowTH)
</code>

For the other algorithms for the automatic threshold value estimation, see the Javadoc. 

  * [[http://fiji.sc/javadoc/fiji/threshold/Auto_Threshold.html|fiji.threshold.Auto_Threshold]]


===== Plugin: Auto Local Threshold =====

Here is an example using Bernsen method. 
<code python linenums:1>
from fiji.threshold import Auto_Local_Threshold as ALT

imp = IJ.getImage()
#IJ.run(imp, "Auto Local Threshold", "method=Bernsen radius=45 parameter_1=0 parameter_2=0 white");
thimp = ALT().exec(imp, "Bernsen", 45, 0, 0, False)
print len(imp)
imps[0].show()
</code>

Available methods are:
  * Bernsen
  * Mean
  * Median
  * MidGrey
  * Niblack
  * Sauvola

Returned value of the exec method is an array of object, namely ImagePlus. Array contains scaled images, if such option is selected. 

Javadoc

  * [[http://fiji.sc/javadoc/fiji/threshold/Auto_Local_Threshold.html|fiji.threshold.Auto_Local_Threshold]]

Source

  * [[https://github.com/fiji/fiji/blob/master/src-plugins/Auto_Threshold/src/main/java/fiji/threshold/Auto_Local_Threshold.java|Fiji github]]

===== GLCM (Texture analysis) =====

Measureing Haralick features. 

Clone the project below, compile and install it as a plugin. 
https://github.com/miura/GLCM2

<code python linenums:1>
from emblcmci.glcm import GLCMtexture
from ij import IJ

imp = IJ.getImage()

glmc = GLCMtexture(1, 45, True, False)
ip = imp.getProcessor()
ip8 = ip.convertToByte(True)
glmc.calcGLCM(ip8)
resmap = glmc.getResultsArray()
pa = glmc.paramA
for p in pa:
    print p, resmap.get(p)
</code>

===== Plugin: MiToBo h-dome transformation =====

h-dome is useful for spot detection in a noisy background. [[https://www.researchgate.net/publication/261206082_A_new_approach_for_spot_detection_in_total_internal_reflection_fluorescence_microscopy | For example, see this reference]]. The example here uses Plugin MiToBo, a huge collection of various components. 

<code:py>
from de.unihalle.informatik.MiToBo.core.datatypes.images import MTBImage
from de.unihalle.informatik.MiToBo.morphology import HDomeTransform3D
from ij import IJ

imp = IJ.getImage()
mtb = MTBImage.createMTBImage( imp.duplicate() )
hdome = HDomeTransform3D(mtb, 10.0)
hdome.runOp()
mtbdone = hdome.getResultImage()
imp2 = mtbdone.getImagePlus()
imp2.show()

</code>

===== Plugin: MorphoLibJ =====

Javadoc: [[http://ijpb.github.io/MorphoLibJ/javadoc/]]
==== Distance Transform Watershed 3D ====

<code:py>
from ij import IJ, ImagePlus
from inra.ijpb.binary import BinaryImages
from inra.ijpb.binary import ChamferWeights3D
from inra.ijpb.data.image import Images3D
from inra.ijpb.watershed import ExtendedMinimaWatershed


imp = IJ.getImage()

normalize = True
dynamic = 2
connectivity = 6

#weights = ChamferWeights3D.fromLabel(  ChamferWeights3D.BORGEFORS.toString() )
#weights = ChamferWeights3D.fromLabel(  "Borgefors (3,4,5)" )
weights = ChamferWeights3D.BORGEFORS.getShortWeights()
dist = BinaryImages.distanceMap( imp.getImageStack(),weights , normalize )
Images3D.invert( dist )
#public static final ImageStack extendedMinimaWatershed( ImageStack image, ImageStack mask, int dynamic, int connectivity, int outputType, boolean verbose )
# @param dynamic the maximum difference between the minima and the boundary of a basin
result = ExtendedMinimaWatershed.extendedMinimaWatershed(dist, imp.getImageStack(), dynamic, connectivity, 16, False )
outimp = ImagePlus( imp.getShortTitle() + "dist-watershed", result )
outimp.show()
</code>

==== Connected Component 3D labeling ====

<code:py>
from ij import IJ, ImagePlus
from inra.ijpb.binary import BinaryImages

imp = IJ.getImage()

connectivity = 6
outbitDepth = 16
outimp = BinaryImages.componentsLabeling(imp, connectivity, outbitDepth)
outimp.setTitle(imp.getShortTitle() + "-labeled")
outimp.show()
</code>

==== Kill Border Objects, 2D Binary image ====

<code py>
from ij import IJ, ImagePlus
from inra.ijpb.morphology import Reconstruction

imp = IJ.getImage() #binary image
newip = Reconstruction.killBorders(imp.getProcessor())
newimp = ImagePlus("BorderKilled", newip)
newimp.show()
</code>

===== Plugin 3D ImageJ Suite =====

3D Suite plugin allows you to process / segment / measure 3D image data. 
In Fiji, all 3D suite related commands are available under: Plugins > 3D >

The plugin webpage is here: [[https://framagit.org/mcib3d/mcib3d-core/-/wikis/home|3D ImageJ Suite]]

The real power of 3D Suite is using it as a library from scripts and plugins. Many useful classes are implemented for processing, segmenting, and most notably measuring 3D objects. 
 
Source codes are located under framagit:

  * [[https://framagit.org/mcib3d/mcib3d-core|MCIB-Core source]]
  * [[https://framagit.org/mcib3d/mcib3d-plugins|MCIB-Plugins source]]

The Javadoc I created (Core and Plugins are merged):

  * [[https://wiki.cmci.info/mcib-javadoc/| MCIB3D Javadoc]]

==== Measureing Spherical 3D ROI positions ====

The code below shows how to measure spherical 3D ROI in an image. We first create 3 3D spheres and then use them for measuring the mean pixel intensity of those 3D ROIs within a synthetic gradient 3D image. 

<code:py>
from ij import IJ, ImagePlus
from mcib3d.geom import ObjectCreator3D
from mcib3d.image3d import ImageHandler

oc3d = ObjectCreator3D(200, 200, 50)
oc3d.createSphere(50, 50, 10, 3, 1, False)
oc3d.createSphere(50, 50, 20, 3, 2, False)
oc3d.createSphere(50, 50, 30, 3, 3, False)

imp = oc3d.getPlus() 
#imp.show()

obj1 = 	oc3d.getObject3DVoxels(1)
obj2 = 	oc3d.getObject3DVoxels(2)
obj3 = 	oc3d.getObject3DVoxels(3)
 

impnew = IJ.createImage("Measured", 200,200, 50, 16)
stack = impnew.getStack()
for i in range(stack.getSize()):
	ip = stack.getProcessor(i + 1)
	ip.setColor( i * 5 )
	ip.fill()

ima = ImageHandler.wrap( impnew )

print "Obj1: ", obj1.getPixMeanValue(ima)
print "Obj2: ",obj2.getPixMeanValue(ima)
print "Obj3: ",obj3.getPixMeanValue(ima)
</code>


===== R: Multi-Peak fitting using R =====

This is an example script using R function to fit peak positions within intensity profile along a selected line ROI. For installation of Rserve, [[http://cmci.embl.de/documents/101105ij_r_jython#using_r_from_imagej_via_rserve|see here.]] The script uses the R package [[http://cran.r-project.org/web/packages/Peaks/index.html|"Peaks"]]. 

The library "Peaks" only works under R version 2.x. With 3.0.1 and 3.0.2, it fails to work with an error message "#Error in .Call("R_SpectrumSearchHighRes", as.vector(y), ...".

<code python linenums:1>
from org.rosuda.REngine.Rserve import RConnection
from ij.gui import Roi, Overlay
 
c = RConnection()
x = c.eval("R.version.string")
print x.asString()
print c.eval("library(Peaks)").asString()
 
imp = IJ.getImage()
roi = imp.getRoi()
if roi.getType() == Roi.LINE:
  print "a line roi"
	profile = roi.getPixels()
	c.assign("prof", profile)
	pks = c.eval("SpectrumSearch(prof, sigma=1, threshold=80, background=FALSE, iterations=20, markov=TRUE, window=10)").asList()
	pksX = pks[0].asIntegers()
	rois = []
	for i in pksX:
		print roi.x1, i
		rois.append(PointRoi(roi.x1, roi.y1 + i))
	ol = Overlay() 
	for aroi in rois:
		ol.add(aroi)
	imp.setOverlay(ol)
	
c.close()
</code>
===== Misc examples =====

==== Running a macro file from Jython ====

To run your custom ImageJ macro from Jython, here is an example. 

<code python>
from java.io import File
from ij.macro import MacroRunner

macropath = "/Users/miura/test.ijm"
macrofile =  File(macropath)
mr = MacroRunner(macrofile)
</code>
==== ImageJ Macro Keywords and Functions ====

Printing out ImageJ macro reserved words.
<code python linenums:1>
from ij.macro import MacroConstants as MC

print "=== keywords ==="
for f in MC.keywords:
	print f

print "=== functions (void) ==="
for f in MC.functions:
	print f

print "=== functions (numeric) ==="
for f in MC.numericFunctions:
	print f

print "=== funcitons (string) ==="
for f in MC.stringFunctions:
	print f

print "=== functions (arrays) ==="
for f in MC.arrayFunctions:
	print f
</code>

==== Implementing Interface ====

Here is an example of implementing PlugIn interface. 
<code python linenums:1>
from ij.plugin import PlugIn

class GreatPlugin(PlugIn):
   def __init__ (self):
      print "This is GreatPlugin class which implements a java interface ij.plugin.Plugin"
   def run(self):
      IJ.open('http://imagej.nih.gov/ij/images/blobs.gif')
   def anotherrun(self):
      imp = IJ.openImage('http://imagej.nih.gov/ij/images/blobs.gif')
      imp.getProcessor().invert()
      imp.show()     

gp = GreatPlugin()
gp.run()
gp.anotherrun()
</code>

See explanation in [[http://www.prasannatech.net/2008/09/implementing-java-interfaces-in-jython.html|here]]. 

==== Shell Command ====

To run Shell command in OSX, here is an example. 

<code python>
from java.lang import Runtime
from java.util import Scanner

def runShellCommand( cmd ):
	proc = Runtime.getRuntime().exec(cmd)
	istream = proc.getInputStream()
	scan = Scanner(istream).useDelimiter("\\n")
	for ss in scan:
		print ss
		

runShellCommand( "pwd" )
runShellCommand( "ls -la" )
</code>


==== Is docker daemon running? ====

Check if the docker daemon is running ():

<code python linenums:1>
from java.lang import Runtime
from java.util import Scanner


def checkDockerRunning( cmd ):
	proc = Runtime.getRuntime().exec(cmd)
	inputst = proc.getInputStream()
	s = Scanner(inputst).useDelimiter("\\n")
	if not s.hasNext():
		print "Please start docker desktop!"
		return False
	for ss in s:
		print ss
		if ss.startswith("CONTAINER ID"):
			return True
		else:
			print "Please start docker desktop!"		
			return False

# below is for OSX. WIth win, just "docker ps"			
cmd = "/usr/local/bin/docker ps" 
if checkDockerRunning( cmd ):
	print "Docker running"
else:
	print "Docker not running"
</code>

===== JAVADOCS =====

  * 3D ImageJ Suite 
    * [[http://wiki.cmci.info/javaapi/mcib-javadoc/|JAVADOC]] (2019 version, deprecated)
    * [[https://wiki.cmci.info/mcib-javadoc/| MCIB3D Javadoc]] (2022 version)
    * [[https://github.com/mcib3d/mcib3d-core|Core Source (old)]] 
    * [[https://framagit.org/mcib3d/mcib3d-core|Core Source (2021-)]]
    * [[https://github.com/mcib3d/mcib3d-plugins|Plugin Source]]  
  * 3D Viewer [[http://wiki.cmci.info/javaapi/3Dprocessor/|JAVADOC]]
  * MultistackReg [[http://wiki.cmci.info/javaapi/multiStackReg_/|JAVADOC]]

====== Discussions? ======

I closed the discussion interface below, as it became the target of spam server. Please post your comments / questions to twitter (@cmci_).