import ij.*;
import ij.process.*;
import ij.gui.*;
import ij.measure.*;

import java.awt.*;
import java.awt.event.*;
import java.math.*;

import javax.swing.*;

import ij.plugin.*;
import ij.plugin.filter.*;
import ij.plugin.PlugIn;

import org.math.plot.*;
import org.math.array.*;
import org.math.io.*;

public class S25_Histogram implements PlugInFilter
{
	ImagePlus imp;
	protected ImageStack stackin;


	double time;
	static int x = 2;
	static int y = 15;
	static int size = 12;
	int maxWidth;
	Font font;
	static double start = 0;
	static double interval = 1;
	static double readNoiseX3 = 10;		// in ADU
	static double binWidth = 4;			// in ADU
	static String subtractOffset = "yes";
	static int decimalPlaces = 0;
	boolean canceled;
	int frame, first, last;

	int numFramesPerSet = 3;
	Rectangle roi;
	double totalDarkValue = 0;
	double avgDarkValue = 0;

	int histogramSize = 800;
	static double seedThreshold = 80;
	static double cleanThreshold = .7;
	int column = 1;
	int fCRIC = 1;

	//int readNoiseX3 = 6;

    public int setup(String arg, ImagePlus imp)
    {
        if (IJ.versionLessThan("1.32c"))
            return DONE;
        this.imp = imp;
        stackin = imp.getStack();

        IJ.register(Photon_Transfer.class);
        if (imp!=null)
        {
            first = 1;
			last = imp.getStackSize();
        }
        return DOES_ALL;
    }

    public void run(ImageProcessor ip)
    {
		JFrame windowPlotKHistogram;
		Plot2DPanel PlotKHistogram;

		boolean seed;

		double[][] histS1 = new double[histogramSize][2];
		double[][] histS2 = new double[histogramSize][2];
		double[][] histS4 = new double[histogramSize][2];
		double[][] histS9 = new double[histogramSize][2];
		double[][] histS1_clean = new double[histogramSize][2];

		for (int i=0; i<histogramSize; i++)
		{
			histS1[i][0] = i;
			histS1[i][1] = 0;

			histS2[i][0] = i;
			histS2[i][1] = 0;

			histS4[i][0] = i;
			histS4[i][1] = 0;

			histS9[i][0] = i;
			histS9[i][1] = 0;

			histS1_clean[i][0] = i;
			histS1_clean[i][1] = 0;


		}

		roi = ip.getRoi();
		if (roi == null)
		{
			roi.x = 0;
			roi.y = 5;
			roi.width = 1;
			roi.height = 10;
			//roi.width = ip.getWidth();
			//roi.height = ip.getHeight();
		}

		//frame++;
		//if (frame==1) showDialog(ip);
		//if (canceled || frame<first || frame>last) return;


		showDialog(ip);

		if (canceled == true) return;

	    for (int stackNum=1; stackNum <= stackin.getSize(); stackNum++)
	    {
			ImageProcessor ipSlice = stackin.getProcessor(stackNum);
			double value_n = 0;
			double value_S2 = 0;
			double value_S4 = 0;
			double value_S9 = 0;
			//double value_S16 = 0;
			//double value_next_largest = 0;
			double value1_largest = 0;
			double value2_largest = 0;
			double value3_largest = 0;
			double value4_largest = 0;
			double value5_largest = 0;
			double value6_largest = 0;
			double value7_largest = 0;
			double value8_largest = 0;
			double value9_largest = 0;

			int columnGroup = 0;
			for (int y = roi.y; y<(roi.y+roi.height); y++)
			{
				for (int x = roi.x + (columnGroup * 12); x < (roi.x + (columnGroup * 12) + roi.width); x++)
				{
					double value_S1 = ipSlice.getPixelValue(x,y);
					if (value_S1 >= seedThreshold)
					{
						seed = true;

						value1_largest = 0;
						value2_largest = 0;
						value3_largest = 0;
						value4_largest = 0;
						value5_largest = 0;
						value6_largest = 0;
						value7_largest = 0;
						value8_largest = 0;
						value9_largest = 0;

						for (int deltaX = -2; deltaX <= 2; deltaX++)
						{
							for (int deltaY = -2; deltaY <= 2; deltaY++)
							{
								// only look at pixels above the read noise!
								value_n = ipSlice.getPixelValue(x+deltaX,y+deltaY);
								if ( value_n > value_S1)	// exit if any pixels are larger than seed
								{
									deltaX = 2;
									deltaY = 2;
									seed = false;
								}

								else if (value_n > readNoiseX3)
								{
									if (value_n > value1_largest)
									{
										value9_largest = value8_largest;
										value8_largest = value7_largest;
										value7_largest = value6_largest;
										value6_largest = value5_largest;
										value5_largest = value4_largest;
										value4_largest = value3_largest;
										value3_largest = value2_largest;
										value2_largest = value1_largest;
										value1_largest = value_n;
									}
									else if (value_n > value2_largest)
									{
										value9_largest = value8_largest;
										value8_largest = value7_largest;
										value7_largest = value6_largest;
										value6_largest = value5_largest;
										value5_largest = value4_largest;
										value4_largest = value3_largest;
										value3_largest = value2_largest;
										value2_largest = value_n;
									}
									else if (value_n > value3_largest)
									{
										value9_largest = value8_largest;
										value8_largest = value7_largest;
										value7_largest = value6_largest;
										value6_largest = value5_largest;
										value5_largest = value4_largest;
										value4_largest = value3_largest;
										value3_largest = value_n;
									}
									else if (value_n > value4_largest)
									{
										value9_largest = value8_largest;
										value8_largest = value7_largest;
										value7_largest = value6_largest;
										value6_largest = value5_largest;
										value5_largest = value4_largest;
										value4_largest = value_n;
									}
									else if (value_n > value5_largest)
									{
										value9_largest = value8_largest;
										value8_largest = value7_largest;
										value7_largest = value6_largest;
										value6_largest = value5_largest;
										value5_largest = value_n;
									}

									else if (value_n > value6_largest)
									{
										value9_largest = value8_largest;
										value8_largest = value7_largest;
										value7_largest = value6_largest;
										value6_largest = value_n;
									}

									else if (value_n > value7_largest)
									{
										value9_largest = value8_largest;
										value8_largest = value7_largest;
										value7_largest = value_n;
									}

									else if (value_n > value8_largest)
									{
										value9_largest = value8_largest;
										value8_largest = value_n;
									}

									else if (value_n > value9_largest)
									{
										value9_largest = value_n;
									}
								} // if > read noise

							} 	// for delta y
						}		// for delta x

						if (seed == true)
						{
							value_S2 = value1_largest + value2_largest;
							value_S4 = value_S2 + value3_largest + value4_largest;
							value_S9 = value_S4 + value5_largest + value6_largest + value7_largest + value8_largest + value9_largest;

							if (value_S1 < histogramSize - binWidth)
							{
								for (int ii=0; ii< binWidth; ii++)
								{
									histS1[(int)( (int)(value_S1/binWidth)*binWidth) +ii][1] += 1;
								}
							}
							//else histS1[(int)histogramSize-1][1] += 1;

							if (value_S2 < histogramSize - binWidth)
							{
								for (int ii=0; ii< binWidth; ii++)
								{
									histS2[(int)( (int)(value_S2/binWidth)*binWidth) +ii][1] += 1;
								}
							}
							//else histS2[(int)histogramSize-1][1] += 1;

							if (value_S4 < histogramSize - binWidth)
							{
								for (int ii=0; ii< binWidth; ii++)
								{
									histS4[(int)( (int)(value_S4/binWidth)*binWidth) +ii][1] += 1;
								}
							}
							//else histS4[(int)histogramSize-1][1] += 1;

							if (value_S9 < histogramSize - binWidth)
							{
								for (int ii=0; ii< binWidth; ii++)
								{
									histS9[(int)( (int)(value_S9/binWidth)*binWidth) +ii][1] += 1;
								}
							}
							//else histS9[(int)histogramSize-1][1] += 1;


							if (value_S1/value_S9 >= cleanThreshold)
							{
								if (value_S1 < histogramSize - binWidth)
								{
									for (int ii=0; ii< binWidth; ii++)
									{
										histS1_clean[(int)( (int)(value_S1/binWidth)*binWidth) +ii][1] += 1;
									}
								}
								//else histS1[(int)histogramSize-1][1] += 1;
							}
						}
					}
				}
			}
		}

		//***************************************************
		// create a new window with KHistogram
		Plot2DPanel plotKHistogram = new Plot2DPanel();
        plotKHistogram.addLegend("SOUTH");
        plotKHistogram.addLinePlot("S1, seed >" + seedThreshold + "  Bin Width = " + binWidth, histS1);
        plotKHistogram.setAxisLabel(0,"ADU");
        plotKHistogram.setAxisLabel(1,"Occurrences");
		plotKHistogram.setAutoBounds(0);
		plotKHistogram.setAutoBounds(1);

		plotKHistogram.addLinePlot("S2", histS2);
		plotKHistogram.addLinePlot("S4", histS4);
		plotKHistogram.addLinePlot("S9", histS9);
		plotKHistogram.addLinePlot("S1 clean", histS1_clean);
		//plotKHistogram.addLinePlot("SumOfCleans", histOfClean);

        windowPlotKHistogram = new JFrame();
        windowPlotKHistogram.setContentPane(plotKHistogram);
        windowPlotKHistogram.setTitle("ADC vs Occurrences");
        windowPlotKHistogram.pack();
        windowPlotKHistogram.setVisible(true);
        windowPlotKHistogram.setFocusable(true);
        windowPlotKHistogram.requestFocusInWindow();
        windowPlotKHistogram.setSize(500,500);
    }



    // will evenutally ask for stack information
    void showDialog(ImageProcessor ip)
    {

		//Rectangle roi = ip.getRoi();
		if (roi.width<ip.getWidth() || roi.height<ip.getHeight()) {
			x = roi.x;
			y = roi.y+roi.height;
			size = (int) ((roi.height - 1.10526)/0.934211);
			if (size<7) size = 7;
			if (size>80) size = 80;
		}
		GenericDialog gd = new GenericDialog("S1 Histogram Plot");
		gd.addNumericField("Seed Threshold >=", seedThreshold, 0);
		gd.addNumericField("Clean Threshold (S1/S9 <)", cleanThreshold, 2);
		gd.addNumericField("Selection Bounds xbase", roi.x, 0);
		gd.addNumericField("Selection Bounds ybase", roi.y, 0);
		gd.addNumericField("Selection Bounds width", roi.width, 0);
		gd.addNumericField("Selection Bounds height", roi.height, 0);
		gd.addNumericField("First Frame:", first, 0);
		gd.addNumericField("Last Frame:", last, 0);
		gd.addNumericField("Read Noise (ADU)", readNoiseX3, 0);
		gd.addNumericField("Bin Width (ADU)", binWidth, 0);
		gd.showDialog();
		if (gd.wasCanceled())
			{canceled = true; return;}
		seedThreshold = gd.getNextNumber();
 		cleanThreshold = gd.getNextNumber();
		x = (int)gd.getNextNumber();
		y = (int)gd.getNextNumber();
		size = (int)gd.getNextNumber();
		decimalPlaces = (int)gd.getNextNumber();
		first = (int)gd.getNextNumber();
		last = (int)gd.getNextNumber();
		readNoiseX3 = gd.getNextNumber();
		binWidth = gd.getNextNumber();
		font = new Font("SansSerif", Font.PLAIN, size);
		ip.setFont(font);
		time = start;
		if (y<size)
			y = size;
		maxWidth = ip.getStringWidth(getString(start+interval*imp.getStackSize()));
		imp.startTiming();
    }

    String getString(double time)
    {
	if (interval==0.0)
		return subtractOffset;
	else
		return (decimalPlaces==0?""+(int)time:IJ.d2s(time, decimalPlaces))+" "+subtractOffset;
    }

}