opencvref_cxcore.cn.htm

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

<p>输入的数组必须有已分配好的底层数据或附加的数据，否则该函数将调用失败 </p>如果输入的数组是<code>IplImage</code> 
格式，使用平面式数据编排并设置了COI，函数返回的指针指向被选定的平面并设置COI=0.利用OPENCV函数对于多通道平面编排图像可以处理每个平面。     
<hr>

<h3><a name="decl_cvGetImage">GetImage</a></h3>
<p class="Blurb">从不确定数组返回图像头</p><pre>IplImage* cvGetImage( const CvArr* arr, IplImage* image_header );
</pre>
<p>
</p><dl>
  <dt>arr 
  </dt><dd>输入数组. 
  </dd><dt>image_header 
  </dt><dd>指向<code>IplImage结构的指针，该结构存贮在一个临时缓存</code> . </dd></dl>    
<p>函数 <a href="#decl_cvGetImage">cvGetImage</a> 从输出数组获得图头，该数组可是以矩阵- <a href="#decl_CvMat*">CvMat*</a>, 或图像 - <code>IplImage*</code>.     
如果是图像函数只是返回输入参数的指针，如是查 <a href="#decl_CvMat*">CvMat*</a>     
函数用输入参数矩阵初始化图像头。因此如果我们把&nbsp; <code>IplImage</code> 转换成 <a href="#decl_CvMat">CvMat</a> 然后再转换 CvMat 回     
IplImage,如果ROI被设置过了我们可能会获得不同的头，这样一些计算图像跨度的IPL函数就会失败。</p>
<hr>

<h3><a name="decl_cvCreateSparseMat">CreateSparseMat</a></h3>
<p class="Blurb">创建稀疏数组</p><pre>CvSparseMat* cvCreateSparseMat( int dims, const int* sizes, int type );
</pre>
<p>
</p><dl>
  <dt>dims 
  </dt><dd>数组维数。相对于密集型矩阵，稀疏数组的维数是不受限制的（最多可达 2<sup>16</sup>).     
  </dd><dt>sizes 
  </dt><dd>数组的维大小. 
  </dd><dt>type 
  </dt><dd>数组元素类型，见 CvMat </dd></dl>    
<p>函数 <a href="#decl_cvCreateSparseMat">cvCreateSparseMat</a> 分配多维稀疏数组.     
Initially the array contain no elements, that is <a href="#decl_cvGet*D">cvGet*D</a> or <a href="#decl_cvGetReal*D">cvGetReal*D</a>     
return zero for every index</p>    
<hr>

<h3><a name="decl_cvReleaseSparseMat">ReleaseSparseMat</a></h3>
<p class="Blurb">删除稀疏数组</p>
<p class="Blurb"><br>void cvReleaseSparseMat( CvSparseMat** mat );<br></p>    
<dl>
  <dt>mat 
  </dt><dd>双指针指向数组。 </dd></dl>
<p>函数 <a href="#decl_cvReleaseSparseMat">cvReleaseSparseMat</a>释放稀疏数组并清空数组指针</p>    
<hr>

<h3><a name="decl_cvCloneSparseMat">CloneSparseMat</a></h3>
<p class="Blurb">创建稀疏数组的拷贝</p><pre>CvSparseMat* cvCloneSparseMat( const CvSparseMat* mat );
</pre>
<p>
</p><dl>
  <dt>mat 
  </dt><dd>输放的数组。 </dd></dl>
<p>函数 <a href="#decl_cvCloneSparseMat">cvCloneSparseMat</a>     
创建输入数组的拷贝并返回指向这个拷贝的指针.</p>    
<hr>

<h2><a name="cxcore_arrays_get_set">获取元素和数组子集</a></h2>
<hr>

<h3><a name="decl_cvGetSubRect">GetSubRect</a></h3>
<p class="Blurb">根据输入的图像或矩阵的矩形数组子集返回矩阵头</p><pre>CvMat* cvGetSubRect( const CvArr* arr, CvMat* submat, CvRect rect );
</pre>
<p>
</p><dl>
  <dt>arr 
  </dt><dd>输入数组 
  </dd><dt>submat 
  </dt><dd>指针指向结果数组头Pointer to the resultant sub-array header.     
  </dd><dt>rect 
  </dt><dd>以0坐标为基准的ROI. </dd></dl>
<p>函数 <a href="#decl_cvGetSubRect">cvGetSubRect</a>     
根据指定的数组矩形返回矩阵头，换句话说，函数允许处理输入数组的指定的一个子矩形，就像一个独立的数组一样进行处理。函数在处理时要考虑进输入数组的ROI，因此数组的ROI是实际上被提取的。</p>    
<hr>

<h3><a name="decl_cvGetRow">GetRow, GetRows</a></h3>    
<p class="Blurb">返回数组的行或在一定跨度内的行</p><pre>CvMat* cvGetRow( const CvArr* arr, CvMat* submat, int row );
CvMat* cvGetRows( const CvArr* arr, CvMat* submat, int start_row, int end_row, int delta_row=1 );
</pre>
<dl>
  <dt>arr 
  </dt><dd>输入数组. 
  </dd><dt>submat 
  </dt><dd>指向返回的子数组头的指针. 
  </dd><dt>row 
  </dt><dd>被选定的行号下标，以0为基准. 
  </dd><dt>start_row 
  </dt><dd>跨度的开始行（包括此行）索引下标，以0为下标基准 
  </dd><dt>end_row 
  </dt><dd>跨度的结束行（不包括此行）索引下标，以0为下标基准. 
  </dd><dt>delta_row 
  </dt><dd>在跨度内的索引下标跨步，从开始行到结束行每隔<code>delta_row行提取一行。</code> </dd></dl>
<p>函数<code>GetRow</code> 和 <code>GetRows</code> 根据指定的行或跨度从输入数组中返回对应的头。     
<code>GetRow</code> 是 <a href="#decl_cvGetRows">cvGetRows</a>的缩写: </p><pre>cvGetRow( arr, submat, row ) ~ cvGetRows( arr, submat, row, row + 1, 1 );
</pre>    
<hr>

<h3><a name="decl_cvGetCol">GetCol, GetCols</a></h3>
<p class="Blurb">返回数组的列或一定跨度内的列</p><pre>CvMat* cvGetCol( const CvArr* arr, CvMat* submat, int col );
CvMat* cvGetCols( const CvArr* arr, CvMat* submat, int start_col, int end_col );
</pre>
<p>
</p><dl>
  <dt>arr 
  </dt><dd>输入数组 
  </dd><dt>submat 
  </dt><dd>指向结果子数组头指针. 
  </dd><dt>col 
  </dt><dd>选定的列索引下标，该下标以0为基准。 
  </dd><dt>start_col 
  </dt><dd>跨度的开始列（包括该列）索引下标，该下标以0为基准。 
  </dd><dt>end_col 
  </dt><dd>跨度的结束列（不包括该列）索引下标，该下标以0为基准。 </dd></dl>
<p>函数 <code>GetCol</code> 和 <code>GetCols</code>     
根据指定的列/列跨度返回头。<code>GetCol</code> 是&nbsp; <a href="#decl_cvGetCols">cvGetCols</a>的缩写形式:</p><pre>cvGetCol( arr, submat, col ); // ~ cvGetCols( arr, submat, col, col + 1 );
</pre>
<hr>

<h3><a name="decl_cvGetDiag">GetDiag</a></h3>
<p class="Blurb">返回一个数组对角线</p><pre>CvMat* cvGetDiag( const CvArr* arr, CvMat* submat, int diag=0 );
</pre>
<p>
</p><dl>
  <dt>arr 
  </dt><dd>输入数组. 
  </dd><dt>submat 
  </dt><dd>指向结果子集的头指针. 
  </dd><dt>diag 
  </dt><dd>数组对角线。0是主对角线，-1是主对角线上面对角线，1是主对角线下对角线，以此类推。 </dd></dl>
<p>函数 <a href="#decl_cvGetDiag">cvGetDiag</a> 根据指定的diag参数返回数组的对角线头。</p>    
<hr>

<h3><a name="decl_cvGetSize">GetSize</a></h3>
<p class="Blurb">返回图像或矩阵ROI大小</p><pre>CvSize cvGetSize( const CvArr* arr );
</pre>
<p>
</p><dl>
  <dt>arr 
  </dt><dd>数组头. </dd></dl>
<p>函数 <a href="#decl_cvGetSize">cvGetSize</a> 返回矩阵或图像的行数和列数，如果是图像就返回ROI的大小</p>    
<hr>

<h3><a name="decl_cvInitSparseMatIterator">InitSparseMatIterator</a></h3>
<p class="Blurb">初始化稀疏数线元素迭代器</p><pre>CvSparseNode* cvInitSparseMatIterator( const CvSparseMat* mat,
                                       CvSparseMatIterator* mat_iterator );
</pre>
<p>
</p><dl>
  <dt>mat 
  </dt><dd>输入的数组. 
  </dd><dt>mat_iterator 
  </dt><dd>被初始化迭代器. </dd></dl>
<p>函数 <a href="#decl_cvInitSparseMatIterator">cvInitSparseMatIterator</a>     
初始化稀疏数组元素的迭代器并且返回指向第一个元素的指针，如果数组为空则返回NULL。</p>    
<hr>

<h3><a name="decl_cvGetNextSparseNode">GetNextSparseNode</a></h3>
<p class="Blurb">初始化稀疏数线元素迭代器</p><pre>CvSparseNode* cvGetNextSparseNode( CvSparseMatIterator* mat_iterator );
</pre>
<p>
</p><dl>
  <dt>mat_iterator 
  </dt><dd>稀疏数组的迭代器 </dd></dl>
<p>函数<a href="#decl_cvGetNextSparseNode">cvGetNextSparseNode</a> 
移动迭代器到下一个稀疏矩阵元素并返回指向他的指针。在当前的版本不存在任何元素的特殊顺序，因为元素是按HASH表存贮的下面的列子描述怎样在稀疏矩阵上迭代     
:</p>
<p><font color="blue" size="4">利</font><font color="blue" size="4">用<a href="#decl_cvInitSparseMatIterator">cvInitSparseMatIterator</a> 和<a href="#decl_cvGetNextSparseNode">cvGetNextSparseNode</a> 计算浮点稀疏数组的和。</font> </p><pre>    double sum;
    int i, dims = cvGetDims( array );
    CvSparseMatIterator mat_iterator;
    CvSparseNode* node = cvInitSparseMatIterator( array, &amp;mat_iterator );

    for( ; node != 0; node = cvGetNextSparseNode( &amp;mat_iterator ))
    {
        int* idx = CV_NODE_IDX( array, node ); /* get pointer to the element indices */
        float val = *(float*)CV_NODE_VAL( array, node ); /* get value of the element
                                                          (assume that the type is CV_32FC1) */
        printf( "(" );
        for( i = 0; i &lt; dims; i++ )
            printf( "%4d%s", idx[i], i &lt; dims - 1 "," : "): " );
        printf( "%g\n", val );

        sum += val;
    }

    printf( "\nTotal sum = %g\n", sum );
</pre>    
<hr>

<h3><a name="decl_cvGetElemType">GetElemType</a></h3>
<p class="Blurb">返回数组元素类型</p><pre>int cvGetElemType( const CvArr* arr );
</pre>
<p>
</p><dl>
  <dt>arr 
  </dt><dd>输入数组. </dd></dl>
<p>函数 <code>GetElemType</code> 返回数组元素类型就像在cvCreateMat 中讨论的一样: </p><pre>CV_8UC1 ... CV_64FC4</pre>    
<hr>

<h3><a name="decl_cvGetDims">GetDims, GetDimSize</a></h3>
<p class="Blurb">返回数组维数和他们的大小或者殊维的大小</p><pre>int cvGetDims( const CvArr* arr, int* sizes=NULL );
int cvGetDimSize( const CvArr* arr, int index );
</pre>
<p>
</p><dl>
  <dt>arr 
  </dt><dd>输入数组. 
  </dd><dt>sizes 
  </dt><dd>可选的输出数组维尺寸向量，对于2D数组第一位是数组行数（高），第二位是数组列数（宽） 
  </dd><dt>index 
  </dt><dd>以0为基准的维索引下标（对于矩阵0意味着行数，1意味着列数，对于图象0意味着高，1意味着宽。 </dd></dl>
<p>函数 <a href="#decl_cvGetDims">cvGetDims</a> 返回维数和他们的大小。如果是     
<code>IplImage</code> 或 <a href="#decl_CvMat">CvMat</a> 总是返回2，不管图像/矩阵行数。函数 <a href="#decl_cvGetDimSize">cvGetDimSize</a> 
返回特定的维大小（每维的元素数）。例如，接下来的代码使用二种方法计算数组元素总数。</p><pre>// via cvGetDims()
int sizes[CV_MAX_DIM];
int i, total = 1;
int dims = cvGetDims( arr, size );
for( i = 0; i &lt; dims; i++ )
    total *= sizes[i];

// via cvGetDims() and cvGetDimSize()
int i, total = 1;
int dims = cvGetDims( arr );
for( i = 0; i &lt; dims; i++ )
    total *= cvGetDimsSize( arr, i );
</pre>    
<hr>

<h3><a name="decl_cvPtr*D">Ptr*D</a></h3>
<p class="Blurb">返回指向特殊数组元素的指针</p><pre>uchar* cvPtr1D( const CvArr* arr, int idx0, int* type=NULL );
uchar* cvPtr2D( const CvArr* arr, int idx0, int idx1, int* type=NULL );
uchar* cvPtr3D( const CvArr* arr, int idx0, int idx1, int idx2, int* type=NULL );
uchar* cvPtrND( const CvArr* arr, int* idx, int* type=NULL, int create_node=1, unsigned* precalc_hashval=NULL );
</pre>
<p>
</p><dl>
  <dt>arr 
  </dt><dd>输入数组. 
  </dd><dt>idx0 
  </dt><dd>元素下标的第一个以0为基准的成员 
  </dd><dt>idx1 
  </dt><dd>元素下标的第二个以0为基准的成员 
  </dd><dt>idx2 
  </dt><dd>元素下标的第三个以0为基准的成员 
  </dd><dt>idx 
  </dt><dd>数组元素下标 
  </dd><dt>type 
  </dt><dd>可选的，矩阵元素类型输出参数 
  </dd><dt>create_node 
  </dt><dd>可选的，为稀疏矩阵输入的参数。如果这个参数非零就意味着被需要的元素如果不存在就会被创建。 
  </dd><dt>precalc_hashval 
  </dt><dd>可选的，为稀疏矩阵设置的输入参数。如果这个指针非NULL，函数不会重新计算节点的HASH值，而是从指定位置获取。这种方法有利于提高智能组合数据的操作（TODO:     
  提供了一个例子) </dd></dl>
<p>函数<a href="#decl_cvPtr*D">cvPtr*D</a> 返回指向特殊数组元素的指针。数组维数应该与转递给函数物下标数相匹配，除了 <a href="#decl_cvPtr1D">cvPtr1D</a> 函数，它可以被用于顺序存取的1D，2D或nD密集数组 </p>    
<p>函数也可以用于稀疏数组，并且如果被需要的节点不存在函数可以创建这个节点并设置为0</p>
<p>就像其它获取数组元素的函数 (<a href="#decl_cvGet%5BReal%5D*D">cvGet[Real]*D</a>, <a href="#decl_cvSet%5BReal%5D*D">cvSet[Real]*D</a>)如果元素的下标超出了范围就会产生错误&nbsp; </p>
<hr>

<h3><a name="decl_cvGet*D">Get*D</a></h3>
<p class="Blurb">返回特殊的数组元素</p><pre>CvScalar cvGet1D( const CvArr* arr, int idx0 );
CvScalar cvGet2D( const CvArr* arr, int idx0, int idx1 );
CvScalar cvGet3D( const CvArr* arr, int idx0, int idx1, int idx2 );
CvScalar cvGetND( const CvArr* arr, int* idx );
</pre>
<p>
</p><dl>
  <dt>arr 
  </dt><dd>输入数组. 
  </dd><dt>idx0 
  </dt><dd>元素下标第一个以0为基准的成员 
  </dd><dt>idx1 
  </dt><dd>元素下标第二个以0为基准的成员 
  </dd><dt>idx2 
  </dt><dd>元素下标第三个以0为基准的成员 
  </dd><dt>idx 
  </dt><dd>元素下标数组 </dd></dl>
<p>函数<a href="#decl_cvGet*D">cvGet*D</a> 返回指定的数组元素。对于稀疏数组如果需要的节点不存在函数返回0