特征提取代码总计,才比较好

读书opencv汉语版教程——第二章

   记录cvSmooth函数的用法和 OpenCV自带的人脸检查评定。

来自http://download.csdn.net/source/3208155#acomment

装有案例,跑起来~~~但是并从未都跑起来。。。作者只把小编能跑的都尽心尽力跑了,毕竟看书照旧很生硬,能运行能出结果,才相比好。

(1)cvSmooth函数
void cvSmooth( const CvArr* src, CvArr* dst,int
smoothtype=CV_GAUSSIAN,int param1, int param2, double param3, double
param4 );
src:输入图像.
dst:输出图像.
smoothtype平滑方法
  CV_BLUR_NO_SCALE(简单不带尺度变换的模糊),对各类象素的
param一×param二 领域求和。假使邻域大小是浮动的,可以优先采用函数 cvIntegral
总结积分图像。
   CV_BLUR (simple blur)-
-对种种象素param一×param二邻域求和并做规范变换 1/(param一×param二)。
   CV_GAUSSIAN(gaussian blur) – -对图像举行核大小为 param一×param二的高斯卷积。
   CV_MEDIAN(median blur) – -对图像举办核大小为param一×param壹的中值滤波 (邻域是方的)。
   CV_BILATERAL(双向滤波) – -应用双向 三x三 滤波,彩色
sigma=param壹,空间 sigma=param二.。

特征提取代码总计

 

param1:平滑操作的首先个参数.
param2:平滑操作的第3个参数.
对于简易/非标变换的高斯模糊的事态,假诺param二的值为零,则代表其被设定为param一。
param3
  对应高斯参数的 Gaussian sigma (标准差).
假若为零,则标准差由下边包车型地铁核尺寸计算:
  sigma = (n/2 – 1)*0.3 + 0.8,
内部 n=param一 对应水平核,n=param二 对应垂直核.
  对小的卷积核 (三×三 to 7×柒) 使用如上公式所示的规范 sigma
速度会快。若是 param3 不为零,而 param一 和 param二 为零,则核大小由sigma
总计 (以确认保障丰盛精确的操作)。

水彩提取

Ø 颜色直方图提取:

Code:

 

#include <cv.h>

#include <highgui.h>

#include <iostream>

using namespace std;

 

 int main( int argc, char** argv )

{

IplImage * src= cvLoadImage(“E:\\Download\\test1.jpg”,1);

 

IplImage* hsv = cvCreateImage( cvGetSize(src), 8, 3 );

IplImage* h_plane = cvCreateImage( cvGetSize(src), 8, 1 );

IplImage* s_plane = cvCreateImage( cvGetSize(src), 8, 1 );

IplImage* v_plane = cvCreateImage( cvGetSize(src), 8, 1 );

IplImage* planes[] = { h_plane, s_plane };

 

/** H 分量划分为十四个等级,S分量划分为几个等级*/

int h_bins = 16, s_bins = 8;

int hist_size[] = {h_bins, s_bins};

 

/** H 分量的变型范围*/

float h_ranges[] = { 0, 180 }; 

 

/** S 分量的变化范围*/

float s_ranges[] = { 0, 255 };

float* ranges[] = { h_ranges, s_ranges };

 

/** 输入图像转换来HSV颜色空间*/

cvCvtColor( src, hsv, CV_BGR2HSV );

cvCvtPixToPlane( hsv, h_plane, s_plane, v_plane, 0 );

 

/** 创设直方图,2维, 各类维度上均分*/

CvHistogram * hist = cvCreateHist( 2, hist_size, CV_HIST_ARRAY, ranges, 1 );

/** 根据H,S七个平面数据计算直方图*/

cvCalcHist( planes, hist, 0, 0 );

 

/** 获取直方图计算的最大值,用于动态展现直方图*/

float max_value;

cvGetMinMaxHistValue( hist, 0, &max_value, 0, 0 );

 

 

/** 设置直方图呈现图像*/

int height = 240;

int width = (h_bins*s_bins*6);

IplImage* hist_img = cvCreateImage( cvSize(width,height), 8, 3 );

cvZero( hist_img );

 

/** 用来展开HSV到纳瓦拉GB颜色转换的方今单位图像*/

IplImage * hsv_color = cvCreateImage(cvSize(1,1),8,3);

IplImage * rgb_color = cvCreateImage(cvSize(1,1),8,3);

int bin_w = width / (h_bins * s_bins);

for(int h = 0; h < h_bins; h++)

{

for(int s = 0; s < s_bins; s++)

{

int i = h*s_bins + s;

/** 获得直方图中的总括次数,计算显示在图像中的中度*/

float bin_val = cvQueryHistValue_2D( hist, h, s );

int intensity = cvRound(bin_val*height/max_value);

 

/** 得到当前直方图表示的颜料,转换来LacrosseGB用于绘制*/

cvSet2D(hsv_color,0,0,cvScalar(h*180.f / h_bins,s*255.f/s_bins,255,0));

cvCvtColor(hsv_color,rgb_color,CV_HSV2BGR);

CvScalar color = cvGet2D(rgb_color,0,0);

 

cvRectangle( hist_img, cvPoint(i*bin_w,height),

cvPoint((i+1)*bin_w,height – intensity),

color, -1, 8, 0 );

}

}

 

cvNamedWindow( “Source”, 1 );

cvShowImage( “Source”, src );

 

cvNamedWindow( “H-S Histogram”, 1 );

cvShowImage( “H-S Histogram”, hist_img );

 

cvWaitKey(0);

}

运作效果截图:

                                                                             

 

越着急,心越慌,越是着急,越要慢,越是不熟悉,越不可能盲进。不然更便于走错路。

  没有缩放的图像平滑仅协助单通道图像,并且协理6人到1肆个人的转换(与cvSobel和cvaplace相似)和叁拾十一个人浮点数到3十三个人浮点数的变换格式。
  不难模糊和高斯模糊援救 一- 或 三-通道, 捌-比特 和 3二-比特
浮点图像。那三种办法能够(in-place)情势处理图像。
  中值和双向滤波工作于 一- 或 三-通道, 八-位图像,不过不可能以 in-place
情势处理图像。

形状提取

Ø Candy算子对边缘提取:

Code:

 

#include “cv.h”

#include “cxcore.h”

#include “highgui.h” 

int main( int argc, char** argv ) 

{

    //声明IplImage指针

         IplImage* pImg = NULL; 

    IplImage* pCannyImg = NULL; 

    //载入图像,强制转化为Gray

pImg = cvLoadImage( “E:\\Download\\test.jpg”, 0); 

//为canny边缘图像申请空间

pCannyImg = cvCreateImage(cvGetSize(pImg), IPL_DEPTH_8U, 1);

//canny边缘检测

cvCanny(pImg, pCannyImg, 50, 150, 3); 

//创立窗口

cvNamedWindow(“src”, 1);

cvNamedWindow(“canny”,1);

//彰显图像

cvShowImage( “src”, pImg ); 

cvShowImage( “canny”, pCannyImg ); 

//等待按键

cvWaitKey(0);

//销毁窗口

cvDestroyWindow( “src” ); 

cvDestroyWindow( “canny” );

//释放图像

cvReleaseImage( &pImg ); 

cvReleaseImage( &pCannyImg );

return 0;

 

运作效果截图:

 

 

 

Ø 角点提取:

Code:

 

#include <stdio.h>

#include “cv.h”

#include “highgui.h”

 

#define MAX_CORNERS 100

 

int main(void)

{

int cornersCount=MAX_COQashqaiNE逍客S;//获得的角点数目

CvPoint2D32f corners[MAX_CORNERS];//输出角点集合

IplImage *srcImage = 0,*grayImage = 0,*corners1 = 0,*corners2 = 0;

int i;

CvScalar color = CV_RGB(255,0,0);

cvNamedWindow(“image”,1);

 

//Load the image to be processed

srcImage = cvLoadImage(“E:\\Download\\1.jpg”,1);

grayImage = cvCreateImage(cvGetSize(srcImage),IPL_DEPTH_8U,1);

 

//copy the source image to copy image after converting the format

//复制并转为灰度图像

cvCvtColor(srcImage,grayImage,CV_BGR2GRAY);

 

//create empty images os same size as the copied images

//两幅权且位浮点图像,cvGoodFeaturesToTrack会用到

corners1 = cvCreateImage(cvGetSize(srcImage),IPL_DEPTH_32F,1);

corners2 = cvCreateImage(cvGetSize(srcImage),IPL_DEPTH_32F,1);

 

cvGoodFeaturesToTrack(grayImage,corners1,corners2,corners,&cornersCount,0.05,

30,//角点的纤维距离是

0,//整个图像

3,0,0.4);

printf(“num corners found: %d\n”,cornersCount);

 

//开首画出每一种点

if (cornersCount>0)

{

for (i=0;i<cornersCount;i++)

{

cvCircle(srcImage,cvPoint((int)(corners[i].x),(int)(corners[i].y)),2,color,2,CV_AA,0);

}

}

cvShowImage(“image”,srcImage);

cvSaveImage(“imagedst.png”,srcImage);

 

cvReleaseImage(&srcImage);

cvReleaseImage(&grayImage);

cvReleaseImage(&corners1);

cvReleaseImage(&corners2);

 

cvWaitKey(0);

return 0;

运作效果截图:

 

 

 

Ø Hough直线提取:

Code:

 

#include <cv.h>

#include <highgui.h>

#include <math.h>

 

int main(int argc, char** argv)

{

    IplImage* src = cvLoadImage( “E:\\Download\\2.jpg” , 0 );

    IplImage* dst;

    IplImage* color_dst;

    CvMemStorage* storage = cvCreateMemStorage(0);

    CvSeq* lines = 0;

    int i;

 

    if( !src )

        return -1;

 

    dst = cvCreateImage( cvGetSize(src), 8, 1 );

    color_dst = cvCreateImage( cvGetSize(src), 8, 3 );

 

    cvCanny( src, dst, 50, 200, 3 );

    cvCvtColor( dst, color_dst, CV_GRAY2BGR );

#if 0

    lines = cvHoughLines2( dst, storage, CV_HOUGH_STANDARD, 1, CV_PI/180, 100, 0, 0 );

 

    for( i = 0; i < MIN(lines->total,100); i++ )

    {

        float* line = (float*)cvGetSeqElem(lines,i);

        float rho = line[0];

        float theta = line[1];

        CvPoint pt1, pt2;

        double a = cos(theta), b = sin(theta);

        double x0 = a*rho, y0 = b*rho;

        pt1.x = cvRound(x0 + 1000*(-b));

        pt1.y = cvRound(y0 + 1000*(a));

        pt2.x = cvRound(x0 – 1000*(-b));

        pt2.y = cvRound(y0 – 1000*(a));

        cvLine( color_dst, pt1, pt2, CV_RGB(255,0,0), 3, CV_AA, 0 );

    }

#else

    lines = cvHoughLines2( dst, storage, CV_HOUGH_PROBABILISTIC, 1, CV_PI/180, 50, 50, 10 );

    for( i = 0; i < lines->total; i++ )

    {

        CvPoint* line = (CvPoint*)cvGetSeqElem(lines,i);

        cvLine( color_dst, line[0], line[1], CV_RGB(255,0,0), 3, CV_AA, 0 );

    }

#endif

    cvNamedWindow( “Source”, 1 );

    cvShowImage( “Source”, src );

 

    cvNamedWindow( “Hough”, 1 );

    cvShowImage( “Hough”, color_dst );

 

    cvWaitKey(0);

 

    return 0;

}

运作效果截图:

 

 

 

Ø Hough圆提取:

Code:

 

#include <cv.h>

#include <highgui.h>

#include <math.h>

#include <iostream>

 

using namespace std;

 

int main(int argc, char** argv)

{

    IplImage* img;

img=cvLoadImage(“E:\\Download\\3.jpg”, 1);

 IplImage* gray = cvCreateImage( cvGetSize(img), 8, 1 );

     CvMemStorage* storage = cvCreateMemStorage(0);

     cvCvtColor( img, gray, CV_BGR2GRAY );

     cvSmooth( gray, gray, CV_GAUSSIAN, 5, 15 );

// smooth it, otherwise a lot of false circles may be detected

CvSeq* circles = cvHoughCircles( gray, storage, CV_HOUGH_GRADIENT, 2, gray->height/4, 200, 100 );

    int i;

     for( i = 0; i < circles->total; i++ )

     {

          float* p = (float*)cvGetSeqElem( circles, i );

          cvCircle( img, cvPoint(cvRound(p[0]),cvRound(p[1])), 3, CV_RGB(0,255,0), -1, 8, 0 );

 cvCircle( img, cvPoint(cvRound(p[0]),cvRound(p[1])), cvRound(p[2]), CV_RGB(255,0,0), 3, 8, 0 );

          cout<<“圆心坐标x= “<<cvRound(p[0])<<endl<<“圆心坐标y= “<<cvRound(p[1])<<endl;

          cout<<“半径=”<<cvRound(p[2])<<endl; 

     }

     cout<<“圆数量=”<<circles->total<<endl;

     cvNamedWindow( “circles”, 1 );

     cvShowImage( “circles”, img );

     cvWaitKey(0);

  

    return 0;

}

 

运作效果截图:

 

 

 

Ø Hough矩形提取:

Code:

 

#include “cv.h”

#include “highgui.h”

#include <stdio.h>

#include <math.h>

#include <string.h>

 

int thresh = 50;

IplImage* img = 0;

IplImage* img0 = 0;

CvMemStorage* storage = 0;

CvPoint pt[4];const char* wndname = “Square Detection Demo”; 

 

double angle( CvPoint* pt1, CvPoint* pt2, CvPoint* pt0 )

{    

double dx1 = pt1->x – pt0->x; 

double dy1 = pt1->y – pt0->y;  

double dx2 = pt2->x – pt0->x;  

double dy2 = pt2->y – pt0->y;    

return (dx1*dx2 + dy1*dy2)/sqrt((dx1*dx1 + dy1*dy1)*(dx2*dx2 + dy2*dy2) + 1e-10);

CvSeq* findSquares4( IplImage* img, CvMemStorage* storage )

{  

CvSeq* contours;

int i, c, l, N = 11;  

CvSize sz = cvSize( img->width & -2, img->height & -2 );

IplImage* timg = cvCloneImage( img );

IplImage* gray = cvCreateImage( sz, 8, 1 ); 

IplImage* pyr = cvCreateImage( cvSize(sz.width/2, sz.height/2), 8, 3 );  

IplImage* tgray;   

CvSeq* result;  

double s, t;  

CvSeq* squares = cvCreateSeq( 0, sizeof(CvSeq), sizeof(CvPoint), storage );   

cvSetImageROI( timg, cvRect( 0, 0, sz.width, sz.height ));   

// down-scale and upscale the image to filter out the noise 

cvPyrDown( timg, pyr, 7 );  

cvPyrUp( pyr, timg, 7 );   

tgray = cvCreateImage( sz, 8, 1 );  

// find squares in every color plane of the image 

for( c = 0; c < 3; c++ )  

{       

cvSetImageCOI( timg, c+1 );     

cvCopy( timg, tgray, 0 );           

for( l = 0; l < N; l++ )     

{          

if( l == 0 )     

{               

cvCanny( tgray, gray, 0, thresh, 5 );        

cvDilate( gray, gray, 0, 1 );      

}           

else       

{             

cvThreshold( tgray, gray, (l+1)*255/N, 255, CV_THRESH_BINARY );

}                       

cvFindContours( gray, storage, &contours, sizeof(CvContour),CV_RETR_LIST, CV_CHAIN_APPROX_SIMPLE, cvPoint(0,0) );          

while( contours )    

{              

  result = cvApproxPoly( contours, sizeof(CvContour), storage,CV_POLY_APPROX_DP, cvContourPerimeter(contours)*0.02, 0 ); 

if( result->total == 4 && fabs(cvContourArea(result,CV_WHOLE_SEQ)) > 1000 &&  cvCheckContourConvexity(result) )  

{               

s = 0;      

for( i = 0; i < 5; i++ )  

{                   

if( i >= 2 )           

{               

t = fabs(angle( (CvPoint*)cvGetSeqElem( result, i ),(CvPoint*)cvGetSeqElem( result, i-2 ),(CvPoint*)cvGetSeqElem( result, i-1 )));   

s = s > t ? s : t;     

}         

}                                            

if( s < 0.3 )                      

for( i = 0; i < 4; i++ )              

cvSeqPush( squares,                    

(CvPoint*)cvGetSeqElem( result, i ));     

}                                      

contours = contours->h_next;      

}   

}

cvReleaseImage( &gray );   

cvReleaseImage( &pyr );  

cvReleaseImage( &tgray );  

cvReleaseImage( &timg );   

return squares;

}  

// the function draws all the squares in the image

void drawSquares( IplImage* img, CvSeq* squares )

{   

CvSeqReader reader;   

IplImage* cpy = cvCloneImage( img );   

int i;       

cvStartReadSeq( squares, &reader, 0 );     

for( i = 0; i < squares->total; i += 4 )  

{       

CvPoint* rect = pt;    

int count = 4;      

memcpy( pt, reader.ptr, squares->elem_size ); 

CV_NEXT_SEQ_ELEM( squares->elem_size, reader ); 

memcpy( pt + 1, reader.ptr, squares->elem_size );     

CV_NEXT_SEQ_ELEM( squares->elem_size, reader );   

memcpy( pt + 2, reader.ptr, squares->elem_size );   

CV_NEXT_SEQ_ELEM( squares->elem_size, reader );     

memcpy( pt + 3, reader.ptr, squares->elem_size );  

CV_NEXT_SEQ_ELEM( squares->elem_size, reader );         

cvPolyLine( cpy, &rect, &count, 1, 1, CV_RGB(0,255,0), 3, CV_AA, 0 );

}        

cvShowImage( wndname, cpy );  

cvReleaseImage( &cpy );

}

void on_trackbar( int a )

{   

if( img )    

drawSquares( img, findSquares4( img, storage ) );

}

char* names[] = { “1.jpg”, 0 };

int main(int argc, char** argv)

{    

int i, c; 

storage = cvCreateMemStorage(0);    

for( i = 0; names[i] != 0; i++ )   

{     

img0 = cvLoadImage( names[i], 1 );   

if( !img0 )    

{        

printf(“Couldn’t load %s\n”, names[i] );    

continue;     

}     

img = cvCloneImage( img0 );       

     cvNamedWindow( wndname, 1 );     

cvCreateTrackbar( “canny thresh”, wndname, &thresh, 1000, on_trackbar );     

on_trackbar(0);       

c = cvWaitKey(0);     

cvReleaseImage( &img );    

cvReleaseImage( &img0 );       

cvClearMemStorage( storage );      

if( c == 27 )       

break;   

}       

cvDestroyWindow( wndname );   

return 0;

运作效果截图:

 

 

 

Ø 边缘直方图提取:

Code:

  

#include “cv.h”

#include “highgui.h”

#include <stdio.h>

#include <ctype.h>

#define PI 3.14

 

int main()

{

    IplImage *src = 0;  // source imagre

    IplImage *histimg = 0; // histogram image 

    CvHistogram *hist = 0; // define multi_demention histogram

    IplImage* canny;

    CvMat* canny_m;

    IplImage* dx; // the sobel x difference 

    IplImage* dy; // the sobel y difference 

    CvMat* gradient; // value of gradient

    CvMat* gradient_dir; // direction of gradient

    CvMat* dx_m; // format transform to matrix

    CvMat* dy_m;

    CvMat* mask;

    CvSize  size;

    IplImage* gradient_im;

    int i,j;

    float theta;

    

    int hdims = 八;     // 划分HIST的个数,越高越规范

    float hranges_arr[] = {-PI/贰,PI/贰}; // 直方图的上界和下界

    float* hranges = hranges_arr;

                                                                                                                                                                                                                                                              

    float max_val;  // 

    int bin_w;

    

    src=cvLoadImage(“E:\\Download\\test.jpg”, 0); // force to gray image

       if(src==0) return -1;

    

    cvNamedWindow( “Histogram”, 0 );

    //cvNamedWindow( “src”, 0);

    size=cvGetSize(src);

    canny=cvCreateImage(cvGetSize(src),8,一);//边缘图像

    dx=cvCreateImage(cvGetSize(src),3二,壹);//x方向上的差分//此处的数据类型为U 不怕溢出呢?

    dy=cvCreateImage(cvGetSize(src),32,1);

    gradient_im=cvCreateImage(cvGetSize(src),3二,一);//梯度图像

    canny_m=cvCreateMat(size.height,size.width,CV_3贰FC一);//边缘矩阵

    dx_m=cvCreateMat(size.height,size.width,CV_32FC1);

    dy_m=cvCreateMat(size.height,size.width,CV_32FC1);

    gradient=cvCreateMat(size.height,size.width,CV_3贰FC一);//梯度矩阵

    gradient_dir=cvCreateMat(size.height,size.width,CV_3二FC一);//梯度方向矩阵

    mask=cvCreateMat(size.height,size.width,CV_32FC1);//掩码

 

    cvCanny(src,canny,60,180,三);//边缘检查测试

    cvConvert(canny,canny_m);//把图像转换为矩阵

    cvSobel(src,dx,壹,0,3);// 一阶X方向的图像差分:dx

    cvSobel(src,dy,0,1,三);// 1阶Y方向的图像差分:dy

    cvConvert(dx,dx_m);

    cvConvert(dy,dy_m);

    cvAdd(dx_m,dy_m,gradient); // value of gradient//梯度不是相等根号下x的导数的平方加上y导数的平方吗?

    cvDiv(dx_m,dy_m,gradient_dir); // direction

    for(i=0;i<size.height;i++)

    for(j=0;j<size.width;j++)

    {

      if(cvmGet(canny_m,i,j)!=0 && cvmGet(dx_m,i,j)!=0)//此行是怎么着看头?只看边缘上的大势?

      {

         theta=cvmGet(gradient_dir,i,j);

         theta=atan(theta);

         cvmSet(gradient_dir,i,j,theta);  

      }

      else

      {

         cvmSet(gradient_dir,i,j,0);

      }

         

    }

   hist = cvCreateHist( 1, &hdims, CV_HIST_ARRAY, &hranges, 1 );  

// 创立二个点名尺寸的直方图,并重返创设的直方图指针

   histimg = cvCreateImage( cvSize(320,200), 八, 三 ); // 创设3个图像,通道

   cvZero( histimg ); // 清;

   cvConvert(gradient_dir,gradient_im);//把梯度方向矩阵转化为图像

   cvCalcHist( &gradient_im, hist, 0, canny ); // 计算直方图

   cvGetMinMaxHistValue( hist, 0, &max_val, 0, 0 );  // 只找最大值

   cvConvertScale( hist->bins, hist->bins, max_val ? 255. / max_val : 0., 0 ); 

// 缩放bin 到区间[0,255] ,比例周详

   cvZero( histimg );

   bin_w = histimg->width /1陆;  // hdims: 条的个数,则bin_w 为条的上升幅度

    

    // 画直方图

    for( i = 0; i < hdims; i++ )

    {

       double val = ( cvGetReal1D(hist->bins,i)*histimg->height/255 );

// 重返单通道数组的钦点成分, 再次来到直方图第i条的轻重缓急,val为histimg中的i条的惊人

        CvScalar color = CV_RGB(255,255,0); //(hsv2rgb(i*180.f/hdims);//直方图颜色

        cvRectangle( histimg, cvPoint(100+i*bin_w,histimg->height),cvPoint(100+(i+1)*bin_w,(int)(histimg->height – val)), color, 1, 八, 0 ); // 画直方图——画矩形,左下角,右上角坐标

     }

    

    cvShowImage( “src”, src);

    cvShowImage( “Histogram”, histimg );

    cvWaitKey(0);

 

    cvDestroyWindow(“src”);

    cvDestroyWindow(“Histogram”);

    cvReleaseImage( &src );

    cvReleaseImage( &histimg );

    cvReleaseHist ( &hist );

    

    return 0;

}

运作效果截图:

 

 

 

Ø 录像流中边缘检查测试:

Code:

 

#include “highgui.h”

#include “cv.h”

#include “stdio.h”

#include <ctype.h> 

int main(int argc,char ** argv)

{

       IplImage * laplace = 0;

       IplImage * colorlaplace = 0;

       IplImage * planes[3] = {0,0,0};

 

       CvCapture *capture = 0;

 

      //从录像头读取

       /*if(argc == 1 ||( argc==2 && strlen(argv[1])==1 && isdigit(argv[1][0]) ))

           capture = cvCaptureFromCAM(argc == 2 ? argv[1][0] -‘0’:0);*/

       //从文件中读取

      /* else if(argc == 2)*/

           capture = cvCaptureFromAVI(“1.avi”);

       if(!capture)

       {

           fprintf(stderr,”Could not initialize capturing…\n”);

           return -1;

       }

       cvNamedWindow(“Laplacian”,1);

       cvNamedWindow(“video”,1);

       //循环捕捉,直到用户按键跳出循环体

       for(;;)

       {

            IplImage * frame =0;    //抓起1祯

            frame = cvQueryFrame(capture);

            if(!frame)

                 break;

            if(!laplace)

            {

               //制造图像

               for(int i=0;i<3;i++)

               planes[i] = cvCreateImage(cvSize(frame->width,frame->height),IPL_DEPTH_8U,1);

               laplace = cvCreateImage(cvSize(frame->width,frame->height),IPL_DEPTH_16S,1);

             colorlaplace=cvCreateImage(cvSize(frame->width,frame->height),IPL_DEPTH_8U,3);

            }

             cvCvtPixToPlane(frame,planes[0],planes[1],planes[2],0);

             for(int i=0;i<3;i++)

             {

                //交流,如通道变换

                cvLaplace(planes[i],laplace,3);

                //使用线性别变化换转换输入函数成分变为无符号整形

                cvConvertScaleAbs(laplace,planes[i],1,0);

              }

            cvCvtPlaneToPix(planes[0],planes[1],planes[2],0,colorlaplace);

            //结构同样(- 顶—左结构,① – 底—左结构)

            colorlaplace->origin = frame->origin;

           //高斯滤波,平滑图像

           // cvSmooth(colorlaplace, colorlaplace, CV_GAUSSIAN, 1, 0, 0);

           //形态学滤波,闭运算

           cvDilate(colorlaplace, colorlaplace, 0, 1);//膨胀

           cvErode(colorlaplace, colorlaplace, 0, 1);//腐蚀

           cvShowImage(“video”, frame);

           cvShowImage(“Laplacian”,colorlaplace);

           if(cvWaitKey(10)>0)

               break;

       }

       cvReleaseCapture(&capture);

       cvDestroyWindow(“Laplacian”);

       cvDestroyWindow(“video”);

       return 0;

}

运营效果截图:

 

 

 

Ø 纹理提取:

Code:

 

#include <iostream>

#include <math.h>

#include “cv.h”

#include “highgui.h”

 

int main(int argc, char* argv[])

{

int tmp[8]={0};

int sum=0;int k=0;

IplImage* img,*dst;

img=cvLoadImage(“E:\\Download\\2.jpg”,0);

CvScalar s;

cvNamedWindow(“img”,NULL);

cvNamedWindow(“dst”,NULL);

cvShowImage(“img”,img);

 

uchar* data=(uchar*)img->imageData;

int step=img->widthStep;

dst=cvCreateImage(cvSize(img->width,img->height),img->depth,1);

dst->widthStep=img->widthStep;

for(int i=1;i<img->height-1;i++)

for(int j=1;j<img->width-1;j++)

{

if(data[(i-1)*step+j-1]>data[i*step+j]) tmp[0]=1;

else tmp[0]=0;

if(data[i*step+(j-1)]>data[i*step+j]) tmp[1]=1;

else tmp[1]=0;

if(data[(i+1)*step+(j-1)]>data[i*step+j]) tmp[2]=1;

else tmp[2]=0;

if (data[(i+1)*step+j]>data[i*step+j]) tmp[3]=1;

else tmp[3]=0;

if (data[(i+1)*step+(j+1)]>data[i*step+j]) tmp[4]=1;

else tmp[4]=0;

if(data[i*step+(j+1)]>data[i*step+j]) tmp[5]=1;

else tmp[5]=0;

if(data[(i-1)*step+(j+1)]>data[i*step+j]) tmp[6]=1;

else tmp[6]=0;

if(data[(i-1)*step+j]>data[i*step+j]) tmp[7]=1;

else tmp[7]=0;

for(k=0;k<=7;k++)

sum+=abs(tmp[k]-tmp[k+1]);

sum=sum+abs(tmp[7]-tmp[0]);

if (sum<=2)

s.val[0]=(tmp[0]*128+tmp[1]*64+tmp[2]*32+tmp[3]*16+tmp[4]*8+tmp[5]*4+tmp[6]*2+tmp[7]);

else s.val[0]=59; 

cvSet2D(dst,i,j,s);

}

 

cvShowImage(“dst”,dst);

cvWaitKey(-1);

 

return 0;

}

运营效果截图:

 

 

从别处抄来的中央代码:

看了壹部分事物发现都挺坑的,然后看了看书,发现书上写的也。。。所以就把看书笔记,和跑动例程都来做多少个打点。

//邻域平均滤波
cvSmooth(pImg,pImg,CV_BLUR,3,3,0,0);        //3x3
cvSmooth(pImg,pImg,CV_BLUR,5,5,0,0);        //5x5
//中值滤波 
cvSmooth(pImg,pImg,CV_MEDIAN,3,3,0,0);      //3x3
cvSmooth(pImg,pImg,CV_MEDIAN,5,5,0,0);      //5x5
//高斯滤波
cvSmooth(pImg,pImg,CV_GAUSSIAN,3,3,0,0);    //3x3
cvSmooth(pImg,pImg,CV_GAUSSIAN,5,5,0,0);    //5x5

至于怎样布置,是首要

本身要好抄来的2个总结例子:

从而计划写在了此间:http://www.cnblogs.com/letben/p/5278595.html

#include "stdafx.h"
#include <iostream>

#pragma comment(lib,"../OpenCV-2.4.8/lib/opencv_core248d.lib")
#pragma comment(lib,"../OpenCV-2.4.8/lib/opencv_highgui248d.lib")
#pragma comment(lib,"../OpenCV-2.4.8/lib/opencv_imgproc248d.lib")

#include "../OpenCV-2.4.8/include/highgui.h"
#include "../OpenCV-2.4.8/include/cv.h"

using namespace std;
using namespace cv;


int _tmain(int argc, char *argv[]) 
{
   IplImage* img = cvLoadImage("3.jpg") ;
   cvNamedWindow("DEMO-in") ;
   cvNamedWindow("DEMO-out") ;
   cvShowImage("DEMO-in",img) ;

   IplImage* out = cvCreateImage(cvGetSize(img), IPL_DEPTH_8U, 3) ;

   cvSmooth(img, out, CV_MEDIAN, 3, 3) ;

   cvShowImage("DEMO-out", out);

   cvReleaseImage( &out ) ;

   cvWaitKey( 0 ) ;
   cvDestroyWindow("DEMO-in") ;
   cvDestroyWindow("DEMO-out") ;

   return 0;
}

 

(2)OpenCV自带的人脸检查测试
代码:

然后是看书又看回到了那本学习opencv的反动装帧书上。

#include "stdafx.h"
#include <stdio.h> 
#include <stdlib.h> 
#include <assert.h> 
#include <math.h> 
#include <float.h> 
#include <limits.h> 
#include <time.h> 
#include <ctype.h>

#include <opencv2\opencv.hpp>
#include <iostream>
#include <string>
using namespace cv;
using namespace std;

#ifdef _EiC 
#define WIN32 
#endif

static CvMemStorage* storage = 0; 
static CvHaarClassifierCascade* cascade = 0;

void detect_and_draw( IplImage* image );

const char* cascade_name = 
"haarcascade_frontalface_alt.xml"; 
/*    "haarcascade_profileface.xml";*/

int main( int argc, char** argv ) 
{ 
    cascade_name = "haarcascade_frontalface_alt.xml"; 
    cascade = (CvHaarClassifierCascade*)cvLoad( cascade_name, 0, 0, 0 ); 

    if( !cascade ) 
    { 
        fprintf( stderr, "ERROR: Could not load classifier cascade\n" ); 
        return -1; 
    } 
    storage = cvCreateMemStorage(0); 
    cvNamedWindow( "result", 0 ); 

    const char* filename = "2.jpg"; 
    IplImage* image = cvLoadImage( filename, 1 );

    if( image ) 
    { 
        detect_and_draw( image ); 
        cvWaitKey(0); 
        cvReleaseImage( &image );   
    }

    cvDestroyWindow("result"); 

    return 0; 
}


void detect_and_draw(IplImage* img ) 
{ 
    double scale=1.2; 
    static CvScalar colors[] = { 
        {{0,0,255}},{{0,128,255}},{{0,255,255}},{{0,255,0}}, 
        {{255,128,0}},{{255,255,0}},{{255,0,0}},{{255,0,255}} 
    };//Just some pretty colors to draw with

    //Image Preparation 
    // 
    IplImage* gray = cvCreateImage(cvSize(img->width,img->height),8,1); 
    IplImage* small_img=cvCreateImage(cvSize(cvRound(img->width/scale),cvRound(img->height/scale)),8,1); 
    cvCvtColor(img,gray, CV_BGR2GRAY); 
    cvResize(gray, small_img, CV_INTER_LINEAR);

    cvEqualizeHist(small_img,small_img); //直方图均衡

    //Detect objects if any 
    // 
    cvClearMemStorage(storage); 
    double t = (double)cvGetTickCount(); 
    CvSeq* objects = cvHaarDetectObjects(small_img, 
        cascade, 
        storage, 
        1.1, 
        2, 
        0/*CV_HAAR_DO_CANNY_PRUNING*/, 
        cvSize(30,30));

    t = (double)cvGetTickCount() - t; 
    printf( "detection time = %gms\n", t/((double)cvGetTickFrequency()*1000.) );

    //Loop through found objects and draw boxes around them 
    for(int i=0;i<(objects? objects->total:0);++i) 
    { 
        CvRect* r=(CvRect*)cvGetSeqElem(objects,i); 
        cvRectangle(img, cvPoint(r->x*scale,r->y*scale), cvPoint((r->x+r->width)*scale,(r->y+r->height)*scale), colors[i%8]); 
    } 
    for( int i = 0; i < (objects? objects->total : 0); i++ ) 
    { 
        CvRect* r = (CvRect*)cvGetSeqElem( objects, i ); 
        CvPoint center; 
        int radius; 
        center.x = cvRound((r->x + r->width*0.5)*scale); 
        center.y = cvRound((r->y + r->height*0.5)*scale); 
        radius = cvRound((r->width + r->height)*0.25*scale); 
        cvCircle( img, center, radius, colors[i%8], 3, 8, 0 ); 
    }

    cvShowImage( "result", img ); 
    cvReleaseImage(&gray); 
    cvReleaseImage(&small_img); 
}

初试牛刀——展现图像

  
那其实是个Haar特征的级联分类器,haarcascade_frontalface_alt.xml那个文件存的应有是正脸的Haar特征数据(估量的,未有研究过,欢迎拍砖指正),这些文件是OpenCV自带的,使用的时候拷贝到自个儿的工程面即可。该多少被加载到static
CvHaarClassifierCascade* cascade变量,由detect_and_draw(IplImage*
img ) 函数里面包车型大巴cvHaarDetectObjects函数来贯彻人脸的检验。

 

例2-1

#include "highgui.h"//1、

int main(int argc,char **argv){ //2、
    IplImage* img = cvLoadImage(argv[1]);//3、
    cvNamedWindow("Example1", CV_WINDOW_AUTOSIZE);//4、
    cvShowImage("Example1", img);//5、
    cvWaitKey(0);//6、
    cvReleaseImage(&img);//7、
    cvDestroyWindow("Example1");//8、
}

 

 

一、高级GUI图像用户界面,包涵媒体的输入输出,录制捕捉,图像视频的编解码,图形交互界面的接口。GUI:Graphical User Interface 图形用户界面(接口)

2、这一个顺序照旧讲求有早晚的C++基础的,比如最起码要明了主函数是干什么的?怎么用自家回想在此以前在一片博文里面涉及过,第6个参数是,在命令行里面,到底键入了多少个字符组,第1个参数用来收获每一种字符串的剧情。关于详细能够看下那篇小说
http://www.cnblogs.com/letben/p/5229933.html 里面简单说了瞬间参数的动静

3、若是能领略主函数的参数情况,那么在命令行里面键入 :opencv教程——展现图像 1.png 。个中第2个参数要想体现的话是:argv[0]如果cout<<argv[0]将会是“opencv教程——展现图像”,所以argv[1] 是 “一.png”所以上边一起也给了三个目录结构,为了能在当前目录里面找到一.png那张图纸。假若找到的话,就加载那张图片,并且把图像消息赋给img。

四、创设2个窗口,命名称叫“Example一”,关于大小是自适应内容大小的,也正是图像内容有多大,大家的窗口就建立多大,以刚好存放大家要出示的剧情此时已窗口不可再变动。可选参数有0.当设置为0的时候,窗口大小能够拖动,比较相符大家壹般选拔照片查看器的习惯,那里供给读者尝试那七个参数

伍、呈现图片函数,把大家的img图片放到刚刚成立好的“Example一”里面

陆、等到用户操作,键入字母后,程序甘休。此参数大于0时,比如4000,指的是在四千微秒后,程序停止。小于等于0时意味着等待用户操作。

7、释放图片占用内部存款和储蓄器

捌、释放窗口占用相关能源。

 图片 1

命令行:

图片 2

图片 3

例2-2播放avi视频

#include "highgui.h"

int main(int argc,char **argv){

    cvNamedWindow("Example2", CV_WINDOW_AUTOSIZE);
    CvCapture* capture = cvCreateFileCapture(argv[1]);//1、
    IplImage* frame;//2、
    while (1){//3、
        frame = cvQueryFrame(capture);//单帧图像赋值,
        if (!frame) break;//如果单帧图像没有值,为真,就退出
        cvShowImage("Example2", frame);
        char c = cvWaitKey(33);//在33毫秒内等待用户输入 字符。
        if (c == 27) break;//如果该字符是 ESC-> 27 的话,就退出
    }
//8、
    cvReleaseCapture(&capture);
    cvDestroyWindow("Example2");

}

 

一、同例1的“三、”1样,那当中是从用户输入的地方获得贰个录像的指标,因为是录像之所以接受格局不可能再是IplImage了,此番改成 指向CvCapture类型的 变量 capture,那是二个打包好的对象,能够动用cvQueryFrame()获得单帧图像。

二、声惠氏(Karicare)个图片类型的变量

三、从摄像对象里面获得的单帧图像传送给当下三个frame

四、假诺frame为空就淡出

五、能履行到此地表明frame不为空,也等于可以显示把当下图像予以呈现,

陆、每张图片等候3三微秒,他能回去用户键入的字符,

7、若是字符是键盘上的ESC的话,就退出。

 

八、释放 录制窗口财富。

 

想壹想:cvWaitKey()里面包车型大巴参数有何样用处?设置成1、50、100来评释你的想法。

例2-三录制播放控制

骨子里早先以为人家书写的挺好的。可是从此处就从头觉得坑了,不理解是写的不咋地,依旧翻译的不密切,同理可得开始蒙受了部分讲不驾驭的点了。然后就本人试,平昔到代码能跑。。。

接下来那里希望把能跑的代码分享出去,也好不不难对团结上学进度的2个记录,从前都看过不少东西只是都忘了。。。以后开端养成记录的习惯,1旦本身忘了,能够还原看看,假如还能够对别人有所帮忙,那就再好但是。

#include "cv.h"//1、
#include "highgui.h"

int g_slider_position = 0;//2、
CvCapture* g_capture = NULL;//3、这句话能通过需要 目录在 include下面。

void onTrackbarSlide(int pos){//4、
    cvSetCaptureProperty(g_capture,CV_CAP_PROP_POS_FRAMES,pos);//5、
}
//如何实现反向的显示,就是 视频播放中,改变滚动条的位置。
int main(int argc,char** argv){

    cvNamedWindow("Example3", CV_WINDOW_AUTOSIZE);
    g_capture = cvCreateFileCapture(argv[1]);
    int frames = (int)cvGetCaptureProperty(g_capture, CV_CAP_PROP_FRAME_COUNT);//6、

    if (frames != 0){//7、
        cvCreateTrackbar("Position", "Example3", &g_slider_position, frames, onTrackbarSlide);
    }

    IplImage* frame;
    while (1){
        frame = cvQueryFrame(g_capture);
        if (!frame) break;
        cvShowImage("Example3", frame);
        char c = cvWaitKey(33);
        if (c == 27)break;

        //8、反向显示
        //g_slider_position = cvGetCaptureProperty(g_capture, CV_CAP_PROP_POS_FRAMES);
        //cvSetTrackbarPos("Position", "Example3", g_slider_position);

    }
    cvReleaseCapture(&g_capture);
    cvDestroyWindow("Example3");
}

一、此番包涵的头多了1个,那几个是opencv 首个版本留下的精髓,与他壹同留下来的还有其余11个文件,那几个是里面最大的3个有4KB。其余的都以三KB还有二个是一KB【http://i.cnblogs.com/Files.aspx
能够到那么些里面下载MyLittleFindy,然后键入目录 以及cv.h 来探望那个新闻。】

二、那一个是滑动地方,假诺不举行反向呈现,这几个参数未有用。这也是自家开头不欣赏那套教程的原由。

三、把它提议来是为着非主函数内可用,以为大家还有参数要选用这么些 录制捕捉
对象。

四、那是三个函数,当我们双击这么些地点的时候,发现七里面,用了这一个函数,可是采纳方法跟我们原先的艺术不大学一年级样。函数的应用相应被传送参数,可是那当中就唯有1个函数名,也正是当下函数的指针,那种方法叫做
回调函数,即,把多个函数的地址作为其余一个顺序的参数字传送进来的办法。个中有三个角色3个是主调函数,此外贰个是回调函数。主调函数中有回调函数的函数名,回调函数正是大家平常意义上的3个函数,只可是当它的应用是以函数地址情势出现的时候,就被号称回调函数。参考

http://www.cnblogs.com/letben/p/5225521.html

本条里面 onTrackbarSlide
便是回调函数了。

5、设置录像参数,第叁个是意味着当前录像,CV_CAP_PROP_POS_FRAMES:有太多的不理解,就是这一个不知道,指的是:总计机视觉_视频_参数_位置_帧数,地点,地点是传递进入的参数

6、那一行比较浅显:总帧数 =
总计机视觉得到摄像参数(当前录像,摄像总帧数)

7、cvCreateTrackbar(“Position”, “Example3”, &g_slider_position,
frames, onTrackbarSlide);主调函数,由她调用回调函数 Position是决定条的名目,example叁 是窗口的名目,控制条的发端位置,那里运用引用依然相比有效的,frames是总帧数,函数地址。

8、由读者本身着想,那怎么思虑那几个参数、函数都不曾介绍啊。。。

 

例二-4 平滑处理

图像平滑:杰出图像的宽大区域、低频成分、主干部分或抑制图像噪声和干扰高频成分的图像处理措施,用以完毕亮度平缓渐变,减小突变梯度,改良图像品质。常见的图像平滑法有1、差值平滑方法;二、线性温滑方法;三、卷积法等 方法的选选择决于噪声连串比如境遇椒盐噪声 可应用线性温滑方法。

 

下一场是那么些调用不了啊。。。

于是 就控制把它调用起来:

#include "highgui.h"
#include "cv.h"

using namespace std;

void example2_4(IplImage *img){

    cvNamedWindow("Example4-in");
    cvNamedWindow("Example4-out");
    cvShowImage("Example4-in",img);
    IplImage * out = cvCreateImage(cvGetSize(img), IPL_DEPTH_8U, 3);//1、
    cvSmooth(img, out, CV_GAUSSIAN,1,31);//2、
    cvShowImage("Example4-out", out);
    cvReleaseImage(&out);
    cvWaitKey(0);
    cvDestroyAllWindows();
}


int main(int argc,char **argv){
    IplImage* img = cvLoadImage(argv[1]);
    example2_4(img);
}

前边的出色读了,默写两遍,前边的就用已知凑就能够了,然后再有零星阿尔巴尼亚语的底稿,最起码不难的单词像这种
release destroy smooth,然后前面包车型客车先后精通起来就很简单了。

因此到了此地必要解释的应该就一跟二了。

一、创设图片,首先要求创造图片的图片大小,然后是图像的深度音讯,那几个是5位的。平常都是六人的,8人刚好用来代表从0-25伍,刚好是用来表示颜色的深浅。rgb三色都以从0-255,0-255,0-25伍。接下来是三,三意味通道,rgb三个通道,要是是灰度图的话是一.唯有黑白。rgb是多少个颜色。所以是三个通道。那样那个out便是跟原图片相同大,深度为七个人,三大路的图形底子。

2、cvSmooth(img, out,
CV_GAUSSIAN,一,31);总括机视觉平滑(输入的图样,输出的图样,选取总结机视觉_高斯方式,横向模糊,纵向模糊);

经济检察测这几个数值都只可以是奇数。估计借使模糊当前点的话,偶数点数相当,奇数的话,就足以知足当下点左右,上下。并不知道1个点是怎么处理的。那里书上给的是叁,3

例二-伍利用cvPryDown()创设1副宽度和惊人为输入图像相似尺寸的图像

 

#include "highgui.h"
#include "cv.h"

IplImage* dopyrDown(IplImage* in,int filter = IPL_GAUSSIAN_5x5){

    assert(in->width % 2 == 0 && in->height % 2 == 0);
    IplImage* out = cvCreateImage(cvSize(in->width / 2, in->height / 2), in->depth, in->nChannels);
    cvPyrDown(in, out);
    return (out);

}

int main(int argc, char **argv){
    IplImage* img = cvLoadImage(argv[1]);
    cvNamedWindow("Example5-in");
    cvShowImage("Example5-in", img);
    IplImage* img1 = dopyrDown(img);

    cvNamedWindow("Example5");
    cvShowImage("Example5", img1);
    cvReleaseImage(&img1);

    cvWaitKey(0);
    cvDestroyAllWindows();
}

 

//多多使用 F12按键 和‘ctrl’+‘-’读作contrl 和减号。F1二用来向下询问函数的宣示大概定义,前边的组合键用以重临到上1层。

/*

   Smoothes the input image with gaussian kernel and then down-samples
it.

   dst_width = floor(src_width/2)[+1],

   dst_height = floor(src_height/2)[+1]

*/

接下来就意识那是向下模糊的章程,它用来将输入的图形应用高斯内核平滑,然后向下采集样品。

 

看样子他的孪生四嫂:

/*

   Up-samples image and smoothes the result with gaussian kernel.

   dst_width = src_width*2,

   dst_height = src_height*2

*/

CVAPI(void)  cvPyrUp( const CvArr* src, CvArr* dst,

                      int filter CV_DEFAULT(CV_GAUSSIAN_5x5) );

尝试采纳这么些函数,让函数能跑起来。大家选取的doPryDown() 把原图缩减为二分之一,然后利用五*伍的章程开始展览高斯模糊,未来选拔 doPryUp() 把原图扩张扩充1倍,然后开始展览模糊。

 

啊,那里assert忘了说了,就是1种硬设定,须要她是个什么样怎么体统,那么些在junit里面看到过,用来进展单元测试。在那个中强硬令输入图片的宽和高均能被二整除,然后缩放才有意义

 

练习:新建1个doPryUp()函数完毕上述功用。

勤学苦练答案:

IplImage* doPyrUp(IplImage* in, int filter = IPL_GAUSSIAN_5x5){

    IplImage* out = cvCreateImage(cvSize(in->width * 2, in->height * 2), in->depth, in->nChannels);
    cvPyrUp(in, out);
    return (out);

}

练习2-6

canny边缘检查评定将出口写入叁个单通道(灰度级)图像

 

#include "highgui.h"
#include "cv.h"
using namespace std;

IplImage* doCanny(IplImage* in,double lowThresh,double highThresh,double aperture){
    assert(in->nChannels = 1);
    if (in->nChannels != 1){
        cout << in->nChannels << endl;
        cout << "不能输出" << endl;
        return 0;
    }
    IplImage* out = cvCreateImage(cvGetSize(in), IPL_DEPTH_8U, 1);//原书这里绝对有问题。
    cvCanny(in, out, lowThresh, highThresh, aperture);
    return out;


}
int main(int argc,char **argv){
    IplImage* img = cvLoadImage(argv[1]);
    cvNamedWindow("Example5");
    cvShowImage("Example5", img);

    IplImage* img1 = cvCreateImage(cvGetSize(img),IPL_DEPTH_8U,1);
    cvConvertImage(img, img1, CV_BGR2GRAY);//这个在 cv.h 包里面
    IplImage* out = doCanny(img1, 10, 100, 3);
    cvNamedWindow("Example5-out");
    cvShowImage("Example5-out", out);
    cvReleaseImage(&out);
    cvWaitKey(0);
    cvDestroyAllWindows();

}

我们曾经主导熟稔了那一个内容,所以以后要从难点名称动手,来化解那一个标题,正是告诉你有四个canny能够做边缘检查评定。

下一场把那几个canny敲出来,坐等它补全参数,只怕先遵照书上的剧情把参数补全,然后最要害的是按F12进去。

接下来你发现了:

/****************************************************************************************\

*                                  Feature detection
                                    *

\****************************************************************************************/

 

/* Runs canny edge detector */

CVAPI(void)  cvCanny( const CvArr* image, CvArr* edges, double threshold1,

                      double threshold2, int  aperture_size
CV_DEFAULT(3) );

为此他们是用来做特征点检查评定的,下边还有荒漠多的别样函数,那应该也是做特征点检查实验的。先结合大家的例子知道这么些东西是干嘛的可比重大:

cvCanny(in, out, lowThresh, highThresh, aperture);

作者们为了把这一个函数跑起来,做了七个doCanny,以下函数评释:

IplImage* doCanny(IplImage* in,double lowThresh,double
highThresh,double aperture)

out是用来输出的图样指针。

/*

输入了3个图形参数 和3个double类型的参数,具体的大概要探望canny参数的贯彻进程。然后那么些就相比往下抠了:F:\opencv249\opencv\sources\modules\imgproc\src去这几个里面找到canny.cpp用个怎么着的开辟以往就能够看人家怎么落到实处的了,然后就需求依赖1些文献,以搞清种种地点都以为什么用的。那一个其实就是算法,算法的目标正是检查实验边缘,算法的贯彻正是那几个事物,要想看驾驭看文献。然后正是所谓的算法优化了,笔者就真特么操蛋,1进去某商店问您会算法么?是金盏银台数么?~依然Mason素数?随便搞一个小学生的数学题都亟待很强的算法才能做出来。化解的标题不等同,难题的小圈子分歧等,想难题的方法不平等,要怎么才能把“会”字说出口?就跟问你会起火1样么?好比你很会做饭了,可是以往要你去中华人民共和国做饭,当然你会的是米利坚的各类几分熟牛排的做法,去了中中原人民共和国,生的倒霉吃,要不没味儿,要不吃不惯要不太硬了,要不咬不动,你认为你还有被应用的股票总市值么?未有呀!你只会美利哥的那套做饭情势,中夏族民共和国没人吃,你那算法没人用。只怕千篇一律是边缘检验,算法优化的壹种是从算法自个儿上优化,还有一种正是一贯丢掉那种所谓的canny格局,直接换了主意。所以关于面试题你会不会算法,你能够算法优化么几乎特么的。对于那种题材只好说供给时间,并且作者原先做过如何的算法实现了如何的优化。再牛逼的算法就须求灵感了。好了
作者即是黑马想起来吐个槽。特么的。

 

既然来了这几个canny里面那么一定还有不少别样的检验方法。能够选用任何的特征点检查测试方法看看结果:笔者看到了
cvCorner哈Rees 试试它是何许利用的。哈哈
并没试出来,不太早晚是有办法弄的,大概是有些点不太符合规范,可想而知如故要快一些叩问整个框架,所以不用扣这么太细。

 

*/

 

canny要求输入图片时单通道的,并且只要不是就冷酷转换来单通道的assert(in->nChannels = 一);所以创造的不贰秘籍是在输入的时候就给2个单通道的图形。

通过

IplImage* img1 = cvCreateImage(cvGetSize(img),IPL_DEPTH_8U,1);

创建图片,大小,深度音信伍个人,单通道。

cvConvertImage(img, img1, CV_BGR2GRAY);

把彩图转换到灰图。

下一场传入。

始建输出图片音信。

IplImage* out = cvCreateImage(cvGetSize(in), IPL_DEPTH_8U, 1);

大小,深度,单通道

做canny传递参数,今后还不通晓这么些参数是怎么用的,由此可知传对了先跑起来加以。

下一场看看效果,然后调参数看看每种参数具体对应什么结果。

 

后边那多少个相比较坑,感觉根本都没说理解。不过至于函数调用也不应该是在此处学的。优化,也不在那里开始展览了,往下看是从录像机读入数据:

例2-9:

 

#include "highgui.h"

int main(int argc,char ** argv){

    CvCapture* capture;

    if (argc == 1){
        capture = cvCreateCameraCapture(0);
    }
    else{
        capture = cvCreateFileCapture(argv[1]);
    }

    assert(capture != NULL);
    cvNamedWindow("Example6", CV_WINDOW_AUTOSIZE);

    IplImage* frame;
    while (1){
        frame = cvQueryFrame(capture);//单帧图像赋值,
        if (!frame) break;//如果单帧图像没有值,为真,就退出
        cvShowImage("Example6", frame);
        char c = cvWaitKey(33);//在33毫秒内等待用户输入 字符。
        if (c == 27) break;//如果该字符是 ESC-> 27 的话,就退出

        //按住ESC是正确终止,按 ctrl+c的效果反而不大好。
    }
    cvReleaseCapture(&capture);
    cvDestroyWindow("Example6");

}

 

经过参数能够发现cvCreateCameraCaptrue(0)是打开录像头

cvCreateFileCapture(路径)
是开拓录像文件。

 

下一场是那些备受诟病的

例二-拾三个完好无损的顺序用来达成读入一个伍彩缤纷录制文件并以灰度格式输出这么些录像文件

自家出口了有点次都是贰个很坑爹的。。。效果,起头对logpolar无感,越读越感觉polar是极点的意味,然后抄了二回之后,得到了二个结出,眨眼之间间觉得这么些怎么特么的是极坐标啊。

所以假如标题是毋庸置疑的:也正是读入3个花团锦簇摄像灰度输出的话:

#include "highgui.h"
#include "cv.h"

int main(int argc,char **argv){
    //得到视频
    CvCapture *capture = 0;
    capture = cvCreateFileCapture("F:\\opencv练习代码\\opencv教程7——写入avi文件\\Debug\\n.mp4");  //得到路径显示图像
    if (!capture)
        return -1;
//从capture里面得到每一帧的图像
    IplImage *bgr_frame = cvQueryFrame(capture);//通过视频得到图像
    double fps = cvGetCaptureProperty(capture, CV_CAP_PROP_FPS);//帧率,就是一个函数用以得到视频的实行,这里面得到的是fps
/*什么是fps
http://baike.baidu.com/link?url=Z1KZNXGP-UB05rJOsom0bv-VDOYG2v6-dylVHBZ8Eo22Vy_klv6GdSo0H3SYfSD5hmCkM2hNQB0gdFmBlTvKM_
*/
    CvSize size = cvSize(
        (int)cvGetCaptureProperty(capture, CV_CAP_PROP_FRAME_WIDTH),
        (int)cvGetCaptureProperty(capture, CV_CAP_PROP_FRAME_HEIGHT));
    CvVideoWriter *writer = cvCreateVideoWriter("D:\\b.avi", CV_FOURCC('M', 'J', 'P', 'G'), fps, size,0);//这里0是灰图,1是彩图。所以不写时候就按默认的1进行处理,然后再写彩图就写不出来。路径,编码格式,帧率,单张frame大小,按灰图输出。
    IplImage* logpolar_frame = cvCreateImage(size, IPL_DEPTH_8U, 1);

    while ((bgr_frame = cvQueryFrame(capture)) != NULL)
    {//这个写法还是比较经典的,在字符流的部分讲述比较多。

        cvCvtColor(bgr_frame,logpolar_frame,CV_BGR2GRAY);//转换成灰图

        cvWriteFrame(writer, logpolar_frame);//写入到输出文件

    }
//释放资源
    cvReleaseVideoWriter(&writer);
    cvReleaseImage(&logpolar_frame);
    cvReleaseCapture(&capture);

    return 0;

}

书上的代码应该是不错的。写出来是比照极坐标弄出来的扭曲的录像文件。

 

习题:

只怕那么些书的面世确实是第三版。因为从没习题1的opencv.sln…

 

所以从第1题早先做呢:

下一场找了半天,也没找到那个 所谓的lkdemo.c,所以一定了那本书的产出时机应该是第3版本,并且未有持续优化,F:\opencv249\opencv\sources\samples\cpp在这一个路子上边找到

lkdemo.cpp,然后打开复制全文,到vs20一叁内部新建筑工程程,项目,粘贴,然后根据大家那篇博文开篇地方的配制方法,配置包涵目录,
库目录,链接器里面包车型地铁链接加载项,然后就好了。然后编写翻译,出现结果。

 

3、四大抵是一个题了,依照大家如今默写的觉得,最起码要能自个儿把这个注释写出来,本身写贰个计算,然后3四题就能比较容易的写出来了。

 

以此并不能够缩放,应该是还有何样点,未有分析透彻。可能是有怎么样函数不太精晓。

第四题并不曾做出来。

#include "highgui.h"
#include "cv.h"

int main(int argc ,char **argv){

    CvCapture *capture = cvCreateCameraCapture(0);
    IplImage* frame;
    CvSize size = cvSize(
        (int)cvGetCaptureProperty(capture, CV_CAP_PROP_FRAME_WIDTH) / 2,
        (int)cvGetCaptureProperty(capture, CV_CAP_PROP_FRAME_HEIGHT) / 2);
    CvVideoWriter* writer = cvCreateAVIWriter(argv[1], 6, 24, size);//后面还有一个参数,1是彩图,0是灰图。默认彩图
    cvNamedWindow("Example6", CV_WINDOW_AUTOSIZE);

    while (1){
        frame = cvQueryFrame(capture);
        cvWriteFrame(writer, frame);
        cvShowImage("Example6", frame);
        char c = cvWaitKey(33);//在33毫秒内等待用户输入 字符。事实上小于41.67都是流程的,
        if (c == 27) break;
    }

    cvReleaseVideoWriter(&writer);
    cvReleaseImage(&frame);
    cvDestroyAllWindows();
    //cvReleaseCapture(&g_capture);
    //感觉程序没有正常结束啊。
    //还好 总之视频是关掉了的。
    return 0;
}

 

 

 

相关文章