Method gradientDoG

src/CLD.cpp:146–190

}

void CLD::gradientDoG(const cv::Mat &src, cv::Mat &dst, const double rho, const double sigma_c)
{
    const double sigma_s = SIGMA_RATIO * sigma_c;
    std::vector<double> gau_c, gau_s;
    MakeGaussianVector(sigma_c, gau_c);
    MakeGaussianVector(sigma_s, gau_s);

    const int kernel = gau_s.size() - 1;

#pragma omp parallel for
    for (int y = 0; y < dst.rows; ++y) {
        for (int x = 0; x < dst.cols; ++x) {
            double gau_c_acc        = 0;
            double gau_s_acc        = 0;
            double gau_c_weight_acc = 0;
            double gau_s_weight_acc = 0;
            cv::Vec3f tmp           = etf.flowField.at<cv::Vec3f>(y, x);
            cv::Point2f gradient    = cv::Point2f(-tmp[0], tmp[1]);

            if (gradient.x == 0 && gradient.y == 0) continue;

            for (int step = -kernel; step <= kernel; ++step) {
                const double row = y + gradient.y * step;
                const double col = x + gradient.x * step;

                if (col > dst.cols - 1 || col < 0.0 || row > dst.rows - 1 || row < 0.0) continue;

                const float value = src.at<float>((int)round(row), (int)round(col));

                const int gau_idx         = abs(step);
                const double gau_c_weight = gau_c[gau_idx];
                const double gau_s_weight = gau_s[gau_idx];

                gau_c_acc += value * gau_c_weight;
                gau_s_acc += value * gau_s_weight;
                gau_c_weight_acc += gau_c_weight;
                gau_s_weight_acc += gau_s_weight;
            }

            double v_c          = gau_c_acc / gau_c_weight_acc;
            double v_s          = gau_s_acc / gau_s_weight_acc;
            dst.at<float>(y, x) = v_c - rho * v_s;
        }
    }
}

void CLD::binaryThresholding(const cv::Mat &src, cv::Mat &dst, const double tau)
{