图像处理lab1

lzf 发布于

文章访问量

图像处理lab1

21371255 刘兆丰

1.Questions

1.1 Convolution

（1）

卷积的三个主要组成部分如下：
(i) 输入：卷积操作的输入是一个图像和一个称为卷积核或滤波器的小矩阵。图像通常表示为二维矩阵，每个元素表示一个像素的灰度值。
(ii) 变换（发生方式）：卷积操作是通过将卷积核与输入图像的每个位置进行元素乘法，并将乘积的总和作为输出的相应位置的像素值来实现的。卷积核通过在图像上滑动并与每个位置的像素进行乘法，以生成输出图像。
(iii) 输出：卷积操作的输出是一个新的图像，其中每个位置的像素值表示通过卷积操作从输入图像中提取的特征。

（2）

卷积操作与相关性操作的不同之处在于卷积操作使用卷积核的旋转180度的版本进行计算，而相关性操作则直接使用原始卷积核进行计算。卷积是线性位移不变的，意味着如果输入图像进行平移，输出图像也会相应平移。而相关性不具有这种性质，即相关性对输入图像的平移不具有等效性。

（3）

为了构建一个在卷积和相关性操作之间产生不同输出的情景，我们可以选择一个非对称的卷积核。例如：

1
2
3
kernel = [[1, 2, 1],
          [0, 0, 0],
          [-1, -2, -1]]

在卷积操作和相关性操作中，使用相同的输入图像和卷积核进行计算，然后比较它们的输出。以下为python代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
import numpy as np
from scipy.ndimage import convolve, correlate
import matplotlib.pyplot as plt
import matplotlib.image as mpimg

# 定义卷积核
kernel = np.array([[1, 2, 1],
                   [0, 0, 0],
                   [-1, -2, -1]])

# 定义输入图像
# image = np.array([[0, 0, 0, 0, 0],
#                   [0, 0, 0, 0, 0],
#                   [0, 255, 255, 255, 0],
#                   [0, 0, 0, 0, 0],
#                   [0, 0, 0, 0, 0]])
image_path = 'saul_goodman.png'  # 替换为您自己图像的路径
image = mpimg.imread(image_path)
print(image.shape)  #shape：  高x长 通道数

num_channels = image.shape[2]
kernel = np.tile(kernel[:, :, np.newaxis], (1, 1, num_channels))
#我们使用np.tile函数对卷积核进行复制。第一个参数是要复制的数组，
# 即卷积核。第二个参数是一个元组，指定每个维度上的复制次数。
# 在这里，我们将卷积核在第一个维度和第二个维度上复制1次，而在第三个维度上复制num_channels次。
# 这样，我们的卷积核将在通道维度上进行复制以适应输入图像的通道数。


# 执行卷积操作
convolved_image = convolve(image, kernel)

# 执行相关性操作
correlated_image = correlate(image, kernel)



# 显示输入图像
plt.figure()
plt.imshow(image)
plt.title('Input Image')

# 显示卷积操作的输出图像
plt.figure()
plt.imshow(convolved_image)
plt.title('Convolved Image')

# 显示相关性操作的输出图像
plt.figure()
plt.imshow(correlated_image)
plt.title('Correlated Image')

# 显示图像
plt.show()

以下为代码执行结果：

（a）输入图像：

image-20240406123249928.png

（b）卷积后图像：

image-20240406123259511.png

（c）相关性后图像：

image-20240406123309467.png

1.2 questions

高通滤波器（High Pass Filter）和低通滤波器（Low Pass Filter）是两种常见的图像滤波器，它们在图像处理和信号处理中具有不同的作用和效果。

（1）高通滤波器（High Pass Filter）：

高通滤波器允许高频信息通过，削弱或滤除低频信息。
它对图像中的边缘、细节和纹理等高频部分更为敏感，可以增强图像的边缘和细节。
高通滤波器通常用于图像增强、边缘检测和特征提取等应用。
在频域上，高通滤波器会保留图像的高频分量，而减弱或抑制低频分量。
（2）低通滤波器（Low Pass Filter）：

低通滤波器允许低频信息通过，削弱或滤除高频信息。
它对图像中的平滑区域和慢变化部分更为敏感，可以平滑图像并减少噪声。
低通滤波器通常用于图像平滑、去噪和模糊化等应用。
在频域上，低通滤波器会保留图像的低频分量，而减弱或抑制高频分量。

(a) A

(b)B

(c)C

(d)B

(e)A

2.Programming

2.1 Template Matching with Cross-correlation

2.1.1 cross-correlation

结果：

image-20240406183037825.png

使用原生的template，识别准确率会降低

2.1.2 zero-mean cross-correlation

结果：

image-20240406183009566.png

check_product_on_shelf():

image-20240406175155563.png

2.1.3 Normalized cross-correlation

change_in_lighting_condition():

image-20240406183143020.png

final_normalized_cross_correlation():

image-20240406183256083.png

2.2 Hybrid images

report

(1) my_filter:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
def my_imfilter(image, kernel):
    filtered_image = np.zeros(image.shape)

    Hi, Wi, Di = image.shape
    Hk, Wk = kernel.shape

    # raise error for even dimension
    for dim in kernel.shape:
        if dim % 2 == 0:
            raise ValueError("Kernel dimension must be odd!")

    # 计算 padding 的大小
    pad_h = Hk // 2
    pad_w = Wk // 2

    # 对输入图像进行边缘填充
    if len(image.shape)==2:
        padded_image = np.pad(image, ((pad_h, pad_h), (pad_w, pad_w)), mode='constant')
    elif len(image.shape)==3:
        padded_image = np.pad(image, ((pad_h, pad_h), (pad_w, pad_w),(0,0)), mode='constant')

    # color or grayscale
    # if len(image.shape) == 3:
    #     num_channels = image.shape[2]
    #     kernel = np.tile(kernel[:, :, np.newaxis], (1, 1, num_channels))


    # 翻转kernel
    flipped_kernel = np.flip(kernel)

    # 遍历图像的每个像素
    if Di:
        for k in range(Di):
            for i in range(Hi):
                for j in range(Wi):
                    # 提取当前像素的邻域 ---- 用于卷积相乘
                    neighborhood = padded_image[i:i + Hk, j:j + Wk, k]

                    # 计算加权邻域和
                    weighted_sum = np.sum(neighborhood * flipped_kernel)

                    # 将计算结果赋值给输出图像的对应位置
                    filtered_image[i, j, k] = weighted_sum
    else:
        for i in range(Hi):
            for j in range(Wi):
                # 提取当前像素的邻域 ---- 用于卷积相乘
                neighborhood = padded_image[i:i + Hk, j:j + Wk]

                # 计算加权邻域和
                weighted_sum = np.sum(neighborhood * kernel)

                # 将计算结果赋值给输出图像的对应位置
                filtered_image[i, j] = weighted_sum

    filtered_image = np.clip(filtered_image, -1, 1)
    return filtered_image

结果：

identity_image

blur_image

large_blur_image

laplacian_image

sobel_image

high_pass_image

（2）gen_hybrid_image
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
def gen_hybrid_image(image1, image2, cutoff_frequency):
    """
     Inputs:
     - image1 -> The image from which to take the low frequencies.
     - image2 -> The image from which to take the high frequencies.
     - cutoff_frequency -> The standard deviation, in pixels, of the Gaussian
                           blur that will remove high frequencies.

     Task:
     - Use my_imfilter to create 'low_frequencies' and 'high_frequencies'.
     - Combine them to create 'hybrid_image'.
    """

    assert image1.shape[0] == image2.shape[0]
    assert image1.shape[1] == image2.shape[1]
    assert image1.shape[2] == image2.shape[2]

    # Steps:
    # (1) Remove the high frequencies from image1 by blurring it. The amount of
    #     blur that works best will vary with different image pairs
    # generate a 1x(2k+1) gaussian kernel with mean=0 and sigma = s, see https://stackoverflow.com/questions/17190649/how-to-obtain-a-gaussian-filter-in-python
    s, k = cutoff_frequency, cutoff_frequency*2
    probs = np.asarray([exp(-z*z/(2*s*s))/sqrt(2*pi*s*s) for z in range(-k,k+1)], dtype=np.float32)
    kernel = np.outer(probs, probs)

    # Your code here:
    low_frequencies = my_imfilter(image1, kernel)
    # Replace with your implementation

    # (2) Remove the low frequencies from image2. The easiest way to do this is to
    #     subtract a blurred version of image2 from the original version of image2.
    #     This will give you an image centered at zero with negative values.
    # Your code here #
    high_frequencies = image2 - my_imfilter(image2,kernel) # Replace with your implementation

    # (3) Combine the high frequencies and low frequencies
    # Your code here #
    hybrid_image = low_frequencies + high_frequencies # Replace with your implementation

    # (4) At this point, you need to be aware that values larger than 1.0
    # or less than 0.0 may cause issues in the functions in Python for saving
    # images to disk. These are called in proj1_part2 after the call to 
    # gen_hybrid_image().
    # One option is to clip (also called clamp) all values below 0.0 to 0.0, 
    # and all values larger than 1.0 to 1.0.
    hybrid_image = np.clip(hybrid_image, 0, 1)

    return low_frequencies, high_frequencies, hybrid_image

结果：

high_frequencies

high_frequencies

hybrid_image

hybrid_image_scales

（3）Extra requirements

my_imfilter_fft

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
def my_imfilter_fft(image, kernel):
    """
    Your function should meet the requirements laid out in the extra credit section on
    the project webpage. Apply a filter (using kernel) to an image. Return the filtered image.
    Inputs
    - image: numpy nd-array of dim (m,n) or (m, n, c)
    - kernel: numpy nd-array of dim (k, l)
    Returns
    - filtered_image: numpy nd-array of dim of equal 2D size (m,n) or 3D size (m, n, c)
    Errors if:
    - filter/kernel has any even dimension -> raise an Exception with a suitable error message.
    """
    filtered_image = np.zeros(image.shape)

    # Check for even dimension
    for dim in kernel.shape:
        if dim % 2 == 0:
            raise ValueError("Kernel dimension must be odd!")

    # Padding parameters
    Hi, Wi, Di = image.shape
    Hk, Wk = kernel.shape
    pad_h = Hk // 2
    pad_w = Wk // 2

    # Pad image
    if len(image.shape) == 2:
        padded_image = np.pad(image, ((pad_h, pad_h), (pad_w, pad_w)), mode='constant')
    elif len(image.shape) == 3:
        padded_image = np.pad(image, ((pad_h, pad_h), (pad_w, pad_w), (0, 0)), mode='constant')

    # Perform FFT on image and kernel
    fft_image = np.fft.fftshift(np.fft.fft2(padded_image, axes=(0, 1)))
    fft_kernel = np.fft.fftshift(np.fft.fft2(kernel, s=image.shape[:2], axes=(0, 1)))

    # Filter in the frequency domain
    filtered_fft = fft_image * fft_kernel

    # Perform inverse FFT
    filtered_image = np.fft.ifft2(np.fft.ifftshift(filtered_fft, axes=(0, 1)), axes=(0, 1)).real

    # Crop the filtered image to remove padding
    filtered_image = filtered_image[pad_h:-pad_h, pad_w:-pad_w]

    # Clip values outside the valid range [-1, 1]
    filtered_image = np.clip(filtered_image, -1, 1)

    return filtered_image
Morty

Morty

我阐释你的梦

7
2
6
TOC
  1. 1. 图像处理lab1
    1. 1.1. 2.Programming
NOTICE

看到这条通知的请立即微信转账50块，收到扣1

CATEGORYS
TAGS
CV Parallel Programming RAID gpt hexo mamba