精华内容
下载资源
问答
  • I am using openCV to capture video from camera and store to and avi file, the problem is that when i finish capturing and run the avi file, the video stream looks awkwardly fast...here is the codevoid...

    I am using openCV to capture video from camera and store to and avi file, the problem is that when i finish capturing and run the avi file, the video stream looks awkwardly fast...

    here is the code

    void main( )

    {

    CvCapture *capture = cvCaptureFromCAM( 0 );

    int width = ( int )cvGetCaptureProperty( capture, CV_CAP_PROP_FRAME_WIDTH );

    int height = ( int )cvGetCaptureProperty( capture, CV_CAP_PROP_FRAME_HEIGHT );

    CvVideoWriter *writer = cvCreateVideoWriter( "myCamCapture.avi",

    -1,30, cvSize( width, height ) );

    cvNamedWindow("d", CV_WINDOW_AUTOSIZE);

    IplImage *frame = 0;

    while( 1 )

    {

    frame = cvQueryFrame( capture );

    cvShowImage("d",frame);

    cvWriteFrame( writer, frame );

    char c = cvWaitKey( 33 );

    if( c == 27 ) break;

    }

    cvReleaseCapture( &capture );

    cvReleaseVideoWriter( &writer );

    cvDestroyWindow( "d" );

    }

    please help

    解决方案

    You're telling the writer that it should play at 30 frames per second. So if you're actually capturing, say, 15 frames per second, those frames are going to be played back faster than than real time.

    Showing the captured image, waiting for a keypress, and writing it to the file all take time. You need to account for that. You might try capturing the video up-front, measuring the actual FPS while it happens, and then writing your AVI using that value.

    展开全文
  • 处理器:E3 1230,基于opencv3.0官方源码编译版本(自带IPP加速) 输入数据 1000*1000 矩阵 测试方法:连续运行10000次,取平均值 规律:尽量使用浮点数据进行处理,因为函数处理前会先转为浮点类型,该操错也耗时...

    处理器:E3 1230,基于opencv3.0官方源码编译版本(自带IPP加速)

    输入数据 1000*1000 矩阵

    测试方法:连续运行10000次,取平均值

    规律:尽量使用浮点数据进行处理,因为函数处理前会先转为浮点类型,该操错也耗时

     

    1、寻找大值最小值

     

    minMaxLoc

    对于CV_32F类型,0.25ms,输入整型数据会大大增加耗时

    耗时基本可以忽略

     

    2、积分图

     

    integral

    对于CV_32F类型,6ms,若为整型数据耗时稍低

     

    3、高斯滤波

     

    GaussianBlur

    对于CV_32F类型,1.4ms

    对于CV_16U类型,7.5ms

    对于CV_8U类型,1.3ms

    耗时明显受矩阵大小的影响

     

    4、矩阵翻转函数

     

    flip

    对于CV_16U, 0.12ms,对于浮点会慢一些

     

    耗时基本可以忽略

     

    5、图像旋转

     

     
    1. getRotationMatrix2D

    2. warpAffine

    getRotationMatrix2D基本不耗时

     

    warpAffine对于CV_16U,2.6ms,对于浮点,1.9ms

     

    7、图像(矩阵)数据类型转换

     

    convertTo

    CV_32F转CV_16U, 0.2ms

     

    CV_16U转CV_32F, 0.2ms

    速度不算很慢,但前提是转换前和转换后的矩阵已经创建好(一个CV_32F的Mat和一个CV_16U的Mat,大小均为1000*1000)

     

    通过循环和指针遍历每一个像素并强制类型转换的耗时:

    CV_32F转CV_16U, 0.5ms

    CV_16U转CV_32F, 0.4ms

     

    可见,convertTo方法是经过优化的(IPP),即使实际中是一个数组(动态数组)也可以通过convertTo方法间接提高速度

     

    8、数据块拷贝

     

    memcpy

    ushort,0.1ms

     

    float,0.3ms

    耗时基本可以忽略

     

    9、矩阵运算

    数据类型为float

    如,矩阵减法

     

    subtract

    0.3~0.5ms

    通过循环和指针遍历每一个像素并作减法的耗时:0.3ms

    可见,使用库函数反而慢了

    还有一点值得注意:遍历矩阵的循环内部,尽量不要加入分支结构(if、switch)这样会大大增加耗时


    如,矩阵乘法

    multiply,对于in-place操作,1.2ms

    而遍历,0.18ms

    注意,相乘尽量采用

     

    a *= factor

    的形式,比

     

    a = a * factor

    要快

    还有一种方式是矩阵乘上一个常数,如

     

     
    1. Mat a;

    2. a *= 10;

    虽然速度优于使用multiply函数,但如果常数是浮点数,会比整数慢,且没有遍历的方式快

     

    结论:如果算法实时性要求高(达到ms级),则尽量采用遍历方式进行矩阵运算

    展开全文
  • 对Matlab、OpencvOpencv+GPU不同平台图像滤波的效率进行了对比,并给出响应的源代码和对比结果,结果表明Opencv+GPU平台对图像滤波效率最高,后面依次是Opencv、Matlab。

             本实验是在win7 64位操作系统下测试,软件版本信息如下:Visual Studio2010、matlab2010a、opencv2.4.9。要使用opencv中的GPU模块,必须先对opencv利用cmake进行从新编译,具体步骤见网友贴吧http://tieba.baidu.com/p/3329042929。

            实验内容是对一张300*400的灰度图(程序中对原图转灰度图)片进行11*11的DCT变换,一共有121个11*11DCT模版。每个模版对应11*11个不同频域值的系数,因为11*11的图像进行DCT离散变换会产生11*11个离散频域值,每个值都由对应的11*11尺寸的DCT模版来滤波求得。实验对这个过程重复20次,然后求平均值得到300*400的图片进行11*11DCT扫描滤波所需要的时间。下面实验采用的图片:


    现在分别给出matlab、opencv、opencv+GPU、C语言自己编写滤波代码条件下的测试结果和源代码。

    不同平台测试结果
     Matlab         Opencv      Opencv+GPU编写C语言函数
    Debug775.3ms1.1216s88.3ms太长
    Release 368.2ms82.3ms10.7966s




    matlab平台

    下面是matlab测试代码

    余弦滤波器产生函数,尺寸为11*11,一共121个

    function d = DctFilter(size)
    % Generates Dct filters.
    for u=1:size
        for v=1:size
            for i=1:size
                for j=1:size
                    pu=sqrt(2/size);
                    pv=sqrt(2/size);
                    if u==1
                        pu=sqrt(1/size);
                    end
                    if v==1
                        pv=sqrt(1/size);
                    end
                    d(u,v,i,j)=pu*pv*cos((i-0.5)*pi/size*(u-1))*cos((j-0.5)*pi/size*(v-1));
                end
            end
        end
    end
    end
    matlab主函数

    I=imread('te.jpg');
    I=rgb2gray(I);
    I=double(I);
    dct_filter=DctFilter(11);
    t=zeros(20,1);
    for n=1:20
    tic
    for p=1:11
        for q=1:11
            tmp=conv2(I,squeeze(dct_filter(p,q,:,:)),'valid');              
        end
    end        
    t(n)=toc;
    end
    time=sum(t)/20
    实验结果表明对300*400图片进行模版尺寸为11*11扫描滤波时每次耗时775.3ms

    opencv平台
    利用opencv自带的滤波函数进行滤波

    矩阵数据类型转换函数

    void im2single(Mat& src,Mat& dst)
    {
     int type;
     type=src.type();
     dst.create(src.size(),CV_32F);
     switch (type)
     {
       case CV_8U:
      src.convertTo(dst,CV_32F,1.0f/255,0);
      /*src.convertTo(dst,CV_32F);
      dst=dst.mul(1.0f/255);	*/
      break;
     }
    }
    测试主函数

    #include <stdio.h>
    #include <opencv.hpp>
    #include "opencv2/gpu/gpu.hpp"
    #include <math.h>
    using namespace cv;
    using namespace std;
    
    void main()
    { 
      float d[11][11]={};
      int u,v,num,i,j,h,w;
      double dmin,dmax;
      float pi=3.14;
      Ptr<FilterEngine> FDct[11][11];
      Mat src;
      Mat src_gray,dst,gray_f;
      Mat kd(11,11,CV_32F);
    
      src=imread("te.jpg");
      cvtColor(src,src_gray,CV_BGR2GRAY);
      im2single(src_gray,gray_f);
      Size sz=src_gray.size();
      h=sz.height;
      w=sz.width;
      dst=Mat::zeros(Size(w,h),CV_32F);
     
      float pu;
            for(u=0;u<11;u++)    
              for(i=0;i<11;i++)          
               {
          pu=sqrt(2.0/11);              
                    if(u==0)
                        pu=sqrt(1.0/11);                              
                    kd.at<float>(i,u)=pu*cos((i+0.5)*pi/11*u);
               } //建立DCT滤波器的分离单维模版
       
        for(i=0;i<11;i++)
         for(j=0;j<11;j++)
             FDct[i][j]= createSeparableLinearFilter(src_gray.type(),dst.type(), kd.col(i), kd.col(j)); //建立可分离的DCT滤波函数   
    
    
      double t = (double)cvGetTickCount();
      for(num=0;num<20;num++)
         for(u=0;u<11;u++)
         for(v=0;v<11;v++)	  
             FDct[u][v]->apply(src_gray,dst); //执行滤波操作
      t = (double)cvGetTickCount() - t;
       
       
      minMaxIdx(dst,&dmin,&dmax);
      dst.convertTo(dst,CV_32F,1.0f/(dmax-dmin),-dmin/(dmax-dmin));
      imshow( "source_window", dst );  
      printf( "run time = %gs\n", t/(cvGetTickFrequency()*1000000)/20 );
      cvWaitKey(0);
    }

    实验结果表明对300*400图片进行模版尺寸为11*11扫描滤波时在release状态下每次耗时368.2ms,在debug状态下每次耗时1.1216s。可以看出opencv图像滤波运行效率比matlab高约一倍。


    opencv+GPU平台
    矩阵数据类型转换函数

    void im2single(Mat& src,Mat& dst)
    {
     int type;
     type=src.type();
     dst.create(src.size(),CV_32F);
     switch (type)
     {
       case CV_8U:
      src.convertTo(dst,CV_32F,1.0f/255,0);
      /*src.convertTo(dst,CV_32F);
      dst=dst.mul(1.0f/255);	*/
      break;
     }
    }
    #include <stdio.h>
    #include <opencv.hpp>
    #include "opencv2/gpu/gpu.hpp"
    #include <math.h>
    using namespace cv;
    using namespace std;
    using namespace cv::gpu;
    
    void main()
    {	
      float d[11][11]={};	 
      int u,v,num,i,j,h,w;
      double dmin,dmax;
      float pi=3.14;
      Ptr<FilterEngine_GPU> FDct[11][11];
    //GPU滤波函数,11*11的DCT变换模版
      Mat src;
      Mat src_gray,dst,gray_f;
      Mat kd(11,11,CV_32F);	
    
      src=imread("te.jpg");
      cvtColor(src,src_gray,CV_BGR2GRAY);	
      im2single(src_gray,gray_f);
       GpuMat dst_gpu, src_gpu;
    //GPU模块下矩阵数据类型
       src_gpu.upload(gray_f);
      
      Size sz=src_gray.size();
      h=sz.height;
      w=sz.width;	 
      dst=Mat::zeros(Size(w,h),CV_32F);	
     
      float pu;
            for(u=0;u<11;u++)     
              for(i=0;i<11;i++)          
               { 
                    pu=sqrt(2.0/11);               
                    if(u==0)
                        pu=sqrt(1.0/11);                               
                    kd.at<float>(i,u)=pu*cos((i+0.5)*pi/11*u);
               }
       
        for(i=0;i<11;i++)
         for(j=0;j<11;j++)	 
             FDct[i][j]= createSeparableLinearFilter_GPU(gray_f.type(),dst.type(), kd.col(i), kd.col(j));
          
        
    
    
      double t = (double)cvGetTickCount();
      for(num=0;num<20;num++)
         for(u=0;u<11;u++)
         for(v=0;v<11;v++)	  
             FDct[u][v]->apply(src_gpu,dst_gpu); 
    //执行滤波操作
      t = (double)cvGetTickCount() - t; 
       
         dst_gpu.download(dst);
      minMaxIdx(dst,&dmin,&dmax);
      dst.convertTo(dst,CV_32F,1.0f/(dmax-dmin),-dmin/(dmax-dmin));
      imshow( "source_window", dst );  
      printf( "run time = %gs\n", t/(cvGetTickFrequency()*1000000)/20 );
      cvWaitKey(0);
    }
    实验结果表明对300*400图片进行模版尺寸为11*11扫描滤波时在release状态下每次耗时82.3ms,在debug状态下每次耗时88.3ms。可以看出opencv+gpu图像滤波运行效率比matlab高约9倍,比单独的opencv高出约4倍。

    C语言编写滤波函数

    产生余弦变换Dct滤波器,尺寸为11*11,一共121个
    void DctFilter( float d[11][11][11][11], int size )
    {
       float pi=3.14;
      float pu,pv;
      int u,v,i,j;
         for(u=0;u<size;u++)
          for(v=0;v<size;v++)
             for(i=0;i<size;i++)
               for(j=0;j<size;j++)
               {
                   pu=sqrt(2.0/size);
                    pv=sqrt(2.0/size);
                    if(u==0)
                        pu=sqrt(1.0/size);                
                    if(v==0)
                        pv=sqrt(1.0/size);                
                    d[u][v][i][j]=pu*pv*cos((i+0.5)*pi/size*u)*cos((j+0.5)*pi/size*v);
               }
    }
    矩阵数据类型转换函数
    void im2single(Mat& src,Mat& dst)
    {
     int type;
     type=src.type();
     dst.create(src.size(),CV_32F);
     switch (type)
     {
       case CV_8U:
      src.convertTo(dst,CV_32F,1.0f/255,0);
      /*src.convertTo(dst,CV_32F);
      dst=dst.mul(1.0f/255);	*/
      break;
     }
    }
    滤波执行函数
    void imfilter(Mat& src_gray,Mat& dst,float d[11][11])
    {
     int h,w;
     float tmp;
     Size sz=src_gray.size();
     h=sz.height;
     w=sz.width;
     //dst.create(size(h-10,w-10),src_gray.type);
     dst=Mat::zeros(Size(w-10,h-10),src_gray.type());
    
     int i,j,m,n;
     
     for(i=5;i<h-6;i++)
     {
      for(j=5;j<w-6;j++)
      {
       for(m=-5;m<6;m++)
        for(n=-5;n<6;n++)
        {
         dst.at<float>(i-5,j-5)+=src_gray.at<float>(i+m,j+n)*d[m+5][n+5];
        }
      }
     }
    
    }
    测试函数:
    在Release状态下测试,在Debug状态下运行会比Release状态下慢很多。
    #include <stdio.h>
    #include <opencv.hpp>
    #include "opencv2/gpu/gpu.hpp"
    #include <math.h>
    using namespace cv;
    using namespace std;
    
    void main()
    {
     
      float d[11][11][11][11]={};
      int u,v,num;
      double dmin,dmax;
      Mat src;
      Mat src_gray,dst,gray_f;
      src=imread("te.jpg");
      cvtColor(src,src_gray,CV_BGR2GRAY);
      DctFilter(d,11);  //产生DCT滤波模版
      im2single(src_gray,gray_f);	 //将原始数据转化为单精度类型
      double t = (double)cvGetTickCount();
      for(num=0;num<20;num++)
         for(u=0;u<11;u++)
         for(v=0;v<11;v++)	  
               imfilter(gray_f,dst,d[u][v]); //对每个Dct模版进行滤波操作
      t = (double)cvGetTickCount() - t;	  
     
      minMaxIdx(dst,&dmin,&dmax);
      dst.convertTo(dst,CV_32F,1.0f/(dmax-dmin),-dmin/(dmax-dmin));
      imshow( "source_window", dst );  
      printf( "run time = %gs\n", t/(cvGetTickFrequency()*1000000)/20 );
      cvWaitKey(0);
    }
    由于代码效率明显很低,只测试了release条件下对300*400图片进行模版尺寸为11*11扫描滤波时在release状态下每次耗时10.7966s。图像滤波的运行效率比前面任意一种方式都低很多。







    展开全文
  • 虽然三种方式都可以完成同样的目的,但是运行速度却有快有慢,尤其是在实现一些复杂算法的时候,效率非常关键,下面就来比较一下这三种方式的运行速度。 实现代码: 代码工程下载地址:...

    本文目的:

    在opencv中有三种方式可以读写图像的像素,分别为:指针读写、迭代器读写、动态地址计算读写。虽然三种方式都可以完成同样的目的,但是运行速度却有快有慢,尤其是在实现一些复杂算法的时候,效率非常关键,下面就来比较一下这三种方式的运行速度。

    实现代码:

    代码工程下载地址:http://download.csdn.net/detail/u013752202/9230389 

    下面代码实现的功能:分别使用三种方法实现图像像素的读写,并改变图像的亮度和对比度,然后对三种方法的运行速度进行比较。

    #include <QtCore/QCoreApplication>
    #include <opencv2/opencv.hpp>
    
    using namespace cv;
    /***********************************
    *通过.ptr指针访问像素
    ************************************/
    void lightAdjustPTR(Mat &image,int contrast,int bright)
    {
        for(int i=0;i<image.rows;i++){
            for(int j=0;j<image.cols;j++){
                for(int ch=0;ch<image.channels();ch++){
                    uchar curVal=image.ptr<Vec3b>(i)[j][ch];
                    image.ptr<Vec3b>(i)[j][ch]=saturate_cast<uchar>(0.01*contrast*curVal+bright);
                }
            }
        }
    }
    /***********************************
    *通过.at动态地址访问像素
    ************************************/
    void lightAdjustAT(Mat &image,int contrast,int bright)
    {
        for(int i=0;i<image.rows;i++){
            for(int j=0;j<image.cols;j++){
                for(int ch=0;ch<image.channels();ch++){
                    uchar curVal=image.at<Vec3b>(i,j)[ch];
                    image.at<Vec3b>(i,j)[ch]=saturate_cast<uchar>(0.01*contrast*curVal+bright);
                }
            }
        }
    }
    /***********************************
    *通过it迭代器访问像素
    ************************************/
    void lightAdjustIT(Mat &image,int contrast,int bright)
    {
        MatIterator_<Vec3b> it=image.begin<Vec3b>();
        MatIterator_<Vec3b> itend=image.end<Vec3b>();
        while(it!=itend){
            for(int ch=0;ch<image.channels();ch++){
                uchar curVal=(*it)[ch];
                (*it)[ch]=saturate_cast<uchar>(0.01*contrast*curVal+bright);
            }
            it++;
        }
    }
    
    
    int main(int argc, char *argv[])
    {
        QCoreApplication a(argc, argv);
    
        Mat srcPTR=imread("1.jpg");
        Mat srcAT=srcPTR.clone();
        Mat srcIT=srcPTR.clone();
        imshow("ShuiTan",srcPTR);
    
        //通过.ptr指针访问
        double timePTRS=static_cast<double>(getTickCount());//获取当前心跳数
        lightAdjustPTR(srcPTR,130,100);
        double timePTRT=((double)getTickCount()-timePTRS)/getTickFrequency();//求运行时间
        cout<<".ptr spent: "<<timePTRT<<"s"<<endl;//打印时间
    
        //通过.at动态地址访问
        double timeATS=static_cast<double>(getTickCount());//获取当前心跳数
        lightAdjustAT(srcAT,130,100);
        double timeATT=((double)getTickCount()-timeATS)/getTickFrequency();//求运行时间
        cout<<".at  spent: "<<timeATT<<"s"<<endl;//打印时间
    
        //通过it迭代器访问
        double timeITS=static_cast<double>(getTickCount());//获取当前心跳数
        lightAdjustIT(srcIT,130,100);
        double timeITT=((double)getTickCount()-timeITS)/getTickFrequency();//求运行时间
        cout<<"*it  spent: "<<timeITT<<"s"<<endl;//打印时间
    
        imshow("ShuiTanPTR",srcPTR);
        imshow("ShuiTanAT",srcAT);
        imshow("ShuiTanIT",srcIT);
        waitKey(0);
    
        return a.exec();
    }
    
    运行结果:

    从下面的运行结果可以看出,三种方法的运行速度从快到慢依次是:指针读写 < 迭代器读写 < 动态地址计算,指针读写的方式是最快的,所以在算法中尽量使用指针读写的方式来访问图像像素或矩阵元素。



    展开全文
  • 刚接触openCV 想请教下 想使用opencv 识别出一张图片中的圆心,如果运行在dragonboard410c上,实现这个算法速度会很慢吗?
  • 我在XP(32bit)电脑上搭建了Visual Studio 2010和OpenCV-3.1.0,OpenCV包含了OpenCV_contrib这个包。 OpenCV-3.1.0自带了6种能同时计算特征点和描述子的算法(笔者浏览了一遍,目测有6个函数)。分别是cv::xfeatures...
  • 找了半天原因最后发现掉了一个flags参数,而且在opencv3版本中,这个参数的设置和之前opencv2版本完全不一样 opencv2 版本一般会设置...直接设置flags=0就可以运行了 c++版本同样的问题: 前一天还好好的,隔...
  • OpenCV——svd速度优化

    千次阅读 2019-08-23 15:05:54
    在发现opencv运行SVD::compute()过程太慢,一张299*299的图片Debug要几s,release也要0.5s。 第一次尝试: 将299*299图像分成13份23*299的图像运行svd。release模式下能达到0.25s,将近快一倍。 第二次: 加上...
  • 我想要把经ROI处理的图片不存入009文件夹,而是放入数组中,然后在图片序列转视频时,调用该数组来合成视频,但我不知道具体该怎么做或者说可以这么做吗? //【5】ROI显示结果 char file[100];...
  • 编译OpenCV4.4测试运行

    千次阅读 2020-07-22 00:26:48
    编译OpenCV编译安装流程错误处理 编译安装流程 错误处理 错误:gcc: error: long: No such file or directory C:\msys64\mingw64\bin\windres.exe: preprocessing failed. make[2]: *** [modules\core\CMakeFiles\...
  • 使用cpu处理一张图需要8s左右,比较慢,本节中调用gpu加快速度 1 查看CUDA Capability 在cuda安装路径中C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v10.0 搜索deviceQuery 在cmd中运行deviceQuery.exe 2...
  • OpenCV

    千次阅读 2014-09-16 15:03:05
    OpenCV(Open Source Computer Vision Library) 由公司在背后提供支持。它包含了超过500个函数来实现用于图形处理和计算机视觉方面的通用算法。
  • 目录Python OpenCV速度提升全汇总前言整体思路具体步骤分析代码运行时间(必要)python加速OpenCV加速随缘说些 前言 周更周更,希望能做到有质量的周更。最近好忙啊,在弄图像算法专利Kaggle的比赛,还有工作上的...
  • opencv

    千次阅读 2016-04-05 17:12:43
    OpenCV是一个基于BSD许可(开源)发行的跨平台计算机视觉库,可以运行在Linux、Windows和Mac OS操作系统上。它轻量级而且高效——由一系列 C 函数和少量 C++ 类构成,同时提供了Python、Ruby、MATLAB等语言的接口,...
  • OpenCV4.0 运行快速风格迁移(Torch)

    千次阅读 2019-01-18 22:11:50
    从《Python 图像风格迁移(模仿名画)》一文中看到 OpenCV 可以运行Torch 模型。也来试试, 先用vs2008编译一个cv3.3, 再下一个"fast-neural-style-master"包,按包中地址下载几个模型,下面是其中一个: ...
  • 如题,最近要做一个有较高实时性要求的图像处理课题,想问一下哪种库比较快?...同时,较新的OpenCV里引入了C++版本的接口,使用较方便,比C版本的会不会大大减速? 谢谢大家,初出茅庐,还请解答指正
  • 正如【opencv四】利用opencv读取显示视频和【opencv七】利用opencv调用电脑摄像头中用到的可以从视频流中捕获到一个一个的帧,并将这些帧逐一显示。我们也可以创建一个写入功能,使得这一个个的帧能够逐一被放入到...
  • 在caffe的人脸检测算法中,使用cv::resize()函数...在Makefile.config里,关于opencv的库引用如下: ifeq($(USE_OPENCV),1) LIBRARIES+=opencv_coreopencv_highguiopencv_imgproc ifeq($(OPENCV_VERSION),3) ...
  • 关于opencv遍历像素速度的提高方案

    千次阅读 2018-01-20 00:15:24
    二值化算法经过测试后基本可以,但是在运动中会出现无法检测特征图像的地方,另外执行的速度还是不快。因为代码中有两个双层嵌套的for循环,这是给遍历图像用的。为了优化for循环遍历像素占用的时间,我的实验过程...
  • debug模式:debug,release 运行发布的exe文件 这三种模式是运行结果是不一样的 ...速度运行发布的exe文件>release >debug 而且摄像头只能工作在运行发布的exe文件下,debug模式如果调用了摄像头程序会退出
  • OpenCV 3.0与OpenCV 2.4的区别

    万次阅读 2016-11-30 14:45:46
    OpenCV 3.0与OpenCV 2.4的区别
  • OpenCV人脸检测的速度

    千次阅读 2012-03-25 18:17:21
    OpenCV人脸检测的速度 由 alkmaar » 2012-03-20 10:19 各位大虾好,小弟有一个关于OpenCV人脸检测的问题想请教一下: 我用摄像头打开480x640的窗口,然后使用OpenCV的人脸检测函数cvHaarDetectObjects...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 17,366
精华内容 6,946
关键字:

opencv运行速度