Merge branch 'master' of https://github.com/Itseez/opencv
Conflicts: modules/imgproc/src/sumpixels.cpppull/1932/head
sprice
12 years ago
commit
1c15776cf5
107 changed files with 8673 additions and 1052 deletions
@ -0,0 +1,21 @@ |
||||
if(NOT WITH_VTK OR ANDROID OR IOS) |
||||
return() |
||||
endif() |
||||
|
||||
find_package(VTK 6.0 QUIET COMPONENTS vtkRenderingCore vtkInteractionWidgets vtkInteractionStyle vtkIOLegacy vtkIOPLY vtkRenderingFreeType vtkRenderingLOD vtkFiltersTexture NO_MODULE) |
||||
|
||||
if(NOT DEFINED VTK_FOUND OR NOT VTK_FOUND) |
||||
find_package(VTK 5.10 QUIET COMPONENTS vtkCommon vtkFiltering vtkRendering vtkWidgets vtkImaging NO_MODULE) |
||||
endif() |
||||
|
||||
if(NOT DEFINED VTK_FOUND OR NOT VTK_FOUND) |
||||
find_package(VTK 5.8 QUIET COMPONENTS vtkCommon vtkFiltering vtkRendering vtkWidgets vtkImaging NO_MODULE) |
||||
endif() |
||||
|
||||
if(VTK_FOUND) |
||||
set(HAVE_VTK ON) |
||||
message(STATUS "Found VTK ver. ${VTK_VERSION} (usefile: ${VTK_USE_FILE})") |
||||
else() |
||||
set(HAVE_VTK OFF) |
||||
message(STATUS "VTK is not found. Please set -DVTK_DIR in CMake to VTK build directory, or set $VTK_DIR enviroment variable to VTK install subdirectory with VTKConfig.cmake file (for windows)") |
||||
endif() |
||||
@ -0,0 +1,102 @@ |
||||
/*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) 2013, OpenCV Foundation, 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 OpenCV Foundation 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*/ |
||||
|
||||
#define sizeoftype ((int)sizeof(type)) |
||||
|
||||
__kernel void arithm_flip_rows(__global const uchar* srcptr, int srcstep, int srcoffset, |
||||
__global uchar* dstptr, int dststep, int dstoffset, |
||||
int rows, int cols, int thread_rows, int thread_cols) |
||||
{ |
||||
int x = get_global_id(0); |
||||
int y = get_global_id(1); |
||||
|
||||
if (x < cols && y < thread_rows) |
||||
{ |
||||
__global const type* src0 = (__global const type*)(srcptr + mad24(y, srcstep, srcoffset + x * sizeoftype)); |
||||
__global const type* src1 = (__global const type*)(srcptr + mad24(rows - y - 1, srcstep, srcoffset + x * sizeoftype)); |
||||
|
||||
__global type* dst0 = (__global type*)(dstptr + mad24(y, dststep, dstoffset + x * sizeoftype)); |
||||
__global type* dst1 = (__global type*)(dstptr + mad24(rows - y - 1, dststep, dstoffset + x * sizeoftype)); |
||||
|
||||
dst0[0] = src1[0]; |
||||
dst1[0] = src0[0]; |
||||
} |
||||
} |
||||
|
||||
__kernel void arithm_flip_rows_cols(__global const uchar* srcptr, int srcstep, int srcoffset, |
||||
__global uchar* dstptr, int dststep, int dstoffset, |
||||
int rows, int cols, int thread_rows, int thread_cols) |
||||
{ |
||||
int x = get_global_id(0); |
||||
int y = get_global_id(1); |
||||
|
||||
if (x < cols && y < thread_rows) |
||||
{ |
||||
__global const type* src0 = (__global const type*)(srcptr + mad24(y, srcstep, x*sizeoftype + srcoffset)); |
||||
__global const type* src1 = (__global const type*)(srcptr + mad24(rows - y - 1, srcstep, (cols - x - 1)*sizeoftype + srcoffset)); |
||||
|
||||
__global type* dst0 = (__global type*)(dstptr + mad24(rows - y - 1, dststep, (cols - x - 1)*sizeoftype + dstoffset)); |
||||
__global type* dst1 = (__global type*)(dstptr + mad24(y, dststep, x * sizeoftype + dstoffset)); |
||||
|
||||
dst0[0] = src0[0]; |
||||
dst1[0] = src1[0]; |
||||
} |
||||
} |
||||
|
||||
__kernel void arithm_flip_cols(__global const uchar* srcptr, int srcstep, int srcoffset, |
||||
__global uchar* dstptr, int dststep, int dstoffset, |
||||
int rows, int cols, int thread_rows, int thread_cols) |
||||
{ |
||||
int x = get_global_id(0); |
||||
int y = get_global_id(1); |
||||
|
||||
if (x < thread_cols && y < rows) |
||||
{ |
||||
__global const type* src0 = (__global const type*)(srcptr + mad24(y, srcstep, x * sizeoftype + srcoffset)); |
||||
__global const type* src1 = (__global const type*)(srcptr + mad24(y, srcstep, (cols - x - 1)*sizeoftype + srcoffset)); |
||||
|
||||
__global type* dst0 = (__global type*)(dstptr + mad24(y, dststep, (cols - x - 1)*sizeoftype + dstoffset)); |
||||
__global type* dst1 = (__global type*)(dstptr + mad24(y, dststep, x * sizeoftype + dstoffset)); |
||||
|
||||
dst1[0] = src1[0]; |
||||
dst0[0] = src0[0]; |
||||
} |
||||
} |
||||
@ -0,0 +1,88 @@ |
||||
/*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, Institute Of Software Chinese Academy Of Science, all rights reserved. |
||||
// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved. |
||||
// Copyright (C) 2013, OpenCV Foundation, 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 copyright holders 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*/ |
||||
|
||||
#ifdef OP_MERGE |
||||
|
||||
#define DECLARE_SRC_PARAM(index) __global const uchar * src##index##ptr, int src##index##_step, int src##index##_offset, |
||||
#define DECLARE_DATA(index) __global const T * src##index = \ |
||||
(__global T *)(src##index##ptr + mad24(src##index##_step, y, x * (int)sizeof(T) + src##index##_offset)); |
||||
#define PROCESS_ELEM(index) dst[index] = src##index[0]; |
||||
|
||||
__kernel void merge(DECLARE_SRC_PARAMS_N |
||||
__global uchar * dstptr, int dst_step, int dst_offset, |
||||
int rows, int cols) |
||||
{ |
||||
int x = get_global_id(0); |
||||
int y = get_global_id(1); |
||||
|
||||
if (x < cols && y < rows) |
||||
{ |
||||
DECLARE_DATA_N |
||||
__global T * dst = (__global T *)(dstptr + mad24(dst_step, y, x * (int)sizeof(T) * cn + dst_offset)); |
||||
PROCESS_ELEMS_N |
||||
} |
||||
} |
||||
|
||||
#elif defined OP_SPLIT |
||||
|
||||
#define DECLARE_DST_PARAM(index) , __global uchar * dst##index##ptr, int dst##index##_step, int dst##index##_offset |
||||
#define DECLARE_DATA(index) __global T * dst##index = \ |
||||
(__global T *)(dst##index##ptr + mad24(y, dst##index##_step, x * (int)sizeof(T) + dst##index##_offset)); |
||||
#define PROCESS_ELEM(index) dst##index[0] = src[index]; |
||||
|
||||
__kernel void split(__global uchar* srcptr, int src_step, int src_offset, int rows, int cols DECLARE_DST_PARAMS) |
||||
{ |
||||
int x = get_global_id(0); |
||||
int y = get_global_id(1); |
||||
|
||||
if (x < cols && y < rows) |
||||
{ |
||||
DECLARE_DATA_N |
||||
__global const T * src = (__global const T *)(srcptr + mad24(y, src_step, x * cn * (int)sizeof(T) + src_offset)); |
||||
PROCESS_ELEMS_N |
||||
} |
||||
} |
||||
|
||||
#else |
||||
#error "No operation" |
||||
#endif |
||||
@ -0,0 +1,222 @@ |
||||
/*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, Institute Of Software Chinese Academy Of Science, all rights reserved.
|
||||
// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved.
|
||||
// Copyright (C) 2010-2012, Multicoreware, Inc., all rights reserved.
|
||||
// Third party copyrights are property of their respective owners.
|
||||
//
|
||||
// @Authors
|
||||
// Jia Haipeng, jiahaipeng95@gmail.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" |
||||
#include "opencv2/ts/ocl_test.hpp" |
||||
|
||||
#ifdef HAVE_OPENCL |
||||
|
||||
namespace cvtest { |
||||
namespace ocl { |
||||
|
||||
PARAM_TEST_CASE(MergeTestBase, MatDepth, Channels, bool) |
||||
{ |
||||
int depth, cn; |
||||
bool use_roi; |
||||
|
||||
TEST_DECLARE_INPUT_PARAMETER(src1) |
||||
TEST_DECLARE_INPUT_PARAMETER(src2) |
||||
TEST_DECLARE_INPUT_PARAMETER(src3) |
||||
TEST_DECLARE_INPUT_PARAMETER(src4) |
||||
TEST_DECLARE_OUTPUT_PARAMETER(dst) |
||||
|
||||
std::vector<Mat> src_roi; |
||||
std::vector<UMat> usrc_roi; |
||||
|
||||
virtual void SetUp() |
||||
{ |
||||
depth = GET_PARAM(0); |
||||
cn = GET_PARAM(1); |
||||
use_roi = GET_PARAM(2); |
||||
|
||||
CV_Assert(cn >= 1 && cn <= 4); |
||||
} |
||||
|
||||
void random_roi() |
||||
{ |
||||
Size roiSize = randomSize(1, MAX_VALUE); |
||||
|
||||
{ |
||||
Border src1Border = randomBorder(0, use_roi ? MAX_VALUE : 0); |
||||
randomSubMat(src1, src1_roi, roiSize, src1Border, depth, 2, 11); |
||||
|
||||
Border src2Border = randomBorder(0, use_roi ? MAX_VALUE : 0); |
||||
randomSubMat(src2, src2_roi, roiSize, src2Border, depth, -1540, 1740); |
||||
|
||||
Border src3Border = randomBorder(0, use_roi ? MAX_VALUE : 0); |
||||
randomSubMat(src3, src3_roi, roiSize, src3Border, depth, -1540, 1740); |
||||
|
||||
Border src4Border = randomBorder(0, use_roi ? MAX_VALUE : 0); |
||||
randomSubMat(src4, src4_roi, roiSize, src4Border, depth, -1540, 1740); |
||||
} |
||||
|
||||
Border dstBorder = randomBorder(0, use_roi ? MAX_VALUE : 0); |
||||
randomSubMat(dst, dst_roi, roiSize, dstBorder, CV_MAKE_TYPE(depth, cn), 5, 16); |
||||
|
||||
UMAT_UPLOAD_INPUT_PARAMETER(src1) |
||||
UMAT_UPLOAD_INPUT_PARAMETER(src2) |
||||
UMAT_UPLOAD_INPUT_PARAMETER(src3) |
||||
UMAT_UPLOAD_INPUT_PARAMETER(src4) |
||||
UMAT_UPLOAD_OUTPUT_PARAMETER(dst) |
||||
|
||||
src_roi.push_back(src1_roi), usrc_roi.push_back(usrc1_roi); |
||||
if (cn >= 2) |
||||
src_roi.push_back(src2_roi), usrc_roi.push_back(usrc2_roi); |
||||
if (cn >= 3) |
||||
src_roi.push_back(src3_roi), usrc_roi.push_back(usrc3_roi); |
||||
if (cn >= 4) |
||||
src_roi.push_back(src4_roi), usrc_roi.push_back(usrc4_roi); |
||||
} |
||||
|
||||
void Near(double threshold = 0.) |
||||
{ |
||||
OCL_EXPECT_MATS_NEAR(dst, threshold); |
||||
} |
||||
}; |
||||
|
||||
typedef MergeTestBase Merge; |
||||
|
||||
OCL_TEST_P(Merge, Accuracy) |
||||
{ |
||||
for(int j = 0; j < test_loop_times; j++) |
||||
{ |
||||
random_roi(); |
||||
|
||||
OCL_OFF(cv::merge(src_roi, dst_roi)); |
||||
OCL_ON(cv::merge(usrc_roi, udst_roi)); |
||||
|
||||
Near(); |
||||
} |
||||
} |
||||
|
||||
PARAM_TEST_CASE(SplitTestBase, MatType, Channels, bool) |
||||
{ |
||||
int depth, cn; |
||||
bool use_roi; |
||||
|
||||
TEST_DECLARE_INPUT_PARAMETER(src) |
||||
TEST_DECLARE_OUTPUT_PARAMETER(dst1) |
||||
TEST_DECLARE_OUTPUT_PARAMETER(dst2) |
||||
TEST_DECLARE_OUTPUT_PARAMETER(dst3) |
||||
TEST_DECLARE_OUTPUT_PARAMETER(dst4) |
||||
|
||||
std::vector<Mat> dst_roi, dst; |
||||
std::vector<UMat> udst_roi, udst; |
||||
|
||||
virtual void SetUp() |
||||
{ |
||||
depth = GET_PARAM(0); |
||||
cn = GET_PARAM(1); |
||||
use_roi = GET_PARAM(2); |
||||
|
||||
CV_Assert(cn >= 1 && cn <= 4); |
||||
} |
||||
|
||||
void random_roi() |
||||
{ |
||||
Size roiSize = randomSize(1, MAX_VALUE); |
||||
Border srcBorder = randomBorder(0, use_roi ? MAX_VALUE : 0); |
||||
randomSubMat(src, src_roi, roiSize, srcBorder, CV_MAKE_TYPE(depth, cn), 5, 16); |
||||
|
||||
{ |
||||
Border dst1Border = randomBorder(0, use_roi ? MAX_VALUE : 0); |
||||
randomSubMat(dst1, dst1_roi, roiSize, dst1Border, depth, 2, 11); |
||||
|
||||
Border dst2Border = randomBorder(0, use_roi ? MAX_VALUE : 0); |
||||
randomSubMat(dst2, dst2_roi, roiSize, dst2Border, depth, -1540, 1740); |
||||
|
||||
Border dst3Border = randomBorder(0, use_roi ? MAX_VALUE : 0); |
||||
randomSubMat(dst3, dst3_roi, roiSize, dst3Border, depth, -1540, 1740); |
||||
|
||||
Border dst4Border = randomBorder(0, use_roi ? MAX_VALUE : 0); |
||||
randomSubMat(dst4, dst4_roi, roiSize, dst4Border, depth, -1540, 1740); |
||||
} |
||||
|
||||
UMAT_UPLOAD_INPUT_PARAMETER(src) |
||||
UMAT_UPLOAD_OUTPUT_PARAMETER(dst1) |
||||
UMAT_UPLOAD_OUTPUT_PARAMETER(dst2) |
||||
UMAT_UPLOAD_OUTPUT_PARAMETER(dst3) |
||||
UMAT_UPLOAD_OUTPUT_PARAMETER(dst4) |
||||
|
||||
dst_roi.push_back(dst1_roi), udst_roi.push_back(udst1_roi), |
||||
dst.push_back(dst1), udst.push_back(udst1); |
||||
if (cn >= 2) |
||||
dst_roi.push_back(dst2_roi), udst_roi.push_back(udst2_roi), |
||||
dst.push_back(dst2), udst.push_back(udst2); |
||||
if (cn >= 3) |
||||
dst_roi.push_back(dst3_roi), udst_roi.push_back(udst3_roi), |
||||
dst.push_back(dst3), udst.push_back(udst3); |
||||
if (cn >= 4) |
||||
dst_roi.push_back(dst4_roi), udst_roi.push_back(udst4_roi), |
||||
dst.push_back(dst4), udst.push_back(udst4); |
||||
} |
||||
}; |
||||
|
||||
typedef SplitTestBase Split; |
||||
|
||||
OCL_TEST_P(Split, Accuracy) |
||||
{ |
||||
for (int j = 0; j < test_loop_times; j++) |
||||
{ |
||||
random_roi(); |
||||
|
||||
OCL_OFF(cv::split(src_roi, dst_roi)); |
||||
OCL_ON(cv::split(usrc_roi, udst_roi)); |
||||
|
||||
for (int i = 0; i < cn; ++i) |
||||
{ |
||||
EXPECT_MAT_NEAR(dst[i], udst[i], 0.0); |
||||
EXPECT_MAT_NEAR(dst_roi[i], udst_roi[i], 0.0); |
||||
} |
||||
} |
||||
} |
||||
|
||||
OCL_INSTANTIATE_TEST_CASE_P(SplitMerge, Merge, Combine(OCL_ALL_DEPTHS, OCL_ALL_CHANNELS, Bool())); |
||||
OCL_INSTANTIATE_TEST_CASE_P(SplitMerge, Split, Combine(OCL_ALL_DEPTHS, OCL_ALL_CHANNELS, Bool())); |
||||
|
||||
} } // namespace cvtest::ocl
|
||||
|
||||
#endif // HAVE_OPENCL
|
||||
@ -0,0 +1,145 @@ |
||||
/*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
|
||||
// Nathan, liujun@multicorewareinc.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 "precomp.hpp" |
||||
#include "opencl_kernels.hpp" |
||||
|
||||
namespace cv { |
||||
|
||||
template <typename T> |
||||
class BlendLinearInvoker : |
||||
public ParallelLoopBody |
||||
{ |
||||
public: |
||||
BlendLinearInvoker(const Mat & _src1, const Mat & _src2, const Mat & _weights1, |
||||
const Mat & _weights2, Mat & _dst) : |
||||
src1(&_src1), src2(&_src2), weights1(&_weights1), weights2(&_weights2), dst(&_dst) |
||||
{ |
||||
} |
||||
|
||||
virtual void operator() (const Range & range) const |
||||
{ |
||||
int cn = src1->channels(), width = src1->cols * cn; |
||||
|
||||
for (int y = range.start; y < range.end; ++y) |
||||
{ |
||||
const float * const weights1_row = weights1->ptr<float>(y); |
||||
const float * const weights2_row = weights2->ptr<float>(y); |
||||
const T * const src1_row = src1->ptr<T>(y); |
||||
const T * const src2_row = src2->ptr<T>(y); |
||||
T * const dst_row = dst->ptr<T>(y); |
||||
|
||||
for (int x = 0; x < width; ++x) |
||||
{ |
||||
int x1 = x / cn; |
||||
float w1 = weights1_row[x1], w2 = weights2_row[x1]; |
||||
float den = (w1 + w2 + 1e-5f); |
||||
float num = (src1_row[x] * w1 + src2_row[x] * w2); |
||||
|
||||
dst_row[x] = saturate_cast<T>(num / den); |
||||
} |
||||
} |
||||
} |
||||
|
||||
private: |
||||
const BlendLinearInvoker & operator= (const BlendLinearInvoker &); |
||||
BlendLinearInvoker(const BlendLinearInvoker &); |
||||
|
||||
const Mat * src1, * src2, * weights1, * weights2; |
||||
Mat * dst; |
||||
}; |
||||
|
||||
static bool ocl_blendLinear( InputArray _src1, InputArray _src2, InputArray _weights1, InputArray _weights2, OutputArray _dst ) |
||||
{ |
||||
int type = _src1.type(), depth = CV_MAT_DEPTH(type), cn = CV_MAT_CN(type); |
||||
|
||||
char cvt[30]; |
||||
ocl::Kernel k("blendLinear", ocl::imgproc::blend_linear_oclsrc, |
||||
format("-D T=%s -D cn=%d -D convertToT=%s", ocl::typeToStr(depth), |
||||
cn, ocl::convertTypeStr(CV_32F, depth, 1, cvt))); |
||||
if (k.empty()) |
||||
return false; |
||||
|
||||
UMat src1 = _src1.getUMat(), src2 = _src2.getUMat(), weights1 = _weights1.getUMat(), |
||||
weights2 = _weights2.getUMat(), dst = _dst.getUMat(); |
||||
|
||||
k.args(ocl::KernelArg::ReadOnlyNoSize(src1), ocl::KernelArg::ReadOnlyNoSize(src2), |
||||
ocl::KernelArg::ReadOnlyNoSize(weights1), ocl::KernelArg::ReadOnlyNoSize(weights2), |
||||
ocl::KernelArg::WriteOnly(dst)); |
||||
|
||||
size_t globalsize[2] = { dst.cols, dst.rows }; |
||||
return k.run(2, globalsize, NULL, false); |
||||
} |
||||
|
||||
} |
||||
|
||||
void cv::blendLinear( InputArray _src1, InputArray _src2, InputArray _weights1, InputArray _weights2, OutputArray _dst ) |
||||
{ |
||||
int type = _src1.type(), depth = CV_MAT_DEPTH(type); |
||||
Size size = _src1.size(); |
||||
|
||||
CV_Assert(depth == CV_8U || depth == CV_32F); |
||||
CV_Assert(size == _src2.size() && size == _weights1.size() && size == _weights2.size()); |
||||
CV_Assert(type == _src2.type() && _weights1.type() == CV_32FC1 && _weights2.type() == CV_32FC1); |
||||
|
||||
_dst.create(size, type); |
||||
|
||||
if (ocl::useOpenCL() && _dst.isUMat() && ocl_blendLinear(_src1, _src2, _weights1, _weights2, _dst)) |
||||
return; |
||||
|
||||
Mat src1 = _src1.getMat(), src2 = _src2.getMat(), weights1 = _weights1.getMat(), |
||||
weights2 = _weights2.getMat(), dst = _dst.getMat(); |
||||
|
||||
if (depth == CV_8U) |
||||
{ |
||||
BlendLinearInvoker<uchar> invoker(src1, src2, weights1, weights2, dst); |
||||
parallel_for_(Range(0, src1.rows), invoker, dst.total()/(double)(1<<16)); |
||||
} |
||||
else if (depth == CV_32F) |
||||
{ |
||||
BlendLinearInvoker<float> invoker(src1, src2, weights1, weights2, dst); |
||||
parallel_for_(Range(0, src1.rows), invoker, dst.total()/(double)(1<<16)); |
||||
} |
||||
} |
||||
@ -0,0 +1,59 @@ |
||||
// License Agreement |
||||
// For Open Source Computer Vision Library |
||||
// |
||||
// Copyright (C) 2010-2012, Institute Of Software Chinese Academy Of Science, all rights reserved. |
||||
// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved. |
||||
// Third party copyrights are property of their respective owners. |
||||
// |
||||
// @Authors |
||||
// Rock Li, Rock.li@amd.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. |
||||
|
||||
__kernel void bilateral(__global const uchar * src, int src_step, int src_offset, |
||||
__global uchar * dst, int dst_step, int dst_offset, int dst_rows, int dst_cols, |
||||
__constant float * color_weight, __constant float * space_weight, __constant int * space_ofs) |
||||
{ |
||||
int x = get_global_id(0); |
||||
int y = get_global_id(1); |
||||
|
||||
if (y < dst_rows && x < dst_cols) |
||||
{ |
||||
int src_index = mad24(y + radius, src_step, x + radius + src_offset); |
||||
int dst_index = mad24(y, dst_step, x + dst_offset); |
||||
float sum = 0.f, wsum = 0.f; |
||||
int val0 = convert_int(src[src_index]); |
||||
|
||||
#pragma unroll |
||||
for (int k = 0; k < maxk; k++ ) |
||||
{ |
||||
int val = convert_int(src[src_index + space_ofs[k]]); |
||||
float w = space_weight[k] * color_weight[abs(val - val0)]; |
||||
sum += (float)(val) * w; |
||||
wsum += w; |
||||
} |
||||
dst[dst_index] = convert_uchar_rtz(sum / wsum + 0.5f); |
||||
} |
||||
} |
||||
@ -0,0 +1,88 @@ |
||||
/*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 |
||||
// Liu Liujun, liujun@multicorewareinc.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*/ |
||||
|
||||
#ifdef DOUBLE_SUPPORT |
||||
#ifdef cl_amd_fp64 |
||||
#pragma OPENCL EXTENSION cl_amd_fp64:enable |
||||
#elif defined (cl_khr_fp64) |
||||
#pragma OPENCL EXTENSION cl_khr_fp64:enable |
||||
#endif |
||||
#endif |
||||
|
||||
#define noconvert |
||||
|
||||
__kernel void blendLinear(__global const uchar * src1ptr, int src1_step, int src1_offset, |
||||
__global const uchar * src2ptr, int src2_step, int src2_offset, |
||||
__global const uchar * weight1, int weight1_step, int weight1_offset, |
||||
__global const uchar * weight2, int weight2_step, int weight2_offset, |
||||
__global uchar * dstptr, int dst_step, int dst_offset, int dst_rows, int dst_cols) |
||||
{ |
||||
int x = get_global_id(0); |
||||
int y = get_global_id(1); |
||||
|
||||
if (x < dst_cols && y < dst_rows) |
||||
{ |
||||
int src1_index = mad24(y, src1_step, src1_offset + x * cn * (int)sizeof(T)); |
||||
int src2_index = mad24(y, src2_step, src2_offset + x * cn * (int)sizeof(T)); |
||||
int weight1_index = mad24(y, weight1_step, weight1_offset + x * (int)sizeof(float)); |
||||
int weight2_index = mad24(y, weight2_step, weight2_offset + x * (int)sizeof(float)); |
||||
int dst_index = mad24(y, dst_step, dst_offset + x * cn * (int)sizeof(T)); |
||||
|
||||
float w1 = *(__global const float *)(weight1 + weight1_index), |
||||
w2 = *(__global const float *)(weight2 + weight2_index); |
||||
float den = w1 + w2 + 1e-5f; |
||||
|
||||
__global const T * src1 = (__global const T *)(src1ptr + src1_index); |
||||
__global const T * src2 = (__global const T *)(src2ptr + src2_index); |
||||
__global T * dst = (__global T *)(dstptr + dst_index); |
||||
|
||||
#pragma unroll |
||||
for (int i = 0; i < cn; ++i) |
||||
{ |
||||
float num = w1 * convert_float(src1[i]) + w2 * convert_float(src2[i]); |
||||
dst[i] = convertToT(num / den); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,375 @@ |
||||
/*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-2013, Advanced Micro Devices, 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*/ |
||||
|
||||
#ifdef BORDER_REPLICATE |
||||
//BORDER_REPLICATE: aaaaaa|abcdefgh|hhhhhhh |
||||
#define ADDR_L(i, l_edge, r_edge) ((i) < (l_edge) ? (l_edge) : (i)) |
||||
#define ADDR_R(i, r_edge, addr) ((i) >= (r_edge) ? (r_edge)-1 : (addr)) |
||||
#define ADDR_H(i, t_edge, b_edge) ((i) < (t_edge) ? (t_edge) :(i)) |
||||
#define ADDR_B(i, b_edge, addr) ((i) >= (b_edge) ? (b_edge)-1 :(addr)) |
||||
#endif |
||||
|
||||
#ifdef BORDER_REFLECT |
||||
//BORDER_REFLECT: fedcba|abcdefgh|hgfedcb |
||||
#define ADDR_L(i, l_edge, r_edge) ((i) < (l_edge) ? -(i)-1 : (i)) |
||||
#define ADDR_R(i, r_edge, addr) ((i) >= (r_edge) ? -(i)-1+((r_edge)<<1) : (addr)) |
||||
#define ADDR_H(i, t_edge, b_edge) ((i) < (t_edge) ? -(i)-1 : (i)) |
||||
#define ADDR_B(i, b_edge, addr) ((i) >= (b_edge) ? -(i)-1+((b_edge)<<1) : (addr)) |
||||
#endif |
||||
|
||||
#ifdef BORDER_REFLECT_101 |
||||
//BORDER_REFLECT_101: gfedcb|abcdefgh|gfedcba |
||||
#define ADDR_L(i, l_edge, r_edge) ((i) < (l_edge) ? -(i) : (i)) |
||||
#define ADDR_R(i, r_edge, addr) ((i) >= (r_edge) ? -(i)-2+((r_edge)<<1) : (addr)) |
||||
#define ADDR_H(i, t_edge, b_edge) ((i) < (t_edge) ? -(i) : (i)) |
||||
#define ADDR_B(i, b_edge, addr) ((i) >= (b_edge) ? -(i)-2+((b_edge)<<1) : (addr)) |
||||
#endif |
||||
|
||||
//blur function does not support BORDER_WRAP |
||||
#ifdef BORDER_WRAP |
||||
//BORDER_WRAP: cdefgh|abcdefgh|abcdefg |
||||
#define ADDR_L(i, l_edge, r_edge) ((i) < (l_edge) ? (i)+(r_edge) : (i)) |
||||
#define ADDR_R(i, r_edge, addr) ((i) >= (r_edge) ? (i)-(r_edge) : (addr)) |
||||
#define ADDR_H(i, t_edge, b_edge) ((i) < (t_edge) ? (i)+(b_edge) : (i)) |
||||
#define ADDR_B(i, b_edge, addr) ((i) >= (b_edge) ? (i)-(b_edge) : (addr)) |
||||
#endif |
||||
|
||||
#ifdef EXTRA_EXTRAPOLATION // border > src image size |
||||
#ifdef BORDER_CONSTANT |
||||
// None |
||||
#elif defined BORDER_REPLICATE |
||||
#define EXTRAPOLATE(x, y, minX, minY, maxX, maxY) \ |
||||
{ \ |
||||
x = max(min(x, maxX - 1), minX); \ |
||||
y = max(min(y, maxY - 1), minY); \ |
||||
} |
||||
#elif defined BORDER_WRAP |
||||
#define EXTRAPOLATE(x, y, minX, minY, maxX, maxY) \ |
||||
{ \ |
||||
if (x < minX) \ |
||||
x -= ((x - maxX + 1) / maxX) * maxX; \ |
||||
if (x >= maxX) \ |
||||
x %= maxX; \ |
||||
if (y < minY) \ |
||||
y -= ((y - maxY + 1) / maxY) * maxY; \ |
||||
if (y >= maxY) \ |
||||
y %= maxY; \ |
||||
} |
||||
#elif defined(BORDER_REFLECT) || defined(BORDER_REFLECT_101) |
||||
#define EXTRAPOLATE_(x, y, minX, minY, maxX, maxY, delta) \ |
||||
{ \ |
||||
if (maxX - minX == 1) \ |
||||
x = minX; \ |
||||
else \ |
||||
do \ |
||||
{ \ |
||||
if (x < minX) \ |
||||
x = minX - (x - minX) - 1 + delta; \ |
||||
else \ |
||||
x = maxX - 1 - (x - maxX) - delta; \ |
||||
} \ |
||||
while (x >= maxX || x < minX); \ |
||||
\ |
||||
if (maxY - minY == 1) \ |
||||
y = minY; \ |
||||
else \ |
||||
do \ |
||||
{ \ |
||||
if (y < minY) \ |
||||
y = minY - (y - minY) - 1 + delta; \ |
||||
else \ |
||||
y = maxY - 1 - (y - maxY) - delta; \ |
||||
} \ |
||||
while (y >= maxY || y < minY); \ |
||||
} |
||||
#ifdef BORDER_REFLECT |
||||
#define EXTRAPOLATE(x, y, minX, minY, maxX, maxY) EXTRAPOLATE_(x, y, minX, minY, maxX, maxY, 0) |
||||
#elif defined(BORDER_REFLECT_101) |
||||
#define EXTRAPOLATE(x, y, minX, minY, maxX, maxY) EXTRAPOLATE_(x, y, minX, minY, maxX, maxY, 1) |
||||
#endif |
||||
#else |
||||
#error No extrapolation method |
||||
#endif |
||||
#else |
||||
#define EXTRAPOLATE(x, y, minX, minY, maxX, maxY) \ |
||||
{ \ |
||||
int _row = y - minY, _col = x - minX; \ |
||||
_row = ADDR_H(_row, 0, maxY - minY); \ |
||||
_row = ADDR_B(_row, maxY - minY, _row); \ |
||||
y = _row + minY; \ |
||||
\ |
||||
_col = ADDR_L(_col, 0, maxX - minX); \ |
||||
_col = ADDR_R(_col, maxX - minX, _col); \ |
||||
x = _col + minX; \ |
||||
} |
||||
#endif |
||||
|
||||
#if USE_DOUBLE |
||||
#ifdef cl_amd_fp64 |
||||
#pragma OPENCL EXTENSION cl_amd_fp64:enable |
||||
#elif defined (cl_khr_fp64) |
||||
#pragma OPENCL EXTENSION cl_khr_fp64:enable |
||||
#endif |
||||
#define FPTYPE double |
||||
#define CONVERT_TO_FPTYPE CAT(convert_double, VEC_SIZE) |
||||
#else |
||||
#define FPTYPE float |
||||
#define CONVERT_TO_FPTYPE CAT(convert_float, VEC_SIZE) |
||||
#endif |
||||
|
||||
#if DATA_DEPTH == 0 |
||||
#define BASE_TYPE uchar |
||||
#elif DATA_DEPTH == 1 |
||||
#define BASE_TYPE char |
||||
#elif DATA_DEPTH == 2 |
||||
#define BASE_TYPE ushort |
||||
#elif DATA_DEPTH == 3 |
||||
#define BASE_TYPE short |
||||
#elif DATA_DEPTH == 4 |
||||
#define BASE_TYPE int |
||||
#elif DATA_DEPTH == 5 |
||||
#define BASE_TYPE float |
||||
#elif DATA_DEPTH == 6 |
||||
#define BASE_TYPE double |
||||
#else |
||||
#error data_depth |
||||
#endif |
||||
|
||||
#define __CAT(x, y) x##y |
||||
#define CAT(x, y) __CAT(x, y) |
||||
|
||||
#define uchar1 uchar |
||||
#define char1 char |
||||
#define ushort1 ushort |
||||
#define short1 short |
||||
#define int1 int |
||||
#define float1 float |
||||
#define double1 double |
||||
|
||||
#define convert_uchar1_sat_rte convert_uchar_sat_rte |
||||
#define convert_char1_sat_rte convert_char_sat_rte |
||||
#define convert_ushort1_sat_rte convert_ushort_sat_rte |
||||
#define convert_short1_sat_rte convert_short_sat_rte |
||||
#define convert_int1_sat_rte convert_int_sat_rte |
||||
#define convert_float1 |
||||
#define convert_double1 |
||||
|
||||
#if DATA_DEPTH == 5 || DATA_DEPTH == 6 |
||||
#define CONVERT_TO_TYPE CAT(CAT(convert_, BASE_TYPE), VEC_SIZE) |
||||
#else |
||||
#define CONVERT_TO_TYPE CAT(CAT(CAT(convert_, BASE_TYPE), VEC_SIZE), _sat_rte) |
||||
#endif |
||||
|
||||
#define VEC_SIZE DATA_CHAN |
||||
|
||||
#define VEC_TYPE CAT(BASE_TYPE, VEC_SIZE) |
||||
#define TYPE VEC_TYPE |
||||
|
||||
#define SCALAR_TYPE CAT(FPTYPE, VEC_SIZE) |
||||
|
||||
#define INTERMEDIATE_TYPE CAT(FPTYPE, VEC_SIZE) |
||||
|
||||
struct RectCoords |
||||
{ |
||||
int x1, y1, x2, y2; |
||||
}; |
||||
|
||||
//#define DEBUG |
||||
#ifdef DEBUG |
||||
#define DEBUG_ONLY(x) x |
||||
#define ASSERT(condition) do { if (!(condition)) { printf("BUG in boxFilter kernel (global=%d,%d): " #condition "\n", get_global_id(0), get_global_id(1)); } } while (0) |
||||
#else |
||||
#define DEBUG_ONLY(x) (void)0 |
||||
#define ASSERT(condition) (void)0 |
||||
#endif |
||||
|
||||
|
||||
inline INTERMEDIATE_TYPE readSrcPixel(int2 pos, __global const uchar* srcptr, int srcstep, const struct RectCoords srcCoords |
||||
#ifdef BORDER_CONSTANT |
||||
, SCALAR_TYPE borderValue |
||||
#endif |
||||
) |
||||
{ |
||||
#ifdef BORDER_ISOLATED |
||||
if(pos.x >= srcCoords.x1 && pos.y >= srcCoords.y1 && pos.x < srcCoords.x2 && pos.y < srcCoords.y2) |
||||
#else |
||||
if(pos.x >= 0 && pos.y >= 0 && pos.x < srcCoords.x2 && pos.y < srcCoords.y2) |
||||
#endif |
||||
{ |
||||
//__global TYPE* ptr = (__global TYPE*)((__global char*)src + pos.x * sizeof(TYPE) + pos.y * srcStepBytes); |
||||
__global TYPE* ptr = (__global TYPE*)(srcptr + pos.y * srcstep + pos.x * sizeof(TYPE)); |
||||
return CONVERT_TO_FPTYPE(*ptr); |
||||
} |
||||
else |
||||
{ |
||||
#ifdef BORDER_CONSTANT |
||||
return borderValue; |
||||
#else |
||||
int selected_col = pos.x; |
||||
int selected_row = pos.y; |
||||
|
||||
EXTRAPOLATE(selected_col, selected_row, |
||||
#ifdef BORDER_ISOLATED |
||||
srcCoords.x1, srcCoords.y1, |
||||
#else |
||||
0, 0, |
||||
#endif |
||||
srcCoords.x2, srcCoords.y2 |
||||
); |
||||
|
||||
// debug border mapping |
||||
//printf("pos=%d,%d --> %d, %d\n", pos.x, pos.y, selected_col, selected_row); |
||||
|
||||
pos = (int2)(selected_col, selected_row); |
||||
if(pos.x >= 0 && pos.y >= 0 && pos.x < srcCoords.x2 && pos.y < srcCoords.y2) |
||||
{ |
||||
//__global TYPE* ptr = (__global TYPE*)((__global char*)src + pos.x * sizeof(TYPE) + pos.y * srcStepBytes); |
||||
__global TYPE* ptr = (__global TYPE*)(srcptr + pos.y * srcstep + pos.x * sizeof(TYPE)); |
||||
return CONVERT_TO_FPTYPE(*ptr); |
||||
} |
||||
else |
||||
{ |
||||
// for debug only |
||||
DEBUG_ONLY(printf("BUG in boxFilter kernel\n")); |
||||
return (FPTYPE)(0.0f); |
||||
} |
||||
#endif |
||||
} |
||||
} |
||||
|
||||
// INPUT PARAMETER: BLOCK_SIZE_Y (via defines) |
||||
|
||||
__kernel |
||||
__attribute__((reqd_work_group_size(LOCAL_SIZE, 1, 1))) |
||||
void filter2D(__global const uchar* srcptr, int srcstep, int srcOffsetX, int srcOffsetY, int srcEndX, int srcEndY, |
||||
__global uchar* dstptr, int dststep, int dstoffset, |
||||
int rows, int cols, |
||||
#ifdef BORDER_CONSTANT |
||||
SCALAR_TYPE borderValue, |
||||
#endif |
||||
__constant FPTYPE* kernelData // transposed: [KERNEL_SIZE_X][KERNEL_SIZE_Y2_ALIGNED] |
||||
) |
||||
{ |
||||
const struct RectCoords srcCoords = {srcOffsetX, srcOffsetY, srcEndX, srcEndY}; // for non-isolated border: offsetX, offsetY, wholeX, wholeY |
||||
|
||||
const int local_id = get_local_id(0); |
||||
const int x = local_id + (LOCAL_SIZE - (KERNEL_SIZE_X - 1)) * get_group_id(0) - ANCHOR_X; |
||||
const int y = get_global_id(1) * BLOCK_SIZE_Y; |
||||
|
||||
INTERMEDIATE_TYPE data[KERNEL_SIZE_Y]; |
||||
__local INTERMEDIATE_TYPE sumOfCols[LOCAL_SIZE]; |
||||
|
||||
int2 srcPos = (int2)(srcCoords.x1 + x, srcCoords.y1 + y - ANCHOR_Y); |
||||
|
||||
int2 pos = (int2)(x, y); |
||||
__global TYPE* dstPtr = (__global TYPE*)((__global char*)dstptr + pos.y * dststep + dstoffset + pos.x * sizeof(TYPE)); // Pointer can be out of bounds! |
||||
bool writeResult = ((local_id >= ANCHOR_X) && (local_id < LOCAL_SIZE - (KERNEL_SIZE_X - 1 - ANCHOR_X)) && |
||||
(pos.x >= 0) && (pos.x < cols)); |
||||
|
||||
#if BLOCK_SIZE_Y > 1 |
||||
bool readAllpixels = true; |
||||
int sy_index = 0; // current index in data[] array |
||||
|
||||
dstRowsMax = min(rows, pos.y + BLOCK_SIZE_Y); |
||||
for (; |
||||
pos.y < dstRowsMax; |
||||
pos.y++, |
||||
dstPtr = (__global TYPE*)((__global char*)dstptr + dststep)) |
||||
#endif |
||||
{ |
||||
ASSERT(pos.y < dstRowsMax); |
||||
|
||||
for ( |
||||
#if BLOCK_SIZE_Y > 1 |
||||
int sy = readAllpixels ? 0 : -1; sy < (readAllpixels ? KERNEL_SIZE_Y : 0); |
||||
#else |
||||
int sy = 0, sy_index = 0; sy < KERNEL_SIZE_Y; |
||||
#endif |
||||
sy++, srcPos.y++) |
||||
{ |
||||
data[sy + sy_index] = readSrcPixel(srcPos, srcptr, srcstep, srcCoords |
||||
#ifdef BORDER_CONSTANT |
||||
, borderValue |
||||
#endif |
||||
); |
||||
} |
||||
|
||||
INTERMEDIATE_TYPE total_sum = 0; |
||||
for (int sx = 0; sx < KERNEL_SIZE_X; sx++) |
||||
{ |
||||
{ |
||||
__constant FPTYPE* k = &kernelData[KERNEL_SIZE_Y2_ALIGNED * sx |
||||
#if BLOCK_SIZE_Y > 1 |
||||
+ KERNEL_SIZE_Y - sy_index |
||||
#endif |
||||
]; |
||||
INTERMEDIATE_TYPE tmp_sum = 0; |
||||
for (int sy = 0; sy < KERNEL_SIZE_Y; sy++) |
||||
{ |
||||
tmp_sum += data[sy] * k[sy]; |
||||
} |
||||
|
||||
sumOfCols[local_id] = tmp_sum; |
||||
barrier(CLK_LOCAL_MEM_FENCE); |
||||
} |
||||
|
||||
int id = local_id + sx - ANCHOR_X; |
||||
if (id >= 0 && id < LOCAL_SIZE) |
||||
total_sum += sumOfCols[id]; |
||||
|
||||
barrier(CLK_LOCAL_MEM_FENCE); |
||||
} |
||||
|
||||
if (writeResult) |
||||
{ |
||||
*dstPtr = CONVERT_TO_TYPE(total_sum); |
||||
} |
||||
|
||||
#if BLOCK_SIZE_Y > 1 |
||||
readAllpixels = false; |
||||
#if BLOCK_SIZE_Y > KERNEL_SIZE_Y |
||||
sy_index = (sy_index + 1 <= KERNEL_SIZE_Y) ? sy_index + 1 : 1; |
||||
#else |
||||
sy_index++; |
||||
#endif |
||||
#endif // BLOCK_SIZE_Y == 1 |
||||
} |
||||
} |
||||
@ -0,0 +1,512 @@ |
||||
/*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, Institute Of Software Chinese Academy Of Science, all rights reserved. |
||||
// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved. |
||||
// Third party copyrights are property of their respective owners. |
||||
// |
||||
// @Authors |
||||
// Shengen Yan,yanshengen@gmail.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*/ |
||||
|
||||
#ifdef DOUBLE_SUPPORT |
||||
#ifdef cl_amd_fp64 |
||||
#pragma OPENCL EXTENSION cl_amd_fp64:enable |
||||
#elif defined (cl_khr_fp64) |
||||
#pragma OPENCL EXTENSION cl_khr_fp64:enable |
||||
#endif |
||||
#endif |
||||
|
||||
#if sqdepth == 6 |
||||
#define CONVERT(step) ((step)>>1) |
||||
#else |
||||
#define CONVERT(step) ((step)) |
||||
#endif |
||||
|
||||
#define LSIZE 256 |
||||
#define LSIZE_1 255 |
||||
#define LSIZE_2 254 |
||||
#define HF_LSIZE 128 |
||||
#define LOG_LSIZE 8 |
||||
#define LOG_NUM_BANKS 5 |
||||
#define NUM_BANKS 32 |
||||
#define GET_CONFLICT_OFFSET(lid) ((lid) >> LOG_NUM_BANKS) |
||||
|
||||
#define noconvert |
||||
|
||||
#if sdepth == 4 |
||||
|
||||
kernel void integral_cols(__global uchar4 *src, __global int *sum, __global TYPE *sqsum, |
||||
int src_offset, int pre_invalid, int rows, int cols, int src_step, int dst_step, int dst1_step) |
||||
{ |
||||
int lid = get_local_id(0); |
||||
int gid = get_group_id(0); |
||||
int4 src_t[2], sum_t[2]; |
||||
TYPE4 sqsum_t[2]; |
||||
__local int4 lm_sum[2][LSIZE + LOG_LSIZE]; |
||||
__local TYPE4 lm_sqsum[2][LSIZE + LOG_LSIZE]; |
||||
__local int* sum_p; |
||||
__local TYPE* sqsum_p; |
||||
src_step = src_step >> 2; |
||||
gid = gid << 1; |
||||
for(int i = 0; i < rows; i =i + LSIZE_1) |
||||
{ |
||||
src_t[0] = (i + lid < rows ? convert_int4(src[src_offset + (lid+i) * src_step + min(gid, cols - 1)]) : 0); |
||||
src_t[1] = (i + lid < rows ? convert_int4(src[src_offset + (lid+i) * src_step + min(gid + 1, cols - 1)]) : 0); |
||||
|
||||
sum_t[0] = (i == 0 ? 0 : lm_sum[0][LSIZE_2 + LOG_LSIZE]); |
||||
sqsum_t[0] = (i == 0 ? (TYPE4)0 : lm_sqsum[0][LSIZE_2 + LOG_LSIZE]); |
||||
sum_t[1] = (i == 0 ? 0 : lm_sum[1][LSIZE_2 + LOG_LSIZE]); |
||||
sqsum_t[1] = (i == 0 ? (TYPE4)0 : lm_sqsum[1][LSIZE_2 + LOG_LSIZE]); |
||||
barrier(CLK_LOCAL_MEM_FENCE); |
||||
|
||||
int bf_loc = lid + GET_CONFLICT_OFFSET(lid); |
||||
lm_sum[0][bf_loc] = src_t[0]; |
||||
lm_sqsum[0][bf_loc] = convert_TYPE4(src_t[0] * src_t[0]); |
||||
|
||||
lm_sum[1][bf_loc] = src_t[1]; |
||||
lm_sqsum[1][bf_loc] = convert_TYPE4(src_t[1] * src_t[1]); |
||||
|
||||
int offset = 1; |
||||
for(int d = LSIZE >> 1 ; d > 0; d>>=1) |
||||
{ |
||||
barrier(CLK_LOCAL_MEM_FENCE); |
||||
int ai = offset * (((lid & 127)<<1) +1) - 1,bi = ai + offset; |
||||
ai += GET_CONFLICT_OFFSET(ai); |
||||
bi += GET_CONFLICT_OFFSET(bi); |
||||
|
||||
if((lid & 127) < d) |
||||
{ |
||||
lm_sum[lid >> 7][bi] += lm_sum[lid >> 7][ai]; |
||||
lm_sqsum[lid >> 7][bi] += lm_sqsum[lid >> 7][ai]; |
||||
} |
||||
offset <<= 1; |
||||
} |
||||
barrier(CLK_LOCAL_MEM_FENCE); |
||||
if(lid < 2) |
||||
{ |
||||
lm_sum[lid][LSIZE_2 + LOG_LSIZE] = 0; |
||||
lm_sqsum[lid][LSIZE_2 + LOG_LSIZE] = 0; |
||||
} |
||||
for(int d = 1; d < LSIZE; d <<= 1) |
||||
{ |
||||
barrier(CLK_LOCAL_MEM_FENCE); |
||||
offset >>= 1; |
||||
int ai = offset * (((lid & 127)<<1) +1) - 1,bi = ai + offset; |
||||
ai += GET_CONFLICT_OFFSET(ai); |
||||
bi += GET_CONFLICT_OFFSET(bi); |
||||
|
||||
if((lid & 127) < d) |
||||
{ |
||||
lm_sum[lid >> 7][bi] += lm_sum[lid >> 7][ai]; |
||||
lm_sum[lid >> 7][ai] = lm_sum[lid >> 7][bi] - lm_sum[lid >> 7][ai]; |
||||
|
||||
lm_sqsum[lid >> 7][bi] += lm_sqsum[lid >> 7][ai]; |
||||
lm_sqsum[lid >> 7][ai] = lm_sqsum[lid >> 7][bi] - lm_sqsum[lid >> 7][ai]; |
||||
} |
||||
} |
||||
barrier(CLK_LOCAL_MEM_FENCE); |
||||
int loc_s0 = gid * dst_step + i + lid - 1 - pre_invalid * dst_step /4, loc_s1 = loc_s0 + dst_step ; |
||||
int loc_sq0 = gid * CONVERT(dst1_step) + i + lid - 1 - pre_invalid * dst1_step / sizeof(TYPE),loc_sq1 = loc_sq0 + CONVERT(dst1_step); |
||||
if(lid > 0 && (i+lid) <= rows) |
||||
{ |
||||
lm_sum[0][bf_loc] += sum_t[0]; |
||||
lm_sum[1][bf_loc] += sum_t[1]; |
||||
lm_sqsum[0][bf_loc] += sqsum_t[0]; |
||||
lm_sqsum[1][bf_loc] += sqsum_t[1]; |
||||
sum_p = (__local int*)(&(lm_sum[0][bf_loc])); |
||||
sqsum_p = (__local TYPE*)(&(lm_sqsum[0][bf_loc])); |
||||
for(int k = 0; k < 4; k++) |
||||
{ |
||||
if(gid * 4 + k >= cols + pre_invalid || gid * 4 + k < pre_invalid) continue; |
||||
sum[loc_s0 + k * dst_step / 4] = sum_p[k]; |
||||
sqsum[loc_sq0 + k * dst1_step / sizeof(TYPE)] = sqsum_p[k]; |
||||
} |
||||
sum_p = (__local int*)(&(lm_sum[1][bf_loc])); |
||||
sqsum_p = (__local TYPE*)(&(lm_sqsum[1][bf_loc])); |
||||
for(int k = 0; k < 4; k++) |
||||
{ |
||||
if(gid * 4 + k + 4 >= cols + pre_invalid) break; |
||||
sum[loc_s1 + k * dst_step / 4] = sum_p[k]; |
||||
sqsum[loc_sq1 + k * dst1_step / sizeof(TYPE)] = sqsum_p[k]; |
||||
} |
||||
} |
||||
barrier(CLK_LOCAL_MEM_FENCE); |
||||
} |
||||
} |
||||
|
||||
kernel void integral_rows(__global int4 *srcsum, __global TYPE4 * srcsqsum,__global int *sum, |
||||
__global TYPE *sqsum, int rows, int cols, int src_step, int src1_step, int sum_step, |
||||
int sqsum_step, int sum_offset, int sqsum_offset) |
||||
{ |
||||
int lid = get_local_id(0); |
||||
int gid = get_group_id(0); |
||||
int4 src_t[2], sum_t[2]; |
||||
TYPE4 sqsrc_t[2],sqsum_t[2]; |
||||
__local int4 lm_sum[2][LSIZE + LOG_LSIZE]; |
||||
__local TYPE4 lm_sqsum[2][LSIZE + LOG_LSIZE]; |
||||
__local int *sum_p; |
||||
__local TYPE *sqsum_p; |
||||
src_step = src_step >> 4; |
||||
src1_step = (src1_step / sizeof(TYPE)) >> 2 ; |
||||
gid <<= 1; |
||||
for(int i = 0; i < rows; i =i + LSIZE_1) |
||||
{ |
||||
src_t[0] = i + lid < rows ? srcsum[(lid+i) * src_step + gid ] : (int4)0; |
||||
sqsrc_t[0] = i + lid < rows ? srcsqsum[(lid+i) * src1_step + gid ] : (TYPE4)0; |
||||
src_t[1] = i + lid < rows ? srcsum[(lid+i) * src_step + gid + 1] : (int4)0; |
||||
sqsrc_t[1] = i + lid < rows ? srcsqsum[(lid+i) * src1_step + gid + 1] : (TYPE4)0; |
||||
|
||||
sum_t[0] = (i == 0 ? 0 : lm_sum[0][LSIZE_2 + LOG_LSIZE]); |
||||
sqsum_t[0] = (i == 0 ? (TYPE4)0 : lm_sqsum[0][LSIZE_2 + LOG_LSIZE]); |
||||
sum_t[1] = (i == 0 ? 0 : lm_sum[1][LSIZE_2 + LOG_LSIZE]); |
||||
sqsum_t[1] = (i == 0 ? (TYPE4)0 : lm_sqsum[1][LSIZE_2 + LOG_LSIZE]); |
||||
barrier(CLK_LOCAL_MEM_FENCE); |
||||
|
||||
int bf_loc = lid + GET_CONFLICT_OFFSET(lid); |
||||
lm_sum[0][bf_loc] = src_t[0]; |
||||
lm_sqsum[0][bf_loc] = sqsrc_t[0]; |
||||
|
||||
lm_sum[1][bf_loc] = src_t[1]; |
||||
lm_sqsum[1][bf_loc] = sqsrc_t[1]; |
||||
|
||||
int offset = 1; |
||||
for(int d = LSIZE >> 1 ; d > 0; d>>=1) |
||||
{ |
||||
barrier(CLK_LOCAL_MEM_FENCE); |
||||
int ai = offset * (((lid & 127)<<1) +1) - 1,bi = ai + offset; |
||||
ai += GET_CONFLICT_OFFSET(ai); |
||||
bi += GET_CONFLICT_OFFSET(bi); |
||||
|
||||
if((lid & 127) < d) |
||||
{ |
||||
lm_sum[lid >> 7][bi] += lm_sum[lid >> 7][ai]; |
||||
lm_sqsum[lid >> 7][bi] += lm_sqsum[lid >> 7][ai]; |
||||
} |
||||
offset <<= 1; |
||||
} |
||||
barrier(CLK_LOCAL_MEM_FENCE); |
||||
if(lid < 2) |
||||
{ |
||||
lm_sum[lid][LSIZE_2 + LOG_LSIZE] = 0; |
||||
lm_sqsum[lid][LSIZE_2 + LOG_LSIZE] = 0; |
||||
} |
||||
for(int d = 1; d < LSIZE; d <<= 1) |
||||
{ |
||||
barrier(CLK_LOCAL_MEM_FENCE); |
||||
offset >>= 1; |
||||
int ai = offset * (((lid & 127)<<1) +1) - 1,bi = ai + offset; |
||||
ai += GET_CONFLICT_OFFSET(ai); |
||||
bi += GET_CONFLICT_OFFSET(bi); |
||||
|
||||
if((lid & 127) < d) |
||||
{ |
||||
lm_sum[lid >> 7][bi] += lm_sum[lid >> 7][ai]; |
||||
lm_sum[lid >> 7][ai] = lm_sum[lid >> 7][bi] - lm_sum[lid >> 7][ai]; |
||||
|
||||
lm_sqsum[lid >> 7][bi] += lm_sqsum[lid >> 7][ai]; |
||||
lm_sqsum[lid >> 7][ai] = lm_sqsum[lid >> 7][bi] - lm_sqsum[lid >> 7][ai]; |
||||
} |
||||
} |
||||
barrier(CLK_LOCAL_MEM_FENCE); |
||||
if(gid == 0 && (i + lid) <= rows) |
||||
{ |
||||
sum[sum_offset + i + lid] = 0; |
||||
sqsum[sqsum_offset + i + lid] = 0; |
||||
} |
||||
if(i + lid == 0) |
||||
{ |
||||
int loc0 = gid * sum_step; |
||||
int loc1 = gid * CONVERT(sqsum_step); |
||||
for(int k = 1; k <= 8; k++) |
||||
{ |
||||
if(gid * 4 + k > cols) break; |
||||
sum[sum_offset + loc0 + k * sum_step / 4] = 0; |
||||
sqsum[sqsum_offset + loc1 + k * sqsum_step / sizeof(TYPE)] = 0; |
||||
} |
||||
} |
||||
int loc_s0 = sum_offset + gid * sum_step + sum_step / 4 + i + lid, loc_s1 = loc_s0 + sum_step ; |
||||
int loc_sq0 = sqsum_offset + gid * CONVERT(sqsum_step) + sqsum_step / sizeof(TYPE) + i + lid, loc_sq1 = loc_sq0 + CONVERT(sqsum_step) ; |
||||
|
||||
if(lid > 0 && (i+lid) <= rows) |
||||
{ |
||||
lm_sum[0][bf_loc] += sum_t[0]; |
||||
lm_sum[1][bf_loc] += sum_t[1]; |
||||
lm_sqsum[0][bf_loc] += sqsum_t[0]; |
||||
lm_sqsum[1][bf_loc] += sqsum_t[1]; |
||||
sum_p = (__local int*)(&(lm_sum[0][bf_loc])); |
||||
sqsum_p = (__local TYPE*)(&(lm_sqsum[0][bf_loc])); |
||||
for(int k = 0; k < 4; k++) |
||||
{ |
||||
if(gid * 4 + k >= cols) break; |
||||
sum[loc_s0 + k * sum_step / 4] = sum_p[k]; |
||||
sqsum[loc_sq0 + k * sqsum_step / sizeof(TYPE)] = sqsum_p[k]; |
||||
} |
||||
sum_p = (__local int*)(&(lm_sum[1][bf_loc])); |
||||
sqsum_p = (__local TYPE*)(&(lm_sqsum[1][bf_loc])); |
||||
for(int k = 0; k < 4; k++) |
||||
{ |
||||
if(gid * 4 + 4 + k >= cols) break; |
||||
sum[loc_s1 + k * sum_step / 4] = sum_p[k]; |
||||
sqsum[loc_sq1 + k * sqsum_step / sizeof(TYPE)] = sqsum_p[k]; |
||||
} |
||||
} |
||||
barrier(CLK_LOCAL_MEM_FENCE); |
||||
} |
||||
} |
||||
|
||||
#elif sdepth == 5 |
||||
|
||||
kernel void integral_cols(__global uchar4 *src, __global float *sum, __global TYPE *sqsum, |
||||
int src_offset, int pre_invalid, int rows, int cols, int src_step, int dst_step, int dst1_step) |
||||
{ |
||||
int lid = get_local_id(0); |
||||
int gid = get_group_id(0); |
||||
float4 src_t[2], sum_t[2]; |
||||
TYPE4 sqsum_t[2]; |
||||
__local float4 lm_sum[2][LSIZE + LOG_LSIZE]; |
||||
__local TYPE4 lm_sqsum[2][LSIZE + LOG_LSIZE]; |
||||
__local float* sum_p; |
||||
__local TYPE* sqsum_p; |
||||
src_step = src_step >> 2; |
||||
gid = gid << 1; |
||||
for(int i = 0; i < rows; i =i + LSIZE_1) |
||||
{ |
||||
src_t[0] = (i + lid < rows ? convert_float4(src[src_offset + (lid+i) * src_step + min(gid, cols - 1)]) : (float4)0); |
||||
src_t[1] = (i + lid < rows ? convert_float4(src[src_offset + (lid+i) * src_step + min(gid + 1, cols - 1)]) : (float4)0); |
||||
|
||||
sum_t[0] = (i == 0 ? (float4)0 : lm_sum[0][LSIZE_2 + LOG_LSIZE]); |
||||
sqsum_t[0] = (i == 0 ? (TYPE4)0 : lm_sqsum[0][LSIZE_2 + LOG_LSIZE]); |
||||
sum_t[1] = (i == 0 ? (float4)0 : lm_sum[1][LSIZE_2 + LOG_LSIZE]); |
||||
sqsum_t[1] = (i == 0 ? (TYPE4)0 : lm_sqsum[1][LSIZE_2 + LOG_LSIZE]); |
||||
barrier(CLK_LOCAL_MEM_FENCE); |
||||
|
||||
int bf_loc = lid + GET_CONFLICT_OFFSET(lid); |
||||
lm_sum[0][bf_loc] = src_t[0]; |
||||
lm_sqsum[0][bf_loc] = convert_TYPE4(src_t[0] * src_t[0]); |
||||
// printf("%f\n", src_t[0].s0); |
||||
|
||||
lm_sum[1][bf_loc] = src_t[1]; |
||||
lm_sqsum[1][bf_loc] = convert_TYPE4(src_t[1] * src_t[1]); |
||||
|
||||
int offset = 1; |
||||
for(int d = LSIZE >> 1 ; d > 0; d>>=1) |
||||
{ |
||||
barrier(CLK_LOCAL_MEM_FENCE); |
||||
int ai = offset * (((lid & 127)<<1) +1) - 1,bi = ai + offset; |
||||
ai += GET_CONFLICT_OFFSET(ai); |
||||
bi += GET_CONFLICT_OFFSET(bi); |
||||
|
||||
if((lid & 127) < d) |
||||
{ |
||||
lm_sum[lid >> 7][bi] += lm_sum[lid >> 7][ai]; |
||||
lm_sqsum[lid >> 7][bi] += lm_sqsum[lid >> 7][ai]; |
||||
} |
||||
offset <<= 1; |
||||
} |
||||
barrier(CLK_LOCAL_MEM_FENCE); |
||||
if(lid < 2) |
||||
{ |
||||
lm_sum[lid][LSIZE_2 + LOG_LSIZE] = 0; |
||||
lm_sqsum[lid][LSIZE_2 + LOG_LSIZE] = 0; |
||||
} |
||||
for(int d = 1; d < LSIZE; d <<= 1) |
||||
{ |
||||
barrier(CLK_LOCAL_MEM_FENCE); |
||||
offset >>= 1; |
||||
int ai = offset * (((lid & 127)<<1) +1) - 1,bi = ai + offset; |
||||
ai += GET_CONFLICT_OFFSET(ai); |
||||
bi += GET_CONFLICT_OFFSET(bi); |
||||
|
||||
if((lid & 127) < d) |
||||
{ |
||||
lm_sum[lid >> 7][bi] += lm_sum[lid >> 7][ai]; |
||||
lm_sum[lid >> 7][ai] = lm_sum[lid >> 7][bi] - lm_sum[lid >> 7][ai]; |
||||
|
||||
lm_sqsum[lid >> 7][bi] += lm_sqsum[lid >> 7][ai]; |
||||
lm_sqsum[lid >> 7][ai] = lm_sqsum[lid >> 7][bi] - lm_sqsum[lid >> 7][ai]; |
||||
} |
||||
} |
||||
barrier(CLK_LOCAL_MEM_FENCE); |
||||
int loc_s0 = gid * dst_step + i + lid - 1 - pre_invalid * dst_step / 4, loc_s1 = loc_s0 + dst_step ; |
||||
int loc_sq0 = gid * CONVERT(dst1_step) + i + lid - 1 - pre_invalid * dst1_step / sizeof(TYPE), loc_sq1 = loc_sq0 + CONVERT(dst1_step); |
||||
if(lid > 0 && (i+lid) <= rows) |
||||
{ |
||||
lm_sum[0][bf_loc] += sum_t[0]; |
||||
lm_sum[1][bf_loc] += sum_t[1]; |
||||
lm_sqsum[0][bf_loc] += sqsum_t[0]; |
||||
lm_sqsum[1][bf_loc] += sqsum_t[1]; |
||||
sum_p = (__local float*)(&(lm_sum[0][bf_loc])); |
||||
sqsum_p = (__local TYPE*)(&(lm_sqsum[0][bf_loc])); |
||||
for(int k = 0; k < 4; k++) |
||||
{ |
||||
if(gid * 4 + k >= cols + pre_invalid || gid * 4 + k < pre_invalid) continue; |
||||
sum[loc_s0 + k * dst_step / 4] = sum_p[k]; |
||||
sqsum[loc_sq0 + k * dst1_step / sizeof(TYPE)] = sqsum_p[k]; |
||||
} |
||||
sum_p = (__local float*)(&(lm_sum[1][bf_loc])); |
||||
sqsum_p = (__local TYPE*)(&(lm_sqsum[1][bf_loc])); |
||||
for(int k = 0; k < 4; k++) |
||||
{ |
||||
if(gid * 4 + k + 4 >= cols + pre_invalid) break; |
||||
sum[loc_s1 + k * dst_step / 4] = sum_p[k]; |
||||
sqsum[loc_sq1 + k * dst1_step / sizeof(TYPE)] = sqsum_p[k]; |
||||
} |
||||
} |
||||
barrier(CLK_LOCAL_MEM_FENCE); |
||||
} |
||||
} |
||||
|
||||
kernel void integral_rows(__global float4 *srcsum, __global TYPE4 * srcsqsum, __global float *sum , |
||||
__global TYPE *sqsum, int rows, int cols, int src_step, int src1_step, int sum_step, |
||||
int sqsum_step, int sum_offset, int sqsum_offset) |
||||
{ |
||||
int lid = get_local_id(0); |
||||
int gid = get_group_id(0); |
||||
float4 src_t[2], sum_t[2]; |
||||
TYPE4 sqsrc_t[2],sqsum_t[2]; |
||||
__local float4 lm_sum[2][LSIZE + LOG_LSIZE]; |
||||
__local TYPE4 lm_sqsum[2][LSIZE + LOG_LSIZE]; |
||||
__local float *sum_p; |
||||
__local TYPE *sqsum_p; |
||||
src_step = src_step >> 4; |
||||
src1_step = (src1_step / sizeof(TYPE)) >> 2; |
||||
for(int i = 0; i < rows; i =i + LSIZE_1) |
||||
{ |
||||
src_t[0] = i + lid < rows ? srcsum[(lid+i) * src_step + gid * 2] : (float4)0; |
||||
sqsrc_t[0] = i + lid < rows ? srcsqsum[(lid+i) * src1_step + gid * 2] : (TYPE4)0; |
||||
src_t[1] = i + lid < rows ? srcsum[(lid+i) * src_step + gid * 2 + 1] : (float4)0; |
||||
sqsrc_t[1] = i + lid < rows ? srcsqsum[(lid+i) * src1_step + gid * 2 + 1] : (TYPE4)0; |
||||
|
||||
sum_t[0] = (i == 0 ? (float4)0 : lm_sum[0][LSIZE_2 + LOG_LSIZE]); |
||||
sqsum_t[0] = (i == 0 ? (TYPE4)0 : lm_sqsum[0][LSIZE_2 + LOG_LSIZE]); |
||||
sum_t[1] = (i == 0 ? (float4)0 : lm_sum[1][LSIZE_2 + LOG_LSIZE]); |
||||
sqsum_t[1] = (i == 0 ? (TYPE4)0 : lm_sqsum[1][LSIZE_2 + LOG_LSIZE]); |
||||
barrier(CLK_LOCAL_MEM_FENCE); |
||||
|
||||
int bf_loc = lid + GET_CONFLICT_OFFSET(lid); |
||||
lm_sum[0][bf_loc] = src_t[0]; |
||||
lm_sqsum[0][bf_loc] = sqsrc_t[0]; |
||||
|
||||
lm_sum[1][bf_loc] = src_t[1]; |
||||
lm_sqsum[1][bf_loc] = sqsrc_t[1]; |
||||
|
||||
int offset = 1; |
||||
for(int d = LSIZE >> 1 ; d > 0; d>>=1) |
||||
{ |
||||
barrier(CLK_LOCAL_MEM_FENCE); |
||||
int ai = offset * (((lid & 127)<<1) +1) - 1,bi = ai + offset; |
||||
ai += GET_CONFLICT_OFFSET(ai); |
||||
bi += GET_CONFLICT_OFFSET(bi); |
||||
|
||||
if((lid & 127) < d) |
||||
{ |
||||
lm_sum[lid >> 7][bi] += lm_sum[lid >> 7][ai]; |
||||
lm_sqsum[lid >> 7][bi] += lm_sqsum[lid >> 7][ai]; |
||||
} |
||||
offset <<= 1; |
||||
} |
||||
barrier(CLK_LOCAL_MEM_FENCE); |
||||
if(lid < 2) |
||||
{ |
||||
lm_sum[lid][LSIZE_2 + LOG_LSIZE] = 0; |
||||
lm_sqsum[lid][LSIZE_2 + LOG_LSIZE] = 0; |
||||
} |
||||
for(int d = 1; d < LSIZE; d <<= 1) |
||||
{ |
||||
barrier(CLK_LOCAL_MEM_FENCE); |
||||
offset >>= 1; |
||||
int ai = offset * (((lid & 127)<<1) +1) - 1,bi = ai + offset; |
||||
ai += GET_CONFLICT_OFFSET(ai); |
||||
bi += GET_CONFLICT_OFFSET(bi); |
||||
|
||||
if((lid & 127) < d) |
||||
{ |
||||
lm_sum[lid >> 7][bi] += lm_sum[lid >> 7][ai]; |
||||
lm_sum[lid >> 7][ai] = lm_sum[lid >> 7][bi] - lm_sum[lid >> 7][ai]; |
||||
|
||||
lm_sqsum[lid >> 7][bi] += lm_sqsum[lid >> 7][ai]; |
||||
lm_sqsum[lid >> 7][ai] = lm_sqsum[lid >> 7][bi] - lm_sqsum[lid >> 7][ai]; |
||||
} |
||||
} |
||||
barrier(CLK_LOCAL_MEM_FENCE); |
||||
if(gid == 0 && (i + lid) <= rows) |
||||
{ |
||||
sum[sum_offset + i + lid] = 0; |
||||
sqsum[sqsum_offset + i + lid] = 0; |
||||
} |
||||
if(i + lid == 0) |
||||
{ |
||||
int loc0 = gid * 2 * sum_step; |
||||
int loc1 = gid * 2 * CONVERT(sqsum_step); |
||||
for(int k = 1; k <= 8; k++) |
||||
{ |
||||
if(gid * 8 + k > cols) break; |
||||
sum[sum_offset + loc0 + k * sum_step / 4] = 0; |
||||
sqsum[sqsum_offset + loc1 + k * sqsum_step / sizeof(TYPE)] = 0; |
||||
} |
||||
} |
||||
int loc_s0 = sum_offset + gid * 2 * sum_step + sum_step / 4 + i + lid, loc_s1 = loc_s0 + sum_step ; |
||||
int loc_sq0 = sqsum_offset + gid * 2 * CONVERT(sqsum_step) + sqsum_step / sizeof(TYPE) + i + lid, loc_sq1 = loc_sq0 + CONVERT(sqsum_step) ; |
||||
if(lid > 0 && (i+lid) <= rows) |
||||
{ |
||||
lm_sum[0][bf_loc] += sum_t[0]; |
||||
lm_sum[1][bf_loc] += sum_t[1]; |
||||
lm_sqsum[0][bf_loc] += sqsum_t[0]; |
||||
lm_sqsum[1][bf_loc] += sqsum_t[1]; |
||||
sum_p = (__local float*)(&(lm_sum[0][bf_loc])); |
||||
sqsum_p = (__local TYPE*)(&(lm_sqsum[0][bf_loc])); |
||||
for(int k = 0; k < 4; k++) |
||||
{ |
||||
if(gid * 8 + k >= cols) break; |
||||
sum[loc_s0 + k * sum_step / 4] = sum_p[k]; |
||||
sqsum[loc_sq0 + k * sqsum_step / sizeof(TYPE)] = sqsum_p[k]; |
||||
} |
||||
sum_p = (__local float*)(&(lm_sum[1][bf_loc])); |
||||
sqsum_p = (__local TYPE*)(&(lm_sqsum[1][bf_loc])); |
||||
for(int k = 0; k < 4; k++) |
||||
{ |
||||
if(gid * 8 + 4 + k >= cols) break; |
||||
sum[loc_s1 + k * sum_step / 4] = sum_p[k]; |
||||
sqsum[loc_sq1 + k * sqsum_step / sizeof(TYPE)] = sqsum_p[k]; |
||||
} |
||||
} |
||||
barrier(CLK_LOCAL_MEM_FENCE); |
||||
} |
||||
} |
||||
|
||||
#endif |
||||
@ -0,0 +1,413 @@ |
||||
/*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, Institute Of Software Chinese Academy Of Science, all rights reserved. |
||||
// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved. |
||||
// Third party copyrights are property of their respective owners. |
||||
// |
||||
// @Authors |
||||
// Shengen Yan,yanshengen@gmail.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*/ |
||||
|
||||
#ifdef DOUBLE_SUPPORT |
||||
#ifdef cl_amd_fp64 |
||||
#pragma OPENCL EXTENSION cl_amd_fp64:enable |
||||
#elif defined (cl_khr_fp64) |
||||
#pragma OPENCL EXTENSION cl_khr_fp64:enable |
||||
#endif |
||||
#endif |
||||
|
||||
#define LSIZE 256 |
||||
#define LSIZE_1 255 |
||||
#define LSIZE_2 254 |
||||
#define HF_LSIZE 128 |
||||
#define LOG_LSIZE 8 |
||||
#define LOG_NUM_BANKS 5 |
||||
#define NUM_BANKS 32 |
||||
#define GET_CONFLICT_OFFSET(lid) ((lid) >> LOG_NUM_BANKS) |
||||
|
||||
#if sdepth == 4 |
||||
|
||||
kernel void integral_sum_cols(__global uchar4 *src, __global int *sum, |
||||
int src_offset, int pre_invalid, int rows, int cols, int src_step, int dst_step) |
||||
{ |
||||
int lid = get_local_id(0); |
||||
int gid = get_group_id(0); |
||||
int4 src_t[2], sum_t[2]; |
||||
__local int4 lm_sum[2][LSIZE + LOG_LSIZE]; |
||||
__local int* sum_p; |
||||
src_step = src_step >> 2; |
||||
gid = gid << 1; |
||||
for(int i = 0; i < rows; i =i + LSIZE_1) |
||||
{ |
||||
src_t[0] = (i + lid < rows ? convert_int4(src[src_offset + (lid+i) * src_step + gid]) : 0); |
||||
src_t[1] = (i + lid < rows ? convert_int4(src[src_offset + (lid+i) * src_step + gid + 1]) : 0); |
||||
|
||||
sum_t[0] = (i == 0 ? 0 : lm_sum[0][LSIZE_2 + LOG_LSIZE]); |
||||
sum_t[1] = (i == 0 ? 0 : lm_sum[1][LSIZE_2 + LOG_LSIZE]); |
||||
barrier(CLK_LOCAL_MEM_FENCE); |
||||
|
||||
int bf_loc = lid + GET_CONFLICT_OFFSET(lid); |
||||
lm_sum[0][bf_loc] = src_t[0]; |
||||
|
||||
lm_sum[1][bf_loc] = src_t[1]; |
||||
|
||||
int offset = 1; |
||||
for(int d = LSIZE >> 1 ; d > 0; d>>=1) |
||||
{ |
||||
barrier(CLK_LOCAL_MEM_FENCE); |
||||
int ai = offset * (((lid & 127)<<1) +1) - 1,bi = ai + offset; |
||||
ai += GET_CONFLICT_OFFSET(ai); |
||||
bi += GET_CONFLICT_OFFSET(bi); |
||||
|
||||
if((lid & 127) < d) |
||||
{ |
||||
lm_sum[lid >> 7][bi] += lm_sum[lid >> 7][ai]; |
||||
} |
||||
offset <<= 1; |
||||
} |
||||
barrier(CLK_LOCAL_MEM_FENCE); |
||||
if(lid < 2) |
||||
{ |
||||
lm_sum[lid][LSIZE_2 + LOG_LSIZE] = 0; |
||||
} |
||||
for(int d = 1; d < LSIZE; d <<= 1) |
||||
{ |
||||
barrier(CLK_LOCAL_MEM_FENCE); |
||||
offset >>= 1; |
||||
int ai = offset * (((lid & 127)<<1) +1) - 1,bi = ai + offset; |
||||
ai += GET_CONFLICT_OFFSET(ai); |
||||
bi += GET_CONFLICT_OFFSET(bi); |
||||
|
||||
if((lid & 127) < d) |
||||
{ |
||||
lm_sum[lid >> 7][bi] += lm_sum[lid >> 7][ai]; |
||||
lm_sum[lid >> 7][ai] = lm_sum[lid >> 7][bi] - lm_sum[lid >> 7][ai]; |
||||
} |
||||
} |
||||
barrier(CLK_LOCAL_MEM_FENCE); |
||||
if(lid > 0 && (i+lid) <= rows) |
||||
{ |
||||
int loc_s0 = gid * dst_step + i + lid - 1 - pre_invalid * dst_step / 4, loc_s1 = loc_s0 + dst_step ; |
||||
lm_sum[0][bf_loc] += sum_t[0]; |
||||
lm_sum[1][bf_loc] += sum_t[1]; |
||||
sum_p = (__local int*)(&(lm_sum[0][bf_loc])); |
||||
for(int k = 0; k < 4; k++) |
||||
{ |
||||
if(gid * 4 + k >= cols + pre_invalid || gid * 4 + k < pre_invalid) continue; |
||||
sum[loc_s0 + k * dst_step / 4] = sum_p[k]; |
||||
} |
||||
sum_p = (__local int*)(&(lm_sum[1][bf_loc])); |
||||
for(int k = 0; k < 4; k++) |
||||
{ |
||||
if(gid * 4 + k + 4 >= cols + pre_invalid) break; |
||||
sum[loc_s1 + k * dst_step / 4] = sum_p[k]; |
||||
} |
||||
} |
||||
barrier(CLK_LOCAL_MEM_FENCE); |
||||
} |
||||
} |
||||
|
||||
kernel void integral_sum_rows(__global int4 *srcsum, __global int *sum, |
||||
int rows, int cols, int src_step, int sum_step, int sum_offset) |
||||
{ |
||||
int lid = get_local_id(0); |
||||
int gid = get_group_id(0); |
||||
int4 src_t[2], sum_t[2]; |
||||
__local int4 lm_sum[2][LSIZE + LOG_LSIZE]; |
||||
__local int *sum_p; |
||||
src_step = src_step >> 4; |
||||
for(int i = 0; i < rows; i =i + LSIZE_1) |
||||
{ |
||||
src_t[0] = i + lid < rows ? srcsum[(lid+i) * src_step + gid * 2] : 0; |
||||
src_t[1] = i + lid < rows ? srcsum[(lid+i) * src_step + gid * 2 + 1] : 0; |
||||
|
||||
sum_t[0] = (i == 0 ? 0 : lm_sum[0][LSIZE_2 + LOG_LSIZE]); |
||||
sum_t[1] = (i == 0 ? 0 : lm_sum[1][LSIZE_2 + LOG_LSIZE]); |
||||
barrier(CLK_LOCAL_MEM_FENCE); |
||||
|
||||
int bf_loc = lid + GET_CONFLICT_OFFSET(lid); |
||||
lm_sum[0][bf_loc] = src_t[0]; |
||||
|
||||
lm_sum[1][bf_loc] = src_t[1]; |
||||
|
||||
int offset = 1; |
||||
for(int d = LSIZE >> 1 ; d > 0; d>>=1) |
||||
{ |
||||
barrier(CLK_LOCAL_MEM_FENCE); |
||||
int ai = offset * (((lid & 127)<<1) +1) - 1,bi = ai + offset; |
||||
ai += GET_CONFLICT_OFFSET(ai); |
||||
bi += GET_CONFLICT_OFFSET(bi); |
||||
|
||||
if((lid & 127) < d) |
||||
{ |
||||
lm_sum[lid >> 7][bi] += lm_sum[lid >> 7][ai]; |
||||
} |
||||
offset <<= 1; |
||||
} |
||||
barrier(CLK_LOCAL_MEM_FENCE); |
||||
if(lid < 2) |
||||
{ |
||||
lm_sum[lid][LSIZE_2 + LOG_LSIZE] = 0; |
||||
} |
||||
for(int d = 1; d < LSIZE; d <<= 1) |
||||
{ |
||||
barrier(CLK_LOCAL_MEM_FENCE); |
||||
offset >>= 1; |
||||
int ai = offset * (((lid & 127)<<1) +1) - 1,bi = ai + offset; |
||||
ai += GET_CONFLICT_OFFSET(ai); |
||||
bi += GET_CONFLICT_OFFSET(bi); |
||||
|
||||
if((lid & 127) < d) |
||||
{ |
||||
lm_sum[lid >> 7][bi] += lm_sum[lid >> 7][ai]; |
||||
lm_sum[lid >> 7][ai] = lm_sum[lid >> 7][bi] - lm_sum[lid >> 7][ai]; |
||||
} |
||||
} |
||||
barrier(CLK_LOCAL_MEM_FENCE); |
||||
if(gid == 0 && (i + lid) <= rows) |
||||
{ |
||||
sum[sum_offset + i + lid] = 0; |
||||
} |
||||
if(i + lid == 0) |
||||
{ |
||||
int loc0 = gid * 2 * sum_step; |
||||
for(int k = 1; k <= 8; k++) |
||||
{ |
||||
if(gid * 8 + k > cols) break; |
||||
sum[sum_offset + loc0 + k * sum_step / 4] = 0; |
||||
} |
||||
} |
||||
|
||||
if(lid > 0 && (i+lid) <= rows) |
||||
{ |
||||
int loc_s0 = sum_offset + gid * 2 * sum_step + sum_step / 4 + i + lid, loc_s1 = loc_s0 + sum_step ; |
||||
lm_sum[0][bf_loc] += sum_t[0]; |
||||
lm_sum[1][bf_loc] += sum_t[1]; |
||||
sum_p = (__local int*)(&(lm_sum[0][bf_loc])); |
||||
for(int k = 0; k < 4; k++) |
||||
{ |
||||
if(gid * 8 + k >= cols) break; |
||||
sum[loc_s0 + k * sum_step / 4] = sum_p[k]; |
||||
} |
||||
sum_p = (__local int*)(&(lm_sum[1][bf_loc])); |
||||
for(int k = 0; k < 4; k++) |
||||
{ |
||||
if(gid * 8 + 4 + k >= cols) break; |
||||
sum[loc_s1 + k * sum_step / 4] = sum_p[k]; |
||||
} |
||||
} |
||||
barrier(CLK_LOCAL_MEM_FENCE); |
||||
} |
||||
} |
||||
|
||||
#elif sdepth == 5 |
||||
|
||||
kernel void integral_sum_cols(__global uchar4 *src, __global float *sum, |
||||
int src_offset, int pre_invalid, int rows, int cols, int src_step, int dst_step) |
||||
{ |
||||
int lid = get_local_id(0); |
||||
int gid = get_group_id(0); |
||||
float4 src_t[2], sum_t[2]; |
||||
__local float4 lm_sum[2][LSIZE + LOG_LSIZE]; |
||||
__local float* sum_p; |
||||
src_step = src_step >> 2; |
||||
gid = gid << 1; |
||||
for(int i = 0; i < rows; i =i + LSIZE_1) |
||||
{ |
||||
src_t[0] = (i + lid < rows ? convert_float4(src[src_offset + (lid+i) * src_step + gid]) : (float4)0); |
||||
src_t[1] = (i + lid < rows ? convert_float4(src[src_offset + (lid+i) * src_step + gid + 1]) : (float4)0); |
||||
|
||||
sum_t[0] = (i == 0 ? (float4)0 : lm_sum[0][LSIZE_2 + LOG_LSIZE]); |
||||
sum_t[1] = (i == 0 ? (float4)0 : lm_sum[1][LSIZE_2 + LOG_LSIZE]); |
||||
barrier(CLK_LOCAL_MEM_FENCE); |
||||
|
||||
int bf_loc = lid + GET_CONFLICT_OFFSET(lid); |
||||
lm_sum[0][bf_loc] = src_t[0]; |
||||
|
||||
lm_sum[1][bf_loc] = src_t[1]; |
||||
|
||||
int offset = 1; |
||||
for(int d = LSIZE >> 1 ; d > 0; d>>=1) |
||||
{ |
||||
barrier(CLK_LOCAL_MEM_FENCE); |
||||
int ai = offset * (((lid & 127)<<1) +1) - 1,bi = ai + offset; |
||||
ai += GET_CONFLICT_OFFSET(ai); |
||||
bi += GET_CONFLICT_OFFSET(bi); |
||||
|
||||
if((lid & 127) < d) |
||||
{ |
||||
lm_sum[lid >> 7][bi] += lm_sum[lid >> 7][ai]; |
||||
} |
||||
offset <<= 1; |
||||
} |
||||
barrier(CLK_LOCAL_MEM_FENCE); |
||||
if(lid < 2) |
||||
{ |
||||
lm_sum[lid][LSIZE_2 + LOG_LSIZE] = 0; |
||||
} |
||||
for(int d = 1; d < LSIZE; d <<= 1) |
||||
{ |
||||
barrier(CLK_LOCAL_MEM_FENCE); |
||||
offset >>= 1; |
||||
int ai = offset * (((lid & 127)<<1) +1) - 1,bi = ai + offset; |
||||
ai += GET_CONFLICT_OFFSET(ai); |
||||
bi += GET_CONFLICT_OFFSET(bi); |
||||
|
||||
if((lid & 127) < d) |
||||
{ |
||||
lm_sum[lid >> 7][bi] += lm_sum[lid >> 7][ai]; |
||||
lm_sum[lid >> 7][ai] = lm_sum[lid >> 7][bi] - lm_sum[lid >> 7][ai]; |
||||
} |
||||
} |
||||
barrier(CLK_LOCAL_MEM_FENCE); |
||||
if(lid > 0 && (i+lid) <= rows) |
||||
{ |
||||
int loc_s0 = gid * dst_step + i + lid - 1 - pre_invalid * dst_step / 4, loc_s1 = loc_s0 + dst_step ; |
||||
lm_sum[0][bf_loc] += sum_t[0]; |
||||
lm_sum[1][bf_loc] += sum_t[1]; |
||||
sum_p = (__local float*)(&(lm_sum[0][bf_loc])); |
||||
for(int k = 0; k < 4; k++) |
||||
{ |
||||
if(gid * 4 + k >= cols + pre_invalid || gid * 4 + k < pre_invalid) continue; |
||||
sum[loc_s0 + k * dst_step / 4] = sum_p[k]; |
||||
} |
||||
sum_p = (__local float*)(&(lm_sum[1][bf_loc])); |
||||
for(int k = 0; k < 4; k++) |
||||
{ |
||||
if(gid * 4 + k + 4 >= cols + pre_invalid) break; |
||||
sum[loc_s1 + k * dst_step / 4] = sum_p[k]; |
||||
} |
||||
} |
||||
barrier(CLK_LOCAL_MEM_FENCE); |
||||
} |
||||
} |
||||
|
||||
kernel void integral_sum_rows(__global float4 *srcsum, __global float *sum, |
||||
int rows, int cols, int src_step, int sum_step, int sum_offset) |
||||
{ |
||||
int lid = get_local_id(0); |
||||
int gid = get_group_id(0); |
||||
float4 src_t[2], sum_t[2]; |
||||
__local float4 lm_sum[2][LSIZE + LOG_LSIZE]; |
||||
__local float *sum_p; |
||||
src_step = src_step >> 4; |
||||
for(int i = 0; i < rows; i =i + LSIZE_1) |
||||
{ |
||||
src_t[0] = i + lid < rows ? srcsum[(lid+i) * src_step + gid * 2] : (float4)0; |
||||
src_t[1] = i + lid < rows ? srcsum[(lid+i) * src_step + gid * 2 + 1] : (float4)0; |
||||
|
||||
sum_t[0] = (i == 0 ? (float4)0 : lm_sum[0][LSIZE_2 + LOG_LSIZE]); |
||||
sum_t[1] = (i == 0 ? (float4)0 : lm_sum[1][LSIZE_2 + LOG_LSIZE]); |
||||
barrier(CLK_LOCAL_MEM_FENCE); |
||||
|
||||
int bf_loc = lid + GET_CONFLICT_OFFSET(lid); |
||||
lm_sum[0][bf_loc] = src_t[0]; |
||||
|
||||
lm_sum[1][bf_loc] = src_t[1]; |
||||
|
||||
int offset = 1; |
||||
for(int d = LSIZE >> 1 ; d > 0; d>>=1) |
||||
{ |
||||
barrier(CLK_LOCAL_MEM_FENCE); |
||||
int ai = offset * (((lid & 127)<<1) +1) - 1,bi = ai + offset; |
||||
ai += GET_CONFLICT_OFFSET(ai); |
||||
bi += GET_CONFLICT_OFFSET(bi); |
||||
|
||||
if((lid & 127) < d) |
||||
{ |
||||
lm_sum[lid >> 7][bi] += lm_sum[lid >> 7][ai]; |
||||
} |
||||
offset <<= 1; |
||||
} |
||||
barrier(CLK_LOCAL_MEM_FENCE); |
||||
if(lid < 2) |
||||
{ |
||||
lm_sum[lid][LSIZE_2 + LOG_LSIZE] = 0; |
||||
} |
||||
for(int d = 1; d < LSIZE; d <<= 1) |
||||
{ |
||||
barrier(CLK_LOCAL_MEM_FENCE); |
||||
offset >>= 1; |
||||
int ai = offset * (((lid & 127)<<1) +1) - 1,bi = ai + offset; |
||||
ai += GET_CONFLICT_OFFSET(ai); |
||||
bi += GET_CONFLICT_OFFSET(bi); |
||||
|
||||
if((lid & 127) < d) |
||||
{ |
||||
lm_sum[lid >> 7][bi] += lm_sum[lid >> 7][ai]; |
||||
lm_sum[lid >> 7][ai] = lm_sum[lid >> 7][bi] - lm_sum[lid >> 7][ai]; |
||||
} |
||||
} |
||||
barrier(CLK_LOCAL_MEM_FENCE); |
||||
if(gid == 0 && (i + lid) <= rows) |
||||
{ |
||||
sum[sum_offset + i + lid] = 0; |
||||
} |
||||
if(i + lid == 0) |
||||
{ |
||||
int loc0 = gid * 2 * sum_step; |
||||
for(int k = 1; k <= 8; k++) |
||||
{ |
||||
if(gid * 8 + k > cols) break; |
||||
sum[sum_offset + loc0 + k * sum_step / 4] = 0; |
||||
} |
||||
} |
||||
|
||||
if(lid > 0 && (i+lid) <= rows) |
||||
{ |
||||
int loc_s0 = sum_offset + gid * 2 * sum_step + sum_step / 4 + i + lid, loc_s1 = loc_s0 + sum_step ; |
||||
lm_sum[0][bf_loc] += sum_t[0]; |
||||
lm_sum[1][bf_loc] += sum_t[1]; |
||||
sum_p = (__local float*)(&(lm_sum[0][bf_loc])); |
||||
for(int k = 0; k < 4; k++) |
||||
{ |
||||
if(gid * 8 + k >= cols) break; |
||||
sum[loc_s0 + k * sum_step / 4] = sum_p[k]; |
||||
} |
||||
sum_p = (__local float*)(&(lm_sum[1][bf_loc])); |
||||
for(int k = 0; k < 4; k++) |
||||
{ |
||||
if(gid * 8 + 4 + k >= cols) break; |
||||
sum[loc_s1 + k * sum_step / 4] = sum_p[k]; |
||||
} |
||||
} |
||||
barrier(CLK_LOCAL_MEM_FENCE); |
||||
} |
||||
} |
||||
|
||||
#endif |
||||
@ -0,0 +1,129 @@ |
||||
/*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
|
||||
// Nathan, liujun@multicorewareinc.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" |
||||
#include "cvconfig.h" |
||||
#include "opencv2/ts/ocl_test.hpp" |
||||
|
||||
#ifdef HAVE_OPENCL |
||||
|
||||
namespace cvtest { |
||||
namespace ocl { |
||||
|
||||
PARAM_TEST_CASE(BlendLinear, MatDepth, Channels, bool) |
||||
{ |
||||
int depth, channels; |
||||
bool useRoi; |
||||
|
||||
TEST_DECLARE_INPUT_PARAMETER(src1) |
||||
TEST_DECLARE_INPUT_PARAMETER(src2) |
||||
TEST_DECLARE_INPUT_PARAMETER(weights2) |
||||
TEST_DECLARE_INPUT_PARAMETER(weights1) |
||||
TEST_DECLARE_OUTPUT_PARAMETER(dst) |
||||
|
||||
virtual void SetUp() |
||||
{ |
||||
depth = GET_PARAM(0); |
||||
channels = GET_PARAM(1); |
||||
useRoi = GET_PARAM(2); |
||||
} |
||||
|
||||
void random_roi() |
||||
{ |
||||
const int type = CV_MAKE_TYPE(depth, channels); |
||||
const double upValue = 256; |
||||
|
||||
Size roiSize = randomSize(1, 20); |
||||
Border src1Border = randomBorder(0, useRoi ? MAX_VALUE : 0); |
||||
randomSubMat(src1, src1_roi, roiSize, src1Border, type, -upValue, upValue); |
||||
|
||||
Border src2Border = randomBorder(0, useRoi ? MAX_VALUE : 0); |
||||
randomSubMat(src2, src2_roi, roiSize, src2Border, type, -upValue, upValue); |
||||
|
||||
Border weights1Border = randomBorder(0, useRoi ? MAX_VALUE : 0); |
||||
randomSubMat(weights1, weights1_roi, roiSize, weights1Border, CV_32FC1, -upValue, upValue); |
||||
|
||||
Border weights2Border = randomBorder(0, useRoi ? MAX_VALUE : 0); |
||||
randomSubMat(weights2, weights2_roi, roiSize, weights2Border, CV_32FC1, 1e-2, upValue); |
||||
|
||||
weights2_roi -= weights1_roi; |
||||
CV_Assert(checkNorm(weights2_roi, weights2(Rect(weights2Border.lef, weights2Border.top, |
||||
roiSize.width, roiSize.height))) < 1e-6); |
||||
|
||||
Border dstBorder = randomBorder(0, useRoi ? MAX_VALUE : 0); |
||||
randomSubMat(dst, dst_roi, roiSize, dstBorder, type, 5, 16); |
||||
|
||||
UMAT_UPLOAD_INPUT_PARAMETER(src1) |
||||
UMAT_UPLOAD_INPUT_PARAMETER(src2) |
||||
UMAT_UPLOAD_INPUT_PARAMETER(weights1) |
||||
UMAT_UPLOAD_INPUT_PARAMETER(weights2) |
||||
UMAT_UPLOAD_OUTPUT_PARAMETER(dst) |
||||
} |
||||
|
||||
void Near(double eps = 0.0) |
||||
{ |
||||
EXPECT_MAT_NEAR(dst, udst, eps); |
||||
EXPECT_MAT_NEAR(dst_roi, udst_roi, eps); |
||||
} |
||||
}; |
||||
|
||||
OCL_TEST_P(BlendLinear, Accuracy) |
||||
{ |
||||
for (int i = 0; i < test_loop_times; ++i) |
||||
{ |
||||
random_roi(); |
||||
|
||||
OCL_OFF(cv::blendLinear(src1_roi, src2_roi, weights1_roi, weights2_roi, dst_roi)); |
||||
OCL_ON(cv::blendLinear(usrc1_roi, usrc2_roi, uweights1_roi, uweights2_roi, udst_roi)); |
||||
|
||||
Near(depth <= CV_32S ? 1.0 : 0.2); |
||||
} |
||||
} |
||||
|
||||
OCL_INSTANTIATE_TEST_CASE_P(ImgProc, BlendLinear, Combine(testing::Values(CV_8U, CV_32F), OCL_ALL_CHANNELS, Bool())); |
||||
|
||||
} } // namespace cvtest::ocl
|
||||
|
||||
#endif |
||||
@ -0,0 +1,135 @@ |
||||
/*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, Institute Of Software Chinese Academy Of Science, all rights reserved.
|
||||
// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved.
|
||||
// Copyright (C) 2010-2012, Multicoreware, 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 "test_precomp.hpp" |
||||
#include "opencv2/ts/ocl_test.hpp" |
||||
|
||||
#ifdef HAVE_OPENCL |
||||
|
||||
namespace cvtest { |
||||
namespace ocl { |
||||
|
||||
/////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Filter2D
|
||||
PARAM_TEST_CASE(Filter2D, MatDepth, Channels, BorderType, bool, bool) |
||||
{ |
||||
static const int kernelMinSize = 2; |
||||
static const int kernelMaxSize = 10; |
||||
|
||||
int type; |
||||
Size dsize; |
||||
Point anchor; |
||||
int borderType; |
||||
bool useRoi; |
||||
Mat kernel; |
||||
|
||||
TEST_DECLARE_INPUT_PARAMETER(src) |
||||
TEST_DECLARE_OUTPUT_PARAMETER(dst) |
||||
|
||||
virtual void SetUp() |
||||
{ |
||||
type = CV_MAKE_TYPE(GET_PARAM(0), GET_PARAM(1)); |
||||
borderType = GET_PARAM(2) | (GET_PARAM(3) ? BORDER_ISOLATED : 0); |
||||
useRoi = GET_PARAM(4); |
||||
} |
||||
|
||||
void random_roi() |
||||
{ |
||||
dsize = randomSize(1, MAX_VALUE); |
||||
|
||||
Size ksize = randomSize(kernelMinSize, kernelMaxSize); |
||||
Mat temp = randomMat(ksize, CV_MAKE_TYPE(((CV_64F == CV_MAT_DEPTH(type)) ? CV_64F : CV_32F), 1), -MAX_VALUE, MAX_VALUE); |
||||
cv::normalize(temp, kernel, 1.0, 0.0, NORM_L1); |
||||
|
||||
Size roiSize = randomSize(ksize.width, MAX_VALUE, ksize.height, MAX_VALUE); |
||||
Border srcBorder = randomBorder(0, useRoi ? MAX_VALUE : 0); |
||||
randomSubMat(src, src_roi, roiSize, srcBorder, type, -MAX_VALUE, MAX_VALUE); |
||||
|
||||
Border dstBorder = randomBorder(0, useRoi ? MAX_VALUE : 0); |
||||
randomSubMat(dst, dst_roi, dsize, dstBorder, type, -MAX_VALUE, MAX_VALUE); |
||||
|
||||
anchor.x = randomInt(-1, ksize.width); |
||||
anchor.y = randomInt(-1, ksize.height); |
||||
|
||||
UMAT_UPLOAD_INPUT_PARAMETER(src) |
||||
UMAT_UPLOAD_OUTPUT_PARAMETER(dst) |
||||
} |
||||
|
||||
void Near(double threshold = 0.0) |
||||
{ |
||||
EXPECT_MAT_NEAR(dst, udst, threshold); |
||||
EXPECT_MAT_NEAR(dst_roi, udst_roi, threshold); |
||||
} |
||||
}; |
||||
|
||||
OCL_TEST_P(Filter2D, Mat) |
||||
{ |
||||
for (int j = 0; j < test_loop_times; j++) |
||||
{ |
||||
random_roi(); |
||||
|
||||
OCL_OFF(cv::filter2D(src_roi, dst_roi, -1, kernel, anchor, 0.0, borderType)); |
||||
OCL_ON(cv::filter2D(usrc_roi, udst_roi, -1, kernel, anchor, 0.0, borderType)); |
||||
|
||||
Near(1.0); |
||||
} |
||||
} |
||||
|
||||
|
||||
OCL_INSTANTIATE_TEST_CASE_P(ImageProc, Filter2D, |
||||
Combine( |
||||
Values(CV_8U, CV_16U, CV_16S, CV_32F, CV_64F), |
||||
Values(1, 2, 4), |
||||
Values((BorderType)BORDER_CONSTANT, |
||||
(BorderType)BORDER_REPLICATE, |
||||
(BorderType)BORDER_REFLECT, |
||||
(BorderType)BORDER_REFLECT_101), |
||||
Bool(), // BORDER_ISOLATED
|
||||
Bool() // ROI
|
||||
) |
||||
); |
||||
|
||||
|
||||
} } // namespace cvtest::ocl
|
||||
|
||||
#endif // HAVE_OPENCL
|
||||
@ -0,0 +1,290 @@ |
||||
/*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, Institute Of Software Chinese Academy Of Science, all rights reserved.
|
||||
// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved.
|
||||
// Copyright (C) 2010-2012, Multicoreware, Inc., all rights reserved.
|
||||
// Third party copyrights are property of their respective owners.
|
||||
//
|
||||
// @Authors
|
||||
// Niko Li, newlife20080214@gmail.com
|
||||
// Jia Haipeng, jiahaipeng95@gmail.com
|
||||
// Zero Lin, Zero.Lin@amd.com
|
||||
// Zhang Ying, zhangying913@gmail.com
|
||||
// Yao Wang, bitwangyaoyao@gmail.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" |
||||
#include "cvconfig.h" |
||||
#include "opencv2/ts/ocl_test.hpp" |
||||
|
||||
#ifdef HAVE_OPENCL |
||||
|
||||
namespace cvtest { |
||||
namespace ocl { |
||||
|
||||
PARAM_TEST_CASE(FilterTestBase, MatType, |
||||
int, // kernel size
|
||||
Size, // dx, dy
|
||||
BorderType, // border type
|
||||
double, // optional parameter
|
||||
bool) // roi or not
|
||||
{ |
||||
int type, borderType, ksize; |
||||
Size size; |
||||
double param; |
||||
bool useRoi; |
||||
|
||||
TEST_DECLARE_INPUT_PARAMETER(src) |
||||
TEST_DECLARE_OUTPUT_PARAMETER(dst) |
||||
|
||||
virtual void SetUp() |
||||
{ |
||||
type = GET_PARAM(0); |
||||
ksize = GET_PARAM(1); |
||||
size = GET_PARAM(2); |
||||
borderType = GET_PARAM(3); |
||||
param = GET_PARAM(4); |
||||
useRoi = GET_PARAM(5); |
||||
} |
||||
|
||||
void random_roi(int minSize = 1) |
||||
{ |
||||
if (minSize == 0) |
||||
minSize = ksize; |
||||
|
||||
Size roiSize = randomSize(minSize, MAX_VALUE); |
||||
Border srcBorder = randomBorder(0, useRoi ? MAX_VALUE : 0); |
||||
randomSubMat(src, src_roi, roiSize, srcBorder, type, 5, 256); |
||||
|
||||
Border dstBorder = randomBorder(0, useRoi ? MAX_VALUE : 0); |
||||
randomSubMat(dst, dst_roi, roiSize, dstBorder, type, -60, 70); |
||||
|
||||
UMAT_UPLOAD_INPUT_PARAMETER(src) |
||||
UMAT_UPLOAD_OUTPUT_PARAMETER(dst) |
||||
} |
||||
|
||||
void Near() |
||||
{ |
||||
int depth = CV_MAT_DEPTH(type); |
||||
bool isFP = depth >= CV_32F; |
||||
|
||||
if (isFP) |
||||
Near(1e-6, true); |
||||
else |
||||
Near(1, false); |
||||
} |
||||
|
||||
void Near(double threshold, bool relative) |
||||
{ |
||||
if (relative) |
||||
{ |
||||
EXPECT_MAT_NEAR_RELATIVE(dst, udst, threshold); |
||||
EXPECT_MAT_NEAR_RELATIVE(dst_roi, udst_roi, threshold); |
||||
} |
||||
else |
||||
{ |
||||
EXPECT_MAT_NEAR(dst, udst, threshold); |
||||
EXPECT_MAT_NEAR(dst_roi, udst_roi, threshold); |
||||
} |
||||
} |
||||
}; |
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Bilateral
|
||||
|
||||
typedef FilterTestBase Bilateral; |
||||
|
||||
OCL_TEST_P(Bilateral, Mat) |
||||
{ |
||||
for (int j = 0; j < test_loop_times; j++) |
||||
{ |
||||
random_roi(); |
||||
|
||||
double sigmacolor = rng.uniform(20, 100); |
||||
double sigmaspace = rng.uniform(10, 40); |
||||
|
||||
OCL_OFF(cv::bilateralFilter(src_roi, dst_roi, ksize, sigmacolor, sigmaspace, borderType)); |
||||
OCL_ON(cv::bilateralFilter(usrc_roi, udst_roi, ksize, sigmacolor, sigmaspace, borderType)); |
||||
|
||||
Near(); |
||||
} |
||||
} |
||||
|
||||
/////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Laplacian
|
||||
|
||||
typedef FilterTestBase LaplacianTest; |
||||
|
||||
OCL_TEST_P(LaplacianTest, Accuracy) |
||||
{ |
||||
double scale = param; |
||||
|
||||
for (int j = 0; j < test_loop_times; j++) |
||||
{ |
||||
random_roi(); |
||||
|
||||
OCL_OFF(cv::Laplacian(src_roi, dst_roi, -1, ksize, scale, 0, borderType)); |
||||
OCL_ON(cv::Laplacian(usrc_roi, udst_roi, -1, ksize, scale, 0, borderType)); |
||||
|
||||
Near(); |
||||
} |
||||
} |
||||
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Sobel
|
||||
|
||||
typedef FilterTestBase SobelTest; |
||||
|
||||
OCL_TEST_P(SobelTest, Mat) |
||||
{ |
||||
int dx = size.width, dy = size.height; |
||||
double scale = param; |
||||
|
||||
for (int j = 0; j < test_loop_times; j++) |
||||
{ |
||||
random_roi(); |
||||
|
||||
OCL_OFF(cv::Sobel(src_roi, dst_roi, -1, dx, dy, ksize, scale, /* delta */0, borderType)); |
||||
OCL_ON(cv::Sobel(usrc_roi, udst_roi, -1, dx, dy, ksize, scale, /* delta */0, borderType)); |
||||
|
||||
Near(); |
||||
} |
||||
} |
||||
|
||||
/////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Scharr
|
||||
|
||||
typedef FilterTestBase ScharrTest; |
||||
|
||||
OCL_TEST_P(ScharrTest, Mat) |
||||
{ |
||||
int dx = size.width, dy = size.height; |
||||
double scale = param; |
||||
|
||||
for (int j = 0; j < test_loop_times; j++) |
||||
{ |
||||
random_roi(); |
||||
|
||||
OCL_OFF(cv::Scharr(src_roi, dst_roi, -1, dx, dy, scale, /* delta */ 0, borderType)); |
||||
OCL_ON(cv::Scharr(usrc_roi, udst_roi, -1, dx, dy, scale, /* delta */ 0, borderType)); |
||||
|
||||
Near(); |
||||
} |
||||
} |
||||
|
||||
/////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// GaussianBlur
|
||||
|
||||
typedef FilterTestBase GaussianBlurTest; |
||||
|
||||
OCL_TEST_P(GaussianBlurTest, Mat) |
||||
{ |
||||
for (int j = 0; j < test_loop_times; j++) |
||||
{ |
||||
random_roi(); |
||||
|
||||
double sigma1 = rng.uniform(0.1, 1.0); |
||||
double sigma2 = rng.uniform(0.1, 1.0); |
||||
|
||||
OCL_OFF(cv::GaussianBlur(src_roi, dst_roi, Size(ksize, ksize), sigma1, sigma2, borderType)); |
||||
OCL_ON(cv::GaussianBlur(usrc_roi, udst_roi, Size(ksize, ksize), sigma1, sigma2, borderType)); |
||||
|
||||
Near(CV_MAT_DEPTH(type) == CV_8U ? 3 : 5e-5, false); |
||||
} |
||||
} |
||||
|
||||
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#define FILTER_BORDER_SET_NO_ISOLATED \ |
||||
Values((BorderType)BORDER_CONSTANT, (BorderType)BORDER_REPLICATE, (BorderType)BORDER_REFLECT, (BorderType)BORDER_WRAP, (BorderType)BORDER_REFLECT_101/*, \
|
||||
(int)BORDER_CONSTANT|BORDER_ISOLATED, (int)BORDER_REPLICATE|BORDER_ISOLATED, \
|
||||
(int)BORDER_REFLECT|BORDER_ISOLATED, (int)BORDER_WRAP|BORDER_ISOLATED, \
|
||||
(int)BORDER_REFLECT_101|BORDER_ISOLATED*/) // WRAP and ISOLATED are not supported by cv:: version
|
||||
|
||||
#define FILTER_BORDER_SET_NO_WRAP_NO_ISOLATED \ |
||||
Values((BorderType)BORDER_CONSTANT, (BorderType)BORDER_REPLICATE, (BorderType)BORDER_REFLECT, /*(int)BORDER_WRAP,*/ (BorderType)BORDER_REFLECT_101/*, \
|
||||
(int)BORDER_CONSTANT|BORDER_ISOLATED, (int)BORDER_REPLICATE|BORDER_ISOLATED, \
|
||||
(int)BORDER_REFLECT|BORDER_ISOLATED, (int)BORDER_WRAP|BORDER_ISOLATED, \
|
||||
(int)BORDER_REFLECT_101|BORDER_ISOLATED*/) // WRAP and ISOLATED are not supported by cv:: version
|
||||
|
||||
#define FILTER_TYPES Values(CV_8UC1, CV_8UC2, CV_8UC4, CV_32FC1, CV_32FC4, CV_64FC1, CV_64FC4) |
||||
|
||||
OCL_INSTANTIATE_TEST_CASE_P(Filter, Bilateral, Combine( |
||||
Values((MatType)CV_8UC1), |
||||
Values(5, 9), // kernel size
|
||||
Values(Size(0, 0)), // not used
|
||||
FILTER_BORDER_SET_NO_ISOLATED, |
||||
Values(0.0), // not used
|
||||
Bool())); |
||||
|
||||
OCL_INSTANTIATE_TEST_CASE_P(Filter, LaplacianTest, Combine( |
||||
FILTER_TYPES, |
||||
Values(1, 3), // kernel size
|
||||
Values(Size(0, 0)), // not used
|
||||
FILTER_BORDER_SET_NO_WRAP_NO_ISOLATED, |
||||
Values(1.0, 0.2, 3.0), // kernel scale
|
||||
Bool())); |
||||
|
||||
OCL_INSTANTIATE_TEST_CASE_P(Filter, SobelTest, Combine( |
||||
FILTER_TYPES, |
||||
Values(3, 5), // kernel size
|
||||
Values(Size(1, 0), Size(1, 1), Size(2, 0), Size(2, 1)), // dx, dy
|
||||
FILTER_BORDER_SET_NO_WRAP_NO_ISOLATED, |
||||
Values(0.0), // not used
|
||||
Bool())); |
||||
|
||||
OCL_INSTANTIATE_TEST_CASE_P(Filter, ScharrTest, Combine( |
||||
FILTER_TYPES, |
||||
Values(0), // not used
|
||||
Values(Size(0, 1), Size(1, 0)), // dx, dy
|
||||
FILTER_BORDER_SET_NO_WRAP_NO_ISOLATED, |
||||
Values(1.0, 0.2), // kernel scale
|
||||
Bool())); |
||||
|
||||
OCL_INSTANTIATE_TEST_CASE_P(Filter, GaussianBlurTest, Combine( |
||||
FILTER_TYPES, |
||||
Values(3, 5), // kernel size
|
||||
Values(Size(0, 0)), // not used
|
||||
FILTER_BORDER_SET_NO_WRAP_NO_ISOLATED, |
||||
Values(0.0), // not used
|
||||
Bool())); |
||||
|
||||
} } // namespace cvtest::ocl
|
||||
|
||||
#endif // HAVE_OPENCL
|
||||
@ -0,0 +1,99 @@ |
||||
Seamless Cloning |
||||
================ |
||||
|
||||
.. highlight:: cpp |
||||
|
||||
seamlessClone |
||||
------------- |
||||
Image editing tasks concern either global changes (color/intensity corrections, filters, deformations) or local changes concerned to a selection. |
||||
Here we are interested in achieving local changes, ones that are restricted to a region manually selected (ROI), in a seamless and effortless manner. |
||||
The extent of the changes ranges from slight distortions to complete replacement by novel content. |
||||
|
||||
.. ocv:function:: void seamlessClone( InputArray src, InputArray dst, InputArray mask, Point p, OutputArray blend, int flags) |
||||
|
||||
:param src: Input 8-bit 3-channel image. |
||||
|
||||
:param dst: Input 8-bit 3-channel image. |
||||
|
||||
:param mask: Input 8-bit 1 or 3-channel image. |
||||
|
||||
:param p: Point in dst image where object is placed. |
||||
|
||||
:param result: Output image with the same size and type as ``dst``. |
||||
|
||||
:param flags: Cloning method that could be one of the following: |
||||
|
||||
* **NORMAL_CLONE** The power of the method is fully expressed when inserting objects with complex outlines into a new background |
||||
|
||||
* **MIXED_CLONE** The classic method, color-based selection and alpha |
||||
masking might be time consuming and often leaves an undesirable halo. Seamless |
||||
cloning, even averaged with the original image, is not effective. Mixed seamless |
||||
cloning based on a loose selection proves effective. |
||||
|
||||
* **FEATURE_EXCHANGE** Feature exchange allows the user to replace easily certain |
||||
features of one object by alternative features. |
||||
|
||||
|
||||
|
||||
colorChange |
||||
----------- |
||||
Given an original color image, two differently colored versions of this image can be mixed seamlessly. |
||||
|
||||
.. ocv:function:: void colorChange( InputArray src, InputArray mask, OutputArray dst, float red_mul = 1.0f, float green_mul = 1.0f, float blue_mul = 1.0f) |
||||
|
||||
:param src: Input 8-bit 3-channel image. |
||||
|
||||
:param mask: Input 8-bit 1 or 3-channel image. |
||||
|
||||
:param dst: Output image with the same size and type as ``src`` . |
||||
|
||||
:param red_mul: R-channel multiply factor. |
||||
|
||||
:param green_mul: G-channel multiply factor. |
||||
|
||||
:param blue_mul: B-channel multiply factor. |
||||
|
||||
Multiplication factor is between .5 to 2.5. |
||||
|
||||
|
||||
illuminationChange |
||||
------------------ |
||||
Applying an appropriate non-linear transformation to the gradient field inside the selection and then integrating back with a Poisson |
||||
solver, modifies locally the apparent illumination of an image. |
||||
|
||||
.. ocv:function:: void illuminationChange(InputArray src, InputArray mask, OutputArray dst, float alpha = 0.2f, float beta = 0.4f) |
||||
|
||||
:param src: Input 8-bit 3-channel image. |
||||
|
||||
:param mask: Input 8-bit 1 or 3-channel image. |
||||
|
||||
:param dst: Output image with the same size and type as ``src``. |
||||
|
||||
:param alpha: Value ranges between 0-2. |
||||
|
||||
:param beta: Value ranges between 0-2. |
||||
|
||||
This is useful to highlight under-exposed foreground objects or to reduce specular reflections. |
||||
|
||||
textureFlattening |
||||
----------------- |
||||
By retaining only the gradients at edge locations, before integrating with the Poisson solver, one washes out the texture of the selected |
||||
region, giving its contents a flat aspect. Here Canny Edge Detector is used. |
||||
|
||||
.. ocv:function:: void textureFlattening(InputArray src, InputArray mask, OutputArray dst, double low_threshold=30 , double high_threshold=45, int kernel_size=3) |
||||
|
||||
:param src: Input 8-bit 3-channel image. |
||||
|
||||
:param mask: Input 8-bit 1 or 3-channel image. |
||||
|
||||
:param dst: Output image with the same size and type as ``src``. |
||||
|
||||
:param low_threshold: Range from 0 to 100. |
||||
|
||||
:param high_threshold: Value > 100. |
||||
|
||||
:param kernel_size: The size of the Sobel kernel to be used. |
||||
|
||||
**NOTE:** |
||||
|
||||
The algorithm assumes that the color of the source image is close to that of the destination. This assumption means that when the colors don't match, the source image color gets tinted toward the color of the destination image. |
||||
@ -0,0 +1,19 @@ |
||||
Decolorization |
||||
============== |
||||
|
||||
.. highlight:: cpp |
||||
|
||||
decolor |
||||
------- |
||||
|
||||
Transforms a color image to a grayscale image. It is a basic tool in digital printing, stylized black-and-white photograph rendering, and in many single channel image processing applications. |
||||
|
||||
.. ocv:function:: void decolor( InputArray src, OutputArray grayscale, OutputArray color_boost ) |
||||
|
||||
:param src: Input 8-bit 3-channel image. |
||||
|
||||
:param grayscale: Output 8-bit 1-channel image. |
||||
|
||||
:param color_boost: Output 8-bit 3-channel image. |
||||
|
||||
This function is to be applied on color images. |
||||
@ -0,0 +1,74 @@ |
||||
Non-Photorealistic Rendering |
||||
============================ |
||||
|
||||
.. highlight:: cpp |
||||
|
||||
edgePreservingFilter |
||||
-------------------- |
||||
|
||||
Filtering is the fundamental operation in image and video processing. Edge-preserving smoothing filters are used in many different applications. |
||||
|
||||
.. ocv:function:: void edgePreservingFilter(InputArray src, OutputArray dst, int flags = 1, float sigma_s = 60, float sigma_r = 0.4f) |
||||
|
||||
:param src: Input 8-bit 3-channel image. |
||||
|
||||
:param dst: Output 8-bit 3-channel image. |
||||
|
||||
:param flags: Edge preserving filters: |
||||
|
||||
* **RECURS_FILTER** |
||||
|
||||
* **NORMCONV_FILTER** |
||||
|
||||
:param sigma_s: Range between 0 to 200. |
||||
|
||||
:param sigma_r: Range between 0 to 1. |
||||
|
||||
|
||||
detailEnhance |
||||
------------- |
||||
This filter enhances the details of a particular image. |
||||
|
||||
.. ocv:function:: void detailEnhance(InputArray src, OutputArray dst, float sigma_s = 10, float sigma_r = 0.15f) |
||||
|
||||
:param src: Input 8-bit 3-channel image. |
||||
|
||||
:param dst: Output image with the same size and type as ``src``. |
||||
|
||||
:param sigma_s: Range between 0 to 200. |
||||
|
||||
:param sigma_r: Range between 0 to 1. |
||||
|
||||
|
||||
pencilSketch |
||||
------------ |
||||
Pencil-like non-photorealistic line drawing |
||||
|
||||
.. ocv:function:: void pencilSketch(InputArray src, OutputArray dst1, OutputArray dst2, float sigma_s = 60, float sigma_r = 0.07f, float shade_factor = 0.02f) |
||||
|
||||
:param src: Input 8-bit 3-channel image. |
||||
|
||||
:param dst1: Output 8-bit 1-channel image. |
||||
|
||||
:param dst2: Output image with the same size and type as ``src``. |
||||
|
||||
:param sigma_s: Range between 0 to 200. |
||||
|
||||
:param sigma_r: Range between 0 to 1. |
||||
|
||||
:param shade_factor: Range between 0 to 0.1. |
||||
|
||||
|
||||
stylization |
||||
----------- |
||||
Stylization aims to produce digital imagery with a wide variety of effects not focused on photorealism. Edge-aware filters are ideal for stylization, as they can abstract regions of low contrast while preserving, or enhancing, high-contrast features. |
||||
|
||||
.. ocv:function:: void stylization(InputArray src, OutputArray dst, float sigma_s = 60, float sigma_r = 0.45f) |
||||
|
||||
:param src: Input 8-bit 3-channel image. |
||||
|
||||
:param dst: Output image with the same size and type as ``src``. |
||||
|
||||
:param sigma_s: Range between 0 to 200. |
||||
|
||||
:param sigma_r: Range between 0 to 1. |
||||
@ -0,0 +1,210 @@ |
||||
/*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) 2013, OpenCV Foundation, 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 "precomp.hpp" |
||||
#include "opencv2/photo.hpp" |
||||
#include "math.h" |
||||
#include <vector> |
||||
#include <limits> |
||||
#include <iostream> |
||||
#include "contrast_preserve.hpp" |
||||
|
||||
using namespace std; |
||||
using namespace cv; |
||||
|
||||
void cv::decolor(InputArray _src, OutputArray _dst, OutputArray _color_boost) |
||||
{ |
||||
Mat I = _src.getMat(); |
||||
_dst.create(I.size(), CV_8UC1); |
||||
Mat dst = _dst.getMat(); |
||||
|
||||
_color_boost.create(I.size(), CV_8UC3); |
||||
Mat color_boost = _color_boost.getMat(); |
||||
|
||||
if(!I.data ) |
||||
{ |
||||
cout << "Could not open or find the image" << endl ; |
||||
return; |
||||
} |
||||
if(I.channels() !=3) |
||||
{ |
||||
cout << "Input Color Image" << endl; |
||||
return; |
||||
} |
||||
|
||||
// Parameter Setting
|
||||
int maxIter = 15; |
||||
int iterCount = 0; |
||||
double tol = .0001; |
||||
double E = 0; |
||||
double pre_E = std::numeric_limits<double>::infinity(); |
||||
|
||||
Decolor obj; |
||||
|
||||
Mat img; |
||||
|
||||
img = Mat(I.size(),CV_32FC3); |
||||
I.convertTo(img,CV_32FC3,1.0/255.0); |
||||
|
||||
// Initialization
|
||||
obj.init(); |
||||
|
||||
vector <double> Cg; |
||||
vector < vector <double> > polyGrad; |
||||
vector < vector < int > > comb; |
||||
|
||||
vector <double> alf; |
||||
|
||||
obj.grad_system(img,polyGrad,Cg,comb); |
||||
obj.weak_order(img,alf); |
||||
|
||||
// Solver
|
||||
Mat Mt = Mat((int)polyGrad.size(),(int)polyGrad[0].size(), CV_32FC1); |
||||
obj.wei_update_matrix(polyGrad,Cg,Mt); |
||||
|
||||
vector <double> wei; |
||||
obj.wei_inti(comb,wei); |
||||
|
||||
//////////////////////////////// main loop starting ////////////////////////////////////////
|
||||
|
||||
while(sqrt(pow(E-pre_E,2)) > tol) |
||||
{ |
||||
iterCount +=1; |
||||
pre_E = E; |
||||
|
||||
vector <double> G_pos; |
||||
vector <double> G_neg; |
||||
|
||||
vector <double> temp; |
||||
vector <double> temp1; |
||||
|
||||
double val = 0.0; |
||||
for(unsigned int i=0;i< polyGrad[0].size();i++) |
||||
{ |
||||
val = 0.0; |
||||
for(unsigned int j =0;j<polyGrad.size();j++) |
||||
val = val + (polyGrad[j][i] * wei[j]); |
||||
temp.push_back(val - Cg[i]); |
||||
temp1.push_back(val + Cg[i]); |
||||
} |
||||
|
||||
double pos = 0.0; |
||||
double neg = 0.0; |
||||
for(unsigned int i =0;i<alf.size();i++) |
||||
{ |
||||
pos = ((1 + alf[i])/2) * exp((-1.0 * 0.5 * pow(temp[i],2))/pow(obj.sigma,2)); |
||||
neg = ((1 - alf[i])/2) * exp((-1.0 * 0.5 * pow(temp1[i],2))/pow(obj.sigma,2)); |
||||
G_pos.push_back(pos); |
||||
G_neg.push_back(neg); |
||||
} |
||||
|
||||
vector <double> EXPsum; |
||||
vector <double> EXPterm; |
||||
|
||||
for(unsigned int i = 0;i<G_pos.size();i++) |
||||
EXPsum.push_back(G_pos[i]+G_neg[i]); |
||||
|
||||
vector <double> temp2; |
||||
|
||||
for(unsigned int i=0;i<EXPsum.size();i++) |
||||
{ |
||||
if(EXPsum[i] == 0) |
||||
temp2.push_back(1.0); |
||||
else |
||||
temp2.push_back(0.0); |
||||
} |
||||
|
||||
for(unsigned int i =0; i < G_pos.size();i++) |
||||
EXPterm.push_back((G_pos[i] - G_neg[i])/(EXPsum[i] + temp2[i])); |
||||
|
||||
double val1 = 0.0; |
||||
vector <double> wei1; |
||||
|
||||
for(unsigned int i=0;i< polyGrad.size();i++) |
||||
{ |
||||
val1 = 0.0; |
||||
for(unsigned int j =0;j<polyGrad[0].size();j++) |
||||
{ |
||||
val1 = val1 + (Mt.at<float>(i,j) * EXPterm[j]); |
||||
} |
||||
wei1.push_back(val1); |
||||
} |
||||
|
||||
for(unsigned int i =0;i<wei.size();i++) |
||||
wei[i] = wei1[i]; |
||||
|
||||
E = obj.energyCalcu(Cg,polyGrad,wei); |
||||
|
||||
if(iterCount > maxIter) |
||||
break; |
||||
|
||||
G_pos.clear(); |
||||
G_neg.clear(); |
||||
temp.clear(); |
||||
temp1.clear(); |
||||
EXPsum.clear(); |
||||
EXPterm.clear(); |
||||
temp2.clear(); |
||||
wei1.clear(); |
||||
} |
||||
|
||||
Mat Gray = Mat::zeros(img.size(),CV_32FC1); |
||||
obj.grayImContruct(wei, img, Gray); |
||||
|
||||
Gray.convertTo(dst,CV_8UC1,255); |
||||
|
||||
/////////////////////////////////// Contrast Boosting /////////////////////////////////
|
||||
|
||||
Mat lab = Mat(img.size(),CV_8UC3); |
||||
Mat color = Mat(img.size(),CV_8UC3); |
||||
|
||||
cvtColor(I,lab,COLOR_BGR2Lab); |
||||
|
||||
vector <Mat> lab_channel; |
||||
split(lab,lab_channel); |
||||
|
||||
dst.copyTo(lab_channel[0]); |
||||
|
||||
merge(lab_channel,lab); |
||||
|
||||
cvtColor(lab,color_boost,COLOR_Lab2BGR); |
||||
} |
||||
@ -0,0 +1,433 @@ |
||||
/*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) 2013, OpenCV Foundation, 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 "precomp.hpp" |
||||
#include "opencv2/photo.hpp" |
||||
#include "math.h" |
||||
#include <vector> |
||||
#include <limits> |
||||
|
||||
using namespace std; |
||||
using namespace cv; |
||||
|
||||
class Decolor |
||||
{ |
||||
private: |
||||
Mat kernelx; |
||||
Mat kernely; |
||||
int order; |
||||
|
||||
public: |
||||
float sigma; |
||||
void init(); |
||||
vector<double> product(vector < vector<int> > &comb, vector <double> &initRGB); |
||||
double energyCalcu(vector <double> &Cg, vector < vector <double> > &polyGrad, vector <double> &wei); |
||||
void singleChannelGradx(const Mat &img, Mat& dest); |
||||
void singleChannelGrady(const Mat &img, Mat& dest); |
||||
void gradvector(const Mat &img, vector <double> &grad); |
||||
void colorGrad(Mat img, vector <double> &Cg); |
||||
void add_vector(vector < vector <int> > &comb, int r,int g,int b); |
||||
void add_to_vector_poly(vector < vector <double> > &polyGrad, vector <double> &curGrad); |
||||
void weak_order(Mat img, vector <double> &alf); |
||||
void grad_system(Mat img, vector < vector < double > > &polyGrad, |
||||
vector < double > &Cg, vector < vector <int> >& comb); |
||||
void wei_update_matrix(vector < vector <double> > &poly, vector <double> &Cg, Mat &X); |
||||
void wei_inti(vector < vector <int> > &comb, vector <double> &wei); |
||||
void grayImContruct(vector <double> &wei, Mat img, Mat &Gray); |
||||
}; |
||||
|
||||
int round_num(double a); |
||||
|
||||
int round_num(double a) |
||||
{ |
||||
return int(a + 0.5); |
||||
} |
||||
|
||||
double Decolor::energyCalcu(vector <double> &Cg, vector < vector <double> > &polyGrad, vector <double> &wei) |
||||
{ |
||||
vector <double> energy; |
||||
vector <double> temp; |
||||
vector <double> temp1; |
||||
|
||||
double val = 0.0; |
||||
for(unsigned int i=0;i< polyGrad[0].size();i++) |
||||
{ |
||||
val = 0.0; |
||||
for(unsigned int j =0;j<polyGrad.size();j++) |
||||
val = val + (polyGrad[j][i] * wei[j]); |
||||
temp.push_back(val - Cg[i]); |
||||
temp1.push_back(val + Cg[i]); |
||||
} |
||||
|
||||
for(unsigned int i=0;i<polyGrad[0].size();i++) |
||||
energy.push_back(-1.0*log(exp(-1.0*pow(temp[i],2)/sigma) + exp(-1.0*pow(temp1[i],2)/sigma))); |
||||
|
||||
double sum = 0.0; |
||||
for(unsigned int i=0;i<polyGrad[0].size();i++) |
||||
sum +=energy[i]; |
||||
|
||||
return (sum/polyGrad[0].size()); |
||||
|
||||
} |
||||
|
||||
void Decolor::init() |
||||
{ |
||||
kernelx = Mat(1,2, CV_32FC1); |
||||
kernely = Mat(2,1, CV_32FC1); |
||||
kernelx.at<float>(0,0)=1.0; |
||||
kernelx.at<float>(0,1)=-1.0; |
||||
kernely.at<float>(0,0)=1.0; |
||||
kernely.at<float>(1,0)=-1.0; |
||||
order = 2; |
||||
sigma = 0.02f; |
||||
} |
||||
|
||||
vector<double> Decolor::product(vector < vector<int> > &comb, vector <double> &initRGB) |
||||
{ |
||||
vector <double> res; |
||||
double dp; |
||||
for (unsigned int i=0;i<comb.size();i++) |
||||
{ |
||||
dp = 0.0; |
||||
for(int j=0;j<3;j++) |
||||
dp = dp + (comb[i][j] * initRGB[j]); |
||||
res.push_back(dp); |
||||
} |
||||
return res; |
||||
} |
||||
|
||||
void Decolor::singleChannelGradx(const Mat &img, Mat& dest) |
||||
{ |
||||
int w=img.size().width; |
||||
int h=img.size().height; |
||||
Point anchor(kernelx.cols - kernelx.cols/2 - 1, kernelx.rows - kernelx.rows/2 - 1); |
||||
filter2D(img, dest, -1, kernelx, anchor, 0.0, BORDER_CONSTANT); |
||||
for(int i=0;i<h;i++) |
||||
dest.at<float>(i,w-1)=0.0; |
||||
} |
||||
|
||||
void Decolor::singleChannelGrady(const Mat &img, Mat& dest) |
||||
{ |
||||
int w=img.size().width; |
||||
int h=img.size().height; |
||||
Point anchor(kernely.cols - kernely.cols/2 - 1, kernely.rows - kernely.rows/2 - 1); |
||||
filter2D(img, dest, -1, kernely, anchor, 0.0, BORDER_CONSTANT); |
||||
for(int j=0;j<w;j++) |
||||
dest.at<float>(h-1,j)=0.0; |
||||
} |
||||
|
||||
void Decolor::gradvector(const Mat &img, vector <double> &grad) |
||||
{ |
||||
Mat dest= Mat(img.size().height,img.size().width, CV_32FC1); |
||||
Mat dest1= Mat(img.size().height,img.size().width, CV_32FC1); |
||||
singleChannelGradx(img,dest); |
||||
singleChannelGrady(img,dest1); |
||||
|
||||
Mat d_trans=dest.t(); |
||||
Mat d1_trans=dest1.t(); |
||||
|
||||
int height = d_trans.size().height; |
||||
int width = d_trans.size().width; |
||||
|
||||
for(int i=0;i<height;i++) |
||||
for(int j=0;j<width;j++) |
||||
grad.push_back(d_trans.at<float>(i,j)); |
||||
|
||||
for(int i=0;i<height;i++) |
||||
for(int j=0;j<width;j++) |
||||
grad.push_back(d1_trans.at<float>(i,j)); |
||||
dest.release(); |
||||
dest1.release(); |
||||
} |
||||
|
||||
void Decolor::colorGrad(Mat img, vector <double> &Cg) |
||||
{ |
||||
|
||||
Mat lab = Mat(img.size(),CV_32FC3); |
||||
|
||||
cvtColor(img,lab,COLOR_BGR2Lab); |
||||
|
||||
vector <Mat> lab_channel; |
||||
split(lab,lab_channel); |
||||
|
||||
vector <double> ImL; |
||||
vector <double> Ima; |
||||
vector <double> Imb; |
||||
|
||||
gradvector(lab_channel[0],ImL); |
||||
gradvector(lab_channel[1],Ima); |
||||
gradvector(lab_channel[2],Imb); |
||||
|
||||
double res =0.0; |
||||
for(unsigned int i=0;i<ImL.size();i++) |
||||
{ |
||||
res=sqrt(pow(ImL[i],2) + pow(Ima[i],2) + pow(Imb[i],2))/100; |
||||
Cg.push_back(res); |
||||
} |
||||
|
||||
ImL.clear(); |
||||
Ima.clear(); |
||||
Imb.clear(); |
||||
} |
||||
|
||||
void Decolor::add_vector(vector < vector <int> > &comb, int r,int g,int b) |
||||
{ |
||||
static int idx =0; |
||||
comb.push_back( vector <int>() ); |
||||
comb.at(idx).push_back( r ); |
||||
comb.at(idx).push_back( g ); |
||||
comb.at(idx).push_back( b ); |
||||
idx++; |
||||
} |
||||
|
||||
void Decolor::add_to_vector_poly(vector < vector <double> > &polyGrad, vector <double> &curGrad) |
||||
{ |
||||
static int idx1 =0; |
||||
polyGrad.push_back( vector <double>() ); |
||||
for(unsigned int i=0;i<curGrad.size();i++) |
||||
polyGrad.at(idx1).push_back(curGrad[i]); |
||||
idx1++; |
||||
} |
||||
|
||||
void Decolor::weak_order(Mat img, vector <double> &alf) |
||||
{ |
||||
int h = img.size().height; |
||||
int w = img.size().width; |
||||
double sizefactor; |
||||
if((h + w) > 800) |
||||
{ |
||||
sizefactor = (double)800/(h+w); |
||||
resize(img,img,Size(round_num(h*sizefactor),round_num(w*sizefactor))); |
||||
} |
||||
|
||||
Mat curIm = Mat(img.size(),CV_32FC1); |
||||
vector <Mat> rgb_channel; |
||||
split(img,rgb_channel); |
||||
|
||||
vector <double> Rg, Gg, Bg; |
||||
vector <double> t1, t2, t3; |
||||
vector <double> tmp1, tmp2, tmp3; |
||||
|
||||
gradvector(rgb_channel[2],Rg); |
||||
gradvector(rgb_channel[1],Gg); |
||||
gradvector(rgb_channel[0],Bg); |
||||
|
||||
double level = .05; |
||||
|
||||
for(unsigned int i=0;i<Rg.size();i++) |
||||
{ |
||||
if(Rg[i] > level) |
||||
t1.push_back(1.0); |
||||
else |
||||
t1.push_back(0.0); |
||||
|
||||
if(Gg[i] > level) |
||||
t2.push_back(1.0); |
||||
else |
||||
t2.push_back(0.0); |
||||
|
||||
if(Bg[i] > level) |
||||
t3.push_back(1.0); |
||||
else |
||||
t3.push_back(0.0); |
||||
|
||||
if(Rg[i] < -1.0*level) |
||||
tmp1.push_back(1.0); |
||||
else |
||||
tmp1.push_back(0.0); |
||||
|
||||
if(Gg[i] < -1.0*level) |
||||
tmp2.push_back(1.0); |
||||
else |
||||
tmp2.push_back(0.0); |
||||
|
||||
if(Bg[i] < -1.0*level) |
||||
tmp3.push_back(1.0); |
||||
else |
||||
tmp3.push_back(0.0); |
||||
} |
||||
for(unsigned int i =0 ;i < Rg.size();i++) |
||||
alf.push_back(t1[i] * t2[i] * t3[i]); |
||||
|
||||
for(unsigned int i =0 ;i < Rg.size();i++) |
||||
alf[i] -= tmp1[i] * tmp2[i] * tmp3[i]; |
||||
|
||||
double sum =0.0; |
||||
for(unsigned int i=0;i<alf.size();i++) |
||||
sum += abs(alf[i]); |
||||
|
||||
sum = (double)100*sum/alf.size(); |
||||
|
||||
Rg.clear(); Gg.clear(); Bg.clear(); |
||||
t1.clear(); t2.clear(); t3.clear(); |
||||
tmp1.clear(); tmp2.clear(); tmp3.clear(); |
||||
} |
||||
|
||||
void Decolor::grad_system(Mat img, vector < vector < double > > &polyGrad, |
||||
vector < double > &Cg, vector < vector <int> >& comb) |
||||
{ |
||||
int h = img.size().height; |
||||
int w = img.size().width; |
||||
|
||||
double sizefactor; |
||||
if((h + w) > 800) |
||||
{ |
||||
sizefactor = (double)800/(h+w); |
||||
resize(img,img,Size(round_num(h*sizefactor),round_num(w*sizefactor))); |
||||
} |
||||
|
||||
h = img.size().height; |
||||
w = img.size().width; |
||||
colorGrad(img,Cg); |
||||
|
||||
Mat curIm = Mat(img.size(),CV_32FC1); |
||||
vector <Mat> rgb_channel; |
||||
split(img,rgb_channel); |
||||
|
||||
for(int r=0 ;r <=order; r++) |
||||
for(int g=0; g<=order;g++) |
||||
for(int b =0; b <=order;b++) |
||||
{ |
||||
if((r+g+b)<=order && (r+g+b) > 0) |
||||
{ |
||||
add_vector(comb,r,g,b); |
||||
for(int i = 0;i<h;i++) |
||||
for(int j=0;j<w;j++) |
||||
curIm.at<float>(i,j)= |
||||
pow(rgb_channel[2].at<float>(i,j),r)*pow(rgb_channel[1].at<float>(i,j),g)* |
||||
pow(rgb_channel[0].at<float>(i,j),b); |
||||
vector <double> curGrad; |
||||
gradvector(curIm,curGrad); |
||||
add_to_vector_poly(polyGrad,curGrad); |
||||
} |
||||
} |
||||
} |
||||
|
||||
void Decolor::wei_update_matrix(vector < vector <double> > &poly, vector <double> &Cg, Mat &X) |
||||
{ |
||||
int size = static_cast<int>(poly.size()), size0 = static_cast<int>(poly[0].size()); |
||||
Mat P = Mat(size, size0, CV_32FC1); |
||||
Mat A = Mat(size, size, CV_32FC1); |
||||
|
||||
for (int i = 0; i < size; i++) |
||||
for (int j = 0; j < size0;j++) |
||||
P.at<float>(i,j) = (float) poly[i][j]; |
||||
|
||||
Mat P_trans = P.t(); |
||||
Mat B = Mat(size, size0, CV_32FC1); |
||||
for(int i =0;i < size;i++) |
||||
{ |
||||
for(int j = 0, end = (int)Cg.size(); j < end;j++) |
||||
B.at<float>(i,j) = (float) (poly[i][j] * Cg[j]); |
||||
} |
||||
|
||||
A = P*P_trans; |
||||
solve(A, B, X, DECOMP_NORMAL); |
||||
|
||||
} |
||||
|
||||
void Decolor::wei_inti(vector < vector <int> > &comb, vector <double> &wei) |
||||
{ |
||||
vector <double> initRGB; |
||||
|
||||
initRGB.push_back( .33 ); |
||||
initRGB.push_back( .33 ); |
||||
initRGB.push_back( .33 ); |
||||
wei = product(comb,initRGB); |
||||
|
||||
vector <int> sum; |
||||
|
||||
for(unsigned int i=0;i<comb.size();i++) |
||||
sum.push_back(comb[i][0] + comb[i][1] + comb[i][2]); |
||||
|
||||
for(unsigned int i=0;i<sum.size();i++) |
||||
{ |
||||
if(sum[i] == 1) |
||||
wei[i] = wei[i] * double(1); |
||||
else |
||||
wei[i] = wei[i] * double(0); |
||||
} |
||||
|
||||
initRGB.clear(); |
||||
sum.clear(); |
||||
|
||||
} |
||||
|
||||
void Decolor::grayImContruct(vector <double> &wei, Mat img, Mat &Gray) |
||||
{ |
||||
int h=img.size().height; |
||||
int w=img.size().width; |
||||
|
||||
vector <Mat> rgb_channel; |
||||
split(img,rgb_channel); |
||||
|
||||
int kk =0; |
||||
|
||||
for(int r =0;r<=order;r++) |
||||
for(int g=0;g<=order;g++) |
||||
for(int b=0;b<=order;b++) |
||||
if((r + g + b) <=order && (r+g+b) > 0) |
||||
{ |
||||
for(int i = 0;i<h;i++) |
||||
for(int j=0;j<w;j++) |
||||
Gray.at<float>(i,j)=Gray.at<float>(i,j) + |
||||
(float) wei[kk]*pow(rgb_channel[2].at<float>(i,j),r)*pow(rgb_channel[1].at<float>(i,j),g)* |
||||
pow(rgb_channel[0].at<float>(i,j),b); |
||||
|
||||
kk=kk+1; |
||||
} |
||||
|
||||
float minval = FLT_MAX; |
||||
float maxval = -FLT_MAX; |
||||
|
||||
for(int i=0;i<h;i++) |
||||
for(int j =0;j<w;j++) |
||||
{ |
||||
if(Gray.at<float>(i,j) < minval) |
||||
minval = Gray.at<float>(i,j); |
||||
|
||||
if(Gray.at<float>(i,j) > maxval) |
||||
maxval = Gray.at<float>(i,j); |
||||
} |
||||
|
||||
Gray -= minval; |
||||
Gray /= maxval - minval; |
||||
} |
||||
@ -0,0 +1,173 @@ |
||||
/*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) 2013, OpenCV Foundation, 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 "precomp.hpp" |
||||
#include "opencv2/photo.hpp" |
||||
#include <iostream> |
||||
#include <stdlib.h> |
||||
|
||||
#include "npr.hpp" |
||||
|
||||
using namespace std; |
||||
using namespace cv; |
||||
|
||||
void cv::edgePreservingFilter(InputArray _src, OutputArray _dst, int flags, float sigma_s, float sigma_r) |
||||
{ |
||||
Mat I = _src.getMat(); |
||||
_dst.create(I.size(), CV_8UC3); |
||||
Mat dst = _dst.getMat(); |
||||
|
||||
int h = I.size().height; |
||||
int w = I.size().width; |
||||
|
||||
Mat res = Mat(h,w,CV_32FC3); |
||||
dst.convertTo(res,CV_32FC3,1.0/255.0); |
||||
|
||||
Domain_Filter obj; |
||||
|
||||
Mat img = Mat(I.size(),CV_32FC3); |
||||
I.convertTo(img,CV_32FC3,1.0/255.0); |
||||
|
||||
obj.filter(img, res, sigma_s, sigma_r, flags); |
||||
|
||||
convertScaleAbs(res, dst, 255,0); |
||||
} |
||||
|
||||
void cv::detailEnhance(InputArray _src, OutputArray _dst, float sigma_s, float sigma_r) |
||||
{ |
||||
Mat I = _src.getMat(); |
||||
_dst.create(I.size(), CV_8UC3); |
||||
Mat dst = _dst.getMat(); |
||||
|
||||
int h = I.size().height; |
||||
int w = I.size().width; |
||||
float factor = 3.0f; |
||||
|
||||
Mat img = Mat(I.size(),CV_32FC3); |
||||
I.convertTo(img,CV_32FC3,1.0/255.0); |
||||
|
||||
Mat res = Mat(h,w,CV_32FC1); |
||||
dst.convertTo(res,CV_32FC3,1.0/255.0); |
||||
|
||||
Mat result = Mat(img.size(),CV_32FC3); |
||||
Mat lab = Mat(img.size(),CV_32FC3); |
||||
vector <Mat> lab_channel; |
||||
|
||||
cvtColor(img,lab,COLOR_BGR2Lab); |
||||
split(lab,lab_channel); |
||||
|
||||
Mat L = Mat(img.size(),CV_32FC1); |
||||
|
||||
lab_channel[0].convertTo(L,CV_32FC1,1.0/255.0); |
||||
|
||||
Domain_Filter obj; |
||||
|
||||
obj.filter(L, res, sigma_s, sigma_r, 1); |
||||
|
||||
Mat detail = Mat(h,w,CV_32FC1); |
||||
|
||||
detail = L - res; |
||||
multiply(detail,factor,detail); |
||||
L = res + detail; |
||||
|
||||
L.convertTo(lab_channel[0],CV_32FC1,255); |
||||
|
||||
merge(lab_channel,lab); |
||||
|
||||
cvtColor(lab,result,COLOR_Lab2BGR); |
||||
result.convertTo(dst,CV_8UC3,255); |
||||
} |
||||
|
||||
void cv::pencilSketch(InputArray _src, OutputArray _dst1, OutputArray _dst2, float sigma_s, float sigma_r, float shade_factor) |
||||
{ |
||||
Mat I = _src.getMat(); |
||||
_dst1.create(I.size(), CV_8UC1); |
||||
Mat dst1 = _dst1.getMat(); |
||||
|
||||
_dst2.create(I.size(), CV_8UC3); |
||||
Mat dst2 = _dst2.getMat(); |
||||
|
||||
Mat img = Mat(I.size(),CV_32FC3); |
||||
I.convertTo(img,CV_32FC3,1.0/255.0); |
||||
|
||||
Domain_Filter obj; |
||||
|
||||
Mat sketch = Mat(I.size(),CV_32FC1); |
||||
Mat color_sketch = Mat(I.size(),CV_32FC3); |
||||
|
||||
obj.pencil_sketch(img, sketch, color_sketch, sigma_s, sigma_r, shade_factor); |
||||
|
||||
sketch.convertTo(dst1,CV_8UC1,255); |
||||
color_sketch.convertTo(dst2,CV_8UC3,255); |
||||
|
||||
} |
||||
|
||||
void cv::stylization(InputArray _src, OutputArray _dst, float sigma_s, float sigma_r) |
||||
{ |
||||
Mat I = _src.getMat(); |
||||
_dst.create(I.size(), CV_8UC3); |
||||
Mat dst = _dst.getMat(); |
||||
|
||||
Mat img = Mat(I.size(),CV_32FC3); |
||||
I.convertTo(img,CV_32FC3,1.0/255.0); |
||||
|
||||
int h = img.size().height; |
||||
int w = img.size().width; |
||||
|
||||
Mat res = Mat(h,w,CV_32FC3); |
||||
Mat magnitude = Mat(h,w,CV_32FC1); |
||||
|
||||
Domain_Filter obj; |
||||
obj.filter(img, res, sigma_s, sigma_r, NORMCONV_FILTER); |
||||
|
||||
obj.find_magnitude(res,magnitude); |
||||
|
||||
Mat stylized = Mat(h,w,CV_32FC3); |
||||
|
||||
vector <Mat> temp; |
||||
split(res,temp); |
||||
multiply(temp[0],magnitude,temp[0]); |
||||
multiply(temp[1],magnitude,temp[1]); |
||||
multiply(temp[2],magnitude,temp[2]); |
||||
merge(temp,stylized); |
||||
|
||||
stylized.convertTo(dst,CV_8UC3,255); |
||||
} |
||||
@ -0,0 +1,582 @@ |
||||
/*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) 2013, OpenCV Foundation, 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 "precomp.hpp" |
||||
#include "opencv2/photo.hpp" |
||||
#include <iostream> |
||||
#include <stdlib.h> |
||||
#include <limits> |
||||
#include "math.h" |
||||
|
||||
|
||||
using namespace std; |
||||
using namespace cv; |
||||
|
||||
double myinf = std::numeric_limits<double>::infinity(); |
||||
|
||||
class Domain_Filter |
||||
{ |
||||
public: |
||||
Mat ct_H, ct_V, horiz, vert, O, O_t, lower_idx, upper_idx; |
||||
void init(const Mat &img, int flags, float sigma_s, float sigma_r); |
||||
void getGradientx( const Mat &img, Mat &gx); |
||||
void getGradienty( const Mat &img, Mat &gy); |
||||
void diffx(const Mat &img, Mat &temp); |
||||
void diffy(const Mat &img, Mat &temp); |
||||
void find_magnitude(Mat &img, Mat &mag); |
||||
void compute_boxfilter(Mat &output, Mat &hz, Mat &psketch, float radius); |
||||
void compute_Rfilter(Mat &O, Mat &horiz, float sigma_h); |
||||
void compute_NCfilter(Mat &O, Mat &horiz, Mat &psketch, float radius); |
||||
void filter(const Mat &img, Mat &res, float sigma_s, float sigma_r, int flags); |
||||
void pencil_sketch(const Mat &img, Mat &sketch, Mat &color_res, float sigma_s, float sigma_r, float shade_factor); |
||||
void Depth_of_field(const Mat &img, Mat &img1, float sigma_s, float sigma_r); |
||||
}; |
||||
|
||||
void Domain_Filter::diffx(const Mat &img, Mat &temp) |
||||
{ |
||||
int channel = img.channels(); |
||||
|
||||
for(int i = 0; i < img.size().height; i++) |
||||
for(int j = 0; j < img.size().width-1; j++) |
||||
{ |
||||
for(int c =0; c < channel; c++) |
||||
{ |
||||
temp.at<float>(i,j*channel+c) = |
||||
img.at<float>(i,(j+1)*channel+c) - img.at<float>(i,j*channel+c); |
||||
} |
||||
} |
||||
} |
||||
|
||||
void Domain_Filter::diffy(const Mat &img, Mat &temp) |
||||
{ |
||||
int channel = img.channels(); |
||||
|
||||
for(int i = 0; i < img.size().height-1; i++) |
||||
for(int j = 0; j < img.size().width; j++) |
||||
{ |
||||
for(int c =0; c < channel; c++) |
||||
{ |
||||
temp.at<float>(i,j*channel+c) = |
||||
img.at<float>((i+1),j*channel+c) - img.at<float>(i,j*channel+c); |
||||
} |
||||
} |
||||
} |
||||
|
||||
void Domain_Filter::getGradientx( const Mat &img, Mat &gx) |
||||
{ |
||||
int w = img.cols; |
||||
int h = img.rows; |
||||
int channel = img.channels(); |
||||
|
||||
for(int i=0;i<h;i++) |
||||
for(int j=0;j<w;j++) |
||||
for(int c=0;c<channel;++c) |
||||
{ |
||||
gx.at<float>(i,j*channel+c) = |
||||
img.at<float>(i,(j+1)*channel+c) - img.at<float>(i,j*channel+c); |
||||
} |
||||
} |
||||
|
||||
void Domain_Filter::getGradienty( const Mat &img, Mat &gy) |
||||
{ |
||||
int w = img.cols; |
||||
int h = img.rows; |
||||
int channel = img.channels(); |
||||
|
||||
for(int i=0;i<h;i++) |
||||
for(int j=0;j<w;j++) |
||||
for(int c=0;c<channel;++c) |
||||
{ |
||||
gy.at<float>(i,j*channel+c) = |
||||
img.at<float>(i+1,j*channel+c) - img.at<float>(i,j*channel+c); |
||||
|
||||
} |
||||
} |
||||
|
||||
void Domain_Filter::find_magnitude(Mat &img, Mat &mag) |
||||
{ |
||||
int h = img.rows; |
||||
int w = img.cols; |
||||
|
||||
vector <Mat> planes; |
||||
split(img, planes); |
||||
|
||||
Mat magXR = Mat(h, w, CV_32FC1); |
||||
Mat magYR = Mat(h, w, CV_32FC1); |
||||
|
||||
Mat magXG = Mat(h, w, CV_32FC1); |
||||
Mat magYG = Mat(h, w, CV_32FC1); |
||||
|
||||
Mat magXB = Mat(h, w, CV_32FC1); |
||||
Mat magYB = Mat(h, w, CV_32FC1); |
||||
|
||||
Sobel(planes[0], magXR, CV_32FC1, 1, 0, 3); |
||||
Sobel(planes[0], magYR, CV_32FC1, 0, 1, 3); |
||||
|
||||
Sobel(planes[1], magXG, CV_32FC1, 1, 0, 3); |
||||
Sobel(planes[1], magYG, CV_32FC1, 0, 1, 3); |
||||
|
||||
Sobel(planes[2], magXB, CV_32FC1, 1, 0, 3); |
||||
Sobel(planes[2], magYB, CV_32FC1, 0, 1, 3); |
||||
|
||||
Mat mag1 = Mat(h,w,CV_32FC1); |
||||
Mat mag2 = Mat(h,w,CV_32FC1); |
||||
Mat mag3 = Mat(h,w,CV_32FC1); |
||||
|
||||
magnitude(magXR,magYR,mag1); |
||||
magnitude(magXG,magYG,mag2); |
||||
magnitude(magXB,magYB,mag3); |
||||
|
||||
mag = mag1 + mag2 + mag3; |
||||
mag = 1.0f - mag; |
||||
} |
||||
|
||||
void Domain_Filter::compute_Rfilter(Mat &output, Mat &hz, float sigma_h) |
||||
{ |
||||
int h = output.rows; |
||||
int w = output.cols; |
||||
|
||||
float a = (float) exp((-1.0 * sqrt(2.0)) / sigma_h); |
||||
|
||||
Mat temp = Mat(h,w,CV_32FC3); |
||||
|
||||
output.copyTo(temp); |
||||
Mat V = Mat(h,w,CV_32FC1); |
||||
|
||||
for(int i=0;i<h;i++) |
||||
for(int j=0;j<w;j++) |
||||
V.at<float>(i,j) = pow(a,hz.at<float>(i,j)); |
||||
|
||||
for(int i=0; i<h; i++) |
||||
{ |
||||
for(int j =1; j < w; j++) |
||||
{ |
||||
temp.at<float>(i,j) = temp.at<float>(i,j) + (temp.at<float>(i,j-1) - temp.at<float>(i,j)) * V.at<float>(i,j); |
||||
} |
||||
} |
||||
|
||||
for(int i=0; i<h; i++) |
||||
{ |
||||
for(int j =w-2; j >= 0; j--) |
||||
{ |
||||
temp.at<float>(i,j) = temp.at<float>(i,j) + (temp.at<float>(i,j+1) - temp.at<float>(i,j)) * V.at<float>(i,j+1); |
||||
} |
||||
} |
||||
|
||||
temp.copyTo(output); |
||||
} |
||||
|
||||
void Domain_Filter::compute_boxfilter(Mat &output, Mat &hz, Mat &psketch, float radius) |
||||
{ |
||||
int h = output.rows; |
||||
int w = output.cols; |
||||
Mat lower_pos = Mat(h,w,CV_32FC1); |
||||
Mat upper_pos = Mat(h,w,CV_32FC1); |
||||
|
||||
lower_pos = hz - radius; |
||||
upper_pos = hz + radius; |
||||
|
||||
lower_idx = Mat::zeros(h,w,CV_32FC1); |
||||
upper_idx = Mat::zeros(h,w,CV_32FC1); |
||||
|
||||
Mat domain_row = Mat::zeros(1,w+1,CV_32FC1); |
||||
|
||||
for(int i=0;i<h;i++) |
||||
{ |
||||
for(int j=0;j<w;j++) |
||||
domain_row.at<float>(0,j) = hz.at<float>(i,j); |
||||
domain_row.at<float>(0,w) = (float) myinf; |
||||
|
||||
Mat lower_pos_row = Mat::zeros(1,w,CV_32FC1); |
||||
Mat upper_pos_row = Mat::zeros(1,w,CV_32FC1); |
||||
|
||||
for(int j=0;j<w;j++) |
||||
{ |
||||
lower_pos_row.at<float>(0,j) = lower_pos.at<float>(i,j); |
||||
upper_pos_row.at<float>(0,j) = upper_pos.at<float>(i,j); |
||||
} |
||||
|
||||
Mat temp_lower_idx = Mat::zeros(1,w,CV_32FC1); |
||||
Mat temp_upper_idx = Mat::zeros(1,w,CV_32FC1); |
||||
|
||||
for(int j=0;j<w;j++) |
||||
{ |
||||
if(domain_row.at<float>(0,j) > lower_pos_row.at<float>(0,0)) |
||||
{ |
||||
temp_lower_idx.at<float>(0,0) = (float) j; |
||||
break; |
||||
} |
||||
} |
||||
for(int j=0;j<w;j++) |
||||
{ |
||||
if(domain_row.at<float>(0,j) > upper_pos_row.at<float>(0,0)) |
||||
{ |
||||
temp_upper_idx.at<float>(0,0) = (float) j; |
||||
break; |
||||
} |
||||
} |
||||
|
||||
int temp = 0; |
||||
for(int j=1;j<w;j++) |
||||
{ |
||||
int count=0; |
||||
for(int k=(int) temp_lower_idx.at<float>(0,j-1);k<w+1;k++) |
||||
{ |
||||
if(domain_row.at<float>(0,k) > lower_pos_row.at<float>(0,j)) |
||||
{ |
||||
temp = count; |
||||
break; |
||||
} |
||||
count++; |
||||
} |
||||
|
||||
temp_lower_idx.at<float>(0,j) = temp_lower_idx.at<float>(0,j-1) + temp; |
||||
|
||||
count = 0; |
||||
for(int k=(int) temp_upper_idx.at<float>(0,j-1);k<w+1;k++) |
||||
{ |
||||
|
||||
|
||||
if(domain_row.at<float>(0,k) > upper_pos_row.at<float>(0,j)) |
||||
{ |
||||
temp = count; |
||||
break; |
||||
} |
||||
count++; |
||||
} |
||||
|
||||
temp_upper_idx.at<float>(0,j) = temp_upper_idx.at<float>(0,j-1) + temp; |
||||
} |
||||
|
||||
for(int j=0;j<w;j++) |
||||
{ |
||||
lower_idx.at<float>(i,j) = temp_lower_idx.at<float>(0,j) + 1; |
||||
upper_idx.at<float>(i,j) = temp_upper_idx.at<float>(0,j) + 1; |
||||
} |
||||
|
||||
} |
||||
psketch = upper_idx - lower_idx; |
||||
} |
||||
void Domain_Filter::compute_NCfilter(Mat &output, Mat &hz, Mat &psketch, float radius) |
||||
{ |
||||
int h = output.rows; |
||||
int w = output.cols; |
||||
int channel = output.channels(); |
||||
|
||||
compute_boxfilter(output,hz,psketch,radius); |
||||
|
||||
Mat box_filter = Mat::zeros(h,w+1,CV_32FC3); |
||||
|
||||
for(int i = 0; i < h; i++) |
||||
{ |
||||
box_filter.at<float>(i,1*channel+0) = output.at<float>(i,0*channel+0); |
||||
box_filter.at<float>(i,1*channel+1) = output.at<float>(i,0*channel+1); |
||||
box_filter.at<float>(i,1*channel+2) = output.at<float>(i,0*channel+2); |
||||
for(int j = 2; j < w+1; j++) |
||||
{ |
||||
for(int c=0;c<channel;c++) |
||||
box_filter.at<float>(i,j*channel+c) = output.at<float>(i,(j-1)*channel+c) + box_filter.at<float>(i,(j-1)*channel+c); |
||||
} |
||||
} |
||||
|
||||
Mat indices = Mat::zeros(h,w,CV_32FC1); |
||||
Mat final = Mat::zeros(h,w,CV_32FC3); |
||||
|
||||
for(int i=0;i<h;i++) |
||||
for(int j=0;j<w;j++) |
||||
indices.at<float>(i,j) = (float) i+1; |
||||
|
||||
Mat a = Mat::zeros(h,w,CV_32FC1); |
||||
Mat b = Mat::zeros(h,w,CV_32FC1); |
||||
|
||||
// Compute the box filter using a summed area table.
|
||||
for(int c=0;c<channel;c++) |
||||
{ |
||||
Mat flag = Mat::ones(h,w,CV_32FC1); |
||||
multiply(flag,c+1,flag); |
||||
|
||||
Mat temp1, temp2; |
||||
multiply(flag - 1,h*(w+1),temp1); |
||||
multiply(lower_idx - 1,h,temp2); |
||||
a = temp1 + temp2 + indices; |
||||
|
||||
multiply(flag - 1,h*(w+1),temp1); |
||||
multiply(upper_idx - 1,h,temp2); |
||||
b = temp1 + temp2 + indices; |
||||
|
||||
int p,q,r,rem; |
||||
int p1,q1,r1,rem1; |
||||
|
||||
// Calculating indices
|
||||
for(int i=0;i<h;i++) |
||||
{ |
||||
for(int j=0;j<w;j++) |
||||
{ |
||||
|
||||
r = (int) b.at<float>(i,j)/(h*(w+1)); |
||||
rem = (int) b.at<float>(i,j) - r*h*(w+1); |
||||
q = rem/h; |
||||
p = rem - q*h; |
||||
if(q==0) |
||||
{ |
||||
p=h; |
||||
q=w; |
||||
r=r-1; |
||||
} |
||||
if(p==0) |
||||
{ |
||||
p=h; |
||||
q=q-1; |
||||
} |
||||
|
||||
r1 = (int) a.at<float>(i,j)/(h*(w+1)); |
||||
rem1 = (int) a.at<float>(i,j) - r1*h*(w+1); |
||||
q1 = rem1/h; |
||||
p1 = rem1 - q1*h; |
||||
if(p1==0) |
||||
{ |
||||
p1=h; |
||||
q1=q1-1; |
||||
} |
||||
|
||||
final.at<float>(i,j*channel+2-c) = (box_filter.at<float>(p-1,q*channel+(2-r)) - box_filter.at<float>(p1-1,q1*channel+(2-r1))) |
||||
/(upper_idx.at<float>(i,j) - lower_idx.at<float>(i,j)); |
||||
} |
||||
} |
||||
} |
||||
|
||||
final.copyTo(output); |
||||
} |
||||
void Domain_Filter::init(const Mat &img, int flags, float sigma_s, float sigma_r) |
||||
{ |
||||
int h = img.size().height; |
||||
int w = img.size().width; |
||||
int channel = img.channels(); |
||||
|
||||
//////////////////////////////////// horizontal and vertical partial derivatives /////////////////////////////////
|
||||
|
||||
Mat derivx = Mat::zeros(h,w-1,CV_32FC3); |
||||
Mat derivy = Mat::zeros(h-1,w,CV_32FC3); |
||||
|
||||
diffx(img,derivx); |
||||
diffy(img,derivy); |
||||
|
||||
Mat distx = Mat::zeros(h,w,CV_32FC1); |
||||
Mat disty = Mat::zeros(h,w,CV_32FC1); |
||||
|
||||
//////////////////////// Compute the l1-norm distance of neighbor pixels ////////////////////////////////////////////////
|
||||
|
||||
for(int i = 0; i < h; i++) |
||||
for(int j = 0,k=1; j < w-1; j++,k++) |
||||
for(int c = 0; c < channel; c++) |
||||
{ |
||||
distx.at<float>(i,k) = |
||||
distx.at<float>(i,k) + abs(derivx.at<float>(i,j*channel+c)); |
||||
} |
||||
|
||||
for(int i = 0,k=1; i < h-1; i++,k++) |
||||
for(int j = 0; j < w; j++) |
||||
for(int c = 0; c < channel; c++) |
||||
{ |
||||
disty.at<float>(k,j) = |
||||
disty.at<float>(k,j) + abs(derivy.at<float>(i,j*channel+c)); |
||||
} |
||||
|
||||
////////////////////// Compute the derivatives of the horizontal and vertical domain transforms. /////////////////////////////
|
||||
|
||||
horiz = Mat(h,w,CV_32FC1); |
||||
vert = Mat(h,w,CV_32FC1); |
||||
|
||||
Mat final = Mat(h,w,CV_32FC3); |
||||
|
||||
Mat tempx,tempy; |
||||
multiply(distx,sigma_s/sigma_r,tempx); |
||||
multiply(disty,sigma_s/sigma_r,tempy); |
||||
|
||||
horiz = 1.0f + tempx; |
||||
vert = 1.0f + tempy; |
||||
|
||||
O = Mat(h,w,CV_32FC3); |
||||
img.copyTo(O); |
||||
|
||||
O_t = Mat(w,h,CV_32FC3); |
||||
|
||||
if(flags == 2) |
||||
{ |
||||
|
||||
ct_H = Mat(h,w,CV_32FC1); |
||||
ct_V = Mat(h,w,CV_32FC1); |
||||
|
||||
for(int i = 0; i < h; i++) |
||||
{ |
||||
ct_H.at<float>(i,0) = horiz.at<float>(i,0); |
||||
for(int j = 1; j < w; j++) |
||||
{ |
||||
ct_H.at<float>(i,j) = horiz.at<float>(i,j) + ct_H.at<float>(i,j-1); |
||||
} |
||||
} |
||||
|
||||
for(int j = 0; j < w; j++) |
||||
{ |
||||
ct_V.at<float>(0,j) = vert.at<float>(0,j); |
||||
for(int i = 1; i < h; i++) |
||||
{ |
||||
ct_V.at<float>(i,j) = vert.at<float>(i,j) + ct_V.at<float>(i-1,j); |
||||
} |
||||
} |
||||
} |
||||
|
||||
} |
||||
|
||||
void Domain_Filter::filter(const Mat &img, Mat &res, float sigma_s = 60, float sigma_r = 0.4, int flags = 1) |
||||
{ |
||||
int no_of_iter = 3; |
||||
int h = img.size().height; |
||||
int w = img.size().width; |
||||
float sigma_h = sigma_s; |
||||
|
||||
init(img,flags,sigma_s,sigma_r); |
||||
|
||||
if(flags == 1) |
||||
{ |
||||
Mat vert_t = vert.t(); |
||||
|
||||
for(int i=0;i<no_of_iter;i++) |
||||
{ |
||||
sigma_h = (float) (sigma_s * sqrt(3.0) * pow(2.0,(no_of_iter - (i+1))) / sqrt(pow(4.0,no_of_iter) -1)); |
||||
|
||||
compute_Rfilter(O, horiz, sigma_h); |
||||
|
||||
O_t = O.t(); |
||||
|
||||
compute_Rfilter(O_t, vert_t, sigma_h); |
||||
|
||||
O = O_t.t(); |
||||
|
||||
} |
||||
} |
||||
else if(flags == 2) |
||||
{ |
||||
|
||||
Mat vert_t = ct_V.t(); |
||||
Mat temp = Mat(h,w,CV_32FC1); |
||||
Mat temp1 = Mat(w,h,CV_32FC1); |
||||
|
||||
float radius; |
||||
|
||||
for(int i=0;i<no_of_iter;i++) |
||||
{ |
||||
sigma_h = (float) (sigma_s * sqrt(3.0) * pow(2.0,(no_of_iter - (i+1))) / sqrt(pow(4.0,no_of_iter) -1)); |
||||
|
||||
radius = (float) sqrt(3.0) * sigma_h; |
||||
|
||||
compute_NCfilter(O, ct_H, temp,radius); |
||||
|
||||
O_t = O.t(); |
||||
|
||||
compute_NCfilter(O_t, vert_t, temp1, radius); |
||||
|
||||
O = O_t.t(); |
||||
} |
||||
} |
||||
|
||||
res = O.clone(); |
||||
} |
||||
|
||||
void Domain_Filter::pencil_sketch(const Mat &img, Mat &sketch, Mat &color_res, float sigma_s, float sigma_r, float shade_factor) |
||||
{ |
||||
|
||||
int no_of_iter = 3; |
||||
init(img,2,sigma_s,sigma_r); |
||||
int h = img.size().height; |
||||
int w = img.size().width; |
||||
|
||||
/////////////////////// convert to YCBCR model for color pencil drawing //////////////////////////////////////////////////////
|
||||
|
||||
Mat color_sketch = Mat(h,w,CV_32FC3); |
||||
|
||||
cvtColor(img,color_sketch,COLOR_BGR2YCrCb); |
||||
|
||||
vector <Mat> YUV_channel; |
||||
Mat vert_t = ct_V.t(); |
||||
|
||||
float sigma_h = sigma_s; |
||||
|
||||
Mat penx = Mat(h,w,CV_32FC1); |
||||
|
||||
Mat pen_res = Mat::zeros(h,w,CV_32FC1); |
||||
Mat peny = Mat(w,h,CV_32FC1); |
||||
|
||||
Mat peny_t; |
||||
|
||||
float radius; |
||||
|
||||
for(int i=0;i<no_of_iter;i++) |
||||
{ |
||||
sigma_h = (float) (sigma_s * sqrt(3.0) * pow(2.0,(no_of_iter - (i+1))) / sqrt(pow(4.0,no_of_iter) -1)); |
||||
|
||||
radius = (float) sqrt(3.0) * sigma_h; |
||||
|
||||
compute_boxfilter(O, ct_H, penx, radius); |
||||
|
||||
O_t = O.t(); |
||||
|
||||
compute_boxfilter(O_t, vert_t, peny, radius); |
||||
|
||||
O = O_t.t(); |
||||
|
||||
peny_t = peny.t(); |
||||
|
||||
for(int k=0;k<h;k++) |
||||
for(int j=0;j<w;j++) |
||||
pen_res.at<float>(k,j) = (shade_factor * (penx.at<float>(k,j) + peny_t.at<float>(k,j))); |
||||
|
||||
if(i==0) |
||||
{ |
||||
sketch = pen_res.clone(); |
||||
split(color_sketch,YUV_channel); |
||||
pen_res.copyTo(YUV_channel[0]); |
||||
merge(YUV_channel,color_sketch); |
||||
cvtColor(color_sketch,color_res,COLOR_YCrCb2BGR); |
||||
} |
||||
|
||||
} |
||||
} |
||||
@ -0,0 +1,193 @@ |
||||
/*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) 2013, OpenCV Foundation, 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 "precomp.hpp" |
||||
#include "opencv2/photo.hpp" |
||||
#include <iostream> |
||||
#include <stdlib.h> |
||||
|
||||
#include "seamless_cloning.hpp" |
||||
|
||||
using namespace std; |
||||
using namespace cv; |
||||
|
||||
void cv::seamlessClone(InputArray _src, InputArray _dst, InputArray _mask, Point p, OutputArray _blend, int flags) |
||||
{ |
||||
Mat src = _src.getMat(); |
||||
Mat dest = _dst.getMat(); |
||||
Mat mask = _mask.getMat(); |
||||
_blend.create(dest.size(), CV_8UC3); |
||||
Mat blend = _blend.getMat(); |
||||
|
||||
int minx = INT_MAX, miny = INT_MAX, maxx = INT_MIN, maxy = INT_MIN; |
||||
int h = mask.size().height; |
||||
int w = mask.size().width; |
||||
|
||||
Mat gray = Mat(mask.size(),CV_8UC1); |
||||
Mat dst_mask = Mat::zeros(dest.size(),CV_8UC1); |
||||
Mat cs_mask = Mat::zeros(src.size(),CV_8UC3); |
||||
Mat cd_mask = Mat::zeros(dest.size(),CV_8UC3); |
||||
|
||||
if(mask.channels() == 3) |
||||
cvtColor(mask, gray, COLOR_BGR2GRAY ); |
||||
else |
||||
gray = mask; |
||||
|
||||
for(int i=0;i<h;i++) |
||||
{ |
||||
for(int j=0;j<w;j++) |
||||
{ |
||||
if(gray.at<uchar>(i,j) == 255) |
||||
{ |
||||
minx = std::min(minx,i); |
||||
maxx = std::max(maxx,i); |
||||
miny = std::min(miny,j); |
||||
maxy = std::max(maxy,j); |
||||
} |
||||
} |
||||
} |
||||
|
||||
int lenx = maxx - minx; |
||||
int leny = maxy - miny; |
||||
|
||||
int minxd = p.y - lenx/2; |
||||
int maxxd = p.y + lenx/2; |
||||
int minyd = p.x - leny/2; |
||||
int maxyd = p.x + leny/2; |
||||
|
||||
if(minxd < 0 || minyd < 0 || maxxd > dest.size().height || maxyd > dest.size().width) |
||||
{ |
||||
cout << "Index out of range" << endl; |
||||
exit(0); |
||||
} |
||||
|
||||
Rect roi_d(minyd,minxd,leny,lenx); |
||||
Rect roi_s(miny,minx,leny,lenx); |
||||
|
||||
Mat destinationROI = dst_mask(roi_d); |
||||
Mat sourceROI = cs_mask(roi_s); |
||||
|
||||
gray(roi_s).copyTo(destinationROI); |
||||
src(roi_s).copyTo(sourceROI,gray(roi_s)); |
||||
|
||||
destinationROI = cd_mask(roi_d); |
||||
cs_mask(roi_s).copyTo(destinationROI); |
||||
|
||||
Cloning obj; |
||||
obj.normal_clone(dest,cd_mask,dst_mask,blend,flags); |
||||
} |
||||
|
||||
void cv::colorChange(InputArray _src, InputArray _mask, OutputArray _dst, float r, float g, float b) |
||||
{ |
||||
Mat src = _src.getMat(); |
||||
Mat mask = _mask.getMat(); |
||||
_dst.create(src.size(), src.type()); |
||||
Mat blend = _dst.getMat(); |
||||
|
||||
float red = r; |
||||
float green = g; |
||||
float blue = b; |
||||
|
||||
Mat gray = Mat::zeros(mask.size(),CV_8UC1); |
||||
|
||||
if(mask.channels() == 3) |
||||
cvtColor(mask, gray, COLOR_BGR2GRAY ); |
||||
else |
||||
gray = mask; |
||||
|
||||
Mat cs_mask = Mat::zeros(src.size(),CV_8UC3); |
||||
|
||||
src.copyTo(cs_mask,gray); |
||||
|
||||
Cloning obj; |
||||
obj.local_color_change(src,cs_mask,gray,blend,red,green,blue); |
||||
} |
||||
|
||||
|
||||
void cv::illuminationChange(InputArray _src, InputArray _mask, OutputArray _dst, float a, float b) |
||||
{ |
||||
|
||||
Mat src = _src.getMat(); |
||||
Mat mask = _mask.getMat(); |
||||
_dst.create(src.size(), src.type()); |
||||
Mat blend = _dst.getMat(); |
||||
float alpha = a; |
||||
float beta = b; |
||||
|
||||
Mat gray = Mat::zeros(mask.size(),CV_8UC1); |
||||
|
||||
if(mask.channels() == 3) |
||||
cvtColor(mask, gray, COLOR_BGR2GRAY ); |
||||
else |
||||
gray = mask; |
||||
|
||||
Mat cs_mask = Mat::zeros(src.size(),CV_8UC3); |
||||
|
||||
src.copyTo(cs_mask,gray); |
||||
|
||||
Cloning obj; |
||||
obj.illum_change(src,cs_mask,gray,blend,alpha,beta); |
||||
|
||||
} |
||||
|
||||
void cv::textureFlattening(InputArray _src, InputArray _mask, OutputArray _dst, |
||||
double low_threshold, double high_threshold, int kernel_size) |
||||
{ |
||||
|
||||
Mat src = _src.getMat(); |
||||
Mat mask = _mask.getMat(); |
||||
_dst.create(src.size(), src.type()); |
||||
Mat blend = _dst.getMat(); |
||||
|
||||
Mat gray = Mat::zeros(mask.size(),CV_8UC1); |
||||
|
||||
if(mask.channels() == 3) |
||||
cvtColor(mask, gray, COLOR_BGR2GRAY ); |
||||
else |
||||
gray = mask; |
||||
|
||||
Mat cs_mask = Mat::zeros(src.size(),CV_8UC3); |
||||
|
||||
src.copyTo(cs_mask,gray); |
||||
|
||||
Cloning obj; |
||||
obj.texture_flatten(src,cs_mask,gray,low_threshold,high_threshold,kernel_size,blend); |
||||
} |
||||
@ -0,0 +1,594 @@ |
||||
/*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) 2013, OpenCV Foundation, 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 "precomp.hpp" |
||||
#include "opencv2/photo.hpp" |
||||
#include <iostream> |
||||
#include <stdlib.h> |
||||
#include <complex> |
||||
#include "math.h" |
||||
|
||||
using namespace std; |
||||
using namespace cv; |
||||
|
||||
class Cloning |
||||
{ |
||||
|
||||
public: |
||||
|
||||
vector <Mat> rgb_channel, rgbx_channel, rgby_channel, output; |
||||
Mat grx, gry, sgx, sgy, srx32, sry32, grx32, gry32, smask, smask1; |
||||
void init_var(Mat &I, Mat &wmask); |
||||
void initialization(Mat &I, Mat &mask, Mat &wmask); |
||||
void scalar_product(Mat mat, float r, float g, float b); |
||||
void array_product(Mat mat1, Mat mat2, Mat mat3); |
||||
void poisson(Mat &I, Mat &gx, Mat &gy, Mat &sx, Mat &sy); |
||||
void evaluate(Mat &I, Mat &wmask, Mat &cloned); |
||||
void getGradientx(const Mat &img, Mat &gx); |
||||
void getGradienty(const Mat &img, Mat &gy); |
||||
void lapx(const Mat &img, Mat &gxx); |
||||
void lapy(const Mat &img, Mat &gyy); |
||||
void dst(double *mod_diff, double *sineTransform,int h,int w); |
||||
void idst(double *mod_diff, double *sineTransform,int h,int w); |
||||
void transpose(double *mat, double *mat_t,int h,int w); |
||||
void solve(const Mat &img, double *mod_diff, Mat &result); |
||||
void poisson_solver(const Mat &img, Mat &gxx , Mat &gyy, Mat &result); |
||||
void normal_clone(Mat &I, Mat &mask, Mat &wmask, Mat &cloned, int num); |
||||
void local_color_change(Mat &I, Mat &mask, Mat &wmask, Mat &cloned, float red_mul, float green_mul, float blue_mul); |
||||
void illum_change(Mat &I, Mat &mask, Mat &wmask, Mat &cloned, float alpha, float beta); |
||||
void texture_flatten(Mat &I, Mat &mask, Mat &wmask, double low_threshold, double high_threhold, int kernel_size, Mat &cloned); |
||||
}; |
||||
|
||||
void Cloning::getGradientx( const Mat &img, Mat &gx) |
||||
{ |
||||
int w = img.size().width; |
||||
int h = img.size().height; |
||||
int channel = img.channels(); |
||||
for(int i=0;i<h;i++) |
||||
for(int j=0;j<w;j++) |
||||
for(int c=0;c<channel;++c) |
||||
{ |
||||
gx.at<float>(i,j*channel+c) = |
||||
(float)img.at<uchar>(i,(j+1)*channel+c) - (float)img.at<uchar>(i,j*channel+c); |
||||
} |
||||
|
||||
} |
||||
|
||||
void Cloning::getGradienty( const Mat &img, Mat &gy) |
||||
{ |
||||
int w = img.size().width; |
||||
int h = img.size().height; |
||||
int channel = img.channels(); |
||||
for(int i=0;i<h;i++) |
||||
for(int j=0;j<w;j++) |
||||
for(int c=0;c<channel;++c) |
||||
{ |
||||
gy.at<float>(i,j*channel+c) = |
||||
(float)img.at<uchar>((i+1),j*channel+c) - (float)img.at<uchar>(i,j*channel+c); |
||||
|
||||
} |
||||
} |
||||
|
||||
void Cloning::lapx( const Mat &img, Mat &gxx) |
||||
{ |
||||
int w = img.size().width; |
||||
int h = img.size().height; |
||||
int channel = img.channels(); |
||||
for(int i=0;i<h;i++) |
||||
for(int j=0;j<w-1;j++) |
||||
for(int c=0;c<channel;++c) |
||||
{ |
||||
gxx.at<float>(i,(j+1)*channel+c) = |
||||
(float)img.at<float>(i,(j+1)*channel+c) - (float)img.at<float>(i,j*channel+c); |
||||
} |
||||
} |
||||
|
||||
void Cloning::lapy( const Mat &img, Mat &gyy) |
||||
{ |
||||
int w = img.size().width; |
||||
int h = img.size().height; |
||||
int channel = img.channels(); |
||||
for(int i=0;i<h-1;i++) |
||||
for(int j=0;j<w;j++) |
||||
for(int c=0;c<channel;++c) |
||||
{ |
||||
gyy.at<float>(i+1,j*channel+c) = |
||||
(float)img.at<float>((i+1),j*channel+c) - (float)img.at<float>(i,j*channel+c); |
||||
|
||||
} |
||||
} |
||||
|
||||
void Cloning::dst(double *mod_diff, double *sineTransform,int h,int w) |
||||
{ |
||||
|
||||
unsigned long int idx; |
||||
|
||||
Mat temp = Mat(2*h+2,1,CV_32F); |
||||
Mat res = Mat(h,1,CV_32F); |
||||
|
||||
Mat planes[] = {Mat_<float>(temp), Mat::zeros(temp.size(), CV_32F)}; |
||||
|
||||
Mat result; |
||||
int p=0; |
||||
for(int i=0;i<w;i++) |
||||
{ |
||||
temp.at<float>(0,0) = 0.0; |
||||
|
||||
for(int j=0,r=1;j<h;j++,r++) |
||||
{ |
||||
idx = j*w+i; |
||||
temp.at<float>(r,0) = (float) mod_diff[idx]; |
||||
} |
||||
|
||||
temp.at<float>(h+1,0)=0.0; |
||||
|
||||
for(int j=h-1, r=h+2;j>=0;j--,r++) |
||||
{ |
||||
idx = j*w+i; |
||||
temp.at<float>(r,0) = (float) (-1.0 * mod_diff[idx]); |
||||
} |
||||
|
||||
merge(planes, 2, result); |
||||
|
||||
dft(result,result,0,0); |
||||
|
||||
Mat planes1[] = {Mat::zeros(result.size(), CV_32F), Mat::zeros(result.size(), CV_32F)}; |
||||
|
||||
split(result, planes1); |
||||
|
||||
std::complex<double> two_i = std::sqrt(std::complex<double>(-1)); |
||||
|
||||
double factor = -2*imag(two_i); |
||||
|
||||
for(int c=1,z=0;c<h+1;c++,z++) |
||||
{ |
||||
res.at<float>(z,0) = (float) (planes1[1].at<float>(c,0)/factor); |
||||
} |
||||
|
||||
for(int q=0,z=0;q<h;q++,z++) |
||||
{ |
||||
idx = q*w+p; |
||||
sineTransform[idx] = res.at<float>(z,0); |
||||
} |
||||
p++; |
||||
} |
||||
} |
||||
|
||||
void Cloning::idst(double *mod_diff, double *sineTransform,int h,int w) |
||||
{ |
||||
int nn = h+1; |
||||
unsigned long int idx; |
||||
dst(mod_diff,sineTransform,h,w); |
||||
for(int i= 0;i<h;i++) |
||||
for(int j=0;j<w;j++) |
||||
{ |
||||
idx = i*w + j; |
||||
sineTransform[idx] = (double) (2*sineTransform[idx])/nn; |
||||
} |
||||
|
||||
} |
||||
|
||||
void Cloning::transpose(double *mat, double *mat_t,int h,int w) |
||||
{ |
||||
|
||||
Mat tmp = Mat(h,w,CV_32FC1); |
||||
unsigned long int idx; |
||||
for(int i = 0 ; i < h;i++) |
||||
{ |
||||
for(int j = 0 ; j < w; j++) |
||||
{ |
||||
|
||||
idx = i*(w) + j; |
||||
tmp.at<float>(i,j) = (float) mat[idx]; |
||||
} |
||||
} |
||||
Mat tmp_t = tmp.t(); |
||||
|
||||
for(int i = 0;i < tmp_t.size().height; i++) |
||||
for(int j=0;j<tmp_t.size().width;j++) |
||||
{ |
||||
idx = i*tmp_t.size().width + j; |
||||
mat_t[idx] = tmp_t.at<float>(i,j); |
||||
} |
||||
} |
||||
|
||||
void Cloning::solve(const Mat &img, double *mod_diff, Mat &result) |
||||
{ |
||||
int w = img.size().width; |
||||
int h = img.size().height; |
||||
|
||||
unsigned long int idx,idx1; |
||||
|
||||
double *sineTransform = new double[(h-2)*(w-2)]; |
||||
double *sineTransform_t = new double[(h-2)*(w-2)]; |
||||
double *denom = new double[(h-2)*(w-2)]; |
||||
double *invsineTransform = new double[(h-2)*(w-2)]; |
||||
double *invsineTransform_t = new double[(h-2)*(w-2)]; |
||||
double *img_d = new double[(h)*(w)]; |
||||
|
||||
dst(mod_diff,sineTransform,h-2,w-2); |
||||
|
||||
transpose(sineTransform,sineTransform_t,h-2,w-2); |
||||
|
||||
dst(sineTransform_t,sineTransform,w-2,h-2); |
||||
|
||||
transpose(sineTransform,sineTransform_t,w-2,h-2); |
||||
|
||||
int cy = 1; |
||||
|
||||
for(int i = 0 ; i < w-2;i++,cy++) |
||||
{ |
||||
for(int j = 0,cx = 1; j < h-2; j++,cx++) |
||||
{ |
||||
idx = j*(w-2) + i; |
||||
denom[idx] = (float) 2*cos(CV_PI*cy/( (double) (w-1))) - 2 + 2*cos(CV_PI*cx/((double) (h-1))) - 2; |
||||
|
||||
} |
||||
} |
||||
|
||||
for(idx = 0 ; idx < (unsigned)(w-2)*(h-2) ;idx++) |
||||
{ |
||||
sineTransform_t[idx] = sineTransform_t[idx]/denom[idx]; |
||||
} |
||||
|
||||
idst(sineTransform_t,invsineTransform,h-2,w-2); |
||||
|
||||
transpose(invsineTransform,invsineTransform_t,h-2,w-2); |
||||
|
||||
idst(invsineTransform_t,invsineTransform,w-2,h-2); |
||||
|
||||
transpose(invsineTransform,invsineTransform_t,w-2,h-2); |
||||
|
||||
for(int i = 0 ; i < h;i++) |
||||
{ |
||||
for(int j = 0 ; j < w; j++) |
||||
{ |
||||
idx = i*w + j; |
||||
img_d[idx] = (double)img.at<uchar>(i,j); |
||||
} |
||||
} |
||||
for(int i = 1 ; i < h-1;i++) |
||||
{ |
||||
for(int j = 1 ; j < w-1; j++) |
||||
{ |
||||
idx = i*w + j; |
||||
img_d[idx] = 0.0; |
||||
} |
||||
} |
||||
for(int i = 1,id1=0 ; i < h-1;i++,id1++) |
||||
{ |
||||
for(int j = 1,id2=0 ; j < w-1; j++,id2++) |
||||
{ |
||||
idx = i*w + j; |
||||
idx1= id1*(w-2) + id2; |
||||
img_d[idx] = invsineTransform_t[idx1]; |
||||
} |
||||
} |
||||
|
||||
for(int i = 0 ; i < h;i++) |
||||
{ |
||||
for(int j = 0 ; j < w; j++) |
||||
{ |
||||
idx = i*w + j; |
||||
if(img_d[idx] < 0.0) |
||||
result.at<uchar>(i,j) = 0; |
||||
else if(img_d[idx] > 255.0) |
||||
result.at<uchar>(i,j) = 255; |
||||
else |
||||
result.at<uchar>(i,j) = (uchar) img_d[idx]; |
||||
} |
||||
} |
||||
|
||||
delete [] sineTransform; |
||||
delete [] sineTransform_t; |
||||
delete [] denom; |
||||
delete [] invsineTransform; |
||||
delete [] invsineTransform_t; |
||||
delete [] img_d; |
||||
} |
||||
|
||||
void Cloning::poisson_solver(const Mat &img, Mat &gxx , Mat &gyy, Mat &result) |
||||
{ |
||||
|
||||
int w = img.size().width; |
||||
int h = img.size().height; |
||||
|
||||
unsigned long int idx; |
||||
|
||||
Mat lap = Mat(img.size(),CV_32FC1); |
||||
|
||||
lap = gxx + gyy; |
||||
|
||||
Mat bound = img.clone(); |
||||
|
||||
rectangle(bound, Point(1, 1), Point(img.cols-2, img.rows-2), Scalar::all(0), -1); |
||||
|
||||
double *boundary_point = new double[h*w]; |
||||
|
||||
for(int i =1;i<h-1;i++) |
||||
for(int j=1;j<w-1;j++) |
||||
{ |
||||
idx=i*w + j; |
||||
boundary_point[idx] = -4*(int)bound.at<uchar>(i,j) + (int)bound.at<uchar>(i,(j+1)) + (int)bound.at<uchar>(i,(j-1)) |
||||
+ (int)bound.at<uchar>(i-1,j) + (int)bound.at<uchar>(i+1,j); |
||||
} |
||||
|
||||
Mat diff = Mat(h,w,CV_32FC1); |
||||
for(int i =0;i<h;i++) |
||||
{ |
||||
for(int j=0;j<w;j++) |
||||
{ |
||||
idx = i*w+j; |
||||
diff.at<float>(i,j) = (float) (lap.at<float>(i,j) - boundary_point[idx]); |
||||
} |
||||
} |
||||
|
||||
double *mod_diff = new double[(h-2)*(w-2)]; |
||||
for(int i = 0 ; i < h-2;i++) |
||||
{ |
||||
for(int j = 0 ; j < w-2; j++) |
||||
{ |
||||
idx = i*(w-2) + j; |
||||
mod_diff[idx] = diff.at<float>(i+1,j+1); |
||||
|
||||
} |
||||
} |
||||
///////////////////////////////////////////////////// Find DST /////////////////////////////////////////////////////
|
||||
|
||||
solve(img,mod_diff,result); |
||||
|
||||
delete [] mod_diff; |
||||
delete [] boundary_point; |
||||
} |
||||
|
||||
void Cloning::init_var(Mat &I, Mat &wmask) |
||||
{ |
||||
grx = Mat(I.size(),CV_32FC3); |
||||
gry = Mat(I.size(),CV_32FC3); |
||||
sgx = Mat(I.size(),CV_32FC3); |
||||
sgy = Mat(I.size(),CV_32FC3); |
||||
|
||||
split(I,rgb_channel); |
||||
|
||||
smask = Mat(wmask.size(),CV_32FC1); |
||||
srx32 = Mat(I.size(),CV_32FC3); |
||||
sry32 = Mat(I.size(),CV_32FC3); |
||||
smask1 = Mat(wmask.size(),CV_32FC1); |
||||
grx32 = Mat(I.size(),CV_32FC3); |
||||
gry32 = Mat(I.size(),CV_32FC3); |
||||
} |
||||
|
||||
void Cloning::initialization(Mat &I, Mat &mask, Mat &wmask) |
||||
{ |
||||
init_var(I,wmask); |
||||
|
||||
getGradientx(I,grx); |
||||
getGradienty(I,gry); |
||||
|
||||
getGradientx(mask,sgx); |
||||
getGradienty(mask,sgy); |
||||
|
||||
Mat Kernel(Size(3, 3), CV_8UC1); |
||||
Kernel.setTo(Scalar(1)); |
||||
|
||||
erode(wmask, wmask, Kernel, Point(-1,-1), 3); |
||||
|
||||
wmask.convertTo(smask,CV_32FC1,1.0/255.0); |
||||
I.convertTo(srx32,CV_32FC3,1.0/255.0); |
||||
I.convertTo(sry32,CV_32FC3,1.0/255.0); |
||||
} |
||||
|
||||
void Cloning::scalar_product(Mat mat, float r, float g, float b) |
||||
{ |
||||
vector <Mat> channels; |
||||
split(mat,channels); |
||||
multiply(channels[2],r,channels[2]); |
||||
multiply(channels[1],g,channels[1]); |
||||
multiply(channels[0],b,channels[0]); |
||||
merge(channels,mat); |
||||
} |
||||
|
||||
void Cloning::array_product(Mat mat1, Mat mat2, Mat mat3) |
||||
{ |
||||
vector <Mat> channels_temp1; |
||||
vector <Mat> channels_temp2; |
||||
split(mat1,channels_temp1); |
||||
split(mat2,channels_temp2); |
||||
multiply(channels_temp2[2],mat3,channels_temp1[2]); |
||||
multiply(channels_temp2[1],mat3,channels_temp1[1]); |
||||
multiply(channels_temp2[0],mat3,channels_temp1[0]); |
||||
merge(channels_temp1,mat1); |
||||
} |
||||
|
||||
void Cloning::poisson(Mat &I, Mat &gx, Mat &gy, Mat &sx, Mat &sy) |
||||
{ |
||||
Mat fx = Mat(I.size(),CV_32FC3); |
||||
Mat fy = Mat(I.size(),CV_32FC3); |
||||
|
||||
fx = gx + sx; |
||||
fy = gy + sy; |
||||
|
||||
Mat gxx = Mat(I.size(),CV_32FC3); |
||||
Mat gyy = Mat(I.size(),CV_32FC3); |
||||
|
||||
lapx(fx,gxx); |
||||
lapy(fy,gyy); |
||||
|
||||
split(gxx,rgbx_channel); |
||||
split(gyy,rgby_channel); |
||||
|
||||
split(I,output); |
||||
|
||||
poisson_solver(rgb_channel[2],rgbx_channel[2], rgby_channel[2],output[2]); |
||||
poisson_solver(rgb_channel[1],rgbx_channel[1], rgby_channel[1],output[1]); |
||||
poisson_solver(rgb_channel[0],rgbx_channel[0], rgby_channel[0],output[0]); |
||||
} |
||||
|
||||
void Cloning::evaluate(Mat &I, Mat &wmask, Mat &cloned) |
||||
{ |
||||
bitwise_not(wmask,wmask); |
||||
|
||||
wmask.convertTo(smask1,CV_32FC1,1.0/255.0); |
||||
I.convertTo(grx32,CV_32FC3,1.0/255.0); |
||||
I.convertTo(gry32,CV_32FC3,1.0/255.0); |
||||
|
||||
array_product(grx32,grx,smask1); |
||||
array_product(gry32,gry,smask1); |
||||
|
||||
poisson(I,grx32,gry32,srx32,sry32); |
||||
|
||||
merge(output,cloned); |
||||
} |
||||
|
||||
void Cloning::normal_clone(Mat &I, Mat &mask, Mat &wmask, Mat &cloned, int num) |
||||
{ |
||||
int w = I.size().width; |
||||
int h = I.size().height; |
||||
|
||||
initialization(I,mask,wmask); |
||||
|
||||
if(num == 1) |
||||
{ |
||||
array_product(srx32,sgx,smask); |
||||
array_product(sry32,sgy,smask); |
||||
|
||||
} |
||||
else if(num == 2) |
||||
{ |
||||
for(int i=0;i < h; i++) |
||||
for(int j=0; j < w; j++) |
||||
{ |
||||
if(abs(sgx.at<float>(i,j) - sgy.at<float>(i,j)) > abs(grx.at<float>(i,j) - gry.at<float>(i,j))) |
||||
{ |
||||
srx32.at<float>(i,j) = sgx.at<float>(i,j) * smask.at<float>(i,j); |
||||
sry32.at<float>(i,j) = sgy.at<float>(i,j) * smask.at<float>(i,j); |
||||
} |
||||
else |
||||
{ |
||||
srx32.at<float>(i,j) = grx.at<float>(i,j) * smask.at<float>(i,j); |
||||
sry32.at<float>(i,j) = gry.at<float>(i,j) * smask.at<float>(i,j); |
||||
} |
||||
} |
||||
} |
||||
else if(num == 3) |
||||
{ |
||||
Mat gray = Mat(mask.size(),CV_8UC1); |
||||
Mat gray8 = Mat(mask.size(),CV_8UC3); |
||||
cvtColor(mask, gray, COLOR_BGR2GRAY ); |
||||
vector <Mat> temp; |
||||
split(I,temp); |
||||
gray.copyTo(temp[2]); |
||||
gray.copyTo(temp[1]); |
||||
gray.copyTo(temp[0]); |
||||
|
||||
merge(temp,gray8); |
||||
|
||||
getGradientx(gray8,sgx); |
||||
getGradienty(gray8,sgy); |
||||
|
||||
array_product(srx32,sgx,smask); |
||||
array_product(sry32,sgy,smask); |
||||
|
||||
} |
||||
|
||||
evaluate(I,wmask,cloned); |
||||
} |
||||
|
||||
void Cloning::local_color_change(Mat &I, Mat &mask, Mat &wmask, Mat &cloned, float red_mul=1.0, |
||||
float green_mul=1.0, float blue_mul=1.0) |
||||
{ |
||||
initialization(I,mask,wmask); |
||||
|
||||
array_product(srx32,sgx,smask); |
||||
array_product(sry32,sgy,smask); |
||||
scalar_product(srx32,red_mul,green_mul,blue_mul); |
||||
scalar_product(sry32,red_mul,green_mul,blue_mul); |
||||
|
||||
evaluate(I,wmask,cloned); |
||||
} |
||||
|
||||
void Cloning::illum_change(Mat &I, Mat &mask, Mat &wmask, Mat &cloned, float alpha, float beta) |
||||
{ |
||||
initialization(I,mask,wmask); |
||||
|
||||
array_product(srx32,sgx,smask); |
||||
array_product(sry32,sgy,smask); |
||||
|
||||
Mat mag = Mat(I.size(),CV_32FC3); |
||||
magnitude(srx32,sry32,mag); |
||||
|
||||
Mat multX, multY, multx_temp, multy_temp; |
||||
|
||||
multiply(srx32,pow(alpha,beta),multX); |
||||
pow(mag,-1*beta, multx_temp); |
||||
multiply(multX,multx_temp,srx32); |
||||
|
||||
multiply(sry32,pow(alpha,beta),multY); |
||||
pow(mag,-1*beta, multy_temp); |
||||
multiply(multY,multy_temp,sry32); |
||||
|
||||
Mat zeroMask = (srx32 != 0); |
||||
|
||||
srx32.copyTo(srx32, zeroMask); |
||||
sry32.copyTo(sry32, zeroMask); |
||||
|
||||
evaluate(I,wmask,cloned); |
||||
} |
||||
|
||||
void Cloning::texture_flatten(Mat &I, Mat &mask, Mat &wmask, double low_threshold, |
||||
double high_threshold, int kernel_size, Mat &cloned) |
||||
{ |
||||
initialization(I,mask,wmask); |
||||
|
||||
Mat out = Mat(mask.size(),CV_8UC1); |
||||
Canny(mask,out,low_threshold,high_threshold,kernel_size); |
||||
|
||||
Mat zeros(sgx.size(), CV_32FC3); |
||||
zeros.setTo(0); |
||||
Mat zerosMask = (out != 255); |
||||
zeros.copyTo(sgx, zerosMask); |
||||
zeros.copyTo(sgy, zerosMask); |
||||
|
||||
array_product(srx32,sgx,smask); |
||||
array_product(sry32,sgy,smask); |
||||
|
||||
evaluate(I,wmask,cloned); |
||||
} |
||||
@ -0,0 +1,181 @@ |
||||
/*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) 2013, OpenCV Foundation, 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 "test_precomp.hpp" |
||||
#include "opencv2/photo.hpp" |
||||
#include <string> |
||||
|
||||
using namespace cv; |
||||
using namespace std; |
||||
|
||||
|
||||
TEST(Photo_SeamlessClone_normal, regression) |
||||
{ |
||||
string folder = string(cvtest::TS::ptr()->get_data_path()) + "cloning/Normal_Cloning/"; |
||||
string original_path1 = folder + "source1.png"; |
||||
string original_path2 = folder + "destination1.png"; |
||||
string original_path3 = folder + "mask.png"; |
||||
|
||||
Mat source = imread(original_path1, IMREAD_COLOR); |
||||
Mat destination = imread(original_path2, IMREAD_COLOR); |
||||
Mat mask = imread(original_path3, IMREAD_COLOR); |
||||
|
||||
ASSERT_FALSE(source.empty()) << "Could not load source image " << original_path1; |
||||
ASSERT_FALSE(destination.empty()) << "Could not load destination image " << original_path2; |
||||
ASSERT_FALSE(mask.empty()) << "Could not load mask image " << original_path3; |
||||
|
||||
Mat result; |
||||
Point p; |
||||
p.x = destination.size().width/2; |
||||
p.y = destination.size().height/2; |
||||
seamlessClone(source, destination, mask, p, result, 1); |
||||
|
||||
imwrite(folder + "cloned.png", result); |
||||
|
||||
} |
||||
|
||||
TEST(Photo_SeamlessClone_mixed, regression) |
||||
{ |
||||
string folder = string(cvtest::TS::ptr()->get_data_path()) + "cloning/Mixed_Cloning/"; |
||||
string original_path1 = folder + "source1.png"; |
||||
string original_path2 = folder + "destination1.png"; |
||||
string original_path3 = folder + "mask.png"; |
||||
|
||||
Mat source = imread(original_path1, IMREAD_COLOR); |
||||
Mat destination = imread(original_path2, IMREAD_COLOR); |
||||
Mat mask = imread(original_path3, IMREAD_COLOR); |
||||
|
||||
ASSERT_FALSE(source.empty()) << "Could not load source image " << original_path1; |
||||
ASSERT_FALSE(destination.empty()) << "Could not load destination image " << original_path2; |
||||
ASSERT_FALSE(mask.empty()) << "Could not load mask image " << original_path3; |
||||
|
||||
Mat result; |
||||
Point p; |
||||
p.x = destination.size().width/2; |
||||
p.y = destination.size().height/2; |
||||
seamlessClone(source, destination, mask, p, result, 2); |
||||
|
||||
imwrite(folder + "cloned.png", result); |
||||
|
||||
} |
||||
|
||||
TEST(Photo_SeamlessClone_featureExchange, regression) |
||||
{ |
||||
string folder = string(cvtest::TS::ptr()->get_data_path()) + "cloning/Monochrome_Transfer/"; |
||||
string original_path1 = folder + "source1.png"; |
||||
string original_path2 = folder + "destination1.png"; |
||||
string original_path3 = folder + "mask.png"; |
||||
|
||||
Mat source = imread(original_path1, IMREAD_COLOR); |
||||
Mat destination = imread(original_path2, IMREAD_COLOR); |
||||
Mat mask = imread(original_path3, IMREAD_COLOR); |
||||
|
||||
ASSERT_FALSE(source.empty()) << "Could not load source image " << original_path1; |
||||
ASSERT_FALSE(destination.empty()) << "Could not load destination image " << original_path2; |
||||
ASSERT_FALSE(mask.empty()) << "Could not load mask image " << original_path3; |
||||
|
||||
Mat result; |
||||
Point p; |
||||
p.x = destination.size().width/2; |
||||
p.y = destination.size().height/2; |
||||
seamlessClone(source, destination, mask, p, result, 3); |
||||
|
||||
imwrite(folder + "cloned.png", result); |
||||
|
||||
} |
||||
|
||||
TEST(Photo_SeamlessClone_colorChange, regression) |
||||
{ |
||||
string folder = string(cvtest::TS::ptr()->get_data_path()) + "cloning/color_change/"; |
||||
string original_path1 = folder + "source1.png"; |
||||
string original_path2 = folder + "mask.png"; |
||||
|
||||
Mat source = imread(original_path1, IMREAD_COLOR); |
||||
Mat mask = imread(original_path2, IMREAD_COLOR); |
||||
|
||||
ASSERT_FALSE(source.empty()) << "Could not load source image " << original_path1; |
||||
ASSERT_FALSE(mask.empty()) << "Could not load mask image " << original_path2; |
||||
|
||||
Mat result; |
||||
colorChange(source, mask, result, 1.5, .5, .5); |
||||
|
||||
imwrite(folder + "cloned.png", result); |
||||
|
||||
} |
||||
|
||||
TEST(Photo_SeamlessClone_illuminationChange, regression) |
||||
{ |
||||
string folder = string(cvtest::TS::ptr()->get_data_path()) + "cloning/Illumination_Change/"; |
||||
string original_path1 = folder + "source1.png"; |
||||
string original_path2 = folder + "mask.png"; |
||||
|
||||
Mat source = imread(original_path1, IMREAD_COLOR); |
||||
Mat mask = imread(original_path2, IMREAD_COLOR); |
||||
|
||||
ASSERT_FALSE(source.empty()) << "Could not load source image " << original_path1; |
||||
ASSERT_FALSE(mask.empty()) << "Could not load mask image " << original_path2; |
||||
|
||||
Mat result; |
||||
illuminationChange(source, mask, result, 0.2f, 0.4f); |
||||
|
||||
imwrite(folder + "cloned.png", result); |
||||
|
||||
} |
||||
|
||||
TEST(Photo_SeamlessClone_textureFlattening, regression) |
||||
{ |
||||
string folder = string(cvtest::TS::ptr()->get_data_path()) + "cloning/Texture_Flattening/"; |
||||
string original_path1 = folder + "source1.png"; |
||||
string original_path2 = folder + "mask.png"; |
||||
|
||||
Mat source = imread(original_path1, IMREAD_COLOR); |
||||
Mat mask = imread(original_path2, IMREAD_COLOR); |
||||
|
||||
ASSERT_FALSE(source.empty()) << "Could not load source image " << original_path1; |
||||
ASSERT_FALSE(mask.empty()) << "Could not load mask image " << original_path2; |
||||
|
||||
Mat result; |
||||
textureFlattening(source, mask, result, 30, 45, 3); |
||||
|
||||
imwrite(folder + "cloned.png", result); |
||||
|
||||
} |
||||
@ -0,0 +1,67 @@ |
||||
/*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) 2013, OpenCV Foundation, 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 "test_precomp.hpp" |
||||
#include "opencv2/photo.hpp" |
||||
#include <string> |
||||
|
||||
using namespace cv; |
||||
using namespace std; |
||||
|
||||
|
||||
TEST(Photo_Decolor, regression) |
||||
{ |
||||
string folder = string(cvtest::TS::ptr()->get_data_path()) + "decolor/"; |
||||
string original_path = folder + "color_image_1.png"; |
||||
|
||||
Mat original = imread(original_path, IMREAD_COLOR); |
||||
|
||||
ASSERT_FALSE(original.empty()) << "Could not load input image " << original_path; |
||||
ASSERT_FALSE(original.channels()!=3) << "Load color input image " << original_path; |
||||
|
||||
Mat grayscale, color_boost; |
||||
decolor(original, grayscale, color_boost); |
||||
|
||||
imwrite(folder + "grayscale.png",grayscale); |
||||
imwrite(folder + "color_boost.png",color_boost); |
||||
|
||||
} |
||||
@ -0,0 +1,130 @@ |
||||
/*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) 2013, OpenCV Foundation, 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 "test_precomp.hpp" |
||||
#include "opencv2/photo.hpp" |
||||
#include <string> |
||||
|
||||
using namespace cv; |
||||
using namespace std; |
||||
|
||||
|
||||
TEST(Photo_NPR_EdgePreserveSmoothing_RecursiveFilter, regression) |
||||
{ |
||||
string folder = string(cvtest::TS::ptr()->get_data_path()) + "npr/"; |
||||
string original_path = folder + "test1.png"; |
||||
|
||||
Mat source = imread(original_path, IMREAD_COLOR); |
||||
|
||||
ASSERT_FALSE(source.empty()) << "Could not load input image " << original_path; |
||||
|
||||
Mat result; |
||||
edgePreservingFilter(source,result,1); |
||||
|
||||
imwrite(folder + "smoothened_RF.png", result); |
||||
|
||||
} |
||||
|
||||
TEST(Photo_NPR_EdgePreserveSmoothing_NormConvFilter, regression) |
||||
{ |
||||
string folder = string(cvtest::TS::ptr()->get_data_path()) + "npr/"; |
||||
string original_path = folder + "test1.png"; |
||||
|
||||
Mat source = imread(original_path, IMREAD_COLOR); |
||||
|
||||
ASSERT_FALSE(source.empty()) << "Could not load input image " << original_path; |
||||
|
||||
Mat result; |
||||
edgePreservingFilter(source,result,2); |
||||
|
||||
imwrite(folder + "smoothened_NCF.png", result); |
||||
|
||||
} |
||||
|
||||
TEST(Photo_NPR_DetailEnhance, regression) |
||||
{ |
||||
string folder = string(cvtest::TS::ptr()->get_data_path()) + "npr/"; |
||||
string original_path = folder + "test1.png"; |
||||
|
||||
Mat source = imread(original_path, IMREAD_COLOR); |
||||
|
||||
ASSERT_FALSE(source.empty()) << "Could not load input image " << original_path; |
||||
|
||||
Mat result; |
||||
detailEnhance(source,result); |
||||
|
||||
imwrite(folder + "detail_enhanced.png", result); |
||||
|
||||
} |
||||
|
||||
TEST(Photo_NPR_PencilSketch, regression) |
||||
{ |
||||
string folder = string(cvtest::TS::ptr()->get_data_path()) + "npr/"; |
||||
string original_path = folder + "test1.png"; |
||||
|
||||
Mat source = imread(original_path, IMREAD_COLOR); |
||||
|
||||
ASSERT_FALSE(source.empty()) << "Could not load input image " << original_path; |
||||
|
||||
Mat result,result1; |
||||
pencilSketch(source,result,result1, 10, 0.1f, 0.03f); |
||||
|
||||
imwrite(folder + "pencil_sketch.png", result); |
||||
imwrite(folder + "color_pencil_sketch.png", result1); |
||||
|
||||
} |
||||
|
||||
TEST(Photo_NPR_Stylization, regression) |
||||
{ |
||||
string folder = string(cvtest::TS::ptr()->get_data_path()) + "npr/"; |
||||
string original_path = folder + "test1.png"; |
||||
|
||||
Mat source = imread(original_path, IMREAD_COLOR); |
||||
|
||||
ASSERT_FALSE(source.empty()) << "Could not load input image " << original_path; |
||||
|
||||
Mat result; |
||||
stylization(source,result); |
||||
|
||||
imwrite(folder + "stylized.png", result); |
||||
|
||||
} |
||||
@ -1,57 +1,11 @@ |
||||
macro(find_qvtk) |
||||
find_library (QVTK_LIBRARY QVTK HINTS ${VTK_DIR} ${VTK_DIR}/bin) |
||||
find_path (QVTK_INCLUDE_DIR QVTKWidget.h HINT ${VTK_INCLUDE_DIRS}) |
||||
find_package_handle_standard_args(QVTK DEFAULT_MSG QVTK_LIBRARY QVTK_INCLUDE_DIR) |
||||
|
||||
if(QVTK_FOUND) |
||||
get_filename_component (QVTK_LIBRARY_DIR ${QVTK_LIBRARY} PATH) |
||||
list(APPEND VTK_LIBRARY_DIRS ${QVTK_LIBRARY_DIR}) |
||||
list(APPEND VTK_INCLUDE_DIRS ${QVTK_INCLUDE_DIR}) |
||||
set (VTK_USE_QVTK ON) |
||||
endif() |
||||
endmacro() |
||||
|
||||
macro(find_vtk) |
||||
find_package(VTK) |
||||
if(${VTK_MAJOR_VERSION} LESS 5) |
||||
MESSAGE(FATAL_ERROR "VTK 5 or more required!") |
||||
endif() |
||||
if(VTK_FOUND) |
||||
if (BUILD_SHARED_LIBS OR (NOT BUILD_SHARED_LIBS AND NOT VTK_BUILD_SHARED_LIBS)) |
||||
find_qvtk() |
||||
message(STATUS "VTK found (include: ${VTK_INCLUDE_DIRS}, lib: ${VTK_LIBRARY_DIRS})") |
||||
link_directories(${VTK_LIBRARY_DIRS}) |
||||
include_directories(SYSTEM ${VTK_INCLUDE_DIRS}) |
||||
set(HAVE_VTK ON) |
||||
else () |
||||
set(HAVE_VTK OFF) |
||||
message (FATAL_ERROR "VTK disabled. You are to build OpenCV in STATIC but VTK is SHARED!") |
||||
endif () |
||||
endif() |
||||
endmacro() |
||||
|
||||
if (NOT OPENCV_INITIAL_PASS AND DEFINED BUILD_opencv_viz AND BUILD_opencv_viz) |
||||
find_vtk() |
||||
endif() |
||||
|
||||
if(DEFINED HAVE_VTK AND HAVE_VTK) |
||||
set(VTK_USE_FILE ${VTK_USE_FILE} CACHE INTERNAL "VTK_USE_FILE") |
||||
include (${VTK_USE_FILE}) |
||||
add_definitions(-DHAVE_VTK) |
||||
if(NOT WITH_VTK OR NOT DEFINED HAVE_VTK OR NOT HAVE_VTK) |
||||
ocv_module_disable(viz) |
||||
endif() |
||||
|
||||
include(${VTK_USE_FILE}) |
||||
set(the_description "Viz") |
||||
set(BUILD_opencv_viz_INIT OFF) |
||||
include_directories(src) |
||||
ocv_define_module(viz opencv_core) |
||||
ocv_define_module(viz opencv_core ${VTK_LIBRARIES}) |
||||
|
||||
if(DEFINED BUILD_opencv_viz AND BUILD_opencv_viz AND DEFINED HAVE_VTK AND HAVE_VTK) |
||||
if (${VTK_VERSION_MAJOR} EQUAL 5) |
||||
target_link_libraries(opencv_viz vtkCommon vtkWidgets vtkFiltering vtkRendering) |
||||
else() |
||||
target_link_libraries(opencv_viz vtkViewsCore vtkRenderingLOD vtkIOPLY vtkRenderingFreeTypeOpenGL vtkRenderingVolumeOpenGL vtkFiltersTexture) |
||||
endif() |
||||
if(APPLE) |
||||
target_link_libraries(opencv_viz "-framework Cocoa") |
||||
endif() |
||||
if(APPLE AND BUILD_opencv_viz) |
||||
target_link_libraries(opencv_viz "-framework Cocoa") |
||||
endif() |
||||
|
||||
@ -0,0 +1,54 @@ |
||||
#include "test_precomp.hpp" |
||||
|
||||
using namespace cv; |
||||
using namespace std; |
||||
|
||||
void tutorial2() |
||||
{ |
||||
/// Create a window
|
||||
viz::Viz3d myWindow("Coordinate Frame"); |
||||
|
||||
/// Add coordinate axes
|
||||
myWindow.showWidget("Coordinate Widget", viz::WCoordinateSystem()); |
||||
|
||||
/// Add line to represent (1,1,1) axis
|
||||
viz::WLine axis(Point3f(-1.0f,-1.0f,-1.0f), Point3f(1.0f,1.0f,1.0f)); |
||||
axis.setRenderingProperty(viz::LINE_WIDTH, 4.0); |
||||
myWindow.showWidget("Line Widget", axis); |
||||
|
||||
/// Construct a cube widget
|
||||
viz::WCube cube_widget(Point3f(0.5,0.5,0.0), Point3f(0.0,0.0,-0.5), true, viz::Color::blue()); |
||||
cube_widget.setRenderingProperty(viz::LINE_WIDTH, 4.0); |
||||
|
||||
/// Display widget (update if already displayed)
|
||||
myWindow.showWidget("Cube Widget", cube_widget); |
||||
|
||||
/// Rodrigues vector
|
||||
Mat rot_vec = Mat::zeros(1,3,CV_32F); |
||||
float translation_phase = 0.0, translation = 0.0; |
||||
while(!myWindow.wasStopped()) |
||||
{ |
||||
/* Rotation using rodrigues */ |
||||
/// Rotate around (1,1,1)
|
||||
rot_vec.at<float>(0,0) += CV_PI * 0.01f; |
||||
rot_vec.at<float>(0,1) += CV_PI * 0.01f; |
||||
rot_vec.at<float>(0,2) += CV_PI * 0.01f; |
||||
|
||||
/// Shift on (1,1,1)
|
||||
translation_phase += CV_PI * 0.01f; |
||||
translation = sin(translation_phase); |
||||
|
||||
/// Construct pose
|
||||
Affine3f pose(rot_vec, Vec3f(translation, translation, translation)); |
||||
|
||||
myWindow.setWidgetPose("Cube Widget", pose); |
||||
|
||||
myWindow.spinOnce(1, true); |
||||
} |
||||
} |
||||
|
||||
|
||||
TEST(Viz_viz3d, DISABLED_tutorial2_pose_of_widget) |
||||
{ |
||||
tutorial2(); |
||||
} |
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in new issue