大疆算法笔试题目解析（一）图像处理

一、图像处理（100分）

中值滤波（median filter）是图像处理中广泛使用的一种滤波器，其原理是对图像f中的每一个像素(i,j),i=1,2,...,H,j=1,2,...,W,用它的方形邻域中的所有像素的中位数来替换它的像素值，其中r被称为该邻域的半径。对一维图像，方形邻域退化为一个闭区间：

1.(20分）试给出对8比特一维灰度图像f(i),i=1,2,...,H进行中值滤波的C/C++算法，并分析算法的时间复杂度。注意该图像只有一列像素。

算法输入：8比特一维灰度图像f,高为H.

算法输出：滤波后的8比特一维灰度图像g.高为H.

函数声明：void medianFilter1D(uchar* f, uchar* g, int H);

#include <iostream>
#include <vector>
#include <algorithm>

typedef unsigned char uchar;

void medianFilterID(uchar* f, uchar* g, int H, int radius) {
    int windowSize = 2 * radius + 1; // Size of the square window

    for (int i = 0; i < H; ++i) {
        std::vector<uchar> neighborhood;

        for (int j = -radius; j <= radius; ++j) {
            int colIndex = i + j;

            // Handle boundary cases by clamping to valid pixel indices
            colIndex = std::max(0, std::min(colIndex, H - 1));
            neighborhood.push_back(f[colIndex]);
        }

        // Sort the neighborhood to find the median
        std::sort(neighborhood.begin(), neighborhood.end());

        // Pick the median value
        g[i] = neighborhood[windowSize / 2];
    }
}

int main() {
    int H = 10; // Height of the image
    int radius = 1; // Neighborhood radius

    uchar input[] = {100, 80, 110, 90, 95, 105, 102, 98, 100, 105};
    uchar output[H];

    medianFilterID(input, output, H, radius);

    std::cout << "Original Image: ";
    for (int i = 0; i < H; ++i) {
        std::cout << static_cast<int>(input[i]) << " ";
    }

    std::cout << "\nFiltered Image: ";
    for (int i = 0; i < H; ++i) {
        std::cout << static_cast<int>(output[i]) << " ";
    }

    return 0;
}

时间复杂度O(n) 

---

2.(20分)试给出对8比特二维灰度图像f(i,j)i=1,2,...,H,j=1,2,...,W 进行中值滤波的算法(写出伪码即可)，并分析算法的时间复杂度。

// 输入：8比特二维灰度图像f，高度H，宽度W，邻域半径r
// 输出：滤波后的图像g

for i from r to H - r:
    for j from r to W - r:
        // 构建方形邻域
        create neighborhood
        for x from -r to r:
            for y from -r to r:
                add f(i + x, j + y) to neighborhood

        // 对邻域内的像素值进行排序
        sort neighborhood

        // 取邻域中的中值
        g(i, j) = neighborhood[(2 * r + 1) * (2 * r + 1) / 2]

时间复杂度O(n^2)

---

3.(20分)(椒盐噪声去除)椒盐噪声也称为脉冲噪声，是图像中经常见到的一种噪声,是一种随机出现的白点或者黑点，在8比特灰度图中像素值分别为255和0.试给出一个去除或减弱灰度图像中椒盐噪声，同时尽量保持图像细节的实际算法(写出伪码即可)，并分析时间复杂度。

// 输入：8比特灰度图像f，高度H，宽度W，邻域半径r
// 输出：去噪后的图像g

for i from r to H - r:
    for j from r to W - r:
        // 构建方形邻域
        create neighborhood
        for x from -r to r:
            for y from -r to r:
                add f(i + x, j + y) to neighborhood

        // 对邻域内的像素值进行排序
        sort neighborhood

        // 取邻域中的中值
        median = neighborhood[(2 * r + 1) * (2 * r + 1) / 2]

        // 判断当前像素是否为椒盐噪声
        if f(i, j) == 0 or f(i, j) == 255:
            g(i, j) = median  // 用中值替代椒盐噪声像素
        else:
            g(i, j) = f(i, j) // 保留原像素值

时间复杂度O(n^2)

---

4.(40分)(加权中值滤波)传统中值滤波的有个弊端:它对所有邻域内像素的重视程度是相等的，这会导致滤波后的图像丢失一些细节。针对这个问题,加权中值滤波(weighted median filter)被提出。现在考虑一维的加权中值滤波。它的原理是，根据邻域像素j与目标像素i的像素值差异对邻域像素j进行加权，然后再计算邻域内所有像素的加权中值.令像素i的邻域内像素值q的加权分布为

 其中f(j)为像素j的像素值。为真值函

数，当x为真时= 1:当x为假时= 0;则加权中值p*为满足式(1)的最小p值. 

                                         

例如，假设某像素点的邻域中有 7个像素，分别为{0,2,3,4,5,7,9}。则在未加权时的中值为4;如果这7个邻域像素对应的权重分别为{0.5,0.5,0.5,.5,0,1,1},则中值为5.

        特别地，考虑如下形式的权重w(i,j):

                              

其中，是以k为中心，r为半径的一个邻域，N =(2r + 1)为邻域中总像素数，分别为中像素的均值和方差，为一个很小的正常数
（1)(20分)试证明:按公式(2)所给权值，对任意序列p，加权和可以表达为的形式，其中

                  

                ​​​​​​​  

其中

反证法：

同理可得b(i)

此时形式已经和p'(i)大致相同，接下来看求和符号这里的求和顺序为k->j>i

而由w(i,j)决定的式子求和为k->i&j,j->i,最终结果都是i

2).(20 分)试给出对 8 比特一维图像f(i),i= 1,2,...,H，按公式(2)定义的权值进行加权中值滤波的算法(写出伪码即可)，并分析时间复杂度

Input: 一维图像 f(i)（长度为 H）、半径 r、常数 epsilon

Function weightedMedianFilter(f, H, r, epsilon):
    Initialize an empty array to store the filtered result: filteredImage
    
    for i = 1 to H do:
        // Compute the range of the neighborhood
        start_index = max(1, i - r)
        end_index = min(H, i + r)
        
        // Create an array to store the weighted values
        weighted_values = []
        
        for j = start_index to end_index do:
            // Compute the weight for the pair (i, j)
            weight = 0
            common_neighbors = 0
            for k = max(start_index, j - r) to min(end_index, j + r) do:
                weight += (1 + ((f[i] - mean(f[start_index:end_index])) * (f[j] - mean(f[start_index:end_index]))) / (variance(f[start_index:end_index]) + epsilon))
                common_neighbors += 1
                
            // Compute the weighted value and store it
            weighted_value = weight / (common_neighbors * common_neighbors)
            weighted_values.append(weighted_value)
        
        // Sort the weighted values
        sorted_values = sort(weighted_values)
        
        // Compute the median index
        median_index = (end_index - start_index + 1) / 2
        
        // Assign the median value to the filtered image
        filteredImage[i] = sorted_values[median_index]
    
    return filteredImage

// Call the function with the input image and parameters
filtered_image = weightedMedianFilter(f, H, r, epsilon)

时间复杂度：O(n),实际循环次数为H*(2r+1)^2