Coursera：Image and Vedio Processing: From Mars to Hollywood作业(部分)

• Write a computer program capable of reducing the number of intensity levels in an image from 256 to 2, in integer powers of 2. The desired number of intensity levels needs to be a variable input to your program.
• Using any programming language you feel comfortable with (it is though recommended to use the provided free Matlab), load an image and then perform a simple spatial 3x3 average of image pixels. In other words, replace the value of every pixel by the average of the values in its 3x3 neighborhood. If the pixel is located at (0,0), this means averaging the values of the pixels at the positions (-1,1), (0,1), (1,1), (-1,0), (0,0), (1,0), (-1,-1), (0,-1), and (1,-1). Be careful with pixels at the image boundaries. Repeat the process for a 10x10 neighborhood and again for a 20x20 neighborhood. Observe what happens to the image (we will discuss this in more details in the very near future, about week 3).
• Rotate the image by 45 and 90 degrees (Matlab provides simple command lines for doing this).
• For every 3×3 block of the image (without overlapping), replace all corresponding 9 pixels by their average. This operation simulates reducing the image spatial resolution. Repeat this for 5×5 blocks and 7×7 blocks. If you are using Matlab, investigate simple command lines to do this important operation.

 task1.py

def task1(img):
    jpg = cv2.imread(img, 0)
    while(True):
        level = int(input('choise level(1-8):'))
        cv2.imshow('level{}'.format(level), jpg-math.pow(2,level))
        cv2.waitKey()

 task2_1.py:

import cv2
import numpy as np

filter = np.zeros((3, 3))

def avg(matrix):
    return matrix.sum() // 9

def filter_flush():
    filter[:, :] = 0

def task(img):
    jpg = cv2.imread(img, 0)
    jc = jpg.copy()
    rl = jpg.shape[0]
    cl = jpg.shape[1]

    #x = [0, 0]
    filter_flush()
    filter[1:, 1:] = jpg[:1, :1]
    jc[0][0] = avg(filter)
    #x = [0, 1:cl-1]
    for ci in range(1, cl - 1):
        filter_flush()
        filter[1:, :] = jpg[:2, ci-1:ci+2]
        jc[0][ci] = avg(filter)
    #x = [0,cl-1]
    filter_flush()
    filter[1:, :2] = jpg[:2, cl-2:]
    jc[0][cl-1] = avg(filter)
    #x = [1:rl-1, :]
    for ri in range(1, rl-1):
        #x = [, 0]
        filter_flush()
        filter[:, 1:] = jpg[ri-1:ri+2, :2]
        jc[ri][0] = avg(filter)
        #x = [, 1:cl-1]
        for ci in range(1, cl-1):
            filter_flush()
            filter[:, :] = jpg[ri-1:ri+2, ci-1:ci+2]
            jc[ri][ci] = avg(filter)
        #x = [, cl-1]
        filter_flush()
        filter[:, :2] = jpg[ri-1:ri+2, cl-2:]
        jc[ri][cl-1] = avg(filter)
    #x = [rl-1, 0]
    filter_flush()
    filter[:2, 1:] = jpg[rl-2:, :2]
    jc[rl-1][0] = avg(filter)
    #x = [rl-1, :cl-1]
    for ci in range(1, cl-1):
        filter_flush()
        filter[1:, :] = jpg[rl-2:, ci-1:ci+2]
        jc[rl-1][ci] = avg(filter)
    #x = [rl-1, cl-1]
    filter_flush()
    filter[:2, :2] = jpg[rl-2:, cl-2:]
    jc[rl-1][cl-1] = avg(filter)

    cv2.imshow('origin', jpg)
    cv2.imshow('after average', jc)
    cv2.waitKey()

 task2_2.py

import cv2
import numpy as np
filter = None

def task2_2(img):
    global filter
    filter = np.zeros((10, 10))
    jpg = cv2.imread(img, 0)
    rl = jpg.shape[0]
    cl = jpg.shape[1]
    ground = np.pad(jpg, ((5,5), (5,5)), 'constant')

    #因为filter是10*10的，所以每个xi都要被卷积四次
    gv = np.zeros((rl+2, cl+2))
    for ri in range(rl+1):
        for ci in range(cl+1):
            filter_flush()
            filter[:] = ground[ri:ri+10, ci:ci+10]
            gv[ri][ci] = gv[ri][ci+1] = gv[ri+1][ci] = gv[ri+1][ci+1] = (gv[ri][ci] + filter.mean()) / 2
    jnew = gv[1:gv.shape[0]-1, 1:gv.shape[1]-1]
    cv2.imwrite('filter10.jpg', jnew)

task2_3.py

import cv2
import numpy as np

def task(img):
    filter = np.zeros((20, 20))
    jpg = cv2.imread(img, 0)
    rl = jpg.shape[0]
    cl = jpg.shape[1]
    ground = np.pad(jpg, ((10,10), (10,10)), 'constant')

    #因为filter是偶*偶的，所以每个xi都要被卷积四次
    gv = np.zeros((rl+2, cl+2))
    for ri in range(rl+1):
        for ci in range(cl+1):
            filter[:] = ground[ri:ri+20, ci:ci+20]
            gv[ri][ci] = gv[ri][ci+1] = gv[ri+1][ci] = gv[ri+1][ci+1] = (gv[ri][ci] + filter.mean()) / 2
    jnew = gv[1:gv.shape[0]-1, 1:gv.shape[1]-1]
    cv2.imwrite('filter20.jpg', jnew)

 task3_1.py

import cv2
import imutils

def task(img):
    cv2.namedWindow('rotate image', cv2.WINDOW_NORMAL)
    image = cv2.imread(img)
    rot = imutils.rotate(image, angle = 45)
    cv2.imshow('rotate image', rot)
    cv2.waitKey()

task3_2.py

import cv2
import imutils

def task(img):
    cv2.namedWindow('rotate image', cv2.WINDOW_NORMAL)
    image = cv2.imread(img)
    rot = imutils.rotate(image, angle = 90)
    cv2.imshow('rotate image', rot)
    cv2.waitKey()

（注：这一题除了使用cv2和imutils外，还可以使用Pillow库Image.rotate())

task4.py

import cv2
import numpy as np

def task(img):
    cv2.namedWindow('origin', cv2.WINDOW_NORMAL)
    cv2.namedWindow('filtered', cv2.WINDOW_NORMAL)
    image = cv2.imread(img)
    kernel = np.ones((3, 3), np.float32) / 9
    # kernel = np.ones((5, 5), np.float32) / 25
    # kernel = np.ones((7, 7), np.float32) / 49
    image_new = cv2.filter2D(image, -1, kernel)
    cv2.imshow('origin', image)
    cv2.imshow('filtered', image_new)
    cv2.waitKey()

• Do a basic implementation of JPEG:

1. Divide the image into non-overlapping 8x8 blocks.
2. Compute the DCT (discrete cosine transform) of each block. This is implemented in popular packages such as Matlab.
3. Quantize each block. You can do this using the tables in the video or simply divide each coefficient by N, round the result to the nearest integer, and multiply back by N. Try for different values of N.
4. You can also try preserving the 8 largest coefficients (out of the total of 8x8=64), and simply rounding them to the closest integer.
5. Visualize the results after inverting the quantization and the DCT.

task1.py

 1 import cv2
 2 import numpy as np
 3 
 4 def task(img):
 5     image = cv2.imread(img, 0) #第二个参数指定为0是为了以灰度模式读取图像
 6     rows = image.shape[0]
 7     cols = image.shape[1]
 8     image_G = np.pad(image, ((0, 8), (0, 8)))
 9     blocks = {}
10     count = 0
11     for i in range(0, rows, 8):
12         for j in range(0, cols, 8):
13             blocks[count] = image_G[i:i+8, j:j+8]
14             count += 1
15     print(blocks)

task2.py

 1 import cv2
 2 import numpy as np
 3 
 4 def task(img):
 5     image = cv2.imread(img, 0) #第二个参数指定为0是为了以灰度模式读取图像
 6     rows = image.shape[0]
 7     cols = image.shape[1]
 8     image_G = np.pad(image, ((0, 8), (0, 8)))
 9     image_DCT = image_G.copy()
10     for i in range(0, rows, 8):
11         for j in range(0, cols, 8):
12             block = image_G[i:i+8, j:j+8]
13             image_DCT[i:i+8, j:j+8] = cv2.dct(block.astype(np.float))
14     image_DCT = image_DCT[:rows, :cols]
15     print(image_DCT)