CSE 131 Module 1: Types & Names

• Module Home
• Studio
• Lab
• Extensions

Extensions

• Extension 1 for this module (5 points):

  Calculator

  In this extension you complete the functionality of a calculator. You accomplish this using the arithmetic, String, boolean, and casting operations discussed in the book.

  • In eclipse, open the calculator package found in the extensions source folder.
  • You will find the following Java files:
    • Calculator Go ahead and run this as a Java application. Play around with the interface and try out some simple computations. Notice that most computations produce the same result. That is because you have not done your work on this extension yet.
    • Computations Notice that all of these methods compute a variable named ans and then return that result. The calculator calls upon these methods to perform the appropriate computations.
    • ComputationsTest is the unit test for this extension. Your code must pass this test for you to earn credit.

      To run the unit test, right (control) click on the ComputationsTest file in the package explorer, drag down to Run as and select JUnit Test.

      The results will be a red or green bar. The red bar means you have errors, and you can see those by clicking on the flagged methods below the red bar. The green bar means your code has passed the test.

  • At the top of each method, a comment explains the computation you must perform in assigning the value to ans for that method.
  • For example, we have completed addDoubles for you. The assignment to ans computes the value d1+d2.

  Methodology

  • Perform your work one section at a time. For example, complete the double operators and test those before moving on to the other data types.

    Resist the urge to finish coding all of your work! If you are doing something wrong, you will go further down a bad path than you should go. Instead, proceed as follows.

    • Run the Calculator program and test your new functionality.

      To test the cast operations, use the copy and paste buttons to transfer a value from one type to another.

    • Run the ComputationsTest and ensure that your new functionality passes the unit test.
  • Move on to the next section and repeat the above until done.

  Some methods in this lab (specifically the casting methods) are not expected to produce any reasonable output. For example, a double cannot be cast to a boolean.

  Your method must nontheless return some value, so return any value you like, but call the error() method so that the program will report an error in the GUI window.

  For example, if a method should return an int but the operation does not make sense, then you would write:

       error();
       return 0;
  

  When you done with this extension, you must be cleared by the TA to receive credit.

  • Commit all your work to your repository
  • Fill in the form below with the relevant information
  • Have a TA check your work
  • The TA should check your work and then fill in his or her name
  • Click OK while the TA watches

  If you worked in a team using a group– repository:

  • Your work must be committed in that repository for this demo.
  • Each team member must complete this form and have the TA authenticate.
    For example, if there are two of you, then the form must be submitted twice, so that each person's last name and 6 digit ID is captured with the repository name.
  • The repository name must be included on each of the submissions.

  ---

  group– ←Enter the name of your group repository here

  ---

  	Last name	6-digit ID
  1

  ---

  TA: Password:
  

  End of extension 1

  ---

• Extension 2 for this module (8 points):

  Credits:

  • Dr. Anne Bracy greatly improved the write-up of this exercise.
  • Logan Sorrentino implemented the GUI that drives the image processing filters.

  Image Processor

  Background

  Pixels

  The word pixel stands for Picture Element. A pixel is a small part of a picture. Pixels are the little dots that make up LCD screens. When you see a low-resolution picture that is grainy, the grain you're seeing are the pixels.

  Representing color in Java

  Pixels are made up of 3 colors: red, green, and blue (hence the term RGB). The color of a pixel is made up of a combination of the intensities of each of red, green, and blue components. Intensities range from 0 (meaning none of that color is present) to 255 (meaning as much as possible of that color is present). You declare a new pixel by coding

  new Color(redValue, greenValue,blueValue)
  

  where redValue is the intensity (an integer between 0 and 255) of red, greenValue is the intensity of green, and blueValue is the intensity of blue.
  

  For example, you get the color black with new Color (0,0,0) (0 intensity for all colors). You get red with new Color (255,0,0) (highest intesity for red, 0 intensity for green and blue).

  Filters

  This work involves writing a number of filters that are applied to images to achieve a given result. There are two kinds of methods that you complete, and each is described below:

  int foo(int pixelComponent)

  Methods with the above signature take in a single pixel component intensity value: an integer between 0 and 255 inclusively. They are obligated to return an intensity value as their result.

  These methods are used by the course software as shown below:

  

  1. A Color object is broken into its red, green, and blue components.
  2. Each component is passed to your foo method, and the result of that function is retained.
  3. The three results are combined into a new Color object.

  In other words, the foo function is used as a filter on each of a Color's components. The foo function is unaware of which component it is processing: it treats each equally.

  Color bar(Color c)

  Methods with the above signature accept and produce a standard Java Color object. These methods can themselves decompose a Color object into its components and create a resulting Color object to achieve whatever effect is desired.

  Project: Image Processing Methods

  1. In Eclipse, open the extensions source folder and then open the imageprocessor package. Find and open the ImageProcessor class.

     This is the main program you run to see the results of your work.

     Go ahead and run it as a Java application. You should see a window pop up with some images preloaded.

  2. Try the darker filter. It has been implemented for you, and it should produce an image in the Target window that resembles the image in the source1 window, but is a bit darker.
  3. Try the combine filter. It has also been implemented but its effects may seem a bit strange. You will soon implement a smarter version of this kind of a filter.
  4. The other methods are not yet implemented, but you are free to try them.

     By the way, you can drag images between the icon panel at the top and the working panels in the middle, or vice versa, so that you can manipulate other images than the ones that are preloaded.

     You can also load your own images by clicking on the icon that resembles a plus sign.

  Directions:

  Now open the Filters class and begin your work as described below.

  It is strongly suggested that you test each filter after its completion before you move on to the next filter. This will ensure that you are making progress and not going down a wrong path.

  Complete the provided stub methods as described below. In the method bodies, use mathematical expressions. Do not use a conditional (if) statement.

  Intensity filters

  Use no conditional execution for this part: only arithmetic expressions as you have learned them in Module 1.

  1. Complete the method called copy, so that each provided intensity value is copied exactly from the source to the target panel.

     Hint: This is a very simple method.

     
  2. Complete the method that will composite the images in the two source panels by averaging their components. This method accepts two parameters, which are color components from the two source panels.
  3. Complete the method called negative that will produce the negative image by inverting the intensity of each component.

     For example, if the parameter value is 0, you should return 255. If the parameter value is 1, you should return 254, and so on.

     
  4. Complete the method posterize that will reduce the number of possible colors in an image. For a given color component, your method will choose between two intensities, 0 or 255, which correspond to that color component being turned off or on completely. So, since each color has three components (red, green, and blue), you will end up with an image that has only 8 different colors.

     Remember that you are not allowed to use conditionals (if) statements for this part of the lab.

     Hint: : Recall that color components are in the range 0-255. Also, recall that if you divide an int by another int, the result number will be truncated. For example, 130 / 128 = 1, but 125 / 128 = 0.

     

  Color filters

  Note that each pixel of an image is represented as a Color object.

  • Continue to use no conditional execution for this part: only arithmetic expressions as you have learned them in Module 1.
  • To create a new Color, you must specify its red, green, and blue components in that order. For example

    Color c = new Color(25,128,0);
    

    declares c to be a color with some red (25 out of 255), half of the possible green, and no blue.
  • If you have a Color c, then you can get its red, green, and blue components as follows:

    int red = c.getRed();
    int green = c.getGreen();
    int blue = c.getBlue();
    

  Create and test methods (whose parameters and return values are Colors) with the following specifications.

  1. Complete the method brighter that will return, for each pixel, a Color that is brighter than the original.

     The Color class makes this easy because it already provides a brighter() method that returns a brighter color.

     If c is a color, then c.brighter() is a brighter version of c's color.

     
  2. Complete the method grayscale that will make a grayscale image from a color image. To do this, you will take in one Color parameter (the Color object for a pixel from the original image) and will produce a new Color in which all the components (red, green, and blue) have the same value.

     Hint: To choose which value, average the three components of the original color.

     

  More Color filters

  OK, now you can use if statements!

  
  
  1. Complete the method blackAndWhite that produces a black and white image by returning, for each pixel, a Color that is either black or white, depending upon the overall intensity of the original color.

     For your return value, use the constant Color.BLACK or Color.WHITE. It's up to you how to decide when a color's components, taken as a whole, should be considered black or white.

     
  2. Complete the method combineBrighter that combines two images by choosing for each pixel the color from the image that has the brighter pixel in that location. To determine which pixel is brighter, compare the sums of the red, green, and blue components of the two pixels. Since the ProcessorTool will run your method for every pair of pixels, the resulting image will have some pixels from the first image and some from the second image.
     

  When you done with this extension, you must be cleared by the TA to receive credit.

  • Commit all your work to your repository
  • Fill in the form below with the relevant information
  • Have a TA check your work
  • The TA should check your work and then fill in his or her name
  • Click OK while the TA watches

  If you worked in a team using a group– repository:

  • Your work must be committed in that repository for this demo.
  • Each team member must complete this form and have the TA authenticate.
    For example, if there are two of you, then the form must be submitted twice, so that each person's last name and 6 digit ID is captured with the repository name.
  • The repository name must be included on each of the submissions.

  ---

  group– ←Enter the name of your group repository here

  ---

  	Last name	6-digit ID
  1

  ---

  TA: Password:
  

  End of extension 2

  ---

• Extension 3 for this module (4 points):

  This is a continuation of the previous extension. It is therefore suggested that you do the previous extension first.

  Image Processor (continued)

  Directions:

  The main program you should run for this extension is Background, which conveniently sets up the images in the bar and panels for you to do this work.

  So run Background as a Java application. You will see two similar images in the source panels, and some other images in the image bar.

  Open the Filters class and begin your work as described below.

  Two more Color filters

  You can use if statements for this work.

  
  
  1. Complete the method bgSubtract so that it returns a Color as follows:
     • If the source1Color and source2Color colors are sufficiently similar, return Color.BLUE. It is up to you to determine what is sufficiently similar, but the idea is to subtract the background so that what is common between the two source images is shown in blue.
     • Otherwise, return source1Color.
     An example is shown below: Where the two images are similar, the corresponding pixel in the target image is blue, because your method returned Color.BLUE. Where the images differ, the first image is shown in the target, because your method returned the pixel color from the first image.

  2. Complete the method bgReplace that functions as follows:
     • If the source1Color is Color.BLUE, then return the source2Color.
     • Otherwise, return source1Color.
     The effect of this filter is to replace the blue color from the first image with the corresponding pixels from the second image.

     To see this work, perform the following steps:

     1. Drag the blue-screen image from the target panel and drop it into the leftmost source panel. The GUI should replace what was there with the blue-screen image.
     2. Drag the other two-bear picture (the reverse of the one shown in the source panel) from the top icon bar into the middle source panel.

        After dragging these images around the GUI, the results should resemble the following:

        Note: No transformation is applied yet. The copy operation appears as the menu choice but the Go button was not pressed.

        
     3. Now apply the bgReplace filter, and the results resemble the following:
     4. For fun, drag the chicken image from the top icon bar into the middle source panel, and reapply the bgReplace filter. The results should resemble the following: The chicken is a smaller image, so it did not take up the entire size of the bear image.

  When you done with this extension, you must be cleared by the TA to receive credit.

  • Commit all your work to your repository
  • Fill in the form below with the relevant information
  • Have a TA check your work
  • The TA should check your work and then fill in his or her name
  • Click OK while the TA watches

  If you worked in a team using a group– repository:

  • Your work must be committed in that repository for this demo.
  • Each team member must complete this form and have the TA authenticate.
    For example, if there are two of you, then the form must be submitted twice, so that each person's last name and 6 digit ID is captured with the repository name.
  • The repository name must be included on each of the submissions.

  ---

  group– ←Enter the name of your group repository here

  ---

  	Last name	6-digit ID
  1

  ---

  TA: Password:
  

  End of extension 3

  ---