Image Processing & Pixel Manipulation

grid = [
    [[255, 100, 50], [0, 200, 150]],
    [[80, 40, 20], [120, 220, 240]]
]
for r in range(2):
    for c in range(2):
        grid[r][c][0] = 0
        grid[r][c][2] = 0
print(grid[0][0])
print(grid[1][1])

Expected result: [0, 100, 0] [0, 220, 0]

The nested loop sets the red (0) and blue (2) components of every pixel to 0 while preserving the green (1) component. Pixel (0,0) becomes [0, 100, 0] and Pixel (1,1) becomes [0, 220, 0].

values = [2, 4]
total = 0
for value in values:
    total += value
print(total)

image = [
    [10, 20, 30, 40],
    [50, 60, 70, 80],
    [90, 100, 110, 120],
    [130, 140, 150, 160]
]
downsampled = []
for r in range(0, 4, 2):
    row = []
    for c in range(0, 4, 2):
        row.append(image[r][c])
    downsampled.append(row)
print(downsampled)

Expected result: [[10, 30], [90, 110]]

Striding by step 2 samples the top-left pixel of each 2x2 spatial block. The resulting downsampled 2x2 grid is [[10, 30], [90, 110]].

values = [2, 4]
total = 0
for value in values:
    total += value
print(total)

pixels = [50, 100, 150, 200]
src_min, src_max = min(pixels), max(pixels)
dst_min, dst_max = 0, 255
stretched = []
for p in pixels:
    val = (p - src_min) / (src_max - src_min) * (dst_max - dst_min) + dst_min
    stretched.append(int(round(val)))
print(stretched)

Expected result: [0, 85, 170, 255]

Linear stretching normalizes the minimum intensity to 0 and the maximum intensity to 255. The intermediate values map proportionally to 85 and 170.

values = [2, 4]
total = 0
for value in values:
    total += value
print(total)

pixels = [0, 1, 1, 2, 2, 2, 3, 3]
hist = [0] * 4
for p in pixels:
    hist[p] += 1
cdf = []
running = 0
for count in hist:
    running += count
    cdf.append(running)
print(hist, cdf)

Expected result: [1, 2, 3, 2] [1, 3, 6, 8]

The histogram counts occurrences of each intensity level [1, 2, 3, 2]. The cumulative distribution function sums these frequencies progressively: [1, 3, 6, 8].

values = [2, 4]
total = 0
for value in values:
    total += value
print(total)

patch = [
    [10, 10, 10],
    [10, 100, 10],
    [10, 10, 10]
]
center = sum(sum(r) for r in patch) // 9
print('Blurred center:', center)

Expected result: Blurred center: 20

The 3x3 box blur filter assigns equal 1/9 weight to all neighbors. The impulse noise spike at 100 is attenuated down to 20, demonstrating low-pass spatial noise suppression.

values = [2, 4]
total = 0
for value in values:
    total += value
print(total)

patch = [
    [20, 20, 20],
    [20, 20, 20],
    [200, 200, 200]
]
Gy = (-1*20 - 2*20 - 1*20) + (1*200 + 2*200 + 1*200)
print('Gy gradient:', Gy)

Expected result: Gy gradient: 720

The Sobel vertical kernel detects intensity steps across rows. Gy = 720 signals a prominent horizontal edge where intensity jumps from 20 to 200.

values = [2, 4]
total = 0
for value in values:
    total += value
print(total)

pixels = [160] * 64
# For 8x8 block with N=8, C(0,0) = (1/8) * sum(pixels)
C00 = (1/8) * sum(pixels)
print('DC coefficient:', int(C00))

Expected result: DC coefficient: 1280

The DC coefficient C(0,0) captures the total average luminance energy of the 8x8 block. In JPEG, adjacent DC terms are delta-coded to exploit inter-block correlation.

values = [2, 4]
total = 0
for value in values:
    total += value
print(total)

m_global = 128
k1 = 0.5
sigma_flat = 4.0
sigma_edge = 32.0

gain_flat = k1 * (m_global / sigma_flat)
gain_edge = k1 * (m_global / sigma_edge)
print(f'Ratio: {int(gain_flat / gain_edge)}')

Expected result: Ratio: 8

Adaptive Contrast Enhancement scales inversely with local standard deviation sigma. Uniform low-contrast regions receive high gain to reveal subtle textures, while sharp edges are suppressed to prevent halo artifacts.

values = [2, 4]
total = 0
for value in values:
    total += value
print(total)