mirrors/opencv
1
0
Fork 0
Code Pull Requests Packages Releases Activity

vendor: OpenCV 5.0.0 snapshot at 40738fb16ceddb5fb3fea747585f7ce6abb0605b

Browse Source
This commit is contained in:
Gitea Mirror Bot
2026-08-22 00:10:33 +08:00
commit f7f077da11
6933 changed files with 2335208 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
modules/photo/perf/opencl/perf_denoising.cpp
+97
View File
@@ -0,0 +1,97 @@
// This file is part of OpenCV project.
// It is subject to the license terms in the LICENSE file found in the top-level directory
// of this distribution and at http://opencv.org/license.html.
// Copyright (C) 2014, Advanced Micro Devices, Inc., all rights reserved.
// Third party copyrights are property of their respective owners.
#include "../perf_precomp.hpp"
#include "opencv2/ts/ocl_perf.hpp"
#ifdef HAVE_OPENCL
namespace opencv_test {
namespace ocl {
OCL_PERF_TEST(Photo, DenoisingGrayscale)
{
Mat _original = imread(getDataPath("cv/denoising/lena_noised_gaussian_sigma=10.png"), IMREAD_GRAYSCALE);
ASSERT_FALSE(_original.empty()) << "Could not load input image";
UMat result(_original.size(), _original.type()), original;
_original.copyTo(original);
declare.in(original).out(result).iterations(10);
OCL_TEST_CYCLE()
cv::fastNlMeansDenoising(original, result, 10);
SANITY_CHECK(result, 1);
}
OCL_PERF_TEST(Photo, DenoisingColored)
{
Mat _original = imread(getDataPath("cv/denoising/lena_noised_gaussian_sigma=10.png"));
ASSERT_FALSE(_original.empty()) << "Could not load input image";
UMat result(_original.size(), _original.type()), original;
_original.copyTo(original);
declare.in(original).out(result).iterations(10);
OCL_TEST_CYCLE()
cv::fastNlMeansDenoisingColored(original, result, 10, 10);
SANITY_CHECK(result, 2);
}
OCL_PERF_TEST(Photo, DISABLED_DenoisingGrayscaleMulti)
{
const int imgs_count = 3;
vector<UMat> original(imgs_count);
Mat tmp;
for (int i = 0; i < imgs_count; i++)
{
string original_path = format("cv/denoising/lena_noised_gaussian_sigma=20_multi_%d.png", i);
tmp = imread(getDataPath(original_path), IMREAD_GRAYSCALE);
ASSERT_FALSE(tmp.empty()) << "Could not load input image " << original_path;
tmp.copyTo(original[i]);
declare.in(original[i]);
}
UMat result(tmp.size(), tmp.type());
declare.out(result).iterations(10);
OCL_TEST_CYCLE()
cv::fastNlMeansDenoisingMulti(original, result, imgs_count / 2, imgs_count, 15);
SANITY_CHECK(result);
}
OCL_PERF_TEST(Photo, DISABLED_DenoisingColoredMulti)
{
const int imgs_count = 3;
vector<UMat> original(imgs_count);
Mat tmp;
for (int i = 0; i < imgs_count; i++)
{
string original_path = format("cv/denoising/lena_noised_gaussian_sigma=20_multi_%d.png", i);
tmp = imread(getDataPath(original_path), IMREAD_COLOR);
ASSERT_FALSE(tmp.empty()) << "Could not load input image " << original_path;
tmp.copyTo(original[i]);
declare.in(original[i]);
}
UMat result(tmp.size(), tmp.type());
declare.out(result).iterations(10);
OCL_TEST_CYCLE()
cv::fastNlMeansDenoisingColoredMulti(original, result, imgs_count / 2, imgs_count, 10, 15);
SANITY_CHECK(result);
}
} } // namespace opencv_test::ocl
#endif // HAVE_OPENCL
modules/photo/perf/perf_ccm.cpp
+103
View File
@@ -0,0 +1,103 @@
// This file is part of OpenCV project.
// It is subject to the license terms in the LICENSE file found in the top-level directory
// of this distribution and at http://opencv.org/license.html.
#include "perf_precomp.hpp"
#include "opencv2/photo.hpp"
namespace opencv_test {
namespace {
using namespace cv;
using namespace std;
PERF_TEST(CV_ccm_perf_480_640, correctImage)
{
string path = cvtest::findDataFile("cv/mcc/mcc_ccm_test.yml");
FileStorage fs(path, FileStorage::READ);
Mat chartsRGB;
fs["chartsRGB"] >> chartsRGB;
fs.release();
ASSERT_FALSE(chartsRGB.empty()) << "chartsRGB is empty after loading from: " << path;
cv::ccm::ColorCorrectionModel model(
chartsRGB.col(1).clone().reshape(3, chartsRGB.rows/3) / 255.0,
cv::ccm::COLORCHECKER_MACBETH
);
model.compute();
Mat img(480, 640, CV_8UC3);
randu(img, 0, 255);
Mat correctedImage;
TEST_CYCLE() { model.correctImage(img, correctedImage); }
SANITY_CHECK_NOTHING();
}
PERF_TEST(CV_ccm_perf_720_1280, correctImage)
{
string path = cvtest::findDataFile("cv/mcc/mcc_ccm_test.yml");
FileStorage fs(path, FileStorage::READ);
Mat chartsRGB;
fs["chartsRGB"] >> chartsRGB;
fs.release();
ASSERT_FALSE(chartsRGB.empty()) << "chartsRGB is empty after loading from: " << path;
cv::ccm::ColorCorrectionModel model(
chartsRGB.col(1).clone().reshape(3, chartsRGB.rows/3) / 255.0,
cv::ccm::COLORCHECKER_MACBETH
);
model.compute();
Mat img(720, 1280, CV_8UC3);
randu(img, 0, 255);
Mat correctedImage;
TEST_CYCLE() { model.correctImage(img, correctedImage); }
SANITY_CHECK_NOTHING();
}
PERF_TEST(CV_ccm_perf_1080_1920, correctImage)
{
string path = cvtest::findDataFile("cv/mcc/mcc_ccm_test.yml");
FileStorage fs(path, FileStorage::READ);
Mat chartsRGB;
fs["chartsRGB"] >> chartsRGB;
fs.release();
ASSERT_FALSE(chartsRGB.empty()) << "chartsRGB is empty after loading from: " << path;
cv::ccm::ColorCorrectionModel model(
chartsRGB.col(1).clone().reshape(3, chartsRGB.rows/3) / 255.0,
cv::ccm::COLORCHECKER_MACBETH
);
model.compute();
Mat img(1080, 1920, CV_8UC3);
randu(img, 0, 255);
Mat correctedImage;
TEST_CYCLE() { model.correctImage(img, correctedImage); }
SANITY_CHECK_NOTHING();
}
PERF_TEST(CV_ccm_perf_2160_3840, correctImage)
{
string path = cvtest::findDataFile("cv/mcc/mcc_ccm_test.yml");
FileStorage fs(path, FileStorage::READ);
Mat chartsRGB;
fs["chartsRGB"] >> chartsRGB;
fs.release();
ASSERT_FALSE(chartsRGB.empty()) << "chartsRGB is empty after loading from: " << path;
cv::ccm::ColorCorrectionModel model(
chartsRGB.col(1).clone().reshape(3, chartsRGB.rows/3) / 255.0,
cv::ccm::COLORCHECKER_MACBETH
);
model.compute();
Mat img(2160, 3840, CV_8UC3);
randu(img, 0, 255);
Mat correctedImage;
TEST_CYCLE() { model.correctImage(img, correctedImage); }
SANITY_CHECK_NOTHING();
}
} // namespace
} // namespace opencv_test
modules/photo/perf/perf_chromatic_aberration.cpp
+39
View File
@@ -0,0 +1,39 @@
// This file is part of OpenCV project.
// It is subject to the license terms in the LICENSE file found in the top-level directory
// of this distribution and at http://opencv.org/license.html
#include "perf_precomp.hpp"
namespace opencv_test
{
namespace
{
PERF_TEST(ChromaticAberration, CorrectChromaticAberration)
{
std::string calib_file = getDataPath("cv/cameracalibration/chromatic_aberration/ca_photo_calib.yaml");
std::string image_file = getDataPath("cv/cameracalibration/chromatic_aberration/ca_photo.png");
cv::Mat src = cv::imread(image_file);
ASSERT_FALSE(src.empty()) << "Could not load input image";
ASSERT_EQ(src.type(), CV_8UC3);
cv::Mat coeffMat;
int degree = -1;
Size calib_size = {-1,-1};
FileStorage fs(calib_file, FileStorage::READ);
ASSERT_TRUE(fs.isOpened());
ASSERT_NO_THROW(cv::loadChromaticAberrationParams(fs.root(), coeffMat, calib_size, degree));
cv::Mat dst;
TEST_CYCLE()
{
cv::correctChromaticAberration(src, coeffMat, dst, calib_size, degree);
}
SANITY_CHECK_NOTHING();
}
} // namespace
} // namespace opencv_test
modules/photo/perf/perf_cuda.cpp
+189
View File
@@ -0,0 +1,189 @@
/*M///////////////////////////////////////////////////////////////////////////////////////
//
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
// By downloading, copying, installing or using the software you agree to this license.
// If you do not agree to this license, do not download, install,
// copy or use the software.
//
//
// License Agreement
// For Open Source Computer Vision Library
//
// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
// * Redistribution's of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
//
// * Redistribution's in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// * The name of the copyright holders may not be used to endorse or promote products
// derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// In no event shall the Intel Corporation or contributors be liable for any direct,
// indirect, incidental, special, exemplary, or consequential damages
// (including, but not limited to, procurement of substitute goods or services;
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//
//M*/
#include "perf_precomp.hpp"
#include "opencv2/photo/cuda.hpp"
#include "opencv2/ts/cuda_perf.hpp"
#include "opencv2/opencv_modules.hpp"
#if defined (HAVE_CUDA) && defined(HAVE_OPENCV_CUDAARITHM) && defined(HAVE_OPENCV_CUDAIMGPROC)
namespace opencv_test { namespace {
using namespace perf;
#define CUDA_DENOISING_IMAGE_SIZES testing::Values(perf::szVGA, perf::sz720p)
//////////////////////////////////////////////////////////////////////
// nonLocalMeans
DEF_PARAM_TEST(Sz_Depth_Cn_WinSz_BlockSz, cv::Size, MatDepth, MatCn, int, int);
PERF_TEST_P(Sz_Depth_Cn_WinSz_BlockSz, CUDA_NonLocalMeans,
Combine(CUDA_DENOISING_IMAGE_SIZES,
Values<MatDepth>(CV_8U),
CUDA_CHANNELS_1_3,
Values(21),
Values(5)))
{
declare.time(600.0);
const cv::Size size = GET_PARAM(0);
const int depth = GET_PARAM(1);
const int channels = GET_PARAM(2);
const int search_window_size = GET_PARAM(3);
const int block_size = GET_PARAM(4);
const float h = 10;
const int borderMode = cv::BORDER_REFLECT101;
const int type = CV_MAKE_TYPE(depth, channels);
cv::Mat src(size, type);
declare.in(src, WARMUP_RNG);
if (PERF_RUN_CUDA())
{
const cv::cuda::GpuMat d_src(src);
cv::cuda::GpuMat dst;
TEST_CYCLE() cv::cuda::nonLocalMeans(d_src, dst, h, search_window_size, block_size, borderMode);
CUDA_SANITY_CHECK(dst);
}
else
{
FAIL_NO_CPU();
}
}
//////////////////////////////////////////////////////////////////////
// fastNonLocalMeans
DEF_PARAM_TEST(Sz_Depth_Cn_WinSz_BlockSz, cv::Size, MatDepth, MatCn, int, int);
PERF_TEST_P(Sz_Depth_Cn_WinSz_BlockSz, CUDA_FastNonLocalMeans,
Combine(CUDA_DENOISING_IMAGE_SIZES,
Values<MatDepth>(CV_8U),
CUDA_CHANNELS_1_3,
Values(21),
Values(7)))
{
declare.time(60.0);
const cv::Size size = GET_PARAM(0);
const int depth = GET_PARAM(1);
const int search_window_size = GET_PARAM(2);
const int block_size = GET_PARAM(3);
const float h = 10;
const int type = CV_MAKE_TYPE(depth, 1);
cv::Mat src(size, type);
declare.in(src, WARMUP_RNG);
if (PERF_RUN_CUDA())
{
const cv::cuda::GpuMat d_src(src);
cv::cuda::GpuMat dst;
TEST_CYCLE() cv::cuda::fastNlMeansDenoising(d_src, dst, h, search_window_size, block_size);
CUDA_SANITY_CHECK(dst);
}
else
{
cv::Mat dst;
TEST_CYCLE() cv::fastNlMeansDenoising(src, dst, h, block_size, search_window_size);
CPU_SANITY_CHECK(dst);
}
}
//////////////////////////////////////////////////////////////////////
// fastNonLocalMeans (colored)
DEF_PARAM_TEST(Sz_Depth_WinSz_BlockSz, cv::Size, MatDepth, int, int);
PERF_TEST_P(Sz_Depth_WinSz_BlockSz, CUDA_FastNonLocalMeansColored,
Combine(CUDA_DENOISING_IMAGE_SIZES,
Values<MatDepth>(CV_8U),
Values(21),
Values(7)))
{
declare.time(60.0);
const cv::Size size = GET_PARAM(0);
const int depth = GET_PARAM(1);
const int search_window_size = GET_PARAM(2);
const int block_size = GET_PARAM(3);
const float h = 10;
const int type = CV_MAKE_TYPE(depth, 3);
cv::Mat src(size, type);
declare.in(src, WARMUP_RNG);
if (PERF_RUN_CUDA())
{
const cv::cuda::GpuMat d_src(src);
cv::cuda::GpuMat dst;
TEST_CYCLE() cv::cuda::fastNlMeansDenoisingColored(d_src, dst, h, h, search_window_size, block_size);
CUDA_SANITY_CHECK(dst);
}
else
{
cv::Mat dst;
TEST_CYCLE() cv::fastNlMeansDenoisingColored(src, dst, h, h, block_size, search_window_size);
CPU_SANITY_CHECK(dst);
}
}
}} // namespace
#endif
modules/photo/perf/perf_hdr.cpp
+64
View File
@@ -0,0 +1,64 @@
// This file is part of OpenCV project.
// It is subject to the license terms in the LICENSE file found in the top-level directory
// of this distribution and at http://opencv.org/license.html.
#include "perf_precomp.hpp"
namespace opencv_test
{
namespace
{
struct ExposureSeq
{
std::vector<Mat> images;
std::vector<float> times;
};
ExposureSeq loadExposureSeq(const std::string& list_filename)
{
std::ifstream list_file(list_filename);
EXPECT_TRUE(list_file.is_open());
string name;
float val;
const String path(list_filename.substr(0, list_filename.find_last_of("\\/") + 1));
ExposureSeq seq;
while (list_file >> name >> val)
{
Mat img = imread(path + name);
EXPECT_FALSE(img.empty()) << "Could not load input image " << path + name;
seq.images.push_back(img);
seq.times.push_back(1 / val);
}
list_file.close();
return seq;
}
PERF_TEST(HDR, Mertens)
{
const ExposureSeq seq = loadExposureSeq(getDataPath("cv/hdr/exposures/list.txt"));
Ptr<MergeMertens> merge = createMergeMertens();
Mat result(seq.images.front().size(), seq.images.front().type());
TEST_CYCLE() merge->process(seq.images, result);
SANITY_CHECK_NOTHING();
}
PERF_TEST(HDR, Debevec)
{
const ExposureSeq seq = loadExposureSeq(getDataPath("cv/hdr/exposures/list.txt"));
Ptr<MergeDebevec> merge = createMergeDebevec();
Mat result(seq.images.front().size(), seq.images.front().type());
TEST_CYCLE() merge->process(seq.images, result, seq.times);
SANITY_CHECK_NOTHING();
}
PERF_TEST(HDR, Robertson)
{
const ExposureSeq seq = loadExposureSeq(getDataPath("cv/hdr/exposures/list.txt"));
Ptr<MergeRobertson> merge = createMergeRobertson();
Mat result(seq.images.front().size(), seq.images.front().type());
TEST_CYCLE() merge->process(seq.images, result, seq.times);
SANITY_CHECK_NOTHING();
}
} // namespace
} // namespace opencv_test
modules/photo/perf/perf_inpaint.cpp
+60
View File
@@ -0,0 +1,60 @@
#include "perf_precomp.hpp"
namespace opencv_test
{
CV_ENUM(InpaintingMethod, INPAINT_NS, INPAINT_TELEA)
typedef tuple<Size, InpaintingMethod> InpaintArea_InpaintingMethod_t;
typedef perf::TestBaseWithParam<InpaintArea_InpaintingMethod_t> InpaintArea_InpaintingMethod;
typedef perf::TestBaseWithParam<InpaintingMethod> Perf_InpaintingMethod;
PERF_TEST_P(InpaintArea_InpaintingMethod, inpaint,
testing::Combine(
testing::Values(::perf::szSmall24, ::perf::szSmall32, ::perf::szSmall64),
InpaintingMethod::all()
)
)
{
Mat src = imread(getDataPath("gpu/hog/road.png"));
Size sz = get<0>(GetParam());
int inpaintingMethod = get<1>(GetParam());
Mat mask(src.size(), CV_8UC1, Scalar(0));
Mat result(src.size(), src.type());
Rect inpaintArea(src.cols/3, src.rows/3, sz.width, sz.height);
mask(inpaintArea).setTo(255);
declare.in(src, mask).out(result).time(120);
TEST_CYCLE() inpaint(src, mask, result, 10.0, inpaintingMethod);
Mat inpaintedArea = result(inpaintArea);
SANITY_CHECK(inpaintedArea);
}
PERF_TEST_P(Perf_InpaintingMethod, inpaintDots, InpaintingMethod::all())
{
Mat src = imread(getDataPath("gpu/hog/road.png"));
int inpaintingMethod = GetParam();
Mat mask(src.size(), CV_8UC1, Scalar(0));
Mat result(src.size(), src.type());
for (int i = 0; i < src.size().height; i += 16) {
for (int j = 0; j < src.size().width; j += 16) {
mask.at<unsigned char>(i, j) = 255;
}
}
declare.in(src, mask).out(result).time(120);
TEST_CYCLE() inpaint(src, mask, result, 10.0, inpaintingMethod);
SANITY_CHECK_NOTHING();
}
} // namespace
modules/photo/perf/perf_intelligent_scissors.cpp
+34
View File
@@ -0,0 +1,34 @@
// This file is part of OpenCV project.
// It is subject to the license terms in the LICENSE file found in the top-level directory
// of this distribution and at http://opencv.org/license.html.
#include "perf_precomp.hpp"
namespace opencv_test { namespace {
typedef perf::TestBaseWithParam<int> TestIntelligentScissorsMB;
PERF_TEST_P(TestIntelligentScissorsMB, buildMap, testing::Values( IMREAD_GRAYSCALE, IMREAD_COLOR ))
{
const int flags = GetParam();
const Mat image = imread(findDataFile("cv/shared/lena.png"), flags);
ASSERT_TRUE(!image.empty());
const Point source_point(275, 63);
segmentation::IntelligentScissorsMB tool;
tool.applyImage(image);
PERF_SAMPLE_BEGIN()
for (size_t idx = 1; idx <= 100; ++idx)
{
tool.buildMap(source_point);
}
PERF_SAMPLE_END()
SANITY_CHECK_NOTHING();
}
}} // namespace
modules/photo/perf/perf_main.cpp
+15
View File
@@ -0,0 +1,15 @@
#include "perf_precomp.hpp"
#include "opencv2/ts/cuda_perf.hpp"
static const char * impls[] = {
#ifdef HAVE_CUDA
"cuda",
#endif
"plain"
};
#if defined(HAVE_HPX)
#include <hpx/hpx_main.hpp>
#endif
CV_PERF_TEST_MAIN_WITH_IMPLS(photo, impls, perf::printCudaInfo())
modules/photo/perf/perf_precomp.hpp
+7
View File
@@ -0,0 +1,7 @@
#ifndef __OPENCV_PERF_PRECOMP_HPP__
#define __OPENCV_PERF_PRECOMP_HPP__
#include "opencv2/ts.hpp"
#include "opencv2/photo.hpp"
#endif