学习OpenCV2——产生随机数

        产生随机数是编程中经常用到的操作，特别在进行初始化的时候需要赋一些随机值。C和C++中产生随机数的方法如rand()、srand()等在OpenCV中仍可以用。此外，OpenCV还特地编写了C++的随机数类RNG，C的随机数类CvRNG，还有一些相关的函数，使用起来更加方便。下面，一一介绍。

说明

关键字前带cv的都是C里的写法，不带cv的是C++里的写法，比如CvRNG和RNG，其本质都是一样的。
计算机产生的随机数都是伪随机数，是根据种子seed和特定算法计算出来的。所以，只要种子一定，算法一定，产生的随机数是相同的
要想产生完全重复的随机数，可以用系统时间做种子。OpenCV中用GetTickCount()，C 中用time()

所有的结果见最后面截图。

1. OpenCV中的C++版本随机数

1.1 RNG

      RNG类是opencv里C++的随机数产生器。它可产生一个64位的int随机数。目前可按均匀分布和高斯分布产生随机数。随机数的产生采用的是Multiply-With-Carry算法和Ziggurat算法。

1.1.1 产生一个随机数

RNG可以产生3种随机数
RNG(int seed)         使用种子seed产生一个64位随机整数，默认-1
RNG::uniform( )      产生一个均匀分布的随机数
RNG::gaussian( )    产生一个高斯分布的随机数

RNG::uniform(a, b )  返回一个[a,b)范围的均匀分布的随机数，a,b的数据类型要一致，而且必须是int、float、double中的一种，默认是int。

RNG::gaussian( σ)   返回一个均值为0，标准差为σ的随机数。

                                 如果要产生均值为λ，标准差为σ的随机数，可以λ+ RNG::gaussian( σ)

//创建RNG对象，使用默认种子“-1”
RNG rng;

//产生64位整数
int N1 = rng;

/*-------------产生均匀分布的随机数uniform和高斯分布的随机数gaussian---------*/

//总是得到double类型数据0.000000，因为会调用uniform(int,int),只会取整数，所以只产生0
double N1a = rng.uniform(0,1);

//产生[0,1)范围内均匀分布的double类型数据
double N1b = rng.uniform((double)0,(double)1);

//产生[0,1)范围内均匀分布的float类型数据，注意被自动转换为double了。
double N1c = rng.uniform(0.f,1.f);

//产生[0,1)范围内均匀分布的double类型数据。
double N1d = rng.uniform(0.,1.);

//可能会因为重载导致编译不通过(确实没通过。。)
//double N1e = rng.uniform(0,0.999999);

//产生符合均值为0，标准差为2的高斯分布的随机数
double N1g = rng.gaussian(2);

    其实，rng既是一个RNG对象，也是一个随机整数。

1.1.2 返回下一个随机数

       上面一次只能返回一个随机数，实际上系统已经生成一个随机数组。如果我们要连续获得随机数，没有必要重新定义一个RNG类，只需要取出随机数组的下一个随机数即可。

RNG:: next                   返回下一个64位随机整数 

RNG:: operator            返回下一个指定类型的随机数

RNG rng;
int N2 = rng.next();                    //返回下一个随机整数，即N1.next();

//返回下一个指定类型的随机数
int N2a = rng.operator uchar();         //返回下一个无符号字符数
int N2b = rng.operator schar();         //返回下一个有符号字符数
int N2c = rng.operator ushort();        //返回下一个无符号短型
int N2d = rng.operator short int();     //返回下一个短整型数
int N2e = rng.operator int();           //返回下一个整型数
int N2f = rng.operator unsigned int();  //返回下一个无符号整型数
int N2g = rng.operator float();         //返回下一个浮点数
int N2h = rng.operator double();        //返回下一个double型数
int N2i = rng.operator ()();            //和rng.next( )等价
int N2j = rng.operator ()(100);         //返回[0,100)范围内的随机数

1.1.3 用随机数填充矩阵 RNG::fill( )

void fill( InputOutputArray mat, int distType, InputArray a, InputArray b, bool saturateRange=false );

InputOutputArray                    输入输出矩阵，最多支持4通道，超过4通道先用reshape()改变结构

int distType                             UNIFORM 或 NORMAL，表示均匀分布和高斯分布

InputArray a                           disType是UNIFORM,a表示为下界(闭区间)；disType是NORMAL,a均值

InputArray b                           disType是UNIFORM,b表示为上界(开区间)；disType是NORMAL,b标准差

bool saturateRange=false     只针对均匀分布有效。当为真的时候，会先把产生随机数的范围变换到数据类型的范围，再产生随机数；

                                             如果为假，会先产生随机数，再进行截断到数据类型的有效区间。请看以下fillM1和fillM2的例子并观察结果 

//产生[1,1000)均匀分布的int随机数填充fillM
Mat_<int>fillM(3,3);
rng.fill(fillM,RNG::UNIFORM,1,1000);
cout << "filM = " << fillM << endl << endl;

Mat fillM1(3,3,CV_8U);
rng.fill(fillM1,RNG::UNIFORM,1,1000,TRUE);
cout << "filM1 = " << fillM1 << endl << endl;

Mat fillM2(3,3,CV_8U);
rng.fill(fillM2,RNG::UNIFORM,1,1000,FALSE);
cout << "filM2 = " << fillM2 << endl << endl;
//fillM1产生的数据都在[0,，255)内，且小于255；
//fillM2产生的数据虽然也在同样范围内，但是由于用了截断操作，所以很多数据都是255,

//产生均值为1，标准差为3的随机double数填进fillN
Mat_<double>fillN(3,3);
rng.fill(fillN,RNG::NORMAL,1,3);
cout << "filN = " << fillN << endl << endl;

    前面的这些方法都是基于RNG类的，需要先定义RNG类，下面的方法则不需要，只不过不能定义seed，所以不能产生不重复的随机数组。

1.2 randu( )

作用：返回均匀分布的随机数，填入数组或矩阵
randu(dst, low, high) ;
dst – 输出数组或矩阵 ；low – 区间下界（闭区间）； high - 区间上界（开区间）

Mat_<int>randuM(3,3);
randu(randuM,Scalar(0),Scalar(255));
cout << "randuM = " << randuM << endl << endl;
//其实randu和rng.fill功能是类似的，只不过rng需要先定义rng

1.3 randn( )

作用：返回高斯分布的随机数，填入数组或矩阵

randn(dst, mean, stddev)

dst – 输出数组或矩阵； mean – 均值； stddev - 标准差

Mat_<int>randnM(3,3);
randn(randnM,0,1);
cout << "randnM = " << randnM << endl << endl;
//其实randu和rng.fill功能是类似的，只不过rng需要先定义rng

1.4 randShuffle( )

作用：将原数组（矩阵）打乱

randShuffle( InputOutputArray dst,     输入输出数组（一维）
                   double iterFactor=1. ,     决定交换数值的行列的位置的一个系数...
                   RNG* rng=0 )              （可选）随机数产生器，0表示使用默认的随机数产生器，即seed=-1。rng决定了打乱的方法

Mat randShufM =(Mat_<double>(2,3) << 1,2,3,4,5,6);
randShuffle(randShufM,7,0);
cout << "randShufM = " << endl<<randShufM<< endl << endl;

2. OpenCV中的C版本随机数

2.1 CvRNG

作用：产生64位随机整数，参见RNG。C++版本中的RNG已经代替了CvRNG

2.2 cvRandArr( )

作用：用CvRNG产生的随机数填充数组(矩阵)

void cvRandArr( CvRNG* rng,       被 cvRNG 初始化的 RNG 状态
                       CvArr* arr,              输出数组
                       int dist_type,           CV_RAND_UNI 或 CV_RAND_NORMAL
                  CvScalar param1,     如果是均匀分布它是随机数范围的闭下边界；如果是正态分布它是随机数的平均值

                  CvScalar param2)     如果是均匀分布它是随机数范围的开上边界；如果是正态分布它是随机数的标准差

CvMat* cvM = cvCreateMat(3,3,CV_16U);                                   //创建3×3的矩阵
cvRandArr(&cvRNG,cvM,CV_RAND_UNI,cvScalarAll(0),cvScalarAll(255));      //给cvM赋值，[0,255)
//cout << "cvM = " <<  cvM << endl << endl;                              //cvM是指针，这样输出的是地址
cout<<"cvM = ";
for(int i=0;i<3;i++)
{
for(int j= 0;j<3;j++)
{

cout<<(int)cvGetReal2D(cvM,i,j)<<"   ";    //如何更方便地输出？

}
cout<<endl;
}
cout<<endl;

2.3 cvRandInt( )

    unsigned int cvRandInt( CvRNG* rng)

    作用： cvRandInt 返回均匀分布的随机 32-bit 无符号整型值并更新 RNG 状态；它和 C 运行库里面的 rand() 函数十分相似，但是它产生的总是一个 32-bit 数，而 rand()返回一个 0 到 RAND_MAX（它是 2**16 或者 2**32, 依赖于操作平台）之间的数。

int cvInt = cvRandInt(&cvRNG);
cout << "cvInt = " << cvInt << endl << endl;

2.4 cvRandReal( )

    double cvRandReal( CvRNG* rng)

    作用： 返回均匀分布的随机浮点数，范围[0,1)

double cvDouble = cvRandReal(&cvRNG);
cout << "cvDouble = " << cvDouble << endl<< endl;

3. C语言随机数

    这里就介绍最基本的2个rand()和srand() 

int rand(void);                                   使用默认种子“1”，产生0到RAND_MAX之间的伪随机数。
                                                          RAND_MAX常量被定义在stdlib.h头文件中。

void srand (unsigned int seed);         使用种子seed产生0到RAND_MAX之间的伪随机数

 rang和srand的唯一区别是，是否设置seed。

//产生[0,10)随机整数
printf("\n rand1 =" );
for (int i=0; i<10; i++)
{
printf("%d ", rand()%10);
}
printf("\n srand1 =" );
srand(8);
for (int i=0; i<10; i++)
{
printf("%d ", rand()%10);
}
printf("\n srand2 =" );
//使用time()获取不重复的种子
srand((unsigned)time(NULL));
for (int i=0; i<10; i++)
{
printf("%d ", rand()%10);
}
printf("\n" );

     使用rand和srand产生随机数小结
1、随机数是由随机种子根据一定的计算方法计算出来的数值。所以，只要计算方法一定，随机种子一定，那么产生的随机数就不会变。
2、默认情况下随机种子来自系统时钟（即定时/计数器的值），想得到完全不重复的随机种子，可以用time()
3、要取[a,b)之间的随机整数使用：(rand() % (b - a)) + a

      要取[0,N)之间的随机浮点数使用： rand() /((double)(RAND_MAX)/N)
     要取[a,b)之间的随机浮点数使用： rand() /((double)(RAND_MAX)/(b-a))+(b-a)

4. 完整程序及结果

程序参照了http://blog.csdn.net/zyttae/article/details/41719349

对原文中不明确的地方进行了说明，并补充了一些新内容

#include <opencv2/highgui/highgui.hpp>
#include <opencv2/core/core.hpp>
#include <iostream>

#include <iostream>
#include "cv.h"
#include "highgui.h"

using namespace cv;
using namespace std;

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

/***********************************OpenCV中的C++版本随机数******************************************/

/*====================================产生一个随机数================================================
*RNG可以产生3种随机数
*RNG(int seed)     使用种子seed产生一个64位随机整数，默认-1
*RNG::uniform（）  产生一个均匀分布的随机数
*RNG::gaussian()   产生一个高斯分布的随机数
*关于种子seed：种子好比是生成随机数的产品证，想要生成不同的随机数，就要用不同种子。你运行此程序两次，
*              会发现两次产生的随机数都是一样的,因为使用了默认种子“-1”。产生不重复随机数的好办法是
*               用getTickCount()返回一个64位长整数的时间数据，绝对不重复。RNG(getTickCount())
===================================================================================================*/

//创建RNG对象，使用默认种子“-1”
RNG rng;

//产生64位整数
int N1 = rng;

/*-------------产生均匀分布的随机数uniform和高斯分布的随机数gaussian---------*/

//总是得到double类型数据0.000000，因为会调用uniform(int,int),只会取整数，所以只产生0
double N1a = rng.uniform(0,1);

//产生[0,1)范围内均匀分布的double类型数据
double N1b = rng.uniform((double)0,(double)1);

//产生[0,1)范围内均匀分布的float类型数据，注意被自动转换为double了。
double N1c = rng.uniform(0.f,1.f);

//产生[0,1)范围内均匀分布的double类型数据。
double N1d = rng.uniform(0.,1.);

//可能会因为重载导致编译不通过(确实没通过。。)
//double N1e = rng.uniform(0,0.999999);

//产生符合均值为0，标准差为2的高斯分布的随机数
double N1g = rng.gaussian(2);

cout << "N1 = " << N1 << endl;
cout << "N1a = " << N1a << endl;
cout << "N1b = " << N1b << endl;
cout << "N1c = " << N1c << endl;
cout << "N1d = " << N1d << endl;
//cout << "N1e = " << N1e << endl;
cout << "N1g = " << N1g << endl;

/*================================返回下一个随机数==============================================
*给定种子，rng就会按照某规律生产一系列随机数，只不过每次按顺序取出一个来。如果要得到另一个随机数，
*不必重新生成一个随机数，只需原随机数列里的下一个随机数即可
*RNG:: next         返回下一个64位随机整数
*RNG:: operator	    返回下一个指定类型的随机数
================================================================================================*/

//返回下一个64位随机数，即n1的下一个
int N2 = rng.next();   //即N1.next();

//返回下一个指定类型的随机数
int N2a = rng.operator uchar();
int N2b = rng.operator schar();
int N2c = rng.operator ushort();
int N2d = rng.operator short int();
int N2e = rng.operator int();
int N2f = rng.operator unsigned int();
int N2g = rng.operator float();
int N2h = rng.operator double();
int N2i = rng.operator ()();            //和rng.next( )等价
int N2j = rng.operator ()(100);         //返回[0,100)范围内的随机数

cout << "N2 = " << N2 << endl;
cout << "N2a = " << N2a << endl;
cout << "N2b = " << N2b << endl;
cout << "N2c = " << N2c << endl;
cout << "N2d = " << N2d << endl;
cout << "N2e = " << N2e << endl;
cout << "N2f = " << N2f << endl;
cout << "N2g = " << N2g << endl;
cout << "N2h = " << N2h << endl;
cout << "N2i = " << N2i << endl;
cout << "N2j = " << N2j << endl<< endl;

/*=======================================用随机数填充数组（矩阵）==========================================
*void RNG:: fill( InputOutputArray mat,       输出矩阵，最多支持4通道，超过4通道先用reshape()改变结构
int distType,               UNIFORM 或 NORMAL
InputArray a,               disType是UNIFORM,a表示为下界(闭区间)；disType是NORMAL,a均值
InputArray b,               disType是UNIFORM,b表示为上界(开区间)；disType是NORMAL,b标准差
bool saturateRange=false)   只针对均匀分布有效。当为真的时候，会先把产生随机数的范围变换到数据类型的范围，
再产生随机数；如果为假，会先产生随机数，再进行截断到数据类型的有效区间。
请看以下fillM1和fillM2的例子并观察结果
===========================================================================================================*/
//产生[1,1000)均匀分布的int随机数填充fillM
Mat_<int>fillM(3,3);
rng.fill(fillM,RNG::UNIFORM,1,1000);
cout << "filM = " << fillM << endl << endl;

Mat fillM1(3,3,CV_8U);
rng.fill(fillM1,RNG::UNIFORM,1,1000,TRUE);
cout << "filM1 = " << fillM1 << endl << endl;

Mat fillM2(3,3,CV_8U);
rng.fill(fillM2,RNG::UNIFORM,1,1000,FALSE);
cout << "filM2 = " << fillM2 << endl << endl;
//fillM1产生的数据都在[0,，255)内，且小于255；
//fillM2产生的数据虽然也在同样范围内，但是由于用了截断操作，所以很多数据都是255,
//因为CV_8U的有效范围就是0~255
//所以我认为最好的方式就是事先想好需要的数据类型和范围，再设置为FALSE(默认值)

//产生均值为1，标准差为3的随机double数填进fillN
Mat_<double>fillN(3,3);
rng.fill(fillN,RNG::NORMAL,1,3);
cout << "filN = " << fillN << endl << endl;

/*=====================================randu( )=====================================================
/*返回均匀分布的随机数，填入数组或矩阵
*   randu(dst, low, high)
*	dst – 输出数组或矩阵
*	low – 区间下界（闭区间）
*	high - 区间上界（开区间）
====================================================================================================*/
Mat_<int>randuM(3,3);
randu(randuM,Scalar(0),Scalar(255));
cout << "randuM = " << randuM << endl << endl;
//其实randu和rng.fill功能是类似的，只不过rng需要先定义rng

/*======================================randn( )======================================================
/*返回高斯分布的随机数，填入数组或矩阵
*   randn(dst, mean, stddev)
*	dst – 输出数组或矩阵
*	mean – 均值
*	stddev - 标准差
======================================================================================================*/
Mat_<int>randnM(3,3);
randn(randnM,0,1);
cout << "randnM = " << randnM << endl << endl;
//其实randu和rng.fill功能是类似的，只不过rng需要先定义rng

/*======================================randShuffle( )=================================================
/*产生随机打乱的数组，就是将原数组打乱
*	randShuffle( InputOutputArray dst,   输入输出数组（一维）
*               double iterFactor=1.,   决定交换数值的行列的位置的一个 系数...
*               RNG* rng=0 )            （可选）随机数产生器，0表示使用默认的随机数产生器，即seed=-1
*				                          rng决定了打乱的方法
=======================================================================================================*/
Mat randShufM =(Mat_<double>(2,3) << 1,2,3,4,5,6);
randShuffle(randShufM,7,0);
cout << "randShufM = " << endl<<randShufM<< endl << endl;

/******************************OpenCV中的C++版本随机数*************************************************/

/*===================================CvRNG============================================================
*产生64位随机整数，参见RNG。C++版本中的RNG已经代替了CvRNG
========================================================================================================*/
CvRNG cvRNG;

/*======================================cvRandArr========================================================
*用CvRNG产生的随机数填充数组(矩阵)
*void cvRandArr( CvRNG* rng,       被 cvRNG 初始化的 RNG 状态
*                 CvArr* arr,       输出数组
*                int dist_type,    CV_RAND_UNI 或 CV_RAND_NORMAL
*		 CvScalar param1,   如果是均匀分布它是随机数范围的闭下边界；如果是正态分布它是随机数的平均值
*		CvScalar param2)   如果是均匀分布它是随机数范围的开上边界；如果是正态分布它是随机数的标准差
========================================================================================================*/
CvMat* cvM = cvCreateMat(3,3,CV_16U);                                   //创建3×3的矩阵
cvRandArr(&cvRNG,cvM,CV_RAND_UNI,cvScalarAll(0),cvScalarAll(255));      //给cvM赋值，[0,255)
//cout << "cvM = " <<  cvM << endl << endl;                              //cvM是指针，这样输出的是地址
cout<<"cvM = ";
for(int i=0;i<3;i++)
{
for(int j= 0;j<3;j++)
{

cout<<(int)cvGetReal2D(cvM,i,j)<<"   ";    //如何更方便地输出？

}
cout<<endl;
}
cout<<endl;

/*=====================================cvRandInt======================================================
unsigned int cvRandInt( CvRNG* rng)
函数 cvRandInt 返回均匀分布的随机 32-bit 无符号整型值并更新 RNG 状态；
它和 C 运行库里面的 rand() 函数十分相似，但是它产生的总是一个 32-bit 数而 rand()
返回一个 0 到 RAND_MAX（它是 2**16 或者 2**32, 依赖于操作平台）之间的数
=====================================================================================================*/
int cvInt = cvRandInt(&cvRNG);
cout << "cvInt = " << cvInt << endl << endl;

/*====================================cvRandReal======================================================
double cvRandReal( CvRNG* rng)
返回均匀分布的随机浮点数，范围[0,1)
=====================================================================================================*/
double cvDouble = cvRandReal(&cvRNG);
cout << "cvDouble = " << cvDouble << endl<< endl;

/******************************纯正的C语言随机数****************************************************
*  OpenCV里的随机数都是基于RNG或CvRNG的，其实C语言里的随机数也能用
****************************************************************************************************/
/*=====================================rand和srand=================================================*
*   int rand(void);   使用默认种子“1”，产生0到RAND_MAX之间的伪随机数。RAND_MAX常量被定义在stdlib.h头文件中。
*   void srand (unsigned int seed);    使用种子seed产生0到RAND_MAX之间的伪随机数
*   rang和srand的唯一区别是，是否设置seed。
*==================================================================================================*/
//产生[0,10)随机整数
printf("\n rand1 =" );
for (int i=0; i<10; i++)
{
printf("%d ", rand()%10);
}
printf("\n srand1 =" );
srand(8);
for (int i=0; i<10; i++)
{
printf("%d ", rand()%10);
}
printf("\n srand2 =" );
//使用time()获取不重复的种子
srand((unsigned)time(NULL));
for (int i=0; i<10; i++)
{
printf("%d ", rand()%10);
}
printf("\n" );
/*=================使用rand和srand产生随机数小结=======================================
1、随机数是由随机种子根据一定的计算方法计算出来的数值。所以，只要计算方法一定，随机种子一定，那么产生的随机数就不会变。
2、默认情况下随机种子来自系统时钟（即定时/计数器的值），想得到完全不重复的随机种子，可以用time()
3、要取[a,b)之间的随机整数使用：(rand() % (b - a)) + a
要取[0,N)之间的随机浮点数使用： rand() /((double)(RAND_MAX)/N)
要取[a,b)之间的随机浮点数使用： rand() /((double)(RAND_MAX)/(b-a))+(b-a)
*============================================================================================================*/

system("pause");
return 0;

}

结果如下图所示





    设置不同的种子，会得到不同的结果，否则结果是不会变的。