from java.io import File

fiji --headless filepath.py

 a = float('nan') 

>>> a = Double.NaN
>>> print a
NaN 

>>> if Double.isNaN(a):
        print "a is NaN!"
a is NaN! 

imp = IJ.getImage()

imp = WindowManager.getCurrentImage()

c = WindowManager.getCurrentImage

 imp = c()

imp = ImagePlus("my new image", FloatProcessor(512, 512))
pix = imp.getProcessor().getPixels()

n_pixels = len(pix)

# catch width
w = imp.getWidth()

# create a ramp gradient from left to right
for i in range(len(pix)):
   pix[i] = i % w

# adjust min and max, since we know them
imp.getProcessor().setMinAndMax(0, w-1)

imp.show()

from java.util import Random
from jarray import zeros

width = 512
height = 512

pix = zeros(width * height, 'b')
Random().nextBytes(pix)

channel = zeros(256, 'b')
for i in range(256):
    channel[i] = (i -128) 
cm = LUT(channel, channel, channel)

imp = ImagePlus("Random", ByteProcessor(width, height, pix, cm))
imp.show()

from java.util import Random
imp = IJ.createImage("A Random Image", "8-bit", 512, 512, 1)
Random().nextBytes(imp.getProcessor().getPixels())
imp.show()

# 1 - Obtain an image
blobs = IJ.openImage("https://imagej.net/ij/images/blobs.gif")
# Make a copy with the same properties as blobs image:
imp = blobs.createImagePlus()
ip = blobs.getProcessor().duplicate()
imp.setProcessor("blobs copy", ip)

# 2 - Apply a threshold: only zeros and ones
# Set the desired threshold range: keep from 0 to 74
ip.setThreshold(147, 147, ImageProcessor.NO_LUT_UPDATE)
# Call the Thresholder to convert the image to a mask
IJ.run(imp, "Convert to Mask", "")

# 3 - Apply watershed
# Create and run new EDM object, which is an Euclidean Distance Map (EDM)
# and run the watershed on the ImageProcessor:
EDM().toWatershed(ip)

# 4 - Show the watersheded image:
imp.show()

imp = IJ.getImage()  # the current image
imp.getProcessor().setThreshold(174, 174, ImageProcessor.NO_LUT_UPDATE)
IJ.run(imp, "Convert to Mask", "")
IJ.run(imp, "Watershed", "")

imp.updateAndDraw()

# Create a table to store the results
table = ResultsTable()
# Create a hidden ROI manager, to store a ROI for each blob or cell
roim = RoiManager(True)
# Create a ParticleAnalyzer, with arguments:
# 1. options (could be SHOW_ROI_MASKS, SHOW_OUTLINES, SHOW_MASKS, SHOW_NONE, ADD_TO_MANAGER, and others; combined with bitwise-or)
# 2. measurement options (see https://imagej.net/ij/developer/api/ij/measure/Measurements.html)
# 3. a ResultsTable to store the measurements
# 4. The minimum size of a particle to consider for measurement
# 5. The maximum size (idem)
# 6. The minimum circularity of a particle
# 7. The maximum circularity
pa = ParticleAnalyzer(ParticleAnalyzer.ADD_TO_MANAGER, Measurements.AREA, table, 0, Double.POSITIVE_INFINITY, 0.0, 1.0)
pa.setHideOutputImage(True)

if pa.analyze(imp):
  print "All ok"
else:
  print "There was a problem in analyzing", blobs

# The measured areas are listed in the first column of the results table, as a float array:
areas = table.getColumn(0)

>>> for area in areas: print area
76.0
185.0
658.0
434.0
...

# Create a new list to store the mean intensity values of each blob:
means = []

for roi in RoiManager.getInstance().getRoisAsArray():
  blobs.setRoi(roi)
  stats = blobs.getStatistics(Measurements.MEAN)
  means.append(stats.mean)

for area, mean in zip(areas, means):
  print area, mean

...
399 23 30 10.12
400 23 30 12.34
...

width = 512
height = 512
stack = ImageStack(width, height)

file = open("/home/albert/Desktop/data.txt", "r")

try:
  fp = FloatProcessor(width, height)
  pix = fp.getPixels()
  cz = 0
  # Add as the first slice:
  stack.addSlice(str(cz), fp)
  # Iterate over all lines in the text file:
  for line in file.readlines():
    x, y, z, value = line.split(" ")
    x = int(x)
    y = int(y)
    z = int(z)
    value = float(value)
    # Advance one slice if the Z changed:
    if z != cz:
      # Next slice
      fp = FloatProcessor(width, height)
      pix = fp.getPixels()
      stack.addSlice(str(cz), fp)
      cz += 1
    # Assign the value:
    pix[y * width + x] = value
  # Prepare and show a new image:  
  imp = ImagePlus("parsed", stack)
  imp.show()
# Ensure closing the file handle even if an error is thrown:
finally:
  file.close()

imp = IJ.openImage("https://imagej.net/ij/images/blobs.gif")
IJ.run(imp, "Histogram", "")

stats = imp.getStatistics()
print stats.histogram

array('i',[0, 0, 0, 0, 0, 0, 0, 0, 53, 0, 0, 0, 0, 0, 0, 0, 304,
           0, 0, 0, 0, 0, 0, 0, 1209, 0, 0, 0, 0, 0, 0, 0, 3511, 0,
           0, 0, 0, 0, 0, 0, 7731, 0, 0, 0, 0, 0, 0, 0, 10396, 0, 0,
           0, 0, 0, 0, 0, 7456, 0, 0, 0, 0, 0, 0, 0, 3829, 0, 0, 0,
           0, 0, 0, 0, 1992, 0, 0, 0, 0, 0, 0, 0, 1394, 0, 0, 0, 0,
           0, 0, 0, 1158, 0, 0, 0, 0, 0, 0, 0, 1022, 0, 0, 0, 0, 0,
           0, 0, 984, 0, 0, 0, 0, 0, 0, 0, 902, 0, 0, 0, 0, 0, 0,
           0, 840, 0, 0, 0, 0, 0, 0, 0, 830, 0, 0, 0, 0, 0, 0, 0,
           926, 0, 0, 0, 0, 0, 0, 0, 835, 0, 0, 0, 0, 0, 0, 0, 901,
           0, 0, 0, 0, 0, 0, 0, 1025, 0, 0, 0, 0, 0, 0, 0, 1180, 0,
           0, 0, 0, 0, 0, 0, 1209, 0, 0, 0, 0, 0, 0, 0, 1614, 0, 0,
           0, 0, 0, 0, 0, 1609, 0, 0, 0, 0, 0, 0, 0, 2220, 0, 0, 0,
           0, 0, 0, 0, 2037, 0, 0, 0, 0, 0, 0, 0, 2373, 0, 0, 0, 0,
           0, 0, 0, 1568, 0, 0, 0, 0, 0, 0, 0, 1778, 0, 0, 0, 0, 0,
           0, 0, 774, 0, 0, 0, 0, 0, 0, 0, 1364, 0, 0, 0, 0, 0, 0, 0])

mean: 103.26857775590551 median: 64.0 area: 65024.

mean: 104.96356275303644 median: 64.0 area: 1976.0

hwin = HistogramWindow(imp)

plotimage = hwin.getImagePlus()
IJ.save(plotimage, "/path/to/our/folder/plot.tif")

imp = WindowManager.getCurrentImage()
if imp.getType() != ImagePlus.COLOR_RGB:
  IJ.showMessage("The active image is not RGB!")
  raise RuntimeException("The active image is not RGB!")

if 1 == imp.getNSlices():
  IJ.showMessage("Not a stack!")
  raise RuntimeException("Not a stack!")

stack = imp.getStack()
red_stack = ImageStack(imp.width, imp.height)
green_stack = ImageStack(imp.width, imp.height)

for i in range(1, imp.getNSlices()+1):
  slice = stack.getProcessor(i)
  red_stack.addSlice(str(i), slice.toFloat(0, None))
  green_stack.addSlice(str(i), slice.toFloat(1, None))

calc = ImageCalculator()
calc.calculate("Divide stack", ImagePlus("red", red_stack), ImagePlus("green", green_stack))

new_stack = ImageStack(imp.width, imp.height)
for i in range(1, imp.getNSlices()+1):
  cp = stack.getProcessor(i).duplicate()
  cp.setPixels(0, red_stack.getProcessor(i))
  new_stack.addSlice(stack.getSliceLabel(i), cp)

ImagePlus("Normalized " + imp.title, new_stack).show()

imp = WindowManager.getCurrentImage()
if imp.getType() != ImagePlus.COLOR_RGB:
  IJ.showMessage("The active image is not RGB!")
  raise RuntimeException("The active image is not RGB!")

if 1 == imp.getNSlices():
  IJ.showMessage("Not a stack!")
  raise RuntimeException("Not a stack!")

stack = imp.getStack()

new_stack = ImageStack(imp.width, imp.height)

for i in range(1, imp.getNSlices()+1):
  # Get the slice i
  slice = stack.getProcessor(i)
  # Get two new FloatProcessor with the green and red channel data in them
  red = slice.toFloat(0, None)
  green = slice.toFloat(1, None)
  pix_red = red.getPixels()
  pix_green = green.getPixels()
  # Create a new FloatProcessor for the normalized result
  new_red = FloatProcessor(imp.width, imp.height)
  pix_new_red = new_red.getPixels()
  # Iterate and set all normalized pixels
  for k in range(len(pix_red)):
    if 0 != pix_green[k]:
      pix_new_red[k] = pix_red[k] / pix_green[k]
  # Create a ColorProcessor that has the normalized red and the same green and blue channels
  cp = slice.duplicate()
  cp.setPixels(0, new_red)   # at channel 0, the red
  # Store the normalized slice in the new stack, copying the same slice label
  new_stack.addSlice(stack.getSliceLabel(i), cp)

new_imp = ImagePlus("Normalized " + imp.title, new_stack)
new_imp.show()

# Obtain current image and its pixels
imp = IJ.getImage()
pix = imp.getProcessor().convertToFloat().getPixels()

# find out the minimal pixel value
min = reduce(Math.min, pix)

# create a new pixel array with the minimal value subtracted
pix2 = map(lambda x: x - min, pix)

ImagePlus("min subtracted", FloatProcessor(imp.width, imp.height, pix2, None)).show()

from ij import IJ, ImagePlus, ImageStack

def extractChannel(imp, nChannel, nFrame):
 """ Extract a stack for a specific color channel and time frame """
 stack = imp.getImageStack()
 ch = ImageStack(imp.width, imp.height)
 for i in range(1, imp.getNSlices() + 1):
   index = imp.getStackIndex(nChannel, i, nFrame)
   ch.addSlice(str(i), stack.getProcessor(index))
 return ImagePlus("Channel " + str(nChannel), ch)

imp = IJ.getImage()
extractChannel(imp, 1, 1).show()

# 2010-12-03 Albert Cardona and Arnim Jenett
# At HHMI Janelia Farm, Fiji tutorials class
#
# Select a directory with multiple image stacks
# all of the same dimensions, and show a channel
# chooser window to visualize up to 5 of them
# in red, green, blue, orange, and gray.
# 
# The stacks are all virtual, opened via LOCI
# with BFVirtualStack. The composition of the
# RGB ColorProcessor is done with the 
# script.imglib library.
# 
# Each color channel is shown normalized.
# Currently works only with TIF stacks,
# and it will interpret them as single-channel.


from loci.plugins.util import BFVirtualStack
from loci.formats import ChannelSeparator
from ij.io import DirectoryChooser
import os
from javax.swing import JScrollPane, JPanel, JComboBox, JLabel, JFrame
from java.awt import Color, GridLayout
from java.awt.event import ActionListener
from script.imglib.math import Compute, Max, Multiply
from script.imglib.algorithm import Normalize
from script.imglib.color import Red, Green, Blue, RGBA
from mpicbg.imglib.image.display.imagej import ImageJFunctions as IJF


# Choose a directory with lots of tif stacks
dc = DirectoryChooser("Choose directory with stacks")
srcDir = dc.getDirectory()

# Open each tif stack as a virtual BFVirtualStack
bfvs = []
names = []
for filename in os.listdir(srcDir):
  if filename.endswith(".tif"):
    print "Reading metadata from", filename
    cs = ChannelSeparator()
    names.append(filename)
    cs.setId(srcDir + filename)
    bfvs.append( BFVirtualStack(srcDir + filename, cs, False, False, False) )

names.sort()
names = ["None"] + names


colorToRGB = {
'Red' : [255,0,0],
'Green' : [0,255,0],
'Blue' : [0,0,255],
'Orange' : [255,127,0],
'Cyan' : [0,255,255],
'Yellow' : [255,255,0],
'Magenta' : [255,0,255],
'Indigo' : [75,0,130],
'Violet' : [238,130,238],
'Greyscale' : [255,255,255],
'Aquamarine' : [127,255,212],
'Navy Blue' : [0,0,128],
'Sky Blye' : [135,206,235],
'Turquoise' : [64,224,208],
'Beige' : [245,245,220],
'Brown' : [165,42,42],
'Chocolate' : [210,105,30],
'Dark wood' : [133,94,66],
'Light wood' : [133,99,99],
'Olive' : [128,128,0],
'Green yellow' : [173,255,47],
'Sea green' : [32,178,170],
'Khaki' : [240,230,140],
'Salmon' : [250,128,114],
'Pink' : [255,192,203],
'Tomato' : [255,99,71],
'Scarlet' : [140,23,23],
'Purple' : [128,0,128],
'Wheat' : [245,222,179],
'Silver grey' : [192,192,192]
}

# Encode color RGB in floats:
tmp = {}
for c,rgb in colorToRGB.iteritems():
  tmp[c] = [v/255.0 for v in rgb]
colorToRGB = tmp

# Colors in the desired listing order:
colors = ['Red', 'Green', 'Blue',
          'Orange', 'Indigo',
          'Cyan', 'Yellow', 'Magenta',
          'Turquoise', 'Tomato', 'Olive',
          'Violet', 'Green yellow', 'Khaki',
          'Scarlet', 'Beige', 'Chocolate',
          'Silver grey', 'Pink', 'Wheat',
          'Sea green', 'Greyscale', 'Light wood',
          'Sky Blye', 'Brown', 'Salmon', 'Navy Blue',
          'Aquamarine', 'Purple', 'Dark wood']

# Initalize table of colors vs stacks to use:
table = {}
for k,v in zip(colors, [1] + [0 for i in range(len(colors)-1)]):
  table[k] = v


def asImg(color, section):
  global bfvs, table
  index = table[color]
  if 0 == index:
    return 0  # is "None" color
  return IJF.wrap(ImagePlus("", bfvs[index-1].getProcessor(section)))

def maybeNormalize(fn):
  """ Do not normalize if no images are present. """
  if 0 == fn:
    return fn
  cursors = []
  fn.findCursors(cursors)
  if len(cursors) > 0:
    return Multiply(Normalize(fn), 255)
  return fn

def blendColors(section):
  global bfvs, table, colorToRGB
  red =  0
  green = 0
  blue = 0
  for colorName,index in table.iteritems():
    if 0 == index: continue
    img = IJF.wrap(ImagePlus("", bfvs[index-1].getProcessor(section)))
    rgb = colorToRGB[colorName]
    if 0 != rgb[0]:
      red = Max(red, Multiply(img, rgb[0]))
    if 0 != rgb[1]:
      green = Max(green, Multiply(img, rgb[1]))
    if 0 != rgb[2]:
      blue = Max(blue, Multiply(img, rgb[2]))
  return red, green, blue

class VS(VirtualStack):
  def __init__(self):
    self.last = None
  def getProcessor(self, i):
    """ Channel color composition into a single RGB image, as ColorProcessor. 'i' is the section index, 1<=i<=size """
    red, green, blue = blendColors(i)
    # Transform to RGB by normalizing and scaling to 255
    red = maybeNormalize(red)
    green = maybeNormalize(green)
    blue = maybeNormalize(blue)
    # Compose
    rgb = RGBA(red, green, blue).asImage()
    self.last = IJF.displayAsVirtualStack(rgb).getProcessor()
    return self.last
  def getSize(self):
    return bfvs[0].getSize()
  def getSliceLabel(self, i):
    return str(i)
  def getWidth(self):
    return self.last.getWidth()
  def getHeight(self):
    return self.last.getHeight()
  def getPixels(self, i):
    return self.getProcessor(i).getPixels()
  def setPixels(self, pix, i):
    pass


# Create a new image stack
print os.path.split(srcDir)
ourImp = ImagePlus(os.path.split(srcDir)[1], VS())
ourImp.show()

# Create a bunch of panels, one for each color channel
all = JPanel()
layout = GridLayout(len(colors), 2)
all.setLayout(layout)

# GUI to choose which stacks is shown in which channel
class Listener(ActionListener):
  def __init__(self, color, choice, imp):
    self.color = color
    self.choice = choice
    self.imp = imp
  def actionPerformed(self, event):
    global table
    table[self.color] = self.choice.getSelectedIndex()
    self.imp.updateAndRepaintWindow()

for color in colors:
  all.add(JLabel(color))
  choice = JComboBox(names)
  choice.setSelectedIndex(table[color])
  choice.addActionListener(Listener(color, choice, ourImp))
  all.add(choice)

frame = JFrame("Channels")
frame.getContentPane().add(JScrollPane(all))
frame.pack()

frame.setVisible(True)

# Albert Cardona 2010-12-17 for Victoria Butler at HHMI Janelia Farm
# Given a PointRoi, order the points in a chain
# Assumes that the point furthest from all points
# is the start or the end of the chain.

from javax.vecmath import Point2f

# Obtain the PointRoi of the current image
proi = IJ.getImage().getRoi()

# Interrupt if the ROI is not a PointRoi instance:
if proi.getClass() != PointRoi:
  raise Exception("Not a PointRoi!")

class Point(Comparable):
  def __init__(self, x, y):
    self.p = Point2f(x, y)
    self.distances = {}
    self.distAll = None
  def distance(self, point):
    return self.p.distance(point.p)
  def distanceToAll(self):
    if self.distAll is None:
      self.distAll = reduce(lambda a, b: a + b, self.distances.values())
    return self.distAll
  def compareTo(self, point):
    if self.distanceToAll() < point.distanceToAll():
      return -1
    return 1
  def toString(self):
    return self.p.toString()
  def closest(self, points):
    """ Find the closest point that is not contained in the set of given points. """
    next = None
    dist = Float.MAX_VALUE
    for p,d in self.distances.iteritems():
      if d < dist and not p in points:
        next = p
        dist = d
    return next

# Convert PointRoi points to Point instances
px = proi.getXCoordinates()
py = proi.getYCoordinates()
bounds = proi.getBounds()
points = []
for i in range(proi.getNCoordinates()):
  points.append(Point(bounds.x + px[i], bounds.y + py[i]))

# Precompute all-to-all distances
allToAll = {}
for j in range(len(points)):
  for k in range(j+1, len(points)):
    distance = points[j].distance(points[k])
    points[j].distances[points[k]] = distance
    points[k].distances[points[j]] = distance

# Choose a starting point.
# In this case, we use the point most distant from all other points
points.sort()
first = points[-1]
print "First:", first

# Grow the chain from the starting point
chain = [first]
seen = set() # for fast look-up
seen.add(chain[0])
while len(chain) < len(points):
  next = chain[-1].closest(seen)
  if next is None:
    break
  chain.append(next)
  seen.add(next)

print "Chain:", chain

# Albert Cardona 2011-06-09 at HHMI Janelia Farm
# Takes a stack of 9 slices
# and then computes the mean and stdDev of slice number 5
# and normalize the intensity of the other 8 slices
# to that of slice 5.
#
# Created for Jiji Chen to process image stacks from
# the multifocus 3D microscope from Matz Gustafsson
# and Sara Abrahamsson


from math import sqrt
import os

def computeMean(pixels):
  return sum(pixels) / float(len(pixels))

def computeStdDev(pixels, mean):
  s = 0
  for i in range(len(pixels)):
    s += pow(pixels[i] - mean, 2)
  return sqrt(s / float(len(pixels) -1))

def process9ImagePlanes(imp):
  # reference slice
  refSlice = 5
  ref = imp.getStack().getProcessor(5)
  refMean = sum(ref.getPixels()) / float(len(ref.getPixels()))
  refStdDev = computeStdDev(ref.getPixels(), refMean)

  # New stack with the corrected slices
  stack = ImageStack(ref.width, ref.height)

  for i in range(1, 10):
    # skip the reference slice
    if 5 == i:
      stack.addSlice(imp.getStack().getSliceLabel(5), ref.convertToFloat())
      continue
    ip = imp.getStack().getProcessor(i).convertToFloat()
    mean = computeMean(ip.getPixels())
    stdDev = computeStdDev(ip.getPixels(), mean)
    ip.add(-mean)
    ip.multiply(1/stdDev)
    ip.multiply(refStdDev)
    ip.add(refMean)
    stack.addSlice(imp.getStack().getSliceLabel(i), ip)

  return ImagePlus(imp.title, stack)


def accept(filename):
  """ Work only with TIFF files. """
  return len(filename) - 4 == filename.rfind(".tif")

def run():
  dc = DirectoryChooser("pick folder with image stacks")
  folder = dc.getDirectory()
  if folder is None:
    return
  for filename in filter(accept, os.listdir(folder)):
    imp = IJ.openImage(os.path.join(folder, filename))
    if imp is None:
      print "Failed to open image:", filename
      continue
    corrected = process9ImagePlanes(imp)
    IJ.save(corrected, os.path.join(folder, filename[0:-4] + "-corrected.tif"))

run()

from java.awt.event import MouseAdapter

def doSomething(imp):
 """ A function to react to a mouse click on an image canvas. """
 IJ.log("clicked on: " + str(imp))

class ML(MouseAdapter):
 def mousePressed(self, event):
   canvas = event.getSource()
   imp = canvas.getImage()
   doSomething(imp)

listener = ML()

for imp in map(WindowManager.getImage, WindowManager.getIDList()):
 win = imp.getWindow()
 if win is None:
   continue
 win.getCanvas().addMouseListener(listener)

clicked on: imp[Untitled-1 400x200x1]

from ij import IJ, WindowManager
from java.awt.event import KeyEvent, KeyAdapter
 
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))
  # Prevent further propagation of the key event:
  keyEvent.consume()

class ListenToKey(KeyAdapter):
  def keyPressed(this, event):
    imp = event.getSource().getImage()
    doSomething(imp, event)
 
listener = ListenToKey()
 
for imp in map(WindowManager.getImage, WindowManager.getIDList()):
  win = imp.getWindow()
  if win is None:
    continue
  canvas = win.getCanvas()
  # Remove existing key listeners
  kls = canvas.getKeyListeners()
  map(canvas.removeKeyListener, kls)
  # Add our key listener
  canvas.addKeyListener(listener)
  # Optionally re-add existing key listeners
  # map(canvas.addKeyListener, kls)

# Walk recursively through an user-selected directory
# and add all found filenames that end with ".tif"
# to a VirtualStack, which is then shown.
#
# It is assumed that all images are of the same type
# and have the same dimensions.

import os
from ij.io import DirectoryChooser
from ij import IJ, ImagePlus, VirtualStack

def run():
  srcDir = DirectoryChooser("Choose!").getDirectory()
  if not srcDir:
    # user canceled dialog
    return
  # Assumes all files have the same size
  vs = None
  for root, directories, filenames in os.walk(srcDir):
    for filename in filenames:
      # Skip non-TIFF files
      if not filename.endswith(".tif"):
        continue
      path = os.path.join(root, filename)
      # Upon finding the first image, initialize the VirtualStack
      if vs is None:
        imp = IJ.openImage(path)
        vs = VirtualStack(imp.width, imp.height, None, srcDir)
      # Add a slice, relative to the srcDir
      vs.addSlice(path[len(srcDir):])
  #
  ImagePlus("Stack from subdirectories", vs).show()

run()

# 2011-10-18 Albert Cardona for Nuno da Costa
# Choose a multi-slice image stack file in a virtual way
# and save each slice as an individual image file
# in a user-chosen directory.

import os
from loci.plugins.util import BFVirtualStack
from loci.formats import ChannelSeparator

def run():
  # Choose a file to open
  od = OpenDialog("Choose multi-image file", None)
  srcDir = od.getDirectory()
  if srcDir is None:
    # User canceled the dialog
    return
  path = os.path.join(srcDir, od.getFileName())
  # Choose a directory to store each slice as a file
  targetDir = DirectoryChooser("Choose target directory").getDirectory()
  if targetDir is None:
    # User canceled the dialog
    return
  # Ready:
  cs = ChannelSeparator()
  cs.setId(path)
  bf = BFVirtualStack(path, cs, False, False, False)
  for sliceIndex in xrange(1, bf.getSize() +1):
    print "Processing slice", sliceIndex
    ip = bf.getProcessor(sliceIndex)
    sliceFileName = os.path.join(targetDir, str(sliceIndex) + ".tif")
    FileSaver(ImagePlus(str(sliceIndex), ip)).saveAsTiff(sliceFileName)

run()

# Albert Cardona 2012-10-05 for Sara Abrahamsson
#
# Take a stack of images and a mask,
# and clear the area outside the mask for every image.
#
# ASSUMES that the mask:
# 1. Is 8-bit;
# 2. has the area to keep as 255;
# 3. has the area to clear as zeros.


from ij import IJ
from ij import WindowManager as WM

# If the images are open:
volume = WM.getImage("stack.tif")
mask = WM.getImage("mask.tif")

# Or if the images have to be loaded from files:
# volume = IJ.openImage("/Users/sara/images/stack.tif")
# mask = IJ.open("/Users/sara/images/mask.tif")

# Obtain the underlying stack of 2d images
stack = volume.getStack()

# Fill every stack slice with zeros for the area outside the mask
for i in xrange(1, stack.getSize() + 1):
  # ip is the ImageProcessor for one stack slice
  ip = stack.getProcessor(i)
  ip.setValue(0)
  ip.fill(mask)

volume.updateAndDraw()
volume.show()

mask = mask.duplicate()
mask.invert()

# 2014-11-24 Harri Jäälinoja

from loci.plugins.in import ImagePlusReader,ImporterOptions,ImportProcess
import sys

filename = sys.argv[1]
opts = ImporterOptions()
opts.setId(filename)
opts.setUngroupFiles(True)

# set up import process
process = ImportProcess(opts)
process.execute()
nseries = process.getSeriesCount()

# reader belonging to the import process
reader = process.getReader()

# reader external to the import process
impReader = ImagePlusReader(process)
for i in range(0, nseries):
    print "%d/%d %s" % (i+1, nseries, process.getSeriesLabel(i))
    
    # activate series (same as checkbox in GUI)
    opts.setSeriesOn(i,True)

    # point import process reader to this series
    reader.setSeries(i)

    # read and process all images in series
    imps = impReader.openImagePlus()
    for imp in imps:
        imp.show()
        wait = Wait(str(i) + imp.getTitle())
        wait.show()
        imp.close()

    # deactivate series (otherwise next iteration will have +1 active series)
    opts.setSeriesOn(i, False)

""" Albert Cardona for Marta Zlatic, 2014-01-24. """

from fiji.ffmpeg import IO
from java.awt import Color
import os

def load(path, first_frame=0, last_frame=-1):
  """ Load the whole movie by default. """
  io = IO()
  imp = io.readMovie(path, False, first_frame, last_frame)
  return imp

def save(path, imp, frame_rate=30, bit_rate=400000):
  """ frame_rate in fps (frames per second).
      bit_rate defines the quality of the movie: higher bit rate results in larger, higher quality movies.
      The movie format (e.g. AVI, MPG, etc.) is chosen by the path filename extension. """
  io = IO()
  io.writeMovie(imp, path, frame_rate, bit_rate)


def process(imp, convert, roi, time_zero, time_range):
  """ Crop, convert to another format, and time-stamp. """
  stack = imp.getStack()
  size = stack.getSize()
  bounds = roi.getBounds()
  new_stack = ImageStack(bounds.width, bounds.height)
  for i in xrange(1, size + 1):
    ip = convert(stack.getProcessor(i))
    ip.setRoi(roi)
    c = ip.crop()
    c.setColor(Color.white)
    time = "%.2f" % (time_zero + time_range * (float(i-1) / (size -1)))
    c.drawString(time, 5, 15)
    new_stack.addSlice(str(i), c)

  return ImagePlus(imp.title, new_stack)


def batch_process(extension, source_dir, output_dir, convert, roi, time_zero, time_range):
  for filename in os.listdir(source_dir):
    if filename.endswith(extension):
      if os.path.exists(target_dir + filename):
        # Skip if movie exists at destination
        continue
      imp = load(source_dir + filename)
      imp2 = process(imp, convert, roi, time_zero, time_range)
      imp.flush()
      save(target_dir + filename, imp2)
      imp2.flush()


def convert(ip):
  """ Convert to 8=bit and crop the range to [0, 128] pixel values. """
  c = ip.convertToByte(True)
  c.setMinAndMax(0, 128)
  return c


source_dir = '/path/to/list_of_AVI_movies/'
target_dir = '/path/to/new_list_of_AVI_movies/'

roi = Roi(50, 50, 256, 256)
time_zero = 30   # start at 30 seconds
time_range = 30  # range of (also) 30 seconds

# Process all AVI movie files, saving them also as AVI files
batch_process('.avi', source_dir, target_dir, convert, roi, time_zero, time_range)

from ij import IJ
from skeleton_analysis import AnalyzeSkeleton_,Graph,Edge,Vertex

# open image, blur, make b/w, skeletonize
imp = IJ.openImage("/path/to/image.tif")
IJ.run(imp,"Gaussian Blur...","sigma=5")
IJ.run(imp,"Make Binary","")
IJ.run(imp,"Skeletonize","")

# run AnalyzeSkeleton
# (see https://fiji.sc/AnalyzeSkeleton 
# and https://fiji.sc/javadoc/skeleton_analysis/package-summary.html)
skel = AnalyzeSkeleton_()
skel.setup("",imp)
skelResult = skel.run(skel.NONE, False, True, None, True, True)

# get the separate skeletons
graph = skelResult.getGraph()
print len(graph)
print skelResult.getNumOfTrees()

def getGraphLength(graph):
    length = 0
    for g in graph.getEdges():
    length = length + g.getLength()
    return length

# find the longest graph
graph = sorted(graph, key=lambda g: getGraphLength(g), reverse=True)
longestGraph = graph[0]

# find the longest edge
edges = longestGraph.getEdges()
edges = sorted(edges, key=lambda edge: edge.getLength(), reverse=True)
longestEdge = edges[0]

# @ImagePlus imp

from fiji.plugin.trackmate.detection import DogDetector
from ij.gui import PointRoi
from ij.plugin.frame import RoiManager
from net.imglib2.img.display.imagej import ImageJFunctions

# Set the parameters for DogDetector
img = ImageJFunctions.wrap(imp)
interval = img
cal = imp.getCalibration()
calibration = [cal.pixelWidth, cal.pixelHeight, cal.pixelDepth]
radius = 0.2 # the radius is half the diameter
threshold = 100
doSubpixel = True
doMedian = False

# Setup spot detector
# (see http://javadoc.imagej.net/Fiji/fiji/plugin/trackmate/detection/DogDetector.html)
# 
# public DogDetector(RandomAccessible<T> img,
#            Interval interval,
#            double[] calibration,
#            double radius,
#            double threshold,
#            boolean doSubPixelLocalization,
#            boolean doMedianFilter)
detector = DogDetector(img, interval, calibration, radius, threshold, doSubpixel, doMedian)

# Start processing and display the results
if detector.process():
    # Get the list of peaks found
    peaks = detector.getResult()
    print str(len(peaks)), "peaks were found."

    # Add points to ROI manager
    rm = RoiManager.getInstance()
    if not rm:
        rm = RoiManager()

    # Loop through all the peak that were found
    for peak in peaks:
        # Print the current coordinates
        print peak.getDoublePosition(0), peak.getDoublePosition(1), peak.getDoublePosition(2)
        # Add the current peak to the Roi manager
        proi = PointRoi(peak.getDoublePosition(0) / cal.pixelWidth, peak.getDoublePosition(1) / cal.pixelHeight)
        proi.setPosition(int(peak.getDoublePosition(2) / cal.pixelDepth))
        rm.addRoi(proi)

    # Show all ROIs on the image
    rm.runCommand(imp, "Show All")

else:
    print "The detector could not process the data."

import ij
print dir(ij)

# -*- coding: iso-8859-15 -*-

as first line into your source code (or if it starts with *\#!/usr/bin/python*, as second line), as suggested [here](http://docs.python.org/tutorial/interpreter.html#source-code-encoding). You might need to replace the string *iso-8859-15* by something like *utf-8* if your source code is encoded in UTF-8.

### Changing the default encoding

By default, Jython encodes the standard output (and other streams) with the ASCII encoding. Often, this is not what you want. You can change the default encoding like this:

    from org.python.core import codecs
    codecs.setDefaultEncoding('utf-8')

### Error handling with try / except / finally

See complete documentation at: [jython book chapter 6](http://jythonpodcast.hostjava.net/jythonbook/chapter6.html).

    x = 10
    y = 0

    try:
         z = x / y
    except NameError, e1:
         print "A variable is not defined!", e1
    except ZeroDivisionError, e2:
         print "Dividing by zero doesn't make any sense! Error:", e2
    finally:
         print "This line will always print no matter what error occurs."

Which prints:

import sys

try:
  z = x / z
except:
  print "Error: ", sys.exc_info()

Error:  (<type 'exceptions.NameError'>, NameError("name 'x' is not defined",), <traceback object at 0x2>)

IJ.log(str(sys.exc_info()))

from sys import path
from java.lang.System import getProperty

# extend the search path by $FIJI_ROOT/bin/
path.append(getProperty('fiji.dir') + '/bin')

# Now you can import $FIJI_ROOT/bin/compat.py
import compat

# Script plugins/my scripts/Filters.py
from ij import IJ
from ij.plugin import Duplicator

def median(imp, radius):
  """ Apply a median filter to a copy
	  of the given ImagePlus, and return it. """
  copy = Duplicator().run(imp)
  IJ.run(copy, "Median...", "radius=" + str(radius))
  return copy

def removeOutliers(imp, radius, threshold, bright):
  """ Apply a remove outliers filter to a copy
	  of the given ImagePlus, and return it. """
  copy = Duplicator().run(imp)
  which = "Bright" if bright else "Dark"
  IJ.run(copy, "Remove Outliers...", "radius=" + str(radius) \
	  + " threshold=" + str(threshold) + " which=" + which)
  return copy

from ij import IJ
import sys
from java.lang.System import getProperty
sys.path.append(getProperty("fiji.dir") + "/plugins/my scripts")
from Filters import median

imp = IJ.getImage()
medianFiltered = median(imp, 5.0)
medianFiltered.show()

from math import sqrt, pow

class Point:
  def __init__(self, x, y):
	self.x = x
	self.y = y
  def distance(self, other):
	return sqrt(pow(self.x - other.x, 2), pow(self.y - other.y, 2))

p1 = Point(10, 20)
p2 = Point(40, 55.3)

print "Distance:", p1.distance(p2)

  def one(self):
    return 1

  @staticmethod
  def two():
    return 2

print Numbers.two()

that = Numbers()
print that.one()

from jarray import array

data = [1.0, 2.0, 3.0, 4.0]

arr = array(data, 'd')

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

from jarray    import array
from java.lang import Class

data = [[1.0, 2.0], [3.0, 4.0]]
twoDimArr = array(data, Class.forName('[D'))

from jarray import array
from java.lang import Class

data = [[[1, 2, 3], [4, 5, 6]], [[1, 2, 3], [4, 5, 6]]]
threeDimArr = array(data, Class.forName('[[D'))

from jarray import array

texts = ["one", "two", "three"]

strings = array(texts, String)

from jarray import zeros

twoDimArr = zeros(5, Class.forName("[D"))

print twoDimArr
# prints: array([D, [None, None, None, None, None])

# fill each slot with a new array of length 3:
for i in range(len(twoDimArr)):
  twoDimArr[i] = zeros(3, 'd')

print twoDimArr
#prints: array([D, [array('d', [0.0, 0.0, 0.0]), array('d', [0.0, 0.0, 0.0]),
# array('d', [0.0, 0.0, 0.0]), array('d', [0.0, 0.0, 0.0]), array('d', [0.0, 0.0, 0.0])])

from fiji.scripting import Weaver
from ij import IJ
from java.lang import Double

# The currently open image
imp = IJ.getImage()

fp = imp.getProcessor().convertToFloat()
pixels = fp.getPixels()  # a float array, float[]

w = Weaver.inline(
    """
    double sum = 0;
    for (int i=0; i<pixels.length; i++) {
        sum += pixels[i];
    }
    return sum / pixels.length;
    """,
    {"pixels" : pixels}, Double)

mean = w.call()

print mean

from ij import IJ, ImagePlus, ImageStack
from fiji.scripting import Weaver

# The currently open image, an 8-bit stack
imp = IJ.openImage("https://imagej.net/ij/images/bat-cochlea-volume.zip")

slices = [None, None]

w = Weaver.inline(
    """
    byte[] pix1 = (byte[]) slices.get(0);
    byte[] pix2 = (byte[]) slices.get(1);

    byte[] xor = new byte[pix1.length];
    for (int i=0; i<pix1.length; i++) {
        xor[i] = (byte)(pix1[i] ^ pix2[i]);
    }
    return xor;
    """,
    {"slices" : slices})

stack = imp.getStack()
stackXOR = ImageStack(stack.width, stack.height)

for i in range(2, imp.getNSlices()+1):
  # Put the pixel arrays into the pre-made list
  slices[0] = stack.getPixels(i-1)
  slices[1] = stack.getPixels(i)
  # Invoke native code
  stackXOR.addSlice( str(i-1), w.call() )

ImagePlus("XORed stack", stackXOR).show()

from ij import IJ, ImagePlus, ImageStack
from fiji.scripting import Weaver

# The currently open image, an 8-bit stack
imp = IJ.openImage("https://imagej.net/ij/images/bat-cochlea-volume.zip")

w = Weaver.method(
  """
  public byte[] xor(byte[] pix1, byte[] pix2) {
    byte[] xor = new byte[pix1.length];
    for (int i=0; i<pix1.length; i++) {
        xor[i] = (byte)(pix1[i] ^ pix2[i]);
    }
    return xor;
  }
  """)

stack = imp.getStack()
stackXOR = ImageStack(stack.width, stack.height)

for i in range(2, imp.getNSlices()+1):
  # Invoke native code
  stackXOR.addSlice( str(i-1), w.xor(stack.getPixels(i-1), stack.getPixels(i)) )

ImagePlus("XORed stack", stackXOR).show()

from net.imglib2.type.numeric.real import FloatType
from net.imglib2.img.display.imagej import ImageJFunctions as IJF
from fiji.scripting import Weaver
from ij import IJ
from net.imglib2 import Cursor, IterableInterval
from net.imglib2.type.numeric.real import FloatType

# Grab a 32-bit image
imp = IJ.getImage()

# View it as an ImgLib2 image
img = IJF.wrap(imp)

# Declare a java method to subtract a value from every pixel
w = Weaver.method(
  """
  public void subtract(final IterableInterval<FloatType> img, final float value) {
    final FloatType v = new FloatType(-value);
    final Cursor<FloatType> cursor = img.cursor();
    while (cursor.hasNext()) {
      cursor.fwd();
      cursor.get().add(v);
    }
  }
  """,
  [IterableInterval, Cursor, FloatType])

w.subtract(img, 10)

imp.updateAndDraw()

import os, sys
from ij import IJ

# Expecting one argument: the file path
if len(sys.argv) < 2:
  print "Usage: ./fiji-linux64 <script-name> <file-path>"
  sys.exit(1)

filepath = sys.argv[1]

# Check if the file exists
if not os.path.exists(filepath):
  print "File does not exist at path:", filepath
  sys.exit(1)

# Open the image
imp = IJ.openImage(filepath)
print "Processing:", imp.title

# Do some processing ...

from ij import IJ
import sys
 
if not len (sys.argv) > 1:
  raise TypeError ("No macro file argument")
 
status = IJ.runMacroFile(sys.argv[1])
if status == '[aborted]':
  raise StandardError ("Macro execution failed")

sys.exit (0)

import name.of.external.java.library as foo

jar tvf <library>.jar