/*
*/
// Install the BIOP Library
call("BIOP_LibInstaller.installLibrary", "BIOP"+File.separator+"BIOPLib.ijm");

// Name ActionBar
bar_name = "BIOP LISH Tools";

bar_file = replace(bar_name, " ", "_")+".ijm";
bar_jar  = replace(bar_name, " ", "_")+".jar";


runFrom = "jar:file:BIOP/"+bar_jar+"!/"+bar_file;
//////////////////////////////////////////////////////////////////////////////////////////////
// The line below is for debugging. Place this VSI file in the ActionBar folder within Plugins
//////////////////////////////////////////////////////////////////////////////////////////////
runFrom = "/plugins/ActionBar/"+bar_file;

if(isOpen(bar_name)) {
	run("Close AB", bar_name);
}

run("Action Bar",runFrom);
exit();


//Start of ActionBar
<codeLibrary>

function toolName() {
	return "BIOP LISH Tools Settings";
}

function sep() {
	return File.separator;
}

function setupDialog() {
	names = newArray("Other Channels", 
				 	 "Bead Detection", 
					 "Beads Channel", 
				     "Beads Z Downsample Factor",
				     "Beads DoG Sigma",
				     "Beads DoG Threshold", 
				     "Beads Lower Distance Thr", 
				     "Beads Upper Distance Thr",
				     "Beads Set Min And Max",
				     "Beads Min Intensity", 
				     "Beads Max Intensity",
				     "Sample Detection", 
				     "Sample Z Downsample Factor",
				     "Sample DoG Sigma",
				     "Sample DoG Threshold", 
				     "Sample Upper Distance Thr",
				     "Sample Set Min And Max",
				     "Sample Min Intensity", 
				     "Sample Max Intensity",
				     "Registration Parameters", 
				     "RANSAC Error", 
					 "Descriptor Significance",
	     		     "Regularization Lambda", 
					 "ICP Max Distance",
				     "ICP Max Iterations");


	types = newArray("n",
					 "m", 
				     "n",
				     "n",
				     "n",
				     "n",
				     "n",
				     "n",
				     "c",
				     "n",
				     "n",
				     "m", 
				     "n",
				     "n",
				     "n",
				     "n",
				     "c",
				     "n",
				     "n",
				     "m",
				     "n",
				     "n",
				     "n",
				     "n",
				     "n");

	defaults =  newArray(488, 
						 "",
						 561, 
				    	 2,
				    	 1.6,
				    	 0.0080,
				    	 10,
				    	 30,	
				    	 false,
				    	 0,
				    	 65550,
				    	 "",
						 2,
				    	 3.0,
				    	 0.0020,
				    	 50,
				    	 false,
				    	 0,
				    	 65550,
				    	 "",
				    	 5,
				    	 3,
				    	 0.1,
				    	 4,
				    	 150);


promptParameters(names, types, defaults);

}

function deconParameters() {

	names = newArray("Compute On",
					 "CUDA Directory", 
					 "CUDA Library", 
					 "GPU Number",
					 "Block Size", 
					 "X Block Size", 
					 "Y Block Size", 
					 "Z Block Size", 
					 "Type Of Iteration", 
					 "Acceleration", 
					 "Number of Iterations", 
					 "Tikhonov Parameter", 
					 "X PSF Size", 
					 "Y PSF Size", 
					 "Z PSF Size");

	types = newArray("l", 
					 "s", 
					 "s",
					 "n",
					 "l",
					 "n",
					 "n",
					 "n",
					 "s",
					 "l",
					 "n",
					 "n",
					 "n",
					 "n",
					 "n",
					 "n");

	defaults = newArray("CPU (Java),GPU (Nvidia CUDA via JNA)",
						"C:/Fiji",
						"FourierConvolutionCUDALib.dll",
						"1",
						"specify maximal blocksize manually,in 256x256x256 blocks,in 512x512x512 blocks,Entire image at once",
						"512",
						"512",
						"512",
						"Efficient Bayesian - Optimization I (fast, precise)",
						"1 (balanced),minimal number of overlapping views,average number of overlapping views",
						10,
						0.0006,
						19,
						19,
						25);
	
	promptParameters(names, types, defaults);
}

function define(file_id) {
	run("Bio-Formats Macro Extensions");
	
	main_path = substring(file_id,0,lastIndexOf(file_id,sep())+1);
	main_file = substring(file_id,lastIndexOf(file_id,sep())+1, lastIndexOf(file_id,"."));
	
	xml_file = main_file+".xml";
	
	
	Ext.setId(file_id);
	
	// Get metadata
	Ext.getSeriesCount(count);
	Ext.setSeries(0);
	Ext.getSizeC(sizeC);
	
	// Angles
	angle_list = "";
	angles = "";
	for(i=0; i<count;i++) {
		Ext.getMetadataValue("Information|Image|V|View|Offset #"+(i+1), val);
		angle_list+="angle_"+(i+1)+"="+(round(parseFloat(val))*(-1))+" ";
		angles+=""+(round(parseFloat(val))*(-1))+",";
	}
	
	// Channels
	channel_list = "";
	channels = "";
	for(i=0; i<sizeC;i++) {
		Ext.getMetadataValue("Information|Image|Channel|IlluminationWavelength|SinglePeak #"+(i+1), val);
		channel_list+="channel_"+(i+1)+"="+substring(val,0,3)+" ";
		channels+=substring(val,0,3)+",";
	}
	
	// Save all these settings for later
	setData("XML File", main_path+xml_file);
	setData("Angles", substring(angles,0,lengthOf(angles)-1));
	setData("All Channels", substring(channels,0,lengthOf(channels)-1));
	
	
	// Missing parameters for define dataset "channel_1=488 _______illumination_1=0"
	// Metadata for angles: Information|Image|V|View|Offset #Num
	// Metadata for channels: Information|Image|Channel|IlluminationWavelength|SinglePeak #Num 
	illumination_list="";
	
	run("Define Multi-View Dataset", "type_of_dataset=[Zeiss Lightsheet Z.1 Dataset (LOCI Bioformats)] "+
									 "xml_filename=["+xml_file+"] "+
									 "first_czi=["+main_path+main_file+".czi] "+
									 angle_list+
									 channel_list+
									 illumination_list+
									 "apply_rotation_to_dataset fix_bioformats"
									);

	return main_path+xml_file;
}

function resave(xml_file) {
	
	main_path = substring(xml_file,0,lastIndexOf(xml_file,sep())+1);
	main_file = substring(xml_file,lastIndexOf(xml_file,sep())+1, lastIndexOf(xml_file,"."));
	
	hdf5_path = main_path+"HDF5"+sep();
	File.makeDirectory(hdf5_path);
	
	// Resave file
	
	setData("HDF5 XML", hdf5_path+main_file+".xml");
	
	run("As HDF5", "select_xml=["+xml_file+"] "+
				   "resave_angle=[All angles] resave_channel=[All channels] resave_illumination=[All illuminations] resave_timepoint=[All Timepoints] "+
				   "export_path=["+hdf5_path+main_file+".xml]"
				   );
	// Resave the newly made XML to a new name, just for backup
	File.copy(main_path+main_file+".xml", hdf5_path+"Initial File - "+main_file+".xml");
	return hdf5_path+main_file+".xml";
}

function detectObjects(hdf5_xml, bead_channel, downsample_z, detection_sigma, detection_threshold, is_manual, min_intensity, max_intensity) {
	
	
	manual = "";
	if(is_manual) {
		manual = "set_minimal_and_maximal_intensity "+
				 "minimal_intensity="+min_intensity+" "+
				 "maximal_intensity="+max_intensity+ " ";
				 
	}
	
	run("Detect Interest Points for Registration", "select_xml=["+hdf5_xml+"] "+
												   "process_angle=[All angles] "+
												   "process_channel=[Single channel (Select from List)] "+
												   "process_illumination=[All illuminations] "+
												   "process_timepoint=[All Timepoints] "+
												   "processing_channel=[channel "+bead_channel+"] "+
												   "type_of_interest_point_detection=Difference-of-Gaussian "+
												   "label_interest_points=[beads "+bead_channel+"] "+
												   "downsample_images "+
												   "limit_amount_of_detections " +
													manual +
												   "subpixel_localization=[3-dimensional quadratic fit] "+
												   "interest_point_specification=[Advanced ...] "+
												   "downsample_xy=[Match Z Resolution (less downsampling)] "+
												   "downsample_z="+downsample_z+"x "+
												   "sigma="+detection_sigma+" "+
												   "threshold="+detection_threshold+" "+
												   "find_maxima "+
												   "maximum_number=3000 "+
												   "type_of_detections_to_use=[Weakest (above threshold)] "+												   
												   "compute_on=[CPU (Java)]");
}



function auto_bounding_box(xml_file, sample_channel, pct_add) {
	run("Define Bounding Box", "select_xml=["+xml_file+"] "+
							   "process_angle=[All angles] "+
							   "process_channel=[Single channel (Select from List)] "+
							   "process_illumination=[All illuminations] "+
							   "process_timepoint=[All Timepoints] "+
							   "processing_channel=[channel "+sample_channel+"] "+
							   "bounding_box=[Automatically reorientate and estimate based on sample features] "+
							   "bounding_box_name=auto-box reorientation=[Automatically reorientate the sample (and store transformation for all views in the XML)] "+
							   "interest_points_channel_"+sample_channel+"=[channel "+sample_channel+" thinned-out] "+
							   "use=[All detections] "+
							   "additional_size="+pct_add);
}

function filterObjects(xml_file, bead_channel, other_channels, lower_thr, upper_thr) {

	ignore_channels = "";
	for(i=0;i<other_channels.length;i++) {
		ignore_channels+="channel_"+other_channels[i]+"_interest_points=[(DO NOT thin out this channel)] ";
	}
	
	run("Remove Detections by Distance", "select_xml=["+xml_file+"] "+
										 "process_angle=[All angles] "+
										 "process_illumination=[All illuminations] "+
										 "process_timepoint=[All Timepoints] "+
										 ignore_channels + 
										 "channel_"+bead_channel+"_interest_points=[beads "+bead_channel+"] "+
										 "channel_"+bead_channel+"_new_label=[channel "+bead_channel+" thinned-out] "+
										 "channel_"+bead_channel+"_=[Keep Range] "+
										 "channel_"+bead_channel+"_range_lower_threshold="+lower_thr+" "+
										 "channel_"+bead_channel+"_range_upper_threshold="+upper_thr);
	
}

function registerCoarse(xml_file, bead_channel, ransac_err, descriptor_significance, lambda) {
	run("Register Dataset based on Interest Points", "select_xml=["+xml_file+"] "+
													 "process_angle=[All angles] "+
													 "process_illumination=[All illuminations] "+
													 "process_timepoint=[All Timepoints] "+
													 "registration_algorithm=[Fast 3d geometric hashing (rotation invariant)] "+
													 "type_of_registration=[Register timepoints individually] "+
													 "interest_points_channel_"+bead_channel+"=[channel "+bead_channel+" thinned-out] "+
													 "fix_tiles=[Fix first tile] "+
													 "map_back_tiles=[Do not map back (use this if tiles are fixed)] "+
													 "transformation=Affine "+
													 "regularize_model "+
													 "model_to_regularize_with=Rigid "+
													 "lamba="+lambda+" "+
													 "allowed_error_for_ransac="+ransac_err+" "+
													 "significance="+descriptor_significance);
}
function registerFine(xml_file, bead_channel, icp_max_distance, icp_max_iter, lambda) {
	run("Register Dataset based on Interest Points", "select_xml=["+xml_file+"] "+
													 "process_angle=[All angles] "+
													 "process_illumination=[All illuminations] "+
													 "process_timepoint=[All Timepoints] "+
													 "registration_algorithm=[Iterative closest-point (ICP, no invariance)] "+
													 "type_of_registration=[Register timepoints individually] "+
													 "interest_points_channel_"+bead_channel+"=[channel "+bead_channel+" thinned-out] "+
													 "fix_tiles=[Fix first tile] "+
													 "map_back_tiles=[Do not map back (use this if tiles are fixed)] "+
													 "transformation=Affine "+
													 "regularize_model "+
													 "model_to_regularize_with=Rigid "+
													 "lamba="+lambda+" "+
													 "maximal_distance="+icp_max_distance+" "+
													 "+maximal_number="+icp_max_iter);
}

function duplicateTransform(xml_file, bead_channel) {
	run("Duplicate Transformations", "apply=[One channel to other channels] "+
									 "select_xml=["+xml_file+"] "+
									 "apply_to_angle=[All angles] "+
									 "apply_to_illumination=[All illuminations] "+
									 "apply_to_timepoint=[All Timepoints] "+
									 "source="+bead_channel+" "+
									 "target=[All Channels] "+
									 "duplicate_which_transformations=[Replace all transformations]");
}


function fuseDeconvolve(xml_file, bead_channel, other_channels, bb_name) {
// some defaults to decide whether they are worth making into editable variables

other_channels = split(getData("Other Channels"), ", ");
channel_string = "detections_to_extract_psf_for_channel_"+bead_channel+"=["+"channel "+bead_channel+" thinned-out]";
for(i=0; i<other_channels.length;i++) {
	channel_string+=" detections_to_extract_psf_for_channel_"+other_channels[i]+"=[Same PSF as channel "+bead_channel+"]";
}
// Save folder
hdf5_file = getData("HDF5 XML");
hdf5_dir = substring(hdf5_file, 0, lastIndexOf(hdf5_file, sep())+1);
fused_decon_dir = hdf5_dir+"Fused"+sep();
File.makeDirectory(fused_decon_dir);

compute_on = getData("Compute On");
cuda_dir   = getData("CUDA Directory");
cuda_lib   = getData("CUDA Library");
gpu_num    = split(getData("GPU Number"), ",");
gpu_str="";
for(i=0; i<gpu_num.length;i++) {
	gpu_str += "gpu_"+gpu_num[i]+" ";
}

print(gpu_str);
block_size = getData("Block Size");
x_block = getData("X Block Size");
y_block = getData("Y Block Size");
z_block = getData("Z Block Size");
iteration_type = getData("Type Of Iteration");
acceleration = getData("Acceleration");
iterations = getData("Number of Iterations");
tikhonov = getData("Tikhonov Parameter");
x_psf = getData("X PSF Size");
y_psf = getData("Y PSF Size");
z_psf = getData("Z PSF Size");


run("Fuse/Deconvolve Dataset", 
	"select_xml=[" + xml_file + "] " + 
	"process_angle=[All angles] " +
	"process_channel=[All channels] " + 
	"process_illumination=[All illuminations] " +
	"process_timepoint=[All Timepoints] " +
	"type_of_image_fusion=[Multi-view deconvolution] " +
	"bounding_box=[Use pre-defined Bounding Box] " +
	"fused_image=[Save as TIFF stack] " +
	"bounding_box_title=["+bb_name+"] "+
	"imglib2_container=[CellImg (large images)] " +
	"use_tikhonov_regularization " +
	"compute_on=["+compute_on+"]" +
	"cuda_directory=["+cuda_dir+"] " +
	"select_native_library_for_cudafourierconvolution="+cuda_lib+" " +
	 gpu_str +
	"compute=["+block_size+"] " +
	"blocksize_x="+x_block+" " +
	"blocksize_y="+y_block+" " +
	"blocksize_z="+z_block+" " +
	"type_of_iteration=["+iteration_type+"] " +
	"osem_acceleration=["+acceleration+"] " +
	"number_of_iterations="+iterations+" " +
	"tikhonov_parameter="+tikhonov+" " +
	"psf_estimation=[Extract from beads] " +
	"psf_size_x="+x_psf+" " + 
	"psf_size_y="+y_psf+" " + 
	"psf_size_z="+z_psf+" " + 
	"psf_display=[Do not show PSFs] " +
	"output_file_directory=" + fused_decon_dir + " " +
	channel_string);	
}


function removeXMLTag(file, tag_name) {
	str = split(File.openAsString(file),"\n");
	res = "";
	start_ignore = false;
	print(tag_name+" Found:");
	for(i=0;i<str.length;i++) {
		if(matches(str[i],".*</?"+tag_name+">.*")) {
			start_ignore= !start_ignore;
			i++;
		}
		if(!start_ignore) {
			res += str[i] +"\n";
		} else {
			print(str[i]);
		}
	}
	print("Done");
	File.saveString(res, hdf5_xml);
	print("XML file Resaved and Eventual "+tag_name+" Tags Removed");
}


/*
 * function fuseDeconvolve(xml_file, bead_channel, other_channels, bb_name, iterations ) {
// some defaults to decide whether they are worth making into editable variables
type_of_iteration = "Efficient Bayesian - Optimization I (fast, precise)";
osem_acceleration ="1 (balanced)";
tikhonov_parameter = 0.006;

other_channels = split(getData("Other Channels"), ", ");
channel_string = "detections_to_extract_psf_for_channel_"+bead_channel+"=["+"channel "+bead_channel+" thinned-out]";
for(i=0; i<other_channels.length;i++) {
	channel_string+=" detections_to_extract_psf_for_channel_"+other_channels[i]+"=[Same PSF as channel "+bead_channel+"]";
}

// Save folder
hdf5_file = getData("HDF5 XML");
hdf5_dir = substring(hdf5_file, 0, lastIndexOf(hdf5_file, sep())+1);
fused_decon_dir = hdf5_dir+"Fused"+sep();
File.makeDirectory(fused_decon_dir);
s
decon_params = getDeconParams();

run("Fuse/Deconvolve Dataset", 
	"select_xml=[" + xml_file + "] " + 
	"process_angle=[All angles] " +
	"process_channel=[All channels] " + 
	"process_illumination=[All illuminations] " +
	"process_timepoint=[All Timepoints] " +
	"type_of_image_fusion=[Multi-view deconvolution] " +
	"bounding_box=[Use pre-defined Bounding Box] " +
	"fused_image=[Save as TIFF stack] " +
	"bounding_box_title=["+bb_name+"] "+
	"imglib2_container=[CellImg (large images)] " +
	"type_of_iteration=[" + type_of_iteration + "] " +
	"osem_acceleration=[" + osem_acceleration + "] " +
	"number_of_iterations=" + iterations + " " +
	"use_tikhonov_regularization " +
	"tikhonov_parameter=" + tikhonov_parameter + " " +
	"compute=[" + compute + "] " +
	compute_string +
	"psf_estimation=[" + psf_estimation + "] " +
	"psf_display=[Do not show PSFs] " +
	"output_file_directory=" + fused_decon_dir + " " +
	"blocksize_x=" + block_size_x + " "+
	"blocksize_y=" + block_size_y + " "+
	"blocksize_z=" + block_size_z + " "+
	cuda_settings +
	channel_string +
	"psf_size_x=" + psf_size_xy + " " +
	"psf_size_y=" + psf_size_xy + " " +
	"psf_size_z=" + psf_size_z + "");	
}

 * 
 */
</codeLibrary>

<line>
<button>
label=Save Parameters
icon=noicon
arg=<macro>
saveParameters();
</macro>

<button>
label=Load Parameters
icon=noicon
arg=<macro>
loadParameters();
</macro>
</line>

<line>
<button>
label=Setup
arg=<macro>
	setupDialog();
</macro>
</line>

<line>
<button>
label=Define Dataset
arg=<macro>
	file_id = File.openDialog("First CZI file");
	define(file_id);
</macro>
</line>

<line>
<button>
label=Resave Dataset
arg=<macro>
xml_file = getData("XML File");
resave(xml_file);
</macro>

<button>
label=Point to HDF5 Dataset
arg=<macro>
	hdf5_file = File.openDialog("XML File Associated to .h5 dataset");
	setData("HDF5 XML", hdf5_file);
</macro>

</line>

<line>
<button>
label=Detect Beads
arg=<macro>
		   hdf5_xml = getData("HDF5 XML");
	   bead_channel = getData("Beads Channel");
	   downsample_z = getData("Beads Z Downsample Factor");
	detection_sigma = getData("Beads DoG Sigma");
detection_threshold = getData("Beads DoG Threshold");
    beads_is_manual = getBool("Beads Set Min And Max");
          beads_min = getData("Beads Min Intensity");
          beads_max = getData("Beads Max Intensity");

detectObjects(hdf5_xml, bead_channel, downsample_z, detection_sigma, detection_threshold, beads_is_manual, beads_min, beads_max);

</macro>
<button>
label=Check Bead Detection Parameters
arg=<macro>
		   hdf5_xml = getData("HDF5 XML");
	   bead_channel = getData("Beads Channel");
	   downsample_z = getData("Z Downsample Factor");

checkObjects(hdf5_xml, bead_channel, downsample_z);

</macro>
</line>



<line>
<button>
label=Thin Out Beads
arg=<macro>
		   hdf5_xml = getData("HDF5 XML");
	   bead_channel = getData("Beads Channel");
	 other_channels = split(getData("Other Channels"), ",");	   
	      lower_thr = getData("Beads Lower Distance Thr");
	      upper_thr = getData("Beads Upper Distance Thr");

filterObjects(hdf5_xml, bead_channel, other_channels, lower_thr, upper_thr);
</macro>

</line>

<line>
<button>
label=Coarse Registration
arg=<macro>
		       hdf5_xml = getData("HDF5 XML");
	       bead_channel = getData("Beads Channel");
	         ransac_err = getData("RANSAC Error");
descriptor_significance = getData("Descriptor Significance");
	     		 lambda = getData("Regularization Lambda");

registerCoarse(hdf5_xml, bead_channel, ransac_err, descriptor_significance, lambda);
</macro>

</line>

<line>
<button>
label=Fine Registration
arg=<macro>
		       hdf5_xml = getData("HDF5 XML");
	       bead_channel = getData("Beads Channel");
	   icp_max_distance = getData("ICP Max Distance");
	       icp_max_iter = getData("ICP Max Iterations");
	     		 lambda = getData("Regularization Lambda");

 registerFine(hdf5_xml, bead_channel, icp_max_distance, icp_max_iter, lambda);
</macro>

</line>


<line>
<button>
label=Apply Transform To Other Channels
arg=<macro>
		   hdf5_xml = getData("HDF5 XML");
	   bead_channel = getData("Beads Channel");

duplicateTransform(hdf5_xml, bead_channel);
</macro>

</line>

<line>
<button>
label=Detect Sample
arg=<macro>
	  hdf5_xml = getData("HDF5 XML");
other_channels = split(getData("Other Channels"),",");
	   downsample_z = getData("Sample Z Downsample Factor");
	detection_sigma = getData("Sample DoG Sigma");
detection_threshold = getData("Sample DoG Threshold");
    sample_is_manual = getBool("Sample Set Min And Max");
          sample_min = getData("Sample Min Intensity");
          sample_max = getData("Sample Max Intensity");

detectObjects(hdf5_xml, other_channels[0], downsample_z, detection_sigma, detection_threshold, sample_is_manual, sample_min, sample_max);
</macro>
</line>


<line>
<button>
label=Filter Sample Detections
arg=<macro>
		 hdf5_xml = getData("HDF5 XML");
   other_channels = split(getData("Other Channels"), ",");
     bead_channel = getData("Beads Channel");
   sample_channel = other_channels[0];
other_channels[0] = bead_channel;
	    upper_thr = getData("Sample Upper Distance Thr");

filterObjects(hdf5_xml, sample_channel, other_channels, 0, upper_thr);
</macro>
</line>

<line>
<button>
label=Extract Sample Bounding Box
arg=<macro>
	  hdf5_xml = getData("HDF5 XML");
other_channels = split(getData("Other Channels"),",");

auto_bounding_box(hdf5_xml, other_channels[0], 10);
</macro>
</line>

<line>
<button>
label=Deconvolution Parameters
arg=<macro>
deconParameters();
</macro>
</line>

<line>
<button>
label=Deconvolve
arg=<macro>
		   hdf5_xml = getData("HDF5 XML");
	   bead_channel = getData("Beads Channel");
	 other_channels = split(getData("Other Channels"), ",");

fuseDeconvolve(hdf5_xml, bead_channel, other_channels, "auto-box");
</macro>
</line>

<line>
<button>
label=Full Processing
arg=<macro>
exit("Currently Broken");
file_id = File.openDialog("First CZI file");


xml_file = define(file_id);
hdf5_xml = resave(xml_file);

     other_channels = split(getData("Other Channels"),",");
	   bead_channel = getData("Beads Channel");
	   downsample_z = getData("Z Downsample Factor");
	detection_sigma = getData("DoG Sigma");
detection_threshold = getData("DoG Threshold");
	 other_channels = split(getData("Other Channels"), ",");	   
	      lower_thr = getData("Lower Distance Thr");
	      upper_thr = getData("Upper Distance Thr");
	         ransac_err = getData("RANSAC Error");
descriptor_significance = getData("Descriptor Significance");
	     		 lambda = getData("Regularization Lambda");
	   icp_max_distance = getData("ICP Max Distance");
	       icp_max_iter = getData("ICP Max Iterations");

	       
detectBeads(hdf5_xml, bead_channel, downsample_z, detection_sigma, detection_threshold);
filterObjects(hdf5_xml, bead_channel, other_channels, lower_thr, upper_thr);
registerCoarse(hdf5_xml, bead_channel, ransac_err, descriptor_significance, lambda);
registerFine(hdf5_xml, bead_channel, icp_max_distance, icp_max_iter, lambda);
duplicateTransform(hdf5_xml, bead_channel);

// Detect Sample
detectBeads(hdf5_xml, other_channels[0], 2, 2.3, 0.005);
sample_channel = other_channels[0];
other_channels[0] = bead_channel;
// Clean Sample
filterObjects(hdf5_xml, sample_channel, other_channels, 0, 30);

registerFine(hdf5_xml, sample_channel, icp_max_distance, icp_max_iter, lambda);

auto_bounding_box(hdf5_xml, sample_channel, 10);


fuseDeconvolve(hdf5_xml, bead_channel, other_channels, "auto-box");
</macro>
</line>
<line>
<button>
label=Application
arg=<macro>
		   hdf5_xml = getData("HDF5 XML");

run("MultiView Reconstruction Application", "select_xml=["+hdf5_xml+"]");
</macro>

</line>

<line>
<button>
label=Clear Bounding Boxes
arg=<macro>
hdf5_xml = getData("HDF5 XML");
removeXMLTag(hdf5_xml,"BoundingBoxes");

</macro>

</line>