import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.io.File;
import java.awt.image.PixelGrabber;
import java.awt.image.MemoryImageSource;

class IMP{
   JFrame frame;
   JPanel mp;
   JScrollPane scroll;
   JMenuItem openItem, exitItem;
   Toolkit toolkit;
   File pic;
   ImageIcon img;
   int [] pixels;
   //Instance Fields you will be using below
   
   //This will be your height and width of your 2d array
   int height=0, width=0;
   
   //your 2D array of pixels
    int picture[][];

    /* 
     * In the Constructor I set up the GUI, the frame the menus. The open pulldown 
     * menu is how you will open an image to manipulate. 
     */
   IMP()
   {
      toolkit = Toolkit.getDefaultToolkit();
      frame = new JFrame("Image Processing Software by Hunter");
      JMenuBar bar = new JMenuBar();
      JMenu file = new JMenu("File");
      JMenu functions = getFunctions();
      frame.addWindowListener(new WindowAdapter(){
              public void windowClosing(WindowEvent ev){quit();}
            });
      openItem = new JMenuItem("Open");
      openItem.addActionListener(new ActionListener(){
          public void actionPerformed(ActionEvent evt){ handleOpen(); }
           });
      exitItem = new JMenuItem("Exit");
      exitItem.addActionListener(new ActionListener(){
          public void actionPerformed(ActionEvent evt){ quit(); }
           });
      file.add(openItem);
      file.add(exitItem);
      bar.add(file);
      bar.add(functions);
      frame.setSize(600, 600);
      mp = new JPanel();
      mp.setBackground(new Color(0, 0, 255));
      scroll = new JScrollPane(mp);
      frame.getContentPane().add(scroll, BorderLayout.CENTER);
      frame.setJMenuBar(bar);
      frame.setVisible(true);      
   }
   
   /* 
    * This method creates the pulldown menu and sets up listeners to selection of the menu choices. If the listeners are activated they call the methods 
    * for handling the choice, fun1, fun2, fun3, fun4, etc. etc. 
    */
   
  private JMenu getFunctions()
  {
     JMenu fun = new JMenu("Functions");
     JMenuItem firstItem = new JMenuItem("first");
     firstItem.addActionListener(new ActionListener(){
          public void actionPerformed(ActionEvent evt){fun1();}
           });
        
      fun.add(firstItem);
      
       JMenuItem secondItem = new JMenuItem("Second");
       secondItem.addActionListener(new ActionListener(){
          public void actionPerformed(ActionEvent evt){fun2();}
           });
        
      
      
       JMenuItem thirdItem = new JMenuItem("Third");
     thirdItem.addActionListener(new ActionListener(){
          public void actionPerformed(ActionEvent evt){fun3();}
           });
        
      
      
       JMenuItem fourthItem = new JMenuItem("Fourth");
     fourthItem.addActionListener(new ActionListener(){
          public void actionPerformed(ActionEvent evt){fun4();}
           });
           
      JMenuItem fifthItem = new JMenuItem("Fifth");
     fifthItem.addActionListener(new ActionListener(){
          public void actionPerformed(ActionEvent evt){fun5();}
           });
        
      fun.add(firstItem);
      fun.add(secondItem);
      fun.add(thirdItem);
      fun.add(fourthItem);
      fun.add(fifthItem);
      return fun;   

  }
  
  /*
   * This method handles opening an image file, breaking down the picture to a one-dimensional array and then drawing the image on the frame. 
   * You don't need to worry about this method. 
   */
    private void handleOpen()
  {  
     img = new ImageIcon();
     JFileChooser chooser = new JFileChooser();
     int option = chooser.showOpenDialog(frame);
     if(option == JFileChooser.APPROVE_OPTION) {
       pic = chooser.getSelectedFile();
       img = new ImageIcon(pic.getPath());
      }
     width = img.getIconWidth();
     height = img.getIconHeight();     
     JLabel label = new JLabel(img);
     pixels = new int[width*height];
     
     int [] results = new int[width*height];
     Image image = img.getImage();
        
     PixelGrabber pg = new PixelGrabber(image, 0, 0, width, height, pixels, 0, width );
     try{
         pg.grabPixels();
     }catch(InterruptedException e)
       {
          System.err.println("Interrupted waiting for pixels");
          return;
       }
     turnTwoDimensional();
     mp.removeAll();
     mp.add(label);
     
     mp.revalidate();
  }
  
  /*
   * The libraries in Java give a one dimensional array of RGB values for an image, I thought a 2-Dimensional array would be more usefull to you
   * So this method changes the one dimensional array to a two-dimensional. 
   */
  private void turnTwoDimensional()
  {
     picture = new int[height][width];
     for(int i=0; i<height; i++)
       for(int j=0; j<width; j++)
          picture[i][j] = pixels[i*width+j];
      
     
  }
  /*
   * This method is called to redraw the screen with the new image. 
   */
  private void resetPicture()
  {
       for(int i=0; i<height; i++)
       for(int j=0; j<width; j++)
          pixels[i*width+j] = picture[i][j];
      Image img2 = toolkit.createImage(new MemoryImageSource(width, height, pixels, 0, width)); 

      JLabel label2 = new JLabel(new ImageIcon(img2));    
       mp.removeAll();
       mp.add(label2);
     
       mp.revalidate(); 
   
    }
    /*
     * This method takes a single integer value and breaks it down doing bit manipulation to 4 individual int values for A, R, G, and B values
     */
  private int [] getPixelArray(int pixel)
  {
      int temp[] = new int[4];
      temp[0] = (pixel >> 24) & 0xff;
      temp[1]   = (pixel >> 16) & 0xff;
      temp[2] = (pixel >>  8) & 0xff;
      temp[3]  = (pixel      ) & 0xff;
      return temp;
      
    }
    /*
     * This method takes an array of size 4 and combines the first 8 bits of each to create one integer. 
     */
  private int getPixels(int rgb[])
  {
         int alpha = 0;
         int rgba = (rgb[0] << 24) | (rgb[1] <<16) | (rgb[2] << 8) | rgb[3];
        return rgba;
  }
  
  
  /**************************************************************************************************
   * This is where you will put your methods. Every method below is called when the corresponding pulldown menu is 
   * used. As long as you have a picture open first the when your fun1, fun2, fun....etc method is called you will 
   * have a 2D array called picture that is holding each pixel from your picture. 
   *************************************************************************************************/
   /*
    * Example function that just removes all red values from the picture. 
    * Each pixel value in picture[i][j] holds an integer value. You need to send that pixel to getPixelArray the method which will return a 4 element array 
    * that holds A,R,G,B values. Ignore [0], that's the Alpha channel which is transparency, we won't be using that, but you can on your own.
    * getPixelArray will breaks down your single int to 4 ints so you can manipulate the values for each level of R, G, B. 
    * After you make changes and do your calculations to your pixel values the getPixels method will put the 4 values in your ARGB array back into a single
    * integer value so you can give it back to the program and display the new picture. 
    */
  private void fun1()
  {
     
    for(int i=0; i<height; i++)
       for(int j=0; j<width; j++)
       {   
          int rgbArray[] = new int[4];
          
          rgbArray = getPixelArray(picture[i][j]);
          //picture[i][j] = changePixels(picture[i][j]);
        
           rgbArray[1] = 0;
           picture[i][j] = getPixels(rgbArray);
        } 
     resetPicture();
  }

  
  /*
   * Gradient picture
   */
    
  private void fun2()
  {
      for(int i=0; i<height; i++)
       for(int j=0; j<width; j++)
       {   
          int rgbArray[] = new int[4];
          
          rgbArray = getPixelArray(picture[i][j]);
          //picture[i][j] = changePixels(picture[i][j]);
        
           rgbArray[1] = j%255;
           rgbArray[2] = j%255;
           rgbArray[3] = j%255;
           picture[i][j] = getPixels(rgbArray);
          
        }
      resetPicture();
  }
  
  /*
   * GrayScale image
   */
  private void fun3()
  {
       for(int i=0; i<height; i++)
       for(int j=0; j<width; j++)
       {   
          int rgbArray[] = new int[4];
          
          rgbArray = getPixelArray(picture[i][j]);
          //picture[i][j] = changePixels(picture[i][j]);
        
          int sum = 0; 
          for(int x =1; x<4; x++)
              sum += rgbArray[x];
           int pix = sum/3;
           if(i == 200 && j==200)
              System.out.println(pix + " " + sum);
           rgbArray[1] = pix;
           rgbArray[2] = pix;
           rgbArray[3] = pix;
           picture[i][j] = getPixels(rgbArray);
          
        }
      resetPicture();
  }
  
  /*
   *  Edge Detection
   */
  private void fun4()
  {
      int  picture2[][] = new int[height][width];
      for(int i=0; i<height; i++)
       for(int j=0; j<width; j++)
       {   
          int rgb[] = new int[4];
          int tl[] = new int[4];
          rgb = getPixelArray(picture[i][j]);
          
          int temp = picture[i][j];
          if(i!=0 && i != height-1 && j != 0 && j != width-1)
          {
            if(temp == picture[i-1][j] && temp == picture[i][j+1] && temp == picture[i+1][j] && temp == picture[i][j-1])
                { rgb[1] = 255; rgb[2] = 255; rgb[3] = 255;}
            }
          picture2[i][j] = getPixels(rgb);
        }
        
        picture = picture2;
        
        resetPicture();
          
  }
 
  /*
   * Isolating the red color. 
   */
  
  private void fun5()
  {
      for(int i=0; i<height; i++)
       for(int j=0; j<width; j++)
       {   
          int rgb[] = new int[4];
          
          rgb = getPixelArray(picture[i][j]);
          
          if(rgb[1] > 200 && rgb[2] <100 && rgb[3] < 100)
          {    rgb[1] = 255; rgb[2] = 0; rgb[3] = 0;}
          else 
          { rgb[1] = 0; rgb[2] = 0; rgb[3] = 0;}
          
        picture[i][j] = getPixels(rgb);
        }
        
       
        
        resetPicture();  
  }

 
  private void quit()
  {  
     System.exit(0);
  }

   public static void main(String [] args)
   {
      IMP imp = new IMP();
   }
 
}