[Computer Vision/OpenCV] 11. Spatial Filtering

 

 

이번 포스팅은 여러가지 필터에 대해서 알아보고 OpenCV로 직접 실습하는 내용을 담았다.

먼저 Low-pass, High-pass filter가 뭔지 알아보고

Uniform Mean, Gaussian, Sobel, Laplacian filter에 대해서 알아본다.

 

저번 포스팅에서 필터링 연산에 대해서 가볍게 다루었기 때문에 기초적인 연산 방법 정리는 제외하였다. 그래도 내가 읽으려고 쓰는 글이니까 최대한 쉽게... 쓰는 중이다.

https://he-kate1130.tistory.com/139

[Computer Vision/OpenCV] 10. Spatial Filtering & Convolution 개념

 

 

 

1. Low/High-pass Filters

영상에서 주파수는 이미지 내부에서 반복적으로 나타나는 패턴이나 변화의 정도를 의미한다.

간단하게 얼마나 자주 주변 픽셀의 intensity가 변하느냐를 의미한다고 이해할 수 있다.

 

높은 frequency라 하면 파장이 짧은, 변화가 급격한 영역을 의미한다.

이미지에서 물체간의 경계선부분, 작은 디테일들처럼 변화가 큰 곳이 고주파 성분을 가졌다.

낮은 frequency라 하면 파장이 긴, 변화가 완만하고 부드러운 영역을 의미한다.

이미지에서의 큰 특징이나, 전체적인 밝기 같은 것들이 낮은 주파수 성분을 가졌다.

 

이미지에서 어떤 부분을 강조해 보고싶냐에 따라서 Filter의 종류를 다르게 사용하여 이미지를 처리한다.

낮은 주파수부분을 보고싶으면 Low-pass Filter를 사용한다.

Low-pass Filter: Uniform Mean Filter, Gaussian Filter ...

높은 주파수 부분을 보고 싶으면 High-pass Filter를 사용한다.

High-pass Filter: Sobel Filter, Laplacian Filter ...

 

2. Uniform Mean Filter

Low-pass Filter 중에서 가장 간단한 형태를 가진 필터다.

필터 커널은 다음처럼 생겼다,

각 element를 모두 1로 하고, normalize한다 (필터 커널의 합이 항상 1이 되어야 하므로)

이런식으로 커널전체 합으로 나누어서 normalize하는 커널들을 Average(Mean) Filter 라고 하는데, 얘는 모든 값이 1이므로 Uniform Mean Filter라고 부른다.

필터를 적용하면 저렇게 이미지가 블러되는 현상이 나타난다.

Uniform Mean Filtering의 장점은 Separable Filter라서 두개 벡터의 곱으로 다음처럼 분리가 가능하다는 것이다.

필터링 런타임에 엄청 도움된다..!!

Convolution 연산은 결합법칙이 성립하기 때문에 가능한 이야기다.

 

 

2. 1. Uniform Mean Filter OpenCv

 

 

이미지 boundary부분은 zero padding을 사용하였다. 커널이 이미지 밖으로 삐져나가기 때문에 그 부분의 값은 0으로 계산하였다.

그래서 이미지의 boundary의 색이 좀 어두운 것을 볼 수 있다.

 

학습을 위해 직접 Uniform Mean Filter 구현을 해보았다. 구현은 separable방식으로 해두었다

 

직접 구현 헤더 : filter.h

#pragma once

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

using namespace cv;
using namespace std;

#define IM_TYPE CV_8UC1  //기본 8bit grayscale

#if (IM_TYPE == CV_8UC1)
typedef uchar G;
#elif (IM_TYPE == CV_16UC1)
typedef ushort G;
#elif (IM_TYPE == CV_32FC1)
typedef float G;
#endif
// =======================================
// 필터 함수 선언
// =======================================

// Uniform Mean Filter 구현. Separable Filter로 만든다.
Mat UniformMeanFilter(const Mat input, int nx, int ny, const char* opt) {
    int row = input.rows;
    int col = input.cols;

    int kernel_x = 2 * nx + 1;
    int kernel_y = 2 * ny + 1;
    float kx = 1.0f / kernel_x;
    float ky = 1.0f / kernel_y;

    Mat temp = Mat::zeros(row, col, input.type());   // 가로 필터링 결과
    Mat output = Mat::zeros(row, col, input.type()); // 세로 필터링 결과

    // --- Pass 1: 가로 방향 필터링 ---
    for (int i = 0; i < row; i++) {
        for (int j = 0; j < col; j++) {
            float sum = 0.0f;
            float weight = 0.0f;

            for (int b = -nx; b <= nx; b++) {
                int jj = j + b;

                if (!strcmp(opt, "zero-paddle")) {
                    if (jj >= 0 && jj < col)
                        sum += kx * (float)input.at<G>(i, jj);
                }
                else if (!strcmp(opt, "mirroring")) {
                    if (jj < 0) jj = -jj;
                    else if (jj >= col) jj = 2 * col - jj - 2;
                    sum += kx * (float)input.at<G>(i, jj);
                }
                else if (!strcmp(opt, "adjustkernel")) {
                    if (jj >= 0 && jj < col) {
                        sum += kx * (float)input.at<G>(i, jj);
                        weight += kx;
                    }
                }
            }

            if (!strcmp(opt, "adjustkernel") && weight != 0)
                temp.at<G>(i, j) = (G)(sum / weight);
            else
                temp.at<G>(i, j) = (G)(sum);
        }
    }

    // --- Pass 2: 세로 방향 필터링 ---
    for (int i = 0; i < row; i++) {
        for (int j = 0; j < col; j++) {
            float sum = 0.0f;
            float weight = 0.0f;

            for (int a = -ny; a <= ny; a++) {
                int ii = i + a;

                if (!strcmp(opt, "zero-paddle")) {
                    if (ii >= 0 && ii < row)
                        sum += ky * (float)temp.at<G>(ii, j);
                }
                else if (!strcmp(opt, "mirroring")) {
                    if (ii < 0) ii = -ii;
                    else if (ii >= row) ii = 2 * row - ii - 2;
                    sum += ky * (float)temp.at<G>(ii, j);
                }
                else if (!strcmp(opt, "adjustkernel")) {
                    if (ii >= 0 && ii < row) {
                        sum += ky * (float)temp.at<G>(ii, j);
                        weight += ky;
                    }
                }
            }

            if (!strcmp(opt, "adjustkernel") && weight != 0)
                output.at<G>(i, j) = (G)(sum / weight);
            else
                output.at<G>(i, j) = (G)(sum);
        }
    }

    return output;
}

 

OpenCV 함수 사용

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

using namespace cv;
using namespace std;

// 직접 구현한 필터 함수 포함된 헤더
#include "filter.h"

int main() {
    Mat src = imread("lena.jpg", IMREAD_GRAYSCALE);
    if (src.empty()) {
        cout << "이미지를 불러올 수 없습니다." << endl;
        return -1;
    }

    int nx = 3;  // 가로 방향 절반 크기 → 전체 커널 크기: 7
    int ny = 3;  // 세로 방향 절반 크기 → 전체 커널 크기: 7

    // 직접 구현한 필터 (zero-padding 방식), separable filter구현
    Mat custom_filtered = UniformMeanFilter(src, nx, ny, "zero-paddle");
    
    // OpenCV sepFilter2D 사용, separable filter
    int kernel_x = 2 * nx + 1;
    int kernel_y = 2 * ny + 1;
    Mat kernelX = Mat::ones(1, kernel_x, CV_32F) / static_cast<float>(kernel_x);
    Mat kernelY = Mat::ones(kernel_y, 1, CV_32F) / static_cast<float>(kernel_y);

    Mat sep_filtered;
    sepFilter2D(src, sep_filtered, -1, kernelX, kernelY, Point(-1, -1), 0, BORDER_CONSTANT);

    // OpenCV boxFilter 사용
    Mat box_filtered;
    boxFilter(src, box_filtered, -1, Size(kernel_x, kernel_y), Point(-1, -1), true, BORDER_CONSTANT);

    // OpenCV blur 사용: 얘는 Border Default 사용
    Mat blur_filtered;
    blur(src, blur_filtered, Size(kernel_x, kernel_y));

    
    // 결과 출력
    imshow("Original", src);
    imshow("Custom Uniform Mean Filter", custom_filtered);
    imshow("OpenCV sepFilter2D", sep_filtered);
    imshow("OpenCV boxFilter", box_filtered);
    imshow("OpenCV blur", blur_filtered);


    waitKey(0);

    return 0;
}

 

3. Gaussian Filter

가우시안 필터는 정규분포를 이용한 필터링이다.

 

문제는 우리가 사용하는 필터는 크기가 정해져 있다. 아까의 Uniform Mean Filter는 3x3짜리로 만들어서 보았다.

근데, 가우시안 분포는 $(-\mathrm{\infty },\mathrm{\infty })$ 에서의 적분값이 1이 된다.

따라서 가우시안으로만 커널을 만들면 적분값이 1이 되지 않는다. 그래서 우리는 필터의 적분값으로 한번 normalize해둬야 한다.

mean = 0인 경우(zero mean Gaussian filter)

가우시안 필터의 장점은 얘도Separable Filter라는 것이다.

그래서 필터링 시에 험악하게 $w(s,t)$를 전부 계산할 필요 없이 하나씩 적용하면 된다.

역시 separable하다

 

 

4. Sobel Filter

소벨 필터는 영상처리에서 엣지 검출에 사용되는 필터링 방식이다. 

이미지에서 각 픽셀의 밝기 값을 중심으로 그 주변 픽셀들의 밝기 값을 조합하여 그 픽셀의 gradient를 계산하여 사용한다.

 

 

마스크 내부의 x,y축 intensity에 대한 미분 값을 각각 $I_x$,  $I_y$로 두고 이 값으로 타겟 픽셀의 값을 결정하겠다는 것이다.

이렇게만 보면 무슨말인지 잘 모르겠다...

 

 

보통 이미지에서 엣지부분은 저렇게 Intensity가 급격하게 변하는 부분이다.

이 엣지 부분을 보면 알 수 있듯이, 이 지점에서 미분값이 극대가 되는 것을 알 수 있다.

 

그리고 여기가 Sobel Filtering으로 검출하고 싶은 부분이다.

그래서 소벨 필터링에서는 커널을 이용해 미분값을 계산하려 한다.

이 미분값을 x에 대해서, y에 대해서 총 두번 구하게 되고

그 값을 합하여 픽셀의 값을 결정하겠다는 것이다.

 

그래서 소벨 필터링에는 x축 필터 마스크, y축 필터 마스크가 따로 있다.

 

그래서 미분값을 어떻게 계산하는걸까?

미분을 계산하는 3가지 대표 방식 중 중앙차분 방식을 차용하여 계산한다.

맨 아래가 중앙차분 https://gaussian37.github.io/vision-concept-edge_detection/

 

$x$에서의 미분값을 좌, 우 $h$ 떨어진 곳의 값으로 구하는 것이다. 

즉, 주변 이웃의 값으로 미분을 하는 것이니 여태 배운 필터링과 접근은 비슷한 셈이다.

 

미분 마스크 아이디어

그래서 x축 미분을 할 때에는 $x_{-1}\ast -1+x_0\ast 0+x_1\ast 1$이렇게 미분 값을 얻는다. y축도 마찬가지다.

($2h$를 나누지 않는 이유는 어차피 필터 전체의 합으로 normalize를 해야하기 때문이다. 나눗셈을 해도 의미가 없다..)

 

다시 소벨 필터링

이제 미분을 어떻게 하는지 알았으면 이제는 소벨 필터링의 x,y축 마스크를 보자.

https://gaussian37.github.io/vision-concept-edge_detection/

 

빨간 박스 안의 두 필터가 각각 소벨 필터 마스크의 x마스크, y마스크에 해당된다. 

그 왼쪽의 Prewitt 필터링이 우리가 위에서 살펴본 미분 방식을 변형없이 들고 온 것이다.

소벨 필터링은 타겟 픽셀의 바로 인접한 픽셀들에 가중치를 2 부여했다.

 

이 마스크를 가지고 각각 $I_x$, $I_y$를 구하고, 이 값으로 필터링을 완료하게 된다.

 

5. Laplacian Filter

소벨 필터에서는 엣지 검출을 위해 미분을 사용해 필터링 했다.

라플라시안은 이제 이차 미분을 한다...

라플라시안 필터는 이렇게 이차 미분 값 합의 절댓값을 output으로 한다.

따라서 마스크는 다음처럼 생기게 된다. (다행히 평범하게 생겼다.)