public void cropAndCopy(
Picture sourcePicture,
int startSourceRow,
int endSourceRow,
int startSourceCol,
int endSourceCol,
int startDestRow,
int startDestCol) {
Pixel leftPixel = null;
Pixel rightPixel = null;
Pixel[][] pixels = this.getPixels2D();
Color rightColor = null;
Pixel[][] fromPixels = sourcePicture.getPixels2D();
Pixel[][] toPixels = this.getPixels2D();
Pixel fromPixel = null;
Pixel toPixel = null;
for (int fromRow = startSourceRow, toRow = endSourceRow;
fromRow < fromPixels.length && toRow < toPixels.length;
fromRow++, toRow++) {
for (int fromCol = startSourceCol, toCol = endSourceCol;
fromCol < fromPixels[0].length && toCol < toPixels[0].length;
fromCol++, toCol++) {
fromPixel = fromPixels[fromRow][fromCol];
toPixel = toPixels[toRow][toCol];
toPixel.setColor(fromPixel.getColor());
}
}
}
/** 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);
}
}
}
// set green 255
public void maxGreen() {
Pixel[][] pixels = this.getPixels2D();
for (Pixel[] rowArray : pixels) {
for (Pixel pixelObj : rowArray) {
pixelObj.setGreen(255);
}
}
}
public void fixUnderwater() {
Pixel[][] pixels = this.getPixels2D();
for (Pixel[] rowArray : pixels) {
for (Pixel pixelObj : rowArray) {
if (pixelObj.getBlue() > 160 && pixelObj.getRed() < 25) {
pixelObj.setBlue(pixelObj.getBlue() + 35);
}
}
}
}
// changes the image to a Grayscale
public void Grayscale() {
Pixel[][] pixels = this.getPixels2D();
for (Pixel[] rowArray : pixels) {
for (Pixel pixelObj : rowArray) {
int average = (int) pixelObj.getAverage();
pixelObj.setGreen(average);
pixelObj.setBlue(average);
pixelObj.setRed(average);
}
}
}
public void mirrorVerticalRightToLeft() {
Pixel[][] pixels = this.getPixels2D();
Pixel leftPixel = null;
Pixel rightPixel = null;
int pictureWidth = pixels[0].length;
for (int row = 0; row < pixels.length; row++) {
for (int col = pixels[0].length - 1; col > pictureWidth / 2; col--) {
rightPixel = pixels[row][col];
leftPixel = pixels[row][(pictureWidth / 2) - (col - pictureWidth / 2)];
leftPixel.setColor(rightPixel.getColor());
}
}
}
public void mirrorArms() {
int mirrorPoint = 205;
Pixel leftPixel = null;
Pixel rightPixel = null;
Pixel[][] pixels = this.getPixels2D();
for (int row = 152; row < 200; row++) {
for (int col = 92; col < mirrorPoint; col++) {
leftPixel = pixels[row][col];
rightPixel = pixels[row][mirrorPoint - col + mirrorPoint];
rightPixel.setColor(leftPixel.getColor());
}
}
}
public void mirrorGull() {
int mirrorPoint = 352;
Pixel leftPixel = null;
Pixel rightPixel = null;
Pixel[][] pixels = this.getPixels2D();
for (int row = 233; row < 323; row++) {
for (int col = 235; col < mirrorPoint; col++) {
leftPixel = pixels[row][col];
rightPixel = pixels[row][mirrorPoint - col + mirrorPoint];
rightPixel.setColor(leftPixel.getColor());
}
}
}
/*
****************** CHECKLIST ******************************
[x] change the colors within the box specified by the parameters
[x] the new Color in each Pixel MUST depend BOTH (a) on that particular Pixel's previous Color and (b) on the value of the amount parameter
*/
public boolean ManipBoxUniformly(int xMin, int yMin, int xMax, int yMax, double amount) {
for (int x = xMin; x < xMax - 1; x++) {
for (int y = yMin; y < yMax - 1; y++) {
amount -= 0.0000001;
if (amount < 0.1) amount = 0.2;
Pixel p = this.getPixel(x, y);
int B = (int) (p.getGreen() * (amount));
p.setGreen(B);
}
}
return true;
}
// implements max red to only the right side of the image
public void rightRed() {
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.setRed(255);
}
}
}
/**
* 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 mirrorHorizontalBotToTop() {
Pixel[][] pixels = this.getPixels2D();
Pixel topPixel = null;
Pixel bottomPixel = null;
int width = pixels[0].length;
for (int col = 0; col < width; col++) {
for (int row = 0; row < pixels.length / 2; row++) {
topPixel = pixels[row][col];
bottomPixel = pixels[(pixels.length) - 1 - row][col];
topPixel.setColor(bottomPixel.getColor());
}
}
}
public void mirrorVerticalBottomToTop() {
Pixel[][] pixels = this.getPixels2D();
Pixel topPixel = null;
Pixel bottomPixel = null;
int width = pixels[0].length;
int height = pixels.length;
for (int row = 0; row < pixels.length; row++) {
for (int col = 0; col < width; col++) {
topPixel = pixels[height - 1 - row][col];
bottomPixel = pixels[row][col];
bottomPixel.setColor(topPixel.getColor());
}
}
}
public void randomColor() {
Pixel[][] pixels = this.getPixels2D();
for (Pixel[] row : pixels) {
for (Pixel currentPixel : row) {
int randomRed, randomBlue, randomGreen;
randomRed = (int) (Math.random() * 256);
randomBlue = (int) (Math.random() * 256);
randomGreen = (int) (Math.random() * 256);
currentPixel.setBlue(randomBlue);
currentPixel.setRed(randomRed);
currentPixel.setGreen(randomGreen);
}
}
}
/**
* 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());
}
}
}
/**
* Method to display pixel information for the passed x and y
*
* @param pictureX the x value in the picture
* @param pictureY the y value in the picture
*/
private void displayPixelInformation(int pictureX, int pictureY) {
// check that this x and y are in range
if (isLocationInPicture(pictureX, pictureY)) {
// save the current x and y index
colIndex = pictureX;
rowIndex = pictureY;
// get the pixel at the x and y
Pixel pixel = new Pixel(picture, colIndex, rowIndex);
// set the values based on the pixel
colValue.setText(Integer.toString(colIndex + numberBase));
rowValue.setText(Integer.toString(rowIndex + numberBase));
rValue.setText("R: " + pixel.getRed());
gValue.setText("G: " + pixel.getGreen());
bValue.setText("B: " + pixel.getBlue());
colorPanel.setBackground(new Color(pixel.getRed(), pixel.getGreen(), pixel.getBlue()));
} else {
clearInformation();
}
// notify the image display of the current x and y
imageDisplay.setCurrentX((int) (colIndex * zoomFactor));
imageDisplay.setCurrentY((int) (rowIndex * zoomFactor));
}
public void mirrorArms() {
int mirrorPoint = 298;
Pixel leftPixel = null;
Pixel rightPixel = null;
int count = 0;
Pixel[][] pixels = this.getPixels2D();
// loop through the rows
for (int row = 153; row < 192; row++) {
// loop from 13 to just before the mirror point
for (int col = 100; col < mirrorPoint; col++) {
leftPixel = pixels[row][col];
rightPixel = pixels[mirrorPoint - row][col];
rightPixel.setColor(leftPixel.getColor());
}
}
}
/**
* Method that will copy all of the passed source picture into the current picture object
*
* @param sourcePicture the picture object to copy
*/
public void copyPicture(SimplePicture sourcePicture) {
Pixel sourcePixel = null;
Pixel targetPixel = null;
// loop through the columns
for (int sourceX = 0, targetX = 0;
sourceX < sourcePicture.getWidth() && targetX < this.getWidth();
sourceX++, targetX++) {
// loop through the rows
for (int sourceY = 0, targetY = 0;
sourceY < sourcePicture.getHeight() && targetY < this.getHeight();
sourceY++, targetY++) {
sourcePixel = sourcePicture.getPixel(sourceX, sourceY);
targetPixel = this.getPixel(targetX, targetY);
targetPixel.setColor(sourcePixel.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++) {
leftPixel = pixels[row][col];
rightPixel = pixels[row][mirrorPoint - col + mirrorPoint];
rightPixel.setColor(leftPixel.getColor());
}
}
}
public boolean compareImages(Image image1, Image image2, Rectangle rect, String attach) {
if (image1 == null || image2 == null) return false;
boolean matched = false;
Iterator iter1 = handlePixels(image1, rect);
Iterator iter2 = handlePixels(image2, rect);
while (iter1.hasNext() && iter2.hasNext()) {
Pixel pixel = (Pixel) iter1.next();
if (pixel.equals((Pixel) iter2.next())) {
matched = true;
} else {
matched = false;
}
}
if (matched) return true;
return false;
}
public void negate() {
Pixel[][] pixels = this.getPixels2D();
for (Pixel[] rowArray : pixels) {
for (Pixel pixelObj : rowArray) {
pixelObj.setRed(255 - pixelObj.getRed());
pixelObj.setGreen(255 - pixelObj.getGreen());
pixelObj.setBlue(255 - pixelObj.getBlue());
}
}
}
public void grayscale() {
Pixel[][] pixels = this.getPixels2D();
for (Pixel[] rowArray : pixels) {
for (Pixel pixelObj : rowArray) {
int ave = (pixelObj.getRed() + pixelObj.getGreen() + pixelObj.getBlue()) / 3;
pixelObj.setBlue(ave);
pixelObj.setRed(ave);
pixelObj.setGreen(ave);
}
}
}
/**
* Create the color information panel
*
* @param labelFont the font to use for labels
* @return the color information panel
*/
private JPanel createColorInfoPanel(Font labelFont) {
// create a color info panel
JPanel colorInfoPanel = new JPanel();
colorInfoPanel.setLayout(new FlowLayout());
// get the pixel at the x and y
Pixel pixel = new Pixel(picture, colIndex, rowIndex);
// create the labels
rValue = new JLabel("R: " + pixel.getRed());
gValue = new JLabel("G: " + pixel.getGreen());
bValue = new JLabel("B: " + pixel.getBlue());
// create the sample color panel and label
colorLabel = new JLabel("Color at location: ");
colorPanel = new JPanel();
colorPanel.setBorder(new LineBorder(Color.black, 1));
// set the color sample to the pixel color
colorPanel.setBackground(pixel.getColor());
// set the font
rValue.setFont(labelFont);
gValue.setFont(labelFont);
bValue.setFont(labelFont);
colorLabel.setFont(labelFont);
colorPanel.setPreferredSize(new Dimension(25, 25));
// add items to the color information panel
colorInfoPanel.add(rValue);
colorInfoPanel.add(gValue);
colorInfoPanel.add(bValue);
colorInfoPanel.add(colorLabel);
colorInfoPanel.add(colorPanel);
return colorInfoPanel;
}
public void negate() {
Pixel[][] pixels = this.getPixels2D();
for (Pixel[] rowArray : pixels) {
for (Pixel pixelObj : rowArray) {
int a = pixelObj.getRed();
int b = pixelObj.getBlue();
int c = pixelObj.getGreen();
pixelObj.setRed(255 - a);
pixelObj.setBlue(255 - b);
pixelObj.setGreen(255 - c);
}
}
}
// TODO how to calculate minimum-difference pixels?
@Override
protected void changeQueue(Pixel p) {
// recalculate neighbors
for (Pixel np : p.neighbors) {
if (np.isEmpty) {
int r = 0, g = 0, b = 0, n = 0;
for (Pixel nnp : np.neighbors) {
if (!nnp.isEmpty) {
r += nnp.color.getRed();
g += nnp.color.getGreen();
b += nnp.color.getBlue();
n++;
}
}
np.nonEmptyNeigh++;
r /= n;
g /= n;
b /= n;
Color avg = new Color(r, g, b);
Color newBlock =
new Color(
r >> blockOffset & blockMask,
g >> blockOffset & blockMask,
b >> blockOffset & blockMask);
int blockIndex =
newBlock.getRed() * rOffset
+ newBlock.getGreen() * gOffset
+ newBlock.getBlue() * bOffset;
if (!np.inQueue) {
np.block = blockIndex;
np.inQueue = true;
pixelBlocks[blockIndex].add(np);
} else if (blockIndex != np.block) {
if (!pixelBlocks[np.block].remove(np)) {
System.out.println(
"Couldn't remove pixel "
+ np
+ ", even though it should be in block "
+ blockIndex
+ " !");
}
np.inQueue = true;
np.block = blockIndex;
pixelBlocks[blockIndex].add(np);
}
np.avg = avg;
}
}
}
public void copy(
Picture fromPic,
int fromStartRow,
int fromStartCol,
int toStartRow,
int toStartCol,
int fromEndRow,
int fromEndCol) {
Pixel fromPixel = null;
Pixel toPixel = null;
Pixel[][] toPixels = this.getPixels2D();
Pixel[][] fromPixels = fromPic.getPixels2D();
for (int fromRow = fromStartRow, toRow = toStartRow;
fromRow <= fromEndRow && toRow < toPixels.length;
fromRow++, toRow++) {
for (int fromCol = fromStartCol, toCol = toStartCol;
fromCol <= fromEndCol && toCol < toPixels.length;
fromCol++, toCol++) {
fromPixel = fromPixels[fromRow][fromCol];
toPixel = toPixels[toRow][toCol];
toPixel.setColor(fromPixel.getColor());
}
}
}
public void greyscale() {
Pixel[][] pixels = this.getPixels2D();
for (Pixel[] rowArray : pixels) {
for (Pixel pixelObj : rowArray) {
int a = pixelObj.getRed();
int b = pixelObj.getBlue();
int c = pixelObj.getGreen();
int d = (a + b + c) / 3;
pixelObj.setRed(d);
pixelObj.setBlue(d);
pixelObj.setGreen(d);
}
}
}
/**
* 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[][] pixels = this.getPixels2D();
Color rightColor = null;
for (int row = 0; row < pixels.length; row++) {
for (int col = 0; col < pixels[0].length - 1; col++) {
leftPixel = pixels[row][col];
rightPixel = pixels[row][col + 1];
rightColor = rightPixel.getColor();
if (leftPixel.colorDistance(rightColor) > edgeDist
|| (row + 1 > pixels.length
&& leftPixel.colorDistance(pixels[row + 1][col].getColor()) > edgeDist))
leftPixel.setColor(Color.BLACK);
else leftPixel.setColor(Color.WHITE);
}
}
}
/**
* 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[][] pixels = this.getPixels2D();
Color rightColor = null;
for (int row = 0; row < pixels.length; row++) {
for (int col = 0; col < pixels[0].length - 1; col++) {
leftPixel = pixels[row][col];
rightPixel = pixels[row][col + 1];
rightColor = rightPixel.getColor();
if (leftPixel.colorDistance(rightColor) > edgeDist) leftPixel.setColor(Color.BLACK);
else leftPixel.setColor(Color.WHITE);
}
}
// code to improve edge detection
Pixel topPixel = null;
Pixel bottomPixel = null;
Color bottomColor = null;
for (int col = 0; col < pixels[0].length; col++) {
for (int row = 0; row < pixels.length - 1; row++) {
topPixel = pixels[row][col];
bottomPixel = pixels[row + 1][col];
bottomColor = bottomPixel.getColor();
if (topPixel.colorDistance(bottomColor) > edgeDist) {
topPixel.setColor(Color.BLACK);
} else {
topPixel.setColor(Color.WHITE);
}
}
}
}
