Laboratory: Transforming Images

Summary: In this laboratory, you will extend the operations you've used to transform colors into operations that transform images.

Reference:

(image-variant image fun): DrFu procedure. Create a new image of the same width and height as image, each of whose pixels is computed by applying fun to the color of the corresponding pixel in image.
(image-transform! image fun): DrFu procedure. Transform image in place by setting each pixel to the result of applying fun to that current pixel color.
(compose f g): Traditional Higher-Order Procedure. Build a one-parameter procedure that applies g to its parameter, and then f to that result. ((compose f g) x) is the same as (f (g x)).
(o f₁ f₂ ... f_n-1 f_n): Traditional Higher-Order Procedure. Build a one-parameter procedure that applies each f, in turn, starting with f_n and working backwards. The composition, when applied to a value, x, produces the same result as (f₁ (f₂ (... (f_n-1 (f_n x))))).
(rgb-lighter rgb-color): DrFu procedure. Build a lighter version of the given color.
(rgb-darker rgb-color): DrFu RGB procedure. Build a darker version of the given color.
(rgb-redder rgb-color): DrFu RGB procedure Build a redder version of the given color.
(rgb-greener rgb-color): DrFu RGB procedure. Build a greener version of the given color.
(rgb-bluer rgb-color): DrFu RGB procedure. Build a bluer version of the given color.
(rgb-rotate rgb-color): DrFu RGB procedure..Rotate the three components of the given color, setting the red component to the value of green, green to the value of blue, and blue to the value of red..
(rgb-phaseshift rgb-color): DrFu RGB procedure.“Phase shift” the color by adding 128 to components less than 128 and subtracting 128 from components greater than 128.
(rgb-complement rgb-color): DrFu RGB procedure. Compute the psuedo-complement of the given color.
(image-transform-pixel! image column row func): DrFu procedure. Modify the pixel at (col,row) in image by applying func to its old color and setting that pixel to the resulting color.

Preparation

In this laboratory, you will be creating a few images and manipulating others. We will also be working with some colors.

a. Create a new 4x3 image, call it canvas, show it, and zoom in to 16x resolution.

b. Open an existing JPEG image of your choice, call it picture, and show it. Please choose an image that is not too large (say, not much more than 250x250).

c. You may have created definitions for three favorite colors, fave1, fave2, and fave3 in a previous lab. Check your library to see if they are there. If not, add some definitions. For example,

(define fave1 (cname->rgb "blue violet"))
(define fave2 (rgb-new 240 0 180))
(define fave3 (rgb-new 180 0 240))

Exercises

Exercise 1: Mapping Transformations

a. Set a few pixels in canvas to colors of your choice. Leave others black or white.

b. What do you expect to happen when you use image-transform! to complement each pixel in canvas, using the following instruction?

(image-transform! canvas rgb-complement)

c. Check your answer experimentally.

d. What do you expect to have happen if you use image-transform! to complement each pixel in picture? (You would use nearly the same instruction, substituting picture for canvas.)

e. Check your answer experimentally.

f. What do you expect to have happen if you once again complement each pixel in picture?

g. Check your answer experimentally.

Exercise 2: Undoing Transformations

a. What do you expect to have happen if you use image-transform! to redden each pixel in canvas?

b. Check your answer experimentally.

c. You may have noticed that in the previous problem, we were able to undo the complement transformation by complementing again. Is there an easy way to undo the redden operation? (You do not have to write code; just explain how to do it.)

d. Are there transformations or sequences of transformations that would be impossible to undo? (That is, can you do something to an image such that there is nothing that you can do to the revised image that will bring back the original image?)

Exercise 3: Pure Transformations

As you may have just observed, there are times that transforming an image can be dangerous, because we cannot easily undo some transformations. As an alternative, many programmers build new images that simulate the transformation, rather than transforming the existing in place. In DrFu, the image-variant operation does just that. It returns the identifier of a new image.

a. Consider the following instruction. What effect do you have expect this instruction to have on canvas?

(define new-image (image-transform! canvas rgb-darker))

b. Check your answer experimentally.

c. Consider the following instruction. What effect do you have expect this instruction to have on canvas?

(define newer-image (image-variant canvas rgb-darker))

d. Check your answer experimentally.

e. What do you expect to have happen if we show newer-image?

f. Check your answer experimentally.

(image-show newer-image)

g. What do you expect to have happen with each of the following:

(define img1 (image-variant canvas rgb-rotate))
(define img2 (image-variant canvas rgb-lighter))
(define img3 (image-variant canvas rgb-phaseshift))
(image-show img1)
(image-show img2)
(image-show img3)

h. Check you answer experimentally.

Exercise 4: Composition

Consider the following definitions.

(define much-darker (compose rgb-darker rgb-darker))
(define red (rgb-new 255 0 0))

a. What color do you expect (much-darker red) to compute? (Answer the question in terms of red, green, and blue values.)

b. Check your answer experimentally.

c. Set the top-left pixel of canvas to red.

d. What effect do you expect the following instruction to have?

(image-transform-pixel! canvas 0 0 (compose rgb-lighter rgb-lighter))

e. Check your answer experimentally.

f. What effect do you expect the following instruction to have?

(image-transform-pixel! canvas 0 0 
                        (compose rgb-lighter (compose rgb-lighter rgb-lighter)))

g. Check your answer experimentally.

Exercise 5: Composition and Order of Operations

Consider the composition (compose rgb-darker rgb-phaseshift).

a. Does this darken the image first or phase-shift the image first.

b. Does it matter? That is, do you get the same result either way?

c. Check your answer experimentally with image-variant.

Exercise 6: Undoing Transformations

Earlier in this lab, we saw that some transformations had natural inverses and some did not. For example, if you complement a color twice, you get the original color. For many colors, if you lighten and then darken the color, you get the original color. (If any of the components is very large, then we may not be able to restore the original color.)

a. Consider the rgb-redder operation. How would you write an inverse to that operation using the color-based transformations along with composition?

b. Test your answer using image-transform. For example, if you decided that the answer was to make the image greener and bluer, you might write something like the following.

(define redder-canvas (image-variant canvas rgb-redder))
(define not-redder-canvas (image-variant redder-canvas (compose rgb-greener rgb-bluer)))
(image-show redder-canvas)
(image-show not-redder-canvas)

In case you were wondering, making the image greener and bluer does not invert the redder operation.

Explorations

Explorations are intended for students interested in further exploring the design aspects of these techniques. They also provide students who finish early with extra activities that may challenge them in different ways. You may do them in either order.

Exploration 1: Combining Transformations

While we only have a few basic transformations, there are, in some sense, an infinite number of ways to combine them. Try to find an interesting composition of basic transformations that someone might want to use as a filter.

Exploration 2: Arithmetic Transformations, Revised

As you have undoubtedly noticed, RGB colors are represented as integers. That means that we can transform colors with arithmetic operations as well as with component based operations. What do you think the following operations will do to your image? Try some of them to find out. Then, try a few of your own devising.

(define t1 (lambda (c) (* 2 c)))
(define t2 (lambda (c) (* 3 c)))
(define t2 (lambda (c) (* -1 c)))
(define t3 (lambda (c) (* 256 c)))
(define t4 (lambda (c) (quotient (+ color-red c) 2)))
(define t5 (lambda (c) (- c color-blue)))

Make sure you save your work regularly. Some of these procedures have the potential to crash DrFu.