/* 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 

    20180411  In subtract BG in ROI macro, with IJ 1.51 PlotProfile no longer send results to the Results window so rewritten with a measurements loop.
    20200108 added scalebar dialogue to simple merge macros
*/

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     


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

/* =============================================================
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=D:\\20171214\\Macro.txt");
}



/*  ============================================================
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.");
  realtitle = getTitle;
  run("Duplicate...", "duplicate");
  title = getTitleStripExtension();
  rename(title);
  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);
}

/* =========================================
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");
}






//=====================================================================================
//  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.
/*  To make wedges instead of single slices, overshoot the rotation (more than 360 degrees number_of_radii) and 
use the project variable depth function projectStackVariableWidth("Max Intensity", 4);  to combine slices such as 10 degrees wedges.
    Warning:  as the images get larger, the further fromt he center, slices will be missed.  To catch every pixel, as the
images get larger, the angular step size has to get smaller, which slows things down.  The macro could be modified
to use the straighten command with lines of thicker pixels, but this would require a projection step for every slice
and would get evern slower.
    Implementation 9 Feb 2020 adds spatial scale to properties.  X axis in in distance units of original image and Y
axis is in radians (which could easily be changed to degrees).
*/
//=====================================================================================
macro"Radial Sweep as a circle [q]"{
  number_of_radii = 720;               // number of pixels on perimeter of circle to be sampled.
  extrasteps = 16;                            // 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
  anglestep = 2 * PI / number_of_radii;
  requires("1.52");
  getVoxelSize(pixelwidth, pixelheight, depth, distanceunit);              //  will be used to reassign scale at the end

  // Gets the center of the area to be resliced.  Could be recoded shorter with new get list functions.
  run("Set Scale...", "distance=1 known=1 pixel=1 unit=px");
  run("Set Measurements...", "  centroid redirect=None decimal=0");
  run("Measure");
  xc = getResult("X", nResults-1);
  yc = getResult("Y", nResults-1);
  selectWindow("Results");
  run("Close");

  Stack.getDimensions(width, height, channels, slices, frames);  //channels and slices will be swapped
  if ( (slices > 1) || (frames > 1) ) exit("Requires multichannel image with no Z or T.");

  //Save the LUTs to apply later.
  Stack.setChannel(1);
  getLut(reds1, greens1, blues1);
  if (channels > 1) {
    Stack.setChannel(2);
    getLut(reds2, greens2, blues2);
  }
  if (channels > 2) {
    Stack.setChannel(3);
    getLut(reds3, greens3, blues3);
  }
  if (channels > 3) {
    Stack.setChannel(4);
    getLut(reds4, greens4, blues4);
  }
  if (channels > 4) {  
    waitForUser("Warning:  LUTs only operate correctly on maximum of 4 channels.");
  }

  // Manage the image data type.
  run("Select None");
  run("Duplicate...", "title=tempimage duplicate");
  run("Restore Selection");
  run("Interpolate", "interval=1");      // If a vector ROI, need to convert to rasters ROI
  run("Hyperstack to Stack");
  slices = nSlices();
  if (slices != channels) exit("Something wrong with number of channels.");
  realtitle = getTitle;
  originaltitle = getTitleStripExtension();
  bits = bitDepth();
  temptitle = originaltitle + "_reslice";
  newtitle = originaltitle + "_radial";
  newslices = 1 + number_of_radii + extrasteps;
  newbits = "" + bits + "-bit Black";
  setBatchMode(true);                                // uncomment for faster execution
  newImage(temptitle, newbits, maxradius, slices, newslices);
  stream = getImageID();
  setPasteMode("Copy");
  s=1;
    for (i=0; i<2*PI+(anglestep*extrasteps); i=i+anglestep) {
      edgex = xc + maxradius * sin(i);
      edgey = yc + maxradius * cos(i);
      selectImage("tempimage");
      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("exit and display");                // uncomment for faster execution
  //projectStackVariableWidth("Max Intensity", 4);

  //Reorient into XY
  run("Select None");
  run("Reslice [/]...", "output=1.000 start=Top avoid");
  rename(newtitle);
  run("Stack to Hyperstack...", "order=xyczt(default) channels=" + slices +" slices=1 frames=1 display=Composite");
  setVoxelSize(pixelwidth, anglestep, depth, distanceunit);

  //Apply the original LUTs
  Stack.setChannel(1);
  setLut(reds1, greens1, blues1);
  if (channels > 1) {
    Stack.setChannel(2);
    setLut(reds2, greens2, blues2);
  }
  if (channels > 2) {
    Stack.setChannel(3);
    setLut(reds3, greens3, blues3);
  }
  if (channels > 3) {
    Stack.setChannel(4);
    setLut(reds4, greens4, blues4);
  }

  rename(newtitle);
  close(temptitle);  // closes the reslice image
  close("tempimage");

}  //end macro("Radial Sweep")


macro "Test calculateMaximumRadius()" {
  print(calculateMaximumRadius());
  selectWindow("Log");
}

//=========================================================
// 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 (works on stacks)"{          // as implemented, does not work on multichannel hyperstacks for individual channels
  run("32-bit");
  for (i=1; i<=nSlices(); i++){  
    setSlice(i);
    changeValues(0,128,NaN); }
}



//===========================================================================
//  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()


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





//=============================================================================
/*
  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 arounf the outside of the area and this
  mean intensity is treated as the background which is subtracted from the mean of the ROI.
*/
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

}

//=============================================================================
/*
    This macro needs to be edited.
*/
macro "measure all ROIs in Roi Manager only including pixel intensities above a threshold" {
  threshold = 220;  // or prompt user for the number -- or start with a background area circled and get this way
//  original = getImageID;
  print(" \t" + getTitle);
  run("Set Measurements...", "area mean redirect=None decimal=5");
  histmax = 16384;
  histmin = threshold;
  for (i=0;  i<roiManager("count");  i++){
//    selectImage(original);
    roiManager("select", i);
    getHistogram(values, counts, histmax-histmin, histmin, histmax-histmin);
    pixelcount = 0;
    integratedint = 0;
    for (h=0; h<histmax-histmin; h++){
      pixelcount = pixelcount + counts[h];
      //integratedint = integratedint + (counts[h] * values[h]);
      integratedint = integratedint + (h * counts[h]);
    }  // for h
  print(i + " \t" + pixelcount + " \t" + integratedint+ " \t" + integratedint/pixelcount);
  }  // for  i
}  // end macro "measure all ROIs in Roi Manager only including pixel intensities above a threshold"


//=========================================================
/*  Since this function was written, a command was added to ImageJ that does this:
    close(pattern)
    Thus, all calls to this function could be replaced.
*/
function closeWindowsNotInterestedIn() {
  n = nImages();
  for (i=1; i<=n; i++) {
    selectImage(i);
    if ( !(endsWith(getTitle(), "C=2")) )   // use not and the title feature you want to keep
      run("Close");
}   // end function closeWindowsNotInterestedIn()



//-----------------------------------------------
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'


//================================================================
//  See http://microscopynotes.com/imagej/float/ for explanation.
//  originally by Kenton Arkill [underwaterginge@GMAIL.COM]
//    Floating means that each image has the same mean pixel value and the same standard deviation. 
//    I find it really useful as it means the same threshold can often be used on all the images. Here is my macro, 
//    it floats the stack to the values of the first slice (so make sure it is a good image):
//
macro "Float the stack"{
run("32-bit");
setSlice(1);
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(1);
}

//===================================================================
//  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 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


/*  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");
}

//==============================================
macro "correct depth light absorption" {
  for (i=1; i<=60; i++){
    setSlice(i);
    multby = 1+ ((nSlices-i) / nSlices);
    run("Multiply...", "value="+multby+" slice");
  }
}

//==============================================
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 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";
  // add command to select none in ROIManager to mae sure all saved?
  roiManager("Save", newName);
  roiManager("reset");
}  // end Save ROI Manager [F7]



/====================================
// Use this function to strip any number of extensions // off images.
// Returns the title without the extension.  
//====================================
function getTitleStripExtension() {
  t = getTitle();
  extensions = newArray(".tif", ".tiff", ".lif", ".lsm", ".czi", ".nd2", ".ND2");    
  for(i=0; i<extensions.length; i++)
    t = replace(t, extensions[i], "");  
  return t;
}  // end getTitleStripExtension()/*  Macros for Ashira Blazer  */



     




/*  ===============================================
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]"{
  requires ('1.38f');
  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"{
  requires ('1.49');
  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)"{
  requires ('1.49');
  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"{
  requires ('1.49');
  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);
}