12.15. Coding Practice

Activecode

An image is just a matrix of pixels. Write the struct definition for image, which should store information about its height and width and contain a matrix of pixels. Select the Parsonsprob tab for hints for the construction of the code.

Example c192_cp_12_ac_2q

#include <iostream>
#include <vector>

struct pixel {
    int r;
    int g;
    int b;
};

// Write your code for the struct image here.

Parsonsprob

An image is just a matrix of pixels. Write the struct definition for image, which should store information about its height and width and contain a matrix of pixels. Use the lines to construct the code, then go back to complete the Activecode tab.

1. std::size_t height;

   ↑ ↓ ← → ✓ Use

2. std::size_t width;

   ↑ ↓ ← → ✓ Use

3. std::vector<pixel> matrix; #distractor

   ↑ ↓ ← → ✓ Use

4. std::vector<std::vector<pixel>> matrix;

   ↑ ↓ ← → ✓ Use

5. std::vector<std::vector> matrix; #distractor

   ↑ ↓ ← → ✓ Use

6. struct image {

   ↑ ↓ ← → ✓ Use

7. };

   ↑ ↓ ← → ✓ Use

Check answer

Activecode

Now let's print an image. Unfortunately we can't print out the actual image to the terminal, but we can print out the pixels in the image matrix. Write the image member function print_image. Separate pixels in the same row with a space and add a new line at the end of each row. Use the print_pixel function we created previously. Select the Parsonsprob tab for hints for the construction of the code.

Example c192_cp_12_ac_4q

#include <cstddef>
#include <iostream>
#include <vector>

struct pixel {
    int r;
    int g;
    int b;
    void print_pixel();
};

struct image {
    std::size_t height;
    std::size_t width;
    std::vector<std::vector<pixel>> matrix;
    void print_image();
};

// Write your implementation of print_image here.

int main() {
    std::vector<std::vector<pixel> > matrix = { { { 0, 255, 255 }, { 0, 0, 0 }, { 255, 255, 255 } },
                                    { { 30, 60, 50 }, { 20, 135, 200 }, { 60, 80, 125 } } };
    image image = { 2, 3, matrix };
    image.print_image();
}

Parsonsprob

Now let's print an image. Unfortunately we can't print out the actual image to the terminal, but we can print out the pixels in the image matrix. Write the image member function print_image. Separate pixels in the same row with a space and add a new line at the end of each row. Use the print_pixel function we created previously. Use the lines to construct the code, then go back to complete the Activecode tab.

1. for (std::size_t c = 0; c < width; ++ c) {

   ↑ ↓ ← → ✓ Use

2. for (std::size_t r = 0; r < height; ++r) {

   ↑ ↓ ← → ✓ Use

3. matrix[r][c].print_pixel();

   ↑ ↓ ← → ✓ Use

4. std::cout << " ";

   ↑ ↓ ← → ✓ Use

5. std::cout << std::endl;

   ↑ ↓ ← → ✓ Use

6. void image::print_image() {

   ↑ ↓ ← → ✓ Use

7. }

   ↑ ↓ ← → ✓ Use

8. }

   ↑ ↓ ← → ✓ Use

9. }

   ↑ ↓ ← → ✓ Use

Check answer

Activecode

Let's write a swap_pixel member function for image. swap_pixel takes two pairs of row indices and column indices from a matrix and swaps the two pixels at those locations. Note that these indices are 0-indexed, unlike the previous crop_index parameters. Select the Parsonsprob tab for hints for the construction of the code.

Example c192_cp_12_ac_6q

#include <stdexcept>
#include <cstddef>
#include <iostream>
#include <vector>
using std::cout;

struct pixel {
    int r;
    int g;
    int b;
    void print_pixel();
};

struct image {
    std::size_t height;
    std::size_t width;
    std::vector<std::vector<pixel> > matrix;
    void print_image();
    void crop_image(std::size_t start_row, std::size_t stop_row, std::size_t start_col, std::size_t stop_col);
    void swap_pixel(std::size_t row1, std::size_t col1, std::size_t row2, std::size_t col2);
};

// Write your implementation of swap_pixel here.

int main() {
    std::vector<std::vector<pixel> > matrix = { { { 0, 140, 255 }, { 0, 0, 0 }, { 15, 20, 255 } } };
    image image = { 1, 3, matrix };
    image.print_image();
    cout << std::endl;
    image.swap_pixel(0, 0, 0, 2);
    image.print_image();
}

Parsonsprob

Let's write a swap_pixel member function for image. swap_pixel takes two pairs of row indices and column indices from a matrix and swaps the two pixels at those locations. Note that these indices are 0-indexed, unlike the previous crop_index parameters. Use the lines to construct the code, then go back to complete the Activecode tab.

1. matrix[row1][col1] = matrix[row2][col2];

   ↑ ↓ ← → ✓ Use

2. matrix[row2][col2] = temp;

   ↑ ↓ ← → ✓ Use

3. pixel temp = { matrix[row1][col1].r, matrix[row1][col1].g,  matrix[row1][col1].b };

   ↑ ↓ ← → ✓ Use

4. void image::swap_pixel(std::size_t row1, std::size_t col1, std::size_t row2, std::size_t col2) {

   ↑ ↓ ← → ✓ Use

5. }

   ↑ ↓ ← → ✓ Use

Check answer

Activecode

Oops! Somehow our image came out upside down. Let's write the image member function flip_vertical, which reverts an image to be right side up. Select the Parsonsprob tab for hints for the construction of the code.

Example c192_cp_12_ac_8q

#include <stdexcept>
#include <cstddef>
#include <iostream>
#include <vector>
using std::cout;

struct pixel {
    int r;
    int g;
    int b;
    void print_pixel();
};

struct image {
    std::size_t height;
    std::size_t width;
    std::vector<std::vector<pixel> > matrix;
    void print_image();
    void crop_image(std::size_t start_row, std::size_t stop_row, std::size_t start_col, std::size_t stop_col);
    void swap_pixel(std::size_t row1, std::size_t col1, std::size_t row2, std::size_t col2);
    void flip_horizontal();
    void flip_vertical();
};

// Write your implementation of flip_vertical here.

int main() {
    std::vector<std::vector<pixel> > matrix = { { { 255, 255, 255 }, { 255, 255, 255 }, { 255, 255, 255 } },
                                    { { 50, 50, 50 }, { 10, 10, 10 }, { 50, 50, 50 } },
                                    { { 30, 30, 30 }, { 70, 70, 70 }, { 30, 30, 30 } },
                                    { { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 } } };
    image image = { 4, 3, matrix };
    image.print_image();
    cout << std::endl;
    image.flip_vertical();
    image.print_image();
}

Parsonsprob

Oops! Somehow our image came out upside down. Let's write the image member function flip_vertical, which reverts an image to be right side up. Use the lines to construct the code, then go back to complete the Activecode tab.

1. ++start;

   ↑ ↓ ← → ✓ Use

2. --end;

   ↑ ↓ ← → ✓ Use

3. std::size_t end = height == 0 ? 0 : height - 1;

   ↑ ↓ ← → ✓ Use

4. std::size_t start = 0;

   ↑ ↓ ← → ✓ Use

5. swap_pixel(start, c, end, c);

   ↑ ↓ ← → ✓ Use

6. void image::flip_vertical() {
       for (std::size_t c = 0; c < width; ++c) {

   ↑ ↓ ← → ✓ Use

7. while (start < end) {

   ↑ ↓ ← → ✓ Use

8. }

   ↑ ↓ ← → ✓ Use

9. }

   ↑ ↓ ← → ✓ Use

10. }

    ↑ ↓ ← → ✓ Use

Check answer

Activecode

Let's return our image to the state of a clean slate. Write the function clear_image, which sets the color of every pixel to white. Select the Parsonsprob tab for hints for the construction of the code.

Example c192_cp_12_ac_10q

#include <stdexcept>
#include <cstddef>
#include <iostream>
#include <vector>
using std::cout;

struct pixel {
    int r;
    int g;
    int b;
    void print_pixel();
};

struct image {
    std::size_t height;
    std::size_t width;
    std::vector<std::vector<pixel> > matrix;
    void print_image();
    void crop_image(std::size_t start_row, std::size_t stop_row, std::size_t start_col, std::size_t stop_col);
    void swap_pixel(std::size_t row1, std::size_t col1, std::size_t row2, std::size_t col2);
    void flip_horizontal();
    void flip_vertical();
    void create_border(pixel p);
    void clear_image();
};

// Write your implementation of clear_image here.

int main() {
    std::vector<std::vector<pixel> > matrix = { { { 0, 0, 0 }, { 10, 10, 10 }, { 65, 70, 255 } },
                                    { { 26, 48, 205 }, { 43, 12, 15 }, { 45, 30, 70 } },
                                    { { 89, 36, 65 }, { 75, 43, 26 }, { 40, 75, 70 } } };
    image image = { 3, 3, matrix };
    image.print_image();
    cout << std::endl;
    image.clear_image();
    image.print_image();
}

Parsonsprob

Let's return our image to the state of a clean slate. Write the function clear_image, which sets the color of every pixel to white. Use the lines to construct the code, then go back to complete the Activecode tab.

1. for (std::size_t c = 0; c < width; c++) {

   ↑ ↓ ← → ✓ Use

2. for (std::size_t r = 0; r < height; r++) {

   ↑ ↓ ← → ✓ Use

3. matrix[r][c].b = 255;

   ↑ ↓ ← → ✓ Use

4. matrix[r][c].g = 255;

   ↑ ↓ ← → ✓ Use

5. matrix[r][c].r = 255;

   ↑ ↓ ← → ✓ Use

6. void image::clear_image () {

   ↑ ↓ ← → ✓ Use

7. }

   ↑ ↓ ← → ✓ Use

8. }

   ↑ ↓ ← → ✓ Use

9. }

   ↑ ↓ ← → ✓ Use

Check answer