mirror of https://github.com/opencv/opencv.git
Open Source Computer Vision Library
https://opencv.org/
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
235 lines
8.0 KiB
235 lines
8.0 KiB
/*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) 2010-2012, Multicoreware, Inc., all rights reserved. |
|
// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved. |
|
// Third party copyrights are property of their respective owners. |
|
// |
|
// @Authors |
|
// Erping Pang, pang_er_ping@163.com |
|
// Xiaopeng Fu, fuxiaopeng2222@163.com |
|
// |
|
// 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 "test_precomp.hpp" |
|
|
|
#ifdef HAVE_OPENCL |
|
|
|
using namespace cvtest; |
|
using namespace testing; |
|
using namespace std; |
|
using namespace cv; |
|
|
|
#define OCL_KMEANS_USE_INITIAL_LABELS 1 |
|
#define OCL_KMEANS_PP_CENTERS 2 |
|
|
|
PARAM_TEST_CASE(Kmeans, int, int, int) |
|
{ |
|
int type; |
|
int K; |
|
int flags; |
|
Mat src ; |
|
ocl::oclMat d_src, d_dists; |
|
|
|
Mat labels, centers; |
|
ocl::oclMat d_labels, d_centers; |
|
virtual void SetUp() |
|
{ |
|
K = GET_PARAM(0); |
|
type = GET_PARAM(1); |
|
flags = GET_PARAM(2); |
|
|
|
// MWIDTH=256, MHEIGHT=256. defined in utility.hpp |
|
Size size = Size(MWIDTH, MHEIGHT); |
|
src.create(size, type); |
|
int row_idx = 0; |
|
const int max_neighbour = MHEIGHT / K - 1; |
|
CV_Assert(K <= MWIDTH); |
|
for(int i = 0; i < K; i++ ) |
|
{ |
|
Mat center_row_header = src.row(row_idx); |
|
center_row_header.setTo(0); |
|
int nchannel = center_row_header.channels(); |
|
for(int j = 0; j < nchannel; j++) |
|
center_row_header.at<float>(0, i*nchannel+j) = 50000.0; |
|
|
|
for(int j = 0; (j < max_neighbour) || |
|
(i == K-1 && j < max_neighbour + MHEIGHT%K); j ++) |
|
{ |
|
Mat cur_row_header = src.row(row_idx + 1 + j); |
|
center_row_header.copyTo(cur_row_header); |
|
Mat tmpmat = randomMat(cur_row_header.size(), cur_row_header.type(), -200, 200, false); |
|
cur_row_header += tmpmat; |
|
} |
|
row_idx += 1 + max_neighbour; |
|
} |
|
} |
|
}; |
|
OCL_TEST_P(Kmeans, Mat){ |
|
if(flags & KMEANS_USE_INITIAL_LABELS) |
|
{ |
|
// inital a given labels |
|
labels.create(src.rows, 1, CV_32S); |
|
int *label = labels.ptr<int>(); |
|
for(int i = 0; i < src.rows; i++) |
|
label[i] = rng.uniform(0, K); |
|
d_labels.upload(labels); |
|
} |
|
d_src.upload(src); |
|
|
|
for(int j = 0; j < LOOP_TIMES; j++) |
|
{ |
|
kmeans(src, K, labels, |
|
TermCriteria( CV_TERMCRIT_EPS+CV_TERMCRIT_ITER, 100, 0), |
|
1, flags, centers); |
|
ocl::kmeans(d_src, K, d_labels, |
|
TermCriteria( CV_TERMCRIT_EPS+CV_TERMCRIT_ITER, 100, 0), |
|
1, flags, d_centers); |
|
Mat dd_labels(d_labels); |
|
Mat dd_centers(d_centers); |
|
if(flags & KMEANS_USE_INITIAL_LABELS) |
|
{ |
|
EXPECT_MAT_NEAR(labels, dd_labels, 0); |
|
EXPECT_MAT_NEAR(centers, dd_centers, 1e-3); |
|
} |
|
else |
|
{ |
|
int row_idx = 0; |
|
for(int i = 0; i < K; i++) |
|
{ |
|
// verify lables with ground truth resutls |
|
int label = labels.at<int>(row_idx); |
|
int header_label = dd_labels.at<int>(row_idx); |
|
for(int j2 = 0; (j2 < MHEIGHT/K)||(i == K-1 && j2 < MHEIGHT/K+MHEIGHT%K); j2++) |
|
{ |
|
ASSERT_NEAR(labels.at<int>(row_idx+j2), label, 0); |
|
ASSERT_NEAR(dd_labels.at<int>(row_idx+j2), header_label, 0); |
|
} |
|
|
|
// verify centers |
|
float *center = centers.ptr<float>(label); |
|
float *header_center = dd_centers.ptr<float>(header_label); |
|
for(int t = 0; t < centers.cols; t++) |
|
ASSERT_NEAR(center[t], header_center[t], 1e-3); |
|
|
|
row_idx += MHEIGHT/K; |
|
} |
|
} |
|
} |
|
} |
|
|
|
INSTANTIATE_TEST_CASE_P(OCL_ML, Kmeans, Combine( |
|
Values(3, 5, 8), |
|
Values(CV_32FC1, CV_32FC2, CV_32FC4), |
|
Values(OCL_KMEANS_USE_INITIAL_LABELS/*, OCL_KMEANS_PP_CENTERS*/))); |
|
|
|
|
|
/////////////////////////////// DistanceToCenters ////////////////////////////////////////// |
|
|
|
CV_ENUM(DistType, NORM_L1, NORM_L2SQR) |
|
|
|
PARAM_TEST_CASE(distanceToCenters, DistType, bool) |
|
{ |
|
int distType; |
|
bool useRoi; |
|
|
|
Mat src, centers, src_roi, centers_roi; |
|
ocl::oclMat ocl_src, ocl_centers, ocl_src_roi, ocl_centers_roi; |
|
|
|
virtual void SetUp() |
|
{ |
|
distType = GET_PARAM(0); |
|
useRoi = GET_PARAM(1); |
|
} |
|
|
|
void random_roi() |
|
{ |
|
Size roiSizeSrc = randomSize(1, MAX_VALUE); |
|
Size roiSizeCenters = randomSize(1, MAX_VALUE); |
|
roiSizeSrc.width = roiSizeCenters.width; |
|
|
|
Border srcBorder = randomBorder(0, useRoi ? MAX_VALUE : 0); |
|
randomSubMat(src, src_roi, roiSizeSrc, srcBorder, CV_32FC1, -MAX_VALUE, MAX_VALUE); |
|
|
|
Border centersBorder = randomBorder(0, useRoi ? 500 : 0); |
|
randomSubMat(centers, centers_roi, roiSizeCenters, centersBorder, CV_32FC1, -MAX_VALUE, MAX_VALUE); |
|
|
|
for (int i = 0; i < centers.rows; i++) |
|
centers.at<float>(i, randomInt(0, centers.cols)) = (float)randomDouble(SHRT_MAX, INT_MAX); |
|
|
|
generateOclMat(ocl_src, ocl_src_roi, src, roiSizeSrc, srcBorder); |
|
generateOclMat(ocl_centers, ocl_centers_roi, centers, roiSizeCenters, centersBorder); |
|
} |
|
}; |
|
|
|
OCL_TEST_P(distanceToCenters, Accuracy) |
|
{ |
|
for (int j = 0; j < LOOP_TIMES; j++) |
|
{ |
|
random_roi(); |
|
|
|
Mat labels, dists; |
|
ocl::distanceToCenters(ocl_src_roi, ocl_centers_roi, dists, labels, distType); |
|
|
|
EXPECT_EQ(dists.size(), labels.size()); |
|
|
|
Mat batch_dists; |
|
cv::batchDistance(src_roi, centers_roi, batch_dists, CV_32FC1, noArray(), distType); |
|
|
|
std::vector<float> gold_dists_v; |
|
gold_dists_v.reserve(batch_dists.rows); |
|
|
|
for (int i = 0; i < batch_dists.rows; i++) |
|
{ |
|
Mat r = batch_dists.row(i); |
|
double mVal; |
|
Point mLoc; |
|
minMaxLoc(r, &mVal, NULL, &mLoc, NULL); |
|
|
|
int ocl_label = labels.at<int>(i, 0); |
|
EXPECT_EQ(mLoc.x, ocl_label); |
|
|
|
gold_dists_v.push_back(static_cast<float>(mVal)); |
|
} |
|
|
|
double relative_error = cv::norm(Mat(gold_dists_v), dists, NORM_INF | NORM_RELATIVE); |
|
ASSERT_LE(relative_error, 1e-5); |
|
} |
|
} |
|
|
|
INSTANTIATE_TEST_CASE_P (OCL_ML, distanceToCenters, Combine(DistType::all(), Bool())); |
|
|
|
#endif
|
|
|