opencvref_cxcore.cn.htm

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

（不会创建新的节点）</p>
<hr>

<h3><a name="decl_cvGetReal*D">GetReal*D</a></h3>
<p class="Blurb">返回单通道数组的指定元素</p><pre>double cvGetReal1D( const CvArr* arr, int idx0 );
double cvGetReal2D( const CvArr* arr, int idx0, int idx1 );
double cvGetReal3D( const CvArr* arr, int idx0, int idx1, int idx2 );
double cvGetRealND( 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_cvGetReal*D">cvGetReal*D</a> 
返回单通道数组的指定元素，如果数组是多通道的，就会产生运行时错误，而 <a href="#decl_cvGet*D">cvGet*D</a>     
函数可以安全的被用于单通道和多通道数组，但他们运行时会有点慢</p>    
<p>如果指定的点不存在对于稀疏数组点会返回0（不会创建新的节点）。</p>
<hr>

<h3><a name="decl_cvmGet">mGet</a></h3>
<p class="Blurb">返回单通道浮点矩阵指定元素</p><pre>double cvmGet( const CvMat* mat, int row, int col );
</pre>
<p>
</p><dl>
  <dt>mat 
  </dt><dd>输入矩阵. 
  </dd><dt>row 
  </dt><dd>行下标，以0为基点. 
  </dd><dt>col 
  </dt><dd>列下标，以0为基点 </dd></dl>
<p>函数 <a href="#decl_cvmGet">cvmGet</a> 是 <a href="#decl_cvGetReal2D">cvGetReal2D</a>对于单通道浮点矩阵的快速替代函数，函数运行比较快速因为它是内连函数     
，这个函数对于数组类型、数组元素类型的检查作的很少，并且仅在调式模式下检查数的行和列范围。</p>
<hr>

<h3><a name="decl_cvSet*D">Set*D</a></h3>
<p class="Blurb">修改指定的数组</p><pre>void cvSet1D( CvArr* arr, int idx0, CvScalar value );
void cvSet2D( CvArr* arr, int idx0, int idx1, CvScalar value );
void cvSet3D( CvArr* arr, int idx0, int idx1, int idx2, CvScalar value );
void cvSetND( CvArr* arr, int* idx, CvScalar value );
</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>value 
  </dt><dd>指派的值 </dd></dl>
<p>函数 <a href="#decl_cvSet*D">cvSet*D</a>     
指定新的值给指定的数组元素。对于稀疏矩阵如果指定节点不存在函数创建新的节点</p>    
<hr>

<h3><a name="decl_cvSetReal*D">SetReal*D</a></h3>
<p class="Blurb">修改指定数组元素值</p><pre>void cvSetReal1D( CvArr* arr, int idx0, double value );
void cvSetReal2D( CvArr* arr, int idx0, int idx1, double value );
void cvSetReal3D( CvArr* arr, int idx0, int idx1, int idx2, double value );
void cvSetRealND( CvArr* arr, int* idx, double value );
</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>value 
  </dt><dd>指派的值 </dd></dl>
<p>函数 <a href="#decl_cvSetReal*D">cvSetReal*D</a>     
分配新的值给单通道数组的指定元素，如果数组是多通道就会产生运行时错误。然而<a href="#decl_cvSet*D">cvSet*D</a>     
可以安全的被用于多通道和单通道数组，只是稍微有点慢。</p>    
<p>对于稀疏数组如果指定的节点不存在函数会创建该节点。</p>
<hr>

<h3><a name="decl_cvmSet">mSet</a></h3>
<p class="Blurb">返回单通道浮点矩阵的指定元素</p><pre>void cvmSet( CvMat* mat, int row, int col, double value );
</pre>
<p>
</p><dl>
  <dt>mat 
  </dt><dd>矩阵. 
  </dd><dt>row 
  </dt><dd>行下标,以0为基点. 
  </dd><dt>col 
  </dt><dd>列下标,以0为基点. 
  </dd><dt>value 
  </dt><dd>矩阵元素的新值 </dd></dl>
<p>函数<a href="#decl_cvmSet">cvmSet</a> 是<a href="#decl_cvSetReal2D">cvSetReal2D</a> 
快速替代,对于单通道浮点矩阵因为这个函数是内连的所以比较快,函数对于数组类型、数组元素类型的检查作的很少，并且仅在调式模式下检查数的行和列范围。</p>    
<hr>

<h3><a name="decl_cvClearND">ClearND</a></h3>
<p class="Blurb">清除指定数组元素</p><pre>void cvClearND( CvArr* arr, int* idx );
</pre>
<p>
</p><dl>
  <dt>arr 
  </dt><dd>输入数组. 
  </dd><dt>idx 
  </dt><dd>数组元素下标 </dd></dl>
<p>函数<a href="#decl_cvClear*D">cvClearND</a> 清除指定密集型数组的元素(置0)或删除稀疏数组的元素     
,如果元素不存在函数不作任何事</p>
<hr>

<h2><a name="cxcore_arrays_copying">拷贝和添加</a></h2>
<hr>

<h3><a name="decl_cvCopy">Copy</a></h3>
<p class="Blurb">拷贝一个数组给另一个数组</p><pre>void cvCopy( const CvArr* src, CvArr* dst, const CvArr* mask=NULL );
</pre>
<p>
</p><dl>
  <dt>src 
  </dt><dd>输入数组. 
  </dd><dt>dst 
  </dt><dd>输出数组 
  </dd><dt>mask 
  </dt><dd>Operation mask, 8-bit single channel array; specifies elements of 
  destination array to be changed. </dd></dl>
<p>函数 <a href="#decl_cvCopy">cvCopy</a> copies selected elements from    
input array to output array:</p>   
<p>dst(I)=src(I) if mask(I)!=0. </p>
<p>If any of the passed arrays is of <code>IplImage</code> type, then its ROI    
and COI fields are used. Both arrays must have the same type, the same number of    
dimensions and the same size. 函数 can also copy sparse arrays (mask is    
not supported in this case).</p>   
<hr>

<h3><a name="decl_cvSet">Set</a></h3>
<p class="Blurb">Sets every element of array to given value</p><pre>void cvSet( CvArr* arr, CvScalar value, const CvArr* mask=NULL );
</pre>
<p>
</p><dl>
  <dt>arr 
  </dt><dd>The destination array. 
  </dd><dt>value 
  </dt><dd>Fill value. 
  </dd><dt>mask 
  </dt><dd>操作覆盖面,8位单通道数组 ; 输出数组中的覆盖面指定元素被除数修改. </dd></dl>    
<p>函数 <a href="#decl_cvSet">cvSet</a> 拷贝数量值到输出数组的每一个被除数选定的元素:</p><pre>arr(I)=value if mask(I)!=0</pre>    
<p>如果数组 <code>arr</code> 是 <code>IplImage</code> 类型, 那么就会使用ROI,但 COI不能设置 .</p>    
<hr>

<h3><a name="decl_cvSetZero">SetZero</a></h3>
<p class="Blurb">清空数组</p><pre>void cvSetZero( CvArr* arr );
#define cvZero cvSetZero
</pre>
<p>
</p><dl>
  <dt>arr 
  </dt><dd>要被清空数组. </dd></dl>
<p>函数 <a href="#decl_cvSetZero">cvSetZero</a> 清空数组. 对于密集型号数组(CvMat, CvMatND or     
IplImage) cvZero(array) 就相当于 cvSet(array,cvScalarAll(0),0),     
对于稀疏数组所有的元素都将被删除.</p><!-- *****************************************************************************************
     *****************************************************************************************
     ***************************************************************************************** -->
<hr>

<h2><a name="cxcore_arrays_permute">变换和置换</a></h2>
<hr>

<h3><a name="decl_cvReshape">Reshape</a></h3>
<p class="Blurb">不拷贝数据修改矩阵/图像形状</p><pre>CvMat* cvReshape( const CvArr* arr, CvMat* header, int new_cn, int new_rows=0 );
</pre>
<p>
</p><dl>
  <dt>arr 
  </dt><dd>输入的数组. 
  </dd><dt>header 
  </dt><dd>被添充的矩阵头 
  </dd><dt>new_cn 
  </dt><dd>新的通道数.<code>new_cn = 0</code> 意味着不修改通道数     
  </dd><dt>new_rows 
  </dt><dd>新的行数. 如果<code>new_rows = 0保持原行数不修改否则根据</code>&nbsp; <code>new_cn</code>     
  值修改输出数组 </dd></dl>    
<p>函数 <a href="#decl_cvReshape">cvReshape</a> 初始化 CvMat 头header     
以便于让头指向修改后的形状（但数据保持原样）-也就是说修改通道数,修改行数或者两者者改变.</p>
<p>例如, 接下来的代码创建一个图像缓存、两个图像头，第一个是 320x240x3 图像第二个是 960x240x1 图像:</p><pre>IplImage* color_img = cvCreateImage( cvSize(320,240), IPL_DEPTH_8U, 3 );
CvMat gray_mat_hdr;
IplImage gray_img_hdr, *gray_img;
cvReshape( color_img, &amp;gray_mat_hdr, 1 );
gray_img = cvGetImage( &amp;gray_mat_hdr, &amp;gray_img_hdr );
</pre>    
<p>下一个例子转换3x3 矩阵成单向量 1x9&nbsp;</p><pre>CvMat* mat = cvCreateMat( 3, 3, CV_32F );
CvMat row_header, *row;
row = cvReshape( mat, &amp;row_header, 0, 1 );
</pre>    
<hr>

<h3><a name="decl_cvReshapeMatND">ReshapeMatND</a></h3>
<p class="Blurb">修改多维数组形状，拷贝/不拷贝数据</p><pre>CvArr* cvReshapeMatND( const CvArr* arr,
                       int sizeof_header, CvArr* header,
                       int new_cn, int new_dims, int* new_sizes );

#define cvReshapeND( arr, header, new_cn, new_dims, new_sizes )   \
      cvReshapeMatND( (arr), sizeof(*(header)), (header),         \
                      (new_cn), (new_dims), (new_sizes))

</pre>
<p>
</p><dl>
  <dt>arr 
  </dt><dd>输入数组 
  </dd><dt>sizeof_header 
  </dt><dd>输出头的大小，对于IplImage, CvMat 和 CvMatND 各种结构输出的头巾是不同的.     
  </dd><dt>header 
  </dt><dd>被添充的输出头. 
  </dd><dt>new_cn 
  </dt><dd>新的通道数，如果<code>new_cn = 0</code> 则通道数保持原样     
  </dd><dt>new_dims 
  </dt><dd>新的维数. 如果<code>new_dims = 0</code> 则维数保持原样。     
  </dd><dt>new_sizes 
  </dt><dd>新的维大小.只有当 只有 <code>new_dims-1值被使用，因为要保持数组的总数一致，因此如果</code> <code>new_dims     
  = 1</code>, <code>new_sizes</code> 是不被使用的 </dd></dl>    
<p>函数<a href="#decl_cvReshapeMatND">cvReshapeMatND</a> 是 <a href="#decl_cvReshape">cvReshape</a> 
的高级版本，它可以处理多维数组（能够呛处理通用的图像和矩阵）并且修改维数，下面的是使用<a href="#decl_cvReshapeMatND">cvReshapeMatND</a>重写 <a href="#decl_cvReshape">cvReshape</a>的二个例子 ：</p><pre>IplImage* color_img = cvCreateImage( cvSize(320,240), IPL_DEPTH_8U, 3 );
IplImage gray_img_hdr, *gray_img;
gray_img = (IplImage*)cvReshapeND( color_img, &amp;gray_img_hdr, 1, 0, 0 );

...

/*second example is modified to convert 2x2x2 array to 8x1 vector */
int size[] = { 2, 2, 2 };
CvMatND* mat = cvCreateMatND( 3, size, CV_32F );
CvMat row_header, *row;
row = cvReshapeND( mat, &amp;row_header, 0, 1, 0 );
</pre>    
<hr>

<h3><a name="decl_cvRepeat">Repeat</a></h3>
<p class="Blurb">用原数组管道式添充输出数组</p><pre>void cvRepeat( const CvArr* src, CvArr* dst );
</pre>
<p>
</p><dl>
  <dt>src 
  </dt><dd>输入数组, 图像或矩阵。     
  </dd><dt>dst 
  </dt><dd>输出数组，图像或矩阵 </dd></dl>
<p>函数<a href="#decl_cvRepeat">cvRepeat</a> 使用被管道化的原数组添充输出数组：</p><pre>dst(i,j)=src(i mod rows(src), j mod cols(src))</pre>    
<p>因此 ，输出数组可能小于输入数组 </p>    
<hr>

<h3><a name="decl_cvFlip">Flip</a></h3>
<p class="Blurb">垂直，水平或即垂直又水平翻转二维数组</p><pre>void  cvFlip( const CvArr* src, CvArr* dst=NULL, int flip_mode=0);
#define cvMirror cvFlip

</pre>
<p>
</p><dl>
  <dt>src 
  </dt><dd>原数组. 
  </dd><dt>