[이미지 - 필터링 적용]

영상에 대해 키보드로 입력 받아 보고 싶은 필터링을 적용하여 출력하기

(가우시안, 미디언, 비등방 필터링)

 

[가우시안 필터링]

Mat Gaussian(Mat image) {
int filtersize = 0;
double sigma = 3.0;

Mat operation(image.size(), CV_8U, Scalar(0));
Mat buff(image.size(), CV_64F, Scalar(0));

int dim = static_cast(8 * sigma + 1.0);
if (dim < 3) dim = 1;
if (dim % 2 == 0) dim++;
int dim2 = dim / 2;

double* Mask = (double*)malloc(sizeof(double) * dim);
for (int i = 0; i < dim; i++) {
    int x = i - dim2;
    Mask[i] = exp(-(x * x) / (2 * sigma * sigma)) / (sqrt(2 * PI) * sigma);
}
double sum;
for (int i = dim2; i < image.cols - dim2; i++) {
    for (int j = dim2; j < image.rows - dim2; j++) {
        sum = 0;
        for (int k = 0; k < dim; k++) {
            int y = k - dim2 + j;
            sum += Mask[k] * image.at(y, i);
        }
        buff.at(j, i) = sum;
    }
}
for (int j = dim2; j < image.rows - dim2; j++) {
    for (int i = dim2; i < image.cols - dim2; i++) {
         sum = 0;
            for (int k = 0; k < dim; k++) {
                int x = k - dim2 + i;
                sum += Mask[k] * buff.at(j, x);
            }
        operation.at(j, i) = saturate_cast(sum);
    }
}
    free(Mask);
    return operation;
}

#가우시안 필터링은 기본적으로 잡음 제거에 탁월하다.

하지만 가우시안 필터링의 분산값을 높게 잡으면 영상이 점점 뿌옆게 되는 단점이 조재한다.

가우시안 필터링

기본적으로 가우시안 필터를 적용할 때, 가로로 적용하고 그 값을 버퍼에 따로 저장하고 세로연산을 수행한다.

속도면에서 한번에 처리하는 것보다 앞선다.

[미디언 필터링]

Mat Median(Mat image) {
    Mat operation(image.size(), CV_8U, Scalar(0));

    for (int i = 1; i < image.rows - 1; i++) {
        for (int j = 1; j < image.cols - 1; j++) {
            uchar* Mask = (uchar*)malloc(sizeof(uchar) * 9); 
            uchar tmp;

            Mask[0] = image.at(i - 1, j - 1);
            Mask[1] = image.at(i - 1, j);
            Mask[2] = image.at(i - 1, j + 1);
            Mask[3] = image.at(i, j - 1);
            Mask[4] = image.at(i, j);
            Mask[5] = image.at(i, j + 1);
            Mask[6] = image.at(i + 1, j - 1);
            Mask[7] = image.at(i + 1, j);
            Mask[8] = image.at(i + 1, j + 1);

            for (int h = 0; h < 9; h++) {
                for (int w = 0; w <= 9 - (h + 1); w++) {
                    if (Mask[w] > Mask[w + 1]) {
                        tmp = Mask[w];
                        Mask[w] = Mask[w + 1];
                        Mask[w + 1] = tmp;
                    }
                }
            }
            operation.at(i, j) = saturate_cast(Mask[4]);
          } 
        }
    return operation;
}

#미디언 필터링은 영상의 소금 후추 잡음에 탁월하다.

mask배열로 읽어와 정렬 후, 중간값을 취하는 형식을 가진다.

미디언 필터링

[비등방 필터링]

Mat Anisotropic(Mat image) {
     Mat operation(image.size(), CV_8U, Scalar(0));
     Mat dblimage(image.size(), CV_64F, Scalar(0));
     Mat buff(image.size(), CV_64F, Scalar(0));

    image.convertTo(dblimage, CV_64F);

    double lambda = 0.25;
    double K = 4;
    double K2 = K * K;
    int itr = 10;

    double gradn, grads, grade, gradw;
    double gcn, gcs, gce, gcw;

    for (int i = 0; i < itr; i++) {
        for (int x = 1; x < image.rows - 1; x++) {
            for (int y = 1; y < image.cols - 1; y++) {

               gradn = dblimage.at(x - 1, y) - dblimage.at(x, y);
               grads = dblimage.at(x + 1, y) - dblimage.at(x, y);
               grade = dblimage.at(x, y - 1) - dblimage.at(x, y);
               gradw = dblimage.at(x, y + 1) - dblimage.at(x, y);

               gcn = gradn / (1.0f + gradn * gradn / K2);
               gcs = grads / (1.0f + grads * grads / K2);
               gce = grade / (1.0f + grade * grade / K2);
               gcw = gradw / (1.0f + gradw * gradw / K2);

               buff.at(x, y) = dblimage.at(x, y) + lambda * (gcn + gcs + gce + gcw);
            }
         }
        buff.copyTo(dblimage);
   }
    dblimage.convertTo(operation, CV_8U);
    return operation;
}

#비등방 필터링은 연산의 기울기 값을 이용하여 필터링하는 연산이다.

비등방 필터링

영상이 엄청나게 선명해진다.

필터링 적용하는 과제.cpp

0.00MB