[OpenCV] 히스토그램 명세화 소스 코드 (C++)

#include "opencv2/opencv.hpp"
#include "opencv2/highgui.hpp"
#include <Windows.h>
#include <string.h>

using namespace cv;
using namespace std;

Mat histogram, histogramImage;	// 레나 영상과 레나 영상의 히스토그램
Mat histogram2, histogramImage2;	// CPU 영상과 CPU 영상의 히스토그램
Mat histogramNew;				// 역평활화 되어 생성된 룩업-테이블
Mat image, image2;				// 불러오는 이미지 1,2
Mat histogramSum, histogramSum2;	// 레나, CPU 영상을 평활화 한 결과를 담는 테이블1, 2
Mat tmp, tmp2;

// params : image
// 히스토그램을 확인할 영상

// params : histogram
// 계산되어 반환될 히스토그램

// params : bins
// 히스토그램의 x축 요소 수

// params : range_max
// 히스토그램의 x축 최대 요소 수

// 과제 : 역평활화 과정만 추가하면 된다.

// 이미지에 대한 히스토그램 계산
void CalcHistogram(Mat image, Mat& histogram, int bins, int range_max = 256) {

	// 히스토그램 값을 저장할 Mat 인스턴스 생성, 0으로 초기화
	histogram = Mat(bins, 1, CV_32F, Scalar(0));

	// x축 값 간격
	float gap = (float)range_max / bins;

	// 영상을 순회하면서 화소를 처리
	for (int i = 0; i < image.rows; i++) {
		for (int j = 0; j < image.cols; j++) {
			// var : workPixel
			// 처리할 화소
			// auto : 컴파일 시점에서 컴파일러가 문맥을 보고 자동으로 변수 타입을 지정, 템플릿같은 곳에 사용시 편리
			auto workPixel = image.at<uchar>(i, j);

			// 해당 화소가 들어갈 영역을 계산
			int idx = (int)(workPixel / gap);

			// 히스토그램에 영역에 값을 누적
			histogram.at<float>(idx)++;
		}
	}
}

string OpenFileDialog()
{
	char name[MAX_PATH] = { 0, };
	OPENFILENAMEA ofn;
	ZeroMemory(&ofn, sizeof(ofn));
	ofn.lStructSize = sizeof(OPENFILENAMEA);
	ofn.hwndOwner = NULL;
	ofn.lpstrFilter = "모든파일(*.*)\0*.*\0";
	ofn.lpstrFile = name;
	ofn.nMaxFile = MAX_PATH;
	ofn.Flags = OFN_EXPLORER | OFN_FILEMUSTEXIST | OFN_HIDEREADONLY;
	ofn.lpstrDefExt = "";

	string strName;

	if (GetOpenFileNameA(&ofn))
		strName = name;

	return strName;
}

// 히스토그램
void GetHistogramImage(Mat histogram, Mat& histogramImage, Size size = Size(256, 200)) {

	// 255로 빈 히스토그램 영상을 생성
	histogramImage = Mat(size, CV_8U, Scalar(255));

	// 히스토그램 한 영역을 표현할 너비
	float gap = (float)(histogramImage.cols / histogram.rows);

	// 히스토그램의 빈도값을 최소가 0, 최대가 출력 영상의 높이값을 갖도록 조정
	normalize(histogram, histogram, 0, histogramImage.rows, NORM_MINMAX);

	for (int i = 0; i < histogram.rows; i++) {
		// 히스토그램 막대사각형의 시작과 끝의 X좌표
		float sx = i * gap;
		float ex = (i + 1) * gap;

		// 사각형의 좌측 하단좌표와 우측 상단 좌표
		Point2f pt_Ib(sx, 0), pt_rt(ex, histogram.at<float>(i));

		// 사각형이 높이 값을 가지면 사각형을 그림
		if (pt_rt.y > 0)
			rectangle(histogramImage, pt_Ib, pt_rt, Scalar(0), -1);
	}

	// X축 기준으로 영상을 뒤집음 (영상에서 좌표계는 아래가 양의 값을 가지므로, 위가 양의 값을 갖는 좌표계로 변환)
	flip(histogramImage, histogramImage, 0);
}

// 히스토그램1 보기
void ShowHistogram1() {
	auto fileName = OpenFileDialog();
	image = imread(fileName, IMREAD_GRAYSCALE);

	if (image.empty()) {
		cout << "파일 읽기 실패" << endl;
		return;
	}

	CalcHistogram(image, histogram, 256);

	cout << histogram.t() << endl;
	GetHistogramImage(histogram, histogramImage);

	imshow("원본 영상 1", image);
	imshow("히스토그램 1", histogramImage);
	waitKey();
}

// 히스토그램2 보기
void ShowHistogram2() {
	auto fileName2 = OpenFileDialog();
	image2 = imread(fileName2, IMREAD_GRAYSCALE);

	if (image2.empty()) {
		cout << "파일 읽기 실패" << endl;
		return;
	}

	CalcHistogram(image2, histogram2, 256);

	cout << histogram2.t() << endl;
	GetHistogramImage(histogram2, histogramImage2);
	imshow("원본 영상 2", image2);
	imshow("히스토그램 2", histogramImage2);
	waitKey();
}

// 평활화 작업 - 평활화 기법으로 명암 분포가 빈약한 영상을 균일하게 만듬
void CalcNormalizedCumulativeFrequency(Mat histogram, Mat& histogramSum) {

	// 히스토그램값을 저장할 Mat인스턴스 생성, 0으로 초기화
	histogramSum = Mat(histogram.rows, 1, CV_32F, Scalar(0));

	// 히스토그램의 누적 합을 계산
	float sum = 0;
	for (int i = 0; i < histogram.rows; i++) {
		sum += histogram.at<float>(i);
		histogramSum.at<float>(i) = sum;
	}

	// 정규화
	for (int i = 0; i < histogramSum.rows; i++) 
		histogramSum.at<float>(i) = histogramSum.at<float>(i) / sum * 255.0;
}

// 레나와 CPU영상을 모두 평활화 한 다음, 평활화된 CPU를 역평활화하여 룩업테이블을 만들고 레나의 매핑하는 함수
void HistogramEqualizing() {

	// 1. 레나 영상 평활화 작업

	// 히스토그램 생성
	CalcHistogram(image, histogram, 256);

	// 누적 빈도 수 계산 및 정규화
	CalcNormalizedCumulativeFrequency(histogram, histogramSum);

	// 정규화된 누적 빈도 수를 기반으로 기존의 화소를 변환
	// 화소값 제어
	tmp = Mat(image.size(), image.type());

	for (int i = 0; i < image.rows; i++) 
		for (int j = 0; j < image.cols; j++) 
			tmp.at <uchar>(i, j) = (uchar)histogramSum.at<float>(image.at<uchar>(i, j));

	// ㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡ

	// 2, cpu 사진 평활화 작업

	// 히스토그램 생성
	CalcHistogram(image2, histogram2, 256);

	// 누적 빈도 수 계산 및 정규화
	CalcNormalizedCumulativeFrequency(histogram2, histogramSum2);

	// 정규화된 누적 빈도 수를 기반으로 기존의 화소를 변환
	// 화소값 제어
	tmp2 = Mat(image2.size(), image2.type());

	for (int i = 0; i < image2.rows; i++) 
		for (int j = 0; j < image2.cols; j++) 
			tmp2.at <uchar>(i, j) = (uchar)histogramSum2.at<float>(image2.at<uchar>(i, j));

	// ㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡ
}

// 역평활화와 룩업테이블 매핑하는 함수
void GetResult()
{
	// 3. cpu 사진 역평활화 작업

	// 히스토그램 생성
	CalcHistogram(tmp2, histogramNew, 256);

	int image_1 = 254;
	int image_2 = 255;

	// 정규화된 값을 명암에 해당하는 값을 역함수로 만들어서 
	// histogramNew에 역함수로 매핑된 역평활화 테이블을 저장한다.

	while (image_1 >= 0) {	// 모두 매핑하면 스탑 (image_1 이 0이되면 역함수 매핑이 끝난다.)

		for (int i = histogramSum2.at<float>(image_1); i <= histogramSum2.at<float>(image_2); i++)
			histogramNew.at<float>(i) = image_2;

		image_2 = image_1--;
	}

	/*
		image_2	= 255 -> 254 -> 253 ------> 1
		image_1 = 254 -> 253 -> 252 ------> 0
		new = 0 -> 254 -> 253 ------------> 2
	*/

	// 4. 룩업-테이블 매핑 작업

	// 정규화된 누적 빈도 수를 기반으로 기존의 화소를 변환
	// 화소값 제어
	auto result = Mat(tmp.size(), tmp.type());

	// 룩업-테이블을 통해 레나의 사진을 명세화한다.
	for (int i = 0; i < tmp.rows; i++)
		for (int j = 0; j < tmp.cols; j++)
			result.at <uchar>(i, j) = (uchar)histogramNew.at <float>(tmp.at<uchar>(i, j));

	// 처리된 영상의 히스토그램 계산
	CalcHistogram(result, histogramNew, 256);
	GetHistogramImage(histogramNew, histogramImage);

	// 명세화 결과 출력
	imshow("명세화 결과 영상", result);
	imshow("명세화 결과 히스토그램", histogramImage);
	waitKey();
}

int main()
{
	ShowHistogram1();	// 히스토그램1 보기
	ShowHistogram2();	// 히스토그램2 보기
	HistogramEqualizing();	// 두 영상 평활화 작업
	GetResult();	// 역평활화로 룩업테이블 생성 후 레나 영상의 매핑
}