前言：
Mat是OpenCV的最基本的类型，他有很多常见的属性和方法，可以获取这张图片的基本信息，帮助我们更好地理解图片，本文做了一个简单的小结，并说明了一些常见的易错点。
一、Mat对象常见的属性以及方法一览
cout << image.cols << endl;         //相片的列数，一共有多少列，对应width
cout << image.rows << endl;         //相片的行数，一共有多少行，对应height
cout << image.dims << endl;         //相片的维度，这里都是二维
 
cout << image.type() << endl;       //16,其实是CV_8U3，即8位无符号三通道
cout << image.total() << endl;      //156500  总共有多少个元素，即rows*cols
cout << image.channels() << endl;   //相片的通道数，可能是1、3、4

//几个需要特别注意的方法，在下面一个一个说明
cout << image.step << endl;         //1500
cout << image.step1() << endl;      //1500
cout << image.elemSize() << endl;   //3
cout << image.elemSize1() << endl;  //1
cout << typeid(image.data).name() << endl;

1、type()方法
该方法返回的是一个int类型的整数，表示的是每一个像素（i,j）的数据类型，常见的比如：
CV_8U：8位单通道无符号，即灰度图像，返回的是0
CV_8UC3：8位三通道无符号，即常见的RGB图像，返回的是16
CV_32FC3：32位浮点数三通道，返回的是21

等等

2、elemSize1()方法
每一个像素位置（i,j）处单个通道所占用的字节数，是以字节byte为单位的。
CV_8U：8位单通道无符号，即灰度图像，只有一个通道，它为1byte
CV_8UC3：8位三通道无符号，即常见的RGB图像，每一个通道是8bit，依然为1byte
CV_32FC3：32位浮点数三通道，每一个通道是32位，所以为4byte
等等

3、elemSize()方法
每一个像素位置（i,j）处所有通道所占用的字节数，是以字节byte为单位的。
CV_8U：8位单通道无符号，即灰度图像，只有一个通道，它为1byte
CV_8UC3：8位三通道无符号，即常见的RGB图像，每一个通道是8bit，有三个通道，所以为3byte
CV_32FC3：32位浮点数三通道，每一个通道是32位，即4byte，一共有三个通道所以是 12byte

等等

注意：elemSize() 和elemSize1()的区别。
4、step属性
这个属性表示的是图片每一行的字节数，一字节byte为单位，
单通道8位灰度图：由于每一个像素只有一个通道，且为8位，即1字节，所以 step=1cols；

三通道8位RGB图：由于每一个像素包含三个通道，每一个通道为1字节，所以一个像素占3字节，所以step=3cols；

对于三通道32位浮点数：即上面的CV_32FC3，每一个像素有三个通道，每一个通道占用32位即4字节，所以每一个像素占用34字节，所以step=34*cols。
5、step1()方法
这个是最容易出错的，step1()=step/elemSize1()
二、Mat类的元素高效遍历方法

Mat类的元素便利有很多的方法，但是油的方法比较慢，这里提供一种高校的元素遍历方法，即通过image.data指针来实现。
2.1 data指针到底是什么意思
需要特别注意的是，
data指针指向的是Mat的首元素的指针，即位置(0,0)处的指针，它是将每一个像素点当成一个一维数组，然后指向这个数组的首元素，如果是单通道，则这个一位数组只有一个元素，如果是三通道，则这个一维数组是三个元素；

而且无论图像是什么类型，他总是返回的是unsigned char * 指针类型,即uchar类型，所以需要注意类型转换。

（1）对于单通道灰度图
//8位单通道，每个像素仅仅占用 1 byte
for (int i = 0; i < rows; i++)
{
    uchar * pixel = a.data + i * a.step;  //将指针移动到每一行的开始
	for (int j = 0; j < 5; j++)
	{
		cout << pixel[0] << endl;  //单通道只有一个元素
        pixel+=1;   //将指针移动到下一列
	}
	cout << endl;
}

（2）对于三通道RGB图像
//8位单通道，每个像素仅仅占用 1 byte
for (int i = 0; i < rows; i++)
{
    uchar * pixel = a.data + i * a.step;  //将指针移动到每一行的开始
	for (int j = 0; j < 5; j++)
	{
		cout << pixel[0] << endl;  //三通道第一个元素
        cout << pixel[1] << endl;  //三通道第二个元素
        cout << pixel[2] << endl;  //三通道第三个元素
 
        pixel+=3;   //将指针移动到下一列的首元素
	}
	cout << endl;
}

（3）对于三通道32位浮点数，即CV_32FC3
//8位单通道，每个像素仅仅占用 1 byte
for (int i = 0; i < rows; i++)
{
    float * pixel = (float *)a.data + i * a.step/4;  //将指针移动到每一行的开始需要转换，为什么需要除以4，一定要弄清楚它的本质
	for (int j = 0; j < 5; j++)
	{
		cout << pixel[0] << endl;  //三通道第一个元素
        cout << pixel[1] << endl;  //三通道第二个元素
        cout << pixel[2] << endl;  //三通道第三个元素
 
        pixel+=3;   //将指针移动到下一列的首元素
	}
	cout << endl;
}

两个需要注意的点：
（1）第一：什么时候需要除以一个数，这取决于每一个像素的每一个通道占用几个字节
 float * pixel = (float *)a.data + i * a.step/4; 

（2）第二：什么时候加1，什么时候加3，这取决于相片的通道数目
pixel+=3; 

Qt 中获取摄像头图像数据的方法

在 Qt 中提供了 QCamera 类用来操作摄像头。（这里的摄像头指的是电脑上常用的那种 USB 摄像头或网络摄像头，暂时还不支持工业相机。）摄像头获取的实时图像可以显示在 QCameraViewfinder 或 QGraphicsVideoItem 上，QCameraImageCapture 可以获取静态的图像，QMediaRecorder 可以用来录像。

用这些现有的组件可以很方便的完成一些基本的相机操作。但是如果我们做的更深入点，比如做个人脸识别、美颜处理一类的就不够用了。这时我们就需要获取相机的每一帧实时图像数据。

在 Qt 中，实现这个功能有两种主要的方法，一种是写一个派生自 QAbstractVideoSurface 的类。第二个方法是用 QVideoProbe。采用 QVideoProbe 比 第一种方法要简单。 

但是按照 https://wiki.qt.io/Qt_5.7_Multimedia_Backends 上面的说法：


  
QVideoProbe support: 

  Android: only for camera 

  Blackberry: no support 

  iOS: no support 

  Linux: only for media player 

  Mac: no support 

  Windows: only for media player 


QVideoProbe 暂时只在 android 平台上支持 QCamera。所以我们这篇文章主要来讲第一种方法。

QAbstractVideoSurface 是个纯虚类。要派生一个类需要我们实现两个函数。 

* bool present(const QVideoFrame &frame); 

* QList supportedPixelFormats(QAbstractVideoBuffer::HandleType type = QAbstractVideoBuffer::NoHandle) const

我们派生的类叫做 CameraImage，那么这个类的头文件可以这样。



class CameraImage : public QAbstractVideoSurface
{
    Q_OBJECT
public:
    QList<QVideoFrame::PixelFormat> supportedPixelFormats(
            QAbstractVideoBuffer::HandleType handleType = QAbstractVideoBuffer::NoHandle) const override;
    explicit CameraImage(QObject *parent = 0);
    void setVideoFrame(const QVideoFrame &frame);
private slots:
    bool present(const QVideoFrame &frame) override;
private:
    void setRGB24Image(const uint8_t *imgBuf, QSize size);
    void setRGB32Image(const uint8_t *imgBuf, QSize size);
    void setMono8Image(const uint8_t *imgBuf, QSize size);
    void setYUY2Image(const uint8_t *imgBuf, QSize size);
    void setVYUYImage(const uint8_t *imgBuf, QSize size);
    void setUYVYImage(const uint8_t *imgBuf, QSize size);
    QImage m_image;
};

这个类中的 m_image 就是用来存放相机图像数据的。相机采集的每一帧数据都会放到这里，供进一步处理。

supportedPixelFormats 函数用来返回所有的支持的 PixelFormats。这里我们只是做个例子，支持最基本的几种，作为一个完善的 CameraImage 类，当然是支持的像素类型越多越好。



CameraImage::CameraImage(QObject *parent)
    : QAbstractVideoSurface(parent)
{

}
QList<QVideoFrame::PixelFormat> CameraImage::supportedPixelFormats(
        QAbstractVideoBuffer::HandleType handleType) const
{
    Q_UNUSED(handleType);
    QList<QVideoFrame::PixelFormat> list;
    list << QVideoFrame::Format_RGB32;
    list << QVideoFrame::Format_ARGB32;
    list << QVideoFrame::Format_RGB24;
    list << QVideoFrame::Format_UYVY;
    list << QVideoFrame::Format_Y8;
    list << QVideoFrame::Format_YUYV;
    return list;
}

present 函数是最重要的，每次相机有新图像到来，都会调用 present 函数。



bool CameraImage::present(const QVideoFrame &frame)
 {
    // 处理捕获的帧
    if(frame.isMapped())
    {
        setVideoFrame(frame);
    }
    else
    {
        QVideoFrame f(frame);
        f.map(QAbstractVideoBuffer::ReadOnly);
        setVideoFrame(f);
    }
    return true;
 }

这里有个 QVideoFrame，需要讲解一下。一个 QVideoFrame 代表的就是相机的一帧数据。QVideoFrame::bits() 返回的是一帧图像的起始地址。但是在调用 bits() 函数之前还要先判断 frame 是否 map 了。所谓 map 就是将图像数据放到 CPU 可以寻址的地方。具体的大家可以看 QVideoFrame 的帮助文档。但是使用的方法很简单，就是先判断是否 map，如果没 map 就 map 一下。之后就可以正常使用了。

setVideoFrame 函数的作用是将 QVideoFrame 转换为 QImage。



void CameraImage::setVideoFrame(const QVideoFrame &frame)
{
    switch (frame.pixelFormat())
    {
    case QVideoFrame::Format_RGB24:
        setRGB24Image(frame.bits(), frame.size());
        break;
    case QVideoFrame::Format_RGB32:
    case QVideoFrame::Format_ARGB32:
    case QVideoFrame::Format_ARGB32_Premultiplied:
        setRGB32Image(frame.bits(), frame.size());
        break;
    case QVideoFrame::Format_Y8:
        setBayerImage(frame.bits(), frame.size());
        break;
    case QVideoFrame::Format_YUYV:
        setYUY2Image(frame.bits(), frame.size());
        break;
    case QVideoFrame::Format_UYVY:
        setUYVYImage(frame.bits(), frame.size());
        break;
    default:
        break;
    }

    // 这里可以做人脸识别一类的其他工作。
}

setVideoFrame 函数中又调用了 setRGB24Image 等其他函数。这些函数实现具体的数据转换操作。代码比较多，这里就不贴出来了。

void setRGB24Image(const uint8_t *imgBuf, QSize size);
void setRGB32Image(const uint8_t *imgBuf, QSize size);
void setMono8Image(const uint8_t *imgBuf, QSize size);
void setYUY2Image(const uint8_t *imgBuf, QSize size);
void setVYUYImage(const uint8_t *imgBuf, QSize size);
void setUYVYImage(const uint8_t *imgBuf, QSize size);

原标题：深度学习中常用的图像数据增强方法-纯干货
微信公众号：OpenCV学堂
关注获取更多计算机视觉与深度学习知识;
觉得文章对你有用，请戳底部广告支持
图像数据增强方法概述
图像数据准备对神经网络与卷积神经网络模型训练有重要影响，当样本空间不够或者样本数量不足的时候会严重影响训练或者导致训练出来的模型泛化程度不够，识别率与准确率不高！本文将会带你学会如何对已有的图像数据进行数据增强，获取样本的多样性与数据的多样性从而为训练模型打下良好基础。通读全文你将get到如何几个技能：
使用标准化对图像进行图像增强
使用几何变换(平移、翻转、旋转)对图像进行数据增强
使用随机调整亮度对图像进行增强
使用随机调整对比度对图像进行增强
演示基于mnist数据集，使用tensorflow+opencv，随机获取9张28x28的大小的数据图像，然后进行处理，处理之后通过opencv来显示结果。加载mnisnt数据集，获取随机9张图像，显示的代码如下：
fromtensorflow.examples.tutorials.mnist importinput_data
importtensorflow astf
importnumpy asnp
importcv2 ascv
mnist = input_data.read_data_sets( "MNIST_data/", one_hot= True)
batch_xs, batch_ys = mnist.train.next_batch( 9)
defshow_images(images_data, win_name):
plot_image = np.zeros(shape=[ 96, 96], dtype=np.float32)
fori inrange( 0, 9):
col = i % 3
row = i // 3
plot_image[row* 28:row* 28+ 28, col* 28:col* 28+ 28] = images_data[i].reshape( 28, 28)
# show the plot
cv.imshow(win_name, cv.resize(plot_image, ( 256, 256)))
batch_xs = batch_xs.reshape(batch_xs.shape[ 0], 1, 28, 28)
show_images(batch_xs, "batches")
sess = tf.Session()
print(batch_xs.shape)
选择9张mnist图像
图像标准化
关于图像标准化的原理，可以看本公众号以前的文章即可，点击如下链接即可查看：
深度学习训练-详解图像数据标准化与归一化
标准化的图像增强代码如下：
defstandardization():
results = np.copy(batch_xs)
fori inrange( 9):
image = sess.run(tf.image.per_image_standardization(batch_xs[i].reshape( 28, 28, -1)))
results[i, :, :, :] = image.reshape( -1, 28, 28)
show_images(results, "standardization")
标准化增强如下
翻转、旋转
图像几何变换通常包括图像的平移、翻转、旋转等操作，利用图像几何操作实现图像数据增强。
翻转操作代码如下：
def random_flip():
copy= np. copy(batch_xs)
copy= np.squeeze( copy, axis= 1)
copy= np.expand_dims( copy, axis= 3)
flip_results = sess.run(tf.image.flip_left_right( copy))
flip_results = np.squeeze(flip_results, axis= 3)
flip_results = np.expand_dims(flip_results, axis= 1)
print(flip_results.shape)
show_images(flip_results, "flip_left_right")
翻转增强之后显示
旋转操作代码如下：
defrandom_rotate():
results = np.copy(batch_xs)
fori inrange( 9):
image = sess.run(tf.image.rot90(batch_xs[i].reshape( 28, 28, -1), i% 4+ 1))
results[i, :, :, :] = image.reshape( -1, 28, 28)
show_images(results, "random_rotate")
随机90度旋转操作增强之后
随机亮度
随机亮度通过调整图像像素值改变图像亮度，这种方式对图像进行数据增强的代码如下：
defrandom_brightness():
results = np.copy(batch_xs)
fori inrange( 9):
image = sess.run(tf.image.random_brightness(batch_xs[i].reshape( 28, 28), 0.9))
results[i, :, :, :] = image.reshape( -1, 28, 28)
show_images(results, "random_brightness")
随机亮度增强之后显示
随机对比度
随机对比度，通过调整图像对比度来对图像进行数据增强，代码实现如下：
defrandom_contrast():
results = np.copy(batch_xs)
fori inrange( 9):
image = sess.run(tf.image.random_contrast(batch_xs[i].reshape( 28, 28, -1), 0.85, 1.5))
results[i, :, :, :] = image.reshape( -1, 28, 28)
show_images(results, "random_contrast")
随机对比度增强之后显示
python运行调用random_flip()
random_brightness()
random_contrast()
random_rotate()
standardization()
cv.waitKey(0)
cv.destroyAllWindows()
寇可为，我复亦为寇可往，我复亦往
插播一条广告，欢迎加入【OpenCV研习社】体系化学习计算机视觉，掌握OpenCV+tensorflow编程技术，扫描下面二维码即可加入，给自己未来加油！
责任编辑：

**图像数据增强方法概述**
图像数据准备对神经网络与卷积神经网络模型训练有重要影响，当样本空间不够或者样本数量不足的时候会严重影响训练或者导致训练出来的模型泛化程度不够，识别率与准确率不高！本文将会带你学会如何对已有的图像数据进行数据增强，获取样本的多样性与数据的多样性从而为训练模型打下良好基础。通读全文你将get到如何几个技能：
1.使用标准化对图像进行图像增强 深度学习训练-详解图像数据标准化与归一化
2.使用几何变换（平移、翻转、旋转）对图像进行数据增强
3.使用随机调整亮度对图像进行增强
4.使用随机调整对比度对图像进行增强
5.添加高斯噪声和椒盐噪声
6.对图像进行仿射变换
opencv2各模块功能

opencv_core：包含核心功能，尤其是底层数据结构和算法函数

opencv_imgproc : 包含图像处理函数

opencv_highgui : 包含读写图像及视频函数，以及操作图形用户界面函数

opencv_features2d : 包含兴趣点检测子，描述子和兴趣点匹配框架

opencv_calib3d : 包含相机标定，双目几何估算以及立体视觉函数

opencv_video : 包含运动估算，特征跟踪以及前景提取函数

opencv_objdetect : 包括物体检测函数，如面部识别
一、加椒盐噪声
图像模拟添加椒盐噪声是通过随机获取像素点并设置为高亮度点和低灰度点来实现的
图像添加椒盐噪声的程序如下：
//利用程序给原图像增加椒盐噪声
//图象模拟添加椒盐噪声是通过随机获取像素点斌那个设置为高亮度点来实现的
 
#include <cstdlib>
#include <iostream>
#include <opencv2\core\core.hpp>
#include <opencv2\highgui\highgui.hpp>
#include <opencv2\imgproc\imgproc.hpp>
 
using namespace cv;
using namespace std;
 
Mat addSaltNoise(const Mat srcImage, int n);
 
 
int main()
{
	Mat srcImage = imread("2345.jpg");
	if (!srcImage.data)
	{
		cout << "读入图像有误！" << endl;
		system("pause");
		return -1;
	}
	imshow("原图像", srcImage);
	Mat dstImage = addSaltNoise(srcImage, 3000);
	imshow("添加椒盐噪声的图像", dstImage);
	//存储图像
	imwrite("salt_pepper_Image.jpg", dstImage);
	waitKey();
	return 0;
}
 
Mat addSaltNoise(const Mat srcImage, int n)
{
	Mat dstImage = srcImage.clone();
	for (int k = 0; k < n; k++)
	{
		//随机取值行列
		int i = rand() % dstImage.rows;
		int j = rand() % dstImage.cols;
		//图像通道判定
		if (dstImage.channels() == 1)
		{
			dstImage.at<uchar>(i, j) = 255;		//盐噪声
		}
		else
		{
			dstImage.at<Vec3b>(i, j)[0] = 255;
			dstImage.at<Vec3b>(i, j)[1] = 255;
			dstImage.at<Vec3b>(i, j)[2] = 255;
		}
	}
	for (int k = 0; k < n; k++)
	{
		//随机取值行列
		int i = rand() % dstImage.rows;
		int j = rand() % dstImage.cols;
		//图像通道判定
		if (dstImage.channels() == 1)
		{
			dstImage.at<uchar>(i, j) = 0;		//椒噪声
		}
		else
		{
			dstImage.at<Vec3b>(i, j)[0] = 0;
			dstImage.at<Vec3b>(i, j)[1] = 0;
			dstImage.at<Vec3b>(i, j)[2] = 0;
		}
	}
	return dstImage;
}


二、添加高斯噪声
高斯噪声是指图像概率密度函数服从高斯分布的一类噪声。
根据Box-Muller变换原理，建设随机变量U1、U2来自独立的处于(0,1)之间的均匀分布，则经过下面两个式子产生的随机变量Z0，Z1服从标准高斯分布。


上式中Z0，Z1满足正态分布，其中均值为0，方差为1，变量U1和U2可以修改为下式：

给图像添加高斯噪声的程序如下：

//给图像添加高斯噪声
#include <cmath>
#include <limits>
#include <cstdlib>
#include <iostream>
#include <opencv2\core\core.hpp>
#include <opencv2\highgui\highgui.hpp>
 
using namespace cv;
using namespace std;
 
double generateGaussianNoise(double m, double sigma);
Mat addGaussianNoise(Mat &srcImag);
 
int main()
{
	Mat srcImage = imread("2345.jpg");
	if (!srcImage.data)
	{
		cout << "读入图片错误！" << endl;
		system("pause");
		return -1;
	}
	imshow("原图像", srcImage);
	Mat dstImage = addGaussianNoise(srcImage);
	imshow("添加高斯噪声后的图像", dstImage);
	waitKey();
	return 0;
}
 
//生成高斯噪声
double generateGaussianNoise(double mu, double sigma)
{
	//定义小值
	const double epsilon = numeric_limits<double>::min();
	static double z0, z1;
	static bool flag = false;
	flag = !flag;
	//flag为假构造高斯随机变量X
	if (!flag)
		return z1 * sigma + mu;
	double u1, u2;
	//构造随机变量
	do
	{
		u1 = rand() * (1.0 / RAND_MAX);
		u2 = rand() * (1.0 / RAND_MAX);
	} while (u1 <= epsilon);
	//flag为真构造高斯随机变量
	z0 = sqrt(-2.0*log(u1))*cos(2 * CV_PI*u2);
	z1 = sqrt(-2.0*log(u1))*sin(2 * CV_PI*u2);
	return z0*sigma + mu;
}
 
//为图像添加高斯噪声
Mat addGaussianNoise(Mat &srcImag)
{
	Mat dstImage = srcImag.clone();
	int channels = dstImage.channels();
	int rowsNumber = dstImage.rows;
	int colsNumber = dstImage.cols*channels;
	//判断图像的连续性
	if (dstImage.isContinuous())
	{
		colsNumber *= rowsNumber;
		rowsNumber = 1;
	}
	for (int i = 0; i < rowsNumber; i++)
	{
		for (int j = 0; j < colsNumber; j++)
		{
			//添加高斯噪声
			int val = dstImage.ptr<uchar>(i)[j] +
				generateGaussianNoise(2, 0.8) * 32;
			if (val < 0)
				val = 0;
			if (val>255)
				val = 255;
			dstImage.ptr<uchar>(i)[j] = (uchar)val;
		}
	}
	return dstImage;
}