opencv近期学习测试代码

#include<opencv2/opencv.hpp>
#include <iostream>
using namespace std;
using namespace cv;
Mat src,dst;
void CallBack_Demo(int, void*);
char out[] = "outPut";
int element_size = 3;
int max_size = 21;
int main()
{
	//显示图像
	
	src = imread("C:\\Users\\siasun\\Desktop\\10.jpg");
	if (src.empty())
	{
		cout << "counld not load image......" << endl;
		return -1;
	}
	namedWindow("image", CV_WINDOW_AUTOSIZE);
	imshow("image", src);
	//显示灰度图
	cvtColor(src, dst, CV_BGR2GRAY);
	namedWindow("image", CV_WINDOW_AUTOSIZE);
	imshow("image", dst);
	printf("input image channels:%d\n", dst.channels());

	//显示图像行列
	int cols = dst.cols;
	int rows = dst.rows;
	printf("rows:%d cols:%d\n", rows,cols);
	const uchar*firstRow = dst.ptr<uchar>(0);
	printf("input image channels:%d\n", *firstRow);

	//创建一张mat图像
	Mat M(3, 3, CV_8UC3, Scalar(0, 0, 255));
	//imshow("image", M);

	//创建与某图大小类型一致的空白图像
	Mat m2 = Mat::zeros(dst.size(), dst.type());
	//imshow("image", m2);

	//掩模,图像增强的两种方法
	cols = src.cols * src.channels();
	rows = src.rows;
	int offset = src.channels();
	Mat dst1 = Mat::zeros(src.size(), src.type());
	/*for (int row = 1; row < rows; row++)
	{
		const uchar* current = src.ptr<uchar>(row);
		const uchar* previous = src.ptr<uchar>(row - 1);
		const uchar* next = src.ptr<uchar>(row + 1);
		uchar* output = img.ptr<uchar>(row);
		for (int col = offset; col < cols; col++)

			output[col] = saturate_cast<uchar>(5 * current[col] - (current[col - offset] + current[col + offset] + previous[col] + next[col]));

	}*/
	Mat kernel = (Mat_<char>(3, 3) << 0, -1, 0, -1, 5, -1, 0, -1, 0);
	filter2D(src, dst1, src.depth(),kernel);
	//imshow("image", dst1);
	//imshow("image1", src);

	//读取图像像素，获取反差图
	Mat gray;
	cvtColor(src, gray, CV_BGR2GRAY);
	int height, width;
	height = gray.rows;
	width = gray.cols;
	for (int row = 0; row < height; row++)
	{
		for (int col = 0; col < width; col++)
		{
			int gray_value = gray.at<uchar>(row, col);
			gray.at<uchar>(row, col) = 255 - gray_value;
		}
	}

	//多通道反差图
	Mat grayMul,invertImg;
	cvtColor(src, gray, CV_BGR2GRAY);
	invertImg = Mat::zeros(src.size(), src.type());                                                                                                                                       
	int height1, width1;
	height1 = gray.rows;
	width1 = gray.cols;
	int channel = src.channels();
	for (int row = 0; row < height1; row++)
	{
		for (int col = 0; col < width1; col++)
		{
			if (channel == 1)
			{
				int gray_value = gray.at<uchar>(row, col);
				gray.at<uchar>(row, col) = 255 - gray_value;
			}
			else
			{
				int chan1 = src.at<Vec3b>(row, col)[0];
				int chan2 = src.at<Vec3b>(row, col)[1];
				int chan3 = src.at<Vec3b>(row, col)[2];
				invertImg.at<Vec3b>(row, col)[0] = 255 - chan1;
				invertImg.at<Vec3b>(row, col)[1] = 255 - chan2;
				invertImg.at<Vec3b>(row, col)[2] = 255 - chan3;
			}
		}
	}
	//opencv反差图算法
	bitwise_not(src, invertImg);//一个算子搞定
	//Vec3b对应三通道的顺序是bgr的uchar类
	//Vec3f对应float类型数据
	//把cv_8uc1转到cv32f1:src.convertTo(dst,CV_32F)
	//取三个数最小值思想min(a,min(b,c))

	//图像混合
	/*int alpha = 0.5;//权重
	addWeighted(src, alpha, src1, (1 - alpha),dst);*/
	char input_title[] = "input title";
	//模糊图像
	blur(src, dst, Size(5, 5), Point(-1, -1));
	GaussianBlur(src, dst, Size(5, 5), 11, 11);
	medianBlur(src, dst, 3);//输入，输出，模板大小
	//双边模糊,更好的保护边缘信息
	bilateralFilter(src, dst, 15, 100, 5);//计算半径，差值范围（以内的用来计算），模板大小
	imshow(input_title, dst);
	//膨胀 结构元素覆盖下图像的最大像素值
	//腐蚀 结构元素覆盖下图像的最小像素值
	//char out[] = "outPut";
	namedWindow("out", CV_WINDOW_AUTOSIZE);
 	createTrackbar("element_size:", "out", &element_size, max_size, CallBack_Demo);
	CallBack_Demo(0, 0);
	//形态学
	//基本梯度 膨胀减去腐蚀
	//内部梯度 原图减去
	//方向梯度 x与y方向做梯度
	//黑帽 闭操作与原图的差值图像
	//顶帽 开操作与原图像的差值图像
	Mat strucElement = getStructuringElement(MORPH_RECT, Size(3,3), Point(0, 0));
	morphologyEx(src, dst, CV_MOP_TOPHAT, strucElement);
	
	//图像金字塔
	//上采样
	pyrUp(src, dst, Size(src.cols * 2, src.rows * 2));
	pyrDown(src, dst, Size(src.cols / 2, src.rows / 2));
	//高斯不同
	Mat g1, g2, gr, dogImg;
	cvtColor(src, gr, CV_BGR2GRAY);

	GaussianBlur(gr, g1, Size(5, 5), 0, 0);
	GaussianBlur(g1, g2, Size(5, 5), 0, 0);
	subtract(g1, g2, dogImg, Mat());
	//sobel边缘检测
	Mat gray_src;
	GaussianBlur(src, dst, Size(3, 3), 0, 0);
	cvtColor(dst, gray_src, CV_BGR2GRAY);
	Mat xgrad, ygrad;
	Sobel(gray_src, xgrad, CV_16S, 1, 0, 3);
	Sobel(gray_src, ygrad, CV_16S, 0, 1, 3);
	convertScaleAbs(xgrad, xgrad);//取绝对值
	convertScaleAbs(ygrad, ygrad);
	Mat xygray;
	//x,y分配权重
	addWeighted(xgrad, 0.5, ygrad, 0.5,0, xygray,-1);
	//分配权重，替换addweighted
	xygray = Mat(xgrad.size(), xgrad.type());
	int heigh = ygrad.rows;
	int weigh = xgrad.cols;
	for (int row = 0; row < heigh; row++)
	{
		for (int col = 0; col < weigh; col++)
		{
			int x = xgrad.at<char>(row, col);
			int y = ygrad.at<char>(row, col);
			int n = x + y;
			xygray.at<char>(row, col) = saturate_cast<char>(n);
		}
	}
	//another method 求边缘
	Scharr(gray_src, xgrad, CV_16S, 1, 0);
	Scharr(gray_src, ygrad, CV_16S, 0, 1);
    //laplance边缘
	Mat lap_img;
	GaussianBlur(src, dst, Size(3, 3), 0, 0);
	cvtColor(dst, gray_src, CV_BGR2GRAY);
	Laplacian(gray_src, lap_img, CV_16S, 3);
	convertScaleAbs(lap_img, lap_img);
	threshold(lap_img, lap_img, 0, 255, THRESH_OTSU | THRESH_BINARY);
	//canny 边缘
	//高斯模糊、灰度、梯度（sobel，scharr）、非最大值抑制、阈值
	Canny(gray_src, dst, 20, 40, 3, false);
	//直方图均衡化，提高图像对比度
	equalizeHist(src, dst);//src需为八位单通道图像
	waitKey(0);

	return 0;
}

void CallBack_Demo(int, void*)
{
	int s = element_size * 2 + 1;
	Mat strucElement = getStructuringElement(MORPH_RECT, Size(s,s), Point(0,0));
	dilate(src, dst, strucElement, Point(-1, -1),1);//后面的1指膨胀迭代次数
	imshow("out", dst);
	return;
}