[Computer Vision/OpenCV] 14. Image Denoising

오늘 포스팅에서는 대표적인 Degradation model 인 salt and pepper 와 gaussian noise를 없애는 denoising방식에 대해서 알아보고 코드 실습을 한다.

 

1. Salt & Pepper Noise

Salt and Pepper noise는 렌덤한 위치에 생성되는 점 형태의 노이즈이다.

intensity 가 255 도는 0인 픽셀이 생성되는데, 이는 주로 센서의 오류나 전송 중에 생긴 여러 문제로 인해 발생한다.

 

그럼 이 노이즈는 어떻게 denoising할 수 있을까?

 

1.1. Low-pass Filter

이 노이즈의 경우  low pass filter를 사용해서 고주파 잡음을 제거하는 방식으로 denoising 할 수 있다.

예를 들면, Uniform Averaging Filter나 Gaussian Averaging Filter같은 것으로 제거할 수 있다. 

근데 생각보다 effective하지는 않다.

average filter로 gaussian filter를 사용했다.

 

이 방식이 효과적이지 않은 이유는 filter의 특징을 생각해보면 알 수 있다.

Averaging filter의 경우 필터 마스크를 이용해서 마스크 만큼의 픽셀값들의 가중 합을 통해서 구하게 된다.

 

따라서 여기에 들어가는 픽셀 값이 0이나 255처럼 극단적인 값이 갑자기 들어가면, 

필터링의 결과도 그만큼 크게 영향을 받는다.

 

그러니 Averaging 방식을 사용하는 필터는 큰 효과가 없는 것이다.

 

1.2. Median Filter

median filter라는 것은 Aberaging방식과 다르게,

커널 윈도우만큼의 픽셀값들 중 중앙값으로 필터링 하는 방식들을 말한다.

 

Salt and Pepper noise는 극단적인 값을 가지고 있어서 아웃라이어 노이즈라고 할 수 있는데

중앙값을 활용하면 이들을 무시할 수 있기 때문에 Denoising에 큰 효과를 볼 수 있다.

 

1.3. Outlier Rejection Method

Median filter의 경우 좋은 효과를 보이지만, 해당 픽셀의 값들을 정렬하고, 선택하는 과정을 거쳐야 한다.

따라서 Bruteforce 방식으로 동작하므로, 괸장히 느리다는 단점이 있다. 

이 단점을 보완하기 위해서 나온 것이 Outlier Rejection Method이다.

 

Salt and Pepper의 경우 아웃라이어라고 볼 수 있다. 

아웃라이어 픽셀들은 이웃 픽셀들과 달리 굉장히 다른 픽셀값을 가지고 있다는 점을 고려하는 방식이다.

Outlier Rejection  방법은 필터링 대상 픽셀(중심 픽셀)과 주변 이웃 픽셀들 간의 통계적 차이를 활용하여,

중심 픽셀이 주변과 지나치게 다른 경우에만 보정한다.

 

과정은 다음과 같다.

1. 자신을 제외한 주변 픽셀들의 평균 M을 얻는다

2. 자신과 M 사이의 차이가 임계값 D 이상이라면 이상치라고 판단한다.

3. 이상치 데이터는 M값으로 대체한다.

 

 

 

1.4. OpenCv C++ code

위의 실험에 사용된 코드는 다음과 같다.

#include <opencv2/opencv.hpp>
#include <iostream>
#include <random>
#include <numeric>

using namespace cv;
using namespace std;


// Salt and Pepper Noise 추가
void addSaltAndPepperNoise(cv::Mat& image, double amount) {
    srand(42); // 고정 시드

    //전체 픽셀수를 고려해서 amount만큼의 노이즈 추가
    int totalPixels = image.rows * image.cols;
    int numSalt = static_cast<int>(amount / 2 * totalPixels);
    int numPepper = static_cast<int>(amount / 2 * totalPixels);

	// Salt 노이즈 추가
    for (int i = 0; i < numSalt; ++i) {
        int y = rand() % image.rows;
        int x = rand() % image.cols;
        image.at<uchar>(y, x) = 255; // salt
    }

	// Pepper 노이즈 추가
    for (int i = 0; i < numPepper; ++i) {
        int y = rand() % image.rows;
        int x = rand() % image.cols;
        image.at<uchar>(y, x) = 0; // pepper
    }
}

// Gaussian 필터링 (평균 필터보다 더 부드럽게 처리됨)
Mat averageFilter(const Mat& input, int ksize) {
    Mat output;
    // sigmaX는 자동 추정된다. ksize는 홀수여야 함
    GaussianBlur(input, output, Size(ksize, ksize), 0);
    return output;
}

// 중앙값 필터링 (Rank-order 필터의 대표적인 예)
Mat medianFilter(const Mat& input, int ksize) {
    Mat output;
    medianBlur(input, output, ksize); // ksize는 홀수만 가능
    return output;
}
// Outlier Rejection 필터링
Mat outlierRejectionFilter(const Mat& input, int ksize, int threshold = 35) {
    Mat output = input.clone();
    int half = ksize / 2;

    for (int y = half; y < input.rows - half; ++y) {
        for (int x = half; x < input.cols - half; ++x) {
            std::vector<uchar> neighbors;
            for (int j = -half; j <= half; ++j) {
                for (int i = -half; i <= half; ++i) {
                    if (i == 0 && j == 0) continue; // center 제외
                    neighbors.push_back(input.at<uchar>(y + j, x + i));
                }
            }
            double mean = accumulate(neighbors.begin(), neighbors.end(), 0.0) / neighbors.size();
            uchar center = input.at<uchar>(y, x);
            if (abs(center - mean) > threshold) {
                output.at<uchar>(y, x) = static_cast<uchar>(mean);
            }
        }
    }

    return output;
}

int main() {
    // 그레이스케일 이미지 로드
    cv::Mat img = cv::imread("lena.jpg", cv::IMREAD_GRAYSCALE);
    if (img.empty()) {
        std::cerr << "이미지를 불러올 수 없습니다." << std::endl;
        return -1;
    }

    // 노이즈 추가
    Mat noisy = img.clone();
    addSaltAndPepperNoise(noisy, 0.10); // 10% 노이즈

    // 필터링
    Mat avgFiltered = averageFilter(noisy, 3);
    Mat medFiltered = medianFilter(noisy, 3);
    Mat outlierFiltered = outlierRejectionFilter(noisy, 3);

    // 결과 출력
    imshow("Original", img);
    imshow("Noisy", noisy);
    imshow("Average Filter", avgFiltered);
    imshow("Median Filter", medFiltered);
    imshow("Outlier Rejection", outlierFiltered);
    waitKey(0);

    return 0;
}

 

2. Gaussian Noise

Gaussian Noise는 이미지에 추가되는 확률적 노이즈 중 하나로,

픽셀 값에 정규분포(가우시안 분포)를 따르는 무작위 값이 더해지는 형태이다.

 

+) AWGN

이 중에서도 평균이 0이고, 모든 픽셀에 독립적으로 동일한 확률로 노이즈가 적용되는

Additive White Gaussian Noise (AWGN) 모델은 가장 일반적으로 사용되는 가정이다.

AWGN 의 중요한 특성은 평균이 0이라는 점이다.

이 성질은 동일한 이미지에 서로 다른 Gaussian 노이즈가 추가된 여러 관측값이 존재할 경우,

그 평균을 취함으로써 노이즈를 상쇄시키고 원본 이미지를 복원할 수 있게 해준다.

 

예를 들면 다음과 같다.

100장의 이미지 I+가우시안 노이즈 데이터가 있다고 하자. 이를 수식으로 표현하면 다음과 같다.

 

이 100장의 노이즈 이미지를 평균을 낸다면 다음과 같이 될 것이다.

 

근데 노이즈 N 은 평균이 0인 가우시안 분포를 따르므로,  저 노이즈 부분은 근사적으로 0 이 될 것이다.

 

따라서 같은 이미지에 Gaussian 노이즈가 추가된 다수의 관측이 존재할 경우, 평균을 통해 노이즈를 제거하고 원본 이미지에 수렴할 수 있다는 것이다. 

 

AWGN을 추가했다. 아래의 denoising에 이 노이즈 이미지를 사용할 것이다.

 

 

그럼 이제 가우시안 계열 노이즈를 denoising하는 필터링 방법을 살펴보자.

 

2.1. Averaging Filter 계열

Gaussian filter나, Uniform mean Filter 같은 Averaging filter들을 사용하여 Denoising할 수 있다.

가장 단순하게 구현할 수 있어서 좋지만, averaging과정 중에서 세부 정보가 손실되는 것이 많을 수 있다. 

만약 필터의 크기가 3x3처럼 작은 경우라면, denoising이 잘 안될 수 있고,

그렇다고 필터의 크기를 키우면 너무 Blurred된다는 것이 큰 단점이다.

완쪽아 가우시안 노이즈 적용 이미지, 오른쪽이 Denoising결과이다.

 

 

 

 

2.2. Bilateral Filtering

Uniform 필터는 픽셀간의 거리를 고려하지 않지만, 가우시안 필터는 픽셀간의 거리를 고려한다는 점이 장점이다.

그러나 가우시안 필터의 문제점은 오버스무딩 현상이 발생한다는 것이다.

픽셀간의 거리를 고려하지만, Intensity의 거리를 고려하지는 않기 때문이다.

 

Bilatteral Filtering은 가우시안 필터링에 intensity도 함께 고려하는 방식이다. 

즉, spatial distance와 intensity distance를 모두 고려한다. 

따라서 필터링 커널의 수식은 다음과 같다.

 

즉, 공간적으로 가까울 수록, 픽셀밝기가 유사할 수록 영향을 크게 주는 방향으로 설계되었다.

 

완쪽의 노이즈를 Bilateral filter를 적용해 제거하는 예시.

 

+) Gaussian filter vs Bilateral filter

두 필터의 특징을 비교하면 다름과 같다.

 

가우시안 필터는

거리 기반 가중 평균을 사용한다.

노이즈 제거 성능이 높지만, 엣지 보존 능력이 떨어진다.

 

Bilateral filter는 

거리와 밝기 기반 가중 평균 필터이다.

노이즈 제거 성능도 높고, 엣지도 잘 보존하는 균형잡힌 필터링 방식이다.

다만 거리에 추가로 밝기 거리까지 계산해야 하기 때문에 연산복잡도가 매우 크다

 

두 필터에 spatial sigma를 동일하게 둘 경우 둘의 denoising은 다음처럼 된다.

미세하게 bilateral 쪽이 더 선명하다

 

 

2.3. OpenCV C++ Code

위의 실습은 아래 코드를 통해서 수행되었다.

#include <opencv2/opencv.hpp>
#include <iostream>
#include <random>

using namespace std;

// Gaussian Noise 추가 함수
void addGaussianNoise(cv::Mat& image, double mean = 0.0, double stddev = 20.0) {
    cv::Mat noise(image.size(), CV_32FC1);
    cv::randn(noise, mean, stddev); // 평균, 표준편차

    cv::Mat image32f;
    image.convertTo(image32f, CV_32FC1); // float 변환
    image32f += noise;

    cv::Mat noisyImage;
    cv::normalize(image32f, image32f, 0, 255, cv::NORM_MINMAX); // 값 범위 정규화
    image32f.convertTo(noisyImage, CV_8UC1); // 다시 uchar로

    image = noisyImage.clone();
}

// 메인 함수
int main() {
    // 그레이스케일 이미지 로드
    cv::Mat img = cv::imread("lena.jpg", cv::IMREAD_GRAYSCALE);
    if (img.empty()) {
        cerr << "이미지를 불러올 수 없습니다." << endl;
        return -1;
    }

    // 원본 복사 후 Gaussian 노이즈 추가
    cv::Mat noisy = img.clone();
    addGaussianNoise(noisy);

    // 설정값 (공간 시그마)
    int kernelSize = 5;         // Gaussian 커널 크기 (홀수)
    double sigmaSpace = 2.0;    // 공간 시그마 (두 필터에 동일 적용)
    double sigmaColor = 75.0;   // Bilateral 필터의 밝기 시그마


    // Gaussian 필터 적용
    cv::Mat gaussianFiltered;
    cv::GaussianBlur(noisy, gaussianFiltered, cv::Size(kernelSize, kernelSize), sigmaSpace);

    // Bilateral 필터 적용
    cv::Mat bilateralFiltered;
    cv::bilateralFilter(noisy, bilateralFiltered, kernelSize, sigmaColor, sigmaSpace);

    // 결과 출력
    cv::imshow("Original", img);
    cv::imshow("Gaussian Noise", noisy);
    cv::imshow("Gaussian Filter", gaussianFiltered);
    cv::imshow("Bilateral Filter", bilateralFiltered);

    cv::waitKey(0);
    return 0;
}