Coding challenges on a fitness tracker: object-oriented design end to end — MIT problem set

Problem 1A Getter That Estimates: Class Variables, None, and datetime

Colorblindness Filters: Transforming Every Pixel

MIT 6.100L Introduction to CS and Programming Using Python, Fall 2022 · Problem set 5, 1) Colorblindness Filters — filter · Dr. Ana Bell · CC BY-NC-SA 4.0 · MIT publishes no solution for this set; the worked solution is ours

Write filter(pixels_list, color), which simulates colorblindness: it applies a colorblindness transformation to every pixel in a list of RGB pixels and returns the list of transformed pixels.

The human eye contains two types of photoreceptive (light sensitive) cells: rods and cones. Rods are responsible for vision in low light environments, such as at night, and cones are responsible for color vision. There are three types of cones, each responsible for a particular color, that is, red, green and blue. The red, green and blue cones all work together allowing you to see the whole spectrum of colors. For example, when the red and blue cones are stimulated in a certain way, you will see the color purple.

The condition known as colorblindness typically manifests as a deficiency in one of these types of cones; for example, protanopia is a lack of sensitivity to red light. The objective of this part is to create filters to simulate these differences. We can replicate the effects of colorblindness with a matrix multiplication between a colorblindness transformation matrix and the RGB values of a particular pixel, which are represented as a vector with 3 entries. You do not need to know anything about matrix multiplication.

filter takes in a list of pixels in RGB form, such as [(0,0,0),(255,255,255),(38,29,58)...], as well as a color: 'red', 'blue', 'green', or 'none'. The purpose of this function is to apply a transformation to the pixels in the input list that simulates impairment in the cones of the input color. Return the list of transformed pixels.

In order to do the transformation, multiply each pixel by the appropriate matrix. The provided make_matrix function supplies a matrix representing the appropriate transformation depending on the input string: for example, make_matrix('red') returns the matrix representing a red deficiency in one's vision.
You must iterate through the list of pixels and multiply each one by the appropriate matrix, using the provided matrix_multiply(matrix1, matrix2). The transformation matrix must be the first argument and the RGB pixel vector the second, or else the resulting image will be incorrect.
matrix_multiply returns a list of floats, and the pixels must be tuples of ints. Convert each value with round() or int(); either is accepted.
The returned list holds one transformed pixel for each input pixel, in the same order.

print(matrix_multiply(make_matrix('none'), (38, 29, 58)))  # [38.0, 29.0, 58.0]
print(filter([(0, 0, 0), (255, 255, 255), (38, 29, 58)], 'none'))  # [(0, 0, 0), (255, 255, 255), (38, 29, 58)]
print(filter([(180, 160, 80), (120, 10, 240)], 'red'))  # [(171, 171, 99), (72, 71, 184)]

Adapted for the browser: Pillow and numpy are not available, so the image arrives as its list of pixels and MIT's img_to_pix and pix_to_img, which only open and save image files, are left out; matrix_multiply is a pure-Python version of MIT's numpy helper with the same name, arguments and result; and the tests compare pixel values where MIT graded the filtered image_15.png by eye.

# --- given: make_matrix and matrix_multiply (do not edit) ---
def make_matrix(color):
    """
    Generates a transformation matrix for the specified color.
    Inputs:
        color: string with exactly one of the following values:
               'red', 'blue', 'green', or 'none'
    Returns:
        matrix: a transformation matrix corresponding to
                deficiency in that color
    """
    # You do not need to understand exactly how this function works.
    if color == 'red':
        c = [[.567, .433, 0], [.558, .442, 0], [0, .242, .758]]
    elif color == 'green':
        c = [[0.625, 0.375, 0], [0.7, 0.3, 0], [0, 0.142, 0.858]]
    elif color == 'blue':
        c = [[.95, 0.05, 0], [0, 0.433, 0.567], [0, 0.475, .525]]
    elif color == 'none':
        c = [[1, 0., 0], [0, 1, 0.], [0, 0., 1]]
    return c


def matrix_multiply(m1, m2):
    """
    Multiplies the input matrices.
    Inputs:
        m1,m2: the input matrices
    Returns:
        result: matrix product of m1 and m2
        in a list of floats
    """
    # A pure-Python stand-in for MIT's numpy.matmul version (numpy is not
    # available in the browser). A matrix (a list of rows) times a vector
    # (a list or tuple of numbers) gives a list of floats.
    def is_matrix(m):
        return len(m) > 0 and type(m[0]) in (list, tuple)

    def dot(u, v):
        if len(u) != len(v):
            raise ValueError("matrix_multiply: the sizes do not match")
        total = 0
        for a, b in zip(u, v):
            total += a * b
        return float(total)

    if is_matrix(m1) and is_matrix(m2):
        columns = [list(col) for col in zip(*m2)]
        return [[dot(row, col) for col in columns] for row in m1]
    if is_matrix(m1):
        return [dot(row, m2) for row in m1]
    if is_matrix(m2):
        return [dot(m1, list(col)) for col in zip(*m2)]
    return dot(m1, m2)


def filter(pixels_list, color):
    """
    pixels_list: a list of pixels in RGB form, such as
            [(0,0,0),(255,255,255),(38,29,58)...]
    color: 'red', 'blue', 'green', or 'none', must be a string representing
           the color deficiency that is being simulated.
    returns: list of pixels in same format as earlier functions,
    transformed by matrix multiplication
    """
    pass

# --- given: make_matrix and matrix_multiply (do not edit) ---
def make_matrix(color):
    """
    Generates a transformation matrix for the specified color.
    Inputs:
        color: string with exactly one of the following values:
               'red', 'blue', 'green', or 'none'
    Returns:
        matrix: a transformation matrix corresponding to
                deficiency in that color
    """
    # You do not need to understand exactly how this function works.
    if color == 'red':
        c = [[.567, .433, 0], [.558, .442, 0], [0, .242, .758]]
    elif color == 'green':
        c = [[0.625, 0.375, 0], [0.7, 0.3, 0], [0, 0.142, 0.858]]
    elif color == 'blue':
        c = [[.95, 0.05, 0], [0, 0.433, 0.567], [0, 0.475, .525]]
    elif color == 'none':
        c = [[1, 0., 0], [0, 1, 0.], [0, 0., 1]]
    return c


def matrix_multiply(m1, m2):
    """
    Multiplies the input matrices.
    Inputs:
        m1,m2: the input matrices
    Returns:
        result: matrix product of m1 and m2
        in a list of floats
    """
    # A pure-Python stand-in for MIT's numpy.matmul version (numpy is not
    # available in the browser). A matrix (a list of rows) times a vector
    # (a list or tuple of numbers) gives a list of floats.
    def is_matrix(m):
        return len(m) > 0 and type(m[0]) in (list, tuple)

    def dot(u, v):
        if len(u) != len(v):
            raise ValueError("matrix_multiply: the sizes do not match")
        total = 0
        for a, b in zip(u, v):
            total += a * b
        return float(total)

    if is_matrix(m1) and is_matrix(m2):
        columns = [list(col) for col in zip(*m2)]
        return [[dot(row, col) for col in columns] for row in m1]
    if is_matrix(m1):
        return [dot(row, m2) for row in m1]
    if is_matrix(m2):
        return [dot(m1, list(col)) for col in zip(*m2)]
    return dot(m1, m2)


def filter(pixels_list, color):
    """
    pixels_list: a list of pixels in RGB form, such as
            [(0,0,0),(255,255,255),(38,29,58)...]
    color: 'red', 'blue', 'green', or 'none', must be a string representing
           the color deficiency that is being simulated.
    returns: list of pixels in same format as earlier functions,
    transformed by matrix multiplication
    """
    pass

Scratchpad— run any Python to test ideas

# Scratchpad — run any Python here to test ideas.
# Anything you write below stays separate from the problem's tests.

print("hello, world")

# Scratchpad — run any Python here to test ideas.
# Anything you write below stays separate from the problem's tests.

print("hello, world")

Python runtime ready in a moment

Visible tests · 3Examples — click to expand

the 'none' filter leaves MIT's example pixels unchanged

the red filter transforms two pixels

each transformed pixel is a tuple of three ints

Hidden tests · 5Bodies hidden — pass/fail only

Hidden test 1

Hidden test 2

Hidden test 3

Hidden test 4

Hidden test 5

Colorblindness Filters: Transforming Every Pixel

Write filter(pixels_list, color), which simulates colorblindness: it applies a colorblindness transformation to every pixel in a list of RGB pixels and returns the list of transformed pixels.

In order to do the transformation, multiply each pixel by the appropriate matrix. The provided make_matrix function supplies a matrix representing the appropriate transformation depending on the input string: for example, make_matrix('red') returns the matrix representing a red deficiency in one's vision.
You must iterate through the list of pixels and multiply each one by the appropriate matrix, using the provided matrix_multiply(matrix1, matrix2). The transformation matrix must be the first argument and the RGB pixel vector the second, or else the resulting image will be incorrect.
matrix_multiply returns a list of floats, and the pixels must be tuples of ints. Convert each value with round() or int(); either is accepted.
The returned list holds one transformed pixel for each input pixel, in the same order.

print(matrix_multiply(make_matrix('none'), (38, 29, 58)))  # [38.0, 29.0, 58.0]
print(filter([(0, 0, 0), (255, 255, 255), (38, 29, 58)], 'none'))  # [(0, 0, 0), (255, 255, 255), (38, 29, 58)]
print(filter([(180, 160, 80), (120, 10, 240)], 'red'))  # [(171, 171, 99), (72, 71, 184)]

# --- given: make_matrix and matrix_multiply (do not edit) ---
def make_matrix(color):
    """
    Generates a transformation matrix for the specified color.
    Inputs:
        color: string with exactly one of the following values:
               'red', 'blue', 'green', or 'none'
    Returns:
        matrix: a transformation matrix corresponding to
                deficiency in that color
    """
    # You do not need to understand exactly how this function works.
    if color == 'red':
        c = [[.567, .433, 0], [.558, .442, 0], [0, .242, .758]]
    elif color == 'green':
        c = [[0.625, 0.375, 0], [0.7, 0.3, 0], [0, 0.142, 0.858]]
    elif color == 'blue':
        c = [[.95, 0.05, 0], [0, 0.433, 0.567], [0, 0.475, .525]]
    elif color == 'none':
        c = [[1, 0., 0], [0, 1, 0.], [0, 0., 1]]
    return c


def matrix_multiply(m1, m2):
    """
    Multiplies the input matrices.
    Inputs:
        m1,m2: the input matrices
    Returns:
        result: matrix product of m1 and m2
        in a list of floats
    """
    # A pure-Python stand-in for MIT's numpy.matmul version (numpy is not
    # available in the browser). A matrix (a list of rows) times a vector
    # (a list or tuple of numbers) gives a list of floats.
    def is_matrix(m):
        return len(m) > 0 and type(m[0]) in (list, tuple)

    def dot(u, v):
        if len(u) != len(v):
            raise ValueError("matrix_multiply: the sizes do not match")
        total = 0
        for a, b in zip(u, v):
            total += a * b
        return float(total)

    if is_matrix(m1) and is_matrix(m2):
        columns = [list(col) for col in zip(*m2)]
        return [[dot(row, col) for col in columns] for row in m1]
    if is_matrix(m1):
        return [dot(row, m2) for row in m1]
    if is_matrix(m2):
        return [dot(m1, list(col)) for col in zip(*m2)]
    return dot(m1, m2)


def filter(pixels_list, color):
    """
    pixels_list: a list of pixels in RGB form, such as
            [(0,0,0),(255,255,255),(38,29,58)...]
    color: 'red', 'blue', 'green', or 'none', must be a string representing
           the color deficiency that is being simulated.
    returns: list of pixels in same format as earlier functions,
    transformed by matrix multiplication
    """
    pass

# --- given: make_matrix and matrix_multiply (do not edit) ---
def make_matrix(color):
    """
    Generates a transformation matrix for the specified color.
    Inputs:
        color: string with exactly one of the following values:
               'red', 'blue', 'green', or 'none'
    Returns:
        matrix: a transformation matrix corresponding to
                deficiency in that color
    """
    # You do not need to understand exactly how this function works.
    if color == 'red':
        c = [[.567, .433, 0], [.558, .442, 0], [0, .242, .758]]
    elif color == 'green':
        c = [[0.625, 0.375, 0], [0.7, 0.3, 0], [0, 0.142, 0.858]]
    elif color == 'blue':
        c = [[.95, 0.05, 0], [0, 0.433, 0.567], [0, 0.475, .525]]
    elif color == 'none':
        c = [[1, 0., 0], [0, 1, 0.], [0, 0., 1]]
    return c


def matrix_multiply(m1, m2):
    """
    Multiplies the input matrices.
    Inputs:
        m1,m2: the input matrices
    Returns:
        result: matrix product of m1 and m2
        in a list of floats
    """
    # A pure-Python stand-in for MIT's numpy.matmul version (numpy is not
    # available in the browser). A matrix (a list of rows) times a vector
    # (a list or tuple of numbers) gives a list of floats.
    def is_matrix(m):
        return len(m) > 0 and type(m[0]) in (list, tuple)

    def dot(u, v):
        if len(u) != len(v):
            raise ValueError("matrix_multiply: the sizes do not match")
        total = 0
        for a, b in zip(u, v):
            total += a * b
        return float(total)

    if is_matrix(m1) and is_matrix(m2):
        columns = [list(col) for col in zip(*m2)]
        return [[dot(row, col) for col in columns] for row in m1]
    if is_matrix(m1):
        return [dot(row, m2) for row in m1]
    if is_matrix(m2):
        return [dot(m1, list(col)) for col in zip(*m2)]
    return dot(m1, m2)


def filter(pixels_list, color):
    """
    pixels_list: a list of pixels in RGB form, such as
            [(0,0,0),(255,255,255),(38,29,58)...]
    color: 'red', 'blue', 'green', or 'none', must be a string representing
           the color deficiency that is being simulated.
    returns: list of pixels in same format as earlier functions,
    transformed by matrix multiplication
    """
    pass

Scratchpad— run any Python to test ideas

# Scratchpad — run any Python here to test ideas.
# Anything you write below stays separate from the problem's tests.

print("hello, world")

# Scratchpad — run any Python here to test ideas.
# Anything you write below stays separate from the problem's tests.

print("hello, world")

Python runtime ready in a moment

Visible tests · 3Examples — click to expand

the 'none' filter leaves MIT's example pixels unchanged

the red filter transforms two pixels

each transformed pixel is a tuple of three ints

Hidden tests · 5Bodies hidden — pass/fail only

Hidden test 1

Hidden test 2

Hidden test 3

Hidden test 4

Hidden test 5