Groovy Scripting

println "Hello, World!"
// Let's show it handling numbers too
println "Result of 2 + 2: " + (2+2)

// what happens if we don't use the parentheses?
print "Result of 2 + 2: " + 2+2

import ij.IJ

IJ.log("Hello, World!")
// Let's show it handling numbers too
IJ.log("Result of 2 + 2: " + (2+2))

// what happens if we don't use the parentheses?
IJ.log("Result of 2 + 2: " + 2+2)

// Import the classes that are needed. 

import ij.IJ							          
import ij.WindowManager					    
import ij.gui.GenericDialog				  
import ij.plugin.frame.RoiManager		

// The IJ class contains a number of utilities. For this script, it provides the "log" functionality
// A class which gives access to the window objects
// A class which allows for creation of custom dialogs with relative ease.
// The ROI Manager - useful for accessing ROIs.

// next we'll define some functions. 

// Function to create a test image
def createTestImage() {
    int imageWidth = 512			// here, we're using explicit types - int holds an integer.
    int imageHeight = 512
    int boxWidth = 128
    int boxHeight = 128
    int offsetX = (int) 192 * 2 * Math.random()  // (int) causes the rest of the statement to be forced to an integer - no decimal places!
    int offsetY = (int) 192 * 2 * Math.random()
    int counts = 64
    int stdv = 16

    // The following are nested definitions. They are not available outside the "createTestImage" function.
    // the following line is called a closure. It's a short-hand way of creating a function.
    // This one returns a string:  makeTitle("Testing", 1, 2) will give 'Testing: 1, 2' as the output.
    def makeTitle = { prefix, x, y -> "${prefix}: ${x}, ${y}" }
      
    // we'll now call the makeTitle function and store the result in a variable called "title"
    // note that it's not a pre-defined type, instead the interpreter will decide what to use.
    def title = makeTitle('TestImage', offsetX, offsetY)
	
    // This closure looks a bit more like a java function. It's going to return either true or false.
    def checkExistence = { titleToCheck ->
        def idList = WindowManager.getIDList()    // get the list of open images
        if (idList == null) return false          // if the list is empty, return false.
        
        // 'collect', in the next line, is a Groovy method that iterates through whatever it is attached to 
        // and executes the code inside the curly brackets on each item it encounters.
        // In this case, it retrieves the title of each image into a list.
        def imageTitles = idList.collect { WindowManager.getImage(it).getTitle() }
        return imageTitles.contains(titleToCheck)
    }

    // That's it for the nested definitions, now lets use them.

    // Check if the image *doesn't* exist..
    if (!checkExistence(title)) {
        // if not, create an ImagePlus with the title, and image dimensions given
        def imp = IJ.createImage(title, "8-bit black", imageWidth, imageHeight, 1)	
        imp.show()

        // The following lines use calls to functionality that's already available - no need to reinvent the wheel.
        // Use the ImageJ mathematical function to add the value of "counts" to the current pixel values.
        IJ.run(imp, "Add...", "value=${counts}")
        // Create a simple rectangular ROI
        imp.setRoi(offsetX, offsetY, boxWidth, boxHeight)
        // and use the Add function again. This will only apply to the ROI
        IJ.run(imp, "Add...", "value=${counts}")
        // Select None removes the ROI - the whole image is now "active"                                    
        IJ.run("Select None")
        // Add noise to the image
        IJ.run(imp, "Add Specified Noise...", "standard=${stdv}")
        // That was a groovy-styled way of building the required parameter string
        // In Java, you would use "standard=" + stdv)

        // Tell ImageJ we're not interested in changes
        imp.changes = false
        // Display the image.
        imp.show()                                                                  
        
    }
}

// Another function to help us to build a dialog to show to the user. 
// It uses the GenericDialog class and takes 3 arguments: titles, defaults and a string for the dialog title.
def createSelectionDialog(imageTitles, defaults, dialogTitle) {                           
    // create a new instance of GenericDialog
    def gd = new GenericDialog(dialogTitle)

    // A quick way to loop through an object, adding choices as we go.
    defaults.eachWithIndex { defVal, index ->
        gd.addChoice("Image_${index + 1}", imageTitles as String[], imageTitles[defVal]) 
    }

    // show the dialog to the user
    gd.showDialog()                                                                       
    if (gd.wasCanceled()) return null   // if the user clicks cancel, return Null. 

    // the next line won't execute if the previous one evaluated as true, because the return statement causes the function to terminate.    
    return defaults.collect { gd.getNextChoiceIndex() }    
}

// Main script execution
def runScript() {
    while (WindowManager.getImageCount() < 10) {            // create a test image as long as the count is less than 10
        createTestImage()
    }

    // retrieve a list of the image titles using the WindowManager class.
    def imageTitles = WindowManager.getIDList().collect { WindowManager.getImage(it).getTitle() }
    
    // now we'll pass this to the createSelectionDialog function that was defined earlier.
    def selectedIndices = createSelectionDialog(imageTitles, [0, 1, 2], 'Select images for processing')
    if (selectedIndices == null) {                          // check if the user clicked cancel - see above!!
        println "Script was canceled."                      // print this to the console (Not the log window)
        return                                              // return without a value
    }
	
    // if selectedIndices wasn't null, the following code will execute
    // get a list of the avilable images (as ImagePlus objects)
    def selectedImages = selectedIndices.collect { WindowManager.getImage(WindowManager.getIDList()[it]) }

    // Display info on the ImageJ log.
    selectedImages.each { imp -> IJ.log("The image '${imp.getTitle()}' has been selected.") }	
}

// This is the only line of code that can actually be run - all the others have to be called.
// So the "runScript" function is called, which subsequently calls other functions.
runScript()