filters.hpp

[詳解]

/*M///////////////////////////////////////////////////////////////////////////////////////




//




//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.




//




//  By downloading, copying, installing or using the software you agree to this license.




//  If you do not agree to this license, do not download, install,




//  copy or use the software.




//




//




//                           License Agreement




//                For Open Source Computer Vision Library




//




// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.




// Copyright (C) 2009, Willow Garage Inc., all rights reserved.




// Third party copyrights are property of their respective owners.




//




// Redistribution and use in source and binary forms, with or without modification,




// are permitted provided that the following conditions are met:




//




//   * Redistribution's of source code must retain the above copyright notice,




//     this list of conditions and the following disclaimer.




//




//   * Redistribution's in binary form must reproduce the above copyright notice,




//     this list of conditions and the following disclaimer in the documentation




//     and/or other materials provided with the distribution.




//




//   * The name of the copyright holders may not be used to endorse or promote products




//     derived from this software without specific prior written permission.




//




// This software is provided by the copyright holders and contributors "as is" and




// any express or implied warranties, including, but not limited to, the implied




// warranties of merchantability and fitness for a particular purpose are disclaimed.




// In no event shall the Intel Corporation or contributors be liable for any direct,




// indirect, incidental, special, exemplary, or consequential damages




// (including, but not limited to, procurement of substitute goods or services;




// loss of use, data, or profits; or business interruption) however caused




// and on any theory of liability, whether in contract, strict liability,




// or tort (including negligence or otherwise) arising in any way out of




// the use of this software, even if advised of the possibility of such damage.




//




//M*/








#ifndef OPENCV_CUDA_FILTERS_HPP




#define OPENCV_CUDA_FILTERS_HPP








#include "saturate_cast.hpp"




#include "vec_traits.hpp"




#include "vec_math.hpp"




#include "type_traits.hpp"












namespace

cv
{
namespace
cuda {
namespace
device


{



template
<typename
Ptr2D>
struct
PointFilter



{



typedef
typename
Ptr2D::elem_type elem_type;



typedef
float
index_type;







explicit
__host__ __device__ __forceinline__ PointFilter(const
Ptr2D& src_,
float
fx = 0.f,
float
fy = 0.f)



: src(src_)



{



CV_UNUSED(fx);



CV_UNUSED(fy);



}







__device__ __forceinline__ elem_type operator ()(float
y,
float
x)
const





{



return
src(__float2int_rz(y), __float2int_rz(x));



}







Ptr2D src;



};







template
<typename
Ptr2D>
struct
LinearFilter



{



typedef
typename
Ptr2D::elem_type elem_type;



typedef
float
index_type;







explicit
__host__ __device__ __forceinline__ LinearFilter(const
Ptr2D& src_,
float
fx = 0.f,
float
fy = 0.f)



: src(src_)



{



CV_UNUSED(fx);



CV_UNUSED(fy);



}



__device__ __forceinline__ elem_type operator ()(float
y,
float
x)
const





{



typedef
typename
TypeVec<float, VecTraits<elem_type>::cn>::vec_type work_type;







work_type out = VecTraits<work_type>::all(0);







const
int
x1 = __float2int_rd(x);



const
int
y1 = __float2int_rd(y);



const
int
x2 = x1 + 1;



const
int
y2 = y1 + 1;







elem_type src_reg = src(y1, x1);



out = out + src_reg * ((x2 - x) * (y2 - y));







src_reg = src(y1, x2);



out = out + src_reg * ((x - x1) * (y2 - y));







src_reg = src(y2, x1);



out = out + src_reg * ((x2 - x) * (y - y1));







src_reg = src(y2, x2);



out = out + src_reg * ((x - x1) * (y - y1));







return
saturate_cast<elem_type>(out);



}







Ptr2D src;



};







template
<typename
Ptr2D>
struct
CubicFilter



{



typedef
typename
Ptr2D::elem_type elem_type;



typedef
float
index_type;



typedef
typename
TypeVec<float, VecTraits<elem_type>::cn>::vec_type work_type;







explicit
__host__ __device__ __forceinline__ CubicFilter(const
Ptr2D& src_,
float
fx = 0.f,
float
fy = 0.f)



: src(src_)



{



CV_UNUSED(fx);



CV_UNUSED(fy);



}







static
__device__ __forceinline__
float
bicubicCoeff(float
x_)



{



float
x = fabsf(x_);



if
(x <= 1.0f)



{



return
x * x * (1.5f * x - 2.5f) + 1.0f;



}



else
if
(x < 2.0f)



{



return
x * (x * (-0.5f * x + 2.5f) - 4.0f) + 2.0f;



}



else




{



return
0.0f;



}



}







__device__ elem_type operator ()(float
y,
float
x)
const





{



const
float
xmin = ::ceilf(x - 2.0f);



const
float
xmax = ::floorf(x + 2.0f);







const
float
ymin = ::ceilf(y - 2.0f);



const
float
ymax = ::floorf(y + 2.0f);







work_type sum = VecTraits<work_type>::all(0);



float
wsum = 0.0f;







for
(float
cy = ymin; cy <= ymax; cy += 1.0f)



{



for
(float
cx = xmin; cx <= xmax; cx += 1.0f)



{



const
float
w = bicubicCoeff(x - cx) * bicubicCoeff(y - cy);



sum = sum + w * src(__float2int_rd(cy), __float2int_rd(cx));



wsum += w;



}



}







work_type res = (!wsum)? VecTraits<work_type>::all(0) : sum / wsum;







return
saturate_cast<elem_type>(res);



}







Ptr2D src;



};



// for integer scaling




template
<typename
Ptr2D>
struct
IntegerAreaFilter



{



typedef
typename
Ptr2D::elem_type elem_type;



typedef
float
index_type;







explicit
__host__ __device__ __forceinline__ IntegerAreaFilter(const
Ptr2D& src_,
float
scale_x_,
float
scale_y_)



: src(src_), scale_x(scale_x_), scale_y(scale_y_), scale(1.f / (scale_x * scale_y)) {}







__device__ __forceinline__ elem_type operator ()(float
y,
float
x)
const





{



float
fsx1 = x * scale_x;



float
fsx2 = fsx1 + scale_x;







int
sx1 = __float2int_ru(fsx1);



int
sx2 = __float2int_rd(fsx2);







float
fsy1 = y * scale_y;



float
fsy2 = fsy1 + scale_y;







int
sy1 = __float2int_ru(fsy1);



int
sy2 = __float2int_rd(fsy2);







typedef
typename
TypeVec<float, VecTraits<elem_type>::cn>::vec_type work_type;



work_type out = VecTraits<work_type>::all(0.f);







for(int
dy = sy1; dy < sy2; ++dy)



for(int
dx = sx1; dx < sx2; ++dx)



{



out = out + src(dy, dx) * scale;



}







return
saturate_cast<elem_type>(out);



}







Ptr2D src;



float
scale_x, scale_y ,scale;



};







template
<typename
Ptr2D>
struct
AreaFilter



{



typedef
typename
Ptr2D::elem_type elem_type;



typedef
float
index_type;







explicit
__host__ __device__ __forceinline__ AreaFilter(const
Ptr2D& src_,
float
scale_x_,
float
scale_y_)



: src(src_), scale_x(scale_x_), scale_y(scale_y_){}







__device__ __forceinline__ elem_type operator ()(float
y,
float
x)
const





{



float
fsx1 = x * scale_x;



float
fsx2 = fsx1 + scale_x;







int
sx1 = __float2int_ru(fsx1);



int
sx2 = __float2int_rd(fsx2);







float
fsy1 = y * scale_y;



float
fsy2 = fsy1 + scale_y;







int
sy1 = __float2int_ru(fsy1);



int
sy2 = __float2int_rd(fsy2);







float
scale = 1.f / (fminf(scale_x, src.width - fsx1) * fminf(scale_y, src.height - fsy1));







typedef
typename
TypeVec<float, VecTraits<elem_type>::cn>::vec_type work_type;



work_type out = VecTraits<work_type>::all(0.f);







for
(int
dy = sy1; dy < sy2; ++dy)



{



for
(int
dx = sx1; dx < sx2; ++dx)



out = out + src(dy, dx) * scale;







if
(sx1 > fsx1)



out = out + src(dy, (sx1 -1) ) * ((sx1 - fsx1) * scale);







if
(sx2 < fsx2)



out = out + src(dy, sx2) * ((fsx2 -sx2) * scale);



}







if
(sy1 > fsy1)



for
(int
dx = sx1; dx < sx2; ++dx)



out = out + src( (sy1 - 1) , dx) * ((sy1 -fsy1) * scale);







if
(sy2 < fsy2)



for
(int
dx = sx1; dx < sx2; ++dx)



out = out + src(sy2, dx) * ((fsy2 -sy2) * scale);







if
((sy1 > fsy1) &&  (sx1 > fsx1))



out = out + src( (sy1 - 1) , (sx1 - 1)) * ((sy1 -fsy1) * (sx1 -fsx1) * scale);







if
((sy1 > fsy1) &&  (sx2 < fsx2))



out = out + src( (sy1 - 1) , sx2) * ((sy1 -fsy1) * (fsx2 -sx2) * scale);







if
((sy2 < fsy2) &&  (sx2 < fsx2))



out = out + src(sy2, sx2) * ((fsy2 -sy2) * (fsx2 -sx2) * scale);







if
((sy2 < fsy2) &&  (sx1 > fsx1))



out = out + src(sy2, (sx1 - 1)) * ((fsy2 -sy2) * (sx1 -fsx1) * scale);







return
saturate_cast<elem_type>(out);



}







Ptr2D src;



float
scale_x, scale_y;



int
width, haight;



};


}}}
// namespace cv { namespace cuda { namespace cudev












#endif

// OPENCV_CUDA_FILTERS_HPP