Computational Problems
Problem 1: Collage
Maximum Score: 15 pts (see red text for point breakdown)
Andy Warhol was a famous American artist, a leader in the movement known as pop art. One of his most iconic works was a collage he created of Marilyn Monroe.
For this problem, you will be doing your own take on a collage in the same style as Warhol. You will have to do the following:
- Find an image (pick any non-offensive image that you like).
- Convert it to GIF if necessary.
- Scale it to the appropriate size.
- Create 5 variants of the image, each with at least one process applied to it (e.g. grayscale, negative, or mirroring, etc.).
- Display them along with the original in a 3×2 pattern in an image window.
When creating your collage, you get to choose which filters you use. However, there are a few requirements for these filters:
- One of them must by a unique filter to be used with the
pixelMapper
function. (Note: thepixelMapper
function is discussed in the book and is part of the starter code). By unique, I mean that the filter must not be one that was given in the book (e.g. grayscale isn’t unique because it is given in the book). Furthermore, this unique function must use anif-else
statement (or possiblyif-elif-else
). - One of the filters must be a mirror effect, either across the horizontal axis (as shown in the kitten example), or across the vertical axis (as we discussed in class).
- One of the filters must use the blur function.
Selecting your Collage Image
Your repository contains a file named green-bird.gif
, which you can use to test out the functions you write. However, you will use another image when it comes time to create your collage.
You can use whatever file you like, either one created by you (e.g. a picture you took) or something you find on the internet. Once you have this image, you will need to convert it into GIF format (a basic GIF, not an animated one). There are many tools available online, including:
https://image.online-convert.com/convert-to-gif
Once you have the file in GIF format, copy it into your working folder.
shrink
Function: The first function you should write is one named shrink
. This function will take in an image and a factor (an integer) and will return a new image that is the same as the original, but reduced in size by the given factor. For example, shrink(my_img, 4)
will return a new image which is the same as my_img
but whose width and height are both 1/4 the size of the original.
For this function, you should start with the double
function given in Listing 6.9 in your textbook (Section 6.5.2) and modify it to suit your needs. We talked about the equation to go from the smaller to the larger version in class so refer to your class notes for guidance on what needs to change in the double
function to make it work like shrink
should.
After you write this function, test it out in the REPL by trying to shrink an image by several different factors (e.g. 2, 3, and 5).
This function is worth 2 pts.
get_shrink_factor
Function: This function will take in an image as well as a target width and height. It will return the minimum factor by which we should shrink the given image so that its width does not exceed target width, and its height does not exceed the target height. The returned factor MUST be an integer value (i.e. don’t return 3.7). If the image is already is within the bounds of the target width and height, it will return 1.
For example, assume my_img
refers to an image object with width 1000 and height 1500.
get_shrink_factor(my_img, 500, 500)
should return 3. This is because if themy_img
was shrunk by a factor of 3, it would result in an image of width 334 and height 500.get_shrink_factor(my_img, 500, 1000)
should return 2. This is because if themy_img
was shrunk by a factor of 2, it would result in an image of width 500 and height 750.get_shrink_factor(my_img, 2000, 2000)
should return 1. This is because the image’s width and height are already within the target range for width and height.
This function is worth 1 pt.
Function: Unique Pixel Filter
This function (whose name you will decide) will fulfill the “unique” filter requirement listed above. This function should take in a pixel and should return a new pixel that is the same as the old pixel but with some special effect/filter applied. Examples of this type of filter as the grayscale
and negative
function given in the book (and also in the starter code).
Your unique filter can do anything you want, as long as it is different from what was done in the book or in class. It must also use an if-else
statement to conditionally modify pixels (you may also include elif
conditions).
You can test this function in the REPL as shown below, but replace unique_filter
with the name of your function, and “foo.gif” with the name of your
from collage_creator import *_x000D_ orig_img = FileImage("green-bird.gif")_x000D_ filtered_img = pixelMapper(orig_img, unique_filter)_x000D_ display(orig_img, "Original Image")_x000D_ display(filtered_img, "Image after applying Unique Filter")
This function is worth 2 pts.
mirror
Function: This function will take in an image and return a new image which is the same as the original but mirrored across either the horizontal or vertical axis. Recall that mirroring is different than flipping, which your book describes. Nonetheless, the code for mirroring and flipping should be quite similar, so make use of the given verticalFlip
function in the starter code, which was discussed in section 6.5.3 in our textbook.
As always, test your mirror filter in the REPL to make sure it works correctly.
This function is worth 2 pts.
Function: Three Other Filters
You are free to use any other filters for the remaining images of your collage. The only restriction is that you must have at least five different filters used overall, which means you need at least three filters outside of the ones previously described. You may use any existing filters from the book/starter code (e.g. grayscale) or you may come up with your own. You may use more than six total filters, but that means you would apply more than one filter to at least one of the images (since you only have 6 shown in your collage).
These additional filters are worth 2 points each, for a total of 6 pts.
create_collage
Function: This function will be the one that puts together everything you have done up to this point. It should do the following steps.
- User the
input()
function to ask the user to enter the filename of an image (e.g. “cute-cat.gif”). - Creates a
FileImage
object from the picture that the user specified. - Ask the user (again, using
input()
) to enter the maximum width of the collage. - Ask the user (again, using
input()
) to enter the maximum height of the collage. - Use the
get_shrink_factor
function to determine how much each the image needs to be shrunk by in order to fit into the requested collage size. Remember that your collage will contain an 3×2 grid of the image, so you will need to take that into account when callingget_shrink_factor
. - Use the
shrink
function to return a shrunken version of the original image. - Apply the five filters to the
FileImage
to create five new image objects, each with a different filter applied to it. - Creates a new
ImageWin
, which will be used to display the collage. The title of the window should read “Joe and Jane’s Collage”, where Joe and Jane would be replaced with you and your partners’ names. The width and height of the window should be the exact size needed to fit the collage: this may or may not be the same as the width and height entered by the user initially. - Use the
setPosition()
method on each of the six image objects to set their placement. You can look at themakeGrayScale
function (Listing 6.4 in Section 6.3.2) to see howsetPosition()
is used to put an image right next to another one. - Use the
draw()
method on each of the six image objects to draw them on theImageWin
object you created. Again, themakeGrayScale
function can help you see how to use thedraw()
method. - VERY IMPORTANT: Call the
exitOnClick()
method on yourImageWin
object to make sure that it doesn’t close until you click somewhere on the image. If you forget this, your image will pop and immediately disappear when you run your program. See thedisplay()
function in the starter code to see how this method works.
The function is worth 2 pts, broken down as follows:
- 1 pt for correctly getting the filename, desired width, and desired height, then resizing the image by the correct scale factor.
- 1 pt for correctly positioning and displaying them six filters into a 3×2 grid.
Testing Your Collage Creator
You should be able to test your collage creator app by running the collage_creator.py
file from your VS code terminal, as follows (replacing python3
with python
if you are using Windows). Before running the command, make sure you have exited the REPL.
python3 collage_creator.py
This should result in you being prompted to enter the filename, then collage width, then collage height, before ultimately displaying the collage in another window. Note that this image window will likely pop up behind your VS Code application so keep an eye out for it there.
To keep things easier for the grader, your program prompts should look like the following after running the program (note that the parts after the colons will be entered by the user).
Enter the name of the image file (GIF format): blues.gif_x000D_
Enter the maximum collage width: 600_x000D_
Enter the maximum collage height: 400_x000D_
You should test out your program for different images (both blues.gif
and your own GIF at a minimum) and for different sizes of collage width/height to make sure it works as expected.