/* Michael Cammer  mcammer@gmail.com  cammem01@nyumc.org
    Macros for ImageJ  Java 1.8

    This collection of macros are the ones I like to have on hand most of the time.
    More at http://microscopynotes.com/imagej/index.html 
    
    Consider putting them in macros folder with name "StartupMacros.fiji.ijm" or "StartupMacros.ijm" so that they load automatically.

	Major updates as of Nov 2022 to add Z stack tools and clean up old code.
	See http://microscopynotes.com/imagej/selective_Z_project/index.html for instructions on how to use Z stack tools.
*/

var clipsize = 150;                // edge size of the box for clipping cells for montage
var snipwindow = -1;
var projectiondepth = 16;     // default depth for projection of variable depth
var tab = " \t";                         
var scalebarSize = 10;        // Scalebar size for simple merge with options     


//Require for Z projection macros
var zstart = -1;	// used by function selectiveZproject()
var zend = -1;		// used by function selectiveZproject()


/*  PULL DOWN MENU DEFINITIONS
 *   Use this to add commands for Distal and Nucleus and adding line segments.
 *   https://imagej.nih.gov/ij/macros/CustomPopupMenu.txt
 */
var pmCmds = newMenu("Popup Menu",
       newArray("First Slice", "Last Slice", "Project stack", "Show Overlays", "Hide Overlays", "Grays LUT", "Color LUT",
       "Brightness/Contrast...", "ROI Manager to front", "Save file as"));
/*  Right click on the image to get a pull down menu with useful commands.  Easy to add
 *   more commands as requested.
 */
macro "Popup Menu" {
	cmd = getArgument();
	if (cmd == "First Slice") setFirstSlice();
	if (cmd == "Last Slice") setLastSlice();
	if (cmd == "Project stack") selectiveZproject();
	if (startsWith(cmd, "Hide")) run("Hide Overlay");
	if (startsWith(cmd, "Show")) run("Show Overlay");
	if (startsWith(cmd, "Gray")) run("Grays");
	if (startsWith(cmd, "Color")) makeFavoriteAIFpseudocolorLUT();
	if (startsWith(cmd, "Bright")) run(cmd);
	if (startsWith(cmd, "ROI")) selectWindow("ROI Manager");	// does not work when minimized
	if (cmd == "Save file as") run("Tiff...");
  }




macro "Project stack with selective depth. [F11]" {
	selectiveZproject();
}
/*
 * Projects a selective range of Z series.
 * This version leaves the original file unchanged.
 * If function is called without a user selection of start & stop poistions, then set to 1 to max Z slices.
 * If function is called with a ROI on image, then cropped to the area and outside cleared to zero.
 * This version works on multichannel (composite color) stacks including time series where the default
 * is project all timepoints.
 * 
 */
function selectiveZproject() {
	Stack.getDimensions(width, height, channels, slices, frames); 
	if (slices == 1) exit ("Requires a Z series.");
	title = getTitleStripExtension();
	if (zstart < 1) zstart = 1;		// If user has not made selection, then project entire stack.
	if (zend < 1) zend = slices;	// If user has not made selection, then project entire stack.	

	if (zend < zstart) {
		temp = zstart;
		zstart = zend;
		zend = temp;
	}

	// if selection, check selection type.  If selection type good for cropping, then set flag to do crop after projection.
	selectionExists = false;
	if ((selectionType >=0) && (selectionType <= 4))
		selectionExists = true;
		
	run("Z Project...", "start=" + zstart + " stop=" + zend + " projection=[Max Intensity] all");
	rename (title + "_MAX" + zstart + "-" + zend);
		
	//If flag set for selection type, crop and clear.  
	if (selectionExists) {
		run("Restore Selection");
		run("Crop");
		run("Make Inverse");		// instead of clear outside to avoid setcolor and bit depth issues
		run("Set...", "value=0 stack");
		run("Make Inverse");
	}
		
	zstart = -1;	// reset for next use
	zend = -1;		// reset for next use
}


/*  The purpose of this tool is to set the current Z slice of a stack or hyperstack as the first slice
 *   for a maximum pixel projection.
 *   This can be set using the F9 key or the Macros pull down menu.
 *   Or it can be done by clicking on the Z0 tool button and then clicking on the image.
 *   A right click on image pull down menu option will be added later.
 */
macro "Set First Slice for projection [F9]" {
	setFirstSlice();
}
function setFirstSlice() {
	Stack.getPosition(channel, slice, frame); 	
	zstart = slice;
}


/*  The purpose of this tool is to set the current Z slice of a stack or hyperstack as the last slice
 *   for a maximum pixel projection.
 *   This can be set using the F10 key or the Macros pull down menu.
 *   Or it can be done by clicking on the Z1 tool button and then clicking on the image.
 *   A right click on image pull down menu option will be added later.
 */
macro "Set Last Slice for projection [F10]" {
	setLastSlice();
}
function setLastSlice() {
	Stack.getPosition(channel, slice, frame); 	
	zend = slice;
}

macro "Click to set first, last, project  Tool - N30 B08 C800 T4115Z " {  
	//setClickToProject();
	leftDivider = getWidth / 3;
	rightDivider = leftDivider * 2;
	getCursorLoc(x, y, z, flags);	
	if (x < leftDivider) 
		setFirstSlice();
	if (x > rightDivider) 
		setLastSlice();
	if ( (x < rightDivider) && (x > leftDivider) )
		selectiveZproject();
}










macro "Click to set first, last, project  Tool - N30 B08 C800 T4115Z " {  
	//setClickToProject();
	leftDivider = getWidth / 3;
	rightDivider = leftDivider * 2;
	getCursorLoc(x, y, z, flags);	
	if (x < leftDivider) {
		Stack.getPosition(channel, slice, frame); 
		zstart = slice;	
	}
	if (x > rightDivider) {
		Stack.getPosition(channel, slice, frame); 
		zstart = slice;	
	}
		zend = z+1;
	if ( (x < rightDivider) && (x > leftDivider) )
		selectiveZproject();
}





macro "---------------------------------" {}



/*===========================================================================
 * ** Multichannel plot profile makes in register intensity plots of multiple channels and overlays them.
 * ** This produces a graphical result based on the deafult plot profile command where the plot of each 
 * channel is the same LUT as in the image.
 * ** If the variable makeOutputTable = true, then a table is also created with the plot profiles
 * per channel.  This table may be saved to import the data into other software.  Set 
 * makeOutputTable = false to turn off table reporting.
 * ** Macro works on multichannel images of any number.  If you ever need more channels than assigned
 * to array processChannel, just add more.  For spectral images from the Zeiss 880, more channels
 * may be required.
 * You may choose which channels to pot and which to not plot.  In the array processChannel, 1 means plot 
 * the channel and 0 means don't plot the channel.
 * ** If run on a hyperstack Z or T series, only the current T &/or Z is operated on.
 * ** Macro operates on the channels set to 1 in the array processChannel.
 * ** Original LUTs are kept and applied.
 =============================================================================*/
macro "Multichannel plot profile" {
	//add error check for line
	makeOutputTable = true;	// set to false if don't want output table
	processChannel = newArray(1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0); // choose which channels to plot or not plot
	Stack.getDimensions(width, height, channels, slices, frames);
	original = getImageID;
	t = getTitleStripExtension();
	mergeString = "";
	newChannelNumber = 1;
	newExecution = true;
	for (c=1; c<=channels; c++) {
		if (processChannel[c-1]) {
			selectImage(original);
			Stack.setChannel(c);
			Color.getLut(reds, greens, blues);

			if (makeOutputTable) {
				profile = getProfile();
				if (newExecution) {		// create a new output table
					getPixelSize(unit, pixelWidth, pixelHeight);
					run("Set Measurements...", "area redirect=None decimal=2");
					run("Measure");
					distances = newArray(profile.length);
					pixelSize = getResult("Length", nResults-1) / profile.length;  // um per pixel
					for(d=0; d<profile.length; d++)
						distances[d] = d * pixelSize;
					Table.create(t + "_results"); 
					Table.setColumn(unit, distances); 
					newExecution = false;
				}
				Table.setColumn("ch"+c, profile); 
				Table.update;
			}

			selectImage(original);
			run("Plot Profile");
			run("Invert");
			Color.setLut(reds, greens, blues);
			rename("plot_ch" + c);
			//run("Merge Channels...", "c1=plot_ch2 c2=plot_ch3 create");
			mergeString = mergeString + "c" + newChannelNumber + "=" + getTitle + " ";
			newChannelNumber++;
		}  // process channel
	} 	// for each channel
	run("Merge Channels...", mergeString + " create");
	rename (t + "_plot");
	selectWindow(t + "_results"); 
}

/*===============================================================================
 * Macro to clean up titles of images based on file names with multiple extensions or
 * other unnecessary info.  Edit as needed.
 * This was written to be stand alone (calls no functions) so it can be run by Ctrl-Shift-R
 */
 macro "Clean up all open image names" {
 	for (n=1; n<=nImages; n++) {
 		selectImage(n);
 	 	t = getTitle();
		extensions = newArray(".tif", ".tiff", ".lif", ".lsm", ".czi", ".nd2", ".ND2", ".oir", ".png", ".jpg");    
 		for(i=0; i<extensions.length; i++)
    		t = replace(t, extensions[i], "");  
    	t = replace(t, "- Image", "");
    	rename(t);	
 	}
 }

/*===============================================================================
 * Saves all open images to the directory in path.
 * Replace first line with commands for interactively entering the path or save one file with the recorder
 * open and copy the path from the recorder.
 */
macro "Save all open images" {
	path = "R:/MicroscopyCore/mcammer/Aifantis lab/Xufeng Chen/colocalization 2023/samples from 230227 293T_H10 S6 transfection BafA1_4hrs (non shift)/";
	 for (n=1; n<=nImages; n++) {
 		selectImage(n);
 	 	t = getTitle();
		saveAs("Tiff", path + t);
 	}
}




/* =============================================================
Should be updated each time macros are edited
*/
function checkCurrentVersion() {
  requires('1.52f');
}







/*    This macro makes kymograms of all ROIs in a ROI Manager meant to report intensity change through time, such as for Ca++ indicator imaging.
 *    Input required is a stack and a ROIManager populated with features that are static in XY to be measured through
 *    time. 
 *    It was originally written for cells that were approximately 12 pixels wide, thus the makeLine command is hard coded
 *    for a line 19 pixels wide, but this may be changed.  (Instead of all kymograms stacked and montaged at the end, they could
 *    be montaged as the macro progresses if each one is a different width.)
 *    At the end, all kymograms are stacked and montaged.
 *    A vertical line drawn down the kymograms can be used to report intensity through time.
 */


macro "Kymograms from all ROI Manager selections" {
	t = getTitleStripExtension();
	rename(t);
	run("Set Measurements...", "area mean min centroid integrated redirect=None decimal=3");
	for (i=0; i< roiManager("count"); i++) {
		selectImage(t);
		roiManager("select", i);
		run("Measure");
		x = getResult("X", nResults-1);
		y = getResult("Y", nResults-1);
		toUnscaled(x, y);
		makeLine(x-9, y, x+9, y);
		run("Reslice [/]...", "output=1.000 slice_count=1 avoid");
		rename(t + "timesliced" + IJ.pad(i,3));
	}
	run("Images to Stack", "  title=time use");
	rename(t + "_kymograms");
	makeFavoriteAIFpseudocolorLUT();  		// optional LUT for showing intensity changes high contrast
	run("Make Montage...", "columns="+nSlices+" rows=1 scale=1 border=1");
	rename(t + "_kymograms-montage");
}  // Kymograms from all ROI Manager selections

/*  ============================================================
WITH OPTIONS SIMPLE FIGURE BASED ON MULTICHANNEL IMAGE DISPLAYED AS IS
version 20200108
Makes a montage figure based on a composite image as displayed.
The required input is a composite color image.  Use adjusts the channels to desied colors and contrast.
Running the macro either merges an entire image or the region of interest selected by user.  
Uses existing contrast without further prompts.
But there is a prompt when there are 3, or more channels to find out whether all images in one row or two rows.
*/
macro "Simple montage figure with options" {
  requires("1.52f");
  Stack.getDimensions(width, height, channels, slices, frames);
  getVoxelSize(width, height, depth, unit);
  if ( (slices>1) || (frames>1) ) exit("Only works for single Z, time, or position images.\nAsk for modification if you need implemented.");
  if ( (slices > 1) || (frames > 1)  ) exit("Requires single Z and single timepoint image");
  if (channels < 2) exit("Requires composite color image.");
  title = getTitleStripExtension();
  if (channels < 2) exit("Not a composite image with 2 or more channels.");
  if (channels == 2) { 
    Dialog.create("get montage info");
    Dialog.addNumber("Size of scalebar ("+unit+"): ", scalebarSize);
    Dialog.show;
    scalebarSize = Dialog.getNumber();
    montageX=3;   montageY=1; }
  if (channels == 3) {
    Dialog.create("get montage info");
    //Dialog.addMessage();
    Dialog.create("Radio Buttons");
    items = newArray("One row of four panels", "2 X 2 panels");
    Dialog.addRadioButtonGroup("Three channels will result in four panels.\nClick which layout preferred.", items, 2, 1, "");
    Dialog.addNumber("Size of scalebar ("+unit+"): ", scalebarSize);
    Dialog.show;
    if ( Dialog.getRadioButton == "One row of four panels") { montageX=4;   montageY=1; }
    else { montageX=2;   montageY=2; }
    scalebarSize = Dialog.getNumber();
  }
  if ((channels==4) || (channels==5)) {
    Dialog.create("get montage info");
    Dialog.create("Radio Buttons");
    items = newArray("One row of panels", "3 X 2 panels");
    Dialog.addRadioButtonGroup("Click which layout preferred.", items, 2, 1, "");
    Dialog.addNumber("Size of scalebar ("+unit+"): ", scalebarSize);
    Dialog.show;
    if ( Dialog.getRadioButton == "One row of panels") { 
      montageX=channels+1;
      montageY=1; }
    else { montageX=3;   montageY=2; }
    scalebarSize = Dialog.getNumber();
  }
  if (channels > 5) exit("Not programmed for more than 5 channels; ask for modification if you need this.");
  simpleMergeAndMontageWithOptions (title, montageX, montageY);
}

macro "Make RGB into Grayscale" {
	originalImage = getImageID();
	run("Duplicate...", " ");
	rename("TEMP");
	run("RGB Stack");
	run("Z Project...", "projection=[Max Intensity]");
	rename("TEMP2");
	run("RGB Color");
	run("Select All");
	run("Copy");
	close("TEMP*");
	selectImage(originalImage);
	run("Paste");
	run("Select None");
}





/* =========================================
WITH OPTIONS This function does the work of montaging.
It takes a number of arguments.
title = text  Title of the image, will have montage added to it.
montageX = integer  How many columns in montage.
montageY = integer   How many rows in montage.
To be implemented in future:
grayscale = true/false  To be coded someday.  This directs the function whether to use LUTs as is or make individual panels in grayscale.
*/
function simpleMergeAndMontageWithOptions (title, montageX, montageY) {
  run("Duplicate...", "duplicate");
  rename(title);
  original = getImageID;
  run("RGB Color");   // This should make a new window
  run("Select All");
  run("Copy");
  setPasteMode("Copy"); 
  close();
  selectImage(original);
  Stack.setDisplayMode("color");
  run("RGB Color");
  run("Hyperstack to Stack");
  setSlice(nSlices);
  run("Add Slice");
  run("Paste");
  run("Scale Bar...", "width="+scalebarSize+" height=4 font=14 color=[White] background=None location=[Lower Right] bold");
  run("Colors...", "foreground=white background=black selection=yellow");
  if ((nSlices==5) & (montageY == 2)) {    //  Make the last panel white if 3 x 2 with only five panels.
    run("Add Slice");
    run("Select All");
    run("Fill", "slice");
  }
  run("Select None");
  run("Make Montage...", "columns="+montageX+" rows="+montageY+" scale=1 border=2 use");
  rename(title+"_montage");
  close(title);
  close(title+" (RGB)");
//Following steps copy the result to the system clipboard for pasting into another application.  Only tested on win7.
  run("Select All");
  run("Copy to System");
  run("Select None");
}














/*  ============================================================
SIMPLE FIGURE BASED ON MULTICHANNEL IMAGE DISPLAYED AS IS
version 20180930
Makes a montage figure based on a composite image as displayed.
The required input is a composite color image.  Use adjusts the channels to desied colors and contrast.
Running the macro either merges an entire image or the region of interest selected by user.  
Uses existing contrast without further prompts.
But there is a prompt when there are 3, or more channels to find out whether all images in one row or two rows.
*/
macro "Simple montage figure" {
  requires("1.52f");
  Stack.getDimensions(width, height, channels, slices, frames);
  if ( (slices>1) || (frames>1) ) exit("Only works for single Z, time, or position images.\nAsk for modification if you need implemented.");
  if ( (slices > 1) || (frames > 1)  ) exit("Requires single Z and single timepoint image");
  if (channels < 2) exit("Requires composite color image.");
  title = getTitleStripExtension();
  if (channels < 2) exit("Not a composite image with 2 or more channels.");
  if (channels == 2) { montageX=3;   montageY=1; }
  if (channels == 3) {
    Dialog.create("get montage info");
    //Dialog.addMessage();
    Dialog.create("Radio Buttons");
    items = newArray("One row of four panels", "2 X 2 panels");
    Dialog.addRadioButtonGroup("Three channels will result in four panels.\nClick which layout preferred.", items, 2, 1, "");
    Dialog.show;
    if ( Dialog.getRadioButton == "One row of four panels") { montageX=4;   montageY=1; }
    else { montageX=2;   montageY=2; }
  }
  if ((channels==4) || (channels==5)) {
    Dialog.create("get montage info");
    Dialog.create("Radio Buttons");
    items = newArray("One row of panels", "3 X 2 panels");
    Dialog.addRadioButtonGroup("Click which layout preferred.", items, 2, 1, "");
    Dialog.show;
    if ( Dialog.getRadioButton == "One row of panels") { 
      montageX=channels+1;
      montageY=1; }
    else { montageX=3;   montageY=2; }
  }
  if (channels > 5) exit("Not programmed for more than 5 channels; ask for modification if you need this.");
  simpleMergeAndMontage (title, montageX, montageY);
}

/* =========================================
This function does the work for Simple merge as is.
It takes a number of arguments.
title = text  Title of the image, will have montage added to it.
montageX = integer  How many columns in montage.
montageY = integer   How many rows in montage.
To be implemented in future:
grayscale = true/false  To be coded someday.  This directs the function whether to use LUTs as is or make individual panels in grayscale.
*/
function simpleMergeAndMontage (title, montageX, montageY) {
  run("Duplicate...", "duplicate");
  rename(title);
  original = getImageID;
  run("RGB Color");   // This should make a new window
  run("Select All");
  run("Copy");
  setPasteMode("Copy"); 
  close();
  selectImage(original);
  Stack.setDisplayMode("color");
  run("RGB Color");
  run("Hyperstack to Stack");
  setSlice(nSlices);
  run("Add Slice");
  run("Paste");
  run("Scale Bar...", "width=10 height=4 font=14 color=[White] background=None location=[Lower Right] bold");
  run("Colors...", "foreground=white background=black selection=yellow");
  if ((nSlices==5) & (montageY == 2)) {    //  Make the last panel white if 3 x 2 with only five panels.
    run("Add Slice");
    run("Select All");
    run("Fill", "slice");
  }
  run("Select None");
  run("Make Montage...", "columns="+montageX+" rows="+montageY+" scale=1 border=2 use");
  rename(title+"_montage");
  close(title);
  close(title+" (RGB)");
//Following steps copy the result to the system clipboard for pasting into another application.  Only tested on win7.
  run("Select All");
  run("Copy to System");
  run("Select None");
}






//===========================================================================
//  This macro takes all open stacks and projects them.  Depending on the filename, in this case
//  "C=#", the projection method may be different.  The projection command automatically names
//  the new windows with the type of projection followed by the original filename.
//===========================================================================
macro "Project all open stacks" {
  projectAllOpenStacks();
}  // "Project all open stacks"

function projectAllOpenStacks(){
  n = nImages();
  for (i=1; i<=n; i++) {
    selectImage(i);
    t = getTitleStripExtension();
    if (  endsWith(getTitle(), "C=2")  )   
      run("Z Project...", "start=1 stop="+nSlices+" projection=[Min Intensity]");
    else 
      run("Z Project...", "start=1 stop="+nSlices+" projection=[Max Intensity]");
    rename(t+"_proj");
  } // for i
}  // end projectAllOpenStacks()


//===============================================================================
// Extracts the nth slice from a timelapse or Z stack.
//===============================================================================
macro "Extract nth slices from stacks"  {
 extract_all_nth_timepoints(2);                       // change the number in this command to the required slice
}

function extract_all_nth_timepoints(extract) {        // extract is an integer between 1 and nSlices
  n = nImages();
  for (i=1; i<=n; i++) {
    selectImage(i);
    t = getTitleStripExtension();
    setSlice(extract);
    title = "M" + extract + "_" + getTitle;
    run("Duplicate...", "title="+title);
    rename(t+"_s" + extract);
  } // for i
}


macro "=========================="{}

//==============================================================
// This is for when you already have color images.
//macro "box location" {
//  getCursorLoc(x, y, z, mousestate);
//  makeRectangle(x-(boxsize/2),y-(boxsize/2), boxsize, boxsize);
//}

macro "Make snipping box" {
  makeRectangle(10,10, clipsize, clipsize); }

//==============================================================
macro "snip out the box [F5]" {
  roiManager("Add");
  run("Duplicate...", "title=[snip]");
}


//=============================================================================
//  calls function clipCellAndPopOnStack(original, clipstack);
//
macro "clip all ROIs in Roi Manager, center, and put in stack for montage" {
  original = getImageID;
  t = getTitle;
  bits = bitDepth();
  if (bits == 24) bitstring="RGB";
  else bitstring = ""+bits+"-bit";
  clipsize = getNumber("Enter side of square box in pixels: ", clipsize);
  setPasteMode("Copy");
  setBatchMode(true);
  newImage("snippedstack "+ t, bitstring+" Black", clipsize, clipsize, 1);
  clipstack = getImageID;
  for (i=0;  i<roiManager("count");  i++){
    selectImage(original);
    roiManager("select", i);
    clipCellAndPopOnStack(original, clipstack);
  }  // for  i
  selectImage(clipstack);
  run("Delete Slice");
  run("Select None");
  setBatchMode(false);
  resetMinAndMax();
}  // macro "clip multiple ROIs in a stack and put in stack for montage"

//=======================================================================
// The ROI of the cell is selected and the original image is active before this function is called.
//  clipstack contains the imageID of the clipped stacks window.
//=======================================================================
function clipCellAndPopOnStack(original, clipstack) {
  requires("1.45m");
  run("Set Scale...", "distance=1 known=1 pixel=1 unit=px");
  run("Set Measurements...", "  centroid area redirect=None decimal=0");
  run("Measure");
  xc = getResult("X", nResults-1);
  yc = getResult("Y", nResults-1);
  selectWindow("Results");
  run("Close");
  selectImage(original);
  makeRectangle(xc-(clipsize/2), yc-(clipsize/2), clipsize, clipsize);
  run("Copy");
  run("Select None");
  setPasteMode("Copy");
  selectImage(clipstack);
  run("Paste");
  run("Add Slice");
}  // clip cell  




macro "^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^"{}
/*===========================================================================
 * Multichannel plot profile makes in register intensity plots of multiple channels and overlays them.
 * This is a graphical result only; numerical values are not saved.
 * It works on multichannel images of any number.
 * If run on a hyperstack Z or T series, only the current T &/or Z is operated on.
 * It operates on the channels set to 1 in the array processChannel.
 * Original LUTs are kept and applied.
 =============================================================================*/
macro "Multichannel plot profile" {
	//add error check for line
	processChannel = newArray(1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); 
	Stack.getDimensions(width, height, channels, slices, frames);
	original = getImageID;
	t = getTitleStripExtension();
	mergeString = "";
	newChannelNumber = 1;
	for (c=1; c<=channels; c++) {
		if (processChannel[c-1]) {
			selectImage(original);
			Stack.setChannel(c);
			Color.getLut(reds, greens, blues);
			run("Plot Profile");
			run("Invert");
			Color.setLut(reds, greens, blues);
			rename("plot_ch" + c);
			//run("Merge Channels...", "c1=plot_ch2 c2=plot_ch3 create");
			mergeString = mergeString + "c" + newChannelNumber + "=" + getTitle + " ";
			newChannelNumber++;
		}  // process channel
	} 	// for each channel
	print (mergeString);
	run("Merge Channels...", mergeString + " create");
	rename (t + "_plot");
}


//=============================================================================
/*
  Framework for iterating through ROI Manager list and spitting out measurments in the Log window.
  In this version, intensity and area are measured.  A band is drawn around the outside of the area and this
  mean intensity is treated as the background which is subtracted from the mean of the ROI.
  
  Ideas for future version:  delete the band measurement from the results table and insert the BG adjusted
  value into the results table.
*/
macro "measurements in ROI Manager list"{
  run("Set Measurements...", "area mean standard shape redirect=None decimal=3");
  numberCells = roiManager("count");
  print(getTitle);
  print("Area \t Mean");
  for (i=0; i<numberCells; i++) {
    roiManager("select", i);
    run("Measure");
    run("Enlarge...", "enlarge=2 pixel");
    run("Make Band...", "band=1");   // 1 um band
    run("Measure");
    mean = getResult("Mean", nResults-2) - getResult("Mean", nResults-1); 
    out = "" + getResult("Area", nResults-2) + " \t " + mean;
    print(out);
  } // for i

}



//=====================================================================================
// Timelapse macros v115   November 2011
//  Macro for ImageJ by Michael Cammer michael@coxcammer.com
//  A roundish (or circular, but with pixel edges, not vectors) ROI is drawn on a timelapse stack such that the 
//  center of the circle is the centroid of the feature to be measured over time and that the entire object at every 
//  time is contained within the perimeter.
//  Then radii spaced by step size perimeter / n step around and are resampled in the time axis
//  and pasted into a new window.
//  After I wrote this, somebody posted a similar plugin version at http://rsbweb.nih.gov/ij/plugins/radial-reslice/
//  This macro produces radial reslices from the center out.  The original version of this reslicing went from the
//  periphery such that the alignment was along the traced outer edge and could be used for the annuluar 
//  intensity and spatial distribution in relation to the outer edge of spreading cells instead of in relation to the center
//  and some slices never even went to the very center.
//=====================================================================================
macro"Radial Sweep as a circle"{
  requires("1.45m");
  run("Set Scale...", "distance=1 known=1 pixel=1 unit=px");
  number_of_radii = 360;                            // number of pixels on perimeter of circle to be sampled.
  run("Set Measurements...", "  centroid redirect=None decimal=0");
  run("Measure");
  xc = getResult("X", nResults-1);
  yc = getResult("Y", nResults-1);
  selectWindow("Results");
  run("Close");
  slices = nSlices();

  step = 2 * PI / number_of_radii;
  extrasteps = 16;  // allows for overshooting to adjust for when slices are projected together

  maxradius = 5 + round(calculateMaximumRadius()/2);  // this is to find the longest radius to make a new window this width or to rescale the shorter lines this length
  original = getImageID();
  originaltitle = getTitle();
  bits = bitDepth();
  newtitle = "reslice_"+originaltitle+"";
  newslices = 1+ number_of_radii + extrasteps;
  newbits = "" + bits + "-bit Black";
  newImage(newtitle, newbits, maxradius, slices, newslices);
  stream = getImageID();

  setBatchMode(true);

  setPasteMode("Copy");
  s=1;
    for (i=0; i<2*PI+(step*extrasteps); i=i+step) {
      edgex = xc + maxradius * sin(i);
      edgey = yc + maxradius * cos(i);
      selectImage(original);
      makeLine(xc, yc, edgex, edgey);
      run("Reslice [/]...", "input=1.000 output=1.000 start=Top");
      run("Select All");
      run("Copy");
      run("Close");
      selectImage(stream);  
      setSlice(s); 
      s++;
      run("Paste");
  }  //for i
 setBatchMode(false);
 resetMinAndMax();
 //projectStackVariableWidth("Max Intensity", 4);
}  //macro("Radial Sweep")

//=========================================================
// This function is required by the macro "Diameter Sweep" to calculate the
// longest possible radius if the selection is non-circular.
// Uses Feret's diameter.
function calculateMaximumRadius (){
  run("Clear Results");
  run("Set Measurements...", "  mean feret's redirect=None decimal=3");
  run("Measure");
  diameter = getResult("Feret",(0));
  selectWindow("Results");
  run("Close");
  return (diameter);
} // function calculateMaximumRadius







//===========================================================================
macro "Change Values (set NaN)"{          // as implemented, does not work on multichannel hyperstacks for individual channels
  run("32-bit");
  for (i=1; i<=nSlices(); i++){  
    setSlice(i);
    changeValues(0,200 ,NaN); 
    }
}


/*================================================================
 * Floating means that each image has the same mean pixel value and the same standard deviation.
 * I find it useful as it means the same threshold can often be used on all the images.
 * However, it may increase salience of noise.
 * See http://microscopynotes.com/imagej/float/ for explanation.
 * Originally by Kenton Arkill [underwaterginge@GMAIL.COM].  I made some modifications.
 * Uses current slice as reference.
 * Note for usage:
 * Multiplying each slice by an incremented constant or number as a function of slice number
 * may be a better enhancement in cases where some slices have very little signal.  
 *================================================================ */
macro "Float the stack"{
	floatStack();
}
function floatStack() {
	run("Select None");
	currentSlice = getSliceNumber();	// At the end, display the same slice as when called.
	run("32-bit");
	// setSlice(1);
  // COmmented out uses current slice as reference.
	getRawStatistics(nPixels, meanref, min, max, stdref, histogram);
	for (i = 1; i <= nSlices; i++) {
       setSlice(i);
	
       getRawStatistics(nPixels, meani, min, max, stdi, histogram);
       run("Subtract...", "value="+meani+" slice");
       run("Divide...", "value="+stdi+" slice");
       run("Multiply...", "value="+stdref+" slice");
       run("Add...", "value="+stdref+" slice");
  }
  run("Enhance Contrast", "saturated=0.35");
  setSlice(currentSlice);
				// Display the same slice as when called.
}



/*================================================================
 * Floating means that each image has the same mean pixel value and the same standard deviation.
 * See macro and function above. 
 * This version allows for a lower threshold to eliminate lower intensity pixels from the calculation.
 * It will fail, however, if there are no pixel values above the threshold.
 * 
 * THIS IS STILL BEING TESTED
 * 
 *================================================================ */
macro "Float the stack with lower bound"{
	floatStackLowerBound(3);
}
function floatStackLowerBound(minimumIntensity) {
	run("Select None");
	currentSlice = getSliceNumber();	// At the end, display the same slice as when called.
	run("32-bit");
	run("Set Measurements...", "mean standard modal min limit redirect=None decimal=2");
	setThreshold(9.7600, 1000000000000000000000000000000.0000);
	//getRawStatistics(nPixels, meanref, min, max, stdref, histogram);
	List.setMeasurements("limit"); 		// enables the "Limit to threshold" option
	stdref = List.getValue("StdDev");
	   meanref = List.getValue("Mean");  print(meanref);  // only for debugging
	for (i = 1; i <= nSlices; i++) {
       setSlice(i);
       //getRawStatistics(nPixels, meani, min, max, stdi, histogram);
       List.setMeasurements("limit"); 	// enables the "Limit to threshold" option
       meani = List.getValue("Mean");
       stdi = List.getValue("StdDev");
       run("Subtract...", "value="+meani+" slice");
       run("Divide...", "value="+stdi+" slice");
       run("Multiply...", "value="+stdref+" slice");
       run("Add...", "value="+stdref+" slice");
  }
  run("Enhance Contrast", "saturated=0.35");
  setSlice(currentSlice); 				// Display the same slice as when called.
}





//==============================================
macro "correct depth light absorption" {
  for (i=1; i<=60; i++){
    setSlice(i);
    multby = 1+ ((nSlices-i) / nSlices);
    run("Multiply...", "value="+multby+" slice");
  }
}
//-----------------------------------------------
macro "Multiply to fix bleaching based on ROI"{
  //checkCurrentVersion();
  original = getImageID();
  run("Set Measurements...", "  mean  redirect=None decimal=0");
  run("Plot Z-axis Profile");    run("Close"); 
  standard = getResult("Mean",(0));
  selectImage(original);
  for (i=1; i<=nSlices; i++){
    bgmean = standard / getResult("Mean",(i-1));
    run("Set Slice...", "slice="+i);
    run("Select All");
    run("Multiply...", "slice value="+bgmean);
  } // for
  run("Select None");
  selectWindow("Results");
  run("Close");
} // macro 'Multiply to fix bleaching based on ROI'


//===================================================================
//  This macro measures the same region of interest in each slice of a stack and subtracts the mean plus
//  specified standard deviation of the mean from each corresponding slice.  It is useful for situations where
//  there is background intensity changing over time due to something like a flickering light source and you 
//  want the stack's background to be uniform.  It may not be appropriate for situations where precise intensity
//  measurements will be made that should be uniform through the stack.  Subtracting one constant from the
//  entire stack is likely better.
//  To use, put a ROI over a region that is background in all slices.  (Choose the ROI on a maximum pixel 
//  projection if features to assure only bg pixels are included.)  Run the macro.
//
macro "Subtract background based on ROI" {
  n = 0;  // this is the number of standard deviations to add to the mean bg to subtract
  checkCurrentVersion();
  image_to_process = getImageID();
  run("Set Measurements...", "  mean  standard  redirect=None decimal=2");
//  run("Plot Z-axis Profile");    // With IJ 1.51 this command no longer send results to the Results window so rewritten with a measurements loop here.
//  run("Close"); 
//  selectImage(image_to_process);
  run("Measure");
  run("Clear Results");
  for (i=1; i<=nSlices; i++){
    run("Measure");
  } // for loop

  run("Select All");
  for (i=1; i<=nSlices; i++){
    bgmean=getResult("Mean",(i-1)) + n*getResult("StdDev",(i-1));
    run("Set Slice...", "slice="+i);
    run("Subtract...", "slice value="+bgmean);
  } // for loop
  run("Select None");
  run("Min...", "value=0 stack");
  resetMinAndMax();
} // Subtract background based on ROI





/*  This macro requires a grayscale stack any bit depth as input.
It duplicates this stack twice, thus requiring sufficient RAM.
The output is 8 bit per channel RGB.
*/
macro "RGB merge adjacent slices into a new stack"{
  //checkCurrentVersion();
  original = getImageID();
  t = getTitleStripExtension(); 
  run("Select None");
  rename("red");
  run("Duplicate...", "title=green duplicate");
  setSlice(1);
  run("Select All");
  run("Copy");
  run("Add Slice");
  run("Paste");
  run("Set...", "value=0 slice");
  run("Select None");
  run("Duplicate...", "title=blue duplicate");
  run("Add Slice");
  selectWindow("red");
  setSlice(nSlices);
  run("Add Slice");
  run("Add Slice");
  selectWindow("green");
  setSlice(nSlices);
  run("Add Slice");
  run("Merge Channels...", "c1=red c2=green c3=blue");
  rename(t+"_runRGB");
} //RGB merge adjacent slices into a new stack



/*
	==================================================================
    This macro is for making a movie of a stack that loops, especially useful for animated GIFs of 3D projections
     that rock back and forth.  Downside:  doubles the size of the stack.
*/
macro "Loop stack" {
    t = getTitle();
    run("Duplicate...", "title=xyztemp duplicate");
    run("Reverse");
    run("Concatenate...", "  title="+t+"_3D image1=["+t+"] image2=[xyztemp] image3=[-- None --]");
}




macro "make test stack for Projections of variable width" {
  size = 25;
  slices = 50;
  width = 256;
  newImage("Untitled", "8-bit black", width, width, slices);
  setColor(255, 255, 255);
  for (i=1; i<slices+1; i++) {
    setSlice(i);
    x = ((i * size) % width);
    y = size * floor ((i*size)/width) + size;
    //print(x,y);
    drawString(""+i ,x , y);
    //makeRectangle(x, y, 10, 10);
    //run("Fill", "slice");
  }
  run("Projections of variable width")
}


//=================================================================
macro "paste with subtract adjacent slices"{
  checkCurrentVersion();
  original = getImageID();
  selectImage(original);    
  setPasteMode("Subtract"); 
  for (i=2;i<=nSlices;i++) {
    run("Set Slice...", "slice="+i);  
    run("Select All");  
    run("Copy");
    run("Set Slice...", "slice="+(i-1));  
    run("Paste");
  }
  selectImage(original); 
  run("Select None");
  run("Set Slice...", "slice="+nSlices); 
  run("Delete Slice");
  run("Set Slice...", "slice="+1);  
  run("Delete Slice");
  run("Brightness/Contrast...");
}  // end  "paste with subtract adjacent slices"


//==================================================================
/*  Version edited 20161002 corrects the global variable projectiondepth getting set to NaN.  It is
    now set correctly to the zdepth entered by the user to be recycled the next time the macro is run.
    A global could also be added for projection type.
*/
macro "Projections of variable width"{
  projtypes = newArray("Max Intensity", "Average Intensity", "Standard Deviation", "Min Intensity", "Median");
  Dialog.create("Projections of variable width");
  Dialog.addMessage("Each slice of the stack is replaced with a projection of the depth\ndefined.");
  Dialog.addChoice("Label", projtypes, "Max Intensity");
  Dialog.addNumber("Slices to project: ", projectiondepth);
  Dialog.show();
  projection = Dialog.getChoice();
  projectiondepth = Dialog.getNumber();
  projectStackVariableWidth(projection, projectiondepth);
}  // Projections of variable width

//==================================================================
/*  Version edited 20161002 corrects the number of slices projected.  Previous versions did zdepth+1 slices.
     Also projects maximum number available.  Previous version stopped one short of the end.
     Also, the slices out to the end are projected at progressively shorter depths.
*/
function projectStackVariableWidth(projtype, zdepth) {
  setBatchMode(true);
  setPasteMode("Copy");
  original = getImageID();
  end = nSlices();
  for (i=1; i<end; i++){
    stop = i + zdepth - 1;
    if (i<(end - zdepth + 2)) 
      run("Z Project...", "start=" + i + " stop=" + stop + " projection=["+projtype+"]");
    else
      run("Z Project...", "start=" + i + " stop=" + end + " projection=["+projtype+"]");
    run("Select All");
    run("Copy");
    run("Close");
    selectImage(original);
    run("Set Slice...", "slice=" + i);
    run("Paste");
  }
  setBatchMode(false);
  run("Select None");
} // end projectStackVariableWidth()

//X================================================X
macro "measure mean  intensity above threshold" {
  // only works on 8 and 16 bit images
  for (s=1; s<=nSlices; s++){
    setSlice(s);
    histogramAboveThreshold(1.01);
  }
}

function histogramAboveThreshold(threshold) {
  getHistogram(values, a, 256);
  counts = 0;
  sum = 0;
  for (i=threshold; i<a.length; i++){
    sum = sum + (i * a[i]);
    counts = counts + a[i];
  }
  print(sum/counts);
}

//===========================================================
// This macro returns stacks resliced from the left by run("Reslice [/]...", "output=1.000 start=Left");
// to their original XYZ orientation.
macro "reorient left resliced stack" {
  run("Reslice [/]...", "output=1.000 start=Top");
  run("Rotate 90 Degrees Right");
  run("Flip Horizontally", "stack");
}


/* 	User manually puts in first and last slice number to have processed.
 *  Same iterative loop for drawing a feature, such as an arrow, through a range of slices.
 */
macro "multiple range by a constant"{
  for (i=90; i<=nSlices; i++){
    setSlice(i);
    multby = 1.8;
    run("Multiply...", "value="+multby+" slice");
  }
}

//================================================================
//This macro is for drawing a ROI onto a range of serial slices of a stack.
//1.  Draw the ROI.
//2.  Add it to the manager (ctrl-t).
//3.  Choose the color using Edit>Options>Colors...
//4.  Run this macro.
//
macro "draw ROI  on range of slices in stack"{
  checkCurrentVersion();
  image_to_process = getImageID();  
  Dialog.create("draw on slices...");
  Dialog.addNumber("first slice to draw on", 1);
  Dialog.addNumber("last slice to draw on", nSlices());
  Dialog.show();
  first =  Dialog.getNumber();
  last = Dialog.getNumber();
  if (last < first) { temp=first; first=last; last=temp; }
  if (first < 1) exit("first slice must be 1 or greater");
  if (last > nSlices()) exit("last slice must be the stack size or smaller");
  n = roiManager("count");  // get the last ROI in the manager  
  selectImage(image_to_process);
  roiManager("select", n-1);
  for (i=first; i<=last; i++){
    setSlice(i);
    run("Draw", "slice");
  } // for loop
  run("Select None");
  resetMinAndMax();
} // draw ROI  on range of slices in stack






//==============================================


macro "shift channel fixed amount to correct registration" {
	ch = 2;
	xoffset = -4;
	yoffset = 5;
	setPasteMode("Copy");
	getDimensions(width, height, channels, slices, frames);
	for (f=1; f<=frames; f++){
		Stack.setFrame(f);
		Stack.setChannel(ch);
		run("Select All");
		run("Copy");
		Roi.move(xoffset, yoffset);
		run("Paste");
	}
	run("Select None");
}



//=====================================================================================
//  This macro is not ready for general use because it requires programming to work right.
//  In its current state it moves the field a fixed amount per step and this amount is 1/22.
macro "Drift Compensation" {
  setPasteMode("Copy");
  for (i=0; i<nSlices; i++) {
    setSlice(i+1);
    makeRectangle(30, 24, 463, 466);
    run("Copy");
    makeRectangle(30, 24-(i/22), 463, 466);
    run("Paste");
  }  // for i
}  //  Drift Compensation


//=======================================================================================
// Pearson's correlation added to stacks macros on 14 June 2011
//=======================================================================================

//**************************************************************
//Macros to implement Pearson's coefficient analysis of digital images.      
//michael.cammer@med.nyu.edu
//Pearson's section written and tested  10 March 2004.
//Additions written October 2010.
//This version requires two stacks.  
//**************************************************************

macro "Pearson's coefficient of ROI" {
  requires("1.32c");
  // This section gets the titles of the images to operate on and converts them to PIDs.
  if (nImages<1) exit ("No image windows are open");   
  titlelist = newArray(nImages);                                      // titles of all open windows
  for (i=1; i<=nImages; i++) {
    selectImage(i);
    titlelist[i-1] = getTitle;
    run("Put Behind [tab]");
  }
  Dialog.create("scatterplot two images")
  Dialog.addMessage("Please pick two images to be compared.\nIf two different images have the same file name, results are unpredictable.");
  Dialog.addChoice("first image", titlelist);
  reversetitlelist = Array.invert(titlelist);
  Dialog.addChoice("second image", reversetitlelist);
  Dialog.show();
  image1 = Dialog.getChoice();
  image2 = Dialog.getChoice();
  print(image1, image2);
  selectWindow(image1);              // get image names and convert them to PIDs because these are more robust for use later.
  image1n = getImageID;
  selectWindow(image2);
  image2n = getImageID;

  for (i=1; i<=nSlices; i++){
    convertISlicesTo1Darrays(image1, image2, i);
  }
}  // end macro Pearson's


//***********************************************************************
// function convertImagesTo1Darrays(image1n, image2n);
// image1 and image2 are the PIDs of the stacks to be compared.
// The images are converted to 1D arrays that can be compared directly without graphics calls.
//***********************************************************************
function convertISlicesTo1Darrays(image1, image2, slice) {
  pixels = getWidth() * getHeight();
  cf = newArray(pixels);
  pip = newArray(pixels);
    arrayindex=0;
    selectImage(image1);  
    setSlice(slice);
    for (x=0; x<getWidth(); x++)
      for (y=0; y<getHeight(); y++){
        cf[arrayindex] = getPixel(x, y);
        arrayindex++;
      } // end for x and y loops
    
    arrayindex=0;
    selectImage(image2);
    setSlice(slice);
    for (x=0; x<getWidth(); x++)
      for (y=0; y<getHeight(); y++){
        pip[arrayindex] = getPixel(x, y);
        arrayindex++;
      } // end for x and y loops
     
  coef = calculateCoefficient(cf, pip);  
}  //end function convertSlicesTo1Darrays()


//*****************************************************************
// function calculateCoefficient(a, b);
// The function is passed two arrays of integers.  The arrays must be of
// equal length.  They are compared using Pearson's coeffiicent.
// Values of Zero are not considered.
//*****************************************************************
function calculateCoefficient(a, b) {
  if (a.length != b.length) exit ("arrays of unequal length");
  n = a.length;
  sXY=0;  sX=0;  sY=0;  sX2=0;  sY2=0; nn = 0;
  for (i=0; i<n; i++){
    if ((a[i] != 0) && (b[i] != 0)) {
      sXY = sXY + (a[i] * b[i]);
      sX = sX + a[i];
      sY = sY + b[i];
      sX2 = sX2 + (a[i] * a[i]);
      sY2 = sY2 + (b[i] * b[i]);
      nn++;
    }  // if
  } // for
  top = sXY - ((sX * sY) / nn);
  bottomleft = sX2 - ((sX * sX) / nn);
  bottomright = sY2 - ((sY * sY) / nn);
  bottom = pow((bottomleft*bottomright),0.5);
  Pearson = top / bottom;
   
  //print('sXY='+sXY+'  sX='+sX+'  sY='+sY+'  sX2='+sX2+'  sY2='+sY2+'  n='+n+' nn='+nn+'  top='+top+'  Pearson='+Pearson); 
  print(Pearson);
  selectWindow("Log");
  return Pearson;
} //calculateCoefficient

// Make noisy image for Pearson's test
//********************************************************************
//macro 'make noisy image for test'{
//  run("New...", "name='noisy image' type=32-bit fill=Ramp width=64 height=64 slices=2");
//  for (z=1;z<=nSlices();z++) {run("Set Slice...", "slice="+z);
//    for (x=0;x<getWidth();x++) for (y=0;y<getHeight();y++) 
//      putPixel(x,y,random());
//  } // z
//}

//macro "test the array"{
//  testa = newArray(3);  testb = newArray(3);
//  testa[0]=1;  testa[1]=2;  testa[2]=3;  testb[0]=2;  testb[1]=5;  testb[2]=6;
//  //testa[0]=1;  testa[1]=1;  testa[2]=1;  testb[0]=1;  testb[1]=1;  testb[2]=1;
//  coef = calculateCoefficient(testa, testb);  
//}  // END OF PEARSON'S MACROS

//===================================================================
//  Applies CLAHE to a stack of images.
//===================================================================
macro "CLAHE on a stack" {
  original = getImageID;
  Dialog.create("CLAHE on a stack");
  blocksize=127;   histogramsize=256;   maximum=3;
  Dialog.addNumber("Block size", blocksize);
  Dialog.addNumber("Histogram bins", histogramsize);
  Dialog.addNumber("Contrast max (3 to 12)", maximum);  // from 3 to 12
  Dialog.show();
  blocksize=Dialog.getNumber(); histogramsize=Dialog.getNumber(); maximum=Dialog.getNumber(); 
  for (i=1; i<=nSlices; i++) {
    selectImage(original);
    setSlice(i);
    run("CLAHE ", "blocksize="+blocksize+" histogram="+histogramsize+" maximum="+maximum);
  } // for i
  resetMinAndMax();
}  // CLAHE on a stack



//====================================================================================
/*  Saving the ROI Manager files in the same directory with the same file name as the TIF file it corresponds 
to makes it very easy to batch process later, to visually inspect the files to see which have segmentations (view 
as details or list in OS), and to move or copy the files together.  (A custom variation can be adding brief extensions 
to the file names for segmentation of different structures, although the ROIs themselves may be named within the 
manager and a single key macro may be programmed to do the renaming.)
How to use the macro:
  Open file from any format.
  Optional: crop.
  Save as TIF.
  Do segmentation and add to ROI Manager.
  Run macro �Save ROI Manager [F7]�.  (The standard version of this macro closes the ROI Manager after saving it; 
      you may comment out the reset command to keep it open for addition or edits of ROIs.)
*/
macro "Save ROI Manager [F7]" {
  if ( getInfo("window.type") != "Image" )  exit("Make sure running macro from image window.");
  dir = getDirectory("image");                         // where to save results
  if (lengthOf(dir) < 1) exit("Make sure the image was opened from disk.");
  title = getTitleStripExtension();    
  newName =dir + title + ".zip";
  roiManager("Deselect");	  // all must be deselected to save all
  roiManager("Save", newName);
  //  roiManager("reset");
		// optional if user wants to close ROI manager
}  // end Save ROI Manager [F7]


/* 	Use this function to strip any number of extensions off images.
 *  Returns the title without the extension. 
 *  Add extensions as desired.
 *  This will also remove .lif from the middle of Leica data.
 */ 
function getTitleStripExtension() {
  t = getTitle();
  extensions = newArray(".tif", ".tiff", ".lif", ".lsm", ".czi", ".nd2", ".ND2", ".oir", ".png", ".jpg");    
  for(i=0; i<extensions.length; i++)
    t = replace(t, extensions[i], "");  
  return t;
}  // end getTitleStripExtension()


/* =============================================================
Macro by Michael Cammer  michael@coxcammer.com    June 2014
Useful for having pictures printed on 4X6, 5X7, or other commercial lab size paper.
A function turns any RGB image into a 4X6 or 5X7 or whatever ratio you need photo ready for printing.  
The photo will have a thin white border defined as a percentage of the dimension (width or height) 
that most bumps up against the border.  (Perhaps a later version would be programmed with a custom color border.)
A commerical lab Snapfish.com works well with a 7% border.
*/
/*	This macro is for preparing images to be printed as photographs by a commercial lab.  Goals are to fit image
 * 	into a standard size, put on a border (coded here as white), and to make the border large enough to prevent
 * 	cropping the edge of the picture.  This macro saves files as JPG, but for better spatial fidelity, this is
 * 	simple to change to PNG.
 */
macro "make single RGB image 5X7 [q]" {
  path = getDirectory("image");
  w = getWidth;
  h = getHeight;
  rotate = false;
  if  (w < h)  {                                       
    run("Rotate 90 Degrees Left");
    rotate = true;
  }  // end if
  makeNewRatio();
  if (rotate) run("Rotate 90 Degrees Right");
  title = "5X7_" + getTitle();
		// As needed, change this ratio to 4/6, 8/10, 11/14, etc. here and in makeNewRatio()
  rename(title);
  // save the new image
  run("Input/Output...", "jpeg=100 gif=-1 file=.txt use_file copy_column copy_row save_column save_row");
  saveAs("Jpeg", path + title);
}

function makeNewRatio()  {
  w = getWidth;
  h = getHeight;
  ratio = 5/7;        //  narrower / wider
  As needed, change this ratio to 4/6, 8/10, 11/14, etc.
  border = 0.05;  // percent that is border
; set oa 0.05% for Snapfish  
  if ( (w/h) >= (1/ratio) ) {
    newWidth = w + (border * w);
    newHeight = newWidth * ratio;
  }
  else {
     newHeight = h + (border * h);
     newWidth = newHeight / ratio;
  }
  run("Colors...", "foreground=black background=white selection=yellow");
	// border color is background; change to any color as desired
  run("Canvas Size...", "width="+newWidth+" height="+newHeight+" position=Center");
}



/*  ===============================================
A future version would have an if statement to check image type and also work on composite images.
*/
macro "EQ each channel of RGB image" {
  path = getDirectory("image");
  run("RGB Stack");
  setSlice(1);
  run("Enhance Contrast...", "saturated=0 equalize");
  setSlice(2);
  run("Enhance Contrast...", "saturated=0 equalize");
  setSlice(3);
  run("Enhance Contrast...", "saturated=0 equalize");
  run("RGB Color");
  title = "eq_" + getTitle();
  rename(title);
  // save the new image
  run("Input/Output...", "jpeg=100 gif=-1 file=.txt use_file copy_column copy_row save_column save_row");
  saveAs("Jpeg", path + title);
}


macro "=====Additional LUTs======"{}
/*  Additional LUT macros for ImageJ by Michael Cammer
    Please feel free to use as needed.

    Other resources:
    http://imagej.nih.gov/ij/download/luts/
    http://rsb.info.nih.gov/ij/macros/

*/
//===========================================
macro "Recolor with ratio LUT [F6]"{
  makeFavoriteAIFpseudocolorLUT();
}
function makeFavoriteAIFpseudocolorLUT(){
  red = newArray(0,4,8,12,16,20,24,28,32,36,40,44,48,52,56,60,64,68,72,76,80,84,88,92,96,100,104,108,112,116,120,124,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,120,112,104,96,88,80,72,64,56,48,40,32,24,16,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,3,7,11,15,19,23,27,31,35,39,43,47,51,55,59,63,67,71,75,79,83,87,91,95,99,103,107,111,115,119,123,127,131,135,139,143,147,151,155,159,163,167,171,175,179,183,187,191,195,199,203,207,211,215,219,223,227,231,235,239,243,247,251,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255);
  green = newArray(0,1,2,3,4,5,6,7,8,9,10,9,9,8,8,7,7,6,6,5,5,5,4,4,3,3,2,2,1,1,0,0,0,7,15,23,31,39,47,55,63,71,79,87,95,103,111,119,127,135,143,151,159,167,175,183,191,199,207,215,223,231,239,247,255,247,239,231,223,215,207,199,191,183,175,167,159,151,143,135,128,129,131,132,134,135,137,139,140,142,143,145,147,148,150,151,153,154,156,158,159,161,162,164,166,167,169,170,172,174,175,177,178,180,181,183,185,186,188,189,191,193,194,196,197,199,201,202,204,205,207,208,210,212,213,215,216,218,220,221,223,224,226,228,229,231,232,234,235,237,239,240,242,243,245,247,248,250,251,253,255,251,247,243,239,235,231,227,223,219,215,211,207,203,199,195,191,187,183,179,175,171,167,163,159,155,151,147,143,139,135,131,127,123,119,115,111,107,103,99,95,91,87,83,79,75,71,67,63,59,55,51,47,43,39,35,31,27,23,19,15,11,7,3,0,8,16,24,32,41,49,57,65,74,82,90,98,106,115,123,131,139,148,156,164,172,180,189,197,205,213,222,230,238,246,254);
  blue = newArray(0,7,15,23,31,39,47,55,63,71,79,87,95,103,111,119,127,135,143,151,159,167,175,183,191,199,207,215,223,231,239,247,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,251,247,243,239,235,231,227,223,219,215,211,207,203,199,195,191,187,183,179,175,171,167,163,159,155,151,147,143,139,135,131,128,126,124,122,120,118,116,114,112,110,108,106,104,102,100,98,96,94,92,90,88,86,84,82,80,78,76,74,72,70,68,66,64,62,60,58,56,54,52,50,48,46,44,42,40,38,36,34,32,30,28,26,24,22,20,18,16,14,12,10,8,6,4,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,16,24,32,41,49,57,65,74,82,90,98,106,115,123,131,139,148,156,164,172,180,189,197,205,213,222,230,238,246,254);
  setLut(red, green, blue);
}

//===========================================
macro "Orange"{
			// This was written before FiJi had an orange command included, still not in pull down LUTs menu (Nov 2022)
  orange();
}
function orange() {
  red = newArray(256);
  green = newArray(256);
  blue = newArray(256);
  for (i=0; i<256; i++) {
    red[i] = i;
    green[i] = i / 2;
    blue[i] = 0;
  }  // for i
  setLut(red, green, blue);
}

//===========================================
macro "Light blue (dapi)"{
  lightBlue();
}
function lightBlue() {
  red = newArray(256);
  green = newArray(256);
  blue = newArray(256);
  for (i=0; i<256; i++) {
    red[i] = 0;
    green[i] = i / 1.75;
    blue[i] = i;
  }  // for i
  setLut(red, green, blue);
}


//===========================================
macro "HiLo"{
				// This was written before FiJi had a HiLo LUT included
  mcHiLoLUT();
}
function mcHiLoLUT() {	
  red = newArray(256);
  green = newArray(256);
  blue = newArray(256);
  for (i=0; i<256; i++) {
    red[i] = i;
    green[i] = i;
    blue[i] = i;
  }  // for i
  blue[255] = 0;
  blue[0] = 255;
  green[255] = 63;
  setLut(red, green, blue);
}




/* =============================================================
Standard ImageJ allows for installing macros from the macro editor text window by typing ctrl i.  Fiji does not.
Therefore, to easily update macros in Fiji, change the path of the current macro file being edited in this macro and
use ctrl s followed by F4 to reinstall the macros from the Fiji text editor.
*/
macro "Install Macros [F4]" {
  run("Install...", "install=[C:/Users/cammem01/OneDrive - NYU Langone Health/_webpages_microscopynotes/imagej/macros/useful_collection_v100.ijm]");
}