--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/imagej2_adjust_threshold_binary.py	Tue Sep 17 17:08:08 2019 -0400
@@ -0,0 +1,63 @@
+#!/usr/bin/env python
+import argparse
+import os
+import shutil
+import subprocess
+import tempfile
+import imagej2_base_utils
+
+parser = argparse.ArgumentParser()
+parser.add_argument( '--input', dest='input', help='Path to the input file' )
+parser.add_argument( '--input_datatype', dest='input_datatype', help='Datatype of the input image' )
+parser.add_argument( '--threshold_min', dest='threshold_min', type=float, help='Minimum threshold value' )
+parser.add_argument( '--threshold_max', dest='threshold_max', type=float, help='Maximum threshold value' )
+parser.add_argument( '--method', dest='method', help='Threshold method' )
+parser.add_argument( '--display', dest='display', help='Display mode' )
+parser.add_argument( '--black_background', dest='black_background', help='Black background' )
+parser.add_argument( '--stack_histogram', dest='stack_histogram', help='Stack histogram' )
+parser.add_argument( '--jython_script', dest='jython_script', help='Path to the Jython script' )
+parser.add_argument( '--output', dest='output', help='Path to the output file' )
+parser.add_argument( '--output_datatype', dest='output_datatype', help='Datatype of the output image' )
+args = parser.parse_args()
+
+tmp_dir = imagej2_base_utils.get_temp_dir()
+# ImageJ expects valid image file extensions, so the Galaxy .dat extension does not
+# work for some features.  The following creates a symlink with an appropriate file
+# extension that points to the Galaxy dataset.  This symlink is used by ImageJ.
+tmp_input_path = imagej2_base_utils.get_input_image_path( tmp_dir, args.input, args.input_datatype )
+tmp_output_path = imagej2_base_utils.get_temporary_image_path( tmp_dir, args.output_datatype )
+# Define command response buffers.
+tmp_out = tempfile.NamedTemporaryFile().name
+tmp_stdout = open( tmp_out, 'wb' )
+tmp_err = tempfile.NamedTemporaryFile().name
+tmp_stderr = open( tmp_err, 'wb' )
+# Java writes a lot of stuff to stderr, so we'll specify a file for handling actual errors.
+error_log = tempfile.NamedTemporaryFile( delete=False ).name
+# Build the command line.
+cmd = imagej2_base_utils.get_base_command_imagej2( None, jython_script=args.jython_script )
+if cmd is None:
+    imagej2_base_utils.stop_err( "ImageJ not found!" )
+cmd += ' %s' % error_log
+cmd += ' %s' % tmp_input_path
+cmd += ' %.3f' % args.threshold_min
+cmd += ' %.3f' % args.threshold_max
+cmd += ' %s' % args.method
+cmd += ' %s' % args.display
+cmd += ' %s' % args.black_background
+cmd += ' %s' % args.stack_histogram
+cmd += ' %s' % tmp_output_path
+cmd += ' %s' % args.output_datatype
+# Run the command.
+proc = subprocess.Popen( args=cmd, stderr=tmp_stderr, stdout=tmp_stdout, shell=True )
+rc = proc.wait()
+# Handle execution errors.
+if rc != 0:
+    error_message = imagej2_base_utils.get_stderr_exception( tmp_err, tmp_stderr, tmp_out, tmp_stdout )
+    imagej2_base_utils.stop_err( error_message )
+# Handle processing errors.
+if os.path.getsize( error_log ) > 0:
+    error_message = open( error_log, 'r' ).read()
+    imagej2_base_utils.stop_err( error_message )
+# Save the output image.
+shutil.move( tmp_output_path, args.output )
+imagej2_base_utils.cleanup_before_exit( tmp_dir )

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/imagej2_adjust_threshold_binary_jython_script.py	Tue Sep 17 17:08:08 2019 -0400
@@ -0,0 +1,49 @@
+import jython_utils
+import sys
+from ij import IJ
+
+# Fiji Jython interpreter implements Python 2.5 which does not
+# provide support for argparse.
+error_log = sys.argv[ -10 ]
+input = sys.argv[ -9 ]
+threshold_min = float( sys.argv[ -8 ] )
+threshold_max = float( sys.argv[ -7 ] )
+method = sys.argv[ -6 ]
+display = sys.argv[ -5 ]
+black_background = jython_utils.asbool( sys.argv[ -4 ] )
+# TODO: this is not being used.
+stack_histogram = jython_utils.asbool( sys.argv[ -3 ] )
+tmp_output_path = sys.argv[ -2 ]
+output_datatype = sys.argv[ -1 ]
+
+# Open the input image file.
+input_image_plus = IJ.openImage( input )
+
+# Create a copy of the image.
+input_image_plus_copy = input_image_plus.duplicate()
+image_processor_copy = input_image_plus_copy.getProcessor()
+
+try:
+    # Convert image to binary if necessary.
+    if not image_processor_copy.isBinary():
+        # Convert the image to binary grayscale.
+        IJ.run( input_image_plus_copy, "Make Binary","iterations=1 count=1 edm=Overwrite do=Nothing" )
+    # Set the options.
+    if black_background:
+        method_str = "%s dark" % method
+    else:
+        method_str = method
+    IJ.setAutoThreshold( input_image_plus_copy, method_str )
+    if display == "red":
+        display_mode = "Red"
+    elif display == "bw":
+        display_mode = "Black & White"
+    elif display == "over_under":
+        display_mode = "Over/Under"
+    IJ.setThreshold( input_image_plus_copy, threshold_min, threshold_max, display_mode )
+    # Run the command.
+    IJ.run( input_image_plus_copy, "threshold", "" )
+    # Save the ImagePlus object as a new image.
+    IJ.saveAs( input_image_plus_copy, output_datatype, tmp_output_path )
+except Exception, e:
+    jython_utils.handle_error( error_log, str( e ) )

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/imagej2_analyze_particles_binary.py	Tue Sep 17 17:08:08 2019 -0400
@@ -0,0 +1,81 @@
+#!/usr/bin/env python
+import argparse
+import os
+import shutil
+import subprocess
+import tempfile
+import imagej2_base_utils
+
+parser = argparse.ArgumentParser()
+parser.add_argument( '--input', dest='input', help='Path to the input file' )
+parser.add_argument( '--input_datatype', dest='input_datatype', help='Datatype of the input image' )
+parser.add_argument( '--black_background', dest='black_background', help='Black background' )
+parser.add_argument( '--size', dest='size', help='Size (pixel^2)' )
+parser.add_argument( '--circularity_min', dest='circularity_min', type=float, help='Circularity minimum' )
+parser.add_argument( '--circularity_max', dest='circularity_max', type=float, help='Circularity maximum' )
+parser.add_argument( '--show', dest='show', help='Show' )
+parser.add_argument( '--display_results', dest='display_results', help='Display results' )
+parser.add_argument( '--all_results', dest='all_results', help='All results' )
+parser.add_argument( '--exclude_edges', dest='exclude_edges', help='Exclude edges' )
+parser.add_argument( '--include_holes', dest='include_holes', help='Include holes' )
+parser.add_argument( '--jython_script', dest='jython_script', help='Path to the Jython script' )
+parser.add_argument( '--results', dest='results', default=None, help='Path to the output results file' )
+parser.add_argument( '--output', dest='output', default=None, help='Path to the output image file' )
+parser.add_argument( '--output_datatype', dest='output_datatype', default='data',  help='Datatype of the output image' )
+args = parser.parse_args()
+
+tmp_dir = imagej2_base_utils.get_temp_dir()
+# ImageJ expects valid image file extensions, so the Galaxy .dat extension does not
+# work for some features.  The following creates a symlink with an appropriate file
+# extension that points to the Galaxy dataset.  This symlink is used by ImageJ.
+tmp_input_path = imagej2_base_utils.get_input_image_path( tmp_dir, args.input, args.input_datatype )
+if args.output is None:
+    tmp_output_path = None
+else:
+    tmp_output_path = imagej2_base_utils.get_temporary_image_path( tmp_dir, args.output_datatype )
+
+# Define command response buffers.
+tmp_out = tempfile.NamedTemporaryFile().name
+tmp_stdout = open( tmp_out, 'wb' )
+tmp_err = tempfile.NamedTemporaryFile().name
+tmp_stderr = open( tmp_err, 'wb' )
+# Java writes a lot of stuff to stderr, so we'll specify a file for handling actual errors.
+error_log = tempfile.NamedTemporaryFile( delete=False ).name
+
+# Build the command line.
+cmd = imagej2_base_utils.get_base_command_imagej2( None, jython_script=args.jython_script )
+if cmd is None:
+    imagej2_base_utils.stop_err( "ImageJ not found!" )
+cmd += ' %s' % error_log
+cmd += ' %s' % tmp_input_path
+cmd += ' %s' % args.black_background
+cmd += ' %s' % args.size
+cmd += ' %.3f' % args.circularity_min
+cmd += ' %.3f' % args.circularity_max
+cmd += ' %s' % args.show
+cmd += ' %s' % args.display_results
+cmd += '%s' % imagej2_base_utils.handle_none_type( args.all_results, val_type='str' )
+cmd += ' %s' % args.exclude_edges
+cmd += ' %s' % args.include_holes
+cmd += '%s' % imagej2_base_utils.handle_none_type( tmp_output_path, val_type='str' )
+cmd += ' %s' % args.output_datatype
+cmd += '%s' % imagej2_base_utils.handle_none_type( args.results, val_type='str' )
+
+# Run the command.
+proc = subprocess.Popen( args=cmd, stderr=tmp_stderr, stdout=tmp_stdout, shell=True )
+rc = proc.wait()
+
+# Handle execution errors.
+if rc != 0:
+    error_message = imagej2_base_utils.get_stderr_exception( tmp_err, tmp_stderr, tmp_out, tmp_stdout )
+    imagej2_base_utils.stop_err( error_message )
+
+# Handle processing errors.
+if os.path.getsize( error_log ) > 0:
+    error_message = open( error_log, 'r' ).read()
+    imagej2_base_utils.stop_err( error_message )
+
+if tmp_output_path is not None:
+    # Save the output image.
+    shutil.move( tmp_output_path, args.output )
+imagej2_base_utils.cleanup_before_exit( tmp_dir )

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/imagej2_analyze_particles_binary_jython_script.py	Tue Sep 17 17:08:08 2019 -0400
@@ -0,0 +1,72 @@
+import jython_utils
+import sys
+from ij import IJ
+from ij.plugin.filter import Analyzer
+
+# Fiji Jython interpreter implements Python 2.5 which does not
+# provide support for argparse.
+error_log = sys.argv[ -14 ]
+input = sys.argv[ -13 ]
+black_background = jython_utils.asbool( sys.argv[ -12 ] )
+size = sys.argv[ -11 ]
+circularity_min = float( sys.argv[ -10 ] )
+circularity_max = float( sys.argv[ -9 ] )
+show = sys.argv[ -8 ]
+display_results = jython_utils.asbool( sys.argv[ -7 ] )
+all_results = jython_utils.asbool( sys.argv[ -6 ] )
+exclude_edges = jython_utils.asbool( sys.argv[ -5 ] )
+include_holes = jython_utils.asbool( sys.argv[ -4 ] )
+tmp_output_path = sys.argv[ -3 ]
+output_datatype = sys.argv[ -2 ]
+results_path = sys.argv[ -1 ]
+
+# Open the input image file.
+input_image_plus = IJ.openImage( input )
+
+# Create a copy of the image.
+input_image_plus_copy = input_image_plus.duplicate()
+image_processor_copy = input_image_plus_copy.getProcessor()
+analyzer = Analyzer( input_image_plus_copy )
+
+try:
+    # Set binary options.
+    options = jython_utils.get_binary_options( black_background=black_background )
+    IJ.run( input_image_plus_copy, "Options...", options )
+
+    # Convert image to binary if necessary.
+    if not image_processor_copy.isBinary():
+        # Convert the image to binary grayscale.
+        IJ.run( input_image_plus_copy, "Make Binary", "" )
+
+    # Set the options.
+    options = [ 'size=%s' % size ]
+    circularity_str = '%.3f-%.3f' % ( circularity_min, circularity_max )
+    options.append( 'circularity=%s' % circularity_str )
+    if show.find( '_' ) >= 0:
+        show_str = '[%s]' % show.replace( '_', ' ' )
+    else:
+        show_str = show
+    options.append( 'show=%s' % show_str )
+    if display_results:
+        options.append( 'display' )
+        if not all_results:
+            options.append( 'summarize' )
+    if exclude_edges:
+        options.append( 'exclude' )
+    if include_holes:
+        options.append( 'include' )
+    # Always run "in_situ".
+    options.append( 'in_situ' )
+
+    # Run the command.
+    IJ.run( input_image_plus_copy, "Analyze Particles...", " ".join( options ) )
+
+    # Save outputs.
+    if tmp_output_path not in [ None, 'None' ]:
+        # Save the ImagePlus object as a new image.
+        IJ.saveAs( input_image_plus_copy, output_datatype, tmp_output_path )
+    if display_results and results_path not in [ None, 'None' ]:
+        results_table = analyzer.getResultsTable()
+        results_table.saveAs( results_path )
+except Exception, e:
+    jython_utils.handle_error( error_log, str( e ) )

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/imagej2_analyze_skeleton.py	Tue Sep 17 17:08:08 2019 -0400
@@ -0,0 +1,61 @@
+#!/usr/bin/env python
+import argparse
+import os
+import shutil
+import subprocess
+import tempfile
+import imagej2_base_utils
+
+parser = argparse.ArgumentParser()
+parser.add_argument( '--input', dest='input', help='Path to the input file' )
+parser.add_argument( '--input_datatype', dest='input_datatype', help='Datatype of the input image' )
+parser.add_argument( '--black_background', dest='black_background', help='Black background' )
+parser.add_argument( '--prune_cycle_method', dest='prune_cycle_method', default='none', help='Prune cycle method' )
+parser.add_argument( '--prune_ends', dest='prune_ends', default='no', help='Prune ends' )
+parser.add_argument( '--calculate_largest_shortest_path', dest='calculate_largest_shortest_path', default='no', help='Calculate largest shortest path' )
+parser.add_argument( '--show_detailed_info', dest='show_detailed_info', default='no', help='Show detailed info' )
+parser.add_argument( '--jython_script', dest='jython_script', help='Path to the Jython script' )
+parser.add_argument( '--output', dest='output', help='Path to the output file' )
+args = parser.parse_args()
+
+tmp_dir = imagej2_base_utils.get_temp_dir()
+# ImageJ expects valid image file extensions, so the Galaxy .dat extension does not
+# work for some features.  The following creates a symlink with an appropriate file
+# extension that points to the Galaxy dataset.  This symlink is used by ImageJ.
+tmp_input_path = imagej2_base_utils.get_input_image_path( tmp_dir, args.input, args.input_datatype )
+
+# Define command response buffers.
+tmp_out = tempfile.NamedTemporaryFile().name
+tmp_stdout = open( tmp_out, 'wb' )
+tmp_err = tempfile.NamedTemporaryFile().name
+tmp_stderr = open( tmp_err, 'wb' )
+# Java writes a lot of stuff to stderr, so we'll specify a file for handling actual errors.
+error_log = tempfile.NamedTemporaryFile( delete=False ).name
+
+# Build the command line.
+cmd = imagej2_base_utils.get_base_command_imagej2( None, jython_script=args.jython_script )
+if cmd is None:
+    imagej2_base_utils.stop_err( "ImageJ not found!" )
+cmd += ' %s' % error_log
+cmd += ' %s' % tmp_input_path
+cmd += ' %s' % args.black_background
+cmd += ' %s' % args.prune_cycle_method
+cmd += ' %s' % args.prune_ends
+cmd += ' %s' % args.calculate_largest_shortest_path
+cmd += ' %s' % args.show_detailed_info
+cmd += ' %s' % args.output
+
+# Run the command.
+proc = subprocess.Popen( args=cmd, stderr=tmp_stderr, stdout=tmp_stdout, shell=True )
+rc = proc.wait()
+
+# Handle execution errors.
+if rc != 0:
+    error_message = imagej2_base_utils.get_stderr_exception( tmp_err, tmp_stderr, tmp_out, tmp_stdout )
+    imagej2_base_utils.stop_err( error_message )
+# Handle processing errors.
+if os.path.getsize( error_log ) > 0:
+    error_message = open( error_log, 'r' ).read()
+    imagej2_base_utils.stop_err( error_message )
+
+imagej2_base_utils.cleanup_before_exit( tmp_dir )

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/imagej2_analyze_skeleton_jython_script.py	Tue Sep 17 17:08:08 2019 -0400
@@ -0,0 +1,147 @@
+import jython_utils
+import math
+import sys
+from ij import IJ
+from sc.fiji.analyzeSkeleton import AnalyzeSkeleton_
+
+BASIC_NAMES = [ 'Branches', 'Junctions', 'End-point Voxels',
+                'Junction Voxels', 'Slab Voxels', 'Average branch length',
+                'Triple Points', 'Quadruple Points', 'Maximum Branch Length' ]
+DETAIL_NAMES = [ 'Skeleton ID', 'Branch length', 'V1 x', 'V1 y', 'V1 z', 'V2 x',
+                 'V2 y', 'V2 z', 'Euclidean distance' ]
+
+def get_euclidean_distance( vertex1, vertex2 ):
+    x1, y1, z1 = get_points( vertex1 )
+    x2, y2, z2 = get_points( vertex2 )
+    return math.sqrt( math.pow( ( x2 - x1 ), 2 ) +
+                      math.pow( ( y2 - y1 ), 2 ) +
+                      math.pow( ( z2 - z1 ), 2 ) )
+
+def get_graph_length( graph ):
+    length = 0
+    for edge in graph.getEdges():
+        length = length + edge.getLength()
+    return length
+
+def get_points( vertex ):
+    # An array of Point, which has attributes x,y,z.
+    point = vertex.getPoints()[ 0 ]
+    return point.x, point.y, point.z
+    
+def get_sorted_edge_lengths( graph ):
+    # Return graph edges sorted from longest to shortest.
+    edges = graph.getEdges()
+    edges = sorted( edges, key=lambda edge: edge.getLength(), reverse=True )
+    return edges
+
+def get_sorted_graph_lengths( result ):
+    # Get the separate graphs (skeletons).
+    graphs = result.getGraph()
+    # Sort graphs from longest to shortest.
+    graphs = sorted( graphs, key=lambda g: get_graph_length( g ), reverse=True )
+    return graphs
+
+def save( result, output, show_detailed_info, calculate_largest_shortest_path, sep='\t' ):
+    num_trees = int( result.getNumOfTrees() )
+    outf = open( output, 'wb' )
+    outf.write( '# %s\n' % sep.join( BASIC_NAMES ) )
+    for index in range( num_trees ):
+        outf.write( '%d%s' % ( result.getBranches()[ index ], sep ) )
+        outf.write( '%d%s' % ( result.getJunctions()[ index ], sep ) )
+        outf.write( '%d%s' % ( result.getEndPoints()[ index ], sep ) )
+        outf.write( '%d%s' % ( result.getJunctionVoxels()[ index ], sep ) )
+        outf.write( '%d%s' % ( result.getSlabs()[ index ], sep ) )
+        outf.write( '%.3f%s' % ( result.getAverageBranchLength()[ index ], sep ) )
+        outf.write( '%d%s' % ( result.getTriples()[ index ], sep ) )
+        outf.write( '%d%s' % ( result.getQuadruples()[ index ], sep ) )
+        outf.write( '%.3f' % result.getMaximumBranchLength()[ index ] )
+        if calculate_largest_shortest_path:
+            outf.write( '%s%.3f%s' % ( sep, result.shortestPathList.get( index ), sep ) )
+            outf.write( '%d%s' % ( result.spStartPosition[ index ][ 0 ], sep ) )
+            outf.write( '%d%s' % ( result.spStartPosition[ index ][ 1 ], sep ) )
+            outf.write( '%d\n' % result.spStartPosition[ index ][ 2 ] )
+        else:
+            outf.write( '\n' )
+    if show_detailed_info:
+        outf.write( '# %s\n' % sep.join( DETAIL_NAMES ) )
+        # The following index is a placeholder for the skeleton ID.
+        # The terms "graph" and "skeleton" refer to the same thing.
+        # Also, the SkeletonResult.java code states that the
+        # private Graph[] graph object is an array of graphs (one
+        # per tree).
+        for index, graph in enumerate( get_sorted_graph_lengths( result ) ):
+            for edge in get_sorted_edge_lengths( graph ):
+                vertex1 = edge.getV1()
+                x1, y1, z1 = get_points( vertex1 )
+                vertex2 = edge.getV2()
+                x2, y2, z2 = get_points( vertex2 )
+                outf.write( '%d%s' % ( index+1, sep ) )
+                outf.write( '%.3f%s' % ( edge.getLength(), sep ) )
+                outf.write( '%d%s' % ( x1, sep ) )
+                outf.write( '%d%s' % ( y1, sep ) )
+                outf.write( '%d%s' % ( z1, sep ) )
+                outf.write( '%d%s' % ( x2, sep ) )
+                outf.write( '%d%s' % ( y2, sep ) )
+                outf.write( '%d%s' % ( z2, sep ) )
+                outf.write( '%.3f' % get_euclidean_distance( vertex1, vertex2 ) )
+                if calculate_largest_shortest_path:
+                    # Keep number of separated items the same for each line.
+                    outf.write( '%s %s' % ( sep, sep ) )
+                    outf.write( ' %s' % sep )
+                    outf.write( ' %s' % sep )
+                    outf.write( ' \n' )
+                else:
+                    outf.write( '\n' )
+    outf.close()
+
+# Fiji Jython interpreter implements Python 2.5 which does not
+# provide support for argparse.
+error_log = sys.argv[ -8 ]
+input = sys.argv[ -7 ]
+black_background = jython_utils.asbool( sys.argv[ -6 ] )
+prune_cycle_method = sys.argv[ -5 ]
+prune_ends = jython_utils.asbool( sys.argv[ -4 ] )
+calculate_largest_shortest_path = jython_utils.asbool( sys.argv[ -3 ] )
+if calculate_largest_shortest_path:
+    BASIC_NAMES.extend( [ 'Longest Shortest Path', 'spx', 'spy', 'spz' ] )
+    DETAIL_NAMES.extend( [ ' ', ' ', ' ', ' ' ] )
+show_detailed_info = jython_utils.asbool( sys.argv[ -2 ] )
+output = sys.argv[ -1 ]
+
+# Open the input image file.
+input_image_plus = IJ.openImage( input )
+
+# Create a copy of the image.
+input_image_plus_copy = input_image_plus.duplicate()
+image_processor_copy = input_image_plus_copy.getProcessor()
+
+try:
+    # Set binary options.
+    options = jython_utils.get_binary_options( black_background=black_background )
+    IJ.run( input_image_plus_copy, "Options...", options )
+
+    # Convert image to binary if necessary.
+    if not image_processor_copy.isBinary():
+        IJ.run( input_image_plus_copy, "Make Binary", "" )
+
+    # Run AnalyzeSkeleton
+    analyze_skeleton = AnalyzeSkeleton_()
+    analyze_skeleton.setup( "", input_image_plus_copy )
+    if prune_cycle_method == 'none':
+        prune_index  = analyze_skeleton.NONE
+    elif prune_cycle_method == 'shortest_branch':
+        prune_index  = analyze_skeleton.SHORTEST_BRANCH
+    elif prune_cycle_method == 'lowest_intensity_voxel':
+        prune_index  = analyze_skeleton.LOWEST_INTENSITY_VOXEL
+    elif prune_cycle_method == 'lowest_intensity_branch':
+        prune_index  = analyze_skeleton.LOWEST_INTENSITY_BRANCH
+    result = analyze_skeleton.run( prune_index,
+                                   prune_ends,
+                                   calculate_largest_shortest_path,
+                                   input_image_plus_copy,
+                                   True,
+                                   True )
+    # Save the results.
+    save( result, output, show_detailed_info, calculate_largest_shortest_path )
+except Exception, e:
+    jython_utils.handle_error( error_log, str( e ) )

Binary file imagej2_base_utils$py.class has changed

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/imagej2_base_utils.py	Tue Sep 17 17:08:08 2019 -0400
@@ -0,0 +1,169 @@
+import os
+import shutil
+import sys
+import tempfile
+
+BUFF_SIZE = 1048576
+
+
+def cleanup_before_exit(tmp_dir):
+    """
+    Remove temporary files and directories prior to tool exit.
+    """
+    if tmp_dir and os.path.exists(tmp_dir):
+        shutil.rmtree(tmp_dir)
+
+
+def get_base_cmd_bunwarpj(jvm_memory):
+    if jvm_memory in [None, 'None']:
+        jvm_memory_str = ''
+    else:
+        jvm_memory_str = '-Xmx%s' % jvm_memory
+    # The following bunwarpj_base_cmd string will look something like this:
+    # "java %s -cp $JAR_DIR/ij-1.49k.jar:$PLUGINS_DIR/bUnwarpJ_-2.6.1.jar \
+    # bunwarpj.bUnwarpJ_" % (jvm_memory_str)
+    # See the bunwarpj.sh script for the fiji 20151222
+    # bioconda recipe in github.
+    bunwarpj_base_cmd = "bunwarpj %s" % jvm_memory_str
+    return bunwarpj_base_cmd
+
+
+def get_base_command_imagej2(memory_size=None, macro=None, jython_script=None):
+    imagej2_executable = get_imagej2_executable()
+    if imagej2_executable is None:
+        return None
+    cmd = '%s --ij2 --headless --debug' % imagej2_executable
+    if memory_size is not None:
+        memory_size_cmd = ' -DXms=%s -DXmx=%s' % (memory_size, memory_size)
+        cmd += memory_size_cmd
+    if macro is not None:
+        cmd += ' --macro %s' % os.path.abspath(macro)
+    if jython_script is not None:
+        cmd += ' --jython %s' % os.path.abspath(jython_script)
+    return cmd
+
+
+def get_file_extension(image_format):
+    """
+    Return a valid bioformats file extension based on the received
+    value of image_format(e.g., "gif" is returned as ".gif".
+    """
+    return '.%s' % image_format
+
+
+def get_file_name_without_extension(file_path):
+    """
+    Eliminate the .ext from the received file name, assuming that
+    the file name consists of only a single '.'.
+    """
+    if os.path.exists(file_path):
+        path, name = os.path.split(file_path)
+        name_items = name.split('.')
+        return name_items[0]
+    return None
+
+
+def get_imagej2_executable():
+    """
+    Fiji names the ImageJ executable different names for different
+    architectures, but our bioconda recipe allows us to do this.
+    """
+    return 'ImageJ'
+
+
+def get_input_image_path(tmp_dir, input_file, image_format):
+    """
+    Bioformats uses file extensions (e.g., .job, .gif, etc)
+    when reading and writing image files, so the Galaxy dataset
+    naming convention of setting all file extensions as .dat
+    must be handled.
+    """
+    image_path = get_temporary_image_path(tmp_dir, image_format)
+    # Remove the file so we can create a symlink.
+    os.remove(image_path)
+    os.symlink(input_file, image_path)
+    return image_path
+
+
+def get_platform_info_dict():
+    '''Return a dict with information about the current platform.'''
+    platform_dict = {}
+    sysname, nodename, release, version, machine = os.uname()
+    platform_dict['os'] = sysname.lower()
+    platform_dict['architecture'] = machine.lower()
+    return platform_dict
+
+
+def get_stderr_exception(tmp_err, tmp_stderr, tmp_out, tmp_stdout, include_stdout=False):
+    tmp_stderr.close()
+    """
+    Return a stderr string of reasonable size.
+    """
+    # Get stderr, allowing for case where it's very large.
+    tmp_stderr = open(tmp_err, 'rb')
+    stderr_str = ''
+    buffsize = BUFF_SIZE
+    try:
+        while True:
+            stderr_str += tmp_stderr.read(buffsize)
+            if not stderr_str or len(stderr_str) % buffsize != 0:
+                break
+    except OverflowError:
+        pass
+    tmp_stderr.close()
+    if include_stdout:
+        tmp_stdout = open(tmp_out, 'rb')
+        stdout_str = ''
+        buffsize = BUFF_SIZE
+        try:
+            while True:
+                stdout_str += tmp_stdout.read(buffsize)
+                if not stdout_str or len(stdout_str) % buffsize != 0:
+                    break
+        except OverflowError:
+            pass
+    tmp_stdout.close()
+    if include_stdout:
+        return 'STDOUT\n%s\n\nSTDERR\n%s\n' % (stdout_str, stderr_str)
+    return stderr_str
+
+
+def get_temp_dir(prefix='tmp-imagej-', dir=None):
+    """
+    Return a temporary directory.
+    """
+    return tempfile.mkdtemp(prefix=prefix, dir=dir)
+
+
+def get_tempfilename(dir=None, suffix=None):
+    """
+    Return a temporary file name.
+    """
+    fd, name = tempfile.mkstemp(suffix=suffix, dir=dir)
+    os.close(fd)
+    return name
+
+
+def get_temporary_image_path(tmp_dir, image_format):
+    """
+    Return the path to a temporary file with a valid image format
+    file extension that can be used with bioformats.
+    """
+    file_extension = get_file_extension(image_format)
+    return get_tempfilename(tmp_dir, file_extension)
+
+
+def handle_none_type(val, val_type='float'):
+    if val is None:
+        return ' None'
+    else:
+        if val_type == 'float':
+            return ' %.3f' % val
+        elif val_type == 'int':
+            return ' %d' % val
+    return ' %s' % val
+
+
+def stop_err(msg):
+    sys.stderr.write(msg)
+    sys.exit(1)

Binary file imagej2_base_utils.pyc has changed

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/imagej2_binary_to_edm.py	Tue Sep 17 17:08:08 2019 -0400
@@ -0,0 +1,65 @@
+#!/usr/bin/env python
+import argparse
+import os
+import shutil
+import subprocess
+import tempfile
+import imagej2_base_utils
+
+parser = argparse.ArgumentParser()
+parser.add_argument( '--input', dest='input', help='Path to the input file' )
+parser.add_argument( '--input_datatype', dest='input_datatype', help='Datatype of the input image' )
+parser.add_argument( '--iterations', dest='iterations', type=int, help='Iterations' )
+parser.add_argument( '--count', dest='count', type=int, help='Count' )
+parser.add_argument( '--black_background', dest='black_background', help='Black background' )
+parser.add_argument( '--pad_edges_when_eroding', dest='pad_edges_when_eroding', help='Pad edges when eroding' )
+parser.add_argument( '--jython_script', dest='jython_script', help='Path to the Jython script' )
+parser.add_argument( '--output', dest='output', help='Path to the output file' )
+parser.add_argument( '--output_datatype', dest='output_datatype', help='Datatype of the output image' )
+args = parser.parse_args()
+
+tmp_dir = imagej2_base_utils.get_temp_dir()
+# ImageJ expects valid image file extensions, so the Galaxy .dat extension does not
+# work for some features.  The following creates a symlink with an appropriate file
+# extension that points to the Galaxy dataset.  This symlink is used by ImageJ.
+tmp_input_path = imagej2_base_utils.get_input_image_path( tmp_dir, args.input, args.input_datatype )
+tmp_output_path = imagej2_base_utils.get_temporary_image_path( tmp_dir, args.output_datatype )
+
+# Define command response buffers.
+tmp_out = tempfile.NamedTemporaryFile().name
+tmp_stdout = open( tmp_out, 'wb' )
+tmp_err = tempfile.NamedTemporaryFile().name
+tmp_stderr = open( tmp_err, 'wb' )
+# Java writes a lot of stuff to stderr, so we'll specify a file for handling actual errors.
+error_log = tempfile.NamedTemporaryFile( delete=False ).name
+
+# Build the command line.
+cmd = imagej2_base_utils.get_base_command_imagej2( None, jython_script=args.jython_script )
+if cmd is None:
+    imagej2_base_utils.stop_err( "ImageJ not found!" )
+cmd += ' %s' % error_log
+cmd += ' %s' % tmp_input_path
+cmd += ' %d' % args.iterations
+cmd += ' %d' % args.count
+cmd += ' %s' % args.black_background
+cmd += ' %s' % args.pad_edges_when_eroding
+cmd += ' %s' % tmp_output_path
+cmd += ' %s' % args.output_datatype
+
+# Run the command.
+proc = subprocess.Popen( args=cmd, stderr=tmp_stderr, stdout=tmp_stdout, shell=True )
+rc = proc.wait()
+
+# Handle execution errors.
+if rc != 0:
+    error_message = imagej2_base_utils.get_stderr_exception( tmp_err, tmp_stderr, tmp_out, tmp_stdout )
+    imagej2_base_utils.stop_err( error_message )
+
+# Handle processing errors.
+if os.path.getsize( error_log ) > 0:
+    error_message = open( error_log, 'r' ).read()
+    imagej2_base_utils.stop_err( error_message )
+
+# Save the output image.
+shutil.move( tmp_output_path, args.output )
+imagej2_base_utils.cleanup_before_exit( tmp_dir )

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/imagej2_binary_to_edm_jython_script.py	Tue Sep 17 17:08:08 2019 -0400
@@ -0,0 +1,44 @@
+import jython_utils
+import sys
+from ij import IJ
+from ij import ImagePlus
+from ij.plugin.filter import Analyzer
+from ij.plugin.filter import EDM
+
+# Fiji Jython interpreter implements Python 2.5 which does not
+# provide support for argparse.
+error_log = sys.argv[ -8 ]
+input = sys.argv[ -7 ]
+iterations = int( sys.argv[ -6 ] )
+count = int( sys.argv[ -5 ] )
+black_background = jython_utils.asbool( sys.argv[ -4 ] )
+pad_edges_when_eroding = jython_utils.asbool( sys.argv[ -3 ] )
+tmp_output_path = sys.argv[ -2 ]
+output_datatype = sys.argv[ -1 ]
+
+# Open the input image file.
+input_image_plus = IJ.openImage( input )
+
+# Create a copy of the image.
+input_image_plus_copy = input_image_plus.duplicate()
+image_processor_copy = input_image_plus_copy.getProcessor()
+
+try:
+    # Set binary options.
+    options = jython_utils.get_binary_options( black_background=black_background,
+                                               iterations=iterations,
+                                               count=count,
+                                               pad_edges_when_eroding=pad_edges_when_eroding )
+    IJ.run( input_image_plus_copy, "Options...", options )
+
+    # Convert image to binary if necessary.
+    if not image_processor_copy.isBinary():
+        # Convert the image to binary grayscale.
+        IJ.run( input_image_plus_copy, "Make Binary", "" )
+
+    # Run the command.
+    IJ.run( input_image_plus_copy, "Distance Map", "" )
+    # Save the ImagePlus object as a new image.
+    IJ.saveAs( input_image_plus_copy, output_datatype, tmp_output_path )
+except Exception, e:
+    jython_utils.handle_error( error_log, str( e ) )

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/imagej2_bunwarpj_adapt_transform.py	Tue Sep 17 17:08:08 2019 -0400
@@ -0,0 +1,65 @@
+#!/usr/bin/env python
+import argparse
+import subprocess
+import tempfile
+import imagej2_base_utils
+
+# Parse Command Line.
+parser = argparse.ArgumentParser()
+parser.add_argument( '--source_image', dest='source_image', help='Source image' )
+parser.add_argument( '--source_image_format', dest='source_image_format', help='Source image format' )
+parser.add_argument( '--target_image', dest='target_image', help='Target image' )
+parser.add_argument( '--target_image_format', dest='target_image_format', help='Target image format' )
+parser.add_argument( '--input_elastic_transformation', dest='input_elastic_transformation', help='Input elastic transformation matrix' )
+parser.add_argument( '--image_size_factor', dest='image_size_factor', type=float, help='Image size factor' )
+parser.add_argument( '--output', dest='output', help='Warping index' )
+
+args = parser.parse_args()
+
+tmp_dir = imagej2_base_utils.get_temp_dir()
+source_image_path = imagej2_base_utils.get_input_image_path( tmp_dir, args.source_image, args.source_image_format )
+target_image_path = imagej2_base_utils.get_input_image_path( tmp_dir, args.target_image, args.target_image_format )
+input_elastic_transformation_path = imagej2_base_utils.get_input_image_path( tmp_dir, args.input_elastic_transformation, 'txt' )
+
+# Define command response buffers.
+tmp_out = tempfile.NamedTemporaryFile().name
+tmp_stdout = open( tmp_out, 'wb' )
+tmp_err = tempfile.NamedTemporaryFile().name
+tmp_stderr = open( tmp_err, 'wb' )
+
+def is_power2( val ):
+    if val < 0:
+        return False
+    if val < 1:
+        val = 1.0 / val
+    val = int( val )
+    return ( ( val & ( val - 1 ) ) == 0 )
+
+# Build the command line to adapt the transformation.
+cmd = imagej2_base_utils.get_base_cmd_bunwarpj( None )
+if cmd is None:
+    imagej2_base_utils.stop_err( "bUnwarpJ not found!" )
+cmd += ' -adapt_transform'
+
+# Make sure the value of image_size_factor is a power of 2 (positive or negative).
+if is_power2( args.image_size_factor ):
+    image_size_factor = args.image_size_factor
+else:
+    msg = "Image size factor must be a positive or negative power of 2 (0.25, 0.5, 2, 4, 8, etc)."
+    imagej2_base_utils.stop_err( msg )
+
+# Target is sent before source.
+cmd += ' %s' % target_image_path
+cmd += ' %s' % source_image_path
+cmd += ' %s' % input_elastic_transformation_path
+cmd += ' %s' % args.output
+cmd += ' %2.f' % image_size_factor
+
+# Adapt the transformation based on the image size factor using bUnwarpJ.
+proc = subprocess.Popen( args=cmd, stderr=subprocess.PIPE, stdout=subprocess.PIPE, shell=True )
+rc = proc.wait()
+if rc != 0:
+    error_message = imagej2_base_utils.get_stderr_exception( tmp_err, tmp_stderr, tmp_out, tmp_stdout )
+    imagej2_base_utils.stop_err( error_message )
+
+imagej2_base_utils.cleanup_before_exit( tmp_dir )

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/imagej2_bunwarpj_align.py	Tue Sep 17 17:08:08 2019 -0400
@@ -0,0 +1,178 @@
+#!/usr/bin/env python
+import argparse
+import os
+import shutil
+import subprocess
+import tempfile
+import imagej2_base_utils
+
+# Parse Command Line.
+parser = argparse.ArgumentParser()
+parser.add_argument( '--source_image', dest='source_image', help='Source image' )
+parser.add_argument( '--source_image_format', dest='source_image_format', help='Source image format' )
+parser.add_argument( '--source_mask', dest='source_mask', default=None, help='Source mask' )
+parser.add_argument( '--source_mask_format', dest='source_mask_format', default=None, help='Source mask image format' )
+parser.add_argument( '--target_image', dest='target_image', help='Target image' )
+parser.add_argument( '--target_image_format', dest='target_image_format', help='Target image format' )
+parser.add_argument( '--target_mask', dest='target_mask', default=None, help='Target mask' )
+parser.add_argument( '--target_mask_format', dest='target_mask_format', default=None, help='Target mask image format' )
+parser.add_argument( '--min_scale_def', dest='min_scale_def', type=int, help='Initial deformation' )
+parser.add_argument( '--max_scale_def', dest='max_scale_def', type=int, help='Final deformation' )
+parser.add_argument( '--max_subsamp_fact', dest='max_subsamp_fact', type=int, help='Image sub-sample factor' )
+parser.add_argument( '--divergence_weight', dest='divergence_weight', type=float, help='Divergence weight' )
+parser.add_argument( '--curl_weight', dest='curl_weight', type=float, help='Curl weight' )
+parser.add_argument( '--image_weight', dest='image_weight', type=float, help='Image weight' )
+parser.add_argument( '--consistency_weight', dest='consistency_weight', type=float, help='Consistency weight' )
+parser.add_argument( '--landmarks_weight', dest='landmarks_weight', type=float, help='Landmarks weight' )
+parser.add_argument( '--landmarks_file', dest='landmarks_file', default=None, help='Landmarks file' )
+parser.add_argument( '--source_affine_file', dest='source_affine_file', default=None, help='Initial source affine matrix transformation' )
+parser.add_argument( '--target_affine_file', dest='target_affine_file', default=None, help='Initial target affine matrix transformation' )
+parser.add_argument( '--mono', dest='mono', default=False, help='Unidirectional registration (source to target)' )
+parser.add_argument( '--source_trans_out', dest='source_trans_out', default=None, help='Direct source transformation matrix' )
+parser.add_argument( '--target_trans_out', dest='target_trans_out', default=None, help='Inverse target transformation matrix' )
+parser.add_argument( '--source_out', help='Output source image' )
+parser.add_argument( '--source_out_datatype', help='Output registered source image format' )
+parser.add_argument( '--target_out', default=None, help='Output target image' )
+parser.add_argument( '--target_out_datatype', default=None, help='Output registered target image format' )
+parser.add_argument( '--jython_script', dest='jython_script', help='Path to the Jython script' )
+
+args = parser.parse_args()
+
+if args.source_trans_out is not None and args.target_trans_out is not None:
+    save_transformation = True
+else:
+    save_transformation = False
+
+tmp_dir = imagej2_base_utils.get_temp_dir()
+source_image_path = imagej2_base_utils.get_input_image_path( tmp_dir, args.source_image, args.source_image_format )
+tmp_source_out_tiff_path = imagej2_base_utils.get_temporary_image_path( tmp_dir, 'tiff' )
+tmp_source_out_path = imagej2_base_utils.get_temporary_image_path( tmp_dir, args.source_out_datatype )
+target_image_path = imagej2_base_utils.get_input_image_path( tmp_dir, args.target_image, args.target_image_format )
+if not args.mono:
+    tmp_target_out_tiff_path = imagej2_base_utils.get_temporary_image_path( tmp_dir, 'tiff' )
+    tmp_target_out_path = imagej2_base_utils.get_temporary_image_path( tmp_dir, args.target_out_datatype )
+if args.source_mask is not None and args.target_mask is not None:
+    tmp_source_mask_path = imagej2_base_utils.get_input_image_path( tmp_dir, args.source_mask, args.source_mask_format )
+    tmp_target_mask_path = imagej2_base_utils.get_input_image_path( tmp_dir, args.target_mask, args.target_mask_format )
+if save_transformation:
+    # bUnwarpJ automatically names the transformation files based on the names
+    # of the source and target image file names.  We've defined symlinks to 
+    # temporary files with valid image extensions since ImageJ does not handle
+    # the Galaxy "dataset.dat" file extensions.
+    source_file_name = imagej2_base_utils.get_file_name_without_extension( tmp_source_out_tiff_path )
+    tmp_source_out_transf_path = os.path.join( tmp_dir, '%s_transf.txt' % source_file_name )
+    target_file_name = imagej2_base_utils.get_file_name_without_extension( tmp_target_out_tiff_path )
+    tmp_target_out_transf_path = os.path.join( tmp_dir, '%s_transf.txt' % target_file_name )
+
+# Define command response buffers.
+tmp_out = tempfile.NamedTemporaryFile().name
+tmp_stdout = open( tmp_out, 'wb' )
+tmp_err = tempfile.NamedTemporaryFile().name
+tmp_stderr = open( tmp_err, 'wb' )
+
+# Build the command line to align the two images.
+cmd = imagej2_base_utils.get_base_cmd_bunwarpj( None )
+if cmd is None:
+    imagej2_base_utils.stop_err( "bUnwarpJ not found!" )
+cmd += ' -align'
+# Target is sent before source.
+cmd += ' %s' % target_image_path
+if args.target_mask is None:
+    target_mask_str = ' NULL'
+else:
+    target_mask_str = ' %s' % tmp_target_mask_path
+cmd += target_mask_str
+cmd += ' %s' % source_image_path
+if args.source_mask is None:
+    source_mask_str = ' NULL'
+else:
+    source_mask_str = ' %s' % tmp_source_mask_path
+cmd += source_mask_str
+cmd += ' %d' % args.min_scale_def
+cmd += ' %d' % args.max_scale_def
+cmd += ' %d' % args.max_subsamp_fact
+cmd += ' %.1f' % args.divergence_weight
+cmd += ' %.1f' % args.curl_weight
+cmd += ' %.1f' % args.image_weight
+cmd += ' %.1f' % args.consistency_weight
+# Source is produced before target.
+cmd += ' %s' % tmp_source_out_tiff_path
+if not args.mono:
+    cmd += ' %s' % tmp_target_out_tiff_path
+if args.landmarks_file is not None:
+    # We have to create a temporary file with a .txt extension here so that
+    # bUnwarpJ will not ignore the Galaxy "dataset.dat" file.
+    tmp_landmarks_file_path = imagej2_base_utils.get_input_image_path( tmp_dir,
+                                                                       args.landmarks_file,
+                                                                       'txt' )
+    cmd += ' -landmarks'
+    cmd += ' %.1f' % args.landmarks_weight
+    cmd += ' %s' % tmp_landmarks_file_path
+if args.source_affine_file is not None and args.target_affine_file is not None:
+    # Target is sent before source.
+    cmd += ' -affine'
+    cmd += ' %s' % args.target_affine_file
+    cmd += ' %s' % args.source_affine_file
+if args.mono:
+    cmd += ' -mono'
+if save_transformation:
+    cmd += ' -save_transformation'
+
+# Align the two images using bUnwarpJ.
+proc = subprocess.Popen( args=cmd, stderr=tmp_stderr, stdout=tmp_stdout, shell=True )
+rc = proc.wait()
+if rc != 0:
+    error_message = imagej2_base_utils.get_stderr_exception( tmp_err, tmp_stderr, tmp_out, tmp_stdout )
+    imagej2_base_utils.stop_err( error_message )
+
+# bUnwarpJ produces tiff image stacks consisting of 3 slices which can be viewed in ImageJ.
+# The 3 slices are:: 1) the registered image, 2) the target image and 3) the black/white
+# warp image.  Galaxy supports only single-layered images, so we'll convert the images so they
+# can be viewed in Galaxy.
+
+# Define command response buffers.
+tmp_out = tempfile.NamedTemporaryFile().name
+tmp_stdout = open( tmp_out, 'wb' )
+tmp_err = tempfile.NamedTemporaryFile().name
+tmp_stderr = open( tmp_err, 'wb' )
+
+# Build the command line to handle the multi-slice tiff images.
+cmd = imagej2_base_utils.get_base_command_imagej2( None, jython_script=args.jython_script )
+if cmd is None:
+    imagej2_base_utils.stop_err( "ImageJ not found!" )
+if args.mono:
+    # bUnwarpJ will produce only a registered source image.
+    cmd += ' %s %s %s %s' % ( tmp_source_out_tiff_path,
+                              args.source_out_datatype,
+                              tmp_source_out_path,
+                              args.mono )
+else:
+    # bUnwarpJ will produce registered source and target images.
+    cmd += ' %s %s %s %s %s %s %s' % ( tmp_source_out_tiff_path,
+                                       args.source_out_datatype,
+                                       tmp_source_out_path,
+                                       tmp_target_out_tiff_path,
+                                       args.target_out_datatype,
+                                       tmp_target_out_path,
+                                       args.mono )
+
+# Merge the multi-slice tiff layers into an image that can be viewed in Galaxy.
+proc = subprocess.Popen( args=cmd, stderr=tmp_stderr, stdout=tmp_stdout, shell=True )
+rc = proc.wait()
+if rc != 0:
+    error_message = imagej2_base_utils.get_stderr_exception( tmp_err, tmp_stderr, tmp_out, tmp_stdout )
+    imagej2_base_utils.stop_err( error_message )
+
+# Save the Registered Source Image to the output dataset.
+shutil.move( tmp_source_out_path, args.source_out )
+if not args.mono:
+    # Move the Registered Target Image to the output dataset.
+    shutil.move( tmp_target_out_path, args.target_out )
+
+# If requested, save matrix transformations as additional datasets.
+if save_transformation:
+    shutil.move( tmp_source_out_transf_path, args.source_trans_out )
+    if not args.mono:
+        shutil.move( tmp_target_out_transf_path, args.target_trans_out )
+
+imagej2_base_utils.cleanup_before_exit( tmp_dir )

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/imagej2_bunwarpj_align_jython_script.py	Tue Sep 17 17:08:08 2019 -0400
@@ -0,0 +1,37 @@
+import sys
+import jython_utils
+from ij import IJ
+
+# Fiji Jython interpreter implements Python 2.5 which does not
+# provide support for argparse.
+
+if sys.argv[ -1 ].lower() in [ 'true' ]:
+    mono = True
+else:
+    mono = False
+
+if mono:
+    # bUnwarpJ has been called with the -mono param.
+    source_tiff_path = sys.argv[ -4 ]
+    source_datatype = sys.argv[ -3 ]
+    source_path = sys.argv[ -2 ]
+else:
+    source_tiff_path = sys.argv[ -7 ]
+    source_datatype = sys.argv[ -6 ]
+    source_path = sys.argv[ -5 ]
+    target_tiff_path = sys.argv[ -4 ]
+    target_datatype = sys.argv[ -3 ]
+    target_path = sys.argv[ -2 ]
+
+# Save the Registered Source Image.
+registered_source_image = IJ.openImage( source_tiff_path )
+if source_datatype == 'tiff':
+    registered_source_image = jython_utils.convert_before_saving_as_tiff( registered_source_image )
+IJ.saveAs( registered_source_image, source_datatype, source_path )
+
+if not mono:
+    # Save the Registered Target Image.
+    registered_target_image = IJ.openImage( target_tiff_path )
+    if target_datatype == 'tiff':
+        registered_target_image = jython_utils.convert_before_saving_as_tiff( registered_target_image )
+    IJ.saveAs( registered_target_image, target_datatype, target_path )

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/imagej2_bunwarpj_compare_elastic.py	Tue Sep 17 17:08:08 2019 -0400
@@ -0,0 +1,65 @@
+#!/usr/bin/env python
+import argparse
+import subprocess
+import tempfile
+import imagej2_base_utils
+
+# Parse Command Line.
+parser = argparse.ArgumentParser()
+parser.add_argument( '--source_image', dest='source_image', help='Source image' )
+parser.add_argument( '--source_image_format', dest='source_image_format', help='Source image format' )
+parser.add_argument( '--target_image', dest='target_image', help='Target image' )
+parser.add_argument( '--target_image_format', dest='target_image_format', help='Target image format' )
+parser.add_argument( '--source_transformation', dest='source_transformation', help='Direct source transformation matrix' )
+parser.add_argument( '--target_transformation', dest='target_transformation', help='Inverse target transformation matrix' )
+parser.add_argument( '--output', dest='output', help='Warping index' )
+
+args = parser.parse_args()
+
+tmp_dir = imagej2_base_utils.get_temp_dir()
+source_image_path = imagej2_base_utils.get_input_image_path( tmp_dir, args.source_image, args.source_image_format )
+target_image_path = imagej2_base_utils.get_input_image_path( tmp_dir, args.target_image, args.target_image_format )
+source_transformation_path = imagej2_base_utils.get_input_image_path( tmp_dir, args.source_transformation, 'txt' )
+target_transformation_path = imagej2_base_utils.get_input_image_path( tmp_dir, args.target_transformation, 'txt' )
+# bUnwarpJ produces several lines of output that we need to discard, so
+# we'll use a temporary output file from which we'll read only the last line.
+tmp_output_path = imagej2_base_utils.get_input_image_path( tmp_dir, args.output, 'txt' )
+
+# Define command response buffers.
+tmp_out = tempfile.NamedTemporaryFile().name
+tmp_stdout = open( tmp_out, 'wb' )
+tmp_err = tempfile.NamedTemporaryFile().name
+tmp_stderr = open( tmp_err, 'wb' )
+
+# Build the command line to calculate the warping index.
+cmd = imagej2_base_utils.get_base_cmd_bunwarpj( None )
+if cmd is None:
+    imagej2_base_utils.stop_err( "bUnwarpJ not found!" )
+cmd += ' -compare_elastic'
+# Target is sent before source.
+cmd += ' %s' % target_image_path
+cmd += ' %s' % source_image_path
+cmd += ' %s' % target_transformation_path
+cmd += ' %s' % source_transformation_path
+cmd += ' > %s' % tmp_output_path
+
+# Calculate the warping index of two elastic transformations using bUnwarpJ.
+proc = subprocess.Popen( args=cmd, stderr=subprocess.PIPE, stdout=subprocess.PIPE, shell=True )
+rc = proc.wait()
+if rc != 0:
+    error_message = imagej2_base_utils.get_stderr_exception( tmp_err, tmp_stderr, tmp_out, tmp_stdout )
+    imagej2_base_utils.stop_err( error_message )
+
+# Example contents of tmp_output_path:
+# ['Target image : ~/tmpKAYF1P.jpg\n',
+#  'Source image : ~/tmpgQX0dy.gif\n',
+#  'Target Transformation file : ~/tmpZJC_4B.txt\n',
+#  'Source Transformation file : ~/tmphsSojl.txt\n',
+#  ' Warping index = 14.87777347388348\n']
+results = open( tmp_output_path, 'r' ).readlines()
+warp_index = results[ -1 ].split( ' ' )[ -1 ]
+outf = open( args.output, 'wb' )
+outf.write( '%s' % warp_index )
+outf.close()
+
+imagej2_base_utils.cleanup_before_exit( tmp_dir )

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/imagej2_bunwarpj_compare_elastic_raw.py	Tue Sep 17 17:08:08 2019 -0400
@@ -0,0 +1,64 @@
+#!/usr/bin/env python
+import argparse
+import subprocess
+import tempfile
+import imagej2_base_utils
+
+# Parse Command Line.
+parser = argparse.ArgumentParser()
+parser.add_argument( '--source_image', dest='source_image', help='Source image' )
+parser.add_argument( '--source_image_format', dest='source_image_format', help='Source image format' )
+parser.add_argument( '--target_image', dest='target_image', help='Target image' )
+parser.add_argument( '--target_image_format', dest='target_image_format', help='Target image format' )
+parser.add_argument( '--target_elastic_transformation', dest='target_elastic_transformation', help='Target elastic transformation matrix' )
+parser.add_argument( '--source_raw_transformation', dest='source_raw_transformation', help='Source raw transformation matrix' )
+parser.add_argument( '--output', dest='output', help='Warping index' )
+
+args = parser.parse_args()
+
+tmp_dir = imagej2_base_utils.get_temp_dir()
+source_image_path = imagej2_base_utils.get_input_image_path( tmp_dir, args.source_image, args.source_image_format )
+target_image_path = imagej2_base_utils.get_input_image_path( tmp_dir, args.target_image, args.target_image_format )
+target_elastic_transformation_path = imagej2_base_utils.get_input_image_path( tmp_dir, args.target_elastic_transformation, 'txt' )
+source_raw_transformation_path = imagej2_base_utils.get_input_image_path( tmp_dir, args.source_raw_transformation, 'txt' )
+# bUnwarpJ produces several lines of output that we need to discard, so
+# we'll use a temporary output file from which we'll read only the last line.
+tmp_output_path = imagej2_base_utils.get_input_image_path( tmp_dir, args.output, 'txt' )
+
+# Define command response buffers.
+tmp_out = tempfile.NamedTemporaryFile().name
+tmp_stdout = open( tmp_out, 'wb' )
+tmp_err = tempfile.NamedTemporaryFile().name
+tmp_stderr = open( tmp_err, 'wb' )
+
+# Build the command line to calculate the warping index.
+cmd = imagej2_base_utils.get_base_cmd_bunwarpj( None )
+if cmd is None:
+    imagej2_base_utils.stop_err( "bUnwarpJ not found!" )
+cmd += ' -compare_elastic_raw'
+cmd += ' %s' % target_image_path
+cmd += ' %s' % source_image_path
+cmd += ' %s' % target_elastic_transformation_path
+cmd += ' %s' % source_raw_transformation_path
+cmd += ' > %s' % tmp_output_path
+
+# Calculate the warping index of elastic and raw transformations using bUnwarpJ.
+proc = subprocess.Popen( args=cmd, stderr=subprocess.PIPE, stdout=subprocess.PIPE, shell=True )
+rc = proc.wait()
+if rc != 0:
+    error_message = imagej2_base_utils.get_stderr_exception( tmp_err, tmp_stderr, tmp_out, tmp_stdout )
+    imagej2_base_utils.stop_err( error_message )
+
+# Example contents of tmp_output_path:
+# ['Target image : ~/tmpHdt9Cs.jpg\n',
+#  'Source image : ~/tmpu6kyfc.gif\n',
+#  'Elastic Transformation file   : ~/tmp4vZurG.txt\n',
+#  'Raw Transformation file : ~/tmp2PNQcT.txt\n',
+#  ' Warping index = 25.007467512204983\n']
+results = open( tmp_output_path, 'r' ).readlines()
+warp_index = results[ -1 ].split( ' ' )[ -1 ]
+outf = open( args.output, 'wb' )
+outf.write( '%s' % warp_index )
+outf.close()
+
+imagej2_base_utils.cleanup_before_exit( tmp_dir )

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/imagej2_bunwarpj_compare_raw.py	Tue Sep 17 17:08:08 2019 -0400
@@ -0,0 +1,64 @@
+#!/usr/bin/env python
+import argparse
+import subprocess
+import tempfile
+import imagej2_base_utils
+
+# Parse Command Line.
+parser = argparse.ArgumentParser()
+parser.add_argument( '--source_image', dest='source_image', help='Source image' )
+parser.add_argument( '--source_image_format', dest='source_image_format', help='Source image format' )
+parser.add_argument( '--target_image', dest='target_image', help='Target image' )
+parser.add_argument( '--target_image_format', dest='target_image_format', help='Target image format' )
+parser.add_argument( '--target_raw_transformation', dest='target_raw_transformation', help='First raw transformation matrix' )
+parser.add_argument( '--source_raw_transformation', dest='source_raw_transformation', help='Second raw transformation matrix' )
+parser.add_argument( '--output', dest='output', help='Warping index' )
+
+args = parser.parse_args()
+
+tmp_dir = imagej2_base_utils.get_temp_dir()
+source_image_path = imagej2_base_utils.get_input_image_path( tmp_dir, args.source_image, args.source_image_format )
+target_image_path = imagej2_base_utils.get_input_image_path( tmp_dir, args.target_image, args.target_image_format )
+target_raw_transformation_path = imagej2_base_utils.get_input_image_path( tmp_dir, args.target_raw_transformation, 'txt' )
+source_raw_transformation_path = imagej2_base_utils.get_input_image_path( tmp_dir, args.source_raw_transformation, 'txt' )
+# bUnwarpJ produces several lines of output that we need to discard, so
+# we'll use a temporary output file from which we'll read only the last line.
+tmp_output_path = imagej2_base_utils.get_input_image_path( tmp_dir, args.output, 'txt' )
+
+# Define command response buffers.
+tmp_out = tempfile.NamedTemporaryFile().name
+tmp_stdout = open( tmp_out, 'wb' )
+tmp_err = tempfile.NamedTemporaryFile().name
+tmp_stderr = open( tmp_err, 'wb' )
+
+# Build the command line to calculate the warping index.
+cmd = imagej2_base_utils.get_base_cmd_bunwarpj( None )
+if cmd is None:
+    imagej2_base_utils.stop_err( "bUnwarpJ not found!" )
+cmd += ' -compare_raw'
+cmd += ' %s' % target_image_path
+cmd += ' %s' % source_image_path
+cmd += ' %s' % target_raw_transformation_path
+cmd += ' %s' % source_raw_transformation_path
+cmd += ' > %s' % tmp_output_path
+
+# Calculate the warping index of two raw transformations using bUnwarpJ.
+proc = subprocess.Popen( args=cmd, stderr=subprocess.PIPE, stdout=subprocess.PIPE, shell=True )
+rc = proc.wait()
+if rc != 0:
+    error_message = imagej2_base_utils.get_stderr_exception( tmp_err, tmp_stderr, tmp_out, tmp_stdout )
+    imagej2_base_utils.stop_err( error_message )
+
+# Example contents of tmp_output_path:
+# ['Target image : ~/tmp5WmDku.jpg\n',
+#  'Source image : ~/tmps74U40.gif\n',
+#  'Target Transformation file : ~/tmpXofC1x.txt\n',
+#  'Source Transformation file : ~/tmpFqNYe4.txt\n',
+#  ' Warping index = 24.111209027033937\n']
+results = open( tmp_output_path, 'r' ).readlines()
+warp_index = results[ -1 ].split( ' ' )[ -1 ]
+outf = open( args.output, 'wb' )
+outf.write( '%s' % warp_index )
+outf.close()
+
+imagej2_base_utils.cleanup_before_exit( tmp_dir )

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/imagej2_bunwarpj_compose_elastic.py	Tue Sep 17 17:08:08 2019 -0400
@@ -0,0 +1,50 @@
+#!/usr/bin/env python
+import argparse
+import subprocess
+import tempfile
+import imagej2_base_utils
+
+# Parse Command Line.
+parser = argparse.ArgumentParser()
+parser.add_argument( '--source_image', dest='source_image', help='Source image' )
+parser.add_argument( '--source_image_format', dest='source_image_format', help='Source image format' )
+parser.add_argument( '--target_image', dest='target_image', help='Target image' )
+parser.add_argument( '--target_image_format', dest='target_image_format', help='Target image format' )
+parser.add_argument( '--source_elastic_transformation', dest='source_elastic_transformation', help='Direct source transformation matrix' )
+parser.add_argument( '--target_elastic_transformation', dest='target_elastic_transformation', help='Inverse target transformation matrix' )
+parser.add_argument( '--output', dest='output', help='Warping index' )
+
+args = parser.parse_args()
+
+tmp_dir = imagej2_base_utils.get_temp_dir()
+source_image_path = imagej2_base_utils.get_input_image_path( tmp_dir, args.source_image, args.source_image_format )
+target_image_path = imagej2_base_utils.get_input_image_path( tmp_dir, args.target_image, args.target_image_format )
+source_elastic_transformation_path = imagej2_base_utils.get_input_image_path( tmp_dir, args.source_elastic_transformation, 'txt' )
+target_elastic_transformation_path = imagej2_base_utils.get_input_image_path( tmp_dir, args.target_elastic_transformation, 'txt' )
+
+# Define command response buffers.
+tmp_out = tempfile.NamedTemporaryFile().name
+tmp_stdout = open( tmp_out, 'wb' )
+tmp_err = tempfile.NamedTemporaryFile().name
+tmp_stderr = open( tmp_err, 'wb' )
+
+# Build the command line to compose the transformations.
+cmd = imagej2_base_utils.get_base_cmd_bunwarpj( None )
+if cmd is None:
+    imagej2_base_utils.stop_err( "bUnwarpJ not found!" )
+cmd += ' -compose_elastic'
+# Target is sent before source.
+cmd += ' %s' % target_image_path
+cmd += ' %s' % source_image_path
+cmd += ' %s' % target_elastic_transformation_path
+cmd += ' %s' % source_elastic_transformation_path
+cmd += ' %s' % args.output
+
+# Compose the two elastic transformations into a raw transformation using bUnwarpJ.
+proc = subprocess.Popen( args=cmd, stderr=subprocess.PIPE, stdout=subprocess.PIPE, shell=True )
+rc = proc.wait()
+if rc != 0:
+    error_message = imagej2_base_utils.get_stderr_exception( tmp_err, tmp_stderr, tmp_out, tmp_stdout )
+    imagej2_base_utils.stop_err( error_message )
+
+imagej2_base_utils.cleanup_before_exit( tmp_dir )

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/imagej2_bunwarpj_compose_raw.py	Tue Sep 17 17:08:08 2019 -0400
@@ -0,0 +1,50 @@
+#!/usr/bin/env python
+import argparse
+import subprocess
+import tempfile
+import imagej2_base_utils
+
+# Parse Command Line.
+parser = argparse.ArgumentParser()
+parser.add_argument( '--source_image', dest='source_image', help='Source image' )
+parser.add_argument( '--source_image_format', dest='source_image_format', help='Source image format' )
+parser.add_argument( '--target_image', dest='target_image', help='Target image' )
+parser.add_argument( '--target_image_format', dest='target_image_format', help='Target image format' )
+parser.add_argument( '--source_raw_transformation', dest='source_raw_transformation', help='Direct source transformation matrix' )
+parser.add_argument( '--target_raw_transformation', dest='target_raw_transformation', help='Inverse target transformation matrix' )
+parser.add_argument( '--output', dest='output', help='Warping index' )
+
+args = parser.parse_args()
+
+tmp_dir = imagej2_base_utils.get_temp_dir()
+source_image_path = imagej2_base_utils.get_input_image_path( tmp_dir, args.source_image, args.source_image_format )
+target_image_path = imagej2_base_utils.get_input_image_path( tmp_dir, args.target_image, args.target_image_format )
+source_raw_transformation_path = imagej2_base_utils.get_input_image_path( tmp_dir, args.source_raw_transformation, 'txt' )
+target_raw_transformation_path = imagej2_base_utils.get_input_image_path( tmp_dir, args.target_raw_transformation, 'txt' )
+
+# Define command response buffers.
+tmp_out = tempfile.NamedTemporaryFile().name
+tmp_stdout = open( tmp_out, 'wb' )
+tmp_err = tempfile.NamedTemporaryFile().name
+tmp_stderr = open( tmp_err, 'wb' )
+
+# Build the command line to compose the two raw transformations.
+cmd = imagej2_base_utils.get_base_cmd_bunwarpj( None )
+if cmd is None:
+    imagej2_base_utils.stop_err( "bUnwarpJ not found!" )
+cmd += ' -compose_raw'
+# Target is sent before source.
+cmd += ' %s' % target_image_path
+cmd += ' %s' % source_image_path
+cmd += ' %s' % target_raw_transformation_path
+cmd += ' %s' % source_raw_transformation_path
+cmd += ' %s' % args.output
+
+# Compose the two raw transformations into another raw transformation using bUnwarpJ.
+proc = subprocess.Popen( args=cmd, stderr=subprocess.PIPE, stdout=subprocess.PIPE, shell=True )
+rc = proc.wait()
+if rc != 0:
+    error_message = imagej2_base_utils.get_stderr_exception( tmp_err, tmp_stderr, tmp_out, tmp_stdout )
+    imagej2_base_utils.stop_err( error_message )
+
+imagej2_base_utils.cleanup_before_exit( tmp_dir )

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/imagej2_bunwarpj_compose_raw_elastic.py	Tue Sep 17 17:08:08 2019 -0400
@@ -0,0 +1,50 @@
+#!/usr/bin/env python
+import argparse
+import subprocess
+import tempfile
+import imagej2_base_utils
+
+# Parse Command Line.
+parser = argparse.ArgumentParser()
+parser.add_argument( '--source_image', dest='source_image', help='Source image' )
+parser.add_argument( '--source_image_format', dest='source_image_format', help='Source image format' )
+parser.add_argument( '--target_image', dest='target_image', help='Target image' )
+parser.add_argument( '--target_image_format', dest='target_image_format', help='Target image format' )
+parser.add_argument( '--source_elastic_transformation', dest='source_elastic_transformation', help='Direct source transformation matrix' )
+parser.add_argument( '--target_raw_transformation', dest='target_raw_transformation', help='Inverse target transformation matrix' )
+parser.add_argument( '--output', dest='output', help='Warping index' )
+
+args = parser.parse_args()
+
+tmp_dir = imagej2_base_utils.get_temp_dir()
+source_image_path = imagej2_base_utils.get_input_image_path( tmp_dir, args.source_image, args.source_image_format )
+target_image_path = imagej2_base_utils.get_input_image_path( tmp_dir, args.target_image, args.target_image_format )
+source_elastic_transformation_path = imagej2_base_utils.get_input_image_path( tmp_dir, args.source_elastic_transformation, 'txt' )
+target_raw_transformation_path = imagej2_base_utils.get_input_image_path( tmp_dir, args.target_raw_transformation, 'txt' )
+
+# Define command response buffers.
+tmp_out = tempfile.NamedTemporaryFile().name
+tmp_stdout = open( tmp_out, 'wb' )
+tmp_err = tempfile.NamedTemporaryFile().name
+tmp_stderr = open( tmp_err, 'wb' )
+
+# Build the command line to compose the raw and elastic transformations.
+cmd = imagej2_base_utils.get_base_cmd_bunwarpj( None )
+if cmd is None:
+    imagej2_base_utils.stop_err( "bUnwarpJ not found!" )
+cmd += ' -compose_raw_elastic'
+# Target is sent before source.
+cmd += ' %s' % target_image_path
+cmd += ' %s' % source_image_path
+cmd += ' %s' % target_raw_transformation_path
+cmd += ' %s' % source_elastic_transformation_path
+cmd += ' %s' % args.output
+
+# Compose the raw and elastic transformations into another raw transformation using bUnwarpJ.
+proc = subprocess.Popen( args=cmd, stderr=subprocess.PIPE, stdout=subprocess.PIPE, shell=True )
+rc = proc.wait()
+if rc != 0:
+    error_message = imagej2_base_utils.get_stderr_exception( tmp_err, tmp_stderr, tmp_out, tmp_stdout )
+    imagej2_base_utils.stop_err( error_message )
+
+imagej2_base_utils.cleanup_before_exit( tmp_dir )

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/imagej2_bunwarpj_convert_to_raw.py	Tue Sep 17 17:08:08 2019 -0400
@@ -0,0 +1,47 @@
+#!/usr/bin/env python
+import argparse
+import subprocess
+import tempfile
+import imagej2_base_utils
+
+# Parse Command Line.
+parser = argparse.ArgumentParser()
+parser.add_argument( '--source_image', dest='source_image', help='Source image' )
+parser.add_argument( '--source_image_format', dest='source_image_format', help='Source image format' )
+parser.add_argument( '--target_image', dest='target_image', help='Target image' )
+parser.add_argument( '--target_image_format', dest='target_image_format', help='Target image format' )
+parser.add_argument( '--elastic_transformation', dest='elastic_transformation', help='Elastic transformation as saved by bUnwarpJ in elastic format' )
+parser.add_argument( '--raw_transformation', dest='raw_transformation', help='Raw transformation' )
+
+args = parser.parse_args()
+
+tmp_dir = imagej2_base_utils.get_temp_dir()
+source_image_path = imagej2_base_utils.get_input_image_path( tmp_dir, args.source_image, args.source_image_format )
+target_image_path = imagej2_base_utils.get_input_image_path( tmp_dir, args.target_image, args.target_image_format )
+elastic_transformation_path = imagej2_base_utils.get_input_image_path( tmp_dir, args.elastic_transformation, 'txt' )
+
+# Define command response buffers.
+tmp_out = tempfile.NamedTemporaryFile().name
+tmp_stdout = open( tmp_out, 'wb' )
+tmp_err = tempfile.NamedTemporaryFile().name
+tmp_stderr = open( tmp_err, 'wb' )
+
+# Build the command line to convert the B-spline (i.e., elastic) transformation to raw.
+cmd = imagej2_base_utils.get_base_cmd_bunwarpj( None )
+if cmd is None:
+    imagej2_base_utils.stop_err( "bUnwarpJ not found!" )
+cmd += ' -convert_to_raw'
+# Target is sent before source.
+cmd += ' %s' % target_image_path
+cmd += ' %s' % source_image_path
+cmd += ' %s' % elastic_transformation_path
+cmd += ' %s' % args.raw_transformation
+
+# Convert the elastic transformation to raw using bUnwarpJ.
+proc = subprocess.Popen( args=cmd, stderr=tmp_stderr, stdout=tmp_stdout, shell=True )
+rc = proc.wait()
+if rc != 0:
+    error_message = imagej2_base_utils.get_stderr_exception( tmp_err, tmp_stderr, tmp_out, tmp_stdout )
+    imagej2_base_utils.stop_err( error_message )
+
+imagej2_base_utils.cleanup_before_exit( tmp_dir )

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/imagej2_bunwarpj_elastic_transform.py	Tue Sep 17 17:08:08 2019 -0400
@@ -0,0 +1,73 @@
+#!/usr/bin/env python
+import argparse
+import shutil
+import subprocess
+import tempfile
+import imagej2_base_utils
+
+# Parse Command Line.
+parser = argparse.ArgumentParser()
+parser.add_argument( '--source_image', dest='source_image', help='Source image' )
+parser.add_argument( '--source_image_format', dest='source_image_format', help='Source image format' )
+parser.add_argument( '--target_image', dest='target_image', help='Target image' )
+parser.add_argument( '--target_image_format', dest='target_image_format', help='Target image format' )
+parser.add_argument( '--elastic_transformation', dest='elastic_transformation', help='Elastic transformation as saved by bUnwarpJ in elastic format' )
+parser.add_argument( '--source_out', help='Output source image' )
+parser.add_argument( '--source_out_datatype', help='Output registered source image format' )
+parser.add_argument( '--jython_script', dest='jython_script', help='Path to the Jython script' )
+
+args = parser.parse_args()
+
+tmp_dir = imagej2_base_utils.get_temp_dir()
+source_image_path = imagej2_base_utils.get_input_image_path( tmp_dir, args.source_image, args.source_image_format )
+tmp_source_out_tiff_path = imagej2_base_utils.get_temporary_image_path( tmp_dir, 'tiff' )
+tmp_source_out_path = imagej2_base_utils.get_temporary_image_path( tmp_dir, args.source_out_datatype )
+target_image_path = imagej2_base_utils.get_input_image_path( tmp_dir, args.target_image, args.target_image_format )
+elastic_transformation_path = imagej2_base_utils.get_input_image_path( tmp_dir, args.elastic_transformation, 'txt' )
+
+# Define command response buffers.
+tmp_out = tempfile.NamedTemporaryFile().name
+tmp_stdout = open( tmp_out, 'wb' )
+tmp_err = tempfile.NamedTemporaryFile().name
+tmp_stderr = open( tmp_err, 'wb' )
+
+# Build the command line to apply the transformation.
+cmd = imagej2_base_utils.get_base_cmd_bunwarpj( None )
+if cmd is None:
+    imagej2_base_utils.stop_err( "bUnwarpJ not found!" )
+cmd += ' -elastic_transform'
+# Target is sent before source.
+cmd += ' %s' % target_image_path
+cmd += ' %s' % source_image_path
+cmd += ' %s' % elastic_transformation_path
+cmd += ' %s' % tmp_source_out_tiff_path
+
+# Apply the elastic transformation using bUnwarpJ.
+proc = subprocess.Popen( args=cmd, stderr=tmp_stderr, stdout=tmp_stdout, shell=True )
+rc = proc.wait()
+if rc != 0:
+    error_message = imagej2_base_utils.get_stderr_exception( tmp_err, tmp_stderr, tmp_out, tmp_stdout )
+    imagej2_base_utils.stop_err( error_message )
+
+# Convert the registered image to the specified output format.
+tmp_out = tempfile.NamedTemporaryFile().name
+tmp_stdout = open( tmp_out, 'wb' )
+tmp_err = tempfile.NamedTemporaryFile().name
+tmp_stderr = open( tmp_err, 'wb' )
+
+cmd = imagej2_base_utils.get_base_command_imagej2( None, jython_script=args.jython_script )
+if cmd is None:
+    imagej2_base_utils.stop_err( "ImageJ not found!" )
+cmd += ' %s %s %s' % ( tmp_source_out_tiff_path,
+                       args.source_out_datatype,
+                       tmp_source_out_path )
+
+proc = subprocess.Popen( args=cmd, stderr=tmp_stderr, stdout=tmp_stdout, shell=True )
+rc = proc.wait()
+if rc != 0:
+    error_message = imagej2_base_utils.get_stderr_exception( tmp_err, tmp_stderr, tmp_out, tmp_stdout )
+    imagej2_base_utils.stop_err( error_message )
+
+# Save the Registered Source Image to the defined output.
+shutil.move( tmp_source_out_path, args.source_out )
+imagej2_base_utils.cleanup_before_exit( tmp_dir )

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/imagej2_bunwarpj_elastic_transform_jython_script.py	Tue Sep 17 17:08:08 2019 -0400
@@ -0,0 +1,16 @@
+import sys
+import jython_utils
+from ij import IJ
+
+# Fiji Jython interpreter implements Python 2.5 which does not
+# provide support for argparse.
+
+source_tiff_path = sys.argv[ -3 ]
+source_datatype = sys.argv[ -2 ]
+source_path = sys.argv[ -1 ]
+
+# Save the Registered Source Image.
+registered_source_image = IJ.openImage( source_tiff_path )
+if source_datatype == 'tiff':
+    registered_source_image = jython_utils.convert_before_saving_as_tiff( registered_source_image )
+IJ.saveAs( registered_source_image, source_datatype, source_path )

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/imagej2_bunwarpj_raw_transform.py	Tue Sep 17 17:08:08 2019 -0400
@@ -0,0 +1,73 @@
+#!/usr/bin/env python
+import argparse
+import shutil
+import subprocess
+import tempfile
+import imagej2_base_utils
+
+# Parse Command Line.
+parser = argparse.ArgumentParser()
+parser.add_argument( '--source_image', dest='source_image', help='Source image' )
+parser.add_argument( '--source_image_format', dest='source_image_format', help='Source image format' )
+parser.add_argument( '--target_image', dest='target_image', help='Target image' )
+parser.add_argument( '--target_image_format', dest='target_image_format', help='Target image format' )
+parser.add_argument( '--raw_transformation', dest='raw_transformation', help='Raw transformation as saved by bUnwarpJ' )
+parser.add_argument( '--source_out', help='Output source image' )
+parser.add_argument( '--source_out_datatype', help='Output registered source image format' )
+parser.add_argument( '--jython_script', dest='jython_script', help='Path to the Jython script' )
+
+args = parser.parse_args()
+
+tmp_dir = imagej2_base_utils.get_temp_dir()
+source_image_path = imagej2_base_utils.get_input_image_path( tmp_dir, args.source_image, args.source_image_format )
+tmp_source_out_tiff_path = imagej2_base_utils.get_temporary_image_path( tmp_dir, 'tiff' )
+tmp_source_out_path = imagej2_base_utils.get_temporary_image_path( tmp_dir, args.source_out_datatype )
+target_image_path = imagej2_base_utils.get_input_image_path( tmp_dir, args.target_image, args.target_image_format )
+raw_transformation_path = imagej2_base_utils.get_input_image_path( tmp_dir, args.raw_transformation, 'txt' )
+
+# Define command response buffers.
+tmp_out = tempfile.NamedTemporaryFile().name
+tmp_stdout = open( tmp_out, 'wb' )
+tmp_err = tempfile.NamedTemporaryFile().name
+tmp_stderr = open( tmp_err, 'wb' )
+
+# Build the command line to apply the raw transformation.
+cmd = imagej2_base_utils.get_base_cmd_bunwarpj( None )
+if cmd is None:
+    imagej2_base_utils.stop_err( "bUnwarpJ not found!" )
+cmd += ' -raw_transform'
+# Target is sent before source.
+cmd += ' %s' % target_image_path
+cmd += ' %s' % source_image_path
+cmd += ' %s' % raw_transformation_path
+cmd += ' %s' % tmp_source_out_tiff_path
+
+# Apply the raw transformation using bUnwarpJ.
+proc = subprocess.Popen( args=cmd, stderr=tmp_stderr, stdout=tmp_stdout, shell=True )
+rc = proc.wait()
+if rc != 0:
+    error_message = imagej2_base_utils.get_stderr_exception( tmp_err, tmp_stderr, tmp_out, tmp_stdout )
+    imagej2_base_utils.stop_err( error_message )
+
+# Convert the registered image to the specified output format.
+tmp_out = tempfile.NamedTemporaryFile().name
+tmp_stdout = open( tmp_out, 'wb' )
+tmp_err = tempfile.NamedTemporaryFile().name
+tmp_stderr = open( tmp_err, 'wb' )
+
+cmd = imagej2_base_utils.get_base_command_imagej2( None, jython_script=args.jython_script )
+if cmd is None:
+    imagej2_base_utils.stop_err( "ImageJ not found!" )
+cmd += ' %s %s %s' % ( tmp_source_out_tiff_path,
+                       args.source_out_datatype,
+                       tmp_source_out_path )
+
+proc = subprocess.Popen( args=cmd, stderr=tmp_stderr, stdout=tmp_stdout, shell=True )
+rc = proc.wait()
+if rc != 0:
+    error_message = imagej2_base_utils.get_stderr_exception( tmp_err, tmp_stderr, tmp_out, tmp_stdout )
+    imagej2_base_utils.stop_err( error_message )
+
+# Save the Registered Source Image to the defined output.
+shutil.move( tmp_source_out_path, args.source_out )
+imagej2_base_utils.cleanup_before_exit( tmp_dir )

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/imagej2_bunwarpj_raw_transform_jython_script.py	Tue Sep 17 17:08:08 2019 -0400
@@ -0,0 +1,16 @@
+import sys
+import jython_utils
+from ij import IJ
+
+# Fiji Jython interpreter implements Python 2.5 which does not
+# provide support for argparse.
+
+source_tiff_path = sys.argv[ -3 ]
+source_datatype = sys.argv[ -2 ]
+source_path = sys.argv[ -1 ]
+
+# Save the Registered Source Image.
+registered_source_image = IJ.openImage( source_tiff_path )
+if source_datatype == 'tiff':
+    registered_source_image = jython_utils.convert_before_saving_as_tiff( registered_source_image )
+IJ.saveAs( registered_source_image, source_datatype, source_path )

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/imagej2_create_image.py	Tue Sep 17 17:08:08 2019 -0400
@@ -0,0 +1,40 @@
+#!/usr/bin/env python
+import argparse
+import shutil
+import subprocess
+import tempfile
+import imagej2_base_utils
+
+if __name__=="__main__":
+    # Parse Command Line.
+    parser = argparse.ArgumentParser()
+    parser.add_argument( '--width', dest='width', type=int, help='Image width in pixels' )
+    parser.add_argument( '--height', dest='height', type=int, help='Image height in pixels' )
+    parser.add_argument( '--depth', dest='depth', type=int, help='Image depth (specifies the number of stack slices)' )
+    parser.add_argument( '--image_type', dest='image_type', help='Image type' )
+    parser.add_argument( '--image_title', dest='image_title', default='', help='Image title' )
+    parser.add_argument( '--output_datatype', dest='output_datatype', help='Output image format' )
+    parser.add_argument( '--jython_script', dest='jython_script', help='Path to the Jython script' )
+    parser.add_argument( '--out_fname', help='Path to the output file' )
+    args = parser.parse_args()
+
+    tmp_dir = imagej2_base_utils.get_temp_dir()
+    tmp_image_path = imagej2_base_utils.get_temporary_image_path( tmp_dir, args.output_datatype )
+
+    # Define command response buffers.
+    tmp_out = tempfile.NamedTemporaryFile().name
+    tmp_stdout = open( tmp_out, 'wb' )
+    tmp_err = tempfile.NamedTemporaryFile().name
+    tmp_stderr = open( tmp_err, 'wb' )
+    # Build the command line.
+    cmd = imagej2_base_utils.get_base_command_imagej2( None, jython_script=args.jython_script )
+    if cmd is None:
+        imagej2_base_utils.stop_err( "ImageJ not found!" )
+    cmd += ' %s %d %d %d %s %s' % ( args.image_title, args.width, args.height, args.depth, args.image_type, tmp_image_path )
+    proc = subprocess.Popen( args=cmd, stderr=tmp_stderr, stdout=tmp_stdout, shell=True )
+    rc = proc.wait()
+    if rc != 0:
+        error_message = imagej2_base_utils.get_stderr_exception( tmp_err, tmp_stderr, tmp_out, tmp_stdout )
+        imagej2_base_utils.stop_err( error_message )
+    shutil.move( tmp_image_path, args.out_fname )
+    imagej2_base_utils.cleanup_before_exit( tmp_dir )

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/imagej2_create_image_jython_script.py	Tue Sep 17 17:08:08 2019 -0400
@@ -0,0 +1,14 @@
+import sys
+from ij import IJ
+
+# Fiji Jython interpreter implements Python 2.5 which does not
+# provide support for argparse.
+title = sys.argv[ -6 ]
+width = int( sys.argv[ -5 ] )
+height = int( sys.argv[ -4 ] )
+depth = int( sys.argv[ -3 ] )
+type = sys.argv[ -2 ].replace( '_', ' ' )
+tmp_image_path = sys.argv[ -1 ]
+
+imp = IJ.newImage( title, type, width, height, depth )
+IJ.save( imp, "%s" % tmp_image_path )

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/imagej2_enhance_contrast.py	Tue Sep 17 17:08:08 2019 -0400
@@ -0,0 +1,63 @@
+#!/usr/bin/env python
+import argparse
+import os
+import shutil
+import subprocess
+import tempfile
+import imagej2_base_utils
+
+parser = argparse.ArgumentParser()
+parser.add_argument( '--input', dest='input', help='Path to the input file' )
+parser.add_argument( '--input_datatype', dest='input_datatype', help='Datatype of the input image' )
+parser.add_argument( '--equalize_histogram', dest='equalize_histogram', help='Equalize_histogram' )
+parser.add_argument( '--saturated_pixels', dest='saturated_pixels', type=float, default=None, help='Saturated pixel pct' )
+parser.add_argument( '--normalize', dest='normalize', help='Normalize' )
+parser.add_argument( '--jython_script', dest='jython_script', help='Path to the Jython script' )
+parser.add_argument( '--output', dest='output', help='Path to the output file' )
+parser.add_argument( '--output_datatype', dest='output_datatype', help='Datatype of the output image' )
+args = parser.parse_args()
+
+tmp_dir = imagej2_base_utils.get_temp_dir()
+# ImageJ expects valid image file extensions, so the Galaxy .dat extension does not
+# work for some features.  The following creates a symlink with an appropriate file
+# extension that points to the Galaxy dataset.  This symlink is used by ImageJ.
+tmp_input_path = imagej2_base_utils.get_input_image_path( tmp_dir, args.input, args.input_datatype )
+tmp_output_path = imagej2_base_utils.get_temporary_image_path( tmp_dir, args.output_datatype )
+
+# Define command response buffers.
+tmp_out = tempfile.NamedTemporaryFile().name
+tmp_stdout = open( tmp_out, 'wb' )
+tmp_err = tempfile.NamedTemporaryFile().name
+tmp_stderr = open( tmp_err, 'wb' )
+# Java writes a lot of stuff to stderr, so we'll specify a file for handling actual errors.
+error_log = tempfile.NamedTemporaryFile( delete=False ).name
+
+# Build the command line.
+cmd = imagej2_base_utils.get_base_command_imagej2( None, jython_script=args.jython_script )
+if cmd is None:
+    imagej2_base_utils.stop_err( "ImageJ not found!" )
+cmd += ' %s' % error_log
+cmd += ' %s' % tmp_input_path
+cmd += ' %s' % args.equalize_histogram
+cmd += imagej2_base_utils.handle_none_type( args.saturated_pixels )
+cmd += ' %s' % args.normalize
+cmd += ' %s' % tmp_output_path
+cmd += ' %s' % args.output_datatype
+
+# Run the command.
+proc = subprocess.Popen( args=cmd, stderr=tmp_stderr, stdout=tmp_stdout, shell=True )
+rc = proc.wait()
+
+# Handle execution errors.
+if rc != 0:
+    error_message = imagej2_base_utils.get_stderr_exception( tmp_err, tmp_stderr, tmp_out, tmp_stdout )
+    imagej2_base_utils.stop_err( error_message )
+
+# Handle processing errors.
+if os.path.getsize( error_log ) > 0:
+    error_message = open( error_log, 'r' ).read()
+    imagej2_base_utils.stop_err( error_message )
+
+# Save the output image.
+shutil.move( tmp_output_path, args.output )
+imagej2_base_utils.cleanup_before_exit( tmp_dir )

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/imagej2_enhance_contrast_jython_script.py	Tue Sep 17 17:08:08 2019 -0400
@@ -0,0 +1,42 @@
+import jython_utils
+import sys
+from ij import IJ
+
+# Fiji Jython interpreter implements Python 2.5 which does not
+# provide support for argparse.
+error_log = sys.argv[ -7 ]
+input = sys.argv[ -6 ]
+equalize_histogram = jython_utils.asbool( sys.argv[ -5 ] )
+saturated_pixels = sys.argv[ -4 ]
+normalize = jython_utils.asbool( sys.argv[ -3 ] )
+tmp_output_path = sys.argv[ -2 ]
+output_datatype = sys.argv[ -1 ]
+
+# Open the input image file.
+input_image_plus = IJ.openImage( input )
+
+# Create a copy of the image.
+input_image_plus_copy = input_image_plus.duplicate()
+image_processor_copy = input_image_plus_copy.getProcessor()
+bit_depth = image_processor_copy.getBitDepth()
+
+# Set the options
+options = []
+# If equalize_histogram, saturated_pixels and normalize are ignored.
+if equalize_histogram:
+    options.append( 'equalize' )
+else:
+    if saturated_pixels not in [ None, 'None' ]:
+        # Fiji allows only a single decimal place for this value.
+        options.append( 'saturated=%.3f' % float( saturated_pixels ) )
+    # Normalization of RGB images is not supported.
+    if bit_depth != 24 and normalize:
+        options.append( 'normalize' )
+try:
+    # Run the command.
+    options = "%s" % ' '.join( options )
+    IJ.run( input_image_plus_copy, "Enhance Contrast...", options )
+    # Save the ImagePlus object as a new image.
+    IJ.saveAs( input_image_plus_copy, output_datatype, tmp_output_path )
+except Exception, e:
+    jython_utils.handle_error( error_log, str( e ) )

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/imagej2_find_edges.py	Tue Sep 17 17:08:08 2019 -0400
@@ -0,0 +1,57 @@
+#!/usr/bin/env python
+import argparse
+import os
+import shutil
+import subprocess
+import tempfile
+import imagej2_base_utils
+
+parser = argparse.ArgumentParser()
+parser.add_argument( '--input', dest='input', help='Path to the input file' )
+parser.add_argument( '--input_datatype', dest='input_datatype', help='Datatype of the input image' )
+parser.add_argument( '--jython_script', dest='jython_script', help='Path to the Jython script' )
+parser.add_argument( '--output', dest='output', help='Path to the output file' )
+parser.add_argument( '--output_datatype', dest='output_datatype', help='Datatype of the output image' )
+args = parser.parse_args()
+
+tmp_dir = imagej2_base_utils.get_temp_dir()
+# ImageJ expects valid image file extensions, so the Galaxy .dat extension does not
+# work for some features.  The following creates a symlink with an appropriate file
+# extension that points to the Galaxy dataset.  This symlink is used by ImageJ.
+tmp_input_path = imagej2_base_utils.get_input_image_path( tmp_dir, args.input, args.input_datatype )
+tmp_output_path = imagej2_base_utils.get_temporary_image_path( tmp_dir, args.output_datatype )
+
+# Define command response buffers.
+tmp_out = tempfile.NamedTemporaryFile().name
+tmp_stdout = open( tmp_out, 'wb' )
+tmp_err = tempfile.NamedTemporaryFile().name
+tmp_stderr = open( tmp_err, 'wb' )
+# Java writes a lot of stuff to stderr, so we'll specify a file for handling actual errors.
+error_log = tempfile.NamedTemporaryFile( delete=False ).name
+
+# Build the command line.
+cmd = imagej2_base_utils.get_base_command_imagej2( None, jython_script=args.jython_script )
+if cmd is None:
+    imagej2_base_utils.stop_err( "ImageJ not found!" )
+cmd += ' %s' % error_log
+cmd += ' %s' % tmp_input_path
+cmd += ' %s' % tmp_output_path
+cmd += ' %s' % args.output_datatype
+
+# Run the command.
+proc = subprocess.Popen( args=cmd, stderr=tmp_stderr, stdout=tmp_stdout, shell=True )
+rc = proc.wait()
+
+# Handle execution errors.
+if rc != 0:
+    error_message = imagej2_base_utils.get_stderr_exception( tmp_err, tmp_stderr, tmp_out, tmp_stdout )
+    imagej2_base_utils.stop_err( error_message )
+
+# Handle processing errors.
+if os.path.getsize( error_log ) > 0:
+    error_message = open( error_log, 'r' ).read()
+    imagej2_base_utils.stop_err( error_message )
+
+# Save the output image.
+shutil.move( tmp_output_path, args.output )
+imagej2_base_utils.cleanup_before_exit( tmp_dir )

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/imagej2_find_edges_jython_script.py	Tue Sep 17 17:08:08 2019 -0400
@@ -0,0 +1,25 @@
+import jython_utils
+import sys
+from ij import IJ
+
+# Fiji Jython interpreter implements Python 2.5 which does not
+# provide support for argparse.
+error_log = sys.argv[ -4 ]
+input = sys.argv[ -3 ]
+tmp_output_path = sys.argv[ -2 ]
+output_datatype = sys.argv[ -1 ]
+
+# Open the input image file.
+input_image_plus = IJ.openImage( input )
+
+# Create a copy of the image.
+input_image_plus_copy = input_image_plus.duplicate()
+image_processor_copy = input_image_plus_copy.getProcessor()
+
+try:
+    # Run the command.
+    IJ.run( input_image_plus_copy, "Find Edges", "" )
+    # Save the ImagePlus object as a new image.
+    IJ.saveAs( input_image_plus_copy, output_datatype, tmp_output_path )
+except Exception, e:
+    jython_utils.handle_error( error_log, str( e ) )

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/imagej2_find_maxima.py	Tue Sep 17 17:08:08 2019 -0400
@@ -0,0 +1,69 @@
+#!/usr/bin/env python
+import argparse
+import os
+import shutil
+import subprocess
+import tempfile
+import imagej2_base_utils
+
+parser = argparse.ArgumentParser()
+parser.add_argument( '--input', dest='input', help='Path to the input file' )
+parser.add_argument( '--input_datatype', dest='input_datatype', help='Datatype of the input image' )
+parser.add_argument( '--scale_when_converting', dest='scale_when_converting', help='Scale when converting RGB image' )
+parser.add_argument( '--weighted_rgb_conversions', dest='weighted_rgb_conversions', help='Weighted RGB conversions for RGB image' )
+parser.add_argument( '--noise_tolerance', dest='noise_tolerance', type=int, help='Noise tolerance' )
+parser.add_argument( '--output_type', dest='output_type', help='Output type' )
+parser.add_argument( '--exclude_edge_maxima', dest='exclude_edge_maxima', help='Exclude edge maxima' )
+parser.add_argument( '--light_background', dest='light_background', help='Light background' )
+parser.add_argument( '--jython_script', dest='jython_script', help='Path to the Jython script' )
+parser.add_argument( '--output', dest='output', help='Path to the output file' )
+parser.add_argument( '--output_datatype', dest='output_datatype', help='Datatype of the output image' )
+args = parser.parse_args()
+
+tmp_dir = imagej2_base_utils.get_temp_dir()
+# ImageJ expects valid image file extensions, so the Galaxy .dat extension does not
+# work for some features.  The following creates a symlink with an appropriate file
+# extension that points to the Galaxy dataset.  This symlink is used by ImageJ.
+tmp_input_path = imagej2_base_utils.get_input_image_path( tmp_dir, args.input, args.input_datatype )
+tmp_output_path = imagej2_base_utils.get_temporary_image_path( tmp_dir, args.output_datatype )
+
+# Define command response buffers.
+tmp_out = tempfile.NamedTemporaryFile().name
+tmp_stdout = open( tmp_out, 'wb' )
+tmp_err = tempfile.NamedTemporaryFile().name
+tmp_stderr = open( tmp_err, 'wb' )
+# Java writes a lot of stuff to stderr, so we'll specify a file for handling actual errors.
+error_log = tempfile.NamedTemporaryFile( delete=False ).name
+
+# Build the command line.
+cmd = imagej2_base_utils.get_base_command_imagej2( None, jython_script=args.jython_script )
+if cmd is None:
+    imagej2_base_utils.stop_err( "ImageJ not found!" )
+cmd += ' %s' % error_log
+cmd += ' %s' % tmp_input_path
+cmd += ' %s' % args.scale_when_converting
+cmd += ' %s' % args.weighted_rgb_conversions
+cmd += ' %d' % args.noise_tolerance
+cmd += ' %s' % args.output_type
+cmd += ' %s' % args.exclude_edge_maxima
+cmd += ' %s' % args.light_background
+cmd += ' %s' % tmp_output_path
+cmd += ' %s' % args.output_datatype
+
+# Run the command.
+proc = subprocess.Popen( args=cmd, stderr=tmp_stderr, stdout=tmp_stdout, shell=True )
+rc = proc.wait()
+
+# Handle execution errors.
+if rc != 0:
+    error_message = imagej2_base_utils.get_stderr_exception( tmp_err, tmp_stderr, tmp_out, tmp_stdout )
+    imagej2_base_utils.stop_err( error_message )
+
+# Handle processing errors.
+if os.path.getsize( error_log ) > 0:
+    error_message = open( error_log, 'r' ).read()
+    imagej2_base_utils.stop_err( error_message )
+
+# Save the output image.
+shutil.move( tmp_output_path, args.output )
+imagej2_base_utils.cleanup_before_exit( tmp_dir )

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/imagej2_find_maxima_jython_script.py	Tue Sep 17 17:08:08 2019 -0400
@@ -0,0 +1,94 @@
+import sys
+import jython_utils
+from ij import ImagePlus, IJ
+from ij.plugin.filter import Analyzer, MaximumFinder
+from ij.process import ImageProcessor
+from jarray import array
+
+# Fiji Jython interpreter implements Python 2.5 which does not
+# provide support for argparse.
+error_log = sys.argv[ -10 ]
+input = sys.argv[ -9 ]
+scale_when_converting = jython_utils.asbool( sys.argv[ -8 ] )
+weighted_rgb_conversions = jython_utils.asbool( sys.argv[ -7 ] )
+noise_tolerance = int( sys.argv[ -6 ] )
+output_type = sys.argv[ -5 ]
+exclude_edge_maxima = jython_utils.asbool( sys.argv[ -4 ] )
+light_background = jython_utils.asbool( sys.argv[ -3 ] )
+tmp_output_path = sys.argv[ -2 ]
+output_datatype = sys.argv[ -1 ]
+
+# Open the input image file.
+input_image_plus = IJ.openImage( input )
+
+# Create a copy of the image.
+input_image_plus_copy = input_image_plus.duplicate()
+image_processor_copy = input_image_plus_copy.getProcessor()
+bit_depth = image_processor_copy.getBitDepth()
+analyzer = Analyzer( input_image_plus_copy )
+
+try:
+    # Set the conversion options.
+    options = []
+    # The following 2 options are applicable only to RGB images.
+    if bit_depth == 24:
+        if scale_when_converting:
+            option.append( "scale" )
+        if weighted_rgb_conversions:
+            options.append( "weighted" )
+    # Perform conversion - must happen even if no options are set.
+    IJ.run( input_image_plus_copy, "Conversions...", "%s" % " ".join( options ) )
+    if output_type in [ 'List', 'Count' ]:
+        # W're  generating a tabular file for the output.
+        # Set the Find Maxima options.
+        options = [ 'noise=%d' % noise_tolerance ]
+        if output_type.find( '_' ) > 0:
+            output_type_str = 'output=[%s]' % output_type.replace( '_', ' ' )
+        else:
+            output_type_str = 'output=%s' % output_type
+        options.append( output_type_str )
+        if exclude_edge_maxima:
+            options.append( 'exclude' )
+        if light_background:
+            options.append( 'light' )
+        # Run the command.
+        IJ.run( input_image_plus_copy, "Find Maxima...", "%s" % " ".join( options ) )
+        results_table = analyzer.getResultsTable()
+        results_table.saveAs( tmp_output_path )
+    else:
+        # Find the maxima of an image (does not find minima).
+        # LIMITATIONS: With output_type=Segmented_Particles
+        # (watershed segmentation), some segmentation lines
+        # may be improperly placed if local maxima are suppressed
+        # by the tolerance.
+        mf = MaximumFinder()
+        if output_type == 'Single_Points':
+            output_type_param = mf.SINGLE_POINTS
+        elif output_type == 'Maxima_Within_Tolerance':
+            output_type_param = mf.IN_TOLERANCE
+        elif output_type == 'Segmented_Particles':
+            output_type_param = mf.SEGMENTED
+        elif output_type == 'List':
+            output_type_param = mf.LIST
+        elif output_type == 'Count':
+            output_type_param = mf.COUNT
+        # Get a new byteProcessor with a normal (uninverted) LUT where
+        # the marked points are set to 255 (Background 0). Pixels outside
+        # of the roi of the input image_processor_copy are not set. No
+        # output image is created for output types POINT_SELECTION, LIST
+        # and COUNT.  In these cases findMaxima returns null.
+        byte_processor = mf.findMaxima( image_processor_copy,
+                                        noise_tolerance,
+                                        ImageProcessor.NO_THRESHOLD,
+                                        output_type_param,
+                                        exclude_edge_maxima,
+                                        False )
+        # Invert the image or ROI.
+        byte_processor.invert()
+        if output_type == 'Segmented_Particles' and not light_background:
+            # Invert the values in this image's LUT (indexed color model).
+            byte_processor.invertLut()
+        image_plus = ImagePlus( "output", byte_processor )
+        IJ.saveAs( image_plus, output_datatype, tmp_output_path )
+except Exception, e:
+    jython_utils.handle_error( error_log, str( e ) )

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/imagej2_macros.xml	Tue Sep 17 17:08:08 2019 -0400
@@ -0,0 +1,106 @@
+<?xml version='1.0' encoding='UTF-8'?>
+<macros>
+    <token name="@WRAPPER_VERSION@">3.0</token>
+    <xml name="fiji_requirements">
+        <requirements>
+            <requirement type="package" version="20170530">fiji</requirement>
+        </requirements>
+    </xml>
+    <xml name="stdio">
+        <stdio>
+            <exit_code range="1:"/>
+            <exit_code range=":-1"/>
+            <regex match="Error:"/>
+            <regex match="Exception:"/>
+        </stdio>
+    </xml>
+    <xml name="image_type">
+        <param name="image_type" type="select" label="Image type">
+            <option value="8-bit_white" selected="True">8-bit white</option>
+            <option value="8-bit_black">8-bit black</option>
+            <option value="8-bit_random">8-bit random</option>
+            <option value="8-bit_ramp">8-bit ramp</option>
+            <option value="16-bit_white">16-bit white</option>
+            <option value="16-bit_black">16-bit black</option>
+            <option value="16-bit_random">16-bit random</option>
+            <option value="16-bit_ramp">16-bit ramp</option>
+            <option value="32-bit_white">32-bit white</option>
+            <option value="32-bit_black">32-bit black</option>
+            <option value="32-bit_random">32-bit random</option>
+            <option value="32-bit_ramp">32-bit ramp</option>
+            <option value="RGB_white">RGB white</option>
+            <option value="RGB_black">RGB black</option>
+            <option value="RGB_random">RGB random</option>
+            <option value="RGB_ramp">RGB ramp</option>
+        </param>
+    </xml>
+    <xml name="make_binary_params">
+        <param name="iterations" type="integer" value="1" min="1" max="100" label="Iterations" help="The number of times (1-100) erosion, dilation, opening, and closing are performed."/>
+        <param name="count" type="integer" value="1" min="1" max="8" label="Count" help="The number of adjacent background pixels necessary (1-8) for erosion or dilation."/>
+        <param name="black_background" type="select" label="Black background" help="If Yes, the background is black and the foreground is white (no implies the opposite).">
+            <option value="no" selected="True">No</option>
+            <option value="yes">Yes</option>
+        </param>
+        <param name="pad_edges_when_eroding" type="select" label="Pad edges when eroding" help="If Yes, eroding does not erode from the edges of the image.">
+            <option value="no" selected="True">No</option>
+            <option value="yes">Yes</option>
+        </param>
+    </xml>
+    <xml name="black_background_param">
+        <param name="black_background" type="select" label="Black background" help="If Yes, the background is black and the foreground is white (no implies the opposite).">
+            <option value="no" selected="True">No</option>
+            <option value="yes">Yes</option>
+        </param>
+    </xml>
+    <token name="@make_binary_args@">
+        --iterations $iterations
+        --count $count
+        --black_background $black_background
+        --pad_edges_when_eroding $pad_edges_when_eroding
+    </token>
+    <token name="@requires_binary_input@">
+.. class:: warningmark
+
+This tool works on binary images, so other image types will automatically be converted to binary
+before they are analyzed.  This step is performed using the ImageJ2 **Make Binary** command with
+the following settings: **Iterations:** 1, **Count:** 1, **Pad edges when eroding:** No.  The tool
+allows you to choose the **Black background** setting.  If these settings are not appropriate,
+first manually convert the image to binary using the **Convert to binary (black and white)**
+tool, which allows you to change them.
+    </token>
+    <xml name="image_datatypes">
+        <option value="bmp">bmp</option>
+        <option value="gif">gif</option>
+        <option value="jpg">jpg</option>
+        <option value="png" selected="true">png</option>
+        <option value="tiff">tiff</option>
+    </xml>
+    <xml name="bunwarpj_citations">
+        <citations>
+            <citation type="bibtex">
+                @InProceedings(Arganda-Carreras2006,
+                    author =     "Ignacio Arganda-Carreras and
+                                        Carlos Oscar S{\'a}nchez Sorzano and
+                                        Roberto Marabini and
+                                        Jos{\'e} Mar\'{\i}a Carazo and
+                                        Carlos Ortiz-de-Solorzano and
+                                        Jan Kybic",
+                    title =          "Consistent and Elastic Registration of Histological Sections Using Vector-Spline Regularization",    
+                    publisher =  "Springer Berlin / Heidelberg",    
+                    booktitle =   "Computer Vision Approaches to Medical Image Analysis",
+                    series =       "Lecture Notes in Computer Science",
+                    year =          "2006",
+                    volume =      "4241",
+                    pages =       "85-95",
+                    month =       "May",
+                    city =            "Graz, Austria")
+            </citation>
+            <citation type="doi">10.1038/nmeth.2019</citation>
+        </citations>
+    </xml>
+    <xml name="fiji_headless_citations">
+        <citations>
+            <citation type="doi">10.1038/nmeth.2102</citation>
+        </citations>
+    </xml>
+</macros>

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/imagej2_make_binary.py	Tue Sep 17 17:08:08 2019 -0400
@@ -0,0 +1,59 @@
+#!/usr/bin/env python
+import argparse
+import os
+import shutil
+import subprocess
+import tempfile
+import imagej2_base_utils
+
+parser = argparse.ArgumentParser()
+parser.add_argument( '--input', dest='input', help='Path to the input file' )
+parser.add_argument( '--input_datatype', dest='input_datatype', help='Datatype of the input image' )
+parser.add_argument( '--iterations', dest='iterations', type=int, help='Iterations' )
+parser.add_argument( '--count', dest='count', type=int, help='Count' )
+parser.add_argument( '--black_background', dest='black_background', help='Black background' )
+parser.add_argument( '--pad_edges_when_eroding', dest='pad_edges_when_eroding', help='Pad edges when eroding' )
+parser.add_argument( '--jython_script', dest='jython_script', help='Path to the Jython script' )
+parser.add_argument( '--output', dest='output', help='Path to the output file' )
+parser.add_argument( '--output_datatype', dest='output_datatype', help='Datatype of the output image' )
+args = parser.parse_args()
+
+tmp_dir = imagej2_base_utils.get_temp_dir()
+# ImageJ expects valid image file extensions, so the Galaxy .dat extension does not
+# work for some features.  The following creates a symlink with an appropriate file
+# extension that points to the Galaxy dataset.  This symlink is used by ImageJ.
+tmp_input_path = imagej2_base_utils.get_input_image_path( tmp_dir, args.input, args.input_datatype )
+tmp_output_path = imagej2_base_utils.get_temporary_image_path( tmp_dir, args.output_datatype )
+# Define command response buffers.
+tmp_out = tempfile.NamedTemporaryFile().name
+tmp_stdout = open( tmp_out, 'wb' )
+tmp_err = tempfile.NamedTemporaryFile().name
+tmp_stderr = open( tmp_err, 'wb' )
+# Java writes a lot of stuff to stderr, so we'll specify a file for handling actual errors.
+error_log = tempfile.NamedTemporaryFile( delete=False ).name
+# Build the command line.
+cmd = imagej2_base_utils.get_base_command_imagej2( None, jython_script=args.jython_script )
+if cmd is None:
+    imagej2_base_utils.stop_err( "ImageJ not found!" )
+cmd += ' %s' % error_log
+cmd += ' %s' % tmp_input_path
+cmd += ' %d' % args.iterations
+cmd += ' %d' % args.count
+cmd += ' %s' % args.black_background
+cmd += ' %s' % args.pad_edges_when_eroding
+cmd += ' %s' % tmp_output_path
+cmd += ' %s' % args.output_datatype
+# Run the command.
+proc = subprocess.Popen( args=cmd, stderr=tmp_stderr, stdout=tmp_stdout, shell=True )
+rc = proc.wait()
+# Handle execution errors.
+if rc != 0:
+    error_message = imagej2_base_utils.get_stderr_exception( tmp_err, tmp_stderr, tmp_out, tmp_stdout )
+    imagej2_base_utils.stop_err( error_message )
+# Handle processing errors.
+if os.path.getsize( error_log ) > 0:
+    error_message = open( error_log, 'r' ).read()
+    imagej2_base_utils.stop_err( error_message )
+# Save the output image.
+shutil.move( tmp_output_path, args.output )
+imagej2_base_utils.cleanup_before_exit( tmp_dir )

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/imagej2_make_binary_jython_script.py	Tue Sep 17 17:08:08 2019 -0400
@@ -0,0 +1,37 @@
+import jython_utils
+import sys
+from ij import IJ
+
+# Fiji Jython interpreter implements Python 2.5 which does not
+# provide support for argparse.
+error_log = sys.argv[ -8 ]
+input = sys.argv[ -7 ]
+iterations = int( sys.argv[ -6 ] )
+count = int( sys.argv[ -5 ] )
+black_background = jython_utils.asbool( sys.argv[ -4 ] )
+pad_edges_when_eroding = jython_utils.asbool( sys.argv[ -3 ] )
+tmp_output_path = sys.argv[ -2 ]
+output_datatype = sys.argv[ -1 ]
+
+# Open the input image file.
+input_image_plus = IJ.openImage( input )
+
+# Create a copy of the image.
+input_image_plus_copy = input_image_plus.duplicate()
+image_processor_copy = input_image_plus_copy.getProcessor()
+
+try:
+    # Set binary options.
+    options = jython_utils.get_binary_options( black_background=black_background,
+                                               iterations=iterations,
+                                               count=count,
+                                               pad_edges_when_eroding=pad_edges_when_eroding )
+    IJ.run( input_image_plus_copy, "Options...", options )
+
+    # Run the command.
+    IJ.run( input_image_plus_copy, "Make Binary", "" )
+
+    # Save the ImagePlus object as a new image.
+    IJ.saveAs( input_image_plus_copy, output_datatype, tmp_output_path )
+except Exception, e:
+    jython_utils.handle_error( error_log, str( e ) )

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/imagej2_math.py	Tue Sep 17 17:08:08 2019 -0400
@@ -0,0 +1,69 @@
+#!/usr/bin/env python
+import argparse
+import os
+import shutil
+import subprocess
+import tempfile
+import imagej2_base_utils
+
+parser = argparse.ArgumentParser()
+parser.add_argument( '--input', dest='input', help='Path to the input file' )
+parser.add_argument( '--input_datatype', dest='input_datatype', help='Datatype of the input image' )
+parser.add_argument( '--operation', dest='operation', help='Operation' )
+parser.add_argument( '--expression', dest='expression', default=None, help='Expression' )
+parser.add_argument( '--bin_constant', dest='bin_constant', type=int, default=None, help='Constant of type binary integer' )
+parser.add_argument( '--float_constant', dest='float_constant', type=float, default=None, help='Constant of type float' )
+parser.add_argument( '--jython_script', dest='jython_script', help='Path to the Jython script' )
+parser.add_argument( '--output', dest='output', help='Path to the output file' )
+parser.add_argument( '--output_datatype', dest='output_datatype', help='Datatype of the output image' )
+args = parser.parse_args()
+
+tmp_dir = imagej2_base_utils.get_temp_dir()
+# ImageJ expects valid image file extensions, so the Galaxy .dat extension does not
+# work for some features.  The following creates a symlink with an appropriate file
+# extension that points to the Galaxy dataset.  This symlink is used by ImageJ.
+tmp_input_path = imagej2_base_utils.get_input_image_path( tmp_dir, args.input, args.input_datatype )
+tmp_output_path = imagej2_base_utils.get_temporary_image_path( tmp_dir, args.output_datatype )
+
+# Define command response buffers.
+tmp_out = tempfile.NamedTemporaryFile().name
+tmp_stdout = open( tmp_out, 'wb' )
+tmp_err = tempfile.NamedTemporaryFile().name
+tmp_stderr = open( tmp_err, 'wb' )
+# Java writes a lot of stuff to stderr, so we'll specify a file for handling actual errors.
+error_log = tempfile.NamedTemporaryFile( delete=False ).name
+
+# Build the command line.
+cmd = imagej2_base_utils.get_base_command_imagej2( None, jython_script=args.jython_script )
+if cmd is None:
+    imagej2_base_utils.stop_err( "ImageJ not found!" )
+cmd += ' %s' % error_log
+cmd += ' %s' % tmp_input_path
+cmd += ' %s' % args.operation
+# Handle the expression, which must be enclosed in " if not None.
+if args.expression in [ None, 'None' ]:
+    cmd += ' None'
+else:
+    cmd += ' "%s"' % args.expression
+cmd += imagej2_base_utils.handle_none_type( args.bin_constant, val_type='int' )
+cmd += imagej2_base_utils.handle_none_type( args.float_constant )
+cmd += ' %s' % tmp_output_path
+cmd += ' %s' % args.output_datatype
+
+# Run the command.
+proc = subprocess.Popen( args=cmd, stderr=tmp_stderr, stdout=tmp_stdout, shell=True )
+rc = proc.wait()
+
+# Handle execution errors.
+if rc != 0:
+    error_message = imagej2_base_utils.get_stderr_exception( tmp_err, tmp_stderr, tmp_out, tmp_stdout )
+    imagej2_base_utils.stop_err( error_message )
+
+# Handle processing errors.
+if os.path.getsize( error_log ) > 0:
+    error_message = open( error_log, 'r' ).read()
+    imagej2_base_utils.stop_err( error_message )
+
+# Save the output image.
+shutil.move( tmp_output_path, args.output )
+imagej2_base_utils.cleanup_before_exit( tmp_dir )

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/imagej2_math_jython_script.py	Tue Sep 17 17:08:08 2019 -0400
@@ -0,0 +1,78 @@
+import jython_utils
+import sys
+from ij import IJ
+
+# Fiji Jython interpreter implements Python 2.5 which does not
+# provide support for argparse.
+error_log = sys.argv[ -8 ]
+input = sys.argv[ -7 ]
+operation = sys.argv[ -6 ]
+expression = sys.argv[ -5 ]
+if sys.argv[ -4 ] in [ None, 'None' ]:
+    bin_constant = None
+else:
+    bin_constant = int( sys.argv[ -4 ] )
+if sys.argv[ -3 ] in [ None, 'None' ]:
+    float_constant = None
+else:
+    float_constant = float( sys.argv[ -3 ] )
+tmp_output_path = sys.argv[ -2 ]
+output_datatype = sys.argv[ -1 ]
+
+# Open the input image file.
+input_image_plus = IJ.openImage( input )
+
+# Create a copy of the image.
+input_image_plus_copy = input_image_plus.duplicate()
+image_processor_copy = input_image_plus_copy.getProcessor()
+bit_depth = image_processor_copy.getBitDepth()
+
+try:
+    if operation.find( '_' ) > 0:
+        # Square_Root.
+        new_operation = operation.replace( '_', ' ' )
+    elif operation in [ 'Square', 'Log', 'Exp', 'Abs', 'Reciprocal' ]:
+        # Unfortunately some ImageJ commands require a "..." ending
+        # while others do not.  There seems to be no pattern.
+        new_operation = '%s' % operation
+    else:
+        new_operation = '%s...' % operation
+
+    if operation == 'Macro':
+        # Apply the macro code to the image via a call to it's
+        # ImageProcessor since this option does not work using
+        # the IJ.run() method.
+        new_expression = expression.lstrip( '"' ).rstrip( '"' )
+        options = 'code=%s' % new_expression
+        image_processor_copy.applyMacro( new_expression )
+    elif operation == 'Min':
+        # Min does not work without using the ImageProcessor.
+        image_processor_copy.min( float_constant )
+    elif operation == 'Max':
+        # Max does not work without using the ImageProcessor.
+        image_processor_copy.max( float_constant )
+    elif operation == 'Abs':
+        if bit_depth not in [ 16, 32 ]:
+            # Convert the image to 32-bit.
+            IJ.run( input_image_plus_copy, "32-bit", "" )
+            IJ.run( input_image_plus_copy, new_operation, "" )
+    elif operation == 'Reciprocal':
+        if bit_depth != 32:
+            # Convert the image to 32 bit.
+            IJ.run( input_image_plus_copy, "32-bit", "" )
+            IJ.run( input_image_plus_copy, new_operation, "" )
+    else:
+        if operation in [ 'AND', 'OR', 'XOR' ]:
+            # Value is a binary number.
+            options = 'value=%d' % bin_constant
+        elif operation in [ 'Log', 'Exp', 'Square', 'Square_Root' ]:
+            # No constant value.
+            options = ''
+        else:
+            # Value is a floating point number.
+            options = 'value=%.3f' % float_constant
+        IJ.run( input_image_plus_copy, "%s" % new_operation, "%s" % options )
+    # Save the ImagePlus object as a new image.
+    IJ.saveAs( input_image_plus_copy, output_datatype, tmp_output_path )
+except Exception, e:
+    jython_utils.handle_error( error_log, str( e ) )

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/imagej2_noise.py	Tue Sep 17 17:08:08 2019 -0400
@@ -0,0 +1,84 @@
+#!/usr/bin/env python
+import argparse
+import os
+import shutil
+import subprocess
+import tempfile
+import imagej2_base_utils
+
+if __name__=="__main__":
+    # Parse Command Line.
+    parser = argparse.ArgumentParser()
+    parser.add_argument( '--input', dest='input', help='Path to the input file' )
+    parser.add_argument( '--input_datatype', dest='input_datatype', help='Datatype of the input image' )
+    parser.add_argument( '--noise', dest='noise', help='Specified noise to add to or remove from the image' )
+    parser.add_argument( '--standard_deviation', dest='standard_deviation', type=float, default=None, help='Standard deviation' )
+    parser.add_argument( '--radius', dest='radius', type=float, default=None, help='Radius' )
+    parser.add_argument( '--threshold', dest='threshold', type=float, default=None, help='Threshold' )
+    parser.add_argument( '--which_outliers', dest='which_outliers', default=None, help='Which outliers' )
+    parser.add_argument( '--randomj', dest='randomj', default=None, help='RandomJ' )
+    parser.add_argument( '--trials', dest='trials', type=float, default=None, help='Trials' )
+    parser.add_argument( '--probability', dest='probability', type=float, default=None, help='Probability' )
+    parser.add_argument( '--lammbda', dest='lammbda', type=float, default=None, help='Lambda' )
+    parser.add_argument( '--order', dest='order', type=int, default=None, help='Order' )
+    parser.add_argument( '--mean', dest='mean', type=float, default=None, help='Mean' )
+    parser.add_argument( '--sigma', dest='sigma', type=float, default=None, help='Sigma' )
+    parser.add_argument( '--min', dest='min', type=float, default=None, help='Min' )
+    parser.add_argument( '--max', dest='max', type=float, default=None, help='Max' )
+    parser.add_argument( '--insertion', dest='insertion', default=None, help='Insertion' )
+    parser.add_argument( '--jython_script', dest='jython_script', help='Path to the Jython script' )
+    parser.add_argument( '--output', dest='output', help='Path to the output file' )
+    args = parser.parse_args()
+
+    tmp_dir = imagej2_base_utils.get_temp_dir()
+    # ImageJ expects valid image file extensions, so the Galaxy .dat extension does not
+    # work for some features.  The following creates a symlink with an appropriate file
+    # extension that points to the Galaxy dataset.  This symlink is used by ImageJ.
+    tmp_input_path = imagej2_base_utils.get_input_image_path( tmp_dir, args.input, args.input_datatype )
+    tmp_output_path = imagej2_base_utils.get_temporary_image_path( tmp_dir, args.input_datatype )
+
+    # Define command response buffers.
+    tmp_out = tempfile.NamedTemporaryFile().name
+    tmp_stdout = open( tmp_out, 'wb' )
+    tmp_err = tempfile.NamedTemporaryFile().name
+    tmp_stderr = open( tmp_err, 'wb' )
+    # Java writes a lot of stuff to stderr, so we'll specify a file for handling actual errors.
+    error_log = tempfile.NamedTemporaryFile( delete=False ).name
+    # Build the command line.
+    cmd = imagej2_base_utils.get_base_command_imagej2( None, jython_script=args.jython_script )
+    if cmd is None:
+        imagej2_base_utils.stop_err( "ImageJ not found!" )
+    cmd += ' %s' % error_log
+    cmd += ' %s' % tmp_input_path
+    cmd += ' %s' % args.input_datatype
+    cmd += ' %s ' % args.noise
+    cmd += imagej2_base_utils.handle_none_type( args.standard_deviation )
+    cmd += imagej2_base_utils.handle_none_type( args.radius )
+    cmd += imagej2_base_utils.handle_none_type( args.threshold )
+    cmd += ' %s' % args.which_outliers
+    cmd += ' %s' % args.randomj
+    cmd += imagej2_base_utils.handle_none_type( args.trials )
+    cmd += imagej2_base_utils.handle_none_type( args.probability )
+    cmd += imagej2_base_utils.handle_none_type( args.lammbda )
+    cmd += imagej2_base_utils.handle_none_type( args.order, val_type='int' )
+    cmd += imagej2_base_utils.handle_none_type( args.mean )
+    cmd += imagej2_base_utils.handle_none_type( args.sigma )
+    cmd += imagej2_base_utils.handle_none_type( args.min )
+    cmd += imagej2_base_utils.handle_none_type( args.max )
+    cmd += ' %s' % args.insertion
+    cmd += ' %s' % tmp_output_path
+
+    proc = subprocess.Popen( args=cmd, stderr=tmp_stderr, stdout=tmp_stdout, shell=True )
+    rc = proc.wait()
+
+    # Handle execution errors.
+    if rc != 0:
+        error_message = imagej2_base_utils.get_stderr_exception( tmp_err, tmp_stderr, tmp_out, tmp_stdout )
+        imagej2_base_utils.stop_err( error_message )
+    # Handle processing errors.
+    if os.path.getsize( error_log ) > 0:
+        error_message = open( error_log, 'r' ).read()
+        imagej2_base_utils.stop_err( error_message )
+    # Save the output image.
+    shutil.move( tmp_output_path, args.output )
+    imagej2_base_utils.cleanup_before_exit( tmp_dir )

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/imagej2_noise_jython_script.py	Tue Sep 17 17:08:08 2019 -0400
@@ -0,0 +1,84 @@
+import sys
+from ij import IJ
+from ij import ImagePlus
+import jython_utils
+
+# Fiji Jython interpreter implements Python 2.5 which does not
+# provide support for argparse.
+error_log = sys.argv[ -19 ]
+input = sys.argv[ -18 ]
+image_datatype = sys.argv[ -17 ]
+noise = sys.argv[ -16 ]
+standard_deviation = sys.argv[ -15 ]
+radius = sys.argv[ -14 ]
+threshold = sys.argv[ -13 ]
+which_outliers = sys.argv[ -12 ]
+randomj = sys.argv[ -11 ]
+trials = sys.argv[ -10 ]
+probability = sys.argv[ -9 ]
+# Note the spelling - so things don't get confused due to Python lambda function.
+lammbda = sys.argv[ -8 ]
+order = sys.argv[ -7 ]
+mean = sys.argv[ -6 ]
+sigma = sys.argv[ -5 ]
+min = sys.argv[ -4 ]
+max = sys.argv[ -3 ]
+insertion = sys.argv[ -2 ]
+tmp_output_path = sys.argv[ -1 ]
+
+error = False
+
+# Open the input image file.
+image_plus = IJ.openImage( input )
+bit_depth = image_plus.getBitDepth()
+image_type = image_plus.getType()
+# Create an ImagePlus object for the image.
+image_plus_copy = image_plus.duplicate()
+# Make a copy of the image.
+image_processor_copy = image_plus_copy.getProcessor()
+
+# Perform the analysis on the ImagePlus object.
+if noise == 'add_noise':
+    IJ.run( image_plus_copy, "Add Noise", "" )
+elif noise == 'add_specified_noise':
+    IJ.run( image_plus_copy, "Add Specified Noise", "standard=&standard_deviation" )
+elif noise == 'salt_and_pepper':
+    IJ.run( image_plus_copy, "Salt and Pepper", "" )
+elif noise == 'despeckle':
+    IJ.run( image_plus_copy, "Despeckle", "" )
+elif noise == 'remove_outliers':
+    IJ.run( image_plus_copy, "Remove Outliers", "radius=&radius threshold=&threshold which=&which_outliers" )
+elif noise == 'remove_nans':
+    if bit_depth == 32:
+        IJ.run( image_plus_copy, "Remove NaNs", "" )
+    else:
+        # When Galaxy metadata for images is enhanced to include information like this,
+        # we'll be able to write tool validators rather than having to stop the job in
+        # an error state.
+        msg = "Remove NaNs requires a 32-bit image, the selected image is %d-bit" % bit_depth
+        jython_utils.handle_error( error_log, msg )
+        error = True
+elif noise == 'rof_denoise':
+    if image_type == ImagePlus.GRAY32:
+        IJ.run( image_plus_copy, "ROF Denoise", "" )
+    else:
+        msg = "ROF Denoise requires an image of type 32-bit grayscale, the selected image is %d-bit" % ( bit_depth )
+        jython_utils.handle_error( error_log, msg )
+        error = True
+elif noise == 'randomj':
+    if randomj == 'randomj_binomial':
+        IJ.run( image_plus_copy, "RandomJ Binomial", "trials=&trials probability=&probability insertion=&insertion" )
+    elif randomj == 'randomj_exponential':
+        IJ.run( image_plus_copy, "RandomJ Exponential", "lambda=&lammbda insertion=&insertion" )
+    elif randomj == 'randomj_gamma':
+        IJ.run( image_plus_copy, "RandomJ Gamma", "order=&order insertion=&insertion" )
+    elif randomj == 'randomj_gaussian':
+        IJ.run( image_plus_copy, "RandomJ Gaussian", "mean=&mean sigma=&sigma insertion=&insertion" )
+    elif randomj == 'randomj_poisson':
+        IJ.run( image_plus_copy, "RandomJ Poisson", "mean=&mean insertion=&insertion" )
+    elif randomj == 'randomj_uniform':
+        IJ.run( image_plus_copy, "RandomJ Uniform", "min=&min max=&max insertion=&insertion" )
+
+if not error:
+    # Save the ImagePlus object as a new image.
+    IJ.saveAs( image_plus_copy, image_datatype, tmp_output_path )

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/imagej2_shadows.py	Tue Sep 17 17:08:08 2019 -0400
@@ -0,0 +1,59 @@
+#!/usr/bin/env python
+import argparse
+import os
+import shutil
+import subprocess
+import tempfile
+import imagej2_base_utils
+
+parser = argparse.ArgumentParser()
+parser.add_argument( '--input', dest='input', help='Path to the input file' )
+parser.add_argument( '--input_datatype', dest='input_datatype', help='Datatype of the input image' )
+parser.add_argument( '--direction', dest='direction', help='Direction' )
+parser.add_argument( '--jython_script', dest='jython_script', help='Path to the Jython script' )
+parser.add_argument( '--output', dest='output', help='Path to the output file' )
+parser.add_argument( '--output_datatype', dest='output_datatype', help='Datatype of the output image' )
+args = parser.parse_args()
+
+tmp_dir = imagej2_base_utils.get_temp_dir()
+# ImageJ expects valid image file extensions, so the Galaxy .dat extension does not
+# work for some features.  The following creates a symlink with an appropriate file
+# extension that points to the Galaxy dataset.  This symlink is used by ImageJ.
+tmp_input_path = imagej2_base_utils.get_input_image_path( tmp_dir, args.input, args.input_datatype )
+tmp_output_path = imagej2_base_utils.get_temporary_image_path( tmp_dir, args.output_datatype )
+
+# Define command response buffers.
+tmp_out = tempfile.NamedTemporaryFile().name
+tmp_stdout = open( tmp_out, 'wb' )
+tmp_err = tempfile.NamedTemporaryFile().name
+tmp_stderr = open( tmp_err, 'wb' )
+# Java writes a lot of stuff to stderr, so we'll specify a file for handling actual errors.
+error_log = tempfile.NamedTemporaryFile( delete=False ).name
+
+# Build the command line.
+cmd = imagej2_base_utils.get_base_command_imagej2( None, jython_script=args.jython_script )
+if cmd is None:
+    imagej2_base_utils.stop_err( "ImageJ not found!" )
+cmd += ' %s' % error_log
+cmd += ' %s' % tmp_input_path
+cmd += ' %s' % args.direction
+cmd += ' %s' % tmp_output_path
+cmd += ' %s' % args.output_datatype
+
+# Run the command.
+proc = subprocess.Popen( args=cmd, stderr=tmp_stderr, stdout=tmp_stdout, shell=True )
+rc = proc.wait()
+
+# Handle execution errors.
+if rc != 0:
+    error_message = imagej2_base_utils.get_stderr_exception( tmp_err, tmp_stderr, tmp_out, tmp_stdout )
+    imagej2_base_utils.stop_err( error_message )
+
+# Handle processing errors.
+if os.path.getsize( error_log ) > 0:
+    error_message = open( error_log, 'r' ).read()
+    imagej2_base_utils.stop_err( error_message )
+
+# Save the output image.
+shutil.move( tmp_output_path, args.output )
+imagej2_base_utils.cleanup_before_exit( tmp_dir )

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/imagej2_shadows_jython_script.py	Tue Sep 17 17:08:08 2019 -0400
@@ -0,0 +1,26 @@
+import jython_utils
+import sys
+from ij import IJ
+
+# Fiji Jython interpreter implements Python 2.5 which does not
+# provide support for argparse.
+error_log = sys.argv[ -5 ]
+input = sys.argv[ -4 ]
+direction = sys.argv[ -3 ]
+tmp_output_path = sys.argv[ -2 ]
+output_datatype = sys.argv[ -1 ]
+
+# Open the input image file.
+input_image_plus = IJ.openImage( input )
+
+# Create a copy of the image.
+input_image_plus_copy = input_image_plus.duplicate()
+image_processor_copy = input_image_plus_copy.getProcessor()
+
+try:
+    # Run the command.
+    IJ.run( input_image_plus_copy, direction, "" )
+    # Save the ImagePlus object as a new image.
+    IJ.saveAs( input_image_plus_copy, output_datatype, tmp_output_path )
+except Exception, e:
+    jython_utils.handle_error( error_log, str( e ) )

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/imagej2_sharpen.py	Tue Sep 17 17:08:08 2019 -0400
@@ -0,0 +1,57 @@
+#!/usr/bin/env python
+import argparse
+import os
+import shutil
+import subprocess
+import tempfile
+import imagej2_base_utils
+
+parser = argparse.ArgumentParser()
+parser.add_argument( '--input', dest='input', help='Path to the input file' )
+parser.add_argument( '--input_datatype', dest='input_datatype', help='Datatype of the input image' )
+parser.add_argument( '--jython_script', dest='jython_script', help='Path to the Jython script' )
+parser.add_argument( '--output', dest='output', help='Path to the output file' )
+parser.add_argument( '--output_datatype', dest='output_datatype', help='Datatype of the output image' )
+args = parser.parse_args()
+
+tmp_dir = imagej2_base_utils.get_temp_dir()
+# ImageJ expects valid image file extensions, so the Galaxy .dat extension does not
+# work for some features.  The following creates a symlink with an appropriate file
+# extension that points to the Galaxy dataset.  This symlink is used by ImageJ.
+tmp_input_path = imagej2_base_utils.get_input_image_path( tmp_dir, args.input, args.input_datatype )
+tmp_output_path = imagej2_base_utils.get_temporary_image_path( tmp_dir, args.output_datatype )
+
+# Define command response buffers.
+tmp_out = tempfile.NamedTemporaryFile().name
+tmp_stdout = open( tmp_out, 'wb' )
+tmp_err = tempfile.NamedTemporaryFile().name
+tmp_stderr = open( tmp_err, 'wb' )
+# Java writes a lot of stuff to stderr, so we'll specify a file for handling actual errors.
+error_log = tempfile.NamedTemporaryFile( delete=False ).name
+
+# Build the command line.
+cmd = imagej2_base_utils.get_base_command_imagej2( None, jython_script=args.jython_script )
+if cmd is None:
+    imagej2_base_utils.stop_err( "ImageJ not found!" )
+cmd += ' %s' % error_log
+cmd += ' %s' % tmp_input_path
+cmd += ' %s' % tmp_output_path
+cmd += ' %s' % args.output_datatype
+
+# Run the command.
+proc = subprocess.Popen( args=cmd, stderr=tmp_stderr, stdout=tmp_stdout, shell=True )
+rc = proc.wait()
+
+# Handle execution errors.
+if rc != 0:
+    error_message = imagej2_base_utils.get_stderr_exception( tmp_err, tmp_stderr, tmp_out, tmp_stdout )
+    imagej2_base_utils.stop_err( error_message )
+
+# Handle processing errors.
+if os.path.getsize( error_log ) > 0:
+    error_message = open( error_log, 'r' ).read()
+    imagej2_base_utils.stop_err( error_message )
+
+# Save the output image.
+shutil.move( tmp_output_path, args.output )
+imagej2_base_utils.cleanup_before_exit( tmp_dir )

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/imagej2_sharpen.xml	Tue Sep 17 17:08:08 2019 -0400
@@ -0,0 +1,49 @@
+<?xml version='1.0' encoding='UTF-8'?>
+<tool id="imagej2_sharpen" name="Sharpen" version="@WRAPPER_VERSION@.0">
+    <description></description>
+    <macros>
+        <import>imagej2_macros.xml</import>
+    </macros>
+    <expand macro="fiji_requirements" />
+    <command>
+<![CDATA[
+    python $__tool_directory__/imagej2_sharpen.py
+    --input "$input"
+    --input_datatype $input.ext
+    --jython_script $__tool_directory__/imagej2_sharpen_jython_script.py
+    --output_datatype $output.ext
+    --output "$output"
+]]>
+    </command>
+    <inputs>
+        <param format="bmp,eps,gif,jpg,pcx,pgm,png,psd,tiff" name="input" type="data" label="Select image"/>
+    </inputs>
+    <outputs>
+        <data name="output" format_source="input" label="${tool.name} on ${on_string}"/>
+    </outputs>
+    <tests>
+        <test>
+            <param name="input" value="blobs.gif" />
+            <output name="output" file="blobs_sharpen.gif" compare="sim_size" />
+        </test>
+    </tests>
+    <help>
+
+**What it does**
+
+<![CDATA[
+
+Increases contrast and accentuates detail in the image, but may also accentuate noise. This filter
+uses the following weighting factors to replace each pixel with a weighted average of the 3x3 neighborhood.
+
+``-1 -1 -1``
+
+``-1 12 -1``
+
+``-1 -1 -1``
+
+]]>
+
+    </help>
+    <expand macro="fiji_headless_citations" />
+</tool>

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/imagej2_sharpen_jython_script.py	Tue Sep 17 17:08:08 2019 -0400
@@ -0,0 +1,25 @@
+import jython_utils
+import sys
+from ij import IJ
+
+# Fiji Jython interpreter implements Python 2.5 which does not
+# provide support for argparse.
+error_log = sys.argv[ -4 ]
+input = sys.argv[ -3 ]
+tmp_output_path = sys.argv[ -2 ]
+output_datatype = sys.argv[ -1 ]
+
+# Open the input image file.
+input_image_plus = IJ.openImage( input )
+
+# Create a copy of the image.
+input_image_plus_copy = input_image_plus.duplicate()
+image_processor_copy = input_image_plus_copy.getProcessor()
+
+try:
+    # Run the command.
+    IJ.run( input_image_plus_copy, "Sharpen", "" )
+    # Save the ImagePlus object as a new image.
+    IJ.saveAs( input_image_plus_copy, output_datatype, tmp_output_path )
+except Exception, e:
+    jython_utils.handle_error( error_log, str( e ) )

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/imagej2_skeletonize3d.py	Tue Sep 17 17:08:08 2019 -0400
@@ -0,0 +1,53 @@
+#!/usr/bin/env python
+import argparse
+import os
+import shutil
+import subprocess
+import tempfile
+import imagej2_base_utils
+
+parser = argparse.ArgumentParser()
+parser.add_argument( '--input', dest='input', help='Path to the input file' )
+parser.add_argument( '--input_datatype', dest='input_datatype', help='Datatype of the input image' )
+parser.add_argument( '--black_background', dest='black_background', help='Black background' )
+parser.add_argument( '--jython_script', dest='jython_script', help='Path to the Jython script' )
+parser.add_argument( '--output', dest='output', help='Path to the output file' )
+parser.add_argument( '--output_datatype', dest='output_datatype', help='Datatype of the output image' )
+args = parser.parse_args()
+
+tmp_dir = imagej2_base_utils.get_temp_dir()
+# ImageJ expects valid image file extensions, so the Galaxy .dat extension does not
+# work for some features.  The following creates a symlink with an appropriate file
+# extension that points to the Galaxy dataset.  This symlink is used by ImageJ.
+tmp_input_path = imagej2_base_utils.get_input_image_path( tmp_dir, args.input, args.input_datatype )
+tmp_output_path = imagej2_base_utils.get_temporary_image_path( tmp_dir, args.output_datatype )
+# Define command response buffers.
+tmp_out = tempfile.NamedTemporaryFile().name
+tmp_stdout = open( tmp_out, 'wb' )
+tmp_err = tempfile.NamedTemporaryFile().name
+tmp_stderr = open( tmp_err, 'wb' )
+# Java writes a lot of stuff to stderr, so we'll specify a file for handling actual errors.
+error_log = tempfile.NamedTemporaryFile( delete=False ).name
+# Build the command line.
+cmd = imagej2_base_utils.get_base_command_imagej2( None, jython_script=args.jython_script )
+if cmd is None:
+    imagej2_base_utils.stop_err( "ImageJ not found!" )
+cmd += ' %s' % error_log
+cmd += ' %s' % tmp_input_path
+cmd += ' %s' % args.black_background
+cmd += ' %s' % tmp_output_path
+cmd += ' %s' % args.output_datatype
+# Run the command.
+proc = subprocess.Popen( args=cmd, stderr=tmp_stderr, stdout=tmp_stdout, shell=True )
+rc = proc.wait()
+# Handle execution errors.
+if rc != 0:
+    error_message = imagej2_base_utils.get_stderr_exception( tmp_err, tmp_stderr, tmp_out, tmp_stdout )
+    imagej2_base_utils.stop_err( error_message )
+# Handle processing errors.
+if os.path.getsize( error_log ) > 0:
+    error_message = open( error_log, 'r' ).read()
+    imagej2_base_utils.stop_err( error_message )
+# Save the output image.
+shutil.move( tmp_output_path, args.output )
+imagej2_base_utils.cleanup_before_exit( tmp_dir )

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/imagej2_skeletonize3d_jython_script.py	Tue Sep 17 17:08:08 2019 -0400
@@ -0,0 +1,36 @@
+import jython_utils
+import sys
+from ij import IJ
+
+# Fiji Jython interpreter implements Python 2.5 which does not
+# provide support for argparse.
+error_log = sys.argv[ -5 ]
+input = sys.argv[ -4 ]
+black_background = jython_utils.asbool( sys.argv[ -3 ] )
+tmp_output_path = sys.argv[ -2 ]
+output_datatype = sys.argv[ -1 ]
+
+# Open the input image file.
+input_image_plus = IJ.openImage( input )
+
+# Create a copy of the image.
+input_image_plus_copy = input_image_plus.duplicate()
+image_processor_copy = input_image_plus_copy.getProcessor()
+
+try:
+    # Set binary options.
+    options = jython_utils.get_binary_options( black_background=black_background )
+    IJ.run( input_image_plus_copy, "Options...", options )
+
+    # Convert image to binary if necessary.
+    if not image_processor_copy.isBinary():
+        # Convert the image to binary grayscale.
+        IJ.run( input_image_plus_copy, "Make Binary", "" )
+
+    # Run the command.
+    IJ.run( input_image_plus_copy, "Skeletonize (2D/3D)", "" )
+
+    # Save the ImagePlus object as a new image.
+    IJ.saveAs( input_image_plus_copy, output_datatype, tmp_output_path )
+except Exception, e:
+    jython_utils.handle_error( error_log, str( e ) )

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/imagej2_smooth.py	Tue Sep 17 17:08:08 2019 -0400
@@ -0,0 +1,57 @@
+#!/usr/bin/env python
+import argparse
+import os
+import shutil
+import subprocess
+import tempfile
+import imagej2_base_utils
+
+parser = argparse.ArgumentParser()
+parser.add_argument( '--input', dest='input', help='Path to the input file' )
+parser.add_argument( '--input_datatype', dest='input_datatype', help='Datatype of the input image' )
+parser.add_argument( '--jython_script', dest='jython_script', help='Path to the Jython script' )
+parser.add_argument( '--output', dest='output', help='Path to the output file' )
+parser.add_argument( '--output_datatype', dest='output_datatype', help='Datatype of the output image' )
+args = parser.parse_args()
+
+tmp_dir = imagej2_base_utils.get_temp_dir()
+# ImageJ expects valid image file extensions, so the Galaxy .dat extension does not
+# work for some features.  The following creates a symlink with an appropriate file
+# extension that points to the Galaxy dataset.  This symlink is used by ImageJ.
+tmp_input_path = imagej2_base_utils.get_input_image_path( tmp_dir, args.input, args.input_datatype )
+tmp_output_path = imagej2_base_utils.get_temporary_image_path( tmp_dir, args.output_datatype )
+
+# Define command response buffers.
+tmp_out = tempfile.NamedTemporaryFile().name
+tmp_stdout = open( tmp_out, 'wb' )
+tmp_err = tempfile.NamedTemporaryFile().name
+tmp_stderr = open( tmp_err, 'wb' )
+# Java writes a lot of stuff to stderr, so we'll specify a file for handling actual errors.
+error_log = tempfile.NamedTemporaryFile( delete=False ).name
+
+# Build the command line.
+cmd = imagej2_base_utils.get_base_command_imagej2( None, jython_script=args.jython_script )
+if cmd is None:
+    imagej2_base_utils.stop_err( "ImageJ not found!" )
+cmd += ' %s' % error_log
+cmd += ' %s' % tmp_input_path
+cmd += ' %s' % tmp_output_path
+cmd += ' %s' % args.output_datatype
+
+# Run the command.
+proc = subprocess.Popen( args=cmd, stderr=tmp_stderr, stdout=tmp_stdout, shell=True )
+rc = proc.wait()
+
+# Handle execution errors.
+if rc != 0:
+    error_message = imagej2_base_utils.get_stderr_exception( tmp_err, tmp_stderr, tmp_out, tmp_stdout )
+    imagej2_base_utils.stop_err( error_message )
+
+# Handle processing errors.
+if os.path.getsize( error_log ) > 0:
+    error_message = open( error_log, 'r' ).read()
+    imagej2_base_utils.stop_err( error_message )
+
+# Save the output image.
+shutil.move( tmp_output_path, args.output )
+imagej2_base_utils.cleanup_before_exit( tmp_dir )

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/imagej2_smooth_jython_script.py	Tue Sep 17 17:08:08 2019 -0400
@@ -0,0 +1,25 @@
+import jython_utils
+import sys
+from ij import IJ
+
+# Fiji Jython interpreter implements Python 2.5 which does not
+# provide support for argparse.
+error_log = sys.argv[ -4 ]
+input = sys.argv[ -3 ]
+tmp_output_path = sys.argv[ -2 ]
+output_datatype = sys.argv[ -1 ]
+
+# Open the input image file.
+input_image_plus = IJ.openImage( input )
+
+# Create a copy of the image.
+input_image_plus_copy = input_image_plus.duplicate()
+image_processor_copy = input_image_plus_copy.getProcessor()
+
+try:
+    # Run the command.
+    IJ.run( input_image_plus_copy, "Smooth", "" )
+    # Save the ImagePlus object as a new image.
+    IJ.saveAs( input_image_plus_copy, output_datatype, tmp_output_path )
+except Exception, e:
+    jython_utils.handle_error( error_log, str( e ) )

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/imagej2_watershed_binary.py	Tue Sep 17 17:08:08 2019 -0400
@@ -0,0 +1,53 @@
+#!/usr/bin/env python
+import argparse
+import os
+import shutil
+import subprocess
+import tempfile
+import imagej2_base_utils
+
+parser = argparse.ArgumentParser()
+parser.add_argument( '--input', dest='input', help='Path to the input file' )
+parser.add_argument( '--input_datatype', dest='input_datatype', help='Datatype of the input image' )
+parser.add_argument( '--black_background', dest='black_background', help='Black background' )
+parser.add_argument( '--jython_script', dest='jython_script', help='Path to the Jython script' )
+parser.add_argument( '--output', dest='output', help='Path to the output file' )
+parser.add_argument( '--output_datatype', dest='output_datatype', help='Datatype of the output image' )
+args = parser.parse_args()
+
+tmp_dir = imagej2_base_utils.get_temp_dir()
+# ImageJ expects valid image file extensions, so the Galaxy .dat extension does not
+# work for some features.  The following creates a symlink with an appropriate file
+# extension that points to the Galaxy dataset.  This symlink is used by ImageJ.
+tmp_input_path = imagej2_base_utils.get_input_image_path( tmp_dir, args.input, args.input_datatype )
+tmp_output_path = imagej2_base_utils.get_temporary_image_path( tmp_dir, args.output_datatype )
+# Define command response buffers.
+tmp_out = tempfile.NamedTemporaryFile().name
+tmp_stdout = open( tmp_out, 'wb' )
+tmp_err = tempfile.NamedTemporaryFile().name
+tmp_stderr = open( tmp_err, 'wb' )
+# Java writes a lot of stuff to stderr, so we'll specify a file for handling actual errors.
+error_log = tempfile.NamedTemporaryFile( delete=False ).name
+# Build the command line.
+cmd = imagej2_base_utils.get_base_command_imagej2( None, jython_script=args.jython_script )
+if cmd is None:
+    imagej2_base_utils.stop_err( "ImageJ not found!" )
+cmd += ' %s' % error_log
+cmd += ' %s' % tmp_input_path
+cmd += ' %s' % args.black_background
+cmd += ' %s' % tmp_output_path
+cmd += ' %s' % args.output_datatype
+# Run the command.
+proc = subprocess.Popen( args=cmd, stderr=tmp_stderr, stdout=tmp_stdout, shell=True )
+rc = proc.wait()
+# Handle execution errors.
+if rc != 0:
+    error_message = imagej2_base_utils.get_stderr_exception( tmp_err, tmp_stderr, tmp_out, tmp_stdout )
+    imagej2_base_utils.stop_err( error_message )
+# Handle processing errors.
+if os.path.getsize( error_log ) > 0:
+    error_message = open( error_log, 'r' ).read()
+    imagej2_base_utils.stop_err( error_message )
+# Save the output image.
+shutil.move( tmp_output_path, args.output )
+imagej2_base_utils.cleanup_before_exit( tmp_dir )

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/imagej2_watershed_binary_jython_script.py	Tue Sep 17 17:08:08 2019 -0400
@@ -0,0 +1,36 @@
+import jython_utils
+import sys
+from ij import IJ
+
+# Fiji Jython interpreter implements Python 2.5 which does not
+# provide support for argparse.
+error_log = sys.argv[ -5 ]
+input = sys.argv[ -4 ]
+black_background = jython_utils.asbool( sys.argv[ -3 ] )
+tmp_output_path = sys.argv[ -2 ]
+output_datatype = sys.argv[ -1 ]
+
+# Open the input image file.
+input_image_plus = IJ.openImage( input )
+
+# Create a copy of the image.
+input_image_plus_copy = input_image_plus.duplicate()
+image_processor_copy = input_image_plus_copy.getProcessor()
+
+try:
+    # Set binary options.
+    options = jython_utils.get_binary_options( black_background=black_background )
+    IJ.run( input_image_plus_copy, "Options...", options )
+
+    # Convert image to binary if necessary.
+    if not image_processor_copy.isBinary():
+        # Convert the image to binary grayscale.
+        IJ.run( input_image_plus_copy, "Make Binary", "" )
+
+    # Run the command.
+    IJ.run( input_image_plus_copy, "Watershed", "" )
+
+    # Save the ImagePlus object as a new image.
+    IJ.saveAs( input_image_plus_copy, output_datatype, tmp_output_path )
+except Exception, e:
+    jython_utils.handle_error( error_log, str( e ) )

Binary file jython_utils$py.class has changed

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/jython_utils.py	Tue Sep 17 17:08:08 2019 -0400
@@ -0,0 +1,48 @@
+import imagej2_base_utils
+from ij import IJ
+
+IMAGE_PLUS_IMAGE_TYPE_FIELD_VALUES = { '0':'GRAY8', '1':'GRAY16', '2':'GRAY32',
+                                       '3':'COLOR_256', '4':'COLOR_RGB' }
+
+def asbool( val ):
+    return str( val ).lower() in [ 'yes', 'true' ]
+
+def convert_before_saving_as_tiff( image_plus ):
+    # The bUnwarpJ plug-in produces TIFF image stacks consisting of 3
+    # slices which can be viewed in ImageJ.  The 3 slices are: 1) the
+    # registered image, 2) the target image and 3) the black/white warp
+    # image.  When running bUnwarpJ from the command line (as these
+    # Galaxy wrappers do) the initial call to IJ.openImage() (to open the
+    # registered source and target images produced by bUnwarpJ) in the
+    # tool's jython_script.py returns an ImagePlus object with a single
+    # slice which is the "generally undesired" slice 3 discussed above.
+    # However, a call to IJ.saveAs() will convert the single-slice TIFF
+    # into a 3-slice TIFF image stack (as described above) if the selected
+    # format for saving is TIFF.  Galaxy supports only single-layered
+    # images, so to work around this behavior, we have to convert the
+    # image to something other than TIFF so that slices are eliminated.
+    # We can then convert back to TIFF for saving.  There might be a way
+    # to do this without converting twice, but I spent a lot of time looking
+    # and I have yet to discover it.
+    tmp_dir = imagej2_base_utils.get_temp_dir()
+    tmp_out_png_path = imagej2_base_utils.get_temporary_image_path( tmp_dir, 'png' )
+    IJ.saveAs( image_plus, 'png', tmp_out_png_path )
+    return IJ.openImage( tmp_out_png_path )
+
+def get_binary_options( black_background, iterations=1, count=1, pad_edges_when_eroding='no' ):
+    options = [ 'edm=Overwrite', 'iterations=%d' % iterations, 'count=%d' % count ]
+    if asbool( pad_edges_when_eroding ):
+        options.append( 'pad' )
+    if asbool( black_background ):
+        options.append( "black" )
+    return " ".join( options )
+
+def get_display_image_type( image_type ):
+    return IMAGE_PLUS_IMAGE_TYPE_FIELD_VALUES.get( str( image_type ), None )
+
+def handle_error( error_log, msg ):
+    # Java writes a lot of stuff to stderr, so the received error_log 
+    # will log actual errors.
+    elh = open( error_log, 'wb' )
+    elh.write( msg )
+    elh.close()

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/readme.md	Tue Sep 17 17:08:08 2019 -0400
@@ -0,0 +1,120 @@
+Galaxy wrappers for ImageJ2 tools
+==================================
+
+ImageJ2 is a new version of ImageJ for the next generation of multidimensional image data, with a focus on scientific imaging. Its central goal is to broaden the paradigm of ImageJ beyond the limitations of ImageJ 1.x, to support the next generation of multidimensional scientific imaging.
+
+Fiji is an image processing package. It can be described as a "batteries-included" distribution of ImageJ (and ImageJ2), bundling Java, Java3D and a lot of plugins organized into a coherent menu structure. Fiji compares to ImageJ as Ubuntu compares to Linux.
+
+More informations is available at:
+
+* [http://fiji.sc/ImageJ2](http://fiji.sc/ImageJ2)
+* [http://fiji.sc/Fiji](http://fiji.sc/Fiji)
+
+
+Installation
+============
+
+Galaxy tool wrappers use specified Fiji Lifeline versions available from [http://fiji.sc/Downloads](http://fiji.sc/Downloads).  Galaxy should be able to automatically install this package.
+
+The wrappers are available at [https://github.com/bgruening/galaxytools/tree/master/tools/image_processing/imagej2](https://github.com/bgruening/galaxytools/tree/master/tools/image_processing/imagej2).
+
+
+Use Docker
+==========
+
+A docker image that installs Galaxy with these imaging tools is available at [https://github.com/bgruening/galaxy-imaging](https://github.com/bgruening/galaxy-imaging).
+
+
+Using Fiji with Galaxy tools
+============================
+
+Galaxy ImageJ2 tool wrappers generate a command line that calls a Python script, passing it a series of arguments including a Jython script named jython_script.py that resides in the same directory as the tool wrapper.  During tool execution, the Python script will call ImageJ2 with the --headless argument to run without the ImageJ2 GUI.  The Jython script is also passed to ImageJ2 along with all command line arguments that it expects.  ImageJ2 will execute the Jython script, passing the expected arguments.  The command line to run ImageJ2 from a Galaxy tool wrapper looks something like this:
+
+`ImageJ2 --ij2 --headless --jython ~jython_script.py arg1, arg2, ...`
+
+Each tool execution starts the ImageJ2 application within a Java virtual machine (JVM).  When ImageJ2 is finished processing the Jython script, the results are either written to a file or returned to the calling Galaxy process.  The JVM is shut down, and the Galaxy job terminates.  This approach provides the ability to run ImageJ2 tools from Galaxy on any supported HPC environment.
+
+Of course, eliminating the ImageJ2 GUI restricts us to wrapping only those ImageJ2 plugins that do not require any GUI components (i.e., the ImageJ2 window manager).  Plugins are written by an open community, so not all of them are written in such a way that they can be executed from the command line and produce useful results.  For example, some plugins create one or more images that can only be accessed via calls to the ImageJ2 window manager, and running in headless mode eliminates the window manager as well as other GUI components.
+
+Those familiar with ImageJ2 will find differences with this general pattern for executing ImageJ2 tools within Galaxy.  ImageJ2 accounts for user defined global preferences which are available to tools throughout the session, and an image can be uploaded and run through any number of available tools, saving only the final image.  While Galaxy currently does not account for user preferences defined in ImageJ2, enhancements to the Galaxy framework are planned that will accomodate these kinds of settings (e.g., binary image options).  Also, since Galaxy initiates a new ImageJ2 session with each tool execution, initial images are uploaded to ImageJ2 and resulting images are saved for each tool execution.
+
+The Galaxy ImageJ2 tools currently fall into the following categories.  Additional tools will be added at a steady pace.
+
+Working with Pixels
+===================
+These Galaxy tools wrap the ImageJ2 plugins that are available in the ImageJ2 Process → Math menu.
+
+* **Operate on pixels** - Applies a mathematical expression (add, subtract, multiply, etc.) to each pixel in the image.  When the resulting pixel value overflows/underflows the legal range of the image's data type, the value is reset to the maximum/minimum value.
+
+Filters and Effects
+===================
+These Galaxy tools wrap the ImageJ2 plugins that are available in the ImageJ2 Process menu.
+
+* **Smooth** - Blurs the image by replacing each pixel with the average of its 3x3 neighborhood.
+* **Sharpen** - Increases contrast and accentuates detail in the image, but may also accentuate noise.
+* **Find Edges** - Uses a Sobel edge detector to highlight sharp changes in intensity in the active image.
+* **Add shadow effect** - Produces a shadow effect, with light appearing to come from the selected direction (East, North, Northeast, Northwest, South, Southeast, Southwest and West).
+* **Find Maxima** - Determines the local maxima in an image and creates a binary (mask-like) image of the same size with the maxima (or one segmented particle per maximum) marked.
+* **Enhance contrast** - Enhances image contrast by using either normalization (contrast stretching) or histogram equalization.
+* **Add or remove noise** - Adds specified noise to or removes noise from images.
+
+Binary Image Tools
+==================
+These Galaxy tools wrap the ImageJ2 plugins that are available in the ImageJ2 Process → Binary menu.
+
+* **Convert to binary** - Converts an image into a binary (black and white) image.
+* **Adjust threshold** - Sets lower and upper threshold values, segmenting grayscale images into
+features of interest and background.
+* **Watershed segmentation** - Automatically separates or cuts apart particles that touch.
+* **Analyze particles** - Analyzes the particles in a segmented binary image, providing information about
+each particle in the image.
+* **Skeletonize images** - Uses the Skeletonize3D plugin to find the centerlines (”skeleton”) of objects in the input image.  Skeletonize3d is a plugin written by Ignacio Arganda-Carreras that offers several advantages over the legacy skeletonization algorithm of ImageJ available in the Process → Binary → Skeletonize menu item.  Skeletonize works only with binary 2D images.  Skeletonize3D works with 8-bit 2D images and stacks, expecting the image to be binary. If not, Skeletonize3D considers all pixel values above 0 to be white (255).  While Skeletonize↑ relies on Black background value, the output of Skeletonize3D always has a value of 255 at the skeleton and 0 at background pixels, independently of the Black background option.
+* **Analyze skeleton** - Tags all pixel/voxels in a skeleton image and then counts all its junctions,
+triple and quadruple points and branches, and measures their average and maximum length.
+* **Convert binary image to EDM** - Converts a binary image into a 8-bit grayscale Euclidean Distance Map (EDM). Each foreground (nonzero) pixel in the binary image is assigned a value equal to its distance from the nearest background (zero) pixel.
+
+**Interpreting binary Images in ImageJ2**
+
+Binary images are thresholded to only two values, typically 0 and 1, but often — as with ImageJ — 0 and 255, that represent black and white on an 8-bit scale.
+
+The interpretation of binary images is not universal. While some software packages will always perform binary operations on 255 values (or 1, or any non-zero value), ImageJ takes into account the foreground and background colors of the binary image.
+
+In ImageJ, the **Black background** global preference setting defines not only how new binary images will be created, but also how previously created images are interpreted. This means objects will be inferred on a image-per-image basis.  As such, inverting the LUT (i.e., pixels with a value of zero are white and pixels with a value 255 are black) of a binary image without updating the black background option may lead to unexpected results.  This issue can currently be avoided by properly selecting the **Black background** option available on all Galaxy binary image tools.
+
+BunwarpJ Plugin Tools
+=====================
+These Galaxy tools wrap the bUnwarpJ plugin [http://fiji.sc/BUnwarpJ](http://fiji.sc/BUnwarpJ).
+
+* **Adapt an elastic transformation** - Adapts an elastic transformation to a new image size by transforming the
+coefficients of a specified elastic transformation according to a real image factor.
+* **Align two images** - Performs a simultaneous registration of two images, A and B. Image A is elastically deformed
+in order to look as similar as possible to image B, and, at the same time, the "inverse"
+transformation (from B to A) is also calculated so a pseudo-invertibility of the final deformation
+could be guaranteed.  Two images are produced: the deformed versions of A and B images.
+* **Compare opposite elastic deformations** - Calculates the warping index of two opposite elast transformations, i.e. the average of the geometrical distance between every pixel and its version after applying both transformations (direct and inverse).
+* **Compare elastic and raw deformation** - Calculates the warping index of an elastic transformation and a raw transformation.
+* **Compare two raw deformations** - Calculates the warping index of two raw transformations (same direction).
+* **Compose two elastic transformations** - Composes two elastic transformations into a raw transformation.
+* **Compose two raw transformations** - Composes two raw transformations into another raw transformation.
+* **Compose a raw and an elastic transformation** - Composes a raw transformation and an elastic transformation
+into a raw transformation.
+* **Convert elastic transformation to raw** - Converts an elastic (i.e., B-spline ) transformation file into a raw transformation file.
+* **Apply elastic transformation** - Applies an elastic transformation to an image, producing another image which is elastically
+deformed according to the transformation.
+* **Apply raw transformation** - Applies a raw transformation to an image, producing another image which is deformed according
+to the transformation.
+
+Other Tools
+===========
+* **Create new image** - Creates a new image of a selected type, size, depth and format.
+* **Convert image format** - Converts the format of an input image file, producing an output image.
+
+Licence
+=======
+
+Fiji is released as open source under the GNU General Public License: [http://www.gnu.org/licenses/gpl.html](http://www.gnu.org/licenses/gpl.html)
+
+Fiji builds on top of the ImageJ2 core, which is licensed under the permissive BSD 2-Clause license: [http://opensource.org/licenses/BSD-2-Clause](http://opensource.org/licenses/BSD-2-Clause)
+
+Plugins and other components have their own licenses.
+

Binary file static/images/bunwarpj_scheme.png has changed

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test-data/adapted_transformation.txt	Tue Sep 17 17:08:08 2019 -0400
@@ -0,0 +1,19 @@
+Intervals=4
+
+X Coeffs -----------------------------------
+   -71.22261496228916  -0.35442767924191093     70.55477101478836    141.48046330114607    212.39813136117553    283.36374640208885    354.43327963109795 
+   -71.28352256238495   -37.226230944094716     76.34084941944606    160.02208968373813       273.55343187174    254.79291915021662     354.2799811586804 
+    -71.2426429370489    -32.71748193741429     177.9000599691838    128.29850224500663    140.92089517714993    258.80790676143397    354.12912297861186 
+   -71.16592771634139   -5.2361603551610765     200.1952417342254    250.67440518610016     175.9632721236523     269.8182348834141    354.05647262505533 
+   -71.11932853032275   -11.878550966054844    225.55781625788134    230.48529336480044     258.5284090366016     303.9164005876728    354.13779763217406 
+   -71.08970622730098    20.302646615516533     74.38994929885534    150.94855292599084    233.92703879457446    303.27842533983653     354.2944484209131 
+   -71.06392165558401   -0.1475022444872089     70.71553999200232    141.56589696490104    212.44426058522552     283.3913227639922    354.44777541221777 
+
+Y Coeffs -----------------------------------
+                -71.0    -70.97352968109173    -70.89411872436696    -70.84117808655046    -70.89411872436696    -70.97352968109173                 -71.0 
+                  0.0    0.0397054783623835    14.202191039012094    119.43281261970162     -64.7898912338142    -78.07610697398358                   0.0 
+                 71.0     41.99965358343721    48.801650399807585     -4.96831542657184     65.92550026202618    52.529005249001116                  71.0 
+                142.0     42.71037318260199    -10.45958071265268     137.6637735153788    13.689619340755756    126.62467245361297     142.0004344305075 
+   212.99999999999997    214.58667057999367    290.49952942694233    211.47733987307876    213.00310018836666     242.7605654138609    213.00173772203004 
+                284.0     284.0005109248762     324.2670965032303    296.04807329727873    307.46661221661003     309.9351077964876    284.00260658304506 
+   354.99999999999994     355.0003406165841    355.00136246633656     355.0024781300123    353.49851662901756     355.0029471996293       355.00173772203 

Binary file test-data/add_specified_noise.gif has changed

Binary file test-data/analyze_particles_masks.gif has changed

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test-data/analyze_particles_nothing.tabular	Tue Sep 17 17:08:08 2019 -0400
@@ -0,0 +1,66 @@
+ 	Area	Mean	Min	Max
+1	136	255	255	255
+2	60	255	255	255
+3	206	255	255	255
+4	139	255	255	255
+5	152	255	255	255
+6	86	255	255	255
+7	72	255	255	255
+8	25	255	255	255
+9	85	255	255	255
+10	9	255	255	255
+11	157	255	255	255
+12	207	255	255	255
+13	29	255	255	255
+14	73	255	255	255
+15	143	255	255	255
+16	125	255	255	255
+17	159	255	255	255
+18	133	255	255	255
+19	85	255	255	255
+20	109	255	255	255
+21	51	255	255	255
+22	133	255	255	255
+23	133	255	255	255
+24	81	255	255	255
+25	162	255	255	255
+26	88	255	255	255
+27	212	255	255	255
+28	55	255	255	255
+29	116	255	255	255
+30	172	255	255	255
+31	103	255	255	255
+32	4	255	255	255
+33	60	255	255	255
+34	198	255	255	255
+35	187	255	255	255
+36	7	255	255	255
+37	85	255	255	255
+38	80	255	255	255
+39	75	255	255	255
+40	103	255	255	255
+41	151	255	255	255
+42	52	255	255	255
+43	122	255	255	255
+44	129	255	255	255
+45	77	255	255	255
+46	171	255	255	255
+47	117	255	255	255
+48	207	255	255	255
+49	119	255	255	255
+50	181	255	255	255
+51	22	255	255	255
+52	49	255	255	255
+53	150	255	255	255
+54	191	255	255	255
+55	170	255	255	255
+56	64	255	255	255
+57	174	255	255	255
+58	270	255	255	255
+59	87	255	255	255
+60	69	255	255	255
+61	1	255	255	255
+62	29	255	255	255
+63	25	255	255	255
+64	16	255	255	255
+65	15	255	255	255

Binary file test-data/analyze_particles_outlines.gif has changed

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test-data/basic.tabular	Tue Sep 17 17:08:08 2019 -0400
@@ -0,0 +1,2 @@
+# Branches	Junctions	End-point Voxels	Junction Voxels	Slab Voxels	Average branch length	Triple Points	Quadruple Points	Maximum Branch Length
+96	60	7	120	1246	17.344	56	3	70.882