Device layer

Overview

// namespaces

namespace cv::cudev::functional_detail;
namespace cv::cudev::vec_math_detail;

// typedefs

typedef cv::cudev::color_cvt_detail::RGB5x52RGB<3, 0, 5> cv::cudev::BGR555_to_BGR_func;
typedef cv::cudev::color_cvt_detail::RGB5x52RGB<4, 0, 5> cv::cudev::BGR555_to_BGRA_func;
typedef cv::cudev::color_cvt_detail::RGB5x52Gray<5> cv::cudev::BGR555_to_GRAY_func;
typedef cv::cudev::color_cvt_detail::RGB5x52RGB<3, 2, 5> cv::cudev::BGR555_to_RGB_func;
typedef cv::cudev::color_cvt_detail::RGB5x52RGB<4, 2, 5> cv::cudev::BGR555_to_RGBA_func;
typedef cv::cudev::color_cvt_detail::RGB5x52RGB<3, 0, 6> cv::cudev::BGR565_to_BGR_func;
typedef cv::cudev::color_cvt_detail::RGB5x52RGB<4, 0, 6> cv::cudev::BGR565_to_BGRA_func;
typedef cv::cudev::color_cvt_detail::RGB5x52Gray<6> cv::cudev::BGR565_to_GRAY_func;
typedef cv::cudev::color_cvt_detail::RGB5x52RGB<3, 2, 6> cv::cudev::BGR565_to_RGB_func;
typedef cv::cudev::color_cvt_detail::RGB5x52RGB<4, 2, 6> cv::cudev::BGR565_to_RGBA_func;
typedef cv::cudev::color_cvt_detail::RGB2RGB5x5<3, 0, 5> cv::cudev::BGR_to_BGR555_func;
typedef cv::cudev::color_cvt_detail::RGB2RGB5x5<3, 0, 6> cv::cudev::BGR_to_BGR565_func;
typedef cv::cudev::color_cvt_detail::RGB2RGB5x5<4, 0, 5> cv::cudev::BGRA_to_BGR555_func;
typedef cv::cudev::color_cvt_detail::RGB2RGB5x5<4, 0, 6> cv::cudev::BGRA_to_BGR565_func;
typedef cv::cudev::color_cvt_detail::Gray2RGB5x5<5> cv::cudev::GRAY_to_BGR555_func;
typedef cv::cudev::color_cvt_detail::Gray2RGB5x5<6> cv::cudev::GRAY_to_BGR565_func;
typedef cv::cudev::color_cvt_detail::RGB2RGB5x5<3, 2, 5> cv::cudev::RGB_to_BGR555_func;
typedef cv::cudev::color_cvt_detail::RGB2RGB5x5<3, 2, 6> cv::cudev::RGB_to_BGR565_func;
typedef cv::cudev::color_cvt_detail::RGB2RGB5x5<4, 2, 5> cv::cudev::RGBA_to_BGR555_func;
typedef cv::cudev::color_cvt_detail::RGB2RGB5x5<4, 2, 6> cv::cudev::RGBA_to_BGR565_func;

// enums

enum
{
    cv::cudev::@285::LOG_WARP_SIZE = 5,
    cv::cudev::@285::WARP_SIZE     = 1 <<LOG_WARP_SIZE,
};

// structs

struct cv::cudev::AffineMapPtr;
struct cv::cudev::AffineMapPtrSz;

template <
    typename T,
    int COUNT
    >
struct cv::cudev::ArrayWrapper;

template <typename T>
struct cv::cudev::Avg;

template <typename SrcDepth>
struct cv::cudev::BGRA_to_BGR_func;

template <typename SrcDepth>
struct cv::cudev::BGRA_to_GRAY_func;

template <>
struct cv::cudev::BGRA_to_HLS4_FULL_func<float>;

template <typename SrcDepth>
struct cv::cudev::BGRA_to_HLS4_FULL_func;

template <typename SrcDepth>
struct cv::cudev::BGRA_to_HLS4_func;

template <>
struct cv::cudev::BGRA_to_HLS4_func<float>;

template <typename SrcDepth>
struct cv::cudev::BGRA_to_HLS_FULL_func;

template <>
struct cv::cudev::BGRA_to_HLS_FULL_func<float>;

template <typename SrcDepth>
struct cv::cudev::BGRA_to_HLS_func;

template <>
struct cv::cudev::BGRA_to_HLS_func<float>;

template <typename SrcDepth>
struct cv::cudev::BGRA_to_HSV4_FULL_func;

template <>
struct cv::cudev::BGRA_to_HSV4_FULL_func<float>;

template <>
struct cv::cudev::BGRA_to_HSV4_func<float>;

template <typename SrcDepth>
struct cv::cudev::BGRA_to_HSV4_func;

template <>
struct cv::cudev::BGRA_to_HSV_FULL_func<float>;

template <typename SrcDepth>
struct cv::cudev::BGRA_to_HSV_FULL_func;

template <typename SrcDepth>
struct cv::cudev::BGRA_to_HSV_func;

template <>
struct cv::cudev::BGRA_to_HSV_func<float>;

template <typename SrcDepth>
struct cv::cudev::BGRA_to_Lab4_func;

template <typename SrcDepth>
struct cv::cudev::BGRA_to_Lab_func;

template <typename SrcDepth>
struct cv::cudev::BGRA_to_Luv4_func;

template <typename SrcDepth>
struct cv::cudev::BGRA_to_Luv_func;

template <typename SrcDepth>
struct cv::cudev::BGRA_to_RGBA_func;

template <typename SrcDepth>
struct cv::cudev::BGRA_to_RGB_func;

template <typename SrcDepth>
struct cv::cudev::BGRA_to_XYZ4_func;

template <typename SrcDepth>
struct cv::cudev::BGRA_to_XYZ_func;

template <typename SrcDepth>
struct cv::cudev::BGRA_to_YCrCb4_func;

template <typename SrcDepth>
struct cv::cudev::BGRA_to_YCrCb_func;

template <typename SrcDepth>
struct cv::cudev::BGRA_to_YUV4_func;

template <typename SrcDepth>
struct cv::cudev::BGRA_to_YUV_func;

template <typename SrcDepth>
struct cv::cudev::BGR_to_BGRA_func;

template <typename SrcDepth>
struct cv::cudev::BGR_to_GRAY_func;

template <typename SrcDepth>
struct cv::cudev::BGR_to_HLS4_FULL_func;

template <>
struct cv::cudev::BGR_to_HLS4_FULL_func<float>;

template <>
struct cv::cudev::BGR_to_HLS4_func<float>;

template <typename SrcDepth>
struct cv::cudev::BGR_to_HLS4_func;

template <typename SrcDepth>
struct cv::cudev::BGR_to_HLS_FULL_func;

template <>
struct cv::cudev::BGR_to_HLS_FULL_func<float>;

template <>
struct cv::cudev::BGR_to_HLS_func<float>;

template <typename SrcDepth>
struct cv::cudev::BGR_to_HLS_func;

template <>
struct cv::cudev::BGR_to_HSV4_FULL_func<float>;

template <typename SrcDepth>
struct cv::cudev::BGR_to_HSV4_FULL_func;

template <>
struct cv::cudev::BGR_to_HSV4_func<float>;

template <typename SrcDepth>
struct cv::cudev::BGR_to_HSV4_func;

template <>
struct cv::cudev::BGR_to_HSV_FULL_func<float>;

template <typename SrcDepth>
struct cv::cudev::BGR_to_HSV_FULL_func;

template <>
struct cv::cudev::BGR_to_HSV_func<float>;

template <typename SrcDepth>
struct cv::cudev::BGR_to_HSV_func;

template <typename SrcDepth>
struct cv::cudev::BGR_to_Lab4_func;

template <typename SrcDepth>
struct cv::cudev::BGR_to_Lab_func;

template <typename SrcDepth>
struct cv::cudev::BGR_to_Luv4_func;

template <typename SrcDepth>
struct cv::cudev::BGR_to_Luv_func;

template <typename SrcDepth>
struct cv::cudev::BGR_to_RGBA_func;

template <typename SrcDepth>
struct cv::cudev::BGR_to_RGB_func;

template <typename SrcDepth>
struct cv::cudev::BGR_to_XYZ4_func;

template <typename SrcDepth>
struct cv::cudev::BGR_to_XYZ_func;

template <typename SrcDepth>
struct cv::cudev::BGR_to_YCrCb4_func;

template <typename SrcDepth>
struct cv::cudev::BGR_to_YCrCb_func;

template <typename SrcDepth>
struct cv::cudev::BGR_to_YUV4_func;

template <typename SrcDepth>
struct cv::cudev::BGR_to_YUV_func;

template <class Predicate>
struct cv::cudev::BinaryNegate;

template <
    class Src1Ptr,
    class Src2Ptr,
    class Op
    >
struct cv::cudev::BinaryTransformPtr;

template <
    class Src1Ptr,
    class Src2Ptr,
    class Op
    >
struct cv::cudev::BinaryTransformPtrSz;

template <
    class Op,
    int n0,
    int n1
    >
struct cv::cudev::BinaryTupleAdapter;

template <class Op>
struct cv::cudev::Binder1st;

template <class Op>
struct cv::cudev::Binder2nd;

struct cv::cudev::Block;

template <
    class BrdImpl,
    class SrcPtr
    >
struct cv::cudev::BrdBase;

template <class SrcPtr>
struct cv::cudev::BrdConstant;

struct cv::cudev::BrdReflect;
struct cv::cudev::BrdReflect101;
struct cv::cudev::BrdReplicate;
struct cv::cudev::BrdWrap;

template <typename SrcPtr>
struct cv::cudev::CommonAreaInterPtr;

template <class SrcPtr>
struct cv::cudev::CommonAreaInterPtrSz;

template <typename T>
struct cv::cudev::ConstantPtr;

template <typename T>
struct cv::cudev::ConstantPtrSz;

template <
    class Tuple,
    template< typename T > class CvtOp
    >
struct cv::cudev::ConvertTuple;

template <class SrcPtr>
struct cv::cudev::CountNonZeroExprBody;

template <typename SrcPtr>
struct cv::cudev::CubicInterPtr;

template <class SrcPtr>
struct cv::cudev::CubicInterPtrSz;

struct cv::cudev::DefaultCopyPolicy;
struct cv::cudev::DefaultGlobReducePolicy;
struct cv::cudev::DefaultHistogramPolicy;
struct cv::cudev::DefaultReduceToVecPolicy;
struct cv::cudev::DefaultSplitMergePolicy;
struct cv::cudev::DefaultTransformPolicy;
struct cv::cudev::DefaultTransposePolicy;

template <class SrcPtr>
struct cv::cudev::DerivXPtr;

template <class SrcPtr>
struct cv::cudev::DerivXPtrSz;

template <class SrcPtr>
struct cv::cudev::DerivYPtr;

template <class SrcPtr>
struct cv::cudev::DerivYPtrSz;

template <
    bool,
    typename T = void
    >
struct cv::cudev::DisableIf;

template <typename T>
struct cv::cudev::DisableIf<false, T>;

template <class T>
struct cv::cudev::DynamicSharedMem;

template <>
struct cv::cudev::DynamicSharedMem<double>;

template <
    bool,
    typename T = void
    >
struct cv::cudev::EnableIf;

template <typename T>
struct cv::cudev::EnableIf<true, T>;

template <class Body>
struct cv::cudev::Expr;

template <class SrcPtr>
struct cv::cudev::FindMaxValExprBody;

template <class SrcPtr>
struct cv::cudev::FindMinMaxValExprBody;

template <class SrcPtr>
struct cv::cudev::FindMinValExprBody;

template <typename SrcDepth>
struct cv::cudev::GRAY_to_BGRA_func;

template <typename SrcDepth>
struct cv::cudev::GRAY_to_BGR_func;

template <typename T>
struct cv::cudev::GlobPtr;

template <typename T>
struct cv::cudev::GlobPtrSz;

template <>
struct cv::cudev::HLS4_to_BGRA_FULL_func<float>;

template <typename SrcDepth>
struct cv::cudev::HLS4_to_BGRA_FULL_func;

template <typename SrcDepth>
struct cv::cudev::HLS4_to_BGRA_func;

template <>
struct cv::cudev::HLS4_to_BGRA_func<float>;

template <>
struct cv::cudev::HLS4_to_BGR_FULL_func<float>;

template <typename SrcDepth>
struct cv::cudev::HLS4_to_BGR_FULL_func;

template <>
struct cv::cudev::HLS4_to_BGR_func<float>;

template <typename SrcDepth>
struct cv::cudev::HLS4_to_BGR_func;

template <>
struct cv::cudev::HLS4_to_RGBA_FULL_func<float>;

template <typename SrcDepth>
struct cv::cudev::HLS4_to_RGBA_FULL_func;

template <>
struct cv::cudev::HLS4_to_RGBA_func<float>;

template <typename SrcDepth>
struct cv::cudev::HLS4_to_RGBA_func;

template <typename SrcDepth>
struct cv::cudev::HLS4_to_RGB_FULL_func;

template <>
struct cv::cudev::HLS4_to_RGB_FULL_func<float>;

template <>
struct cv::cudev::HLS4_to_RGB_func<float>;

template <typename SrcDepth>
struct cv::cudev::HLS4_to_RGB_func;

template <>
struct cv::cudev::HLS_to_BGRA_FULL_func<float>;

template <typename SrcDepth>
struct cv::cudev::HLS_to_BGRA_FULL_func;

template <>
struct cv::cudev::HLS_to_BGRA_func<float>;

template <typename SrcDepth>
struct cv::cudev::HLS_to_BGRA_func;

template <typename SrcDepth>
struct cv::cudev::HLS_to_BGR_FULL_func;

template <>
struct cv::cudev::HLS_to_BGR_FULL_func<float>;

template <>
struct cv::cudev::HLS_to_BGR_func<float>;

template <typename SrcDepth>
struct cv::cudev::HLS_to_BGR_func;

template <>
struct cv::cudev::HLS_to_RGBA_FULL_func<float>;

template <typename SrcDepth>
struct cv::cudev::HLS_to_RGBA_FULL_func;

template <>
struct cv::cudev::HLS_to_RGBA_func<float>;

template <typename SrcDepth>
struct cv::cudev::HLS_to_RGBA_func;

template <>
struct cv::cudev::HLS_to_RGB_FULL_func<float>;

template <typename SrcDepth>
struct cv::cudev::HLS_to_RGB_FULL_func;

template <typename SrcDepth>
struct cv::cudev::HLS_to_RGB_func;

template <>
struct cv::cudev::HLS_to_RGB_func<float>;

template <typename SrcDepth>
struct cv::cudev::HSV4_to_BGRA_FULL_func;

template <>
struct cv::cudev::HSV4_to_BGRA_FULL_func<float>;

template <>
struct cv::cudev::HSV4_to_BGRA_func<float>;

template <typename SrcDepth>
struct cv::cudev::HSV4_to_BGRA_func;

template <>
struct cv::cudev::HSV4_to_BGR_FULL_func<float>;

template <typename SrcDepth>
struct cv::cudev::HSV4_to_BGR_FULL_func;

template <typename SrcDepth>
struct cv::cudev::HSV4_to_BGR_func;

template <>
struct cv::cudev::HSV4_to_BGR_func<float>;

template <>
struct cv::cudev::HSV4_to_RGBA_FULL_func<float>;

template <typename SrcDepth>
struct cv::cudev::HSV4_to_RGBA_FULL_func;

template <typename SrcDepth>
struct cv::cudev::HSV4_to_RGBA_func;

template <>
struct cv::cudev::HSV4_to_RGBA_func<float>;

template <>
struct cv::cudev::HSV4_to_RGB_FULL_func<float>;

template <typename SrcDepth>
struct cv::cudev::HSV4_to_RGB_FULL_func;

template <>
struct cv::cudev::HSV4_to_RGB_func<float>;

template <typename SrcDepth>
struct cv::cudev::HSV4_to_RGB_func;

template <>
struct cv::cudev::HSV_to_BGRA_FULL_func<float>;

template <typename SrcDepth>
struct cv::cudev::HSV_to_BGRA_FULL_func;

template <typename SrcDepth>
struct cv::cudev::HSV_to_BGRA_func;

template <>
struct cv::cudev::HSV_to_BGRA_func<float>;

template <>
struct cv::cudev::HSV_to_BGR_FULL_func<float>;

template <typename SrcDepth>
struct cv::cudev::HSV_to_BGR_FULL_func;

template <typename SrcDepth>
struct cv::cudev::HSV_to_BGR_func;

template <>
struct cv::cudev::HSV_to_BGR_func<float>;

template <>
struct cv::cudev::HSV_to_RGBA_FULL_func<float>;

template <typename SrcDepth>
struct cv::cudev::HSV_to_RGBA_FULL_func;

template <typename SrcDepth>
struct cv::cudev::HSV_to_RGBA_func;

template <>
struct cv::cudev::HSV_to_RGBA_func<float>;

template <>
struct cv::cudev::HSV_to_RGB_FULL_func<float>;

template <typename SrcDepth>
struct cv::cudev::HSV_to_RGB_FULL_func;

template <typename SrcDepth>
struct cv::cudev::HSV_to_RGB_func;

template <>
struct cv::cudev::HSV_to_RGB_func<float>;

template <
    int BIN_COUNT,
    class SrcPtr
    >
struct cv::cudev::HistogramBody;

template <int A>
struct cv::cudev::Int2Type;

template <typename SrcPtr>
struct cv::cudev::IntegerAreaInterPtr;

template <class SrcPtr>
struct cv::cudev::IntegerAreaInterPtrSz;

template <class SrcPtr>
struct cv::cudev::IntegralBody;

template <typename F>
struct cv::cudev::IsBinaryFunction;

template <int N>
struct cv::cudev::IsPowerOf2;

template <typename F>
struct cv::cudev::IsUnaryFunction;

template <typename SrcDepth>
struct cv::cudev::LBGRA_to_Lab4_func;

template <typename SrcDepth>
struct cv::cudev::LBGRA_to_Lab_func;

template <typename SrcDepth>
struct cv::cudev::LBGRA_to_Luv4_func;

template <typename SrcDepth>
struct cv::cudev::LBGRA_to_Luv_func;

template <typename SrcDepth>
struct cv::cudev::LBGR_to_Lab4_func;

template <typename SrcDepth>
struct cv::cudev::LBGR_to_Lab_func;

template <typename SrcDepth>
struct cv::cudev::LBGR_to_Luv4_func;

template <typename SrcDepth>
struct cv::cudev::LBGR_to_Luv_func;

template <typename SrcDepth>
struct cv::cudev::LRGBA_to_Lab4_func;

template <typename SrcDepth>
struct cv::cudev::LRGBA_to_Lab_func;

template <typename SrcDepth>
struct cv::cudev::LRGBA_to_Luv4_func;

template <typename SrcDepth>
struct cv::cudev::LRGBA_to_Luv_func;

template <typename SrcDepth>
struct cv::cudev::LRGB_to_Lab4_func;

template <typename SrcDepth>
struct cv::cudev::LRGB_to_Lab_func;

template <typename SrcDepth>
struct cv::cudev::LRGB_to_Luv4_func;

template <typename SrcDepth>
struct cv::cudev::LRGB_to_Luv_func;

template <typename SrcDepth>
struct cv::cudev::Lab4_to_BGRA_func;

template <typename SrcDepth>
struct cv::cudev::Lab4_to_BGR_func;

template <typename SrcDepth>
struct cv::cudev::Lab4_to_LBGRA_func;

template <typename SrcDepth>
struct cv::cudev::Lab4_to_LBGR_func;

template <typename SrcDepth>
struct cv::cudev::Lab4_to_LRGBA_func;

template <typename SrcDepth>
struct cv::cudev::Lab4_to_LRGB_func;

template <typename SrcDepth>
struct cv::cudev::Lab4_to_RGBA_func;

template <typename SrcDepth>
struct cv::cudev::Lab4_to_RGB_func;

template <typename SrcDepth>
struct cv::cudev::Lab_to_BGRA_func;

template <typename SrcDepth>
struct cv::cudev::Lab_to_BGR_func;

template <typename SrcDepth>
struct cv::cudev::Lab_to_LBGRA_func;

template <typename SrcDepth>
struct cv::cudev::Lab_to_LBGR_func;

template <typename SrcDepth>
struct cv::cudev::Lab_to_LRGBA_func;

template <typename SrcDepth>
struct cv::cudev::Lab_to_LRGB_func;

template <typename SrcDepth>
struct cv::cudev::Lab_to_RGBA_func;

template <typename SrcDepth>
struct cv::cudev::Lab_to_RGB_func;

template <class SrcPtr>
struct cv::cudev::LaplacianPtr<1, SrcPtr>;

template <
    int ksize,
    class SrcPtr
    >
struct cv::cudev::LaplacianPtr;

template <class SrcPtr>
struct cv::cudev::LaplacianPtr<3, SrcPtr>;

template <
    int ksize,
    class SrcPtr
    >
struct cv::cudev::LaplacianPtrSz;

template <
    typename A,
    typename B
    >
struct cv::cudev::LargerType;

template <typename SrcPtr>
struct cv::cudev::LinearInterPtr;

template <class SrcPtr>
struct cv::cudev::LinearInterPtrSz;

template <
    int N,
    int CURRENT_VAL = N,
    int COUNT = 0
    >
struct cv::cudev::Log2;

template <
    int N,
    int COUNT
    >
struct cv::cudev::Log2<N, 0, COUNT>;

template <
    class SrcPtr,
    class TablePtr
    >
struct cv::cudev::LutPtr;

template <
    class SrcPtr,
    class TablePtr
    >
struct cv::cudev::LutPtrSz;

template <typename SrcDepth>
struct cv::cudev::Luv4_to_BGRA_func;

template <typename SrcDepth>
struct cv::cudev::Luv4_to_BGR_func;

template <typename SrcDepth>
struct cv::cudev::Luv4_to_LBGRA_func;

template <typename SrcDepth>
struct cv::cudev::Luv4_to_LBGR_func;

template <typename SrcDepth>
struct cv::cudev::Luv4_to_LRGBA_func;

template <typename SrcDepth>
struct cv::cudev::Luv4_to_LRGB_func;

template <typename SrcDepth>
struct cv::cudev::Luv4_to_RGBA_func;

template <typename SrcDepth>
struct cv::cudev::Luv4_to_RGB_func;

template <typename SrcDepth>
struct cv::cudev::Luv_to_BGRA_func;

template <typename SrcDepth>
struct cv::cudev::Luv_to_BGR_func;

template <typename SrcDepth>
struct cv::cudev::Luv_to_LBGRA_func;

template <typename SrcDepth>
struct cv::cudev::Luv_to_LBGR_func;

template <typename SrcDepth>
struct cv::cudev::Luv_to_LRGBA_func;

template <typename SrcDepth>
struct cv::cudev::Luv_to_LRGB_func;

template <typename SrcDepth>
struct cv::cudev::Luv_to_RGBA_func;

template <typename SrcDepth>
struct cv::cudev::Luv_to_RGB_func;

template <>
struct cv::cudev::MakeVec<double, 4>;

template <>
struct cv::cudev::MakeVec<ushort, 2>;

template <>
struct cv::cudev::MakeVec<ushort, 1>;

template <>
struct cv::cudev::MakeVec<uint, 3>;

template <>
struct cv::cudev::MakeVec<ushort, 3>;

template <>
struct cv::cudev::MakeVec<uint, 4>;

template <>
struct cv::cudev::MakeVec<ushort, 4>;

template <>
struct cv::cudev::MakeVec<bool, 4>;

template <>
struct cv::cudev::MakeVec<uint, 2>;

template <
    typename T,
    int CN
    >
struct cv::cudev::MakeVec;

template <>
struct cv::cudev::MakeVec<double, 3>;

template <>
struct cv::cudev::MakeVec<bool, 1>;

template <>
struct cv::cudev::MakeVec<bool, 3>;

template <>
struct cv::cudev::MakeVec<bool, 2>;

template <>
struct cv::cudev::MakeVec<double, 1>;

template <>
struct cv::cudev::MakeVec<uint, 1>;

template <>
struct cv::cudev::MakeVec<uchar, 3>;

template <>
struct cv::cudev::MakeVec<schar, 1>;

template <>
struct cv::cudev::MakeVec<float, 4>;

template <>
struct cv::cudev::MakeVec<float, 2>;

template <>
struct cv::cudev::MakeVec<float, 1>;

template <>
struct cv::cudev::MakeVec<schar, 2>;

template <>
struct cv::cudev::MakeVec<schar, 4>;

template <>
struct cv::cudev::MakeVec<schar, 3>;

template <>
struct cv::cudev::MakeVec<uchar, 4>;

template <>
struct cv::cudev::MakeVec<double, 2>;

template <>
struct cv::cudev::MakeVec<float, 3>;

template <>
struct cv::cudev::MakeVec<uchar, 1>;

template <>
struct cv::cudev::MakeVec<short, 2>;

template <>
struct cv::cudev::MakeVec<short, 3>;

template <>
struct cv::cudev::MakeVec<short, 1>;

template <>
struct cv::cudev::MakeVec<uchar, 2>;

template <>
struct cv::cudev::MakeVec<short, 4>;

template <typename T>
struct cv::cudev::Max;

template <typename T>
struct cv::cudev::Min;

template <class SrcPtr>
struct cv::cudev::NearestInterPtr;

template <class SrcPtr>
struct cv::cudev::NearestInterPtrSz;

struct cv::cudev::NormHamming;

template <typename T>
struct cv::cudev::NormL1;

template <>
struct cv::cudev::NormL1<float>;

struct cv::cudev::NormL2;
struct cv::cudev::NullType;
struct cv::cudev::PerspectiveMapPtr;
struct cv::cudev::PerspectiveMapPtrSz;

template <
    class SrcPtr,
    class MapXPtr,
    class MapYPtr
    >
struct cv::cudev::PtrTraits<RemapPtr2Sz<SrcPtr, MapXPtr, MapYPtr>>;

template <class Body>
struct cv::cudev::PtrTraits<Expr<Body>>;

template <
    class SrcPtr,
    class Op
    >
struct cv::cudev::PtrTraits<UnaryTransformPtrSz<SrcPtr, Op>>;

template <class PtrTuple>
struct cv::cudev::PtrTraits<ZipPtrSz<PtrTuple>>;

template <typename T>
struct cv::cudev::PtrTraits<Texture<T>>;

template <class SrcPtr>
struct cv::cudev::PtrTraits<DerivYPtrSz<SrcPtr>>;

template <class SrcPtr>
struct cv::cudev::PtrTraits<CubicInterPtrSz<SrcPtr>>;

template <class Ptr2DSz>
struct cv::cudev::PtrTraits;

template <class SrcPtr>
struct cv::cudev::PtrTraits<DerivXPtrSz<SrcPtr>>;

template <class SrcPtr>
struct cv::cudev::PtrTraits<CommonAreaInterPtrSz<SrcPtr>>;

template <typename T>
struct cv::cudev::PtrTraits<ConstantPtrSz<T>>;

template <
    class SrcPtr,
    class MapPtr
    >
struct cv::cudev::PtrTraits<RemapPtr1Sz<SrcPtr, MapPtr>>;

template <class SrcPtr>
struct cv::cudev::PtrTraits<SobelYPtrSz<SrcPtr>>;

template <class MaskPtr>
struct cv::cudev::PtrTraits<SingleMaskChannelsSz<MaskPtr>>;

template <
    class SrcPtr,
    class TablePtr
    >
struct cv::cudev::PtrTraits<LutPtrSz<SrcPtr, TablePtr>>;

template <class SrcPtr>
struct cv::cudev::PtrTraits<LinearInterPtrSz<SrcPtr>>;

template <class SrcPtr>
struct cv::cudev::PtrTraits<NearestInterPtrSz<SrcPtr>>;

template <>
struct cv::cudev::PtrTraits<PerspectiveMapPtrSz>;

template <class SrcPtr>
struct cv::cudev::PtrTraits<SobelXPtrSz<SrcPtr>>;

template <
    int ksize,
    class SrcPtr
    >
struct cv::cudev::PtrTraits<LaplacianPtrSz<ksize, SrcPtr>>;

template <typename T>
struct cv::cudev::PtrTraits<GpuMat_<T>>;

template <class SrcPtr>
struct cv::cudev::PtrTraits<ScharrYPtrSz<SrcPtr>>;

template <class SrcPtr>
struct cv::cudev::PtrTraits<IntegerAreaInterPtrSz<SrcPtr>>;

template <class SrcPtr>
struct cv::cudev::PtrTraits<ScharrXPtrSz<SrcPtr>>;

template <typename T>
struct cv::cudev::PtrTraits<GlobPtrSz<T>>;

template <class SrcPtr>
struct cv::cudev::PtrTraits<ResizePtrSz<SrcPtr>>;

template <
    class Src1Ptr,
    class Src2Ptr,
    class Op
    >
struct cv::cudev::PtrTraits<BinaryTransformPtrSz<Src1Ptr, Src2Ptr, Op>>;

template <>
struct cv::cudev::PtrTraits<AffineMapPtrSz>;

template <
    class Ptr2DSz,
    class Ptr2D
    >
struct cv::cudev::PtrTraitsBase;

template <class SrcPtr>
struct cv::cudev::PyrDownBody;

template <class SrcPtr>
struct cv::cudev::PyrUpBody;

template <typename SrcDepth>
struct cv::cudev::RGBA_to_GRAY_func;

template <typename SrcDepth>
struct cv::cudev::RGBA_to_HLS4_FULL_func;

template <>
struct cv::cudev::RGBA_to_HLS4_FULL_func<float>;

template <typename SrcDepth>
struct cv::cudev::RGBA_to_HLS4_func;

template <>
struct cv::cudev::RGBA_to_HLS4_func<float>;

template <typename SrcDepth>
struct cv::cudev::RGBA_to_HLS_FULL_func;

template <>
struct cv::cudev::RGBA_to_HLS_FULL_func<float>;

template <typename SrcDepth>
struct cv::cudev::RGBA_to_HLS_func;

template <>
struct cv::cudev::RGBA_to_HLS_func<float>;

template <>
struct cv::cudev::RGBA_to_HSV4_FULL_func<float>;

template <typename SrcDepth>
struct cv::cudev::RGBA_to_HSV4_FULL_func;

template <>
struct cv::cudev::RGBA_to_HSV4_func<float>;

template <typename SrcDepth>
struct cv::cudev::RGBA_to_HSV4_func;

template <typename SrcDepth>
struct cv::cudev::RGBA_to_HSV_FULL_func;

template <>
struct cv::cudev::RGBA_to_HSV_FULL_func<float>;

template <typename SrcDepth>
struct cv::cudev::RGBA_to_HSV_func;

template <>
struct cv::cudev::RGBA_to_HSV_func<float>;

template <typename SrcDepth>
struct cv::cudev::RGBA_to_Lab4_func;

template <typename SrcDepth>
struct cv::cudev::RGBA_to_Lab_func;

template <typename SrcDepth>
struct cv::cudev::RGBA_to_Luv4_func;

template <typename SrcDepth>
struct cv::cudev::RGBA_to_Luv_func;

template <typename SrcDepth>
struct cv::cudev::RGBA_to_XYZ4_func;

template <typename SrcDepth>
struct cv::cudev::RGBA_to_XYZ_func;

template <typename SrcDepth>
struct cv::cudev::RGBA_to_YCrCb4_func;

template <typename SrcDepth>
struct cv::cudev::RGBA_to_YCrCb_func;

template <typename SrcDepth>
struct cv::cudev::RGBA_to_YUV4_func;

template <typename SrcDepth>
struct cv::cudev::RGBA_to_YUV_func;

template <typename SrcDepth>
struct cv::cudev::RGB_to_GRAY_func;

template <>
struct cv::cudev::RGB_to_HLS4_FULL_func<float>;

template <typename SrcDepth>
struct cv::cudev::RGB_to_HLS4_FULL_func;

template <typename SrcDepth>
struct cv::cudev::RGB_to_HLS4_func;

template <>
struct cv::cudev::RGB_to_HLS4_func<float>;

template <>
struct cv::cudev::RGB_to_HLS_FULL_func<float>;

template <typename SrcDepth>
struct cv::cudev::RGB_to_HLS_FULL_func;

template <>
struct cv::cudev::RGB_to_HLS_func<float>;

template <typename SrcDepth>
struct cv::cudev::RGB_to_HLS_func;

template <>
struct cv::cudev::RGB_to_HSV4_FULL_func<float>;

template <typename SrcDepth>
struct cv::cudev::RGB_to_HSV4_FULL_func;

template <>
struct cv::cudev::RGB_to_HSV4_func<float>;

template <typename SrcDepth>
struct cv::cudev::RGB_to_HSV4_func;

template <typename SrcDepth>
struct cv::cudev::RGB_to_HSV_FULL_func;

template <>
struct cv::cudev::RGB_to_HSV_FULL_func<float>;

template <>
struct cv::cudev::RGB_to_HSV_func<float>;

template <typename SrcDepth>
struct cv::cudev::RGB_to_HSV_func;

template <typename SrcDepth>
struct cv::cudev::RGB_to_Lab4_func;

template <typename SrcDepth>
struct cv::cudev::RGB_to_Lab_func;

template <typename SrcDepth>
struct cv::cudev::RGB_to_Luv4_func;

template <typename SrcDepth>
struct cv::cudev::RGB_to_Luv_func;

template <typename SrcDepth>
struct cv::cudev::RGB_to_XYZ4_func;

template <typename SrcDepth>
struct cv::cudev::RGB_to_XYZ_func;

template <typename SrcDepth>
struct cv::cudev::RGB_to_YCrCb4_func;

template <typename SrcDepth>
struct cv::cudev::RGB_to_YCrCb_func;

template <typename SrcDepth>
struct cv::cudev::RGB_to_YUV4_func;

template <typename SrcDepth>
struct cv::cudev::RGB_to_YUV_func;

template <
    class Reductor,
    class SrcPtr
    >
struct cv::cudev::ReduceToColumnBody;

template <
    class Reductor,
    class SrcPtr
    >
struct cv::cudev::ReduceToRowBody;

template <
    class SrcPtr,
    class MapPtr
    >
struct cv::cudev::RemapPtr1;

template <
    class SrcPtr,
    class MapPtr
    >
struct cv::cudev::RemapPtr1Sz;

template <
    class SrcPtr,
    class MapXPtr,
    class MapYPtr
    >
struct cv::cudev::RemapPtr2;

template <
    class SrcPtr,
    class MapXPtr,
    class MapYPtr
    >
struct cv::cudev::RemapPtr2Sz;

template <class SrcPtr>
struct cv::cudev::ResizePtr;

template <class SrcPtr>
struct cv::cudev::ResizePtrSz;

template <class SrcPtr>
struct cv::cudev::ScharrXPtr;

template <class SrcPtr>
struct cv::cudev::ScharrXPtrSz;

template <class SrcPtr>
struct cv::cudev::ScharrYPtr;

template <class SrcPtr>
struct cv::cudev::ScharrYPtrSz;

template <
    bool,
    typename ThenType,
    typename ElseType
    >
struct cv::cudev::SelectIf;

template <
    typename ThenType,
    typename ElseType
    >
struct cv::cudev::SelectIf<false, ThenType, ElseType>;

template <class MaskPtr>
struct cv::cudev::SingleMaskChannels;

template <class MaskPtr>
struct cv::cudev::SingleMaskChannelsSz;

template <class SrcPtr>
struct cv::cudev::SobelXPtr;

template <class SrcPtr>
struct cv::cudev::SobelXPtrSz;

template <class SrcPtr>
struct cv::cudev::SobelYPtr;

template <class SrcPtr>
struct cv::cudev::SobelYPtrSz;

template <typename T>
struct cv::cudev::Sum;

template <class SrcPtr>
struct cv::cudev::SumExprBody;

template <typename T>
struct cv::cudev::Texture;

template <typename T>
struct cv::cudev::TexturePtr;

template <typename T>
struct cv::cudev::ThreshBinaryFunc;

template <typename T>
struct cv::cudev::ThreshBinaryInvFunc;

template <typename T>
struct cv::cudev::ThreshToZeroFunc;

template <typename T>
struct cv::cudev::ThreshToZeroInvFunc;

template <typename T>
struct cv::cudev::ThreshTruncFunc;

template <class SrcPtr>
struct cv::cudev::TransposeBody;

template <
    typename P0,
    typename P1,
    typename P2,
    typename P3,
    typename P4,
    typename P5,
    typename P6,
    typename P7,
    typename P8,
    typename P9
    >
struct cv::cudev::TupleTraits<tuple<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9>>;

template <typename T>
struct cv::cudev::TupleTraits;

template <typename T>
struct cv::cudev::TypeTraits;

template <typename A>
struct cv::cudev::TypesEquals<A, A>;

template <
    typename A,
    typename B
    >
struct cv::cudev::TypesEquals;

template <class Predicate>
struct cv::cudev::UnaryNegate;

template <
    class SrcPtr,
    class Op
    >
struct cv::cudev::UnaryTransformPtr;

template <
    class SrcPtr,
    class Op
    >
struct cv::cudev::UnaryTransformPtrSz;

template <
    class Op,
    int n
    >
struct cv::cudev::UnaryTupleAdapter;

template <>
struct cv::cudev::VecTraits<char4>;

template <>
struct cv::cudev::VecTraits<double4>;

template <>
struct cv::cudev::VecTraits<char3>;

template <>
struct cv::cudev::VecTraits<char2>;

template <>
struct cv::cudev::VecTraits<double>;

template <>
struct cv::cudev::VecTraits<double2>;

template <>
struct cv::cudev::VecTraits<double1>;

template <>
struct cv::cudev::VecTraits<uint1>;

template <>
struct cv::cudev::VecTraits<uint2>;

template <>
struct cv::cudev::VecTraits<uint>;

template <>
struct cv::cudev::VecTraits<char1>;

template <>
struct cv::cudev::VecTraits<uint3>;

template <>
struct cv::cudev::VecTraits<ushort3>;

template <>
struct cv::cudev::VecTraits<ushort4>;

template <typename T>
struct cv::cudev::VecTraits;

template <>
struct cv::cudev::VecTraits<ushort2>;

template <>
struct cv::cudev::VecTraits<ushort>;

template <>
struct cv::cudev::VecTraits<ushort1>;

template <>
struct cv::cudev::VecTraits<double3>;

template <>
struct cv::cudev::VecTraits<uchar4>;

template <>
struct cv::cudev::VecTraits<uint4>;

template <>
struct cv::cudev::VecTraits<uchar2>;

template <>
struct cv::cudev::VecTraits<float4>;

template <>
struct cv::cudev::VecTraits<int1>;

template <>
struct cv::cudev::VecTraits<uchar3>;

template <>
struct cv::cudev::VecTraits<int3>;

template <>
struct cv::cudev::VecTraits<float3>;

template <>
struct cv::cudev::VecTraits<float1>;

template <>
struct cv::cudev::VecTraits<float2>;

template <>
struct cv::cudev::VecTraits<float>;

template <>
struct cv::cudev::VecTraits<int4>;

template <>
struct cv::cudev::VecTraits<int2>;

template <>
struct cv::cudev::VecTraits<short4>;

template <>
struct cv::cudev::VecTraits<uchar>;

template <>
struct cv::cudev::VecTraits<uchar1>;

template <>
struct cv::cudev::VecTraits<schar>;

template <>
struct cv::cudev::VecTraits<short3>;

template <>
struct cv::cudev::VecTraits<short2>;

template <>
struct cv::cudev::VecTraits<short1>;

template <>
struct cv::cudev::VecTraits<short>;

struct cv::cudev::Warp;
struct cv::cudev::WithOutMask;

template <typename SrcDepth>
struct cv::cudev::XYZ4_to_BGRA_func;

template <typename SrcDepth>
struct cv::cudev::XYZ4_to_BGR_func;

template <typename SrcDepth>
struct cv::cudev::XYZ4_to_RGBA_func;

template <typename SrcDepth>
struct cv::cudev::XYZ4_to_RGB_func;

template <typename SrcDepth>
struct cv::cudev::XYZ_to_BGRA_func;

template <typename SrcDepth>
struct cv::cudev::XYZ_to_BGR_func;

template <typename SrcDepth>
struct cv::cudev::XYZ_to_RGBA_func;

template <typename SrcDepth>
struct cv::cudev::XYZ_to_RGB_func;

template <typename SrcDepth>
struct cv::cudev::YCrCb4_to_BGRA_func;

template <typename SrcDepth>
struct cv::cudev::YCrCb4_to_BGR_func;

template <typename SrcDepth>
struct cv::cudev::YCrCb4_to_RGBA_func;

template <typename SrcDepth>
struct cv::cudev::YCrCb4_to_RGB_func;

template <typename SrcDepth>
struct cv::cudev::YCrCb_to_BGRA_func;

template <typename SrcDepth>
struct cv::cudev::YCrCb_to_BGR_func;

template <typename SrcDepth>
struct cv::cudev::YCrCb_to_RGBA_func;

template <typename SrcDepth>
struct cv::cudev::YCrCb_to_RGB_func;

template <typename SrcDepth>
struct cv::cudev::YUV4_to_BGRA_func;

template <typename SrcDepth>
struct cv::cudev::YUV4_to_BGR_func;

template <typename SrcDepth>
struct cv::cudev::YUV4_to_RGBA_func;

template <typename SrcDepth>
struct cv::cudev::YUV4_to_RGB_func;

template <typename SrcDepth>
struct cv::cudev::YUV_to_BGRA_func;

template <typename SrcDepth>
struct cv::cudev::YUV_to_BGR_func;

template <typename SrcDepth>
struct cv::cudev::YUV_to_RGBA_func;

template <typename SrcDepth>
struct cv::cudev::YUV_to_RGB_func;

template <
    class Ptr0,
    class Ptr1,
    class Ptr2
    >
struct cv::cudev::ZipPtr<tuple<Ptr0, Ptr1, Ptr2>>;

template <
    class Ptr0,
    class Ptr1
    >
struct cv::cudev::ZipPtr<tuple<Ptr0, Ptr1>>;

template <
    class Ptr0,
    class Ptr1,
    class Ptr2,
    class Ptr3
    >
struct cv::cudev::ZipPtr<tuple<Ptr0, Ptr1, Ptr2, Ptr3>>;

template <class PtrTuple>
struct cv::cudev::ZipPtr;

template <class PtrTuple>
struct cv::cudev::ZipPtrSz;

template <typename T>
struct cv::cudev::abs_func;

template <>
struct cv::cudev::abs_func<uchar>;

template <>
struct cv::cudev::abs_func<short>;

template <>
struct cv::cudev::abs_func<ushort>;

template <>
struct cv::cudev::abs_func<schar>;

template <>
struct cv::cudev::abs_func<double>;

template <>
struct cv::cudev::abs_func<float>;

template <>
struct cv::cudev::abs_func<uint>;

template <typename T>
struct cv::cudev::absdiff_func;

template <>
struct cv::cudev::acos_func<uint>;

template <>
struct cv::cudev::acos_func<short>;

template <>
struct cv::cudev::acos_func<uchar>;

template <>
struct cv::cudev::acos_func<schar>;

template <>
struct cv::cudev::acos_func<double>;

template <>
struct cv::cudev::acos_func<ushort>;

template <typename T>
struct cv::cudev::acos_func;

template <>
struct cv::cudev::acos_func<float>;

template <>
struct cv::cudev::acosh_func<uint>;

template <>
struct cv::cudev::acosh_func<ushort>;

template <>
struct cv::cudev::acosh_func<short>;

template <>
struct cv::cudev::acosh_func<uchar>;

template <>
struct cv::cudev::acosh_func<schar>;

template <typename T>
struct cv::cudev::acosh_func;

template <>
struct cv::cudev::acosh_func<float>;

template <>
struct cv::cudev::acosh_func<double>;

template <>
struct cv::cudev::asin_func<uint>;

template <>
struct cv::cudev::asin_func<ushort>;

template <>
struct cv::cudev::asin_func<uchar>;

template <>
struct cv::cudev::asin_func<short>;

template <>
struct cv::cudev::asin_func<schar>;

template <>
struct cv::cudev::asin_func<float>;

template <typename T>
struct cv::cudev::asin_func;

template <>
struct cv::cudev::asin_func<double>;

template <>
struct cv::cudev::asinh_func<uchar>;

template <>
struct cv::cudev::asinh_func<short>;

template <>
struct cv::cudev::asinh_func<ushort>;

template <>
struct cv::cudev::asinh_func<schar>;

template <>
struct cv::cudev::asinh_func<uint>;

template <>
struct cv::cudev::asinh_func<double>;

template <typename T>
struct cv::cudev::asinh_func;

template <>
struct cv::cudev::asinh_func<float>;

template <>
struct cv::cudev::atan2_func<uchar>;

template <>
struct cv::cudev::atan2_func<short>;

template <>
struct cv::cudev::atan2_func<ushort>;

template <>
struct cv::cudev::atan2_func<schar>;

template <>
struct cv::cudev::atan2_func<uint>;

template <>
struct cv::cudev::atan2_func<double>;

template <>
struct cv::cudev::atan2_func<float>;

template <typename T>
struct cv::cudev::atan2_func;

template <>
struct cv::cudev::atan_func<uint>;

template <>
struct cv::cudev::atan_func<uchar>;

template <>
struct cv::cudev::atan_func<short>;

template <>
struct cv::cudev::atan_func<schar>;

template <>
struct cv::cudev::atan_func<ushort>;

template <>
struct cv::cudev::atan_func<double>;

template <typename T>
struct cv::cudev::atan_func;

template <>
struct cv::cudev::atan_func<float>;

template <>
struct cv::cudev::atanh_func<short>;

template <typename T>
struct cv::cudev::atanh_func;

template <>
struct cv::cudev::atanh_func<ushort>;

template <>
struct cv::cudev::atanh_func<schar>;

template <>
struct cv::cudev::atanh_func<float>;

template <>
struct cv::cudev::atanh_func<uchar>;

template <>
struct cv::cudev::atanh_func<double>;

template <>
struct cv::cudev::atanh_func<uint>;

template <
    typename _Arg1,
    typename _Arg2,
    typename _Result
    >
struct cv::cudev::binary_function;

template <typename T>
struct cv::cudev::bit_and;

template <typename T>
struct cv::cudev::bit_lshift;

template <typename T>
struct cv::cudev::bit_not;

template <typename T>
struct cv::cudev::bit_or;

template <typename T>
struct cv::cudev::bit_rshift;

template <typename T>
struct cv::cudev::bit_xor;

template <>
struct cv::cudev::cos_func<short>;

template <>
struct cv::cudev::cos_func<schar>;

template <typename T>
struct cv::cudev::cos_func;

template <>
struct cv::cudev::cos_func<float>;

template <>
struct cv::cudev::cos_func<double>;

template <>
struct cv::cudev::cos_func<uchar>;

template <>
struct cv::cudev::cos_func<uint>;

template <>
struct cv::cudev::cos_func<ushort>;

template <>
struct cv::cudev::cosh_func<uint>;

template <>
struct cv::cudev::cosh_func<float>;

template <>
struct cv::cudev::cosh_func<double>;

template <>
struct cv::cudev::cosh_func<schar>;

template <>
struct cv::cudev::cosh_func<ushort>;

template <typename T>
struct cv::cudev::cosh_func;

template <>
struct cv::cudev::cosh_func<uchar>;

template <>
struct cv::cudev::cosh_func<short>;

template <
    typename T,
    bool angleInDegrees
    >
struct cv::cudev::direction_func;

template <typename T>
struct cv::cudev::divides;

template <typename T>
struct cv::cudev::equal_to;

template <>
struct cv::cudev::exp10_func<uchar>;

template <>
struct cv::cudev::exp10_func<short>;

template <>
struct cv::cudev::exp10_func<schar>;

template <>
struct cv::cudev::exp10_func<double>;

template <>
struct cv::cudev::exp10_func<float>;

template <>
struct cv::cudev::exp10_func<uint>;

template <typename T>
struct cv::cudev::exp10_func;

template <>
struct cv::cudev::exp10_func<ushort>;

template <typename T>
struct cv::cudev::exp2_func;

template <>
struct cv::cudev::exp2_func<uchar>;

template <>
struct cv::cudev::exp2_func<ushort>;

template <>
struct cv::cudev::exp2_func<short>;

template <>
struct cv::cudev::exp2_func<uint>;

template <>
struct cv::cudev::exp2_func<double>;

template <>
struct cv::cudev::exp2_func<float>;

template <>
struct cv::cudev::exp2_func<schar>;

template <>
struct cv::cudev::exp_func<uchar>;

template <>
struct cv::cudev::exp_func<uint>;

template <>
struct cv::cudev::exp_func<ushort>;

template <>
struct cv::cudev::exp_func<short>;

template <>
struct cv::cudev::exp_func<float>;

template <>
struct cv::cudev::exp_func<schar>;

template <typename T>
struct cv::cudev::exp_func;

template <>
struct cv::cudev::exp_func<double>;

template <typename T>
struct cv::cudev::greater;

template <typename T>
struct cv::cudev::greater_equal;

template <>
struct cv::cudev::hypot_func<ushort>;

template <>
struct cv::cudev::hypot_func<uint>;

template <>
struct cv::cudev::hypot_func<short>;

template <typename T>
struct cv::cudev::hypot_func;

template <>
struct cv::cudev::hypot_func<float>;

template <>
struct cv::cudev::hypot_func<schar>;

template <>
struct cv::cudev::hypot_func<uchar>;

template <>
struct cv::cudev::hypot_func<double>;

template <typename T>
struct cv::cudev::identity;

template <typename T>
struct cv::cudev::less;

template <typename T>
struct cv::cudev::less_equal;

template <>
struct cv::cudev::log10_func<uint>;

template <>
struct cv::cudev::log10_func<ushort>;

template <>
struct cv::cudev::log10_func<uchar>;

template <>
struct cv::cudev::log10_func<schar>;

template <>
struct cv::cudev::log10_func<double>;

template <>
struct cv::cudev::log10_func<short>;

template <typename T>
struct cv::cudev::log10_func;

template <>
struct cv::cudev::log10_func<float>;

template <>
struct cv::cudev::log2_func<ushort>;

template <>
struct cv::cudev::log2_func<short>;

template <>
struct cv::cudev::log2_func<double>;

template <typename T>
struct cv::cudev::log2_func;

template <>
struct cv::cudev::log2_func<float>;

template <>
struct cv::cudev::log2_func<schar>;

template <>
struct cv::cudev::log2_func<uchar>;

template <>
struct cv::cudev::log2_func<uint>;

template <>
struct cv::cudev::log_func<uint>;

template <>
struct cv::cudev::log_func<schar>;

template <>
struct cv::cudev::log_func<short>;

template <>
struct cv::cudev::log_func<uchar>;

template <>
struct cv::cudev::log_func<float>;

template <typename T>
struct cv::cudev::log_func;

template <>
struct cv::cudev::log_func<double>;

template <>
struct cv::cudev::log_func<ushort>;

template <typename T>
struct cv::cudev::logical_and;

template <typename T>
struct cv::cudev::logical_not;

template <typename T>
struct cv::cudev::logical_or;

template <typename T>
struct cv::cudev::magnitude_func;

template <typename T>
struct cv::cudev::magnitude_sqr_func;

template <>
struct cv::cudev::maximum<schar>;

template <>
struct cv::cudev::maximum<float>;

template <>
struct cv::cudev::maximum<double>;

template <>
struct cv::cudev::maximum<ushort>;

template <>
struct cv::cudev::maximum<uchar>;

template <typename T>
struct cv::cudev::maximum;

template <>
struct cv::cudev::maximum<uint>;

template <>
struct cv::cudev::maximum<short>;

template <typename T>
struct cv::cudev::minimum;

template <>
struct cv::cudev::minimum<uchar>;

template <>
struct cv::cudev::minimum<uint>;

template <>
struct cv::cudev::minimum<ushort>;

template <>
struct cv::cudev::minimum<schar>;

template <>
struct cv::cudev::minimum<short>;

template <>
struct cv::cudev::minimum<float>;

template <>
struct cv::cudev::minimum<double>;

template <typename T>
struct cv::cudev::minus;

template <typename T>
struct cv::cudev::modulus;

template <typename T>
struct cv::cudev::multiplies;

template <typename T>
struct cv::cudev::negate;

template <typename T>
struct cv::cudev::not_equal_to;

template <>
struct cv::cudev::numeric_limits<uint>;

template <>
struct cv::cudev::numeric_limits<uchar>;

template <>
struct cv::cudev::numeric_limits<schar>;

template <>
struct cv::cudev::numeric_limits<float>;

template <>
struct cv::cudev::numeric_limits<ushort>;

template <>
struct cv::cudev::numeric_limits<bool>;

template <class T>
struct cv::cudev::numeric_limits;

template <>
struct cv::cudev::numeric_limits<double>;

template <>
struct cv::cudev::numeric_limits<short>;

template <typename T>
struct cv::cudev::plus;

template <typename T>
struct cv::cudev::pow_func;

template <>
struct cv::cudev::pow_func<double>;

template <
    typename T1,
    typename T2
    >
struct cv::cudev::project1st;

template <
    typename T1,
    typename T2
    >
struct cv::cudev::project2nd;

template <>
struct cv::cudev::saturate_cast_fp16_func<short, float>;

template <>
struct cv::cudev::saturate_cast_fp16_func<float, short>;

template <
    typename T,
    typename D
    >
struct cv::cudev::saturate_cast_fp16_func;

template <
    typename T,
    typename D
    >
struct cv::cudev::saturate_cast_func;

template <>
struct cv::cudev::sin_func<ushort>;

template <>
struct cv::cudev::sin_func<uint>;

template <>
struct cv::cudev::sin_func<uchar>;

template <>
struct cv::cudev::sin_func<short>;

template <>
struct cv::cudev::sin_func<schar>;

template <>
struct cv::cudev::sin_func<double>;

template <typename T>
struct cv::cudev::sin_func;

template <>
struct cv::cudev::sin_func<float>;

template <>
struct cv::cudev::sinh_func<uchar>;

template <>
struct cv::cudev::sinh_func<uint>;

template <>
struct cv::cudev::sinh_func<ushort>;

template <>
struct cv::cudev::sinh_func<short>;

template <>
struct cv::cudev::sinh_func<double>;

template <>
struct cv::cudev::sinh_func<float>;

template <>
struct cv::cudev::sinh_func<schar>;

template <typename T>
struct cv::cudev::sinh_func;

template <typename T>
struct cv::cudev::sqr_func;

template <>
struct cv::cudev::sqrt_func<short>;

template <>
struct cv::cudev::sqrt_func<ushort>;

template <>
struct cv::cudev::sqrt_func<uchar>;

template <>
struct cv::cudev::sqrt_func<uint>;

template <>
struct cv::cudev::sqrt_func<schar>;

template <typename T>
struct cv::cudev::sqrt_func;

template <>
struct cv::cudev::sqrt_func<double>;

template <>
struct cv::cudev::sqrt_func<float>;

template <>
struct cv::cudev::tan_func<ushort>;

template <>
struct cv::cudev::tan_func<uint>;

template <>
struct cv::cudev::tan_func<uchar>;

template <>
struct cv::cudev::tan_func<float>;

template <>
struct cv::cudev::tan_func<short>;

template <>
struct cv::cudev::tan_func<double>;

template <>
struct cv::cudev::tan_func<schar>;

template <typename T>
struct cv::cudev::tan_func;

template <>
struct cv::cudev::tanh_func<uint>;

template <typename T>
struct cv::cudev::tanh_func;

template <>
struct cv::cudev::tanh_func<ushort>;

template <>
struct cv::cudev::tanh_func<double>;

template <>
struct cv::cudev::tanh_func<schar>;

template <>
struct cv::cudev::tanh_func<float>;

template <>
struct cv::cudev::tanh_func<uchar>;

template <>
struct cv::cudev::tanh_func<short>;

template <
    typename _Arg,
    typename _Result
    >
struct cv::cudev::unary_function;

// classes

template <typename T>
class cv::cudev::GpuMat_;

// global functions

__device__ __forceinline__ uchar1
cv::cudev::abs(const uchar1& a);

__device__ __forceinline__ uchar2
cv::cudev::abs(const uchar2& a);

__device__ __forceinline__ uchar3
cv::cudev::abs(const uchar3& a);

__device__ __forceinline__ uchar4
cv::cudev::abs(const uchar4& a);

__device__ __forceinline__ char1
cv::cudev::abs(const char1& a);

__device__ __forceinline__ char2
cv::cudev::abs(const char2& a);

__device__ __forceinline__ char3
cv::cudev::abs(const char3& a);

__device__ __forceinline__ char4
cv::cudev::abs(const char4& a);

__device__ __forceinline__ ushort1
cv::cudev::abs(const ushort1& a);

__device__ __forceinline__ ushort2
cv::cudev::abs(const ushort2& a);

__device__ __forceinline__ ushort3
cv::cudev::abs(const ushort3& a);

__device__ __forceinline__ ushort4
cv::cudev::abs(const ushort4& a);

__device__ __forceinline__ short1
cv::cudev::abs(const short1& a);

__device__ __forceinline__ short2
cv::cudev::abs(const short2& a);

__device__ __forceinline__ short3
cv::cudev::abs(const short3& a);

__device__ __forceinline__ short4
cv::cudev::abs(const short4& a);

__device__ __forceinline__ int1
cv::cudev::abs(const int1& a);

__device__ __forceinline__ int2
cv::cudev::abs(const int2& a);

__device__ __forceinline__ int3
cv::cudev::abs(const int3& a);

__device__ __forceinline__ int4
cv::cudev::abs(const int4& a);

__device__ __forceinline__ uint1
cv::cudev::abs(const uint1& a);

__device__ __forceinline__ uint2
cv::cudev::abs(const uint2& a);

__device__ __forceinline__ uint3
cv::cudev::abs(const uint3& a);

__device__ __forceinline__ uint4
cv::cudev::abs(const uint4& a);

__device__ __forceinline__ float1
cv::cudev::abs(const float1& a);

__device__ __forceinline__ float2
cv::cudev::abs(const float2& a);

__device__ __forceinline__ float3
cv::cudev::abs(const float3& a);

__device__ __forceinline__ float4
cv::cudev::abs(const float4& a);

__device__ __forceinline__ double1
cv::cudev::abs(const double1& a);

__device__ __forceinline__ double2
cv::cudev::abs(const double2& a);

__device__ __forceinline__ double3
cv::cudev::abs(const double3& a);

__device__ __forceinline__ double4
cv::cudev::abs(const double4& a);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, abs_func<typename PtrTraits<SrcPtr>::value_type>>>
cv::cudev::abs_(const SrcPtr& src);

template <
    class SrcPtr1,
    class SrcPtr2
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<SrcPtr1>::ptr_type, typename PtrTraits<SrcPtr2>::ptr_type, absdiff_func<typename LargerType<typename PtrTraits<SrcPtr1>::value_type, typename PtrTraits<SrcPtr2>::value_type>::type>>>
cv::cudev::absdiff_(
    const SrcPtr1& src1,
    const SrcPtr2& src2
    );

__device__ __forceinline__ float1
cv::cudev::acos(const uchar1& a);

__device__ __forceinline__ float2
cv::cudev::acos(const uchar2& a);

__device__ __forceinline__ float3
cv::cudev::acos(const uchar3& a);

__device__ __forceinline__ float4
cv::cudev::acos(const uchar4& a);

__device__ __forceinline__ float1
cv::cudev::acos(const char1& a);

__device__ __forceinline__ float2
cv::cudev::acos(const char2& a);

__device__ __forceinline__ float3
cv::cudev::acos(const char3& a);

__device__ __forceinline__ float4
cv::cudev::acos(const char4& a);

__device__ __forceinline__ float1
cv::cudev::acos(const ushort1& a);

__device__ __forceinline__ float2
cv::cudev::acos(const ushort2& a);

__device__ __forceinline__ float3
cv::cudev::acos(const ushort3& a);

__device__ __forceinline__ float4
cv::cudev::acos(const ushort4& a);

__device__ __forceinline__ float1
cv::cudev::acos(const short1& a);

__device__ __forceinline__ float2
cv::cudev::acos(const short2& a);

__device__ __forceinline__ float3
cv::cudev::acos(const short3& a);

__device__ __forceinline__ float4
cv::cudev::acos(const short4& a);

__device__ __forceinline__ float1
cv::cudev::acos(const int1& a);

__device__ __forceinline__ float2
cv::cudev::acos(const int2& a);

__device__ __forceinline__ float3
cv::cudev::acos(const int3& a);

__device__ __forceinline__ float4
cv::cudev::acos(const int4& a);

__device__ __forceinline__ float1
cv::cudev::acos(const uint1& a);

__device__ __forceinline__ float2
cv::cudev::acos(const uint2& a);

__device__ __forceinline__ float3
cv::cudev::acos(const uint3& a);

__device__ __forceinline__ float4
cv::cudev::acos(const uint4& a);

__device__ __forceinline__ float1
cv::cudev::acos(const float1& a);

__device__ __forceinline__ float2
cv::cudev::acos(const float2& a);

__device__ __forceinline__ float3
cv::cudev::acos(const float3& a);

__device__ __forceinline__ float4
cv::cudev::acos(const float4& a);

__device__ __forceinline__ double1
cv::cudev::acos(const double1& a);

__device__ __forceinline__ double2
cv::cudev::acos(const double2& a);

__device__ __forceinline__ double3
cv::cudev::acos(const double3& a);

__device__ __forceinline__ double4
cv::cudev::acos(const double4& a);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, acos_func<typename PtrTraits<SrcPtr>::value_type>>>
cv::cudev::acos_(const SrcPtr& src);

__device__ __forceinline__ float1
cv::cudev::acosh(const uchar1& a);

__device__ __forceinline__ float2
cv::cudev::acosh(const uchar2& a);

__device__ __forceinline__ float3
cv::cudev::acosh(const uchar3& a);

__device__ __forceinline__ float4
cv::cudev::acosh(const uchar4& a);

__device__ __forceinline__ float1
cv::cudev::acosh(const char1& a);

__device__ __forceinline__ float2
cv::cudev::acosh(const char2& a);

__device__ __forceinline__ float3
cv::cudev::acosh(const char3& a);

__device__ __forceinline__ float4
cv::cudev::acosh(const char4& a);

__device__ __forceinline__ float1
cv::cudev::acosh(const ushort1& a);

__device__ __forceinline__ float2
cv::cudev::acosh(const ushort2& a);

__device__ __forceinline__ float3
cv::cudev::acosh(const ushort3& a);

__device__ __forceinline__ float4
cv::cudev::acosh(const ushort4& a);

__device__ __forceinline__ float1
cv::cudev::acosh(const short1& a);

__device__ __forceinline__ float2
cv::cudev::acosh(const short2& a);

__device__ __forceinline__ float3
cv::cudev::acosh(const short3& a);

__device__ __forceinline__ float4
cv::cudev::acosh(const short4& a);

__device__ __forceinline__ float1
cv::cudev::acosh(const int1& a);

__device__ __forceinline__ float2
cv::cudev::acosh(const int2& a);

__device__ __forceinline__ float3
cv::cudev::acosh(const int3& a);

__device__ __forceinline__ float4
cv::cudev::acosh(const int4& a);

__device__ __forceinline__ float1
cv::cudev::acosh(const uint1& a);

__device__ __forceinline__ float2
cv::cudev::acosh(const uint2& a);

__device__ __forceinline__ float3
cv::cudev::acosh(const uint3& a);

__device__ __forceinline__ float4
cv::cudev::acosh(const uint4& a);

__device__ __forceinline__ float1
cv::cudev::acosh(const float1& a);

__device__ __forceinline__ float2
cv::cudev::acosh(const float2& a);

__device__ __forceinline__ float3
cv::cudev::acosh(const float3& a);

__device__ __forceinline__ float4
cv::cudev::acosh(const float4& a);

__device__ __forceinline__ double1
cv::cudev::acosh(const double1& a);

__device__ __forceinline__ double2
cv::cudev::acosh(const double2& a);

__device__ __forceinline__ double3
cv::cudev::acosh(const double3& a);

__device__ __forceinline__ double4
cv::cudev::acosh(const double4& a);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, acosh_func<typename PtrTraits<SrcPtr>::value_type>>>
cv::cudev::acosh_(const SrcPtr& src);

static
__host__ AffineMapPtrSz
cv::cudev::affineMap(
    Size dstSize,
    const GpuMat_<float>& warpMat
    );

__device__ __forceinline__ float2
cv::cudev::asin(const uchar2& a);

__device__ __forceinline__ float3
cv::cudev::asin(const uchar3& a);

__device__ __forceinline__ float4
cv::cudev::asin(const uchar4& a);

__device__ __forceinline__ float1
cv::cudev::asin(const uchar1& a);

__device__ __forceinline__ float1
cv::cudev::asin(const char1& a);

__device__ __forceinline__ float2
cv::cudev::asin(const char2& a);

__device__ __forceinline__ float3
cv::cudev::asin(const char3& a);

__device__ __forceinline__ float4
cv::cudev::asin(const char4& a);

__device__ __forceinline__ float1
cv::cudev::asin(const ushort1& a);

__device__ __forceinline__ float2
cv::cudev::asin(const ushort2& a);

__device__ __forceinline__ float3
cv::cudev::asin(const ushort3& a);

__device__ __forceinline__ float4
cv::cudev::asin(const ushort4& a);

__device__ __forceinline__ float3
cv::cudev::asin(const short3& a);

__device__ __forceinline__ float4
cv::cudev::asin(const short4& a);

__device__ __forceinline__ float1
cv::cudev::asin(const short1& a);

__device__ __forceinline__ float2
cv::cudev::asin(const short2& a);

__device__ __forceinline__ float1
cv::cudev::asin(const int1& a);

__device__ __forceinline__ float2
cv::cudev::asin(const int2& a);

__device__ __forceinline__ float3
cv::cudev::asin(const int3& a);

__device__ __forceinline__ float4
cv::cudev::asin(const int4& a);

__device__ __forceinline__ float1
cv::cudev::asin(const uint1& a);

__device__ __forceinline__ float2
cv::cudev::asin(const uint2& a);

__device__ __forceinline__ float3
cv::cudev::asin(const uint3& a);

__device__ __forceinline__ float4
cv::cudev::asin(const uint4& a);

__device__ __forceinline__ float1
cv::cudev::asin(const float1& a);

__device__ __forceinline__ float2
cv::cudev::asin(const float2& a);

__device__ __forceinline__ float3
cv::cudev::asin(const float3& a);

__device__ __forceinline__ float4
cv::cudev::asin(const float4& a);

__device__ __forceinline__ double3
cv::cudev::asin(const double3& a);

__device__ __forceinline__ double4
cv::cudev::asin(const double4& a);

__device__ __forceinline__ double2
cv::cudev::asin(const double2& a);

__device__ __forceinline__ double1
cv::cudev::asin(const double1& a);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, asin_func<typename PtrTraits<SrcPtr>::value_type>>>
cv::cudev::asin_(const SrcPtr& src);

__device__ __forceinline__ float2
cv::cudev::asinh(const uchar2& a);

__device__ __forceinline__ float3
cv::cudev::asinh(const uchar3& a);

__device__ __forceinline__ float4
cv::cudev::asinh(const uchar4& a);

__device__ __forceinline__ float1
cv::cudev::asinh(const uchar1& a);

__device__ __forceinline__ float1
cv::cudev::asinh(const char1& a);

__device__ __forceinline__ float2
cv::cudev::asinh(const char2& a);

__device__ __forceinline__ float3
cv::cudev::asinh(const char3& a);

__device__ __forceinline__ float4
cv::cudev::asinh(const char4& a);

__device__ __forceinline__ float1
cv::cudev::asinh(const ushort1& a);

__device__ __forceinline__ float2
cv::cudev::asinh(const ushort2& a);

__device__ __forceinline__ float3
cv::cudev::asinh(const ushort3& a);

__device__ __forceinline__ float4
cv::cudev::asinh(const ushort4& a);

__device__ __forceinline__ float4
cv::cudev::asinh(const short4& a);

__device__ __forceinline__ float1
cv::cudev::asinh(const short1& a);

__device__ __forceinline__ float2
cv::cudev::asinh(const short2& a);

__device__ __forceinline__ float3
cv::cudev::asinh(const short3& a);

__device__ __forceinline__ float1
cv::cudev::asinh(const int1& a);

__device__ __forceinline__ float2
cv::cudev::asinh(const int2& a);

__device__ __forceinline__ float3
cv::cudev::asinh(const int3& a);

__device__ __forceinline__ float4
cv::cudev::asinh(const int4& a);

__device__ __forceinline__ float1
cv::cudev::asinh(const uint1& a);

__device__ __forceinline__ float2
cv::cudev::asinh(const uint2& a);

__device__ __forceinline__ float3
cv::cudev::asinh(const uint3& a);

__device__ __forceinline__ float4
cv::cudev::asinh(const uint4& a);

__device__ __forceinline__ float1
cv::cudev::asinh(const float1& a);

__device__ __forceinline__ float2
cv::cudev::asinh(const float2& a);

__device__ __forceinline__ float3
cv::cudev::asinh(const float3& a);

__device__ __forceinline__ float4
cv::cudev::asinh(const float4& a);

__device__ __forceinline__ double3
cv::cudev::asinh(const double3& a);

__device__ __forceinline__ double4
cv::cudev::asinh(const double4& a);

__device__ __forceinline__ double2
cv::cudev::asinh(const double2& a);

__device__ __forceinline__ double1
cv::cudev::asinh(const double1& a);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, asinh_func<typename PtrTraits<SrcPtr>::value_type>>>
cv::cudev::asinh_(const SrcPtr& src);

__device__ __forceinline__ float1
cv::cudev::atan(const uchar1& a);

__device__ __forceinline__ float2
cv::cudev::atan(const uchar2& a);

__device__ __forceinline__ float3
cv::cudev::atan(const uchar3& a);

__device__ __forceinline__ float4
cv::cudev::atan(const uchar4& a);

__device__ __forceinline__ float1
cv::cudev::atan(const char1& a);

__device__ __forceinline__ float2
cv::cudev::atan(const char2& a);

__device__ __forceinline__ float3
cv::cudev::atan(const char3& a);

__device__ __forceinline__ float4
cv::cudev::atan(const char4& a);

__device__ __forceinline__ float1
cv::cudev::atan(const ushort1& a);

__device__ __forceinline__ float2
cv::cudev::atan(const ushort2& a);

__device__ __forceinline__ float3
cv::cudev::atan(const ushort3& a);

__device__ __forceinline__ float4
cv::cudev::atan(const ushort4& a);

__device__ __forceinline__ float3
cv::cudev::atan(const short3& a);

__device__ __forceinline__ float4
cv::cudev::atan(const short4& a);

__device__ __forceinline__ float2
cv::cudev::atan(const short2& a);

__device__ __forceinline__ float1
cv::cudev::atan(const short1& a);

__device__ __forceinline__ float1
cv::cudev::atan(const int1& a);

__device__ __forceinline__ float2
cv::cudev::atan(const int2& a);

__device__ __forceinline__ float3
cv::cudev::atan(const int3& a);

__device__ __forceinline__ float4
cv::cudev::atan(const int4& a);

__device__ __forceinline__ float1
cv::cudev::atan(const uint1& a);

__device__ __forceinline__ float2
cv::cudev::atan(const uint2& a);

__device__ __forceinline__ float3
cv::cudev::atan(const uint3& a);

__device__ __forceinline__ float4
cv::cudev::atan(const uint4& a);

__device__ __forceinline__ float1
cv::cudev::atan(const float1& a);

__device__ __forceinline__ float2
cv::cudev::atan(const float2& a);

__device__ __forceinline__ float3
cv::cudev::atan(const float3& a);

__device__ __forceinline__ float4
cv::cudev::atan(const float4& a);

__device__ __forceinline__ double1
cv::cudev::atan(const double1& a);

__device__ __forceinline__ double2
cv::cudev::atan(const double2& a);

__device__ __forceinline__ double3
cv::cudev::atan(const double3& a);

__device__ __forceinline__ double4
cv::cudev::atan(const double4& a);

__device__ __forceinline__ float1
cv::cudev::atan2(
    const uchar1& a,
    const uchar1& b
    );

__device__ __forceinline__ float2
cv::cudev::atan2(
    const uchar2& a,
    const uchar2& b
    );

__device__ __forceinline__ float3
cv::cudev::atan2(
    const uchar3& a,
    const uchar3& b
    );

__device__ __forceinline__ float4
cv::cudev::atan2(
    const uchar4& a,
    const uchar4& b
    );

__device__ __forceinline__ float1
cv::cudev::atan2(
    const char1& a,
    const char1& b
    );

__device__ __forceinline__ float2
cv::cudev::atan2(
    const char2& a,
    const char2& b
    );

__device__ __forceinline__ float3
cv::cudev::atan2(
    const char3& a,
    const char3& b
    );

__device__ __forceinline__ float4
cv::cudev::atan2(
    const char4& a,
    const char4& b
    );

__device__ __forceinline__ float1
cv::cudev::atan2(
    const ushort1& a,
    const ushort1& b
    );

__device__ __forceinline__ float2
cv::cudev::atan2(
    const ushort2& a,
    const ushort2& b
    );

__device__ __forceinline__ float3
cv::cudev::atan2(
    const ushort3& a,
    const ushort3& b
    );

__device__ __forceinline__ float4
cv::cudev::atan2(
    const ushort4& a,
    const ushort4& b
    );

__device__ __forceinline__ float1
cv::cudev::atan2(
    const short1& a,
    const short1& b
    );

__device__ __forceinline__ float2
cv::cudev::atan2(
    const short2& a,
    const short2& b
    );

__device__ __forceinline__ float3
cv::cudev::atan2(
    const short3& a,
    const short3& b
    );

__device__ __forceinline__ float4
cv::cudev::atan2(
    const short4& a,
    const short4& b
    );

__device__ __forceinline__ float1
cv::cudev::atan2(
    const uint1& a,
    const uint1& b
    );

__device__ __forceinline__ float2
cv::cudev::atan2(
    const uint2& a,
    const uint2& b
    );

__device__ __forceinline__ float3
cv::cudev::atan2(
    const uint3& a,
    const uint3& b
    );

__device__ __forceinline__ float4
cv::cudev::atan2(
    const uint4& a,
    const uint4& b
    );

__device__ __forceinline__ float1
cv::cudev::atan2(
    const int1& a,
    const int1& b
    );

__device__ __forceinline__ float2
cv::cudev::atan2(
    const int2& a,
    const int2& b
    );

__device__ __forceinline__ float3
cv::cudev::atan2(
    const int3& a,
    const int3& b
    );

__device__ __forceinline__ float4
cv::cudev::atan2(
    const int4& a,
    const int4& b
    );

__device__ __forceinline__ float1
cv::cudev::atan2(
    const float1& a,
    const float1& b
    );

__device__ __forceinline__ float2
cv::cudev::atan2(
    const float2& a,
    const float2& b
    );

__device__ __forceinline__ float3
cv::cudev::atan2(
    const float3& a,
    const float3& b
    );

__device__ __forceinline__ float4
cv::cudev::atan2(
    const float4& a,
    const float4& b
    );

__device__ __forceinline__ double1
cv::cudev::atan2(
    const double1& a,
    const double1& b
    );

__device__ __forceinline__ double2
cv::cudev::atan2(
    const double2& a,
    const double2& b
    );

__device__ __forceinline__ double3
cv::cudev::atan2(
    const double3& a,
    const double3& b
    );

__device__ __forceinline__ double4
cv::cudev::atan2(
    const double4& a,
    const double4& b
    );

__device__ __forceinline__ float1
cv::cudev::atan2(
    const uchar1& a,
    float s
    );

__device__ __forceinline__ float1
cv::cudev::atan2(
    float s,
    const uchar1& b
    );

__device__ __forceinline__ float2
cv::cudev::atan2(
    const uchar2& a,
    float s
    );

__device__ __forceinline__ float2
cv::cudev::atan2(
    float s,
    const uchar2& b
    );

__device__ __forceinline__ float3
cv::cudev::atan2(
    const uchar3& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::atan2(
    float s,
    const uchar3& b
    );

__device__ __forceinline__ float4
cv::cudev::atan2(
    const uchar4& a,
    float s
    );

__device__ __forceinline__ float4
cv::cudev::atan2(
    float s,
    const uchar4& b
    );

__device__ __forceinline__ double1
cv::cudev::atan2(
    const uchar1& a,
    double s
    );

__device__ __forceinline__ double1
cv::cudev::atan2(
    double s,
    const uchar1& b
    );

__device__ __forceinline__ double2
cv::cudev::atan2(
    const uchar2& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::atan2(
    const uchar3& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::atan2(
    double s,
    const uchar3& b
    );

__device__ __forceinline__ double4
cv::cudev::atan2(
    const uchar4& a,
    double s
    );

__device__ __forceinline__ double4
cv::cudev::atan2(
    double s,
    const uchar4& b
    );

__device__ __forceinline__ double2
cv::cudev::atan2(
    double s,
    const uchar2& b
    );

__device__ __forceinline__ float1
cv::cudev::atan2(
    const char1& a,
    float s
    );

__device__ __forceinline__ float1
cv::cudev::atan2(
    float s,
    const char1& b
    );

__device__ __forceinline__ float2
cv::cudev::atan2(
    const char2& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::atan2(
    const char3& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::atan2(
    float s,
    const char3& b
    );

__device__ __forceinline__ float4
cv::cudev::atan2(
    const char4& a,
    float s
    );

__device__ __forceinline__ float2
cv::cudev::atan2(
    float s,
    const char2& b
    );

__device__ __forceinline__ float4
cv::cudev::atan2(
    float s,
    const char4& b
    );

__device__ __forceinline__ double1
cv::cudev::atan2(
    const char1& a,
    double s
    );

__device__ __forceinline__ double1
cv::cudev::atan2(
    double s,
    const char1& b
    );

__device__ __forceinline__ double2
cv::cudev::atan2(
    const char2& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::atan2(
    const char3& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::atan2(
    double s,
    const char3& b
    );

__device__ __forceinline__ double4
cv::cudev::atan2(
    const char4& a,
    double s
    );

__device__ __forceinline__ double4
cv::cudev::atan2(
    double s,
    const char4& b
    );

__device__ __forceinline__ double2
cv::cudev::atan2(
    double s,
    const char2& b
    );

__device__ __forceinline__ float1
cv::cudev::atan2(
    const ushort1& a,
    float s
    );

__device__ __forceinline__ float1
cv::cudev::atan2(
    float s,
    const ushort1& b
    );

__device__ __forceinline__ float2
cv::cudev::atan2(
    const ushort2& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::atan2(
    const ushort3& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::atan2(
    float s,
    const ushort3& b
    );

__device__ __forceinline__ float4
cv::cudev::atan2(
    const ushort4& a,
    float s
    );

__device__ __forceinline__ float2
cv::cudev::atan2(
    float s,
    const ushort2& b
    );

__device__ __forceinline__ float4
cv::cudev::atan2(
    float s,
    const ushort4& b
    );

__device__ __forceinline__ double1
cv::cudev::atan2(
    const ushort1& a,
    double s
    );

__device__ __forceinline__ double1
cv::cudev::atan2(
    double s,
    const ushort1& b
    );

__device__ __forceinline__ double2
cv::cudev::atan2(
    const ushort2& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::atan2(
    const ushort3& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::atan2(
    double s,
    const ushort3& b
    );

__device__ __forceinline__ double4
cv::cudev::atan2(
    const ushort4& a,
    double s
    );

__device__ __forceinline__ double4
cv::cudev::atan2(
    double s,
    const ushort4& b
    );

__device__ __forceinline__ double2
cv::cudev::atan2(
    double s,
    const ushort2& b
    );

__device__ __forceinline__ float1
cv::cudev::atan2(
    const short1& a,
    float s
    );

__device__ __forceinline__ float1
cv::cudev::atan2(
    float s,
    const short1& b
    );

__device__ __forceinline__ float2
cv::cudev::atan2(
    const short2& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::atan2(
    const short3& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::atan2(
    float s,
    const short3& b
    );

__device__ __forceinline__ float4
cv::cudev::atan2(
    const short4& a,
    float s
    );

__device__ __forceinline__ float4
cv::cudev::atan2(
    float s,
    const short4& b
    );

__device__ __forceinline__ float2
cv::cudev::atan2(
    float s,
    const short2& b
    );

__device__ __forceinline__ double1
cv::cudev::atan2(
    const short1& a,
    double s
    );

__device__ __forceinline__ double1
cv::cudev::atan2(
    double s,
    const short1& b
    );

__device__ __forceinline__ double2
cv::cudev::atan2(
    const short2& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::atan2(
    const short3& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::atan2(
    double s,
    const short3& b
    );

__device__ __forceinline__ double4
cv::cudev::atan2(
    const short4& a,
    double s
    );

__device__ __forceinline__ double4
cv::cudev::atan2(
    double s,
    const short4& b
    );

__device__ __forceinline__ double2
cv::cudev::atan2(
    double s,
    const short2& b
    );

__device__ __forceinline__ float1
cv::cudev::atan2(
    const uint1& a,
    float s
    );

__device__ __forceinline__ float1
cv::cudev::atan2(
    float s,
    const uint1& b
    );

__device__ __forceinline__ float2
cv::cudev::atan2(
    const uint2& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::atan2(
    const uint3& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::atan2(
    float s,
    const uint3& b
    );

__device__ __forceinline__ float4
cv::cudev::atan2(
    const uint4& a,
    float s
    );

__device__ __forceinline__ float4
cv::cudev::atan2(
    float s,
    const uint4& b
    );

__device__ __forceinline__ float2
cv::cudev::atan2(
    float s,
    const uint2& b
    );

__device__ __forceinline__ double1
cv::cudev::atan2(
    const uint1& a,
    double s
    );

__device__ __forceinline__ double1
cv::cudev::atan2(
    double s,
    const uint1& b
    );

__device__ __forceinline__ double2
cv::cudev::atan2(
    const uint2& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::atan2(
    const uint3& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::atan2(
    double s,
    const uint3& b
    );

__device__ __forceinline__ double4
cv::cudev::atan2(
    const uint4& a,
    double s
    );

__device__ __forceinline__ double4
cv::cudev::atan2(
    double s,
    const uint4& b
    );

__device__ __forceinline__ double2
cv::cudev::atan2(
    double s,
    const uint2& b
    );

__device__ __forceinline__ float1
cv::cudev::atan2(
    const int1& a,
    float s
    );

__device__ __forceinline__ float1
cv::cudev::atan2(
    float s,
    const int1& b
    );

__device__ __forceinline__ float2
cv::cudev::atan2(
    const int2& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::atan2(
    const int3& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::atan2(
    float s,
    const int3& b
    );

__device__ __forceinline__ float4
cv::cudev::atan2(
    const int4& a,
    float s
    );

__device__ __forceinline__ float4
cv::cudev::atan2(
    float s,
    const int4& b
    );

__device__ __forceinline__ float2
cv::cudev::atan2(
    float s,
    const int2& b
    );

__device__ __forceinline__ double1
cv::cudev::atan2(
    const int1& a,
    double s
    );

__device__ __forceinline__ double1
cv::cudev::atan2(
    double s,
    const int1& b
    );

__device__ __forceinline__ double2
cv::cudev::atan2(
    const int2& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::atan2(
    const int3& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::atan2(
    double s,
    const int3& b
    );

__device__ __forceinline__ double4
cv::cudev::atan2(
    const int4& a,
    double s
    );

__device__ __forceinline__ double4
cv::cudev::atan2(
    double s,
    const int4& b
    );

__device__ __forceinline__ double2
cv::cudev::atan2(
    double s,
    const int2& b
    );

__device__ __forceinline__ float1
cv::cudev::atan2(
    const float1& a,
    float s
    );

__device__ __forceinline__ float1
cv::cudev::atan2(
    float s,
    const float1& b
    );

__device__ __forceinline__ float2
cv::cudev::atan2(
    const float2& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::atan2(
    const float3& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::atan2(
    float s,
    const float3& b
    );

__device__ __forceinline__ float4
cv::cudev::atan2(
    const float4& a,
    float s
    );

__device__ __forceinline__ float4
cv::cudev::atan2(
    float s,
    const float4& b
    );

__device__ __forceinline__ float2
cv::cudev::atan2(
    float s,
    const float2& b
    );

__device__ __forceinline__ double1
cv::cudev::atan2(
    const float1& a,
    double s
    );

__device__ __forceinline__ double1
cv::cudev::atan2(
    double s,
    const float1& b
    );

__device__ __forceinline__ double2
cv::cudev::atan2(
    const float2& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::atan2(
    const float3& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::atan2(
    double s,
    const float3& b
    );

__device__ __forceinline__ double4
cv::cudev::atan2(
    const float4& a,
    double s
    );

__device__ __forceinline__ double4
cv::cudev::atan2(
    double s,
    const float4& b
    );

__device__ __forceinline__ double2
cv::cudev::atan2(
    double s,
    const float2& b
    );

__device__ __forceinline__ double1
cv::cudev::atan2(
    const double1& a,
    double s
    );

__device__ __forceinline__ double1
cv::cudev::atan2(
    double s,
    const double1& b
    );

__device__ __forceinline__ double2
cv::cudev::atan2(
    const double2& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::atan2(
    const double3& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::atan2(
    double s,
    const double3& b
    );

__device__ __forceinline__ double4
cv::cudev::atan2(
    const double4& a,
    double s
    );

__device__ __forceinline__ double2
cv::cudev::atan2(
    double s,
    const double2& b
    );

__device__ __forceinline__ double4
cv::cudev::atan2(
    double s,
    const double4& b
    );

template <
    class SrcPtr1,
    class SrcPtr2
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<SrcPtr1>::ptr_type, typename PtrTraits<SrcPtr2>::ptr_type, atan2_func<typename LargerType<typename PtrTraits<SrcPtr1>::value_type, typename PtrTraits<SrcPtr2>::value_type>::type>>>
cv::cudev::atan2_(
    const SrcPtr1& src1,
    const SrcPtr2& src2
    );

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, atan_func<typename PtrTraits<SrcPtr>::value_type>>>
cv::cudev::atan_(const SrcPtr& src);

__device__ __forceinline__ float1
cv::cudev::atanh(const uchar1& a);

__device__ __forceinline__ float2
cv::cudev::atanh(const uchar2& a);

__device__ __forceinline__ float3
cv::cudev::atanh(const uchar3& a);

__device__ __forceinline__ float4
cv::cudev::atanh(const uchar4& a);

__device__ __forceinline__ float1
cv::cudev::atanh(const char1& a);

__device__ __forceinline__ float2
cv::cudev::atanh(const char2& a);

__device__ __forceinline__ float3
cv::cudev::atanh(const char3& a);

__device__ __forceinline__ float4
cv::cudev::atanh(const char4& a);

__device__ __forceinline__ float1
cv::cudev::atanh(const ushort1& a);

__device__ __forceinline__ float2
cv::cudev::atanh(const ushort2& a);

__device__ __forceinline__ float3
cv::cudev::atanh(const ushort3& a);

__device__ __forceinline__ float4
cv::cudev::atanh(const ushort4& a);

__device__ __forceinline__ float1
cv::cudev::atanh(const short1& a);

__device__ __forceinline__ float2
cv::cudev::atanh(const short2& a);

__device__ __forceinline__ float3
cv::cudev::atanh(const short3& a);

__device__ __forceinline__ float4
cv::cudev::atanh(const short4& a);

__device__ __forceinline__ float1
cv::cudev::atanh(const int1& a);

__device__ __forceinline__ float2
cv::cudev::atanh(const int2& a);

__device__ __forceinline__ float3
cv::cudev::atanh(const int3& a);

__device__ __forceinline__ float4
cv::cudev::atanh(const int4& a);

__device__ __forceinline__ float1
cv::cudev::atanh(const uint1& a);

__device__ __forceinline__ float2
cv::cudev::atanh(const uint2& a);

__device__ __forceinline__ float3
cv::cudev::atanh(const uint3& a);

__device__ __forceinline__ float4
cv::cudev::atanh(const uint4& a);

__device__ __forceinline__ float1
cv::cudev::atanh(const float1& a);

__device__ __forceinline__ float2
cv::cudev::atanh(const float2& a);

__device__ __forceinline__ float3
cv::cudev::atanh(const float3& a);

__device__ __forceinline__ float4
cv::cudev::atanh(const float4& a);

__device__ __forceinline__ double1
cv::cudev::atanh(const double1& a);

__device__ __forceinline__ double2
cv::cudev::atanh(const double2& a);

__device__ __forceinline__ double3
cv::cudev::atanh(const double3& a);

__device__ __forceinline__ double4
cv::cudev::atanh(const double4& a);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, atanh_func<typename PtrTraits<SrcPtr>::value_type>>>
cv::cudev::atanh_(const SrcPtr& src);

__device__ __forceinline__ int
cv::cudev::atomicAdd(
    int* address,
    int val
    );

__device__ __forceinline__ uint
cv::cudev::atomicAdd(
    uint* address,
    uint val
    );

__device__ __forceinline__ float
cv::cudev::atomicAdd(
    float* address,
    float val
    );

static
__device__ double
cv::cudev::atomicAdd(
    double* address,
    double val
    );

__device__ __forceinline__ int
cv::cudev::atomicMax(
    int* address,
    int val
    );

__device__ __forceinline__ uint
cv::cudev::atomicMax(
    uint* address,
    uint val
    );

static
__device__ float
cv::cudev::atomicMax(
    float* address,
    float val
    );

static
__device__ double
cv::cudev::atomicMax(
    double* address,
    double val
    );

__device__ __forceinline__ int
cv::cudev::atomicMin(
    int* address,
    int val
    );

__device__ __forceinline__ uint
cv::cudev::atomicMin(
    uint* address,
    uint val
    );

static
__device__ float
cv::cudev::atomicMin(
    float* address,
    float val
    );

static
__device__ double
cv::cudev::atomicMin(
    double* address,
    double val
    );

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, BGR_to_BGRA_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::BGR_to_BGRA_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, BGR_to_GRAY_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::BGR_to_GRAY_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, BGR_to_HLS4_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::BGR_to_HLS4_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, BGR_to_HLS4_FULL_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::BGR_to_HLS4_FULL_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, BGR_to_HLS_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::BGR_to_HLS_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, BGR_to_HLS_FULL_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::BGR_to_HLS_FULL_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, BGR_to_HSV4_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::BGR_to_HSV4_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, BGR_to_HSV4_FULL_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::BGR_to_HSV4_FULL_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, BGR_to_HSV_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::BGR_to_HSV_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, BGR_to_HSV_FULL_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::BGR_to_HSV_FULL_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, BGR_to_Lab4_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::BGR_to_Lab4_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, BGR_to_Lab_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::BGR_to_Lab_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, BGR_to_Luv4_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::BGR_to_Luv4_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, BGR_to_Luv_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::BGR_to_Luv_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, BGR_to_RGB_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::BGR_to_RGB_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, BGR_to_RGBA_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::BGR_to_RGBA_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, BGR_to_XYZ4_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::BGR_to_XYZ4_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, BGR_to_XYZ_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::BGR_to_XYZ_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, BGR_to_YCrCb4_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::BGR_to_YCrCb4_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, BGR_to_YCrCb_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::BGR_to_YCrCb_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, BGR_to_YUV4_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::BGR_to_YUV4_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, BGR_to_YUV_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::BGR_to_YUV_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, BGRA_to_BGR_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::BGRA_to_BGR_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, BGRA_to_GRAY_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::BGRA_to_GRAY_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, BGRA_to_HLS4_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::BGRA_to_HLS4_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, BGRA_to_HLS4_FULL_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::BGRA_to_HLS4_FULL_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, BGRA_to_HLS_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::BGRA_to_HLS_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, BGRA_to_HLS_FULL_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::BGRA_to_HLS_FULL_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, BGRA_to_HSV4_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::BGRA_to_HSV4_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, BGRA_to_HSV4_FULL_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::BGRA_to_HSV4_FULL_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, BGRA_to_HSV_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::BGRA_to_HSV_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, BGRA_to_HSV_FULL_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::BGRA_to_HSV_FULL_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, BGRA_to_Lab4_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::BGRA_to_Lab4_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, BGRA_to_Lab_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::BGRA_to_Lab_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, BGRA_to_Luv4_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::BGRA_to_Luv4_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, BGRA_to_Luv_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::BGRA_to_Luv_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, BGRA_to_RGB_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::BGRA_to_RGB_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, BGRA_to_RGBA_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::BGRA_to_RGBA_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, BGRA_to_XYZ4_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::BGRA_to_XYZ4_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, BGRA_to_XYZ_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::BGRA_to_XYZ_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, BGRA_to_YCrCb4_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::BGRA_to_YCrCb4_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, BGRA_to_YCrCb_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::BGRA_to_YCrCb_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, BGRA_to_YUV4_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::BGRA_to_YUV4_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, BGRA_to_YUV_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::BGRA_to_YUV_(const SrcPtr& src);

template <
    int n0,
    int n1,
    class Op
    >
__host__ __device__ BinaryTupleAdapter<Op, n0, n1>
cv::cudev::binaryTupleAdapter(const Op& op);

template <class Op>
__host__ __device__ Binder1st<Op>
cv::cudev::bind1st(
    const Op& op,
    const typename Op::first_argument_type& arg1
    );

template <class Op>
__host__ __device__ Binder2nd<Op>
cv::cudev::bind2nd(
    const Op& op,
    const typename Op::second_argument_type& arg2
    );

template <
    class InIt,
    class OutIt
    >
static
__device__ static __forceinline__ void
cv::cudev::blockCopy(
    InIt beg,
    InIt end,
    OutIt out
    );

template <
    class It,
    typename T
    >
static
__device__ static __forceinline__ void
cv::cudev::blockFill(
    It beg,
    It end,
    const T& value
    );

template <
    int N,
    typename T,
    class Op
    >
__device__ __forceinline__ void
cv::cudev::blockReduce(
    volatile T* smem,
    T& val,
    uint tid,
    const Op& op
    );

template <
    int N,
    typename P0,
    typename P1,
    typename P2,
    typename P3,
    typename P4,
    typename P5,
    typename P6,
    typename P7,
    typename P8,
    typename P9,
    typename R0,
    typename R1,
    typename R2,
    typename R3,
    typename R4,
    typename R5,
    typename R6,
    typename R7,
    typename R8,
    typename R9,
    class Op0,
    class Op1,
    class Op2,
    class Op3,
    class Op4,
    class Op5,
    class Op6,
    class Op7,
    class Op8,
    class Op9
    >
__device__ __forceinline__ void
cv::cudev::blockReduce(
    const tuple<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9>& smem,
    const tuple<R0, R1, R2, R3, R4, R5, R6, R7, R8, R9>& val,
    uint tid,
    const tuple<Op0, Op1, Op2, Op3, Op4, Op5, Op6, Op7, Op8, Op9>& op
    );

template <
    int N,
    typename K,
    typename V,
    class Cmp
    >
__device__ __forceinline__ void
cv::cudev::blockReduceKeyVal(
    volatile K* skeys,
    K& key,
    volatile V* svals,
    V& val,
    uint tid,
    const Cmp& cmp
    );

template <
    int N,
    typename K,
    typename VP0,
    typename VP1,
    typename VP2,
    typename VP3,
    typename VP4,
    typename VP5,
    typename VP6,
    typename VP7,
    typename VP8,
    typename VP9,
    typename VR0,
    typename VR1,
    typename VR2,
    typename VR3,
    typename VR4,
    typename VR5,
    typename VR6,
    typename VR7,
    typename VR8,
    typename VR9,
    class Cmp
    >
__device__ __forceinline__ void
cv::cudev::blockReduceKeyVal(
    volatile K* skeys,
    K& key,
    const tuple<VP0, VP1, VP2, VP3, VP4, VP5, VP6, VP7, VP8, VP9>& svals,
    const tuple<VR0, VR1, VR2, VR3, VR4, VR5, VR6, VR7, VR8, VR9>& val,
    uint tid,
    const Cmp& cmp
    );

template <
    int N,
    typename KP0,
    typename KP1,
    typename KP2,
    typename KP3,
    typename KP4,
    typename KP5,
    typename KP6,
    typename KP7,
    typename KP8,
    typename KP9,
    typename KR0,
    typename KR1,
    typename KR2,
    typename KR3,
    typename KR4,
    typename KR5,
    typename KR6,
    typename KR7,
    typename KR8,
    typename KR9,
    typename VP0,
    typename VP1,
    typename VP2,
    typename VP3,
    typename VP4,
    typename VP5,
    typename VP6,
    typename VP7,
    typename VP8,
    typename VP9,
    typename VR0,
    typename VR1,
    typename VR2,
    typename VR3,
    typename VR4,
    typename VR5,
    typename VR6,
    typename VR7,
    typename VR8,
    typename VR9,
    class Cmp0,
    class Cmp1,
    class Cmp2,
    class Cmp3,
    class Cmp4,
    class Cmp5,
    class Cmp6,
    class Cmp7,
    class Cmp8,
    class Cmp9
    >
__device__ __forceinline__ void
cv::cudev::blockReduceKeyVal(
    const tuple<KP0, KP1, KP2, KP3, KP4, KP5, KP6, KP7, KP8, KP9>& skeys,
    const tuple<KR0, KR1, KR2, KR3, KR4, KR5, KR6, KR7, KR8, KR9>& key,
    const tuple<VP0, VP1, VP2, VP3, VP4, VP5, VP6, VP7, VP8, VP9>& svals,
    const tuple<VR0, VR1, VR2, VR3, VR4, VR5, VR6, VR7, VR8, VR9>& val,
    uint tid,
    const tuple<Cmp0, Cmp1, Cmp2, Cmp3, Cmp4, Cmp5, Cmp6, Cmp7, Cmp8, Cmp9>& cmp
    );

template <
    int THREADS_NUM,
    typename T
    >
__device__ __forceinline__ T
cv::cudev::blockScanExclusive(
    T data,
    volatile T* smem,
    uint tid
    );

template <
    int THREADS_NUM,
    typename T
    >
__device__ T
cv::cudev::blockScanInclusive(
    T data,
    volatile T* smem,
    uint tid
    );

template <
    class InIt,
    class OutIt,
    class UnOp
    >
static
__device__ static __forceinline__ void
cv::cudev::blockTransfrom(
    InIt beg,
    InIt end,
    OutIt out,
    const UnOp& op
    );

template <
    class InIt1,
    class InIt2,
    class OutIt,
    class BinOp
    >
static
__device__ static __forceinline__ void
cv::cudev::blockTransfrom(
    InIt1 beg1,
    InIt1 end1,
    InIt2 beg2,
    OutIt out,
    const BinOp& op
    );

template <
    class OutIt,
    typename T
    >
static
__device__ static __forceinline__ void
cv::cudev::blockYota(
    OutIt beg,
    OutIt end,
    T value
    );

template <class SrcPtr>
__host__ BrdConstant<typename PtrTraits<SrcPtr>::ptr_type>
cv::cudev::brdConstant(
    const SrcPtr& src,
    typename PtrTraits<SrcPtr>::value_type val
    );

template <class SrcPtr>
__host__ BrdConstant<typename PtrTraits<SrcPtr>::ptr_type>
cv::cudev::brdConstant(const SrcPtr& src);

template <class SrcPtr>
__host__ BrdBase<BrdReflect, typename PtrTraits<SrcPtr>::ptr_type>
cv::cudev::brdReflect(const SrcPtr& src);

template <class SrcPtr>
__host__ BrdBase<BrdReflect101, typename PtrTraits<SrcPtr>::ptr_type>
cv::cudev::brdReflect101(const SrcPtr& src);

template <class SrcPtr>
__host__ BrdBase<BrdReplicate, typename PtrTraits<SrcPtr>::ptr_type>
cv::cudev::brdReplicate(const SrcPtr& src);

template <class SrcPtr>
__host__ BrdBase<BrdWrap, typename PtrTraits<SrcPtr>::ptr_type>
cv::cudev::brdWrap(const SrcPtr& src);

template <
    typename T,
    typename D
    >
__device__ __forceinline__ D
cv::cudev::cast_fp16(T v);

__device__ __forceinline__ short
cv::cudev::cast_fp16< float, short >(float v);

__device__ __forceinline__ float
cv::cudev::cast_fp16< short, float >(short v);

__host__ __forceinline__ void
cv::cudev::checkCudaError(
    cudaError_t err,
    const char* file,
    const int line,
    const char* func
    );

template <typename T>
__host__ ConstantPtr<T>
cv::cudev::constantPtr(T value);

template <typename T>
ConstantPtrSz<T> __host__
cv::cudev::constantPtr(
    T value,
    int rows,
    int cols
    );

__device__ __forceinline__ float1
cv::cudev::cos(const uchar1& a);

__device__ __forceinline__ float2
cv::cudev::cos(const uchar2& a);

__device__ __forceinline__ float3
cv::cudev::cos(const uchar3& a);

__device__ __forceinline__ float4
cv::cudev::cos(const uchar4& a);

__device__ __forceinline__ float1
cv::cudev::cos(const char1& a);

__device__ __forceinline__ float2
cv::cudev::cos(const char2& a);

__device__ __forceinline__ float3
cv::cudev::cos(const char3& a);

__device__ __forceinline__ float4
cv::cudev::cos(const char4& a);

__device__ __forceinline__ float1
cv::cudev::cos(const ushort1& a);

__device__ __forceinline__ float2
cv::cudev::cos(const ushort2& a);

__device__ __forceinline__ float3
cv::cudev::cos(const ushort3& a);

__device__ __forceinline__ float4
cv::cudev::cos(const ushort4& a);

__device__ __forceinline__ float1
cv::cudev::cos(const short1& a);

__device__ __forceinline__ float2
cv::cudev::cos(const short2& a);

__device__ __forceinline__ float3
cv::cudev::cos(const short3& a);

__device__ __forceinline__ float4
cv::cudev::cos(const short4& a);

__device__ __forceinline__ float1
cv::cudev::cos(const int1& a);

__device__ __forceinline__ float2
cv::cudev::cos(const int2& a);

__device__ __forceinline__ float3
cv::cudev::cos(const int3& a);

__device__ __forceinline__ float4
cv::cudev::cos(const int4& a);

__device__ __forceinline__ float1
cv::cudev::cos(const uint1& a);

__device__ __forceinline__ float2
cv::cudev::cos(const uint2& a);

__device__ __forceinline__ float3
cv::cudev::cos(const uint3& a);

__device__ __forceinline__ float4
cv::cudev::cos(const uint4& a);

__device__ __forceinline__ float1
cv::cudev::cos(const float1& a);

__device__ __forceinline__ float2
cv::cudev::cos(const float2& a);

__device__ __forceinline__ float3
cv::cudev::cos(const float3& a);

__device__ __forceinline__ float4
cv::cudev::cos(const float4& a);

__device__ __forceinline__ double1
cv::cudev::cos(const double1& a);

__device__ __forceinline__ double2
cv::cudev::cos(const double2& a);

__device__ __forceinline__ double3
cv::cudev::cos(const double3& a);

__device__ __forceinline__ double4
cv::cudev::cos(const double4& a);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, cos_func<typename PtrTraits<SrcPtr>::value_type>>>
cv::cudev::cos_(const SrcPtr& src);

__device__ __forceinline__ float1
cv::cudev::cosh(const uchar1& a);

__device__ __forceinline__ float2
cv::cudev::cosh(const uchar2& a);

__device__ __forceinline__ float3
cv::cudev::cosh(const uchar3& a);

__device__ __forceinline__ float4
cv::cudev::cosh(const uchar4& a);

__device__ __forceinline__ float1
cv::cudev::cosh(const char1& a);

__device__ __forceinline__ float2
cv::cudev::cosh(const char2& a);

__device__ __forceinline__ float3
cv::cudev::cosh(const char3& a);

__device__ __forceinline__ float4
cv::cudev::cosh(const char4& a);

__device__ __forceinline__ float1
cv::cudev::cosh(const ushort1& a);

__device__ __forceinline__ float2
cv::cudev::cosh(const ushort2& a);

__device__ __forceinline__ float3
cv::cudev::cosh(const ushort3& a);

__device__ __forceinline__ float4
cv::cudev::cosh(const ushort4& a);

__device__ __forceinline__ float2
cv::cudev::cosh(const short2& a);

__device__ __forceinline__ float3
cv::cudev::cosh(const short3& a);

__device__ __forceinline__ float4
cv::cudev::cosh(const short4& a);

__device__ __forceinline__ float1
cv::cudev::cosh(const short1& a);

__device__ __forceinline__ float1
cv::cudev::cosh(const int1& a);

__device__ __forceinline__ float2
cv::cudev::cosh(const int2& a);

__device__ __forceinline__ float3
cv::cudev::cosh(const int3& a);

__device__ __forceinline__ float4
cv::cudev::cosh(const int4& a);

__device__ __forceinline__ float1
cv::cudev::cosh(const uint1& a);

__device__ __forceinline__ float2
cv::cudev::cosh(const uint2& a);

__device__ __forceinline__ float3
cv::cudev::cosh(const uint3& a);

__device__ __forceinline__ float4
cv::cudev::cosh(const uint4& a);

__device__ __forceinline__ float1
cv::cudev::cosh(const float1& a);

__device__ __forceinline__ float2
cv::cudev::cosh(const float2& a);

__device__ __forceinline__ float3
cv::cudev::cosh(const float3& a);

__device__ __forceinline__ float4
cv::cudev::cosh(const float4& a);

__device__ __forceinline__ double1
cv::cudev::cosh(const double1& a);

__device__ __forceinline__ double2
cv::cudev::cosh(const double2& a);

__device__ __forceinline__ double3
cv::cudev::cosh(const double3& a);

__device__ __forceinline__ double4
cv::cudev::cosh(const double4& a);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, cosh_func<typename PtrTraits<SrcPtr>::value_type>>>
cv::cudev::cosh_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<CountNonZeroExprBody<SrcPtr>>
cv::cudev::countNonZero_(const SrcPtr& src);

template <
    typename D,
    class SrcPtr
    >
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, saturate_cast_func<typename PtrTraits<SrcPtr>::value_type, D>>>
cv::cudev::cvt_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<DerivXPtrSz<typename PtrTraits<SrcPtr>::ptr_type>>
cv::cudev::derivX_(const SrcPtr& src);

template <class SrcPtr>
__host__ DerivXPtrSz<typename PtrTraits<SrcPtr>::ptr_type>
cv::cudev::derivXPtr(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<DerivYPtrSz<typename PtrTraits<SrcPtr>::ptr_type>>
cv::cudev::derivY_(const SrcPtr& src);

template <class SrcPtr>
__host__ DerivYPtrSz<typename PtrTraits<SrcPtr>::ptr_type>
cv::cudev::derivYPtr(const SrcPtr& src);

__host__ __device__ __forceinline__ int
cv::cudev::divUp(
    int total,
    int grain
    );

__device__ __forceinline__ float1
cv::cudev::exp(const uchar1& a);

__device__ __forceinline__ float2
cv::cudev::exp(const uchar2& a);

__device__ __forceinline__ float3
cv::cudev::exp(const uchar3& a);

__device__ __forceinline__ float4
cv::cudev::exp(const uchar4& a);

__device__ __forceinline__ float1
cv::cudev::exp(const char1& a);

__device__ __forceinline__ float2
cv::cudev::exp(const char2& a);

__device__ __forceinline__ float3
cv::cudev::exp(const char3& a);

__device__ __forceinline__ float4
cv::cudev::exp(const char4& a);

__device__ __forceinline__ float1
cv::cudev::exp(const ushort1& a);

__device__ __forceinline__ float2
cv::cudev::exp(const ushort2& a);

__device__ __forceinline__ float3
cv::cudev::exp(const ushort3& a);

__device__ __forceinline__ float4
cv::cudev::exp(const ushort4& a);

__device__ __forceinline__ float1
cv::cudev::exp(const short1& a);

__device__ __forceinline__ float2
cv::cudev::exp(const short2& a);

__device__ __forceinline__ float3
cv::cudev::exp(const short3& a);

__device__ __forceinline__ float4
cv::cudev::exp(const short4& a);

__device__ __forceinline__ float1
cv::cudev::exp(const int1& a);

__device__ __forceinline__ float2
cv::cudev::exp(const int2& a);

__device__ __forceinline__ float3
cv::cudev::exp(const int3& a);

__device__ __forceinline__ float4
cv::cudev::exp(const int4& a);

__device__ __forceinline__ float1
cv::cudev::exp(const uint1& a);

__device__ __forceinline__ float2
cv::cudev::exp(const uint2& a);

__device__ __forceinline__ float3
cv::cudev::exp(const uint3& a);

__device__ __forceinline__ float4
cv::cudev::exp(const uint4& a);

__device__ __forceinline__ float1
cv::cudev::exp(const float1& a);

__device__ __forceinline__ float2
cv::cudev::exp(const float2& a);

__device__ __forceinline__ float3
cv::cudev::exp(const float3& a);

__device__ __forceinline__ float4
cv::cudev::exp(const float4& a);

__device__ __forceinline__ double1
cv::cudev::exp(const double1& a);

__device__ __forceinline__ double2
cv::cudev::exp(const double2& a);

__device__ __forceinline__ double3
cv::cudev::exp(const double3& a);

__device__ __forceinline__ double4
cv::cudev::exp(const double4& a);

__device__ __forceinline__ float1
cv::cudev::exp10(const uchar1& a);

__device__ __forceinline__ float2
cv::cudev::exp10(const uchar2& a);

__device__ __forceinline__ float3
cv::cudev::exp10(const uchar3& a);

__device__ __forceinline__ float4
cv::cudev::exp10(const uchar4& a);

__device__ __forceinline__ float1
cv::cudev::exp10(const char1& a);

__device__ __forceinline__ float2
cv::cudev::exp10(const char2& a);

__device__ __forceinline__ float3
cv::cudev::exp10(const char3& a);

__device__ __forceinline__ float4
cv::cudev::exp10(const char4& a);

__device__ __forceinline__ float1
cv::cudev::exp10(const ushort1& a);

__device__ __forceinline__ float2
cv::cudev::exp10(const ushort2& a);

__device__ __forceinline__ float3
cv::cudev::exp10(const ushort3& a);

__device__ __forceinline__ float4
cv::cudev::exp10(const ushort4& a);

__device__ __forceinline__ float1
cv::cudev::exp10(const short1& a);

__device__ __forceinline__ float2
cv::cudev::exp10(const short2& a);

__device__ __forceinline__ float3
cv::cudev::exp10(const short3& a);

__device__ __forceinline__ float4
cv::cudev::exp10(const short4& a);

__device__ __forceinline__ float1
cv::cudev::exp10(const int1& a);

__device__ __forceinline__ float2
cv::cudev::exp10(const int2& a);

__device__ __forceinline__ float3
cv::cudev::exp10(const int3& a);

__device__ __forceinline__ float4
cv::cudev::exp10(const int4& a);

__device__ __forceinline__ float1
cv::cudev::exp10(const uint1& a);

__device__ __forceinline__ float2
cv::cudev::exp10(const uint2& a);

__device__ __forceinline__ float3
cv::cudev::exp10(const uint3& a);

__device__ __forceinline__ float4
cv::cudev::exp10(const uint4& a);

__device__ __forceinline__ float1
cv::cudev::exp10(const float1& a);

__device__ __forceinline__ float2
cv::cudev::exp10(const float2& a);

__device__ __forceinline__ float3
cv::cudev::exp10(const float3& a);

__device__ __forceinline__ float4
cv::cudev::exp10(const float4& a);

__device__ __forceinline__ double1
cv::cudev::exp10(const double1& a);

__device__ __forceinline__ double2
cv::cudev::exp10(const double2& a);

__device__ __forceinline__ double3
cv::cudev::exp10(const double3& a);

__device__ __forceinline__ double4
cv::cudev::exp10(const double4& a);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, exp10_func<typename PtrTraits<SrcPtr>::value_type>>>
cv::cudev::exp10_(const SrcPtr& src);

__device__ __forceinline__ float1
cv::cudev::exp2(const uchar1& a);

__device__ __forceinline__ float2
cv::cudev::exp2(const uchar2& a);

__device__ __forceinline__ float3
cv::cudev::exp2(const uchar3& a);

__device__ __forceinline__ float4
cv::cudev::exp2(const uchar4& a);

__device__ __forceinline__ float1
cv::cudev::exp2(const char1& a);

__device__ __forceinline__ float2
cv::cudev::exp2(const char2& a);

__device__ __forceinline__ float3
cv::cudev::exp2(const char3& a);

__device__ __forceinline__ float4
cv::cudev::exp2(const char4& a);

__device__ __forceinline__ float1
cv::cudev::exp2(const ushort1& a);

__device__ __forceinline__ float2
cv::cudev::exp2(const ushort2& a);

__device__ __forceinline__ float3
cv::cudev::exp2(const ushort3& a);

__device__ __forceinline__ float4
cv::cudev::exp2(const ushort4& a);

__device__ __forceinline__ float1
cv::cudev::exp2(const short1& a);

__device__ __forceinline__ float2
cv::cudev::exp2(const short2& a);

__device__ __forceinline__ float3
cv::cudev::exp2(const short3& a);

__device__ __forceinline__ float4
cv::cudev::exp2(const short4& a);

__device__ __forceinline__ float1
cv::cudev::exp2(const int1& a);

__device__ __forceinline__ float2
cv::cudev::exp2(const int2& a);

__device__ __forceinline__ float3
cv::cudev::exp2(const int3& a);

__device__ __forceinline__ float4
cv::cudev::exp2(const int4& a);

__device__ __forceinline__ float1
cv::cudev::exp2(const uint1& a);

__device__ __forceinline__ float2
cv::cudev::exp2(const uint2& a);

__device__ __forceinline__ float3
cv::cudev::exp2(const uint3& a);

__device__ __forceinline__ float4
cv::cudev::exp2(const uint4& a);

__device__ __forceinline__ float1
cv::cudev::exp2(const float1& a);

__device__ __forceinline__ float2
cv::cudev::exp2(const float2& a);

__device__ __forceinline__ float3
cv::cudev::exp2(const float3& a);

__device__ __forceinline__ float4
cv::cudev::exp2(const float4& a);

__device__ __forceinline__ double3
cv::cudev::exp2(const double3& a);

__device__ __forceinline__ double4
cv::cudev::exp2(const double4& a);

__device__ __forceinline__ double2
cv::cudev::exp2(const double2& a);

__device__ __forceinline__ double1
cv::cudev::exp2(const double1& a);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, exp2_func<typename PtrTraits<SrcPtr>::value_type>>>
cv::cudev::exp2_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, exp_func<typename PtrTraits<SrcPtr>::value_type>>>
cv::cudev::exp_(const SrcPtr& src);

template <class Ptr2DSz>
__host__ int
cv::cudev::getCols(const Ptr2DSz& ptr);

template <class Ptr2DSz>
__host__ int
cv::cudev::getRows(const Ptr2DSz& ptr);

template <typename T>
__host__ __device__ GlobPtr<T>
cv::cudev::globPtr(
    T* data,
    size_t step
    );

template <typename T>
__host__ __device__ GlobPtrSz<T>
cv::cudev::globPtr(
    T* data,
    size_t step,
    int rows,
    int cols
    );

template <typename T>
__host__ GlobPtrSz<T>
cv::cudev::globPtr(const GpuMat& mat);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, GRAY_to_BGR_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::GRAY_to_BGR_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, GRAY_to_BGRA_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::GRAY_to_BGRA_(const SrcPtr& src);

template <
    class SrcPtr,
    typename ResType,
    class MaskPtr
    >
__host__ void
cv::cudev::gridCalcSum(
    const SrcPtr& src,
    GpuMat_<ResType>& dst,
    const MaskPtr& mask,
    Stream& stream = Stream::Null()
    );

template <
    class SrcPtr,
    typename ResType
    >
__host__ void
cv::cudev::gridCalcSum(
    const SrcPtr& src,
    GpuMat_<ResType>& dst,
    Stream& stream = Stream::Null()
    );

template <
    class Policy,
    class SrcPtr,
    typename ResType,
    class MaskPtr
    >
__host__ void
cv::cudev::gridCalcSum_(
    const SrcPtr& src,
    GpuMat_<ResType>& dst,
    const MaskPtr& mask,
    Stream& stream = Stream::Null()
    );

template <
    class Policy,
    class SrcPtr,
    typename ResType
    >
__host__ void
cv::cudev::gridCalcSum_(
    const SrcPtr& src,
    GpuMat_<ResType>& dst,
    Stream& stream = Stream::Null()
    );

template <
    class SrcPtr,
    typename DstType,
    class MaskPtr
    >
__host__ void
cv::cudev::gridCopy(
    const SrcPtr& src,
    GpuMat_<DstType>& dst,
    const MaskPtr& mask,
    Stream& stream = Stream::Null()
    );

template <
    class SrcPtr,
    typename DstType,
    class MaskPtr
    >
__host__ void
cv::cudev::gridCopy(
    const SrcPtr& src,
    const GlobPtrSz<DstType>& dst,
    const MaskPtr& mask,
    Stream& stream = Stream::Null()
    );

template <
    class SrcPtr,
    typename DstType
    >
__host__ void
cv::cudev::gridCopy(
    const SrcPtr& src,
    GpuMat_<DstType>& dst,
    Stream& stream = Stream::Null()
    );

template <
    class SrcPtr,
    typename DstType
    >
__host__ void
cv::cudev::gridCopy(
    const SrcPtr& src,
    const GlobPtrSz<DstType>& dst,
    Stream& stream = Stream::Null()
    );

template <
    class SrcPtrTuple,
    typename D0,
    typename D1,
    class MaskPtr
    >
__host__ void
cv::cudev::gridCopy(
    const SrcPtrTuple& src,
    const tuple<GpuMat_<D0>&, GpuMat_<D1>&>& dst,
    const MaskPtr& mask,
    Stream& stream = Stream::Null()
    );

template <
    class SrcPtrTuple,
    typename D0,
    typename D1,
    class MaskPtr
    >
__host__ void
cv::cudev::gridCopy(
    const SrcPtrTuple& src,
    const tuple<GlobPtrSz<D0>, GlobPtrSz<D1>>& dst,
    const MaskPtr& mask,
    Stream& stream = Stream::Null()
    );

template <
    class SrcPtrTuple,
    typename D0,
    typename D1
    >
__host__ void
cv::cudev::gridCopy(
    const SrcPtrTuple& src,
    const tuple<GpuMat_<D0>&, GpuMat_<D1>&>& dst,
    Stream& stream = Stream::Null()
    );

template <
    class SrcPtrTuple,
    typename D0,
    typename D1
    >
__host__ void
cv::cudev::gridCopy(
    const SrcPtrTuple& src,
    const tuple<GlobPtrSz<D0>, GlobPtrSz<D1>>& dst,
    Stream& stream = Stream::Null()
    );

template <
    class SrcPtrTuple,
    typename D0,
    typename D1,
    typename D2,
    class MaskPtr
    >
__host__ void
cv::cudev::gridCopy(
    const SrcPtrTuple& src,
    const tuple<GpuMat_<D0>&, GpuMat_<D1>&, GpuMat_<D2>&>& dst,
    const MaskPtr& mask,
    Stream& stream = Stream::Null()
    );

template <
    class SrcPtrTuple,
    typename D0,
    typename D1,
    typename D2,
    class MaskPtr
    >
__host__ void
cv::cudev::gridCopy(
    const SrcPtrTuple& src,
    const tuple<GlobPtrSz<D0>, GlobPtrSz<D1>, GlobPtrSz<D2>>& dst,
    const MaskPtr& mask,
    Stream& stream = Stream::Null()
    );

template <
    class SrcPtrTuple,
    typename D0,
    typename D1,
    typename D2
    >
__host__ void
cv::cudev::gridCopy(
    const SrcPtrTuple& src,
    const tuple<GpuMat_<D0>&, GpuMat_<D1>&, GpuMat_<D2>&>& dst,
    Stream& stream = Stream::Null()
    );

template <
    class SrcPtrTuple,
    typename D0,
    typename D1,
    typename D2
    >
__host__ void
cv::cudev::gridCopy(
    const SrcPtrTuple& src,
    const tuple<GlobPtrSz<D0>, GlobPtrSz<D1>, GlobPtrSz<D2>>& dst,
    Stream& stream = Stream::Null()
    );

template <
    class SrcPtrTuple,
    typename D0,
    typename D1,
    typename D2,
    typename D3,
    class MaskPtr
    >
__host__ void
cv::cudev::gridCopy(
    const SrcPtrTuple& src,
    const tuple<GpuMat_<D0>&, GpuMat_<D1>&, GpuMat_<D2>&, GpuMat_<D3>&>& dst,
    const MaskPtr& mask,
    Stream& stream = Stream::Null()
    );

template <
    class SrcPtrTuple,
    typename D0,
    typename D1,
    typename D2,
    typename D3,
    class MaskPtr
    >
__host__ void
cv::cudev::gridCopy(
    const SrcPtrTuple& src,
    const tuple<GlobPtrSz<D0>, GlobPtrSz<D1>, GlobPtrSz<D2>, GlobPtrSz<D3>>& dst,
    const MaskPtr& mask,
    Stream& stream = Stream::Null()
    );

template <
    class Policy,
    class SrcPtr,
    typename DstType,
    class MaskPtr
    >
__host__ void
cv::cudev::gridCopy_(
    const SrcPtr& src,
    GpuMat_<DstType>& dst,
    const MaskPtr& mask,
    Stream& stream = Stream::Null()
    );

template <
    class Policy,
    class SrcPtr,
    typename DstType,
    class MaskPtr
    >
__host__ void
cv::cudev::gridCopy_(
    const SrcPtr& src,
    const GlobPtrSz<DstType>& dst,
    const MaskPtr& mask,
    Stream& stream = Stream::Null()
    );

template <
    class Policy,
    class SrcPtr,
    typename DstType
    >
__host__ void
cv::cudev::gridCopy_(
    const SrcPtr& src,
    GpuMat_<DstType>& dst,
    Stream& stream = Stream::Null()
    );

template <
    class Policy,
    class SrcPtr,
    typename DstType
    >
__host__ void
cv::cudev::gridCopy_(
    const SrcPtr& src,
    const GlobPtrSz<DstType>& dst,
    Stream& stream = Stream::Null()
    );

template <
    class Policy,
    class SrcPtrTuple,
    typename D0,
    typename D1,
    class MaskPtr
    >
__host__ void
cv::cudev::gridCopy_(
    const SrcPtrTuple& src,
    const tuple<GpuMat_<D0>&, GpuMat_<D1>&>& dst,
    const MaskPtr& mask,
    Stream& stream = Stream::Null()
    );

template <
    class Policy,
    class SrcPtrTuple,
    typename D0,
    typename D1,
    class MaskPtr
    >
__host__ void
cv::cudev::gridCopy_(
    const SrcPtrTuple& src,
    const tuple<GlobPtrSz<D0>, GlobPtrSz<D1>>& dst,
    const MaskPtr& mask,
    Stream& stream = Stream::Null()
    );

template <
    class Policy,
    class SrcPtrTuple,
    typename D0,
    typename D1
    >
__host__ void
cv::cudev::gridCopy_(
    const SrcPtrTuple& src,
    const tuple<GpuMat_<D0>&, GpuMat_<D1>&>& dst,
    Stream& stream = Stream::Null()
    );

template <
    class Policy,
    class SrcPtrTuple,
    typename D0,
    typename D1
    >
__host__ void
cv::cudev::gridCopy_(
    const SrcPtrTuple& src,
    const tuple<GlobPtrSz<D0>, GlobPtrSz<D1>>& dst,
    Stream& stream = Stream::Null()
    );

template <
    class Policy,
    class SrcPtrTuple,
    typename D0,
    typename D1,
    typename D2,
    class MaskPtr
    >
__host__ void
cv::cudev::gridCopy_(
    const SrcPtrTuple& src,
    const tuple<GpuMat_<D0>&, GpuMat_<D1>&, GpuMat_<D2>&>& dst,
    const MaskPtr& mask,
    Stream& stream = Stream::Null()
    );

template <
    class Policy,
    class SrcPtrTuple,
    typename D0,
    typename D1,
    typename D2,
    class MaskPtr
    >
__host__ void
cv::cudev::gridCopy_(
    const SrcPtrTuple& src,
    const tuple<GlobPtrSz<D0>, GlobPtrSz<D1>, GlobPtrSz<D2>>& dst,
    const MaskPtr& mask,
    Stream& stream = Stream::Null()
    );

template <
    class Policy,
    class SrcPtrTuple,
    typename D0,
    typename D1,
    typename D2
    >
__host__ void
cv::cudev::gridCopy_(
    const SrcPtrTuple& src,
    const tuple<GpuMat_<D0>&, GpuMat_<D1>&, GpuMat_<D2>&>& dst,
    Stream& stream = Stream::Null()
    );

template <
    class Policy,
    class SrcPtrTuple,
    typename D0,
    typename D1,
    typename D2
    >
__host__ void
cv::cudev::gridCopy_(
    const SrcPtrTuple& src,
    const tuple<GlobPtrSz<D0>, GlobPtrSz<D1>, GlobPtrSz<D2>>& dst,
    Stream& stream = Stream::Null()
    );

template <
    class Policy,
    class SrcPtrTuple,
    typename D0,
    typename D1,
    typename D2,
    typename D3,
    class MaskPtr
    >
__host__ void
cv::cudev::gridCopy_(
    const SrcPtrTuple& src,
    const tuple<GpuMat_<D0>&, GpuMat_<D1>&, GpuMat_<D2>&, GpuMat_<D3>&>& dst,
    const MaskPtr& mask,
    Stream& stream = Stream::Null()
    );

template <
    class Policy,
    class SrcPtrTuple,
    typename D0,
    typename D1,
    typename D2,
    typename D3,
    class MaskPtr
    >
__host__ void
cv::cudev::gridCopy_(
    const SrcPtrTuple& src,
    const tuple<GlobPtrSz<D0>, GlobPtrSz<D1>, GlobPtrSz<D2>, GlobPtrSz<D3>>& dst,
    const MaskPtr& mask,
    Stream& stream = Stream::Null()
    );

template <
    class Policy,
    class SrcPtrTuple,
    typename D0,
    typename D1,
    typename D2,
    typename D3
    >
__host__ void
cv::cudev::gridCopy_(
    const SrcPtrTuple& src,
    const tuple<GpuMat_<D0>&, GpuMat_<D1>&, GpuMat_<D2>&, GpuMat_<D3>&>& dst,
    Stream& stream = Stream::Null()
    );

template <
    class Policy,
    class SrcPtrTuple,
    typename D0,
    typename D1,
    typename D2,
    typename D3
    >
__host__ void
cv::cudev::gridCopy_(
    const SrcPtrTuple& src,
    const tuple<GlobPtrSz<D0>, GlobPtrSz<D1>, GlobPtrSz<D2>, GlobPtrSz<D3>>& dst,
    Stream& stream = Stream::Null()
    );

template <
    class SrcPtrTuple,
    typename D0,
    typename D1,
    typename D2,
    typename D3
    >
__host__ void
cv::cudev::gridCopy_(
    const SrcPtrTuple& src,
    const tuple<GpuMat_<D0>&, GpuMat_<D1>&, GpuMat_<D2>&, GpuMat_<D3>&>& dst,
    Stream& stream = Stream::Null()
    );

template <
    class SrcPtrTuple,
    typename D0,
    typename D1,
    typename D2,
    typename D3
    >
__host__ void
cv::cudev::gridCopy_(
    const SrcPtrTuple& src,
    const tuple<GlobPtrSz<D0>, GlobPtrSz<D1>, GlobPtrSz<D2>, GlobPtrSz<D3>>& dst,
    Stream& stream = Stream::Null()
    );

template <
    class SrcPtr,
    typename ResType,
    class MaskPtr
    >
__host__ void
cv::cudev::gridCountNonZero(
    const SrcPtr& src,
    GpuMat_<ResType>& dst,
    const MaskPtr& mask,
    Stream& stream = Stream::Null()
    );

template <
    class SrcPtr,
    typename ResType
    >
__host__ void
cv::cudev::gridCountNonZero(
    const SrcPtr& src,
    GpuMat_<ResType>& dst,
    Stream& stream = Stream::Null()
    );

template <
    class Policy,
    class SrcPtr,
    typename ResType,
    class MaskPtr
    >
__host__ void
cv::cudev::gridCountNonZero_(
    const SrcPtr& src,
    GpuMat_<ResType>& dst,
    const MaskPtr& mask,
    Stream& stream = Stream::Null()
    );

template <
    class Policy,
    class SrcPtr,
    typename ResType
    >
__host__ void
cv::cudev::gridCountNonZero_(
    const SrcPtr& src,
    GpuMat_<ResType>& dst,
    Stream& stream = Stream::Null()
    );

template <
    class SrcPtr,
    typename ResType,
    class MaskPtr
    >
__host__ void
cv::cudev::gridFindMaxVal(
    const SrcPtr& src,
    GpuMat_<ResType>& dst,
    const MaskPtr& mask,
    Stream& stream = Stream::Null()
    );

template <
    class SrcPtr,
    typename ResType
    >
__host__ void
cv::cudev::gridFindMaxVal(
    const SrcPtr& src,
    GpuMat_<ResType>& dst,
    Stream& stream = Stream::Null()
    );

template <
    class Policy,
    class SrcPtr,
    typename ResType,
    class MaskPtr
    >
__host__ void
cv::cudev::gridFindMaxVal_(
    const SrcPtr& src,
    GpuMat_<ResType>& dst,
    const MaskPtr& mask,
    Stream& stream = Stream::Null()
    );

template <
    class Policy,
    class SrcPtr,
    typename ResType
    >
__host__ void
cv::cudev::gridFindMaxVal_(
    const SrcPtr& src,
    GpuMat_<ResType>& dst,
    Stream& stream = Stream::Null()
    );

template <
    class SrcPtr,
    typename ResType,
    class MaskPtr
    >
__host__ void
cv::cudev::gridFindMinMaxVal(
    const SrcPtr& src,
    GpuMat_<ResType>& dst,
    const MaskPtr& mask,
    Stream& stream = Stream::Null()
    );

template <
    class SrcPtr,
    typename ResType
    >
__host__ void
cv::cudev::gridFindMinMaxVal(
    const SrcPtr& src,
    GpuMat_<ResType>& dst,
    Stream& stream = Stream::Null()
    );

template <
    class Policy,
    class SrcPtr,
    typename ResType,
    class MaskPtr
    >
__host__ void
cv::cudev::gridFindMinMaxVal_(
    const SrcPtr& src,
    GpuMat_<ResType>& dst,
    const MaskPtr& mask,
    Stream& stream = Stream::Null()
    );

template <
    class Policy,
    class SrcPtr,
    typename ResType
    >
__host__ void
cv::cudev::gridFindMinMaxVal_(
    const SrcPtr& src,
    GpuMat_<ResType>& dst,
    Stream& stream = Stream::Null()
    );

template <
    class SrcPtr,
    typename ResType,
    class MaskPtr
    >
__host__ void
cv::cudev::gridFindMinVal(
    const SrcPtr& src,
    GpuMat_<ResType>& dst,
    const MaskPtr& mask,
    Stream& stream = Stream::Null()
    );

template <
    class SrcPtr,
    typename ResType
    >
__host__ void
cv::cudev::gridFindMinVal(
    const SrcPtr& src,
    GpuMat_<ResType>& dst,
    Stream& stream = Stream::Null()
    );

template <
    class Policy,
    class SrcPtr,
    typename ResType,
    class MaskPtr
    >
__host__ void
cv::cudev::gridFindMinVal_(
    const SrcPtr& src,
    GpuMat_<ResType>& dst,
    const MaskPtr& mask,
    Stream& stream = Stream::Null()
    );

template <
    class Policy,
    class SrcPtr,
    typename ResType
    >
__host__ void
cv::cudev::gridFindMinVal_(
    const SrcPtr& src,
    GpuMat_<ResType>& dst,
    Stream& stream = Stream::Null()
    );

template <
    int BIN_COUNT,
    class SrcPtr,
    typename ResType,
    class MaskPtr
    >
__host__ void
cv::cudev::gridHistogram(
    const SrcPtr& src,
    GpuMat_<ResType>& dst,
    const MaskPtr& mask,
    Stream& stream = Stream::Null()
    );

template <
    int BIN_COUNT,
    class SrcPtr,
    typename ResType
    >
__host__ void
cv::cudev::gridHistogram(
    const SrcPtr& src,
    GpuMat_<ResType>& dst,
    Stream& stream = Stream::Null()
    );

template <
    int BIN_COUNT,
    class Policy,
    class SrcPtr,
    typename ResType,
    class MaskPtr
    >
__host__ void
cv::cudev::gridHistogram_(
    const SrcPtr& src,
    GpuMat_<ResType>& dst,
    const MaskPtr& mask,
    Stream& stream = Stream::Null()
    );

template <
    int BIN_COUNT,
    class Policy,
    class SrcPtr,
    typename ResType
    >
__host__ void
cv::cudev::gridHistogram_(
    const SrcPtr& src,
    GpuMat_<ResType>& dst,
    Stream& stream = Stream::Null()
    );

template <
    class SrcPtr,
    typename DstType
    >
__host__ void
cv::cudev::gridIntegral(
    const SrcPtr& src,
    GpuMat_<DstType>& dst,
    Stream& stream = Stream::Null()
    );

template <
    class SrcPtrTuple,
    typename DstType,
    class MaskPtr
    >
__host__ void
cv::cudev::gridMerge(
    const SrcPtrTuple& src,
    GpuMat_<DstType>& dst,
    const MaskPtr& mask,
    Stream& stream = Stream::Null()
    );

template <
    class SrcPtrTuple,
    typename DstType,
    class MaskPtr
    >
__host__ void
cv::cudev::gridMerge(
    const SrcPtrTuple& src,
    const GlobPtrSz<DstType>& dst,
    const MaskPtr& mask,
    Stream& stream = Stream::Null()
    );

template <
    class SrcPtrTuple,
    typename DstType
    >
__host__ void
cv::cudev::gridMerge(
    const SrcPtrTuple& src,
    GpuMat_<DstType>& dst,
    Stream& stream = Stream::Null()
    );

template <
    class SrcPtrTuple,
    typename DstType
    >
__host__ void
cv::cudev::gridMerge(
    const SrcPtrTuple& src,
    const GlobPtrSz<DstType>& dst,
    Stream& stream = Stream::Null()
    );

template <
    class Policy,
    class SrcPtrTuple,
    typename DstType,
    class MaskPtr
    >
__host__ void
cv::cudev::gridMerge_(
    const SrcPtrTuple& src,
    GpuMat_<DstType>& dst,
    const MaskPtr& mask,
    Stream& stream = Stream::Null()
    );

template <
    class Policy,
    class SrcPtrTuple,
    typename DstType,
    class MaskPtr
    >
__host__ void
cv::cudev::gridMerge_(
    const SrcPtrTuple& src,
    const GlobPtrSz<DstType>& dst,
    const MaskPtr& mask,
    Stream& stream = Stream::Null()
    );

template <
    class Policy,
    class SrcPtrTuple,
    typename DstType
    >
__host__ void
cv::cudev::gridMerge_(
    const SrcPtrTuple& src,
    GpuMat_<DstType>& dst,
    Stream& stream = Stream::Null()
    );

template <
    class Policy,
    class SrcPtrTuple,
    typename DstType
    >
__host__ void
cv::cudev::gridMerge_(
    const SrcPtrTuple& src,
    const GlobPtrSz<DstType>& dst,
    Stream& stream = Stream::Null()
    );

template <
    class SrcPtr,
    typename ResType,
    class MaskPtr
    >
__host__ void
cv::cudev::gridMinMaxLoc(
    const SrcPtr& src,
    GpuMat_<ResType>& valBuf,
    GpuMat_<int>& locBuf,
    const MaskPtr& mask,
    Stream& stream = Stream::Null()
    );

template <
    class SrcPtr,
    typename ResType
    >
__host__ void
cv::cudev::gridMinMaxLoc(
    const SrcPtr& src,
    GpuMat_<ResType>& valBuf,
    GpuMat_<int>& locBuf,
    Stream& stream = Stream::Null()
    );

template <
    class Policy,
    class SrcPtr,
    typename ResType,
    class MaskPtr
    >
__host__ void
cv::cudev::gridMinMaxLoc_(
    const SrcPtr& src,
    GpuMat_<ResType>& valBuf,
    GpuMat_<int>& locBuf,
    const MaskPtr& mask,
    Stream& stream = Stream::Null()
    );

template <
    class Policy,
    class SrcPtr,
    typename ResType
    >
__host__ void
cv::cudev::gridMinMaxLoc_(
    const SrcPtr& src,
    GpuMat_<ResType>& valBuf,
    GpuMat_<int>& locBuf,
    Stream& stream = Stream::Null()
    );

template <
    class SrcPtr,
    typename DstType
    >
__host__ void
cv::cudev::gridPyrDown(
    const SrcPtr& src,
    GpuMat_<DstType>& dst,
    Stream& stream = Stream::Null()
    );

template <
    class Brd,
    class SrcPtr,
    typename DstType
    >
__host__ void
cv::cudev::gridPyrDown_(
    const SrcPtr& src,
    GpuMat_<DstType>& dst,
    Stream& stream = Stream::Null()
    );

template <
    class SrcPtr,
    typename DstType
    >
__host__ void
cv::cudev::gridPyrUp(
    const SrcPtr& src,
    GpuMat_<DstType>& dst,
    Stream& stream = Stream::Null()
    );

template <
    class Reductor,
    class SrcPtr,
    typename ResType,
    class MaskPtr
    >
__host__ void
cv::cudev::gridReduceToColumn(
    const SrcPtr& src,
    GpuMat_<ResType>& dst,
    const MaskPtr& mask,
    Stream& stream = Stream::Null()
    );

template <
    class Reductor,
    class SrcPtr,
    typename ResType
    >
__host__ void
cv::cudev::gridReduceToColumn(
    const SrcPtr& src,
    GpuMat_<ResType>& dst,
    Stream& stream = Stream::Null()
    );

template <
    class Reductor,
    class Policy,
    class SrcPtr,
    typename ResType,
    class MaskPtr
    >
__host__ void
cv::cudev::gridReduceToColumn_(
    const SrcPtr& src,
    GpuMat_<ResType>& dst,
    const MaskPtr& mask,
    Stream& stream = Stream::Null()
    );

template <
    class Reductor,
    class Policy,
    class SrcPtr,
    typename ResType
    >
__host__ void
cv::cudev::gridReduceToColumn_(
    const SrcPtr& src,
    GpuMat_<ResType>& dst,
    Stream& stream = Stream::Null()
    );

template <
    class Reductor,
    class SrcPtr,
    typename ResType,
    class MaskPtr
    >
__host__ void
cv::cudev::gridReduceToRow(
    const SrcPtr& src,
    GpuMat_<ResType>& dst,
    const MaskPtr& mask,
    Stream& stream = Stream::Null()
    );

template <
    class Reductor,
    class SrcPtr,
    typename ResType
    >
__host__ void
cv::cudev::gridReduceToRow(
    const SrcPtr& src,
    GpuMat_<ResType>& dst,
    Stream& stream = Stream::Null()
    );

template <
    class SrcPtr,
    typename DstType,
    class MaskPtr
    >
__host__ void
cv::cudev::gridSplit(
    const SrcPtr& src,
    const tuple<GpuMat_<DstType>&, GpuMat_<DstType>&>& dst,
    const MaskPtr& mask,
    Stream& stream = Stream::Null()
    );

template <
    class SrcPtr,
    typename DstType
    >
__host__ void
cv::cudev::gridSplit(
    const SrcPtr& src,
    const tuple<GpuMat_<DstType>&, GpuMat_<DstType>&>& dst,
    Stream& stream = Stream::Null()
    );

template <
    class SrcPtr,
    typename DstType,
    class MaskPtr
    >
__host__ void
cv::cudev::gridSplit(
    const SrcPtr& src,
    const tuple<GpuMat_<DstType>&, GpuMat_<DstType>&, GpuMat_<DstType>&>& dst,
    const MaskPtr& mask,
    Stream& stream = Stream::Null()
    );

template <
    class SrcPtr,
    typename DstType
    >
__host__ void
cv::cudev::gridSplit(
    const SrcPtr& src,
    const tuple<GpuMat_<DstType>&, GpuMat_<DstType>&, GpuMat_<DstType>&>& dst,
    Stream& stream = Stream::Null()
    );

template <
    class SrcPtr,
    typename DstType,
    class MaskPtr
    >
__host__ void
cv::cudev::gridSplit(
    const SrcPtr& src,
    const tuple<GpuMat_<DstType>&, GpuMat_<DstType>&, GpuMat_<DstType>&, GpuMat_<DstType>&>& dst,
    const MaskPtr& mask,
    Stream& stream = Stream::Null()
    );

template <
    class SrcPtr,
    typename DstType
    >
__host__ void
cv::cudev::gridSplit(
    const SrcPtr& src,
    const tuple<GpuMat_<DstType>&, GpuMat_<DstType>&, GpuMat_<DstType>&, GpuMat_<DstType>&>& dst,
    Stream& stream = Stream::Null()
    );

template <
    class SrcPtr,
    typename DstType,
    int COUNT,
    class MaskPtr
    >
__host__ void
cv::cudev::gridSplit(
    const SrcPtr& src,
    GpuMat_<DstType>(&) dst [COUNT],
    const MaskPtr& mask,
    Stream& stream = Stream::Null()
    );

template <
    class SrcPtr,
    typename DstType,
    int COUNT,
    class MaskPtr
    >
__host__ void
cv::cudev::gridSplit(
    const SrcPtr& src,
    GlobPtrSz<DstType>(&) dst [COUNT],
    const MaskPtr& mask,
    Stream& stream = Stream::Null()
    );

template <
    class SrcPtr,
    typename DstType,
    int COUNT
    >
__host__ void
cv::cudev::gridSplit(
    const SrcPtr& src,
    GpuMat_<DstType>(&) dst [COUNT],
    Stream& stream = Stream::Null()
    );

template <
    class SrcPtr,
    typename DstType,
    int COUNT
    >
__host__ void
cv::cudev::gridSplit(
    const SrcPtr& src,
    GlobPtrSz<DstType>(&) dst [COUNT],
    Stream& stream = Stream::Null()
    );

template <
    class Policy,
    class SrcPtr,
    typename DstType,
    class MaskPtr
    >
__host__ void
cv::cudev::gridSplit_(
    const SrcPtr& src,
    const tuple<GpuMat_<DstType>&, GpuMat_<DstType>&>& dst,
    const MaskPtr& mask,
    Stream& stream = Stream::Null()
    );

template <
    class Policy,
    class SrcPtr,
    typename DstType,
    class MaskPtr
    >
__host__ void
cv::cudev::gridSplit_(
    const SrcPtr& src,
    GpuMat_<DstType>(&) dst [2],
    const MaskPtr& mask,
    Stream& stream = Stream::Null()
    );

template <
    class Policy,
    class SrcPtr,
    typename DstType,
    class MaskPtr
    >
__host__ void
cv::cudev::gridSplit_(
    const SrcPtr& src,
    GlobPtrSz<DstType>(&) dst [2],
    const MaskPtr& mask,
    Stream& stream = Stream::Null()
    );

template <
    class Policy,
    class SrcPtr,
    typename DstType
    >
__host__ void
cv::cudev::gridSplit_(
    const SrcPtr& src,
    const tuple<GpuMat_<DstType>&, GpuMat_<DstType>&>& dst,
    Stream& stream = Stream::Null()
    );

template <
    class Policy,
    class SrcPtr,
    typename DstType
    >
__host__ void
cv::cudev::gridSplit_(
    const SrcPtr& src,
    GpuMat_<DstType>(&) dst [2],
    Stream& stream = Stream::Null()
    );

template <
    class Policy,
    class SrcPtr,
    typename DstType
    >
__host__ void
cv::cudev::gridSplit_(
    const SrcPtr& src,
    GlobPtrSz<DstType>(&) dst [2],
    Stream& stream = Stream::Null()
    );

template <
    class Policy,
    class SrcPtr,
    typename DstType,
    class MaskPtr
    >
__host__ void
cv::cudev::gridSplit_(
    const SrcPtr& src,
    const tuple<GpuMat_<DstType>&, GpuMat_<DstType>&, GpuMat_<DstType>&>& dst,
    const MaskPtr& mask,
    Stream& stream = Stream::Null()
    );

template <
    class Policy,
    class SrcPtr,
    typename DstType,
    class MaskPtr
    >
__host__ void
cv::cudev::gridSplit_(
    const SrcPtr& src,
    GpuMat_<DstType>(&) dst [3],
    const MaskPtr& mask,
    Stream& stream = Stream::Null()
    );

template <
    class Policy,
    class SrcPtr,
    typename DstType,
    class MaskPtr
    >
__host__ void
cv::cudev::gridSplit_(
    const SrcPtr& src,
    GlobPtrSz<DstType>(&) dst [3],
    const MaskPtr& mask,
    Stream& stream = Stream::Null()
    );

template <
    class Policy,
    class SrcPtr,
    typename DstType
    >
__host__ void
cv::cudev::gridSplit_(
    const SrcPtr& src,
    const tuple<GpuMat_<DstType>&, GpuMat_<DstType>&, GpuMat_<DstType>&>& dst,
    Stream& stream = Stream::Null()
    );

template <
    class Policy,
    class SrcPtr,
    typename DstType
    >
__host__ void
cv::cudev::gridSplit_(
    const SrcPtr& src,
    GpuMat_<DstType>(&) dst [3],
    Stream& stream = Stream::Null()
    );

template <
    class Policy,
    class SrcPtr,
    typename DstType
    >
__host__ void
cv::cudev::gridSplit_(
    const SrcPtr& src,
    GlobPtrSz<DstType>(&) dst [3],
    Stream& stream = Stream::Null()
    );

template <
    class Policy,
    class SrcPtr,
    typename DstType,
    class MaskPtr
    >
__host__ void
cv::cudev::gridSplit_(
    const SrcPtr& src,
    const tuple<GpuMat_<DstType>&, GpuMat_<DstType>&, GpuMat_<DstType>&, GpuMat_<DstType>&>& dst,
    const MaskPtr& mask,
    Stream& stream = Stream::Null()
    );

template <
    class Policy,
    class SrcPtr,
    typename DstType,
    class MaskPtr
    >
__host__ void
cv::cudev::gridSplit_(
    const SrcPtr& src,
    GpuMat_<DstType>(&) dst [4],
    const MaskPtr& mask,
    Stream& stream = Stream::Null()
    );

template <
    class Policy,
    class SrcPtr,
    typename DstType,
    class MaskPtr
    >
__host__ void
cv::cudev::gridSplit_(
    const SrcPtr& src,
    GlobPtrSz<DstType>(&) dst [4],
    const MaskPtr& mask,
    Stream& stream = Stream::Null()
    );

template <
    class Policy,
    class SrcPtr,
    typename DstType
    >
__host__ void
cv::cudev::gridSplit_(
    const SrcPtr& src,
    const tuple<GpuMat_<DstType>&, GpuMat_<DstType>&, GpuMat_<DstType>&, GpuMat_<DstType>&>& dst,
    Stream& stream = Stream::Null()
    );

template <
    class Policy,
    class SrcPtr,
    typename DstType
    >
__host__ void
cv::cudev::gridSplit_(
    const SrcPtr& src,
    GpuMat_<DstType>(&) dst [4],
    Stream& stream = Stream::Null()
    );

template <
    class Policy,
    class SrcPtr,
    typename DstType
    >
__host__ void
cv::cudev::gridSplit_(
    const SrcPtr& src,
    GlobPtrSz<DstType>(&) dst [4],
    Stream& stream = Stream::Null()
    );

template <
    class SrcPtr1,
    class SrcPtr2,
    typename DstType,
    class Op,
    class MaskPtr
    >
__host__ void
cv::cudev::gridTransformBinary(
    const SrcPtr1& src1,
    const SrcPtr2& src2,
    GpuMat_<DstType>& dst,
    const Op& op,
    const MaskPtr& mask,
    Stream& stream = Stream::Null()
    );

template <
    class SrcPtr1,
    class SrcPtr2,
    typename DstType,
    class Op,
    class MaskPtr
    >
__host__ void
cv::cudev::gridTransformBinary(
    const SrcPtr1& src1,
    const SrcPtr2& src2,
    const GlobPtrSz<DstType>& dst,
    const Op& op,
    const MaskPtr& mask,
    Stream& stream = Stream::Null()
    );

template <
    class SrcPtr1,
    class SrcPtr2,
    typename DstType,
    class Op
    >
__host__ void
cv::cudev::gridTransformBinary(
    const SrcPtr1& src1,
    const SrcPtr2& src2,
    GpuMat_<DstType>& dst,
    const Op& op,
    Stream& stream = Stream::Null()
    );

template <
    class SrcPtr1,
    class SrcPtr2,
    typename DstType,
    class Op
    >
__host__ void
cv::cudev::gridTransformBinary(
    const SrcPtr1& src1,
    const SrcPtr2& src2,
    const GlobPtrSz<DstType>& dst,
    const Op& op,
    Stream& stream = Stream::Null()
    );

template <
    class Policy,
    class SrcPtr1,
    class SrcPtr2,
    typename DstType,
    class BinOp,
    class MaskPtr
    >
__host__ void
cv::cudev::gridTransformBinary_(
    const SrcPtr1& src1,
    const SrcPtr2& src2,
    GpuMat_<DstType>& dst,
    const BinOp& op,
    const MaskPtr& mask,
    Stream& stream = Stream::Null()
    );

template <
    class Policy,
    class SrcPtr1,
    class SrcPtr2,
    typename DstType,
    class BinOp,
    class MaskPtr
    >
__host__ void
cv::cudev::gridTransformBinary_(
    const SrcPtr1& src1,
    const SrcPtr2& src2,
    const GlobPtrSz<DstType>& dst,
    const BinOp& op,
    const MaskPtr& mask,
    Stream& stream = Stream::Null()
    );

template <
    class Policy,
    class SrcPtr1,
    class SrcPtr2,
    typename DstType,
    class BinOp
    >
__host__ void
cv::cudev::gridTransformBinary_(
    const SrcPtr1& src1,
    const SrcPtr2& src2,
    GpuMat_<DstType>& dst,
    const BinOp& op,
    Stream& stream = Stream::Null()
    );

template <
    class Policy,
    class SrcPtr1,
    class SrcPtr2,
    typename DstType,
    class BinOp
    >
__host__ void
cv::cudev::gridTransformBinary_(
    const SrcPtr1& src1,
    const SrcPtr2& src2,
    const GlobPtrSz<DstType>& dst,
    const BinOp& op,
    Stream& stream = Stream::Null()
    );

template <
    class SrcPtr,
    typename D0,
    typename D1,
    class OpTuple,
    class MaskPtr
    >
__host__ void
cv::cudev::gridTransformTuple(
    const SrcPtr& src,
    const tuple<GpuMat_<D0>&, GpuMat_<D1>&>& dst,
    const OpTuple& op,
    const MaskPtr& mask,
    Stream& stream = Stream::Null()
    );

template <
    class SrcPtr,
    typename D0,
    typename D1,
    class OpTuple,
    class MaskPtr
    >
__host__ void
cv::cudev::gridTransformTuple(
    const SrcPtr& src,
    const tuple<GlobPtrSz<D0>, GlobPtrSz<D1>>& dst,
    const OpTuple& op,
    const MaskPtr& mask,
    Stream& stream = Stream::Null()
    );

template <
    class SrcPtr,
    typename D0,
    typename D1,
    class OpTuple
    >
__host__ void
cv::cudev::gridTransformTuple(
    const SrcPtr& src,
    const tuple<GpuMat_<D0>&, GpuMat_<D1>&>& dst,
    const OpTuple& op,
    Stream& stream = Stream::Null()
    );

template <
    class SrcPtr,
    typename D0,
    typename D1,
    class OpTuple
    >
__host__ void
cv::cudev::gridTransformTuple(
    const SrcPtr& src,
    const tuple<GlobPtrSz<D0>, GlobPtrSz<D1>>& dst,
    const OpTuple& op,
    Stream& stream = Stream::Null()
    );

template <
    class SrcPtr,
    typename D0,
    typename D1,
    typename D2,
    class OpTuple,
    class MaskPtr
    >
__host__ void
cv::cudev::gridTransformTuple(
    const SrcPtr& src,
    const tuple<GpuMat_<D0>&, GpuMat_<D1>&, GpuMat_<D2>&>& dst,
    const OpTuple& op,
    const MaskPtr& mask,
    Stream& stream = Stream::Null()
    );

template <
    class SrcPtr,
    typename D0,
    typename D1,
    typename D2,
    class OpTuple,
    class MaskPtr
    >
__host__ void
cv::cudev::gridTransformTuple(
    const SrcPtr& src,
    const tuple<GlobPtrSz<D0>, GlobPtrSz<D1>, GlobPtrSz<D2>>& dst,
    const OpTuple& op,
    const MaskPtr& mask,
    Stream& stream = Stream::Null()
    );

template <
    class SrcPtr,
    typename D0,
    typename D1,
    typename D2,
    class OpTuple
    >
__host__ void
cv::cudev::gridTransformTuple(
    const SrcPtr& src,
    const tuple<GpuMat_<D0>&, GpuMat_<D1>&, GpuMat_<D2>&>& dst,
    const OpTuple& op,
    Stream& stream = Stream::Null()
    );

template <
    class SrcPtr,
    typename D0,
    typename D1,
    typename D2,
    class OpTuple
    >
__host__ void
cv::cudev::gridTransformTuple(
    const SrcPtr& src,
    const tuple<GlobPtrSz<D0>, GlobPtrSz<D1>, GlobPtrSz<D2>>& dst,
    const OpTuple& op,
    Stream& stream = Stream::Null()
    );

template <
    class SrcPtr,
    typename D0,
    typename D1,
    typename D2,
    typename D3,
    class OpTuple,
    class MaskPtr
    >
__host__ void
cv::cudev::gridTransformTuple(
    const SrcPtr& src,
    const tuple<GpuMat_<D0>&, GpuMat_<D1>&, GpuMat_<D2>&, GpuMat_<D3>&>& dst,
    const OpTuple& op,
    const MaskPtr& mask,
    Stream& stream = Stream::Null()
    );

template <
    class SrcPtr,
    typename D0,
    typename D1,
    typename D2,
    typename D3,
    class OpTuple,
    class MaskPtr
    >
__host__ void
cv::cudev::gridTransformTuple(
    const SrcPtr& src,
    const tuple<GlobPtrSz<D0>, GlobPtrSz<D1>, GlobPtrSz<D2>, GlobPtrSz<D3>>& dst,
    const OpTuple& op,
    const MaskPtr& mask,
    Stream& stream = Stream::Null()
    );

template <
    class SrcPtr,
    typename D0,
    typename D1,
    typename D2,
    typename D3,
    class OpTuple
    >
__host__ void
cv::cudev::gridTransformTuple(
    const SrcPtr& src,
    const tuple<GpuMat_<D0>&, GpuMat_<D1>&, GpuMat_<D2>&, GpuMat_<D3>&>& dst,
    const OpTuple& op,
    Stream& stream = Stream::Null()
    );

template <
    class SrcPtr,
    typename D0,
    typename D1,
    typename D2,
    typename D3,
    class OpTuple
    >
__host__ void
cv::cudev::gridTransformTuple(
    const SrcPtr& src,
    const tuple<GlobPtrSz<D0>, GlobPtrSz<D1>, GlobPtrSz<D2>, GlobPtrSz<D3>>& dst,
    const OpTuple& op,
    Stream& stream = Stream::Null()
    );

template <
    class Policy,
    class SrcPtr,
    typename D0,
    typename D1,
    class OpTuple,
    class MaskPtr
    >
__host__ void
cv::cudev::gridTransformTuple_(
    const SrcPtr& src,
    const tuple<GpuMat_<D0>&, GpuMat_<D1>&>& dst,
    const OpTuple& op,
    const MaskPtr& mask,
    Stream& stream = Stream::Null()
    );

template <
    class Policy,
    class SrcPtr,
    typename D0,
    typename D1,
    class OpTuple,
    class MaskPtr
    >
__host__ void
cv::cudev::gridTransformTuple_(
    const SrcPtr& src,
    const tuple<GlobPtrSz<D0>, GlobPtrSz<D1>>& dst,
    const OpTuple& op,
    const MaskPtr& mask,
    Stream& stream = Stream::Null()
    );

template <
    class Policy,
    class SrcPtr,
    typename D0,
    typename D1,
    class OpTuple
    >
__host__ void
cv::cudev::gridTransformTuple_(
    const SrcPtr& src,
    const tuple<GpuMat_<D0>&, GpuMat_<D1>&>& dst,
    const OpTuple& op,
    Stream& stream = Stream::Null()
    );

template <
    class Policy,
    class SrcPtr,
    typename D0,
    typename D1,
    class OpTuple
    >
__host__ void
cv::cudev::gridTransformTuple_(
    const SrcPtr& src,
    const tuple<GlobPtrSz<D0>, GlobPtrSz<D1>>& dst,
    const OpTuple& op,
    Stream& stream = Stream::Null()
    );

template <
    class Policy,
    class SrcPtr,
    typename D0,
    typename D1,
    typename D2,
    class OpTuple,
    class MaskPtr
    >
__host__ void
cv::cudev::gridTransformTuple_(
    const SrcPtr& src,
    const tuple<GpuMat_<D0>&, GpuMat_<D1>&, GpuMat_<D2>&>& dst,
    const OpTuple& op,
    const MaskPtr& mask,
    Stream& stream = Stream::Null()
    );

template <
    class Policy,
    class SrcPtr,
    typename D0,
    typename D1,
    typename D2,
    class OpTuple,
    class MaskPtr
    >
__host__ void
cv::cudev::gridTransformTuple_(
    const SrcPtr& src,
    const tuple<GlobPtrSz<D0>, GlobPtrSz<D1>, GlobPtrSz<D2>>& dst,
    const OpTuple& op,
    const MaskPtr& mask,
    Stream& stream = Stream::Null()
    );

template <
    class Policy,
    class SrcPtr,
    typename D0,
    typename D1,
    typename D2,
    class OpTuple
    >
__host__ void
cv::cudev::gridTransformTuple_(
    const SrcPtr& src,
    const tuple<GpuMat_<D0>&, GpuMat_<D1>&, GpuMat_<D2>&>& dst,
    const OpTuple& op,
    Stream& stream = Stream::Null()
    );

template <
    class Policy,
    class SrcPtr,
    typename D0,
    typename D1,
    typename D2,
    class OpTuple
    >
__host__ void
cv::cudev::gridTransformTuple_(
    const SrcPtr& src,
    const tuple<GlobPtrSz<D0>, GlobPtrSz<D1>, GlobPtrSz<D2>>& dst,
    const OpTuple& op,
    Stream& stream = Stream::Null()
    );

template <
    class Policy,
    class SrcPtr,
    typename D0,
    typename D1,
    typename D2,
    typename D3,
    class OpTuple,
    class MaskPtr
    >
__host__ void
cv::cudev::gridTransformTuple_(
    const SrcPtr& src,
    const tuple<GpuMat_<D0>&, GpuMat_<D1>&, GpuMat_<D2>&, GpuMat_<D3>&>& dst,
    const OpTuple& op,
    const MaskPtr& mask,
    Stream& stream = Stream::Null()
    );

template <
    class Policy,
    class SrcPtr,
    typename D0,
    typename D1,
    typename D2,
    typename D3,
    class OpTuple,
    class MaskPtr
    >
__host__ void
cv::cudev::gridTransformTuple_(
    const SrcPtr& src,
    const tuple<GlobPtrSz<D0>, GlobPtrSz<D1>, GlobPtrSz<D2>, GlobPtrSz<D3>>& dst,
    const OpTuple& op,
    const MaskPtr& mask,
    Stream& stream = Stream::Null()
    );

template <
    class Policy,
    class SrcPtr,
    typename D0,
    typename D1,
    typename D2,
    typename D3,
    class OpTuple
    >
__host__ void
cv::cudev::gridTransformTuple_(
    const SrcPtr& src,
    const tuple<GpuMat_<D0>&, GpuMat_<D1>&, GpuMat_<D2>&, GpuMat_<D3>&>& dst,
    const OpTuple& op,
    Stream& stream = Stream::Null()
    );

template <
    class Policy,
    class SrcPtr,
    typename D0,
    typename D1,
    typename D2,
    typename D3,
    class OpTuple
    >
__host__ void
cv::cudev::gridTransformTuple_(
    const SrcPtr& src,
    const tuple<GlobPtrSz<D0>, GlobPtrSz<D1>, GlobPtrSz<D2>, GlobPtrSz<D3>>& dst,
    const OpTuple& op,
    Stream& stream = Stream::Null()
    );

template <
    class SrcPtr,
    typename DstType,
    class Op,
    class MaskPtr
    >
__host__ void
cv::cudev::gridTransformUnary(
    const SrcPtr& src,
    GpuMat_<DstType>& dst,
    const Op& op,
    const MaskPtr& mask,
    Stream& stream = Stream::Null()
    );

template <
    class SrcPtr,
    typename DstType,
    class Op,
    class MaskPtr
    >
__host__ void
cv::cudev::gridTransformUnary(
    const SrcPtr& src,
    const GlobPtrSz<DstType>& dst,
    const Op& op,
    const MaskPtr& mask,
    Stream& stream = Stream::Null()
    );

template <
    class SrcPtr,
    typename DstType,
    class Op
    >
__host__ void
cv::cudev::gridTransformUnary(
    const SrcPtr& src,
    GpuMat_<DstType>& dst,
    const Op& op,
    Stream& stream = Stream::Null()
    );

template <
    class SrcPtr,
    typename DstType,
    class Op
    >
__host__ void
cv::cudev::gridTransformUnary(
    const SrcPtr& src,
    const GlobPtrSz<DstType>& dst,
    const Op& op,
    Stream& stream = Stream::Null()
    );

template <
    class Policy,
    class SrcPtr,
    typename DstType,
    class UnOp,
    class MaskPtr
    >
__host__ void
cv::cudev::gridTransformUnary_(
    const SrcPtr& src,
    GpuMat_<DstType>& dst,
    const UnOp& op,
    const MaskPtr& mask,
    Stream& stream = Stream::Null()
    );

template <
    class Policy,
    class SrcPtr,
    typename DstType,
    class UnOp,
    class MaskPtr
    >
__host__ void
cv::cudev::gridTransformUnary_(
    const SrcPtr& src,
    const GlobPtrSz<DstType>& dst,
    const UnOp& op,
    const MaskPtr& mask,
    Stream& stream = Stream::Null()
    );

template <
    class Policy,
    class SrcPtr,
    typename DstType,
    class UnOp
    >
__host__ void
cv::cudev::gridTransformUnary_(
    const SrcPtr& src,
    GpuMat_<DstType>& dst,
    const UnOp& op,
    Stream& stream = Stream::Null()
    );

template <
    class Policy,
    class SrcPtr,
    typename DstType,
    class UnOp
    >
__host__ void
cv::cudev::gridTransformUnary_(
    const SrcPtr& src,
    const GlobPtrSz<DstType>& dst,
    const UnOp& op,
    Stream& stream = Stream::Null()
    );

template <
    class SrcPtr,
    typename DstType
    >
__host__ void
cv::cudev::gridTranspose(
    const SrcPtr& src,
    GpuMat_<DstType>& dst,
    Stream& stream = Stream::Null()
    );

template <
    class SrcPtr,
    typename DstType
    >
__host__ void
cv::cudev::gridTranspose(
    const SrcPtr& src,
    const GlobPtrSz<DstType>& dst,
    Stream& stream = Stream::Null()
    );

template <
    class Policy,
    class SrcPtr,
    typename DstType
    >
__host__ void
cv::cudev::gridTranspose_(
    const SrcPtr& src,
    GpuMat_<DstType>& dst,
    Stream& stream = Stream::Null()
    );

template <
    class Policy,
    class SrcPtr,
    typename DstType
    >
__host__ void
cv::cudev::gridTranspose_(
    const SrcPtr& src,
    const GlobPtrSz<DstType>& dst,
    Stream& stream = Stream::Null()
    );

template <
    int BIN_COUNT,
    class SrcPtr
    >
__host__ Expr<HistogramBody<BIN_COUNT, SrcPtr>>
cv::cudev::histogram_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, HLS4_to_BGR_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::HLS4_to_BGR_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, HLS4_to_BGR_FULL_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::HLS4_to_BGR_FULL_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, HLS4_to_BGRA_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::HLS4_to_BGRA_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, HLS4_to_BGRA_FULL_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::HLS4_to_BGRA_FULL_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, HLS4_to_RGB_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::HLS4_to_RGB_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, HLS4_to_RGB_FULL_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::HLS4_to_RGB_FULL_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, HLS4_to_RGBA_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::HLS4_to_RGBA_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, HLS4_to_RGBA_FULL_func<typename VecTraits<typename