[Computer Vision/OpenCV] 9. Histogram Matching

 

 

저번 포스팅으로 히스토그램 Equalization을 배웠다. Histogram Equalization은 히스토그램의 분포를 균일하게 만드는 방법이다.

오늘은, 균일한 분포를넘어서서  "특정한 분포"로 바꾸는 Histogram Matching에 대해서 배운다.

이 과정에서 Histogram Equalization이 사용되기 때문에 equalization에 대해서 어느정도 알고 있어야 한다.

 

Histogram Matching

특정한 히스토그램 형태로 이미지의 원본 히스토그램을 변환하는 것을 histogram matching이라고 한다.

즉, 원본 히스토그램 S를 변형하여 히스토그램 Z로 만든다.

 

 

Histogram Matching 과정

위의 사진으로 알 수 있듯이 Histogram Equalization을 통해서 Transfer Function T와 G를 구할 수 있다.

이렇게 구한 두개의 Transfer Funciton을 활용하면 S->Z로 히스토그램 매칭을 할 수 있다.

 

1. 먼저 원본과 목표 히스토그램의 equalization function을 구한다.

2. 이 두 function을 활용해 s->z로 intensity 매핑을 할 수 있다. 

$$z=G^{-1}(d)=G^{-1}(T(s))$$

 

Histogram Matching OpenCV 실습

컬러와 그레이스케일 이미지 모두에서 적용한 예시를 들고 왔다.

컬러 이미지의 경우에는 YUV변환 하여 Y(밝기)에서먄 변환하여 사용한다.

(따라서 밝기만 변하므로, 히스토그램은 grayscale과 동일할 것이다)

 

Grayscale Image

가장 위의 사진과 히스토그램이 변환할 사진

중간 히스토그램과 사진이 매칭 대상이다.

가장 아래의의 사진과 히스토그램이 매칭 후의 사진과 히스토그램이다.

 

결과를 살펴보면 히스토그램 모양이 유사하게 매칭된 것을 알 수 있다

 

 

Color Image

위의 사진과 히스토그램이 변환할 사진

두번째 히스토그램과 사진이 매칭 대상이다.

 

컬러 이미지는 BGR채널을 YUV 채널로 바꾸어 Y채널에만 적용한다.

Y는 이미지의 밝기를 의미하고, U,V는 이미지 픽셀의 색상을 결정한다.

 

히스토그램 매칭의 결과는 따라서 이미지의 색상정보는 그대로, 밝기 정보만 매칭된다.

 

 

아래의 매칭 결과를 살펴보면 히스토그램 모양이 유사하게 매칭된 것을 알 수 있다.

 

 

Histogram Matching OpenCV Code

사용 함수가 많아져서 따로 헤더파일을 만들었다. 

 

histogram.h

#pragma once
#ifndef HISTOGRAM_H
#define HISTOGRAM_H

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

using namespace cv;
using namespace std;

// 이미지를 그레이스케일로 변환
inline Mat convertToGrayscale(const Mat& img) {
    Mat grayImg;
    if (img.channels() == 3)
        cvtColor(img, grayImg, COLOR_BGR2GRAY);
    else
        grayImg = img;
    return grayImg;
}


// 히스토그램 계산
inline vector<Mat> calculateHistogram(const Mat& img) {
    vector<Mat> histograms;

    if (img.channels() == 1) {  // Grayscale Image
        Mat hist;
        int histSize = 256;
        float range[] = { 0, 256 };
        const float* histRange = { range };

        calcHist(&img, 1, 0, Mat(), hist, 1, &histSize, &histRange);
        histograms.push_back(hist);
    }
    else if (img.channels() == 3) {  // Color Image (BGR or RGB)
        vector<Mat> channels;
        split(img, channels);

        int histSize = 256;
        float range[] = { 0, 256 };
        const float* histRange = { range };

        for (int i = 0; i < 3; ++i) {
            Mat hist;
            calcHist(&channels[i], 1, 0, Mat(), hist, 1, &histSize, &histRange);
            histograms.push_back(hist);
        }
    }

    return histograms;
}

// 확률 밀도 함수(PDF) 계산
inline Mat computePDF(const Mat& hist) {
    return hist / sum(hist)[0];
}

// 누적 분포 함수(CDF) 계산
inline Mat computeCDF(const Mat& pdf) {
    Mat cdf = pdf.clone();
    for (int i = 1; i < cdf.rows; ++i) {
        cdf.at<float>(i) += cdf.at<float>(i - 1);
    }
    return cdf;
}

// 매칭을 위한 Lookup Table 생성
inline Mat generateLookupTable(const Mat& sourceCDF, const Mat& referenceCDF) {
    Mat lookupTable(1, 256, CV_8U);
    for (int i = 0; i < 256; ++i) {
        float sourceValue = sourceCDF.at<float>(i);
        uchar matchedValue = 0;
        for (int j = 0; j < 256; ++j) {
            if (referenceCDF.at<float>(j) >= sourceValue) {
                matchedValue = static_cast<uchar>(j);
                break;
            }
        }
        lookupTable.at<uchar>(i) = matchedValue;
    }
    return lookupTable;
}

// Lookup Table 적용
inline Mat applyLookupTable(const Mat& img, const Mat& lookupTable) {
    Mat result;
    LUT(img, lookupTable, result);
    return result;
}

// 히스토그램 매칭inline Mat histogramMatching(
inline Mat histogramMatching(
    const Mat& src,
    const Mat& ref,
    vector<Mat>& hist_src,
    vector<Mat>& hist_dst,
    vector<Mat>& hist_result,
    bool Color = false)
{
    if (src.channels() == 3 && Color) {  // 컬러 이미지 처리 (YUV 변환 후 Y 채널 매칭)
        Mat srcYUV, refYUV;
        cvtColor(src, srcYUV, COLOR_BGR2YUV);
        cvtColor(ref, refYUV, COLOR_BGR2YUV);

        // 채널 분리
        vector<Mat> srcChannels, refChannels;
        split(srcYUV, srcChannels);
        split(refYUV, refChannels);

        // Y 채널의 히스토그램 계산
        hist_src = calculateHistogram(srcChannels[0]);
        hist_dst = calculateHistogram(refChannels[0]);

        // PDF 및 CDF 계산
        Mat pdf_src = computePDF(hist_src[0]);
        Mat pdf_dst = computePDF(hist_dst[0]);

        Mat cdf_src = computeCDF(pdf_src);
        Mat cdf_dst = computeCDF(pdf_dst);

        // Lookup Table 생성 및 적용
        Mat lookupTable = generateLookupTable(cdf_src, cdf_dst);
        srcChannels[0] = applyLookupTable(srcChannels[0], lookupTable);

        // 매칭된 이미지 병합 및 색상 복원
        Mat matchedYUV, result;
        merge(srcChannels, matchedYUV);
        cvtColor(matchedYUV, result, COLOR_YUV2BGR);

        // 매칭된 이미지의 Y 채널 히스토그램 계산
        hist_result = calculateHistogram(srcChannels[0]);

        return result;
    }
    else {  // 그레이스케일 이미지 처리
        Mat srcGray = convertToGrayscale(src);
        Mat refGray = convertToGrayscale(ref);

        hist_src = calculateHistogram(srcGray);
        hist_dst = calculateHistogram(refGray);

        Mat pdf_src = computePDF(hist_src[0]);
        Mat pdf_dst = computePDF(hist_dst[0]);

        Mat cdf_src = computeCDF(pdf_src);
        Mat cdf_dst = computeCDF(pdf_dst);

        Mat lookupTable = generateLookupTable(cdf_src, cdf_dst);

        Mat result = applyLookupTable(srcGray, lookupTable);

        hist_result = calculateHistogram(result);

        return result;
    }
}


// 히스토그램 이미지로 그리기
inline Mat drawHistogram(
    const vector<Mat>& hists,  // 히스토그램 목록 (Y, BGR or YUV)
    int histSize = 256,
    int hist_w = 512,
    int hist_h = 500,
    int margin = 60) {

    Mat histImg(hist_h + 2 * margin, hist_w + 2 * margin, CV_8UC3, Scalar(0, 0, 0));
    Scalar colors[3] = { Scalar(255, 255, 255), Scalar(0, 255, 0), Scalar(0, 0, 255) };  // B, G, R or Y, U, V
    int channelCount = hists.size();

    for (int ch = 0; ch < channelCount; ++ch) {
        Mat hist = hists[ch];

        // 정규화하여 최대값을 hist_h에 맞춤
        normalize(hist, hist, 0, hist_h, NORM_MINMAX);

        for (int i = 1; i < histSize; ++i) {
            line(histImg,
                Point(margin + (i - 1) * (hist_w / histSize), margin + hist_h - cvRound(hist.at<float>(i - 1))),
                Point(margin + i * (hist_w / histSize), margin + hist_h - cvRound(hist.at<float>(i))),
                colors[ch % 3], 1);  // 선으로 표시
        }
    }

    // 축 그리기
    line(histImg, Point(margin - 2, margin), Point(margin - 2, margin + hist_h+2), Scalar(255, 255, 255)); // Y축
    line(histImg, Point(margin - 2, margin + hist_h+2), Point(margin + hist_w, margin + hist_h+2), Scalar(255, 255, 255)); // X축

    return histImg;
}

#endif // HISTOGRAM_H

 

hist_matching.cpp

#include "histogram.h"
#include <opencv2/opencv.hpp>
#include <iostream>

using namespace cv;
using namespace std;

int main() {
    Mat img_src = imread("sunset.jpg", IMREAD_COLOR);
    Mat img_dst = imread("lake.jpg", IMREAD_COLOR);

    if (img_src.empty() || img_dst.empty()) {
        cout << "Error loading images!" << endl;
        return -1;
    }

    vector<Mat> hist_src, hist_dst, hist_result;
    vector<Mat> hist_src_g, hist_dst_g, hist_result_g;

    imshow("Source Image", img_src);
	hist_src = calculateHistogram(img_src);
    // For Grayscale Matching
    Mat result_gray = histogramMatching(img_src, img_dst, hist_src_g, hist_dst_g, hist_result_g, false);

    imshow("Source Image", convertToGrayscale(img_src));
    imshow("Reference Image", convertToGrayscale(img_dst));
    imshow("Matched Image (Grayscale)", result_gray);

    imshow("Source Histogram (Grayscale)", drawHistogram(hist_src_g));
    imshow("Reference Histogram (Grayscale)", drawHistogram(hist_dst_g));
    imshow("Matched Histogram (Grayscale)", drawHistogram(hist_result_g));

    // For Color Matching
    Mat result_color = histogramMatching(img_src, img_dst, hist_src, hist_dst, hist_result, true);

    imshow("Source Image (Color)", img_src);
    imshow("Reference Image (Color)", img_dst);
    imshow("Matched Image (Color)", result_color);

    imshow("Source Histogram (Y Channel)", drawHistogram(hist_src));
    imshow("Reference Histogram (Y Channel)", drawHistogram(hist_dst));
    imshow("Matched Histogram (Y Channel)", drawHistogram(hist_result));

    waitKey(0);
    return 0;
}