requires("1.41o");

// PROMPT FOR PARAMETERS TO MEASURE
// AND
// MISC GLOBAL SETTINGS



arrayParamChoices = newArray(19);
Dialog.create("Check the required parameters");
	Dialog.addString("Thin Section Name?", "");
	Dialog.addNumber("SET SCALE: 1 pixel is X microns:", 0);
	Dialog.addCheckbox("AREA?", true);
	Dialog.addCheckbox("MAJOR AXIS?", false);
	Dialog.addCheckbox("MINOR AXIS?", false);
	Dialog.addCheckbox("ASPECT_RATIO?", false);
	Dialog.addCheckbox("CIRCULARITY?", false);
	Dialog.addCheckbox("ANGLE?", false);
	Dialog.addMessage("");
	Dialog.addCheckbox("CRACK AREA?", false);
	Dialog.addMessage("(If checked, parameter choices above are ignored)");
	Dialog.addMessage("");
	Dialog.addCheckbox("BatchMode (recommended)?", true);
	Dialog.addCheckbox("Garbage Collect (recommended)?", true);
	Dialog.addCheckbox("Save raw results?", true);
	
	Dialog.show();

	arrayParamChoices[0] = Dialog.getString();		//ts_name
	arrayParamChoices[17] = Dialog.getNumber();		//set_scale
	arrayParamChoices[3] = Dialog.getCheckbox();		//area_dialog
	arrayParamChoices[4] = Dialog.getCheckbox();		//major_dialog
	arrayParamChoices[5] = Dialog.getCheckbox();		//minor_dialog
	arrayParamChoices[6] = Dialog.getCheckbox();		//aspectratio_dialog
	arrayParamChoices[7] = Dialog.getCheckbox();		//circ_dialog 
	arrayParamChoices[8] = Dialog.getCheckbox();		//angle_dialog
	arrayParamChoices[1] = Dialog.getCheckbox();		//crack_area
	arrayParamChoices[9] = Dialog.getCheckbox();		//batch
	arrayParamChoices[10] = Dialog.getCheckbox();		//garbage_collect
	arrayParamChoices[12] = Dialog.getCheckbox();		//save_raw
	
// WHICH PARAMETERS WERE CHOSEN?
// SEND THESE TO THE STATISTICS CHOICES FUNCTION

if(parseInt(arrayParamChoices[10])==true) garbageCollect();
if (arrayParamChoices[3]==0 && arrayParamChoices[4]==0 && arrayParamChoices[5] == 0 && arrayParamChoices[6] == 0 && arrayParamChoices[7] == 0 && arrayParamChoices[8] == 0 && arrayParamChoices[1] == 0) {showMessage("You need to choose a parameter or do crack area measurements"); exit();}
if (arrayParamChoices[0]=="") {showMessage("You need to label the thin section.  Run the macro again."); exit();}
if (arrayParamChoices[1] == true) {
	arrayParamChoices[3] = false;
	arrayParamChoices[4] = false;
	arrayParamChoices[5] = false;
	arrayParamChoices[6] = false;
	arrayParamChoices[7] = false;
	arrayParamChoices[8] = false;
}
if (arrayParamChoices[3] == true) {arraySettingsArea = statsdialog("AREA");}
if (arrayParamChoices[4] == true) {arraySettingsMajor = statsdialog("MAJOR");}
if (arrayParamChoices[5] == true) {arraySettingsMinor = statsdialog("MINOR");}
if (arrayParamChoices[6] == true) {arraySettingsAspect = statsdialog("ASPECT_RATIO");}
if (arrayParamChoices[7] == true) {arraySettingsCirc = statsdialog("CIRCULARITY");}
if (arrayParamChoices[8] == true) {arraySettingsAngle = statsdialog("ANGLE");}

arrayParamChoices[14] = getDirectory("Where to Save Statistics File Output?  "); //output_directory

// PUT RAW DATA FILES IN THEIR OWN DIRECTORY
if (arrayParamChoices[12]==true && arrayParamChoices[1]==false) {
	datadir = getDirectory("Where to Put Raw Data Output?  ");
	// datadir = arrayParamChoices[14]+"\\"+arrayParamChoices[0]+"_RAWDATA\\"; 
	File.makeDirectory(datadir); // Creates a directory
}
	else datadir=arrayParamChoices[14];

	
// OPEN THE BINARY PARTICLE FILE
setBatchMode(parseInt(arrayParamChoices[9]));
if (arrayParamChoices[1] == true) showMessage("Choose the Binary Crack Image  ");
	else showMessage("Choose the Binary Particle Image  ");
open("");

run("Set Scale...", "distance=1 known=1 pixel=1 unit=micron");

if(parseInt(arrayParamChoices[10])==true) garbageCollect();

// THE NERVOUS SYSTEM
// MOVING MEASUREMENT WINDOW
// FIRST COORDINATES ARE READ INTO AN ARRAY, AND CHECKED TO BE SURE NONE ARE DEEPER THAN THE IMAGE HEIGHT

showMessage("Choose the Coordinates File \nData should be space delimited, and in pixels (not microns)\nMake sure there are no empty lines at the top or end of the file (no lines with just carriage returns)");
open("");

arraySplit = split(getInfo(),'\n');
numLines = 0;
iHeight = getHeight();
for (m=0; m<arraySplit.length; m++) {
	arraySubSplit = split(arraySplit[m], " ");
	isTop = parseInt(arraySubSplit[1]);
	if (isTop <= iHeight) {
		numLines = numLines + 1;
	}
}
arrayCoords = newArray(numLines);

for (m=0; m<arrayCoords.length; m++) {
	arrayCoords[m] = arraySplit[m];
}

run ("Close");

// GET DAY & TIME #1
getDateAndTime(year1, month1, dayOfWeek1, dayOfMonth1, hour1, minute1, second1, msec1);
time1 = getTime();


if (arrayCoords.length < arraySplit.length) showMessageWithCancel("Alert!","There are y-coordinate values in your file \nthat are greater than the height of the image. \nThis is OK (they'll be ignored). \nJust wanted to let you know!");

if (arrayParamChoices[1] == true) crackarea(arrayParamChoices, arrayCoords);
if (arrayParamChoices[3] == true) processSettings(arraySettingsArea, arrayParamChoices, arrayCoords);
if (arrayParamChoices[4] == true) processSettings(arraySettingsMajor, arrayParamChoices, arrayCoords);
if (arrayParamChoices[5] == true) processSettings(arraySettingsMinor, arrayParamChoices, arrayCoords);
if (arrayParamChoices[6] == true) processSettings(arraySettingsAspect, arrayParamChoices, arrayCoords);
if (arrayParamChoices[7] == true) processSettings(arraySettingsCirc, arrayParamChoices, arrayCoords);
if (arrayParamChoices[8] == true) processSettings(arraySettingsAngle, arrayParamChoices, arrayCoords);

function processSettings(arraySettings, arrayParamChoices, arrayCoords) {
	if(parseInt(arrayParamChoices[10])==true) garbageCollect();
	arrayReturnedStats = 0;

	// Save one text file with histogram bin limits
	if(arraySettings[16] == true) histbins(arraySettings);
	
	// PRINT AND SAVE STATISTICS RESULTS
	arrayReturnedStats = actualmeas(arrayCoords, arraySettings, arrayParamChoices);
	printarray(arrayReturnedStats);
	selectWindow("Log"); save(arrayParamChoices[14]+arrayParamChoices[0]+"_"+arraySettings[20]+"_"+"STATISTICS.txt"); run ("Close");

	if(parseInt(arrayParamChoices[10])==true) garbageCollect();
}


// GET DAY & TIME #2
getDateAndTime(year2, month2, dayOfWeek2, dayOfMonth2, hour2, minute2, second2, msec2);
time2 = getTime();
elapsed_minutes = (time2-time1)/60000;
elapsed_seconds = (time2-time1)/1000;
elapsed_hours = (time2-time1)/3600000;
print("FINISHED ", arrayParamChoices[0]);
print("Began on ", month1, "/",dayOfMonth1, ", at ", hour1,":",minute1,":",second1, ", and...");
print("ended on ", month2, "/",dayOfMonth2, ", at ", hour2,":",minute2,":",second2);
print("Taking ",  elapsed_seconds, " seconds...");
print("or", elapsed_minutes, " minutes...");
print("or", elapsed_hours, " hours.");

// Tidy Up
close(); setBatchMode(false);

// STATSDIALOG PROMPTS FOR MEASUREMENT OPTIONS AND STATISTICS OPTIONS
// FOR EACH CHOSEN PARAMETER

function statsdialog(parameter) {
	arraySettings = newArray(29);

	Dialog.create(""+parameter+"");
		Dialog.addMessage("          "+parameter+" MEASUREMENT OPTIONS:");
		Dialog.addNumber("Approx. max. particle size (pixels):", 50);
		Dialog.addNumber("Minimum particle size to measure (pixels):", 9);
		Dialog.addMessage("          "+parameter+" STATISTICS OPTIONS: ");
		Dialog.addCheckbox("# of Particles?", true);
		Dialog.addCheckbox("Cumulative?", true);
		Dialog.addCheckbox("Mean?", true);
		Dialog.addCheckbox("Median?", true);
		Dialog.addCheckbox("Mode?", true);
		Dialog.addCheckbox("Maximum?", true);
		Dialog.addCheckbox("Minimum?", true);
		Dialog.addCheckbox("Standard Deviation?", true);
		Dialog.addCheckbox("Skewness?", true);
		Dialog.addCheckbox("Kurtosis?", true);
		Dialog.addCheckbox("Calculate Percentiles?", true);
		Dialog.addNumber("Percentile #1:", 25);
		Dialog.addNumber("Percentile #2:", 50);
		Dialog.addNumber("Percentile #3:", 75);
		Dialog.addNumber("Percentile #4:", 95);
		Dialog.addNumber("Percentile #5:", 99);
		Dialog.addCheckbox("Histogram?", true);
		Dialog.addChoice("Data transformation?", newArray("None", "Phi", "Log"));
		Dialog.addNumber("# of Histogram Bins:", 10);
		Dialog.addNumber("Bin Min:", 0);
		Dialog.addNumber("Bin Max:", 10);
		
		Dialog.addMessage("");
		Dialog.show();
	
		arraySettings[25] = Dialog.getNumber();	//approx max part size
		arraySettings[24] = Dialog.getNumber();  	//min_parts
		arraySettings[28] = Dialog.getCheckbox();		//numb_parts
		arraySettings[1] = Dialog.getCheckbox();	//area_cumulative_dialog
		arraySettings[2] = Dialog.getCheckbox();	//area_mean_dialog
		arraySettings[3] = Dialog.getCheckbox();	//area_median_dialog
		arraySettings[4] = Dialog.getCheckbox();	//area_mode_dialog
		arraySettings[5] = Dialog.getCheckbox();	//area_maximum_dialog
		arraySettings[6] = Dialog.getCheckbox();	//area_minimum_dialog
		arraySettings[7] = Dialog.getCheckbox();	//area_stdev_dialog
		arraySettings[8] = Dialog.getCheckbox();	//area_skewness_dialog
		arraySettings[9] = Dialog.getCheckbox();	//area_kurtosis_dialog
		arraySettings[10] = Dialog.getCheckbox();	//area_percents_dialog
		arraySettings[11] = Dialog.getNumber();	//area_perc[0]
		arraySettings[12] = Dialog.getNumber();	//area_perc[1]
		arraySettings[13] = Dialog.getNumber();	//area_perc[2]
		arraySettings[14] = Dialog.getNumber();	//area_perc[3]
		arraySettings[15] = Dialog.getNumber();	//area_perc[4]
		arraySettings[16] = Dialog.getCheckbox();	//area_histogram_dialog
		arraySettings[27] = Dialog.getChoice();  //liner__phi_log
		arraySettings[17] = Dialog.getNumber();	//area_nBins_dialog 
		arraySettings[18] = Dialog.getNumber();	//area_minbin_dialog
		arraySettings[19] = Dialog.getNumber();	//area_maxbin_dialog
		arraySettings[20] = parameter;		//parameter being measured
	return arraySettings;
}  // END OF STATS DIALOG FUNCTION


// COLLECTING THE ACTUAL MEAUREMENTS
function actualmeas(arrayCoords, arraySettings, arrayParamChoices) {
	
	hist_scale = arrayParamChoices[17];
	
	tostring = arraySettings[20];
	if (tostring == "AREA") {meas = "area"; result_code = "Area";}
	if (tostring == "MAJOR") {meas = "fit"; result_code = "Major";}
	if (tostring == "MINOR") {meas = "fit"; result_code = "Minor";}
	if (tostring == "ASPECT_RATIO") {meas = "fit"; result_code = "Aspect_Ratio";}
	if (tostring == "CIRCULARITY") {meas = "circularity"; result_code = "Circ.";}
	if (tostring == "ANGLE") {meas = "fit"; result_code = "Angle";}

	arrayReturnedStats = newArray(arrayCoords.length+1);
	arrayReturnedStats[0] = "ROI_X, ROI_Y, ROI_Width, ROI_Height, ROI_Area, ROI_Mid_Y, Number_Parts, Cumulative_"+tostring+", Mean_"+tostring+", Median_"+tostring+", Mode_"+tostring+", Max_"+tostring+", Min_"+tostring+", StDev_"+tostring+", Skewness_"+tostring+", Kurtosis_"+tostring+", Perc1Value, Perc1Closest, Perc2Value, Perc2Closest, Perc3Value, Perc3Closest, Perc4Value, Perc4Closest, Perc5Value, Perc5Closest, Histogram_"+tostring+"";
	comfort_space = arraySettings[25]*3;
	
	for (y=0; y<arrayCoords.length; y++) {
		arraySubCoord = split(arrayCoords[y], " ");
		box_left = parseFloat(arraySubCoord[0]);
		box_top = parseFloat(arraySubCoord[1]);
		box_width = parseFloat(arraySubCoord[2]);
		box_height = parseFloat(arraySubCoord[3]);
		// box_numb = parseFloat(arraySubCoord[6]);
	  image_width = getWidth();
	  big_box_top = (box_top-comfort_space);
	  big_box_height = box_height+(2*comfort_space);
	  mid_y = box_top+(box_height/2);
	  min_parts = parseFloat(arraySettings[24]);
		
		makeRectangle(0, big_box_top, image_width, big_box_height);
		
		run("Set Measurements...", " "+meas+" centroid bounding redirect=None decimal=5");
		run("Analyze Particles...", "minimum="+min_parts+" maximum=9999999 bins=20 show=Nothing clear record include"); run("Select None");
		
		x=0;
		for (j=0; j<nResults; j++) {
			partCenterX = getResult("X", j); 
			partCenterY = getResult("Y", j);
			partXStart = getResult("XStart", j);
			partYStart = getResult("YStart", j);
			partHeight = getResult("Height", j);
			partWidth = getResult("Width", j);
			partXEnd = partXStart+partWidth;
			partYEnd = partYStart+partHeight;
			box_right = box_left+box_width;
			box_bottom = box_top + box_height;
						
			if (partCenterY >= box_top && partCenterY < box_bottom && partCenterX >= box_left && partXEnd < box_right) {
				setResult("inside", j, 1);
				x = x+1;
			}
		}
		arrayResults = newArray(x); g=0;
			if (tostring == "ASPECT_RATIO") { // CALCULATE ASPECT RATIO
			for (j=0; j<nResults; j++) {
				if (getResult("inside", j) == 1) {
					boogerhead = 1-(getResult("Minor", j)/getResult("Major", j));
					arrayResults[g] = boogerhead;
					g=g+1;
				}
			}
		} else {
			for (j=0; j<nResults; j++) {
				if (getResult("inside", j) == 1) {
					arrayResults[g] = getResult(result_code, j);
					g=g+1;
				}
			}
		}
			
		// Gets past the circularity '-1' issue
		if (tostring == "CIRCULARITY") {
			for (j=0; j<arrayResults.length; j++) {
				if (arrayResults[j] == -1) arrayResults[j] = 1;
			}
		}
		out_box_left = box_left * hist_scale;
		out_box_top = (box_top*hist_scale);
		out_box_width = box_width * hist_scale;
		out_box_height = box_height * hist_scale;
		out_area = (out_box_width)*(out_box_height);
		out_midpoint = (mid_y*hist_scale);
		arrayReturnedStats[y+1] = "" + out_box_left + ", " + out_box_top + ", " + out_box_width + ", " + out_box_height + ", " + out_area + ", " + out_midpoint + ", " + stats(arrayResults, arraySettings, arrayParamChoices);
	}  // end of FOR that loops through boxcoords
return arrayReturnedStats;
}

// DECISIONS ON WHETHER A STATISTIC HAS BEEN CHOSEN
function stats(arrayResults, arraySettings, arrayParamChoices) {

	// Changing the scale from pixels to microns
	param = arraySettings[20];
	scale = arrayParamChoices[17];
	if (param == "AREA" || param == "ASPECT_RATIO" || param == "ANGLE" || param == "CIRCULARITY") {
		if (param == "AREA") {
			for (x=0; x<arrayResults.length; x++) {
				arrayResults[x] = arrayResults[x]*pow(scale, 2);
			}
		}
	} else {
		for (x=0; x<arrayResults.length; x++) { // sets scale from pixels to microns
			arrayResults[x] = arrayResults[x]*scale;
		}
	}
	
	// Save Raw Data?
	if (arrayParamChoices[12] == true) {
		printarray(arrayResults);
		selectWindow("Log"); save(datadir+arrayParamChoices[0]+"_"+arraySettings[20]+"_"+"DATABOX_"+(y+1)+".txt"); run ("Close");
	}
			
	sort(arrayResults);
	
	number = arrayResults.length;
	if (arraySettings[28] == true) numb_out = number;
		else numb_out = "NA";

	// CUMULATIVE
	cum = cumulative(arrayResults);
	if (arraySettings[1] == true) cum_out = cumulative(arrayResults);
		else cum_out = "NA";

	// MEAN	
	mean = cum / arrayResults.length;
	if (arraySettings[2] == true) mean_out = mean;
		else mean_out = "NA";

	// MEDIAN
	if (arraySettings[3] == true) median_var = median(arrayResults);
		else median_var = "NA";

	// MODE
	if (arraySettings[4] == true) mode = calcmode(arrayResults, arraySettings);
		else mode = "NA";

	// MAX	
	if (arraySettings[5] == true) maxinarray = arrayResults[arrayResults.length-1];
		else maxinarray = "NA";

	// MIN	
	if (arraySettings[6] == true) mininarray = arrayResults[0];
		else mininarray = "NA";

	// STANDARD DEVIATION
	stdev_var = stdev(arrayResults, mean);
	if (arraySettings[7] == true) stdev_out= stdev_var;
		else stdev_out = "NA";

	// SKEWNESS
	if (arraySettings[8] == true) skewness_var = skewness(arrayResults, mean, stdev_var);
		else skewness_var = "NA";

	// KURTOSIS
	if (arraySettings[9] == true) kurtosis_var = kurtosis(arrayResults, mean, stdev_var);
		else kurtosis_var = "NA";

	// PERCENTILES
	if (arraySettings[10] == true) {
		perc_var = percentiles(arrayResults, arraySettings);
	} else {
		perc_var = "NA, NA, NA, NA, NA, NA, NA, NA, NA, NA";
	}

	// HISTOGRAM
	if (arraySettings[16] == true) {
		nBins = arraySettings[17];
		min = arraySettings[18];
		max = arraySettings[19];
		hist_scale = arraySettings[27];
		hist_var = hist(arrayResults, nBins, min, max, hist_scale);
	} else {
		hist_var = "NA";
	}
		
	if(parseInt(arrayParamChoices[10])==true) garbageCollect();
	statsout = "" + numb_out + ", " + cum_out + ", " + mean_out + ", " + median_var + ", " + mode + ", " + maxinarray + ", " + mininarray + ", " + stdev_out + ", " + skewness_var + ", " + kurtosis_var + ", " + perc_var + ", " + hist_var;
	
return statsout;
}

function cumulative(arrayResults) {
	cumsum=0;
	for (z=0; z<arrayResults.length; z++) {cumsum = arrayResults[z] + cumsum;}; return(cumsum);
}

function median(arrayResults) {
	if (arrayResults.length%2 > 0) {
		median_var = (arrayResults[(arrayResults.length/2)]);
		return median_var;
	} else {
		median_var = ((arrayResults[(arrayResults.length/2)-1] + arrayResults[(arrayResults.length/2)])/2);
		return median_var;
	}
}

function calcmode(arrayResults, arraySettings) {
	temp2 = 0; temp3 = 0; temp4 = 0; param = arraySettings[20];
	for (z=0; z<arrayResults.length; z++) {
		if (param=="ASPECT_RATIO" || param=="CIRCULARITY") {
			temp1 = arrayResults[z];
			if (z != (arrayResults.length-1)) temp2 = arrayResults[z+1];
		} else {
			temp1 = round(arrayResults[z]);
			if (z != (arrayResults.length-1)) temp2 = round(arrayResults[z+1]);
		}
		if (temp1 == temp2) {
			temp3 = temp3+1;
		} else {
			temp3 = temp3+1;
			if (temp3 > temp4) {
				temp4=temp3;
				temp5=round(arrayResults[z]);
			}
			temp3 = 0;
		}
	}
	return temp5;
}

function stdev(arrayResults, mean) {
	cum_minusmean_squ = 0;
	for (z=0; z<arrayResults.length; z++) {
		minusmean = arrayResults[z] - mean;
		cum_minusmean_squ = cum_minusmean_squ + pow(minusmean, 2);
	}
	dev = sqrt(cum_minusmean_squ / (arrayResults.length-1));
	return dev;
}

function skewness(arrayResults, mean, stdev_var) {
	cum_minusmean_cub = 0;
	for (z=0; z<arrayResults.length; z++) {
		minusmean = arrayResults[z] - mean;
		cum_minusmean_cub = cum_minusmean_cub + pow(minusmean, 3);
	}
	skew = (cum_minusmean_cub / (arrayResults.length*pow(stdev_var,3)));
	return skew;
}

function kurtosis(arrayResults, mean, stdev_var) {
	cum_minusmean_quad = 0;
	for (z=0; z<arrayResults.length; z++) {
		minusmean = arrayResults[z] - mean;
		cum_minusmean_quad = cum_minusmean_quad + pow(minusmean, 4);
	}
	kurt = (cum_minusmean_quad / (arrayResults.length*pow(stdev_var,4)));
	return kurt;
}

// array can be sorted or unsorted for histogram function
function hist(arrayResults, nBins, min, max, hist_scale) {
	increment = (max-min)/nBins;
	Lowerlimitarray = newArray(nBins);
	Upperlimitarray = newArray(nBins);
	Cumcountarray = newArray(nBins);
	arrayBinLimits = newArray(nBins);
		
		if (hist_scale == "Phi") {
		for (x=0; x<arrayResults.length; x++) {
			arrayResults[x] = -log(arrayResults[x]/1000)/log(2);
		}
	} 
	
	if (hist_scale == "Log") {
		for (x=0; x<arrayResults.length; x++) {
			arrayResults[x] = log(arrayResults[x])/log(10);
		}
	}
	
	overmax=0; undermin=0; sum = 0;
	for (x=0; x<arrayResults.length; x++) {
		leave = false;
		if (arrayResults[x] > max) {overmax = overmax+1; leave = true;}
		if (arrayResults[x] < min) {undermin = undermin+1; leave = true;}
		for (z=0; z<nBins; z++) {
			lowerlimit = (increment*z)+min; Lowerlimitarray[z] = lowerlimit;
			upperlimit = increment+(increment*z)+min; Upperlimitarray[z] = upperlimit;
			if (leave != true && (arrayResults[x] > lowerlimit || (z==0 && arrayResults[x] == lowerlimit)) && arrayResults[x] <= upperlimit) {
				Cumcountarray[z] = (Cumcountarray[z] + 1);
				leave = true;
			}
		}
	}
	
	comma = ", "; str = "" + undermin + comma;
	for (i=0; i<Cumcountarray.length; i++) {
		if (i < Cumcountarray.length-1) {
			str = str + Cumcountarray[i] + comma;
		} else {
			str = str + Cumcountarray[i] + comma + overmax;
		}
	}
	return str;
}

// Calculating, printing, and storing the histogram bins
function histbins(arraySettings) {
	max = arraySettings[19];
	min = arraySettings[18];
	nBins = arraySettings[17];
	increment = (max-min)/nBins;
	increment_holder = (max-min)/nBins;
	arrayBinLimits = newArray(nBins+2);
		
	str = ""; comma = ", ";
	arrayBinLimits[0] = "Limit_1, Limit_2";
	arrayBinLimits[arrayBinLimits.length-1] = "(Last Column is the count OVER maximum bin)";
	for (i=1; i<(arrayBinLimits.length-1); i++) {
		arrayBinLimits[i] = str + (min+(increment-increment_holder)) + comma + (min+increment);
		increment = increment+increment_holder;
	}
	printarray(arrayBinLimits);
	selectWindow("Log"); save(arrayParamChoices[14]+arrayParamChoices[0]+"_"+arraySettings[20]+"_"+"HISTOGRAM_LIMITS.txt"); run ("Close");
}

// array needs to be sorted for percentiles function
function percentiles(arrayResults, arraySettings) {
	result = newArray(5);  // define the percentiles here
	one = arraySettings[11]; two =arraySettings[12]; three =arraySettings[13]; four = arraySettings[14]; five = arraySettings[15];
	perc = newArray(one, two, three, four, five);
	for (x=0; x<perc.length; x++) {
		leave=false;
		for (z=(arrayResults.length); z>0; z--) {
			if (leave == true) z=0;
			temp=(z/arrayResults.length)*100; temp2=((z+1)/arrayResults.length)*100; 
			if (temp<=perc[x] && leave != true) {
				result[x]= arrayResults[z];
				perc[x] = temp2;
				leave = true;
			}
		}
	}
			
	str = ""; comma = ", ";
	for (x=0; x<perc.length; x++) {
		if (x < perc.length-1) {
			str = str + result[x] + comma + perc[x] + comma;
		} else {
			str = str + result[x] + comma + perc[x];
		}
	}
	return str;
}


//  MISC FUNCTIONS...
//  The 'sort' and 'quicksort' functions are courtesy of Wayne Wasband, wsr@NIH.GOV

function sort(array) {quickSort(array, 0, lengthOf(array)-1);}
function quickSort(array, from, to) {
	z = from; x = to;
	center = array[(from+to)/2];
do {
	while (z<to && center>array[z]) z++;
	while (x>from && center<array[x]) x--;
	if (z<x) {temp=array[z]; array[z]=array[x]; array[x]=temp;}
	if (z<=x) {z++; x--;}
} while(z<=x);
	if (from<x) quickSort(array, from, x);
	if (z<to) quickSort(array, z, to);
}

// printarray
function printarray(array) {
	for (x=0; x<array.length; x++) {
		print(array[x]);
	}
}

// Garbage Collect
function garbageCollect() {
	call("java.lang.System.gc");
}


function crackarea(arrayParamChoices, arrayCoords) {
	hist_scale = arrayParamChoices[17];
	arrayReturnedStats = newArray(arrayCoords.length+1);
	arrayReturnedStats[0] = "ROI_X, ROI_Y, ROI_Width, ROI_Height, ROI_Area, ROI_Mid_Y, Crack_Area";
	if(parseInt(arrayParamChoices[10])==true) garbageCollect();
	
	for (y=0; y<arrayCoords.length; y++) {
		showStatus(""+(y/arrayCoords.length)*100+"% DONE"); wait(125); // showStatus and 'wait' can be deleted if the user doesn't want to see the program's progress.
		arraySubCoord = split(arrayCoords[y], " ");
		box_left = parseFloat(arraySubCoord[0]);
		box_top = parseFloat(arraySubCoord[1]);
		box_width = parseFloat(arraySubCoord[2]);
		box_height = parseFloat(arraySubCoord[3]);
	  mid_y = box_top+(box_height/2);
		
		makeRectangle(box_left, box_top, box_width, box_height);
		
		run("Set Measurements...", " area redirect=None decimal=5");
		run("Analyze Particles...", "minimum=1 maximum=99999999 bins=20 show=Nothing clear record include"); run("Select None");
		
		areaCum = 0;
		for (j=0; j<nResults; j++) {
			areaNow = pow(hist_scale, 2)*getResult("Area", j);  // sets scale from pixels to microns
			areaCum = areaCum + areaNow;
		}
		
		arrayReturnedStats[y+1] = "" + (box_left*hist_scale) + ", " + (box_top*hist_scale) + ", " + (box_width*hist_scale) + ", " + (box_height*hist_scale) + ", " + (box_width*hist_scale)*(box_height*hist_scale) + ", " + (mid_y*hist_scale) + ", " + areaCum;
	}
	if(parseInt(arrayParamChoices[10])==true) garbageCollect();
	printarray(arrayReturnedStats);
	selectWindow("Log"); save(arrayParamChoices[14]+arrayParamChoices[0]+"_"+"CRACKAREA.txt"); run ("Close");
}