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);
}