OpenCV入门代码总结

最新推荐文章于 2023-05-07 15:33:15 发布
最新推荐文章于 2023-05-07 15:33:15 发布
阅读量146 收藏
点赞数
分类专栏： C++ OpenCV
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sjsndjsndh/article/details/119861572
版权

quickopencv.h

#pragma once
#include<opencv2/opencv.hpp>
#include<string>
using namespace cv;
//using namespace std;

class QuickDemo {
public:
	void colorSpace_Demo(Mat &image);
	void mat_creation_demo(Mat &image);
	void pixel_vist_demo(Mat &image);
	void operators_demo(Mat &image);
	void tracking_bar_demo(Mat &image);
	void key_demo(Mat &image);
	void color_style_demo(Mat &image);
	void bitwise_demo(Mat &image);
	void channels_demo(Mat &image);
	void inrange_demo(Mat &image);
	void pixed_statistic_demo(Mat &image);
	void drawing_demo(Mat &image);
	void random_drawing(Mat &image);
	void polyline_drawing_demo(Mat &image);
	void mouse_drawing_demo(Mat &image);
	void mouse_drawing_circle_demo(Mat &image);
	void norm_demo(Mat &image);
	void resize_demo(Mat &image);
	void flip_demo(Mat &image);
	void rotate_demo(Mat &image);
	void video_demo(Mat &image);
	void historgram_demo(Mat &image);
	void historgram_2d_demo(Mat &image);
	void historgram_eq_demo(Mat &image);
	void blur_demo(Mat &image);
	void gaussian_blur_demo(Mat &image);
	void bilfilter_demo(Mat &image);
	void bsm_demo(String &path);
};

quickdemo.cpp

#include<quickopencv.h>
#include<math.h>
#include<string>

void QuickDemo::colorSpace_Demo(Mat& image) {
	Mat hsv, gray;
	cvtColor(image, hsv, COLOR_BGR2HSV);
	cvtColor(image, gray, COLOR_BGR2GRAY);
	namedWindow("hsv", WINDOW_FREERATIO);
	namedWindow("gray", WINDOW_FREERATIO);
	imshow("hsv", hsv);
	imshow("gray", gray);
	imwrite("D:/hsv.png",hsv);
	imwrite("D:/gray.png",gray);
}

void QuickDemo::mat_creation_demo(Mat& image) {
	Mat m1, m2;
	m1 = image.clone();
	image.copyTo(m2);

	// 创建空白图像
	Mat m3 = Mat::ones(Size(512,512), CV_8UC3);
	m3 = Scalar(255, 0, 0);
	std::cout << "width:" << m3.cols << " height:" << m3.rows << " channels:" << m3.channels() << std::endl;
	//std::cout<<m3<<std::endl;
	Mat m4 = m3.clone();
	m4 = Scalar(0, 255, 255);
	imshow("创建图像", m3);
}

void QuickDemo::pixel_vist_demo(Mat& image) {
	int w = image.cols;
	int h = image.rows;
	int dims = image.channels();
	/*	for (int row = 0; row < h; row++) {
			for (int col = 0; col < w; col++) {
				if (dims == 1) { // 单通道灰度图像
					int pv = image.at<uchar>(row, col);
					image.at<uchar>(row, col) = 255 - pv;
				}
				if (dims == 3) { // 彩色图像
					Vec3b bgr = image.at<Vec3b>(row, col);
					image.at<Vec3b>(row, col)[0] = 255 - bgr[0];
					image.at<Vec3b>(row, col)[1] = 255 - bgr[1];
					image.at<Vec3b>(row, col)[2] = 255 - bgr[2];
				}
		}*/
	for (int row = 0; row < h; row++) {
		uchar* current_row = image.ptr<uchar>(row);
		for (int col = 0; col < w; col++) {
			if (dims == 1) {
				*current_row++ = 255 - *current_row;
			}
			if (dims == 3) {
				*current_row++ = 255 - *current_row;
				*current_row++ = 255 - *current_row;
				*current_row++ = 255 - *current_row;
			}
		}
	}

	imshow("像素读写演示", image);
}

void QuickDemo::operators_demo(Mat &image) {
	Mat dst = Mat::zeros(image.size(), image.type());
	Mat m = Mat::zeros(image.size(), image.type());
	m = Scalar(50, 50, 50);

/*	int w = image.cols;
	int h = image.rows;
	int dims = image.channels();
	for (int row = 0; row < h; row++) {
		for (int col = 0; col < w; col++) {
			Vec3b p1 = image.at<Vec3b>(row, col);
			Vec3b p2 = m.at<Vec3b>(row, col);
			dst.at<Vec3b>(row, col)[0] = saturate_cast<uchar>(p1[0] + p2[0]);
			dst.at<Vec3b>(row, col)[1] = saturate_cast<uchar>(p1[1] + p2[1]);
			dst.at<Vec3b>(row, col)[2] = saturate_cast<uchar>(p1[2] + p2[2]);
		}
	}*/
	subtract(image, m, dst);
	namedWindow("加法操作", WINDOW_FREERATIO);
	imshow("加法操作", dst);
}

static void on_lightness(int b, void* userdata) {
	Mat image = *((Mat*)userdata);
	Mat dst = Mat::zeros(image.size(),image.type());
	Mat m = Mat::zeros(image.size(), image.type());
	addWeighted(image, 1.0, m, 0, b, dst);
	imshow("亮度与对比度调整", dst);
}

static void on_constant(int b, void* userdata) {
	Mat image = *((Mat*)userdata);
	Mat dst = Mat::zeros(image.size(), image.type());
	Mat m = Mat::zeros(image.size(), image.type());
	double constrast = b / 100.0;
	addWeighted(image, constrast, m, 0.0, 0, dst);
	imshow("亮度与对比度调整", dst);
}

void QuickDemo::tracking_bar_demo(Mat &image) {
	namedWindow("亮度与对比度调整", WINDOW_AUTOSIZE);
	int lightness = 50;
	int max_value = 100;
	int constant_value = 100;
	createTrackbar("Value Bar:", "亮度与对比度调整",&lightness, max_value, on_lightness,(void*)(&image));
	createTrackbar("Constant Bar:", "亮度与对比度调整",&constant_value,200, on_constant,(void*)(&image));
	on_lightness(50, &image);
}

void QuickDemo::key_demo(Mat &image) {
	Mat dst = Mat::zeros(image.size(), image.type());
	while (true) {
		int c = waitKey(100);
		if (c == 27) { // 退出
			break;
		}
		if (c == 49) { // Key # 1
			std::cout << "you enter key # 1" << std::endl;
			cvtColor(image, dst, COLOR_BGR2GRAY);
		}
		if (c == 50) { // Key # 2
			std::cout << "you enter key # 2" << std::endl;
			cvtColor(image, dst, COLOR_BGR2HSV);
		}
		if (c == 51) { // Key # 3
			std::cout << "you enter key # 3" << std::endl;
			dst = Scalar(50, 50, 50);
			add(image, dst, dst);
		}
		imshow("键盘响应",dst);
	}
}

void QuickDemo::color_style_demo(Mat& image) {
	int colormap[] = {
		COLORMAP_AUTUMN,
		COLORMAP_BONE,
		COLORMAP_JET,
		COLORMAP_WINTER,
		COLORMAP_RAINBOW,
		COLORMAP_OCEAN,
		COLORMAP_SUMMER,
		COLORMAP_SPRING,
		COLORMAP_COOL,
		COLORMAP_HSV,
		COLORMAP_PINK,
		COLORMAP_HOT,
		COLORMAP_PARULA,
		COLORMAP_MAGMA,
		COLORMAP_INFERNO,
		COLORMAP_PLASMA,
		COLORMAP_VIRIDIS,
		COLORMAP_CIVIDIS,
		COLORMAP_TWILIGHT,
		COLORMAP_TWILIGHT_SHIFTED,
	};
	Mat dst;
	int index = 0;
	while (true) {
		int c = waitKey(500);
		if (c == 27) {
			break;
		}
		applyColorMap(image, dst, colormap[index % 20]);
		index++;
		imshow("颜色风格", dst);
	}
}

void QuickDemo::bitwise_demo(Mat& image) {
	Mat m1 = Mat::zeros(Size(256, 256), CV_8UC3);
	Mat m2 = Mat::zeros(Size(256, 256), CV_8UC3);
	rectangle(m1, Rect(100, 100, 80, 80), Scalar(255, 255, 0), -1, LINE_8, 0);
	rectangle(m2, Rect(150, 150, 80, 80), Scalar(0, 255, 255), -1, LINE_8, 0);
	imshow("m1", m1);
	imshow("m2", m2);
	Mat dst;
	bitwise_xor(m1, m2 , dst);
	imshow("像素位操作",dst);
}

void QuickDemo::channels_demo(Mat& image) {
	std::vector<Mat>mv;
	split(image, mv);
	int h = mv[0].cols;
	int w = mv[0].rows;
	int channels = mv[0].dims;
	printf("图像的高为:%d,宽为:%d,通道数为:%d", h, w, channels);
	imshow("蓝色", mv[0]);
	imshow("绿色", mv[1]);
	imshow("红色", mv[2]);

	Mat dst;
	mv[1] = 0;
	mv[2] = 0;
	merge(mv, dst);
	imshow("蓝色", dst);

	int from_to[] = { 0,2,1,1,2,0 };
	mixChannels(&image,1,&dst,1,from_to,3);
	imshow("通道混合",dst);
}

void QuickDemo::inrange_demo(Mat& image) {
	Mat hsv;
	cvtColor(image, hsv, COLOR_BGR2HSV);
	Mat mask;
	inRange(hsv,Scalar(35,43,46),Scalar(77,255,255),mask);

	Mat readback = Mat::zeros(image.size(), image.type());
	readback = Scalar(40,40,200);
	bitwise_not(mask,mask);
	imshow("mask", mask);
	image.copyTo(readback, mask);
	imshow("roi区域提取", readback);
}

void QuickDemo::pixed_statistic_demo(Mat& image) {
	double minv, maxv;
	Point minLoc, maxLoc;
	std::vector<Mat>mv;
	split(image, mv);
	for (int i = 0; i < mv.size(); i++) {
		minMaxLoc(mv[i], &minv, &maxv, &minLoc, &maxLoc, Mat());
		std::cout <<"No.channels:"<<i << "min value" << minv << "max vlaue" << maxv << std::endl;
	}
	Mat mean, stddev;
	meanStdDev(image, mean, stddev);
	std::cout << "means:" << mean << std::endl;
	std::cout <<"stddev:" << stddev << std::endl;
}

void QuickDemo::drawing_demo(Mat& image) {
	Rect rect;
	rect.x = 100;
	rect.y = 100;
	rect.width = 250;
	rect.height = 300;
	Mat bg = Mat::zeros(image.size(), image.type());
	rectangle(bg,rect,Scalar(0,0,255),-1,8,0);
	circle(bg, Point(350, 400), 15, Scalar(255, 0, 0), -1,8,0);
	line(bg, Point(100, 100), Point(350, 400), Scalar(0, 255, 0), 2, LINE_AA, 0);
	RotatedRect rrt;
	rrt.center = Point(200, 200);
	rrt.size = Size(100, 200);
	rrt.angle = 90.0;
	ellipse(bg, rrt, Scalar(0, 255, 255), 2, 8);
	//Mat dst;
	//addWeighted(image, 0.7, bg, 0.3, 0 ,dst);
	namedWindow("绘图演示",WINDOW_FREERATIO);
	imshow("绘图演示",bg);
}

void QuickDemo::random_drawing(Mat& image) {
	Mat canvas = Mat::zeros(image.size(), CV_8UC3);
	int w = canvas.cols;
	int h = canvas.rows;
	RNG mg(12345);
	while (true) {
		int c = waitKey(100);
		if (c == 27) {//退出
			break;
		}
		int x1 = mg.uniform(0, w);
		int y1 = mg.uniform(0, h);
		int x2 = mg.uniform(0, w);
		int y2 = mg.uniform(0, h);
		int b = mg.uniform(0, 255);
		int g = mg.uniform(0, 255);
		int r = mg.uniform(0, 255);

		canvas = Scalar(0, 0, 0);
		line(canvas, Point(x1, y1), Point(x2, y2), Scalar(b, g, r), 1, LINE_AA, 0);
		imshow("随机绘制演示", canvas);
	}
}

void QuickDemo::polyline_drawing_demo(Mat& image) {
	Mat canvas = Mat::zeros(Size(512, 512), CV_8UC3);
	Point p1(100, 100);
	Point p2(350, 100);
	Point p3(450, 250);
	Point p4(320, 450);
	Point p5(80, 400);
	std::vector<Point>pts;
	pts.push_back(p1);
	pts.push_back(p2);
	pts.push_back(p3);
	pts.push_back(p4);
	pts.push_back(p5);
	//fillPoly(canvas, pts, Scalar(255, 255, 0), 8, 0);
	//polylines(canvas, pts, true, Scalar(0, 0, 255), 2, LINE_AA, 0);
	std::vector<std::vector<Point>>contours;
	contours.push_back(pts);
	drawContours(canvas, contours, -1, Scalar(255,0,0),-1);
	imshow("多边形绘制", canvas);
}

Point sp(-1, -1);
Point ep(-1, -1);
Mat temp;

static void on_draw(int event, int x, int y, int flags, void* userdata) {
	/* event:表示鼠标的事件*/
	Mat image = *((Mat*)userdata);
	if (event == EVENT_LBUTTONDOWN) {
		sp.x = x;
		sp.y = y;
		std::cout << "start point:" << sp << std::endl;
	}
	else if (event == EVENT_LBUTTONUP) {
		ep.x = x;
		ep.y = y;
		int dx = ep.x - sp.x;
		int dy = ep.y - sp.y;
		if (dx > 0 && dy > 0) {
			Rect box(sp.x, sp.y, dx, dy);
			temp.copyTo(image);
			imshow("ROI区域", image(box));
			rectangle(image, box, Scalar(0, 0, 255), 2, 8, 0);
			imshow("鼠标绘制", image);
			//ready for next drawing
			sp.x = -1;
			sp.y = -1;
		}
	}
	else if (event == EVENT_MOUSEMOVE) {
		if (sp.x > 0 && sp.y > 0) {
			ep.x = x;
			ep.y = y;
			int dx = ep.x - sp.x;
			int dy = ep.y - sp.y;
			if (dx > 0 && dy > 0) {
				Rect box(sp.x, sp.y, dx, dy);
				temp.copyTo(image);
				rectangle(image, box, Scalar(0, 0, 255), 2, 8, 0);
				imshow("鼠标绘制", image);
			}
		}
	}
}

void QuickDemo::mouse_drawing_demo(Mat& image) {
	namedWindow("鼠标绘制", WINDOW_AUTOSIZE);
	setMouseCallback("鼠标绘制", on_draw,(void*)(&image));
	imshow("鼠标绘制", image);
	temp = image.clone();
}

static void draw_circle(int event, int x, int y, int flags, void* userdata) {
	Mat image = *((Mat*)userdata);
	if (event == EVENT_LBUTTONDOWN) {
		sp.x=x;
		sp.y=y;
		std::cout << "start point:" << sp << std::endl;
	}
	else if (event == EVENT_LBUTTONUP) {
		ep.x = x;
		ep.y = y;
		int dx = ep.x - sp.x; // 横坐标差距
		int dy = ep.y - sp.y;// 纵坐标差距
		if (dx > 0 && dy > 0) {
			int r = pow(dx, 2) + pow(dy, 2);
			r = int(sqrt(r));
			circle(image, sp, r, Scalar(0, 0, 255), 2, 8, 0);
			imshow("鼠标绘制", image);
			//ready for next drawing
			sp.x = -1;
			sp.y = -1;
		}
	}
	else if (event == EVENT_MOUSEMOVE) {
		if (sp.x > 0 && sp.y > 0) {
			ep.x = x;
			ep.y = y;
			int dx = ep.x - sp.x;
			int dy = ep.y - sp.y;
			if (dx > 0 && dy > 0) {
				int r = pow(dx, 2) + pow(dy, 2);
				r = int(sqrt(r));
				temp.copyTo(image);
				circle(image, sp, r, Scalar(0, 0, 255), 2, 8, 0);
				imshow("鼠标绘制", image);
			}
		}
	}
}

void QuickDemo::mouse_drawing_circle_demo(Mat& image) {
	namedWindow("鼠标绘制", WINDOW_AUTOSIZE);
	setMouseCallback("鼠标绘制", draw_circle, (void*)(&image));
	imshow("鼠标绘制", image);
	temp = image.clone();
}

void QuickDemo::norm_demo(Mat& image) {
	Mat dst;
	image.convertTo(dst, CV_32F);

	std::cout << image.type() << std::endl;
	std::cout << dst.type() << std::endl;

	normalize(image, dst, 1.0, 0, NORM_MINMAX);
	std::cout << dst.type() << std::endl;
	imshow("图像数据归一化", dst);
	// CV_8UC3 -> CV_32FC3
}

void QuickDemo::resize_demo(Mat& image) {
	Mat zoomin, zoomout;
	int h = image.rows;
	int w = image.cols;
	resize(image, zoomin, Size(w / 2, h / 2), 0, 0, INTER_LINEAR);
	imshow("zoomin", zoomin);
	resize(image, zoomout, Size(w * 1.5, h * 1.5), 0, 0, INTER_LINEAR);
	imshow("zoomout", zoomout);
}

void QuickDemo::flip_demo(Mat& image) {
	Mat dst;
	//flip(image, dst, 0);// 上下翻转
	//flip(image, dst, 1);// 左右翻转
	flip(image, dst, 0);// 180º旋转
	namedWindow("图像翻转", WINDOW_FREERATIO);
	imshow("图像翻转", dst);
}

void QuickDemo::rotate_demo(Mat& image) {
	Mat dst, M;
	int w = image.cols;
	int h = image.rows;
	M = getRotationMatrix2D(Point(w / 2, h / 2), 45, 1.0);
	double cos = abs(M.at<double>(0, 0));
	double sin = abs(M.at<double>(0, 1));
	int nw = cos * w + sin * h;
	int nh = sin * w + cos * h;
	M.at<double>(0, 2) += (nw / 2 - w / 2);
	M.at<double>(1, 2) += (nh / 2 - h / 2);
	warpAffine(image, dst, M, Size(nw,nh), INTER_LINEAR, 0, Scalar(255,255,0));
	namedWindow("旋转演示", WINDOW_FREERATIO);
	imshow("旋转演示", dst);
}

void QuickDemo::video_demo(Mat& image) {
	VideoCapture capture("D:/image/vtest.avi");
	int frame_width = capture.get(CAP_PROP_FRAME_WIDTH);
	int frame_height = capture.get(CAP_PROP_FRAME_HEIGHT);
	int count = capture.get(CAP_PROP_FRAME_COUNT);
	double fps = capture.get(CAP_PROP_FPS);
	std::cout << "frame width:" << frame_width << std::endl;
	std::cout << "frame height:" << frame_height << std::endl;
	std::cout << "Number of frames:" << count << std::endl;
	std::cout << "FPS:" << fps << std::endl;
	VideoWriter writer("D:/image/first.avi", capture.get(CAP_PROP_FOURCC), fps, Size(frame_width, frame_height), true);
	Mat frame;
	while (true) {
		capture.read(frame);
		if (frame.empty()) {
			break;
		}
		imshow("frame", frame);
		writer.write(frame);
		// TODO:do something
		int c = waitKey(100);
		if (c == 27) {// 退出
			break;
		}
	}
	// release
	capture.release();
	writer.release();
}

void QuickDemo::historgram_demo(Mat& image) {
	// 三通道分离
	std::vector<Mat>bgr_plane;
	split(image, bgr_plane);
	// 参数变量
	const int channels[1] = { 0 };
	const int bins[1] = { 256 };
	float hranges[2] = { 0,255 };
	const float* ranges[1] = { hranges };
	Mat b_hist;
	Mat g_hist;
	Mat r_hist;
	// 计算Blue,Green,Red通道的直方图
	calcHist(&bgr_plane[0], 1, 0, Mat(), b_hist, 1, bins, ranges);
	calcHist(&bgr_plane[1], 1, 0, Mat(), g_hist, 1, bins, ranges);
	calcHist(&bgr_plane[2], 1, 0, Mat(), r_hist, 1, bins, ranges);
	// 显示直方图
	int hist_w = 512;
	int hist_h = 400;
	int bin_w = cvRound((double)hist_w / bins[0]);
	Mat histImage = Mat::zeros(hist_h, hist_w, CV_8UC3);
	// 归一化直方图数据
	normalize(b_hist, b_hist, 0, histImage.rows, NORM_MINMAX, -1, Mat());
	normalize(g_hist, g_hist, 0, histImage.rows, NORM_MINMAX, -1, Mat());
	normalize(r_hist, r_hist, 0, histImage.rows, NORM_MINMAX, -1, Mat());
	// 绘制直方图曲线
	for (int i = 1; i < bins[0]; i++) {
		line(histImage, Point(bin_w * (i - 1), hist_h - cvRound(b_hist.at<float>(i - 1))),
			Point(bin_w * (i), hist_h - cvRound(b_hist.at<float>(i))), Scalar(255, 0, 0), 2, 8, 0);
		line(histImage, Point(bin_w * (i - 1), hist_h - cvRound(g_hist.at<float>(i - 1))),
			Point(bin_w * (i), hist_h - cvRound(g_hist.at<float>(i))), Scalar(0, 255, 0), 2, 8, 0);
		line(histImage, Point(bin_w * (i - 1), hist_h - cvRound(r_hist.at<float>(i - 1))),
			Point(bin_w * (i), hist_h - cvRound(r_hist.at<float>(i))), Scalar(0, 0, 255), 2, 8, 0);
	}
	// 显示直方图
	namedWindow("Histogram Demo", WINDOW_AUTOSIZE);
	imshow("Histogram Demo", histImage);
}

void QuickDemo::historgram_2d_demo(Mat& image){
	// 2D直方图
	Mat hsv, hs_hist;
	cvtColor(image, hsv, COLOR_BGR2HSV);
	int hbins = 30, sbins = 32;
	int hist_bins[] = { hbins,sbins };
	float h_range[] = { 0,180 };
	float s_range[] = { 0,256 };
	const float* hs_ranges[] = { h_range,s_range };
	int hs_channels[] = { 0,1 };
	calcHist(&hsv, 1, hs_channels, Mat(), hs_hist, 2, hist_bins, hs_ranges, true, false);
	double maxVal = 0;
	minMaxLoc(hs_hist, 0, &maxVal, 0, 0);
	int scale = 10;
	Mat hist2d_image = Mat::zeros(sbins * scale, hbins * scale, CV_8UC3);
	for (int h = 0; h < hbins; h++) {
		for (int s = 0; s < sbins; s++) {
			float binVal = hs_hist.at<float>(h, s);
			int intensity = cvRound(binVal * 255 / maxVal);
			rectangle(hist2d_image, Point(h * scale, s * scale),
				Point((h + 1) * scale - 1, (s + 1) * scale - 1),
				Scalar::all(intensity),
				-1);
		}
	}
	applyColorMap(hist2d_image, hist2d_image, COLORMAP_JET);
	imshow("H-S Histogram", hist2d_image);
}

void QuickDemo::historgram_eq_demo(Mat& image) {
	Mat gray,dst;
	cvtColor(image, gray, COLOR_BGR2GRAY);
	equalizeHist(gray, dst);
	namedWindow("直方图均衡化演示", WINDOW_FREERATIO);
	imshow("直方图均衡化演示", dst);
}

void QuickDemo::blur_demo(Mat& image) {
	Mat dst;
	blur(image, dst, Size(23, 23), Point(-1, -1));
	imshow("图像模糊", dst);
}

void QuickDemo::gaussian_blur_demo(Mat& image) {
	Mat dst;
	GaussianBlur(image, dst, Size(5, 5), 15);
	imshow("图像模糊", dst);
}

void QuickDemo::bilfilter_demo(Mat& image) {
	Mat dst;
	bilateralFilter(image, dst, 0, 100, 10);
	imshow("双边模糊", dst);
}

void QuickDemo::bsm_demo(String& path) {
	VideoCapture capture;
	capture.open(path);
	Mat frame;
	Mat bsmaskMOG2, bsmaskKNN;
	namedWindow("input video", WINDOW_AUTOSIZE);
	namedWindow("MOG2", WINDOW_AUTOSIZE);
	namedWindow("KNN", WINDOW_AUTOSIZE);

	Mat kernel = getStructuringElement(MORPH_RECT, Size(3, 3), Point(-1, -1));

	// intialization BS
	Ptr<BackgroundSubtractor> pMOG2 = createBackgroundSubtractorMOG2();
	Ptr<BackgroundSubtractor> pKNN = createBackgroundSubtractorKNN();

	while (capture.read(frame)) {
		imshow("input video", frame);
		// MOG BSM
		pMOG2->apply(frame, bsmaskMOG2);
		morphologyEx(bsmaskMOG2, bsmaskMOG2,MORPH_OPEN, kernel,Point(-1, -1));
		imshow("MOG2", bsmaskMOG2);
		// KNN BSM
		pKNN->apply(frame, bsmaskKNN);
		imshow("KNN", bsmaskKNN);
		char c = waitKey(100);
		if (c == 27) {
			break;
		}
	}

	capture.release();
	waitKey(0);
}
我是小洋
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
OpenCV 入门教程：图像读取和显示
小蓝枣的博客
07-08 2552
在计算机视觉和图像处理领域，读取和显示图像是最基础且常见的操作之一。 OpenCV 作为一个强大的计算机视觉库，提供了丰富的功能来处理图像数据。本文将以读取和显示图像文件为中心，介绍使用 OpenCV 进行图像读取和显示的基本步骤和实例。
OpenCV 入门教程
12-22
### OpenCV 入门教程知识点解析 #### 一、OpenCV简介 **OpenCV**（Open Source Computer Vision Library）是一个开放源代码的计算机视觉库，它由一系列的函数组成，覆盖了从基本图像处理到复杂视觉算法的广泛领域...
OpenCV最详细入门（一）-python（代码全部可以直接运行）
WUHU648的博客
07-05 13万+
OpenCV详细入门（基础篇） 一、OpenCV介绍 OpenCV（open source computer vision library）是一个基于BSD许可（开源）发行的跨平台计算机视觉库，可以运行在Linux、Windows、Android和Mac OS操作系统上。 它轻量级而且高效——由一系列 C 函数和少量 C++ 类构成，同时提供了Python、Ruby、MATLAB等语言的接口，实现了图像处理和计算机视觉方面的很多通用算法。 OpenCV用C++语言编写，它的主要接口也是C++语言，但是依然保
OpenCV基础入门
suren_jun的博客
12-22 1628
图像是人类视觉的基础，是自然景物的客观反映。模拟图像通过某种物理量的强弱变化来记录图像信息，所以是连续变换的。因为模拟信号容易受到干扰，如今已经被数字图像全面替代数字图像，其亮度用离散的数值表示位数：0~255灰度图，其中0，代表最黑，255，表示最白图像分类二值图像：由0和1组成的二值图像灰度图：采用像素8位的非线性尺度来保存，有256级灰度，如果16位，则65536级灰度彩色图：通常采用RGB三个分量表示，分别介于（0~255），采用8位无符号整形。
openCV入门学习
Alex999000的博客
07-05 668
openCv入门学习
C++ opencv操作入门教程
qq_46017342的博客
05-07 5615
C++ opencv操作入门教程
OpenCV初学总结
A_Bright_CH的博客
04-30 2476
今天初学OpenCV，目前还没学到图像识别的地方，只是停留在对图片的处理上。 下面就让我来总结一下，学了一个下午的收获有哪些吧。 函数使用查表 图像.shape： 这是一个列表，返回至多3个数，(h,w,颜色通道数) 类型转换： im = cv2.cvtColor(图片，cv2.COLOR_类型2类型(类型名大写，RGB/BGR/HSV)) 使图片按变换矩阵变： im = warpAffine(图像，变换矩阵，(w,h)(原图形的参数)) 旋转系数矩阵： im = cv2.getRotationMatrix
【OpenCV入门教程之一】 安装OpenCV：OpenCV 3.0、OpenCV 2.4.8、OpenCV 2.4.9 +VS 开发环境配置
热门推荐
【浅墨的游戏编程Blog】毛星云（浅墨）的专栏
02-24 77万+
本系列文章由zhmxy555（毛星云）编写，转载请注明出处。   文章链接： http://blog.csdn.net/poem_qianmo/article/details/19809337 作者：毛星云（浅墨）    邮箱： happylifemxy@163.com  写作当前博文时配套使用OpenCV版本：2.4.8因为读研期间的研究方向是图像处理，所以浅墨这段时间闭门研究了很多OpenCV
opencv入门：人脸检测
AI路漫漫
10-03 1880
Haar-like算法,Adaboost，级联分类器
毛星云opencv入门图像模糊blur代码
weixin_52634719的博客
10-15 260
#include<opencv2/highgui/highgui.hpp> #include<opencv2/imgproc/imgproc.hpp> #include<iostream> using namespace std; using namespace cv; int main() { Mat srcImage=imread("C:/Users/离子键/source/repos/Project8/1.jpg"); imshow("均值滤波【原图】...
毛星云opencv入门erode图像腐蚀代码
weixin_52634719的博客
10-15 218
using namespace std; using namespace cv; int main() { Mat srcImage=imread("C:/Users/离子键/source/repos/Project8/1.jpg"); imshow("【原图】腐蚀操作", srcImage); Mat element = getStructuringElement(MORPH_RECT, Size(5, 15)); Mat dstImage; erode(srcI...
OpenCV 入门
08-03
《OpenCV3编程入门》书本配套源代码 ============================== ####《Introduction to OpenCV3 Programming》Book Source Code ![](http://img.blog.csdn.net/20150325155409850) 本书有OpenCV2、...
OpenCV入门教程.7z
05-16
**OpenCV入门教程** OpenCV（开源计算机视觉库）是一个强大的跨平台计算机视觉库，它包含了大量的用于图像处理和计算机视觉的算法。本教程将帮助初学者了解OpenCV的基础知识，掌握C++语言与OpenCV的结合应用。 **1...
2024浙江省行政区划矢量图层-省市县乡镇四级行政区划数据下载-带python代码
最新发布
08-02
2024最新浙江省行政区划矢量图层数据，包含省、市、县、乡镇四级行政区划数据下载，附带shp转geojson的python代码
年度销售计划表.xlsx.xlsx
08-01
销售统计，调查问卷，库存明细，跟进表，业绩统计表，差异分析 ，产品清单 适用人群：学习不同技术领域的小白或进阶学习者；可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。
蓝牙BLE 4.0开发课程
08-01
蓝牙BLE 4.0课程
每日销售情况统计表.xls
08-01
销售统计，调查问卷，库存明细，跟进表，业绩统计表，差异分析 ，产品清单 适用人群：学习不同技术领域的小白或进阶学习者；可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。
TI官网cc2530资料.zip
08-01
TI官网cc2530资料.zip
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值