1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

# -*- coding: utf-8 -*-

# 네이버 실시간 검색어 크롤링 
# 
# 네이버에서 제공하는 실시간 인기 검색어 상위 20개를
# 자동추출하는 프로그램 
#
# 크롤이 대상 웹페이지: 아래 주소에서 실시간 검색어 정보를 얻을 수 있다.
# URL: http://datalab.naver.com/keyword/realtimeList.naver?where=main
# 
# 찾는 방법: 읽어 온 문서를 파싱해서 검색어를 찾는 과정은 다음과 같다.
# ul tag를 모두 찾고,
# class attribute가 rank_list인 것을 찾고,
# span tag안에 들어있는 실시간 검색어를 추출
#
#
# 사용모듈
# requests: HTTP request와 response, 네트워크를 통해웹페이지 접속
# BeautifulSoup: 웹페이지를 파싱 
#
# 주의사항: 
# Beautiful soup이 반환하는 값은 배열 안에 들어가 있음
# index[0]이 맨 앞에 들어 있는 값임.
#
#
import requests
from bs4 import BeautifulSoup

# 실시간 검색어를 제공하는 웹이지를 읽음
response = requests.get('http://datalab.naver.com/keyword/realtimeList.naver?where=main')
# 웹페이즈를 파싱
dom = BeautifulSoup(response.text, 'html.parser')

#print(response.text)  # for debugging

# ul tag를 모두 찾음
result = dom.find_all('ul')

#print result # for debugging

for res in result:
    
    #print(str(res['class']))  # for debugging
    #print "-------------------------\n"  # for debugging

    # 실시간 검색어를 출력한다.
    # class attribute의 값이 rank_list인 경우에,
    if res['class'][0] == 'rank_list':
        # 검색어가 들어있는 span tag를 모두 찾아서,
        keywords = res.find_all('span')
        # span tag의 contents 중 첫번째 [0] 요소를 출력하면 된다.
        # 한글을 올바르게 출력하기 위해서는 
        # 이 파일의 맨 위에 utf-8 coding임을 코멘트로 명시
        for key in keywords:  # 상위 20개의 실시간 검색어가 들어있다.
            print key.contents[0]
        break

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

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

using namespace cv;
using namespace std;

// reference와 target은 변경시키지 않을 것이므로 const
// result는 변경결과를 담는다.
void histMatch(const Mat &reference, const Mat &target, Mat &result)
{
	const float HISTMATCH = 0.000001;  // threshold of histogram difference
	double min, max;

	vector<Mat> ref_channels;  // 벤치마킹 이미지를 색채널별로 분리해서 저장
	split(reference, ref_channels);
	vector<Mat> tgt_channels;  // 색변경 대상 이미지를 채널별로 분리
	split(target, tgt_channels);
	
	int histSize = 256;  // histogram을 256 level로 작성
	float range[] = { 0, 256 };  // 최소와 최대 bin
	const float *histRange = { range };
	bool uniform = true;

	for (int i = 0; i < 3; i++)
	{
		Mat ref_hist, tgt_hist;  // 생성된 히스토그램 저장
		Mat ref_hist_accum, tgt_hist_accum;  // 히스토그램의 CDF계산

		calcHist(&ref_channels[i], 1, 0, Mat(), ref_hist, 1, &histSize, &histRange, uniform, false);
		calcHist(&tgt_channels[i], 1, 0, Mat(), tgt_hist, 1, &histSize, &histRange, uniform, false);

		minMaxLoc(ref_hist, &min, &max);  // 히스토그램에서 최소값과 최대값을 구한다.
		if (max == 0)
		{
			cout << "ERROR: max is 0 in ref_hist" << endl;
		}
		normalize(ref_hist, ref_hist, min / max, 1.0, NORM_MINMAX);  // 히스토그램 값을 0 ~ 1까지로 normalize한다.

		minMaxLoc(tgt_hist, &min, &max);  // 히스토그램에서 최소값과 최대값을 구한다.
		if (max == 0)
		{
			cout << "ERROR: max is 0 in tgt_hist" << endl;
		}
		normalize(tgt_hist, tgt_hist, min / max, 1.0, NORM_MINMAX);  // 히스토그램 값을 0 ~ 1까지로 normalize한다.

		//
		// CDF를 계산한다.
		//
		ref_hist.copyTo(ref_hist_accum);  // 복사본을 만든다.
		tgt_hist.copyTo(tgt_hist_accum);

		float *src_cdf_data = ref_hist_accum.ptr<float>();  // pointer로 access하면 성능을 높일 수 있다.
		float *dst_cdf_data = tgt_hist_accum.ptr<float>();

		for (int j = 1; j < 256; j++)
		{
			src_cdf_data[j] += src_cdf_data[j - 1];
			dst_cdf_data[j] += dst_cdf_data[j - 1];
		}

		//
		// 계산된 CDF를 normalize한다.
		//
		minMaxLoc(ref_hist_accum, &min, &max);
		normalize(ref_hist_accum, ref_hist_accum, min / max, 1.0, NORM_MINMAX);
		minMaxLoc(tgt_hist_accum, &min, &max);
		normalize(tgt_hist_accum, tgt_hist_accum, min / max, 1.0, NORM_MINMAX);

		// 
		// Histogram matching을 수행
		//
		Mat lut(1, 256, CV_8UC1);  // Lookup table을 만든다.
		uchar *M = lut.ptr<uchar>();
		uchar last = 0;
		for (int j = 0; j < tgt_hist_accum.rows; j++)
		{
			float F1 = dst_cdf_data[j];

			//
			// 벤치마킹이미지에서 유사한 CDF 값을 갖는 픽셀 intensity를 찾는다.
			//
			for (uchar k = last; k < ref_hist_accum.rows; k++)
			{
				float F2 = src_cdf_data[k];
				if (abs(F2 - F1) < HISTMATCH || F2 > F1)  // 유사한 CDF이거나, 
				{
					M[j] = k;  // 변경대상 이미지의 intensity j는 intensity k로 변환
					last = k;  // 다음 검색을 시작할 위치
					break;  // 다음 intensity로
				}

			}
		}

		LUT(tgt_channels[i], lut, tgt_channels[i]);  // Lookup table을 이용한 색깔 변화
	}  // end of for

	merge(tgt_channels, result);  // 3개 채널들을 합쳐서 이미지를 재생성

}

// test 1
#define REF_IMG "img_osaka_night.jpg"
#define TGT_IMG "img2_garden.jpg"

// test 2
//#define REF_IMG "img2_garden.jpg"
//#define TGT_IMG "img_osaka_night.jpg"

// test 3
//#define REF_IMG "img2_beach.jpg"
//#define TGT_IMG "img2_grapefarm.jpg"

// test 4
//#define REF_IMG "img2_grapefarm.jpg"
//#define TGT_IMG "img2_beach.jpg"

int main(int argc, char** argv)
{

	Mat ref = imread(REF_IMG, IMREAD_COLOR); 	// 색깔을 벤치마킹할 이미지, BGR 포맷으로 읽는다.
	if (ref.empty() == true)
	{
		cout << "Unable to read reference image" << endl;
		return -1;
	}
	Mat tgt = imread(TGT_IMG, IMREAD_COLOR); 	// 색깔을 변경할 이미지
	if (tgt.empty() == true)
	{
		cout << "Unable to read target image" << endl;
		return -1;
	}
	Mat dst = tgt.clone();  // 색깔 변경 결과를 담을 이미지

	namedWindow("Reference", WINDOW_KEEPRATIO);  // 벤치마킹 이미지 표시창, 비율따라 크기 조정
	namedWindow("Target", WINDOW_KEEPRATIO); // 변경대상 이미지
	namedWindow("Result", WINDOW_KEEPRATIO);  // 변경결과를 담을 이미지
	
	imshow("Reference", ref);
	imshow("Target", tgt);

	histMatch(ref, tgt, dst);
	imshow("Result", dst);

	waitKey();
	return 0;
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100

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

using namespace cv;
using namespace std;

//
// 슬라이드 바의 위치에 해당하는 값
// 최소 0에서 최대 200까지 움직인다.
//
int init_brightness = 100;
int init_contrast = 100;

Mat image;

const char* keys = { "{@imageName1| img_osaka_night.jpg |input image file} \\
{@imageName2| fruits.jpg|input image file} \\
{N | 1.0 | this is double value} \\
{help h ? | | this is help}" };


void updateBrightnessContrast(int, void*)
{
	int histSize = 255;
	int var_brightness = init_brightness - 100;
	int var_contrast = init_contrast - 100;

	double a, b;
	if (var_contrast > 0)
	{
		double delta = 127.0*var_contrast / 100;
		a = 255.0 / (255.0 - delta * 2);
		b = a*(var_brightness - delta);
	}
	else
	{
		double delta = -128.0*var_contrast / 100;
		a = (256.0 - delta * 2) / 255.0;
		b = a*var_brightness + delta;
	}

	cout << "a: " << a << " b: " << b << endl;

	Mat dst, hist;
	//
	// image의 각 픽셀값을 변경하여, dst를 만들어 화면에 표시
	// pixel =  a*pixel + b
	//
	image.convertTo(dst, CV_8U, a, b);
	imshow("image", dst);

	// dst의 히스토그램을 계산한다.
	calcHist(&dst, 1, 0, Mat(), hist, 1, &histSize, 0);

	Mat histImage = Mat::ones(200, 320, CV_8U) * 255;  // 320 * 200의 흰색이미지를 만든다.

	normalize(hist, hist, 0, histImage.rows, CV_MINMAX, CV_32F);
	
	int binW = cvRound((double)histImage.cols / histSize);

	for (int i = 0; i < histSize; i++)
	{
		Point leftUp = Point(i*binW, histImage.rows);
		Point rightDown = Point((i + 1)*binW, histImage.rows - cvRound(hist.at<float>(i)));
		rectangle(histImage, leftUp, rightDown, Scalar::all(0), -1, 8, 0);
		imshow("histogram", histImage);
	}
}


/*
   read in an image as a gray
*/
int main(int argc, char** argv)
{
	CommandLineParser parser(argc, argv, String(keys));
	parser.about("This is test program for commandlineparser of opencv");
	string inputImage1 = parser.get<string>("@imageName1");

	image = imread(inputImage1, IMREAD_GRAYSCALE);
	if (image.empty() == true)
	{
		cout << "Unable to read the image " << inputImage1 << "." << endl;
		return -1;
	}
	namedWindow("image", WINDOW_KEEPRATIO);
	namedWindow("histogram", WINDOW_KEEPRATIO);

	createTrackbar("brightness", "image", &init_brightness, 200, updateBrightnessContrast);
	createTrackbar("contrast", "image", &init_contrast, 200, updateBrightnessContrast);

	// 이 함수를 호출해야
	// 이미지를 화면에 표시할 수 있다.
	//
	updateBrightnessContrast(0, 0);

	waitKey();
	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

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

using namespace cv;
using namespace std;

int init_brightness = 100;
int init_contrast = 100;

Mat image;

const char* keys = { "{@imageName1| fruits.jpg|input image file} \\
{@imageName2| fruits.jpg|input image file} \\
{N | 1.0 | this is double value} \\
{help h ? | | this is help}" };


int main(int argc, char** argv)
{
	CommandLineParser parser(argc, argv, String(keys));
	parser.about("This is test program for commandlineparser of opencv by kyungkoo jun");
	string inputImage1 = parser.get<string>("@imageName1");
	string inputImage2 = parser.get<string>("@imageName2");

	cout << "argument1 is : " << inputImage1 << endl;
	cout << "argument2 is : " << inputImage2 << endl;
	cout << "argument N is : " << parser.get<double>("N") << endl;

	if (parser.has("help") == true)
	{
		cout << "have help" << endl;
		parser.printMessage();
	}
	else
	{
		cout << "no help" << endl;
	}
	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

%
% 히스토그램 equalization
%
clear all;
close all;

% 테스트 데이터
% intensity - value
% data = [0 1;
%     1 2;
%     2 30;
%     3 50;
%     4 2;
%     5 2;
%     6 2;
%     7 30;
%     8 50;
%     9 2;
%     10 1;
%     ];

data = [0 1;
    1 2;
    2 30;
    3 50;
    4 100;
    5 2;
    6 2;
    7 1;
    8 1;
    9 2;
    10 1;
    ];

max_intensity = size(data,1)-1;

% 바그래프로 데이터를 출력
figure;
bar(data(:,1), data(:,2));
title('Original Histogram');
ylim([0, max(data(:,2)+10)]);

disp(sum(data(:,2)))

% cumulative 합을 계산
% intensity - cumulative 합
data_temp = data;
data_temp(:,2) = cumsum(data(:,2));
data1 = data;
data1(:,2) = round(max_intensity*cumsum(data(:,2))/sum(data(:,2)));

figure;
bar(data_temp(:,1), data_temp(:,2));
title('Cumulative Sum');
ylim([0, max(data_temp(:,2)+10)]);

% 바그래프로 cumulative합을 출력
figure;
bar(data1(:,1), data1(:,2));
title('Normalized Cumulative Sum');
ylim([0,max_intensity+1]);

% equalized data
equData = data;
equData(:,2) = zeros(max_intensity+1, 1);

for k=1:max_intensity+1
    newIntensity = data1(k,2);
    newIntensityIdx = newIntensity+1;
    equData(newIntensityIdx, 2) = equData(newIntensityIdx,2)+ data(k,2); 
end

figure;
bar(equData(:,1), equData(:,2));
title('Equalized Histogram');

disp(sum(equData(:,2)))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

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

using namespace cv;
using namespace std;

int main(int argc, char** argv)
{
	float data[10] = { 3, 4, 5, 6, 7, 3, 4, 2, 5, 3 };

	Mat m(1, 10, CV_32F, data);

	normalize(m, m, 1.0, 10.0, NORM_MINMAX);

	for (int r = 0; r < m.rows; r++)
	{
		for (int c = 0; c < m.cols; c++)
		{
			printf("%.2f ", m.at<float>(r, c));
		}
	}
	cout << endl;
	
	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

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

using namespace cv;
using namespace std;


int main(int argc, char** argv)
{

	Mat gimage, nimage;
	Mat src = imread("img_osaka_night.jpg");
	resize(src, src, Size(), 0.15, 0.15);

	cvtColor(src, gimage, CV_BGR2GRAY); 

	normalize(gimage, nimage, 128, 255, NORM_MINMAX);

	imshow("Original", gimage);
	imshow("Normalized:128-255", nimage);

	cout << ("Press any key to exit...\n");
	waitKey();

	return 0;
}