IplImage

一、资源

In this chapter, APIs will make U crazy. Good luck! Next, Review Linear Algebra.

Ref: http://blog.csdn.net/u012269327/article/category/2291085【学习Opencv笔记】

二、IplImage

  • Data structure

"modules/core/include/opencv2/core/types_c.h"

  1. typedef struct _IplImage
  2. {
  3.     int  nSize;             /* sizeof(IplImage) */
  4.     int  ID;                /* version (=0)*/
  5.     int  nChannels;         /* Most of OpenCV functions support 1,2,3 or 4 channels */
  6.     int  alphaChannel;      /* Ignored by OpenCV */
  7.     int  depth;             /* Pixel depth in bits: IPL_DEPTH_8U, IPL_DEPTH_8S, IPL_DEPTH_16S,
  8.                                IPL_DEPTH_32S, IPL_DEPTH_32F and IPL_DEPTH_64F are supported.  */
  9.     char colorModel[4];     /* Ignored by OpenCV */
  10.     char channelSeq[4];     /* ditto */
  11.     int  dataOrder;         /* 0 - interleaved color channels 隔行扫描, 1 - separate color channels .
  12.                                cvCreateImage can only create  images */
  13.     int  origin;            /* 0 - top-left origin,
  14.                                1 - bottom-left origin (Windows bitmaps style).  */
  15.     int  align;             /* Alignment of image rows (4 or 8).
  16.                                OpenCV ignores it and uses widthStep instead.    */
  17.     int  width;             /* Image width in pixels.                           */
  18.     int  height;            /* Image height in pixels.                          */
  19.     struct _IplROI *roi;    /* Image ROI. If NULL, the whole image is selected. 函数的操作被限定在一小块区域*/
  20.     struct _IplImage *maskROI;      /* Must be NULL. */
  21.     void  *imageId;                 /* "           " */
  22.     struct _IplTileInfo *tileInfo;  /* "           " */
  23.     int  imageSize;         /* Image data size in bytes
  24.                                (==image->height*image->widthStep
  25.                                in case of interleaved data)*/
  26.     char *imageData;        /* Pointer to aligned image data.         */
  27.     int  widthStep;         /* Size of aligned image row in bytes.    */
  28.     int  BorderMode[4];     /* Ignored by OpenCV.                     */
  29.     int  BorderConst[4];    /* Ditto.                                 */
  30.     char *imageDataOrigin;  /* Pointer to very origin of image data
  31.                                (not necessarily aligned) -
  32.                                needed for correct deallocation */
  33. }
  34. IplImage;

三、局部区域操作

  • 单区域操作 - ROI
  1. #include <highgui.h>

  2. int main(void)
  3. {
  4.     IplImage* src;
  5.     cvNamedWindow("Example3_12_pre", CV_WINDOW_AUTOSIZE);
  6.     cvNamedWindow("Example3_12_post", CV_WINDOW_AUTOSIZE);
  7.     if(((src=cvLoadImage("/home/unsw/lolo.jpg",)) !=  ))
  8.     {
  9.         int x = atoi("");
  10.         int y = atoi("");
  11.         int width = atoi("");
  12.         int height = atoi("");
  13.         int add = atoi("");
  14.         cvShowImage( "Example3_12_pre", src);
  15.         cvSetImageROI(src, cvRect(x,y,width,height));     // 设置专注范围
  16.         cvAddS(src, cvScalar(add, , , ), src, NULL);　 // 只在专注的范围执行函数
  17.         cvResetImageROI(src);　　                         // 如果注销，下一个函数（显示图像）则只会显示指定区域
  18.         cvShowImage( "Example3_12_post",src);
  19.         cvWaitKey();
  20.     }
  21.     cvReleaseImage( &src );
  22.     cvDestroyWindow("Example3_12_pre");
  23.     cvDestroyWindow("Example3_12_post");
  24.     return ;
  25. }
  • 多区域同时处理

但以下方式更加灵活，方便实现多区域同时处理。

  1. int main(int argc, char** argv)
  2. {
  3.     IplImage* interest_img;
  4.     CvRect interest_rect;
  5.     if( argc ==  && ((interest_img=cvLoadImage(argv[],)) !=  ))
  6.     {
  7.         interest_rect.x = atoi(argv[]);
  8.         interest_rect.y = atoi(argv[]);
  9.         interest_rect.width = atoi(argv[]);
  10.         interest_rect.height = atoi(argv[]);
  11.         int add = atoi(argv[]);
  12.  
  13.         // Assuming IplImage *interest_img; and
  14.         //  CvRect interest_rect;
  15.         //  Use widthStep to get a region of interest
  16.         //
  17.         // (Alternate method)
  18.         //
  19.         IplImage *sub_img = cvCreateImageHeader(
  20.           cvSize(
  21.              interest_rect.width,
  22.              interest_rect.height
  23.           ),
  24.           interest_img->depth,
  25.           interest_img->nChannels
  26.         );
  27.  
  28.         sub_img->origin = interest_img->origin;
  29.  
  30.         sub_img->widthStep = interest_img->widthStep;
  31.  
  32.         sub_img->imageData = interest_img->imageData +
  33.           　　interest_rect.y * interest_img->widthStep  +
  34.           　　interest_rect.x * interest_img->nChannels;
  35.  
  36.         cvAddS( sub_img, cvScalar(add), sub_img );
  37.  
  38.         cvReleaseImageHeader(&sub_img);
  39.  
  40.         cvNamedWindow( "Roi_Add", CV_WINDOW_AUTOSIZE );
  41.         cvShowImage( "Roi_Add", interest_img );
  42.         cvWaitKey();
  43.     }
  44.     return ;
  45. }

四、矩阵图像处理函数

全部API

  1. 、cvLoadImage：将图像文件加载至内存；
  2.  
  3. 、cvNamedWindow：在屏幕上创建一个窗口；
  4.  
  5. 、cvShowImage：在一个已创建好的窗口中显示图像；
  6.  
  7. 、cvWaitKey：使程序暂停，等待用户触发一个按键操作；
  8.  
  9. 、cvReleaseImage：释放图像文件所分配的内存；
  10.  
  11. 、cvDestroyWindow：销毁显示图像文件的窗口；
  12.  
  13. 、cvCreateFileCapture：通过参数设置确定要读入的AVI文件；
  14.  
  15. 、cvQueryFrame：用来将下一帧视频文件载入内存；
  16.  
  17. 、cvReleaseCapture：释放CvCapture结构开辟的内存空间；
  18.  
  19. 、cvCreateTrackbar：创建一个滚动条；
  20.  
  21. 、cvSetCaptureProperty：设置CvCapture对象的各种属性；
  22.  
  23. 、cvGetCaptureProperty：查询CvCapture对象的各种属性；
  24.  
  25. 、cvGetSize：当前图像结构的大小；
  26.  
  27. 、cvSmooth：对图像进行平滑处理；
  28.  
  29. 、cvPyrDown：图像金字塔，降采样，图像缩小为原来四分之一；
  30.  
  31. 、cvCanny：Canny边缘检测；
  32.  
  33. 、cvCreateCameraCapture：从摄像设备中读入数据；
  34.  
  35. 、cvCreateVideoWriter：创建一个写入设备以便逐帧将视频流写入视频文件；
  36.  
  37. 、cvWriteFrame：逐帧将视频流写入文件；
  38.  
  39. 、cvReleaseVideoWriter：释放CvVideoWriter结构开辟的内存空间；
  40.  
  41. 、CV_MAT_ELEM：从矩阵中得到一个元素；
  42.  
  43. 、cvAbs：计算数组中所有元素的绝对值；
  44.  
  45. 、cvAbsDiff：计算两个数组差值的绝对值；
  46.  
  47. 、cvAbsDiffS：计算数组和标量差值的绝对值；
  48.  
  49. 、cvAdd：两个数组的元素级的加运算；
  50.  
  51. 、cvAddS：一个数组和一个标量的元素级的相加运算；
  52.  
  53. 、cvAddWeighted：两个数组的元素级的加权相加运算(alpha运算)；
  54.  
  55. 、cvAvg：计算数组中所有元素的平均值；
  56.  
  57. 、cvAvgSdv：计算数组中所有元素的绝对值和标准差；
  58.  
  59. 、cvCalcCovarMatrix：计算一组n维空间向量的协方差；
  60.  
  61. 、cvCmp：对两个数组中的所有元素运用设置的比较操作；
  62.  
  63. 、cvCmpS：对数组和标量运用设置的比较操作；
  64.  
  65. 、cvConvertScale：用可选的缩放值转换数组元素类型；
  66.  
  67. 、cvCopy：把数组中的值复制到另一个数组中；
  68.  
  69. 、cvCountNonZero：计算数组中非0值的个数；
  70.  
  71. 、cvCrossProduct：计算两个三维向量的向量积(叉积)；
  72.  
  73. 、cvCvtColor：将数组的通道从一个颜色空间转换另外一个颜色空间；
  74.  
  75. 、cvDet：计算方阵的行列式；
  76.  
  77. 、cvDiv：用另外一个数组对一个数组进行元素级的除法运算；
  78.  
  79. 、cvDotProduct：计算两个向量的点积；
  80.  
  81. 、cvEigenVV：计算方阵的特征值和特征向量；
  82.  
  83. 、cvFlip：围绕选定轴翻转；
  84.  
  85. 、cvGEMM：矩阵乘法；
  86.  
  87. 、cvGetCol：从一个数组的列中复制元素；
  88.  
  89. 、cvGetCols：从数据的相邻的多列中复制元素；
  90.  
  91. 、cvGetDiag：复制数组中对角线上的所有元素；
  92.  
  93. 、cvGetDims：返回数组的维数；
  94.  
  95. 、cvGetDimSize：返回一个数组的所有维的大小；
  96.  
  97. 、cvGetRow：从一个数组的行中复制元素值；
  98.  
  99. 、cvGetRows：从一个数组的多个相邻的行中复制元素值；
  100.  
  101. 、cvGetSize：得到二维的数组的尺寸，以CvSize返回；
  102.  
  103. 、cvGetSubRect：从一个数组的子区域复制元素值；
  104.  
  105. 、cvInRange：检查一个数组的元素是否在另外两个数组中的值的范围内；
  106.  
  107. 、cvInRangeS：检查一个数组的元素的值是否在另外两个标量的范围内；
  108.  
  109. 、cvInvert：求矩阵的逆；
  110.  
  111. 、cvMahalonobis：计算两个向量间的马氏距离；
  112.  
  113. 、cvMax：在两个数组中进行元素级的取最大值操作；
  114.  
  115. 、cvMaxS：在一个数组和一个标量中进行元素级的取最大值操作；
  116.  
  117. 、cvMerge：把几个单通道图像合并为一个多通道图像；
  118.  
  119. 、cvMin：在两个数组中进行元素级的取最小值操作；
  120.  
  121. 、cvMinS：在一个数组和一个标量中进行元素级的取最小值操作；
  122.  
  123. 、cvMinMaxLoc：寻找数组中的最大最小值；
  124.  
  125. 、cvMul：计算两个数组的元素级的乘积(点乘)；
  126.  
  127. 、cvNot：按位对数组中的每一个元素求反；
  128.  
  129. 、cvNormalize：将数组中元素进行归一化；
  130.  
  131. 、cvOr：对两个数组进行按位或操作；
  132.  
  133. 、cvOrs：在数组与标量之间进行按位或操作；
  134.  
  135. 、cvReduce：通过给定的操作符将二维数组简为向量；
  136.  
  137. 、cvRepeat：以平铺的方式进行数组复制；
  138.  
  139. 、cvSet：用给定值初始化数组；
  140.  
  141. 、cvSetZero：将数组中所有元素初始化为0；
  142.  
  143. 、cvSetIdentity：将数组中对角线上的元素设为1，其他置0；
  144.  
  145. 、cvSolve：求出线性方程组的解；
  146.  
  147. 、cvSplit：将多通道数组分割成多个单通道数组；
  148.  
  149. 、cvSub：两个数组元素级的相减；
  150.  
  151. 、cvSubS：元素级的从数组中减去标量；
  152.  
  153. 、cvSubRS：元素级的从标量中减去数组；
  154.  
  155. 、cvSum：对数组中的所有元素求和；
  156.  
  157. 、cvSVD：二维矩阵的奇异值分解；
  158.  
  159. 、cvSVBkSb：奇异值回代计算；
  160.  
  161. 、cvTrace：计算矩阵迹；
  162.  
  163. 、cvTranspose：矩阵的转置运算；
  164.  
  165. 、cvXor：对两个数组进行按位异或操作；
  166.  
  167. 、cvXorS：在数组和标量之间进行按位异或操作；
  168.  
  169. 、cvZero：将所有数组中的元素置为0；
  170.  
  171. 、cvConvertScaleAbs：计算可选的缩放值的绝对值之后再转换数组元素的类型；
  172.  
  173. 、cvNorm：计算数组的绝对范数， 绝对差分范数或者相对差分范数；
  174.  
  175. 、cvAnd：对两个数组进行按位与操作；
  176.  
  177. 、cvAndS：在数组和标量之间进行按位与操作；  
  178.  
  179. 、cvScale：是cvConvertScale的一个宏，可以用来重新调整数组的内容，并且可以将参数从一种数据类型转换为另一种；
  180.  
  181. 、cvT：是函数cvTranspose的缩写；
  182.  
  183. 、cvLine：画直线；
  184.  
  185. 、cvRectangle：画矩形；
  186.  
  187. 、cvCircle：画圆；
  188.  
  189. 、cvEllipse：画椭圆；
  190.  
  191. 、cvEllipseBox：使用外接矩形描述椭圆；
  192.  
  193. 、cvFillPoly、cvFillConvexPoly、cvPolyLine：画多边形；
  194.  
  195. 、cvPutText：在图像上输出一些文本；
  196.  
  197. 、cvInitFont：采用一组参数配置一些用于屏幕输出的基本个特定字体；
  198.  
  199. 、cvSave：矩阵保存；
  200.  
  201. 、cvLoad：矩阵读取；
  202.  
  203. 、cvOpenFileStorage：为读/写打开存储文件；
  204.  
  205. 、cvReleaseFileStorage：释放存储的数据；
  206.  
  207. 、cvStartWriteStruct：开始写入新的数据结构；
  208.  
  209. 、cvEndWriteStruct：结束写入数据结构；
  210.  
  211. 、cvWriteInt：写入整数型；
  212.  
  213. 、cvWriteReal：写入浮点型；
  214.  
  215. 、cvWriteString：写入字符型；
  216.  
  217. 、cvWriteComment：写一个XML或YAML的注释字串；
  218.  
  219. 、cvWrite：写一个对象；
  220.  
  221. 、cvWriteRawData：写入多个数值；
  222.  
  223. 、cvWriteFileNode：将文件节点写入另一个文件存储器；
  224.  
  225. 、cvGetRootFileNode：获取存储器最顶层的节点；
  226.  
  227. 、cvGetFileNodeByName：在映图或存储器中找到相应节点；
  228.  
  229. 、cvGetHashedKey：为名称返回一个惟一的指针；
  230.  
  231. 、cvGetFileNode：在映图或文件存储器中找到节点；
  232.  
  233. 、cvGetFileNodeName：返回文件的节点名；
  234.  
  235. 、cvReadInt：读取一个无名称的整数型；
  236.  
  237. 、cvReadIntByName：读取一个有名称的整数型；
  238.  
  239. 、cvReadReal：读取一个无名称的浮点型；
  240.  
  241. 、cvReadRealByName：读取一个有名称的浮点型；
  242.  
  243. 、cvReadString：从文件节点中寻找字符串；
  244.  
  245. 、cvReadStringByName：找到一个有名称的文件节点并返回它；
  246.  
  247. 、cvRead：将对象解码并返回它的指针；
  248.  
  249. 、cvReadByName：找到对象并解码；
  250.  
  251. 、cvReadRawData：读取多个数值；
  252.  
  253. 、cvStartReadRawData：初始化文件节点序列的读取；
  254.  
  255. 、cvReadRawDataSlice：读取文件节点的内容；
  256.  
  257. 、cvGetModuleInfo：检查IPP库是否已经正常安装并且检验运行是否正常；
  258.  
  259. 、cvResizeWindow：用来调整窗口的大小；
  260.  
  261. 、cvSaveImage：保存图像；
  262.  
  263. 、cvMoveWindow：将窗口移动到其左上角为x,y的位置；
  264.  
  265. 、cvDestroyAllWindow：用来关闭所有窗口并释放窗口相关的内存空间；
  266.  
  267. 、cvGetTrackbarPos：读取滑动条的值；
  268.  
  269. 、cvSetTrackbarPos：设置滑动条的值；
  270.  
  271. 、cvGrabFrame：用于快速将视频帧读入内存；
  272.  
  273. 、cvRetrieveFrame：对读入帧做所有必须的处理；
  274.  
  275. 、cvConvertImage：用于在常用的不同图像格式之间转换；
  276.  
  277. 、cvErode：形态腐蚀；
  278.  
  279. 、cvDilate：形态学膨胀；
  280.  
  281. 、cvMorphologyEx：更通用的形态学函数；
  282.  
  283. 、cvFloodFill：漫水填充算法，用来进一步控制哪些区域将被填充颜色；
  284.  
  285. 、cvResize：放大或缩小图像；
  286.  
  287. 、cvPyrUp：图像金字塔，将现有的图像在每个维度上都放大两倍；
  288.  
  289. 、cvPyrSegmentation：利用金字塔实现图像分割；
  290.  
  291. 、cvThreshold：图像阈值化；
  292.  
  293. 、cvAcc：可以将8位整数类型图像累加为浮点图像；
  294.  
  295. 、cvAdaptiveThreshold：图像自适应阈值；
  296.  
  297. 、cvFilter2D：图像卷积；
  298.  
  299. 、cvCopyMakeBorder：将特定的图像轻微变大，然后以各种方式自动填充图像边界；
  300.  
  301. 、cvSobel：图像边缘检测，Sobel算子；
  302.  
  303. 、cvLaplace：拉普拉斯变换、图像边缘检测；
  304.  
  305. 、cvHoughLines2：霍夫直线变换；
  306.  
  307. 、cvHoughCircles：霍夫圆变换；
  308.  
  309. 、cvRemap：图像重映射，校正标定图像，图像插值；
  310.  
  311. 、cvWarpAffine：稠密仿射变换；
  312.  
  313. 、cvGetQuadrangleSubPix：仿射变换；
  314.  
  315. 、cvGetAffineTransform：仿射映射矩阵的计算；
  316.  
  317. 、cvCloneImage：将整个IplImage结构复制到新的IplImage中；
  318.  
  319. 、cv2DRotationMatrix：仿射映射矩阵的计算；
  320.  
  321. 、cvTransform：稀疏仿射变换；
  322.  
  323. 、cvWarpPerspective：密集透视变换(单应性)；
  324.  
  325. 、cvGetPerspectiveTransform：计算透视映射矩阵；
  326.  
  327. 、cvPerspectiveTransform：稀疏透视变换；
  328.  
  329. 、cvCartToPolar：将数值从笛卡尔空间到极坐标(极性空间)进行映射；
  330.  
  331. 、cvPolarToCart：将数值从极性空间到笛卡尔空间进行映射；
  332.  
  333. 、cvLogPolar：对数极坐标变换；
  334.  
  335. 、cvDFT：离散傅里叶变换；
  336.  
  337. 、cvMulSpectrums：频谱乘法；
  338.  
  339. 、cvDCT：离散余弦变换；
  340.  
  341. 、cvIntegral：计算积分图像；
  342.  
  343. 、cvDistTransform：图像的距离变换；
  344.  
  345. 、cvEqualizeHist：直方图均衡化；
  346.  
  347. 、cvCreateHist：创建一新直方图；
  348.  
  349. 、cvMakeHistHeaderForArray：根据已给出的数据创建直方图；
  350.  
  351. 、cvNormalizeHist：归一化直方图；
  352.  
  353. 、cvThreshHist：直方图阈值函数；
  354.  
  355. 、cvCalcHist：从图像中自动计算直方图；
  356.  
  357. 、cvCompareHist：用于对比两个直方图的相似度；
  358.  
  359. 、cvCalcEMD2：陆地移动距离(EMD)算法；
  360.  
  361. 、cvCalcBackProject：反向投影；
  362.  
  363. 、cvCalcBackProjectPatch：图块的方向投影；
  364.  
  365. 、cvMatchTemplate：模板匹配；
  366.  
  367. 、cvCreateMemStorage：用于创建一个内存存储器；
  368.  
  369. 、cvCreateSeq：创建序列；
  370.  
  371. 、cvSeqInvert：将序列进行逆序操作；
  372.  
  373. 、cvCvtSeqToArray：复制序列的全部或部分到一个连续内存数组中；
  374.  
  375. 、cvFindContours：从二值图像中寻找轮廓；
  376.  
  377. 、cvDrawContours：绘制轮廓；
  378.  
  379. 、cvApproxPoly：使用多边形逼近一个轮廓；
  380.  
  381. 、cvContourPerimeter：轮廓长度；
  382.  
  383. 、cvContoursMoments：计算轮廓矩；
  384.  
  385. 、cvMoments：计算Hu不变矩；
  386.  
  387. 、cvMatchShapes：使用矩进行匹配；
  388.  
  389. 、cvInitLineIterator：对任意直线上的像素进行采样；
  390.  
  391. 、cvSampleLine：对直线采样；
  392.  
  393. 、cvAbsDiff：帧差；
  394.  
  395. 、cvWatershed：分水岭算法；
  396.  
  397. 、cvInpaint：修补图像；
  398.  
  399. 、cvGoodFeaturesToTrack：寻找角点；
  400.  
  401. 、cvFindCornerSubPix：用于发现亚像素精度的角点位置；
  402.  
  403. 、cvCalcOpticalFlowLK：实现非金字塔的Lucas-Kanade稠密光流算法；
  404.  
  405. 、cvMeanShift：mean-shift跟踪算法；
  406.  
  407. 、cvCamShift：camshift跟踪算法；
  408.  
  409. 、cvCreateKalman：创建Kalman滤波器；
  410.  
  411. 、cvCreateConDensation：创建condensation滤波器；
  412.  
  413. 、cvConvertPointsHomogenious：对齐次坐标进行转换；
  414.  
  415. 、cvFindChessboardCorners：定位棋盘角点；
  416.  
  417. 、cvFindHomography：计算单应性矩阵；
  418.  
  419. 、cvRodrigues2：罗德里格斯变换；
  420.  
  421. 、cvFitLine：直线拟合算法；
  422.  
  423. 、cvCalcCovarMatrix：计算协方差矩阵；
  424.  
  425. 、cvInvert：计算协方差矩阵的逆矩阵；
  426.  
  427. 、cvMahalanobis：计算Mahalanobis距离；
  428.  
  429. 、cvKMeans2：K均值；
  430.  
  431. 、cvCloneMat：根据一个已有的矩阵创建一个新矩阵；
  432.  
  433. 、cvPreCornerDetect：计算用于角点检测的特征图；
  434.  
  435. 、cvGetImage：CvMat图像数据格式转换成IplImage图像数据格式；
  436.  
  437. 、cvMatMul：两矩阵相乘；

openCV函数 - 219个

  • 常用API 

常用函数
cvAbs 计算数组中所有元素的绝对值 042
cvAbsDiff 计算两个数组差值的绝对值 042
cvAbsDiffs 计算数组和标量差值的绝对值 042
cvAdd 两个数组的元素级的加运算 033
cvAdds 一个数组和一个标量的元素级的相加运算 033
cvAddWeighted 两个数组的元素的加权相加运算（alpha融合） 000
cvAvg 计算数组所有元素的平均值 011
cvAvgSdv 计算数组中所有元素的绝对值和标准差 011
cvCalcCovarMatrix 计算一组n维空间向量的协方差 020
cvCmp 对两个数组中的所有元素运用设置的比较操作 002
cvCmps 对数组和标量运用设置的比较 002
cvConvertScale 用可选的缩放值转换数组元素类型 013
cvConvertScaleAbs 计算可选的缩放值的绝对值之后在转换数组元素的类型 013
cvCopy 把数组中的值复制到另一个数组中 001
cvCountNonZero 计算数组中非0值的个数 047
cvCrossProduct 计算两个三维向量的向量积（叉积） 051
cvCvtColor 将数组通道从一个颜色空间转换到另外一个颜色空间 010
cvDet 计算方阵的行列式 031
cvDiv 用另外一个数组对一个数组进行元素级的除法运算 041
cvDotProduct 计算两个向量的点积 050
cvEigenVV 计算方阵的特征值和特征向量 031
cvFlip 围绕选定翻转 012
cvGEMM 矩阵乘法 032
cvGetCol 从一个数组的列中复制元素  
cvGetCols 从数据的相邻的多列中复制元素 045
cvGetDiag 复制数组中对角线上的所有元素 045
cvGetDims 返回数组的维数 044
cvGetDimSize 返回一个数组的所有维大小  
cvGetRow 从一个数组的行中复制元素  
cvGetRows 从一个数组的多个相邻行中复制元素 045
cvGetSize 得到二维数组的尺寸，一CvSize返回 014
cvGetSubRect 从一个数组的子区域复制元素值 015
cvInRange 检查一个数组的元素是否在另外两个数组中的值范围内  
cvInRangeS 检查一个数组的元素是否在另外两个标量的范围内  
cvInvert 求矩阵的转置  
cvMahalonobis 计算两个向量间的马氏距离  
cvMax 在两个数组中进行元素级的取最大值操作 002
cvMaxS 在一个数组和一个标量中进行元素级的取最大值操作 002
cvMerge 把几个单通道图像合并为一个多通道图像 011
cvMin 在两个数组中进行元素级的取最小值操作 002
cvMinS 在一个数组和一个标量中进行元素级的取最小值操作 002
cvMinMaxLoc 寻找数组中的最大最小值 046
cvMul 计算两个数组元素级的乘积 041
cvNot 按位对数组中的每一个元素求反 043
cvNorm 计算两个数组的正态相关性  
cvNormalize 将数组中的元素归一化  
cvOr 对两个数组元素按位或操作 043
cvOrs 对数组与标量之间进行按位或操作  
cvReduce 通过给定的操作符将二维数组约简为向量  
cvRepeat 以平铺的方式进行数组复制 001
cvSet 用给定值初始化数组 040
cvSetZero 将数组中的所有元素初始为0 040
cvSetIdentity 将数组中对角线上的元素设为1,其他为0  
cvSolve 求出线性方程的解  
cvSplit 将多通道数组分割成但通道数组 011
cvSub 两个数组元素级的相减 033
cvSubS 元素级的从数组减去标量  
cvSubRS 元素级的从标量减去数组  
cvSum 对数组中的所有元素求和 011
cvSVD 二维矩阵的奇异值分解  
cvSVBkSb 奇异值回代计算  
cvTrace 计算矩阵迹  
cvTranspose 矩阵的转置运算  
cvXor 对两个数组进行按位异或运算 043
cvXorS 在数组和标量之间进行安慰异或操作  
cvZero 将所有数组中的元素置为0 040
  • 000. 两张图像融合
  1. #include <highgui.h>
  2. #include <stdio.h>
  3.  
  4. // alphablend <imageA> <image B> <x> <y> <width> <height>
  5. //            <alpha> <beta>
  6.  
  7. int main(void)
  8. {
  9.     char *argvv[];
  10.     argvv[] = "/home/unsw/lolo.jpg";
  11.     argvv[] = "/home/unsw/lolo2.jpg";
  12.     argvv[] = "";
  13.     argvv[] = "";
  14.     argvv[] = "";
  15.     argvv[] = "";
  16.     argvv[] = "";
  17.     argvv[] = "0.1";
  18.  
  19.     IplImage *src1, *src2;
  20.     if( ((src1=cvLoadImage(argvv[],)) != ) &&
  21.             ((src2=cvLoadImage(argvv[],)) !=  ))
  22.     {
  23.         int x = atoi(argvv[]);
  24.         int y = atoi(argvv[]);
  25.         int width = atoi(argvv[]);
  26.         int height = atoi(argvv[]);
  27.         double alpha = (double)atof(argvv[]);
  28.         double beta  = (double)atof(argvv[]);
  29.  
  30.         cvSetImageROI(src1, cvRect(x,y,width,height));
  31.         cvSetImageROI(src2, cvRect(,,width,height));
  32.  
  33.         // 图片混合显示
  34.         cvAddWeighted(src1, alpha, src2, beta, 0.0, src1);
  35.  
  36.         cvResetImageROI(src1);
  37.         cvNamedWindow( "Alpha_blend",  );
  38.         cvShowImage( "Alpha_blend", src1 );
  39.         cvWaitKey();
  40.     }
  41.     else
  42.         printf("Couldn't load one or both of %s, %s\n",argvv[],argvv[]);
  43.     return ;
  44. }

cvAddWeighted

  • 001. 图片拷贝
  1. #include <cv.h>
  2. #include <highgui.h>
  3. #include <stdio.h>  
  4.  
  5. int main(int argc, char** argv)
  6. {
  7.     IplImage *src1, *src2,*src3;
  8.     src1=cvLoadImage("5.jpg");
  9.     src2=cvLoadImage("3.jpg");  // 作为mask
  10.     src3=cvLoadImage("7.jpg");  
  11.  
  12.     cvCopy(src1,src3,src2);  
  13.  
  14.     cvShowImage( "测试1", src1);
  15.     cvShowImage( "测试2", src2);
  16.     cvShowImage( "测试3", src3);
  17.     cvWaitKey();
  18.     return ;
  19. }

cvCopy

下面的没有去点开关

  1. #include <cv.h>
  2. #include <highgui.h>
  3. #include <stdio.h>
  4. #include <iostream>
  5. using namespace std;  
  6.  
  7. int main()
  8. {
  9.     IplImage *src1, *src2,*src3;
  10.     src1 = cvLoadImage("1.jpg");
  11.     src2 = cvLoadImage("7.jpg");  
  12.  
  13.     cvRepeat(src1,src2);  
  14.  
  15.     cvShowImage( "测试1", src1);
  16.     cvShowImage( "测试2", src2);
  17.     cvWaitKey();
  18.     return ;
  19. }

cvRepeat

  • 002. 图片比较
  1. CV_CMP_EQ    (src1i == src2i)
  2. CV_CMP_GT    (src1i > src2i)
  3. CV_CMP_GE    (src1i >= src2i)
  4. CV_CMP_LT    (src1i < src2i)
  5. CV_CMP_LE    (src1i <= src2i)
  6. CV_CMP_NE    (src1i != src2i)

比较方式：cmp_op

  1. #include <cv.h>
  2. #include <highgui.h>
  3. #include <stdio.h>  
  4.  
  5. int main(int argc, char** argv)
  6. {
  7.     IplImage *src1, *src2,*src3;
  8.     src1=cvLoadImage("5.jpg");
  9.     src2=cvLoadImage("6.jpg");
  10.     src3=cvLoadImage("5.jpg");  
  11.  
  12.     cvCmp(src1,src2,src3,CV_CMP_GE);  
  13.  
  14.     cvShowImage( "测试1", src1);
  15.     cvShowImage( "测试2", src2);
  16.     cvShowImage( "测试3", src3);
  17.     cvWaitKey();
  18.     return ;
  19. }

cvCmp

  1. #include <cv.h>
  2. #include <highgui.h>
  3. #include <stdio.h>  
  4.  
  5. int main(int argc, char** argv)
  6. {
  7.     IplImage *src1,*src2;
  8.     src1=cvLoadImage("5.jpg");
  9.     src2=cvLoadImage("5.jpg");  
  10.  
  11.     cvCmpS(src1,250.2,src2,CV_CMP_GE);  
  12.  
  13.     cvShowImage( "测试1", src1);
  14.     cvShowImage( "测试2", src2);
  15.     cvWaitKey();
  16.     return ;
  17. }

cvCmpS

  1. #include <cv.h>
  2. #include <highgui.h>
  3. #include <stdio.h>  
  4.  
  5. int main(int argc, char** argv)
  6. {
  7.     IplImage *src1, *src2,*src3;
  8.     src1 = cvLoadImage("7.jpg");
  9.     src2 = cvLoadImage("1.jpg");
  10.     src3 = cvLoadImage("3.jpg");  
  11.  
  12.     cvMax(src2,src3,src1);  
  13.  
  14.     cvShowImage( "测试1", src1);
  15.     cvShowImage( "测试2", src2);
  16.     cvShowImage( "测试3", src3);
  17.     cvWaitKey();
  18.     return ;
  19. }

cvMax

  1. #include <cv.h>
  2. #include <highgui.h>
  3. #include <stdio.h>  
  4.  
  5. int main(int argc, char** argv)
  6. {
  7.     IplImage *src1, *src2,*src3;
  8.     src1 = cvLoadImage("7.jpg");
  9.     src2 = cvLoadImage("1.jpg");  
  10.  
  11.     cvMaxS(src2,,src1);  
  12.  
  13.     cvShowImage( "测试1", src1);
  14.     cvShowImage( "测试2", src2);
  15.     cvWaitKey();
  16.     return ;
  17. }

cvMaxS

  1. #include <cv.h>
  2. #include <highgui.h>
  3. #include <stdio.h>  
  4.  
  5. int main(int argc, char** argv)
  6. {
  7.     IplImage *src1, *src2,*src3;
  8.     src1 = cvLoadImage("7.jpg");
  9.     src2 = cvLoadImage("1.jpg");
  10.     src3 = cvLoadImage("3.jpg");  
  11.  
  12.     cvMin(src2,src3,src1);  
  13.  
  14.     cvShowImage( "测试1", src1);
  15.     cvShowImage( "测试2", src2);
  16.     cvShowImage( "测试3", src3);
  17.     cvWaitKey();
  18.     return ;
  19. }

cvMin

  1. #include <cv.h>
  2. #include <highgui.h>
  3. #include <stdio.h>  
  4.  
  5. int main(int argc, char** argv)
  6. {
  7.     IplImage *src1, *src2,*src3;
  8.     src1 = cvLoadImage("7.jpg");
  9.     src2 = cvLoadImage("1.jpg");  
  10.  
  11.     cvMinS(src2,,src1);  
  12.  
  13.     cvShowImage( "测试1", src1);
  14.     cvShowImage( "测试2", src2);
  15.     cvWaitKey();
  16.     return ;
  17. }

cvMinS

  • 010. 色彩空间调整
  1. #include <cv.h>
  2. #include <highgui.h>
  3. #include <stdio.h>
  4.  
  5. int main(int argc, char** argv)
  6. {
  7.     IplImage  *src2,*src3;
  8.     src2=cvLoadImage("/home/unsw/lolo.jpg");
  9.     src3=cvLoadImage("/home/unsw/lolo.jpg");
  10.  
  11.     cvCvtColor(src2,src3,CV_RGB2HSV);
  12.     cvShowImage( "测试2", src2);
  13.     cvShowImage( "测试3", src3);
  14.     cvWaitKey();
  15.     return ;
  16. }
  1. CV_BGR2RGB
  2. CV_RGB2BGR
  3. CV_RGBA2BGRA
  4. CV_BGRA2RGBA         在RGB或BGR色彩空间之间转换(包括或者不包括alpha 通道)
  5. CV_RGB2RGBA
  6. CV_BGR2BGRA           在RGB或BGR图像中加入alpha 通道
  7. CV_RGBA2RGB
  8. CV_BGRA2BGR           从RGB或BGR图像中删除alpha 通道
  9. CV_RGB2BGRA
  10. CV_RGBA2BGR
  11. CV_BGRA2RGB
  12. CV_BGR2RGBA            加入或者移除alpha通道时，转换RGB到BGR 色彩空间
  13. CV_RGB2GRAY
  14. CV_BGR2GRAY            转换RGB或者BGR色彩空间为灰度空间
  15. CV_GRAY2RGB
  16. CV_GRAY2BGR
  17. CV_RGBA2GRAY
  18. CV_BGRA2GRAY         转换灰度为RGB或者BGR色彩空间(在进程中选择移除alpha通道)
  19. CV_GRAY2RGBA
  20. CV_GRAY2BGRA         转换灰度为RGB或者BGR色彩空间并且加入alpha通道
  21. CV_RGB2BGR565
  22. CV_BGR2BGR565
  23. CV_BGR5652RGB
  24. CV_BGR5652BGR
  25. CV_RGBA2BGR565
  26. CV_BGRA2BGR565
  27. CV_BGR5652RGBA
  28. CV_BGR5652BGRA        在从RGB或者BGR色彩空间转换到BGR565彩色图画时，选择加入或者移除 alpha通道 (16位图)
  29. CV_GRAY2BGR565
  30. CV_BGR5652GRAY         转换灰度为BGR565彩色图像或者反变换(16位图)
  31. CV_RGB2BGR555
  32. CV_BGR2BGR555
  33. CV_BGR5552RGB
  34. CV_BGR5552BGR
  35. CV_RGBA2BGR555
  36. CV_BGRA2BGR555          在从RGB或者BGR色彩空间转换到BGR555色彩空间时，选择加入或者移除alpha通道(16位图)
  37. CV_BGR5552RGBA
  38. CV_BGR5552BGRA
  39. CV_GRAY2BGR555
  40. CV_BGR5552GRAY          转换灰度到BGR555色彩空间或者反变换(16位图)
  41. CV_RGB2XYZ
  42. CV_BGR2XYZ
  43. CV_XYZ2RGB
  44. CV_XYZ2BGR                    转换RGB或者BGR色彩空间到CIE XYZ色彩空间或者反变换(Rec 709和D65 白点)
  45. CV_RGB2YCrCb
  46. CV_BGR2YCrCb
  47. CV_YCrCb2RGB
  48. CV_YCrCb2BGR                转换RGB 或者BGR色彩空间到luma-chroma (aka YCC)色彩空间
  49. CV_RGB2HSV
  50. CV_BGR2HSV
  51. CV_HSV2RGB
  52. CV_HSV2BGR                    转换RGB或者BGR色彩空间到HSV(hue，saturation，value)色彩空间或反变换
  53. CV_RGB2HLS
  54. CV_BGR2HLS
  55. CV_HLS2RGB
  56. CV_HLS2BGR                     转换RGB或者BGR色彩空间到HLS(hue，Lightness，saturation)色彩空间或反变换
  57. CV_RGB2Lab
  58. CV_BGR2Lab
  59. CV_Lab2RGB
  60. CV_Lab2BGR                      转换RGB或者BGR色彩空间到CIE LAB色彩空间或反变换
  61. CV_RGB2Luv
  62. CV_BGR2Luv
  63. CV_Luv2RGB
  64. CV_Luv2BGR                        转换RGB或者BGR色彩空间到CIE Luv色彩空间
  65. CV_BayerBG2RGB
  66. CV_BayerGB2RGB               转换Bayer模式(单通道) 到RGB或者BGR色彩空间
  67. CV_BayerRG2RGB
  68. CV_BayerGR2RGB
  69. CV_BayerBG2BGR
  70. CV_BayerGB2BGR
  71. CV_BayerRG2BGR
  72. CV_BayerGR2BGR

色彩空间宏

  • 011. 多通道 分解 or 合并 or 总和 or 均值、标准差
  1. #include<cv.h>
  2. #include<cxcore.h>
  3. #include<highgui.h>
  4.  
  5. using namespace std;
  6.  
  7. int main(int argc,char **argv)
  8. {
  9.     //if(argc>=2)
  10.     {
  11.         IplImage *image,*change,*H,*S,*V,*R,*B,*G,*two,*Zero;
  12.         //创建图像显示窗口
  13.         cvNamedWindow("image",CV_WINDOW_AUTOSIZE);
  14.         cvNamedWindow("R",CV_WINDOW_AUTOSIZE);
  15.         cvNamedWindow("G",CV_WINDOW_AUTOSIZE);
  16.         cvNamedWindow("B",CV_WINDOW_AUTOSIZE);
  17.         cvNamedWindow("HS",CV_WINDOW_AUTOSIZE);
  18.         cvNamedWindow("HV",CV_WINDOW_AUTOSIZE);
  19.         cvNamedWindow("VS",CV_WINDOW_AUTOSIZE);
  20.         cvNamedWindow("RG",CV_WINDOW_AUTOSIZE);
  21.         cvNamedWindow("RB",CV_WINDOW_AUTOSIZE);
  22.         cvNamedWindow("BG",CV_WINDOW_AUTOSIZE);
  23.         cvNamedWindow("Zero",CV_WINDOW_AUTOSIZE);
  24.  
  25.         image=cvLoadImage("/home/unsw/lolo.jpg);//载入图像
  26.  
  27.         //分配图像空间
  28.         change=cvCreateImage(cvSize(image->width,image->height),IPL_DEPTH_8U,);
  29.         R=cvCreateImage(cvSize(image->width,image->height),IPL_DEPTH_8U,);
  30.         G=cvCreateImage(cvSize(image->width,image->height),IPL_DEPTH_8U,);
  31.         B=cvCreateImage(cvSize(image->width,image->height),IPL_DEPTH_8U,);
  32.         H=cvCreateImage(cvSize(image->width,image->height),IPL_DEPTH_8U,);
  33.         S=cvCreateImage(cvSize(image->width,image->height),IPL_DEPTH_8U,);
  34.         V=cvCreateImage(cvSize(image->width,image->height),IPL_DEPTH_8U,);
  35.         two=cvCreateImage(cvSize(image->width,image->height),IPL_DEPTH_8U,);
  36.         Zero=cvCreateImage(cvSize(image->width,image->height),IPL_DEPTH_8U,);
  37.  
  38.         cvZero(Zero);//在将两个通道合并是，不能没有第三个通道，而是将该通道设为空白，即全0
  39.  
  40.         cout<<"IPL_DEPTH_8U = "<<IPL_DEPTH_8U<<endl;
  41.         cout<<"CV_RGB2HSV = "<<CV_RGB2HSV<<endl;
  42.         cout<<"CV_HSV2RGB = "<<CV_HSV2RGB<<endl;
  43.  
  44.         cvCvtColor(image,change,CV_RGB2HSV);  //将RGB色系转换为HSV色系
  45.  
  46.         cvSplit(image,R,G,B,);//分离多通道
  47.         cvSplit(change,H,S,V,);//分离多通道
  48.  
  49.         //显示RGB图单通道图
  50.         cvShowImage("image",image);
  51.         cvShowImage("Zero",Zero);
  52.         cvShowImage("R",R);
  53.         cvShowImage("G",G);
  54.         cvShowImage("B",B);
  55.  
  56.         cvMerge(R,G,Zero,,two);   //合并两个图像空间
  57.         cvShowImage("RG",two);//显示B通道为空白时的图像
  58.  
  59.         cvMerge(Zero,G,B,,two);
  60.         cvShowImage("BG",two);
  61.  
  62.         cvMerge(R,Zero,B,,two);
  63.         cvShowImage("RB",two);
  64.  
  65.         cvMerge(H,S,Zero,,two);
  66.         cvCvtColor(two,change,CV_HSV2RGB);//cvShowImage是按照RGB色彩方式显示图像的，故要通过RGB色系展示对HSV色系的更改效果
  67.         cvShowImage("HS",change);
  68.  
  69.         cvMerge(Zero,S,V,,two);
  70.         cvCvtColor(two,change,CV_HSV2RGB);//cvShowImage是按照RGB色彩方式显示图像的，故要通过RGB色系展示对HSV色系的更改效果
  71.         cvShowImage("VS",change);
  72.  
  73.         cvMerge(H,Zero,V,,two);
  74.         cvCvtColor(two,change,CV_HSV2RGB);//cvShowImage是按照RGB色彩方式显示图像的，故要通过RGB色系展示对HSV色系的更改效果
  75.         cvShowImage("HV",change);
  76.  
  77.         cvWaitKey();
  78.  
  79.         cvDestroyAllWindows();
  80.         cvReleaseImage(&image);
  81.         cvReleaseImage(&change);
  82.     }
  83.     system("pause");
  84.     return ;
  85. }

多通道分解实例

  1. void cvMerge(//cvSplit()的逆运算
  2.     const CvArr* src0,//图1
  3.     const CvArr* src1,//图2
  4.     const CvArr* src2,//图3
  5.     const CvArr* src3,//图4
  6.     CvArr* dst//结果图
  7. );

cvMerge

  1. #include <cv.h>
  2. #include <highgui.h>
  3. #include <stdio.h>  
  4.  
  5. int main(int argc, char** argv)
  6. {
  7.     IplImage *src1,*src2,*dst11,*dst12,*dst13;  
  8.  
  9.     src1=cvLoadImage("5.jpg");
  10.     src2=cvLoadImage("7.jpg");  
  11.  
  12.     dst11 = cvCreateImage(cvSize(src1->width, src1->height), IPL_DEPTH_8U, );
  13.     dst12 = cvCreateImage(cvSize(src1->width, src1->height), IPL_DEPTH_8U, );
  14.     dst13 = cvCreateImage(cvSize(src1->width, src1->height), IPL_DEPTH_8U, );  
  15.  
  16.     cvSplit(src1, dst11, dst12, dst13, );//分解
  17.     cvMerge(dst11,dst12,dst13,NULL,src2);  //再合并
  18.  
  19.     cvShowImage( "测试", src2);  
  20.  
  21.     cvWaitKey();
  22.     return ;
  23. }

多通道合并实例

  1. #include <cv.h>
  2. #include <highgui.h>
  3. #include <stdio.h>
  4. #include <iostream>
  5. using namespace std;  
  6.  
  7. int main()
  8. {
  9.     IplImage *src1,*dst1,*dst2,*dst3,*dst4;
  10.     src1=cvLoadImage("3.jpg",);  
  11.  
  12.     CvScalar cs = cvSum(src1);  
  13.  
  14.     cout << "通道一总和：";
  15.     cout << cs.val[] << endl;
  16.     cout << "通道二总和：";
  17.     cout << cs.val[] << endl;
  18.     cout << "通道三总和：";
  19.     cout << cs.val[] << endl;
  20.     cout << "通道四总和：";
  21.     cout << cs.val[] << endl;  
  22.  
  23.     getchar();
  24.     return ;
  25. }

cvSum

  1. #include <cv.h>
  2. #include <highgui.h>
  3. #include <iostream>
  4. #include <stdio.h>
  5. using namespace std;  
  6.  
  7. int main(int argc, char** argv)
  8. {
  9.     IplImage *src1;
  10.     src1=cvLoadImage("1.jpg");  
  11.  
  12.     CvScalar cs;  
  13.  
  14.     cs = cvAvg(src1);  
  15.  
  16.     cout<<cs.val[] << endl;
  17.     cout<<cs.val[] << endl;
  18.     cout<<cs.val[] << endl;
  19.     cout<<cs.val[] << endl;  
  20.  
  21.     getchar();
  22.     return ;
  23. }

cvAvg

  1. #include <cv.h>
  2. #include <highgui.h>
  3. #include <iostream>
  4. #include <stdio.h>
  5. using namespace std;  
  6.  
  7. int main(int argc, char** argv)
  8. {
  9.     IplImage *src1;
  10.     src1=cvLoadImage("1.jpg");  
  11.  
  12.     CvScalar cs,cs1;  
  13.  
  14.     cvAvgSdv(src1,&cs,&cs1);   // <-- 多了标准差
  15.  
  16.     cout<<"平均值："<<endl;
  17.     cout<<cs.val[] << endl;
  18.     cout<<cs.val[] << endl;
  19.     cout<<cs.val[] << endl;
  20.     cout<<cs.val[] << endl;
  21.     cout <<endl;  
  22.  
  23.     cout <<"标准差"<<endl;
  24.     cout<<cs1.val[] << endl;
  25.     cout<<cs1.val[] << endl;
  26.     cout<<cs1.val[] << endl;
  27.     cout<<cs1.val[] << endl;  
  28.  
  29.     getchar();
  30.     return ;
  31. }

cvAvgSdv附送标准差

  • 012. 轴翻转
  • 013. 像素线性变换
  1. #include <cv.h>
  2. #include <highgui.h>
  3. #include <stdio.h>  
  4.  
  5. int main(int argc, char** argv)
  6. {
  7.     IplImage  *src2,*src3;
  8.     src2=cvLoadImage("3.jpg");
  9.     src3=cvLoadImage("7.jpg");  
  10.  
  11.     cvConvertScale(src2,src3,4.0,-220.0);  
  12.  
  13.     cvShowImage( "测试2", src2);
  14.     cvShowImage( "测试3", src3);
  15.     getchar();
  16.     return ;
  17. }

cvConvertScale

  1. #include <cv.h>
  2. #include <highgui.h>
  3. #include <stdio.h>  
  4.  
  5. int main(int argc, char** argv)
  6. {
  7.     IplImage  *src2,*src3;
  8.     src2=cvLoadImage("3.jpg");
  9.     src3=cvLoadImage("7.jpg");  
  10.  
  11.     cvConvertScaleAbs(src2,src3,4.0,-220.5);  
  12.  
  13.     cvShowImage( "测试2", src2);
  14.     cvShowImage( "测试3", src3);
  15.     cvWaitKey();
  16.     return ;
  17. }

cvConvertScaleAbs

cvScale是cvConvertScale的一个宏，可以用来重新调整数组的内容，并且可以将参数从一种数据类型转换为另一种；

  1. #include <cv.h>
  2. #include <highgui.h>
  3. #include <stdio.h>
  4. #include <iostream>
  5. using namespace std;  
  6.  
  7. int main()
  8. {
  9.     IplImage* src1 = cvLoadImage("1.jpg",CV_LOAD_IMAGE_GRAYSCALE);    
  10.  
  11.     IplImage* src2 = cvCloneImage(src1);    
  12.  
  13.     IplImage* dst = cvCreateImage(cvGetSize(src1),IPL_DEPTH_64F,src1->nChannels);    
  14.  
  15.     double max_Val,min_Val;
  16.     cvScale(src1,dst,1.0,0.0);
  17.     cvAdd(dst,dst,dst);    
  18.  
  19.     cvMinMaxLoc(dst, &min_Val, &max_Val, NULL, NULL, NULL);    // <--
  20.  
  21.     cvScale(dst,src2,1.0,0.0);    
  22.  
  23.     cvScale(dst, dst, 1.0/(max_Val-min_Val), 1.0*(-min_Val)/(max_Val-min_Val));   // <--
  24.  
  25.     cvMinMaxLoc(dst, &min_Val, &max_Val, NULL, NULL, NULL);    
  26.  
  27.     cvShowImage("测试1",src1);    
  28.  
  29.     cvShowImage("测试2",src2);    
  30.  
  31.     cvShowImage("结果",dst);    
  32.  
  33.     cvWaitKey(-);
  34.     return ;
  35. }

cvScale

  • 014. 图像尺寸
  1. #include <cv.h>
  2. #include <highgui.h>
  3. #include <stdio.h>
  4. #include <iostream>
  5. using namespace std;  
  6.  
  7. int main()
  8. {
  9.     IplImage *src1;
  10.     src1=cvLoadImage("5.jpg");  
  11.  
  12.     CvSize cs = cvGetSize(src1);  
  13.  
  14.     cout << "图像的尺寸为：（单位：像素）"<<endl;
  15.     cout <<"高："<< cs.height << endl;
  16.     cout <<"宽："<<cs.width << endl;  
  17.  
  18.     getchar();
  19.     return ;
  20. }

cvGetSize

  • 015. 截取图像区域
  1. #include <cv.h>
  2. #include <highgui.h>
  3. #include <stdio.h>
  4. #include <iostream>
  5. using namespace std;  
  6.  
  7. int main()
  8. {
  9.     IplImage *res;
  10.     int subX = ;
  11.     int subY = ;  
  12.  
  13.     CvMat matSrc;  
  14.  
  15.     res = cvLoadImage("1.jpg", CV_LOAD_IMAGE_COLOR);  
  16.  
  17.     subX = res->width / ;
  18.     subY = res->height / ;  
  19.  
  20.     CvMat *pMat = cvGetSubRect(res, &matSrc, cvRect(, , res->width - subX, res->height - subY));  
  21.  
  22.     IplImage *pSubImg = cvCreateImageHeader(cvSize(, ), , );
  23.     cvGetImage(pMat, pSubImg);   
  24.  
  25.     cvShowImage("所截图像",pSubImg);
  26.     cvShowImage("原图像", res);
  27.     cvWaitKey();
  28.     return ;
  29. }

cvGetSubRect

  • 016. 像素设值
  1. #include <cv.h>
  2. #include <highgui.h>
  3. #include <stdio.h>  
  4.  
  5. int main()
  6. {
  7.     IplImage *src1, *src2;
  8.     src1 = cvLoadImage("1.jpg");
  9.     src2 = cvLoadImage("1.jpg");  
  10.  
  11.     CvScalar cs;
  12.     cs.val[] = ;
  13.     cs.val[] = ;
  14.     cs.val[] = ;
  15.     cs.val[] = ;  
  16.  
  17.     cvSet(src1,cs);  
  18.  
  19.     cvShowImage( "结果图", src1);
  20.     cvShowImage( "原图", src2);
  21.     cvWaitKey();
  22.     return ;
  23. }

cvSet

  1. #include <cv.h>
  2. #include <highgui.h>
  3. #include <stdio.h>  
  4.  
  5. int main()
  6. {
  7.     IplImage *src1, *src2;
  8.     src1 = cvLoadImage("1.jpg");
  9.     src2 = cvLoadImage("1.jpg");  
  10.  
  11.     CvScalar cs;
  12.     cs.val[] = ;
  13.     cs.val[] = ;
  14.     cs.val[] = ;
  15.     cs.val[] = ;  
  16.  
  17.     cvSetZero(src1);  
  18.  
  19.     cvShowImage( "结果图", src1);
  20.     cvShowImage( "原图", src2);
  21.     cvWaitKey();
  22.     return ;
  23. }

cvSetZero

  • 020 协方差矩阵

  • 协方差矩阵很简单，可它却是很多领域里的非常有力的工具。它能导出一个变换矩阵，这个矩阵能使数据完全去相关(decorrelation)。从不同的角度来看，也就是说能够找出一组最佳的基以紧凑的方式来表达数据。(完整的证明请参考瑞利商)。
  • 这个方法在统计学中被称为主成分分析(principal components analysis)，在图像处理中称为Karhunen-Loève 变换(KL-变换)。
  1. CV_IMPL void
  2. cvCalcCovarMatrix( const CvArr** vecarr, int count,
  3.                    CvArr* covarr, CvArr* avgarr, int flags )
  4. {
  5.     cv::Mat cov0 = cv::cvarrToMat(covarr), cov = cov0, mean0, mean;
  6.     CV_Assert( vecarr !=  && count >=  ); 
  7.  
  8.     if( avgarr )
  9.         mean = mean0 = cv::cvarrToMat(avgarr);
  10.  
  11.     if( (flags & CV_COVAR_COLS) !=  || (flags & CV_COVAR_ROWS) !=  )
  12.     {    
  13.  
  14.         cv::Mat data = cv::cvarrToMat(vecarr[]);
  15.         cv::calcCovarMatrix( data, cov, mean, flags, cov.type() );
  16.     }
  17.     else
  18.     {
  19.         std::vector<cv::Mat> data(count);
  20.         for( int i = ; i < count; i++ )
  21.             data[i] = cv::cvarrToMat(vecarr[i]);
  22.         cv::calcCovarMatrix( &data[], count, cov, mean, flags, cov.type() );
  23.     }    
  24.  
  25.     if( mean.data != mean0.data && mean0.data )
  26.         mean.convertTo(mean0, mean0.type());
  27.  
  28.     if( cov.data != cov0.data )
  29.         cov.convertTo(cov0, cov0.type());
  30. }

"modules/core/src/matmul.cpp"

　

该函数的使用 1：

  1. #include <opencv2/core/core.hpp>
  2. #include <opencv2/highgui/highgui.hpp>
  3.  
  4. #include <iostream>
  5.  
  6. using namespace cv;
  7. using namespace std;
  8.  
  9. int main(int /*argc*/, char** /*argv*/)
  10. {
  11.     Mat_<float> samples = (Mat_<float>(, ) << 1.0, 2.0, 3.0,
  12.                                                 4.0, 5.0, 6.0,
  13.                                                 7.0, 8.0, 9.0);
  14.  
  15.     Mat cov, mu;
  16.     cv::calcCovarMatrix(samples, cov, mu, CV_COVAR_NORMAL | CV_COVAR_ROWS);
  17.  
  18.     cout << "cov: " << endl;
  19.     cout << cov << endl;
  20.  
  21.     cout << "mu: " << endl;
  22.     cout << mu << endl;
  23.  
  24.     return ;
  25. }

运行结果：

  1. cov:
  2.  [, , ;
  3.   , , ;
  4.   , , ]
  5. mu:
  6.   [,  ,  ]

该函数的使用 2：

  1. #include <iostream>
  2. #include <fstream>
  3. #include <cv.h>
  4. #include <highgui.h>
  5.  
  6. using namespace std;
  7. using namespace cv; 
  8.  
  9. // OpenCV Covariance Example
  10. // Chye Connsynn and Carson Reynolds March 23, 2011
  11. // An example that computes a covariance matrix
  12. // Tested using OpenCV 2.2 on OS X 10.6.7
  13.  
  14. int main( int argc, char** argv ) {
  15.   // Input matrix size
  16.   const int rows = ;
  17.   const int cols = ;  
  18.  
  19.   // Input matrix
  20.   float x[rows][cols] = {{, , },
  21.              {, , }};
  22.  
  23.   // Place input into CvMat**
  24.   CvMat** input = new CvMat*[rows];
  25.   for(int i=; i<rows; i++) {
  26.     input[i] = cvCreateMat(, cols, CV_32FC1);
  27.     for(int j=; j<cols; j++) {
  28.       cvmSet(input[i], , j, x[i][j]);
  29.     }
  30.   }
  31.  
  32.   // Covariance matrix is N x N,
  33.   // where N is input matrix column size
  34.   const int n = cols;
  35.  
  36.   // Output variables passed by reference
  37.   CvMat* output = cvCreateMat(n, n, CV_32FC1);
  38.   CvMat* meanvec = cvCreateMat(, rows, CV_32FC1);
  39.  
  40.   // Calculate covariance matrix
  41.   cvCalcCovarMatrix((const void **) input, \
  42.             rows, output, meanvec, CV_COVAR_NORMAL);
  43.  
  44.   //Show result
  45.   cout << "Covariance matrix:" << endl;
  46.   for(int i=; i<n; i++) {
  47.     for(int j=; j<n; j++) {
  48.       cout << "(" << i << "," << j << "): ";
  49.       // normalize by n - 1 so that results are the same
  50.       // as MATLAB's cov() and Mathematica's Covariance[]
  51.       printf ("%f ", cvGetReal2D(output,i,j) / (rows - ));
  52.       cout << "\t";
  53.     }
  54.     cout << endl;
  55.   }
  56.   return();
  57. }

运行结果：

  1. Covariance matrix:
  2. (,): 12.500000     (,): -2.500000     (,): -112.500000
  3. (,): -2.500000     (,): 0.500000     (,): 22.500000
  4. (,): -112.500000     (,): 22.500000     (,): 1012.500000
  • 021. 转置矩阵
  1. #include <cv.h>
  2. #include <highgui.h>
  3. #include <stdio.h>
  4. #include <iostream>
  5. using namespace std;
  6. int main()
  7. {
  8.     double a[][] =
  9.     {
  10.         {,,,,},
  11.         {,,,,},
  12.         {,,,,},
  13.         {,,,,},
  14.         {,,,,}
  15.     };  
  16.  
  17.     CvMat va = cvMat(,, CV_64FC1,a);  
  18.  
  19.     double b[][] = {};  
  20.  
  21.     CvMat vb = cvMat(,, CV_64FC1,b);  
  22.  
  23.     cout<<"目标矩阵："<<endl;  
  24.  
  25.     for(int i=;i<;i++)
  26.     {
  27.         for(int j=;j<;j++)
  28.             printf("%f\t",cvmGet(&va,i,j));
  29.         cout << endl;
  30.     }  
  31.  
  32.     cvTranspose(&va,&vb);  
  33.  
  34.     cout<<"结果矩阵："<<endl;  
  35.  
  36.     for(int i=;i<;i++)
  37.     {
  38.         for(int j=;j<;j++)
  39.             printf("%f\t",cvmGet(&vb,i,j));
  40.         cout << endl;
  41.     }  
  42.  
  43.     getchar();
  44.     return ;  
  45.  
  46. }

cvTranspose

cvNorm函数

cvNormalize函数

cvReduce函数

  • 030. 计算矩阵的 行列式
  1. #include <cv.h>
  2. #include <highgui.h>
  3. #include <stdio.h>
  4. #include <iostream>
  5. using namespace std;
  6.  
  7. int main()
  8. {
  9.     double va[] = {,,,,,,,,};
  10.     CvMat Va=cvMat(, , CV_64FC1, va);
  11.     cout << "该矩阵的行列式的值为"<<cvDet(&Va) << endl;
  12.     getchar();
  13.     return ;
  14. }

适用于小型矩阵。

  • 031. 矩阵的 特征值 和 特征向量
  • 032. 矩阵 乘法
  1. double cvGEMM(//矩阵的广义乘法运算
  2.     const CvArr* src1,//乘数矩阵
  3.     const CvArr* src2,//乘数矩阵
  4.     double alpha,//1号矩阵系数
  5.     const CvArr* src3,//加权矩阵
  6.     double beta,//2号矩阵系数
  7.     CvArr* dst,//结果矩阵
  8.     int tABC = //变换标记
  9. );

cvGEMM定义

CV_GEMM_A_T 转置 src1
CV_GEMM_B_T 转置 src2
CV_GEMM_C_T 转置 src3

函数对应的乘法运算公式为：

  1. dst = (alpha * src1) x src2 + (beta * src3)
  1. #include <cv.h>
  2. #include <highgui.h>
  3. #include <stdio.h>
  4. #include <iostream>
  5. using namespace std;  
  6.  
  7. int main()
  8. {
  9.     double a[][] =
  10.     {
  11.         {,,},
  12.         {,,},
  13.         {,,}
  14.     };  
  15.  
  16.     CvMat va=cvMat(,, CV_64FC1,a);  
  17.  
  18.     cout<<"目标矩阵1："<<endl;  
  19.  
  20.     for(int i=;i<;i++)
  21.     {
  22.         for(int j=;j<;j++)
  23.             printf("%f\t",cvmGet(&va,i,j));
  24.         cout << endl;
  25.     }  
  26.  
  27.     double b[][] =
  28.     {
  29.         {,,},
  30.         {,,},
  31.         {,,}
  32.     };  
  33.  
  34.     CvMat vb =cvMat(, , CV_64FC1, b);  
  35.  
  36.     cout<<"目标矩阵2："<<endl;
  37.     for(int i=;i<;i++)
  38.     {
  39.         for(int j=;j<;j++)
  40.             printf("%f\t",cvmGet(&vb,i,j));
  41.         cout << endl;
  42.     }  
  43.  
  44.     double c[][] = {,,,,,,,,};
  45.     CvMat vc = cvMat(,, CV_64FC1, c);   
  46.  
  47.     cvGEMM(&va,&vb,,&vc,,&vc);  
  48.  
  49.     cout << "结果矩阵："<< endl;
  50.     for(int i=;i<;i++)
  51.     {
  52.         for(int j=;j<;j++)
  53.         printf("%f\t",cvmGet(&vc,i,j));
  54.         cout << endl;
  55.     }
  56.     getchar();
  57.     return ;
  58. }

cvGEMM

  • 033. 矩阵 加减法
  1. #include <cv.h>
  2. #include <highgui.h>
  3. #include <stdio.h>  
  4.  
  5. int main(int argc, char** argv)
  6. {
  7.     IplImage *src1, *src2,*src3;
  8.     src1=cvLoadImage("1.jpg");
  9.     src2=cvLoadImage("3.jpg");
  10.     src3=cvLoadImage("4.jpg");  
  11.  
  12.     cvAdd(src1,src2,src2);  
  13.  
  14.     cvShowImage( "测试1", src1);
  15.     cvShowImage( "测试2", src2);
  16.     cvShowImage( "测试3", src3);
  17.     cvWaitKey();
  18.     return ;
  19. }

cvAdd

  1. #include <cv.h>
  2. #include <highgui.h>
  3. #include <stdio.h>  
  4.  
  5. int main()
  6. {
  7.     IplImage *src1,*src2,*src3;  
  8.  
  9.     src1 = cvLoadImage("3.jpg");
  10.     src2 = cvLoadImage("1.jpg");
  11.     src3 = cvLoadImage("7.jpg");  
  12.  
  13.     cvSub(src1,src2,src3);  
  14.  
  15.     cvShowImage("",src1);
  16.     cvShowImage("",src2);
  17.     cvShowImage("",src3);  
  18.  
  19.     cvWaitKey();
  20.     return ;
  21. }

cvSub

  • 040. 矩阵各元素 初始化
cvZero相当于“与0”
cvSetZero
cvSet 有mask
  • 041. 矩阵各元素 相除 or 相乘

"modules/core/include/opencv2/core/types_c.h"

  1. /* CvArr* is used to pass arbitrary
  2.  * array-like data structures
  3.  * into functions where the particular
  4.  * array type is recognized at runtime:
  5.  */
  6. typedef void CvArr;

CvArr

  1. #include <cv.h>
  2. #include <highgui.h>
  3. #include <stdio.h>
  4. #include <iostream>
  5. using namespace std;  
  6.  
  7. int main()
  8. {
  9.     double va[] = {,,,,,,,,};
  10.     CvMat Va=cvMat(, , CV_64FC1, va);
  11.     double vb[] = {,,,,,,,,};
  12.     CvMat Vb=cvMat(, , CV_64FC1, vb);   
  13.  
  14.     cout<< "矩阵A："<<endl;
  15.     for(int i =  ;i <  ; i++)
  16.     {
  17.         for(int j = ; j < ; j++)
  18.             cout << CV_MAT_ELEM(Va,double,i,j)<<"  ";
  19.         cout << endl;
  20.     }  
  21.  
  22.     cout<< "矩阵B："<<endl;
  23.     for(int i =  ;i <  ; i++)
  24.     {
  25.         for(int j = ; j < ; j++)
  26.             cout << CV_MAT_ELEM(Vb,double,i,j)<<" ";
  27.         cout << endl;
  28.     }  
  29.  
  30.     cvDiv(&Va,&Vb,&Va,);  
  31.  
  32.     cout<< "运算后的矩阵："<<endl;
  33.     for(int i =  ;i <  ; i++)
  34.     {
  35.         for(int j = ; j < ; j++)
  36.             cout << CV_MAT_ELEM(Va,double,i,j)<<" ";
  37.         cout << endl;
  38.     }  
  39.  
  40.     getchar();
  41.     return ;
  42. }

cvDiv

  1. void cvMul(//两个矩阵对应元素相乘
  2.     const CvArr* src1,//矩阵1
  3.     const CvArr* src2,//矩阵2
  4.     CvArr* dst,//结果矩阵
  5.     double scale = //因子系数
  6. );

cvMul

  1. #include <cv.h>
  2. #include <highgui.h>
  3. #include <stdio.h>
  4. #include <iostream>
  5. using namespace std;  
  6.  
  7. int main()
  8. {
  9.     double a[][] =
  10.     {
  11.         {,,},
  12.         {,,},
  13.         {,,}
  14.     };  
  15.  
  16.     CvMat va = cvMat(,, CV_64FC1,a);  
  17.  
  18.     double b[][] =
  19.     {
  20.         {,,},
  21.         {,,},
  22.         {,,}
  23.     };  
  24.  
  25.     CvMat vb = cvMat(,, CV_64FC1,b);  
  26.  
  27.     cout<<"目标矩阵："<<endl;  
  28.  
  29.     for(int i=;i<;i++)
  30.     {
  31.         for(int j=;j<;j++)
  32.             printf("%f\t",cvmGet(&va,i,j));
  33.         cout << endl;
  34.     }  
  35.  
  36.     cout<<"因子矩阵："<<endl;  
  37.  
  38.     for(int i=;i<;i++)
  39.     {
  40.         for(int j=;j<;j++)
  41.             printf("%f\t",cvmGet(&vb,i,j));
  42.         cout << endl;
  43.     }  
  44.  
  45.     cvMul(&va,&vb,&va);  
  46.  
  47.     cout<<"结果矩阵："<<endl;  
  48.  
  49.     for(int i=;i<;i++)
  50.     {
  51.         for(int j=;j<;j++)
  52.             printf("%f\t",cvmGet(&va,i,j));
  53.         cout << endl;
  54.     }  
  55.  
  56.     getchar();
  57.     return ;  
  58.  
  59. }

cvMul

  • 042. 矩阵各元素 绝对值
  1. void cvAbs(  //取src中元素的绝对值，写到dst中
  2. 　　const CvArr* src,
  3. 　　const dst
  4. );  
  5.  
  6. void cvAbsDiff( //src1减去src2的差的绝对值存入dst
  7. 　　const CvArr* src1,
  8. 　　const CvArr* src2,
  9. 　　const dst
  10. );  
  11.  
  12. void cvAbsDiffs( //src中每个元素减去value存入dst中
  13. 　　const CvArr* src,
  14. 　　CvScalar value,
  15. 　　const dst
  16. );

cvAbs, cvAbsDiff, cvAbsDiffs函数定义

  1. #include <cv.h>
  2. #include <highgui.h>
  3. #include <cxcore.h>
  4. #include <iostream>
  5. using namespace std;  
  6.  
  7. int main( int argc, char** argv ){
  8.     CvMat *mat;
  9.     mat=cvCreateMat(,,CV_32FC1);  
  10.  
  11.     float value = 0.0;
  12.     int i = , j = ;
  13.     cout<<"初始化原始数组"<<endl;
  14.     for ( i = ; i < ; i ++ ){
  15.         for( j = ; j < ; j ++ ){  
  16.  
  17.             value -= 1.0;   // 赋值 -1 --> -16
  18.             CV_MAT_ELEM( *mat, float, i, j) = value;
  19.         }
  20.     }
  21.     for ( i = ; i < ; i ++ ){
  22.         for( j = ; j < ; j ++ ){  
  23.  
  24.             cout<<"\t"<<CV_MAT_ELEM( *mat, float, i, j);
  25.         }
  26.         cout<<endl;
  27.     }
  28.     CvMat *matDes;  
  29.  
  30.     matDes=cvCreateMat(,,CV_32FC1);   
  31.  
  32.     cout<<"目标矩阵"<<endl;
  33.     for ( i = ; i < ; i ++ ){
  34.         for( j = ; j < ; j ++ ){
  35.             cvmSet( matDes, i, j,);
  36.             cout<<"\t"<<CV_MAT_ELEM( *matDes, float, i, j);
  37.         }  
  38.  
  39.         cout<<endl;
  40.     }  
  41.  
  42.     cvAbs( mat, matDes );
  43.     cout<<"数组的绝对值"<<endl;
  44.     for ( i = ; i < ; i ++ ){
  45.         for( j = ; j < ; j ++ ){  
  46.  
  47.             cout<<"\t"<<CV_MAT_ELEM( *matDes, float, i, j);
  48.         }  
  49.  
  50.         cout<<endl;
  51.     }  
  52.  
  53.     CvMat *matDiff1 = cvCreateMat(,,CV_32FC1);  
  54.  
  55.     cvAbsDiff( mat,matDes , matDiff1);
  56.     cout<<"两个差的绝对值"<<endl;
  57.     for ( i = ; i < ; i ++ ){
  58.         for( j = ; j < ; j ++ ){  
  59.  
  60.             cout<<"\t"<<CV_MAT_ELEM( *matDiff1, float, i, j);
  61.         }  
  62.  
  63.         cout<<endl;
  64.     }  
  65.  
  66.     CvScalar cs;
  67.     cs.val[] = 2.0;
  68.     cs.val[] = 1.0;  
  69.  
  70.     cvAbsDiffS( mat, matDiff1,cs);
  71.     cout<<"矩阵减去标准值的绝对值"<<endl;
  72.     for ( i = ; i < ; i ++ ){
  73.         for( j = ; j < ; j ++ ){  
  74.  
  75.             cout<<"\t"<<CV_MAT_ELEM( *matDiff1, float, i, j);
  76.         }  
  77.  
  78.         cout<<endl;
  79.     }
  80.     cvReleaseMat( &mat );
  81.     cvReleaseMat( &matDes );
  82.     getchar();
  83.     return ;
  84. }
  • 043. 矩阵中各元素 逻辑运算
cvNot
cvOr
  1. #include <cv.h>
  2. #include <highgui.h>
  3. #include <stdio.h>  
  4.  
  5. int main(int argc, char** argv)
  6. {
  7.     IplImage *src1, *src2,*src3;
  8.     src1=cvLoadImage("1.jpg");
  9.     src2=cvLoadImage("3.jpg");
  10.     src3=cvLoadImage("4.jpg");  
  11.  
  12.     cvAnd(src1,src2,src3);  
  13.  
  14.     cvShowImage( "测试1", src1);
  15.     cvShowImage( "测试2", src2);
  16.     cvShowImage( "测试3", src3);
  17.     cvWaitKey();
  18.     return ;
  19. }

cvAnd

cvXor
  • 044. 矩阵的维度和大小
  1. #include <cv.h>
  2. #include <highgui.h>
  3. #include <stdio.h>
  4. #include <iostream>
  5. using namespace std;
  6.  
  7. int main()
  8. {
  9.     double a[][] =
  10.     {
  11.         {,,,,},
  12.         {,,,,},
  13.         {,,,,},
  14.         {,,,,},
  15.         {,,,,}
  16.     };
  17.  
  18.     CvMat va=cvMat(,, CV_64FC1,a);
  19.  
  20.     cout<<"目标矩阵："<<endl;
  21.  
  22.     for(int i=;i<;i++)
  23.     {
  24.         for(int j=;j<;j++)
  25.             printf("%f\t",cvmGet(&va,i,j));
  26.         cout << endl;
  27.     }
  28.  
  29.     int sizes[] = {};
  30.  
  31.     int v = cvGetDims(&va,sizes);
  32.     cout << "矩阵的维数：";
  33.         cout << v << endl;
  34.     cout << "每个维度上的大小："<<endl;
  35.     for(int i =  ; i<&&sizes[i]!=;i++)
  36.     cout << sizes[i] << endl;
  37.     getchar();
  38.     return ;
  39. }

cvGetDims

  • 045. 矩阵的 某行 or 某列 or 对角线
  1. #include <cv.h>
  2. #include <highgui.h>
  3. #include <stdio.h>
  4. #include <iostream>
  5. using namespace std;  
  6.  
  7. int main()
  8. {
  9.     double a[][] =
  10.     {
  11.         {,,,,},
  12.         {,,,,},
  13.         {,,,,},
  14.         {,,,,},
  15.         {,,,,}
  16.     };  
  17.  
  18.     CvMat va=cvMat(,, CV_64FC1,a);  
  19.  
  20.     cout<<"目标矩阵："<<endl;  
  21.  
  22.     for(int i=;i<;i++)
  23.     {
  24.         for(int j=;j<;j++)
  25.             printf("%f\t",cvmGet(&va,i,j));
  26.         cout << endl;
  27.     }  
  28.  
  29.     CvMat vb =cvMat(,, CV_64FC1);
  30.     CvMat vc =cvMat(,, CV_64FC1);   
  31.  
  32.     vc = *(cvGetRows(&va,&vb,,));  
  33.  
  34.     cout << "所要取的行为："<< endl;
  35.     for(int i=;i<vc.rows;i++)
  36.     {
  37.         for(int j=;j<vc.cols;j++)
  38.             printf("%f\t",cvmGet(&vc,i,j));
  39.         cout << endl;
  40.     }
  41.     getchar();
  42.     return ;
  43. }

cvGetRows

  1. #include <cv.h>
  2. #include <highgui.h>
  3. #include <stdio.h>
  4. #include <iostream>
  5. using namespace std;  
  6.  
  7. int main()
  8. {
  9.     double a[][] =
  10.     {
  11.         {,,,,},
  12.         {,,,,},
  13.         {,,,,},
  14.         {,,,,},
  15.         {,,,,}
  16.     };  
  17.  
  18.     CvMat va=cvMat(,, CV_64FC1,a);  
  19.  
  20.     cout<<"目标矩阵："<<endl;  
  21.  
  22.     for(int i=;i<;i++)
  23.     {
  24.         for(int j=;j<;j++)
  25.             printf("%f\t",cvmGet(&va,i,j));
  26.         cout << endl;
  27.     }  
  28.  
  29.     CvMat vb =cvMat(,, CV_64FC1);
  30.     CvMat vc =cvMat(,, CV_64FC1);   
  31.  
  32.     vc = *(cvGetCols(&va,&vb,,));  
  33.  
  34.     cout << "所要取的列为："<< endl;
  35.     for(int i=;i<vc.rows;i++)
  36.     {
  37.         for(int j=;j<vc.cols;j++)
  38.         printf("%f\t",cvmGet(&vc,i,j));
  39.         cout << endl;
  40.     }
  41.     getchar();
  42.     return ;
  43. }

cvGetCols

  1. #include <cv.h>
  2. #include <highgui.h>
  3. #include <stdio.h>
  4. #include <iostream>
  5. using namespace std;  
  6.  
  7. int main()
  8. {
  9.     double a[][] =
  10.     {
  11.         {,,,,},
  12.         {,,,,},
  13.         {,,,,},
  14.         {,,,,},
  15.         {,,,,}
  16.     };  
  17.  
  18.     CvMat va=cvMat(,, CV_64FC1,a);  
  19.  
  20.     cout<<"目标矩阵："<<endl;  
  21.  
  22.     for(int i=;i<;i++)
  23.     {
  24.         for(int j=;j<;j++)
  25.             printf("%f\t",cvmGet(&va,i,j));
  26.         cout << endl;
  27.     }  
  28.  
  29.     CvMat vb =cvMat(,, CV_64FC1);
  30.     CvMat vc =cvMat(,, CV_64FC1);   
  31.  
  32.     vc = *(cvGetDiag(&va,&vb,));  
  33.  
  34.     cout << "所要取的对角线为："<< endl;
  35.     for(int i=;i<vc.rows;i++)
  36.     {
  37.         for(int j=;j<vc.cols;j++)
  38.         printf("%f\t",cvmGet(&vc,i,j));
  39.         cout << endl;
  40.     }
  41.     getchar();
  42.     return ;
  43. }

cvGetDiag

  • 046. 矩阵中 最大最小值
  1. #include <cv.h>
  2. #include <highgui.h>
  3. #include <stdio.h>
  4. #include <iostream>
  5. using namespace std;  
  6.  
  7. int main()
  8. {
  9.     double a[][] =
  10.     {
  11.         {,,},
  12.         {,,},
  13.         {,,}
  14.     };  
  15.  
  16.     CvMat va = cvMat(,, CV_64FC1,a);  
  17.  
  18.     cout<<"目标矩阵："<<endl;  
  19.  
  20.     for(int i=;i<;i++)
  21.     {
  22.         for(int j=;j<;j++)
  23.             printf("%f\t",cvmGet(&va,i,j));
  24.         cout << endl;
  25.     }  
  26.  
  27.     double min_Val,max_Val;  
  28.  
  29.     cvMinMaxLoc(&va,&min_Val,&max_Val);  
  30.  
  31.     cout << "最小值为：" << endl;
  32.     cout << min_Val << endl;  
  33.  
  34.     cout << "最大值为：" << endl;
  35.     cout << max_Val << endl;  
  36.  
  37.     getchar();
  38.     return ;  
  39.  
  40. }

cvMinMaxLoc

  • 047. 矩阵中 非零的个数
  • 050. 向量的点积
  1. #include <cv.h>
  2. #include <highgui.h>
  3. #include <stdio.h>
  4. #include <iostream>
  5. using namespace std;  
  6.  
  7. int main()
  8. {
  9.     double va[] = {,,};
  10.     double vb[] = {,,};
  11.     CvMat Va=cvMat(, , CV_64FC1, va);
  12.     CvMat Vb=cvMat(, , CV_64FC1, vb);
  13.     cout << "其内积为：" << cvDotProduct(&Va,&Vb);
  14.     getchar();
  15.     return ;
  16. }

cvDotProduct

  • 051. 三维向量的叉积
  1. 叉积，又名叉乘。 最早源自于三维向量空间的运算，因此也叫向量的外积，或者向量积。 两个三维向量的叉积等于一个新的向量， 该向量与前两者垂直，且长度为前两者张成的平行四边形面积， 其方向按照右手螺旋决定。
  1. #include <cv.h>
  2. #include <highgui.h>
  3. #include <stdio.h>
  4. #include <iostream>
  5. using namespace std;
  6.  
  7. int main()
  8. {
  9.     double va[] = {,,};
  10.     double vb[] = {,,};
  11.     double vc[];
  12.  
  13.     CvMat Va=cvMat(, , CV_64FC1, va);
  14.     CvMat Vb=cvMat(, , CV_64FC1, vb);
  15.     CvMat Vc=cvMat(, , CV_64FC1, vc);
  16.  
  17.     cvCrossProduct(&Va, &Vb, &Vc);
  18.     //显示向量element
  19.     cout <<CV_MAT_ELEM(Vc,double,,)<<endl;
  20.     cout <<CV_MAT_ELEM(Vc,double,,)<<endl;
  21.     cout <<CV_MAT_ELEM(Vc,double,,)<<endl;
  22.     getchar();
  23.     return ;
  24. }

cvCrossProduct

cvSVD函数

cvSVBkSb函数

cvSVBkSb函数

[OpenCV] IplImage and Operation的更多相关文章

  1. OpenCV IplImage FlyCapture2 Image Conversion 两种图像类的相互转化

    OpenCV的IplImag和 FlyCapture2 的 Image是两种常见的图片格式,在实际的应用中,我们通常要混合使用OpenCV和FlyCapture2这两个SDK,所以这两种图片格式之间的 ...

  2. FlyCapture2 fc2Image OpenCV IplImage Conversion 两种图像格式之间的转换

    fc2Image是FlyCapture SDK的C语言库中的图片格式,由于在Windows上的MinGW无法编译FlyCapture2的C++库,只能使用C语言库,所以当我们在同时使用OpenCV的图 ...

  3. [OpenCV] IplImage and Functions

    In this chapter, APIs will make U crazy. Good luck! Next, Review Linear Algebra.  Ref: http://blog.c ...

  4. opencv Iplimage结构简介

    IplImage 结构解读: typedef struct _IplImage{int nSize;                    /* IplImage大小 */int ID;        ...

  5. OpenCV——IplImage

    IplImage结构: typedef struct _IplImage { int nSize; /* IplImage大小 */ int ID; /* 版本 (=0)*/ int nChannel ...

  6. opencv——IplImage结构

    一.作业要求: 采用MATLAB或opencv+C编程实现.每一题写明题目,给出试验程序代码,实验结果图片命名区分并作出效果比对,最后实验总结说明每一题蕴含的图像处理方法的效果以及应用场合等. 采用M ...

  7. OpenCV ——IplImage应用解析

    由于OpenCV主要针对的是计算机视觉方面的处理,因此在函数库中,最重要的结构体是IplImage结构.IplImage结构来源于Intel的另外一个函数库Intel Image Processing ...

  8. opencv IplImage各参数详细介绍以及如何从一个JPEG图像数据指针转换得到IplImage

    这篇文章里介绍得最清楚了.http://blog.chinaunix.net/uid-22682903-id-1771421.html 关于颜色空间  RGB颜色空间已经非常熟悉了.HSV颜色空间需要 ...

  9. [Python] python vs cplusplus

    一些学习过程中的总结的两种语言的小对比,帮助理解OO programming. Continue... 字典 序列 --> 字典 Python: def get_counts(sequence) ...

随机推荐

  1. 修复Windows10系统的注册表？

    在打开的管理员命令提示符窗口,输入如下命令: ———————————————————————————————— reg add "HKEY_LOCAL_MACHINE\SOFTWARE\Mi ...

  2. ELK(Logstash＋Elasticsearch＋Kibana)的原理和详细搭建

    一. Elastic Stack Elastic Stack是ELK的官方称呼,网址:https://www.elastic.co/cn/products ,其作用是“构建在开源基础之上, Elast ...

  3. Java中的this和super

    在Java中有两个非常特殊的变量:this和super,这两个变量在使用前都是不需要声明的.this变量使用在一个成员函数的内部,指向当前对象,当前对象指的是调用当前正在执行方法的那个对象.super ...

  4. sps和pps的简单理解记录

    最近博客写出了日记的既视感... 使用RTP传输H264的时候,需要用到sdp协议描述,其中有两项:Sequence Parameter Sets (SPS) 和Picture Parameter S ...

  5. css布局你该了解的

    记录一下: static :默认值:默认布局. fixed :固定定位:类似于absolute,但不随着滚动条的移动而改变位置. float: 给元素的float属性赋值后,就是脱离文档流,进行左右浮 ...

  6. CSS2.0中最常用的18条技巧

    一.使用css缩写 使用缩写可以帮助减少你CSS文件的大小,更加容易阅读.  具体内容请浏览:CSS常用缩写语法 二.明确定义单位,除非值为0. 忘记定义尺寸的单位是CSS新手普遍的错误.在HTML中 ...

  7. Qt Creator设置多核编译（-j8参数）

    In the qtcreator go to the "Projects tab" and set "Make arguments" as you like: ...

  8. VIM下的可视模式的相关知识

    三种可视模式: v 激活面向字符的可视模式: V 激活面向行的可视模式: ctrl+v 激活面向列块的可视模式: 选择高亮区: 上面的 v 是可以与跳转指令 以及表示范围的指令组合使用的. 如:vl, ...

  9. 第三百七十八节，Django+Xadmin打造上线标准的在线教育平台—django自带的admin后台管理介绍

    第三百七十八节,Django+Xadmin打造上线标准的在线教育平台—django自带的admin后台管理介绍 配置django的admin数据库管理后台 首先urls.py配置数据库后台路由映射,一 ...

  10. Java内存、CPU占用率过高

    windows下揪出java程序占用cpu很高的线程 并找到问题代码 死循环线程代码 linux下查找java进程占用CPU过高原因 Java 占用CPU使用率很高的分析 记一次线上Java程序导致服 ...