import java.awt.*;
import java.awt.font.*;
import java.awt.geom.*;
import java.awt.image.BufferedImage;
import java.text.*;
import java.util.*;
import java.util.List; // resolves problem with java.awt.List and java.util.List
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.
 *
 * @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 height the height of the desired picture
   * @param width the width of the desired picture
   */
  public Picture(int height, int width)
  {
    // let the parent class handle this width and height
    super(width,height);
  }

  /**
   * Constructor that takes a picture and creates a
   * copy of that picture
   * @param copyPicture the picture to copy
   */
  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;

  }

  /** Method to set the blue to 0 */
  public void zeroBlue()
  {
    Pixel[][] pixels = this.getPixels2D();
    for (Pixel[] rowArray : pixels)
    {
      for (Pixel pixelObj : rowArray)
      {
        pixelObj.setBlue(0);
      }
    }
  }

  public void keepOnlyBlue()
  {
    Pixel[][] pixels = this.getPixels2D();
    for (Pixel[] rowArray : pixels)
    {
      for (Pixel pixelObj : rowArray)
      {
         pixelObj.setRed(0);
         pixelObj.setGreen(0);
      }
    }
  }

  public void keepOnlyGreen()
  {
    Pixel[][] pixels = this.getPixels2D();
    for (Pixel[] rowArray : pixels)
    {
      for (Pixel pixelObj : rowArray)
      {
         pixelObj.setBlue(0);
         pixelObj.setRed(0);
      }
    }
  }

  public void keepOnlyRed()
  {
    Pixel[][] pixels = this.getPixels2D();
    for (Pixel[] rowArray : pixels)
    {
      for (Pixel pixelObj : rowArray)
      {
         pixelObj.setBlue(0);
         pixelObj.setGreen(0);
      }
    }
  }

  public void negate()
  {
    Pixel[][] pixels = this.getPixels2D();
    for (Pixel[] rowArray : pixels)
    {
      for (Pixel pixelObj : rowArray)
      {
        pixelObj.setRed(pixelObj.getRed() - 255);
        pixelObj.setGreen(pixelObj.getGreen() - 255);
        pixelObj.setBlue(pixelObj.getBlue() - 255);
      }
    }
  }

  public void grayscale()
  {
    Pixel[][] pixels = this.getPixels2D();
    for (Pixel[] rowArray : pixels)
    {
      for (Pixel pixelObj : rowArray)
      {
        int avg = (int)((pixelObj.getRed() + pixelObj.getGreen() + pixelObj.getBlue()) / 3);
        pixelObj.setRed(avg);
        pixelObj.setBlue(avg);
        pixelObj.setGreen(avg);
      }
    }
  }

  public void invert()
  {
      Pixel[][] pixels = this.getPixels2D();
      for (int row = 0; row < pixels.length; row++)
      {
          for (int col = 0; col < pixels[0].length; col++)
          {
              int red = 255 - pixels[row][col].getRed();
              int green = 255 - pixels[row][col].getGreen();
              int blue = 255 - pixels[row][col].getBlue();

              Color newColor = new Color(red, green, blue);

              pixels[row][col].setColor(newColor);
          }
      }
  }

  public void darken(int amount)
  {
      Pixel[][] pixels = this.getPixels2D();
      for (int row = 0; row < pixels.length; row++)
      {
          for (int col = 0; col < pixels[0].length; col++)
          {
              int red = pixels[row][col].getRed() - amount;
              int green = pixels[row][col].getGreen() - amount;
              int blue = pixels[row][col].getBlue() - amount;

              Color newColor = new Color(red, green, blue);

              pixels[row][col].setColor(newColor);
          }
      }
  }

  /**
   * Method to fix the fish
   * Takes a sample and adjust the image
   * to better see the fish
   */

  public void fixUnderwater()
  {
    Pixel[][] pixels = this.getPixels2D();

    int redAverage = 0;
    int greenAverage = 0;
    int blueAverage = 0;
    int totalPixels = 0;

    int maxRed = 0;
    int minRed = 255;
    int maxGreen = 0;
    int minGreen = 255;
    int maxBlue = 0;
    int minBlue = 255;

    // takes a sample from a fish and finds the average color value and range of colors
    for (int row = 26; row < 36; row++)
    {
        for (int col = 178; col < 198; col++)
        {
            totalPixels++;

            Pixel myPixel = pixels[row][col];

            redAverage += myPixel.getRed();
            greenAverage += myPixel.getGreen();
            blueAverage += myPixel.getBlue();

            if (myPixel.getRed() > maxRed) { maxRed = myPixel.getRed(); }
            if (myPixel.getRed() < minRed) { minRed = myPixel.getRed(); }
            if (myPixel.getGreen() > maxGreen) { maxGreen = myPixel.getGreen(); }
            if (myPixel.getGreen() < minGreen) { minGreen = myPixel.getGreen(); }
            if (myPixel.getBlue() > maxBlue) { maxBlue = myPixel.getBlue(); }
            if (myPixel.getGreen() < minBlue) { minBlue = myPixel.getBlue(); }

        }
    }

    redAverage = redAverage / totalPixels;
    greenAverage = greenAverage / totalPixels;
    blueAverage = blueAverage / totalPixels;

    Color averageColor = new Color(redAverage, greenAverage, blueAverage);

    // calculates the range
    int redRange = (maxRed - minRed);
    int greenRange = (maxGreen - minGreen);
    int blueRange = (maxBlue - minBlue);

    int redDistance = redRange;
    int greenDistance = greenRange;
    int blueDistance = blueRange;

    double maxDistance = Math.sqrt(redDistance * redDistance +
                                   greenDistance * greenDistance +
                                   blueDistance * blueDistance);

    double tolerance = 1.7; // higher tolerance means more pixels will be identified as "fish"

    // changes the image based on calculated distance from sample value
    for (int row = 0; row < pixels.length; row++) // Pixel[] rowArray : pixels)
    {
      for (int col = 0; col < pixels[0].length; col++) // Pixel pixelObj : rowArray)
      {
          Pixel myPixel = pixels[row][col]; //

          boolean closeEnough = myPixel.colorDistance(averageColor) < maxDistance * tolerance; // stopped here, define this***
          // System.out.println(myPixel.colorDistance(averageColor));
          if (closeEnough)
          {
              myPixel.setBlue(myPixel.getBlue() + 50);
          }
          else
          {
              myPixel.setBlue(myPixel.getBlue() - 50);
          }
      }
    }
  }

  /** Method that mirrors the picture around a
    * vertical mirror in the center of the picture
    * from left to right */
  public void mirrorVertical()
  {
    Pixel[][] pixels = this.getPixels2D();
    Pixel leftPixel = null;
    Pixel rightPixel = null;
    int width = pixels[0].length;
    for (int row = 0; row < pixels.length; row++)
    {
      for (int col = 0; col < width / 2; col++)
      {
        leftPixel = pixels[row][col];
        rightPixel = pixels[row][width - 1 - col];
        rightPixel.setColor(leftPixel.getColor());
      }
    }
  }

  public void mirrorVerticalRightToLeft()
  {
    Pixel[][] pixels = this.getPixels2D();
    Pixel leftPixel = null;
    Pixel rightPixel = null;
    int width = pixels[0].length;
    for (int row = 0; row < pixels.length; row++)
    {
      for (int col = 0; col < width / 2; col++)
      {
        leftPixel = pixels[row][col];
        rightPixel = pixels[row][width - 1 - col];
        leftPixel.setColor(rightPixel.getColor());
      }
    }
  }

  public void mirrorHorizontal()
  {
      Pixel[][] pixels = this.getPixels2D();
      Pixel topPixel = null;
      Pixel bottomPixel = null;
      int height = pixels.length;
      for (int row = 0; row < height; row++)
      {
          for (int col = 0; col < pixels[0].length; col++)
          {
              topPixel = pixels[row][col];
              bottomPixel = pixels[height - 1 - row][col];
              bottomPixel.setColor(topPixel.getColor());
          }
      }
  }

  public void mirrorHorizontalBottomToTop()
  {
      Pixel[][] pixels = this.getPixels2D();
      Pixel topPixel = null;
      Pixel bottomPixel = null;
      int height = pixels.length;
      for (int row = 0; row < height; row++)
      {
          for (int col = 0; col < pixels[0].length; col++)
          {
              topPixel = pixels[row][col];
              bottomPixel = pixels[height - 1 - row][col];
              topPixel.setColor(bottomPixel.getColor());
          }
      }
  }

  public void mirrorDiagonal() // mirrors from top right to bottom left
  {
      Pixel[][] pixels = this.getPixels2D();
      Pixel topRightPixel = null;
      Pixel bottomLeftPixel = null;
      int maxLength;
      if (pixels.length < pixels[0].length) { maxLength = pixels.length; }
      else {maxLength = pixels[0].length; }

      for (int row = 0; row < maxLength; row++)
      {
          for (int col = row; col < maxLength; col++)
          {
              topRightPixel = pixels[row][col];
              bottomLeftPixel = pixels[col][row];
              bottomLeftPixel.setColor(topRightPixel.getColor());
          }
      }
  }

  /** Mirror just part of a picture of a temple */
  public void mirrorTemple()
  {
    int mirrorPoint = 276;
    Pixel leftPixel = null;
    Pixel rightPixel = null;
    int count = 0;
    Pixel[][] pixels = this.getPixels2D();

    // loop through the rows
    for (int row = 27; row < 97; row++)
    {
      // loop from 13 to just before the mirror point
      for (int col = 13; col < mirrorPoint; col++)
      {
        count++;
        leftPixel = pixels[row][col];
        rightPixel = pixels[row]
                         [mirrorPoint - col + mirrorPoint];
        rightPixel.setColor(leftPixel.getColor());
      }
    }
    System.out.println(count);
  }

  /** Mirrors the arms of the snowman */
  public void mirrorArms()
  {
    int mirrorPoint = 193;
    Pixel topPixel = null;
    Pixel bottomPixel = null;
    Pixel[][] pixels = this.getPixels2D();

    // Left arm
    for (int row = 158; row < mirrorPoint; row++)
    {
      // loop from 13 to just before the mirror point
      for (int col = 103; col < 170; col++)
      {
        topPixel = pixels[row][col];
        bottomPixel = pixels[mirrorPoint - row + mirrorPoint][col];
        bottomPixel.setColor(topPixel.getColor());
      }
    }

    int mirrorPoint2 = 198;
    Pixel topPixel2 = null;
    Pixel bottomPixel2 = null;

    // Right arm
    for (int row = 171; row < mirrorPoint2; row++)
    {
      // loop from 13 to just before the mirror point
      for (int col = 239; col < 294; col++)
      {
        topPixel2 = pixels[row][col];
        bottomPixel2 = pixels[mirrorPoint2 - row + mirrorPoint2][col];
        bottomPixel2.setColor(topPixel2.getColor());
      }
    }
  }

  public void mirrorGull()
  {
    int mirrorPoint = 345;
    Pixel rightPixel = null;
    Pixel leftPixel = null;
    Pixel[][] pixels = this.getPixels2D();

    // Seagull
    for (int row = 235; row < 323; row++)
    {
      for (int col = 238; col < mirrorPoint; col++)
      {
        rightPixel = pixels[row][col];
        leftPixel = pixels[row][mirrorPoint - col + mirrorPoint/3];
        leftPixel.setColor(rightPixel.getColor());
      }
    }
  }

  /** copy from the passed fromPic to the
    * specified startRow and startCol in the
    * current picture
    * @param fromPic the picture to copy from
    * @param startRow the start row to copy to
    * @param startCol the start col to copy to
    */
  public void copy(Picture fromPic,
                 int startRow, int startCol)
  {
    Pixel fromPixel = null;
    Pixel toPixel = null;
    Pixel[][] toPixels = this.getPixels2D();
    Pixel[][] fromPixels = fromPic.getPixels2D();
    for (int fromRow = 0, toRow = startRow;
         fromRow < fromPixels.length &&
         toRow < toPixels.length;
         fromRow++, toRow++)
    {
      for (int fromCol = 0, toCol = startCol;
           fromCol < fromPixels[0].length &&
           toCol < toPixels[0].length;
           fromCol++, toCol++)
      {
        fromPixel = fromPixels[fromRow][fromCol];
        toPixel = toPixels[toRow][toCol];
        toPixel.setColor(fromPixel.getColor());
        System.out.println("Fromrow " + fromRow + " toRow " + toRow + " fromCol" + fromCol + " toCol " + toCol);
      }
    }
  }

  public void copy2(Picture fromPic, int startRow, int endRow, int startCol, int endCol)
  {
    Pixel fromPixel = null;
    Pixel toPixel = null;
    Pixel[][] toPixels = this.getPixels2D();
    Pixel[][] fromPixels = fromPic.getPixels2D();
    for (int fromRow = 0, toRow = startRow;
         fromRow < fromPixels.length &&
         toRow < endRow;
         fromRow++, toRow++)
    {
      for (int fromCol = 0, toCol = startCol;
           fromCol < fromPixels[0].length &&
           toCol < endCol;
           fromCol++, toCol++)
      {
        fromPixel = fromPixels[fromRow][fromCol];
        toPixel = toPixels[toRow][toCol];
        toPixel.setColor(fromPixel.getColor());
        //System.out.println("Fromrow " + fromRow + " toRow " + toRow + " fromCol" + fromCol + " toCol " + toCol);
        //System.out.println(fromPixels[0].length);
      }
    }
  }

  /** Method to create a collage of several pictures */
  public void createCollage()
  {
    Picture flower1 = new Picture("flower1.jpg");
    Picture flower2 = new Picture("flower2.jpg");

    //this.copy(flower1,100,0);
    this.copy2(flower1,0,100, 0, 100);
    //flower1.explore();
    //this.copy(flower1,200,0);
    // Mirroring
    int mirrorPoint = 98;
    Pixel rightPixel = null;
    Pixel leftPixel = null;
    Pixel[][] pixels = this.getPixels2D();
    for (int row = 0; row < 98; row++)
    {
      for (int col = 0; col < 88; col++)
      {
        rightPixel = pixels[row][col];
        leftPixel = pixels[mirrorPoint - row + mirrorPoint][col];
        leftPixel.setColor(rightPixel.getColor());
      }
    }
    Picture flowerNoBlue = new Picture(flower2);
    flowerNoBlue.zeroBlue();
    this.copy2(flowerNoBlue,300,350,80,500);

    Picture flowerinverse = new Picture(flower2);
    flowerinverse.invert();
    this.copy2(flowerinverse, 100, 300, 80, 300);
    //this.copy(flowerNoBlue,300,0);
    //this.copy(flower1,400,0);
    //this.copy(flower2,500,0);
    //this.mirrorVertical();


    this.write("collage.jpg");
  }

  public void myCollage()
  {
      Picture flower1 = new Picture("flower1.jpg");
      this.copy2(flower1,10,20, 0, 100);
      this.write("mycollage.jpg");
  }

  /** Method to show large changes in color
    * @param edgeDist the distance for finding edges
    */
  public void edgeDetection(int edgeDist)
  {
    Pixel leftPixel = null;
    Pixel rightPixel = null;
    Pixel topPixel = null;
    Pixel bottomPixel = null;

    Pixel[][] pixels = this.getPixels2D();
    for (int row = 0; row < pixels.length - 1; row++)
    {
      for (int col = 0;
           col < pixels[0].length-1; col++)
      {
        leftPixel = pixels[row][col];
        rightPixel = pixels[row][col+1];
        topPixel = pixels[row][col];
        bottomPixel = pixels[row + 1][col];
        if (leftPixel.colorDistance(rightPixel.getColor()) > edgeDist ||
            topPixel.colorDistance(bottomPixel.getColor()) > edgeDist)
          leftPixel.setColor(Color.BLACK);
        else
          leftPixel.setColor(Color.WHITE);
      }
    }
  }

  /**
   * Method for edge detection, my way.
   * Handy methods used in this method are below.
   *
   *
   *
   */

  public void edgeDetection2(int edgeDist)
  {
      Pixel currentPixel = null, testPixel = null;

      // width and height of pixel cluster
      int testWidth = 3;
      int testHeight = 3;

      Pixel[][] pixels = this.getPixels2D();
      double[][] edgeAngle = new double[Math.round(pixels.length / testHeight)][Math.round(pixels[0].length / testWidth)];
          // the 2D array edgeAngle will store the perceived angle (in radians) of the edge

      for (int row = 0; row < pixels.length - testHeight; row += testHeight)
      {
          for (int col = 0; col < pixels[0].length - testWidth; col += testWidth)
          {
              Pixel[][] currentPixels = this.getPixelCluster(pixels, row, col, testWidth, testHeight);

              double greatestDistance = -10;
              double greatestAngle = -1; // not actually the greatest value, but corresponding to greatest distance
              // I may need to determin which of the two partial clusters is darker, for filling in purposes
              for (double angle = 0; angle < Math.PI + 0.1; angle += Math.PI / 8)
              {
                  ArrayList<Pixel> group1 = this.getPartialArray(currentPixels, angle, 0);
                  Color group1Color = this.getAverageColor(this.getPixelColors(group1));
                  ArrayList<Pixel> group2 = this.getPartialArray(currentPixels, angle, 1);
                  Color group2Color = this.getAverageColor(this.getPixelColors(group2));

                  double currentColorDistance = this.colorDistance(group1Color, group2Color);

                  if (currentColorDistance > greatestDistance)
                  {
                      greatestDistance = currentColorDistance;
                      greatestAngle = angle;
                  }

              }

              greatestAngle = Math.round(greatestAngle * 100.0) / 100.0;
              edgeAngle[row / testHeight][col / testWidth] = greatestAngle;


              if (greatestDistance > edgeDist)
              {
                  ArrayList<Pixel> group1 = this.getPartialArray(currentPixels, greatestAngle, 0);
                  ArrayList<Pixel> group2 = this.getPartialArray(currentPixels, greatestAngle, 1);

                  for (Pixel pixel : group1)
                  {
                      pixel.setColor(Color.BLACK);
                  }

                  for (Pixel pixel : group2)
                  {
                      pixel.setColor(Color.WHITE);
                  }
              }
              else
              {
                  for (Pixel[] pixelArray : currentPixels)
                  {
                      for (Pixel pixel : pixelArray)
                      {
                          pixel.setColor(Color.WHITE);
                      }
                  }
              }
          }
      }

      File file = new File("outputAngles.txt");
      try{
      PrintWriter writer = new PrintWriter(file, "UTF-8");


      for (int row = 0; row < edgeAngle.length; row++)
      {
          for (int col = 0; col < edgeAngle[0].length; col++)
          {
              writer.print(edgeAngle[row][col]);
              writer.print(" ");
          }
          writer.print("\n");
      }
      writer.close();
      }
      catch(Exception e){ e.printStackTrace(); }
  }

  public double colorDistance(Color testColor1, Color testColor2)
  {
      double redDistance = testColor2.getRed() - testColor1.getRed();
      double greenDistance = testColor2.getGreen() - testColor1.getGreen();
      double blueDistance = testColor2.getBlue() - testColor1.getBlue();
      double distance = Math.sqrt(redDistance * redDistance +
                                  greenDistance * greenDistance +
                                  blueDistance * blueDistance);
      return distance;
  }

  public Color getAverageColor(Color[] myColors)
  {
      int totalRed = 0;
      int totalGreen = 0;
      int totalBlue = 0;

      int total = 0;

      for (Color currentColor : myColors)
      {
          totalRed += currentColor.getRed();
          totalGreen += currentColor.getGreen();
          totalBlue += currentColor.getBlue();
          total++;
      }

      return new Color(totalRed / total, totalGreen / total, totalBlue / total);

  }

  public Color[] getPixelColors(ArrayList<Pixel> pixels)
  {
      Color[] myColors = new Color[pixels.size()];
      int count = 0;
      for (Pixel currentPixel : pixels)
      {
          myColors[count] = currentPixel.getColor();
          count++;
      }

      return myColors;
  }

  public Pixel[][] getPixelCluster(Pixel[][] pixels, int startRow, int startCol,
                                   int width, int height)
  {
      Pixel[][] pixelCluster = new Pixel[height][width];

      if (pixels.length < startRow + height || pixels[0].length < startCol + width)
      {
          return pixelCluster;
      }

      for (int row = startRow; row < startRow + height; row++)
      {
          for (int col = startCol; col < startCol + width; col++)
          {
              pixelCluster[row - startRow][col - startCol] = pixels[row][col];
          }
      }

      return pixelCluster;
  }

  /**
   * Method getPartialArray takes an array of pixels,
   * an angle to divide the array, and the "type of" that
   * determines whether it returns the top/right (0) or
   * the bottom/left (1)
   *
   * This one only takes the elements that lie on the line of division
   *
   * Need to update this method to match the one below ********
   *
   * @param pixels
   * @param angle the angle to divide, given in radians (0 to pi)
   */
  public ArrayList<Pixel> getPartialArrayLine(Pixel[][] fullArray, double angle, int typeOf)
  {
      int rows = fullArray.length, cols = fullArray[0].length;
          int centerRow = rows / 2, centerCol = cols / 2;
          int arrayLength = (rows * cols);
          ArrayList<Pixel> tempList = new ArrayList<Pixel>();

          double slope = Math.tan(angle);
          if (slope == 0) slope = 0.001;
          double newSlope = -1 / slope;

          for (int i = 0; i < arrayLength; i++)
          {
              int currentRow = i / cols, currentCol = i % cols;
              //System.out.println(i + "\t" + currentRow + " " + currentCol);
              if (currentCol == (newSlope * (currentRow - centerRow) + centerCol))
                      // this tests whether the current cell is above/below the "line"
              {
                  if (typeOf == 1)
                  {
                      tempList.add(fullArray[currentRow][currentCol]);
                      //System.out.println("added " + i);
                  }
              }
              else
              {
                  if (typeOf == 0)
                  {
                      tempList.add(fullArray[currentRow][currentCol]);
                      //System.out.println("added " + i);
                  }
              }
          }

          return tempList;
  }


  /**
   * Method getPartialArray takes an array of pixels,
   * an angle to divide the array, and the "type of" that
   * determines whether it returns the top/right (0) or
   * the bottom/left (1)
   *
   * Need to update this method to match the one below ********
   *
   * @param pixels
   * @param angle the angle to divide, given in radians (0 to pi)
   */
  public ArrayList<Pixel> getPartialArray(Pixel[][] fullArray, double angle, int typeOf)
  {
      int rows = fullArray.length, cols = fullArray[0].length;
          int centerRow = rows / 2, centerCol = cols / 2;
          int arrayLength = (rows * cols);
          ArrayList<Pixel> tempList = new ArrayList<Pixel>();

          double slope = Math.tan(angle);
          if (slope == 0) slope = 0.001;
          double newSlope = -1 / slope;

          for (int i = 0; i < arrayLength; i++)
          {
              int currentRow = i / cols, currentCol = i % cols;
              //System.out.println(i + "\t" + currentRow + " " + currentCol);
              if (currentCol < (newSlope * (currentRow - centerRow) + centerCol))
                      // this tests whether the current cell is above/below the "line"
              {
                  if (typeOf == 1)
                  {
                      tempList.add(fullArray[currentRow][currentCol]);
                      //System.out.println("added " + i);
                  }
              }
              else
              {
                  if (typeOf == 0)
                  {
                      tempList.add(fullArray[currentRow][currentCol]);
                      //System.out.println("added " + i);
                  }
              }
          }

          return tempList;
  }

  public static ArrayList<Integer> getPartialArray(int[][] fullArray, double angle, int typeOf)
      {
          int rows = fullArray.length, cols = fullArray[0].length;
          int centerRow = rows / 2, centerCol = cols / 2;
          int arrayLength = (rows * cols);
          ArrayList<Integer> tempList = new ArrayList<Integer>();

          double slope = Math.tan(angle);
          if (slope == 0) slope = 0.001;
          double newSlope = -1 / slope;

          for (int i = 0; i < arrayLength; i++)
          {
              int currentRow = i / cols, currentCol = i % cols;
              System.out.println(i + "\t" + currentRow + " " + currentCol);
              if (currentCol < (newSlope * (currentRow - centerRow) + centerCol))
              {
                  if (typeOf == 1)
                  {
                      tempList.add(fullArray[currentRow][currentCol]);
                      System.out.println("added " + i);
                  }
              }
              else
              {
                  if (typeOf == 0)
                  {

                      tempList.add(fullArray[currentRow][currentCol]);
                      System.out.println("added " + i);
                  }
              }
          }

          return tempList;
      }


  /* Main method for testing - each class in Java can have a main
   * method
   */
  public static void main(String[] args)
  {
    Picture beach = new Picture("caterpillar.jpg");
    beach.explore();
    beach.zeroBlue();
    beach.explore();
  }

} // this } is the end of class Picture, put all new methods before this