import java.awt.*;
import java.awt.font.*;
import java.awt.geom.*;
import java.awt.image.BufferedImage;
import java.text.*;

/**
 * A class that represents a picture.  This class inherits from 
 * SimplePicture and allows the student to add functionality to
 * the Picture class.  
 * 
 * Copyright Georgia Institute of Technology 2004-2005
 * @author Barbara Ericson ericson@cc.gatech.edu
 */
public class Picture extends SimplePicture 
{
  ///////////////////// constructors //////////////////////////////////
  
  /**
   * Constructor that takes no arguments 
   */
  public Picture ()
  {
    /* not needed but use it to show students the implicit call to super()
     * child constructors always call a parent constructor 
     */
    super();  
  }
  
  /**
   * Constructor that takes a file name and creates the picture 
   * @param fileName the name of the file to create the picture from
   */
  public Picture(String fileName)
  {
    // let the parent class handle this fileName
    super(fileName);
  }
  
  /**
   * Constructor that takes the width and height
   * @param width the width of the desired picture
   * @param height the height of the desired picture
   */
  public Picture(int width, int height)
  {
    // let the parent class handle this width and height
    super(width,height);
  }
  
  /**
   * Constructor that takes a picture and creates a 
   * copy of that picture
   */
  public Picture(Picture copyPicture)
  {
    // let the parent class do the copy
    super(copyPicture);
  }
  
  /**
   * Constructor that takes a buffered image
   * @param image the buffered image to use
   */
  public Picture(BufferedImage image)
  {
    super(image);
  }
  
  ////////////////////// methods ///////////////////////////////////////
  
  /**
   * Method to return a string with information about this picture.
   * @return a string with information about the picture such as fileName,
   * height and width.
   */
  public String toString()
  {
    String output = "Picture, filename " + getFileName() + 
      " height " + getHeight() 
      + " width " + getWidth();
    return output;
    
  }
 public void increaseblue()
  {
  clearBlue();
  }
 
 public void decreaseBlue()
  {
 clearBlue();
  }
 
  public void clearBlue()
  {
    Pixel[] pixelArray = this.getPixels();
    int index = 0;
    Pixel pixelObj = null;

    // loop through all the pixels in the array
    while (index < pixelArray.length/2)
    {
    pixelObj = pixelArray[index];
     // set the blue value of the current pixel to the new value
      pixelObj.setBlue(0);
      index++;
    }
  }
 
   /*public void clearBlue()
  {
        Pixel pixelObj = null;

    // loop through all the rows
     for (int y=0;y<this.getHeight();y++)
    {
    // loop through all the columns
      for (int x=0;x<this.getWidth();x++)
          {
          // get the current pixel
      pixelObj = this.getPixel(x,y);

      // do something to the color

      // set the new color
      pixelObj.setColor(colorObj);
     }
  } 
   }*/
     public void clearBlueWhile()
  {
    Pixel[] pixelArray = this.getPixels();
    int index = 0;
    Pixel pixelObj = null;

    // loop through all the pixels in the array
    while (index < pixelArray.length/2)
    {
    pixelObj = pixelArray[index];
     // set the blue value of the current pixel to the new value
      pixelObj.setBlue(0);
      index++;
    }
  }
  
public void mirrorVertical()
 {
   int mirrorPoint = this.getWidth() / 2;
   Pixel leftPixel = null;
   Pixel rightPixel = null;

   // loop through the rows
   for (int y = 0; y < this.getHeight(); y++)
   {
     // loop from 0 to just before the mirror point
     for (int x = 0; x < mirrorPoint; x++)
     {
       leftPixel = this.getPixel(x, y);
       rightPixel = this.getPixel(this.getWidth() - 1 - x, y);
       leftPixel.setColor(rightPixel.getColor());
     }
   }
 }

 public void mirrorHorizontal()
 {
   int mirrorPoint = this.getHeight() / 2;
   Pixel topPixel = null;
   Pixel bottomPixel = null;

   // loop through the column
   for (int x = 0; x < this.getWidth(); x++)
   {
     // loop from 0 to just before the mirror point
     for (int y = 0; y < mirrorPoint; y++)
     {
       topPixel = this.getPixel(x, y);
       bottomPixel = this.getPixel(x,this.getHeight() - 1 - y);
       topPixel.setColor(bottomPixel.getColor());
     }
   }
 }      
  
 public void copyKatie()
 {
   String sourceFile = 
     FileChooser.getMediaPath("KatieFancy.jpg");
   Picture sourcePicture = new Picture(sourceFile);
   Pixel sourcePixel = null;
   Pixel targetPixel = null;

   // loop through the columns
   for (int sourceX = 73, targetX = 100;
        sourceX < 130;
        sourceX++, targetX++)   
   {
       // loop through the rows
     for (int sourceY = 3, targetY = 100;
          sourceY < 80;
          sourceY++, targetY++)   
     {

       // set the target pixel color to the source pixel color
       sourcePixel = sourcePicture.getPixel(sourceX,sourceY);
       targetPixel = this.getPixel(targetX,targetY);
       targetPixel.setColor(sourcePixel.getColor());
     }
   }
 }
/**
  Method to copy part oif the source picture to the current picture.
  @param sourcePicture the picture to copy from
  @param startX the x at the upper left corner to start copying from in the source picture (inclusive)
  @param startY the y at the upper left corner to start copying from in the source picture (inclusive)
  @param endX the x at the bottom right corner (exclusive)
  @param endY the y at the bottom right corner (exclusive)
  @param targetStartX the upper left corner to start copying to in the target (this picture)
  @paran targetStartY the upper left corner to start copying to in the target (this picture)
  */
  
public void copy(Picture sourcePicture, int startX, int startY, 
                           int endX, int endY, int targetStartX, int targetStartY)
  {
    Pixel sourcePixel = null;
    Pixel targetPixel = null;

    // loop through the x values
    for (int x = startX, tx = targetStartX; 
         x < endX; 
         x++, tx++)
    {
      // loop through the y values
      for (int y = startY, ty = targetStartY; 
           y < endY; 
           y++, ty++) 
      {
// copy the source color to the target color
        sourcePixel = sourcePicture.getPixel(x,y);
        targetPixel = this.getPixel(tx,ty);
        targetPixel.setColor(sourcePixel.getColor());
      }
    }
  }
/**
 * This methoid copies all of the source picture into the target (this picture) 
 * starting at the upper left corner specified by the targetStartX and targetStartY
 * @param sourcePicutre the picture to copy from
 * @param targetStartX the x value of the upper left corner to
 * start copying to the in the target (this picture)
 * @param targetStartY the y value of the upper left corner to
 * start copying to in the target (this picture)
*/ 
  
public void copy (Picture sourcePicture,
                  int targetStartX,
                  int targetStartY)
{
  this.copy(sourcePicture, 0, 0, sourcePicture.getWidth(),
       sourcePicture.getHeight(),targetStartX,
       targetStartY);
}
 public void removeRedEye(int startX, int startY, int endX, 
                           int endY, Color newColor)
  {
    Pixel pixelObj = null;
    
    // loop through the pixels in the rectangle defined by the // startX, startY, and endX and endY
    for (int x = startX; x < endX; x++)  
    {
      for (int y = startY; y < endY; y++)  
      {

        // get the current pixel
        pixelObj = getPixel(x,y);
        // if the color is near red then change it
        if (pixelObj.colorDistance(Color.red) < 167)
       {
          pixelObj.setColor(newColor);
       }
      }
    }
  } 

public void edgeDetection(int dist)
{
    Pixel topObj = null;
    Pixel bottomObj = null;
    
    // loop through the pixels x and y
    for (int x = 0; x < this.getWidth(); x++)  
    {
      for (int y = 0; y < this.getHeight() -1; y++)  
      {

        // get the top and bottom pixel
        topObj = getPixel(x,y);
        bottomObj = getPixel(x,y+1);
        
        // if the dist between the colors is greater than the passed dist set to black
        if (topObj.colorDistance(bottomObj.getColor() ) > dist)
       {
       topObj.setColor(Color.BLACK);
       }
      else
      {
       topObj.setColor(Color.WHITE);
      }
     }
    }
} 

public void swapBackground(Picture oldBackground,
                             Picture newBackground)
  {
    Pixel currPixel = null;
    Pixel oldPixel = null;
    Pixel newPixel = null;

    // loop through the columns
    for (int x=0; x<this.getWidth(); x++)
    {

      // loop through the rows
      for (int y=0; y<this.getHeight(); y++)
      {
 // get the current pixel and old background pixel
        currPixel = this.getPixel(x,y);
        oldPixel = oldBackground.getPixel(x,y);

        /* if the distance between the current pixel color 
         * and the old background pixel color is less than the 15
         * then swap in the new background pixel
         */
        if (currPixel.colorDistance(oldPixel.getColor()) < 15.0)
        {
          newPixel = newBackground.getPixel(x,y);
          currPixel.setColor(newPixel.getColor());
        }
      }
    }
  }
/** 
 * Method to do chromakey using a green background 
 * @pram newBg the new bacground image to use to replace
 * the green from the current picture
*/

public void chromakey(Picture newBg)
  {
    Pixel currPixel = null;
    Pixel newPixel = null;

    // loop through the columns
    for (int x=0; x<this.getWidth(); x++)
    {

      // loop through the rows
      for (int y=0; y<this.getHeight(); y++)
      {
 // get the current pixel
        currPixel = this.getPixel(x,y);

        /* if the distance is mostly green
         * (blue value is greater than red and blue combined),
         * then use new backround color
         */
        if (currPixel.getRed() + currPixel.getBlue() < currPixel.getGreen())
        {
          newPixel = newBg.getPixel(x,y);
          currPixel.setColor(newPixel.getColor());
        }
      }
    }
  }

/**
 * Method to copy flower pictures to create a collage.
 * All the flower pictures will be lined up near the 
 * bottom of the current picture (5 pixcels from the bottom)
 */


/* to copy a picture to a file use
pictureObjectName.write(FileChooser.getMediaPath("NameNewFile.jpg"));
*/

public void createFlowerCollage()
   {
     Picture source1Picture = 
       new Picture(FileChooser.getMediaPath("flower2.jpg"));
     Picture source2Picture =
       new Picture(FileChooser.getMediaPath("flower1.jpg"));
     int targetBottomY = this.getHeight() - 5;
     
     // copy source1Picture to 0, targetBottomY - height
     this.copy(source1Picture,0,0,
               source1Picture.getWidth(),
               source1Picture.getHeight(),
               0,targetBottomY - 
               source1Picture.getHeight());
     
     // copy source2Picture to 100, targetBottomY - height
     this.copy(source2Picture,0,0,
               source2Picture.getWidth(),
               source2Picture.getHeight(),
               100,targetBottomY - 
               source2Picture.getHeight());
// negate the source1Picture
     source1Picture.edgeDetection(100);
     
     // copy negated source1Picture to 200
     this.copy(source1Picture,0,0,
               source1Picture.getWidth(),
               source1Picture.getHeight(),
               200,targetBottomY - 
               source1Picture.getHeight());

     // clear the blue from source 1 picture
    source1Picture.clearBlue();
     
     // copy source2Picture to 300
     this.copy(source2Picture,0,0,
               source2Picture.getWidth(),
               source2Picture.getHeight(),
               300,targetBottomY - 
               source2Picture.getHeight());
     
     // copy negated source1Picture to 400
     this.copy(source1Picture,0,0,
               source1Picture.getWidth(),
               source1Picture.getHeight(),
               400,targetBottomY - 
               source1Picture.getHeight());
   

   int mirrorPoint = this.getHeight() / 2;
   Pixel topPixel = null;
   Pixel bottomPixel = null;

   // loop through the column
   for (int x = 0; x < this.getWidth(); x++)
   {
     // loop from 0 to just before the mirror point
     for (int y = 0; y < mirrorPoint; y++)
     {
       topPixel = this.getPixel(x, y);
       bottomPixel = this.getPixel(x,this.getHeight() - 1 - y);
       topPixel.setColor(bottomPixel.getColor());
     }
   }
}


  public static void main(String[] args) 
  {
  
   String file = FileChooser.getMediaPath("640x480.jpg");
   Picture p = new Picture(file);
   p.show();
   p.createFlowerCollage();
   p.repaint();

p.write(FileChooser.getMediaPath("pflower.jpg"));
    
      }
}

//public static void main(String[] args) 
//{
 
   //Picture kCurtis = new Picture(FileChooser.getMediaPath("kCurtis_GSSm.jpg"));
   //Picture newBack = new Picture(FileChooser.getMediaPath("water.jpg"));
   //kCurtis.chromakey(newBack);
   //kCurtis.show();
   //kCurtis.write(FileChooser.getMediaPath("kCurtisWater.jpg"));
//
  //}*/
//}
  
/* to copy a picture to a file use
pictureObjectName.write(FileChooser.getMediaPath("NameNewFile.jpg"));
*/ 
// this } is the end of class Picture, put all new methods before this