gistfile1.c++

#include "StdAfx.h"
#include "Filter.h"

Filter::Filter(void)
{
}


Filter::~Filter(void)
{
}

IplImage* Filter::loadImage(char* file_name, int iscolor)
{
	IplImage* tmp = cvLoadImage(file_name, iscolor);
	if(tmp == NULL){
		printf("loadImage: %s is not found.\n", file_name);
		return NULL;
	}
	return tmp;
}

void Filter::gaussian(char* file_name)
{
	IplImage* src_img;
	if((src_img = loadImage(file_name, CV_LOAD_IMAGE_ANYCOLOR)) == NULL)
		return;

	cvNamedWindow("src_gaussian");
	cvNamedWindow("dst_gaussian");

	IplImage* dst_img = cvCreateImage(cvGetSize(src_img), src_img->depth, src_img->nChannels);

	cvSmooth(src_img, dst_img, CV_GAUSSIAN, 9);

	cvShowImage ("src_gaussian", src_img);
	cvShowImage ("dst_gaussian", dst_img);

	cvWaitKey (0);

	cvDestroyAllWindows();

	cvReleaseImage(&src_img);
	cvReleaseImage(&dst_img);

}

void Filter::canny(char* file_name)
{
	IplImage* src_img;
	if((src_img = loadImage(file_name, CV_LOAD_IMAGE_ANYCOLOR)) == NULL)
		return;

	cvNamedWindow("src_canny");
	cvNamedWindow("gray_canny");
	cvNamedWindow("dst_canny");

	IplImage* gray_img = cvCreateImage(cvGetSize(src_img), IPL_DEPTH_8U, 1);
	cvCvtColor (src_img, gray_img, CV_BGR2GRAY);
	IplImage* dst_img = cvCreateImage(cvGetSize(src_img), gray_img->depth, gray_img->nChannels);

	cvCanny(gray_img, dst_img, 64, 128);

	cvShowImage ("src_canny", src_img);
	cvShowImage ("gray_canny", gray_img);
	cvShowImage ("dst_canny", dst_img);

	cvWaitKey (0);

	cvDestroyAllWindows();

	cvReleaseImage(&src_img);
	cvReleaseImage(&gray_img);
	cvReleaseImage(&dst_img);

}

void Filter::equalizeHist(char* file_name)
{
	IplImage* src_img;
	if((src_img = loadImage(file_name, CV_LOAD_IMAGE_ANYCOLOR)) == NULL)
		return;

	cvNamedWindow("src_equalizeHist");
	cvNamedWindow("gray_equalizeHist");
	cvNamedWindow("dst_equalizeHist");

	IplImage* gray_img = cvCreateImage(cvGetSize(src_img), IPL_DEPTH_8U, 1);
	cvCvtColor (src_img, gray_img, CV_BGR2GRAY);
	IplImage* dst_img = cvCreateImage(cvGetSize(src_img), gray_img->depth, gray_img->nChannels);

	cvEqualizeHist(gray_img, dst_img);

	cvShowImage ("src_equalizeHist", src_img);
	cvShowImage ("gray_equalizeHist", gray_img);
	cvShowImage ("dst_equalizeHist", dst_img);

	cvWaitKey (0);

	cvDestroyAllWindows();

	cvReleaseImage(&src_img);
	cvReleaseImage(&gray_img);
	cvReleaseImage(&dst_img);

}

void Filter::apply(char* file_name)
{
}

void Filter::gamma(char* file_name)
{
	IplImage* src_img;
	if((src_img = loadImage(file_name, CV_LOAD_IMAGE_ANYCOLOR)) == NULL)
		return;

	IplImage* dst_img[3];
	dst_img[0] = cvCreateImage(cvGetSize(src_img), src_img->depth, src_img->nChannels);
	dst_img[1] = cvCreateImage(cvGetSize(src_img), src_img->depth, src_img->nChannels);
	dst_img[2] = cvCreateImage(cvGetSize(src_img), src_img->depth, src_img->nChannels);

	double gamma_param[3] = {0.8, 1.2, 1.5};
	uchar LUT[3][256]; 

	for(int i = 0; i < 3; i++){
		for (int j = 0; j < 256; j++){  
			LUT[i][j] = (int)(pow((double)j / 255.0, 1.0 / gamma_param[i]) * 255.0);  
		}  
	}

	CvMat lut_mat[3];
	lut_mat[0] = cvMat(1, 256, CV_8UC1, LUT[0]);  
	lut_mat[1] = cvMat(1, 256, CV_8UC1, LUT[1]);  
	lut_mat[2] = cvMat(1, 256, CV_8UC1, LUT[2]);  

	cvLUT(src_img, dst_img[0], &lut_mat[0]);  
	cvLUT(src_img, dst_img[1], &lut_mat[1]);  
	cvLUT(src_img, dst_img[2], &lut_mat[2]);  

	cvNamedWindow ("src_gamma");
	cvShowImage ("src_gamma", src_img);
	cvNamedWindow ("dst_gamma_0");
	cvShowImage ("dst_gamma_0", dst_img[0]);
	cvNamedWindow ("dst_gamma_1");
	cvShowImage ("dst_gamma_1", dst_img[1]);
	cvNamedWindow ("dst_gamma_2");
	cvShowImage ("dst_gamma_2", dst_img[2]);

	cvWaitKey (0);

	cvDestroyAllWindows();
	cvReleaseImage (&src_img);
	cvReleaseImage (&dst_img[0]);
	cvReleaseImage (&dst_img[1]);
	cvReleaseImage (&dst_img[2]);

}

void Filter::showHist(char* file_name)
{
	int bin_w;
	int hist_size = 256;
	int src_ch = 0, ch_width = 260;
	float max_value = 0;
	float range_0[] = { 0, 256 };
	float *ranges[] = { range_0 };
	IplImage *src_img, *dst_img[4], *hist_img, *hist_sep_img[4];
	CvHistogram *hist;

	if((src_img = loadImage(file_name, CV_LOAD_IMAGE_ANYCOLOR)) == NULL)
		return;

	src_ch = src_img->nChannels;
	for (int i = 0; i < 4; i++) {
		dst_img[i] = cvCreateImage(cvGetSize(src_img), src_img->depth, 1);
	}

	for(int i = 0; i < 4; i++){
		hist_sep_img[i] = cvCreateImage(cvSize(ch_width, 200), IPL_DEPTH_8U, 1);
		cvSet(hist_sep_img[i], cvScalarAll(255), 0);
	}

	hist = cvCreateHist(1, &hist_size, CV_HIST_ARRAY, ranges, 1);
	hist_img = cvCreateImage(cvSize(ch_width * src_ch, 200), IPL_DEPTH_8U, 1);
	cvSet(hist_img, cvScalarAll(255), 0);

	if (src_ch == 1)
		cvCopy(src_img, dst_img[0]);
	else
		cvSplit(src_img, dst_img[0], dst_img[1], dst_img[2], NULL);

	for (int i = 0; i < src_ch; i++) {
		cvCalcHist(&dst_img[i], hist, 0, NULL); // それぞれのチャネル画像に対応するヒストグラムを計算
		cvGetMinMaxHistValue (hist, 0, &max_value, 0, 0); // それぞれのチャネル画像のヒストグラムの最大値
		cvScale (hist->bins, hist->bins, ((double) hist_img->height) / max_value, 0);

		bin_w = cvRound ((double) ch_width / hist_size);
		for (int j = 0; j < hist_size; j++){
			cvRectangle(hist_img,
			cvPoint(j * bin_w + (i * ch_width), hist_img->height),
			cvPoint ((j + 1) * bin_w + (i * ch_width),
			hist_img->height - cvRound(cvGetReal1D(hist->bins, j))), cvScalarAll(0), -1, 8, 0);

			cvRectangle(hist_sep_img[i],
			cvPoint(j * bin_w, hist_img->height),
			cvPoint ((j + 1) * bin_w,
			hist_img->height - cvRound(cvGetReal1D(hist->bins, j))), cvScalarAll(0), -1, 8, 0);

		}
	}

	cvNamedWindow ("src");
	cvShowImage ("src", src_img);
	for(int i = 0; i < src_ch; i++){
		char* title;
		if(i == 0)
			title = "blue";
		else if(i == 1)
			title = "green";
		else if(i == 2)
			title = "red";
		cvNamedWindow (title);
		cvMoveWindow(title, 50, 100);
		cvShowImage (title, hist_sep_img[i]);
	}

	cvWaitKey (0);

	cvDestroyAllWindows();
	cvReleaseImage (&src_img);
	for (int i = 0; i < 4; i++) {
		cvReleaseImage (&dst_img[i]);
		cvReleaseImage (&hist_sep_img[i]);
	}

	cvReleaseImage (&hist_img);
	cvReleaseHist (&hist);

}

void Filter::showChannel(char* file_name)
{
	int r_avg, g_avg, b_avg;
	CvScalar average;
	IplImage *src_img, *red_1, *green_1, *blue_1;
	IplImage *red_3, *green_3, *blue_3;

	cvNamedWindow("src");
	cvNamedWindow("red");
	cvNamedWindow("green");
	cvNamedWindow("blue");

	if((src_img = loadImage(file_name, CV_LOAD_IMAGE_ANYCOLOR)) == NULL)
		return;

	red_1 = cvCreateImage(cvGetSize(src_img), IPL_DEPTH_8U, 1);
	green_1 = cvCreateImage(cvGetSize(src_img), IPL_DEPTH_8U, 1);
	blue_1 = cvCreateImage(cvGetSize(src_img), IPL_DEPTH_8U, 1);

	red_3 = cvCreateImage(cvGetSize(src_img), IPL_DEPTH_8U, 3);
	green_3 = cvCreateImage(cvGetSize(src_img), IPL_DEPTH_8U, 3);
	blue_3 = cvCreateImage(cvGetSize(src_img), IPL_DEPTH_8U, 3);
	
	cvSetZero(red_3);
	cvSetZero(green_3);
	cvSetZero(blue_3);

	cvSplit(src_img, blue_1, green_1, red_1, NULL);

	cvMerge(NULL, NULL, red_1, NULL, red_3);
	cvMerge(NULL, green_1, NULL, NULL, green_3);
	cvMerge(blue_1, NULL, NULL, NULL, blue_3);

	cvShowImage("src", src_img);
	cvShowImage("red", red_3);
	cvShowImage("green", green_3);
	cvShowImage("blue", blue_3);

	average = cvAvg(src_img);
	r_avg = (int)average.val[2];
	g_avg = (int)average.val[1];
	b_avg = (int)average.val[0];
	printf("avg=(%3d, %3d, %3d)\n", r_avg, g_avg, b_avg);

	cvWaitKey(0);

	cvDestroyAllWindows();
	cvReleaseImage(&src_img);
	cvReleaseImage(&red_1);
	cvReleaseImage(&green_1);
	cvReleaseImage(&blue_1);
	cvReleaseImage(&red_3);
	cvReleaseImage(&green_3);
	cvReleaseImage(&blue_3);
}