ij-Groovy Examples

Batch Processing

This script batch processes all images with extension ".png" in the input directory. Applies a median filter to each, and saves them in the output directory.
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
import ij.*
 
//
// Process files with given extension.
//
 
// Names with extension .png
def nameFilter = ~/.*.png/
 
// Input directory
def inputDir = new File("my_input_dir");
 
// Output directory
def outputDir = new File("my_output_dir");
outputDir.mkdirs();
 
// List all files with extension ".png"
def inputFiles = new ArrayList<File>()
inputDir.eachFileMatch(nameFilter) {inputFiles.add(it)}
 
// Iterate through all input files
inputFiles.each { inputFile ->
  def src = IJ.openImage(inputFile.absolutePath)
  def dest = process(src)
  def outputFile = new File(outputDir, inputFile.name)
  IJ.saveAs(dest, "tif", outputFile.absolutePath)
}
 
 
def ImagePlus process(ImagePlus src) {
  // Do some processing
  IJ.run(src, "Median...", "radius=4")
  return src
}

Process Current ImageJ Image

This scripts gets a reference to currently selected image in ImageJ then applies median filter to it. If no image is opened shows "No image" error message.
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import ij.IJ
 
process()
 
def process() {
  // Get currently selected image
  def imp = IJ.image
  if (imp == null) {
    // Show error message
    IJ.noImage()
    return
  }
 
  // Do some processing
  IJ.run(imp, "Median...", "radius=4")
  // ...
}

Save Image with a Transparency

Example of using Java API to create and save an image with an alpha channel (translucent).
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
import ij.process.*
import java.awt.*
import java.awt.color.*
import java.awt.image.*
import javax.imageio.ImageIO
 
def ColorProcessor cp // = ...
def ByteProcessor alpha // = ...
def BufferedImage bi = createTransparent(cp, alpha)
ImageIO.write(bi, "PNG", new File("transparent-image.png"))
 
// Pixels with alpha equal 0 will be transparent, pixels with alpha=255 will
// be opaque, values between 0 and 255 will vary transparency.
 
def createTransparent(ColorProcessor src, ByteProcessor alpha) {
  def cs = ColorSpace.getInstance(ColorSpace.CS_sRGB)
  def bits = [8, 8, 8, 8] as int[]
  def cm = new ComponentColorModel(cs, bits, true, false,
                                   Transparency.BITMASK, DataBuffer.TYPE_BYTE)
  def raster = cm.createCompatibleWritableRaster(src.width, src.height)
  def dataBuffer = raster.dataBuffer as DataBufferByte
 
  final data = dataBuffer.data
  final n = (src.pixels as int[]).length
  final r = new byte[n]
  final g = new byte[n]
  final b = new byte[n]
  final a = (byte[]) alpha.pixels
  src.getRGB(r, g, b)
  for (int i = 0; i < n; ++i) {
    final int offset = i * 4
    data[offset] = r[i]
    data[offset + 1] = g[i]
    data[offset + 2] = b[i]
    data[offset + 3] = a[i]
  }
 
  return new BufferedImage(cm, raster, false, null)
}