图像点运算(代数运算、逻辑运算及几何运算)

环境：vs2019+OpenCV4.5.1

实验内容：图像（相加）平均去除高斯噪音

/*
图像平均的一种重要应用是在天文学领域，在该领域在非常低的照度下成像常常会导致传感器噪声；以至于单幅图像无法解析；
多次高斯模糊求平均值可以消除图像在低照度下的噪音
*/
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

using namespace cv;
using namespace std;

//产生高斯噪声的函数，

double generateGaussianNoise()
{
	static bool hasSpare = false;
	static double rand1, rand2;

	if (hasSpare)
	{
		hasSpare = false;
		//sqrt()函数：求给定值的平方根
		return sqrt(rand1) * sin(rand2);
	}

	hasSpare = true;
	//其值最小为32767,最大为2147483647 通常在产生随机小数时可以使用RAND_MAX。
	rand1 = rand() / ((double)RAND_MAX);
	// 1e-100是一个科学记数法的数字1x10的-100次方
	if (rand1 < 1e-100) rand1 = 1e-100;
	rand1 = -2 * log(rand1);
	rand2 = (rand() / ((double)RAND_MAX)) * CV_PI * 2;
	//    cout << "gaussi: " << sqrt(rand1) * cos(rand2) << endl;
	return sqrt(rand1) * cos(rand2);
}

//为图像添加高斯噪声
void addGaussianNoise(Mat& srcImag)
{
	//    Mat dstImage = srcImag.clone();
	int channels = srcImag.channels();
	int rowsNumber = srcImag.rows;
	int colsNumber = srcImag.cols * channels;
	//判断图像的连续性  cv::Mat::isContinuous()函数，返回bool值，判断存储是否连续。
	if (srcImag.isContinuous())
	{
		colsNumber *= rowsNumber;
		rowsNumber = 1;
	}
	for (int i = 0; i < rowsNumber; i++)
	{
		for (int j = 0; j < colsNumber; j++)
		{
			//添加高斯噪声
			//uchar * data01 = image.ptr(0)[1];//data01是指向image第一行第二个元素的指针。
			int val = srcImag.ptr<uchar>(i)[j] +
					  generateGaussianNoise() * 32;
			if (val < 0)
				val = 0;
			if (val > 255)
				val = 255;
			srcImag.ptr<uchar>(i)[j] = (uchar)val;
		}
	};
	//imshow("newname", srcImag);
	//    return srcImag;
}


Mat eliminate_noise(vector<Mat>& img_vec)
{
	//返回容器是否为空
	if (img_vec.empty()) {
		cerr << "image vector empty" << endl;
		Mat err;
		return err;
	}
	Mat average = Mat::zeros(img_vec.at(0).size(), CV_32FC3);
	int n = (int)img_vec.size();
	for (int i = 0; i < n; i++) {
		accumulate(img_vec.at(i), average);//累加到average
	}
	average = average / n; //求出平均图像
	average.convertTo(average, CV_8U);

	return average;
}


int main(int argc, char* argv[])
{
	//    string name ="image.jpg";
	size_t ImageSize = 20;
	//atoi()函数返回转换后的整型数。
	//int ImageSize = atoi(argv[2]);
	//string name = argv[1];
	Mat pic = imread("d:\\images\\dili.jpg", IMREAD_COLOR);
	//    根据数量生成图片
	vector<Mat> my_pics;
	string newname;
	for (size_t i = 0; i < (size_t)ImageSize; i++) {
		Mat newImage = pic.clone();
		addGaussianNoise(newImage);

		ostringstream ss;
		ss << "noise" << i << ".jpg";		
		newname = ss.str();
		//        imwrite(newname, newImage);
		my_pics.push_back(newImage);
	}
	//　　c.at(idx) 传回索引idx所指的数据，如果idx越界，抛出out_of_range。
	imshow("noise", my_pics.at(0));
	cout << "add Noise end" << endl;

	//获得消除噪声的输出
	Mat out = eliminate_noise(my_pics);
	ostringstream ss;
	ss << "output" << ImageSize << ".jpg";
	newname = ss.str();
	Mat dest_img = out.clone();
	imwrite(newname, dest_img);
	cout << "deal end" << endl;
	imshow("src", pic);
	imshow("dst", dest_img);
	waitKey(0);

	return 0;

	/*
	* 
	 //size_t是一些C/C++标准在stddef.h中定义的。这个类型足以用来表示对象的大小。
	 //size_t是无符号的，并且是平台无关的，表示0-MAXINT的范围；
		
	方法str()将缓冲区的内容复制到一个string对象中，并返回
	ostr1 << "ostr1 " << 2012 << endl; // 格式化，此处endl也将格式化进ostr1中
	cout << ostr1.str();
		
	 Mat::zeros
	返回指定的大小和类型的零数组。
	C++: static MatExpr Mat::zeros(int rows, int cols, int type)
	C++: static MatExpr Mat::zeros(Size size, int type)
	C++: static MatExpr Mat::zeros(int ndims, const int* sizes, int type)
	参数
	ndims – 数组的维数。
	rows–行数。
	cols  –列数。
	size–替代矩阵大小规格Size(cols, rows)的方法。
	sizes– 指定数组的形状的整数数组。
	type– 创建的矩阵的类型。
	该方法返回一个 Matlab 式的零数组初始值设定项。它可以用于快速形成一个常数数组作为函数参数，
	作为矩阵的表达式或矩阵初始值设定项的一部分。
	Mat A；
	A = Mat::zeros （3，3，CV_32F）；
	在上面的示例中，只要A不是 3 x 3浮点矩阵它就会被分配新的矩阵。否则为现有的
	矩阵 A填充零。
	*/
}

实验内容：自己选定两副图像，读入图像尝试实现图像相减、相乘、相除的代数运算

#include 
#include 
#include 
#include 
#include 

using namespace std;
using namespace cv;

int main(int argc, char* argv[])
{
    Mat img1 = imread("d:\\images\\view.jpg");
    Mat img2 = imread("d:\\images\\rain.jpg");

    int height = img1.rows;                //行数
    int width = img1.cols;                   //列数
    int dims = img1.dims;                    //维数
    cout << height << "  " << width << "  " << dims << endl;

    Mat tmp(height, width, CV_8UC3, Scalar(2, 2, 2));  //产生一个[height width 3]所有元素全为2的矩阵
    Mat re;
    //运算符重载真是让人喜欢
    re = img1 + Scalar(100, 100, 100);                    //图像相加
    imshow("加", re);

    re = img1 - img2;                      //图像相减
    imshow("减", re);

    re = img1 * 2;                      //图像和一个数相乘    
    imshow("乘", re);

    re = img1 / 2;                    //图像和一个数相除
    imshow("除", re);

    re = img1.mul(tmp);            //img1和tmp每个元素相乘
    imshow("image5", re);
    Vec3i s = re.at<Vec3b>(1, 1);   //数据访问
    cout << s.val[0] << "  " << s.val[1] << "  " << s.val[2] << endl;

    imwrite("re.jpg", re);
    waitKey();

    return 0;
    /*
    *
    加运算就是两幅图像对应像素的灰度值或彩色分量进行相加。主要有两种用途，一种是消除图像的随机噪声，
    主要做是讲同一场景的图像进行相加后再取平均；
    另一种是用来做特效，把多幅图像叠加在一起，再进一步进行处理。
    对于灰度图像，因为只有单通道，所以直接进行相应位置的像素加法即可，
    对于彩色图像，则应该将对应的颜色的分量分别进行相加。
    通常来将，两幅或多幅相加的图像的大小和尺寸应该相同。

    减法运算就是两幅图像见对象像素的灰度值或彩色分量进行相减，它可以用于目标检测

    图像的乘法运算就是将两幅图像对应的灰度值或彩色分量进行相乘。
    乘运算的主要作用是抑制图像的某些区域，掩膜值置为1，否则置为0。乘运算有时也被用来实现卷积或相关的运算。

    图像除运算就是两幅图像对应像素的灰度值或彩色分量进行相除。
    简单的除运算可以用于改变图像的灰度级
    */
}

实验内容：放大和缩小

#include 
#include 
#include 
#include 
#include 
#include 

using namespace std;
using namespace cv;

int main()
{
    Mat src = imread("d:\\images\\dili.jpg");

    if (src.data != NULL)
    {
        Mat bigImage;
        //放大图像
        resize(src, bigImage, Size(src.cols * 2, src.rows * 2));

        Mat smallImage;
        //缩小图像
        resize(src, smallImage, Size(src.cols / 2, src.rows / 2));

        imshow("原始图像", src);

        imshow("放大图像", bigImage);

        imshow("缩小图像", smallImage);

        cvWaitKey(0);
    }
    else
    {
        cout << "图片加载失败，请检查文件是否存在!" << endl;
    }

    getchar();
    return 0;
}
/*
* 1、最邻近插值法(Nearest Interpolation)

这是最简单的一种插值方法，不需要计算。在待求像素的四邻像素中，
将距离待求像素最近的邻接像素灰度值赋予待求像素。设i+u, j+v(i, j为正整数，
u, v为大于零小于1的小数，下同)为待求象素坐标，

最邻近元法计算量较小，但可能会造成插值生成的图像灰度上的不连续，在灰度变化的地方可能出现明显的锯齿状。

双线性内插法的计算比最邻近点法复杂，计算量较大，但没有灰度不连续的缺点。它具有低通滤波性质，
使高频分量受损，图像轮廓可能会有一点模糊。图像看起来更光滑。

*/

实验内容：实现图像的镜像

#include 
#include 

using namespace cv;
/*图像水平镜像变换是将图像左半部分和右半部分以图像的垂直中轴线为中心，进行镜像变换。
* 图像垂直变换是将图像上半部分和下半部分以图像的水平中轴线为中心，进行镜像对换
* 
* 图像的对角镜像变换是以原图像水平中轴线和垂直中轴线的交点为中心将图像进行变换，
	相当于先对图像进行水平镜像变换，再进行垂直镜像变换
*/
int main() {
#pragma region 镜像处理
		Mat image = imread("d:\\images\\dili.jpg");
		Mat src=image.clone();
		namedWindow("initial");
		imshow("initial",image);
		waitKey(0);
		int W=image.cols;
		int L=image.rows;

		Vec3b temp;
		//竖直镜像
		for (int x=0;x<W;x++)
		{
			//下面两种变换方法的不同之处在于
			//变换方法一
	// 		for (int y1=0,y2=L-1;y2-y1>0;y1++,y2--)
	// 		{
	// 			temp = image.at(y1,x);
	// 			image.at(y1,x)=image.at(y2,x);
	// 			image.at(y2,x)=temp;
	// 		}
			//变换方法二
			for (int y1=0,y2=L-1;y1<=y2/2;y1++)
			{
				temp = image.at<Vec3b>(y1,x);
				image.at<Vec3b>(y1,x)=image.at<Vec3b>(y2-y1,x);
				image.at<Vec3b>(y2-y1,x)=temp;
			}
		}
		namedWindow("竖直镜像");
		imshow("竖直镜像",image);
		waitKey(0);

		//水平镜像
		imshow("src",src);
		waitKey(0);
		for (int y=0;y<L;y++)
		{
			for (int x1=0,x2=W-1;x1<x2;x1++,x2--)
			{
				temp=src.at<Vec3b>(y,x1);
				src.at<Vec3b>(y,x1)=src.at<Vec3b>(y,x2);
				src.at<Vec3b>(y,x2)=temp;
			}
		}
		namedWindow("水平镜像");
		imshow("水平镜像",src);
		waitKey(0);

		system("pause");
		return 0;
	}