<学习opencv>opencv函数

/*=========================================================================*/
//                              openCV中的函数
/*=========================================================================*/

"做东西"的对象
因此，新功能通常由关联的新对象类型表示，可以将其视为执行此功能的“机器”。
大多数 这些机器有重载operator()，其中正式使它们成为函数对象或函子。
如果您不熟悉这种编程习惯，那么重要的想法是，
与“普通”函数不同，函数对象被创建并且可以在其中维护状态信息。
因此，可以使用他们需要的任何数据或配置来设置它们，并且它们被“要求”通过公共成员函数执行服务，
或者通过被称为函数本身（通常通过重载2 ）来执行服务。

主成分分析(cv::PCA)
主成分分析，是分析多维度分布并从该分布中提取携带最多信息的特定维度子集的过程。
由PCA计算的尺寸不一定是最初指定分布的基础尺寸。实际上，PCA最重要的一个方面是能够生成一个新的基础，
其轴可以按其重要性排序。这些基矢量将作为整体分布的协方差矩阵的特征向量，
相应的特征值将告诉我们该维度中分布的程度。

给定一次分布，PCA对象可以计算并保留这个新的基础。
新基础的最大优点是对应于大特征值的基矢量承载了关于分布中的对象的大部分信息。
因此，在不失去太多准确性的情况下，我们可以丢弃信息量较少的维度。
这种降维称为KLT变换 。加载样本分布并计算主成分后，您可能希望使用该信息执行各种操作，例如将KLT变换应用于新向量。当您将PCA功能作为功能对象时，它可以“记住”您需要了解的内容，然后使用该信息提供按需转换新向量的“服务”。

CV::PCA::PCA())

    PCA::PCA();
    PCA :: PCA（
        cv :: InputArray data，     // Data，作为2d数组中的行或列
        cv :: InputArray mean，     // average（如果已知），1-by-n或n-by-1
        int flags，                 //是'data'的向量行或列
        int maxComponents = 0       //要保留的最大尺寸
    ）;
    PCA对象有一个默认的构造函数，cv::PCA() 简单地说 构建PCA对象并初始化空结构。第二种形式执行默认构造，然后立即继续 将其论点传递给PCA::operator()() （下面讨论）。 

    CV::PCA ::operator()()
    PCA ::operator()(
        cv :: InputArray data，     // Data，作为2d数组中的行或列
        cv :: InputArray mean，     // average（如果已知），1-by-n或n-by-1
        int flags，                 //是'data'的向量行或列
        int maxComponents = 0       //要保留的最大尺寸
    );

重载operator()() 用于PCA 构建PCA对象内部的分布模型。
所述data 参数是一个包含所有构成该分布的样品的阵列。
可选地，mean 可以提供包含每个维度中的平均值的第二阵列（mean 可以是n ×1或1× n ）。
数据可以排列为n × D （n 行样本，每个D 维）或D × n 阵列（n 列样本，每个D 维）。
该flags 参数目前仅用于指定数据的在该装置data 和mean。
特别地，flags可以设置为cv::PCA_DATA_AS_ROW 或cv::PCA_DATA_AS_COL
以指示任一data 是Ñ × d 和mean 是Ñ × 1 或data 为d × Ñ 和mean 是1 × Ñ，分别。
最后一个参数maxComponents 指定了PCA应保留的最大组件数（维度）。默认情况下，保留所有组件。

【注意】
任何后续调用都cv::PCA::operator()()将覆盖特征向量和特征值的内部表示，
因此您可以在需要时回收PCA对象（即，如果不是，则不必为每个要处理的新分布重新分配新的对象更长时间需要有关的信息）。

cv::PCA::project()
    cv::Mat PCA::project(       //返回结果，作为2d矩阵
        cv::InputArray vec  ,   //指向项目,行或列
    )const ;

    void PCA::project(
        cv::InputArray vec      //指向项目
        cv::OutputArray result  //投影结果，减少空间
    )const ;

    一旦加载了参考分布cv::PCA::operator()()，就可以开始要求PCA对象为你做有用的事情，
    比如计算一组矢量的KLT投影到主成分分析计算出的基矢量上。
    该cv::PCA::project() 功能有两种形式; 第一个返回包含投影结果的矩阵，
    而第二个将结果写入您提供的矩阵。第一种形式的优点是您可以在矩阵表达式中使用它。

    所述vec 参数包含输入向量。当首次分析分布时，vec 要求具有与data传递给PCA的数组相同的维数和“方向”
    （即，如果您的数据在调用时是列cv::PCA::operator()() ，vec 也应将数据排列成列） 。

cv::PCA::backProject()

    cv::Mat PCA::backProject(       //返回结果，作为2d矩阵
        cv::InputArray vec ,        //投影结果，减少空间
    ) const ;

    void PCA::backProject(
        cv::InputArray vec ,        //投影结果，减少空间
        reduced space               //"重建"矢量，全尺寸
        cv::OutputArray result
    )const ;
    该cv::PCA::backProject() 功能 执行cv::PCA::project()与输入和输出数组类似限制的反向操作。
    该vec 参数包含的输入矢量，其中该时间是从投影空间。
    它们将具有与maxComponents，您在配置PCA对象时指定的维度相同的维度，
    以及与data 首次分析分布时传递给PCA 的阵列相同的“方向”
    （即，如果您的数据在调用时是列cv::PCA::operator()，则vec 也应该将数据排列成列）。

    返回的数组将具有vec 与具有相同方向相同数量的对象，
    但每个对象的维度将是您在首次配置PCA对象时为PCA对象提供的原始数据的维度cv::PCA::operator()() 。

【注意】
如果在开始时配置PCA对象时没有保留所有维度，则反投影向量的结果
-它们本身是原始数据空间中某些向量的投影-将不等于 。
当然，差异应该很小，即使保留的组件数量远小于原始尺寸，因为这是首先使用PCA的重点。

奇异值分解(cv::SVD)
该cv::SVD class 是类似于cv::PCA 在 这是相同的一种功能对象。
然而，它的目的却截然不同。奇异值分解本质上是一种工具，用于处理非方形，
病态或其他表现不佳的矩阵，例如在求解欠定线性系统时遇到的矩阵。

cv::SVD() ;
    SVD::SVD(
        cv::InputArray A ,      //线性系统，阵列
        int flags = 0           //构造什么，以及A是否可以分解
    )；

    运算符cv:：svd:：operator()()将要分解的矩阵传递给cv:：svd对象。
    如前所述，矩阵A分解为矩阵U，A矩阵v
    （实际上是v的转置，我们称之为vt）和一组奇异值（矩阵w的对角元素）。

    标志可以是cv:：svd:：modify_a、cv:：svd:：no_uv或cv:：svd:：full_uv中的任意一个。
    后两个是互斥的，但可以与第一个结合在一起。cv:：svd:：modify_a标志表示计算时可以修改矩阵a。
    这会加快计算速度并节省一些内存。当输入矩阵已经很大时，这一点更为重要。
    标志cv:：svd:：no_uv告诉cv:：svd不要显式计算矩阵u和vt，而标志cv:：svd:：full_uv则表明，
    您不仅希望计算u和vt，而且希望将它们表示为全尺寸的方形正交矩阵。

cv::SVD::compute()
    void SVD::compute(
        cv::InputArray A ,      //线性系统，要分解的数组
        cv::OutputArray W ,     //输出数组'W'，奇异值
        cv::OutputArray U ,     //输出数组'U'，左奇异向量
        cv::OutputArray Vt ,    //输出数组'Vt'，右奇异向量
        int flags = 0           //构造什么，以及A是否可以分解
    )
    该函数是cv::SVD::operator()() 用于分解矩阵A的替代方法 。
    主要区别在于矩阵W ，U 和Vt 存储在用户提供的数组中，而不是保存在内部。
    支持的标志正是支持的标志cv::SVD::operator()() 。

cv::SVD::solveZ()
    void SVD::solveZ(
        cv::InputArray A  ,  //线性系统，要分解的数组
        cv::OutputArray z ,  //一种可能的解决方案(单位长度)
    );
    鉴于 欠定（单数）线性系统，cv::SVD::solveZ() 将（尝试）找到单位长度解，
    并将解决方案放入阵列中z 。然而，由于线性系统是单一的，它可能没有解决方案，
    或者它可能具有无限的解决方案系列。cv::SVD::solveZ() 会找到一个解决方案，如果存在的话。
    如果不存在解，那么返回值 将是最小化的向量 ，即使实际上不是，也是零。

cv::SVD::backSubst()
    void SVD::backSubst(
        void::InputArray b ,
        cv::OutputArray x
    ) ;

    void SVD::backSubst(
        cv::InputArray W  ,    //输出数组'W'，奇异值
        cv::InputArray U  ,    //输出数组'U',左奇异向量
        cv::InputArray Vt ,    //输出数组'Vt',右奇异向量
        cv::InputArray b ,     //线性系统的右侧
        cv::OutputArray x      //找到线性系统的解决方案
    ) ;

 随机数发生器(cv::RNG())

    随机数Tor（rng）对象持有生成随机数的伪随机序列的状态。
    使用它的好处是您可以方便地维护多个伪随机数流。
    【注意】在编写大型系统时，最好在代码的不同模块中使用单独的随机数流。
    这样，删除一个模块不会改变其他模块中的流的行为。

    一旦创建，随机数发生器提供按需生成随机数的“服务”，从统一或高斯分布中提取。
    发电机 使用Multiply with Carry （MWC）算法[Goresky03]进行均匀分布和Ziggurat算法
    [ Marsaglia00]用于从高斯分布生成数字。

cv::theRNG()
    cv::RNG& theRNG(void) ; //返回一个随机数生成器
    该cv::theRNG() 功能 返回调用它的线程的默认随机数生成器。
    OpenCV会自动cv::RNG 为执行中的每个线程创建一个实例。
    这是由cv::randu() 或等函数隐式访问的随机数生成器cv::randn()。
    如果您想要单个数字或初始化单个数组，这些功能很方便。
    但是，如果你有一个你自己的循环需要生成大量的随机数，
    你最好抓住一个随机数生成器的引用-在这种情况下，默认生成器，
    但你可以使用自己的 - 而且使用RNG::operator T() 让您的随机数

cv::RNG()
    cv::RNG::RNG(无效) ;
    cv::RNG::RNG(unit64 state) ;    //使用种子‘state’创建
    你可以使用默认构造函数创建RNG(),也可以通过传递64位无符号整数来将其用作随机数序列的种子。
    如果调用默认构造函数(或传递0给第二个变体)，生成器将使用标准化值来进行初始化。

cv::RNG::operator T(),其中T是你最喜欢的类型
cv::RNG::operator uchar() ;
cv::RNG::operator schar() ;
cv::RNG::operator ushort() ;
cv::RNG::operator short int() ;
cv::RNG::operator int() ;
cv::RNG::operator unsigned() ;
cv::RNG::operator float() ;
cv::RNG::operator double() ;
cv::RNG::operator T()实际上是一套不同的方法返回cv::RNG 某个特定类型的新随机数。
其中每个都是一个重载的强制转换操作符，因此实际上您将RNG对象转换为您想要的任何类型.

[例]使用默认随机数生成器生成一对整数和一对浮点数
——————————————————————————————————————————————————————————————————————
cv::RNG rng = cv::theRNG() ;
cout << "一个整数：" << (int)rng << endl ;
cout << "另一个整数:" << int(rng) << endl ;
cout << "浮点数："  << (float)rng << endl ;
cout << "另一个浮点数：" << float(rng) << endl ;
生成整数类型时,它们将在整个可用值范围内生成（使用前面描述的MWC算法，因此统一）。
生成浮点类型时，它们将始终位于间隔范围内[0.0, 1.0) 。

cv::RNG::operator()
    unsigned int cv::RNG::operator()() ;               //从0-UINT_MAX返回随机值
    unsigned int cv::RNG::operator()(unsigned int N) ; //从0-（N-1）返回值

当你在生成 整数随机数，重载operator()() 允许一个方便的方法来抓住另一个。
实质上，呼叫my_rng() 等同于呼叫(unsigned int)my_rng。
更有趣的形式cv::RNG::operator()() 采用整数参数N。
该形式返回（使用前面描述的MWC算法，因此统一）随机无符号整数模N。
因此，通过返回整数的范围my_rng( N ) 是整数然后从范围0到N-1 。

cv::RNG::uniform()
    int cv::RNG::uniform(int a, int b) ;            //从a-（b-1）返回值
    float cv::RNG::uniform(float a, float b) ;      //范围[a，b）的返回值
    double cv::RNG::uniform(double a, double b) ;   //范围[a，b）的返回值

 此功能允许您生成随机数 在区间内统一（使用MWC算法）[a, b) 。

cv::RNG::gaussian(double sigma) ;   //高斯数，零均值
这个功能允许您从具有标准偏差的零均值高斯分布使用Ziggurat算法）生成随机数sigma 。  

cv::RNG::fill()
    void cv::RNG::fill(
        InputArray mat,        //输入数组，值将被覆盖
        int distType ,         //分布类型（高斯或均匀）
        InputArray a ,         // min（uniform）或mean（Gaussian）
        InputArray b           // max（统一）或std-deviation（高斯）
    )

该cv::RNG::fill() 算法填充矩阵mat 的最多四个通道，从特定分布中抽取随机数。
该分布由distType 参数选择，可以是cv::RNG::UNIFORM或cv::RNG::NORMAL。
在均匀分布的情况下，每个元素mat 将填充从该区间生成的随机值 。
在高斯（cv::RNG::NORMAL ）分布的情况下，每个元素都是从一个分布中生成的，其平均值取自 ：和 。a 标准差取自b： 。重要的是要注意阵列a 并且b 不是维度mat ; 相反，它们是n c ×1或1× n c ，其中n c 是通道的数量mat
（即，每个元素没有单独的分布mat ; a 并b 指定一个分布，而不是每个元素的一个分布mat 。）