diff --git a/modules/calib/misc/python/test/test_calibration.py b/modules/calib/misc/python/test/test_calibration.py index a02bb46a17..43ee8930f0 100755 --- a/modules/calib/misc/python/test/test_calibration.py +++ b/modules/calib/misc/python/test/test_calibration.py @@ -140,8 +140,8 @@ class calibration_test(NewOpenCVTests): self.assertTrue(jacobian is not None) def test_sampsonDistance_valid2D(self): - pt1 = (np.random.rand(3, 10) * 256).astype(np.float64) - pt2 = (np.random.rand(3, 10) * 256).astype(np.float64) + pt1 = (np.random.rand(1, 1, 3) * 256).astype(np.float64) + pt2 = (np.random.rand(1, 1, 3) * 256).astype(np.float64) F = (np.random.rand(3, 3) * 256).astype(np.float64) dist = cv.sampsonDistance(pt1, pt2, F) self.assertTrue(isinstance(dist, (float, np.floating))) diff --git a/modules/core/src/arithm.simd.hpp b/modules/core/src/arithm.simd.hpp index f687834c8b..0689399dc6 100644 --- a/modules/core/src/arithm.simd.hpp +++ b/modules/core/src/arithm.simd.hpp @@ -559,6 +559,7 @@ static int scalarBinaryKernel(const void* src0_, size_t s0y, size_t s0x, const void*, size_t, size_t, void* dst_, size_t dsty, int width, int height, const double* params, int, void*) { + if (width <= 0 || height <= 0) return 0; s0y /= sizeof(T); s1y /= sizeof(T); dsty /= sizeof(Tr); @@ -593,6 +594,7 @@ static int scalarBinaryKernel(const void* src0_, size_t s0y, size_t s0x, template static void expandScalar(const T* sc, size_t sx, int n0, WT* scbuf, int n) { + if (n0 <= 0 || n <= 0) return; int i = 0; for (; i < n0; i++) scbuf[i] = (WT)sc[i*sx]; for (; i < n; i++) scbuf[i] = scbuf[i - n0]; @@ -899,6 +901,7 @@ static int vecBinaryKernel(const void* src0_, size_t s0y, size_t s0x, void* dst_, size_t dsty, int width, int height, const double* params, int, void*) { + if (width <= 0 || height <= 0) return 0; s0y /= sizeof(T); s1y /= sizeof(T); dsty /= sizeof(Tr); @@ -1394,6 +1397,7 @@ static int notKernel(const void* src0_, size_t s0y, size_t s0x, void* dst_, size_t dsty, int width, int height, const double*, int, void*) { + if (width <= 0 || height <= 0) return 0; s0y /= sizeof(T); dsty /= sizeof(T); CV_Assert(s0x == 1u || width == 1); @@ -1471,6 +1475,7 @@ static int addWeightedKernel(const void* src0_, size_t s0y, size_t s0x, void* dst_, size_t dsty, int width, int height, const double* params, int, void*) { + if (width <= 0 || height <= 0) return 0; s0y /= sizeof(T); s1y /= sizeof(T); dsty /= sizeof(Tr); CV_Assert((s0x|s1x) == 1u || (s0x|s1x) + (size_t)width == 1u); const T* src0 = (const T*)src0_; diff --git a/modules/core/src/arithm_expr.cpp b/modules/core/src/arithm_expr.cpp index 5601ed9fba..8892e450f3 100644 --- a/modules/core/src/arithm_expr.cpp +++ b/modules/core/src/arithm_expr.cpp @@ -1262,6 +1262,14 @@ void TExpr::exec(const Mat* const* inputs, Mat* outputs) for (int s = 1; ok && s < nslots; s++) if (arginfo[s].kind == OUTPUT) ok = ok && outputs[arginfo[s].index].isContinuous(); const size_t total = ok ? r.total() * rcn : 0; + if (ok && total == 0) + { + const MatShape rshape = r.size; + for (int s = 1; s < nslots; s++) + if (arginfo[s].kind == OUTPUT) + outputs[arginfo[s].index].create(rshape, CV_MAKETYPE(arginfo[s].depth, rcn)); + return; + } if (ok && total <= EW_FASTPATH_MAX) { const MatShape rshape = r.size; // spatial dims (channels separate), as a MatShape @@ -1422,6 +1430,8 @@ void TExpr::exec(const Mat* const* inputs, Mat* outputs) // ---- 4. parallel work hint: total output scalars x summed per-element op cost / budget. ---- long long otot = (long long)rchannels; for (int d = 0; d < (int)spatial.size(); d++) otot *= spatial[d]; + if (otot == 0) + return; // One stripe per 2^16 cost units. The unit is ~1/4 cycle of the VECTORIZED kernel, but // element-wise work is memory-bound, so a stripe costs several times what that model says - // a coarser budget leaves a 32-core box running 2 stripes on DNN-sized tensors (1-4 MB). @@ -1945,6 +1955,8 @@ void texpr(const std::string& expr, InputArrayOfArrays _inputs, OutputArrayOfArr CV_Assert(_inputs.kind() == _InputArray::STD_VECTOR_MAT); const std::vector& inps = *(const std::vector*)_inputs.getObj(); const int ninputs = (int)inps.size(); + for (int i = 0; i < ninputs; i++) + CV_Assert(!inps[i].empty()); // Input depths are known now, so build a fully-typed program straight away: one INPUT slot per // input (slot index i carries input i's depth), then parse the expression into instructions. diff --git a/modules/core/src/channels.cpp b/modules/core/src/channels.cpp index 3def05a533..e88d34a47e 100644 --- a/modules/core/src/channels.cpp +++ b/modules/core/src/channels.cpp @@ -114,9 +114,15 @@ void cv::mixChannels( const Mat* src, size_t nsrcs, Mat* dst, size_t ndsts, cons int *sdelta = (int*)(tab + npairs*4), *ddelta = sdelta + npairs; for( i = 0; i < nsrcs; i++ ) + { + CV_Assert( !src[i].empty() && src[i].size == dst[0].size && src[i].depth() == depth ); arrays[i] = &src[i]; + } for( i = 0; i < ndsts; i++ ) + { + CV_Assert( !dst[i].empty() && dst[i].size == dst[0].size && dst[i].depth() == depth ); arrays[i + nsrcs] = &dst[i]; + } ptrs[nsrcs + ndsts] = 0; for( i = 0; i < npairs; i++ ) diff --git a/modules/core/src/copy.cpp b/modules/core/src/copy.cpp index c009b39bb1..df0986553f 100644 --- a/modules/core/src/copy.cpp +++ b/modules/core/src/copy.cpp @@ -910,6 +910,12 @@ void repeat(InputArray _src, int ny, int nx, OutputArray _dst) CV_Assert( ny > 0 && nx > 0 ); Size ssize = _src.size(); + if( ssize.empty() ) + { + _dst.create(0, 0, _src.type()); + return; + } + CV_Assert( (int64_t)ssize.height * ny <= INT_MAX && (int64_t)ssize.width * nx <= INT_MAX ); _dst.create(ssize.height*ny, ssize.width*nx, _src.type()); #if !defined __APPLE__ @@ -1237,12 +1243,15 @@ void cv::copyMakeBorder( InputArray _src, OutputArray _dst, int top, int bottom, { CV_INSTRUMENT_REGION(); - CV_Assert( top >= 0 && bottom >= 0 && left >= 0 && right >= 0 && _src.dims() <= 2); + CV_Assert( top >= 0 && bottom >= 0 && left >= 0 && right >= 0 && _src.dims() <= 2 ); + CV_Assert( !_src.empty() ); + + Mat src = _src.getMat(); + CV_Assert( (int64_t)src.rows + top + bottom <= INT_MAX ); + CV_Assert( (int64_t)src.cols + left + right <= INT_MAX ); CV_OCL_RUN(_dst.isUMat(), ocl_copyMakeBorder(_src, _dst, top, bottom, left, right, borderType, value)) - - Mat src = _src.getMat(); int type = src.type(); if( src.isSubmatrix() && (borderType & BORDER_ISOLATED) == 0 ) diff --git a/modules/core/src/dxt.cpp b/modules/core/src/dxt.cpp index 6ebd399204..6f748107e3 100644 --- a/modules/core/src/dxt.cpp +++ b/modules/core/src/dxt.cpp @@ -3495,6 +3495,11 @@ void cv::dft( InputArray _src0, OutputArray _dst, int flags, int nonzero_rows ) #endif Mat src0 = _src0.getMat(), src = src0; + if (src.empty()) + { + _dst.release(); + return; + } bool inv = (flags & DFT_INVERSE) != 0; int type = src.type(); int depth = src.depth(); @@ -3698,16 +3703,24 @@ void cv::mulSpectrums( InputArray _srcA, InputArray _srcB, { CV_INSTRUMENT_REGION(); + if (_srcA.empty() && _srcB.empty()) + { + _dst.release(); + return; + } + + int type = _srcA.type(); + CV_Assert( type == _srcB.type() && _srcA.size() == _srcB.size() ); + CV_Assert( type == CV_32FC1 || type == CV_32FC2 || type == CV_64FC1 || type == CV_64FC2 ); + CV_Assert( !_srcA.empty() && !_srcB.empty() ); + CV_OCL_RUN(_dst.isUMat() && _srcA.dims() <= 2 && _srcB.dims() <= 2, ocl_mulSpectrums(_srcA, _srcB, _dst, flags, conjB)) Mat srcA = _srcA.getMat(), srcB = _srcB.getMat(); - int depth = srcA.depth(), cn = srcA.channels(), type = srcA.type(); + int depth = srcA.depth(), cn = srcA.channels(); size_t rows = srcA.rows, cols = srcA.cols; - CV_Assert( type == srcB.type() && srcA.size() == srcB.size() ); - CV_Assert( type == CV_32FC1 || type == CV_32FC2 || type == CV_64FC1 || type == CV_64FC2 ); - _dst.create( srcA.rows, srcA.cols, type ); Mat dst = _dst.getMat(); @@ -3753,12 +3766,18 @@ void cv::mulSpectrums( InputArray _srcA, InputArray _srcB, void cv::divSpectrums( InputArray _srcA, InputArray _srcB, OutputArray _dst, int flags, bool conjB) { Mat srcA = _srcA.getMat(), srcB = _srcB.getMat(); + if (srcA.empty() && srcB.empty()) + { + _dst.release(); + return; + } int depth = srcA.depth(), cn = srcA.channels(), type = srcA.type(); int rows = srcA.rows, cols = srcA.cols; int j, k; CV_Assert( type == srcB.type() && srcA.size() == srcB.size() ); CV_Assert( type == CV_32FC1 || type == CV_32FC2 || type == CV_64FC1 || type == CV_64FC2 ); + CV_Assert( !srcA.empty() && !srcB.empty() ); _dst.create( srcA.rows, srcA.cols, type ); Mat dst = _dst.getMat(); @@ -4628,6 +4647,11 @@ void cv::dct( InputArray _src0, OutputArray _dst, int flags ) CV_INSTRUMENT_REGION(); Mat src0 = _src0.getMat(), src = src0; + if (src.empty()) + { + _dst.release(); + return; + } int type = src.type(), depth = src.depth(); CV_Assert( type == CV_32FC1 || type == CV_64FC1 ); diff --git a/modules/core/src/mathfuncs.cpp b/modules/core/src/mathfuncs.cpp index 1bdc47e5f5..f652f31df3 100644 --- a/modules/core/src/mathfuncs.cpp +++ b/modules/core/src/mathfuncs.cpp @@ -1539,7 +1539,7 @@ double cv::solvePoly( InputArray _coeffs0, OutputArray _roots0, int maxIters ) int cdepth = CV_MAT_DEPTH(ctype); CV_Assert( CV_MAT_DEPTH(ctype) >= CV_32F && CV_MAT_CN(ctype) <= 2 ); - CV_Assert( coeffs0.rows == 1 || coeffs0.cols == 1 ); + CV_Assert( (coeffs0.rows == 1 || coeffs0.cols == 1) && coeffs0.total() >= 2 ); int n0 = coeffs0.cols + coeffs0.rows - 2, n = n0; @@ -1562,6 +1562,7 @@ double cv::solvePoly( InputArray _coeffs0, OutputArray _roots0, int maxIters ) if( std::abs(coeffs[n].re) + std::abs(coeffs[n].im) > DBL_EPSILON ) break; } + CV_Assert( std::abs(coeffs[n].re) + std::abs(coeffs[n].im) > DBL_EPSILON ); // Related issue: https://github.com/opencv/opencv/issues/23644, // This the initialization scheme of "Initial approximations in Durand-Kerner's root finding method" by Guggenheimer. diff --git a/modules/core/src/matrix_operations.cpp b/modules/core/src/matrix_operations.cpp index d03570a767..633d4039dc 100644 --- a/modules/core/src/matrix_operations.cpp +++ b/modules/core/src/matrix_operations.cpp @@ -793,11 +793,11 @@ void cv::reduce(InputArray _src, OutputArray _dst, int dim, int op, int dtype) srcUMat = _src.getUMat(); Mat src = _src.getMat(); + if (src.empty()) { + src.convertTo(_dst, dtype); + return; + } if (src.dims <= 1) { - if (src.dims == 0) { - src.convertTo(_dst, dtype); - return; - } CV_Assert(dim == 0); dim = 1; } diff --git a/modules/core/src/matrix_transform.cpp b/modules/core/src/matrix_transform.cpp index fa53ddfc01..d9cf9b0ac6 100644 --- a/modules/core/src/matrix_transform.cpp +++ b/modules/core/src/matrix_transform.cpp @@ -531,6 +531,7 @@ void transpose(InputArray src_, const std::vector& order, OutputArray dst_) Mat inp = src_.getMat(); const int ndims = inp.dims; + CV_Assert(!(ndims == 0 && inp.empty())); CV_CheckEQ(order.size(), static_cast(ndims), "Number of dimensions shouldn't change"); bool used[CV_MAX_DIM] = {false}; @@ -553,6 +554,8 @@ void transpose(InputArray src_, const std::vector& order, OutputArray dst_) dst_.create(ndims, newShape, inp.type()); Mat out = dst_.getMat(); + if (out.total() == 0) + return; nd::copy(nd::permute(nd::viewOf(inp), order.data()), nd::viewOf(out)); } @@ -1195,6 +1198,7 @@ void repeat(InputArray _src, const std::vector& repeats, OutputArray _dst) Mat src = _src.getMat(); const int ndims = src.dims; + CV_Assert(!(ndims == 0 && src.empty())); CV_CheckEQ(repeats.size(), (size_t)ndims, "repeat: the number of repeats must match the number of dimensions"); int outShape[CV_MAX_DIM]; @@ -1208,7 +1212,7 @@ void repeat(InputArray _src, const std::vector& repeats, OutputArray _dst) _dst.create(ndims, outShape, src.type()); Mat dst = _dst.getMat(); - if (dst.total() == 0) + if (dst.total() == 0 || src.empty()) return; // Each repeated output axis is split into (repeat index, position), the former @@ -1249,6 +1253,7 @@ void slice(InputArray _src, const std::vector& starts, const std::vector& starts, const std::vector= CV_HARDWARE_MAX_FEATURE) + return false; return currentFeatures->have[feature]; } diff --git a/modules/core/src/types.cpp b/modules/core/src/types.cpp index 8c732df5c7..6deecf109b 100644 --- a/modules/core/src/types.cpp +++ b/modules/core/src/types.cpp @@ -79,11 +79,11 @@ void KeyPoint::convert(const std::vector& keypoints, std::vector= 0 ) + if( idx >= 0 && idx < (int)keypoints.size() ) points2f[i] = keypoints[idx].pt; else { - CV_Error( cv::Error::StsBadArg, "keypointIndexes has element < 0. TODO: process this case" ); + CV_Error( cv::Error::StsBadArg, "keypointIndexes has element out of range" ); //points2f[i] = Point2f(-1, -1); } } diff --git a/modules/core/test/test_arithm_expr.cpp b/modules/core/test/test_arithm_expr.cpp index 637dfb6450..9727b1d365 100644 --- a/modules/core/test/test_arithm_expr.cpp +++ b/modules/core/test/test_arithm_expr.cpp @@ -29,6 +29,14 @@ TEST(Core_TExpr, add) EXPECT_LE(cvtest::norm(got, exp, NORM_INF), 1e-3); } +TEST(Core_TExpr, empty_inputs) +{ + Mat emptyA(0, 0, CV_32F), emptyB(0, 0, CV_32F); + std::vector out; + EXPECT_THROW(cv::texpr("{0} + {1}", std::vector{ emptyA, emptyB }, out), cv::Exception); + EXPECT_THROW(cv::texpr("0 - 0", std::vector{ emptyA }, out), cv::Exception); +} + // Built-in binary functions min/max/absdiff parsed and dispatched through emitBinary. TEST(Core_TExpr, minmax_absdiff) { diff --git a/modules/core/test/test_math.cpp b/modules/core/test/test_math.cpp index 341be985a0..bf87668430 100644 --- a/modules/core/test/test_math.cpp +++ b/modules/core/test/test_math.cpp @@ -2009,6 +2009,11 @@ TEST(Core_SolvePoly, degree_2_polynomials) for (float c2 = -20; c2 <= 20; c2++) { coefs.at(2) = c2; + if (c1 == 0 && c2 == 0) + { + EXPECT_THROW(cv::solvePoly(coefs, r), cv::Exception); + continue; + } prec = cv::solvePoly(coefs, r); EXPECT_LE(prec, 1e-6); } @@ -2038,6 +2043,11 @@ TEST(Core_SolvePoly, degree_4_polynomials) for (float c4 = -10; c4 <= 10; c4++) { coefs.at(4) = c4; + if (c1 == 0 && c2 == 0 && c3 == 0 && c4 == 0) + { + EXPECT_THROW(cv::solvePoly(coefs, r), cv::Exception); + continue; + } prec = cv::solvePoly(coefs, r); EXPECT_LE(prec, 1e-3); } @@ -2068,6 +2078,19 @@ TEST(Core_SolvePoly, different_magnitudes_polynomials) } } +TEST(Core_SolvePoly, invalid_inputs) +{ + Mat r; + Mat empty; + EXPECT_THROW(cv::solvePoly(empty, r), cv::Exception); + + Mat single(1, 1, CV_64F, Scalar(5.0)); + EXPECT_THROW(cv::solvePoly(single, r), cv::Exception); + + Mat zeroPoly(3, 1, CV_64F, Scalar(0.0)); + EXPECT_THROW(cv::solvePoly(zeroPoly, r), cv::Exception); +} + class Core_PhaseTest : public cvtest::BaseTest { int t; diff --git a/modules/core/test/test_misc.cpp b/modules/core/test/test_misc.cpp index 6320f2f20c..e3f915dd44 100644 --- a/modules/core/test/test_misc.cpp +++ b/modules/core/test/test_misc.cpp @@ -321,6 +321,41 @@ TEST(Core_BorderInterpolate, wrap_no_overflow_29232) EXPECT_LT(r, 5); } +TEST(Core_CopyMakeBorder, empty_src_and_overflow) +{ + Mat emptySrc, dst; + EXPECT_THROW(cv::copyMakeBorder(emptySrc, dst, 1, 1, 1, 1, cv::BORDER_CONSTANT, cv::Scalar(0)), cv::Exception); + + Mat src(5, 5, CV_8UC1, Scalar(1)); + EXPECT_THROW(cv::copyMakeBorder(src, dst, INT_MAX, 1, 0, 0, cv::BORDER_CONSTANT, cv::Scalar(0)), cv::Exception); + EXPECT_THROW(cv::copyMakeBorder(src, dst, 0, 0, INT_MAX, 1, cv::BORDER_CONSTANT, cv::Scalar(0)), cv::Exception); +} + +TEST(Core_MixChannels, empty_and_mismatched_inputs) +{ + Mat emptySrc, emptyDst; + std::vector fromTo = {0, 0}; + EXPECT_THROW(cv::mixChannels(&emptySrc, 1, &emptyDst, 1, fromTo.data(), 1), cv::Exception); + + Mat src(5, 5, CV_8UC1, Scalar(1)); + EXPECT_THROW(cv::mixChannels(&src, 1, &emptyDst, 1, fromTo.data(), 1), cv::Exception); + EXPECT_THROW(cv::mixChannels(&emptySrc, 1, &src, 1, fromTo.data(), 1), cv::Exception); + + Mat dstMismatched(6, 6, CV_8UC1); + EXPECT_THROW(cv::mixChannels(&src, 1, &dstMismatched, 1, fromTo.data(), 1), cv::Exception); +} + +TEST(Core_Repeat, empty_and_overflow) +{ + Mat emptySrc, dst; + cv::repeat(emptySrc, 5, 5, dst); + EXPECT_TRUE(dst.empty()); + + Mat src(2, 2, CV_8U, Scalar(1)); + EXPECT_THROW(cv::repeat(src, INT_MAX, 1, dst), cv::Exception); + EXPECT_THROW(cv::repeat(src, 1, INT_MAX, dst), cv::Exception); +} + class ThrowErrorParallelLoopBody : public cv::ParallelLoopBody { public: @@ -1072,4 +1107,92 @@ TEST_F(TestSetUpSkip, NoBodyRun) { FAIL() << "Unreachable code called"; } +TEST(Core_HardwareSupport, OutOfBounds) { + EXPECT_FALSE(cv::checkHardwareSupport(-1)); + EXPECT_FALSE(cv::checkHardwareSupport(-100)); + EXPECT_FALSE(cv::checkHardwareSupport(CV_HARDWARE_MAX_FEATURE)); + EXPECT_FALSE(cv::checkHardwareSupport(652214343)); + + EXPECT_TRUE(cv::getHardwareFeatureName(-1).empty()); + EXPECT_TRUE(cv::getHardwareFeatureName(CV_HARDWARE_MAX_FEATURE).empty()); + EXPECT_TRUE(cv::getHardwareFeatureName(652214343).empty()); +} + +TEST(Core_KeyPoint, ConvertOutOfBounds) { + std::vector kpts = { cv::KeyPoint(1.0f, 2.0f, 5.0f) }; + std::vector pts; + + // Negative index throws + EXPECT_THROW(cv::KeyPoint::convert(kpts, pts, { -1 }), cv::Exception); + + // Out-of-bounds positive index throws + EXPECT_THROW(cv::KeyPoint::convert(kpts, pts, { 1 }), cv::Exception); + EXPECT_THROW(cv::KeyPoint::convert(kpts, pts, { 100 }), cv::Exception); + EXPECT_THROW(cv::KeyPoint::convert({}, pts, { 0 }), cv::Exception); + + // Valid index works + EXPECT_NO_THROW(cv::KeyPoint::convert(kpts, pts, { 0 })); + ASSERT_EQ(pts.size(), 1u); + EXPECT_EQ(pts[0], cv::Point2f(1.0f, 2.0f)); +} + +TEST(Core_EmptyMat, FuzzRegressions) { + cv::Mat empty_mat; + cv::Mat mask_1x1 = cv::Mat::ones(1, 1, CV_8U); + + // cv::mean + EXPECT_NO_THROW({ + cv::Scalar m = cv::mean(empty_mat); + EXPECT_EQ(m, cv::Scalar::all(0.0)); + }); + EXPECT_NO_THROW({ + cv::Scalar m = cv::mean(cv::Mat(0, 4, CV_32F)); + EXPECT_EQ(m, cv::Scalar::all(0.0)); + }); + EXPECT_THROW(cv::mean(empty_mat, mask_1x1), cv::Exception); + + // cv::norm + EXPECT_NO_THROW({ + double n = cv::norm(empty_mat); + EXPECT_EQ(n, 0.0); + }); + EXPECT_NO_THROW({ + double n = cv::norm(cv::Mat(0, 4, CV_32F)); + EXPECT_EQ(n, 0.0); + }); + EXPECT_THROW(cv::norm(empty_mat, cv::NORM_L2, mask_1x1), cv::Exception); + EXPECT_NO_THROW({ + double n = cv::norm(empty_mat, empty_mat); + EXPECT_EQ(n, 0.0); + }); + + // cv::reduce + cv::Mat dst; + EXPECT_NO_THROW(cv::reduce(empty_mat, dst, 0, cv::REDUCE_SUM)); + EXPECT_TRUE(dst.empty()); + EXPECT_NO_THROW(cv::reduce(cv::Mat(0, 4, CV_32F), dst, 0, cv::REDUCE_SUM)); + + // cv::dft, cv::dct + EXPECT_NO_THROW(cv::dft(empty_mat, dst)); + EXPECT_TRUE(dst.empty()); + EXPECT_NO_THROW(cv::dct(empty_mat, dst)); + EXPECT_TRUE(dst.empty()); + + // cv::mulSpectrums, cv::divSpectrums + EXPECT_NO_THROW(cv::mulSpectrums(empty_mat, empty_mat, dst, 0)); + EXPECT_TRUE(dst.empty()); + EXPECT_NO_THROW(cv::divSpectrums(empty_mat, empty_mat, dst, 0)); + EXPECT_TRUE(dst.empty()); + cv::Mat spec_4x4 = cv::Mat::ones(4, 4, CV_32FC1); + EXPECT_THROW(cv::mulSpectrums(empty_mat, spec_4x4, dst, 0), cv::Exception); + EXPECT_THROW(cv::mulSpectrums(spec_4x4, empty_mat, dst, 0), cv::Exception); + EXPECT_THROW(cv::divSpectrums(empty_mat, spec_4x4, dst, 0), cv::Exception); + EXPECT_THROW(cv::divSpectrums(spec_4x4, empty_mat, dst, 0), cv::Exception); + + // cv::transposeND, cv::repeat, cv::slice + EXPECT_THROW(cv::transposeND(empty_mat, {}, dst), cv::Exception); + EXPECT_THROW(cv::repeat(empty_mat, {}, dst), cv::Exception); + EXPECT_THROW(cv::slice(empty_mat, {}, {}, {}, dst), cv::Exception); +} + }} // namespace diff --git a/modules/dnn/src/tensorflow/tf_importer.cpp b/modules/dnn/src/tensorflow/tf_importer.cpp index 9774ac5b79..2fe6be2df3 100644 --- a/modules/dnn/src/tensorflow/tf_importer.cpp +++ b/modules/dnn/src/tensorflow/tf_importer.cpp @@ -3080,6 +3080,9 @@ void TFImporter::populateNet() if (newEngine) { + if (layersOutputs.empty()) + CV_Error(Error::StsError, "TensorFlow graph contains no valid layers"); + Net::Impl* netimpl = dstNet.getImpl(); for (const std::string& outputName : layersOutputs.back()) netimpl->newArg(outputName, DNN_ARG_OUTPUT); @@ -3093,6 +3096,7 @@ void TFImporter::populateNet() for (const String& extraOutName: extraOutputs) { if (!dstNet.haveArg(extraOutName)) { CV_LOG_WARNING(NULL, "DNN/TF: the model extra output '" << extraOutName << "' is not found"); + continue; } Arg arg = dstNet.getArg(extraOutName); extraOutSet.insert(arg.idx); diff --git a/modules/dnn/test/test_tf_importer.cpp b/modules/dnn/test/test_tf_importer.cpp index b52cd609ee..329d014849 100644 --- a/modules/dnn/test/test_tf_importer.cpp +++ b/modules/dnn/test/test_tf_importer.cpp @@ -27,6 +27,12 @@ static std::string _tf(TString filename) return (getOpenCVExtraDir() + "/dnn/") + filename; } +TEST(Test_TensorFlow, empty_buffer) +{ + std::vector emptyBuffer; + EXPECT_THROW(cv::dnn::readNetFromTensorflow(emptyBuffer), cv::Exception); +} + TEST(Test_TensorFlow, inception_accuracy) { Net net; diff --git a/modules/geometry/misc/java/test/GeometryTest.java b/modules/geometry/misc/java/test/GeometryTest.java index 59d92b987d..1d8152a1c3 100644 --- a/modules/geometry/misc/java/test/GeometryTest.java +++ b/modules/geometry/misc/java/test/GeometryTest.java @@ -438,14 +438,16 @@ public class GeometryTest extends OpenCVTestCase { } public void testGetDefaultNewCameraMatrixMat() { - Mat mtx = Geometry.getDefaultNewCameraMatrix(gray0); + Mat cameraMatrix = new Mat(3, 3, CvType.CV_8U, new Scalar(0)); + Mat mtx = Geometry.getDefaultNewCameraMatrix(cameraMatrix); assertFalse(mtx.empty()); assertEquals(0, Core.countNonZero(mtx)); } public void testGetDefaultNewCameraMatrixMatSizeBoolean() { - Mat mtx = Geometry.getDefaultNewCameraMatrix(gray0, size, true); + Mat cameraMatrix = new Mat(3, 3, CvType.CV_8U, new Scalar(0)); + Mat mtx = Geometry.getDefaultNewCameraMatrix(cameraMatrix, size, true); assertFalse(mtx.empty()); assertFalse(0 == Core.countNonZero(mtx)); diff --git a/modules/geometry/misc/objc/test/Cv3dTest.swift b/modules/geometry/misc/objc/test/Cv3dTest.swift index f22ebcc9a1..edcd9fef9c 100644 --- a/modules/geometry/misc/objc/test/Cv3dTest.swift +++ b/modules/geometry/misc/objc/test/Cv3dTest.swift @@ -174,14 +174,16 @@ class GeometryTest: OpenCVTestCase { } func testGetDefaultNewCameraMatrixMat() { - let mtx = Geometry.getDefaultNewCameraMatrix(cameraMatrix: gray0) + let cameraMatrix = Mat(rows: 3, cols: 3, type: CvType.CV_8U, scalar: Scalar(0)) + let mtx = Geometry.getDefaultNewCameraMatrix(cameraMatrix: cameraMatrix) XCTAssertFalse(mtx.empty()) XCTAssertEqual(0, Core.countNonZero(src: mtx)) } func testGetDefaultNewCameraMatrixMatSizeBoolean() { - let mtx = Geometry.getDefaultNewCameraMatrix(cameraMatrix: gray0, imgsize: size, centerPrincipalPoint: true) + let cameraMatrix = Mat(rows: 3, cols: 3, type: CvType.CV_8U, scalar: Scalar(0)) + let mtx = Geometry.getDefaultNewCameraMatrix(cameraMatrix: cameraMatrix, imgsize: size, centerPrincipalPoint: true) XCTAssertFalse(mtx.empty()) XCTAssertFalse(0 == Core.countNonZero(src: mtx)) diff --git a/modules/geometry/src/fundam.cpp b/modules/geometry/src/fundam.cpp index 3aba71247a..01933bde8a 100644 --- a/modules/geometry/src/fundam.cpp +++ b/modules/geometry/src/fundam.cpp @@ -1294,12 +1294,17 @@ double sampsonDistance(InputArray _pt1, InputArray _pt2, InputArray _F) { CV_INSTRUMENT_REGION(); - CV_Assert(_pt1.depth() == CV_64F && _pt2.depth() == CV_64F && _F.depth() == CV_64F); - CV_DbgAssert(_pt1.rows() == 3 && _F.size() == Size(3, 3) && _pt1.rows() == _pt2.rows()); + CV_Assert(_pt1.depth() == CV_64F && _pt2.depth() == CV_64F && _F.type() == CV_64FC1); + CV_Assert(_pt1.dims() <= 2 && _pt1.total() * _pt1.channels() == 3); + CV_Assert(_pt2.dims() <= 2 && _pt2.total() * _pt2.channels() == 3); + CV_Assert(_F.size() == Size(3, 3)); Mat pt1(_pt1.getMat()); Mat pt2(_pt2.getMat()); Mat F(_F.getMat()); + if (!pt1.isContinuous()) pt1 = pt1.clone(); + if (!pt2.isContinuous()) pt2 = pt2.clone(); + if (!F.isContinuous()) F = F.clone(); Vec3d F_pt1 = *F.ptr() * *pt1.ptr(); Vec3d Ft_pt2 = F.ptr()->t() * *pt2.ptr(); diff --git a/modules/geometry/src/min_enclosing_triangle.cpp b/modules/geometry/src/min_enclosing_triangle.cpp index 7bd15fced0..2939cc3f32 100644 --- a/modules/geometry/src/min_enclosing_triangle.cpp +++ b/modules/geometry/src/min_enclosing_triangle.cpp @@ -317,10 +317,19 @@ namespace minEnclosingTriangle { */ static void findMinEnclosingTriangle(cv::InputArray points, CV_OUT cv::OutputArray triangle, CV_OUT double &area) { - CV_Assert(!points.empty()); + if (points.empty()) { + area = 0; + triangle.release(); + return; + } std::vector resultingTriangle; cv::Mat polygon; convexHull(points, polygon, true, true); + if (polygon.empty()) { + area = 0; + triangle.release(); + return; + } findMinEnclosingTriangle(polygon, resultingTriangle, area); cv::Mat(resultingTriangle).copyTo(triangle); } @@ -422,6 +431,11 @@ static void findMinimumAreaEnclosingTriangle(const std::vector &pol static void returnMinimumAreaEnclosingTriangle(const std::vector &polygon, std::vector &triangle, double &area) { unsigned int nrOfPoints = static_cast(polygon.size()); + if (nrOfPoints == 0) { + area = 0; + triangle.clear(); + return; + } for (int i = 0; i < 3; i++) { triangle.push_back(polygon[i % nrOfPoints]); diff --git a/modules/geometry/src/pinhole.cpp b/modules/geometry/src/pinhole.cpp index c1d4ac0435..c0e92832fe 100644 --- a/modules/geometry/src/pinhole.cpp +++ b/modules/geometry/src/pinhole.cpp @@ -50,6 +50,7 @@ Mat getDefaultNewCameraMatrix( InputArray _cameraMatrix, Size imgsize, bool centerPrincipalPoint ) { Mat cameraMatrix = _cameraMatrix.getMat(); + CV_Assert( cameraMatrix.size() == Size(3, 3) ); if( !centerPrincipalPoint && cameraMatrix.type() == CV_64F ) return cameraMatrix; diff --git a/modules/geometry/src/ptcloud/normal_estimation.cpp b/modules/geometry/src/ptcloud/normal_estimation.cpp index 0d55334cf9..9ebc23305e 100644 --- a/modules/geometry/src/ptcloud/normal_estimation.cpp +++ b/modules/geometry/src/ptcloud/normal_estimation.cpp @@ -54,6 +54,11 @@ normalEstimate(OutputArray normals, OutputArray curvatures, InputArray input_pts nn_idx_.getMatVector(nn_idx); CV_CheckEQ((int) nn_idx.size(), pts_size, "The point number of NN search result should be equal to the size of the point cloud."); + for (int i = 0; i < pts_size; ++i) + { + CV_CheckTypeEQ(nn_idx[i].type(), CV_32SC1, "Each matrix in nn_idx must be CV_32SC1"); + CV_Assert(!nn_idx[i].empty() && (nn_idx[i].rows == 1 || nn_idx[i].cols == 1)); + } } if (normals.channels() == 3 && normals.isVector()) @@ -80,10 +85,8 @@ normalEstimate(OutputArray normals, OutputArray curvatures, InputArray input_pts for (int i = range.start; i < range.end; ++i) { // Neighbor indices for this point come from either the built kd-tree or the caller. - const int *nn_idx_ptr_base; - int row_cols; - if (buildNN) { nn_idx_ptr_base = builtIdx.ptr(i); row_cols = builtIdx.cols; } - else { nn_idx_ptr_base = (int *) nn_idx[i].data; row_cols = nn_idx[i].cols; } + const int *nn_idx_ptr_base = buildNN ? builtIdx.ptr(i) : nullptr; + int row_cols = buildNN ? builtIdx.cols : (int)nn_idx[i].total(); // The maximum size that may be used for this row int bound = max_neighbor_num > row_cols ? row_cols : max_neighbor_num; // The first point should be itself @@ -91,13 +94,23 @@ normalEstimate(OutputArray normals, OutputArray curvatures, InputArray input_pts // Push the nearest neighbor points to pt_set for (int j = 1; j < bound; ++j) { - cur_nei_idx = nn_idx_ptr_base[j]; - // If the index is less than 0, + cur_nei_idx = buildNN ? nn_idx_ptr_base[j] : nn_idx[i].at(j); + // If the index is less than 0 or out of range, // the nn_idx of this row will no longer have any information. - if (cur_nei_idx < 0) break; + if (cur_nei_idx < 0 || cur_nei_idx >= pts_size) break; pt_set.push_back(ori_pts.row(cur_nei_idx)); } + float *normals_ptr_base = normals_ptr + 3 * i; + if (pt_set.rows < 3) + { + normals_ptr_base[0] = 0.f; + normals_ptr_base[1] = 0.f; + normals_ptr_base[2] = 0.f; + curvatures_ptr[i] = 0.f; + continue; + } + Mat mean; // Calculate the mean of point set, use "reduce()" is faster than default method in PCA reduce(pt_set, mean, 0, REDUCE_AVG); @@ -105,14 +118,29 @@ normalEstimate(OutputArray normals, OutputArray curvatures, InputArray input_pts PCA pca(pt_set, mean, PCA::DATA_AS_ROW); const float *eigenvectors_ptr = (float *) pca.eigenvectors.data; - float *normals_ptr_base = normals_ptr + 3 * i; - normals_ptr_base[0] = eigenvectors_ptr[6]; - normals_ptr_base[1] = eigenvectors_ptr[7]; - normals_ptr_base[2] = eigenvectors_ptr[8]; + if (pca.eigenvectors.rows >= 3) + { + normals_ptr_base[0] = eigenvectors_ptr[6]; + normals_ptr_base[1] = eigenvectors_ptr[7]; + normals_ptr_base[2] = eigenvectors_ptr[8]; + } + else + { + normals_ptr_base[0] = 0.f; + normals_ptr_base[1] = 0.f; + normals_ptr_base[2] = 0.f; + } const float *eigenvalues_ptr = (float *) pca.eigenvalues.data; - curvatures_ptr[i] = eigenvalues_ptr[2] / - (eigenvalues_ptr[0] + eigenvalues_ptr[1] + eigenvalues_ptr[2]); + if (pca.eigenvalues.rows >= 3) + { + curvatures_ptr[i] = eigenvalues_ptr[2] / + (eigenvalues_ptr[0] + eigenvalues_ptr[1] + eigenvalues_ptr[2]); + } + else + { + curvatures_ptr[i] = 0.f; + } } }); } diff --git a/modules/geometry/test/test_boundingrect.cpp b/modules/geometry/test/test_boundingrect.cpp index 0911484462..1bbd689f5e 100644 --- a/modules/geometry/test/test_boundingrect.cpp +++ b/modules/geometry/test/test_boundingrect.cpp @@ -161,4 +161,17 @@ TEST(Imgproc_BoundingRect, out_of_int_range_29837) EXPECT_EQ(boundingRect(ints), Rect(imin, imin, imax, imax)); } +TEST(Geometry_MinEnclosingTriangle, empty_and_collinear) +{ + Mat empty; + std::vector triangle; + double area = cv::minEnclosingTriangle(empty, triangle); + EXPECT_EQ(area, 0.0); + EXPECT_TRUE(triangle.empty()); + + std::vector onePoint = { Point2f(0, 0) }; + area = cv::minEnclosingTriangle(onePoint, triangle); + EXPECT_EQ(area, 0.0); +} + }} // namespace diff --git a/modules/geometry/test/test_fundam.cpp b/modules/geometry/test/test_fundam.cpp index 3e4ded5bff..926666221f 100644 --- a/modules/geometry/test/test_fundam.cpp +++ b/modules/geometry/test/test_fundam.cpp @@ -442,5 +442,25 @@ TEST(Calib3d_FindFundamentalMat, Crash) findFundamentalMat(m1, m2, mask, FM_LMEDS, 1, 0.99); } +TEST(Geometry_SampsonDistance, invalid_inputs) +{ + Mat pt1 = Mat(Vec2d(1.0, 2.0)); + Mat pt2 = Mat(Vec2d(1.0, 2.0)); + Mat F = Mat::eye(3, 3, CV_64F); + EXPECT_THROW(cv::sampsonDistance(pt1, pt2, F), cv::Exception); + + Mat F_bad = Mat::eye(2, 2, CV_64F); + Mat pt3d = Mat(Vec3d(1.0, 2.0, 1.0)); + EXPECT_THROW(cv::sampsonDistance(pt3d, pt3d, F_bad), cv::Exception); + + // Multi-point 3xN and Nx3 matrices must be rejected + Mat pts_3x2 = Mat::ones(3, 2, CV_64F); + Mat pts_2x3 = Mat::ones(2, 3, CV_64F); + EXPECT_THROW(cv::sampsonDistance(pts_3x2, pt3d, F), cv::Exception); + EXPECT_THROW(cv::sampsonDistance(pt3d, pts_3x2, F), cv::Exception); + EXPECT_THROW(cv::sampsonDistance(pts_2x3, pt3d, F), cv::Exception); + EXPECT_THROW(cv::sampsonDistance(pt3d, pts_2x3, F), cv::Exception); +} + }} // namespace /* End of file. */ diff --git a/modules/geometry/test/test_normal_estimation.cpp b/modules/geometry/test/test_normal_estimation.cpp index 8503dbb19d..ce0d8d6e93 100644 --- a/modules/geometry/test/test_normal_estimation.cpp +++ b/modules/geometry/test/test_normal_estimation.cpp @@ -105,5 +105,49 @@ TEST(NormalEstimationTest, InternalKnnMatchesExternal) ASSERT_LE(total_theta / (float)num, 1.f); // normals parallel to the plane normal } +TEST(NormalEstimationTest, EmptyAndInvalidInputs) +{ + Mat empty; + vector normals; + vector curvatures; + normalEstimate(normals, curvatures, empty, noArray(), 5); + EXPECT_TRUE(normals.empty()); + EXPECT_TRUE(curvatures.empty()); + + Mat pts(2, 3, CV_32F, Scalar(0)); + std::vector badIdx = { Mat(1, 1, CV_8U, Scalar(0)), Mat(1, 1, CV_8U, Scalar(0)) }; + EXPECT_THROW(normalEstimate(normals, curvatures, pts, badIdx, 1), cv::Exception); + + // Column-vector neighbor indices (e.g., std::vector> or Mat(K, 1, CV_32S)) + Mat plane_pts; + vector model({1, 2, 3, 4}); + int num = 50, k = 10; + vector limit({5, 55, 5, 55, 0, 0}); + generatePlane(plane_pts, model, 0.f, num, limit); + + Mat knn_idx(num, k, CV_32S); + flann::Index tree(plane_pts, flann::KDTreeIndexParams()); + tree.knnSearch(plane_pts, knn_idx, noArray(), k); + + vector refNormals, colNormals; + vector refCurv, colCurv; + normalEstimate(refNormals, refCurv, plane_pts, knn_idx, k); + + std::vector> col_knn_idx(num, std::vector(k)); + for (int i = 0; i < num; ++i) + for (int j = 0; j < k; ++j) + col_knn_idx[i][j] = knn_idx.at(i, j); + normalEstimate(colNormals, colCurv, plane_pts, col_knn_idx, k); + + ASSERT_EQ(refNormals.size(), colNormals.size()); + for (int i = 0; i < num; ++i) + { + EXPECT_NEAR(refNormals[i].x, colNormals[i].x, 1e-6f); + EXPECT_NEAR(refNormals[i].y, colNormals[i].y, 1e-6f); + EXPECT_NEAR(refNormals[i].z, colNormals[i].z, 1e-6f); + EXPECT_NEAR(refCurv[i], colCurv[i], 1e-6f); + } +} + } // namespace } // opencv_test diff --git a/modules/imgcodecs/src/loadsave.cpp b/modules/imgcodecs/src/loadsave.cpp index 320cc73d5e..b8a64efb68 100644 --- a/modules/imgcodecs/src/loadsave.cpp +++ b/modules/imgcodecs/src/loadsave.cpp @@ -47,6 +47,7 @@ #include "grfmts.hpp" #include "utils.hpp" #include "exif.hpp" +#include #undef min #undef max #include @@ -279,6 +280,14 @@ static ImageDecoder findDecoder( const String& filename ) { return ImageDecoder(); } +#if defined(S_ISREG) + struct stat st; + if (fstat(fileno(f), &st) != 0 || !S_ISREG(st.st_mode)) { + fclose(f); + return ImageDecoder(); + } +#endif + // read the file signature String signature(maxlen, ' '); maxlen = fread( (void*)signature.c_str(), 1, maxlen, f ); diff --git a/modules/imgcodecs/test/test_read_write.cpp b/modules/imgcodecs/test/test_read_write.cpp index 2508ef2dbd..ba03c4b843 100644 --- a/modules/imgcodecs/test/test_read_write.cpp +++ b/modules/imgcodecs/test/test_read_write.cpp @@ -628,4 +628,14 @@ TEST(Imgcodecs, decode_over2GB) EXPECT_THROW(dst = cv::imdecode(buf, cv::IMREAD_COLOR), cv::Exception); } +TEST(Imgcodecs, non_regular_file) +{ +#if !defined(_WIN32) + cv::Mat dst; + EXPECT_NO_THROW(dst = cv::imread("/dev/null")); + EXPECT_TRUE(dst.empty()); + EXPECT_FALSE(cv::haveImageReader("/dev/null")); +#endif +} + }} // namespace diff --git a/modules/imgproc/src/colormap.cpp b/modules/imgproc/src/colormap.cpp index 94d64992c2..734a774233 100644 --- a/modules/imgproc/src/colormap.cpp +++ b/modules/imgproc/src/colormap.cpp @@ -749,6 +749,8 @@ namespace colormap cv::cvtColor(src, srcGray, cv::COLOR_BGR2GRAY);//BGR because of historical cv::LUT() usage _dst.create(src.size(), lut_type); + if (src.empty()) + return; Mat dstMat = _dst.getMat(); //we do not use cv::LUT() which requires src.channels() == dst.channels() @@ -804,7 +806,7 @@ namespace colormap void applyColorMap(InputArray src, OutputArray dst, int colormap) { - colormap::ColorMap* cm = + std::unique_ptr cm( colormap == COLORMAP_AUTUMN ? (colormap::ColorMap*)(new colormap::Autumn) : colormap == COLORMAP_BONE ? (colormap::ColorMap*)(new colormap::Bone) : colormap == COLORMAP_CIVIDIS ? (colormap::ColorMap*)(new colormap::Cividis) : @@ -826,14 +828,12 @@ namespace colormap colormap == COLORMAP_TWILIGHT ? (colormap::ColorMap*)(new colormap::Twilight) : colormap == COLORMAP_TWILIGHT_SHIFTED ? (colormap::ColorMap*)(new colormap::TwilightShifted) : colormap == COLORMAP_VIRIDIS ? (colormap::ColorMap*)(new colormap::Viridis) : - colormap == COLORMAP_WINTER ? (colormap::ColorMap*)(new colormap::Winter) : 0; + colormap == COLORMAP_WINTER ? (colormap::ColorMap*)(new colormap::Winter) : 0); if( !cm ) CV_Error( Error::StsBadArg, "Unknown colormap id; use one of COLORMAP_*"); (*cm)(src, dst); - - delete cm; } void applyColorMap(InputArray src, OutputArray dst, InputArray userColor) diff --git a/modules/imgproc/src/contours_link.cpp b/modules/imgproc/src/contours_link.cpp index 0e59892b7d..1899ad74b1 100644 --- a/modules/imgproc/src/contours_link.cpp +++ b/modules/imgproc/src/contours_link.cpp @@ -402,6 +402,11 @@ void cv::findContoursLinkRuns(InputArray _image, _hierarchy.clear(); Mat image = _image.getMat(); + if (image.empty()) + { + _contours.clear(); + return; + } LinkRunner runner; runner.process(image); diff --git a/modules/imgproc/src/distransform.cpp b/modules/imgproc/src/distransform.cpp index f65eacbcda..4c727943d1 100644 --- a/modules/imgproc/src/distransform.cpp +++ b/modules/imgproc/src/distransform.cpp @@ -959,6 +959,12 @@ static void distanceTransform_L1_8U(InputArray _src, OutputArray _dst) CV_Assert( src.type() == CV_8UC1 || src.type() == CV_BoolC1); + if( src.empty() ) + { + _dst.release(); + return; + } + _dst.create( src.size(), CV_8UC1); Mat dst = _dst.getMat(); @@ -980,6 +986,13 @@ void cv::distanceTransform( InputArray _src, OutputArray _dst, OutputArray _labe CV_Assert( src.type() == CV_8UC1 || src.type() == CV_BoolC1); + if( src.empty() ) + { + _dst.release(); + if( need_labels ) _labels.release(); + return; + } + _dst.create( src.size(), CV_32F); Mat dst = _dst.getMat(); diff --git a/modules/imgproc/src/drawing.cpp b/modules/imgproc/src/drawing.cpp index 24369cf343..fb23e44156 100644 --- a/modules/imgproc/src/drawing.cpp +++ b/modules/imgproc/src/drawing.cpp @@ -2179,6 +2179,7 @@ void cv::drawContours( InputOutputArray _image, InputArrayOfArrays _contours, int i = 0, end = (int)ncontours; if (contourIdx >= 0) { + CV_CheckLT(contourIdx, (int)ncontours, "contourIdx must be less than number of contours"); i = contourIdx; end = i + 1; } diff --git a/modules/imgproc/src/fisheye.cpp b/modules/imgproc/src/fisheye.cpp index c43defce47..ea3cb826a8 100644 --- a/modules/imgproc/src/fisheye.cpp +++ b/modules/imgproc/src/fisheye.cpp @@ -13,6 +13,7 @@ void initUndistortRectifyMap( InputArray K, InputArray D, InputArray R, InputArr { CV_INSTRUMENT_REGION(); + CV_Assert( size.width > 0 && size.height > 0 ); CV_Assert( m1type == CV_16SC2 || m1type == CV_32F || m1type <=0 ); map1.create( size, m1type <= 0 ? CV_16SC2 : m1type ); map2.create( size, map1.type() == CV_16SC2 ? CV_16UC1 : CV_32F ); diff --git a/modules/imgproc/src/gabor.cpp b/modules/imgproc/src/gabor.cpp index 0f2da7f2cd..6b1ccb0cb3 100644 --- a/modules/imgproc/src/gabor.cpp +++ b/modules/imgproc/src/gabor.cpp @@ -51,6 +51,11 @@ cv::Mat cv::getGaborKernel( Size ksize, double sigma, double theta, double lambd, double gamma, double psi, int ktype ) { + CV_Assert( std::isfinite(sigma) && sigma > 0 ); + CV_Assert( std::isfinite(gamma) && gamma > 0 ); + CV_Assert( std::isfinite(lambd) && std::abs(lambd) > DBL_EPSILON ); + CV_Assert( std::isfinite(theta) ); + double sigma_x = sigma; double sigma_y = sigma/gamma; int nstds = 3; @@ -67,6 +72,8 @@ cv::Mat cv::getGaborKernel( Size ksize, double sigma, double theta, else ymax = cvRound(std::max(fabs(nstds*sigma_x*s), fabs(nstds*sigma_y*c))); + CV_Assert( xmax >= 0 && ymax >= 0 ); + xmin = -xmax; ymin = -ymax; diff --git a/modules/imgproc/src/grabcut.cpp b/modules/imgproc/src/grabcut.cpp index da7e9cdee4..b0221a9ce1 100644 --- a/modules/imgproc/src/grabcut.cpp +++ b/modules/imgproc/src/grabcut.cpp @@ -558,6 +558,9 @@ void cv::grabCut( InputArray _img, InputOutputArray _mask, Rect rect, if( img.type() != CV_8UC3 ) CV_Error( cv::Error::StsBadArg, "image must have CV_8UC3 type" ); + CV_Check(mode, mode == GC_INIT_WITH_RECT || mode == GC_INIT_WITH_MASK || + mode == GC_EVAL || mode == GC_EVAL_FREEZE_MODEL, "Unknown mode"); + GMM bgdGMM( bgdModel ), fgdGMM( fgdModel ); Mat compIdxs( img.size(), CV_32SC1 ); diff --git a/modules/imgproc/src/histogram.cpp b/modules/imgproc/src/histogram.cpp index 554122c3c7..e9b03a1d6f 100644 --- a/modules/imgproc/src/histogram.cpp +++ b/modules/imgproc/src/histogram.cpp @@ -1292,7 +1292,7 @@ void cv::calcHist( InputArrayOfArrays images, const std::vector& channels, int i, dims = (int)histSize.size(), rsz = (int)ranges.size(), csz = (int)channels.size(); int nimages = (int)images.total(); - CV_Assert(nimages > 0 && dims > 0); + CV_Assert(nimages > 0 && dims > 0 && dims <= CV_MAX_DIM); CV_Assert(rsz == dims*2 || (rsz == 0 && images.depth(0) == CV_8U)); CV_Assert(csz == 0 || csz == dims); float* _ranges[CV_MAX_DIM]; @@ -2008,7 +2008,7 @@ void cv::calcBackProject( InputArrayOfArrays images, const std::vector& cha int i, dims = H.dims, rsz = (int)ranges.size(), csz = (int)channels.size(); int nimages = (int)images.total(); - CV_Assert(nimages > 0); + CV_Assert(nimages > 0 && dims <= CV_MAX_DIM); CV_Assert(rsz == dims*2 || (rsz == 2 && _1d) || (rsz == 0 && images.depth(0) == CV_8U)); CV_Assert(csz == 0 || csz == dims || (csz == 1 && _1d)); diff --git a/modules/imgproc/src/hough.cpp b/modules/imgproc/src/hough.cpp index 4254f49ef0..7c2f2b94a7 100644 --- a/modules/imgproc/src/hough.cpp +++ b/modules/imgproc/src/hough.cpp @@ -977,6 +977,17 @@ void HoughLines( InputArray _image, OutputArray lines, { CV_INSTRUMENT_REGION(); + CV_Check(rho, std::isfinite((float)rho) && (float)rho > 0, "rho must be positive and finite"); + CV_Check(theta, std::isfinite((float)theta) && (float)theta > 0, "theta must be positive and finite"); + CV_CheckGT(threshold, 0, "threshold must be greater than 0"); + CV_CheckGE(max_theta, min_theta, "max_theta must be greater than min_theta"); + + if (_image.empty()) + { + lines.release(); + return; + } + int type = CV_32FC2; if (lines.fixedType()) { @@ -1000,6 +1011,18 @@ void HoughLinesP(InputArray _image, OutputArray _lines, { CV_INSTRUMENT_REGION(); + CV_Check(rho, std::isfinite((float)rho) && (float)rho > 0, "rho must be positive and finite"); + CV_Check(theta, std::isfinite((float)theta) && (float)theta > 0, "theta must be positive and finite"); + CV_CheckGT(threshold, 0, "threshold must be greater than 0"); + CV_Check(minLineLength, std::isfinite(minLineLength) && minLineLength >= 0, "minLineLength out of range"); + CV_Check(maxGap, std::isfinite(maxGap) && maxGap >= 0, "maxGap out of range"); + + if (_image.empty()) + { + _lines.release(); + return; + } + CV_OCL_RUN(_image.isUMat() && _lines.isUMat(), ocl_HoughLinesP(_image, _lines, rho, theta, threshold, minLineLength, maxGap)); @@ -2387,6 +2410,8 @@ static void HoughCircles( InputArray _image, OutputArray _circles, cw[i] = GetCircle4f(circles[i]); if (ncircles > 0) Mat(1, (int)ncircles, cv::traits::Type::value, &cw[0]).copyTo(_circles); + else + _circles.release(); } else if( type == CV_32FC3 ) { @@ -2395,6 +2420,8 @@ static void HoughCircles( InputArray _image, OutputArray _circles, cwow[i] = GetCircle(circles[i]); if (ncircles > 0) Mat(1, (int)ncircles, cv::traits::Type::value, &cwow[0]).copyTo(_circles); + else + _circles.release(); } else CV_Error(Error::StsError, "Internal error"); diff --git a/modules/imgproc/src/imgwarp.cpp b/modules/imgproc/src/imgwarp.cpp index 6ae67d3a2d..4ba3e71975 100644 --- a/modules/imgproc/src/imgwarp.cpp +++ b/modules/imgproc/src/imgwarp.cpp @@ -1416,13 +1416,18 @@ void cv::remap( InputArray _src, OutputArray _dst, CV_CheckLE(_src.dims(), 2, "Only 2D images are supported, N-D input (e.g. a batch of images) must be processed image by image"); + CV_Assert( !_src.empty() ); CV_Assert( !_map1.empty() ); + Mat map1 = _map1.getMat(), map2 = _map2.getMat(); + CV_Assert( (map1.type() == CV_16SC2 && (map2.empty() || map2.type() == CV_16UC1 || map2.type() == CV_16SC1)) || + (map1.type() == CV_32FC1 && map2.type() == CV_32FC1) || + (map1.type() == CV_32FC2 && map2.empty()) ); CV_Assert( _map2.empty() || (_map2.size() == _map1.size())); CV_OCL_RUN(_src.dims() <= 2 && _dst.isUMat(), ocl_remap(_src, _dst, _map1, _map2, interpolation, borderType, borderValue)) - Mat src = _src.getMat(), map1 = _map1.getMat(), map2 = _map2.getMat(); + Mat src = _src.getMat(); _dst.create( map1.size(), src.type() ); Mat dst = _dst.getMat(); @@ -1676,7 +1681,14 @@ void cv::convertMaps( InputArray _map1, InputArray _map2, CV_INSTRUMENT_REGION(); Mat map1 = _map1.getMat(), map2 = _map2.getMat(), dstmap1, dstmap2; + if( map1.empty() ) + { + _dstmap1.release(); + _dstmap2.release(); + return; + } Size size = map1.size(); + CV_Assert( map2.empty() || map1.size() == map2.size() ); const Mat *m1 = &map1, *m2 = &map2; int m1type = m1->type(), m2type = m2->type(); @@ -1745,12 +1757,12 @@ void cv::convertMaps( InputArray _map1, InputArray _map2, for( y = 0; y < size.height; y++ ) { const float* src1f = m1->ptr(y); - const float* src2f = m2->ptr(y); + const float* src2f = !m2->empty() ? m2->ptr(y) : nullptr; const short* src1 = (const short*)src1f; const ushort* src2 = (const ushort*)src2f; float* dst1f = dstmap1.ptr(y); - float* dst2f = dstmap2.ptr(y); + float* dst2f = !dstmap2.empty() ? dstmap2.ptr(y) : nullptr; short* dst1 = (short*)dst1f; ushort* dst2 = (ushort*)dst2f; x = 0; @@ -3071,6 +3083,9 @@ PkLab.net 2018 based on cv::linearPolar from OpenCV by J.L. Blanco, Apr 2009 void cv::warpPolar(InputArray _src, OutputArray _dst, Size dsize, Point2f center, double maxRadius, int flags) { + CV_Assert( !_src.empty() ); + CV_Assert( std::isfinite(maxRadius) && maxRadius > 0); + // if dest size is empty given than calculate using proportional setting // thus we calculate needed angles to keep same area as bounding circle if ((dsize.width <= 0) && (dsize.height <= 0)) diff --git a/modules/imgproc/src/median_blur.dispatch.cpp b/modules/imgproc/src/median_blur.dispatch.cpp index 6e1b9c917d..1cca458b7f 100644 --- a/modules/imgproc/src/median_blur.dispatch.cpp +++ b/modules/imgproc/src/median_blur.dispatch.cpp @@ -188,7 +188,7 @@ void medianBlur( InputArray _src0, OutputArray _dst, int ksize ) CV_INSTRUMENT_REGION(); CV_Assert(!_src0.empty()); - + CV_CheckGT(ksize, 0, "ksize must be positive"); CV_Assert( (ksize % 2 == 1) && (_src0.dims() <= 2 )); if( ksize <= 1 || _src0.empty() ) diff --git a/modules/imgproc/src/samplers.cpp b/modules/imgproc/src/samplers.cpp index da8a1284ac..cb0b5e3656 100644 --- a/modules/imgproc/src/samplers.cpp +++ b/modules/imgproc/src/samplers.cpp @@ -292,7 +292,16 @@ void cv::getRectSubPix( InputArray _image, Size patchSize, Point2f center, { CV_INSTRUMENT_REGION(); + CV_CheckGT(patchSize.width, 0, ""); + CV_CheckGT(patchSize.height, 0, ""); + Mat image = _image.getMat(); + if( image.empty() ) + { + _patch.release(); + return; + } + int depth = image.depth(), cn = image.channels(); int ddepth = patchType < 0 ? depth : CV_MAT_DEPTH(patchType); diff --git a/modules/imgproc/src/smooth.dispatch.cpp b/modules/imgproc/src/smooth.dispatch.cpp index 52581b4e42..8ffc18967b 100644 --- a/modules/imgproc/src/smooth.dispatch.cpp +++ b/modules/imgproc/src/smooth.dispatch.cpp @@ -198,6 +198,7 @@ softdouble getGaussianKernelBitExact(std::vector& result, int n, dou Mat getGaussianKernel(int n, double sigma, int ktype) { CV_CheckDepth(ktype, ktype == CV_32F || ktype == CV_64F, ""); + CV_Assert(n > 0); Mat kernel(n, 1, ktype); std::vector kernel_bitexact; diff --git a/modules/imgproc/src/sumpixels.dispatch.cpp b/modules/imgproc/src/sumpixels.dispatch.cpp index 0506189d7e..4b656198f3 100644 --- a/modules/imgproc/src/sumpixels.dispatch.cpp +++ b/modules/imgproc/src/sumpixels.dispatch.cpp @@ -422,6 +422,8 @@ void integral(InputArray _src, OutputArray _sum, OutputArray _sqsum, OutputArray if ( sqdepth <= 0 ) sqdepth = CV_64F; sdepth = CV_MAT_DEPTH(sdepth), sqdepth = CV_MAT_DEPTH(sqdepth); + CV_Assert( sdepth == CV_32S || sdepth == CV_32F || sdepth == CV_64F ); + CV_Assert( sqdepth == CV_32F || sqdepth == CV_64F || sqdepth == CV_32S ); CV_OCL_RUN(_sum.isUMat() && !_tilted.needed(), (_sqsum.needed() ? ocl_integral(_src, _sum, _sqsum, sdepth, sqdepth) : ocl_integral(_src, _sum, sdepth))); @@ -442,6 +444,14 @@ void integral(InputArray _src, OutputArray _sum, OutputArray _sqsum, OutputArray tilted = _tilted.getMat(); } + if( src.empty() ) + { + sum.setTo(0); + if( _sqsum.needed() ) sqsum.setTo(0); + if( _tilted.needed() ) tilted.setTo(0); + return; + } + hal::integral(depth, sdepth, sqdepth, src.ptr(), src.step, sum.ptr(), sum.step, diff --git a/modules/imgproc/src/undistort.dispatch.cpp b/modules/imgproc/src/undistort.dispatch.cpp index 51c5f142cc..27730d5b4c 100644 --- a/modules/imgproc/src/undistort.dispatch.cpp +++ b/modules/imgproc/src/undistort.dispatch.cpp @@ -66,6 +66,7 @@ void initUndistortRectifyMap( InputArray _cameraMatrix, InputArray _distCoeffs, InputArray _matR, InputArray _newCameraMatrix, Size size, int m1type, OutputArray _map1, OutputArray _map2 ) { + CV_Assert( size.width > 0 && size.height > 0 ); Mat cameraMatrix = _cameraMatrix.getMat(), distCoeffs = _distCoeffs.getMat(); Mat matR = _matR.getMat(), newCameraMatrix = _newCameraMatrix.getMat(); @@ -150,6 +151,7 @@ void initInverseRectificationMap( InputArray _cameraMatrix, InputArray _distCoef InputArray _matR, InputArray _newCameraMatrix, const Size& size, int m1type, OutputArray _map1, OutputArray _map2 ) { + CV_Assert( size.width > 0 && size.height > 0 ); // Parameters Mat cameraMatrix = _cameraMatrix.getMat(), distCoeffs = _distCoeffs.getMat(); Mat matR = _matR.getMat(), newCameraMatrix = _newCameraMatrix.getMat(); @@ -274,6 +276,15 @@ void undistort( InputArray _src, OutputArray _dst, InputArray _cameraMatrix, Mat src = _src.getMat(), cameraMatrix = _cameraMatrix.getMat(); Mat distCoeffs = _distCoeffs.getMat(), newCameraMatrix = _newCameraMatrix.getMat(); + CV_Assert( cameraMatrix.size() == Size(3, 3) ); + CV_Assert( newCameraMatrix.empty() || newCameraMatrix.size() == Size(3, 3) ); + + if( src.empty() ) + { + _dst.release(); + return; + } + _dst.create( src.size(), src.type() ); Mat dst = _dst.getMat(); diff --git a/modules/imgproc/test/test_color.cpp b/modules/imgproc/test/test_color.cpp index 1664c88a13..e0b9aa124e 100644 --- a/modules/imgproc/test/test_color.cpp +++ b/modules/imgproc/test/test_color.cpp @@ -3396,4 +3396,11 @@ TEST(ImgProc_applyColorMap, dimensions) ASSERT_EQ(cv::norm(dst, gt, NORM_L1), 0); } +TEST(ImgProc_applyColorMap, empty_src) +{ + Mat emptySrc, dst; + cv::applyColorMap(emptySrc, dst, cv::COLORMAP_JET); + EXPECT_TRUE(dst.empty()); +} + }} // namespace diff --git a/modules/imgproc/test/test_filter.cpp b/modules/imgproc/test/test_filter.cpp index 100a0493fd..e36549f21f 100644 --- a/modules/imgproc/test/test_filter.cpp +++ b/modules/imgproc/test/test_filter.cpp @@ -1503,5 +1503,11 @@ TEST_F(FastFilterEngineTest, FullImage) { } } +TEST(Imgproc_Gabor, invalid_parameters) +{ + EXPECT_THROW(cv::getGaborKernel(Size(5, 5), 0, 0, 1.0, 1.0), cv::Exception); + EXPECT_THROW(cv::getGaborKernel(Size(5, 5), 1.0, 0, 1.0, 0), cv::Exception); + EXPECT_THROW(cv::getGaborKernel(Size(5, 5), 1.0, 0, 0, 1.0), cv::Exception); +} }} // namespace diff --git a/modules/imgproc/test/test_houghlines.cpp b/modules/imgproc/test/test_houghlines.cpp index 82b2864b13..8c05a28e51 100644 --- a/modules/imgproc/test/test_houghlines.cpp +++ b/modules/imgproc/test/test_houghlines.cpp @@ -470,4 +470,26 @@ INSTANTIATE_TEST_CASE_P( Imgproc, HoughLinesPointSetTest, testing::Combine(testi testing::Values( (CV_PI / 2.0f), (CV_PI * 5.0f / 12.0f) ) )); +TEST(Imgproc_HoughLines, invalid_parameters) +{ + Mat img(10, 10, CV_8U, Scalar(0)); + std::vector lines; + EXPECT_THROW(cv::HoughLines(img, lines, 0, CV_PI/180, 1), cv::Exception); + EXPECT_THROW(cv::HoughLines(img, lines, -1, CV_PI/180, 1), cv::Exception); + EXPECT_THROW(cv::HoughLines(img, lines, DBL_MAX, CV_PI/180, 1), cv::Exception); + EXPECT_THROW(cv::HoughLines(img, lines, 1, 0, 1), cv::Exception); + EXPECT_THROW(cv::HoughLines(img, lines, 1, -CV_PI/180, 1), cv::Exception); + EXPECT_THROW(cv::HoughLines(img, lines, 1, DBL_MAX, 1), cv::Exception); + EXPECT_THROW(cv::HoughLines(img, lines, 1, CV_PI/180, 0), cv::Exception); + + std::vector linesP; + EXPECT_THROW(cv::HoughLinesP(img, linesP, 0, CV_PI/180, 1), cv::Exception); + EXPECT_THROW(cv::HoughLinesP(img, linesP, -1, CV_PI/180, 1), cv::Exception); + EXPECT_THROW(cv::HoughLinesP(img, linesP, DBL_MAX, CV_PI/180, 1), cv::Exception); + EXPECT_THROW(cv::HoughLinesP(img, linesP, 1, 0, 1), cv::Exception); + EXPECT_THROW(cv::HoughLinesP(img, linesP, 1, -CV_PI/180, 1), cv::Exception); + EXPECT_THROW(cv::HoughLinesP(img, linesP, 1, DBL_MAX, 1), cv::Exception); + EXPECT_THROW(cv::HoughLinesP(img, linesP, 1, CV_PI/180, 0), cv::Exception); +} + }} // namespace diff --git a/modules/imgproc/test/test_imgwarp.cpp b/modules/imgproc/test/test_imgwarp.cpp index e524a9fd97..fce902e852 100644 --- a/modules/imgproc/test/test_imgwarp.cpp +++ b/modules/imgproc/test/test_imgwarp.cpp @@ -1345,5 +1345,29 @@ TEST(Imgproc_Warping, interpolate_loop) cv::warpAffine(src, dst, M, cv::Size(50, 50), cv::INTER_NEAREST, cv::BORDER_REFLECT_101); } +TEST(Imgproc_Warping, convertMaps_remap_warpPolar_validation) +{ + Mat emptySrc, dst; + Mat map1(10, 10, CV_32FC1, Scalar(0)), map2(10, 10, CV_32FC1, Scalar(0)); + EXPECT_THROW(cv::remap(emptySrc, dst, map1, map2, INTER_LINEAR), cv::Exception); + + Mat mismatchedMap2(5, 5, CV_32FC1, Scalar(0)); + Mat dstm1, dstm2; + EXPECT_THROW(cv::convertMaps(map1, mismatchedMap2, dstm1, dstm2, CV_16SC2), cv::Exception); + + EXPECT_THROW(cv::warpPolar(emptySrc, dst, Size(50, 50), Point2f(25, 25), 25, WARP_POLAR_LINEAR), cv::Exception); + Mat src(10, 10, CV_8U, Scalar(0)); + EXPECT_THROW(cv::warpPolar(src, dst, Size(50, 50), Point2f(25, 25), 0, WARP_POLAR_LINEAR), cv::Exception); + EXPECT_THROW(cv::warpPolar(src, dst, Size(50, 50), Point2f(25, 25), -5, WARP_POLAR_LINEAR), cv::Exception); + + // getRectSubPix: empty image returns empty patch; non-positive patchSize throws + EXPECT_NO_THROW(cv::getRectSubPix(emptySrc, Size(3, 3), Point2f(1.f, 1.f), dst)); + EXPECT_TRUE(dst.empty()); + EXPECT_THROW(cv::getRectSubPix(src, Size(0, 3), Point2f(1.f, 1.f), dst), cv::Exception); + EXPECT_THROW(cv::getRectSubPix(src, Size(3, 0), Point2f(1.f, 1.f), dst), cv::Exception); + EXPECT_THROW(cv::getRectSubPix(src, Size(-1, 3), Point2f(1.f, 1.f), dst), cv::Exception); + EXPECT_THROW(cv::getRectSubPix(src, Size(3, -1), Point2f(1.f, 1.f), dst), cv::Exception); +} + }} // namespace /* End of file. */ diff --git a/modules/objdetect/src/aruco/aruco_dictionary.cpp b/modules/objdetect/src/aruco/aruco_dictionary.cpp index 3e975c00bf..14d80a6472 100644 --- a/modules/objdetect/src/aruco/aruco_dictionary.cpp +++ b/modules/objdetect/src/aruco/aruco_dictionary.cpp @@ -250,6 +250,10 @@ void Dictionary::generateImageMarker(int id, int sidePixels, OutputArray _img, i Mat Dictionary::getByteListFromBits(const Mat &bits) { + CV_Assert(!bits.empty()); + CV_Assert(bits.type() == CV_8UC1); + CV_Assert(bits.rows == bits.cols); + // integer ceil int nbytes = (bits.cols * bits.rows + 8 - 1) / 8; diff --git a/modules/objdetect/src/calibinit.cpp b/modules/objdetect/src/calibinit.cpp index 83c6b062b7..0a852254d5 100644 --- a/modules/objdetect/src/calibinit.cpp +++ b/modules/objdetect/src/calibinit.cpp @@ -2108,6 +2108,13 @@ void drawChessboardCorners( InputOutputArray image, Size patternSize, int nelems = corners.checkVector(2, CV_32F, true); CV_Assert(nelems >= 0); + if (patternWasFound) + { + CV_CheckGT(patternSize.width, 0, "patternSize.width must be positive"); + CV_CheckGT(patternSize.height, 0, "patternSize.height must be positive"); + CV_CheckGE(nelems, patternSize.area(), "Number of corners must be at least patternSize.area()"); + } + const int shift = 0; const int radius = 4; const int r = radius*(1 << shift); diff --git a/modules/objdetect/test/test_arucodetection.cpp b/modules/objdetect/test/test_arucodetection.cpp index 397367f00a..784d975ece 100644 --- a/modules/objdetect/test/test_arucodetection.cpp +++ b/modules/objdetect/test/test_arucodetection.cpp @@ -1498,4 +1498,16 @@ INSTANTIATE_TEST_CASE_P( aruco::CORNER_REFINE_APRILTAG )); +TEST(ArucoDictionary, getByteListFromBits_invalid) +{ + Mat empty; + EXPECT_THROW(aruco::Dictionary::getByteListFromBits(empty), cv::Exception); + + Mat nonSquare(3, 5, CV_8UC1, Scalar(0)); + EXPECT_THROW(aruco::Dictionary::getByteListFromBits(nonSquare), cv::Exception); + + Mat non8u(4, 4, CV_32F, Scalar(0)); + EXPECT_THROW(aruco::Dictionary::getByteListFromBits(non8u), cv::Exception); +} + }} // namespace diff --git a/modules/objdetect/test/test_chesscorners_badarg.cpp b/modules/objdetect/test/test_chesscorners_badarg.cpp index 48468b0946..cb3daf5bf3 100644 --- a/modules/objdetect/test/test_chesscorners_badarg.cpp +++ b/modules/objdetect/test/test_chesscorners_badarg.cpp @@ -109,5 +109,13 @@ void CV_ChessboardDetectorBadArgTest::run( int /*start_from */) TEST(Calib3d_ChessboardDetector, badarg) { CV_ChessboardDetectorBadArgTest test; test.safe_run(); } +TEST(Calib3d_ChessboardDetector, drawChessboardCorners_badarg) +{ + Mat img(100, 100, CV_8UC3, Scalar::all(0)); + std::vector corners(4); + EXPECT_THROW(cv::drawChessboardCorners(img, Size(5, 5), corners, true), cv::Exception); + EXPECT_THROW(cv::drawChessboardCorners(img, Size(-1, 5), corners, true), cv::Exception); +} + }} // namespace /* End of file. */