import java.awt.color.ColorSpace;
import java.awt.image.*;
import java.awt.*;
import java.io.File;
import java.io.IOException;
import javax.imageio.ImageIO;
import java.util.Scanner;
import javax.swing.JFrame; 
import javax.swing.JPanel;

import java.awt.event.*;

public class Blob {
	
 
    public static final int gauss_width(double sigma) {
    	// fill this in.  Given a sigma, compute the appropriate width of a 
    	// Gaussian filter for that sigma.
    }
    
    public static final double[][] gauss(double sigma) {
    	// Fill this in.  Compute a 2D array that contains the appropriate
    	// entries for a Gaussian filter.  Use the formula for a Gaussian
    	// to compute the values, and make sure that you normalize. 
    	
    }
    
   
    private static BufferedImage convertToGrayscale(BufferedImage source) {      
        BufferedImage image = new BufferedImage( source.getWidth(), source.getHeight(), BufferedImage.TYPE_BYTE_GRAY );  
        Graphics g = image.getGraphics();  
        g.drawImage( source, 0, 0, null );  
        g.dispose();
        return image;
   }

	
	private static BufferedImage readImage() {
		final String dir = "c:\\dwj\\matlab\\teach\\CMSC 426\\"; 
		//The path needs to be changed from a machine to another
		
		BufferedImage img = null;
		BufferedImage imggray = null;
		String fname;
		Scanner scan = new Scanner (System.in);
		
		System.out.println ("Enter file name:");
		fname = scan.nextLine();
		File dirfile = new File(dir + fname);
		
		
		try {
            img = ImageIO.read(dirfile);
        } catch (IOException e) {System.out.println("Image not read");
        }
        
       imggray = convertToGrayscale(img);
        
        imggray = img;
       return imggray; 
	}
	
	public static double [][] myConvolve(double [][] img, int ih, int iw, int h, int w, double [][] filter){
		// In order to find blobs, we must preserve all smoothed values as doubles.  
		// Java's convolution converts to integers.  This rounding off loses too much information
		// about local extrema.
		double [][] res_img = new double [iw][ih];
		for (int i=0;i<ih;i++){
			for (int j=0; j<iw; j++){
				res_img[j][i] = img[j][i];
			}
		}
		int h2 = (h-1)/2;
		int w2 = (w-1)/2;
		for (int i = h2; i < ih - h2; i++){
			for (int j = w2; j < iw - w2; j++){
				res_img[j][i] = 0;
				for (int ii = -h2; ii <= h2; ii++){
					for (int jj = -w2; jj <= w2; jj++){
						res_img[j][i] += img[j-jj][i-ii]*filter[jj+w2][ii+h2];
						
					}
				}
			}
		}
			
		return res_img;		
	}
	
	public static double[][] smoothNext(double [][] last_smoothed, int ih, int iw, int n, double kk, double sigma) {
		// last_smooothed is an image that has been smoothed n times already.  That means
		// it's been smoothed with a Gaussian of standard deviation sigma*kk^n.
		// n must be at least one.
		// We want to create the next image, that has been smoothed with a Gaussian of sigma*kk^(n+1)
  		double lastsig = sigma*Math.pow(kk, n-1);
  		double sig = Math.sqrt(Math.pow(lastsig*kk, 2) - Math.pow(lastsig, 2)); 
        int w = gauss_width(sig);
        double [][] nextimg = myConvolve(last_smoothed, ih, iw, w, w, gauss(sig));
        
        return nextimg;
	}
	
	public static void main(String[] args) {
		BufferedImage img = null;
		double [][] imgsmooth1;
		double [][] imgsmooth2;
		double [][] imgsmooth3;
		double [][] imgsmooth4;

		int img_width, img_height;
		double sigma = 1.6;
		double kk = 1.26;
		int w;
		int n = 0;
		// n indicates the number of times the image has been smoothed.
		
		img = readImage();
		Graphics g = img.getGraphics();
		g.setColor(Color.RED);

        img_height = img.getHeight();
        img_width = img.getWidth();
        
        double [][] imgdouble = new double [img_width][img_height];
		byte pix[]=new byte[1];
		int pix1int;        
		for (int i=0;i<img_height;i++){
			for (int j=0; j<img_width; j++){
				img.getRaster().getDataElements(j,i,pix);
				pix1int =((int)pix[0])& 0xff;
				imgdouble[j][i] = ((double) pix1int)/255.0;
			}
		}
				
				
        w = gauss_width(sigma);
        imgsmooth1 = myConvolve(imgdouble, img_height, img_width, w, w, gauss(sigma));

        n = 1;
        imgsmooth2 = smoothNext(imgsmooth1, img_height, img_width, n, kk, sigma);
        // Note that this doesn't smooth with a Gaussian of sigma.  Rather, it chooses
        // a Gaussian so that, assuming that imgsmooth1 was already smoothed with a Gaussian
        // of sigma, we will smooth so the resulting image is the same as if it were smoothed
        // with a Gaussian of sigma*kk.
        n = n + 1;
        imgsmooth3 = smoothNext(imgsmooth2, img_height, img_width, n, kk, sigma);
        n = n + 1;
        imgsmooth4 = smoothNext(imgsmooth3, img_height, img_width, n, kk, sigma);
        n = n + 1;
        
        
		double diff1[][]=new double[img_height][img_width];
		double diff2[][]=new double[img_height][img_width];
		double diff3[][]=new double[img_height][img_width];
     
	
		for (int i=0;i<img_height;i++){
			for (int j=0; j<img_width; j++){
				diff1[i][j] = imgsmooth2[j][i] - imgsmooth1[j][i];
				diff2[i][j] = imgsmooth3[j][i] - imgsmooth2[j][i];
				diff3[i][j] = imgsmooth4[j][i] - imgsmooth3[j][i];
			}
		}
		// Above shows an example of smoothing to create the first four scales of the image and
		// taking the differences between pixels at neighboring scales.  So, a point at (i,j)
		// in imgsmooth3 will be a blob point if diff2[i][j] is bigger than all neighboring 
		// values at its own scale and at all neighboring scales, (in diff1 and diff3).
		
		// Now you need to compute these extrema.  You should smooth 9 more times, at least,
		// to find extrema at 10 different possible scales.
		
		// When you find an extrema, you can draw it with: g.drawOval(j,i,n,n);
		

        JFrame f = new JFrame("Image");
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        f.setPreferredSize(new Dimension (img_height, img_width));
        MyImagePanel panel = new MyImagePanel (img, img_height, img_width); 
	    JPanel mainpane = new JPanel();
	    mainpane.setBackground(Color.black);
	    mainpane.add(panel);
	    f.getContentPane().add(mainpane);
	    f.pack();
	    f.setVisible(true);
        
        
	
	}
	
	
	
	

	
	
}