Performance OpenCV3.0:启用OpenCL比禁用OpenCL时，冲浪检测速度较慢

在我的项目中，我已经成功地使用矩形实现了冲浪检测和跟踪。我的目标是使它尽可能快地运行（最大fps）。问题是当我尝试使用OpenCL时，代码以1fps的速度运行，但当禁用时，代码以4fps的速度运行。 我正在Core-i3 PC上使用Visual studio 2015和OpenCV3.0。 摄像头-罗技高清920

我不确定在普通PC上冲浪检测的平均速度是多少，但我希望它以更高的fps运行。我还需要在类似ODROID-XU3的ARM板上实现相同的代码

由于OpenCV3.0使用透明API（在后台使用OpenCL），我认为这是提高速度的最佳选择，但事实并非如此

如何使其运行更快（更快的fps）

代码如下：

void surf_detection::surf_detect(){

UMat img_extractor, snap_extractor;

if (crop_image_.empty())
    cv_snapshot.copyTo(dst);
else
    crop_image_.copyTo(dst);
//dst = QImagetocv(crop_image_);

imshow("dst", dst);

Ptr<SURF> detector = SURF::create(minHessian);
Ptr<DescriptorExtractor> extractor = SURF::create(minHessian);

cvtColor(dst, src, CV_BGR2GRAY);
cvtColor(frame, gray_image, CV_BGR2GRAY);


detector->detect(src, keypoints_1);
//printf("Object: %d keypoints detected\n", (int)keypoints_1.size());
detector->detect(gray_image, keypoints_2);
//printf("Object: %d keypoints detected\n", (int)keypoints_1.size());

extractor->compute(src, keypoints_1, img_extractor);
// printf("Object: %d descriptors extracted\n", img_extractor.rows);
extractor->compute(gray_image, keypoints_2, snap_extractor);

std::vector<Point2f> scene_corners(4);
std::vector<Point2f> obj_corners(4);

obj_corners[0] = (cvPoint(0, 0));
obj_corners[1] = (cvPoint(src.cols, 0));
obj_corners[2] = (cvPoint(src.cols, src.rows));
obj_corners[3] = (cvPoint(0, src.rows));

vector<DMatch> matches;
matcher.match(img_extractor, snap_extractor, matches);

double max_dist = 0; double min_dist = 100;

//-- Quick calculation of max and min distances between keypoints
for (int i = 0; i < img_extractor.rows; i++)
{
    double dist = matches[i].distance;
    if (dist < min_dist) min_dist = dist;
    if (dist > max_dist) max_dist = dist;
}
//printf("-- Max dist : %f \n", max_dist);
//printf("-- Min dist : %f \n", min_dist);

vector< DMatch > good_matches;

for (int i = 0; i < img_extractor.rows; i++)
{
    if (matches[i].distance <= max(2 * min_dist, 0.02))
    {
        good_matches.push_back(matches[i]);
    }
}

UMat img_matches;
drawMatches(src, keypoints_1, gray_image, keypoints_2,
    good_matches, img_matches, Scalar::all(-1), Scalar::all(-1),
    vector<char>(), DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS);

if (good_matches.size() >= 4){

    for (int i = 0; i<good_matches.size(); i++){

        //get the keypoints from good matches
        obj.push_back(keypoints_1[good_matches[i].queryIdx].pt);
        scene.push_back(keypoints_2[good_matches[i].trainIdx].pt);

    }
}

H = findHomography(obj, scene, CV_RANSAC);

perspectiveTransform(obj_corners, scene_corners, H);

line(img_matches, scene_corners[0], scene_corners[1], Scalar(0, 255, 0), 4);
line(img_matches, scene_corners[1], scene_corners[2], Scalar(0, 255, 0), 4);
line(img_matches, scene_corners[2], scene_corners[3], Scalar(0, 255, 0), 4);
line(img_matches, scene_corners[3], scene_corners[0], Scalar(0, 255, 0), 4);

imshow("Good matches", img_matches);

void surf_detection:：surf_detect（）{
UMat img_提取器、snap_提取器；
if（裁剪图像为空（）
cv_快照复制到（dst）；
其他的
裁剪图像复制到（dst）；
//dst=QImagetocv（裁剪图像）；
imshow（“dst”，dst）；
Ptr检测器=SURF:：create（minHessian）；
Ptr提取器=SURF:：create（minHessian）；
CVT颜色（dst、src、CV_bgr2灰色）；
CVT颜色（帧、灰度图像、CV\U BGR2GRAY）；
检测器->检测（src，关键点1）；
//printf（“检测到对象：%d个关键点，\n”，（int）关键点_1.size（））；
检测器->检测（灰度图像，关键点2）；
//printf（“检测到对象：%d个关键点，\n”，（int）关键点_1.size（））；
提取器->计算（src、keypoints\u 1、img\u提取器）；
//printf（“提取了%d个描述符的对象”，img\u extractor.rows）；
提取器->计算（灰度图像、关键点、捕捉提取器）；
std：：矢量场景_角（4）；
std：：矢量obj_角（4）；
obj_角点[0]=（cvPoint（0,0））；
obj_角点[1]=（cvPoint（src.cols，0））；
obj_角点[2]=（cvPoint（src.cols，src.rows））；
obj_角点[3]=（cvPoint（0，src.行））；
向量匹配；
matcher.match（img_提取器、snap_提取器、matches）；
双最大距离=0；双最小距离=100；
//--快速计算关键点之间的最大和最小距离
for（int i=0；i最大距离）最大距离=距离；
}
//printf（“--Max dist:%f\n”，Max\u dist）；
//printf（“--最小距离：%f\n”，最小距离）；
向量良好匹配；
for（int i=0；i