opencv 学习: 08 计算代码执行耗时

原创 已于 2025-11-13 18:41:21 修改 · 159 阅读 · 4 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#opencv #linux #c++ #计算机视觉

于 2025-11-13 15:46:25 首次发布
部署运行你感兴趣的模型镜像

讲如何比较各个遍历方式的效率。

效率是图像处理关心的一个问题。这就要检查处理效率，进而找到程序的性能瓶颈。

但是，程序的性能与条理之间，需要做好权衡。

1.执行时间衡量

cv::getTickCount() 用于获取自计算机启动后，经过的时钟周期数。
cv::getTickFrequency() 用于获取每秒时钟周期数。

将 “结束时周期” 减去 “开始时的周期” 得到 被测量代码 “消耗的周期数”。最后，除以每秒周期数，来作为代码的执行耗时。

cpp 11 以上可以借助 chrono 函数来处理计时。

#include <chrono>
auto start = std::chrono::high_resolution_clock::now();
//process
auto end = std::chrono::high_resolution_clock::now();
std::chrono::duration<double> duration = end - start;
std::cout << "colorReduce_pointer used time: " << duration.count() << "s" << std::endl;

实现方式如下：

const int64 start = cv::getTickCount();

//some process

//elapsed time in seconds
const int64 duration = (cv::getTickCount() - start) / cv::getTickFrequency();

具体的绝对执行时间与机器有关。并且也与编译程序的编译器、编译条件有关。

包含少量语句的较短循环通常比包含单个语句的较长循环执行效率更高，即使处理的元素总数相同。类似地，如果你有不同的计算应用到一个像素，在一个循环中应用它们，而不是写一个连续的循环，每个计算一个。

多线程是提高算法效率的另一种方法。但是这里先不做深入。

2.完整代码

#include <iostream>
#include <opencv2/opencv.hpp>
#include <chrono>

//指针实现
void colorReduce_pointer(cv::Mat/*&*/ image, int div)
{
    int row, col;

    // 每行图像的数据元素个数
    for (size_t i = 0; i < image.rows; i++)
    {
        // 得到第 i 行的数据指针
        uchar* data = image.ptr<uchar>(i);

        for(size_t j = 0; j < (image.cols * image.channels()); j++)
        {
            // 处理第 i 行第 j 列 像素数据 
            // 不用区分灰度图和彩色图片了，每次移动一个通道数据字段
            data[j] = data[j] / div * div + div / 2;
        }
      
    }
}

//指针实现
void colorReduce_pointer_v2(cv::Mat/*&*/ image, int div)
{
    int row, col;

    // 每行图像的数据元素个数
    size_t colsdataCnt = image.cols * image.channels();
    // 预先计算出结果，避免不必要的重复计算
    uint64 div2 = div / 2;

    for (size_t i = 0; i < image.rows; i++)
    {
        // 得到第 i 行的数据指针
        uchar* data = image.ptr<uchar>(i);

        for(size_t j = 0; j < colsdataCnt; j++)
        {
            // 处理第 i 行第 j 列 像素数据 
            // 不用区分灰度图和彩色图片了，每次移动一个通道数据字段
            data[j] = data[j] / div * div + div2;
        }
      
    }
}

//at 方法, 非常慢，只能说在别无选择时，做随机像素访问用。不适用与遍历扫描像素
void colorReduce_at(cv::Mat/*&*/ image, int div)
{
    // 预先计算出结果，避免不必要的重复计算
    uint64 div2 = div / 2;

    for (size_t i = 0; i < image.rows; i++)
    {
        // 得到第 i 行的数据指针
        uchar* data = image.ptr<uchar>(i);

        // 处理第 i 行第 j 列 像素数据 
        for(size_t j = 0; j < image.cols; j++)
        {
            image.at<cv::Vec3b>(i,j)[0] = image.at<cv::Vec3b>(i,j)[0] / div * div + div2;
            image.at<cv::Vec3b>(i,j)[1] = image.at<cv::Vec3b>(i,j)[1] / div * div + div2;
            image.at<cv::Vec3b>(i,j)[2] = image.at<cv::Vec3b>(i,j)[2] / div * div + div2;
        }
    }
}

//迭代器实现
void colorReduce_iterator(cv::Mat/*&*/ image, int div)
{
    int row, col;

    //只是对彩色图像的处理
    cv::Mat_<cv::Vec3b>::iterator it = image.begin<cv::Vec3b>();
    cv::Mat_<cv::Vec3b>::iterator it_end = image.end<cv::Vec3b>();
  
    for ( ; it != it_end; it++)
    {
        //对每个通道进行计算
        (*it)[0] = ((*it)[0] / div) * div + div / 2;
        (*it)[1] = ((*it)[1] / div) * div + div / 2;
        (*it)[2] = ((*it)[2] / div) * div + div / 2;
    }
}


//reshape 方式
void colorReduce_reshape(cv::Mat image, int div)
{
    //数据连续
    if (image.isContinuous())
    {
        //reshape 方法改变矩阵维度，而不需要任何内存复制或重新分配。列数，会自动做对应调整。
        //实现对矩阵元素的序列化
        image.reshape(1, // 通道数
                      1);// 行数
        //std::cout << "image is Continuous." << std::endl;
    }
  
    int row = image.rows;
    size_t colsdataCnt = image.cols * image.channels();// 此时这里的 cols，就相当于原来的 行数 * 列数

    // 每行图像的数据元素个数

    for (size_t i = 0; i < row; i++)
    {
        // 得到第 i 行的数据指针
        uchar* data = image.ptr<uchar>(i);

        for(size_t j = 0; j < colsdataCnt; j++)
        {
            // 处理第 i 行第 j 列 像素数据 
            // 不用区分灰度图和彩色图片了，每次移动一个通道数据字段
            data[j] = data[j] / div * div + div / 2;
        }
      
    }
}


//保持不修改原图，另外返回结果图片
//可以同时传入同一张图，然后会同源修改
//或者传入一张新的图片，另外修改
void colorReduce(const cv::Mat& origin,cv::Mat& result, int div)
{
    int row, col;
    //利用 cv::Mat 的creat 方法封装的机制，
    //如果提供的参数与当前Mat具有相同的行、列数，以及数据类型。将什么也不做，立即返回。
    //如果不同，则创建一个新内存区域
    //这将使得，调用时使用同一张图片，则不会重复创建内存
    result.create(origin.size(), origin.type());

    // 每行图像的数据元素个数
    size_t colsdataCnt = result.cols * result.channels();

    for (size_t i = 0; i < result.rows; i++)
    {
        // 分别得到第 i 行的数据指针
        const uchar* data_origin = origin.ptr<uchar>(i);
        uchar* data_result = result.ptr<uchar>(i);

        for(size_t j = 0; j < colsdataCnt; j++)
        {
            // 处理第 i 行第 j 列 像素数据 
            // 不用区分灰度图和彩色图片了，每次移动一个通道数据字段
            data_result[j] = data_origin[j] / div * div + div / 2;
        }
      
    }
}

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

    // 检查命令行参数

    if (argc != 4)
    {
        std::cerr << "Usage: " << argv[0] << " <input_image> <colorReduce> <output_image>" << std::endl;
        return -1;
    }

    // 读取输入图像和logo图像
    cv::Mat input_image = cv::imread(argv[1]);

    // 检查输入图像和logo图像是否成功读取
    if (input_image.empty())
    {
        std::cerr << "Error: Could not open or find input image" << std::endl;
    }

    cv::namedWindow("input_image", cv::WINDOW_NORMAL);
    cv::imshow("input_image", input_image);
    cv::waitKey(0);

    int reduce = std::stof(argv[2]);
    if (reduce < 0 || reduce > 255)
    {
        std::cerr << "Error: colorReduce must be between 0 and 255" << std::endl;
        return -1;
    }

    {
        const int64 start = cv::getTickCount();
        colorReduce_pointer(input_image, reduce);
        const int64 end = cv::getTickCount();
        std::cout << "colorReduce_pointer used time: " << (end - start) / cv::getTickFrequency() << "s" << std::endl;
    }

    { //演示 chrono
        auto start = std::chrono::high_resolution_clock::now();
        colorReduce_pointer(input_image, reduce);
        auto end = std::chrono::high_resolution_clock::now();
        std::chrono::duration<double> duration = end - start;
        std::cout << "colorReduce_pointer (chrono) used time: " << duration.count() << "s" << std::endl;
    }

    {
        const int64 start = cv::getTickCount();
        colorReduce_pointer_v2(input_image, reduce);
        const int64 end = cv::getTickCount();
        std::cout << "colorReduce_pointer_v2 used time: " << (end - start) / cv::getTickFrequency() << "s" << std::endl;
    }

    {
        const int64 start = cv::getTickCount();
        colorReduce_at(input_image, reduce);
        const int64 end = cv::getTickCount();
        std::cout << "colorReduce_at used time: " << (end - start) / cv::getTickFrequency() << "s" << std::endl;
    }

    {
        const int64 start = cv::getTickCount();
        colorReduce_iterator(input_image, reduce);
        const int64 end = cv::getTickCount();
        std::cout << "colorReduce_iterator used time: " << (end - start) / cv::getTickFrequency() << "s" << std::endl;
    }

    {
        const int64 start = cv::getTickCount();
        colorReduce_reshape(input_image, reduce);
        const int64 end = cv::getTickCount();
        std::cout << "colorReduce_reshape used time: " << (end - start) / cv::getTickFrequency() << "s" << std::endl;
    }

  
    {
        cv::Mat newImage = input_image.clone();
        //inplace 修改原图方式
        const int64 start = cv::getTickCount();
        colorReduce(newImage,newImage, reduce);
        const int64 end = cv::getTickCount();
        std::cout << "colorReduce (in-place process) used time: " << (end - start) / cv::getTickFrequency() << "s" << std::endl;
    }

    {
        cv::Mat newImage;
        //colorReduce 会reallocate 内存 会增加耗时
        const int64 start = cv::getTickCount();
        colorReduce(input_image,newImage, reduce);
        const int64 end = cv::getTickCount();
        std::cout << "colorReduce (reallocate memory) used time: " << (end - start) / cv::getTickFrequency() << "s" << std::endl;
    }

    cv::imwrite(argv[3], input_image);
    cv::namedWindow("output_image", cv::WINDOW_NORMAL);
    cv::imshow("output_image", input_image);
    cv::waitKey(0);

    return 0;
}

对同一图像的处理时间的比较，colorReduce_iterator 慢的很稳定，指针方式要比它快很多。

两个指针方法中，多行和一行遍历的时间差不多。colorReduce_pointer_v2 版本也没有快许多，可能是编译器层面做了优化。

通过避免循环中不必要的重复计算也可以提高效率。

重新分配内存的处理方式，这里没有看的太明显，但是要知道，重新分配内存是耗时的操作。

$ ./build/document_processor build/2.jpg 8 build/2_out.jpg
colorReduce_pointer used time: 0.113196s
colorReduce_pointer (chrono) used time: 0.103103s
colorReduce_pointer_v2 used time: 0.0836637s
colorReduce_at used time: 0.501025s
colorReduce_iterator used time: 0.315552s
colorReduce_reshape used time: 0.0980302s
colorReduce (in-place process) used time: 0.100326s
colorReduce (reallocate memory) used time: 0.0879106s

$ ./build/document_processor build/2.jpg 64 build/2_out.jpg
colorReduce_pointer used time: 0.0888434s
colorReduce_pointer (chrono) used time: 0.0986318s
colorReduce_pointer_v2 used time: 0.0872247s
colorReduce_at used time: 0.402873s
colorReduce_iterator used time: 0.264107s
colorReduce_reshape used time: 0.0916848s
colorReduce (in-place process) used time: 0.0893917s
colorReduce (reallocate memory) used time: 0.0915852s

您可能感兴趣的与本文相关的镜像

PyTorch 2.6

PyTorch 2.6

PyTorch
Cuda

PyTorch 是一个开源的 Python 机器学习库，基于 Torch 库，底层由 C++ 实现，应用于人工智能领域，如计算机视觉和自然语言处理

C#与OpenCvSharp：用轮廓检测实现闪电般的对象计数！
墨夶的博客
07-24 1167
摘要： 针对传统对象计数方法效率低、误差大的问题，本文提出基于OpenCvSharp的轮廓检测解决方案。通过灰度化、高斯模糊、二值化和形态学处理等预处理步骤，结合FindContours函数精准提取目标轮廓，实现毫秒级高效计数（1000个对象/秒）。关键创新点包括面积筛选机制（过滤噪点）和距离变换技术（定位质心）。实验表明，该方法较人工计数效率提升100倍，准确率达99.5%，适用于工业零件统计、农产品计数等高密度场景。附完整C#代码实现，包含预处理、轮廓绘制及性能优化技巧。
视觉革命：C#携手OpenCV开启计算机视觉新纪元
墨夶的博客
12-17 796
C#（发音为“C Sharp”）是由微软公司开发的一种面向对象的高级编程语言，最初设计用于Windows平台上的软件开发。随着.NET Core的推出，C#现已实现了真正的跨平台兼容性，可以在Linux、macOS等多个操作系统上运行。凭借其丰富的类库、直观的语法以及高效的编译器优化，C#逐渐成为了企业级应用开发的主流工具之一。OpenCV（Open Source Computer Vision Library）是一个开源的计算机视觉和机器学习软件库，提供了数百种现成的函数来处理图像和视频流。
Pyhton&OpenCV 计算程序运行耗时
程为
08-05 538
利用opencv的两个函数进行时间耗费计算
【OpenCV cv::parallel_for_并行化循环】原理、用法、其它类似函数
一起学习进步！
05-18 1394
OpenCV 中的 `cv::parallel_for_` 是用于实现 **并行化循环** 的核心工具，它通过多线程加速计算密集型任务。
OpenCV 学习记录：首篇
m0_74825488的博客
12-24 853
是一个开源的计算机视觉和机器学习软件库。它由 Intel 开发，旨在帮助开发人员在实时计算机视觉应用中解决各种问题。OpenCV 提供了丰富的工具和函数，能够支持图像处理、视频分析、物体检测、人脸识别、机器学习等功能，广泛应用于自动驾驶、安防监控、医学图像分析等领域。
opencv计算代码运行耗时情况
qq_40590753的博客
05-04 718
在图像处理中，由于每秒要处理大量操作，因此必须使代码不仅提供正确的解决方案，而且还必须以最快的方式提供。因此，在本章中，你将学习 衡量代码的性能。 一些提高代码性能的技巧。 你将看到以下功能：cv.getTickCount，cv.getTickFrequency等。 除了OpenCV，Python还提供了一个模块time，这有助于衡量执行时间。另一个模块profile有助于获取有关代码的详细报告...
技巧 | OpenCV程序执行时间计算
小白学视觉
07-14 1480
点击上方“小白学视觉”，选择加"星标"或“置顶”重磅干货，第一时间送达 01引言大家用OpenCV做开发，经常需要调试算法，打印出算法的执行时间，OpenCV中没有直接获...
深入学习OpenCV：第三章OpenCV 核心模块介绍（上）
一个技术宅的博客
04-15 4799
OpenCV 核心模块的介绍文章，涵盖图像基础操作、像素处理、算术运算、性能优化等核心功能。由于内容比较多，分为三篇文章进行描述，本文是第一部分。
OpenCV 并行计算函数 parallel_for_ 的使用
热门推荐
泠山的博客
07-22 1万+
任务描述：我要定义两个Mat矩阵的逐元素乘积，如下所示（1）自定义一个类继承自 ParallelLoopBody，并且重载括号运算class ParallelAdd : public ParallelLoopBody //参考官方给出的answer，构造一个并行的循环体类 {public :ParallelAdd(Mat & _src1 , Mat & _src2 , Mat _result) //构造函数 {
OpenCV学习 day3
cjh200341的博客
08-02 746
本文介绍了图像处理中的灰度化和二值化技术。灰度化将彩色图像转换为单通道灰度图，详细讲解了最大值法、平均值法和加权均值法三种灰度化方法。二值化则将灰度图转化为黑白两色图像，阐述了阈值法、反阈值法和截断阈值法等基本方法。文章通过代码示例展示了各种方法的实现过程，并对比了不同处理效果的差异。这些技术在计算机视觉、OCR识别等领域有广泛应用，能够简化图像数据、提高处理效率。
Opencv C++图像处理：矩阵Mat + 随机数RNG + 计算耗时 + 鼠标事件
生活需要深度
08-07 885
Mat.depth() 获取矩阵：存储格式（返回0~6）：enum{CV_8U=0, CV_8S=1, CV_16U=2, CV_16S=3, CV_32S=4, CV_32F=5, CV_64F=6}dst2.at(y, x)[c] = cv::saturate_cast(src.at(y, x)[c] * 2);别名的基础格式为cv::Matx{1,2,3,4,5,6}{1,2,3,4,5,6}{f,d}。
深度学习与OpenCV结合：图像阈值调节新境界（技术前沿）
在数字化时代，深度学习和OpenCV作为两大核心技术，已经在图像处理领域引起了革命性的改变。本章旨在为读者提供深度学习与OpenCV的基础知识框架，为后续章节中的应用和优化打下坚实的基础。 ## 1.1 深度学习简介 ...
基于OpenCV的图像梯度与边缘检测研究
Candy5204的博客
12-15 569
标题:基于OpenCV的图像梯度与边缘检测研究内容:1.摘要 本研究旨在系统探究基于OpenCV库的图像梯度计算与边缘检测算法的性能表现与适用边界。通过在COCO-Val子集（含1000幅自然场景图像）和自建工业缺陷图像数据集（327幅高对比度灰度图）上，对Sobel、Scharr、Laplacian及Canny四种主流方法进行定量评估，采用F1-score、平均精度（AP@0.5）和边缘定位误差（EPE，单位：像素）作为核心指标。实验结果表明：Canny算子在综合边缘完整性与噪声抑制方面最优，平均F1-s
opencv和matlab中相机内参标定模型
Jared_Chen的博客
12-13 626
OpenCV和MATLAB的相机标定工具在模型实现上存在差异。针孔模型中，OpenCV采用固定PlumbBob模型（含径向k1-k3和切向p1-p2畸变），而MATLAB提供可选的'Brown'模型或带轴倾斜的'Skew'模型。鱼眼模型中，OpenCV使用基于等距投影的专用模型(k1-k4)，MATLAB则采用更灵活的Kannala-Brandt多项式模型。两者标定结果不能直接互换，建议根据应用场景选择工具并保持一致性：OpenCV适合实际部署，MATLAB更适合研究验证。
【OpenCV】Python图像处理几何变换之缩放
最新发布
棒棒的皮皮
12-16 427
摘要：图像缩放是通过调整图像尺寸实现几何变换的基础操作，OpenCV的cv2.resize()函数支持多种缩放方式。核心原理包括插值算法选择（INTER_NEAREST、INTER_LINEAR、INTER_CUBIC等）和尺寸比例计算。实现场景包括固定比例缩放、指定尺寸缩放、保持宽高比缩放等，应用涵盖图像预处理、多分辨率显示等。关键注意事项包括尺寸格式转换（width,height）、插值算法选择（缩小推荐INTER_AREA，放大推荐INTER_CUBIC）以及中文路径处理等问题。
OPENCV（python）--初学之路（十七）二进制鲁棒独立（BRIEF)和定向快速和轮换（ORB)
WGK1005的博客
12-12 1125
本文介绍了两种高效的特征描述算法BRIEF和ORB。BRIEF是一种二进制描述符，通过比较像素点对的强度生成紧凑的二进制字符串，显著减少了内存占用和计算时间。ORB则结合了FAST特征点检测和旋转不变的BRIEF描述子，通过金字塔多尺度特征和强度加权质心计算方向，实现了高效且专利免费的替代方案。文章提供了OpenCV中的实现代码，包括BRIEF描述符提取和ORB特征点检测的详细步骤，并讨论了算法参数设置和实际应用场景。作者在雪景中完成本文写作，最后以张岱的诗句作结，表达对技术探索的坚持与共勉之情。
OpenCV 学习9-灰度转黑白二值图像
木梓油
12-16 477
图像二值化是将灰度或彩色图像简化为黑白两种状态的处理方法，在OCR识别、条形码读取、医学图像处理等场景中广泛应用。OpenCV提供的cv2.threshold()函数通过设定阈值实现二值化，支持多种阈值类型，包括二进制阈值化、反向二进制等。其中OTSU算法能自动计算最优阈值，通过最大化类间方差实现最佳分割效果。该方法通过保留关键结构、去除冗余信息，有效提升了图像处理效率。
超越SIFT与ORB：深入OpenCV特征检测API的设计哲学与高阶实践
不懂先生的博客
12-12 469
从早期Moravec到Harris的角点启蒙，到SIFT、SURF的尺度不变性突破，再到ORB、BRISK的效率革命，乃至当今深度特征描述符的崛起，这条演进路径清晰勾勒出我们对图像本质信息提取的不断深化。它更是一座精心设计的桥梁，系统地封装了不同时代的算法智慧，并提供了一套统一、可扩展的架构，供开发者穿梭于经典理论与工程实践之间。本文将深入OpenCV特征检测与描述子模块的内核，剖析其API设计背后的模块化思想，探讨性能优化的隐秘角落，并展示如何将传统特征与深度学习范式进行创新性融合。
【图像算法 - 38】工业巡检应用：基于 YOLO 与 OpenCV 的高精度管道缺陷检测系统实现
qq_42910179的博客
12-13 1464
本文详细介绍了基于YOLOv12和 OpenCV 实现管道缺陷检测的完整流程。通过端到端的目标检测框架，我们能够自动识别7 类关键管道缺陷，大幅提升巡检效率与准确性。该系统可集成至管道机器人、CCTV分析平台或无人机巡检系统，为城市生命线工程的安全运行提供智能保障，在智慧城市、能源安全、工业4.0等领域具有广阔应用前景。🔧工程建议：实际部署时，建议结合 GIS 信息将缺陷位置映射到真实管网坐标，生成结构化维修工单，实现“检测-定位-派单”闭环。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值