Picture Manipulation Methods

[Jason Newman]

Hi, I'm new here. And in my class we have been learning java with pictures and other media.
And so I'd like to contribute a BUNCH of manipulation methods for pictures.
I'm not sure if this is were I should post it, or even IF I should post it, I just want to contribute to anyone who is interested.
Sure, everything would be done much better in Photoshop, but where is the fun in that?
Also, I'm going to try to remove anything that is related to the class, but if there is anything in here that is class related, I apologize.
All of this is done in Dr. Java.

  import java.awt.*;
import java.awt.font.*;

import java.awt.geom.*;
import java.text.*;
import java.io.*;

/**
 * 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 [e-mail]
 */
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);
  }
  
  ////////////////////// 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 decreaseRed()
  {Pixel[] pixelArray=this.getPixels();
  int value = 0;
      // loop through all pixels in the array
    for (Pixel pixelObj : pixelArray)
    {
      // get the red value
      value= pixelObj.getRed();
      
      //decrease the red value by 50 (1/2)
      value= value/ 2;
        
        
        //set the red value of the current pixel the new value
        pixelObj.setRed(value);
    }
  }
  
   public void decreaseBlue()
  {Pixel[] pixelArray=this.getPixels();
  int value = 0;
      // loop through all pixels in the array
    for (Pixel pixelObj : pixelArray)
    {
      // get the blue value
      value= pixelObj.getBlue();
      
      //decrease the blue value by 50 (1/2)
      value= value/ 2;
        
        
        //set the blue value of the current pixel the new value
        pixelObj.setBlue(value);
    }
  }
    public void decreaseGreen()
  {Pixel[] pixelArray=this.getPixels();
  int value = 0;
      // loop through all pixels in the array
    for (Pixel pixelObj : pixelArray)
    {
      // get the green value
      value= pixelObj.getRed();
      
      //decrease the green value by 50 (1/2)
      value= value/ 2;
        
        
        //set the green value of the current pixel the new value
        pixelObj.setGreen(value);
    }
  }
    
    public void decreaseRed2()
    {
      Pixel[] pixelArray = this.getPixels();
      int value=0;
      Pixel pixelObj=null;
      int index = 0;
        
        //loop through all the pixels 
      while(index<pixelArray.length)
      {
      //get the red value
      value=pixelObj.getRed();
      
      //decrease the red value
      value = value / 2;
      
     //set the pixel red
      pixelObj.setRed(value);
      
      //imcrement the index
      index=index + 1;
    }
}
      /**
       * *Method to increase the red by 30%
       */
  public void increaseBlue()
{
  Pixel[] pixelArray = this.getPixels();
  Pixel pixelObj = null;
  int value = 0;
  int index = 0;
  //loop through all the pixels
  while (index>< pixelArray.length)
  {
    // get the current pixel
    pixelObj = pixelArray[index];
    //get the value
    value = pixelObj.getBlue();
    // increase value
    value = (int)(value * 1.3);
    //set the blue vaue
    pixelObj.setBlue(value);
    // incrememt the index
    
    index++;;
  }
  }
       
 public void increaseRed()
{
  Pixel[] pixelArray = this.getPixels();
  Pixel pixelObj = null;
  int value = 0;
  int index = 0;
  //loop through all the pixels
  while (index< pixelArray.length)
  {
    // get the current pixel
    pixelObj = pixelArray[index];
    //get the value
    value = pixelObj.getBlue();
    // increase value
    value = (int)(value * 1.3);
    //set the Blue vaue
    pixelObj.setBlue(value);
    // incrememt the index
    
    index++;;
  }
  }
 
 public void increaseGreen()
{
  Pixel[] pixelArray = this.getPixels();
  Pixel pixelObj = null;
  int value = 0;
  int index = 0;
  //loop through all the pixels
  while (index< pixelArray.length)
  {
    // get the current pixel
    pixelObj = pixelArray[index];
    //get the value
    value = pixelObj.getGreen();
    // increase value
    value = (int)(value * 1.3);
    //set the blue vaue
    pixelObj.setBlue(value);
    // incrememt the index
    
    index++;;
  }
  }
 
 public void clearBlue()
{
  Pixel[] pixelArray = this.getPixels();
  Pixel pixelObj = null;
  int value = 0;
  int index = 0;
  //loop through all the pixels
  while (index< pixelArray.length)
  {
    // get the current pixel
    pixelObj = pixelArray[index];
    //get the value
    value = pixelObj.getBlue();
    // increase value
 
    //set the blue vaue
    pixelObj.setBlue(0);
    // incrememt the index
    
    index++;;
  }
  }
  public void clearRed()
{
  Pixel[] pixelArray = this.getPixels();
  Pixel pixelObj = null;
  int value = 0;
  int index = 0;
  //loop through all the pixels
  while (index< pixelArray.length)
  {
    // get the current pixel
    pixelObj = pixelArray[index];
    //get the value
    value = pixelObj.getRed();
    // increase value
 
    //set the Red vaue
    pixelObj.setRed(0);
    // incrememt the index
    
    index++;;
  }
  }
  
   public void clearGreen()
{
  Pixel[] pixelArray = this.getPixels();
  Pixel pixelObj = null;
  int value = 0;
  int index = 0;
  //loop through all the pixels
  while (index< pixelArray.length)
  {
    // get the current pixel
    pixelObj = pixelArray[index];
    //get the value
    value = pixelObj.getGreen();
    // increase value
 
    //set the Green vaue
    pixelObj.setGreen(0);
    // incrememt the index
    
    index++;;
  }
  }
   
   /**
    * Method to simulate a sunset by
    * decreasing the green and blue
    * and blue
    */
   public void makeSunset()
   {
     Pixel[] pixelArray = this.getPixels();
     Pixel pixelObj = null;
     int value= 0;
     int i = 0;
     
     // loop through all the pixels 
     while (i < pixelArray.length)
     {
       //get the current pixel
       pixelObj = pixelArray[i];
       
      //change the blue value
       value = pixelObj.getBlue();
         pixelObj.setBlue((int) (value * 0.7));
         
        //change the Green value
       value = pixelObj.getGreen();
         pixelObj.setGreen((int) (value * 0.7));
         
       // imcrement the index
         i++;
     }
   }
  public void decreaseRed3()
     {  Pixel[] pixelArray = this.getPixels();
     Pixel pixelObj = null;
     int value= 0;
     int i = 0;
      while (i < pixelArray.length)
      {
          pixelObj = pixelArray[i];
       value = pixelObj.getRed();
         pixelObj.setRed((int) (value / 2));
           i++;
   }

  }
 /**
 * Method to change the picture to grey scale with luminance
 */
 public void greyscale2()
 {
   Pixel[] pixelArray=this.getPixels();
   Pixel pixelObj=null;
   int intensity=0;
   
   //loop through all the pixels
   for(int i=0; i< pixelArray.length;
       i++)
   {
     //get the current pixel
     pixelObj=pixelArray[i];
     
     //compute the average intensity
     intensity=(int)(pixelObj.getRed()*0.299 + pixelObj.getGreen()*0.587 + pixelObj.getBlue()*0.114);
     
     //set the pixel color
     pixelObj.setColor(new Color(intensity,intensity,intensity));
   }
 }


 
 
 
 
/**
 * Method to change the picture to grey scale
 */
 public void greyscale()
 {
   Pixel[] pixelArray=this.getPixels();
   Pixel pixelObj=null;
   int intensity=0;
   
   //loop through all the pixels
   for(int i=0; i< pixelArray.length;
       i++)
   {
     //get the current pixel
     pixelObj=pixelArray[i];
     
     //compute the average intensity
     intensity=(pixelObj.getRed() + pixelObj.getGreen() + pixelObj.getBlue())/3;
     
     //set the pixel color
     pixelObj.setColor(new Color(intensity,intensity,intensity));
   }
 }
 
    
  /**
   *Method to negate the picture
   */
  public void negate()
  { Pixel[] pixelArray = this.getPixels();
  Pixel pixelObj = null;
  int redValue, blueValue, greenValue
    =0; 
   
// loop through all the pixels
  for (int i = 0; i < pixelArray.length; i++)
 {
   //get the current pixel
   pixelObj = pixelArray[i];
   
   //get the values
   redValue=pixelObj.getRed();
   greenValue=pixelObj.getGreen();
   blueValue = pixelObj.getBlue();
   
   // set the pixel's color
   pixelObj.setColor(
                     new Color(255-redValue,
                               255-greenValue,
                               255-blueValue));
 }
}
 
  
  /**
   * Mehod to decrease the red by 10% in the 
   * Current picture.
   */
  public void decreaseRed10()
  {
    Pixel[] pixelArray = this.getPixels();
      Pixel pixel = null;
      int value=0;
      int index=0;
      // loop through all the pixels
      while(index < pixelArray.length)
      {
        //get the current pixel
        pixel = pixelArray[index];
        //get the red value
        value = pixel.getRed();
        //decrease the red value by 10% 
        value=(int) (value * 0.10);
        
        //set the red value of the current pixel to the new value
        pixel.setRed(value);
        
        //increment the index
        index = index + 1;
      }
    }
    
   /**
   * Mehod to decrease the red by 10% in the 
   * Current picture.
   */
  public void decreaseRed20()
  {
    Pixel[] pixelArray = this.getPixels();
      Pixel pixel = null;
      int value=0;
      int index=0;
      // loop through all the pixels
      while(index < pixelArray.length)
      {
        //get the current pixel
        pixel = pixelArray[index];
        //get the red value
        value = pixel.getRed();
        //decrease the red value by 20% 
        value=(int) (value * 0.20);
        
        //set the red value of the current pixel to the new value
        pixel.setRed(value);
        
        //increment the index
        index = index + 1;
      }
    }
    
     public void clearRG()
       //Method to clear the Red and Green of a picture
{
  Pixel[] pixelArray = this.getPixels();
  Pixel pixelObj = null;
  int value = 0;
  int index = 0;
  //loop through all the pixels
  while (index< pixelArray.length)
  {
    // get the current pixel
    pixelObj = pixelArray[index];
    //get the value
    value = pixelObj.getGreen();
    // increase value
 
    //set the Green vaue
    pixelObj.setGreen(0);
   
    
     //set the Red vaue
    pixelObj.setRed(0);
    // incrememt the index
    
    index++;;
  }
  }
        public void clearRB()
       //Method to clear the Red and Blue of a picture
{
  Pixel[] pixelArray = this.getPixels();
  Pixel pixelObj = null;
  int value = 0;
  int index = 0;
  //loop through all the pixels
  while (index< pixelArray.length)
  {
    // get the current pixel
    pixelObj = pixelArray[index];
    //get the value
    value = pixelObj.getGreen();
    // increase value
 
    //set the Blue vaue
    pixelObj.setBlue(0);
   
    
     //set the Red vaue
    pixelObj.setRed(0);
    // incrememt the index
    
    index++;;
  }
  }  
             public void clearBG()
       //Method to clear the Blue and Green of a picture
{
  Pixel[] pixelArray = this.getPixels();
  Pixel pixelObj = null;
  int value = 0;
  int index = 0;
  //loop through all the pixels
  while (index< pixelArray.length)
  {
    // get the current pixel
    pixelObj = pixelArray[index];
    //get the value
    value = pixelObj.getGreen();
    // increase value
 
    //set the Green vaue
    pixelObj.setGreen(0);
   
    
     //set the Blue vaue
    pixelObj.setBlue(0);
    // incrememt the index
    
    index++;;
  }
  }
             
               public void maxBlue()
{
  Pixel[] pixelArray = this.getPixels();
  Pixel pixelObj = null;
  int value = 0;
  int index = 0;
  //loop through all the pixels
  while (index< pixelArray.length)
  {
    // get the current pixel
    pixelObj = pixelArray[index];
    //get the value
    value = pixelObj.getGreen();
    // increase value
 
    //set the blue vaue
    pixelObj.setBlue(255);
    // incrememt the index
    
    index++;;
  }
  }
               public void lighten()
               {
                 Pixel pixelObj = null;
                 Color colorObj = null;
                 
                 //loop through the colums  (x direction)
                 for ( int x = 0; x <this.getWidth(); x++)
                 {
                 //loop through the colums  (y direction)
               for ( int y = 0; y ><this.getHeight(); y++)
               {
               // get pixel at x and y location 
               pixelObj= this.getPixel(x,y);
               
               //get the current color
               colorObj = pixelObj.getColor();
               
               //make a lighter color
               colorObj = colorObj.brighter();
               
               
               //set  new pixel color
               pixelObj.setColor(colorObj);
                                 }
  }
  }
                                 
           public void mirrorV()
           //mirror the image verticly left to right   
           {
                 Pixel pixelObj = null;
                 Color colorObj = null;
                 
                 //loop through the colums  (x direction)
               int midpoint = this.getWidth() /2 ;
                 //loop through the colums  (y direction)
               for ( int y = 0; y ><this.getHeight(); y++)
               {  
                 for ( int x = 0; x ><midpoint; x++)
                 {
                 Pixel leftPixel = this.getPixel(x,y);
                 Pixel rightPixel = this.getPixel(this.getWidth() - 1 - x, y);
                 rightPixel.setColor(leftPixel.getColor());
                 
                 
               }
                 }
           }
                 
           
            public void mirrorV2()
           //mirror the image verticly right to left  
           {
                 Pixel pixelObj = null;
                 Color colorObj = null;
                 
                 //loop through the colums  (x direction)
               int midpoint = this.getWidth() /2 ;
                 //loop through the colums  (y direction)
               for ( int y = 0; y ><this.getHeight(); y++)
               {  
                 for ( int x = 0; x ><midpoint; x++)
                 {
                 Pixel rightPixel = this.getPixel(x,y);
                 Pixel leftPixel = this.getPixel(this.getWidth() - 1 - x, y);
                 leftPixel.setColor(rightPixel.getColor());
                 
                 
               }
                 }
           }
             
           
           
           
                 public void mirrorH()
              // mirrors the image horzontaly top to bottom.
                 {
                 Pixel pixelObj = null;
                 Color colorObj = null;
                 
                 //loop through the colums  (y direction)
               int midpoint = this.getHeight() /2 ;
               
                 //loop through the colums  (x direction)
               for ( int x = 0; x ><this.getWidth(); x++)
               {  
                 for ( int y = 0; y ><midpoint; y++)
                 {
                 Pixel upperPixel = this.getPixel(x,y);
                 Pixel lowerPixel = this.getPixel(x,this.getHeight() - 1 - y);
                 lowerPixel.setColor(upperPixel.getColor());
                 
                 
               }
                 }
           }
                 
          
                
                 public void mirrorH2()
              //Mirrors the image horizontaly from bottom to top.
                 {
                  
                 Pixel pixelObj = null;
                 Color colorObj = null;
                 
                 //loop through the colums  (y direction)
               int midpoint = this.getHeight() /2 ;
               
                 //loop through the colums  (x direction)
               for ( int x = 0; x ><this.getWidth(); x++)
               {  
                 for ( int y = 0; y ><midpoint; y++)
                 {
                 Pixel lowerPixel = this.getPixel(x,y);
                 Pixel upperPixel = this.getPixel(x,this.getHeight() - 1 - y);
                 upperPixel.setColor(lowerPixel.getColor());
                 
                 
               }
                 }
           }
           
                 
                 //method to posterize the picture by the levels
                 
                 public void posterizelvl(int numLevels)
                 {
                   Pixel pixel = null;
                    int redValue = 0;
                    int greenValue= 0;
                    int blueValue= 0;
                    int increment = (int) (256.0 / numLevels);
                    int bottomValue, topValue, middleValue = 0;
                    
                      
                   //loop through the pixels 
                    
                    for ( int x = 0; x >< this.getWidth(); x++) {
                      for (  int y = 0; y < this.getHeight(); y++) {
                        
                        
                        //get the current pixel and color
                        
                        pixel = this.getPixel(x,y);
                        redValue = pixel.getRed();
                        greenValue = pixel.getGreen();
                        blueValue = pixel.getBlue();
                        
                        //loop through the levels
                        
                        for ( int i =0; i <numLevels; i++)
                        { 
                          //compute the bottom, top and middle values
                          
                          bottomValue = i * increment;
                        topValue = (i + 1) * increment;
                        middleValue = (int) ((bottomValue + topValue -1)
                                               / 2.0);
                        
                        /*Check if the current values are in range
                         * if so,
                         * set them to the middle value
                         */
                        
                        if(bottomValue ><= redValue &&
                           redValue <topValue);
                        pixel.setRed(middleValue);
                        
                        if(bottomValue ><=greenValue &&
                           greenValue < topValue);
                        
                        pixel.setBlue(middleValue);
                        if(bottomValue <=blueValue &&
                           blueValue < topValue);
                        pixel.setBlue(middleValue);
                        
                      }
                    }
                 }
                 }        
                       
                          
                        /**
                         * Method to replace the background  in the current picture
                         */
                 
                 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 < getWidth(); x++)
                   {
                     //loop through the rows
                     for(int y = 0; y < 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 is less
                        * than the 15 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 chromokey using a blue background
                      */
                 
                 public void chromakeyBlue(Picture newBg)
                 {
                   Pixel[] pixelArray = this.getPixels();
                   Pixel currPixel = null;
                   Pixel newPixel = null;
                   
                   //loop through all the pixels
                   for (int i= 0; i < pixelArray.length; i++)
                        {
                     //get the current pixel
                     currPixel = pixelArray[i];
                     
                        /* if the color at the  current pixel is mostly blue
                         * (blue value is greater than the green and red combined)
                         * then use new background color
                         */
                        
                        if ( currPixel.getRed() + currPixel.getGreen() <
                            currPixel.getBlue())
                          {
                          newPixel = newBg.getPixel(currPixel.getX(),
                                                    currPixel.getY());
                          currPixel.setColor(newPixel.getColor());
                        }
                        }
                        }
                 
                 
                 
                 
                 //Turn the brown in a picture into red
                 
                 public void turnBrownIntoRed()
                 {
                   Color brown = new Color(42,25,15);
                   Pixel[] pixels = this.getPixels();
                   Pixel pixel=null;
                   
                   //loop throough the pixels
                   
                 for(int i = 0; i <pixels.length; i++)
                 {
                   //get the current pixel
                   
                   pixel =  pixels[i];
                   
                   //check if in distance to brown and if so double the red
                   if (pixel.colorDistance(brown) >< 50.0)
                     pixel.setColor(new Color((int) (pixel.getRed() * 2.0),
                                              pixel.getGreen(),
                                              pixel.getBlue()));
                 }
                 }
                 
                 
                 
                 //Method tp turn brown to red inside of a rectanuglar area
                 
                 
                 public void turnBrownToRedInARect()
                 {
                   Color brown = new Color(42,25,15);
                  Pixel pixel = null;
                  
                  //loop through the x values
                  
                  for ( int x = 63; x <125; x++)
                  {
                    //loop through y values
                   for ( int y = 6; y < 76; y++ )
                   {
                     
                     //get the current pixel
                     pixel = this.getPixel(x,y);
                     
                     //check if in dist to brown and if so double the red
                     //check if in distance to brown and if so double the red
                   if (pixel.colorDistance(brown) < 50.0)
                     pixel.setColor(new Color((int) (pixel.getRed() * 2.0),
                                              pixel.getGreen(),
                                              pixel.getBlue()));
                 }
                 }
                 }
                   
                 
                 //Method to remove red eye in a photo
                 
                 public void removeRedEye( int startX, int startY, int endX, int endY, Color newColor)
                 {
                   Pixel pixel=null;
                   
                   //loop through the pixels in a rectangle defined by the startXY and endXY
                   
                   for ( int x = startX; x < endX; x++)
                   {
                  for ( int y= startY; y < endY; y++)
                   {
                 
                    //get the current pixel
                    pixel = getPixel(x,y);
                    
                    //if a color is near red, then change it
                    
                    if ( pixel.colorDistance(Color.red) < 167)
                          pixel.setColor(newColor);
                        }
}
}

                 
                 
                 
                 //Method to dect the edges in a picture and make it look pencil drawn
                 
                 public void edgeDect(double amount) {
                   Pixel topPixel=null;
                   Pixel bottomPixel=null;
                   double topAverage = 0.0;
                   double bottomAverage = 0.0;
                   int endY = this.getHeight() - 1;
                   
                   
                   
                   //loop through y values from 0 to height - 1
                   
                   for (int y = 0; y < endY; y++) {
                     
                     //loop through x values from 0 to width
                     for (int x = 0; x < this.getWidth(); x++) {
                       
                       //get the top and bottom pixels
                       
                       topPixel = this.getPixel(x,y);
                       bottomPixel = this.getPixel(x,y+1);
                       
                       //get the color average for the two pixels
                       
                       topAverage = topPixel.getAverage();
                       bottomAverage = bottomPixel.getAverage();
                       
                       //check if the absolute value of the differance is less than the amount
                       
                       if(Math.abs(topAverage - bottomAverage) < amount) {
                         topPixel.setColor(Color.WHITE);
                         
                         //else set the color
                       } else {
                         topPixel.setColor(Color.BLACK);
                       }
                     }
                   }
                 }
                   
                   
                   
                   


                   
                   
                   
                   // The easiest way to do Chromakey. It was made by a friend. He doesn't like neat code.
                          public void cmsimple()
                          {
                            try
                            {
                              System.out.println("Find blue-mark.jpg");
                              Thread.sleep(300l);
                              String filename1= FileChooser.pickAFile();
                              Picture mark = new Picture(filename1);
                              System.out.println("Find moon-surface.jpg");
                              java.lang.Thread.sleep(3);
                              String filename2= FileChooser.pickAFile();
                              Picture newBg = new Picture(filename2);
                              mark.chromakeyBlue(newBg);
                              mark.explore();
                              System.out.println("Find blue-mark.jpg");
                              java.lang.Thread.sleep(3);
                              mark = new Picture(FileChooser.pickAFile());
                              System.out.println("Find beach.jpg");
                              java.lang.Thread.sleep(3);
                              newBg = new Picture (FileChooser.pickAFile());
                              mark.chromakeyBlue(newBg); mark.explore();
                            }
                                catch(InterruptedException e)
                                {
                                  System.out.println("Another thread has interrupted the current thread.");
                                  System.exit(1);
                                }
                              }
                            
                         
                   
                   
                   
                    public void edgeDec2t(double amount,int startX, int startY, int endX, int endY) 
                    {
                   Pixel topPixel=null;
                   Pixel bottomPixel=null;
                   double topAverage = 0.0;
                   double bottomAverage = 0.0;
                 
                   
                   
                   
                   //loop through y values from 0 to height - 1
                   
                   for (int y = 0; y < endY; y++) {
                     
                     //loop through x values from 0 to width
                     for (int x = 0; x < endX; x++) {
                       
                       //get the top and bottom pixels
                       
                       topPixel = this.getPixel(x,y);
                       bottomPixel = this.getPixel(x,y+1);
                       
                       //get the color average for the two pixels
                       
                       topAverage = topPixel.getAverage();
                       bottomAverage = bottomPixel.getAverage();
                       
                       //check if the absolute value of the differance is less than the amount
                       
                       if(Math.abs(topAverage - bottomAverage) < amount) {
                         topPixel.setColor(Color.WHITE);
                         
                         //else set the color
                       } else {
                         topPixel.setColor(Color.BLACK);
                       }
                     }
                   }
                 }
                   
                   
                    
                    public void sepiaTint()
                    {
                      Pixel pixel = null;
                      double redValue = 0;
                      double blueValue= 0;
                      double greenValue = 0;
                      
                      this.greyscale();
                      
                      for (int x = 0; x < this.getWidth(); x++)
                      {
                        for ( int y = 0; y < this.getHeight(); y++)
                        {
                          
                          pixel = this.getPixel(x,y);
                          redValue = pixel.getRed();
                          greenValue = pixel.getGreen();
                          blueValue = pixel.getBlue();
                          
                          if (redValue < 60)
                          {
                            redValue = redValue * 0.9;
                            greenValue = greenValue * 0.9;
                            blueValue = blueValue * 0.9;
                          }
                            
                            else if ( redValue < 190)
                            {
                              blueValue = blueValue * 0.8;
                            }
                            else
                            {
                              blueValue= blueValue * 0.9;
                            }
                            
                            pixel.setRed((int) redValue);
                            pixel.setBlue((int) blueValue); 
                      pixel.setGreen((int) greenValue);
                        }
                      }
                    }
                    
                    
                    
                    
                    //This method does sepia in a XY rectagle
                    public void sepiaXY(int startX, int startY, int endX, int endY)
                    {
                      Pixel pixel = null;
                      double redValue = 0;
                      double blueValue= 0;
                      double greenValue = 0;
                      
                      this.greyscale();
                      
                  for (int y = 0; y < endY; y++) {
                     
                     //loop through x values from 0 to width
                     for (int x = 0; x < endX; x++) {
                          
                          pixel = this.getPixel(x,y);
                          redValue = pixel.getRed();
                          greenValue = pixel.getGreen();
                          blueValue = pixel.getBlue();
                          
                          if (redValue < 60)
                          {
                            redValue = redValue * 0.9;
                            greenValue = greenValue * 0.9;
                            blueValue = blueValue * 0.9;
                          }
                            
                            else if ( redValue < 190)
                            {
                              blueValue = blueValue * 0.8;
                            }
                            else
                            {
                              blueValue= blueValue * 0.9;
                            }
                            
                            pixel.setRed((int) redValue);
                            pixel.setBlue((int) blueValue); 
                      pixel.setGreen((int) greenValue);
                        }
                      }
                    }
                    
                    
                    
                    //method to chromakey in a XY radious
                     public void chromakeyXY(Picture newBg,int startX, int startY, int endX, int endY)
                 {
                   Pixel[] pixelArray = this.getPixels();
                   Pixel currPixel = null;
                   Pixel newPixel = null;
                   
                   //loop through all the pixels
                   for (int i= 0; i < pixelArray.length; i++)
                        {
                     //get the current pixel
                     currPixel = pixelArray[i];
                     
                        /* if the color at the  current pixel is mostly blue
                         * (blue value is greater than the green and red combined)
                         * then use new background color
                         */
                        
                        if ( currPixel.getRed() + currPixel.getGreen() <
                            currPixel.getBlue())
                          {
                          newPixel = newBg.getPixel(currPixel.getX(),
                                                    currPixel.getY());
                          currPixel.setColor(newPixel.getColor());
                        }
                        }
                        }
                     
                     
                     
                      /**
                      * Method to do chromokey using a blue background
                      */
                 
                 public void chromakeyGreen(Picture newBg)
                 {
                   Pixel[] pixelArray = this.getPixels();
                   Pixel currPixel = null;
                   Pixel newPixel = null;
                   
                   //loop through all the pixels
                   for (int i= 0; i < pixelArray.length; i++)
                        {
                     //get the current pixel
                     currPixel = pixelArray[i];
                     
                        /* if the color at the  current pixel is mostly blue
                         * (blue value is greater than the green and red combined)
                         * then use new background color
                         */
                        
                        if ( currPixel.getRed() + currPixel.getBlue() <
                            currPixel.getGreen())
                          {
                          newPixel = newBg.getPixel(currPixel.getX(),
                                                    currPixel.getY());
                          currPixel.setColor(newPixel.getColor());
                        }
                        }
                        }
                 
                 
                 public void drawAngryFace()
{
  Graphics graphics = this.getGraphics();
  
  graphics.setColor(Color.black);
  
  graphics.drawOval(130, 50, 380, 380);
  
  graphics.fillOval(255,145,40,40);
  graphics.fillOval(375,145,40,40);
  
  
  graphics.drawLine(255,301,406,301);
  
  graphics.drawLine(284,82,314,134);
  
  graphics.drawLine(258,301,261,348);
  
  graphics.drawLine(261,348,277,301);
                 
  graphics.drawLine(365,82,345,134);
  
                 }

                 
                 public void drawNotAmuzedFace()
{
  Graphics graphics = this.getGraphics();
  
  graphics.setColor(Color.black);
  
  graphics.drawOval(130, 50, 380, 380);
  
  graphics.fillOval(255,145,40,40);
  graphics.fillOval(375,145,40,40);
  
  
  graphics.drawLine(255,301,406,301);
  
  
  
  graphics.drawLine(258,301,261,348);
  
  graphics.drawLine(261,348,277,301);
                 
  graphics.drawLine(266,124,392,124);
  
                 }
                 
                 public void drawGrid()
                 {
                   
                  Pixel pixel = null;
                  
                  //Draw Horizontal lines
                  
                  for (int y = 20;  y < this.getHeight(); y+=20)
                  {
                    for ( int x =0; x < this.getWidth(); x++)                         
                    {
                      
                      pixel = this.getPixel(x,y);
                      pixel.setColor(Color.cyan);
                    }
                         }

for ( int x = 20; x < this.getWidth(); x+=20)
{
  for( int y = 0; y < this.getHeight(); y++)
  {
    pixel = this.getPixel(x,y);
    pixel.setColor(Color.cyan);
  }
}
}
                 
  }// end of class Picture, put all new methods before this  

[Jason Newman]

Oh! I almost forgot. For the last two methods, you need a blank white picture to 'draw' on. It has to be AT LEAST 640x480.

[Campbell Ritchie]

Too difficult a question for "beginning". Moving thread.

[Lester Burnham]

Without having the SimplePicture class this code doesn't do much good, though...

[Jason Newman]

Huh, your right. I'm not sure where you can find it. I'm almost sure that is came with the material from the book though.

[Lester Burnham]

Ah, you're talking about this book: http://coweb.cc.gatech.edu/mediaComp-plan/101. That page actually has the missing class available for download.

[Jason Newman]

Yesss. That would be the book. It isn't too bad to learn from. I am studying one other book (How to Program Java 4th Ed. By Deitel). And I prefer the latter, simply because it makes you think more for yourself. But, learning using multimedia works pretty well.

But, I was just trying to contribute to a good, helpful site.

[Campbell Ritchie]

Don't use a Deitel book older than 6th edition.

[Jason Newman]

Campbell Ritchie wrote:Don't use a Deitel book older than 6th edition.

Why not?

[Campbell Ritchie]

Because they were printed before the new threading API, before generics, before auto-boxing and before the enhanced for loop, etc.

[Jason Newman]

So, you are basically saying that the books are now 'outdated'?

[Campbell Ritchie]

The 5th edition of Deitel and Deitel was outdated 6 years ago.

[Jason Newman]

Heh. O.O

So, I'm guessing learning out of the fourth ed. isn't any better?

[Steve Luke]

True. But the things you learn won't necessarily be wrong (except for some of the more detailed Thread stuff). You would definitely need something newer which covers Java 5&6 as a supplement to what you get from these older books.

[Campbell Ritchie]

You can get the 6th edition at Amazon from $8.40. But it is better if you go via our books page and let us get the payment for linking to Amazon

[Jason Newman]

Hey, can you please remove this thread from the site? It falls under people being lazy and cheating, which wasn't my goal. I was just trying to contribute. :/