void emboss(Mat& f)

{

Mat mask(3, 3, CV_32F, Scalar(0)), res;

mask.at<float>(0, 0) = -1.0;

mask.at<float>(2, 2) = 1.0;

filter2D(f, res, CV_16S, mask);

res.convertTo(res, CV_8U, 1, 128);

namedWindow("엠보싱"); imshow("엠보싱", res);

}

void waterColor(Mat& f)

{

#define dsize 7

#define sigma 32

int iterate = 20;

Mat t1 = f.clone(), t2;

for (int i = 0; i<iterate; i++)

if (i % 2 == 0) bilateralFilter(t1, t2, dsize, sigma, sigma);

else bilateralFilter(t2, t1, dsize, sigma, sigma);

namedWindow("수채화");

if (iterate % 2 == 0) imshow("수채화", t1);

else imshow("수채화", t2);

}

void sketch(Mat& f)

{

Mat gray, edge, display;

int thres = 5;

cvtColor(f, gray, CV_BGR2GRAY);

blur(gray, gray, Size(3, 3));

Canny(gray, edge, thres, thres*2.5, 3);

display.create(f.size(), f.type());

display = Scalar::all(128);

f.copyTo(display, edge);

namedWindow("스케치"); imshow("스케치", display);

}

void onTrackbar(int thres, void* gray)

{

Mat* image = (Mat*)gray;

Mat edge, display;

Canny(*image, edge, thres, thres*3, 3);

display.create(input.size(), input.type());

display = Scalar::all(128);

input.copyTo(display, edge);

imshow("스케치 농도", display);

}

void sketchByTrackbar(Mat& input)

{

int pos = 0;

Mat gray;

cvtColor(input, gray, CV_BGR2GRAY);

blur(gray, gray, Size(3, 3));

namedWindow("스케치 농도");

createTrackbar("임계값", "스케치 농도", &pos, 200, onTrackbar, &gray);

setTrackbarPos("임계값", "스케치 농도", pos);

waitKey(1);

}

코드

#include <opencv2/opencv.hpp>

#include <opencv2/highgui.hpp>

using namespace cv;

using namespace std;

bool ldown = false, lup = false;

Mat img, gray_img;

Point corner1, corner2;

Rect box;

void Canny_edge(Mat img);

static void mouse_callback(int event, int x, int y, int, void* param) {

if (event == EVENT_LBUTTONDOWN) {

ldown = true;

corner1.x = x;

corner1.y = y;

}

if (event == EVENT_LBUTTONUP) {

if (abs(x - corner1.x) > 20 && abs(y - corner1.y) > 20) {

lup = true;

corner2.x = x;

corner2.y = y;

}

else {

ldown = false;

}

}

if (ldown == true && lup == false) {

Point pt;

pt.x = x;

pt.y = y;

Mat locale_img = img.clone();

rectangle(locale_img, corner1, pt, Scalar(255, 0, 0));

imshow("Original IMG", locale_img);

}

if (ldown == true && lup == true) {

box.width = abs(corner1.x - corner2.x);

box.height = abs(corner1.y - corner2.y);

box.x = min(corner1.x, corner2.x);

box.y = min(corner1.y, corner2.y);

Mat crop(gray_img, box);

Canny_edge(crop);

ldown = false; lup = false;

}

}

void Canny_edge(Mat img) {

Mat contours;

Canny(img, contours, 50, 100);

imshow("Canny_edge", contours);

Mat contoursInv;

threshold(contours, contoursInv, 128, 255, THRESH_BINARY_INV);

imshow("Canny_edge_INV", contoursInv);

}

int main(int args, char *argv[]) {

img = imread("image/flower.jpg", CV_LOAD_IMAGE_COLOR);;

if (!img.data) {

cout << "Image Can't Load" << endl;

return -1;

}

cvtColor(img, gray_img, CV_BGR2GRAY);

imshow("Gray_img", gray_img);

namedWindow("Original IMG");

imshow("Original IMG", img);

setMouseCallback("Original IMG", mouse_callback);

waitKey(0);

}

결과값

코드

#include "opencv2/opencv.hpp"  

#include <opencv/cv.h>

#include <iostream>

using namespace cv;

using namespace std;

int main() {

Mat image = imread("image/food.jpg", CV_LOAD_IMAGE_COLOR);

namedWindow("video", CV_WINDOW_AUTOSIZE);

namedWindow("Canny", CV_WINDOW_AUTOSIZE);

namedWindow("Sobel", CV_WINDOW_AUTOSIZE);

// Original Image to Gray Image

Mat gray;

cvtColor(image, gray, CV_BGR2GRAY);

// Sobel Filter

Mat sobelX;

Mat sobelY;

Sobel(gray, sobelX, CV_8U, 1, 0);

Sobel(gray, sobelY, CV_8U, 0, 1);

Mat imageSobel;

imageSobel = abs(sobelX) + abs(sobelY);

Mat imageCanny;

Canny(gray, imageCanny, 50, 200);

imshow("video", image);

imshow("Canny", imageCanny);

imshow("Sobel", imageSobel);

waitKey(0);

}

결과값

결과값

코드

#include "opencv2/opencv.hpp"  

#include <iostream>  

using namespace cv;

using namespace std;

int main(){

VideoCapture capture("image/Wildlife.wmv");

int fps = capture.get(CAP_PROP_FPS);

int ex = static_cast<int>(capture.get(CV_CAP_PROP_FOURCC));

char EXT[] = {

(char)(ex & 0XFF),

(char)((ex & 0XFF00) >> 8),

(char)((ex & 0XFF0000) >> 16),

(char)((ex & 0XFF000000) >> 24),

0

};

int hei = capture.get(CAP_PROP_FRAME_HEIGHT);

int wid = capture.get(CAP_PROP_FRAME_WIDTH);

printf("fourcc = %s \n", EXT);

printf("size = [%d x %d]\n", wid, hei);

printf("fps = %d\n", fps);

Mat frame;

Mat frameCanny;

//namedWindow("input", 1);

Size size = Size((int)capture.get(CAP_PROP_FRAME_WIDTH),

(int)capture.get(CAP_PROP_FRAME_HEIGHT));

VideoWriter outputVideo;

outputVideo.open("ouput.avi", CV_FOURCC('D', 'I', 'B', ' '), fps, size, true);

if (!outputVideo.isOpened())

{

cout << "동영상을 저장하기 위한 초기화 작업 중 에러 발생" << endl;

return 1;

}

while (1)

{

capture >> frame;

if (!frame.empty()) {

Canny(frame, frameCanny, 80, 150, 3);

imshow("video", frame);

imshow("Canny", frameCanny);

outputVideo << frameCanny;

outputVideo.write(frameCanny);

if (waitKey(30) == 'q') break;

}

}

return 0;

}

#include <opencv2/imgcodecs.hpp>  

#include <opencv2/imgproc.hpp>  

#include <opencv2/highgui.hpp>  

#include <iostream>  

using namespace cv;

using namespace std;

int main()

{

VideoCapture cap1("image/Wildlife.wmv");

Mat frame1;

namedWindow("video", 1);

while(true){

cap1 >> frame1;

imshow("video", frame1);

if (waitKey(30) == 'q') break;  

}

return 0;

}

#include<iostream>

#include<opencv2\core.hpp>

#include<opencv\cv.h>

#include<opencv2\highgui.hpp>

#include<opencv2\imgproc.hpp>

using namespace cv;

using namespace std;

int main() {

Mat src1 = imread("image/bike.jpg", CV_LOAD_IMAGE_COLOR);

Mat src2 = imread("image/holse.jpg", CV_LOAD_IMAGE_COLOR);

Mat dst;

int value;

resize(src1, src1, Size(src2.cols, src2.rows), 0, 0, 1);

namedWindow("Dissolve Image", CV_WINDOW_AUTOSIZE);

createTrackbar("혼합계수", "Dissolve Image", &value, 100);

setTrackbarPos("혼합계수", "Dissolve Image", 50);

while (true) {

value = getTrackbarPos("혼합계수", "Dissolve Image");

//계수값은 0 ~ 100이고 alpha는 0 ~ 1 값이므로 아래와 같이 처리해 줘야한다.

double alpha = (value / 100) + ((value % 100) * 0.01);

double beta = 1 - alpha;

addWeighted(src1, alpha , src2, beta, 0.0, dst);

imshow("Dissolve Image", dst);

if (waitKey(1) == 'q') break;

}

waitKey(0);

}

#include<iostream>

#include<opencv2\core.hpp>

#include<opencv\cv.h>

#include<opencv2\highgui.hpp>

#include<opencv2\imgproc.hpp>

using namespace cv;

using namespace std;

int main() {

Mat src1 = imread("image/buddha.jpg", CV_LOAD_IMAGE_COLOR);

Mat src2 = imread("image/girl.jpg", CV_LOAD_IMAGE_COLOR);

Mat dst;

int alpha = 0.5;

int beta = 1 - alpha;

namedWindow("Dissolve Image", CV_WINDOW_AUTOSIZE);

//디졸브 하기

addWeighted(src1, alpha, src2, beta, 0.0, dst);

imshow("Dissolve Image", dst);

waitKey(0);

}

트랙바 만들기

코드

#include<iostream>

#include<opencv2\core.hpp>

#include<opencv\cv.h>

#include<opencv2\highgui.hpp>

#include<opencv2\imgproc.hpp>

#define MAX 255

using namespace cv;

using namespace std;

int main() {

Mat image = imread("image/flower.jpg", 0);

Mat thresholded;

int thredshold;

if (!image.data)

{

std::cout << "open failed" << std::endl;

return 0;

}

namedWindow("Binary Image");

while (true) {

threshold(image, thresholded, MAX - thredshold, MAX, THRESH_BINARY);

imshow("Binary Image", thresholded);

int key = waitKey(1);

if (key == 'q') break;

}

waitKey(0);

return 0;

}