OpenCV图像处理笔记（一）：图片基本操作

#include<opencv2/opencv.hpp>
#include<iostream>
#include<math.h>
using namespace cv;

int main(int argc, char ** argv) {
	Mat src, dst;
	src = imread("C:\Users\15646\Pictures\雷军.jpg");

	if (!src.data)
	{
		printf("no imagen");
		return -1;
	}
	namedWindow("input img", CV_WINDOW_AUTOSIZE);
	imshow("input img", src);
	
	int cols = (src.cols-1)* src.channels();
	int offsetx = src.channels();
	int rows = src.rows;
	dst = Mat(src.size(), src.type());
	for (int row = 1; row < rows-1; row++)
	{
		const uchar* current = src.ptr<uchar>(row);
		const uchar* previous = src.ptr<uchar>(row - 1);
		const uchar* next = src.ptr<uchar>(row);
		uchar* output = dst.ptr<uchar>(row);
		for (int col = offsetx; col<cols;col++)
		{
			output[col] = saturate_cast<uchar>(5 * current[col] - (current[col - offsetx] +
				current[col + offsetx] + previous[col] + next[col]));
		}
	}

	namedWindow("contrast img ", CV_WINDOW_AUTOSIZE);
	imshow("contrast img ", dst);
	waitKey(0);
	return 0;
}

   Mat kernel = (Mat_<char>(3, 3) << 0, -1, 0, -1, 5, -1, 0, -1, 0);
filter2D(src,dst,src.depth(),kernel);

void copyTo(Mat mat)    克隆
void convertTo(Mat dst, int type) 
Mat clone() 克隆
int channels()  获取通道
int depth()
bool empty();
uchar* ptr(i=0)  获取指针

Mat A= imread(imgFilePath);
Mat B(A)  // 只复制

Mat F = A.clone(); 或 Mat G; A.copyTo(G);

cv::Mat::Mat构造函数
	Mat M(2,2,CV_8UC3, Scalar(0,0,255))
	其中前两个参数分别表示行(row)跟列(column)、第三个CV_8UC3中的8表示每个通道占8位、U表示无符号、C表示Char类型、3表示通道数目是3，
	第四个参数是向量表示初始化每个像素值是多少，向量长度对应通道数目一致

创建多维数组cv::Mat::create
	 int sz[3] = {2,2,2};     
	Mat  L(3,sz, CV_8UC1, Scalar::all(0));

Mat C = (Mat_<double>(3,3) << 0, -1, 0, -1, 5, -1, 0, -1, 0);

   Mat m2;
m2 = Mat::zeros(2, 2, CV_8UC1);
imshow("demo2", m2);

Scalar intensity = img.at<uchar>(y, x); 
或者 Scalar intensity = img.at<uchar>(Point(x, y));

Vec3f intensity = img.at<Vec3f>(y, x); 
float blue = intensity.val[0]; 
float green = intensity.val[1]; 
float red = intensity.val[2];

img.at<uchar>(y, x) = 128;

img.at<Vec3b>(y,x)[0]=128; // blue
img.at<Vec3b>(y,x)[1]=128; // green
img.at<Vec3b>(y,x)[2]=128; 

img = Scalar(0);

Rect r(10, 10, 100, 100);  
Mat smallImg = img(r);

int main(int argc, char ** argo) {

	Mat src, gray_src;
	src = imread("C:\Users\Administrator\Pictures\girl.jpg");
	if (src.empty())
	{
		cout <<" read img error!"<< endl ;
	}

	namedWindow("src img", CV_WINDOW_AUTOSIZE);
	imshow("src img", src);

	cvtColor(src, gray_src, CV_BGR2GRAY);
	//namedWindow("gray_src img", CV_WINDOW_AUTOSIZE);
	//imshow("gray_src img", gray_src);


	int height = gray_src.rows;
	int width = gray_src.cols;

	for (int row =0;row<height;row++)
	{
		for (int col = 0;  col< width;col ++)
		{
			//获取像素值
			int gray = gray_src.at<uchar>(row, col);
			gray_src.at<uchar>(row, col) = 255 - gray;
		}
	}

	namedWindow("gray_src_change img", CV_WINDOW_AUTOSIZE);
	imshow("gray_src_change img", gray_src);

	//Mat操作
	Mat dst;
	dst.create(src.size(), src.type());
	height = src.rows;
	width = src.cols;
	//获取图片通道值
	int nc = src.channels();

	/*for (int row = 0; row < height; row++)
	{
		for (int col = 0; col < width; col++)
		{
			if (nc ==1)
			{
				int gray = gray_src.at<uchar>(row, col);
				gray_src.at<uchar>(row, col) = 255 - gray;
			}
			else if(nc == 3)
			{
				int b = src.at<Vec3b>(row, col)[0];
				int g = src.at<Vec3b>(row, col)[1];
				int r = src.at<Vec3b>(row, col)[2];
				dst.at<Vec3b>(row, col)[0] = 255 - b;
				dst.at<Vec3b>(row, col)[1] = 255 - g;
				dst.at<Vec3b>(row, col)[2] = 255 - r; 
			}
		}
	}*/

	//上面的转换代码可以替换,效果相同
	bitwise_not(src, dst);
	imshow("gray_src_change_by_mat img", dst);

	cout << "enter anything" << endl;
	waitKey(0);
	return 0;
}

void addWeighted(InputArray src1, 
                    double alpha, 
                    InputArray src2,
                    double beta, 
                    double gamma, 
                    OutputArray dst, 
                    int dtype = -1);

参数1：输入图像Mat – src1
参数2：输入图像src1的alpha值
参数3：输入图像Mat – src2
参数4：输入图像src2的alpha值
参数5：gamma值
参数6：输出混合图像

注意点：两张图像的大小和类型必须一致才可以

//设置权重
	double alpha = 0.5;
	if (src1.rows==src2.rows && src1.cols==src2.cols && src1.type() == src2.type())
	{
		addWeighted(src1, alpha, src2, (1.0 - alpha), 0.0, dst);
		//multiply(src1, src2, dst, 1.0); 图像相乘
		imshow("dst", dst);
	}

Mat new_image = Mat::zeros( image.size(), image.type() );  创建一张跟原图像大小和类型一致的空白图像、像素值初始化为0

saturate_cast<uchar>(value)确保值大小范围为0~255之间

Mat.at<Vec3b>(y,x)[index]=value 给每个像素点每个通道赋值

int height = src1.rows; //高度
	int width = src1.cols; //宽度
	double alpha = 0.8; 
	int beta = 30;

	//生成一个空的大小和src1一样大的图
	output = Mat::zeros(src1.size(), src1.type());
	for (int row = 0; row < height; row++)
	{
		for (int col = 0; col < width; col++)
		{
			if (src1.channels()==3)
			{
				//像素点变换，换值,达到调整亮度和对比度的效果
				float b = src1.at<Vec3b>(row, col)[0]; //blue
				float g = src1.at<Vec3b>(row, col)[1]; //green
				float r = src1.at<Vec3b>(row, col)[2]; //red

				output.at<Vec3b>(row, col)[0] = saturate_cast<uchar>(alpha*b + beta);
				output.at<Vec3b>(row, col)[1] = saturate_cast<uchar>(alpha*g + beta);
				output.at<Vec3b>(row, col)[2] = saturate_cast<uchar>(alpha*r + beta);
			}
			else if(src1.channels()==1)
			{
				output.at<uchar>(row, col) = saturate_cast<uchar>(alpha*src1.at<uchar>(row, col)+ beta);
			}
			
		}
	}

Point表示2D平面上一个点x,y
	Point p;
	p.x = 10;
	p.y = 8;
 	or
	p = Pont(10,8);
	
Scalar表示四个元素的向量
	Scalar(a, b, c);// a = blue, b = green, c = red表示RGB三个通道

画线 cv::line （LINE_4LINE_8LINE_AA）
画椭圆cv::ellipse
画矩形cv::rectangle
画圆cv::circle
画填充cv::fillPoly

#include<opencv2opencv.hpp>
#include<iostream>
 
using namespace std;
using namespace cv;
Mat bgImage;
void Myline();
void MyRectangle();
void MyEllipse();
void MyCircle();
void MyPolygon();

int main() {

	bgImage = imread("C:\Users\Administrator\Pictures\girl2.jpg");
	if (!bgImage.data)
	{
		return -1;
	}

	Myline();
	MyRectangle();
	MyEllipse();
	MyCircle();
	MyPolygon();

	imshow("bgImage", bgImage);

	waitKey(0);
	return 0;
}
//画线
void Myline() {
	Point p1 = Point(20, 30);
	Point p2;

	p2.x = 300;
	p2.y = 300;

	//设置颜色
	Scalar color = Scalar(0, 0, 255);
	line(bgImage, p1, p2, color, 1, LINE_8);
}

//画矩形
void MyRectangle() {
	Rect rect = Rect(150, 500, 300, 300);
	Scalar color = Scalar(255, 0, 0);
	rectangle(bgImage, rect, color, 2, LINE_8);
}

//绘制椭圆
void MyEllipse() {
	Scalar color = Scalar(0, 255, 0);
	ellipse(bgImage, 
		Point(bgImage.cols / 2, bgImage.rows / 2), 
		Size(bgImage.cols / 4, bgImage.rows / 8),
		90,0,360,color,2,LINE_8);
}

//绘制圆
void MyCircle() {
	Scalar color = Scalar(0, 255, 0);
	Point center = Point(bgImage.cols / 2, bgImage.rows / 2);
	circle(bgImage, center, 150, color, 2, LINE_8);
}

//绘制多边形
void MyPolygon() {
	Point pts[1][5];
	pts[0][0] = Point(100, 100);
	pts[0][1] = Point(100, 200);
	pts[0][2] = Point(200, 200);
	pts[0][3] = Point(200, 100);
	pts[0][4] = Point(100, 100);

	const Point* ppts[] = {pts[0]};
	int npt[] = { 5 };
	Scalar color = Scalar(255, 140, 0);

	fillPoly(bgImage, ppts, npt, 1, color, LINE_8);
}

生成高斯随机数gaussian (double sigma)
生成正态分布随机数uniform (int a, int b)

void RandomLineDemo() {
	RNG rng(12345);
	Point pt1, pt2;
	Mat new_img = Mat::zeros(bgImage.size(), bgImage.type());
	for (int i = 0; i < 100000;i++)
	{
		//随机生成的两个端点
		pt1.x = rng.uniform(0, bgImage.cols);
		pt2.x = rng.uniform(0, bgImage.cols);
		pt1.y = rng.uniform(0, bgImage.rows);
		pt2.y = rng.uniform(0, bgImage.rows);

		int num = rng.uniform(0, 255);
		line(new_img, pt1, pt2, CV_RGB(rng.uniform(0, 255), rng.uniform(0, 255), rng.uniform(0, 255)), 1, LINE_8);

		//延迟50ms
		if (waitKey(50)>0)
		{
			break;
		}
		imshow("随机生成图片", new_img);
	}	
}

putText函数 中设置fontFace(cv::HersheyFonts), 

putText(bgImage, "Hello World", Point(300, 300), CV_FONT_BLACK, 1.0, CV_RGB(255, 69, 0), 1, LINE_8);