Программа OpenCV / C ++ работает медленнее, чем ее numpy-аналог, что мне делать?

Некоторое время назад я реализовал алгоритм анализа Прокруста в Python, и мне недавно сказали перенести его на OpenCV / C ++. После его завершения я провел несколько тестов, и для тех же входных данных / экземпляров код C ++ занимает в два раза больше времени, чем код Python (примерно 8 против 4 секунд, соответственно. Я повторяю тесты тысячу раз, чтобы убедиться, что я Я не измеряю их за слишком маленький период). Я сбит с толку этими результатами.

Я использовал gprof, чтобы попытаться понять, что происходит, но я не могу сказать много, что ошибается, кроме того факта, что cv :: Mat :: ~ Mat () занимает 34,67% времени выполнения и вызывается в 100+ раз чаще, чем любые другие функции. Не уверен, что мне делать с этим, если только я не должен заменить cv :: Mats на std :: vectors или необработанные массивы, оба из которых могут показаться мне плохой практикой.

void align(const cv::Mat& points, const cv::Mat& pointsRef, cv::Mat& res, cv::Mat& ops) {
    cv::Mat pts(points.rows, points.cols, CV_64FC1);
    cv::Mat ptsRef(points.rows, points.cols, CV_64FC1);
    points.copyTo(pts);
    pointsRef.copyTo(ptsRef);

    cv::Mat avgs = meanOfColumns(pts);
    for(int i = 0; i < avgs.cols; i++) {
        pts.col(i) -= avgs.col(i);
    }
    cv::Mat avgsR = meanOfColumns(ptsRef);
    for(int i = 0; i < avgsR.cols; i++) {
        ptsRef.col(i) -= avgsR.col(i);
    }

    cv::Mat x2(pts.rows, 1, CV_64FC1);
    cv::Mat y2(pts.rows, 1, CV_64FC1);
    cv::Mat x2R(pts.rows, 1, CV_64FC1);
    cv::Mat y2R(pts.rows, 1, CV_64FC1);
    cv::pow(pts.col(0), 2, x2);
    cv::pow(pts.col(1), 2, y2);
    cv::pow(ptsRef.col(0), 2, x2R);
    cv::pow(ptsRef.col(1), 2, y2R);
    cv::Mat sqrootP(pts.rows, 1, CV_64FC1);
    cv::Mat sqrootPR(pts.rows, 1, CV_64FC1);
    cv::sqrt(x2R + y2R, sqrootPR);
    cv::sqrt(x2 + y2, sqrootP);
    double offsetS = (cv::mean(sqrootPR) / cv::mean(sqrootP))[0];
    pts *= offsetS;

    cv::Mat rot(pts.rows, 1, CV_64FC1);
    cv::Mat rotR(pts.rows, 1, CV_64FC1);
    rot = arctan2(pts.col(1), pts.col(0));
    rotR = arctan2(ptsRef.col(1), ptsRef.col(0));
    double offsetR = -cv::mean((rot - rotR))[0];
    cv::Mat angRot(pts.rows, 1, CV_64FC1);
    angRot = rot + offsetR;
    cv::Mat dist(pts.rows, 1, CV_64FC1);
    cv::pow(pts.col(0), 2, x2);
    cv::pow(pts.col(1), 2, y2);
    cv::sqrt(x2 + y2, dist);
    copyColumn(dist.mul(cosine(angRot)), res, 0, 0);
    copyColumn(dist.mul(sine(angRot)), res, 0, 1);

    ops.at<double>(0, 0) = -avgs.at<double>(0, 0);
    ops.at<double>(0, 1) = -avgs.at<double>(0, 1);
    ops.at<double>(0, 2) = offsetS * cv::cos(offsetR / RADIANS_TO_DEGREES);
    ops.at<double>(0, 3) = offsetS * cv::sin(offsetR / RADIANS_TO_DEGREES);
}

Это код для выровняйте 2 набора точек. Он вызывает некоторые функции, которые не показаны, но они просты, и я могу объяснить их, если необходимо, хотя я надеюсь, что их имен достаточно, чтобы понять, что они делают.

Я обычный программист на C ++, не бойтесь я, ребята.

Похоже, что Игнасио Васкес-Абрамс прав. Более краткий / прямой пример:

#include <boost/date_time/posix_time/posix_time.hpp>
#include <cv.hpp>
#include <iostream>

using namespace boost::posix_time;

int main() {
    cv::Mat m1(1000, 1000, CV_64FC1);
    cv::Mat m2(1000, 1000, CV_64FC1);
    ptime firstValue( microsec_clock::local_time() );
    for(int i = 0; i < 10; i++) {
        cv::Mat m3 = m1 * m2;
    }
    ptime secondValue( microsec_clock::local_time() );
    time_duration diff = secondValue - firstValue;
    std::cout << diff.seconds() << "." << diff.fractional_seconds() << " microsec" << std::endl;
}

На моей машине это занимает около 14+ секунд. Теперь Python:

import datetime
import numpy as np

if __name__ == '__main__':
    print datetime.datetime.now()
    m1 = np.zeros((1000, 1000), dtype=float)
    m2 = np.zeros((1000, 1000), dtype=float)
    for i in range(1000):
        m3 = np.dot(m1, m2)
    print datetime.datetime.now()

Это занимает 4+ секунды, хотя в примере C ++ это выполняется только 10 раз, а в Python (Fortran) - 1000.

Хорошо, хорошо, время обновления.

Я просмотрел Код Python, который я использовал, и понял, что он загружал только подмножество точек (около 5%) ... Это означает, что мои тесты C ++ фактически выполняли примерно в 20 раз больше экземпляров, чем код Python, поэтому код C ++ на самом деле составляет около 10 раза быстрее, поскольку код был только вдвое медленнее. По-прежнему кажется, что numpy превзошел OpenCV в некоторых операциях.