/**
  *  SFUtil:  Utilities for StarField class in conjunction with ImageJ 
  *  Glen Cowan, RHUL Physics Department
  *  November, 2004
  */

import ij.*;
import ij.process.*;
import ij.gui.*;
import ij.io.*;
import ij.plugin.filter.*;
import java.awt.*;
import java.awt.image.*;
import java.util.*;
import java.math.*;
import java.io.*;

public class SFUtil {

  static StarField starFieldFromImageJ (ImagePlus imp, ImageProcessor ip){
      
// Factory method to return StarField object from ImageJ's current image

//    double gain = IJ.getNumber("enter gain (e-/ADU)", 2.3);
    double gain = SFPar.getGain();
    int ny = ip.getHeight();
    int nx = ip.getWidth();
//    IJ.write("nx = " + nx);
//    IJ.write("ny = " + ny);
//    IJ.write("total pixels = " + nx*ny);

// get pixel info and pack into image array
    
    Pixel[][] pixelArray = new Pixel[nx][ny];
    int[] pixelList = new int[nx*ny];           // needed for median
    for (int j=0; j<ny; j++){
      for (int i=0; i<nx; i++){
        int val = ip.getPixel(i,j);
        pixelArray[i][j] = new Pixel(i, j, val);
        int k = i + nx*j;
        pixelList[k] = val;
      }
    }

// compute median, mode, minVal (threshold)

    Arrays.sort(pixelList);        // from java.util
    int midIndex = nx*ny/2;
    double median;
    if ( midIndex%2 == 0 ){
      median = (double)pixelList[midIndex-1];     // array index starts at 0
    }
    else {
      median = ((double)(pixelList[midIndex-1] + pixelList[midIndex])) / 2.0;
    }

// Quick background estimate would be best estimated by the mode, but this has
// problems with binning.  Not sure of algorithm used, but sometimes the bins
// are very broad leading to a mode that is significantly different from the
// typical background level.  So for now go with the median.

    ImageStatistics istat = imp.getStatistics();
    double mode = istat.dmode;
//    int minVal = (int)(mode + 5*Math.sqrt(mode/gain));
    int minVal = (int)(median + 5*Math.sqrt(median/gain));
    IJ.write("mode = " + mode);
    IJ.write("median = " + median);
    IJ.write("minVal = " + minVal);

// create and initialize StarField
       
    StarField sf = new StarField(nx, ny);
    sf.setMinVal(minVal);
    sf.setMode(mode);
    sf.setMedian(median);
    sf.setGain(gain);
    sf.setPixelArray(pixelArray);
 
    return sf;
      
  }               // end of starFieldFromImageJ

//-------------------------------------------------------------------------
  
  static void setStarFieldFromIJ(StarField sf, ImagePlus imp, ImageProcessor ip){

// takes an existing StarField object and initializes its data members from
// an ImageJ image

//    double gain = IJ.getNumber("enter gain (e-/ADU)", 2.3);
    double gain = SFPar.getGain();
    int ny = ip.getHeight();
    int nx = ip.getWidth();
//    IJ.write("nx = " + nx);
//    IJ.write("ny = " + ny);
//    IJ.write("total pixels = " + nx*ny);

// get pixel info and pack into image array
    
    Pixel[][] pixelArray = new Pixel[nx][ny];
    int[] pixelList = new int[nx*ny];           // needed for median
    for (int j=0; j<ny; j++){
      for (int i=0; i<nx; i++){
        int val = ip.getPixel(i,j);
        pixelArray[i][j] = new Pixel(i, j, val);
        int k = i + nx*j;
        pixelList[k] = val;
      }
    }

// compute median, mode, minVal (threshold)

    Arrays.sort(pixelList);        // from java.util
    int midIndex = nx*ny/2;
    double median;
    if ( midIndex%2 == 0 ){
      median = (double)pixelList[midIndex-1];     // array index starts at 0
    }
    else {
      median = ((double)(pixelList[midIndex-1] + pixelList[midIndex])) / 2.0;
    }

// Quick background estimate would be best estimated by the mode, but this has
// problems with binning.  Not sure of algorithm used, but sometimes the bins
// are very broad leading to a mode that is significantly different from the
// typical background level.  So for now go with the median.

    ImageStatistics istat = imp.getStatistics();
    double mode = istat.dmode;
//    int minVal = (int)(mode + 5*Math.sqrt(mode/gain));
    int minVal = (int)(median + 5*Math.sqrt(median/gain));
    IJ.write("mode = " + mode);
    IJ.write("median = " + median);
    IJ.write("minVal = " + minVal);

    sf.setNx(nx);
    sf.setNy(ny);
    sf.setMinVal(minVal);
    sf.setMode(mode);
    sf.setMedian(median);
    sf.setGain(gain);
    sf.setPixelArray(pixelArray);

  }

//-------------------------------------------------------------------------

  static void showClusterMap(StarField sf){
      
// Creates a new image showing the clusters.  
// This becomes the new default image.
      
    int nx = sf.getNx();
    int ny = sf.getNy();
    Pixel[][] pixelArray = sf.getPixelArray();

    ImagePlus imp = NewImage.createRGBImage("cluster map",
                           nx, ny, 1, NewImage.FILL_WHITE);
    ImageProcessor IP = imp.getProcessor();

    int[] clusterPixels = (int[]) IP.getPixels();
    for (int j=0; j<ny; j++){
      for (int i=0; i<nx; i++){
        int cNum = pixelArray[i][j].getCluster();
        int k = i + nx*j;
        if ( cNum >= 0 ) {
          clusterPixels[k] = (255 & 0xff) << 16;           // red
        }
      }
    }

// then superimpose the barycentre and local peaks

    int numClus = sf.getClusterVec().size();
    for (int i=0; i<numClus; i++){
      Cluster c = (Cluster)(sf.getClusterVec().elementAt(i));

      int numPeaks = c.getPeakVec().size();
      for (int j=0; j<numPeaks; j++){
        Pixel p = (Pixel)(c.getPeakVec().elementAt(j));
        int x = p.getI();
        int y = p.getJ();
        IP.setColor(java.awt.Color.blue);
        drawPoint(IP, (double)x, (double)y, 1);
      }

      Star star = c.getStar(sf);
      double muX = star.getX();
      double muY = star.getY();
      IP.setColor(java.awt.Color.green);
      drawPoint(IP, muX, muY, 2);

    }

    imp.show();
    imp.updateAndDraw();

  }             // end of showClusterMap

//-------------------------------------------------------------------------

  static void showStarMap(ApPhot ap){
      
// Creates a new image showing the clusters, stars and their apertures.  
// This becomes the new default image.
      
    int nx = ap.getNx();
    int ny = ap.getNy();
    Pixel[][] pixelArray = ap.getPixelArray();

    ImagePlus imp = NewImage.createRGBImage("star map",
                           nx, ny, 1, NewImage.FILL_WHITE);
    ImageProcessor IP = imp.getProcessor();

// first show the clusters 

    int[] clusterPixels = (int[]) IP.getPixels();
    for (int j=0; j<ny; j++){
      for (int i=0; i<nx; i++){
        int cNum = pixelArray[i][j].getCluster();
        int k = i + nx*j;
        if ( cNum >= 0 ) {
          clusterPixels[k] = (255 & 0xff) << 16;           // red
        }
      }
    }

// then show the stars

    IP.setColor(java.awt.Color.blue);
    int numStars = ap.getStarVec().size();
    for (int i=0; i<numStars; i++){
      Star s = (Star)(ap.getStarVec().elementAt(i));
      double x = s.getX();
      double y = s.getY();
      drawPoint(IP, x, y, 2);
    }

// show the apertures

    int numAps = ap.getApVec().size();
    for (int i=0; i<numStars; i++){
      Aperture a = (Aperture)(ap.getApVec().elementAt(i));       // signal
      Aperture b = (Aperture)(ap.getBckApVec().elementAt(i));    // background
      double x = a.getX();
      double y = a.getY();
      double r = a.getRadius();
      IP.setColor(java.awt.Color.blue);
      drawCircle(IP, x, y, r);
      IP.setColor(java.awt.Color.green);
      double rInner = b.getRInner();
      double rOuter = b.getROuter();
      drawCircle(IP, x, y, rInner);
      drawCircle(IP, x, y, rOuter);
    }

    imp.show();
    imp.updateAndDraw();

  }             // end of showStarMap

//-------------------------------------------------------------------------

  static void drawCircle(ImageProcessor IP, double x0, double y0, double r){

// Can't get this to work with graphics overlay so as a temporary kludge
// this is implemented with ImageProcessor's lineTo and moveTo.

    int n = 20;
    double dtheta = 2.*Math.PI/(double)n;
    int ix = (int)Math.round(x0 + r);
    int iy = (int)Math.round(y0);
    IP.moveTo(ix, iy);
    for (int i=1; i<=n; i++){
      double theta = (double)(i)*dtheta;
      double x = x0 + r*Math.cos(theta);
      double y = y0 + r*Math.sin(theta);
      ix = (int)Math.round(x);
      iy = (int)Math.round(y);
      IP.lineTo(ix, iy);
    }
  }

//-------------------------------------------------------------------------

  static void drawPoint(ImageProcessor IP, double x0, double y0, double r0){

// Ultra kludge to get reasonable sized data points

    int n = (int)Math.round(r0);
    double dr = 1.0;
    for (int j=0; j<=n; j++){
      double r = r0 - dr*(double)j;
      int ix = (int)Math.round(x0 + r);
      int iy = (int)Math.round(y0);
      IP.moveTo(ix, iy);
      int m = 6;
      double dtheta = 2.*Math.PI/(double)m;
      for (int i=1; i<=m; i++){
        double theta = (double)(i)*dtheta;
        double x = x0 + r*Math.cos(theta);
        double y = y0 + r*Math.sin(theta);
        ix = (int)Math.round(x);
        iy = (int)Math.round(y);
        IP.lineTo(ix, iy);
      }
    }
  }

//-------------------------------------------------------------------------

  static Vector getFileVec(){

//  gets a list of files from a file and puts them into a vector of strings.
//  Uses code from ImageJ plugin List_Opener
    
    Vector fileVec = new Vector();

    OpenDialog od = new OpenDialog("Input file list opener", null);
    String name = od.getFileName();
    if (name==null) { return fileVec; }      // -------------------> early exit
    IJ.write("Reading data files listed in " + name);

    String dir = od.getDirectory();
    Opener o = new Opener();
    int count = 0;
    String separator = System.getProperty("file.separator");
    try {
      BufferedReader r = new BufferedReader(new FileReader(dir+name));
      while (true) {
        String path = r.readLine();
        if (path==null) {
          break;
        }
        else {
          if (path.indexOf(separator)<0) {
             path = dir + path;
          }

// put file name into fileVec

          fileVec.addElement(path);
          count++;
          IJ.write(count+" + " +path);

        }
      }          // end while(true)
      r.close();
    }
    catch (IOException e) {
      IJ.error(""+e);
      return fileVec;
    }
    return fileVec;

  }

}            // end of class SFUtil