1. Workshop for Programming And Systems Management Teachers
Chapter 5
Manipulating Pictures, Arrays, and Loops
Georgia Institute of Technology

2. Georgia Institute of Technology
Learning Goals
Understand at a conceptual and practical level
How to manipulate digital images using methods?
What is an array?
What is a loop?
While and for loops
What is a package?
How do you import classes?
What is a comment?
Georgia Institute of Technology

3. Georgia Institute of Technology
Digital Pictures
Represented as an array of pixels
With a red, green, and blue value stored for each pixel
Stored in .jpg (JPEG) files
International standard
With lossy compression
Lossy means not all data is stored
But what is lost isn’t that important
Compression means made smaller
Other formats for storing digital pictures are GIFF and BMP
For more about JPEG see
See for more information about GIFF.
See for more information about BMP. This windows format is not compressed.
Georgia Institute of Technology

4. Georgia Institute of Technology
What is an Array?
Storage for a sequence of items
Of the same type
You can access items by using an index
The index starts at 0
The first item is at index 0
The second item is at index 1
The last item is at index (length – 1) 1 2 3 4 5 3 7 9 2 1 5 1 2 3 8 3 2 6
Think of seats in a row of a movie theater. They have an index too. They often start at 1.
Java uses a 0-based index. This is a holdover from C when the index was really the distance from the beginning of the array. The distance from the beginning of the array to the first element is 0.
Georgia Institute of Technology

5. How do you Declare an Array?
There are two ways
Type[] name;
Type name[];
You can give values for the array when you declare it
int[] grades = {88, 90, 75, 93, 94};
You can also create the array when you declare it
int[] grades = new int[5];
Georgia Institute of Technology

6. How do you Access Array Items?
In Java to access an array item use
arrayName[index]
To set a value in an array
grades[0] = 88;
grades[1] = 90;
To get a value from an array
int total = grades[0] + grades[1] + grades[2] + grades[3] + grades[4];
Arrays know their lengths
arrayName.length;
Georgia Institute of Technology

7. Georgia Institute of Technology
Array Exercise
In DrJava declare and create these two arrays
Check that you created them correctly by getting the value at each index
Check the length of the array with
arrayName.length 3 7 9 2 1 5 8 3 2 6
Georgia Institute of Technology

8. Manipulating a Picture
To manipulate a picture we need to manipulate the pixels that make up the picture
Change the red, green, or blue values at the pixel
Pixel is also a class
Each pixel object has a red, green, and blue value
Georgia Institute of Technology

9. What Data does a Picture Object Have?
A picture object has an array of pixel objects
That it read from the JPEG file
It knows it’s width
pictureObj.getWidth()
It knows it’s height
pictureObj.getHeight()
It knows how to return an array of pixels
Pixel[] pixels = pictureObject.getPixels()
Georgia Institute of Technology

10. Georgia Institute of Technology
Picture Exercise
Create a picture in DrJava
get the pictures width, height, and pixels
String fileName = FileChooser.pickAFile();
Picture picture = new Picture(fileName);
int width = picture.getWidth();
System.out.println(“The picture width is “ + width);
int height = picture.getHeight();
System.out.println(“The picture height is “ + height);
Pixel[] pixels = picture.getPixels();
System.out.println(pixels.length + “ pixels”);
Georgia Institute of Technology

11. Georgia Institute of Technology
Pixel Objects
Each pixel has a red, green, and blue value
getRed(), getGreen(), getBlue()
setRed(v), setGreen(v), setBlue(v)
Each pixel knows the location it was in the picture object
getX(), get(Y)
You can also get and set the color at the pixel
getColor(), setColor(color)
Georgia Institute of Technology

12. Georgia Institute of Technology
Pixel X and Y Values
A picture has pixels arranged in a grid
The location of the pixel along the horizontal axis is the x value
x starts at 0 to width - 1
The location of the pixel along the vertical axis is the y value
y starts at 0 to height - 1
Georgia Institute of Technology

13. Georgia Institute of Technology
Color Objects
There is a class defined in Java that represents color
The Color class in the package java.awt
To use the class you must either
import java.awt.Color;
Use the full name java.awt.Color
You can create a color object by giving the red, green, and blue values
Color color = new Color(255,10,125);
Georgia Institute of Technology

14. Georgia Institute of Technology
Predefined Colors
The Color class has defined class constants for many colors
Color.red, Color.green, Color.blue, Color.black, Color.white, Color.yellow, Color.gray, Color.orange, Color.pink, Color.cyan, Color.magenta
Or you can use all uppercase names
Color.RED, Color.BLUE, …
Originally the predefined colors where are lowercase names. However, the Java convention for constants is to use all uppercase letters. So the uppercase names for the predefined colors were added.
Georgia Institute of Technology

15. Getting and Setting Pixel Colors
To get a pixel’s color as a color object
Color color = pixel.getColor();
int red = color.getRed();
int green = color.getGreen();
To set a pixel’s color using a new color object
Color newColor = new Color(red,green,blue);
Pixel.setColor(newColor);
Georgia Institute of Technology

16. Using Classes in Packages
All classes in the Java language are in a package
You can use any class in java.lang
System, Math, Object
For classes in other packages you need to import them
import java.awt.Color;
Import java.awt.*; //import all classes in this package
To use the short name: Color
Or use the fully qualified name
packageName.ClassName
Some people prefer to import each class by naming each one in an import statement. This is helpful for other people who may not know what package each class is in. However, if you are using several classes from the same package you can use the ‘*’ to import all classes in the same package. This will not extend to sub-packages.
Georgia Institute of Technology

17. Georgia Institute of Technology
Undefined Class Error
If you forget to import a class
Yet, you use the short name for the class
It won’t compile
Undefined class error
Undefined class errors mean
You need to import the class
You misspelled the class
Georgia Institute of Technology

18. Georgia Institute of Technology
Pixel Exercise
In DrJava
Pick a file and create a picture object
Get the array of pixels from the picture object
Get the 1st pixel from the array of pixels
Get the red, green, and blue value for this pixel
Get the x and y location of this pixel
Get the color of this pixel
Get the red, green, and blue values of the color
Georgia Institute of Technology

19. Georgia Institute of Technology
Changing Pixel Colors
There are two ways to change the color of a pixel in a picture
pixel.setRed(value), pixel.setGreen(value), pixel.setBlue(value)
pixel.setColor(color)
But, you won’t see any change in the picture
Until you ask it to repaint
picture.repaint();
Georgia Institute of Technology

20. Georgia Institute of Technology
Changing a Color
The Color class has methods for making a color object
Lighter
color.brighter();
Darker
color.darker();
Example
> Color testColor = new Color(168,131,105);
> System.out.println(testColor);
java.awt.Color[r=168,g=131,b=105]
> testColor = testColor.darker();
java.awt.Color[r=117,g=91,b=73]
> testColor = testColor.brighter();
java.awt.Color[r=167,g=130,b=104]
Georgia Institute of Technology

21. Georgia Institute of Technology
Rounding Errors
Notice that when you made the color darker and then lighter the resulting color was slightly off of the original
The change is calculated in floating point
The result is stored in integer form
The decimal part is lost
Rounding errors also occur because of the limited storage for floating point numbers
We can’t store all the digits in some numbers
Georgia Institute of Technology

22. Changing a Picture Exercise
> String fileName = "C:/intro-prog-java/mediasources/catapillarClipart.jpg";
> Picture picture = new Picture(fileName);
> picture.show();
> picture.getPixel(10,100).setColor(Color.black);
> picture.getPixel(11,100).setColor(Color.black);
> picture.getPixel(12,100).setColor(Color.black);
> picture.getPixel(13,100).setColor(Color.black);
> picture.getPixel(14,100).setColor(Color.black);
> picture.getPixel(15,100).setColor(Color.black);
> picture.getPixel(16,100).setColor(Color.black);
> picture.getPixel(17,100).setColor(Color.black);
> picture.getPixel(18,100).setColor(Color.black);
> picture.getPixel(19,100).setColor(Color.black);
> picture.repaint();
Type the above code in the interactions pane and see what happens.
Georgia Institute of Technology

23. How do we Know if it Worked?
A very important part of programming is testing the result
Just because code compiles and runs without error doesn’t mean it is correct
There could be an error in the logic
It could fail under certain conditions
It could even return the correct answer but for the wrong reason
Georgia Institute of Technology

24. Georgia Institute of Technology
The Picture Explorer
Tool that creates a copy of the current picture and lets you explore it
See the color, x, and y values at the cursor
To use the tool on a picture object
picture.explore();
Use it to see if the colors have changed
Georgia Institute of Technology

25. Changing the Red in a Picture
One way to change a picture is to reduce the amount of red in it
What if we want to decrease it by half?
If we have a value of 255 what should the new value be?
How do we reduce any value by half?
What if we want to increase it by 25%?
If we have a value of 125 what should the new value be?
How do we increase any value by 25%?
To decrease the red value by half multiply it by To increase the red value by 25% multiply it by 1.25.
Georgia Institute of Technology

26. Changing all the Pixels in a Picture
There are 360 x 181 = 65,160 pixels in the caterpillar picture
Do we really want to write the code to change each one of these
Get the current pixel
Get the red value of the current pixel
Change the red value of the current pixel to 0.5 the original value
Put the new red value in the current pixel
Georgia Institute of Technology

27. We Need a Loop (Iteration)
A way to execute a series of statements
With something changing each time the statements are executed
Different pixel to change
And some way to tell when we are done with the repetition
Some test to see if the loop should stop
Georgia Institute of Technology

28. Georgia Institute of Technology
Loop Exercise
Ask a person to clap 12 times
How does s/he know when to stop?
What changes each time s/he claps?
If you are following a recipe that asks you to stir the ingredients 50 times how would you do this?
What if you were trying to break a sit-up record
How would you know if you did break it?
Georgia Institute of Technology

29. Loops often need Counters
If you want to do something x times you often need a counter
That starts at 0
And you add 1 to it each time you finish doing the thing you are repeating
When the counter reaches the number you are trying to do you stop the loop
What is the value of the counter the last time the statements of the loop are executed?
The counter is also often referred to as an index.
Georgia Institute of Technology

30. Georgia Institute of Technology
The While Loop
In Java one way to repeat a block of statements while an expression is true is to use a while loop
Create a counter and set it to the start value
Check that the counter is less then the stop value
If it is less than execute the statements in the loop
Add one to the counter and go back to check that the counter is less than the stop value
Georgia Institute of Technology

31. Total the Numbers from 1 to 100
What if you want to add all the numbers from 1 to 100?
You will need something to hold the total
What type should it be?
What value should it start out with?
You will need something that counts from 1 to 100
And add that value to the total
Stop when you get to 100
What type should it be? What value should it start with?
Georgia Institute of Technology

32. Georgia Institute of Technology
While Loop Syntax
Adding up the numbers from 1 to 100
int counter = 1;
int total = 0;
while (counter <= 100) {
total = total + counter;
counter = counter + 1; }
System.out.println(total);
When you type the above code into DrJava you will need to do Shift-Enter when you type the while loop code in (so that it doesn’t try to evaluate the while loop till you have all the code entered.
Georgia Institute of Technology

33. Decrease Red Algorithm
To decrease the red value in a picture by 50%
Get the array of pixels from the picture
Set up an index to start at 0
Check if the index is less than the length of the array
If it is go on to step 4 of the loop
If it isn’t jump to the first instruction after the loop
Get the pixel at the current index from the array of pixels
Get the red value at the pixel
Multiply the red value by 0.5
Set the red value at the pixel to the reduced red value
Increment the index and go back to step 3
In this algorithm assume that you go on to the next step unless told to do otherwise.
Georgia Institute of Technology

34. Georgia Institute of Technology
What is an Algorithm?
An algorithm is a description of the steps needed to do a task
Can be written in English
A recipe is an algorithm
A program is an implementation of an algorithm
in a particular computer language
Georgia Institute of Technology

35. From Algorithm to Program (code)
How do we get the array of pixels from the current picture object?
We have used
Pixel[] pixels = picture.getPixels();
But we want to get the array of pixels from the current object
Pixel[] pixels = this.getPixels();
Or we can leave off the this
Pixel[] pixels = getPixels();
This is a keyword that refers to the current object. If you leave off an object the compiler will assume you mean the current object (implicit this).
Georgia Institute of Technology

36. Georgia Institute of Technology
Loop Algorithm to Code
How to write (code) the loop?
Use a while loop with a counter for the index starting at 0
int index = 0;
Loop while the index is less than the length of the array
while (index < pixels.length)
Get the current pixel from the array of pixels for the current index
Pixel pixel = pixels[index];
Georgia Institute of Technology

37. Loop Algorithm to Code - Continued
Get the red value at the pixel
int redValue = pixel.getRed();
Decrease the red value by 0.5
redValue = redValue * 0.5;
Set the pixel red value
pixel.setRed(redValue);
Add one to (increment) the index
index = index + 1;
Georgia Institute of Technology

38. Georgia Institute of Technology
Decrease Red Method
public void decreaseRed() {
// get the array of pixels for this picture object
Pixel[] pixels = this.getPixels();
// start the index at 0
int index = 0;
// loop while the index is less than the length of the pixels array
while (index < pixels.length)
// get the current pixel at this index
Pixel pixel = pixels[index];
// get the red value at the pixel
int redValue = pixel.getRed();
// set the red value to half what it was
redValue = redValue * 0.5;
// set the red for this pixel to the new value
pixel.setRed(redValue);
// increment the index
index = index + 1; }
Georgia Institute of Technology

39. Georgia Institute of Technology
Comments
Comments are explanations of your code to help people understand your code
They are ignored by the compiler
There are several kinds in Java
// a comment that lasts to the end of the line
/* a comment that can take up several lines
until a */
/** a Javadoc comment that is used to create html documentation of your code */
Javadoc is a utility that comes with the JDK for creating html documentation from your source code (*.java files).
Georgia Institute of Technology

40. Georgia Institute of Technology
Loss of Precision
If you try the code on the previous slide you will get a compiler error
Possible loss of precision
It is complaining about putting a double value into a int variable
Loss of fractional part
Double clicking on an error in the Compiler Output pane will highlight the statement that caused the error and change the definitions pane to show you the problem.
Georgia Institute of Technology

41. Casting to Solve Loss of Precision Error
It will compile if we tell the compiler we know about the possible loss of precision
And that it is intended
By using a cast to int
redValue = (int) (redValue * 0.5);
Notice that we cast the result of the multiplication back to an integer
Casting is forcing a value into a type
(type) expression
Georgia Institute of Technology

42. Move Declarations Outside Loops
When you need a variable in a loop it is best to declare it before the loop
Otherwise you are declaring a new variable each time through the loop
Which is slower than just changing the value associated with the variable
In some languages you must declare all variables at the beginning of a method (function)
In Java you can declare variables anywhere in a method
As long as you declare them before you use them
Georgia Institute of Technology

43. Shortcuts for Common Operations
In programming you often need to add one to a value
index = index + 1;
You may use the shortcut
index++; or ++index;
If you wanted to subtract 1 instead
index = index – 1;
index--; or -- index;
You can also use x += y as a shortcut for x = x + y, x-=y for x = x – y, x*=y for x=x*y, and x/=y for x = x / y.
Georgia Institute of Technology

44. Decrease Red Method Version 2
public void decreaseRed() {
Pixel pixel = null; // the current pixel
int redValue; // the amount of red
// get the array of pixels for this picture object
Pixel[] pixels = this.getPixels();
// start the index at 0
int index = 0;
// loop while the index is less than the length of the pixels array
while (index < pixels.length)
// get the current pixel at this index
pixel = pixels[index];
// get the red value at the pixel
redValue = pixel.getRed();
// set the red value to half what it was
redValue = (int) (redValue * 0.5);
// set the red for this pixel to the new value
pixel.setRed(redValue);
// increment the index
index++; }
Georgia Institute of Technology

45. Georgia Institute of Technology
Decrease Red Exercise
In DrJava
Add the method decreaseRed() to Picture.java
Compile the method
Test it by doing the following in the interactions pane
> String fileName = "C:/intro-prog-java/mediasources/catapillarClipart.jpg";
> Picture picture = new Picture(fileName);
> picture.show();
> picture.explore();
> picture.decreaseRed();
> picture.repaint();
Use the picture explorer to check that the red values where reduced by 50%.
Georgia Institute of Technology

46. Georgia Institute of Technology
Tracing Code
An important skill to develop is the ability to trace code
Also called walking through or stepping through your code
Look at each line and predict what will happen
Show the variables and their values
Georgia Institute of Technology

47. Step Through decreaseRed()
A picture object was created from the file “catapillarClipart.jpg” and then was sent the message decreaseRed()
The picture object was implicitly passed to the method decreaseRed()
Some variables were declared for later use in the loop
Pixel pixel = null;
int redValue;
The array of pixel objects was returned from sending getPixels() to the picture object
Pixel[] pixels = this.getPixels();
Georgia Institute of Technology

48. Step Through decreaseRed() - cont
An index variable was declared and set to 0
int index = 0;
The while loop tests if the index is less than the length of the array
while (index < pixels.length) {
And if so it executes the statements in the body of the loop {}
It sets the variable pixel to the pixel at the index in the array of pixels
pixel = pixels[index];
It gets the red value of that pixel
redValue = pixel.getRed();
it sets the red value to 0.5 * the original value
redValue = (int) (redValue * 0.5);
It sets the pixel’s red to the new value
pixel.setRed(redValue);
It increments the index value
index++;
Georgia Institute of Technology

49. Memory Map of decreaseRed()
width=360
height=181
What does memory look like the first time through the loop?
How about the 2nd time through?
How about the 3rd time through?
How about the last time through?
Picture: Class
getPixels() …
this
pixels
R=255,
G=255,
B=255,
X=0,
Y=0
R=255,
G=255,
B=255,
X=1,
Y=0
R=255,
G=255,
B=255,
X=2,
Y=0 …
pixel
Pixel: Class
getRed()
setRed()…
redValue = 255
index = 0
Georgia Institute of Technology

50. Georgia Institute of Technology
Increase Red
What if you want to increase red by 30%
How would you do that?
Multiplying by 0.5 reduces the red by 50%
Multiplying by 1.0 would keep the same red value
Multiplying by 1.3 would increase the red by 30%
Multiplying by 1.7 would increase the red by 70%
Georgia Institute of Technology

51. Increase Red Algorithm
To increase the red value in a picture by 30%
Get the array of pixels from the picture
Set up an index to start at 0
Check if the index is less than the length of the array
If it is go on to step 4 of the loop
If it isn’t jump to the first instruction after the loop
Get the pixel at the current index from the array of pixels
Get the red value at the pixel
Multiply the red value by 1.3
Set the red value at the pixel to the reduced red value
Increment the index and go back to step 3
Georgia Institute of Technology

52. Increase Red: Algorithm to Code
The algorithm for this method is very similar to the algorithm for decrease red
Start with the code for decreaseRed
Change the line of code that multiplied the current red value by 0.5 to 1.3
Change the name of the method
Change any comments that need changing
Georgia Institute of Technology

53. Georgia Institute of Technology
increaseRed Method
public void increaseRed() {
Pixel pixel = null; // the current pixel
int redValue; // the amount of red
// get the array of pixels for this picture object
Pixel[] pixels = this.getPixels();
// start the index at 0
int index = 0;
// loop while the index is less than the length of the pixels array
while (index < pixels.length)
// get the current pixel at this index
pixel = pixels[index];
// get the red value at the pixel
redValue = pixel.getRed();
// increase the red value to 30% more than the original
redValue = (int) (redValue * 1.3);
// set the red for this pixel to the new value
pixel.setRed(redValue);
// increment the index
index++; }
Georgia Institute of Technology

54. Georgia Institute of Technology
Clear the Blue Values
What if you want to clear the blue from a picture
Set all the blue values to 0 for all the pixels
The algorithm is similar to decreaseRed() and increaseRed() except
You don’t need to get the value out for blue and multiply it by some value and then set the blue value
Just set the blue value to 0
Georgia Institute of Technology

55. Georgia Institute of Technology
Clear Blue Exercise
In Picture.java
Write the object method
public void clearBlue()
That sets the blue value to 0 for all pixels in a picture
Georgia Institute of Technology

56. Georgia Institute of Technology
Faking a Sunset
If you want to make an outdoor scene look like it happened during sunset
You might want to increase the red
But you can’t increase past 255
Another idea is to reduce the blue and green
To emphasize the red
Try to reduce the blue and green by 30%
Georgia Institute of Technology

57. Faking a Sunset Algorithm
Reduce the blue and green by 30%
Get the array of pixels from the picture
Set up an index to start at 0
Check if the index is less than the length of the array
If it is go on to step 4 of the loop
If it isn’t jump to the first instruction after the loop
Get the pixel at the current index from the array of pixels
Set the blue value at the pixel to 0.7 times the original value
Set the green value at the pixel to 0.7 times the original value
Increment the index and go back to step 3
Georgia Institute of Technology

58. Georgia Institute of Technology
Faking a Sunset Method
/**
* Method to fake a sunset by reducing the blue and green in a picture
* by 30% */
public void fakeSunset() {
Pixel pixel = null; // the current pixel
// get the array of pixels for this picture object
Pixel[] pixels = this.getPixels();
// start the index at 0
int index = 0;
// loop while the index is less than the length of the pixels array
while (index < pixels.length)
// get the current pixel at this index
pixel = pixels[index];
// set the blue value to 0.7 times the original blue value
pixel.setBlue((int) 0.7 * pixel.getBlue());
// set the green value to 0.7 times the original green value
pixel.setGreen((int) 0.7 * pixel.getGreen());
// increment the index
index++; }
Georgia Institute of Technology

59. Georgia Institute of Technology
A For Loop
Programmers like shortcuts
Especially those that reduce errors
And mean less typing
We have been using a while loop with an index
We had to declare the index variable and initialize it before the loop
If you forget this there will be a compiler error
We had to increment the index in the loop
If you forget this it will be an infinite loop
The shortcut for this is a For Loop
Georgia Institute of Technology

60. Georgia Institute of Technology
For Loop Syntax
for (initialization area; continuation test; change area)
Initialization area
Declare variables and initialize them
Continuation test
If true do body of loop
If false jump to next statement after the loop
Change area
Change the loop variables
Increment or decrement them
Each of the three parts of a for loop are optional. However, the ‘;’s have to be there. You can declare and initialize more than one variable in the initialization area, just separate them with commas.
Georgia Institute of Technology

61. Comparison of While and For Loops
int index = 0;
while (index < pixels.length) {
statements .
index++; }
for (int i=0; i < pixels.length; i++) {
statements . }
Programmers often use i as an index variable name.
Even though the variable i is declared and initialized in the for loop it actually only is declared before the test. It is not repeated each time through the loop.
Even though the increment is right after the continuation test in the for loop it doesn’t happen till after the last statement in the loop.
Georgia Institute of Technology

62. Change clearBlue() to use a For Loop
/**
* Method to clear the blue from the picture (set
* the blue to 0 for all pixels) */
public void clearBlue() {
// get the array of pixels from the current picture
Pixel[] pixels = this.getPixels();
// declare the variable that will refer to the current pixel
Pixel pixel = null;
// declare the index and initialize it to 0
int index = 0;
// loop through all the pixels
while (index < pixels.length)
// get the current pixel
pixel = pixels[index];
// set the blue on the pixel to 0
pixel.setBlue(0);
index++; }
/**
* Method to clear the blue from the picture (set
* the blue to 0 for all pixels) */
public void clearBlue() {
Pixel pixel = null; // current pixel in loop
// get the array of pixels from the current picture
Pixel[] pixels = this.getPixels();
// loop through all the pixels
for (int i = 0; i < pixels.length; i++)
// get the current pixel
pixel = pixels[i];
// set the blue on the pixel to 0
pixel.setBlue(0); }
Georgia Institute of Technology

63. Using System.out.println() in a Loop
One way to check what is happening in your program is to add
System.out.println(expression);
You might add this to the loop to check the value of ‘i’ during it.
And to verify that the increment happens after the last statement in the loop
Georgia Institute of Technology

64. Change to For Loop Exercise
Edit fakeSunset() and change it from using a while loop to using a for loop
Move the declaration of the index to the for loop initialization area
Move the index increment to the for loop change area
Execute the code to make sure it still works
Georgia Institute of Technology

65. Georgia Institute of Technology
Negating an Image
How would you turn a picture into a negative?
White should become black
255,255,255 becomes 0,0,0
Black should become white
0,0,0 becomes 255,255,255
Georgia Institute of Technology

66. Georgia Institute of Technology
Negate Algorithm
Subtract current value from 255 for red, green, and blue
Get the array of pixels from the picture
Loop starting an index at 0 and incrementing by 1
Check if the index is less than the length of the array
If it is go on to step 4 of the loop
If it isn’t jump to the first instruction after the loop
Get the pixel at the current index from the array of pixels
Set the red value to 255 – current red value
Set the blue value to 255 – current blue value
Set the green value to 255 – current green value
Increment the index and go back to step 3
Georgia Institute of Technology

67. Georgia Institute of Technology
Negate Method
/**
* Method to negate the picture */
public void negate() {
Pixel pixel = null;
// get the array of pixels
Pixel[] pixels = this.getPixels();
// loop through all the pixels
for (int i = 0; i < pixels.length; i++)
// get the current pixel
pixel = pixels[i];
// set the pixel color values to the new values
pixel.setRed(255 - pixel.getRed());
pixel.setGreen(255 - pixel.getGreen());
pixel.setBlue(255 - pixel.getBlue()); }
Georgia Institute of Technology

68. Georgia Institute of Technology
Changing to Grayscale
Grayscale ranges from black to white
The red, green, and blue values are the same
How can we change any color to gray?
What number can we use for all three values?
The intensity of the color
We can average the colors
(red + green + blue) / 3
Example
( ) / 3 = 90
To average x numbers get the sum of all the numbers and then divide by x.
Georgia Institute of Technology

69. Georgia Institute of Technology
Grayscale Algorithm
Set color values to the average of the original values
Get the array of pixels from the picture
Loop starting an index at 0
Check if the index is less than the length of the array
If it is go on to step 4 of the loop
If it isn’t jump to the first instruction after the loop
Get the pixel at the current index from the array of pixels
Calculate the average of the current values
Set the red value to the average
Set the blue value to the average
Set the green value to the average
Increment the index and go to step 3
Georgia Institute of Technology

70. Georgia Institute of Technology
Grayscale Method
/**
* Method to change the picture to gray scale */
public void grayscale() {
Pixel pixel = null;
int intensity = 0;
// get the array of pixels
Pixel[] pixels = this.getPixels();
// loop through all the pixels
for (int i = 0; i < pixels.length; i++)
// get the current pixel
pixel = pixels[i];
// compute the intensity of the pixel (average value)
intensity = (int) ((pixel.getRed() + pixel.getGreen() +
pixel.getBlue()) / 3);
// set the pixel color to the new color
pixel.setColor(new Color(intensity,intensity,intensity)); }
Georgia Institute of Technology

71. Georgia Institute of Technology
Grayscale Result
Georgia Institute of Technology

72. Georgia Institute of Technology
Luminance
We perceive blue to be darker than red, and green
Even when the same amount of light is reflected
A better grayscale model should take this into account
Weight green the highest (* 0.587)
red less (* 0.299) and
blue the very least (* 0.114)
Georgia Institute of Technology

73. Grayscale with Luminance Exercise
Create a new method grayscaleWithLuminance
Using the new algorithm for calculating intensity
Georgia Institute of Technology

74. Georgia Institute of Technology
Summary
Pictures have a grid of pixels
You can change the picture by changing the color of the pixel
You will need to repaint the picture
Arrays let you store and retrieve values of the same type using an index
You will need to import classes that you wish to use that aren’t in java.lang
Loops allow you to execute a block of statements zero to many times
Georgia Institute of Technology