From c2209ad5e4c6e574516f814740e6998d4d5572db Mon Sep 17 00:00:00 2001 From: Joe Howse Date: Fri, 31 Dec 2021 13:49:33 -0400 Subject: [PATCH 1/9] Doc warnings about experimental UMatUsageFlags --- modules/core/include/opencv2/core/mat.hpp | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-) diff --git a/modules/core/include/opencv2/core/mat.hpp b/modules/core/include/opencv2/core/mat.hpp index fdcb8fc817..5b5218a573 100644 --- a/modules/core/include/opencv2/core/mat.hpp +++ b/modules/core/include/opencv2/core/mat.hpp @@ -458,7 +458,16 @@ CV_EXPORTS InputOutputArray noArray(); /////////////////////////////////// MatAllocator ////////////////////////////////////// -//! Usage flags for allocator +/** @brief Usage flags for allocator + + @warning All flags except `USAGE_DEFAULT` are experimental. + + @warning For the OpenCL allocator, `USAGE_ALLOCATE_SHARED_MEMORY` depends on + OpenCV's optional, experimental integration with OpenCL SVM. To enable this + integration, build OpenCV using the `WITH_OPENCL_SVM=ON` CMake option and, at + runtime, call `cv::ocl::Context::getDefault().setUseSVM(true);` or similar + code. Note that SVM is incompatible with OpenCL 1.x. +*/ enum UMatUsageFlags { USAGE_DEFAULT = 0, From c685293297ae8b17edcd9230101463771a25ae58 Mon Sep 17 00:00:00 2001 From: Stefano Allegretti Date: Mon, 3 Jan 2022 18:15:09 +0100 Subject: [PATCH 2/9] Fix #21366 --- modules/imgproc/src/connectedcomponents.cpp | 6 +++--- modules/imgproc/test/test_connectedcomponents.cpp | 11 +++++++++++ 2 files changed, 14 insertions(+), 3 deletions(-) diff --git a/modules/imgproc/src/connectedcomponents.cpp b/modules/imgproc/src/connectedcomponents.cpp index 1ad74ed38a..f2d41f454d 100644 --- a/modules/imgproc/src/connectedcomponents.cpp +++ b/modules/imgproc/src/connectedcomponents.cpp @@ -1570,7 +1570,7 @@ namespace cv{ #define CONDITION_S img_row[c - 1] > 0 #define CONDITION_X img_row[c] > 0 -#define ACTION_1 // nothing to do +#define ACTION_1 img_labels_row[c] = 0; #define ACTION_2 img_labels_row[c] = label; \ P_[label] = label; \ label = label + 1; @@ -1831,7 +1831,7 @@ namespace cv{ std::vector P_(Plength, 0); LabelT* P = P_.data(); - //P[0] = 0; + P[0] = 0; LabelT lunique = 1; // First scan @@ -1851,7 +1851,7 @@ namespace cv{ #define CONDITION_S img_row[c - 1] > 0 #define CONDITION_X img_row[c] > 0 -#define ACTION_1 // nothing to do +#define ACTION_1 img_labels_row[c] = 0; #define ACTION_2 img_labels_row[c] = lunique; \ P[lunique] = lunique; \ lunique = lunique + 1; // new label diff --git a/modules/imgproc/test/test_connectedcomponents.cpp b/modules/imgproc/test/test_connectedcomponents.cpp index ed11ea6fda..e1a6b761c7 100644 --- a/modules/imgproc/test/test_connectedcomponents.cpp +++ b/modules/imgproc/test/test_connectedcomponents.cpp @@ -789,5 +789,16 @@ TEST(Imgproc_ConnectedComponents, single_column) } +TEST(Imgproc_ConnectedComponents, 4conn_regression_21366) +{ + Mat src = Mat::zeros(Size(10, 10), CV_8UC1); + { + Mat labels, stats, centroids; + EXPECT_NO_THROW(cv::connectedComponentsWithStats(src, labels, stats, centroids, 4)); + } +} + + + } } // namespace From f6fe5c07f61eb0bc934672200b2bfd453f2fc41d Mon Sep 17 00:00:00 2001 From: Alexander Alekhin Date: Tue, 4 Jan 2022 12:48:27 +0000 Subject: [PATCH 3/9] copyright: 2022 --- LICENSE | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/LICENSE b/LICENSE index b6c6296125..3003954c3f 100644 --- a/LICENSE +++ b/LICENSE @@ -7,13 +7,13 @@ copy or use the software. For Open Source Computer Vision Library (3-clause BSD License) -Copyright (C) 2000-2021, Intel Corporation, all rights reserved. +Copyright (C) 2000-2022, Intel Corporation, all rights reserved. Copyright (C) 2009-2011, Willow Garage Inc., all rights reserved. Copyright (C) 2009-2016, NVIDIA Corporation, all rights reserved. Copyright (C) 2010-2013, Advanced Micro Devices, Inc., all rights reserved. -Copyright (C) 2015-2021, OpenCV Foundation, all rights reserved. +Copyright (C) 2015-2022, OpenCV Foundation, all rights reserved. Copyright (C) 2015-2016, Itseez Inc., all rights reserved. -Copyright (C) 2019-2021, Xperience AI, all rights reserved. +Copyright (C) 2019-2022, Xperience AI, all rights reserved. Third party copyrights are property of their respective owners. Redistribution and use in source and binary forms, with or without modification, From bf5e09d5abb2946dfcf85b1743cd2c89d75b3228 Mon Sep 17 00:00:00 2001 From: Vincent Rabaud Date: Wed, 5 Jan 2022 13:42:55 +0100 Subject: [PATCH 4/9] Remove unnecessary use of ref-capture in code example. --- modules/core/include/opencv2/core/mat.hpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/modules/core/include/opencv2/core/mat.hpp b/modules/core/include/opencv2/core/mat.hpp index 5b5218a573..919fa0b6f9 100644 --- a/modules/core/include/opencv2/core/mat.hpp +++ b/modules/core/include/opencv2/core/mat.hpp @@ -2100,7 +2100,7 @@ public: Mat_ image = Mat::zeros(3, sizes, CV_8UC3); - image.forEach([&](Pixel& pixel, const int position[]) -> void { + image.forEach([](Pixel& pixel, const int position[]) -> void { pixel.x = position[0]; pixel.y = position[1]; pixel.z = position[2]; From f3e0479a8f5cec08831051953f41776b8903305a Mon Sep 17 00:00:00 2001 From: Christoph Rackwitz Date: Sat, 8 Jan 2022 23:42:21 +0100 Subject: [PATCH 5/9] kmeans: assertion "There can't be more clusters than elements" --- modules/core/src/kmeans.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/modules/core/src/kmeans.cpp b/modules/core/src/kmeans.cpp index 544882ef1d..f5a5bc5c6c 100644 --- a/modules/core/src/kmeans.cpp +++ b/modules/core/src/kmeans.cpp @@ -240,7 +240,7 @@ double cv::kmeans( InputArray _data, int K, attempts = std::max(attempts, 1); CV_Assert( data0.dims <= 2 && type == CV_32F && K > 0 ); - CV_CheckGE(N, K, "Number of clusters should be more than number of elements"); + CV_CheckGE(N, K, "There can't be more clusters than elements"); Mat data(N, dims, CV_32F, data0.ptr(), isrow ? dims * sizeof(float) : static_cast(data0.step)); From 05dbaf7672729fc5a9d02bd76bfe93595419a16b Mon Sep 17 00:00:00 2001 From: Alexander Alekhin Date: Mon, 10 Jan 2022 12:16:01 +0300 Subject: [PATCH 6/9] videoio(msmf): use info message in SourceReaderCB destructor --- modules/videoio/src/cap_msmf.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/modules/videoio/src/cap_msmf.cpp b/modules/videoio/src/cap_msmf.cpp index fcc9260584..bb0dea4121 100644 --- a/modules/videoio/src/cap_msmf.cpp +++ b/modules/videoio/src/cap_msmf.cpp @@ -449,7 +449,7 @@ private: // Destructor is private. Caller should call Release. virtual ~SourceReaderCB() { - CV_LOG_WARNING(NULL, "terminating async callback"); + CV_LOG_INFO(NULL, "terminating async callback"); } public: From 649f747f8a418c6df5853b7b0940ac3826573ad2 Mon Sep 17 00:00:00 2001 From: h6197627 <44726212+h6197627@users.noreply.github.com> Date: Mon, 10 Jan 2022 13:51:07 +0200 Subject: [PATCH 7/9] Merge pull request #21405 from h6197627:3.4 * Use c++ namespaces explicitly * Add root cv c++ namespace --- modules/calib3d/src/dls.cpp | 208 ++++++++++++++++--------------- modules/calib3d/src/dls.h | 52 ++++---- modules/calib3d/src/solvepnp.cpp | 20 +-- 3 files changed, 141 insertions(+), 139 deletions(-) diff --git a/modules/calib3d/src/dls.cpp b/modules/calib3d/src/dls.cpp index a0ff0c3e1e..f0b9d850e9 100644 --- a/modules/calib3d/src/dls.cpp +++ b/modules/calib3d/src/dls.cpp @@ -21,15 +21,15 @@ # include "opencv2/core/eigen.hpp" #endif -using namespace std; +namespace cv { -dls::dls(const cv::Mat& opoints, const cv::Mat& ipoints) +dls::dls(const Mat& opoints, const Mat& ipoints) { - N = std::max(opoints.checkVector(3, CV_32F), opoints.checkVector(3, CV_64F)); - p = cv::Mat(3, N, CV_64F); - z = cv::Mat(3, N, CV_64F); - mn = cv::Mat::zeros(3, 1, CV_64F); + N = std::max(opoints.checkVector(3, CV_32F), opoints.checkVector(3, CV_64F)); + p = Mat(3, N, CV_64F); + z = Mat(3, N, CV_64F); + mn = Mat::zeros(3, 1, CV_64F); cost__ = 9999; @@ -40,14 +40,14 @@ dls::dls(const cv::Mat& opoints, const cv::Mat& ipoints) if (opoints.depth() == ipoints.depth()) { if (opoints.depth() == CV_32F) - init_points(opoints, ipoints); + init_points(opoints, ipoints); else - init_points(opoints, ipoints); + init_points(opoints, ipoints); } else if (opoints.depth() == CV_32F) - init_points(opoints, ipoints); + init_points(opoints, ipoints); else - init_points(opoints, ipoints); + init_points(opoints, ipoints); } dls::~dls() @@ -55,10 +55,10 @@ dls::~dls() // TODO Auto-generated destructor stub } -bool dls::compute_pose(cv::Mat& R, cv::Mat& t) +bool dls::compute_pose(Mat& R, Mat& t) { - std::vector R_; + std::vector R_; R_.push_back(rotx(CV_PI/2)); R_.push_back(roty(CV_PI/2)); R_.push_back(rotz(CV_PI/2)); @@ -67,7 +67,7 @@ bool dls::compute_pose(cv::Mat& R, cv::Mat& t) for (int i = 0; i < 3; ++i) { // Make a random rotation - cv::Mat pp = R_[i] * ( p - cv::repeat(mn, 1, p.cols) ); + Mat pp = R_[i] * ( p - repeat(mn, 1, p.cols) ); // clear for new data C_est_.clear(); @@ -99,13 +99,13 @@ bool dls::compute_pose(cv::Mat& R, cv::Mat& t) return false; } -void dls::run_kernel(const cv::Mat& pp) +void dls::run_kernel(const Mat& pp) { - cv::Mat Mtilde(27, 27, CV_64F); - cv::Mat D = cv::Mat::zeros(9, 9, CV_64F); + Mat Mtilde(27, 27, CV_64F); + Mat D = Mat::zeros(9, 9, CV_64F); build_coeff_matrix(pp, Mtilde, D); - cv::Mat eigenval_r, eigenval_i, eigenvec_r, eigenvec_i; + Mat eigenval_r, eigenval_i, eigenvec_r, eigenvec_i; compute_eigenvec(Mtilde, eigenval_r, eigenval_i, eigenvec_r, eigenvec_i); /* @@ -115,16 +115,16 @@ void dls::run_kernel(const cv::Mat& pp) // extract the optimal solutions from the eigen decomposition of the // Multiplication matrix - cv::Mat sols = cv::Mat::zeros(3, 27, CV_64F); + Mat sols = Mat::zeros(3, 27, CV_64F); std::vector cost; int count = 0; for (int k = 0; k < 27; ++k) { // V(:,k) = V(:,k)/V(1,k); - cv::Mat V_kA = eigenvec_r.col(k); // 27x1 - cv::Mat V_kB = cv::Mat(1, 1, z.depth(), V_kA.at(0)); // 1x1 - cv::Mat V_k; cv::solve(V_kB.t(), V_kA.t(), V_k); // A/B = B'\A' - cv::Mat( V_k.t()).copyTo( eigenvec_r.col(k) ); + Mat V_kA = eigenvec_r.col(k); // 27x1 + Mat V_kB = Mat(1, 1, z.depth(), V_kA.at(0)); // 1x1 + Mat V_k; solve(V_kB.t(), V_kA.t(), V_k); // A/B = B'\A' + Mat( V_k.t()).copyTo( eigenvec_r.col(k) ); //if (imag(V(2,k)) == 0) #ifdef HAVE_EIGEN @@ -138,24 +138,24 @@ void dls::run_kernel(const cv::Mat& pp) stmp[1] = eigenvec_r.at(3, k); stmp[2] = eigenvec_r.at(1, k); - cv::Mat H = Hessian(stmp); + Mat H = Hessian(stmp); - cv::Mat eigenvalues, eigenvectors; - cv::eigen(H, eigenvalues, eigenvectors); + Mat eigenvalues, eigenvectors; + eigen(H, eigenvalues, eigenvectors); if(positive_eigenvalues(&eigenvalues)) { // sols(:,i) = stmp; - cv::Mat stmp_mat(3, 1, CV_64F, &stmp); + Mat stmp_mat(3, 1, CV_64F, &stmp); stmp_mat.copyTo( sols.col(count) ); - cv::Mat Cbar = cayley2rotbar(stmp_mat); - cv::Mat Cbarvec = Cbar.reshape(1,1).t(); + Mat Cbar = cayley2rotbar(stmp_mat); + Mat Cbarvec = Cbar.reshape(1,1).t(); // cost(i) = CbarVec' * D * CbarVec; - cv::Mat cost_mat = Cbarvec.t() * D * Cbarvec; + Mat cost_mat = Cbarvec.t() * D * Cbarvec; cost.push_back( cost_mat.at(0) ); count++; @@ -166,30 +166,30 @@ void dls::run_kernel(const cv::Mat& pp) // extract solutions sols = sols.clone().colRange(0, count); - std::vector C_est, t_est; + std::vector C_est, t_est; for (int j = 0; j < sols.cols; ++j) { // recover the optimal orientation // C_est(:,:,j) = 1/(1 + sols(:,j)' * sols(:,j)) * cayley2rotbar(sols(:,j)); - cv::Mat sols_j = sols.col(j); - double sols_mult = 1./(1.+cv::Mat( sols_j.t() * sols_j ).at(0)); - cv::Mat C_est_j = cayley2rotbar(sols_j).mul(sols_mult); + Mat sols_j = sols.col(j); + double sols_mult = 1./(1.+Mat( sols_j.t() * sols_j ).at(0)); + Mat C_est_j = cayley2rotbar(sols_j).mul(sols_mult); C_est.push_back( C_est_j ); - cv::Mat A2 = cv::Mat::zeros(3, 3, CV_64F); - cv::Mat b2 = cv::Mat::zeros(3, 1, CV_64F); + Mat A2 = Mat::zeros(3, 3, CV_64F); + Mat b2 = Mat::zeros(3, 1, CV_64F); for (int i = 0; i < N; ++i) { - cv::Mat eye = cv::Mat::eye(3, 3, CV_64F); - cv::Mat z_mul = z.col(i)*z.col(i).t(); + Mat eye = Mat::eye(3, 3, CV_64F); + Mat z_mul = z.col(i)*z.col(i).t(); A2 += eye - z_mul; b2 += (z_mul - eye) * C_est_j * pp.col(i); } // recover the optimal translation - cv::Mat X2; cv::solve(A2, b2, X2); // A\B + Mat X2; solve(A2, b2, X2); // A\B t_est.push_back(X2); } @@ -197,12 +197,12 @@ void dls::run_kernel(const cv::Mat& pp) // check that the points are infront of the center of perspectivity for (int k = 0; k < sols.cols; ++k) { - cv::Mat cam_points = C_est[k] * pp + cv::repeat(t_est[k], 1, pp.cols); - cv::Mat cam_points_k = cam_points.row(2); + Mat cam_points = C_est[k] * pp + repeat(t_est[k], 1, pp.cols); + Mat cam_points_k = cam_points.row(2); if(is_empty(&cam_points_k)) { - cv::Mat C_valid = C_est[k], t_valid = t_est[k]; + Mat C_valid = C_est[k], t_valid = t_est[k]; double cost_valid = cost[k]; C_est_.push_back(C_valid); @@ -213,20 +213,20 @@ void dls::run_kernel(const cv::Mat& pp) } -void dls::build_coeff_matrix(const cv::Mat& pp, cv::Mat& Mtilde, cv::Mat& D) +void dls::build_coeff_matrix(const Mat& pp, Mat& Mtilde, Mat& D) { CV_Assert(!pp.empty() && N > 0); - cv::Mat eye = cv::Mat::eye(3, 3, CV_64F); + Mat eye = Mat::eye(3, 3, CV_64F); // build coeff matrix // An intermediate matrix, the inverse of what is called "H" in the paper // (see eq. 25) - cv::Mat H = cv::Mat::zeros(3, 3, CV_64F); - cv::Mat A = cv::Mat::zeros(3, 9, CV_64F); - cv::Mat pp_i(3, 1, CV_64F); + Mat H = Mat::zeros(3, 3, CV_64F); + Mat A = Mat::zeros(3, 9, CV_64F); + Mat pp_i(3, 1, CV_64F); - cv::Mat z_i(3, 1, CV_64F); + Mat z_i(3, 1, CV_64F); for (int i = 0; i < N; ++i) { z.col(i).copyTo(z_i); @@ -236,10 +236,10 @@ void dls::build_coeff_matrix(const cv::Mat& pp, cv::Mat& Mtilde, cv::Mat& D) H = eye.mul(N) - z * z.t(); // A\B - cv::solve(H, A, A, cv::DECOMP_NORMAL); + solve(H, A, A, DECOMP_NORMAL); H.release(); - cv::Mat ppi_A(3, 1, CV_64F); + Mat ppi_A(3, 1, CV_64F); for (int i = 0; i < N; ++i) { z.col(i).copyTo(z_i); @@ -253,18 +253,18 @@ void dls::build_coeff_matrix(const cv::Mat& pp, cv::Mat& Mtilde, cv::Mat& D) // generate random samples std::vector u(5); - cv::randn(u, 0, 200); + randn(u, 0, 200); - cv::Mat M2 = cayley_LS_M(f1coeff, f2coeff, f3coeff, u); + Mat M2 = cayley_LS_M(f1coeff, f2coeff, f3coeff, u); - cv::Mat M2_1 = M2(cv::Range(0,27), cv::Range(0,27)); - cv::Mat M2_2 = M2(cv::Range(0,27), cv::Range(27,120)); - cv::Mat M2_3 = M2(cv::Range(27,120), cv::Range(27,120)); - cv::Mat M2_4 = M2(cv::Range(27,120), cv::Range(0,27)); + Mat M2_1 = M2(Range(0,27), Range(0,27)); + Mat M2_2 = M2(Range(0,27), Range(27,120)); + Mat M2_3 = M2(Range(27,120), Range(27,120)); + Mat M2_4 = M2(Range(27,120), Range(0,27)); M2.release(); // A/B = B'\A' - cv::Mat M2_5; cv::solve(M2_3.t(), M2_2.t(), M2_5); + Mat M2_5; solve(M2_3.t(), M2_2.t(), M2_5); M2_2.release(); M2_3.release(); // construct the multiplication matrix via schur compliment of the Macaulay @@ -273,13 +273,13 @@ void dls::build_coeff_matrix(const cv::Mat& pp, cv::Mat& Mtilde, cv::Mat& D) } -void dls::compute_eigenvec(const cv::Mat& Mtilde, cv::Mat& eigenval_real, cv::Mat& eigenval_imag, - cv::Mat& eigenvec_real, cv::Mat& eigenvec_imag) +void dls::compute_eigenvec(const Mat& Mtilde, Mat& eigenval_real, Mat& eigenval_imag, + Mat& eigenvec_real, Mat& eigenvec_imag) { #ifdef HAVE_EIGEN Eigen::MatrixXd Mtilde_eig, zeros_eig; - cv::cv2eigen(Mtilde, Mtilde_eig); - cv::cv2eigen(cv::Mat::zeros(27, 27, CV_64F), zeros_eig); + cv2eigen(Mtilde, Mtilde_eig); + cv2eigen(Mat::zeros(27, 27, CV_64F), zeros_eig); Eigen::MatrixXcd Mtilde_eig_cmplx(27, 27); Mtilde_eig_cmplx.real() = Mtilde_eig; @@ -293,20 +293,20 @@ void dls::compute_eigenvec(const cv::Mat& Mtilde, cv::Mat& eigenval_real, cv::Ma Eigen::MatrixXd eigvec_real = ces.eigenvectors().real(); Eigen::MatrixXd eigvec_imag = ces.eigenvectors().imag(); - cv::eigen2cv(eigval_real, eigenval_real); - cv::eigen2cv(eigval_imag, eigenval_imag); - cv::eigen2cv(eigvec_real, eigenvec_real); - cv::eigen2cv(eigvec_imag, eigenvec_imag); + eigen2cv(eigval_real, eigenval_real); + eigen2cv(eigval_imag, eigenval_imag); + eigen2cv(eigvec_real, eigenvec_real); + eigen2cv(eigvec_imag, eigenvec_imag); #else EigenvalueDecomposition es(Mtilde); eigenval_real = es.eigenvalues(); eigenvec_real = es.eigenvectors(); - eigenval_imag = eigenvec_imag = cv::Mat(); + eigenval_imag = eigenvec_imag = Mat(); #endif } -void dls::fill_coeff(const cv::Mat * D_mat) +void dls::fill_coeff(const Mat * D_mat) { // TODO: shift D and coefficients one position to left @@ -394,9 +394,9 @@ void dls::fill_coeff(const cv::Mat * D_mat) } -cv::Mat dls::LeftMultVec(const cv::Mat& v) +Mat dls::LeftMultVec(const Mat& v) { - cv::Mat mat_ = cv::Mat::zeros(3, 9, CV_64F); + Mat mat_ = Mat::zeros(3, 9, CV_64F); for (int i = 0; i < 3; ++i) { @@ -407,12 +407,12 @@ cv::Mat dls::LeftMultVec(const cv::Mat& v) return mat_; } -cv::Mat dls::cayley_LS_M(const std::vector& a, const std::vector& b, const std::vector& c, const std::vector& u) +Mat dls::cayley_LS_M(const std::vector& a, const std::vector& b, const std::vector& c, const std::vector& u) { // TODO: input matrix pointer // TODO: shift coefficients one position to left - cv::Mat M = cv::Mat::zeros(120, 120, CV_64F); + Mat M = Mat::zeros(120, 120, CV_64F); M.at(0,0)=u[1]; M.at(0,35)=a[1]; M.at(0,83)=b[1]; M.at(0,118)=c[1]; M.at(1,0)=u[4]; M.at(1,1)=u[1]; M.at(1,34)=a[1]; M.at(1,35)=a[10]; M.at(1,54)=b[1]; M.at(1,83)=b[10]; M.at(1,99)=c[1]; M.at(1,118)=c[10]; @@ -538,7 +538,7 @@ cv::Mat dls::cayley_LS_M(const std::vector& a, const std::vector return M.t(); } -cv::Mat dls::Hessian(const double s[]) +Mat dls::Hessian(const double s[]) { // the vector of monomials is // m = [ const ; s1^2 * s2 ; s1 * s2 ; s1 * s3 ; s2 * s3 ; s2^2 * s3 ; s2^3 ; ... @@ -577,73 +577,73 @@ cv::Mat dls::Hessian(const double s[]) Hs3[14]=0; Hs3[15]=3*s[2]*s[2]; Hs3[16]=s[0]*s[1]; Hs3[17]=0; Hs3[18]=s[0]*s[0]; Hs3[19]=0; // fill Hessian matrix - cv::Mat H(3, 3, CV_64F); - H.at(0,0) = cv::Mat(cv::Mat(f1coeff).rowRange(1,21).t()*cv::Mat(20, 1, CV_64F, &Hs1)).at(0,0); - H.at(0,1) = cv::Mat(cv::Mat(f1coeff).rowRange(1,21).t()*cv::Mat(20, 1, CV_64F, &Hs2)).at(0,0); - H.at(0,2) = cv::Mat(cv::Mat(f1coeff).rowRange(1,21).t()*cv::Mat(20, 1, CV_64F, &Hs3)).at(0,0); + Mat H(3, 3, CV_64F); + H.at(0,0) = Mat(Mat(f1coeff).rowRange(1,21).t()*Mat(20, 1, CV_64F, &Hs1)).at(0,0); + H.at(0,1) = Mat(Mat(f1coeff).rowRange(1,21).t()*Mat(20, 1, CV_64F, &Hs2)).at(0,0); + H.at(0,2) = Mat(Mat(f1coeff).rowRange(1,21).t()*Mat(20, 1, CV_64F, &Hs3)).at(0,0); - H.at(1,0) = cv::Mat(cv::Mat(f2coeff).rowRange(1,21).t()*cv::Mat(20, 1, CV_64F, &Hs1)).at(0,0); - H.at(1,1) = cv::Mat(cv::Mat(f2coeff).rowRange(1,21).t()*cv::Mat(20, 1, CV_64F, &Hs2)).at(0,0); - H.at(1,2) = cv::Mat(cv::Mat(f2coeff).rowRange(1,21).t()*cv::Mat(20, 1, CV_64F, &Hs3)).at(0,0); + H.at(1,0) = Mat(Mat(f2coeff).rowRange(1,21).t()*Mat(20, 1, CV_64F, &Hs1)).at(0,0); + H.at(1,1) = Mat(Mat(f2coeff).rowRange(1,21).t()*Mat(20, 1, CV_64F, &Hs2)).at(0,0); + H.at(1,2) = Mat(Mat(f2coeff).rowRange(1,21).t()*Mat(20, 1, CV_64F, &Hs3)).at(0,0); - H.at(2,0) = cv::Mat(cv::Mat(f3coeff).rowRange(1,21).t()*cv::Mat(20, 1, CV_64F, &Hs1)).at(0,0); - H.at(2,1) = cv::Mat(cv::Mat(f3coeff).rowRange(1,21).t()*cv::Mat(20, 1, CV_64F, &Hs2)).at(0,0); - H.at(2,2) = cv::Mat(cv::Mat(f3coeff).rowRange(1,21).t()*cv::Mat(20, 1, CV_64F, &Hs3)).at(0,0); + H.at(2,0) = Mat(Mat(f3coeff).rowRange(1,21).t()*Mat(20, 1, CV_64F, &Hs1)).at(0,0); + H.at(2,1) = Mat(Mat(f3coeff).rowRange(1,21).t()*Mat(20, 1, CV_64F, &Hs2)).at(0,0); + H.at(2,2) = Mat(Mat(f3coeff).rowRange(1,21).t()*Mat(20, 1, CV_64F, &Hs3)).at(0,0); return H; } -cv::Mat dls::cayley2rotbar(const cv::Mat& s) +Mat dls::cayley2rotbar(const Mat& s) { - double s_mul1 = cv::Mat(s.t()*s).at(0,0); - cv::Mat s_mul2 = s*s.t(); - cv::Mat eye = cv::Mat::eye(3, 3, CV_64F); + double s_mul1 = Mat(s.t()*s).at(0,0); + Mat s_mul2 = s*s.t(); + Mat eye = Mat::eye(3, 3, CV_64F); - return cv::Mat( eye.mul(1.-s_mul1) + skewsymm(&s).mul(2.) + s_mul2.mul(2.) ).t(); + return Mat( eye.mul(1.-s_mul1) + skewsymm(&s).mul(2.) + s_mul2.mul(2.) ).t(); } -cv::Mat dls::skewsymm(const cv::Mat * X1) +Mat dls::skewsymm(const Mat * X1) { - cv::MatConstIterator_ it = X1->begin(); - return (cv::Mat_(3,3) << 0, -*(it+2), *(it+1), - *(it+2), 0, -*(it+0), - -*(it+1), *(it+0), 0); + MatConstIterator_ it = X1->begin(); + return (Mat_(3,3) << 0, -*(it+2), *(it+1), + *(it+2), 0, -*(it+0), + -*(it+1), *(it+0), 0); } -cv::Mat dls::rotx(const double t) +Mat dls::rotx(const double t) { // rotx: rotation about y-axis double ct = cos(t); double st = sin(t); - return (cv::Mat_(3,3) << 1, 0, 0, 0, ct, -st, 0, st, ct); + return (Mat_(3,3) << 1, 0, 0, 0, ct, -st, 0, st, ct); } -cv::Mat dls::roty(const double t) +Mat dls::roty(const double t) { // roty: rotation about y-axis double ct = cos(t); double st = sin(t); - return (cv::Mat_(3,3) << ct, 0, st, 0, 1, 0, -st, 0, ct); + return (Mat_(3,3) << ct, 0, st, 0, 1, 0, -st, 0, ct); } -cv::Mat dls::rotz(const double t) +Mat dls::rotz(const double t) { // rotz: rotation about y-axis double ct = cos(t); double st = sin(t); - return (cv::Mat_(3,3) << ct, -st, 0, st, ct, 0, 0, 0, 1); + return (Mat_(3,3) << ct, -st, 0, st, ct, 0, 0, 0, 1); } -cv::Mat dls::mean(const cv::Mat& M) +Mat dls::mean(const Mat& M) { - cv::Mat m = cv::Mat::zeros(3, 1, CV_64F); + Mat m = Mat::zeros(3, 1, CV_64F); for (int i = 0; i < M.cols; ++i) m += M.col(i); return m.mul(1./(double)M.cols); } -bool dls::is_empty(const cv::Mat * M) +bool dls::is_empty(const Mat * M) { - cv::MatConstIterator_ it = M->begin(), it_end = M->end(); + MatConstIterator_ it = M->begin(), it_end = M->end(); for(; it != it_end; ++it) { if(*it < 0) return false; @@ -651,9 +651,11 @@ bool dls::is_empty(const cv::Mat * M) return true; } -bool dls::positive_eigenvalues(const cv::Mat * eigenvalues) +bool dls::positive_eigenvalues(const Mat * eigenvalues) { CV_Assert(eigenvalues && !eigenvalues->empty()); - cv::MatConstIterator_ it = eigenvalues->begin(); + MatConstIterator_ it = eigenvalues->begin(); return *(it) > 0 && *(it+1) > 0 && *(it+2) > 0; } + +} // namespace cv diff --git a/modules/calib3d/src/dls.h b/modules/calib3d/src/dls.h index f03bee49d7..a3382498c9 100644 --- a/modules/calib3d/src/dls.h +++ b/modules/calib3d/src/dls.h @@ -5,22 +5,21 @@ #include -using namespace std; -using namespace cv; +namespace cv { class dls { public: - dls(const cv::Mat& opoints, const cv::Mat& ipoints); + dls(const Mat& opoints, const Mat& ipoints); ~dls(); - bool compute_pose(cv::Mat& R, cv::Mat& t); + bool compute_pose(Mat& R, Mat& t); private: // initialisation template - void init_points(const cv::Mat& opoints, const cv::Mat& ipoints) + void init_points(const Mat& opoints, const Mat& ipoints) { for(int i = 0; i < N; i++) { @@ -49,33 +48,33 @@ private: } // main algorithm - cv::Mat LeftMultVec(const cv::Mat& v); - void run_kernel(const cv::Mat& pp); - void build_coeff_matrix(const cv::Mat& pp, cv::Mat& Mtilde, cv::Mat& D); - void compute_eigenvec(const cv::Mat& Mtilde, cv::Mat& eigenval_real, cv::Mat& eigenval_imag, - cv::Mat& eigenvec_real, cv::Mat& eigenvec_imag); - void fill_coeff(const cv::Mat * D); + Mat LeftMultVec(const Mat& v); + void run_kernel(const Mat& pp); + void build_coeff_matrix(const Mat& pp, Mat& Mtilde, Mat& D); + void compute_eigenvec(const Mat& Mtilde, Mat& eigenval_real, Mat& eigenval_imag, + Mat& eigenvec_real, Mat& eigenvec_imag); + void fill_coeff(const Mat * D); // useful functions - cv::Mat cayley_LS_M(const std::vector& a, const std::vector& b, - const std::vector& c, const std::vector& u); - cv::Mat Hessian(const double s[]); - cv::Mat cayley2rotbar(const cv::Mat& s); - cv::Mat skewsymm(const cv::Mat * X1); + Mat cayley_LS_M(const std::vector& a, const std::vector& b, + const std::vector& c, const std::vector& u); + Mat Hessian(const double s[]); + Mat cayley2rotbar(const Mat& s); + Mat skewsymm(const Mat * X1); // extra functions - cv::Mat rotx(const double t); - cv::Mat roty(const double t); - cv::Mat rotz(const double t); - cv::Mat mean(const cv::Mat& M); - bool is_empty(const cv::Mat * v); - bool positive_eigenvalues(const cv::Mat * eigenvalues); + Mat rotx(const double t); + Mat roty(const double t); + Mat rotz(const double t); + Mat mean(const Mat& M); + bool is_empty(const Mat * v); + bool positive_eigenvalues(const Mat * eigenvalues); - cv::Mat p, z, mn; // object-image points + Mat p, z, mn; // object-image points int N; // number of input points std::vector f1coeff, f2coeff, f3coeff, cost_; // coefficient for coefficients matrix - std::vector C_est_, t_est_; // optimal candidates - cv::Mat C_est__, t_est__; // optimal found solution + std::vector C_est_, t_est_; // optimal candidates + Mat C_est__, t_est__; // optimal found solution double cost__; // optimal found solution }; @@ -738,7 +737,7 @@ public: { /*if(isSymmetric(src)) { // Fall back to OpenCV for a symmetric matrix! - cv::eigen(src, _eigenvalues, _eigenvectors); + eigen(src, _eigenvalues, _eigenvectors); } else {*/ Mat tmp; // Convert the given input matrix to double. Is there any way to @@ -770,4 +769,5 @@ public: Mat eigenvectors() { return _eigenvectors; } }; +} // namespace cv #endif // DLS_H diff --git a/modules/calib3d/src/solvepnp.cpp b/modules/calib3d/src/solvepnp.cpp index ad5c85b222..6ed88edab5 100644 --- a/modules/calib3d/src/solvepnp.cpp +++ b/modules/calib3d/src/solvepnp.cpp @@ -100,12 +100,12 @@ void drawFrameAxes(InputOutputArray image, InputArray cameraMatrix, InputArray d CV_Assert(length > 0); // project axes points - vector axesPoints; + std::vector axesPoints; axesPoints.push_back(Point3f(0, 0, 0)); axesPoints.push_back(Point3f(length, 0, 0)); axesPoints.push_back(Point3f(0, length, 0)); axesPoints.push_back(Point3f(0, 0, length)); - vector imagePoints; + std::vector imagePoints; projectPoints(axesPoints, rvec, tvec, cameraMatrix, distCoeffs, imagePoints); // draw axes lines @@ -120,7 +120,7 @@ bool solvePnP( InputArray opoints, InputArray ipoints, { CV_INSTRUMENT_REGION(); - vector rvecs, tvecs; + std::vector rvecs, tvecs; int solutions = solvePnPGeneric(opoints, ipoints, cameraMatrix, distCoeffs, rvecs, tvecs, useExtrinsicGuess, (SolvePnPMethod)flags, rvec, tvec); if (solutions > 0) @@ -298,8 +298,8 @@ bool solvePnPRansac(InputArray _opoints, InputArray _ipoints, return false; } - vector opoints_inliers; - vector ipoints_inliers; + std::vector opoints_inliers; + std::vector ipoints_inliers; opoints = opoints.reshape(3); ipoints = ipoints.reshape(2); opoints.convertTo(opoints_inliers, CV_64F); @@ -420,7 +420,7 @@ int solveP3P( InputArray _opoints, InputArray _ipoints, else imgPts = imgPts.reshape(1, 2*imgPts.rows); - vector reproj_errors(solutions); + std::vector reproj_errors(solutions); for (size_t i = 0; i < reproj_errors.size(); i++) { Mat rvec; @@ -710,7 +710,7 @@ static void solvePnPRefine(InputArray _objectPoints, InputArray _imagePoints, rvec0.convertTo(rvec, CV_64F); tvec0.convertTo(tvec, CV_64F); - vector ipoints_normalized; + std::vector ipoints_normalized; undistortPoints(ipoints, ipoints_normalized, cameraMatrix, distCoeffs); Mat sd = Mat(ipoints_normalized).reshape(1, npoints*2); Mat objectPoints0 = opoints.reshape(1, npoints); @@ -804,7 +804,7 @@ int solvePnPGeneric( InputArray _opoints, InputArray _ipoints, Mat cameraMatrix = Mat_(cameraMatrix0); Mat distCoeffs = Mat_(distCoeffs0); - vector vec_rvecs, vec_tvecs; + std::vector vec_rvecs, vec_tvecs; if (flags == SOLVEPNP_EPNP || flags == SOLVEPNP_DLS || flags == SOLVEPNP_UPNP) { if (flags == SOLVEPNP_DLS) @@ -829,7 +829,7 @@ int solvePnPGeneric( InputArray _opoints, InputArray _ipoints, } else if (flags == SOLVEPNP_P3P || flags == SOLVEPNP_AP3P) { - vector rvecs, tvecs; + std::vector rvecs, tvecs; solveP3P(opoints, ipoints, _cameraMatrix, _distCoeffs, rvecs, tvecs, flags); vec_rvecs.insert(vec_rvecs.end(), rvecs.begin(), rvecs.end()); vec_tvecs.insert(vec_tvecs.end(), tvecs.begin(), tvecs.end()); @@ -1082,7 +1082,7 @@ int solvePnPGeneric( InputArray _opoints, InputArray _ipoints, for (size_t i = 0; i < vec_rvecs.size(); i++) { - vector projectedPoints; + std::vector projectedPoints; projectPoints(objectPoints, vec_rvecs[i], vec_tvecs[i], cameraMatrix, distCoeffs, projectedPoints); double rmse = norm(Mat(projectedPoints, false), imagePoints, NORM_L2) / sqrt(2*projectedPoints.size()); From 4db3a388ddef8799fa97e6e38dd8971ba2b25221 Mon Sep 17 00:00:00 2001 From: Vincent Rabaud Date: Tue, 11 Jan 2022 12:01:47 +0100 Subject: [PATCH 8/9] Fix a potential UBSAN error. We only use that value as uint64_t below anyway. --- modules/core/src/matrix.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/modules/core/src/matrix.cpp b/modules/core/src/matrix.cpp index 1deff6b450..be3dcc2608 100644 --- a/modules/core/src/matrix.cpp +++ b/modules/core/src/matrix.cpp @@ -269,7 +269,7 @@ void setSize( Mat& m, int _dims, const int* _sz, const size_t* _steps, bool auto else if( autoSteps ) { m.step.p[i] = total; - int64 total1 = (int64)total*s; + uint64 total1 = (uint64)total*s; if( (uint64)total1 != (size_t)total1 ) CV_Error( CV_StsOutOfRange, "The total matrix size does not fit to \"size_t\" type" ); total = (size_t)total1; From 80d9f624d0e9d5de216f0920545423db17806835 Mon Sep 17 00:00:00 2001 From: Alexander Alekhin Date: Wed, 12 Jan 2022 04:14:48 +0000 Subject: [PATCH 9/9] dnn: don't use aligned load without alignment checks - weights are unaligned in dasiamprn sample (comes from numpy) --- modules/dnn/src/layers/convolution_layer.cpp | 5 +++-- modules/dnn/src/layers/layers_common.simd.hpp | 2 ++ 2 files changed, 5 insertions(+), 2 deletions(-) diff --git a/modules/dnn/src/layers/convolution_layer.cpp b/modules/dnn/src/layers/convolution_layer.cpp index 1236ff5783..f5c158453d 100644 --- a/modules/dnn/src/layers/convolution_layer.cpp +++ b/modules/dnn/src/layers/convolution_layer.cpp @@ -347,7 +347,9 @@ public: if (!blobs.empty()) { Mat wm = blobs[0].reshape(1, numOutput); - if( wm.step1() % VEC_ALIGN != 0 ) + if ((wm.step1() % VEC_ALIGN != 0) || + !isAligned(wm.data) + ) { int newcols = (int)alignSize(wm.step1(), VEC_ALIGN); Mat wm_buffer = Mat(numOutput, newcols, wm.type()); @@ -1299,7 +1301,6 @@ public: } } } - // now compute dot product of the weights // and im2row-transformed part of the tensor #if CV_TRY_AVX512_SKX diff --git a/modules/dnn/src/layers/layers_common.simd.hpp b/modules/dnn/src/layers/layers_common.simd.hpp index accc644676..049d1f8b02 100644 --- a/modules/dnn/src/layers/layers_common.simd.hpp +++ b/modules/dnn/src/layers/layers_common.simd.hpp @@ -81,6 +81,8 @@ void fastConv( const float* weights, size_t wstep, const float* bias, int blockSize, int vecsize, int vecsize_aligned, const float* relu, bool initOutput ) { + CV_Assert(isAligned<32>(weights)); + int outCn = outShape[1]; size_t outPlaneSize = outShape[2]*outShape[3]; float r0 = 1.f, r1 = 1.f, r2 = 1.f;