opencv python比c++；？ 我试图用Python和C++来定义Hy圈，看看C++是否能在处理时间上产生优势（直觉上应该）！ 版本 python:3.6.4 gcc编译器：gcc（Ubuntu 5.4.0-6ubuntu1~16.04.9）5.4.0 20160609 cmake:3.5.1 opencv:3.4.1

我实际上是用anaconda安装opencv的。令人惊讶的C++版本 也起作用

我使用的图像如下所示：

Python代码

导入cv2
导入时间
导入系统
def hough_变换（src、dp、mindest、param1=100、param2=100、minRadius=0、maxRadius=0）：
灰色=cv2.CVT颜色（src、cv2.COLOR\u RGB2GRAY）
开始时间=time.time（）
圆=cv2。霍夫圆（灰色，
cv2.HOUGH_梯度，
dp=dp，
心灵主义者，
param1=param1，
param2=param2，
最小半径=最小半径，
最大半径=最大半径）
结束时间=time.time（）
打印（“hough圆变换所用的时间为：{}”。格式（结束时间-开始时间））
#如果圆不是无：
#圆=圆。重塑（圆。形状[1]，圆。形状[2]）
#其他：
#raise VALUERROR（“错误！！！！！未检测到圆尝试调整参数或最小和最大半径”）
#
#a=输入（“输入1以可视化”）
#如果int（a）==1：
#对于圆形中的圆形：
#圆心=（圆[0]，圆[1]）
#半径=圆[2]
#cv2.圆（src，中心，半径，（255,0,0），5）
#
#cv2.namedWindow（“霍夫圆”，cv2.WINDOW_NORMAL）
#cv2.imshow（“霍夫圆”，src）
#cv2.等待键（0）
#cv2.destroyAllWindows（）
#
#
返回
如果名称=“\uuuuu main\uuuuuuuu”：
如果len（sys.argv）！=2:
raisevalueerror（“用法：python hough_circle.py”）
image=cv2.imread（sys.argv[1]）
image=cv2.cvt颜色（image，cv2.COLOR\u BGR2RGB）
hough_变换（图像，1.7100,50,30690700）

C++代码

#包括
#包括
#包括
使用名称空间std；
使用名称空间cv；
void-hough_变换（Mat-src，double-dp，double-mindsist，double-param1=100，double-param2=100，int-minRadius=0，int-maxRadius=0）
{
席灰色；
CVT颜色（src、灰色、颜色_rgb2灰色）；
矢量圆；
int start_time=时钟（）；
HoughCircles（灰色、圆形、HOUGH_梯度、dp、Minist、param1、param2、minRadius、maxRadius）；
int end_time=时钟（）；
老实说，我不希望这两个之间有任何区别。Python库很可能是C++库周围的包装器，意味着一旦它们进入OpenCV的核心，如果用相同的优化标志编译，它们将具有相同的性能。
我所期望的唯一一个轻微的放缓是python达到了这一点；实际上python代码很少；差异不太可能是可测量的。我认为，当您执行单个测试时，您从另一个角度看到它的事实并不能证明任何事情；并且得到0.2s的差异，这可能是微不足道的dif在硬盘中寻找文件要处理。
< P>我不期望两者之间有任何区别。老实说，Python库很可能是C++库周围的包装器，意味着一旦它们进入OpenCV的核心，如果用相同的优化标志编译它们，它们将具有相同的性能。

我所期望的唯一一个轻微的放缓是python达到了这一点；实际上python代码很少；差异不太可能是可测量的。我认为，当您执行单个测试时，您从另一个角度看到它的事实并不能证明任何事情；并且得到0.2s的差异，这可能是微不足道的dif仅在硬盘中引用要处理的文件。
我实际上比较了两种不同的时间，即wall和CPU。
在Linux中，C++中的时钟（）给了CPU时间，在Windows中它给出了墙时间。所以当我把Python代码改为Time.CordCe（）时，都给出了相同的结果。
 UKMonkey解释，Python和C++中的Hough计算时间没有任何差别，但是，在C++中运行整个程序快了2.5倍（循环100次）。将其下移到C++：P. 
< P>我实际上比较了2个不同的时间，即墙和CPU。
在Linux中，C++中的时钟（）给了CPU时间，在Windows中它给出了墙时间。所以当我把Python代码改为Time.CordCe（）时，都给出了相同的结果。
如UKMonkey所解释的，在Python和C++中计算霍夫的时间根本没有任何差别，但是，在C++中运行整个程序几乎快2.5倍（循环100次）。下拉到C++：P. < /p>你使用什么编译器标志？请增加测试用例，至少运行几秒钟。这样的小偏差证明没有什么，因为它们在计算机的正常运行之间是常见的。请注意：请复制从终端粘贴文本，而不是提供文本图片。您使用编译器标志，如-O1-O2-O3或-Ofast？不，我不使用任何标志。这是我的cmake文件：cmake_最小值（版本2.8）项目（hough）查找包（需要OpenCV）添加可执行文件（hoigh_圆测试hough_圆测试.cpp）目标链接库（hough_圆测试${OpenCV_LIBS}）您使用的编译器标志是什么？请增加测试用例，使其至少运行几秒钟。由于计算机的正常运行，这些小偏差证明不了什么，因为它们在执行之间很常见。旁注：请从终端复制粘贴文本，而不是提供文本图片。您是否使用编译器标志，如e-O1-O2-O3或-Ofast？不，我不使用任何标志。这是我的cmake文件：cmake_最低要求（版本2.8）项目（hough）查找包（需要OpenCV）添加可执行文件（hoigh_循环\u测试hough
import cv2
import time
import sys

def hough_transform(src,dp,minDist,param1=100,param2=100,minRadius=0,maxRadius=0):
    gray = cv2.cvtColor(src,cv2.COLOR_RGB2GRAY)
    start_time = time.time()
    circles=cv2.HoughCircles(gray,
                             cv2.HOUGH_GRADIENT,
                             dp = dp,
                             minDist = minDist,
                             param1=param1,
                             param2=param2,
                             minRadius=minRadius,
                             maxRadius=maxRadius)
    end_time = time.time()
    print("Time taken for hough circle transform is : {}".format(end_time-start_time))
    # if circles is not None:
    #         circles = circles.reshape(circles.shape[1],circles.shape[2])
    # else:
    #     raise ValueError("ERROR!!!!!! circle not detected try tweaking the parameters or the min and max radius")
    #
    # a = input("enter 1 to visualize")
    # if int(a) == 1 :
    #     for circle in circles:
    #         center = (circle[0],circle[1])
    #         radius = circle[2]
    #         cv2.circle(src, center, radius, (255,0,0), 5)
    #
    #     cv2.namedWindow("Hough circle",cv2.WINDOW_NORMAL)
    #     cv2.imshow("Hough circle",src)
    #     cv2.waitKey(0)
    #     cv2.destroyAllWindows()
    #
    #
    return

if __name__ == "__main__":
    if len(sys.argv) != 2:
        raise ValueError("usage: python hough_circle.py <path to image>")
    image = cv2.imread(sys.argv[1])
    image = cv2.cvtColor(image,cv2.COLOR_BGR2RGB)
    hough_transform(image,1.7,100,50,30,690,700)

#include <iostream>
#include <opencv2/opencv.hpp>
#include <ctime>
using namespace std;
using namespace cv;

void hough_transform(Mat src, double dp, double minDist, double param1=100, double param2=100, int minRadius=0, int maxRadius=0 )
{
  Mat gray;
  cvtColor( src, gray, COLOR_RGB2GRAY);
  vector<Vec3f> circles;
  int start_time = clock();
  HoughCircles( gray, circles, HOUGH_GRADIENT, dp, minDist, param1, param2, minRadius, maxRadius);
  int end_time = clock();
  cout<<"Time taken hough circle transform: "<<(end_time-start_time)/double(CLOCKS_PER_SEC)<<endl;
  // cout<<"Enter 1 to visualize the image";
  // int vis;
  // cin>>vis;
  // if (vis == 1)
  // {
  //   for( size_t i = 0; i < circles.size(); i++ )
  //   {
  //       Point center(cvRound(circles[i][0]), cvRound(circles[i][1]));
  //       int radius = cvRound(circles[i][2]);
  //       circle( src, center, radius, Scalar(255,0,0), 5);
  //   }
  //   namedWindow( "Hough Circle", WINDOW_NORMAL);
  //   imshow( "Hough Circle", src);
  //   waitKey(0);
  //   destroyAllWindows();
  // }
  return;
}

int main(int argc, char** argv)
{
  if( argc != 2 ){
    cout<<"Usage hough_circle <path to image.jpg>";
    return -1;
  }
  Mat image;
  image = imread(argv[1]);
  cvtColor(image,image,COLOR_BGR2RGB);
  hough_transform(image,1.7,100,50,30,690,700);
  return 0;
}