개발일지

int main(void)
{
	Mat image1(50, 512, CV_8UC1, Scalar(0));
	Mat image2(50, 512, CV_8UC1, Scalar(0));
	for (int i = 0; i < image1.rows; i++)
	{
		for (int j = 0; j < image1.cols; j++)
		{
			image1.at<uchar>(i, j) = j / 2;
			image2.at<uchar>(i, j) = (j / 20) * 10; // 20 pixel 단위
		}
	}
	imshow("image1", image1);
	imshow("image2", image2);
	waitKey();
	return 0;
}

int main(void)
{
	Mat image = imread("Image/bright.jpg", IMREAD_GRAYSCALE);
	if (image.empty())
	{
		cout << "영상 읽기 실패" << endl;
		exit(1);
	}
	Rect roi(500, 313, 20, 15);
	Mat roi_img = image(roi);
	cout << "[roi_img] = " << endl;
	for (int i = 0; i < roi_img.rows; i++)
	{
			for (int j = 0; j < roi_img.cols; j++)
			{
				cout.width(5);
				cout << (int)roi_img.at<uchar>(i, j);
			}
		cout << endl;
	}
	rectangle(image, roi, Scalar(255), 1);
	imshow("image", image);
	waitKey();
	return 0;
}

int main(void)
{
	Mat image = imread("Image/bright.jpg", IMREAD_GRAYSCALE);
	CV_Assert(!image.empty());
	// satuate_cast 연산
	Mat dst1 = image + 100;
	Mat dst2 = image - 100;
	Mat dst3 = 255 - image;
	Mat dst4(image.size(), image.type());
	Mat dst5(image.size(), image.type());
	for (int i = 0; i < image.rows; i++)
	{
		for (int j = 0; j < image.cols; j++)
		{
			dst4.at<uchar>(i, j) = saturate_cast<uchar>(image.at<uchar>(i, j) + 100);
			//dst4.at<uchar>(i, j) = image.at<uchar>(i, j) + 100;
			dst5.at<uchar>(i, j) = 255 - image.at<uchar>(i, j);
		}
	}
	imshow("Original", image);
	imshow("dst1 - 밝게", dst1);
	imshow("dst2 - 어둡게", dst2);
	imshow("dst3 - 반전", dst3);
	imshow("dst4 - 밝게", dst4);
	imshow("dst5 - 반전", dst5);
	waitKey();
	return 0;
}

int main(void)
{
	Mat image1 = imread("image/add1.jpg", IMREAD_GRAYSCALE);
	Mat image2 = imread("image/add2.jpg", IMREAD_GRAYSCALE);

	CV_Assert(!(image1.empty() || image2.empty()));
	double alpha = 0.6, beta = 0.7;

	Mat add_img1 = image1 + image2;
	Mat add_img2 = image1 * 0.5 + image2 * 0.5;
	Mat add_img3 = image1 * alpha + image2 * (1 - alpha);
	Mat add_img4;

	// add_img4 = image1 * alpha + image2 * beta + 0
	addWeighted(image1, alpha, image2, beta, 0, add_img4);

	imshow("image1", image1);
	imshow("add_img1", add_img1);
	imshow("add_img2", add_img2);
	imshow("add_img3", add_img3);
	imshow("add_img4", add_img4);

	waitKey();
	return 0;
}

   uchar data[] =
   {
      10,200,5,7,9,
      15,35,60,80,170,
      100,2,55,37,70
   };

   Mat m1(3, 5, CV_8U, data);
   Mat m2(3, 5, CV_8U, Scalar(50));
   cout << "[m1] = " << endl << m1 << endl;
   cout << "[m2] = " << endl << m2 << endl;

   Mat rMin;
   min(m1, 30, rMin);         //m1 행렬의 원소 중 30보다 큰 것들은 전부 '30'처리
   cout << "[rMin]=" << endl << rMin << endl;
   Mat rMax;
   max(m1, m2, rMax);         //m1의 원소와 m2의 원소를 비교하여 큰 원소가 반영됨
   cout << "[rMax]=" << endl << rMax << endl;

   double minVal, maxVal;
   Point minLoc, maxLoc;


   minMaxLoc(
      m1,
      &minVal,
      &maxVal,
      &minLoc,
      &maxLoc
   );
   cout << minVal << endl;         //m1 원소의 최소값
   cout << maxVal << endl;         //m1 원소의 최대값
   cout << minLoc << endl;         //
   cout << maxLoc << endl;

void showMatInfo(Mat mat, string str)
{
	cout << "채널 : " << mat.channels() << "\t\t";
	cout << "행열 : " << mat.size << endl;
	cout << str + " = " << endl << mat << endl;
	cout << "--------------------------------------" << endl << endl;
}

int main(void)
{
	Mat image = imread("image/minMax.jpg", IMREAD_GRAYSCALE);

	double minVal, maxVal;
	minMaxIdx(image, &minVal, &maxVal);
	cout << "최소값 = " << minVal << endl;
	cout << "최대값 = " << maxVal << endl;

	double ratio = (maxVal - minVal) / 255;

	cout << ratio << endl;
	// 0.301961

	Mat dest = (image - minVal) / ratio;

	imshow("dest", dest);
	imshow("image", image);
	waitKey();

}

	vector<Point> pt;
	pt.push_back(Point(0, 1));
	pt.push_back(Point(2, 3));
	pt.push_back(Point(4, 5));
	cout << pt << endl;

	Matx22f m(
		0, 1,  // 0 >> 0*0 + 1*1 = 1
		2, 3	// 1 >> 2*0 + 3*1 = 3
	);

	vector<Point> result;
	transform(pt, result, m);
	cout << result << endl;

int main(void)
{
	vector<Point> rect_pt1, rect_pt2;
	rect_pt1.push_back(Point(200, 50));
	rect_pt1.push_back(Point(400, 50));
	rect_pt1.push_back(Point(400, 250));
	rect_pt1.push_back(Point(200, 250));

	float theta = 20 * CV_PI / 180; // 라디안

	Matx22f m(cos(theta), -sin(theta), sin(theta), cos(theta));

	transform(rect_pt1, rect_pt2, m);

	Mat image(400, 500, CV_8UC3, Scalar(255, 255, 255));

	for (int i = 0; i < 4; i++)
	{
		line(image, rect_pt1[i], rect_pt1[(i + 1) % 4], Scalar(0, 0, 0), 1);
		line(image, rect_pt2[i], rect_pt2[(i + 1) % 4], Scalar(255, 0, 0), 2);
		cout << "rect_pt1[" << to_string(i) + "] = " << rect_pt1[i] << "\t";
		cout << "rect_pt2[" << to_string(i) + "] = " << rect_pt2[i] << endl;
	}
	imshow("image", image);
	waitKey();
	return 0;

}

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

using namespace cv;
using namespace std;



int main(void)
{
	Mat m = (Mat_<uchar>(3, 4) <<
		11, 13, 17, 26,
		39, 40, 42, 43,
		56, 72, 99, 88);
	cout << m << endl;

	//calcHist(
	// const Mat * images, 
	// int nimages,
	//	const int* channels, 
	// InputArray mask,
	//	SparseMat & hist, 
	// int dims,
	//	const int* histSize, 
	// const float** ranges,
	//	bool uniform = true, 
	//  bool accumulate = false);


	int channels[] = { 0 };
	Mat hist;
	int histSize[] = { 4 };
	float range[] = { 0,101 };
	const float* ranges[] = { range };
	calcHist(
		&m,//원본 이미지 설정
		1,
		channels,      //0번 채널만 계산(gray)
		Mat(),         //Matrix Masking을 하지 않겠다.
		hist,
		1,            //결과 매트리스를 몇차원으로 받을 것인가에 대한 설정
		histSize,
		ranges         //유효 범위를 설정한다(0,256)
	);

	cout << hist.t() << endl;

	waitKey(0);
	return 0;

}

int main(void)
{
	Mat m = (Mat_<Vec3b>(3, 4) <<
		Vec3b(10, 10, 40), Vec3b(20, 10, 40), Vec3b(30, 10, 40), Vec3b(40, 10, 40),
		Vec3b(50, 40, 40), Vec3b(60, 40, 40), Vec3b(70, 40, 40), Vec3b(80, 40, 40),
		Vec3b(90, 80, 90), Vec3b(80, 80, 90), Vec3b(70, 80, 90), Vec3b(60, 80, 90)
		);

	cout << m << endl;
	cout << m.channels() << endl;

	// 0 : [2, 3, 4, 3]
	int channels[] = { 0 };
	Mat hist;

	// 0 부터 100사이를 4 간격으로
	int histSize[] = { 4 };
	float range[] = { 0,101 };
	const float* ranges[] = { range };
	calcHist(
		&m,//원본 이미지 설정
		1,
		channels,      //0번 채널만 계산(gray)
		Mat(),         //Matrix Masking을 하지 않겠다.
		hist,
		1,            //결과 매트리스를 몇차원으로 받을 것인가에 대한 설정
		histSize,
		ranges         //유효 범위를 설정한다(0,256)
	);

	cout << hist.t() << endl;

	waitKey(0);
	return 0;

}

normalize()

int main(void)
{
	// 0 ~256 >> 10단계로 나누어서 누적값을 카운팅한 결과값이다.

	Mat hist = (Mat_<float>(1, 10) <<
		5000, 3000, 190, 6500, 1200,
		3500, 6000, 12000, 35000, 4000);

	cout << hist << endl << endl;

	//void normalize(
	// InputArray src, 
	// InputOutputArray dst, 
	// double alpha = 1, 
	// double beta = 0,
	//int norm_type = NORM_L2 );

	normalize(hist, hist, 0, 200, NORM_MINMAX ); //최소 190 을 0, 최대 35000을 200으로
	cout << hist << endl;

}

int main(void)
{
	// 0 ~256 >> 10단계로 나누어서 누적값을 카운팅한 결과값이다.

	Mat hist = (Mat_<float>(1, 10) <<
		5000, 3000, 190, 6500, 1200,
		3500, 6000, 12000, 35000, 4000);

	cout << hist << endl << endl;

	normalize(hist, hist, 1, 0, NORM_L1 ); // 총 합의 비율만큼 계산하기
	cout << hist << endl;
	cout << sum(hist) << endl;

}

int main(void)
{

	// calcHist로 데이터를 뽑았다고 친다.
	Mat hist = (Mat_<float>(1, 10) <<
		5000, 3000, 190, 6500, 1200,
		3500, 6000, 12000, 35000, 4000);

	cout << hist << endl << endl;

	normalize(hist, hist, 0, 200, NORM_MINMAX ); // 총 합의 비율만큼 계산하기
	cout << hist << endl << endl;
 


	Mat img(200, 256, CV_8U, 255);


	// 원래는 구해야 한다.
	float bin = 256 / 10; // img.Width / hist.Height

	// for문을 사용해야 되지만, 규칙을 찾기 위해 직접 기록.
	// [27, 16, 0, 36, 5, 19, 33, 67, 200, 21]
	rectangle(img, Point(0, 0), Point(25, 27), 128, -1);
	rectangle(img, Point(25, 0), Point(50, 16), 128, -1);
	rectangle(img, Point(50, 0), Point(75, 0), 128, -1);
	rectangle(img, Point(75, 0), Point(100, 36), 128, -1);
	rectangle(img, Point(100, 0), Point(125, 5), 128, -1);
	rectangle(img, Point(125, 0), Point(150, 19), 128, -1);
	rectangle(img, Point(150, 0), Point(175, 33), 128, -1);
	rectangle(img, Point(175, 0), Point(200, 67), 128, -1);
	rectangle(img, Point(200, 0), Point(225, 200), 128, -1);
	rectangle(img, Point(225, 0), Point(250, 21), 128, -1);


	flip(img, img, 0);
	imshow("1", img);
	waitKey();

}

이미지를 그레이스케일로 바꾸고 histgram을 통해 그래프 살펴보기

int main(void)
{
	Mat img = imread("image/tiger.bmp", IMREAD_GRAYSCALE);

 
	int channels[] = { 0 };
	Mat hist;

	// 0 부터 100사이를 4 간격으로
	int histSize[] = { 255 };
	float range[] = { 0,255 };
	const float* ranges[] = { range };

	calcHist(
		&img,//원본 이미지 설정
		1,
		channels,      //0번 채널만 계산(gray)
		Mat(),         //Matrix Masking을 하지 않겠다.
		hist,
		1,            //결과 매트리스를 몇차원으로 받을 것인가에 대한 설정
		histSize,
		ranges         //유효 범위를 설정한다(0,256)
	);


	normalize(hist, hist, 0, 200, NORM_MINMAX);
	Mat histImage(200, 256, CV_8U, 255);
	int bin = histSize[0] / (range[1] - range[0]);

	for (int i = 0; i < histSize[0]; i++)
	{
		rectangle(histImage, Point(i * bin, 0), Point((i + 1) * bin, (int)(hist.at<float>(i, 0))), 128, -1);
	}

	flip(histImage, histImage, 0);
	imshow("원본", img);
	imshow("gray", histImage);
	waitKey();

}

int main(void)
{
	Mat img = imread("image/tiger.bmp", IMREAD_COLOR);


	const int channel_B[] = { 0 };
	const int channel_G[] = { 1 };
	const int channel_R[] = { 2 };
	Mat histB, histG, histR;

	// 0 부터 100사이를 4 간격으로
	int histSize[] = { 255 };
	float range[] = { 0,255 };
	const float* ranges[] = { range };

	calcHist(&img, 1, channel_B, Mat(), histB, 1, histSize, ranges);
	calcHist(&img, 1, channel_G, Mat(), histG, 1, histSize, ranges);
	calcHist(&img, 1, channel_R, Mat(), histR, 1, histSize, ranges);

	Mat histImageB(200, 256, CV_8UC3, Scalar(0, 0, 0));
	normalize(histImageB, histImageB, 0, 200, NORM_MINMAX);
	Mat histImageG(200, 256, CV_8UC3, Scalar(0, 0, 0));
	normalize(histImageG, histImageG, 0, 200, NORM_MINMAX);
	Mat histImageR(200, 256, CV_8UC3, Scalar(0, 0, 0));
	normalize(histImageR, histImageR, 0, 200, NORM_MINMAX);
	int bin = img.cols / histSize[0];


	for (int i = 0; i < histSize[0]; i++)
	{
		rectangle(histImageB, Point(i * bin, 0), Point((i + 1) * bin, (int)(histB.at<float>(i, 0))), Scalar(255,0,0), -1);
		rectangle(histImageG, Point(i * bin, 0), Point((i + 1) * bin, (int)(histG.at<float>(i, 0))), Scalar(0, 255, 0), -1);
		rectangle(histImageR, Point(i * bin, 0), Point((i + 1) * bin, (int)(histR.at<float>(i, 0))), Scalar(0, 0, 255), -1);
	}

	flip(histImageB, histImageB, 0);
	flip(histImageG, histImageG, 0);
	flip(histImageR, histImageR, 0);
	imshow("원본", img);
	imshow("Blue", histImageB);
	imshow("Green", histImageG);
	imshow("Red", histImageR);
	waitKey();
}

위에꺼 함수화 처리??

void hist(Mat img, const int channel)
{
	int histSize[] = { 255 };
	float range[] = { 0,255 };
	const float* ranges[] = { range };
	Mat histcolor;
	int r, g, b;
	r = g = b = 0;
	string title;

	calcHist(&img, 1, &channel, Mat(), histcolor, 1, histSize, ranges);

	Mat histImage(200, 256, CV_8UC3, Scalar(0, 0, 0));
	normalize(histImage, histImage, 0, 200, NORM_MINMAX);

	int bin = img.cols / histSize[0];
	
	switch (channel)
	{
	case 0: title = "Blue"; b = 255; break;
	case 1: title = "Green";g = 255; break;
	case 2: title = "Red"; r = 255; break;
	default:
		break;
	}

	for (int i = 0; i < histSize[0]; i++)
		rectangle(histImage, Point(i * bin, 0), Point((i + 1) * bin, (int)(histcolor.at<float>(i, 0))), Scalar(b, g, r), -1);

	flip(histImage, histImage, 0);
	imshow(title, histImage);
}

int main(void)
{
	Mat img = imread("image/tiger.bmp", IMREAD_COLOR);

	const int channel_B =  0 ;
	const int channel_G =  1 ;
	const int channel_R =  2 ;
	Mat histB, histG, histR;

	hist(img, channel_B);
	hist(img, channel_G);
	hist(img, channel_R);

	imshow("원본", img);
	waitKey();
}

채널 합성 & 분리

int main(void)
{
	Mat img = imread("Image/tiger.bmp", IMREAD_COLOR);
	cout << img.channels() << endl;
	cout << img.rows << endl;
	cout << img.cols << endl;


	Mat ch0(3, 4, CV_8U, Scalar(10));
	cout << ch0 << endl << endl;
	Mat ch1(3, 4, CV_8U, Scalar(20));
	cout << ch1 << endl << endl;
	Mat ch2(3, 4, CV_8U, Scalar(30));
	cout << ch2 << endl << endl;

	Mat bgr_arr[] = { ch0, ch1, ch2 };
	cout << bgr_arr[2] << endl << endl;

	// 채널 합성
	Mat bgr;
	merge(bgr_arr, 3, bgr);
	cout << bgr << endl << endl;

	// 3채널을 >> 1채널 3개로 분리
	vector<Mat> bgr3;
	split(bgr, bgr3);

	cout << bgr3[0] << endl << endl;
	cout << bgr3[1] << endl << endl;
	cout << bgr3[2] << endl << endl;

}

int main(void)
{
	Mat img = imread("Image/tiger.bmp", IMREAD_COLOR);
	cout << img.channels() << endl;
	cout << img.rows << endl;
	cout << img.cols << endl;

	Mat bgr[3];
	split(img, bgr);

	//imshow("1" , img);
	//imshow("b" , bgr[0]);
	//imshow("g" , bgr[1]);
	//imshow("r" , bgr[2]);

	cout << bgr[0].channels() << endl;

	Mat temp(img.rows, img.cols, CV_8U, Scalar(0));

	Mat arr[3] = { temp, temp, bgr[2] };
	Mat result;
	merge(arr, 3, result);
	imshow("result", result);
	waitKey();

}

int main(void)
{
	uchar data[] = {
		0, 1, 2, 3,
		4, 5, 6, 7,
		8, 9, 0, 1
	};
	Mat ch0(3, 4, CV_8U, data);
	Mat ch1(3, 4, CV_8U, data);
	Mat ch2(3, 4, CV_8U, data);
	vector<Mat> vec;
	vec.push_back(ch0);
	vec.push_back(ch1);
	vec.push_back(ch2);

	Mat result;
	merge(vec, result);
	cout << result << endl;

}

오류나오는 코드

int main(void)
{
	uchar data[] = {
		0, 1, 2, 3,
		4, 5, 6, 7,
		8, 9, 0, 1
	};
	Mat ch0(3, 4, CV_8U, data);
	Mat ch1(3, 4, CV_8U, data);
	Mat ch2(3, 4, CV_8U, data);
	vector<Mat> vec;
	vec.push_back(ch0);
	vec.push_back(ch1);
	vec.push_back(ch2);

	// 3채널
	Mat result;
	merge(vec, result);
	cout << result << endl << endl;

	//2채널
	Mat m1(result.size(), CV_8UC2, Scalar(0));
	cout << m1 << endl << endl;

	//1채널
	Mat m2(result.size(), CV_8UC1, Scalar(0));
	cout << m2 << endl << endl;

	Mat out[] = { m1, m2 };

	int ar[] = {
		0, 0,
		2, 1,
		1, 2
	};

	mixChannels(&result, 1, out, 2, ar, 3);

		cout << m1 << endl << endl;
		cout << m2 << endl << endl;
}

void showMatInfo(Mat mat, string str)
{
	cout << "채널 : " << mat.channels() << "\t\t";
	cout << "행열 : " << mat.size << endl;
	cout << str + " = " << endl << mat << endl;
	cout << "--------------------------------------" << endl << endl;
}

int main(void)
{
	Mat m1(3, 6, CV_8UC1, Scalar(10));
	showMatInfo(m1, "m1");

	Mat m2(3, 6, CV_8UC1, Scalar(50));
	showMatInfo(m2, "m2");

	Mat mask(m1.size(), CV_8UC1, Scalar(0));
	showMatInfo(mask, "Mask");

	//
	Rect rect(Point(3, 0), Size(3, 3));
	cout << "rect.x = " << rect.x << endl;
	cout << "rect.y = " << rect.y << endl;
	cout << "rect.width = " << rect.width << endl;
	cout << "rect.height = " << rect.height << endl;

	//특정영역만 값을 설정
	mask(rect).setTo(1);
	showMatInfo(mask, "mask");

	//덧셈
	Mat m3;
	m3 = m1 + m2;
	showMatInfo(m3, "m3");
	add(m1, m2, m3);
	showMatInfo(m3, "m3");

	//덧셈 원하는 마스크 영역
	Mat m4;
	add(m1, m2, m4, mask);
	showMatInfo(m4, "m4");
	showMatInfo(mask, "mask");

	// 나눗셈
	Mat m5;
	divide(m2, m1, m5);
	showMatInfo(m5, "m5");

	//---------------
	Matx<float, 1, 5> m10(1, 2, 3, 5, 10);
	Mat m60;
	exp(m10, m60);
	showMatInfo(m60, "m60");
	log(m10, m60);
	showMatInfo(m60, "m60");
	sqrt(m10, m60);
	showMatInfo(m60, "m60");
	pow(m10,2, m60);
	showMatInfo(m60, "m60");


}

논리연산

int main(void)
{
	Mat image1(300, 300, CV_8U, Scalar(0));
	Mat image2(300, 300, CV_8U, Scalar(0));

	Point center = image1.size() / 2;
	circle(image1, center, 100, Scalar(255), -1);
	imshow("image1", image1);

	rectangle(image2,Point(0,0), Point(150,300), Scalar(255), -1);
	imshow("image2", image2);

	Mat image3;
	bitwise_or(image1, image2, image3);
	imshow("image3", image3);

	Mat image4;
	bitwise_and(image1, image2, image4);
	imshow("image4", image4);

	Mat image5;
	bitwise_xor(image1, image2, image5);
	imshow("image5", image5);

	Mat image6;
	bitwise_not(image1, image6);
	imshow("image6", image6);



	waitKey();
}

void showMatInfo(Mat mat, string str)
{
	cout << "채널 : " << mat.channels() << "\t\t";
	cout << "행열 : " << mat.size << endl;
	cout << str + " = " << endl << mat << endl;
	cout << "--------------------------------------" << endl << endl;
}

int main(void)
{
	char data[] = {
			10, 30, 40, 50,
			60, 70, 75, 90,
			100, 150, 200, 250
	};

	Mat image(3, 4, CV_8U, data);
	showMatInfo(image, "image");

	Mat result;
	threshold(image,  result, 70, 255, THRESH_BINARY);
	showMatInfo(result, "result");

}

int main(void)
{
	Mat image = imread("Image/bit_test.jpg", IMREAD_COLOR);
	Mat logo = imread("Image/logo.jpg", IMREAD_COLOR);

	//imshow("1", image);
	imshow("2", logo);


	Mat result1;
	// 이진화
	threshold(logo, result1, 70, 255, THRESH_BINARY);
	//imshow("3", result1);

	Mat masks[5];
	// 0, 1, 2은 값을 받는다. 2개는 놀고 있다.
	split(result1, masks);
	imshow("blue", masks[0]);
	imshow("green", masks[1]);
	imshow("red", masks[2]);

	bitwise_or(masks[0], masks[1],  masks[3]);
	bitwise_or(masks[2], masks[3], masks[3]);
	imshow("or", masks[3]);

	bitwise_not(masks[3], masks[4]);
	imshow("not", masks[4]);

	waitKey();
}

#include <opencv2/opencv.hpp>

using namespace cv;
using namespace std;


string title = "Event Drawing";
Mat image;

void onMouse(int event, int x, int y, int flags, void* param)
{
	static Point pt(-1, -1);

	switch (event)
	{
	case EVENT_LBUTTONDOWN:
		if (pt.x < 0)
			pt = Point(x, y);
		else
		{
			rectangle(image, pt, Point(x, y), Scalar(50), 2);
			imshow(title, image);
			pt = Point(-1, -1);
		}
		break;

	case EVENT_RBUTTONDOWN:
		if (pt.x < 0)
			pt = Point(x, y);
		else
		{
			Point2d pt2 = pt - Point(x, y);
			int radius = (int)sqrt(pt2.x * pt2.x + pt2.y * pt2.y);
			circle(image, pt, radius, Scalar(150), 2);
			imshow(title, image);
			pt = Point(-1, -1);
		}
		break;
	}
}

int main(void)
{
	image = Mat(300, 500, CV_8UC1, Scalar(255));

	imshow(title, image);
	setMouseCallback(title, onMouse, 0);

	waitKey(0);
	return 0;
}

별 그리기

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

using namespace cv;
using namespace std;


string title = "Star Drawing"; 
Mat image(400, 600, CV_8UC3, Scalar(255, 255, 255));

int main(void)
{
	int num = 5;
	int radius = 100;
	double deg = 360 / num; // degree
	double rad = deg / 180.0 * 3.141592;
	Point pt_zero = Point(300, 200);
	Point* pt;
	double pt_rad = 0;

	pt = new Point[num];

	for (int i = 0; i < num; i++)
	{
		pt[i].x = pt_zero.x + (radius * cos(pt_rad));
		pt[i].y = pt_zero.y + (radius * sin(pt_rad));
		pt_rad += rad;
	}

	for (int i = 0; i < num; i++)
	{
		int j = i + 2;
		j %= num;

		line(image, pt[i], pt[j], Scalar(255, 0, 0), 4, LINE_AA);
	}
	line(image, pt_zero, pt_zero, Scalar(255, 0, 0), 4, LINE_AA);
	imshow(title, image);

	waitKey(0);
	return 0;

}

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

using namespace cv;
using namespace std;


string title = "Star Drawing";
Mat image(400, 600, CV_8UC3, Scalar(255, 255, 255));

int main(void)
{
	Mat img = imread("Image/cat1.jpg", IMREAD_COLOR);


	cout << format("dims(%d)", img.dims) << endl;				// 차원
	cout << format("width(%d)", img.size().width) << endl;			// 가로
	cout << format("height(%d)", img.size().height) << endl;		// 세로
	cout << format("rows(%d)", img.rows) << endl;				// 가로
	cout << format("cols(%d)", img.cols) << endl;				// 세로
	cout << img.size() << endl;										//

	cout << format("depth(%d)", img.depth()) << endl;				//
	cout << format("channels(%d)", img.channels()) << endl;			// 점의 개수
	cout << format("total(%d)", img.total()) << endl;			// 점의 개수
	cout << img.rows * img.cols << endl;					// 점 1개당 바이트 수
	cout << format("elemSize(%d)", img.elemSize()) << endl;			// 점 1개의 칼라 바이트 수
	cout << "type" << img.type() << " " << CV_8UC3 << endl;			//

	Rect roi(0, 0, 3, 2); // Region of Interest
	cout << img(roi) << endl;

	imshow(title, img);
	waitKey(0);
	return 0;

}

그레이스케일 값 넣어보기

int main(void)
{
	Mat img = imread("image/cat1.jpg", IMREAD_COLOR);

	for (int row = 0; row < img.rows; row++)
	{
		for (int col = 0; col < img.cols; col++)
		{
			Vec3b v = img.at<Vec3b>(row, col);
			uchar value = (uchar)((double)v[0] * 0.11 + (double)v[1] * 0.3 + (double)v[2] * 0.59);
			Vec3b result(value, value, value);
			img.at<Vec3b>(row, col) = result;
		}
	}

	imshow("img", img);
	waitKey();

}

파일 압축 복사하기

int main(void)
{
	Mat img = imread("Image/cat1.jpg", IMREAD_COLOR);

	vector<int> att;
	att.push_back(IMWRITE_JPEG_QUALITY);
	att.push_back(25); // 95

	imwrite("Image/cat1_001.jpg", img); // 파일 복사하기
	imwrite("Image/cat1_002.jpg", img, att); // 파일 복사하기


	waitKey(0);
	return 0;

}

int main(void)
{
	Mat img1 = imread("Image/고기.jpg", IMREAD_COLOR);
	Mat img2;
	flip(img1, img2, 0);  // 0 : x 축

	Mat img3;
	flip(img1, img3, 1);  // 1 : y 축

	Mat img4;
	flip(img1, img4, -1);  // -1 : 원점대칭

	Mat img5;
	repeat(img1, 2, 3, img5);//2행3열만큼 반복(6개)

	Mat img6;
	transpose(img1, img6);   //90도 회전전치

	imshow("img1", img1);
	imshow("img2", img2);
	imshow("img3", img3);
	imshow("img4", img4);
	imshow("img5", img5);
	imshow("img6", img6);


	waitKey(0);
	return 0;

}

flip 사용하지 않고 90도 회전, 상하좌우 만들기

	Mat img7(img1.rows, img1.cols, CV_8UC3);
	Mat img8(img1.cols, img1.rows, CV_8UC3);

	for (int rows = 0; rows < img1.rows; rows++)
	{
		for (int cols = 0; cols < img1.cols; cols++)
		{
			Vec3b v = img1.at<Vec3b>(rows, cols);
			img7.at<Vec3b>(rows, img1.cols - 1 - cols) = v;
			img8.at<Vec3b>(img1.cols - 1 - cols, rows) = v;
		}
	}

	imshow("img7", img7);
	imshow("img8", img8);

키보드 제어하기

#include <opencv2/opencv.hpp>

using namespace cv;
using namespace std;

//cout << "[m2] = " << endl << m2 << endl;


int main(void)
{
	Mat image(200, 300, CV_8U, 255);
	namedWindow("키보드", WINDOW_AUTOSIZE);
	imshow("키보드", image);

	while (1)
	{
		int key = waitKeyEx(20);
		if (key == 27) // esc : 27
			break;

		switch (key)
		{
		case 'a': cout << "a 입력" << endl;
			break;
		case 'b': cout << "b 입력" << endl;
			break;
		case 0x41: cout << "A 입력" << endl;
			break;
		case 66: cout << "B 입력" << endl;
			break;
		case 0x250000: cout << "왼쪽 화살표 입력" << endl;
			break;
		case 0x260000: cout << "위쪽 화살표 입력" << endl;
			break;
		case 0x270000: cout << "오른쪽 화살표 입력" << endl;
			break;
		case 0x280000: cout << "아래쪽 화살표 입력" << endl;
			break;
		}
	}

	return 0;
}

이미지 출력

int main(void)
{
	string fileName = "Image/cat1.jpg";
	Mat image = imread(fileName, IMREAD_COLOR);
	imshow("image", image);

	waitKey();

	return 0;
}

트랙바 이벤트

#include <opencv2/opencv.hpp>

using namespace cv;
using namespace std;

//cout << "[m2] = " << endl << m2 << endl;

string title = "트랙바";
Mat image;

void onChange(int value, void* userData)
{
	int add_value = value - 127;
	cout << "추가 화소값" << add_value << endl;
	Mat tmp = image + add_value;
	imshow(title, tmp);
}

int main(void)
{
	int value = 128;
	image = Mat(300, 400, CV_8UC1, Scalar(120));

	namedWindow(title, WINDOW_AUTOSIZE);
	createTrackbar("밝기값", title, &value, 255, onChange);

	imshow(title, image);
	waitKey(0);

	return 0;
}

선, 사각형 그리기

#include <opencv2/opencv.hpp>

using namespace cv;
using namespace std;


int main(void)
{
	Scalar red(0, 0, 255), green(0, 255, 0), blue(255, 0, 0);
	Scalar white(255, 255, 255);
	Scalar yellow(0, 255, 255);

	Mat image(400, 600, CV_8UC3, white);
	Point pt1(50, 130), pt2(200, 300), pt3(300, 150), pt4(400, 50);
	Rect rect(pt3, Size(200, 150));

	// void line(
	// InputOutputArray img, 
	// Point pt1, 
	// Point pt2, 
	// const Scalar& color,
	//	int thickness = 1, int lineType = LINE_8, int shift = 0);


	line(image, pt1, pt2, red);
	line(image, pt3, pt4, green, 2, LINE_AA);
	line(image, pt3, pt4, blue, 6, LINE_8, 1);//모든 좌표값 >> 1 (크기가 1/2 배)

	rectangle(image, rect, green, 2);
	//FILLED : 색 체우기
	rectangle(image, rect, blue, FILLED, LINE_4, 1);//모든 좌표값 >> 1 (크기가 1/2 배)
	rectangle(image, pt1, pt2, red, 3);

	imshow("직선 사각형", image);
	waitKey(0);

	return 0;
}

int main(void)
{
	Scalar olive(128, 128, 0), violet(221, 160, 221), brown(42, 42, 165);
	Point pt1(20, 100), pt2(20, 200), pt3(20, 250);

	Mat image(300, 500, CV_8UC3, Scalar(255, 255, 255));

	//void putText( 
	// InputOutputArray img, 
	// const String& text, 
	// Point org,
	// int fontFace, 
	// double fontScale, 
	// Scalar color,
	//	int thickness = 1, int lineType = LINE_8, bool bottomLeftOrigin = false );

	putText(image, "SIMPLEX", Point(20, 30), FONT_HERSHEY_SIMPLEX, 1, brown);
	putText(image, "DUPLEX", pt1, FONT_HERSHEY_DUPLEX, 2, olive);
	putText(image, "TRIPLEX", pt2, FONT_HERSHEY_TRIPLEX, 3, violet);
	putText(image, "ITALIC", pt3, FONT_HERSHEY_PLAIN | FONT_ITALIC, 2, violet);

	imshow("putText", image);
	waitKey(0);

	return 0;
}

원 만들기

int main(void)
{
	Scalar orange(0, 165, 255), blue(255, 0, 0), magenta(255, 0, 255);
	Mat image(300, 500, CV_8UC3, Scalar(255, 255, 255));

	Point center = (Point)image.size() / 2;
	Point pt1(70, 50), pt2(350, 220);

	//void circle(
	// InputOutputArray img, 
	// Point center, 
	// int radius,
	//	const Scalar & color, int thickness = 1,	int lineType = LINE_8, int shift = 0);

	circle(image, center, 100, blue);
	circle(image, pt1, 80, orange, 2);
	circle(image, pt2, 60, magenta, -1);

	int font = FONT_HERSHEY_COMPLEX;
	putText(image, "center_blue", center, font, 1.2, blue);
	putText(image, "pt1_orange", pt1, font, 0.8, orange);
	putText(image, "pt2_magenta", pt2 + Point(2, 2), font, 0.5, Scalar(0, 0, 0), 2);
	putText(image, "pt2_magenta", pt2, font, 0.5, magenta, 1);

	imshow("원", image);
	waitKey(0);

	return 0;
}

타원 만들기

int main(void)
{
	Scalar orange(0, 165, 255), blue(255, 0, 0), magenta(255, 0, 255);
	Mat image(300, 700, CV_8UC3, Scalar(255, 255, 255));

	Point pt1(120, 150), pt2(550, 150);

	circle(image, pt1, 1, Scalar(0), 1);
	circle(image, pt2, 1, Scalar(0), 1);

	//void ellipse(
	// InputOutputArray img, 
	// Point center, 
	// Size axes,
	//	double angle,   //회전 각도
	// double startAngle, 
	// double endAngle,  
	//	const Scalar & color, int thickness = 1,	int lineType = LINE_8, int shift = 0);

	ellipse(image, pt1, Size(100, 60), 0, 0, 360, orange, 2);
	ellipse(image, pt1, Size(100, 60), 0, 30, 270, blue, 4);

	ellipse(image, pt2, Size(100, 60), 30, 0, 360, orange, 2);
	ellipse(image, pt2, Size(100, 60), 30, -30, 160, blue, 4);
	//ellipse(image, pt2, Size(100, 60), 30, 330, 160, blue, 4);

	imshow("타원", image);
	waitKey(0);


	return 0;
}

#include <opencv2/opencv.hpp>

using namespace cv;
using namespace std;


int main(void)
{
	// 행렬(height , width)
	Matx <float, 2, 3> m1 (1,2,3,4,5,6);
	cout << "[m1] = "<< endl << m1 << endl;

	//m1(행, 열)
	cout << m1(0, 0) << endl;
	cout << m1(1, 2) << endl;


	Matx23f m2(1, 2, 3, 4, 5, 6);
	cout << "[m2] = " << endl << m2 << endl;


		return 0;
}

#include <opencv2/opencv.hpp>

using namespace cv;
using namespace std;


//CV_8U 은 생략형이다 CV_8UC1
//#define CV_8U   0
//#define CV_8S   1
//#define CV_16U  2
//#define CV_16S  3
//#define CV_32S  4
//#define CV_32F  5
//#define CV_64F  6
//#define CV_16F  7


int main(void)
{
	// 행, 열, CV_타입채널
	// 행, 열, CV_타입1
	// Pixel (Gray)

	//ex1)
	Mat m1(2, 3, CV_8U);
	cout << "[m1] = " << endl << m1 << endl;

	//ex2)
	// Mat m2(2, 3, CV_8U, 20);
	Mat m2(2, 3, CV_8U, Scalar(20));  //Scalar 는 내부에 sRGB 값이 들어갈 수 있다.
	cout << "[m2] = " << endl << m2 << endl;

	return 0;
}

#include <opencv2/opencv.hpp>

using namespace cv;
using namespace std;


int main(void)
{
	// 행, 열, CV_타입채널
	// 행, 열, CV_타입1
	// Pixel (Gray)

	//ex1)
	Mat m1(2, 3, CV_8U);
	cout << "[m1] = " << endl << m1 << endl;

	//ex2)
	// Mat m2(2, 3, CV_8U, 20);
	// Red[0 255] [0 65534] [0 65534] [0 65534]
	// 초기화 방법
	//Scalar 는 내부에 sRGB 값이 들어갈 수 있다.
	// 최대값 255로 고정 
	Mat m2(2, 3, CV_8U, Scalar(400)); 
	cout << "[m2] = " << endl << m2 << endl;


	float data[] =
	{
		1.1f, 2.2f, 3.3f,
		4.4f, 5.5f, 6.6f
	};
	Mat m3(2, 3, CV_32F, data);
	cout << "[m3] = " << endl << m3 << endl;

	double data1[] =
	{
		1.1, 2.2, 3.3,
		4.4, 5.5, 6.6
	};

	Mat m4 = (Mat_<uchar>(2, 4) << 1, 2, 3, 4, 5, 6, 7, 8);
	cout << "[m4] = " << endl << m4 << endl;


	return 0;
}

int main(void)
{
	//Mat static
	cout << CV_8U << endl;
	cout << CV_8UC1 << endl;

	Mat m1 = Mat::ones(3, 4, CV_8U);
	cout << "[m1] = " << endl << m1 << endl;


	Mat m2 = Mat::zeros(3, 4, CV_8U);
	cout << "[m2] = " << endl << m2 << endl;


	Mat m3 = Mat::eye(3, 4, CV_8U);  //eye 단위행렬
	cout << "[m3] = " << endl << m3 << endl;

	return 0;
}

int main(void)
{
	Mat_<int> m1(2, 4, 100);
	m1 << 1, 2, 3, 4, 5, 6, 7, 8;

	// 부모 = 자식; // 부 = 자
	// 업캐스팅

	Mat m2 = m1;
	cout << "[m2] = " << endl << m2 << endl;

	Mat m3(5, 3, CV_32FC3); // float(b) float(g) float(r)
	cout << "차원수 = " << m3.dims << endl;
	cout << "행 개수 = " << m3.rows << endl;
	cout << "열 개수 = " << m3.cols << endl;
	cout << "행렬 크기 = " << m3.size() << endl;
	cout << "전체 원소(픽셀) 크기 = " << m3.total() << endl;
	cout << "한 원소(픽셀) 크기 = " << m3.elemSize() << endl;
	cout << "채널당 원소의 크기 = " << m3.elemSize1() << endl;
	cout << "채널의 개수 = " << m3.channels() << endl;
	// #define CV_32F		5
	cout << "깊이 = " << m3.depth() << endl;

	// 1. 원소(화소)1개 : float(b) float(g) float(r)
	// 2. CV_32FC3 선택한다.
	// 3. CV_깊이채널 : >> CV_깊이(5)채널(3)
	// 4. CV_32FC3의 상수값은 21이다.
	cout << "CV_32FC3 = " << CV_32FC3 << endl;


	return 0;
}

int main(void)
{
	//1.(+,-,/)는 성분끼리 일어난다.(*,%는 없다.)
	Mat m1(2, 3, CV_8U, 13);      //13
	Mat m2(2, 3, CV_8U, 3);         //3
	cout << endl << m1 + m2 << endl;      //모든 성분의 값 : 13 +3 =16
	cout << endl << m1 - m2 << endl;      //모든 성분의 값 : 13 -3 =10

	//2. 성분끼리 곱하고 싶은 경우
	cout << m1.mul(m2) << endl;            //모든 성분의 값 : 13 *3 =32

	//3. *는 수학적인 곱을 의미한다.
	// 
	//4. float에서만 연산이 가능하다.
	Mat m3(2, 3, CV_32F, 3.0f);
	Mat m4(3, 2, CV_32F, 4.0f);
	cout << m3 * m4 << endl << endl;

	//5. Mat * 스칼라 : 4칙 연산 모두 성립한다.
	Mat m5(2, 3, CV_8U, 3);
	cout << m5 + 3 << endl << endl;
	cout << m5 - 3 << endl << endl;
	cout << m5 * 3 << endl << endl;
	cout << m5 * 0.3 << endl << endl;
	cout << m5 / 3 << endl << endl;


	// 6. 정수에 대한 / 에 대해서는 결과값에 대하여 사사오입이 일어한다

	// 7. 스칼라 대입시에 모두 초기화가 된다.
	Mat m6(2, 3, CV_8U, 5);
	m6 = 100;
	cout << m6 << endl << endl;

	// 8.
	Mat m7 = m6;
	cout << m7 << endl << endl;
	m7 = 200;
	cout << "[m6] = " << m6 << endl << endl;

	return 0;
}

#include <opencv2/opencv.hpp>

using namespace cv;
using namespace std;

//cout << "[m2] = " << endl << m2 << endl;

void matInfo(string n, Mat m)
{
	cout << "[" << n << "행렬]" << endl;
	cout << "채널수 = " << m.channels() << endl;
	cout << "행 x 열 = " << m.rows << " X " << m.cols << endl << endl;
	cout << m << endl << endl;
}
int main(void)
{
	// Mat 크기 변동, 형태
	Mat m = (Mat_<uchar>(2, 4) << 1, 2, 3, 4, 5, 6, 7, 8);
	cout << "[m] = " << endl << m << endl << endl;

	//로우 크기 변경
	// 작으면 잘라버리고, 많으면 행이 추가된다.
	m.resize(1);
	cout << "[m] = " << endl << m << endl << endl;

	m.resize(3);
	cout << "[m] = " << endl << m << endl << endl;

	m.resize(5, 100);
	cout << "[m] = " << endl << m << endl << endl;


	Mat m1 = (Mat_<uchar>(2, 6) << 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12);
	matInfo("m1", m1);

	// 채널 변경
	Mat m2 = m1.reshape(2);
	matInfo("m2", m2);

	// 채널, 로우
	Mat m3 = m1.reshape(3, 2);
	matInfo("m3", m3);

	m1.create(3, 5, CV_16S);
	matInfo("m1", m1);


	return 0;
}

int main(void)
{

	double data[] = { 1.1, 2.2, 3.3, 4.4,
	5.5, 6.6, 7.7, 8.9,
	9.9, 10, 11, 12 };
	Mat m1(3, 4, CV_64F, data);
	Mat m2 = m1.clone();
	Mat m3, m4;
	m1.copyTo(m3);
	m1.convertTo(m4, CV_8U);
	cout << "m1 = " << m1 << endl << endl;
	cout << "m2 = " << m2 << endl << endl;
	cout << "m3 = " << m3 << endl << endl;
	cout << "m4 = " << m4 << endl << endl;

	return 0;
}

int main(void)
{
	vector<float> v1(5, 3.14f);
	//cout << v1 << endl;
	//첫 인자가 행 갯수이고 두번째가 초기값 설정
	cout << (Mat)v1 << endl;
	Mat m1 = (Mat)v1;
	cout << m1.channels() << endl;
	cout << m1.rows << endl;
	cout << m1.cols << endl;
	cout << ((Mat)v1).reshape(1, 1) << endl;
	
	//
	vector<Point> v2;
	v2.push_back(Point(1, 2));
	v2.push_back(Point(3, 4));
	v2.push_back(Point(5, 6));
	cout << v2.size() << endl;

	cout << v2 << endl;
	cout << (Mat)v2 << endl;
	cout << ((Mat)v2).reshape(1, 2) << endl;

	int ar1[] = { 10, 20, 30, 40, 50, 60 };
	int num; // &num
	// ar1[0]			&ar1[0]
	//*(ar1+0)			ar1

	vector<int> v3(ar1, ar1 + sizeof(ar1) / sizeof(int));
	cout << ((Mat)v3).reshape(1, 1) << endl;

	Size ar2[] = { Size(1,2), Size(3,4), Size(5,6) };
	vector<Size> v4(ar2, ar2 + sizeof(ar2) / sizeof(Size));
	cout << "last : " << ((Mat)v4).reshape(1, 1) << endl;

	return 0;
}

int main(void)
{
	int arr[] = { 10, 20, 30, 40, 50 };
	vector<int> v1(arr, arr + sizeof(arr) / sizeof(int));
	cout << v1.size() << endl;
	cout << ((Mat)v1).reshape(1, 1) << endl;

	v1.insert(v1.begin() + 2, 100);
	cout << ((Mat)v1).reshape(1, 1) << endl;

	v1[0] = 300;
	cout << ((Mat)v1).reshape(1, 1) << endl;

	v1.erase(v1.begin() + 3);
	cout << ((Mat)v1).reshape(1, 1) << endl;

	v1.clear();

	return 0;
}

#include <opencv2/opencv.hpp>

using namespace cv;
using namespace std;

int main(void)
{
	// 행렬의 약자.
	// 사용은 할수 있는 형태이다.
	//Mat image;
	// 200 : 가로 해상도
	// 300 : 세로 해상도
	// CV_8U : 8bit unsigned char(gray)
	// 255 (세로, 가로)
	Mat image(200, 300, CV_8U, Scalar(255));
	cout << "행 개수 : " << image.rows << endl;
	cout << "열 개수 : " << image.cols << endl;


	// 윈도우 창 생성
	string title = "윈도우";
	namedWindow(title, WINDOW_AUTOSIZE);
	moveWindow(title, 100, 200);
	imshow(title, image);

	//블로킹 용도로 사용
	waitKey();

}

	Mat image(600, 800, CV_8U, Scalar(0)); // 0은 검은색 255는 흰색

Point 활용

#include <opencv2/opencv.hpp>

using namespace cv;
using namespace std;

int main(void)
{
	//제너릭 방식
	Point_<int> pt1(100, 200);
	cout << pt1 << endl; // [100,200]
	cout << pt1.x << endl;  //  100
	cout << pt1.y << endl;  //  200

	Point_<float> pt2(10.12f, 20.20f);
	cout << pt2 << endl; // [10.12,20.2]
	cout << pt2.x << endl;  //  10.12
	cout << pt2.y << endl;  //  20.2

	//2i 가 정수타입
	// typedef Point_<int> Point2i;
	Point2i pt3(100, 200); 
	cout << pt3 << endl; //  [100,200]
	cout << pt3.x << endl;  //  100
	cout << pt3.y << endl;  //  200

	Point2i a(3, 4), b(4, 5);
	Point2i c = a + b; // 벡터 합
	cout << c << endl;

	Point2i d = c * 2;
	cout << d << endl;

	//int e = a.dot(b); // 내적 
	cout << a.dot(b) << endl;

	Point f(1, 2), g(1, 2);
	cout << (f == g) << endl;  //비교 가능

	Point h(1, 2);
	Point2f i(1.0f, 2.0f);
	Point j = h + (Point)i;
	cout << j << endl;  // [2, 4]

	Point3i k(1, 2, 3);
	cout << k << endl;  // [1, 2, 3]


}

#include <opencv2/opencv.hpp>

using namespace cv;
using namespace std;

int main(void)
{
	Size t;
	Size_<int> a(10, 20);
	cout << a << endl;

	Size2i b(10, 20);
	cout << b.width << endl;
	cout << b.height << endl;
	cout << b.area() << endl;

}

#include <opencv2/opencv.hpp>

using namespace cv;
using namespace std;

int main(void)
{
	/*
	_Tp x; //!< x coordinate of the top-left corner
	_Tp y; //!< y coordinate of the top-left corner
	_Tp width; //!< width of the rectangle
	_Tp height; // !< height of the rectangle
	*/

	Rect t(10, 20, 30, 40);
	cout << t << endl;
	cout << t.x << endl;
	cout << t.y << endl;
	cout << t.width << endl;
	cout << t.height << endl;

	Rect s(Point(1, 2), Point(3, 4));
	cout << s << endl;
}

#include <opencv2/opencv.hpp>

using namespace cv;
using namespace std;

int main(void)
{
	
	Vec<int, 5> v1(1, 2, 3, 4, 5);
	cout << v1 << endl;

	Vec3i v2(1, 2, 3);
	Vec3i v3(3, 6, 7);
	Vec3i v4 = v2 + v3;
	cout << v4 << endl;
	cout << v4[0] << endl;
	cout << v2 * 3 << endl;


}

#include <opencv2/opencv.hpp>

using namespace cv;
using namespace std;

void onMouse(int e, int x, int y, int f, void *p)
{
	switch ( e)
	{
	case EVENT_LBUTTONDOWN:
		cout << 1<< ":" <<*(int *)p << endl;
		break;

	case EVENT_RBUTTONDOWN:
		cout << 2 << endl;
		break;

	case EVENT_LBUTTONUP:
		cout << 3 << endl;
		break;

	case EVENT_RBUTTONUP:
		cout << 4 << endl;
		break;

	case EVENT_MOUSEMOVE:
		cout << x<< " " << y << endl;
		break;


	default:
		break;
	}
}

int main(void)
{
	//  B G R
	Scalar red(0, 0, 255);
	cout << red << endl;  // [0, 0,  255, 0]

	Mat image(200, 300, CV_8U);
	image.setTo(255);
	// UI
	imshow("마우스", image);

	// event1
	int num = 10;
	setMouseCallback("마우스", onMouse, &num);


	waitKey();


}