struct Test{

private:

int num;

char str;

void Initialize();

public:

int i;

int j;

void func(int n);

protected:

float k;

};

void main()

{

Test test;

test.num=1; // 에러

test.i=10; // 대입 가능

test.func(3); // 호출 가능

test.Initialize(); // 에러

} 

// BGR -> GRAY

Mat ColorToGray(Mat& src)

{

Mat gray;

assert(src.type() != CV_8UC3);

vector<Mat> channels;

split(src,channels);

gray = (0.333 * channels[0]) + (0.333 * channels[1]) + (0.333 * channels[2]);

return gray;

}

#include <iostream>

#include <opencv2/core/core.hpp>

#include <opencv2/imgproc/imgproc.hpp>

#include <opencv2/highgui/highgui.hpp>

using namespace cv;

int main()

{

Mat gray_img = imread("lena.tif", 0);

if (!gray_img.data) return -1; 

// 고정 임계 값 처리

Mat bin_img, bininv_img, trunc_img, tozero_img, tozeroinv_img;

// 입력 이미지 출력 이미지, 임계 값, maxVal, 임계 값 처리 방법

threshold(gray_img, bin_img, 0, 255, THRESH_BINARY | THRESH_OTSU);

threshold(gray_img, bininv_img, 0, 255, THRESH_BINARY_INV | THRESH_OTSU);

threshold(gray_img, trunc_img, 0, 255, THRESH_TRUNC | THRESH_OTSU);

threshold(gray_img, tozero_img, 0, 255, THRESH_TOZERO | THRESH_OTSU);

threshold(gray_img, tozeroinv_img, 0, 255, THRESH_TOZERO_INV | THRESH_OTSU);

// 적응적인 임계 값 처리

Mat adaptive_img;

// 입력 이미지 출력 이미지 maxVal, 임계 값 결정 방법, 임계 값 처리 방법, blockSize, C

adaptiveThreshold (gray_img, adaptive_img, 255, ADAPTIVE_THRESH_GAUSSIAN_C, THRESH_BINARY, 7, 8);

// 결과 이​​미지보기

namedWindow("Binary",CV_WINDOW_AUTOSIZE | CV_WINDOW_FREERATIO);

namedWindow("Binary Inv",CV_WINDOW_AUTOSIZE | CV_WINDOW_FREERATIO);

namedWindow("Trunc",CV_WINDOW_AUTOSIZE | CV_WINDOW_FREERATIO);

namedWindow("ToZero",CV_WINDOW_AUTOSIZE | CV_WINDOW_FREERATIO);

namedWindow("ToZero Inv",CV_WINDOW_AUTOSIZE | CV_WINDOW_FREERATIO);

namedWindow("Adaptive",CV_WINDOW_AUTOSIZE | CV_WINDOW_FREERATIO);

imshow("Binary",bin_img);

imshow("Binary Inv",bininv_img);

imshow("Trunc",trunc_img);

imshow("ToZero",tozero_img);

imshow("ToZero Inv",tozeroinv_img);

imshow("Adaptive",adaptive_img);

waitKey(0);

return 0;

}

#include <iostream>

#include <opencv2/core/core.hpp>

#include <opencv2/imgproc/imgproc.hpp>

#include <opencv2/highgui/highgui.hpp>

using namespace cv;

int main() {

Mat src_img = imread("lena.tif", 1);

if (!src_img.data) return -1; 

// NOT 연산

Mat dst_img = ~src_img;

namedWindow("src image",CV_WINDOW_AUTOSIZE | CV_WINDOW_FREERATIO);

namedWindow("dst image",CV_WINDOW_AUTOSIZE | CV_WINDOW_FREERATIO);

imshow("src image",src_img);

imshow("dst image",dst_img);

waitKey(0);

return 0;

}

#include <iostream>

#include <opencv2/core/core.hpp>

#include <opencv2/imgproc/imgproc.hpp>

#include <opencv2/highgui/highgui.hpp>

using namespace cv;

int main()

{

Mat src_img = imread("lena.tif", 1);

if (!src_img.data) return -1; 

Mat dst_img1;

Mat dst_img2(src_img.rows * 0.5, src_img.cols * 2.0, src_img.type ());

Mat v_img, h_img, b_img;

flip(src_img, v_img, 0); // 수평으로 반전 (수직 반전)

flip(src_img, h_img, 1); // 수직으로 반전 (수평 반전)

flip(src_img, b_img, -1); // 두 축으로 반전 (수직 반전 + 수평 반전)

namedWindow("vertical flip image",CV_WINDOW_AUTOSIZE | CV_WINDOW_FREERATIO);

namedWindow("horizo​​ntal flip image",CV_WINDOW_AUTOSIZE | CV_WINDOW_FREERATIO);

namedWindow("both flip image",CV_WINDOW_AUTOSIZE | CV_WINDOW_FREERATIO);

imshow("vertical flip image",v_img);

imshow("horizo​​ntal flip image",h_img);

imshow("both flip image",b_img);

waitKey(0);

return 0;

}

#include <iostream>

#include <opencv2/core/core.hpp>

#include <opencv2/imgproc/imgproc.hpp>

#include <opencv2/highgui/highgui.hpp>

using namespace cv;

int main()

{

Mat src_img = imread("lena.tif", 1);

if (!src_img.data) return -1; 

Mat dst_img1;

Mat dst_img2(src_img.rows * 0.5, src_img.cols * 2.0, src_img.type ());

// INTER_LINER (이중 선형 보간)의 크기 변경

resize (src_img, dst_img1, cv :: Size (), 0.5, 0.5);

// INTER_CUBIC (바이 큐빅 보간)의 크기 변경

resize (src_img, dst_img2, dst_img2.size(), INTER_CUBIC);

namedWindow ( "resize image1",CV_WINDOW_AUTOSIZE | CV_WINDOW_FREERATIO);

namedWindow ( "resize image2",CV_WINDOW_AUTOSIZE | CV_WINDOW_FREERATIO);

imshow ( "resize image1",dst_img1);

imshow ( "resize image2",dst_img2);

waitKey(0);

return 0;

}

#include <iostream>

#include <opencv2/core/core.hpp>

#include <opencv2/imgproc/imgproc.hpp>

#include <opencv2/highgui/highgui.hpp>

using namespace cv;

int main()

{

Mat bgr_img = imread ( "lena.tif", 1);

if (!bgr_img.data) return -1; 

Mat dst_img;

// BGR -> HSV

cvtColor (bgr_img, dst_img, CV_BGR2HSV);

imshow("BGR -> HSV",dst_img);

// BGR -> Lab

cvtColor (bgr_img, dst_img, CV_BGR2Lab);

imshow("BGR -> Lab",dst_img);

// BGR -> YCrCb

cvtColor (bgr_img, dst_img, CV_BGR2YCrCb);

imshow("BGR -> YCrCb",dst_img);

  // BGR -> XYZ

cvtColor(bgr_img, dst_img, CV_BGR2XYZ);

imshow("BGR -> XYZ",dst_img);

waitKey(0);

return 0;

}

#include <iostream>

#include <opencv2/core/core.hpp>

#include <opencv2/highgui/highgui.hpp>

using namespace cv;

int main()

{

// 초기화시에 칠

Mat red_img(Size(640, 480), CV_8UC3, Scalar(0,0,255));

Mat white_img(Size(640, 480), CV_8UC3, Scalar::all(255));

Mat black_img = Mat::zeros(Size (640, 480), CV_8UC3); 

// 초기화 후 채우기

Mat green_img = red_img.clone();

green_img = Scalar(0,255,0);

namedWindow("red image",CV_WINDOW_AUTOSIZE | CV_WINDOW_FREERATIO);

namedWindow("white image",CV_WINDOW_AUTOSIZE | CV_WINDOW_FREERATIO);

namedWindow("black image",CV_WINDOW_AUTOSIZE | CV_WINDOW_FREERATIO);

namedWindow("green image",CV_WINDOW_AUTOSIZE | CV_WINDOW_FREERATIO);

imshow("red image",red_img);

imshow("white image",white_img);

imshow("black image",black_img);

imshow("green image",green_img);

waitKey(0);

return 0;

}

#include <iostream>

#include <opencv2/core/core.hpp>

using namespace cv;

using namespace std;

void main() {

// 3x3 단위행렬 (= Mat::eye(3,3, CV_64F) )

Mat m = (Mat_<double>(3,3) << 1, 0, 0, 0, 1, 0, 0, 0, 1);

// 2x2 회전행렬

double angle = 30, a = cos(angle*CV_PI/180), b = sin(angle*CV_PI/180);

Mat r = (Mat_<double>(2,2) << a, -b, b, a);

cout << "m=" << m << endl << endl;

cout << "r=" << r << endl;

}

#include <iostream>

#include <opencv2/core/core.hpp>

using namespace cv;

using namespace std;

void main() {

Mat mat1 = Mat::ones(5, 5, CV_8U)*3;

Mat mat2 = Mat::zeros(5, 5, CV_8U);

Mat mat3 = Mat::eye(5, 5, CV_8U);

cout << "mat1=" << mat1 << endl << endl;

cout << "mat2=" << mat2 << endl << endl;

cout << "mat3=" << mat3 << endl;

}

#include <iostream>

#include <opencv2/core/core.hpp>

using namespace cv;

using namespace std;

void main() {

float data[] = {1,2,3,4,5,6,7,8,9};

Mat m1(3, 3, CV_32F, data);

cout << "m1=" << m1 << endl;

}

#include <iostream>

#include <opencv2/core/core.hpp>

using namespace cv;

using namespace std;

void main() {

Mat m1(3, 3, CV_32F, Scalar(5));

cout << "m1=" << m1 << endl;

Mat m2(3, 3, CV_32F);

m2 = Scalar(5);

cout << "m2=" << m2 << endl;

Mat m3 = Mat::ones(3, 3, CV_32F)*5;

cout << "m3=" << m3 << endl;

Mat m4 = Mat::zeros(3, 3, CV_32F)+5;

cout << "m4=" << m4 << endl;

}

#include <iostream>

#include <opencv2/core/core.hpp>

using namespace cv;

using namespace std;

void main() {

Mat mat(3, 2, CV_8UC1);

// 랜덤균일분포，[0,256)

randu(mat, Scalar(0), Scalar(256));

cout << mat << endl << endl;

// 랜덤정규분포，mean=128, stddev=10

randn(mat, Scalar(128), Scalar(10));

cout << mat << endl << endl;  

// RNG 초기화

RNG gen(getTickCount());

// 랜덤균일분포，[0,256)

gen.fill(mat, RNG::UNIFORM, Scalar(0), Scalar(256));

cout << mat << endl << endl;

// 랜덤정규분포，mean=128, stddev=10

gen.fill(mat, RNG::NORMAL, Scalar(128), Scalar(10));

cout << mat << endl << endl;

}

#include <iostream>

#include <opencv2/core/core.hpp>

using namespace cv;

using namespace std;

void main() {

// CV32SC2, 3x3 열

// 초기화＋reshape을 이용한 변환

Mat m0 = (Mat_<int>(3,6) << 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18);

Mat m1 = m0.reshape(2);

// 이런 식으로도 할 수 있다.

Vec2i data[] = {Vec2i(1,2), Vec2i(3,4), Vec2i(5,6), Vec2i(7,8), Vec2i(9,10),

Vec2i(11,12), Vec2i(13,14), Vec2i(15,16), Vec2i(17,18)};

Mat m2 =  Mat(3, 3, CV_32SC2, data).clone();

//

Mat m3 = (Mat_<Vec2i>(3,3) <<Vec2i(1,2), Vec2i(3,4), Vec2i(5,6), Vec2i(7,8),

Vec2i(9,10), Vec2i(11,12), Vec2i(13,14), Vec2i(15,16), Vec2i(17,18));

cout << "m1=" << m1 << endl << endl;

cout << "m2=" << m2 << endl << endl;

cout << "m3=" << m3 << endl << endl;

}

#include <iostream>

#include <opencv2/core/core.hpp>

using namespace cv;

using namespace std;

void main() {

Mat m1(3, 4, CV_64FC1);

// 행의수

cout << "rows:" << m1.rows <<endl;

// 열의수

cout << "cols:" << m1.cols << endl;

// 차수

cout << "dims:" << m1.dims << endl;

// 크기(2차원의 경우)

cout << "size[]:" << m1.size().width << "," << m1.size().height << endl;

// 비트 깊이

cout << "depth (ID):" << m1.depth() << "(=" << CV_64F << ")" << endl;

// 채널수

cout << "channels:" << m1.channels() << endl;

// 1요소의 크기[바이트]

cout << "elemSize:" << m1.elemSize() << "[byte]" << endl;

// 1요소의 1채널분의 크기[바이트]

cout << "elemSize1 (elemSize/channels):" << m1.elemSize1() << "[byte]" << endl;

// total

cout << "total:" << m1.total() << endl;

// 스텝수[바이트]

cout << "step:" << m1.step << "[byte]" << endl;

// 1단계의 채널 개수

cout << "step1 (step/elemSize1):" << m1.step1()  << endl;

// 데이터는 연속이가？

cout << "isContinuous:" << (m1.isContinuous()?"true":"false") << endl;

// 데이터가 잘렸는가？

cout << "isSubmatrix:" << (m1.isSubmatrix()?"true":"false") << endl;

// 데이터는 비어있나？

cout << "empty:" << (m1.empty()?"true":"false") << endl;

}

#include <iostream>

#include <opencv2/core/core.hpp>

using namespace cv;

using namespace std;

void main() {

Mat m1(4, 5, CV_32FC(5));  //5x4

Rect roi_rect(0, 0, 3, 4); //4x3

Mat r1(m1, roi_rect);

// 행의수

cout << "rows:" << r1.rows <<endl;

// 열의수

cout << "cols:" << r1.cols << endl;

// 차수

cout << "dims:" << r1.dims << endl;

// 크기(2차원의 경우)

cout << "size[]:" << r1.size().width << "," << r1.size().height << endl;

// 비트 깊이

cout << "depth (ID):" << r1.depth() << "(=" << CV_32F << ")" << endl;

// 채널수

cout << "channels:" << r1.channels() << endl;

//  1요소의 크기[바이트]

cout << "elemSize:" << r1.elemSize() << "[byte]" << endl;

// 1요소의 1채널분의 크기[바이트]

cout << "elemSize1 (elemSize/channels):" << r1.elemSize1() << "[byte]" << endl;

// total

cout << "total:" << r1.total() << endl;

// 스텝수[바이트]

cout << "step:" << r1.step << "[byte]" << endl;

// 1단계의 채널 개수

cout << "step1 (step/elemSize1):" << r1.step1()  << endl;

//  데이터는 연속이가？

cout << "isContinuous:" << (r1.isContinuous()?"true":"false") << endl;

// 데이터가 잘렸는가？

cout << "isSubmatrix:" << (r1.isSubmatrix()?"true":"false") << endl;

// 데이터는 비어있나？

cout << "empty:" << (r1.empty()?"true":"false") << endl;

}

int64 startTime = getTickCount(); double frequency = getTickFrequency();

//처리할 프로그램 함수()

int64 endTime = getTickCount(); cout << (endTime - startTime) / frequency;

int64 t,tinit;

tinit = getTickCount();

//처리 함수()

t = getTickCount() - tinit;