C++ 测量OpenCV FPS

我正在寻找一种测量openCV FPS的正确方法。我找到了好几种方法。但是没有一个适合我

我测试的第一个使用time\t start和time\t end。我认为一个是错误的，一旦它返回一个转储函数作为fps x time plot（我真的无法想象fps plot怎么会是转储函数）

这里是这个情节的图像

我测试的第二个使用t=（double）cvGetTickCount（）来测量fps。这种方法在返回120 fps结果时是错误的，但是，对于以120 fps捕获的30秒长的视频，处理时间不应超过1分钟。所以这是一种错误的测量FPS的方法

for(;;)
    {

        clock_t start=CLOCK();

        Mat frame, finalFrame;
        capture >> frame; 

        finalFrame = frame;

        cvtColor(frame, frame, CV_BGR2GRAY);

        GaussianBlur(frame, frame, Size(7,7), 1.5, 1.5);
        threshold(frame, frame, 20, 255, CV_THRESH_BINARY);

        dilate(frame, frame, Mat(), Point(-1, -1), 2, 1, 1);
        erode(frame, frame, Mat(), Point(-1, -1), 2, 1, 1);

        Canny(frame, frame, 20, 20*2, 3 );

        vector<Vec3f> circles;

        findContours(frame,_contours,_storage,CV_RETR_CCOMP,CV_CHAIN_APPROX_SIMPLE );

        vector<vector<Point> > contours_poly( _contours.size() );
        vector<Rect> boundRect( _contours.size() );
        vector<Point2f>center( _contours.size() );
        vector<float>radius( _contours.size() );


        int temp = 0;

        for( int i = 0; i < _contours.size(); i++ )
        { 
            if( _contours[i].size() > 100 )
            {
               approxPolyDP( Mat(_contours[i]), contours_poly[i], 3, true );
               boundRect[i] = boundingRect( Mat(_contours[i]) );
               minEnclosingCircle( (Mat)_contours[i], center[i], radius[i] );
               temp = i;
               break;
            }
        }



        double dur = CLOCK()-start;
            printf("avg time per frame %f ms. fps %f. frameno = %d\n",avgdur(dur),avgfps(),frameno++ );

        frameCounter++;

        if(frameCounter == 3600)
        break;

        if(waitKey(1000/120) >= 0) break;
    }

有人知道在openCV中测量FPS的另一种方法吗

另外，我试图在视频的每一帧中找到圆圈。视频帧大小为320x240像素

更新2 我试图测量FPS的代码

for(;;)
    {

        clock_t start=CLOCK();

        Mat frame, finalFrame;
        capture >> frame; 

        finalFrame = frame;

        cvtColor(frame, frame, CV_BGR2GRAY);

        GaussianBlur(frame, frame, Size(7,7), 1.5, 1.5);
        threshold(frame, frame, 20, 255, CV_THRESH_BINARY);

        dilate(frame, frame, Mat(), Point(-1, -1), 2, 1, 1);
        erode(frame, frame, Mat(), Point(-1, -1), 2, 1, 1);

        Canny(frame, frame, 20, 20*2, 3 );

        vector<Vec3f> circles;

        findContours(frame,_contours,_storage,CV_RETR_CCOMP,CV_CHAIN_APPROX_SIMPLE );

        vector<vector<Point> > contours_poly( _contours.size() );
        vector<Rect> boundRect( _contours.size() );
        vector<Point2f>center( _contours.size() );
        vector<float>radius( _contours.size() );


        int temp = 0;

        for( int i = 0; i < _contours.size(); i++ )
        { 
            if( _contours[i].size() > 100 )
            {
               approxPolyDP( Mat(_contours[i]), contours_poly[i], 3, true );
               boundRect[i] = boundingRect( Mat(_contours[i]) );
               minEnclosingCircle( (Mat)_contours[i], center[i], radius[i] );
               temp = i;
               break;
            }
        }



        double dur = CLOCK()-start;
            printf("avg time per frame %f ms. fps %f. frameno = %d\n",avgdur(dur),avgfps(),frameno++ );

        frameCounter++;

        if(frameCounter == 3600)
        break;

        if(waitKey(1000/120) >= 0) break;
    }

（；；）的

{
时钟启动=时钟（）；
垫架，最终架；
捕获>>帧；
最终帧=帧；
CVT颜色（边框、边框、CV_BGR2GRAY）；
GaussianBlur（框架，框架，大小（7,7），1.5,1.5）；
阈值（帧，帧，20，255，CV_THRESH_二进制）；
扩张（框架，框架，垫（），点（-1，-1），2，1，1）；
腐蚀（框架，框架，垫（），点（-1，-1），2，1，1）；
Canny（帧，帧，20,20*2,3）；
矢量圆；
findContours（框架、轮廓、存储、CV-RETR-CCOMP、CV-CHAIN-Abrox-SIMPLE）；
向量等高线_poly（_courts.size（））；
向量boundRect（_outlows.size（））；
向量中心（_等高线.size（））；
向量体（_contours.size（））；
内部温度=0；
对于（int i=0；i<_courses.size（）；i++）
{ 
如果（_等高线[i].size（）>100）
{
近似多边形（Mat（_等高线[i]），等高线_多边形[i]，3，真）；
boundRect[i]=boundingRect（Mat（_等高线[i]）；
MineConclosingCircle（（Mat）_轮廓[i]，中心[i]，半径[i]）；
温度=i；
打破
}
}
双dur=时钟（）-启动；
printf（“每帧平均时间%f ms.fps%f.frameno=%d\n”，avgdur（dur），avgfps（），frameno++）；
帧计数器++；
如果（帧计数器==3600）
打破
如果（等待键（1000/120）>=0）中断；
}

更新

使用Zaw-Lin方法执行程序！

---

我已经发布了一种方法来做到这一点。有必要进行一点平均，否则fps将过于跳跃

编辑 我在process（）中加入了一个Sleep，它给出了正确的fps和持续时间（+/-1ms）

#包括“opencv2/highgui/highgui.hpp”
#包括“opencv2/imgproc/imgproc.hpp”
#包括
#包括
使用名称空间cv；
#如果已定义（_MSC_VER）|已定义（WIN32）|已定义（_WIN32）|已定义（_WIN32|）\
||已定义（WIN64）| |已定义（_WIN64）| |已定义（uu WIN64_uuu）
#包括
bool_qpcInited=假；
双PCFreq=0.0；
__int64 countstart=0；
void InitCounter（）
{
大整数李；
if（！QueryPerformanceFrequency（&li））
{
标准：：cout 1000）
{
_fpstart=时钟（）；
_平均GFPS=0.7*_平均GFPS+0.3*_fps1秒；
_fps1sec=0；
}
_fps1sec++；
返回平均GFPS；
}
脱空工艺（垫和框架）
{
睡眠（3）；
}
int main（int argc，字符**argv）
{
int frameno=0；
cv：：垫架；
cv：：视频捕获上限（0）；
对于（；；）
{
//cap>>框架；
双启动=时钟（）；
过程（框架）；
双dur=时钟（）-启动；
printf（“每帧平均时间%f ms.fps%f.frameno=%d\n”，avgdur（dur），avgfps（），frameno++）；
如果（等待键（1）=27）
出口（0）；
}
返回0；
}    

如果处理视频文件，可以使用OpenCV的API获取原始FPS。从实时流捕获时，以下方法不起作用：

cv::VideoCapture capture("C:\\video.avi");
if (!capture.isOpened())
{
    std::cout  << "!!! Could not open input video" << std::endl;
    return;
}

std::cout << "FPS: " << capture.get(CV_CAP_PROP_FPS) << std::endl;

cv:：VideoCapture捕获（“C:\\video.avi”）；
如果（！capture.isOpened（））
{
std：：cout您可以使用opencv助手

#包括
#包括
#包括“opencv2/core.hpp”
#包括“opencv2/core/utility.hpp”
#包括“opencv2/video.hpp”
#包括“opencv2/highgui.hpp”
使用名称空间cv；
内部主（内部ac，字符**av）{
视频捕获（0）；
垫架；
对于（；；）{
int64 start=cv:：getTickCount（）；
捕获>>帧；
if（frame.empty（））
打破
/*在这里做一些图像处理*/
char key=（char）waitKey（1）；
双fps=cv:：getTickFrequency（）/（cv:：getTickCount（）-start）；
std:：cout我只需测量walltime，然后简单地将帧除以经过的时间。在linux上：

/*
* compile with:
*   g++ -ggdb webcam_fps_example2.cpp -o webcam_fps_example2 `pkg-config --cflags --libs opencv`
*/

#include "opencv2/opencv.hpp"
#include <time.h>
#include <sys/time.h>


using namespace cv;
using namespace std;

double get_wall_time(){
    struct timeval time;
    if (gettimeofday(&time,NULL)){
        //  Handle error
        return 0;
    }
    return (double)time.tv_sec + (double)time.tv_usec * .000001;
}


int main(int argc, char** argv)
{
    VideoCapture cap;
    // open the default camera, use something different from 0 otherwise;
    // Check VideoCapture documentation.
    if(!cap.open(0))
        return 0;

    cap.set(CV_CAP_PROP_FRAME_WIDTH,1920);
    cap.set(CV_CAP_PROP_FRAME_HEIGHT,1080);

    double wall0 = get_wall_time();
    for(int x = 0; x < 500; x++)
    {
          Mat frame;
          cap >> frame;
          if( frame.empty() ) break; // end of video stream
          //imshow("this is you, smile! :)", frame);
          if( waitKey(10) == 27 ) break; // stop capturing by pressing ESC 
    }
    double wall1 = get_wall_time();
    double fps = 500/(wall1 - wall0);
    cout << "Wall Time = " << wall1 - wall0 << endl;
    cout << "FPS = " << fps << endl;
    // the camera will be closed automatically upon exit
    // cap.close();
    return 0;
}

/*
*编译时使用：
*g++-ggdb webcam\u fps\u example2.cpp-o webcam\u fps\u example2`pkg config--cflags--libs opencv`
*/
#包括“opencv2/opencv.hpp”
#包括
#包括
使用名称空间cv；
使用名称空间std；
双进站时间（）{
结构时间值时间；
if（gettimeofday（&time，NULL））{
//处理错误
返回0；
}
返回（双）time.tv_sec+（双）time.tv_usec*.000001；
}
int main（int argc，字符**argv）
{
视频捕捉帽；
//打开默认相机，使用与0不同的东西，否则；
//查看视频捕获文档。
如果（！cap.open（0））
返回0；
封盖套件（CV、封盖、道具、框架、宽度，1920）；
封盖套件（CV、封盖、支柱、框架、高度，1080）；
double wall0=获取墙时间（）；
对于（int x=0；x<500；x++）
{
垫架；
cap>>框架；
if（frame.empty（））中断；//视频流结束
//imshow（“这就是你，微笑！：）”，框架）；
如果（waitKey（10）==27）中断；//按ESC停止捕获
}
double wall 1=获取墙时间（）；
双fps=500/（墙1-墙0）；
你想测量视频的fps还是当前运行时的fps（以了解算法的运行速度）？我正在寻找一种测量运行时fps的方法！
ge
/*
* compile with:
*   g++ -ggdb webcam_fps_example2.cpp -o webcam_fps_example2 `pkg-config --cflags --libs opencv`
*/

#include "opencv2/opencv.hpp"
#include <time.h>
#include <sys/time.h>


using namespace cv;
using namespace std;

double get_wall_time(){
    struct timeval time;
    if (gettimeofday(&time,NULL)){
        //  Handle error
        return 0;
    }
    return (double)time.tv_sec + (double)time.tv_usec * .000001;
}


int main(int argc, char** argv)
{
    VideoCapture cap;
    // open the default camera, use something different from 0 otherwise;
    // Check VideoCapture documentation.
    if(!cap.open(0))
        return 0;

    cap.set(CV_CAP_PROP_FRAME_WIDTH,1920);
    cap.set(CV_CAP_PROP_FRAME_HEIGHT,1080);

    double wall0 = get_wall_time();
    for(int x = 0; x < 500; x++)
    {
          Mat frame;
          cap >> frame;
          if( frame.empty() ) break; // end of video stream
          //imshow("this is you, smile! :)", frame);
          if( waitKey(10) == 27 ) break; // stop capturing by pressing ESC 
    }
    double wall1 = get_wall_time();
    double fps = 500/(wall1 - wall0);
    cout << "Wall Time = " << wall1 - wall0 << endl;
    cout << "FPS = " << fps << endl;
    // the camera will be closed automatically upon exit
    // cap.close();
    return 0;
}