//-------------------------------------------------------------

// 메인

//-------------------------------------------------------------

void main() {

char * wnSrc = "src";

//Mat src = imread("resizesample.tif");

Mat src = imread("조명.jpg");

//Mat src = imread("ColorCheckerChart.png");

if(!src.data) exit(1);

//fun2(src);

imshow(wnSrc,src);

cvSetMouseCallback(wnSrc, onMouse, &src);

waitKey(0);

}

//-------------------------------------------------------------

// 마우스 이벤트

//-------------------------------------------------------------

void onMouse(int event, int x, int y, int flags, void* param) {

//Point3i rgb;

Mat *src = (Mat *)param;

static vector<Point3i> pt;

switch(event) {

case CV_EVENT_RBUTTONDOWN: //오른쪽버튼 DOWN

pt.push_back(Point3i(src->at<Vec3b>(y,x)[0], src->at<Vec3b>(y,x)[1], src->at<Vec3b>(y,x)[2]));

break;

case CV_EVENT_LBUTTONDOWN: //오른쪽버튼 DOWN

draw(*src, pt);

pt.clear();

break;

}

imshow("src",*src);

}

//-------------------------------------------------------------

// 컬러 그리기

//-------------------------------------------------------------

void draw(Mat &src, vector<Point3i> range) {

int gap = 5;

Mat temp = Mat(src.size(), src.type(),Scalar(0,255,0));

for(int i = 0; i< src.rows; i++) {

for(int j = 0; j< src.cols; j++){

Vec3b col = src.at<Vec3b>(i,j);

for(int k = 0; k<range.size(); k++) {

if( ( col[0] >= range[k].x - gap && col[0] <= range[k].x + gap) && 

( col[1] >= range[k].y - gap && col[1] <= range[k].y + gap) && 

( col[2] >= range[k].z - gap && col[2] <= range[k].z + gap) )

circle(temp,Point(j,i),1,Scalar(range[k].x,range[k].y,range[k].z),2);

}

}

}

imshow("temp",temp);

}

void main() {

char * wnSrc = "src";

Mat src = imread("resizesample.tif");

if(!src.data) exit(1);

imshow(wnSrc,src);

cvSetMouseCallback(wnSrc, onMouse, &src);

waitKey(0);

}

//-------------------------------------------------------------

// 마우스 이벤트

//-------------------------------------------------------------

void onMouse(int event, int x, int y, int flags, void* param) {

Scalar rgb;

Mat *src = (Mat *)param;

switch(event) {

case CV_EVENT_RBUTTONDOWN: //오른쪽버튼 DOWN

rgb[0]= src->at<Vec3b>(y,x)[0];

rgb[1]= src->at<Vec3b>(y,x)[1];

rgb[2]= src->at<Vec3b>(y,x)[2];

cout<<"B("<<rgb[0]<<")";

cout<<"G("<<rgb[1]<<")";

cout<<"R("<<rgb[2]<<")"<<endl;

color_extraction(*src,rgb);

break;

}

imshow("src",*src);

}

//-------------------------------------------------------------

// 컬러 추출

//-------------------------------------------------------------

void color_extraction( Mat &src, Scalar rgb ) {

Mat dst, addMat;

unsigned int gap = 5;

Scalar lowerBGR, uperBGR;

lowerBGR[0] = (rgb[0] - gap);

lowerBGR[1] = (rgb[1] - gap);

lowerBGR[2] = (rgb[2] - gap);

uperBGR[0]  = (rgb[0] + gap);

uperBGR[1]  = (rgb[1] + gap);

uperBGR[2]  = (rgb[2] + gap);

inRange(src, lowerBGR, uperBGR, dst);

dilate( dst, dst, Mat() );dilate( dst, dst, Mat() );

erode( dst, dst, Mat() );

cvtColor(dst,dst,CV_GRAY2BGR);

add(src,dst,addMat);

imshow("Add",addMat);

imshow("Color_Detect Demo",dst);

}

#include <iostream>

#include <opencv2/core/core.hpp>

#include <opencv2/highgui/highgui.hpp>

using namespace cv;

using namespace std;

// .ptr와 [] 사용하기(.at보다 빠름)

void colorReduce(Mat &image, int div=64) {

int nl= image.rows; // 행 개수

int nc= image.cols * image.channels(); // 각 행에 있는 원소의 총 개수

for (int j=0; j<nl; j++) {

uchar* data= image.ptr<uchar>(j);

for (int i=0; i<nc; i++) {

data[i]= data[i]/div*div + div/2;

}    

}

}

void main()

{

Mat image;

int64 t, tinit;

image= imread("image.jpg");

if (!image.data) {

cerr<<"Error: 이미지 파일을 읽을 수 없습니다!!"<<endl;

exit(1);

}

imshow("original", image);

tinit = getTickCount();

colorReduce(image);

t = getTickCount() - tinit;

cout << "using .ptr and [] =" << 1000.*t/getTickFrequency() << "ms" << endl;

imshow("color reduce", image);

waitKey(0);

}

#include "colordetecth.h"

void onMouse(int event, int x, int y, int flags, void* param);

void fun(Mat &image, Scalar rgb);

void main() {

char * wnSrc = "src";

Mat src;

src = imread("sample.tif");

//src = imread("ColorCheckerChart.png");

imshow(wnSrc,src);

cvSetMouseCallback(wnSrc, onMouse, &src);

waitKey(0);

}

void onMouse(int event, int x, int y, int flags, void* param) {

Scalar rgb;

Mat *src = (Mat *)param;

switch(event) {

case CV_EVENT_RBUTTONDOWN: //오른쪽버튼 DOWN

rgb[0]= src->at<Vec3b>(y,x)[0];

rgb[1]= src->at<Vec3b>(y,x)[1];

rgb[2]= src->at<Vec3b>(y,x)[2];

cout<<"B("<<rgb[0]<<")";

cout<<"G("<<rgb[1]<<")";

cout<<"R("<<rgb[2]<<")"<<endl;

fun(*src,rgb);

break;

case CV_EVENT_RBUTTONUP: //오른쪽버튼 UP

break;

case CV_EVENT_RBUTTONDBLCLK: //오른쪽버튼 떠블클릭

break;

case CV_EVENT_LBUTTONDOWN: //왼쪽버튼 DOWN

break;

case CV_EVENT_LBUTTONUP: //외쪽버튼 UP

break;

case CV_EVENT_LBUTTONDBLCLK: //외쪽버튼 더블클릭

break;

case CV_EVENT_MOUSEMOVE: //마우스움직임

if(flags & CV_EVENT_FLAG_RBUTTON){

//printf("현재 마우스 좌표는 (%d, %d) 입니다.\n", x, y);

//src->at<Vec3b>(y,x) = 255;

}

break;

}

imshow("src",*src);

} 

void fun(Mat &image, Scalar rgb) {

for(int y=0; y<image.rows; y++) {

for(int x=0; x<image.cols; x++) {

if(y<80 & x<255) {

image.at<Vec3b>(y,x)[0] = rgb[0];

image.at<Vec3b>(y,x)[1] = rgb[1];

image.at<Vec3b>(y,x)[2] = rgb[2];

}

}

}

}

#include <iostream>

using namespace std;

#include <opencv2/core/core.hpp>

#include <opencv2/highgui/highgui.hpp>

#include <opencv2/imgproc/imgproc.hpp>

using namespace cv;

// 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;

}