opencvref_cv.cn.htm

opencv 中文文档 关于opencv 的所有函数

<pre>
void cvCornerMinEigenVal( const CvArr* image, CvArr* eigenval, int block_size, int aperture_size=3 );
</pre><p><dl>
<dt>image<dd>输入图像.
<dt>eigenval<dd>保存最小特征值的图像.                 
  与输入图像大小一致
<dt>block_size<dd>邻域大小 (见讨论 <a href="#decl_cvCornerEigenValsAndVecs">cvCornerEigenValsAndVecs</a>).                 
<dt>aperture_size<dd>Sobel 算子的核尺寸(见 <a href="#decl_cvSobel">cvSobel</a>).   
  当输入图像是浮点数格式时，该参数表示用来计算差分固定的浮点滤波器的个数.
</dl><p>
函数 <a href="#decl_cvCornerMinEigenVal">cvCornerMinEigenVal</a>                 
与 <a href="#decl_cvCornerEigenValsAndVecs">cvCornerEigenValsAndVecs</a>                 
类似，但是它仅仅计算和存储每个象素点差分相关矩阵的最小特征值，即前一个函数的                 
min(λ<sub>1</sub>, λ<sub>2</sub>)                   
</p>


<hr><h3><a name="decl_cvFindCornerSubPix">FindCornerSubPix</a></h3>
<p class="Blurb"><span style="FONT-FAMILY: 宋体; mso-ascii-font-family: Helvetica; mso-hansi-font-family: Helvetica">精确角点位置</span></p>
<pre>
void cvFindCornerSubPix( const CvArr* image, CvPoint2D32f* corners,
                         int count, CvSize win, CvSize zero_zone,
                         CvTermCriteria criteria );
</pre><p><dl>
<dt>image<dd>输入图像.
<dt>corners<dd>输入角点的初始坐标，也存储精确的输出坐标
<dt>count<dd>角点数目
<dt>win<dd>搜索窗口的一半尺寸。如果 <code>win</span></code>=(5,5)                 
  那么使用 5*2+1 × 5*2+1 = 11 × 11 大小的搜索窗口                   
<dt>zero_zone<dd>死区的一半尺寸，死区为不对搜索区的中央位置做求和运算的区域。它是用来避免自相关矩阵出现的某些可能的奇异性。当值为            
  (-1,-1) 表示没有死区。                
<dt>criteria<dd>求角点的迭代过程的终止条件。即角点位置的确定，要么迭代数大于某个设定值，或者是精确度达到某个设定值。                 
  <code>criteria</span></code> 
  可以是最大迭代数目，或者是设定的精确度，也可以是它们的组合。               
</dl><p>
函数 <a href="#decl_cvFindCornerSubPix">cvFindCornerSubPix</a>                 
通过迭代来发现具有子象素精度的角点位置，或如图所示的放射鞍点（radial                 
saddle points）。</p>                
<p>
<image align="center" src="pics/cornersubpix.png">
</p>
<p>
子象素级角点定位的实现是基于对向量正交性的观测而实现的，即从中央点<code>q</code>到其邻域点<code>p</code> 的向量
和<code>p</code>点处的图像梯度正交（服从图像和测量噪声）。考虑以下的表达式：
</p>
<pre>
ε<sub>i</sub>=DI<sub>p<sub>i</sub></sub><sup>T</sup>&#8226;(q-p<sub>i</sub>)
</pre>
其中，<code>DI<sub>p<sub>i</sub></sub></code>表示在<code>q</code>的一个邻域点<code>p<sub>i</sub></code>处的图像梯度，<code>q</code>的值通过最小化<code>&epsilon;<sub>i</sub></code>得到。通过将<code>&epsilon;<sub>i</sub></code>设为0，可以建立系统方程如下：
<pre>
sum<sub>i</sub>(DI<sub>p<sub>i</sub></sub>&#8226;DI<sub>p<sub>i</sub></sub><sup>T</sup>)&#8226;q - sum<sub>i</sub>(DI<sub>p<sub>i</sub></sub>&#8226;DI<sub>p<sub>i</sub></sub><sup>T</sup>&#8226;p<sub>i</sub>) = 0
</pre>
<p>
其中<code>q</code>的邻域（搜索窗）中的梯度被累加。调用第一个梯度参数<code>G</code>和第二个梯度参数<code>b</code>，得到：</p>
<pre>
q=G<sup>-1</sup>&#8226;b
</pre>
<p>
该算法将搜索窗的中心设为新的中心<code>q</code>，然后迭代，直到找到低于某个阈值点的中心位置。
</p>


<hr><h3><a name="decl_cvGoodFeaturesToTrack">GoodFeaturesToTrack</a></h3>
<p class="Blurb"><span style="FONT-FAMILY: 宋体; mso-ascii-font-family: Helvetica; mso-hansi-font-family: Helvetica">确定图像的强角点</span></p>
<pre>
void cvGoodFeaturesToTrack( const CvArr* image, CvArr* eig_image, CvArr* temp_image,
                            CvPoint2D32f* corners, int* corner_count,
                            double quality_level, double min_distance,
                            const CvArr* mask=NULL );
</pre><p><dl>
<dt>image<dd>输入图像，8-位或浮点32-比特，单通道
<dt>eig_image<dd>临时浮点32-位图像，尺寸与输入图像一致
<dt>temp_image<dd>另外一个临时图像，格式与尺寸与 <code>eig_image</span></code>                 
  一致                
<dt>corners<dd>输出参数，检测到的角点
<dt>corner_count<dd>输出参数，检测到的角点数目
<dt>quality_level<dd>最大最小特征值的乘法因子。定义可接受图像角点的最小质量因子。
<dt>min_distance<dd>限制因子。得到的角点的最小距离。使用            
  Euclidian 距离                
<dt>mask<dd>ROI:感兴趣区域。函数在ROI中计算角点，如果                 
  mask 为 NULL，则选择整个图像。                
</dl><p>
函数 <a href="#decl_cvGoodFeaturesToTrack">cvGoodFeaturesToTrack</a>                 
在图像中寻找具有大特征值的角点。该函数，首先用<a href="#decl_cvCornerMinEigenVal">cvCornerMinEigenVal</a>                 
计算输入图像的每一个象素点的最小特征值，并将结果存储到变量           
<code>eig_image 中。</code>然后进行非最大值抑制（仅保留3x3邻域中的局部最大值）。下一步将最小特征值小于           
<code>quality_level</span></code>&#8226;max(<code>eig_image</span></code>(x,y))                 
排除掉。最后，函数确保所有发现的角点之间具有足够的距离，（最强的角点第一个保留，然后检查新的角点与已有角点之间的距离大于           
<code>min_distance ）。</code></p>                


<hr><h2>采样、差值和几何变换</h2>

<hr><h3><a name="decl_cvInitLineIterator">InitLineIterator</a></h3>
<p class="Blurb"><span style="FONT-FAMILY: 宋体; mso-ascii-font-family: Helvetica; mso-hansi-font-family: Helvetica">初始化线段迭代器</span></p>
<pre>
int cvInitLineIterator( const CvArr* image, CvPoint pt1, CvPoint pt2,
                        CvLineIterator* line_iterator, int connectivity=8 );
</pre><p><dl>
<dt>image<dd>带采线段的输入图像.
<dt>pt1<dd>线段起始点
<dt>pt2<dd>线段结束点
<dt>line_iterator<dd>指向线段迭代器状态结构的指针
<dt>connectivity<dd>被扫描线段的连通数，4 或 8.                
</dl><p>
函数 <a href="#decl_cvInitLineIterator">cvInitLineIterator</a>                 
初始化线段迭代器，并返回两点之间的象素点数目。两个点必须在图像内。当迭代器初始化后，连接两点的光栅线上所有点，都可以连续通过调用           
<code>CV_NEXT_LINE_POINT</span></code> 
来得到。线段上的点是使用 4－连通或8－连通利用 Bresenham                 
算法逐点计算的。</p>
<h4><span style="FONT-FAMILY: 宋体; mso-ascii-font-family: Helvetica; mso-hansi-font-family: Helvetica">例子：使用线段迭代器计算彩色线上象素值的和</span></h4>
<pre>
    CvScalar sum_line_pixels( IplImage* image, CvPoint pt1, CvPoint pt2 )
    {
        CvLineIterator iterator;
        int blue_sum = 0, green_sum = 0, red_sum = 0;
        int count = cvInitLineIterator( image, pt1, pt2, &amp;iterator, 8 );

        for( int i = 0; i &lt; count; i++ ){
            blue_sum += iterator.ptr[0];
            green_sum += iterator.ptr[1];
            red_sum += iterator.ptr[2];
            CV_NEXT_LINE_POINT(iterator);

            /* print the pixel coordinates: demonstrates how to calculate the coordinates */
            {
            int offset, x, y;
            /* assume that ROI is not set, otherwise need to take it into account. */
            offset = iterator.ptr - (uchar*)(image-&gt;imageData);
            y = offset/image-&gt;widthStep;
            x = (offset - y*image-&gt;widthStep)/(3*sizeof(uchar) /* size of pixel */);
            printf(&quot;(%d,%d)\n&quot;, x, y );
            }
        }
        return cvScalar( blue_sum, green_sum, red_sum );
    }
</pre>


<hr><h3><a name="decl_cvSampleLine">SampleLine</a></h3>
<p class="Blurb"><span style="FONT-FAMILY: 宋体; mso-ascii-font-family: Helvetica; mso-hansi-font-family: Helvetica">将光栅线读入缓冲区</span></p>
<pre>
int cvSampleLine( const CvArr* image, CvPoint pt1, CvPoint pt2,
                  void* buffer, int connectivity=8 );
</pre><p><dl>
<dt>image<dd>带采线段的输入图像
<dt>pt1<dd>起点
<dt>pt2<dd>终点
<dt>buffer<dd>存储线段点的缓存区，必须有足够大小来存储点            
  max( |<code>pt2.x</span></code>-<code>pt1.x</span></code>|+1,                 
  |<code>pt2.y</span></code>-<code>pt1.y</span></code>|+1                 
  ) ：8－连通情况下，或者 |<code>pt2.x</span></code>-<code>pt1.x</span></code>|+|<code>pt2.y</span></code>-<code>pt1.y</span></code>|+1                 
  ： 4－连通情况下.                
<dt>connectivity<dd>线段的连通方式, 4 or 8.   
</dl><p>
函数 cvSampleLine 实现了线段迭代器的一个特殊应用。它读取由两点 pt1 和 pt2 确定的线段上的所有图像点，包括终点，并存储到缓存中。</p>                 


<hr><h3><a name="decl_cvGetRectSubPix">GetRectSubPix</a></h3>
<p class="Blurb"><span style="FONT-FAMILY: 宋体; mso-ascii-font-family: Helvetica; mso-hansi-font-family: Helvetica">从图像中提取象素矩形，使用子象素精度</span></p>
<pre>
void cvGetRectSubPix( const CvArr* src, CvArr* dst, CvPoint2D32f center );
</pre><p><dl>
<dt>src<dd>输入图像.
<dt>dst<dd>提取的矩形.
<dt>center<dd>提取的象素矩形的中心，浮点数坐标。中心必须位于图像内部.
</dl><p>
函数 <a href="#decl_cvGetRectSubPix">cvGetRectSubPix</a>                 
从图像 <code>src 中提取矩形</span></code>:</p>               
<pre>
dst(x, y) = src(x + center.x - (width(dst)-1)*0.5, y + center.y - (height(dst)-1)*0.5)
</pre>
<p>其中非整数象素点坐标采用双线性差值提取。对多通道图像，每个通道独立单独完成提取。尽管函数要求矩形的中心一定要在输入图像之中，但是有可能出现矩形的一部分超出图像边界的情况，这时，该函数复制边界的模识（<a href="http://www.assuredigit.com">hunnish</a>:即用于矩形相交的图像边界线段的象素来代替矩形超越部分的象素）。
</p>


<hr><h3><a name="decl_cvGetQuadrangleSubPix">GetQuadrangleSubPix</a></h3>
<p class="Blurb"><span style="FONT-FAMILY: 宋体; mso-ascii-font-family: Helvetica; mso-hansi-font-family: Helvetica">提取象素四边形，使用子象素精度</span></p>
<pre>
void cvGetQuadrangleSubPix( const CvArr* src, CvArr* dst, const CvMat* map_matrix,
                            int fill_outliers=0, CvScalar fill_value=cvScalarAll(0) );
</pre><p><dl>
<dt>src<dd>输入图像.
<dt>dst<dd>提取的四边形.
<dt>map_matrix<dd>3 × 2 变换矩阵 [<code>A</span></code>|<code>b</span></code>]                 
  （见讨论）.   
<dt>fill_outliers<dd>该标志位指定是否对原始图像边界外面的象素点使用复制模式(<code>fill_outliers</code>=0)进行差值或者将其设置为指定值(<code>fill_outliers</code>=1)。
<dt>fill_value<dd>对超出图像边界的矩形象素设定的值(当 <code>fill_outliers</code>=1时的情况).               
</dl><p>
函数 <a href="#decl_cvGetQuadrangleSubPix">cvGetQuadrangleSubPix</a>                 
 以子象素精度从图像 <code>src</code>                
中提取四边形，使用子象素精度，并且将结果存储于 <code>dst</span></code>                
,计算公式是：</p>                
<pre>
dst(x+width(dst)/2, y+height(dst)/2)= src( A<sub>11</sub>x+A<sub>12</sub>y+b<sub>1</sub>, A<sub>21</sub>x+A<sub>22</sub>y+b<sub>2</sub>),

w其中 <code>A</code>和 <code>b</code> 均来自映射矩阵(译者注：A, b为几何形变参数) <code>map_matrix</code>
             | A<sub>11</sub> A<sub>12</sub>  b<sub>1</sub> |
map_matrix = |            |
             | A<sub>21</sub> A<sub>22</sub>  b<sub>2</sub> |
</pre>
<p>其中在非整数坐标 A&#8226;(x,y)<sup>T</sup>+b                 
的象素点值通过双线性变换得到。多通道图像的每一个通道都单独计算.</p>
<h4><span style="FONT-FAMILY: 宋体; mso-ascii-font-family: Helvetica; mso-hansi-font-family: Helvetica">例子：使用</span> 
cvGetQuadrangleSubPix <span style="FONT-FAMILY: 宋体; mso-ascii-font-family: Helvetica; mso-hansi-font-family: Helvetica">进行图像旋转</span></h4>               
<pre>
#include &quot;cv.h&quot;
#include &quot;highgui.h&quot;
#include &quot;math.h&quot;

int main( int argc, char** argv )
{
    IplImage* src;
    /* the first command line parameter must be image file name */
    if( argc==2 &amp;&amp; (src = cvLoadImage(argv[1], -1))!=0)
    {
        IplImage* dst = cvCloneImage( src );
        int delta = 1;
        int angle = 0;

        cvNamedWindow( &quot;src&quot;, 1 );
        cvShowImage( &quot;src&quot;, src );

        for(;;)
        {
            float m[6];
            double factor = (cos(angle*CV_PI/180.) + 1.1)*3;
            CvMat M = cvMat( 2, 3, CV_32F, m );
            int w = src-&gt;width;
            int h = src-&gt;height;

            m[0] = (float)(factor*cos(-angle*2*CV_PI/180.));
            m[1] = (float)(factor*sin(-angle*2*CV_PI/180.));
            m[2] = w*0.5f;
            m[3] = -m[1];
            m[4] = m[0];
            m[5] = h*0.5f;

            cvGetQuadrangleSubPix( src, dst, &amp;M, 1, cvScalarAll(0));

            cvNamedWindow( &quot;dst&quot;, 1 );