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 PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::HLS4_to_RGBA_FULL_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, HLS_to_BGR_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::HLS_to_BGR_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, HLS_to_BGR_FULL_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::HLS_to_BGR_FULL_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, HLS_to_BGRA_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::HLS_to_BGRA_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, HLS_to_BGRA_FULL_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::HLS_to_BGRA_FULL_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, HLS_to_RGB_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::HLS_to_RGB_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, HLS_to_RGB_FULL_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::HLS_to_RGB_FULL_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, HLS_to_RGBA_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::HLS_to_RGBA_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, HLS_to_RGBA_FULL_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::HLS_to_RGBA_FULL_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, HSV4_to_BGR_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::HSV4_to_BGR_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, HSV4_to_BGR_FULL_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::HSV4_to_BGR_FULL_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, HSV4_to_BGRA_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::HSV4_to_BGRA_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, HSV4_to_BGRA_FULL_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::HSV4_to_BGRA_FULL_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, HSV4_to_RGB_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::HSV4_to_RGB_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, HSV4_to_RGB_FULL_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::HSV4_to_RGB_FULL_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, HSV4_to_RGBA_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::HSV4_to_RGBA_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, HSV4_to_RGBA_FULL_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::HSV4_to_RGBA_FULL_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, HSV_to_BGR_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::HSV_to_BGR_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, HSV_to_BGR_FULL_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::HSV_to_BGR_FULL_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, HSV_to_BGRA_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::HSV_to_BGRA_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, HSV_to_BGRA_FULL_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::HSV_to_BGRA_FULL_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, HSV_to_RGB_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::HSV_to_RGB_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, HSV_to_RGB_FULL_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::HSV_to_RGB_FULL_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, HSV_to_RGBA_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::HSV_to_RGBA_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, HSV_to_RGBA_FULL_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::HSV_to_RGBA_FULL_(const SrcPtr& src);

__device__ __forceinline__ float1
cv::cudev::hypot(
    const uchar1& a,
    const uchar1& b
    );

__device__ __forceinline__ float2
cv::cudev::hypot(
    const uchar2& a,
    const uchar2& b
    );

__device__ __forceinline__ float3
cv::cudev::hypot(
    const uchar3& a,
    const uchar3& b
    );

__device__ __forceinline__ float4
cv::cudev::hypot(
    const uchar4& a,
    const uchar4& b
    );

__device__ __forceinline__ float1
cv::cudev::hypot(
    const char1& a,
    const char1& b
    );

__device__ __forceinline__ float2
cv::cudev::hypot(
    const char2& a,
    const char2& b
    );

__device__ __forceinline__ float3
cv::cudev::hypot(
    const char3& a,
    const char3& b
    );

__device__ __forceinline__ float4
cv::cudev::hypot(
    const char4& a,
    const char4& b
    );

__device__ __forceinline__ float4
cv::cudev::hypot(
    const ushort4& a,
    const ushort4& b
    );

__device__ __forceinline__ float1
cv::cudev::hypot(
    const ushort1& a,
    const ushort1& b
    );

__device__ __forceinline__ float2
cv::cudev::hypot(
    const ushort2& a,
    const ushort2& b
    );

__device__ __forceinline__ float3
cv::cudev::hypot(
    const ushort3& a,
    const ushort3& b
    );

__device__ __forceinline__ float4
cv::cudev::hypot(
    const short4& a,
    const short4& b
    );

__device__ __forceinline__ float1
cv::cudev::hypot(
    const short1& a,
    const short1& b
    );

__device__ __forceinline__ float2
cv::cudev::hypot(
    const short2& a,
    const short2& b
    );

__device__ __forceinline__ float3
cv::cudev::hypot(
    const short3& a,
    const short3& b
    );

__device__ __forceinline__ float4
cv::cudev::hypot(
    const uint4& a,
    const uint4& b
    );

__device__ __forceinline__ float1
cv::cudev::hypot(
    const uint1& a,
    const uint1& b
    );

__device__ __forceinline__ float2
cv::cudev::hypot(
    const uint2& a,
    const uint2& b
    );

__device__ __forceinline__ float3
cv::cudev::hypot(
    const uint3& a,
    const uint3& b
    );

__device__ __forceinline__ float2
cv::cudev::hypot(
    const int2& a,
    const int2& b
    );

__device__ __forceinline__ float3
cv::cudev::hypot(
    const int3& a,
    const int3& b
    );

__device__ __forceinline__ float4
cv::cudev::hypot(
    const int4& a,
    const int4& b
    );

__device__ __forceinline__ float1
cv::cudev::hypot(
    const int1& a,
    const int1& b
    );

__device__ __forceinline__ float4
cv::cudev::hypot(
    const float4& a,
    const float4& b
    );

__device__ __forceinline__ float1
cv::cudev::hypot(
    const float1& a,
    const float1& b
    );

__device__ __forceinline__ float2
cv::cudev::hypot(
    const float2& a,
    const float2& b
    );

__device__ __forceinline__ float3
cv::cudev::hypot(
    const float3& a,
    const float3& b
    );

__device__ __forceinline__ double4
cv::cudev::hypot(
    const double4& a,
    const double4& b
    );

__device__ __forceinline__ double2
cv::cudev::hypot(
    const double2& a,
    const double2& b
    );

__device__ __forceinline__ double3
cv::cudev::hypot(
    const double3& a,
    const double3& b
    );

__device__ __forceinline__ double1
cv::cudev::hypot(
    const double1& a,
    const double1& b
    );

__device__ __forceinline__ float1
cv::cudev::hypot(
    const uchar1& a,
    float s
    );

__device__ __forceinline__ float1
cv::cudev::hypot(
    float s,
    const uchar1& b
    );

__device__ __forceinline__ float2
cv::cudev::hypot(
    const uchar2& a,
    float s
    );

__device__ __forceinline__ float2
cv::cudev::hypot(
    float s,
    const uchar2& b
    );

__device__ __forceinline__ float3
cv::cudev::hypot(
    const uchar3& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::hypot(
    float s,
    const uchar3& b
    );

__device__ __forceinline__ float4
cv::cudev::hypot(
    const uchar4& a,
    float s
    );

__device__ __forceinline__ float4
cv::cudev::hypot(
    float s,
    const uchar4& b
    );

__device__ __forceinline__ double4
cv::cudev::hypot(
    double s,
    const uchar4& b
    );

__device__ __forceinline__ double2
cv::cudev::hypot(
    double s,
    const uchar2& b
    );

__device__ __forceinline__ double1
cv::cudev::hypot(
    const uchar1& a,
    double s
    );

__device__ __forceinline__ double1
cv::cudev::hypot(
    double s,
    const uchar1& b
    );

__device__ __forceinline__ double2
cv::cudev::hypot(
    const uchar2& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::hypot(
    const uchar3& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::hypot(
    double s,
    const uchar3& b
    );

__device__ __forceinline__ double4
cv::cudev::hypot(
    const uchar4& a,
    double s
    );

__device__ __forceinline__ float4
cv::cudev::hypot(
    float s,
    const char4& b
    );

__device__ __forceinline__ float2
cv::cudev::hypot(
    float s,
    const char2& b
    );

__device__ __forceinline__ float1
cv::cudev::hypot(
    const char1& a,
    float s
    );

__device__ __forceinline__ float1
cv::cudev::hypot(
    float s,
    const char1& b
    );

__device__ __forceinline__ float2
cv::cudev::hypot(
    const char2& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::hypot(
    const char3& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::hypot(
    float s,
    const char3& b
    );

__device__ __forceinline__ float4
cv::cudev::hypot(
    const char4& a,
    float s
    );

__device__ __forceinline__ double2
cv::cudev::hypot(
    double s,
    const char2& b
    );

__device__ __forceinline__ double4
cv::cudev::hypot(
    double s,
    const char4& b
    );

__device__ __forceinline__ double1
cv::cudev::hypot(
    const char1& a,
    double s
    );

__device__ __forceinline__ double1
cv::cudev::hypot(
    double s,
    const char1& b
    );

__device__ __forceinline__ double2
cv::cudev::hypot(
    const char2& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::hypot(
    const char3& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::hypot(
    double s,
    const char3& b
    );

__device__ __forceinline__ double4
cv::cudev::hypot(
    const char4& a,
    double s
    );

__device__ __forceinline__ float2
cv::cudev::hypot(
    float s,
    const ushort2& b
    );

__device__ __forceinline__ float1
cv::cudev::hypot(
    const ushort1& a,
    float s
    );

__device__ __forceinline__ float1
cv::cudev::hypot(
    float s,
    const ushort1& b
    );

__device__ __forceinline__ float2
cv::cudev::hypot(
    const ushort2& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::hypot(
    const ushort3& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::hypot(
    float s,
    const ushort3& b
    );

__device__ __forceinline__ float4
cv::cudev::hypot(
    const ushort4& a,
    float s
    );

__device__ __forceinline__ float4
cv::cudev::hypot(
    float s,
    const ushort4& b
    );

__device__ __forceinline__ double2
cv::cudev::hypot(
    double s,
    const ushort2& b
    );

__device__ __forceinline__ double4
cv::cudev::hypot(
    double s,
    const ushort4& b
    );

__device__ __forceinline__ double1
cv::cudev::hypot(
    const ushort1& a,
    double s
    );

__device__ __forceinline__ double1
cv::cudev::hypot(
    double s,
    const ushort1& b
    );

__device__ __forceinline__ double2
cv::cudev::hypot(
    const ushort2& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::hypot(
    const ushort3& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::hypot(
    double s,
    const ushort3& b
    );

__device__ __forceinline__ double4
cv::cudev::hypot(
    const ushort4& a,
    double s
    );

__device__ __forceinline__ float2
cv::cudev::hypot(
    float s,
    const short2& b
    );

__device__ __forceinline__ float1
cv::cudev::hypot(
    const short1& a,
    float s
    );

__device__ __forceinline__ float1
cv::cudev::hypot(
    float s,
    const short1& b
    );

__device__ __forceinline__ float2
cv::cudev::hypot(
    const short2& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::hypot(
    const short3& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::hypot(
    float s,
    const short3& b
    );

__device__ __forceinline__ float4
cv::cudev::hypot(
    const short4& a,
    float s
    );

__device__ __forceinline__ float4
cv::cudev::hypot(
    float s,
    const short4& b
    );

__device__ __forceinline__ double2
cv::cudev::hypot(
    double s,
    const short2& b
    );

__device__ __forceinline__ double4
cv::cudev::hypot(
    double s,
    const short4& b
    );

__device__ __forceinline__ double1
cv::cudev::hypot(
    const short1& a,
    double s
    );

__device__ __forceinline__ double1
cv::cudev::hypot(
    double s,
    const short1& b
    );

__device__ __forceinline__ double2
cv::cudev::hypot(
    const short2& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::hypot(
    const short3& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::hypot(
    double s,
    const short3& b
    );

__device__ __forceinline__ double4
cv::cudev::hypot(
    const short4& a,
    double s
    );

__device__ __forceinline__ float2
cv::cudev::hypot(
    float s,
    const uint2& b
    );

__device__ __forceinline__ float1
cv::cudev::hypot(
    const uint1& a,
    float s
    );

__device__ __forceinline__ float1
cv::cudev::hypot(
    float s,
    const uint1& b
    );

__device__ __forceinline__ float2
cv::cudev::hypot(
    const uint2& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::hypot(
    const uint3& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::hypot(
    float s,
    const uint3& b
    );

__device__ __forceinline__ float4
cv::cudev::hypot(
    const uint4& a,
    float s
    );

__device__ __forceinline__ float4
cv::cudev::hypot(
    float s,
    const uint4& b
    );

__device__ __forceinline__ double4
cv::cudev::hypot(
    double s,
    const uint4& b
    );

__device__ __forceinline__ double2
cv::cudev::hypot(
    double s,
    const uint2& b
    );

__device__ __forceinline__ double1
cv::cudev::hypot(
    const uint1& a,
    double s
    );

__device__ __forceinline__ double1
cv::cudev::hypot(
    double s,
    const uint1& b
    );

__device__ __forceinline__ double2
cv::cudev::hypot(
    const uint2& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::hypot(
    const uint3& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::hypot(
    double s,
    const uint3& b
    );

__device__ __forceinline__ double4
cv::cudev::hypot(
    const uint4& a,
    double s
    );

__device__ __forceinline__ float2
cv::cudev::hypot(
    float s,
    const int2& b
    );

__device__ __forceinline__ float1
cv::cudev::hypot(
    const int1& a,
    float s
    );

__device__ __forceinline__ float1
cv::cudev::hypot(
    float s,
    const int1& b
    );

__device__ __forceinline__ float2
cv::cudev::hypot(
    const int2& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::hypot(
    const int3& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::hypot(
    float s,
    const int3& b
    );

__device__ __forceinline__ float4
cv::cudev::hypot(
    const int4& a,
    float s
    );

__device__ __forceinline__ float4
cv::cudev::hypot(
    float s,
    const int4& b
    );

__device__ __forceinline__ double4
cv::cudev::hypot(
    double s,
    const int4& b
    );

__device__ __forceinline__ double2
cv::cudev::hypot(
    double s,
    const int2& b
    );

__device__ __forceinline__ double1
cv::cudev::hypot(
    const int1& a,
    double s
    );

__device__ __forceinline__ double1
cv::cudev::hypot(
    double s,
    const int1& b
    );

__device__ __forceinline__ double2
cv::cudev::hypot(
    const int2& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::hypot(
    const int3& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::hypot(
    double s,
    const int3& b
    );

__device__ __forceinline__ double4
cv::cudev::hypot(
    const int4& a,
    double s
    );

__device__ __forceinline__ float3
cv::cudev::hypot(
    float s,
    const float3& b
    );

__device__ __forceinline__ float4
cv::cudev::hypot(
    const float4& a,
    float s
    );

__device__ __forceinline__ float4
cv::cudev::hypot(
    float s,
    const float4& b
    );

__device__ __forceinline__ float3
cv::cudev::hypot(
    const float3& a,
    float s
    );

__device__ __forceinline__ float2
cv::cudev::hypot(
    float s,
    const float2& b
    );

__device__ __forceinline__ float1
cv::cudev::hypot(
    const float1& a,
    float s
    );

__device__ __forceinline__ float1
cv::cudev::hypot(
    float s,
    const float1& b
    );

__device__ __forceinline__ float2
cv::cudev::hypot(
    const float2& a,
    float s
    );

__device__ __forceinline__ double1
cv::cudev::hypot(
    const float1& a,
    double s
    );

__device__ __forceinline__ double1
cv::cudev::hypot(
    double s,
    const float1& b
    );

__device__ __forceinline__ double2
cv::cudev::hypot(
    const float2& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::hypot(
    const float3& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::hypot(
    double s,
    const float3& b
    );

__device__ __forceinline__ double4
cv::cudev::hypot(
    const float4& a,
    double s
    );

__device__ __forceinline__ double2
cv::cudev::hypot(
    double s,
    const float2& b
    );

__device__ __forceinline__ double4
cv::cudev::hypot(
    double s,
    const float4& b
    );

__device__ __forceinline__ double1
cv::cudev::hypot(
    const double1& a,
    double s
    );

__device__ __forceinline__ double1
cv::cudev::hypot(
    double s,
    const double1& b
    );

__device__ __forceinline__ double2
cv::cudev::hypot(
    const double2& a,
    double s
    );

__device__ __forceinline__ double4
cv::cudev::hypot(
    const double4& a,
    double s
    );

__device__ __forceinline__ double4
cv::cudev::hypot(
    double s,
    const double4& b
    );

__device__ __forceinline__ double3
cv::cudev::hypot(
    double s,
    const double3& b
    );

__device__ __forceinline__ double3
cv::cudev::hypot(
    const double3& a,
    double s
    );

__device__ __forceinline__ double2
cv::cudev::hypot(
    double s,
    const double2& b
    );

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

template <class SrcPtr>
__host__ Expr<IntegralBody<SrcPtr>>
cv::cudev::integral_(const SrcPtr& src);

template <class SrcPtr>
__host__ IntegerAreaInterPtrSz<typename PtrTraits<SrcPtr>::ptr_type>
cv::cudev::interArea(
    const SrcPtr& src,
    Size areaSize
    );

template <class SrcPtr>
__host__ CommonAreaInterPtrSz<typename PtrTraits<SrcPtr>::ptr_type>
cv::cudev::interArea(
    const SrcPtr& src,
    Size2f areaSize
    );

template <class SrcPtr>
__host__ CubicInterPtrSz<typename PtrTraits<SrcPtr>::ptr_type>
cv::cudev::interCubic(const SrcPtr& src);

template <class SrcPtr>
__host__ LinearInterPtrSz<typename PtrTraits<SrcPtr>::ptr_type>
cv::cudev::interLinear(const SrcPtr& src);

template <class SrcPtr>
__host__ NearestInterPtrSz<typename PtrTraits<SrcPtr>::ptr_type>
cv::cudev::interNearest(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, Lab4_to_BGR_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::Lab4_to_BGR_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, Lab4_to_BGRA_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::Lab4_to_BGRA_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, Lab4_to_LBGR_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::Lab4_to_LBGR_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, Lab4_to_LBGRA_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::Lab4_to_LBGRA_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, Lab4_to_LRGB_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::Lab4_to_LRGB_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, Lab4_to_LRGBA_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::Lab4_to_LRGBA_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, Lab4_to_RGB_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::Lab4_to_RGB_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, Lab4_to_RGBA_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::Lab4_to_RGBA_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, Lab_to_BGR_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::Lab_to_BGR_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, Lab_to_BGRA_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::Lab_to_BGRA_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, Lab_to_LBGR_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::Lab_to_LBGR_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, Lab_to_LBGRA_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::Lab_to_LBGRA_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, Lab_to_LRGB_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::Lab_to_LRGB_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, Lab_to_LRGBA_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::Lab_to_LRGBA_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, Lab_to_RGB_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::Lab_to_RGB_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, Lab_to_RGBA_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::Lab_to_RGBA_(const SrcPtr& src);

template <
    int ksize,
    class SrcPtr
    >
__host__ Expr<LaplacianPtrSz<ksize, typename PtrTraits<SrcPtr>::ptr_type>>
cv::cudev::laplacian_(const SrcPtr& src);

template <
    int ksize,
    class SrcPtr
    >
__host__ LaplacianPtrSz<ksize, typename PtrTraits<SrcPtr>::ptr_type>
cv::cudev::laplacianPtr(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, LBGR_to_Lab4_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::LBGR_to_Lab4_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, LBGR_to_Lab_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::LBGR_to_Lab_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, LBGR_to_Luv4_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::LBGR_to_Luv4_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, LBGR_to_Luv_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::LBGR_to_Luv_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, LBGRA_to_Lab4_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::LBGRA_to_Lab4_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, LBGRA_to_Lab_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::LBGRA_to_Lab_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, LBGRA_to_Luv4_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::LBGRA_to_Luv4_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, LBGRA_to_Luv_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::LBGRA_to_Luv_(const SrcPtr& src);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, LRGB_to_Lab4_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::LRGB_to_Lab4_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, LRGB_to_Lab_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::LRGB_to_Lab_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, LRGB_to_Luv4_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::LRGB_to_Luv4_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, LRGB_to_Luv_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::LRGB_to_Luv_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, LRGBA_to_Lab4_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::LRGBA_to_Lab4_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, LRGBA_to_Lab_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::LRGBA_to_Lab_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, LRGBA_to_Luv4_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::LRGBA_to_Luv4_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, LRGBA_to_Luv_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::LRGBA_to_Luv_(const SrcPtr& src);

template <
    class SrcPtr,
    class TablePtr
    >
__host__ Expr<LutPtrSz<typename PtrTraits<SrcPtr>::ptr_type, typename PtrTraits<TablePtr>::ptr_type>>
cv::cudev::lut_(
    const SrcPtr& src,
    const TablePtr& tbl
    );

template <
    class SrcPtr,
    class TablePtr
    >
__host__ LutPtrSz<typename PtrTraits<SrcPtr>::ptr_type, typename PtrTraits<TablePtr>::ptr_type>
cv::cudev::lutPtr(
    const SrcPtr& src,
    const TablePtr& tbl
    );

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, Luv4_to_BGR_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::Luv4_to_BGR_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, Luv4_to_BGRA_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::Luv4_to_BGRA_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, Luv4_to_LBGR_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::Luv4_to_LBGR_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, Luv4_to_LBGRA_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::Luv4_to_LBGRA_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, Luv4_to_LRGB_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::Luv4_to_LRGB_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, Luv4_to_LRGBA_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::Luv4_to_LRGBA_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, Luv4_to_RGB_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::Luv4_to_RGB_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, Luv4_to_RGBA_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::Luv4_to_RGBA_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, Luv_to_BGR_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::Luv_to_BGR_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, Luv_to_BGRA_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::Luv_to_BGRA_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, Luv_to_LBGR_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::Luv_to_LBGR_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, Luv_to_LBGRA_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::Luv_to_LBGRA_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, Luv_to_LRGB_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::Luv_to_LRGB_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, Luv_to_LRGBA_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::Luv_to_LRGBA_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, Luv_to_RGB_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::Luv_to_RGB_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, Luv_to_RGBA_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::Luv_to_RGBA_(const SrcPtr& src);

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

template <class Body>
__host__ Expr<Body>
cv::cudev::makeExpr(const Body& body);

__device__ __forceinline__ uchar1
cv::cudev::max(
    const uchar1& a,
    const uchar1& b
    );

__device__ __forceinline__ uchar2
cv::cudev::max(
    const uchar2& a,
    const uchar2& b
    );

__device__ __forceinline__ uchar3
cv::cudev::max(
    const uchar3& a,
    const uchar3& b
    );

__device__ __forceinline__ uchar4
cv::cudev::max(
    const uchar4& a,
    const uchar4& b
    );

__device__ __forceinline__ char1
cv::cudev::max(
    const char1& a,
    const char1& b
    );

__device__ __forceinline__ char2
cv::cudev::max(
    const char2& a,
    const char2& b
    );

__device__ __forceinline__ char3
cv::cudev::max(
    const char3& a,
    const char3& b
    );

__device__ __forceinline__ char4
cv::cudev::max(
    const char4& a,
    const char4& b
    );

__device__ __forceinline__ ushort4
cv::cudev::max(
    const ushort4& a,
    const ushort4& b
    );

__device__ __forceinline__ ushort1
cv::cudev::max(
    const ushort1& a,
    const ushort1& b
    );

__device__ __forceinline__ ushort2
cv::cudev::max(
    const ushort2& a,
    const ushort2& b
    );

__device__ __forceinline__ ushort3
cv::cudev::max(
    const ushort3& a,
    const ushort3& b
    );

__device__ __forceinline__ short4
cv::cudev::max(
    const short4& a,
    const short4& b
    );

__device__ __forceinline__ short1
cv::cudev::max(
    const short1& a,
    const short1& b
    );

__device__ __forceinline__ short2
cv::cudev::max(
    const short2& a,
    const short2& b
    );

__device__ __forceinline__ short3
cv::cudev::max(
    const short3& a,
    const short3& b
    );

__device__ __forceinline__ uint4
cv::cudev::max(
    const uint4& a,
    const uint4& b
    );

__device__ __forceinline__ uint1
cv::cudev::max(
    const uint1& a,
    const uint1& b
    );

__device__ __forceinline__ uint2
cv::cudev::max(
    const uint2& a,
    const uint2& b
    );

__device__ __forceinline__ uint3
cv::cudev::max(
    const uint3& a,
    const uint3& b
    );

__device__ __forceinline__ int4
cv::cudev::max(
    const int4& a,
    const int4& b
    );

__device__ __forceinline__ int1
cv::cudev::max(
    const int1& a,
    const int1& b
    );

__device__ __forceinline__ int2
cv::cudev::max(
    const int2& a,
    const int2& b
    );

__device__ __forceinline__ int3
cv::cudev::max(
    const int3& a,
    const int3& b
    );

__device__ __forceinline__ float4
cv::cudev::max(
    const float4& a,
    const float4& b
    );

__device__ __forceinline__ float1
cv::cudev::max(
    const float1& a,
    const float1& b
    );

__device__ __forceinline__ float2
cv::cudev::max(
    const float2& a,
    const float2& b
    );

__device__ __forceinline__ float3
cv::cudev::max(
    const float3& a,
    const float3& b
    );

__device__ __forceinline__ double4
cv::cudev::max(
    const double4& a,
    const double4& b
    );

__device__ __forceinline__ double1
cv::cudev::max(
    const double1& a,
    const double1& b
    );

__device__ __forceinline__ double2
cv::cudev::max(
    const double2& a,
    const double2& b
    );

__device__ __forceinline__ double3
cv::cudev::max(
    const double3& a,
    const double3& b
    );

__device__ __forceinline__ uchar1
cv::cudev::max(
    const uchar1& a,
    uchar s
    );

__device__ __forceinline__ uchar1
cv::cudev::max(
    uchar s,
    const uchar1& b
    );

__device__ __forceinline__ uchar2
cv::cudev::max(
    const uchar2& a,
    uchar s
    );

__device__ __forceinline__ uchar2
cv::cudev::max(
    uchar s,
    const uchar2& b
    );

__device__ __forceinline__ uchar3
cv::cudev::max(
    const uchar3& a,
    uchar s
    );

__device__ __forceinline__ uchar3
cv::cudev::max(
    uchar s,
    const uchar3& b
    );

__device__ __forceinline__ uchar4
cv::cudev::max(
    const uchar4& a,
    uchar s
    );

__device__ __forceinline__ uchar4
cv::cudev::max(
    uchar s,
    const uchar4& b
    );

__device__ __forceinline__ float2
cv::cudev::max(
    float s,
    const uchar2& b
    );

__device__ __forceinline__ float4
cv::cudev::max(
    float s,
    const uchar4& b
    );

__device__ __forceinline__ float1
cv::cudev::max(
    const uchar1& a,
    float s
    );

__device__ __forceinline__ float1
cv::cudev::max(
    float s,
    const uchar1& b
    );

__device__ __forceinline__ float2
cv::cudev::max(
    const uchar2& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::max(
    const uchar3& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::max(
    float s,
    const uchar3& b
    );

__device__ __forceinline__ float4
cv::cudev::max(
    const uchar4& a,
    float s
    );

__device__ __forceinline__ double2
cv::cudev::max(
    double s,
    const uchar2& b
    );

__device__ __forceinline__ double1
cv::cudev::max(
    const uchar1& a,
    double s
    );

__device__ __forceinline__ double1
cv::cudev::max(
    double s,
    const uchar1& b
    );

__device__ __forceinline__ double2
cv::cudev::max(
    const uchar2& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::max(
    const uchar3& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::max(
    double s,
    const uchar3& b
    );

__device__ __forceinline__ double4
cv::cudev::max(
    const uchar4& a,
    double s
    );

__device__ __forceinline__ double4
cv::cudev::max(
    double s,
    const uchar4& b
    );

__device__ __forceinline__ char4
cv::cudev::max(
    char s,
    const char4& b
    );

__device__ __forceinline__ char2
cv::cudev::max(
    char s,
    const char2& b
    );

__device__ __forceinline__ char1
cv::cudev::max(
    const char1& a,
    char s
    );

__device__ __forceinline__ char1
cv::cudev::max(
    char s,
    const char1& b
    );

__device__ __forceinline__ char2
cv::cudev::max(
    const char2& a,
    char s
    );

__device__ __forceinline__ char3
cv::cudev::max(
    const char3& a,
    char s
    );

__device__ __forceinline__ char3
cv::cudev::max(
    char s,
    const char3& b
    );

__device__ __forceinline__ char4
cv::cudev::max(
    const char4& a,
    char s
    );

__device__ __forceinline__ float2
cv::cudev::max(
    float s,
    const char2& b
    );

__device__ __forceinline__ float1
cv::cudev::max(
    const char1& a,
    float s
    );

__device__ __forceinline__ float1
cv::cudev::max(
    float s,
    const char1& b
    );

__device__ __forceinline__ float2
cv::cudev::max(
    const char2& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::max(
    const char3& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::max(
    float s,
    const char3& b
    );

__device__ __forceinline__ float4
cv::cudev::max(
    const char4& a,
    float s
    );

__device__ __forceinline__ float4
cv::cudev::max(
    float s,
    const char4& b
    );

__device__ __forceinline__ double2
cv::cudev::max(
    double s,
    const char2& b
    );

__device__ __forceinline__ double4
cv::cudev::max(
    double s,
    const char4& b
    );

__device__ __forceinline__ double1
cv::cudev::max(
    const char1& a,
    double s
    );

__device__ __forceinline__ double1
cv::cudev::max(
    double s,
    const char1& b
    );

__device__ __forceinline__ double2
cv::cudev::max(
    const char2& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::max(
    const char3& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::max(
    double s,
    const char3& b
    );

__device__ __forceinline__ double4
cv::cudev::max(
    const char4& a,
    double s
    );

__device__ __forceinline__ ushort2
cv::cudev::max(
    ushort s,
    const ushort2& b
    );

__device__ __forceinline__ ushort1
cv::cudev::max(
    const ushort1& a,
    ushort s
    );

__device__ __forceinline__ ushort1
cv::cudev::max(
    ushort s,
    const ushort1& b
    );

__device__ __forceinline__ ushort2
cv::cudev::max(
    const ushort2& a,
    ushort s
    );

__device__ __forceinline__ ushort3
cv::cudev::max(
    const ushort3& a,
    ushort s
    );

__device__ __forceinline__ ushort3
cv::cudev::max(
    ushort s,
    const ushort3& b
    );

__device__ __forceinline__ ushort4
cv::cudev::max(
    const ushort4& a,
    ushort s
    );

__device__ __forceinline__ ushort4
cv::cudev::max(
    ushort s,
    const ushort4& b
    );

__device__ __forceinline__ float2
cv::cudev::max(
    float s,
    const ushort2& b
    );

__device__ __forceinline__ float4
cv::cudev::max(
    float s,
    const ushort4& b
    );

__device__ __forceinline__ float1
cv::cudev::max(
    const ushort1& a,
    float s
    );

__device__ __forceinline__ float1
cv::cudev::max(
    float s,
    const ushort1& b
    );

__device__ __forceinline__ float2
cv::cudev::max(
    const ushort2& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::max(
    const ushort3& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::max(
    float s,
    const ushort3& b
    );

__device__ __forceinline__ float4
cv::cudev::max(
    const ushort4& a,
    float s
    );

__device__ __forceinline__ double2
cv::cudev::max(
    double s,
    const ushort2& b
    );

__device__ __forceinline__ double1
cv::cudev::max(
    const ushort1& a,
    double s
    );

__device__ __forceinline__ double1
cv::cudev::max(
    double s,
    const ushort1& b
    );

__device__ __forceinline__ double2
cv::cudev::max(
    const ushort2& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::max(
    const ushort3& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::max(
    double s,
    const ushort3& b
    );

__device__ __forceinline__ double4
cv::cudev::max(
    const ushort4& a,
    double s
    );

__device__ __forceinline__ double4
cv::cudev::max(
    double s,
    const ushort4& b
    );

__device__ __forceinline__ short2
cv::cudev::max(
    short s,
    const short2& b
    );

__device__ __forceinline__ short4
cv::cudev::max(
    short s,
    const short4& b
    );

__device__ __forceinline__ short1
cv::cudev::max(
    const short1& a,
    short s
    );

__device__ __forceinline__ short1
cv::cudev::max(
    short s,
    const short1& b
    );

__device__ __forceinline__ short2
cv::cudev::max(
    const short2& a,
    short s
    );

__device__ __forceinline__ short3
cv::cudev::max(
    const short3& a,
    short s
    );

__device__ __forceinline__ short3
cv::cudev::max(
    short s,
    const short3& b
    );

__device__ __forceinline__ short4
cv::cudev::max(
    const short4& a,
    short s
    );

__device__ __forceinline__ float2
cv::cudev::max(
    float s,
    const short2& b
    );

__device__ __forceinline__ float1
cv::cudev::max(
    const short1& a,
    float s
    );

__device__ __forceinline__ float1
cv::cudev::max(
    float s,
    const short1& b
    );

__device__ __forceinline__ float2
cv::cudev::max(
    const short2& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::max(
    const short3& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::max(
    float s,
    const short3& b
    );

__device__ __forceinline__ float4
cv::cudev::max(
    const short4& a,
    float s
    );

__device__ __forceinline__ float4
cv::cudev::max(
    float s,
    const short4& b
    );

__device__ __forceinline__ double2
cv::cudev::max(
    double s,
    const short2& b
    );

__device__ __forceinline__ double4
cv::cudev::max(
    double s,
    const short4& b
    );

__device__ __forceinline__ double1
cv::cudev::max(
    const short1& a,
    double s
    );

__device__ __forceinline__ double1
cv::cudev::max(
    double s,
    const short1& b
    );

__device__ __forceinline__ double2
cv::cudev::max(
    const short2& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::max(
    const short3& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::max(
    double s,
    const short3& b
    );

__device__ __forceinline__ double4
cv::cudev::max(
    const short4& a,
    double s
    );

__device__ __forceinline__ uint2
cv::cudev::max(
    uint s,
    const uint2& b
    );

__device__ __forceinline__ uint1
cv::cudev::max(
    const uint1& a,
    uint s
    );

__device__ __forceinline__ uint1
cv::cudev::max(
    uint s,
    const uint1& b
    );

__device__ __forceinline__ uint2
cv::cudev::max(
    const uint2& a,
    uint s
    );

__device__ __forceinline__ uint3
cv::cudev::max(
    const uint3& a,
    uint s
    );

__device__ __forceinline__ uint3
cv::cudev::max(
    uint s,
    const uint3& b
    );

__device__ __forceinline__ uint4
cv::cudev::max(
    const uint4& a,
    uint s
    );

__device__ __forceinline__ uint4
cv::cudev::max(
    uint s,
    const uint4& b
    );

__device__ __forceinline__ float2
cv::cudev::max(
    float s,
    const uint2& b
    );

__device__ __forceinline__ float4
cv::cudev::max(
    float s,
    const uint4& b
    );

__device__ __forceinline__ float1
cv::cudev::max(
    const uint1& a,
    float s
    );

__device__ __forceinline__ float1
cv::cudev::max(
    float s,
    const uint1& b
    );

__device__ __forceinline__ float2
cv::cudev::max(
    const uint2& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::max(
    const uint3& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::max(
    float s,
    const uint3& b
    );

__device__ __forceinline__ float4
cv::cudev::max(
    const uint4& a,
    float s
    );

__device__ __forceinline__ double2
cv::cudev::max(
    double s,
    const uint2& b
    );

__device__ __forceinline__ double1
cv::cudev::max(
    const uint1& a,
    double s
    );

__device__ __forceinline__ double1
cv::cudev::max(
    double s,
    const uint1& b
    );

__device__ __forceinline__ double2
cv::cudev::max(
    const uint2& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::max(
    const uint3& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::max(
    double s,
    const uint3& b
    );

__device__ __forceinline__ double4
cv::cudev::max(
    const uint4& a,
    double s
    );

__device__ __forceinline__ double4
cv::cudev::max(
    double s,
    const uint4& b
    );

__device__ __forceinline__ int2
cv::cudev::max(
    int s,
    const int2& b
    );

__device__ __forceinline__ int4
cv::cudev::max(
    int s,
    const int4& b
    );

__device__ __forceinline__ int1
cv::cudev::max(
    const int1& a,
    int s
    );

__device__ __forceinline__ int1
cv::cudev::max(
    int s,
    const int1& b
    );

__device__ __forceinline__ int2
cv::cudev::max(
    const int2& a,
    int s
    );

__device__ __forceinline__ int3
cv::cudev::max(
    const int3& a,
    int s
    );

__device__ __forceinline__ int3
cv::cudev::max(
    int s,
    const int3& b
    );

__device__ __forceinline__ int4
cv::cudev::max(
    const int4& a,
    int s
    );

__device__ __forceinline__ float2
cv::cudev::max(
    float s,
    const int2& b
    );

__device__ __forceinline__ float1
cv::cudev::max(
    const int1& a,
    float s
    );

__device__ __forceinline__ float1
cv::cudev::max(
    float s,
    const int1& b
    );

__device__ __forceinline__ float2
cv::cudev::max(
    const int2& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::max(
    const int3& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::max(
    float s,
    const int3& b
    );

__device__ __forceinline__ float4
cv::cudev::max(
    const int4& a,
    float s
    );

__device__ __forceinline__ float4
cv::cudev::max(
    float s,
    const int4& b
    );

__device__ __forceinline__ double4
cv::cudev::max(
    double s,
    const int4& b
    );

__device__ __forceinline__ double2
cv::cudev::max(
    double s,
    const int2& b
    );

__device__ __forceinline__ double1
cv::cudev::max(
    const int1& a,
    double s
    );

__device__ __forceinline__ double1
cv::cudev::max(
    double s,
    const int1& b
    );

__device__ __forceinline__ double2
cv::cudev::max(
    const int2& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::max(
    const int3& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::max(
    double s,
    const int3& b
    );

__device__ __forceinline__ double4
cv::cudev::max(
    const int4& a,
    double s
    );

__device__ __forceinline__ float2
cv::cudev::max(
    float s,
    const float2& b
    );

__device__ __forceinline__ float1
cv::cudev::max(
    const float1& a,
    float s
    );

__device__ __forceinline__ float1
cv::cudev::max(
    float s,
    const float1& b
    );

__device__ __forceinline__ float2
cv::cudev::max(
    const float2& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::max(
    const float3& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::max(
    float s,
    const float3& b
    );

__device__ __forceinline__ float4
cv::cudev::max(
    const float4& a,
    float s
    );

__device__ __forceinline__ float4
cv::cudev::max(
    float s,
    const float4& b
    );

__device__ __forceinline__ double2
cv::cudev::max(
    double s,
    const float2& b
    );

__device__ __forceinline__ double4
cv::cudev::max(
    double s,
    const float4& b
    );

__device__ __forceinline__ double1
cv::cudev::max(
    const float1& a,
    double s
    );

__device__ __forceinline__ double1
cv::cudev::max(
    double s,
    const float1& b
    );

__device__ __forceinline__ double2
cv::cudev::max(
    const float2& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::max(
    const float3& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::max(
    double s,
    const float3& b
    );

__device__ __forceinline__ double4
cv::cudev::max(
    const float4& a,
    double s
    );

__device__ __forceinline__ double1
cv::cudev::max(
    const double1& a,
    double s
    );

__device__ __forceinline__ double1
cv::cudev::max(
    double s,
    const double1& b
    );

__device__ __forceinline__ double2
cv::cudev::max(
    const double2& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::max(
    const double3& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::max(
    double s,
    const double3& b
    );

__device__ __forceinline__ double4
cv::cudev::max(
    const double4& a,
    double s
    );

__device__ __forceinline__ double4
cv::cudev::max(
    double s,
    const double4& b
    );

__device__ __forceinline__ double2
cv::cudev::max(
    double s,
    const double2& b
    );

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

template <class SrcPtr>
__host__ Expr<FindMaxValExprBody<SrcPtr>>
cv::cudev::maxVal_(const SrcPtr& src);

__device__ __forceinline__ uchar4
cv::cudev::min(
    const uchar4& a,
    const uchar4& b
    );

__device__ __forceinline__ uchar1
cv::cudev::min(
    const uchar1& a,
    const uchar1& b
    );

__device__ __forceinline__ uchar2
cv::cudev::min(
    const uchar2& a,
    const uchar2& b
    );

__device__ __forceinline__ uchar3
cv::cudev::min(
    const uchar3& a,
    const uchar3& b
    );

__device__ __forceinline__ char4
cv::cudev::min(
    const char4& a,
    const char4& b
    );

__device__ __forceinline__ char1
cv::cudev::min(
    const char1& a,
    const char1& b
    );

__device__ __forceinline__ char2
cv::cudev::min(
    const char2& a,
    const char2& b
    );

__device__ __forceinline__ char3
cv::cudev::min(
    const char3& a,
    const char3& b
    );

__device__ __forceinline__ ushort4
cv::cudev::min(
    const ushort4& a,
    const ushort4& b
    );

__device__ __forceinline__ ushort1
cv::cudev::min(
    const ushort1& a,
    const ushort1& b
    );

__device__ __forceinline__ ushort2
cv::cudev::min(
    const ushort2& a,
    const ushort2& b
    );

__device__ __forceinline__ ushort3
cv::cudev::min(
    const ushort3& a,
    const ushort3& b
    );

__device__ __forceinline__ short4
cv::cudev::min(
    const short4& a,
    const short4& b
    );

__device__ __forceinline__ short1
cv::cudev::min(
    const short1& a,
    const short1& b
    );

__device__ __forceinline__ short2
cv::cudev::min(
    const short2& a,
    const short2& b
    );

__device__ __forceinline__ short3
cv::cudev::min(
    const short3& a,
    const short3& b
    );

__device__ __forceinline__ uint4
cv::cudev::min(
    const uint4& a,
    const uint4& b
    );

__device__ __forceinline__ uint1
cv::cudev::min(
    const uint1& a,
    const uint1& b
    );

__device__ __forceinline__ uint2
cv::cudev::min(
    const uint2& a,
    const uint2& b
    );

__device__ __forceinline__ uint3
cv::cudev::min(
    const uint3& a,
    const uint3& b
    );

__device__ __forceinline__ int1
cv::cudev::min(
    const int1& a,
    const int1& b
    );

__device__ __forceinline__ int2
cv::cudev::min(
    const int2& a,
    const int2& b
    );

__device__ __forceinline__ int3
cv::cudev::min(
    const int3& a,
    const int3& b
    );

__device__ __forceinline__ int4
cv::cudev::min(
    const int4& a,
    const int4& b
    );

__device__ __forceinline__ float4
cv::cudev::min(
    const float4& a,
    const float4& b
    );

__device__ __forceinline__ float1
cv::cudev::min(
    const float1& a,
    const float1& b
    );

__device__ __forceinline__ float2
cv::cudev::min(
    const float2& a,
    const float2& b
    );

__device__ __forceinline__ float3
cv::cudev::min(
    const float3& a,
    const float3& b
    );

__device__ __forceinline__ double2
cv::cudev::min(
    const double2& a,
    const double2& b
    );

__device__ __forceinline__ double3
cv::cudev::min(
    const double3& a,
    const double3& b
    );

__device__ __forceinline__ double4
cv::cudev::min(
    const double4& a,
    const double4& b
    );

__device__ __forceinline__ double1
cv::cudev::min(
    const double1& a,
    const double1& b
    );

__device__ __forceinline__ uchar4
cv::cudev::min(
    uchar s,
    const uchar4& b
    );

__device__ __forceinline__ uchar2
cv::cudev::min(
    uchar s,
    const uchar2& b
    );

__device__ __forceinline__ uchar1
cv::cudev::min(
    const uchar1& a,
    uchar s
    );

__device__ __forceinline__ uchar1
cv::cudev::min(
    uchar s,
    const uchar1& b
    );

__device__ __forceinline__ uchar2
cv::cudev::min(
    const uchar2& a,
    uchar s
    );

__device__ __forceinline__ uchar3
cv::cudev::min(
    const uchar3& a,
    uchar s
    );

__device__ __forceinline__ uchar3
cv::cudev::min(
    uchar s,
    const uchar3& b
    );

__device__ __forceinline__ uchar4
cv::cudev::min(
    const uchar4& a,
    uchar s
    );

__device__ __forceinline__ float2
cv::cudev::min(
    float s,
    const uchar2& b
    );

__device__ __forceinline__ float1
cv::cudev::min(
    const uchar1& a,
    float s
    );

__device__ __forceinline__ float1
cv::cudev::min(
    float s,
    const uchar1& b
    );

__device__ __forceinline__ float2
cv::cudev::min(
    const uchar2& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::min(
    const uchar3& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::min(
    float s,
    const uchar3& b
    );

__device__ __forceinline__ float4
cv::cudev::min(
    const uchar4& a,
    float s
    );

__device__ __forceinline__ float4
cv::cudev::min(
    float s,
    const uchar4& b
    );

__device__ __forceinline__ double2
cv::cudev::min(
    double s,
    const uchar2& b
    );

__device__ __forceinline__ double4
cv::cudev::min(
    double s,
    const uchar4& b
    );

__device__ __forceinline__ double1
cv::cudev::min(
    const uchar1& a,
    double s
    );

__device__ __forceinline__ double1
cv::cudev::min(
    double s,
    const uchar1& b
    );

__device__ __forceinline__ double2
cv::cudev::min(
    const uchar2& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::min(
    const uchar3& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::min(
    double s,
    const uchar3& b
    );

__device__ __forceinline__ double4
cv::cudev::min(
    const uchar4& a,
    double s
    );

__device__ __forceinline__ char2
cv::cudev::min(
    char s,
    const char2& b
    );

__device__ __forceinline__ char1
cv::cudev::min(
    const char1& a,
    char s
    );

__device__ __forceinline__ char1
cv::cudev::min(
    char s,
    const char1& b
    );

__device__ __forceinline__ char2
cv::cudev::min(
    const char2& a,
    char s
    );

__device__ __forceinline__ char3
cv::cudev::min(
    const char3& a,
    char s
    );

__device__ __forceinline__ char3
cv::cudev::min(
    char s,
    const char3& b
    );

__device__ __forceinline__ char4
cv::cudev::min(
    const char4& a,
    char s
    );

__device__ __forceinline__ char4
cv::cudev::min(
    char s,
    const char4& b
    );

__device__ __forceinline__ float4
cv::cudev::min(
    float s,
    const char4& b
    );

__device__ __forceinline__ float2
cv::cudev::min(
    float s,
    const char2& b
    );

__device__ __forceinline__ float1
cv::cudev::min(
    const char1& a,
    float s
    );

__device__ __forceinline__ float1
cv::cudev::min(
    float s,
    const char1& b
    );

__device__ __forceinline__ float2
cv::cudev::min(
    const char2& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::min(
    const char3& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::min(
    float s,
    const char3& b
    );

__device__ __forceinline__ float4
cv::cudev::min(
    const char4& a,
    float s
    );

__device__ __forceinline__ double2
cv::cudev::min(
    double s,
    const char2& b
    );

__device__ __forceinline__ double1
cv::cudev::min(
    const char1& a,
    double s
    );

__device__ __forceinline__ double1
cv::cudev::min(
    double s,
    const char1& b
    );

__device__ __forceinline__ double2
cv::cudev::min(
    const char2& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::min(
    const char3& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::min(
    double s,
    const char3& b
    );

__device__ __forceinline__ double4
cv::cudev::min(
    const char4& a,
    double s
    );

__device__ __forceinline__ double4
cv::cudev::min(
    double s,
    const char4& b
    );

__device__ __forceinline__ ushort4
cv::cudev::min(
    ushort s,
    const ushort4& b
    );

__device__ __forceinline__ ushort2
cv::cudev::min(
    ushort s,
    const ushort2& b
    );

__device__ __forceinline__ ushort1
cv::cudev::min(
    const ushort1& a,
    ushort s
    );

__device__ __forceinline__ ushort1
cv::cudev::min(
    ushort s,
    const ushort1& b
    );

__device__ __forceinline__ ushort2
cv::cudev::min(
    const ushort2& a,
    ushort s
    );

__device__ __forceinline__ ushort3
cv::cudev::min(
    const ushort3& a,
    ushort s
    );

__device__ __forceinline__ ushort3
cv::cudev::min(
    ushort s,
    const ushort3& b
    );

__device__ __forceinline__ ushort4
cv::cudev::min(
    const ushort4& a,
    ushort s
    );

__device__ __forceinline__ float4
cv::cudev::min(
    float s,
    const ushort4& b
    );

__device__ __forceinline__ float2
cv::cudev::min(
    float s,
    const ushort2& b
    );

__device__ __forceinline__ float1
cv::cudev::min(
    const ushort1& a,
    float s
    );

__device__ __forceinline__ float1
cv::cudev::min(
    float s,
    const ushort1& b
    );

__device__ __forceinline__ float2
cv::cudev::min(
    const ushort2& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::min(
    const ushort3& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::min(
    float s,
    const ushort3& b
    );

__device__ __forceinline__ float4
cv::cudev::min(
    const ushort4& a,
    float s
    );

__device__ __forceinline__ double4
cv::cudev::min(
    double s,
    const ushort4& b
    );

__device__ __forceinline__ double2
cv::cudev::min(
    double s,
    const ushort2& b
    );

__device__ __forceinline__ double1
cv::cudev::min(
    const ushort1& a,
    double s
    );

__device__ __forceinline__ double1
cv::cudev::min(
    double s,
    const ushort1& b
    );

__device__ __forceinline__ double2
cv::cudev::min(
    const ushort2& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::min(
    const ushort3& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::min(
    double s,
    const ushort3& b
    );

__device__ __forceinline__ double4
cv::cudev::min(
    const ushort4& a,
    double s
    );

__device__ __forceinline__ short2
cv::cudev::min(
    short s,
    const short2& b
    );

__device__ __forceinline__ short1
cv::cudev::min(
    const short1& a,
    short s
    );

__device__ __forceinline__ short1
cv::cudev::min(
    short s,
    const short1& b
    );

__device__ __forceinline__ short2
cv::cudev::min(
    const short2& a,
    short s
    );

__device__ __forceinline__ short3
cv::cudev::min(
    const short3& a,
    short s
    );

__device__ __forceinline__ short3
cv::cudev::min(
    short s,
    const short3& b
    );

__device__ __forceinline__ short4
cv::cudev::min(
    const short4& a,
    short s
    );

__device__ __forceinline__ short4
cv::cudev::min(
    short s,
    const short4& b
    );

__device__ __forceinline__ float4
cv::cudev::min(
    float s,
    const short4& b
    );

__device__ __forceinline__ float2
cv::cudev::min(
    float s,
    const short2& b
    );

__device__ __forceinline__ float1
cv::cudev::min(
    const short1& a,
    float s
    );

__device__ __forceinline__ float1
cv::cudev::min(
    float s,
    const short1& b
    );

__device__ __forceinline__ float2
cv::cudev::min(
    const short2& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::min(
    const short3& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::min(
    float s,
    const short3& b
    );

__device__ __forceinline__ float4
cv::cudev::min(
    const short4& a,
    float s
    );

__device__ __forceinline__ double2
cv::cudev::min(
    double s,
    const short2& b
    );

__device__ __forceinline__ double1
cv::cudev::min(
    const short1& a,
    double s
    );

__device__ __forceinline__ double1
cv::cudev::min(
    double s,
    const short1& b
    );

__device__ __forceinline__ double2
cv::cudev::min(
    const short2& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::min(
    const short3& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::min(
    double s,
    const short3& b
    );

__device__ __forceinline__ double4
cv::cudev::min(
    const short4& a,
    double s
    );

__device__ __forceinline__ double4
cv::cudev::min(
    double s,
    const short4& b
    );

__device__ __forceinline__ uint2
cv::cudev::min(
    uint s,
    const uint2& b
    );

__device__ __forceinline__ uint4
cv::cudev::min(
    uint s,
    const uint4& b
    );

__device__ __forceinline__ uint1
cv::cudev::min(
    const uint1& a,
    uint s
    );

__device__ __forceinline__ uint1
cv::cudev::min(
    uint s,
    const uint1& b
    );

__device__ __forceinline__ uint2
cv::cudev::min(
    const uint2& a,
    uint s
    );

__device__ __forceinline__ uint3
cv::cudev::min(
    const uint3& a,
    uint s
    );

__device__ __forceinline__ uint3
cv::cudev::min(
    uint s,
    const uint3& b
    );

__device__ __forceinline__ uint4
cv::cudev::min(
    const uint4& a,
    uint s
    );

__device__ __forceinline__ float2
cv::cudev::min(
    float s,
    const uint2& b
    );

__device__ __forceinline__ float1
cv::cudev::min(
    const uint1& a,
    float s
    );

__device__ __forceinline__ float1
cv::cudev::min(
    float s,
    const uint1& b
    );

__device__ __forceinline__ float2
cv::cudev::min(
    const uint2& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::min(
    const uint3& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::min(
    float s,
    const uint3& b
    );

__device__ __forceinline__ float4
cv::cudev::min(
    const uint4& a,
    float s
    );

__device__ __forceinline__ float4
cv::cudev::min(
    float s,
    const uint4& b
    );

__device__ __forceinline__ double4
cv::cudev::min(
    double s,
    const uint4& b
    );

__device__ __forceinline__ double2
cv::cudev::min(
    double s,
    const uint2& b
    );

__device__ __forceinline__ double1
cv::cudev::min(
    const uint1& a,
    double s
    );

__device__ __forceinline__ double1
cv::cudev::min(
    double s,
    const uint1& b
    );

__device__ __forceinline__ double2
cv::cudev::min(
    const uint2& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::min(
    const uint3& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::min(
    double s,
    const uint3& b
    );

__device__ __forceinline__ double4
cv::cudev::min(
    const uint4& a,
    double s
    );

__device__ __forceinline__ int2
cv::cudev::min(
    int s,
    const int2& b
    );

__device__ __forceinline__ int1
cv::cudev::min(
    const int1& a,
    int s
    );

__device__ __forceinline__ int1
cv::cudev::min(
    int s,
    const int1& b
    );

__device__ __forceinline__ int2
cv::cudev::min(
    const int2& a,
    int s
    );

__device__ __forceinline__ int3
cv::cudev::min(
    const int3& a,
    int s
    );

__device__ __forceinline__ int3
cv::cudev::min(
    int s,
    const int3& b
    );

__device__ __forceinline__ int4
cv::cudev::min(
    const int4& a,
    int s
    );

__device__ __forceinline__ int4
cv::cudev::min(
    int s,
    const int4& b
    );

__device__ __forceinline__ float4
cv::cudev::min(
    float s,
    const int4& b
    );

__device__ __forceinline__ float2
cv::cudev::min(
    float s,
    const int2& b
    );

__device__ __forceinline__ float1
cv::cudev::min(
    const int1& a,
    float s
    );

__device__ __forceinline__ float1
cv::cudev::min(
    float s,
    const int1& b
    );

__device__ __forceinline__ float2
cv::cudev::min(
    const int2& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::min(
    const int3& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::min(
    float s,
    const int3& b
    );

__device__ __forceinline__ float4
cv::cudev::min(
    const int4& a,
    float s
    );

__device__ __forceinline__ double2
cv::cudev::min(
    double s,
    const int2& b
    );

__device__ __forceinline__ double1
cv::cudev::min(
    const int1& a,
    double s
    );

__device__ __forceinline__ double1
cv::cudev::min(
    double s,
    const int1& b
    );

__device__ __forceinline__ double2
cv::cudev::min(
    const int2& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::min(
    double s,
    const int3& b
    );

__device__ __forceinline__ double4
cv::cudev::min(
    const int4& a,
    double s
    );

__device__ __forceinline__ double4
cv::cudev::min(
    double s,
    const int4& b
    );

__device__ __forceinline__ double3
cv::cudev::min(
    const int3& a,
    double s
    );

__device__ __forceinline__ float4
cv::cudev::min(
    float s,
    const float4& b
    );

__device__ __forceinline__ float2
cv::cudev::min(
    float s,
    const float2& b
    );

__device__ __forceinline__ float1
cv::cudev::min(
    const float1& a,
    float s
    );

__device__ __forceinline__ float1
cv::cudev::min(
    float s,
    const float1& b
    );

__device__ __forceinline__ float2
cv::cudev::min(
    const float2& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::min(
    const float3& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::min(
    float s,
    const float3& b
    );

__device__ __forceinline__ float4
cv::cudev::min(
    const float4& a,
    float s
    );

__device__ __forceinline__ double3
cv::cudev::min(
    const float3& a,
    double s
    );

__device__ __forceinline__ double2
cv::cudev::min(
    double s,
    const float2& b
    );

__device__ __forceinline__ double1
cv::cudev::min(
    const float1& a,
    double s
    );

__device__ __forceinline__ double1
cv::cudev::min(
    double s,
    const float1& b
    );

__device__ __forceinline__ double2
cv::cudev::min(
    const float2& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::min(
    double s,
    const float3& b
    );

__device__ __forceinline__ double4
cv::cudev::min(
    const float4& a,
    double s
    );

__device__ __forceinline__ double4
cv::cudev::min(
    double s,
    const float4& b
    );

__device__ __forceinline__ double4
cv::cudev::min(
    double s,
    const double4& b
    );

__device__ __forceinline__ double2
cv::cudev::min(
    double s,
    const double2& b
    );

__device__ __forceinline__ double1
cv::cudev::min(
    const double1& a,
    double s
    );

__device__ __forceinline__ double1
cv::cudev::min(
    double s,
    const double1& b
    );

__device__ __forceinline__ double2
cv::cudev::min(
    const double2& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::min(
    double s,
    const double3& b
    );

__device__ __forceinline__ double4
cv::cudev::min(
    const double4& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::min(
    const double3& a,
    double s
    );

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

template <class SrcPtr>
__host__ Expr<FindMinMaxValExprBody<SrcPtr>>
cv::cudev::minMaxVal_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<FindMinValExprBody<SrcPtr>>
cv::cudev::minVal_(const SrcPtr& src);

template <class Predicate>
__host__ __device__ UnaryNegate<Predicate>
cv::cudev::not1(const Predicate& pred);

template <class Predicate>
__host__ __device__ BinaryNegate<Predicate>
cv::cudev::not2(const Predicate& pred);

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, logical_not<T>>>
cv::cudev::operator!(const GlobPtrSz<T>& src);

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, logical_not<T>>>
cv::cudev::operator!(const Texture<T>& src);

template <class Body>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, logical_not<typename Body::value_type>>>
cv::cudev::operator!(const Expr<Body>& src);

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, logical_not<T>>>
cv::cudev::operator!(const GpuMat_<T>& src);

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

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

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

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

__device__ __forceinline__ uchar1
cv::cudev::operator!(const char1& a);

__device__ __forceinline__ uchar2
cv::cudev::operator!(const char2& a);

__device__ __forceinline__ uchar3
cv::cudev::operator!(const char3& a);

__device__ __forceinline__ uchar4
cv::cudev::operator!(const char4& a);

__device__ __forceinline__ uchar1
cv::cudev::operator!(const ushort1& a);

__device__ __forceinline__ uchar2
cv::cudev::operator!(const ushort2& a);

__device__ __forceinline__ uchar3
cv::cudev::operator!(const ushort3& a);

__device__ __forceinline__ uchar4
cv::cudev::operator!(const ushort4& a);

__device__ __forceinline__ uchar1
cv::cudev::operator!(const short1& a);

__device__ __forceinline__ uchar2
cv::cudev::operator!(const short2& a);

__device__ __forceinline__ uchar3
cv::cudev::operator!(const short3& a);

__device__ __forceinline__ uchar4
cv::cudev::operator!(const short4& a);

__device__ __forceinline__ uchar1
cv::cudev::operator!(const int1& a);

__device__ __forceinline__ uchar2
cv::cudev::operator!(const int2& a);

__device__ __forceinline__ uchar3
cv::cudev::operator!(const int3& a);

__device__ __forceinline__ uchar4
cv::cudev::operator!(const int4& a);

__device__ __forceinline__ uchar1
cv::cudev::operator!(const uint1& a);

__device__ __forceinline__ uchar2
cv::cudev::operator!(const uint2& a);

__device__ __forceinline__ uchar3
cv::cudev::operator!(const uint3& a);

__device__ __forceinline__ uchar4
cv::cudev::operator!(const uint4& a);

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

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

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

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

__device__ __forceinline__ uchar1
cv::cudev::operator!(const double1& a);

__device__ __forceinline__ uchar2
cv::cudev::operator!(const double2& a);

__device__ __forceinline__ uchar3
cv::cudev::operator!(const double3& a);

__device__ __forceinline__ uchar4
cv::cudev::operator!(const double4& a);

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, typename PtrTraits<GpuMat_<T>>::ptr_type, not_equal_to<T>>>
cv::cudev::operator!=(
    const GpuMat_<T>& src1,
    const GpuMat_<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, typename PtrTraits<GlobPtrSz<T>>::ptr_type, not_equal_to<T>>>
cv::cudev::operator!=(
    const GpuMat_<T>& src1,
    const GlobPtrSz<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, typename PtrTraits<GpuMat_<T>>::ptr_type, not_equal_to<T>>>
cv::cudev::operator!=(
    const GlobPtrSz<T>& src1,
    const GpuMat_<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, typename PtrTraits<Texture<T>>::ptr_type, not_equal_to<T>>>
cv::cudev::operator!=(
    const GpuMat_<T>& src1,
    const Texture<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, typename PtrTraits<GpuMat_<T>>::ptr_type, not_equal_to<T>>>
cv::cudev::operator!=(
    const Texture<T>& src1,
    const GpuMat_<T>& src2
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, typename PtrTraits<Body>::ptr_type, not_equal_to<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator!=(
    const GpuMat_<T>& src1,
    const Expr<Body>& src2
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, typename PtrTraits<GpuMat_<T>>::ptr_type, not_equal_to<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator!=(
    const Expr<Body>& src1,
    const GpuMat_<T>& src2
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, Binder2nd<not_equal_to<T>>>>
cv::cudev::operator!=(
    const GpuMat_<T>& src,
    T val
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, Binder1st<not_equal_to<T>>>>
cv::cudev::operator!=(
    T val,
    const GpuMat_<T>& src
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, typename PtrTraits<Texture<T>>::ptr_type, not_equal_to<T>>>
cv::cudev::operator!=(
    const GlobPtrSz<T>& src1,
    const Texture<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, typename PtrTraits<GlobPtrSz<T>>::ptr_type, not_equal_to<T>>>
cv::cudev::operator!=(
    const GlobPtrSz<T>& src1,
    const GlobPtrSz<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, typename PtrTraits<GlobPtrSz<T>>::ptr_type, not_equal_to<T>>>
cv::cudev::operator!=(
    const Texture<T>& src1,
    const GlobPtrSz<T>& src2
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, typename PtrTraits<Body>::ptr_type, not_equal_to<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator!=(
    const GlobPtrSz<T>& src1,
    const Expr<Body>& src2
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, Binder1st<not_equal_to<T>>>>
cv::cudev::operator!=(
    T val,
    const GlobPtrSz<T>& src
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, typename PtrTraits<GlobPtrSz<T>>::ptr_type, not_equal_to<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator!=(
    const Expr<Body>& src1,
    const GlobPtrSz<T>& src2
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, Binder2nd<not_equal_to<T>>>>
cv::cudev::operator!=(
    const GlobPtrSz<T>& src,
    T val
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, typename PtrTraits<Texture<T>>::ptr_type, not_equal_to<T>>>
cv::cudev::operator!=(
    const Texture<T>& src1,
    const Texture<T>& src2
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, typename PtrTraits<Texture<T>>::ptr_type, not_equal_to<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator!=(
    const Expr<Body>& src1,
    const Texture<T>& src2
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, typename PtrTraits<Body>::ptr_type, not_equal_to<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator!=(
    const Texture<T>& src1,
    const Expr<Body>& src2
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, Binder2nd<not_equal_to<T>>>>
cv::cudev::operator!=(
    const Texture<T>& src,
    T val
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, Binder1st<not_equal_to<T>>>>
cv::cudev::operator!=(
    T val,
    const Texture<T>& src
    );

template <
    class Body1,
    class Body2
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Body1>::ptr_type, typename PtrTraits<Body2>::ptr_type, not_equal_to<typename LargerType<typename PtrTraits<Body1>::value_type, typename PtrTraits<Body2>::value_type>::type>>>
cv::cudev::operator!=(
    const Expr<Body1>& a,
    const Expr<Body2>& b
    );

template <class Body>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, Binder2nd<not_equal_to<typename Body::value_type>>>>
cv::cudev::operator!=(
    const Expr<Body>& a,
    typename Body::value_type val
    );

template <class Body>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, Binder1st<not_equal_to<typename Body::value_type>>>>
cv::cudev::operator!=(
    typename Body::value_type val,
    const Expr<Body>& a
    );

__device__ __forceinline__ uchar2
cv::cudev::operator!=(
    const uchar2& a,
    const uchar2& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator!=(
    const uchar1& a,
    const uchar1& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator!=(
    const uchar3& a,
    const uchar3& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator!=(
    const uchar4& a,
    const uchar4& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator!=(
    const char1& a,
    const char1& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator!=(
    const char3& a,
    const char3& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator!=(
    const char4& a,
    const char4& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator!=(
    const char2& a,
    const char2& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator!=(
    const ushort2& a,
    const ushort2& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator!=(
    const ushort4& a,
    const ushort4& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator!=(
    const ushort3& a,
    const ushort3& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator!=(
    const ushort1& a,
    const ushort1& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator!=(
    const short2& a,
    const short2& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator!=(
    const short1& a,
    const short1& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator!=(
    const short3& a,
    const short3& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator!=(
    const short4& a,
    const short4& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator!=(
    const int4& a,
    const int4& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator!=(
    const int3& a,
    const int3& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator!=(
    const int2& a,
    const int2& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator!=(
    const int1& a,
    const int1& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator!=(
    const uint1& a,
    const uint1& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator!=(
    const uint3& a,
    const uint3& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator!=(
    const uint4& a,
    const uint4& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator!=(
    const uint2& a,
    const uint2& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator!=(
    const float2& a,
    const float2& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator!=(
    const float3& a,
    const float3& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator!=(
    const float4& a,
    const float4& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator!=(
    const float1& a,
    const float1& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator!=(
    const double1& a,
    const double1& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator!=(
    const double4& a,
    const double4& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator!=(
    const double3& a,
    const double3& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator!=(
    const double2& a,
    const double2& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator!=(
    uchar s,
    const uchar4& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator!=(
    const uchar1& a,
    uchar s
    );

__device__ __forceinline__ uchar1
cv::cudev::operator!=(
    uchar s,
    const uchar1& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator!=(
    const uchar2& a,
    uchar s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator!=(
    const uchar3& a,
    uchar s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator!=(
    uchar s,
    const uchar3& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator!=(
    const uchar4& a,
    uchar s
    );

__device__ __forceinline__ uchar2
cv::cudev::operator!=(
    uchar s,
    const uchar2& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator!=(
    const char1& a,
    char s
    );

__device__ __forceinline__ uchar1
cv::cudev::operator!=(
    char s,
    const char1& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator!=(
    const char2& a,
    char s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator!=(
    const char3& a,
    char s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator!=(
    char s,
    const char3& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator!=(
    const char4& a,
    char s
    );

__device__ __forceinline__ uchar4
cv::cudev::operator!=(
    char s,
    const char4& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator!=(
    char s,
    const char2& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator!=(
    const ushort1& a,
    ushort s
    );

__device__ __forceinline__ uchar1
cv::cudev::operator!=(
    ushort s,
    const ushort1& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator!=(
    const ushort2& a,
    ushort s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator!=(
    const ushort3& a,
    ushort s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator!=(
    ushort s,
    const ushort3& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator!=(
    const ushort4& a,
    ushort s
    );

__device__ __forceinline__ uchar4
cv::cudev::operator!=(
    ushort s,
    const ushort4& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator!=(
    ushort s,
    const ushort2& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator!=(
    short s,
    const short4& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator!=(
    const short1& a,
    short s
    );

__device__ __forceinline__ uchar1
cv::cudev::operator!=(
    short s,
    const short1& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator!=(
    const short2& a,
    short s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator!=(
    const short3& a,
    short s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator!=(
    short s,
    const short3& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator!=(
    const short4& a,
    short s
    );

__device__ __forceinline__ uchar2
cv::cudev::operator!=(
    short s,
    const short2& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator!=(
    const int1& a,
    int s
    );

__device__ __forceinline__ uchar1
cv::cudev::operator!=(
    int s,
    const int1& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator!=(
    const int2& a,
    int s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator!=(
    const int3& a,
    int s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator!=(
    int s,
    const int3& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator!=(
    const int4& a,
    int s
    );

__device__ __forceinline__ uchar4
cv::cudev::operator!=(
    int s,
    const int4& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator!=(
    int s,
    const int2& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator!=(
    uint s,
    const uint4& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator!=(
    const uint1& a,
    uint s
    );

__device__ __forceinline__ uchar1
cv::cudev::operator!=(
    uint s,
    const uint1& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator!=(
    const uint2& a,
    uint s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator!=(
    const uint3& a,
    uint s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator!=(
    uint s,
    const uint3& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator!=(
    const uint4& a,
    uint s
    );

__device__ __forceinline__ uchar2
cv::cudev::operator!=(
    uint s,
    const uint2& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator!=(
    const float1& a,
    float s
    );

__device__ __forceinline__ uchar1
cv::cudev::operator!=(
    float s,
    const float1& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator!=(
    const float2& a,
    float s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator!=(
    const float3& a,
    float s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator!=(
    float s,
    const float3& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator!=(
    const float4& a,
    float s
    );

__device__ __forceinline__ uchar4
cv::cudev::operator!=(
    float s,
    const float4& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator!=(
    float s,
    const float2& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator!=(
    const double1& a,
    double s
    );

__device__ __forceinline__ uchar1
cv::cudev::operator!=(
    double s,
    const double1& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator!=(
    const double2& a,
    double s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator!=(
    const double3& a,
    double s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator!=(
    double s,
    const double3& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator!=(
    const double4& a,
    double s
    );

__device__ __forceinline__ uchar4
cv::cudev::operator!=(
    double s,
    const double4& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator!=(
    double s,
    const double2& b
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, Binder2nd<modulus<T>>>>
cv::cudev::operator%(
    const GlobPtrSz<T>& src,
    T val
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, typename PtrTraits<GlobPtrSz<T>>::ptr_type, modulus<T>>>
cv::cudev::operator%(
    const GlobPtrSz<T>& src1,
    const GlobPtrSz<T>& src2
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, Binder1st<modulus<T>>>>
cv::cudev::operator%(
    T val,
    const GlobPtrSz<T>& src
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, typename PtrTraits<Texture<T>>::ptr_type, modulus<T>>>
cv::cudev::operator%(
    const Texture<T>& src1,
    const Texture<T>& src2
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, typename PtrTraits<Body>::ptr_type, modulus<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator%(
    const Texture<T>& src1,
    const Expr<Body>& src2
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, Binder2nd<modulus<T>>>>
cv::cudev::operator%(
    const Texture<T>& src,
    T val
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, Binder1st<modulus<T>>>>
cv::cudev::operator%(
    T val,
    const Texture<T>& src
    );

template <class Body>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, Binder2nd<modulus<typename Body::value_type>>>>
cv::cudev::operator%(
    const Expr<Body>& a,
    typename Body::value_type val
    );

template <
    class Body1,
    class Body2
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Body1>::ptr_type, typename PtrTraits<Body2>::ptr_type, modulus<typename LargerType<typename PtrTraits<Body1>::value_type, typename PtrTraits<Body2>::value_type>::type>>>
cv::cudev::operator%(
    const Expr<Body1>& a,
    const Expr<Body2>& b
    );

template <class Body>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, Binder1st<modulus<typename Body::value_type>>>>
cv::cudev::operator%(
    typename Body::value_type val,
    const Expr<Body>& a
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, typename PtrTraits<Texture<T>>::ptr_type, modulus<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator%(
    const Expr<Body>& src1,
    const Texture<T>& src2
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, typename PtrTraits<Body>::ptr_type, modulus<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator%(
    const GpuMat_<T>& src1,
    const Expr<Body>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, typename PtrTraits<GpuMat_<T>>::ptr_type, modulus<T>>>
cv::cudev::operator%(
    const Texture<T>& src1,
    const GpuMat_<T>& src2
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, typename PtrTraits<GlobPtrSz<T>>::ptr_type, modulus<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator%(
    const Expr<Body>& src1,
    const GlobPtrSz<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, typename PtrTraits<GlobPtrSz<T>>::ptr_type, modulus<T>>>
cv::cudev::operator%(
    const GpuMat_<T>& src1,
    const GlobPtrSz<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, typename PtrTraits<GpuMat_<T>>::ptr_type, modulus<T>>>
cv::cudev::operator%(
    const GpuMat_<T>& src1,
    const GpuMat_<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, typename PtrTraits<GpuMat_<T>>::ptr_type, modulus<T>>>
cv::cudev::operator%(
    const GlobPtrSz<T>& src1,
    const GpuMat_<T>& src2
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, typename PtrTraits<GpuMat_<T>>::ptr_type, modulus<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator%(
    const Expr<Body>& src1,
    const GpuMat_<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, typename PtrTraits<Texture<T>>::ptr_type, modulus<T>>>
cv::cudev::operator%(
    const GpuMat_<T>& src1,
    const Texture<T>& src2
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, Binder2nd<modulus<T>>>>
cv::cudev::operator%(
    const GpuMat_<T>& src,
    T val
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, Binder1st<modulus<T>>>>
cv::cudev::operator%(
    T val,
    const GpuMat_<T>& src
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, typename PtrTraits<Texture<T>>::ptr_type, modulus<T>>>
cv::cudev::operator%(
    const GlobPtrSz<T>& src1,
    const Texture<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, typename PtrTraits<GlobPtrSz<T>>::ptr_type, modulus<T>>>
cv::cudev::operator%(
    const Texture<T>& src1,
    const GlobPtrSz<T>& src2
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, typename PtrTraits<Body>::ptr_type, modulus<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator%(
    const GlobPtrSz<T>& src1,
    const Expr<Body>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, typename PtrTraits<GpuMat_<T>>::ptr_type, bit_and<T>>>
cv::cudev::operator&(
    const GpuMat_<T>& src1,
    const GpuMat_<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, typename PtrTraits<GlobPtrSz<T>>::ptr_type, bit_and<T>>>
cv::cudev::operator&(
    const GpuMat_<T>& src1,
    const GlobPtrSz<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, typename PtrTraits<GpuMat_<T>>::ptr_type, bit_and<T>>>
cv::cudev::operator&(
    const GlobPtrSz<T>& src1,
    const GpuMat_<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, typename PtrTraits<Texture<T>>::ptr_type, bit_and<T>>>
cv::cudev::operator&(
    const GpuMat_<T>& src1,
    const Texture<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, typename PtrTraits<GpuMat_<T>>::ptr_type, bit_and<T>>>
cv::cudev::operator&(
    const Texture<T>& src1,
    const GpuMat_<T>& src2
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, typename PtrTraits<Body>::ptr_type, bit_and<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator&(
    const GpuMat_<T>& src1,
    const Expr<Body>& src2
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, typename PtrTraits<GpuMat_<T>>::ptr_type, bit_and<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator&(
    const Expr<Body>& src1,
    const GpuMat_<T>& src2
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, Binder2nd<bit_and<T>>>>
cv::cudev::operator&(
    const GpuMat_<T>& src,
    T val
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, Binder1st<bit_and<T>>>>
cv::cudev::operator&(
    T val,
    const GpuMat_<T>& src
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, typename PtrTraits<GlobPtrSz<T>>::ptr_type, bit_and<T>>>
cv::cudev::operator&(
    const GlobPtrSz<T>& src1,
    const GlobPtrSz<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, typename PtrTraits<Texture<T>>::ptr_type, bit_and<T>>>
cv::cudev::operator&(
    const GlobPtrSz<T>& src1,
    const Texture<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, typename PtrTraits<GlobPtrSz<T>>::ptr_type, bit_and<T>>>
cv::cudev::operator&(
    const Texture<T>& src1,
    const GlobPtrSz<T>& src2
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, typename PtrTraits<Body>::ptr_type, bit_and<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator&(
    const GlobPtrSz<T>& src1,
    const Expr<Body>& src2
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, typename PtrTraits<GlobPtrSz<T>>::ptr_type, bit_and<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator&(
    const Expr<Body>& src1,
    const GlobPtrSz<T>& src2
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, Binder2nd<bit_and<T>>>>
cv::cudev::operator&(
    const GlobPtrSz<T>& src,
    T val
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, Binder1st<bit_and<T>>>>
cv::cudev::operator&(
    T val,
    const GlobPtrSz<T>& src
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, typename PtrTraits<Texture<T>>::ptr_type, bit_and<T>>>
cv::cudev::operator&(
    const Texture<T>& src1,
    const Texture<T>& src2
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, typename PtrTraits<Body>::ptr_type, bit_and<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator&(
    const Texture<T>& src1,
    const Expr<Body>& src2
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, typename PtrTraits<Texture<T>>::ptr_type, bit_and<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator&(
    const Expr<Body>& src1,
    const Texture<T>& src2
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, Binder2nd<bit_and<T>>>>
cv::cudev::operator&(
    const Texture<T>& src,
    T val
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, Binder1st<bit_and<T>>>>
cv::cudev::operator&(
    T val,
    const Texture<T>& src
    );

template <class Body>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, Binder2nd<bit_and<typename Body::value_type>>>>
cv::cudev::operator&(
    const Expr<Body>& a,
    typename Body::value_type val
    );

template <
    class Body1,
    class Body2
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Body1>::ptr_type, typename PtrTraits<Body2>::ptr_type, bit_and<typename LargerType<typename PtrTraits<Body1>::value_type, typename PtrTraits<Body2>::value_type>::type>>>
cv::cudev::operator&(
    const Expr<Body1>& a,
    const Expr<Body2>& b
    );

template <class Body>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, Binder1st<bit_and<typename Body::value_type>>>>
cv::cudev::operator&(
    typename Body::value_type val,
    const Expr<Body>& a
    );

__device__ __forceinline__ uchar1
cv::cudev::operator&(
    const uchar1& a,
    const uchar1& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator&(
    const uchar2& a,
    const uchar2& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator&(
    const uchar3& a,
    const uchar3& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator&(
    const uchar4& a,
    const uchar4& b
    );

__device__ __forceinline__ char1
cv::cudev::operator&(
    const char1& a,
    const char1& b
    );

__device__ __forceinline__ char2
cv::cudev::operator&(
    const char2& a,
    const char2& b
    );

__device__ __forceinline__ char3
cv::cudev::operator&(
    const char3& a,
    const char3& b
    );

__device__ __forceinline__ char4
cv::cudev::operator&(
    const char4& a,
    const char4& b
    );

__device__ __forceinline__ ushort1
cv::cudev::operator&(
    const ushort1& a,
    const ushort1& b
    );

__device__ __forceinline__ ushort2
cv::cudev::operator&(
    const ushort2& a,
    const ushort2& b
    );

__device__ __forceinline__ ushort3
cv::cudev::operator&(
    const ushort3& a,
    const ushort3& b
    );

__device__ __forceinline__ ushort4
cv::cudev::operator&(
    const ushort4& a,
    const ushort4& b
    );

__device__ __forceinline__ short1
cv::cudev::operator&(
    const short1& a,
    const short1& b
    );

__device__ __forceinline__ short2
cv::cudev::operator&(
    const short2& a,
    const short2& b
    );

__device__ __forceinline__ short3
cv::cudev::operator&(
    const short3& a,
    const short3& b
    );

__device__ __forceinline__ short4
cv::cudev::operator&(
    const short4& a,
    const short4& b
    );

__device__ __forceinline__ int1
cv::cudev::operator&(
    const int1& a,
    const int1& b
    );

__device__ __forceinline__ int2
cv::cudev::operator&(
    const int2& a,
    const int2& b
    );

__device__ __forceinline__ int3
cv::cudev::operator&(
    const int3& a,
    const int3& b
    );

__device__ __forceinline__ int4
cv::cudev::operator&(
    const int4& a,
    const int4& b
    );

__device__ __forceinline__ uint1
cv::cudev::operator&(
    const uint1& a,
    const uint1& b
    );

__device__ __forceinline__ uint2
cv::cudev::operator&(
    const uint2& a,
    const uint2& b
    );

__device__ __forceinline__ uint3
cv::cudev::operator&(
    const uint3& a,
    const uint3& b
    );

__device__ __forceinline__ uint4
cv::cudev::operator&(
    const uint4& a,
    const uint4& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator&(
    const uchar1& a,
    uchar s
    );

__device__ __forceinline__ uchar1
cv::cudev::operator&(
    uchar s,
    const uchar1& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator&(
    const uchar2& a,
    uchar s
    );

__device__ __forceinline__ uchar2
cv::cudev::operator&(
    uchar s,
    const uchar2& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator&(
    const uchar3& a,
    uchar s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator&(
    uchar s,
    const uchar3& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator&(
    const uchar4& a,
    uchar s
    );

__device__ __forceinline__ uchar4
cv::cudev::operator&(
    uchar s,
    const uchar4& b
    );

__device__ __forceinline__ char2
cv::cudev::operator&(
    char s,
    const char2& b
    );

__device__ __forceinline__ char4
cv::cudev::operator&(
    char s,
    const char4& b
    );

__device__ __forceinline__ char1
cv::cudev::operator&(
    const char1& a,
    char s
    );

__device__ __forceinline__ char1
cv::cudev::operator&(
    char s,
    const char1& b
    );

__device__ __forceinline__ char2
cv::cudev::operator&(
    const char2& a,
    char s
    );

__device__ __forceinline__ char3
cv::cudev::operator&(
    const char3& a,
    char s
    );

__device__ __forceinline__ char3
cv::cudev::operator&(
    char s,
    const char3& b
    );

__device__ __forceinline__ char4
cv::cudev::operator&(
    const char4& a,
    char s
    );

__device__ __forceinline__ ushort1
cv::cudev::operator&(
    const ushort1& a,
    ushort s
    );

__device__ __forceinline__ ushort1
cv::cudev::operator&(
    ushort s,
    const ushort1& b
    );

__device__ __forceinline__ ushort2
cv::cudev::operator&(
    const ushort2& a,
    ushort s
    );

__device__ __forceinline__ ushort3
cv::cudev::operator&(
    const ushort3& a,
    ushort s
    );

__device__ __forceinline__ ushort3
cv::cudev::operator&(
    ushort s,
    const ushort3& b
    );

__device__ __forceinline__ ushort4
cv::cudev::operator&(
    const ushort4& a,
    ushort s
    );

__device__ __forceinline__ ushort4
cv::cudev::operator&(
    ushort s,
    const ushort4& b
    );

__device__ __forceinline__ ushort2
cv::cudev::operator&(
    ushort s,
    const ushort2& b
    );

__device__ __forceinline__ short4
cv::cudev::operator&(
    short s,
    const short4& b
    );

__device__ __forceinline__ short1
cv::cudev::operator&(
    const short1& a,
    short s
    );

__device__ __forceinline__ short1
cv::cudev::operator&(
    short s,
    const short1& b
    );

__device__ __forceinline__ short2
cv::cudev::operator&(
    const short2& a,
    short s
    );

__device__ __forceinline__ short3
cv::cudev::operator&(
    const short3& a,
    short s
    );

__device__ __forceinline__ short3
cv::cudev::operator&(
    short s,
    const short3& b
    );

__device__ __forceinline__ short4
cv::cudev::operator&(
    const short4& a,
    short s
    );

__device__ __forceinline__ short2
cv::cudev::operator&(
    short s,
    const short2& b
    );

__device__ __forceinline__ int1
cv::cudev::operator&(
    const int1& a,
    int s
    );

__device__ __forceinline__ int1
cv::cudev::operator&(
    int s,
    const int1& b
    );

__device__ __forceinline__ int2
cv::cudev::operator&(
    const int2& a,
    int s
    );

__device__ __forceinline__ int3
cv::cudev::operator&(
    const int3& a,
    int s
    );

__device__ __forceinline__ int3
cv::cudev::operator&(
    int s,
    const int3& b
    );

__device__ __forceinline__ int4
cv::cudev::operator&(
    const int4& a,
    int s
    );

__device__ __forceinline__ int4
cv::cudev::operator&(
    int s,
    const int4& b
    );

__device__ __forceinline__ int2
cv::cudev::operator&(
    int s,
    const int2& b
    );

__device__ __forceinline__ uint2
cv::cudev::operator&(
    uint s,
    const uint2& b
    );

__device__ __forceinline__ uint4
cv::cudev::operator&(
    uint s,
    const uint4& b
    );

__device__ __forceinline__ uint1
cv::cudev::operator&(
    const uint1& a,
    uint s
    );

__device__ __forceinline__ uint1
cv::cudev::operator&(
    uint s,
    const uint1& b
    );

__device__ __forceinline__ uint2
cv::cudev::operator&(
    const uint2& a,
    uint s
    );

__device__ __forceinline__ uint3
cv::cudev::operator&(
    const uint3& a,
    uint s
    );

__device__ __forceinline__ uint3
cv::cudev::operator&(
    uint s,
    const uint3& b
    );

__device__ __forceinline__ uint4
cv::cudev::operator&(
    const uint4& a,
    uint s
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, typename PtrTraits<GpuMat_<T>>::ptr_type, logical_and<T>>>
cv::cudev::operator&&(
    const GpuMat_<T>& src1,
    const GpuMat_<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, typename PtrTraits<GlobPtrSz<T>>::ptr_type, logical_and<T>>>
cv::cudev::operator&&(
    const GpuMat_<T>& src1,
    const GlobPtrSz<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, typename PtrTraits<GpuMat_<T>>::ptr_type, logical_and<T>>>
cv::cudev::operator&&(
    const GlobPtrSz<T>& src1,
    const GpuMat_<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, typename PtrTraits<Texture<T>>::ptr_type, logical_and<T>>>
cv::cudev::operator&&(
    const GpuMat_<T>& src1,
    const Texture<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, typename PtrTraits<GpuMat_<T>>::ptr_type, logical_and<T>>>
cv::cudev::operator&&(
    const Texture<T>& src1,
    const GpuMat_<T>& src2
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, typename PtrTraits<GpuMat_<T>>::ptr_type, logical_and<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator&&(
    const Expr<Body>& src1,
    const GpuMat_<T>& src2
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, typename PtrTraits<Body>::ptr_type, logical_and<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator&&(
    const GpuMat_<T>& src1,
    const Expr<Body>& src2
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, Binder2nd<logical_and<T>>>>
cv::cudev::operator&&(
    const GpuMat_<T>& src,
    T val
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, Binder1st<logical_and<T>>>>
cv::cudev::operator&&(
    T val,
    const GpuMat_<T>& src
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, typename PtrTraits<GlobPtrSz<T>>::ptr_type, logical_and<T>>>
cv::cudev::operator&&(
    const GlobPtrSz<T>& src1,
    const GlobPtrSz<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, typename PtrTraits<Texture<T>>::ptr_type, logical_and<T>>>
cv::cudev::operator&&(
    const GlobPtrSz<T>& src1,
    const Texture<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, typename PtrTraits<GlobPtrSz<T>>::ptr_type, logical_and<T>>>
cv::cudev::operator&&(
    const Texture<T>& src1,
    const GlobPtrSz<T>& src2
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, typename PtrTraits<Body>::ptr_type, logical_and<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator&&(
    const GlobPtrSz<T>& src1,
    const Expr<Body>& src2
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, Binder2nd<logical_and<T>>>>
cv::cudev::operator&&(
    const GlobPtrSz<T>& src,
    T val
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, typename PtrTraits<GlobPtrSz<T>>::ptr_type, logical_and<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator&&(
    const Expr<Body>& src1,
    const GlobPtrSz<T>& src2
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, Binder1st<logical_and<T>>>>
cv::cudev::operator&&(
    T val,
    const GlobPtrSz<T>& src
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, typename PtrTraits<Texture<T>>::ptr_type, logical_and<T>>>
cv::cudev::operator&&(
    const Texture<T>& src1,
    const Texture<T>& src2
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, typename PtrTraits<Body>::ptr_type, logical_and<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator&&(
    const Texture<T>& src1,
    const Expr<Body>& src2
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, typename PtrTraits<Texture<T>>::ptr_type, logical_and<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator&&(
    const Expr<Body>& src1,
    const Texture<T>& src2
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, Binder2nd<logical_and<T>>>>
cv::cudev::operator&&(
    const Texture<T>& src,
    T val
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, Binder1st<logical_and<T>>>>
cv::cudev::operator&&(
    T val,
    const Texture<T>& src
    );

template <class Body>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, Binder1st<logical_and<typename Body::value_type>>>>
cv::cudev::operator&&(
    typename Body::value_type val,
    const Expr<Body>& a
    );

template <class Body>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, Binder2nd<logical_and<typename Body::value_type>>>>
cv::cudev::operator&&(
    const Expr<Body>& a,
    typename Body::value_type val
    );

template <
    class Body1,
    class Body2
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Body1>::ptr_type, typename PtrTraits<Body2>::ptr_type, logical_and<typename LargerType<typename PtrTraits<Body1>::value_type, typename PtrTraits<Body2>::value_type>::type>>>
cv::cudev::operator&&(
    const Expr<Body1>& a,
    const Expr<Body2>& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator&&(
    const uchar1& a,
    const uchar1& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator&&(
    const uchar2& a,
    const uchar2& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator&&(
    const uchar4& a,
    const uchar4& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator&&(
    const uchar3& a,
    const uchar3& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator&&(
    const char1& a,
    const char1& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator&&(
    const char3& a,
    const char3& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator&&(
    const char4& a,
    const char4& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator&&(
    const char2& a,
    const char2& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator&&(
    const ushort1& a,
    const ushort1& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator&&(
    const ushort2& a,
    const ushort2& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator&&(
    const ushort4& a,
    const ushort4& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator&&(
    const ushort3& a,
    const ushort3& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator&&(
    const short2& a,
    const short2& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator&&(
    const short3& a,
    const short3& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator&&(
    const short4& a,
    const short4& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator&&(
    const short1& a,
    const short1& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator&&(
    const int1& a,
    const int1& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator&&(
    const int3& a,
    const int3& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator&&(
    const int4& a,
    const int4& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator&&(
    const int2& a,
    const int2& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator&&(
    const uint2& a,
    const uint2& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator&&(
    const uint1& a,
    const uint1& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator&&(
    const uint4& a,
    const uint4& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator&&(
    const uint3& a,
    const uint3& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator&&(
    const float1& a,
    const float1& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator&&(
    const float2& a,
    const float2& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator&&(
    const float4& a,
    const float4& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator&&(
    const float3& a,
    const float3& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator&&(
    const double1& a,
    const double1& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator&&(
    const double2& a,
    const double2& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator&&(
    const double3& a,
    const double3& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator&&(
    const double4& a,
    const double4& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator&&(
    const uchar1& a,
    uchar s
    );

__device__ __forceinline__ uchar1
cv::cudev::operator&&(
    uchar s,
    const uchar1& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator&&(
    const uchar2& a,
    uchar s
    );

__device__ __forceinline__ uchar2
cv::cudev::operator&&(
    uchar s,
    const uchar2& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator&&(
    const uchar3& a,
    uchar s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator&&(
    uchar s,
    const uchar3& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator&&(
    const uchar4& a,
    uchar s
    );

__device__ __forceinline__ uchar4
cv::cudev::operator&&(
    uchar s,
    const uchar4& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator&&(
    const char1& a,
    char s
    );

__device__ __forceinline__ uchar1
cv::cudev::operator&&(
    char s,
    const char1& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator&&(
    const char2& a,
    char s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator&&(
    const char3& a,
    char s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator&&(
    char s,
    const char3& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator&&(
    const char4& a,
    char s
    );

__device__ __forceinline__ uchar2
cv::cudev::operator&&(
    char s,
    const char2& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator&&(
    char s,
    const char4& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator&&(
    ushort s,
    const ushort2& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator&&(
    const ushort1& a,
    ushort s
    );

__device__ __forceinline__ uchar1
cv::cudev::operator&&(
    ushort s,
    const ushort1& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator&&(
    const ushort2& a,
    ushort s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator&&(
    const ushort3& a,
    ushort s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator&&(
    ushort s,
    const ushort3& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator&&(
    const ushort4& a,
    ushort s
    );

__device__ __forceinline__ uchar4
cv::cudev::operator&&(
    ushort s,
    const ushort4& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator&&(
    short s,
    const short4& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator&&(
    short s,
    const short2& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator&&(
    const short1& a,
    short s
    );

__device__ __forceinline__ uchar1
cv::cudev::operator&&(
    short s,
    const short1& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator&&(
    const short2& a,
    short s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator&&(
    const short3& a,
    short s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator&&(
    short s,
    const short3& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator&&(
    const short4& a,
    short s
    );

__device__ __forceinline__ uchar1
cv::cudev::operator&&(
    const int1& a,
    int s
    );

__device__ __forceinline__ uchar1
cv::cudev::operator&&(
    int s,
    const int1& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator&&(
    const int2& a,
    int s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator&&(
    const int3& a,
    int s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator&&(
    int s,
    const int3& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator&&(
    const int4& a,
    int s
    );

__device__ __forceinline__ uchar4
cv::cudev::operator&&(
    int s,
    const int4& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator&&(
    int s,
    const int2& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator&&(
    uint s,
    const uint4& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator&&(
    const uint1& a,
    uint s
    );

__device__ __forceinline__ uchar1
cv::cudev::operator&&(
    uint s,
    const uint1& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator&&(
    const uint2& a,
    uint s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator&&(
    const uint3& a,
    uint s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator&&(
    uint s,
    const uint3& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator&&(
    const uint4& a,
    uint s
    );

__device__ __forceinline__ uchar2
cv::cudev::operator&&(
    uint s,
    const uint2& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator&&(
    const float1& a,
    float s
    );

__device__ __forceinline__ uchar1
cv::cudev::operator&&(
    float s,
    const float1& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator&&(
    const float2& a,
    float s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator&&(
    const float3& a,
    float s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator&&(
    float s,
    const float3& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator&&(
    const float4& a,
    float s
    );

__device__ __forceinline__ uchar4
cv::cudev::operator&&(
    float s,
    const float4& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator&&(
    float s,
    const float2& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator&&(
    double s,
    const double4& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator&&(
    const double1& a,
    double s
    );

__device__ __forceinline__ uchar1
cv::cudev::operator&&(
    double s,
    const double1& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator&&(
    const double2& a,
    double s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator&&(
    const double3& a,
    double s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator&&(
    double s,
    const double3& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator&&(
    const double4& a,
    double s
    );

__device__ __forceinline__ uchar2
cv::cudev::operator&&(
    double s,
    const double2& b
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, typename PtrTraits<GpuMat_<T>>::ptr_type, multiplies<T>>>
cv::cudev::operator*(
    const GpuMat_<T>& src1,
    const GpuMat_<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, typename PtrTraits<GlobPtrSz<T>>::ptr_type, multiplies<T>>>
cv::cudev::operator*(
    const GpuMat_<T>& src1,
    const GlobPtrSz<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, typename PtrTraits<GpuMat_<T>>::ptr_type, multiplies<T>>>
cv::cudev::operator*(
    const GlobPtrSz<T>& src1,
    const GpuMat_<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, typename PtrTraits<Texture<T>>::ptr_type, multiplies<T>>>
cv::cudev::operator*(
    const GpuMat_<T>& src1,
    const Texture<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, typename PtrTraits<GpuMat_<T>>::ptr_type, multiplies<T>>>
cv::cudev::operator*(
    const Texture<T>& src1,
    const GpuMat_<T>& src2
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, typename PtrTraits<Body>::ptr_type, multiplies<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator*(
    const GpuMat_<T>& src1,
    const Expr<Body>& src2
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, typename PtrTraits<GpuMat_<T>>::ptr_type, multiplies<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator*(
    const Expr<Body>& src1,
    const GpuMat_<T>& src2
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, Binder2nd<multiplies<T>>>>
cv::cudev::operator*(
    const GpuMat_<T>& src,
    T val
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, Binder1st<multiplies<T>>>>
cv::cudev::operator*(
    T val,
    const GpuMat_<T>& src
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, typename PtrTraits<Texture<T>>::ptr_type, multiplies<T>>>
cv::cudev::operator*(
    const GlobPtrSz<T>& src1,
    const Texture<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, typename PtrTraits<GlobPtrSz<T>>::ptr_type, multiplies<T>>>
cv::cudev::operator*(
    const GlobPtrSz<T>& src1,
    const GlobPtrSz<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, typename PtrTraits<GlobPtrSz<T>>::ptr_type, multiplies<T>>>
cv::cudev::operator*(
    const Texture<T>& src1,
    const GlobPtrSz<T>& src2
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, typename PtrTraits<Body>::ptr_type, multiplies<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator*(
    const GlobPtrSz<T>& src1,
    const Expr<Body>& src2
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, typename PtrTraits<GlobPtrSz<T>>::ptr_type, multiplies<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator*(
    const Expr<Body>& src1,
    const GlobPtrSz<T>& src2
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, Binder2nd<multiplies<T>>>>
cv::cudev::operator*(
    const GlobPtrSz<T>& src,
    T val
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, Binder1st<multiplies<T>>>>
cv::cudev::operator*(
    T val,
    const GlobPtrSz<T>& src
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, typename PtrTraits<Texture<T>>::ptr_type, multiplies<T>>>
cv::cudev::operator*(
    const Texture<T>& src1,
    const Texture<T>& src2
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, typename PtrTraits<Body>::ptr_type, multiplies<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator*(
    const Texture<T>& src1,
    const Expr<Body>& src2
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, typename PtrTraits<Texture<T>>::ptr_type, multiplies<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator*(
    const Expr<Body>& src1,
    const Texture<T>& src2
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, Binder2nd<multiplies<T>>>>
cv::cudev::operator*(
    const Texture<T>& src,
    T val
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, Binder1st<multiplies<T>>>>
cv::cudev::operator*(
    T val,
    const Texture<T>& src
    );

template <
    class Body1,
    class Body2
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Body1>::ptr_type, typename PtrTraits<Body2>::ptr_type, multiplies<typename LargerType<typename PtrTraits<Body1>::value_type, typename PtrTraits<Body2>::value_type>::type>>>
cv::cudev::operator*(
    const Expr<Body1>& a,
    const Expr<Body2>& b
    );

template <class Body>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, Binder2nd<multiplies<typename Body::value_type>>>>
cv::cudev::operator*(
    const Expr<Body>& a,
    typename Body::value_type val
    );

template <class Body>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, Binder1st<multiplies<typename Body::value_type>>>>
cv::cudev::operator*(
    typename Body::value_type val,
    const Expr<Body>& a
    );

__device__ __forceinline__ int4
cv::cudev::operator*(
    const uchar4& a,
    const uchar4& b
    );

__device__ __forceinline__ int2
cv::cudev::operator*(
    const uchar2& a,
    const uchar2& b
    );

__device__ __forceinline__ int1
cv::cudev::operator*(
    const uchar1& a,
    const uchar1& b
    );

__device__ __forceinline__ int3
cv::cudev::operator*(
    const uchar3& a,
    const uchar3& b
    );

__device__ __forceinline__ int1
cv::cudev::operator*(
    const char1& a,
    const char1& b
    );

__device__ __forceinline__ int2
cv::cudev::operator*(
    const char2& a,
    const char2& b
    );

__device__ __forceinline__ int3
cv::cudev::operator*(
    const char3& a,
    const char3& b
    );

__device__ __forceinline__ int4
cv::cudev::operator*(
    const char4& a,
    const char4& b
    );

__device__ __forceinline__ int1
cv::cudev::operator*(
    const ushort1& a,
    const ushort1& b
    );

__device__ __forceinline__ int2
cv::cudev::operator*(
    const ushort2& a,
    const ushort2& b
    );

__device__ __forceinline__ int3
cv::cudev::operator*(
    const ushort3& a,
    const ushort3& b
    );

__device__ __forceinline__ int4
cv::cudev::operator*(
    const ushort4& a,
    const ushort4& b
    );

__device__ __forceinline__ int1
cv::cudev::operator*(
    const short1& a,
    const short1& b
    );

__device__ __forceinline__ int2
cv::cudev::operator*(
    const short2& a,
    const short2& b
    );

__device__ __forceinline__ int3
cv::cudev::operator*(
    const short3& a,
    const short3& b
    );

__device__ __forceinline__ int4
cv::cudev::operator*(
    const short4& a,
    const short4& b
    );

__device__ __forceinline__ int4
cv::cudev::operator*(
    const int4& a,
    const int4& b
    );

__device__ __forceinline__ int3
cv::cudev::operator*(
    const int3& a,
    const int3& b
    );

__device__ __forceinline__ int1
cv::cudev::operator*(
    const int1& a,
    const int1& b
    );

__device__ __forceinline__ int2
cv::cudev::operator*(
    const int2& a,
    const int2& b
    );

__device__ __forceinline__ uint3
cv::cudev::operator*(
    const uint3& a,
    const uint3& b
    );

__device__ __forceinline__ uint4
cv::cudev::operator*(
    const uint4& a,
    const uint4& b
    );

__device__ __forceinline__ uint1
cv::cudev::operator*(
    const uint1& a,
    const uint1& b
    );

__device__ __forceinline__ uint2
cv::cudev::operator*(
    const uint2& a,
    const uint2& b
    );

__device__ __forceinline__ float4
cv::cudev::operator*(
    const float4& a,
    const float4& b
    );

__device__ __forceinline__ float3
cv::cudev::operator*(
    const float3& a,
    const float3& b
    );

__device__ __forceinline__ float2
cv::cudev::operator*(
    const float2& a,
    const float2& b
    );

__device__ __forceinline__ float1
cv::cudev::operator*(
    const float1& a,
    const float1& b
    );

__device__ __forceinline__ double3
cv::cudev::operator*(
    const double3& a,
    const double3& b
    );

__device__ __forceinline__ double4
cv::cudev::operator*(
    const double4& a,
    const double4& b
    );

__device__ __forceinline__ double1
cv::cudev::operator*(
    const double1& a,
    const double1& b
    );

__device__ __forceinline__ double2
cv::cudev::operator*(
    const double2& a,
    const double2& b
    );

__device__ __forceinline__ int2
cv::cudev::operator*(
    int s,
    const uchar2& b
    );

__device__ __forceinline__ int1
cv::cudev::operator*(
    const uchar1& a,
    int s
    );

__device__ __forceinline__ int1
cv::cudev::operator*(
    int s,
    const uchar1& b
    );

__device__ __forceinline__ int2
cv::cudev::operator*(
    const uchar2& a,
    int s
    );

__device__ __forceinline__ int3
cv::cudev::operator*(
    const uchar3& a,
    int s
    );

__device__ __forceinline__ int3
cv::cudev::operator*(
    int s,
    const uchar3& b
    );

__device__ __forceinline__ int4
cv::cudev::operator*(
    const uchar4& a,
    int s
    );

__device__ __forceinline__ int4
cv::cudev::operator*(
    int s,
    const uchar4& b
    );

__device__ __forceinline__ float4
cv::cudev::operator*(
    float s,
    const uchar4& b
    );

__device__ __forceinline__ float2
cv::cudev::operator*(
    float s,
    const uchar2& b
    );

__device__ __forceinline__ float1
cv::cudev::operator*(
    const uchar1& a,
    float s
    );

__device__ __forceinline__ float1
cv::cudev::operator*(
    float s,
    const uchar1& b
    );

__device__ __forceinline__ float2
cv::cudev::operator*(
    const uchar2& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::operator*(
    const uchar3& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::operator*(
    float s,
    const uchar3& b
    );

__device__ __forceinline__ float4
cv::cudev::operator*(
    const uchar4& a,
    float s
    );

__device__ __forceinline__ double1
cv::cudev::operator*(
    const uchar1& a,
    double s
    );

__device__ __forceinline__ double1
cv::cudev::operator*(
    double s,
    const uchar1& b
    );

__device__ __forceinline__ double2
cv::cudev::operator*(
    const uchar2& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::operator*(
    const uchar3& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::operator*(
    double s,
    const uchar3& b
    );

__device__ __forceinline__ double4
cv::cudev::operator*(
    const uchar4& a,
    double s
    );

__device__ __forceinline__ double4
cv::cudev::operator*(
    double s,
    const uchar4& b
    );

__device__ __forceinline__ double2
cv::cudev::operator*(
    double s,
    const uchar2& b
    );

__device__ __forceinline__ int1
cv::cudev::operator*(
    const char1& a,
    int s
    );

__device__ __forceinline__ int1
cv::cudev::operator*(
    int s,
    const char1& b
    );

__device__ __forceinline__ int2
cv::cudev::operator*(
    const char2& a,
    int s
    );

__device__ __forceinline__ int3
cv::cudev::operator*(
    const char3& a,
    int s
    );

__device__ __forceinline__ int3
cv::cudev::operator*(
    int s,
    const char3& b
    );

__device__ __forceinline__ int4
cv::cudev::operator*(
    const char4& a,
    int s
    );

__device__ __forceinline__ int2
cv::cudev::operator*(
    int s,
    const char2& b
    );

__device__ __forceinline__ int4
cv::cudev::operator*(
    int s,
    const char4& b
    );

__device__ __forceinline__ float1
cv::cudev::operator*(
    const char1& a,
    float s
    );

__device__ __forceinline__ float1
cv::cudev::operator*(
    float s,
    const char1& b
    );

__device__ __forceinline__ float2
cv::cudev::operator*(
    const char2& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::operator*(
    const char3& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::operator*(
    float s,
    const char3& b
    );

__device__ __forceinline__ float4
cv::cudev::operator*(
    const char4& a,
    float s
    );

__device__ __forceinline__ float4
cv::cudev::operator*(
    float s,
    const char4& b
    );

__device__ __forceinline__ float2
cv::cudev::operator*(
    float s,
    const char2& b
    );

__device__ __forceinline__ double1
cv::cudev::operator*(
    const char1& a,
    double s
    );

__device__ __forceinline__ double1
cv::cudev::operator*(
    double s,
    const char1& b
    );

__device__ __forceinline__ double2
cv::cudev::operator*(
    const char2& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::operator*(
    const char3& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::operator*(
    double s,
    const char3& b
    );

__device__ __forceinline__ double4
cv::cudev::operator*(
    const char4& a,
    double s
    );

__device__ __forceinline__ double2
cv::cudev::operator*(
    double s,
    const char2& b
    );

__device__ __forceinline__ double4
cv::cudev::operator*(
    double s,
    const char4& b
    );

__device__ __forceinline__ int1
cv::cudev::operator*(
    const ushort1& a,
    int s
    );

__device__ __forceinline__ int1
cv::cudev::operator*(
    int s,
    const ushort1& b
    );

__device__ __forceinline__ int2
cv::cudev::operator*(
    const ushort2& a,
    int s
    );

__device__ __forceinline__ int3
cv::cudev::operator*(
    const ushort3& a,
    int s
    );

__device__ __forceinline__ int3
cv::cudev::operator*(
    int s,
    const ushort3& b
    );

__device__ __forceinline__ int4
cv::cudev::operator*(
    const ushort4& a,
    int s
    );

__device__ __forceinline__ int4
cv::cudev::operator*(
    int s,
    const ushort4& b
    );

__device__ __forceinline__ int2
cv::cudev::operator*(
    int s,
    const ushort2& b
    );

__device__ __forceinline__ float1
cv::cudev::operator*(
    const ushort1& a,
    float s
    );

__device__ __forceinline__ float1
cv::cudev::operator*(
    float s,
    const ushort1& b
    );

__device__ __forceinline__ float2
cv::cudev::operator*(
    const ushort2& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::operator*(
    const ushort3& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::operator*(
    float s,
    const ushort3& b
    );

__device__ __forceinline__ float4
cv::cudev::operator*(
    const ushort4& a,
    float s
    );

__device__ __forceinline__ float2
cv::cudev::operator*(
    float s,
    const ushort2& b
    );

__device__ __forceinline__ float4
cv::cudev::operator*(
    float s,
    const ushort4& b
    );

__device__ __forceinline__ double1
cv::cudev::operator*(
    const ushort1& a,
    double s
    );

__device__ __forceinline__ double1
cv::cudev::operator*(
    double s,
    const ushort1& b
    );

__device__ __forceinline__ double2
cv::cudev::operator*(
    const ushort2& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::operator*(
    const ushort3& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::operator*(
    double s,
    const ushort3& b
    );

__device__ __forceinline__ double4
cv::cudev::operator*(
    const ushort4& a,
    double s
    );

__device__ __forceinline__ double4
cv::cudev::operator*(
    double s,
    const ushort4& b
    );

__device__ __forceinline__ double2
cv::cudev::operator*(
    double s,
    const ushort2& b
    );

__device__ __forceinline__ int1
cv::cudev::operator*(
    const short1& a,
    int s
    );

__device__ __forceinline__ int1
cv::cudev::operator*(
    int s,
    const short1& b
    );

__device__ __forceinline__ int2
cv::cudev::operator*(
    const short2& a,
    int s
    );

__device__ __forceinline__ int3
cv::cudev::operator*(
    const short3& a,
    int s
    );

__device__ __forceinline__ int3
cv::cudev::operator*(
    int s,
    const short3& b
    );

__device__ __forceinline__ int4
cv::cudev::operator*(
    const short4& a,
    int s
    );

__device__ __forceinline__ int2
cv::cudev::operator*(
    int s,
    const short2& b
    );

__device__ __forceinline__ int4
cv::cudev::operator*(
    int s,
    const short4& b
    );

__device__ __forceinline__ float1
cv::cudev::operator*(
    const short1& a,
    float s
    );

__device__ __forceinline__ float1
cv::cudev::operator*(
    float s,
    const short1& b
    );

__device__ __forceinline__ float2
cv::cudev::operator*(
    const short2& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::operator*(
    const short3& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::operator*(
    float s,
    const short3& b
    );

__device__ __forceinline__ float4
cv::cudev::operator*(
    const short4& a,
    float s
    );

__device__ __forceinline__ float4
cv::cudev::operator*(
    float s,
    const short4& b
    );

__device__ __forceinline__ float2
cv::cudev::operator*(
    float s,
    const short2& b
    );

__device__ __forceinline__ double2
cv::cudev::operator*(
    double s,
    const short2& b
    );

__device__ __forceinline__ double1
cv::cudev::operator*(
    const short1& a,
    double s
    );

__device__ __forceinline__ double1
cv::cudev::operator*(
    double s,
    const short1& b
    );

__device__ __forceinline__ double2
cv::cudev::operator*(
    const short2& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::operator*(
    const short3& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::operator*(
    double s,
    const short3& b
    );

__device__ __forceinline__ double4
cv::cudev::operator*(
    const short4& a,
    double s
    );

__device__ __forceinline__ double4
cv::cudev::operator*(
    double s,
    const short4& b
    );

__device__ __forceinline__ int1
cv::cudev::operator*(
    const int1& a,
    int s
    );

__device__ __forceinline__ int1
cv::cudev::operator*(
    int s,
    const int1& b
    );

__device__ __forceinline__ int2
cv::cudev::operator*(
    const int2& a,
    int s
    );

__device__ __forceinline__ int3
cv::cudev::operator*(
    const int3& a,
    int s
    );

__device__ __forceinline__ int3
cv::cudev::operator*(
    int s,
    const int3& b
    );

__device__ __forceinline__ int4
cv::cudev::operator*(
    const int4& a,
    int s
    );

__device__ __forceinline__ int4
cv::cudev::operator*(
    int s,
    const int4& b
    );

__device__ __forceinline__ int2
cv::cudev::operator*(
    int s,
    const int2& b
    );

__device__ __forceinline__ float1
cv::cudev::operator*(
    const int1& a,
    float s
    );

__device__ __forceinline__ float1
cv::cudev::operator*(
    float s,
    const int1& b
    );

__device__ __forceinline__ float2
cv::cudev::operator*(
    const int2& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::operator*(
    const int3& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::operator*(
    float s,
    const int3& b
    );

__device__ __forceinline__ float4
cv::cudev::operator*(
    const int4& a,
    float s
    );

__device__ __forceinline__ float4
cv::cudev::operator*(
    float s,
    const int4& b
    );

__device__ __forceinline__ float2
cv::cudev::operator*(
    float s,
    const int2& b
    );

__device__ __forceinline__ double1
cv::cudev::operator*(
    const int1& a,
    double s
    );

__device__ __forceinline__ double1
cv::cudev::operator*(
    double s,
    const int1& b
    );

__device__ __forceinline__ double2
cv::cudev::operator*(
    const int2& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::operator*(
    const int3& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::operator*(
    double s,
    const int3& b
    );

__device__ __forceinline__ double4
cv::cudev::operator*(
    const int4& a,
    double s
    );

__device__ __forceinline__ double2
cv::cudev::operator*(
    double s,
    const int2& b
    );

__device__ __forceinline__ double4
cv::cudev::operator*(
    double s,
    const int4& b
    );

__device__ __forceinline__ uint1
cv::cudev::operator*(
    const uint1& a,
    uint s
    );

__device__ __forceinline__ uint1
cv::cudev::operator*(
    uint s,
    const uint1& b
    );

__device__ __forceinline__ uint2
cv::cudev::operator*(
    const uint2& a,
    uint s
    );

__device__ __forceinline__ uint3
cv::cudev::operator*(
    const uint3& a,
    uint s
    );

__device__ __forceinline__ uint3
cv::cudev::operator*(
    uint s,
    const uint3& b
    );

__device__ __forceinline__ uint4
cv::cudev::operator*(
    const uint4& a,
    uint s
    );

__device__ __forceinline__ uint2
cv::cudev::operator*(
    uint s,
    const uint2& b
    );

__device__ __forceinline__ uint4
cv::cudev::operator*(
    uint s,
    const uint4& b
    );

__device__ __forceinline__ float4
cv::cudev::operator*(
    float s,
    const uint4& b
    );

__device__ __forceinline__ float1
cv::cudev::operator*(
    const uint1& a,
    float s
    );

__device__ __forceinline__ float1
cv::cudev::operator*(
    float s,
    const uint1& b
    );

__device__ __forceinline__ float2
cv::cudev::operator*(
    const uint2& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::operator*(
    const uint3& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::operator*(
    float s,
    const uint3& b
    );

__device__ __forceinline__ float4
cv::cudev::operator*(
    const uint4& a,
    float s
    );

__device__ __forceinline__ float2
cv::cudev::operator*(
    float s,
    const uint2& b
    );

__device__ __forceinline__ double4
cv::cudev::operator*(
    double s,
    const uint4& b
    );

__device__ __forceinline__ double2
cv::cudev::operator*(
    double s,
    const uint2& b
    );

__device__ __forceinline__ double1
cv::cudev::operator*(
    const uint1& a,
    double s
    );

__device__ __forceinline__ double1
cv::cudev::operator*(
    double s,
    const uint1& b
    );

__device__ __forceinline__ double2
cv::cudev::operator*(
    const uint2& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::operator*(
    const uint3& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::operator*(
    double s,
    const uint3& b
    );

__device__ __forceinline__ double4
cv::cudev::operator*(
    const uint4& a,
    double s
    );

__device__ __forceinline__ float4
cv::cudev::operator*(
    float s,
    const float4& b
    );

__device__ __forceinline__ float2
cv::cudev::operator*(
    float s,
    const float2& b
    );

__device__ __forceinline__ float1
cv::cudev::operator*(
    const float1& a,
    float s
    );

__device__ __forceinline__ float1
cv::cudev::operator*(
    float s,
    const float1& b
    );

__device__ __forceinline__ float2
cv::cudev::operator*(
    const float2& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::operator*(
    const float3& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::operator*(
    float s,
    const float3& b
    );

__device__ __forceinline__ float4
cv::cudev::operator*(
    const float4& a,
    float s
    );

__device__ __forceinline__ double4
cv::cudev::operator*(
    double s,
    const float4& b
    );

__device__ __forceinline__ double2
cv::cudev::operator*(
    double s,
    const float2& b
    );

__device__ __forceinline__ double1
cv::cudev::operator*(
    const float1& a,
    double s
    );

__device__ __forceinline__ double1
cv::cudev::operator*(
    double s,
    const float1& b
    );

__device__ __forceinline__ double2
cv::cudev::operator*(
    const float2& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::operator*(
    const float3& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::operator*(
    double s,
    const float3& b
    );

__device__ __forceinline__ double4
cv::cudev::operator*(
    const float4& a,
    double s
    );

__device__ __forceinline__ double1
cv::cudev::operator*(
    const double1& a,
    double s
    );

__device__ __forceinline__ double1
cv::cudev::operator*(
    double s,
    const double1& b
    );

__device__ __forceinline__ double2
cv::cudev::operator*(
    const double2& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::operator*(
    const double3& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::operator*(
    double s,
    const double3& b
    );

__device__ __forceinline__ double4
cv::cudev::operator*(
    const double4& a,
    double s
    );

__device__ __forceinline__ double2
cv::cudev::operator*(
    double s,
    const double2& b
    );

__device__ __forceinline__ double4
cv::cudev::operator*(
    double s,
    const double4& b
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, Binder2nd<plus<T>>>>
cv::cudev::operator+(
    const GlobPtrSz<T>& src,
    T val
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, Binder1st<plus<T>>>>
cv::cudev::operator+(
    T val,
    const GlobPtrSz<T>& src
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, typename PtrTraits<Texture<T>>::ptr_type, plus<T>>>
cv::cudev::operator+(
    const Texture<T>& src1,
    const Texture<T>& src2
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, typename PtrTraits<Body>::ptr_type, plus<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator+(
    const Texture<T>& src1,
    const Expr<Body>& src2
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, typename PtrTraits<Texture<T>>::ptr_type, plus<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator+(
    const Expr<Body>& src1,
    const Texture<T>& src2
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, Binder2nd<plus<T>>>>
cv::cudev::operator+(
    const Texture<T>& src,
    T val
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, typename PtrTraits<GpuMat_<T>>::ptr_type, plus<T>>>
cv::cudev::operator+(
    const GpuMat_<T>& src1,
    const GpuMat_<T>& src2
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, Binder1st<plus<T>>>>
cv::cudev::operator+(
    T val,
    const Texture<T>& src
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, typename PtrTraits<GlobPtrSz<T>>::ptr_type, plus<T>>>
cv::cudev::operator+(
    const GlobPtrSz<T>& src1,
    const GlobPtrSz<T>& src2
    );

template <
    class Body1,
    class Body2
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Body1>::ptr_type, typename PtrTraits<Body2>::ptr_type, plus<typename LargerType<typename PtrTraits<Body1>::value_type, typename PtrTraits<Body2>::value_type>::type>>>
cv::cudev::operator+(
    const Expr<Body1>& a,
    const Expr<Body2>& b
    );

template <class Body>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, Binder1st<plus<typename Body::value_type>>>>
cv::cudev::operator+(
    typename Body::value_type val,
    const Expr<Body>& a
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, typename PtrTraits<GpuMat_<T>>::ptr_type, plus<T>>>
cv::cudev::operator+(
    const GlobPtrSz<T>& src1,
    const GpuMat_<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, typename PtrTraits<Texture<T>>::ptr_type, plus<T>>>
cv::cudev::operator+(
    const GpuMat_<T>& src1,
    const Texture<T>& src2
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, typename PtrTraits<Body>::ptr_type, plus<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator+(
    const GpuMat_<T>& src1,
    const Expr<Body>& src2
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, typename PtrTraits<GpuMat_<T>>::ptr_type, plus<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator+(
    const Expr<Body>& src1,
    const GpuMat_<T>& src2
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, Binder2nd<plus<T>>>>
cv::cudev::operator+(
    const GpuMat_<T>& src,
    T val
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, typename PtrTraits<GlobPtrSz<T>>::ptr_type, plus<T>>>
cv::cudev::operator+(
    const GpuMat_<T>& src1,
    const GlobPtrSz<T>& src2
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, Binder1st<plus<T>>>>
cv::cudev::operator+(
    T val,
    const GpuMat_<T>& src
    );

template <class Body>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, Binder2nd<plus<typename Body::value_type>>>>
cv::cudev::operator+(
    const Expr<Body>& a,
    typename Body::value_type val
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, typename PtrTraits<Texture<T>>::ptr_type, plus<T>>>
cv::cudev::operator+(
    const GlobPtrSz<T>& src1,
    const Texture<T>& src2
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, typename PtrTraits<GlobPtrSz<T>>::ptr_type, plus<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator+(
    const Expr<Body>& src1,
    const GlobPtrSz<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, typename PtrTraits<GpuMat_<T>>::ptr_type, plus<T>>>
cv::cudev::operator+(
    const Texture<T>& src1,
    const GpuMat_<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, typename PtrTraits<GlobPtrSz<T>>::ptr_type, plus<T>>>
cv::cudev::operator+(
    const Texture<T>& src1,
    const GlobPtrSz<T>& src2
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, typename PtrTraits<Body>::ptr_type, plus<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator+(
    const GlobPtrSz<T>& src1,
    const Expr<Body>& src2
    );

__device__ __forceinline__ int1
cv::cudev::operator+(
    const uchar1& a,
    const uchar1& b
    );

__device__ __forceinline__ int2
cv::cudev::operator+(
    const uchar2& a,
    const uchar2& b
    );

__device__ __forceinline__ int3
cv::cudev::operator+(
    const uchar3& a,
    const uchar3& b
    );

__device__ __forceinline__ int4
cv::cudev::operator+(
    const uchar4& a,
    const uchar4& b
    );

__device__ __forceinline__ int1
cv::cudev::operator+(
    const char1& a,
    const char1& b
    );

__device__ __forceinline__ int2
cv::cudev::operator+(
    const char2& a,
    const char2& b
    );

__device__ __forceinline__ int3
cv::cudev::operator+(
    const char3& a,
    const char3& b
    );

__device__ __forceinline__ int4
cv::cudev::operator+(
    const char4& a,
    const char4& b
    );

__device__ __forceinline__ int1
cv::cudev::operator+(
    const ushort1& a,
    const ushort1& b
    );

__device__ __forceinline__ int2
cv::cudev::operator+(
    const ushort2& a,
    const ushort2& b
    );

__device__ __forceinline__ int3
cv::cudev::operator+(
    const ushort3& a,
    const ushort3& b
    );

__device__ __forceinline__ int4
cv::cudev::operator+(
    const ushort4& a,
    const ushort4& b
    );

__device__ __forceinline__ int1
cv::cudev::operator+(
    const short1& a,
    const short1& b
    );

__device__ __forceinline__ int2
cv::cudev::operator+(
    const short2& a,
    const short2& b
    );

__device__ __forceinline__ int3
cv::cudev::operator+(
    const short3& a,
    const short3& b
    );

__device__ __forceinline__ int4
cv::cudev::operator+(
    const short4& a,
    const short4& b
    );

__device__ __forceinline__ int4
cv::cudev::operator+(
    const int4& a,
    const int4& b
    );

__device__ __forceinline__ int1
cv::cudev::operator+(
    const int1& a,
    const int1& b
    );

__device__ __forceinline__ int2
cv::cudev::operator+(
    const int2& a,
    const int2& b
    );

__device__ __forceinline__ int3
cv::cudev::operator+(
    const int3& a,
    const int3& b
    );

__device__ __forceinline__ uint3
cv::cudev::operator+(
    const uint3& a,
    const uint3& b
    );

__device__ __forceinline__ uint2
cv::cudev::operator+(
    const uint2& a,
    const uint2& b
    );

__device__ __forceinline__ uint1
cv::cudev::operator+(
    const uint1& a,
    const uint1& b
    );

__device__ __forceinline__ uint4
cv::cudev::operator+(
    const uint4& a,
    const uint4& b
    );

__device__ __forceinline__ float3
cv::cudev::operator+(
    const float3& a,
    const float3& b
    );

__device__ __forceinline__ float2
cv::cudev::operator+(
    const float2& a,
    const float2& b
    );

__device__ __forceinline__ float4
cv::cudev::operator+(
    const float4& a,
    const float4& b
    );

__device__ __forceinline__ float1
cv::cudev::operator+(
    const float1& a,
    const float1& b
    );

__device__ __forceinline__ double4
cv::cudev::operator+(
    const double4& a,
    const double4& b
    );

__device__ __forceinline__ double3
cv::cudev::operator+(
    const double3& a,
    const double3& b
    );

__device__ __forceinline__ double2
cv::cudev::operator+(
    const double2& a,
    const double2& b
    );

__device__ __forceinline__ double1
cv::cudev::operator+(
    const double1& a,
    const double1& b
    );

__device__ __forceinline__ int1
cv::cudev::operator+(
    const uchar1& a,
    int s
    );

__device__ __forceinline__ int1
cv::cudev::operator+(
    int s,
    const uchar1& b
    );

__device__ __forceinline__ int2
cv::cudev::operator+(
    const uchar2& a,
    int s
    );

__device__ __forceinline__ int2
cv::cudev::operator+(
    int s,
    const uchar2& b
    );

__device__ __forceinline__ int3
cv::cudev::operator+(
    const uchar3& a,
    int s
    );

__device__ __forceinline__ int3
cv::cudev::operator+(
    int s,
    const uchar3& b
    );

__device__ __forceinline__ int4
cv::cudev::operator+(
    const uchar4& a,
    int s
    );

__device__ __forceinline__ int4
cv::cudev::operator+(
    int s,
    const uchar4& b
    );

__device__ __forceinline__ float1
cv::cudev::operator+(
    const uchar1& a,
    float s
    );

__device__ __forceinline__ float1
cv::cudev::operator+(
    float s,
    const uchar1& b
    );

__device__ __forceinline__ float2
cv::cudev::operator+(
    const uchar2& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::operator+(
    const uchar3& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::operator+(
    float s,
    const uchar3& b
    );

__device__ __forceinline__ float4
cv::cudev::operator+(
    const uchar4& a,
    float s
    );

__device__ __forceinline__ float2
cv::cudev::operator+(
    float s,
    const uchar2& b
    );

__device__ __forceinline__ float4
cv::cudev::operator+(
    float s,
    const uchar4& b
    );

__device__ __forceinline__ double1
cv::cudev::operator+(
    const uchar1& a,
    double s
    );

__device__ __forceinline__ double1
cv::cudev::operator+(
    double s,
    const uchar1& b
    );

__device__ __forceinline__ double2
cv::cudev::operator+(
    const uchar2& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::operator+(
    const uchar3& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::operator+(
    double s,
    const uchar3& b
    );

__device__ __forceinline__ double4
cv::cudev::operator+(
    const uchar4& a,
    double s
    );

__device__ __forceinline__ double4
cv::cudev::operator+(
    double s,
    const uchar4& b
    );

__device__ __forceinline__ double2
cv::cudev::operator+(
    double s,
    const uchar2& b
    );

__device__ __forceinline__ int1
cv::cudev::operator+(
    const char1& a,
    int s
    );

__device__ __forceinline__ int1
cv::cudev::operator+(
    int s,
    const char1& b
    );

__device__ __forceinline__ int2
cv::cudev::operator+(
    const char2& a,
    int s
    );

__device__ __forceinline__ int3
cv::cudev::operator+(
    const char3& a,
    int s
    );

__device__ __forceinline__ int3
cv::cudev::operator+(
    int s,
    const char3& b
    );

__device__ __forceinline__ int4
cv::cudev::operator+(
    const char4& a,
    int s
    );

__device__ __forceinline__ int2
cv::cudev::operator+(
    int s,
    const char2& b
    );

__device__ __forceinline__ int4
cv::cudev::operator+(
    int s,
    const char4& b
    );

__device__ __forceinline__ float2
cv::cudev::operator+(
    float s,
    const char2& b
    );

__device__ __forceinline__ float1
cv::cudev::operator+(
    const char1& a,
    float s
    );

__device__ __forceinline__ float1
cv::cudev::operator+(
    float s,
    const char1& b
    );

__device__ __forceinline__ float2
cv::cudev::operator+(
    const char2& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::operator+(
    const char3& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::operator+(
    float s,
    const char3& b
    );

__device__ __forceinline__ float4
cv::cudev::operator+(
    const char4& a,
    float s
    );

__device__ __forceinline__ float4
cv::cudev::operator+(
    float s,
    const char4& b
    );

__device__ __forceinline__ double1
cv::cudev::operator+(
    const char1& a,
    double s
    );

__device__ __forceinline__ double1
cv::cudev::operator+(
    double s,
    const char1& b
    );

__device__ __forceinline__ double2
cv::cudev::operator+(
    const char2& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::operator+(
    const char3& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::operator+(
    double s,
    const char3& b
    );

__device__ __forceinline__ double4
cv::cudev::operator+(
    const char4& a,
    double s
    );

__device__ __forceinline__ double4
cv::cudev::operator+(
    double s,
    const char4& b
    );

__device__ __forceinline__ double2
cv::cudev::operator+(
    double s,
    const char2& b
    );

__device__ __forceinline__ int1
cv::cudev::operator+(
    const ushort1& a,
    int s
    );

__device__ __forceinline__ int1
cv::cudev::operator+(
    int s,
    const ushort1& b
    );

__device__ __forceinline__ int2
cv::cudev::operator+(
    const ushort2& a,
    int s
    );

__device__ __forceinline__ int3
cv::cudev::operator+(
    const ushort3& a,
    int s
    );

__device__ __forceinline__ int3
cv::cudev::operator+(
    int s,
    const ushort3& b
    );

__device__ __forceinline__ int4
cv::cudev::operator+(
    const ushort4& a,
    int s
    );

__device__ __forceinline__ int4
cv::cudev::operator+(
    int s,
    const ushort4& b
    );

__device__ __forceinline__ int2
cv::cudev::operator+(
    int s,
    const ushort2& b
    );

__device__ __forceinline__ float1
cv::cudev::operator+(
    const ushort1& a,
    float s
    );

__device__ __forceinline__ float1
cv::cudev::operator+(
    float s,
    const ushort1& b
    );

__device__ __forceinline__ float2
cv::cudev::operator+(
    const ushort2& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::operator+(
    const ushort3& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::operator+(
    float s,
    const ushort3& b
    );

__device__ __forceinline__ float4
cv::cudev::operator+(
    const ushort4& a,
    float s
    );

__device__ __forceinline__ float2
cv::cudev::operator+(
    float s,
    const ushort2& b
    );

__device__ __forceinline__ float4
cv::cudev::operator+(
    float s,
    const ushort4& b
    );

__device__ __forceinline__ double1
cv::cudev::operator+(
    const ushort1& a,
    double s
    );

__device__ __forceinline__ double1
cv::cudev::operator+(
    double s,
    const ushort1& b
    );

__device__ __forceinline__ double2
cv::cudev::operator+(
    const ushort2& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::operator+(
    const ushort3& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::operator+(
    double s,
    const ushort3& b
    );

__device__ __forceinline__ double4
cv::cudev::operator+(
    const ushort4& a,
    double s
    );

__device__ __forceinline__ double4
cv::cudev::operator+(
    double s,
    const ushort4& b
    );

__device__ __forceinline__ double2
cv::cudev::operator+(
    double s,
    const ushort2& b
    );

__device__ __forceinline__ int1
cv::cudev::operator+(
    const short1& a,
    int s
    );

__device__ __forceinline__ int1
cv::cudev::operator+(
    int s,
    const short1& b
    );

__device__ __forceinline__ int2
cv::cudev::operator+(
    const short2& a,
    int s
    );

__device__ __forceinline__ int3
cv::cudev::operator+(
    const short3& a,
    int s
    );

__device__ __forceinline__ int3
cv::cudev::operator+(
    int s,
    const short3& b
    );

__device__ __forceinline__ int4
cv::cudev::operator+(
    const short4& a,
    int s
    );

__device__ __forceinline__ int4
cv::cudev::operator+(
    int s,
    const short4& b
    );

__device__ __forceinline__ int2
cv::cudev::operator+(
    int s,
    const short2& b
    );

__device__ __forceinline__ float1
cv::cudev::operator+(
    const short1& a,
    float s
    );

__device__ __forceinline__ float1
cv::cudev::operator+(
    float s,
    const short1& b
    );

__device__ __forceinline__ float2
cv::cudev::operator+(
    const short2& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::operator+(
    const short3& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::operator+(
    float s,
    const short3& b
    );

__device__ __forceinline__ float4
cv::cudev::operator+(
    const short4& a,
    float s
    );

__device__ __forceinline__ float4
cv::cudev::operator+(
    float s,
    const short4& b
    );

__device__ __forceinline__ float2
cv::cudev::operator+(
    float s,
    const short2& b
    );

__device__ __forceinline__ double1
cv::cudev::operator+(
    const short1& a,
    double s
    );

__device__ __forceinline__ double1
cv::cudev::operator+(
    double s,
    const short1& b
    );

__device__ __forceinline__ double2
cv::cudev::operator+(
    const short2& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::operator+(
    const short3& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::operator+(
    double s,
    const short3& b
    );

__device__ __forceinline__ double4
cv::cudev::operator+(
    const short4& a,
    double s
    );

__device__ __forceinline__ double4
cv::cudev::operator+(
    double s,
    const short4& b
    );

__device__ __forceinline__ double2
cv::cudev::operator+(
    double s,
    const short2& b
    );

__device__ __forceinline__ int1
cv::cudev::operator+(
    const int1& a,
    int s
    );

__device__ __forceinline__ int1
cv::cudev::operator+(
    int s,
    const int1& b
    );

__device__ __forceinline__ int2
cv::cudev::operator+(
    const int2& a,
    int s
    );

__device__ __forceinline__ int3
cv::cudev::operator+(
    const int3& a,
    int s
    );

__device__ __forceinline__ int3
cv::cudev::operator+(
    int s,
    const int3& b
    );

__device__ __forceinline__ int4
cv::cudev::operator+(
    const int4& a,
    int s
    );

__device__ __forceinline__ int4
cv::cudev::operator+(
    int s,
    const int4& b
    );

__device__ __forceinline__ int2
cv::cudev::operator+(
    int s,
    const int2& b
    );

__device__ __forceinline__ float2
cv::cudev::operator+(
    float s,
    const int2& b
    );

__device__ __forceinline__ float1
cv::cudev::operator+(
    const int1& a,
    float s
    );

__device__ __forceinline__ float1
cv::cudev::operator+(
    float s,
    const int1& b
    );

__device__ __forceinline__ float2
cv::cudev::operator+(
    const int2& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::operator+(
    const int3& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::operator+(
    float s,
    const int3& b
    );

__device__ __forceinline__ float4
cv::cudev::operator+(
    const int4& a,
    float s
    );

__device__ __forceinline__ float4
cv::cudev::operator+(
    float s,
    const int4& b
    );

__device__ __forceinline__ double1
cv::cudev::operator+(
    const int1& a,
    double s
    );

__device__ __forceinline__ double1
cv::cudev::operator+(
    double s,
    const int1& b
    );

__device__ __forceinline__ double2
cv::cudev::operator+(
    const int2& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::operator+(
    const int3& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::operator+(
    double s,
    const int3& b
    );

__device__ __forceinline__ double4
cv::cudev::operator+(
    const int4& a,
    double s
    );

__device__ __forceinline__ double4
cv::cudev::operator+(
    double s,
    const int4& b
    );

__device__ __forceinline__ double2
cv::cudev::operator+(
    double s,
    const int2& b
    );

__device__ __forceinline__ uint1
cv::cudev::operator+(
    const uint1& a,
    uint s
    );

__device__ __forceinline__ uint1
cv::cudev::operator+(
    uint s,
    const uint1& b
    );

__device__ __forceinline__ uint2
cv::cudev::operator+(
    const uint2& a,
    uint s
    );

__device__ __forceinline__ uint3
cv::cudev::operator+(
    const uint3& a,
    uint s
    );

__device__ __forceinline__ uint3
cv::cudev::operator+(
    uint s,
    const uint3& b
    );

__device__ __forceinline__ uint4
cv::cudev::operator+(
    const uint4& a,
    uint s
    );

__device__ __forceinline__ uint4
cv::cudev::operator+(
    uint s,
    const uint4& b
    );

__device__ __forceinline__ uint2
cv::cudev::operator+(
    uint s,
    const uint2& b
    );

__device__ __forceinline__ float1
cv::cudev::operator+(
    const uint1& a,
    float s
    );

__device__ __forceinline__ float1
cv::cudev::operator+(
    float s,
    const uint1& b
    );

__device__ __forceinline__ float2
cv::cudev::operator+(
    const uint2& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::operator+(
    const uint3& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::operator+(
    float s,
    const uint3& b
    );

__device__ __forceinline__ float4
cv::cudev::operator+(
    const uint4& a,
    float s
    );

__device__ __forceinline__ float4
cv::cudev::operator+(
    float s,
    const uint4& b
    );

__device__ __forceinline__ float2
cv::cudev::operator+(
    float s,
    const uint2& b
    );

__device__ __forceinline__ double1
cv::cudev::operator+(
    const uint1& a,
    double s
    );

__device__ __forceinline__ double1
cv::cudev::operator+(
    double s,
    const uint1& b
    );

__device__ __forceinline__ double2
cv::cudev::operator+(
    const uint2& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::operator+(
    const uint3& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::operator+(
    double s,
    const uint3& b
    );

__device__ __forceinline__ double4
cv::cudev::operator+(
    const uint4& a,
    double s
    );

__device__ __forceinline__ double4
cv::cudev::operator+(
    double s,
    const uint4& b
    );

__device__ __forceinline__ double2
cv::cudev::operator+(
    double s,
    const uint2& b
    );

__device__ __forceinline__ float1
cv::cudev::operator+(
    const float1& a,
    float s
    );

__device__ __forceinline__ float1
cv::cudev::operator+(
    float s,
    const float1& b
    );

__device__ __forceinline__ float2
cv::cudev::operator+(
    const float2& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::operator+(
    const float3& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::operator+(
    float s,
    const float3& b
    );

__device__ __forceinline__ float4
cv::cudev::operator+(
    const float4& a,
    float s
    );

__device__ __forceinline__ float4
cv::cudev::operator+(
    float s,
    const float4& b
    );

__device__ __forceinline__ float2
cv::cudev::operator+(
    float s,
    const float2& b
    );

__device__ __forceinline__ double1
cv::cudev::operator+(
    const float1& a,
    double s
    );

__device__ __forceinline__ double1
cv::cudev::operator+(
    double s,
    const float1& b
    );

__device__ __forceinline__ double2
cv::cudev::operator+(
    const float2& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::operator+(
    const float3& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::operator+(
    double s,
    const float3& b
    );

__device__ __forceinline__ double4
cv::cudev::operator+(
    const float4& a,
    double s
    );

__device__ __forceinline__ double2
cv::cudev::operator+(
    double s,
    const float2& b
    );

__device__ __forceinline__ double4
cv::cudev::operator+(
    double s,
    const float4& b
    );

__device__ __forceinline__ double1
cv::cudev::operator+(
    const double1& a,
    double s
    );

__device__ __forceinline__ double1
cv::cudev::operator+(
    double s,
    const double1& b
    );

__device__ __forceinline__ double2
cv::cudev::operator+(
    const double2& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::operator+(
    const double3& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::operator+(
    double s,
    const double3& b
    );

__device__ __forceinline__ double4
cv::cudev::operator+(
    const double4& a,
    double s
    );

__device__ __forceinline__ double4
cv::cudev::operator+(
    double s,
    const double4& b
    );

__device__ __forceinline__ double2
cv::cudev::operator+(
    double s,
    const double2& b
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, negate<T>>>
cv::cudev::operator-(const GpuMat_<T>& src);

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, negate<T>>>
cv::cudev::operator-(const GlobPtrSz<T>& src);

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, negate<T>>>
cv::cudev::operator-(const Texture<T>& src);

template <class Body>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, negate<typename Body::value_type>>>
cv::cudev::operator-(const Expr<Body>& src);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, Binder2nd<minus<T>>>>
cv::cudev::operator-(
    const Texture<T>& src,
    T val
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, typename PtrTraits<Body>::ptr_type, minus<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator-(
    const Texture<T>& src1,
    const Expr<Body>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, typename PtrTraits<GpuMat_<T>>::ptr_type, minus<T>>>
cv::cudev::operator-(
    const GpuMat_<T>& src1,
    const GpuMat_<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, typename PtrTraits<GlobPtrSz<T>>::ptr_type, minus<T>>>
cv::cudev::operator-(
    const GpuMat_<T>& src1,
    const GlobPtrSz<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, typename PtrTraits<GpuMat_<T>>::ptr_type, minus<T>>>
cv::cudev::operator-(
    const GlobPtrSz<T>& src1,
    const GpuMat_<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, typename PtrTraits<GpuMat_<T>>::ptr_type, minus<T>>>
cv::cudev::operator-(
    const Texture<T>& src1,
    const GpuMat_<T>& src2
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, typename PtrTraits<Body>::ptr_type, minus<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator-(
    const GpuMat_<T>& src1,
    const Expr<Body>& src2
    );

template <
    class Body1,
    class Body2
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Body1>::ptr_type, typename PtrTraits<Body2>::ptr_type, minus<typename LargerType<typename PtrTraits<Body1>::value_type, typename PtrTraits<Body2>::value_type>::type>>>
cv::cudev::operator-(
    const Expr<Body1>& a,
    const Expr<Body2>& b
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, typename PtrTraits<GpuMat_<T>>::ptr_type, minus<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator-(
    const Expr<Body>& src1,
    const GpuMat_<T>& src2
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, Binder2nd<minus<T>>>>
cv::cudev::operator-(
    const GpuMat_<T>& src,
    T val
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, Binder1st<minus<T>>>>
cv::cudev::operator-(
    T val,
    const GlobPtrSz<T>& src
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, typename PtrTraits<Body>::ptr_type, minus<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator-(
    const GlobPtrSz<T>& src1,
    const Expr<Body>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, typename PtrTraits<GlobPtrSz<T>>::ptr_type, minus<T>>>
cv::cudev::operator-(
    const GlobPtrSz<T>& src1,
    const GlobPtrSz<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, typename PtrTraits<GlobPtrSz<T>>::ptr_type, minus<T>>>
cv::cudev::operator-(
    const Texture<T>& src1,
    const GlobPtrSz<T>& src2
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, Binder1st<minus<T>>>>
cv::cudev::operator-(
    T val,
    const GpuMat_<T>& src
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, typename PtrTraits<GlobPtrSz<T>>::ptr_type, minus<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator-(
    const Expr<Body>& src1,
    const GlobPtrSz<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, typename PtrTraits<Texture<T>>::ptr_type, minus<T>>>
cv::cudev::operator-(
    const GlobPtrSz<T>& src1,
    const Texture<T>& src2
    );

template <class Body>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, Binder2nd<minus<typename Body::value_type>>>>
cv::cudev::operator-(
    const Expr<Body>& a,
    typename Body::value_type val
    );

template <class Body>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, Binder1st<minus<typename Body::value_type>>>>
cv::cudev::operator-(
    typename Body::value_type val,
    const Expr<Body>& a
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, Binder2nd<minus<T>>>>
cv::cudev::operator-(
    const GlobPtrSz<T>& src,
    T val
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, typename PtrTraits<Texture<T>>::ptr_type, minus<T>>>
cv::cudev::operator-(
    const Texture<T>& src1,
    const Texture<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, typename PtrTraits<Texture<T>>::ptr_type, minus<T>>>
cv::cudev::operator-(
    const GpuMat_<T>& src1,
    const Texture<T>& src2
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, typename PtrTraits<Texture<T>>::ptr_type, minus<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator-(
    const Expr<Body>& src1,
    const Texture<T>& src2
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, Binder1st<minus<T>>>>
cv::cudev::operator-(
    T val,
    const Texture<T>& src
    );

__device__ __forceinline__ int3
cv::cudev::operator-(
    const uchar3& a,
    const uchar3& b
    );

__device__ __forceinline__ int4
cv::cudev::operator-(
    const uchar4& a,
    const uchar4& b
    );

__device__ __forceinline__ int1
cv::cudev::operator-(
    const uchar1& a,
    const uchar1& b
    );

__device__ __forceinline__ int2
cv::cudev::operator-(
    const uchar2& a,
    const uchar2& b
    );

__device__ __forceinline__ int4
cv::cudev::operator-(
    const char4& a,
    const char4& b
    );

__device__ __forceinline__ int2
cv::cudev::operator-(
    const char2& a,
    const char2& b
    );

__device__ __forceinline__ int3
cv::cudev::operator-(
    const char3& a,
    const char3& b
    );

__device__ __forceinline__ int1
cv::cudev::operator-(
    const char1& a,
    const char1& b
    );

__device__ __forceinline__ int3
cv::cudev::operator-(
    const ushort3& a,
    const ushort3& b
    );

__device__ __forceinline__ int4
cv::cudev::operator-(
    const ushort4& a,
    const ushort4& b
    );

__device__ __forceinline__ int2
cv::cudev::operator-(
    const ushort2& a,
    const ushort2& b
    );

__device__ __forceinline__ int1
cv::cudev::operator-(
    const ushort1& a,
    const ushort1& b
    );

__device__ __forceinline__ int3
cv::cudev::operator-(
    const short3& a,
    const short3& b
    );

__device__ __forceinline__ int4
cv::cudev::operator-(
    const short4& a,
    const short4& b
    );

__device__ __forceinline__ int2
cv::cudev::operator-(
    const short2& a,
    const short2& b
    );

__device__ __forceinline__ int1
cv::cudev::operator-(
    const short1& a,
    const short1& b
    );

__device__ __forceinline__ int1
cv::cudev::operator-(
    const int1& a,
    const int1& b
    );

__device__ __forceinline__ int2
cv::cudev::operator-(
    const int2& a,
    const int2& b
    );

__device__ __forceinline__ int4
cv::cudev::operator-(
    const int4& a,
    const int4& b
    );

__device__ __forceinline__ int3
cv::cudev::operator-(
    const int3& a,
    const int3& b
    );

__device__ __forceinline__ uint4
cv::cudev::operator-(
    const uint4& a,
    const uint4& b
    );

__device__ __forceinline__ uint1
cv::cudev::operator-(
    const uint1& a,
    const uint1& b
    );

__device__ __forceinline__ uint3
cv::cudev::operator-(
    const uint3& a,
    const uint3& b
    );

__device__ __forceinline__ uint2
cv::cudev::operator-(
    const uint2& a,
    const uint2& b
    );

__device__ __forceinline__ float3
cv::cudev::operator-(
    const float3& a,
    const float3& b
    );

__device__ __forceinline__ float2
cv::cudev::operator-(
    const float2& a,
    const float2& b
    );

__device__ __forceinline__ float4
cv::cudev::operator-(
    const float4& a,
    const float4& b
    );

__device__ __forceinline__ float1
cv::cudev::operator-(
    const float1& a,
    const float1& b
    );

__device__ __forceinline__ double4
cv::cudev::operator-(
    const double4& a,
    const double4& b
    );

__device__ __forceinline__ double2
cv::cudev::operator-(
    const double2& a,
    const double2& b
    );

__device__ __forceinline__ double3
cv::cudev::operator-(
    const double3& a,
    const double3& b
    );

__device__ __forceinline__ double1
cv::cudev::operator-(
    const double1& a,
    const double1& b
    );

__device__ __forceinline__ int1
cv::cudev::operator-(
    const uchar1& a,
    int s
    );

__device__ __forceinline__ int1
cv::cudev::operator-(
    int s,
    const uchar1& b
    );

__device__ __forceinline__ int2
cv::cudev::operator-(
    const uchar2& a,
    int s
    );

__device__ __forceinline__ int3
cv::cudev::operator-(
    const uchar3& a,
    int s
    );

__device__ __forceinline__ int3
cv::cudev::operator-(
    int s,
    const uchar3& b
    );

__device__ __forceinline__ int4
cv::cudev::operator-(
    const uchar4& a,
    int s
    );

__device__ __forceinline__ int4
cv::cudev::operator-(
    int s,
    const uchar4& b
    );

__device__ __forceinline__ int2
cv::cudev::operator-(
    int s,
    const uchar2& b
    );

__device__ __forceinline__ float1
cv::cudev::operator-(
    const uchar1& a,
    float s
    );

__device__ __forceinline__ float1
cv::cudev::operator-(
    float s,
    const uchar1& b
    );

__device__ __forceinline__ float2
cv::cudev::operator-(
    const uchar2& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::operator-(
    const uchar3& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::operator-(
    float s,
    const uchar3& b
    );

__device__ __forceinline__ float4
cv::cudev::operator-(
    const uchar4& a,
    float s
    );

__device__ __forceinline__ float4
cv::cudev::operator-(
    float s,
    const uchar4& b
    );

__device__ __forceinline__ float2
cv::cudev::operator-(
    float s,
    const uchar2& b
    );

__device__ __forceinline__ double4
cv::cudev::operator-(
    double s,
    const uchar4& b
    );

__device__ __forceinline__ double1
cv::cudev::operator-(
    const uchar1& a,
    double s
    );

__device__ __forceinline__ double1
cv::cudev::operator-(
    double s,
    const uchar1& b
    );

__device__ __forceinline__ double2
cv::cudev::operator-(
    const uchar2& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::operator-(
    const uchar3& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::operator-(
    double s,
    const uchar3& b
    );

__device__ __forceinline__ double4
cv::cudev::operator-(
    const uchar4& a,
    double s
    );

__device__ __forceinline__ double2
cv::cudev::operator-(
    double s,
    const uchar2& b
    );

__device__ __forceinline__ int2
cv::cudev::operator-(
    int s,
    const char2& b
    );

__device__ __forceinline__ int1
cv::cudev::operator-(
    const char1& a,
    int s
    );

__device__ __forceinline__ int1
cv::cudev::operator-(
    int s,
    const char1& b
    );

__device__ __forceinline__ int2
cv::cudev::operator-(
    const char2& a,
    int s
    );

__device__ __forceinline__ int3
cv::cudev::operator-(
    const char3& a,
    int s
    );

__device__ __forceinline__ int3
cv::cudev::operator-(
    int s,
    const char3& b
    );

__device__ __forceinline__ int4
cv::cudev::operator-(
    const char4& a,
    int s
    );

__device__ __forceinline__ int4
cv::cudev::operator-(
    int s,
    const char4& b
    );

__device__ __forceinline__ float1
cv::cudev::operator-(
    const char1& a,
    float s
    );

__device__ __forceinline__ float1
cv::cudev::operator-(
    float s,
    const char1& b
    );

__device__ __forceinline__ float2
cv::cudev::operator-(
    const char2& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::operator-(
    const char3& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::operator-(
    float s,
    const char3& b
    );

__device__ __forceinline__ float4
cv::cudev::operator-(
    const char4& a,
    float s
    );

__device__ __forceinline__ float4
cv::cudev::operator-(
    float s,
    const char4& b
    );

__device__ __forceinline__ float2
cv::cudev::operator-(
    float s,
    const char2& b
    );

__device__ __forceinline__ double1
cv::cudev::operator-(
    const char1& a,
    double s
    );

__device__ __forceinline__ double1
cv::cudev::operator-(
    double s,
    const char1& b
    );

__device__ __forceinline__ double2
cv::cudev::operator-(
    const char2& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::operator-(
    const char3& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::operator-(
    double s,
    const char3& b
    );

__device__ __forceinline__ double4
cv::cudev::operator-(
    const char4& a,
    double s
    );

__device__ __forceinline__ double4
cv::cudev::operator-(
    double s,
    const char4& b
    );

__device__ __forceinline__ double2
cv::cudev::operator-(
    double s,
    const char2& b
    );

__device__ __forceinline__ int4
cv::cudev::operator-(
    int s,
    const ushort4& b
    );

__device__ __forceinline__ int2
cv::cudev::operator-(
    int s,
    const ushort2& b
    );

__device__ __forceinline__ int1
cv::cudev::operator-(
    const ushort1& a,
    int s
    );

__device__ __forceinline__ int1
cv::cudev::operator-(
    int s,
    const ushort1& b
    );

__device__ __forceinline__ int2
cv::cudev::operator-(
    const ushort2& a,
    int s
    );

__device__ __forceinline__ int3
cv::cudev::operator-(
    const ushort3& a,
    int s
    );

__device__ __forceinline__ int3
cv::cudev::operator-(
    int s,
    const ushort3& b
    );

__device__ __forceinline__ int4
cv::cudev::operator-(
    const ushort4& a,
    int s
    );

__device__ __forceinline__ float2
cv::cudev::operator-(
    float s,
    const ushort2& b
    );

__device__ __forceinline__ float1
cv::cudev::operator-(
    const ushort1& a,
    float s
    );

__device__ __forceinline__ float1
cv::cudev::operator-(
    float s,
    const ushort1& b
    );

__device__ __forceinline__ float2
cv::cudev::operator-(
    const ushort2& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::operator-(
    const ushort3& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::operator-(
    float s,
    const ushort3& b
    );

__device__ __forceinline__ float4
cv::cudev::operator-(
    const ushort4& a,
    float s
    );

__device__ __forceinline__ float4
cv::cudev::operator-(
    float s,
    const ushort4& b
    );

__device__ __forceinline__ double2
cv::cudev::operator-(
    double s,
    const ushort2& b
    );

__device__ __forceinline__ double1
cv::cudev::operator-(
    const ushort1& a,
    double s
    );

__device__ __forceinline__ double1
cv::cudev::operator-(
    double s,
    const ushort1& b
    );

__device__ __forceinline__ double2
cv::cudev::operator-(
    const ushort2& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::operator-(
    const ushort3& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::operator-(
    double s,
    const ushort3& b
    );

__device__ __forceinline__ double4
cv::cudev::operator-(
    const ushort4& a,
    double s
    );

__device__ __forceinline__ double4
cv::cudev::operator-(
    double s,
    const ushort4& b
    );

__device__ __forceinline__ int1
cv::cudev::operator-(
    const short1& a,
    int s
    );

__device__ __forceinline__ int1
cv::cudev::operator-(
    int s,
    const short1& b
    );

__device__ __forceinline__ int2
cv::cudev::operator-(
    const short2& a,
    int s
    );

__device__ __forceinline__ int3
cv::cudev::operator-(
    const short3& a,
    int s
    );

__device__ __forceinline__ int3
cv::cudev::operator-(
    int s,
    const short3& b
    );

__device__ __forceinline__ int4
cv::cudev::operator-(
    const short4& a,
    int s
    );

__device__ __forceinline__ int4
cv::cudev::operator-(
    int s,
    const short4& b
    );

__device__ __forceinline__ int2
cv::cudev::operator-(
    int s,
    const short2& b
    );

__device__ __forceinline__ float1
cv::cudev::operator-(
    const short1& a,
    float s
    );

__device__ __forceinline__ float1
cv::cudev::operator-(
    float s,
    const short1& b
    );

__device__ __forceinline__ float2
cv::cudev::operator-(
    const short2& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::operator-(
    const short3& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::operator-(
    float s,
    const short3& b
    );

__device__ __forceinline__ float4
cv::cudev::operator-(
    const short4& a,
    float s
    );

__device__ __forceinline__ float2
cv::cudev::operator-(
    float s,
    const short2& b
    );

__device__ __forceinline__ float4
cv::cudev::operator-(
    float s,
    const short4& b
    );

__device__ __forceinline__ double1
cv::cudev::operator-(
    const short1& a,
    double s
    );

__device__ __forceinline__ double1
cv::cudev::operator-(
    double s,
    const short1& b
    );

__device__ __forceinline__ double2
cv::cudev::operator-(
    const short2& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::operator-(
    const short3& a,
    double s
    );

__device__ __forceinline__ double4
cv::cudev::operator-(
    const short4& a,
    double s
    );

__device__ __forceinline__ double4
cv::cudev::operator-(
    double s,
    const short4& b
    );

__device__ __forceinline__ double2
cv::cudev::operator-(
    double s,
    const short2& b
    );

__device__ __forceinline__ double3
cv::cudev::operator-(
    double s,
    const short3& b
    );

__device__ __forceinline__ int2
cv::cudev::operator-(
    int s,
    const int2& b
    );

__device__ __forceinline__ int1
cv::cudev::operator-(
    const int1& a,
    int s
    );

__device__ __forceinline__ int1
cv::cudev::operator-(
    int s,
    const int1& b
    );

__device__ __forceinline__ int2
cv::cudev::operator-(
    const int2& a,
    int s
    );

__device__ __forceinline__ int3
cv::cudev::operator-(
    const int3& a,
    int s
    );

__device__ __forceinline__ int3
cv::cudev::operator-(
    int s,
    const int3& b
    );

__device__ __forceinline__ int4
cv::cudev::operator-(
    const int4& a,
    int s
    );

__device__ __forceinline__ int4
cv::cudev::operator-(
    int s,
    const int4& b
    );

__device__ __forceinline__ float4
cv::cudev::operator-(
    float s,
    const int4& b
    );

__device__ __forceinline__ float1
cv::cudev::operator-(
    const int1& a,
    float s
    );

__device__ __forceinline__ float1
cv::cudev::operator-(
    float s,
    const int1& b
    );

__device__ __forceinline__ float2
cv::cudev::operator-(
    const int2& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::operator-(
    const int3& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::operator-(
    float s,
    const int3& b
    );

__device__ __forceinline__ float4
cv::cudev::operator-(
    const int4& a,
    float s
    );

__device__ __forceinline__ float2
cv::cudev::operator-(
    float s,
    const int2& b
    );

__device__ __forceinline__ double2
cv::cudev::operator-(
    double s,
    const int2& b
    );

__device__ __forceinline__ double4
cv::cudev::operator-(
    double s,
    const int4& b
    );

__device__ __forceinline__ double1
cv::cudev::operator-(
    const int1& a,
    double s
    );

__device__ __forceinline__ double1
cv::cudev::operator-(
    double s,
    const int1& b
    );

__device__ __forceinline__ double2
cv::cudev::operator-(
    const int2& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::operator-(
    const int3& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::operator-(
    double s,
    const int3& b
    );

__device__ __forceinline__ double4
cv::cudev::operator-(
    const int4& a,
    double s
    );

__device__ __forceinline__ uint4
cv::cudev::operator-(
    uint s,
    const uint4& b
    );

__device__ __forceinline__ uint1
cv::cudev::operator-(
    uint s,
    const uint1& b
    );

__device__ __forceinline__ uint2
cv::cudev::operator-(
    uint s,
    const uint2& b
    );

__device__ __forceinline__ uint1
cv::cudev::operator-(
    const uint1& a,
    uint s
    );

__device__ __forceinline__ uint2
cv::cudev::operator-(
    const uint2& a,
    uint s
    );

__device__ __forceinline__ uint3
cv::cudev::operator-(
    const uint3& a,
    uint s
    );

__device__ __forceinline__ uint3
cv::cudev::operator-(
    uint s,
    const uint3& b
    );

__device__ __forceinline__ uint4
cv::cudev::operator-(
    const uint4& a,
    uint s
    );

__device__ __forceinline__ float2
cv::cudev::operator-(
    float s,
    const uint2& b
    );

__device__ __forceinline__ float1
cv::cudev::operator-(
    const uint1& a,
    float s
    );

__device__ __forceinline__ float1
cv::cudev::operator-(
    float s,
    const uint1& b
    );

__device__ __forceinline__ float2
cv::cudev::operator-(
    const uint2& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::operator-(
    const uint3& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::operator-(
    float s,
    const uint3& b
    );

__device__ __forceinline__ float4
cv::cudev::operator-(
    const uint4& a,
    float s
    );

__device__ __forceinline__ float4
cv::cudev::operator-(
    float s,
    const uint4& b
    );

__device__ __forceinline__ double1
cv::cudev::operator-(
    const uint1& a,
    double s
    );

__device__ __forceinline__ double1
cv::cudev::operator-(
    double s,
    const uint1& b
    );

__device__ __forceinline__ double2
cv::cudev::operator-(
    const uint2& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::operator-(
    const uint3& a,
    double s
    );

__device__ __forceinline__ double4
cv::cudev::operator-(
    const uint4& a,
    double s
    );

__device__ __forceinline__ double2
cv::cudev::operator-(
    double s,
    const uint2& b
    );

__device__ __forceinline__ double3
cv::cudev::operator-(
    double s,
    const uint3& b
    );

__device__ __forceinline__ double4
cv::cudev::operator-(
    double s,
    const uint4& b
    );

__device__ __forceinline__ float1
cv::cudev::operator-(
    const float1& a,
    float s
    );

__device__ __forceinline__ float1
cv::cudev::operator-(
    float s,
    const float1& b
    );

__device__ __forceinline__ float2
cv::cudev::operator-(
    const float2& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::operator-(
    const float3& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::operator-(
    float s,
    const float3& b
    );

__device__ __forceinline__ float4
cv::cudev::operator-(
    const float4& a,
    float s
    );

__device__ __forceinline__ float4
cv::cudev::operator-(
    float s,
    const float4& b
    );

__device__ __forceinline__ float2
cv::cudev::operator-(
    float s,
    const float2& b
    );

__device__ __forceinline__ double1
cv::cudev::operator-(
    const float1& a,
    double s
    );

__device__ __forceinline__ double2
cv::cudev::operator-(
    const float2& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::operator-(
    const float3& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::operator-(
    double s,
    const float3& b
    );

__device__ __forceinline__ double4
cv::cudev::operator-(
    const float4& a,
    double s
    );

__device__ __forceinline__ double2
cv::cudev::operator-(
    double s,
    const float2& b
    );

__device__ __forceinline__ double1
cv::cudev::operator-(
    double s,
    const float1& b
    );

__device__ __forceinline__ double4
cv::cudev::operator-(
    double s,
    const float4& b
    );

__device__ __forceinline__ double1
cv::cudev::operator-(
    const double1& a,
    double s
    );

__device__ __forceinline__ double1
cv::cudev::operator-(
    double s,
    const double1& b
    );

__device__ __forceinline__ double2
cv::cudev::operator-(
    const double2& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::operator-(
    const double3& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::operator-(
    double s,
    const double3& b
    );

__device__ __forceinline__ double4
cv::cudev::operator-(
    const double4& a,
    double s
    );

__device__ __forceinline__ double4
cv::cudev::operator-(
    double s,
    const double4& b
    );

__device__ __forceinline__ double2
cv::cudev::operator-(
    double s,
    const double2& b
    );

template <class Body>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, Binder1st<divides<typename Body::value_type>>>>
cv::cudev::operator::(
    typename Body::value_type val,
    const Expr<Body>& a
    );

template <class Body>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, Binder2nd<divides<typename Body::value_type>>>>
cv::cudev::operator::(
    const Expr<Body>& a,
    typename Body::value_type val
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, typename PtrTraits<GpuMat_<T>>::ptr_type, divides<T>>>
cv::cudev::operator::(
    const GpuMat_<T>& src1,
    const GpuMat_<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, typename PtrTraits<Texture<T>>::ptr_type, divides<T>>>
cv::cudev::operator::(
    const GpuMat_<T>& src1,
    const Texture<T>& src2
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, Binder1st<divides<T>>>>
cv::cudev::operator::(
    T val,
    const Texture<T>& src
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, typename PtrTraits<GpuMat_<T>>::ptr_type, divides<T>>>
cv::cudev::operator::(
    const Texture<T>& src1,
    const GpuMat_<T>& src2
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, typename PtrTraits<Body>::ptr_type, divides<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator::(
    const GpuMat_<T>& src1,
    const Expr<Body>& src2
    );

template <
    class Body1,
    class Body2
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Body1>::ptr_type, typename PtrTraits<Body2>::ptr_type, divides<typename LargerType<typename PtrTraits<Body1>::value_type, typename PtrTraits<Body2>::value_type>::type>>>
cv::cudev::operator::(
    const Expr<Body1>& a,
    const Expr<Body2>& b
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, typename PtrTraits<GpuMat_<T>>::ptr_type, divides<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator::(
    const Expr<Body>& src1,
    const GpuMat_<T>& src2
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, Binder2nd<divides<T>>>>
cv::cudev::operator::(
    const GpuMat_<T>& src,
    T val
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, Binder1st<divides<T>>>>
cv::cudev::operator::(
    T val,
    const GpuMat_<T>& src
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, typename PtrTraits<GlobPtrSz<T>>::ptr_type, divides<T>>>
cv::cudev::operator::(
    const GlobPtrSz<T>& src1,
    const GlobPtrSz<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, typename PtrTraits<Texture<T>>::ptr_type, divides<T>>>
cv::cudev::operator::(
    const GlobPtrSz<T>& src1,
    const Texture<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, typename PtrTraits<GlobPtrSz<T>>::ptr_type, divides<T>>>
cv::cudev::operator::(
    const Texture<T>& src1,
    const GlobPtrSz<T>& src2
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, typename PtrTraits<Body>::ptr_type, divides<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator::(
    const GlobPtrSz<T>& src1,
    const Expr<Body>& src2
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, typename PtrTraits<GlobPtrSz<T>>::ptr_type, divides<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator::(
    const Expr<Body>& src1,
    const GlobPtrSz<T>& src2
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, Binder2nd<divides<T>>>>
cv::cudev::operator::(
    const GlobPtrSz<T>& src,
    T val
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, Binder1st<divides<T>>>>
cv::cudev::operator::(
    T val,
    const GlobPtrSz<T>& src
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, typename PtrTraits<Body>::ptr_type, divides<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator::(
    const Texture<T>& src1,
    const Expr<Body>& src2
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, typename PtrTraits<Texture<T>>::ptr_type, divides<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator::(
    const Expr<Body>& src1,
    const Texture<T>& src2
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, Binder2nd<divides<T>>>>
cv::cudev::operator::(
    const Texture<T>& src,
    T val
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, typename PtrTraits<GlobPtrSz<T>>::ptr_type, divides<T>>>
cv::cudev::operator::(
    const GpuMat_<T>& src1,
    const GlobPtrSz<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, typename PtrTraits<Texture<T>>::ptr_type, divides<T>>>
cv::cudev::operator::(
    const Texture<T>& src1,
    const Texture<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, typename PtrTraits<GpuMat_<T>>::ptr_type, divides<T>>>
cv::cudev::operator::(
    const GlobPtrSz<T>& src1,
    const GpuMat_<T>& src2
    );

__device__ __forceinline__ int2
cv::cudev::operator::(
    const uchar2& a,
    const uchar2& b
    );

__device__ __forceinline__ int1
cv::cudev::operator::(
    const uchar1& a,
    const uchar1& b
    );

__device__ __forceinline__ int4
cv::cudev::operator::(
    const uchar4& a,
    const uchar4& b
    );

__device__ __forceinline__ int3
cv::cudev::operator::(
    const uchar3& a,
    const uchar3& b
    );

__device__ __forceinline__ int3
cv::cudev::operator::(
    const char3& a,
    const char3& b
    );

__device__ __forceinline__ int2
cv::cudev::operator::(
    const char2& a,
    const char2& b
    );

__device__ __forceinline__ int4
cv::cudev::operator::(
    const char4& a,
    const char4& b
    );

__device__ __forceinline__ int1
cv::cudev::operator::(
    const char1& a,
    const char1& b
    );

__device__ __forceinline__ int2
cv::cudev::operator::(
    const ushort2& a,
    const ushort2& b
    );

__device__ __forceinline__ int3
cv::cudev::operator::(
    const ushort3& a,
    const ushort3& b
    );

__device__ __forceinline__ int4
cv::cudev::operator::(
    const ushort4& a,
    const ushort4& b
    );

__device__ __forceinline__ int1
cv::cudev::operator::(
    const ushort1& a,
    const ushort1& b
    );

__device__ __forceinline__ int4
cv::cudev::operator::(
    const short4& a,
    const short4& b
    );

__device__ __forceinline__ int1
cv::cudev::operator::(
    const short1& a,
    const short1& b
    );

__device__ __forceinline__ int2
cv::cudev::operator::(
    const short2& a,
    const short2& b
    );

__device__ __forceinline__ int3
cv::cudev::operator::(
    const short3& a,
    const short3& b
    );

__device__ __forceinline__ int2
cv::cudev::operator::(
    const int2& a,
    const int2& b
    );

__device__ __forceinline__ int3
cv::cudev::operator::(
    const int3& a,
    const int3& b
    );

__device__ __forceinline__ int4
cv::cudev::operator::(
    const int4& a,
    const int4& b
    );

__device__ __forceinline__ int1
cv::cudev::operator::(
    const int1& a,
    const int1& b
    );

__device__ __forceinline__ uint2
cv::cudev::operator::(
    const uint2& a,
    const uint2& b
    );

__device__ __forceinline__ uint4
cv::cudev::operator::(
    const uint4& a,
    const uint4& b
    );

__device__ __forceinline__ uint3
cv::cudev::operator::(
    const uint3& a,
    const uint3& b
    );

__device__ __forceinline__ uint1
cv::cudev::operator::(
    const uint1& a,
    const uint1& b
    );

__device__ __forceinline__ float3
cv::cudev::operator::(
    const float3& a,
    const float3& b
    );

__device__ __forceinline__ float4
cv::cudev::operator::(
    const float4& a,
    const float4& b
    );

__device__ __forceinline__ float2
cv::cudev::operator::(
    const float2& a,
    const float2& b
    );

__device__ __forceinline__ float1
cv::cudev::operator::(
    const float1& a,
    const float1& b
    );

__device__ __forceinline__ double3
cv::cudev::operator::(
    const double3& a,
    const double3& b
    );

__device__ __forceinline__ double4
cv::cudev::operator::(
    const double4& a,
    const double4& b
    );

__device__ __forceinline__ double2
cv::cudev::operator::(
    const double2& a,
    const double2& b
    );

__device__ __forceinline__ double1
cv::cudev::operator::(
    const double1& a,
    const double1& b
    );

__device__ __forceinline__ int1
cv::cudev::operator::(
    const uchar1& a,
    int s
    );

__device__ __forceinline__ int1
cv::cudev::operator::(
    int s,
    const uchar1& b
    );

__device__ __forceinline__ int2
cv::cudev::operator::(
    const uchar2& a,
    int s
    );

__device__ __forceinline__ int3
cv::cudev::operator::(
    const uchar3& a,
    int s
    );

__device__ __forceinline__ int3
cv::cudev::operator::(
    int s,
    const uchar3& b
    );

__device__ __forceinline__ int4
cv::cudev::operator::(
    const uchar4& a,
    int s
    );

__device__ __forceinline__ int2
cv::cudev::operator::(
    int s,
    const uchar2& b
    );

__device__ __forceinline__ int4
cv::cudev::operator::(
    int s,
    const uchar4& b
    );

__device__ __forceinline__ float1
cv::cudev::operator::(
    const uchar1& a,
    float s
    );

__device__ __forceinline__ float1
cv::cudev::operator::(
    float s,
    const uchar1& b
    );

__device__ __forceinline__ float2
cv::cudev::operator::(
    const uchar2& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::operator::(
    const uchar3& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::operator::(
    float s,
    const uchar3& b
    );

__device__ __forceinline__ float4
cv::cudev::operator::(
    const uchar4& a,
    float s
    );

__device__ __forceinline__ float2
cv::cudev::operator::(
    float s,
    const uchar2& b
    );

__device__ __forceinline__ float4
cv::cudev::operator::(
    float s,
    const uchar4& b
    );

__device__ __forceinline__ double1
cv::cudev::operator::(
    const uchar1& a,
    double s
    );

__device__ __forceinline__ double1
cv::cudev::operator::(
    double s,
    const uchar1& b
    );

__device__ __forceinline__ double2
cv::cudev::operator::(
    const uchar2& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::operator::(
    const uchar3& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::operator::(
    double s,
    const uchar3& b
    );

__device__ __forceinline__ double4
cv::cudev::operator::(
    const uchar4& a,
    double s
    );

__device__ __forceinline__ double2
cv::cudev::operator::(
    double s,
    const uchar2& b
    );

__device__ __forceinline__ double4
cv::cudev::operator::(
    double s,
    const uchar4& b
    );

__device__ __forceinline__ int1
cv::cudev::operator::(
    const char1& a,
    int s
    );

__device__ __forceinline__ int1
cv::cudev::operator::(
    int s,
    const char1& b
    );

__device__ __forceinline__ int2
cv::cudev::operator::(
    const char2& a,
    int s
    );

__device__ __forceinline__ int3
cv::cudev::operator::(
    const char3& a,
    int s
    );

__device__ __forceinline__ int3
cv::cudev::operator::(
    int s,
    const char3& b
    );

__device__ __forceinline__ int4
cv::cudev::operator::(
    const char4& a,
    int s
    );

__device__ __forceinline__ int2
cv::cudev::operator::(
    int s,
    const char2& b
    );

__device__ __forceinline__ int4
cv::cudev::operator::(
    int s,
    const char4& b
    );

__device__ __forceinline__ float1
cv::cudev::operator::(
    const char1& a,
    float s
    );

__device__ __forceinline__ float2
cv::cudev::operator::(
    const char2& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::operator::(
    const char3& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::operator::(
    float s,
    const char3& b
    );

__device__ __forceinline__ float4
cv::cudev::operator::(
    const char4& a,
    float s
    );

__device__ __forceinline__ float4
cv::cudev::operator::(
    float s,
    const char4& b
    );

__device__ __forceinline__ float2
cv::cudev::operator::(
    float s,
    const char2& b
    );

__device__ __forceinline__ float1
cv::cudev::operator::(
    float s,
    const char1& b
    );

__device__ __forceinline__ double3
cv::cudev::operator::(
    double s,
    const char3& b
    );

__device__ __forceinline__ double1
cv::cudev::operator::(
    const char1& a,
    double s
    );

__device__ __forceinline__ double2
cv::cudev::operator::(
    const char2& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::operator::(
    const char3& a,
    double s
    );

__device__ __forceinline__ double4
cv::cudev::operator::(
    const char4& a,
    double s
    );

__device__ __forceinline__ double1
cv::cudev::operator::(
    double s,
    const char1& b
    );

__device__ __forceinline__ double2
cv::cudev::operator::(
    double s,
    const char2& b
    );

__device__ __forceinline__ double4
cv::cudev::operator::(
    double s,
    const char4& b
    );

__device__ __forceinline__ int3
cv::cudev::operator::(
    int s,
    const ushort3& b
    );

__device__ __forceinline__ int1
cv::cudev::operator::(
    const ushort1& a,
    int s
    );

__device__ __forceinline__ int2
cv::cudev::operator::(
    const ushort2& a,
    int s
    );

__device__ __forceinline__ int3
cv::cudev::operator::(
    const ushort3& a,
    int s
    );

__device__ __forceinline__ int4
cv::cudev::operator::(
    const ushort4& a,
    int s
    );

__device__ __forceinline__ int4
cv::cudev::operator::(
    int s,
    const ushort4& b
    );

__device__ __forceinline__ int2
cv::cudev::operator::(
    int s,
    const ushort2& b
    );

__device__ __forceinline__ int1
cv::cudev::operator::(
    int s,
    const ushort1& b
    );

__device__ __forceinline__ float3
cv::cudev::operator::(
    float s,
    const ushort3& b
    );

__device__ __forceinline__ float1
cv::cudev::operator::(
    const ushort1& a,
    float s
    );

__device__ __forceinline__ float2
cv::cudev::operator::(
    const ushort2& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::operator::(
    const ushort3& a,
    float s
    );

__device__ __forceinline__ float4
cv::cudev::operator::(
    const ushort4& a,
    float s
    );

__device__ __forceinline__ float1
cv::cudev::operator::(
    float s,
    const ushort1& b
    );

__device__ __forceinline__ float2
cv::cudev::operator::(
    float s,
    const ushort2& b
    );

__device__ __forceinline__ float4
cv::cudev::operator::(
    float s,
    const ushort4& b
    );

__device__ __forceinline__ double1
cv::cudev::operator::(
    const ushort1& a,
    double s
    );

__device__ __forceinline__ double2
cv::cudev::operator::(
    const ushort2& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::operator::(
    const ushort3& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::operator::(
    double s,
    const ushort3& b
    );

__device__ __forceinline__ double4
cv::cudev::operator::(
    const ushort4& a,
    double s
    );

__device__ __forceinline__ double4
cv::cudev::operator::(
    double s,
    const ushort4& b
    );

__device__ __forceinline__ double2
cv::cudev::operator::(
    double s,
    const ushort2& b
    );

__device__ __forceinline__ double1
cv::cudev::operator::(
    double s,
    const ushort1& b
    );

__device__ __forceinline__ int1
cv::cudev::operator::(
    const short1& a,
    int s
    );

__device__ __forceinline__ int1
cv::cudev::operator::(
    int s,
    const short1& b
    );

__device__ __forceinline__ int2
cv::cudev::operator::(
    const short2& a,
    int s
    );

__device__ __forceinline__ int3
cv::cudev::operator::(
    const short3& a,
    int s
    );

__device__ __forceinline__ int3
cv::cudev::operator::(
    int s,
    const short3& b
    );

__device__ __forceinline__ int4
cv::cudev::operator::(
    const short4& a,
    int s
    );

__device__ __forceinline__ int2
cv::cudev::operator::(
    int s,
    const short2& b
    );

__device__ __forceinline__ int4
cv::cudev::operator::(
    int s,
    const short4& b
    );

__device__ __forceinline__ float3
cv::cudev::operator::(
    float s,
    const short3& b
    );

__device__ __forceinline__ float1
cv::cudev::operator::(
    const short1& a,
    float s
    );

__device__ __forceinline__ float1
cv::cudev::operator::(
    float s,
    const short1& b
    );

__device__ __forceinline__ float2
cv::cudev::operator::(
    const short2& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::operator::(
    const short3& a,
    float s
    );

__device__ __forceinline__ float4
cv::cudev::operator::(
    const short4& a,
    float s
    );

__device__ __forceinline__ float4
cv::cudev::operator::(
    float s,
    const short4& b
    );

__device__ __forceinline__ float2
cv::cudev::operator::(
    float s,
    const short2& b
    );

__device__ __forceinline__ double1
cv::cudev::operator::(
    const short1& a,
    double s
    );

__device__ __forceinline__ double1
cv::cudev::operator::(
    double s,
    const short1& b
    );

__device__ __forceinline__ double2
cv::cudev::operator::(
    const short2& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::operator::(
    const short3& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::operator::(
    double s,
    const short3& b
    );

__device__ __forceinline__ double4
cv::cudev::operator::(
    const short4& a,
    double s
    );

__device__ __forceinline__ double2
cv::cudev::operator::(
    double s,
    const short2& b
    );

__device__ __forceinline__ double4
cv::cudev::operator::(
    double s,
    const short4& b
    );

__device__ __forceinline__ int1
cv::cudev::operator::(
    const int1& a,
    int s
    );

__device__ __forceinline__ int1
cv::cudev::operator::(
    int s,
    const int1& b
    );

__device__ __forceinline__ int2
cv::cudev::operator::(
    const int2& a,
    int s
    );

__device__ __forceinline__ int3
cv::cudev::operator::(
    const int3& a,
    int s
    );

__device__ __forceinline__ int3
cv::cudev::operator::(
    int s,
    const int3& b
    );

__device__ __forceinline__ int4
cv::cudev::operator::(
    const int4& a,
    int s
    );

__device__ __forceinline__ int4
cv::cudev::operator::(
    int s,
    const int4& b
    );

__device__ __forceinline__ int2
cv::cudev::operator::(
    int s,
    const int2& b
    );

__device__ __forceinline__ float1
cv::cudev::operator::(
    const int1& a,
    float s
    );

__device__ __forceinline__ float1
cv::cudev::operator::(
    float s,
    const int1& b
    );

__device__ __forceinline__ float2
cv::cudev::operator::(
    const int2& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::operator::(
    const int3& a,
    float s
    );

__device__ __forceinline__ float4
cv::cudev::operator::(
    const int4& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::operator::(
    float s,
    const int3& b
    );

__device__ __forceinline__ float2
cv::cudev::operator::(
    float s,
    const int2& b
    );

__device__ __forceinline__ float4
cv::cudev::operator::(
    float s,
    const int4& b
    );

__device__ __forceinline__ double1
cv::cudev::operator::(
    const int1& a,
    double s
    );

__device__ __forceinline__ double1
cv::cudev::operator::(
    double s,
    const int1& b
    );

__device__ __forceinline__ double2
cv::cudev::operator::(
    const int2& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::operator::(
    const int3& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::operator::(
    double s,
    const int3& b
    );

__device__ __forceinline__ double4
cv::cudev::operator::(
    const int4& a,
    double s
    );

__device__ __forceinline__ double2
cv::cudev::operator::(
    double s,
    const int2& b
    );

__device__ __forceinline__ double4
cv::cudev::operator::(
    double s,
    const int4& b
    );

__device__ __forceinline__ uint1
cv::cudev::operator::(
    const uint1& a,
    uint s
    );

__device__ __forceinline__ uint1
cv::cudev::operator::(
    uint s,
    const uint1& b
    );

__device__ __forceinline__ uint2
cv::cudev::operator::(
    const uint2& a,
    uint s
    );

__device__ __forceinline__ uint3
cv::cudev::operator::(
    const uint3& a,
    uint s
    );

__device__ __forceinline__ uint4
cv::cudev::operator::(
    const uint4& a,
    uint s
    );

__device__ __forceinline__ uint3
cv::cudev::operator::(
    uint s,
    const uint3& b
    );

__device__ __forceinline__ uint2
cv::cudev::operator::(
    uint s,
    const uint2& b
    );

__device__ __forceinline__ uint4
cv::cudev::operator::(
    uint s,
    const uint4& b
    );

__device__ __forceinline__ float1
cv::cudev::operator::(
    const uint1& a,
    float s
    );

__device__ __forceinline__ float1
cv::cudev::operator::(
    float s,
    const uint1& b
    );

__device__ __forceinline__ float2
cv::cudev::operator::(
    const uint2& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::operator::(
    const uint3& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::operator::(
    float s,
    const uint3& b
    );

__device__ __forceinline__ float4
cv::cudev::operator::(
    const uint4& a,
    float s
    );

__device__ __forceinline__ float4
cv::cudev::operator::(
    float s,
    const uint4& b
    );

__device__ __forceinline__ float2
cv::cudev::operator::(
    float s,
    const uint2& b
    );

__device__ __forceinline__ double1
cv::cudev::operator::(
    const uint1& a,
    double s
    );

__device__ __forceinline__ double1
cv::cudev::operator::(
    double s,
    const uint1& b
    );

__device__ __forceinline__ double2
cv::cudev::operator::(
    const uint2& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::operator::(
    const uint3& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::operator::(
    double s,
    const uint3& b
    );

__device__ __forceinline__ double4
cv::cudev::operator::(
    const uint4& a,
    double s
    );

__device__ __forceinline__ double4
cv::cudev::operator::(
    double s,
    const uint4& b
    );

__device__ __forceinline__ double2
cv::cudev::operator::(
    double s,
    const uint2& b
    );

__device__ __forceinline__ float4
cv::cudev::operator::(
    const float4& a,
    float s
    );

__device__ __forceinline__ float1
cv::cudev::operator::(
    const float1& a,
    float s
    );

__device__ __forceinline__ float2
cv::cudev::operator::(
    const float2& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::operator::(
    const float3& a,
    float s
    );

__device__ __forceinline__ float3
cv::cudev::operator::(
    float s,
    const float3& b
    );

__device__ __forceinline__ float4
cv::cudev::operator::(
    float s,
    const float4& b
    );

__device__ __forceinline__ float2
cv::cudev::operator::(
    float s,
    const float2& b
    );

__device__ __forceinline__ float1
cv::cudev::operator::(
    float s,
    const float1& b
    );

__device__ __forceinline__ double1
cv::cudev::operator::(
    double s,
    const float1& b
    );

__device__ __forceinline__ double2
cv::cudev::operator::(
    const float2& a,
    double s
    );

__device__ __forceinline__ double1
cv::cudev::operator::(
    const float1& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::operator::(
    const float3& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::operator::(
    double s,
    const float3& b
    );

__device__ __forceinline__ double4
cv::cudev::operator::(
    const float4& a,
    double s
    );

__device__ __forceinline__ double2
cv::cudev::operator::(
    double s,
    const float2& b
    );

__device__ __forceinline__ double4
cv::cudev::operator::(
    double s,
    const float4& b
    );

__device__ __forceinline__ double4
cv::cudev::operator::(
    const double4& a,
    double s
    );

__device__ __forceinline__ double1
cv::cudev::operator::(
    const double1& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::operator::(
    const double3& a,
    double s
    );

__device__ __forceinline__ double3
cv::cudev::operator::(
    double s,
    const double3& b
    );

__device__ __forceinline__ double1
cv::cudev::operator::(
    double s,
    const double1& b
    );

__device__ __forceinline__ double4
cv::cudev::operator::(
    double s,
    const double4& b
    );

__device__ __forceinline__ double2
cv::cudev::operator::(
    double s,
    const double2& b
    );

__device__ __forceinline__ double2
cv::cudev::operator::(
    const double2& a,
    double s
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, Binder2nd<less<T>>>>
cv::cudev::operator<(
    const Texture<T>& src,
    T val
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, typename PtrTraits<Texture<T>>::ptr_type, less<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator<(
    const Expr<Body>& src1,
    const Texture<T>& src2
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, Binder2nd<less<T>>>>
cv::cudev::operator<(
    const GlobPtrSz<T>& src,
    T val
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, typename PtrTraits<Texture<T>>::ptr_type, less<T>>>
cv::cudev::operator<(
    const GpuMat_<T>& src1,
    const Texture<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, typename PtrTraits<Texture<T>>::ptr_type, less<T>>>
cv::cudev::operator<(
    const GlobPtrSz<T>& src1,
    const Texture<T>& src2
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, typename PtrTraits<GlobPtrSz<T>>::ptr_type, less<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator<(
    const Expr<Body>& src1,
    const GlobPtrSz<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, typename PtrTraits<GlobPtrSz<T>>::ptr_type, less<T>>>
cv::cudev::operator<(
    const Texture<T>& src1,
    const GlobPtrSz<T>& src2
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, typename PtrTraits<Body>::ptr_type, less<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator<(
    const GlobPtrSz<T>& src1,
    const Expr<Body>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, typename PtrTraits<GpuMat_<T>>::ptr_type, less<T>>>
cv::cudev::operator<(
    const GlobPtrSz<T>& src1,
    const GpuMat_<T>& src2
    );

template <class Body>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, Binder1st<less<typename Body::value_type>>>>
cv::cudev::operator<(
    typename Body::value_type val,
    const Expr<Body>& a
    );

template <class Body>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, Binder2nd<less<typename Body::value_type>>>>
cv::cudev::operator<(
    const Expr<Body>& a,
    typename Body::value_type val
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, typename PtrTraits<GpuMat_<T>>::ptr_type, less<T>>>
cv::cudev::operator<(
    const GpuMat_<T>& src1,
    const GpuMat_<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, typename PtrTraits<Texture<T>>::ptr_type, less<T>>>
cv::cudev::operator<(
    const Texture<T>& src1,
    const Texture<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, typename PtrTraits<GpuMat_<T>>::ptr_type, less<T>>>
cv::cudev::operator<(
    const Texture<T>& src1,
    const GpuMat_<T>& src2
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, typename PtrTraits<Body>::ptr_type, less<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator<(
    const GpuMat_<T>& src1,
    const Expr<Body>& src2
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, typename PtrTraits<GpuMat_<T>>::ptr_type, less<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator<(
    const Expr<Body>& src1,
    const GpuMat_<T>& src2
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, Binder2nd<less<T>>>>
cv::cudev::operator<(
    const GpuMat_<T>& src,
    T val
    );

template <
    class Body1,
    class Body2
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Body1>::ptr_type, typename PtrTraits<Body2>::ptr_type, less<typename LargerType<typename PtrTraits<Body1>::value_type, typename PtrTraits<Body2>::value_type>::type>>>
cv::cudev::operator<(
    const Expr<Body1>& a,
    const Expr<Body2>& b
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, Binder1st<less<T>>>>
cv::cudev::operator<(
    T val,
    const GpuMat_<T>& src
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, typename PtrTraits<GlobPtrSz<T>>::ptr_type, less<T>>>
cv::cudev::operator<(
    const GlobPtrSz<T>& src1,
    const GlobPtrSz<T>& src2
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, Binder1st<less<T>>>>
cv::cudev::operator<(
    T val,
    const Texture<T>& src
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, typename PtrTraits<Body>::ptr_type, less<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator<(
    const Texture<T>& src1,
    const Expr<Body>& src2
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, Binder1st<less<T>>>>
cv::cudev::operator<(
    T val,
    const GlobPtrSz<T>& src
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, typename PtrTraits<GlobPtrSz<T>>::ptr_type, less<T>>>
cv::cudev::operator<(
    const GpuMat_<T>& src1,
    const GlobPtrSz<T>& src2
    );

__device__ __forceinline__ uchar3
cv::cudev::operator<(
    const uchar3& a,
    const uchar3& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator<(
    const uchar4& a,
    const uchar4& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator<(
    const uchar1& a,
    const uchar1& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator<(
    const uchar2& a,
    const uchar2& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator<(
    const char1& a,
    const char1& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator<(
    const char4& a,
    const char4& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator<(
    const char3& a,
    const char3& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator<(
    const char2& a,
    const char2& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator<(
    const ushort2& a,
    const ushort2& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator<(
    const ushort3& a,
    const ushort3& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator<(
    const ushort4& a,
    const ushort4& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator<(
    const ushort1& a,
    const ushort1& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator<(
    const short1& a,
    const short1& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator<(
    const short4& a,
    const short4& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator<(
    const short3& a,
    const short3& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator<(
    const short2& a,
    const short2& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator<(
    const int4& a,
    const int4& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator<(
    const int2& a,
    const int2& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator<(
    const int1& a,
    const int1& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator<(
    const int3& a,
    const int3& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator<(
    const uint2& a,
    const uint2& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator<(
    const uint4& a,
    const uint4& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator<(
    const uint3& a,
    const uint3& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator<(
    const uint1& a,
    const uint1& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator<(
    const float2& a,
    const float2& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator<(
    const float4& a,
    const float4& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator<(
    const float3& a,
    const float3& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator<(
    const float1& a,
    const float1& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator<(
    const double2& a,
    const double2& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator<(
    const double3& a,
    const double3& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator<(
    const double4& a,
    const double4& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator<(
    const double1& a,
    const double1& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator<(
    const uchar1& a,
    uchar s
    );

__device__ __forceinline__ uchar2
cv::cudev::operator<(
    const uchar2& a,
    uchar s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator<(
    const uchar3& a,
    uchar s
    );

__device__ __forceinline__ uchar4
cv::cudev::operator<(
    const uchar4& a,
    uchar s
    );

__device__ __forceinline__ uchar4
cv::cudev::operator<(
    uchar s,
    const uchar4& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator<(
    uchar s,
    const uchar2& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator<(
    uchar s,
    const uchar3& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator<(
    uchar s,
    const uchar1& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator<(
    const char4& a,
    char s
    );

__device__ __forceinline__ uchar1
cv::cudev::operator<(
    const char1& a,
    char s
    );

__device__ __forceinline__ uchar1
cv::cudev::operator<(
    char s,
    const char1& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator<(
    const char2& a,
    char s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator<(
    const char3& a,
    char s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator<(
    char s,
    const char3& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator<(
    char s,
    const char4& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator<(
    char s,
    const char2& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator<(
    ushort s,
    const ushort1& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator<(
    const ushort2& a,
    ushort s
    );

__device__ __forceinline__ uchar1
cv::cudev::operator<(
    const ushort1& a,
    ushort s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator<(
    const ushort3& a,
    ushort s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator<(
    ushort s,
    const ushort3& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator<(
    const ushort4& a,
    ushort s
    );

__device__ __forceinline__ uchar2
cv::cudev::operator<(
    ushort s,
    const ushort2& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator<(
    ushort s,
    const ushort4& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator<(
    const short4& a,
    short s
    );

__device__ __forceinline__ uchar2
cv::cudev::operator<(
    const short2& a,
    short s
    );

__device__ __forceinline__ uchar1
cv::cudev::operator<(
    const short1& a,
    short s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator<(
    const short3& a,
    short s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator<(
    short s,
    const short3& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator<(
    short s,
    const short4& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator<(
    short s,
    const short2& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator<(
    short s,
    const short1& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator<(
    const int2& a,
    int s
    );

__device__ __forceinline__ uchar4
cv::cudev::operator<(
    int s,
    const int4& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator<(
    const int1& a,
    int s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator<(
    const int3& a,
    int s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator<(
    int s,
    const int3& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator<(
    const int4& a,
    int s
    );

__device__ __forceinline__ uchar1
cv::cudev::operator<(
    int s,
    const int1& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator<(
    int s,
    const int2& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator<(
    uint s,
    const uint1& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator<(
    const uint4& a,
    uint s
    );

__device__ __forceinline__ uchar2
cv::cudev::operator<(
    const uint2& a,
    uint s
    );

__device__ __forceinline__ uchar1
cv::cudev::operator<(
    const uint1& a,
    uint s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator<(
    const uint3& a,
    uint s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator<(
    uint s,
    const uint3& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator<(
    uint s,
    const uint4& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator<(
    uint s,
    const uint2& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator<(
    float s,
    const float1& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator<(
    const float2& a,
    float s
    );

__device__ __forceinline__ uchar1
cv::cudev::operator<(
    const float1& a,
    float s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator<(
    const float3& a,
    float s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator<(
    float s,
    const float3& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator<(
    const float4& a,
    float s
    );

__device__ __forceinline__ uchar2
cv::cudev::operator<(
    float s,
    const float2& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator<(
    float s,
    const float4& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator<(
    double s,
    const double4& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator<(
    const double1& a,
    double s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator<(
    const double3& a,
    double s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator<(
    double s,
    const double3& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator<(
    const double4& a,
    double s
    );

__device__ __forceinline__ uchar2
cv::cudev::operator<(
    const double2& a,
    double s
    );

__device__ __forceinline__ uchar1
cv::cudev::operator<(
    double s,
    const double1& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator<(
    double s,
    const double2& b
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, Binder2nd<bit_lshift<T>>>>
cv::cudev::operator<<(
    const GpuMat_<T>& src,
    T val
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, typename PtrTraits<GpuMat_<T>>::ptr_type, bit_lshift<T>>>
cv::cudev::operator<<(
    const GpuMat_<T>& src1,
    const GpuMat_<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, typename PtrTraits<GlobPtrSz<T>>::ptr_type, bit_lshift<T>>>
cv::cudev::operator<<(
    const GpuMat_<T>& src1,
    const GlobPtrSz<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, typename PtrTraits<GpuMat_<T>>::ptr_type, bit_lshift<T>>>
cv::cudev::operator<<(
    const GlobPtrSz<T>& src1,
    const GpuMat_<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, typename PtrTraits<Texture<T>>::ptr_type, bit_lshift<T>>>
cv::cudev::operator<<(
    const GpuMat_<T>& src1,
    const Texture<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, typename PtrTraits<GpuMat_<T>>::ptr_type, bit_lshift<T>>>
cv::cudev::operator<<(
    const Texture<T>& src1,
    const GpuMat_<T>& src2
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, Binder1st<bit_lshift<T>>>>
cv::cudev::operator<<(
    T val,
    const GpuMat_<T>& src
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, typename PtrTraits<Body>::ptr_type, bit_lshift<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator<<(
    const GlobPtrSz<T>& src1,
    const Expr<Body>& src2
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, typename PtrTraits<GlobPtrSz<T>>::ptr_type, bit_lshift<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator<<(
    const Expr<Body>& src1,
    const GlobPtrSz<T>& src2
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, Binder2nd<bit_lshift<T>>>>
cv::cudev::operator<<(
    const GlobPtrSz<T>& src,
    T val
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, typename PtrTraits<GlobPtrSz<T>>::ptr_type, bit_lshift<T>>>
cv::cudev::operator<<(
    const Texture<T>& src1,
    const GlobPtrSz<T>& src2
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, Binder1st<bit_lshift<T>>>>
cv::cudev::operator<<(
    T val,
    const GlobPtrSz<T>& src
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, typename PtrTraits<Texture<T>>::ptr_type, bit_lshift<T>>>
cv::cudev::operator<<(
    const Texture<T>& src1,
    const Texture<T>& src2
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, typename PtrTraits<Body>::ptr_type, bit_lshift<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator<<(
    const Texture<T>& src1,
    const Expr<Body>& src2
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, typename PtrTraits<Texture<T>>::ptr_type, bit_lshift<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator<<(
    const Expr<Body>& src1,
    const Texture<T>& src2
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, Binder2nd<bit_lshift<T>>>>
cv::cudev::operator<<(
    const Texture<T>& src,
    T val
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, Binder1st<bit_lshift<T>>>>
cv::cudev::operator<<(
    T val,
    const Texture<T>& src
    );

template <
    class Body1,
    class Body2
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Body1>::ptr_type, typename PtrTraits<Body2>::ptr_type, bit_lshift<typename LargerType<typename PtrTraits<Body1>::value_type, typename PtrTraits<Body2>::value_type>::type>>>
cv::cudev::operator<<(
    const Expr<Body1>& a,
    const Expr<Body2>& b
    );

template <class Body>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, Binder1st<bit_lshift<typename Body::value_type>>>>
cv::cudev::operator<<(
    typename Body::value_type val,
    const Expr<Body>& a
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, typename PtrTraits<Body>::ptr_type, bit_lshift<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator<<(
    const GpuMat_<T>& src1,
    const Expr<Body>& src2
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, typename PtrTraits<GpuMat_<T>>::ptr_type, bit_lshift<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator<<(
    const Expr<Body>& src1,
    const GpuMat_<T>& src2
    );

template <class Body>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, Binder2nd<bit_lshift<typename Body::value_type>>>>
cv::cudev::operator<<(
    const Expr<Body>& a,
    typename Body::value_type val
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, typename PtrTraits<GlobPtrSz<T>>::ptr_type, bit_lshift<T>>>
cv::cudev::operator<<(
    const GlobPtrSz<T>& src1,
    const GlobPtrSz<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, typename PtrTraits<Texture<T>>::ptr_type, bit_lshift<T>>>
cv::cudev::operator<<(
    const GlobPtrSz<T>& src1,
    const Texture<T>& src2
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, typename PtrTraits<GpuMat_<T>>::ptr_type, less_equal<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator<=(
    const Expr<Body>& src1,
    const GpuMat_<T>& src2
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, Binder2nd<less_equal<T>>>>
cv::cudev::operator<=(
    const GpuMat_<T>& src,
    T val
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, Binder1st<less_equal<T>>>>
cv::cudev::operator<=(
    T val,
    const GpuMat_<T>& src
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, typename PtrTraits<GlobPtrSz<T>>::ptr_type, less_equal<T>>>
cv::cudev::operator<=(
    const GlobPtrSz<T>& src1,
    const GlobPtrSz<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, typename PtrTraits<Texture<T>>::ptr_type, less_equal<T>>>
cv::cudev::operator<=(
    const GlobPtrSz<T>& src1,
    const Texture<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, typename PtrTraits<GlobPtrSz<T>>::ptr_type, less_equal<T>>>
cv::cudev::operator<=(
    const Texture<T>& src1,
    const GlobPtrSz<T>& src2
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, typename PtrTraits<Body>::ptr_type, less_equal<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator<=(
    const GlobPtrSz<T>& src1,
    const Expr<Body>& src2
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, typename PtrTraits<GlobPtrSz<T>>::ptr_type, less_equal<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator<=(
    const Expr<Body>& src1,
    const GlobPtrSz<T>& src2
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, Binder2nd<less_equal<T>>>>
cv::cudev::operator<=(
    const GlobPtrSz<T>& src,
    T val
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, Binder1st<less_equal<T>>>>
cv::cudev::operator<=(
    T val,
    const GlobPtrSz<T>& src
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, typename PtrTraits<Texture<T>>::ptr_type, less_equal<T>>>
cv::cudev::operator<=(
    const Texture<T>& src1,
    const Texture<T>& src2
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, typename PtrTraits<Body>::ptr_type, less_equal<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator<=(
    const Texture<T>& src1,
    const Expr<Body>& src2
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, Binder1st<less_equal<T>>>>
cv::cudev::operator<=(
    T val,
    const Texture<T>& src
    );

template <class Body>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, Binder2nd<less_equal<typename Body::value_type>>>>
cv::cudev::operator<=(
    const Expr<Body>& a,
    typename Body::value_type val
    );

template <class Body>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, Binder1st<less_equal<typename Body::value_type>>>>
cv::cudev::operator<=(
    typename Body::value_type val,
    const Expr<Body>& a
    );

template <
    class Body1,
    class Body2
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Body1>::ptr_type, typename PtrTraits<Body2>::ptr_type, less_equal<typename LargerType<typename PtrTraits<Body1>::value_type, typename PtrTraits<Body2>::value_type>::type>>>
cv::cudev::operator<=(
    const Expr<Body1>& a,
    const Expr<Body2>& b
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, typename PtrTraits<Texture<T>>::ptr_type, less_equal<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator<=(
    const Expr<Body>& src1,
    const Texture<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, typename PtrTraits<Texture<T>>::ptr_type, less_equal<T>>>
cv::cudev::operator<=(
    const GpuMat_<T>& src1,
    const Texture<T>& src2
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, Binder2nd<less_equal<T>>>>
cv::cudev::operator<=(
    const Texture<T>& src,
    T val
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, typename PtrTraits<GpuMat_<T>>::ptr_type, less_equal<T>>>
cv::cudev::operator<=(
    const Texture<T>& src1,
    const GpuMat_<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, typename PtrTraits<GpuMat_<T>>::ptr_type, less_equal<T>>>
cv::cudev::operator<=(
    const GlobPtrSz<T>& src1,
    const GpuMat_<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, typename PtrTraits<GlobPtrSz<T>>::ptr_type, less_equal<T>>>
cv::cudev::operator<=(
    const GpuMat_<T>& src1,
    const GlobPtrSz<T>& src2
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, typename PtrTraits<Body>::ptr_type, less_equal<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator<=(
    const GpuMat_<T>& src1,
    const Expr<Body>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, typename PtrTraits<GpuMat_<T>>::ptr_type, less_equal<T>>>
cv::cudev::operator<=(
    const GpuMat_<T>& src1,
    const GpuMat_<T>& src2
    );

__device__ __forceinline__ uchar1
cv::cudev::operator<=(
    const uchar1& a,
    const uchar1& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator<=(
    const uchar3& a,
    const uchar3& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator<=(
    const uchar4& a,
    const uchar4& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator<=(
    const uchar2& a,
    const uchar2& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator<=(
    const char3& a,
    const char3& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator<=(
    const char4& a,
    const char4& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator<=(
    const char1& a,
    const char1& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator<=(
    const char2& a,
    const char2& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator<=(
    const ushort3& a,
    const ushort3& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator<=(
    const ushort4& a,
    const ushort4& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator<=(
    const ushort2& a,
    const ushort2& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator<=(
    const ushort1& a,
    const ushort1& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator<=(
    const short2& a,
    const short2& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator<=(
    const short4& a,
    const short4& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator<=(
    const short1& a,
    const short1& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator<=(
    const short3& a,
    const short3& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator<=(
    const int1& a,
    const int1& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator<=(
    const int3& a,
    const int3& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator<=(
    const int4& a,
    const int4& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator<=(
    const int2& a,
    const int2& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator<=(
    const uint1& a,
    const uint1& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator<=(
    const uint2& a,
    const uint2& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator<=(
    const uint3& a,
    const uint3& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator<=(
    const uint4& a,
    const uint4& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator<=(
    const float1& a,
    const float1& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator<=(
    const float4& a,
    const float4& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator<=(
    const float3& a,
    const float3& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator<=(
    const float2& a,
    const float2& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator<=(
    const double2& a,
    const double2& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator<=(
    const double3& a,
    const double3& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator<=(
    const double1& a,
    const double1& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator<=(
    const double4& a,
    const double4& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator<=(
    uchar s,
    const uchar2& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator<=(
    uchar s,
    const uchar3& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator<=(
    const uchar1& a,
    uchar s
    );

__device__ __forceinline__ uchar1
cv::cudev::operator<=(
    uchar s,
    const uchar1& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator<=(
    const uchar3& a,
    uchar s
    );

__device__ __forceinline__ uchar4
cv::cudev::operator<=(
    const uchar4& a,
    uchar s
    );

__device__ __forceinline__ uchar2
cv::cudev::operator<=(
    const uchar2& a,
    uchar s
    );

__device__ __forceinline__ uchar4
cv::cudev::operator<=(
    uchar s,
    const uchar4& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator<=(
    char s,
    const char1& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator<=(
    char s,
    const char3& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator<=(
    char s,
    const char4& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator<=(
    const char1& a,
    char s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator<=(
    const char3& a,
    char s
    );

__device__ __forceinline__ uchar4
cv::cudev::operator<=(
    const char4& a,
    char s
    );

__device__ __forceinline__ uchar2
cv::cudev::operator<=(
    const char2& a,
    char s
    );

__device__ __forceinline__ uchar2
cv::cudev::operator<=(
    char s,
    const char2& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator<=(
    const ushort2& a,
    ushort s
    );

__device__ __forceinline__ uchar1
cv::cudev::operator<=(
    ushort s,
    const ushort1& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator<=(
    ushort s,
    const ushort2& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator<=(
    ushort s,
    const ushort4& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator<=(
    const ushort4& a,
    ushort s
    );

__device__ __forceinline__ uchar1
cv::cudev::operator<=(
    const ushort1& a,
    ushort s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator<=(
    const ushort3& a,
    ushort s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator<=(
    ushort s,
    const ushort3& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator<=(
    const short2& a,
    short s
    );

__device__ __forceinline__ uchar1
cv::cudev::operator<=(
    short s,
    const short1& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator<=(
    short s,
    const short2& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator<=(
    short s,
    const short3& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator<=(
    short s,
    const short4& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator<=(
    const short4& a,
    short s
    );

__device__ __forceinline__ uchar1
cv::cudev::operator<=(
    const short1& a,
    short s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator<=(
    const short3& a,
    short s
    );

__device__ __forceinline__ uchar4
cv::cudev::operator<=(
    int s,
    const int4& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator<=(
    const int1& a,
    int s
    );

__device__ __forceinline__ uchar2
cv::cudev::operator<=(
    int s,
    const int2& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator<=(
    int s,
    const int1& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator<=(
    const int2& a,
    int s
    );

__device__ __forceinline__ uchar4
cv::cudev::operator<=(
    const int4& a,
    int s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator<=(
    const int3& a,
    int s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator<=(
    int s,
    const int3& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator<=(
    uint s,
    const uint4& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator<=(
    const uint4& a,
    uint s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator<=(
    uint s,
    const uint3& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator<=(
    const uint1& a,
    uint s
    );

__device__ __forceinline__ uchar1
cv::cudev::operator<=(
    uint s,
    const uint1& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator<=(
    uint s,
    const uint2& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator<=(
    const uint2& a,
    uint s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator<=(
    const uint3& a,
    uint s
    );

__device__ __forceinline__ uchar1
cv::cudev::operator<=(
    float s,
    const float1& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator<=(
    const float2& a,
    float s
    );

__device__ __forceinline__ uchar1
cv::cudev::operator<=(
    const float1& a,
    float s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator<=(
    const float3& a,
    float s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator<=(
    float s,
    const float3& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator<=(
    float s,
    const float2& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator<=(
    float s,
    const float4& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator<=(
    const float4& a,
    float s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator<=(
    double s,
    const double3& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator<=(
    const double4& a,
    double s
    );

__device__ __forceinline__ uchar2
cv::cudev::operator<=(
    const double2& a,
    double s
    );

__device__ __forceinline__ uchar1
cv::cudev::operator<=(
    double s,
    const double1& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator<=(
    const double1& a,
    double s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator<=(
    const double3& a,
    double s
    );

__device__ __forceinline__ uchar2
cv::cudev::operator<=(
    double s,
    const double2& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator<=(
    double s,
    const double4& b
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, typename PtrTraits<Texture<T>>::ptr_type, equal_to<T>>>
cv::cudev::operator==(
    const Texture<T>& src1,
    const Texture<T>& src2
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, Binder1st<equal_to<T>>>>
cv::cudev::operator==(
    T val,
    const Texture<T>& src
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, typename PtrTraits<GpuMat_<T>>::ptr_type, equal_to<T>>>
cv::cudev::operator==(
    const GpuMat_<T>& src1,
    const GpuMat_<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, typename PtrTraits<GlobPtrSz<T>>::ptr_type, equal_to<T>>>
cv::cudev::operator==(
    const GpuMat_<T>& src1,
    const GlobPtrSz<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, typename PtrTraits<GpuMat_<T>>::ptr_type, equal_to<T>>>
cv::cudev::operator==(
    const GlobPtrSz<T>& src1,
    const GpuMat_<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, typename PtrTraits<Texture<T>>::ptr_type, equal_to<T>>>
cv::cudev::operator==(
    const GpuMat_<T>& src1,
    const Texture<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, typename PtrTraits<GpuMat_<T>>::ptr_type, equal_to<T>>>
cv::cudev::operator==(
    const Texture<T>& src1,
    const GpuMat_<T>& src2
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, typename PtrTraits<Body>::ptr_type, equal_to<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator==(
    const GpuMat_<T>& src1,
    const Expr<Body>& src2
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, typename PtrTraits<GpuMat_<T>>::ptr_type, equal_to<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator==(
    const Expr<Body>& src1,
    const GpuMat_<T>& src2
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, Binder2nd<equal_to<T>>>>
cv::cudev::operator==(
    const GpuMat_<T>& src,
    T val
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, Binder1st<equal_to<T>>>>
cv::cudev::operator==(
    T val,
    const GpuMat_<T>& src
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, typename PtrTraits<GlobPtrSz<T>>::ptr_type, equal_to<T>>>
cv::cudev::operator==(
    const GlobPtrSz<T>& src1,
    const GlobPtrSz<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, typename PtrTraits<Texture<T>>::ptr_type, equal_to<T>>>
cv::cudev::operator==(
    const GlobPtrSz<T>& src1,
    const Texture<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, typename PtrTraits<GlobPtrSz<T>>::ptr_type, equal_to<T>>>
cv::cudev::operator==(
    const Texture<T>& src1,
    const GlobPtrSz<T>& src2
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, typename PtrTraits<Body>::ptr_type, equal_to<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator==(
    const GlobPtrSz<T>& src1,
    const Expr<Body>& src2
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, Binder2nd<equal_to<T>>>>
cv::cudev::operator==(
    const GlobPtrSz<T>& src,
    T val
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, Binder1st<equal_to<T>>>>
cv::cudev::operator==(
    T val,
    const GlobPtrSz<T>& src
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, typename PtrTraits<Body>::ptr_type, equal_to<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator==(
    const Texture<T>& src1,
    const Expr<Body>& src2
    );

template <class Body>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, Binder2nd<equal_to<typename Body::value_type>>>>
cv::cudev::operator==(
    const Expr<Body>& a,
    typename Body::value_type val
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, typename PtrTraits<Texture<T>>::ptr_type, equal_to<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator==(
    const Expr<Body>& src1,
    const Texture<T>& src2
    );

template <class Body>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, Binder1st<equal_to<typename Body::value_type>>>>
cv::cudev::operator==(
    typename Body::value_type val,
    const Expr<Body>& a
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, typename PtrTraits<GlobPtrSz<T>>::ptr_type, equal_to<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator==(
    const Expr<Body>& src1,
    const GlobPtrSz<T>& src2
    );

template <
    class Body1,
    class Body2
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Body1>::ptr_type, typename PtrTraits<Body2>::ptr_type, equal_to<typename LargerType<typename PtrTraits<Body1>::value_type, typename PtrTraits<Body2>::value_type>::type>>>
cv::cudev::operator==(
    const Expr<Body1>& a,
    const Expr<Body2>& b
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, Binder2nd<equal_to<T>>>>
cv::cudev::operator==(
    const Texture<T>& src,
    T val
    );

__device__ __forceinline__ uchar2
cv::cudev::operator==(
    const uchar2& a,
    const uchar2& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator==(
    const uchar3& a,
    const uchar3& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator==(
    const uchar4& a,
    const uchar4& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator==(
    const uchar1& a,
    const uchar1& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator==(
    const char1& a,
    const char1& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator==(
    const char2& a,
    const char2& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator==(
    const char4& a,
    const char4& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator==(
    const char3& a,
    const char3& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator==(
    const ushort2& a,
    const ushort2& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator==(
    const ushort1& a,
    const ushort1& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator==(
    const ushort4& a,
    const ushort4& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator==(
    const ushort3& a,
    const ushort3& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator==(
    const short4& a,
    const short4& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator==(
    const short2& a,
    const short2& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator==(
    const short1& a,
    const short1& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator==(
    const short3& a,
    const short3& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator==(
    const int4& a,
    const int4& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator==(
    const int1& a,
    const int1& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator==(
    const int2& a,
    const int2& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator==(
    const int3& a,
    const int3& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator==(
    const uint3& a,
    const uint3& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator==(
    const uint4& a,
    const uint4& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator==(
    const uint2& a,
    const uint2& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator==(
    const uint1& a,
    const uint1& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator==(
    const float2& a,
    const float2& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator==(
    const float4& a,
    const float4& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator==(
    const float3& a,
    const float3& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator==(
    const float1& a,
    const float1& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator==(
    const double3& a,
    const double3& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator==(
    const double2& a,
    const double2& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator==(
    const double1& a,
    const double1& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator==(
    const double4& a,
    const double4& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator==(
    uchar s,
    const uchar1& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator==(
    const uchar2& a,
    uchar s
    );

__device__ __forceinline__ uchar1
cv::cudev::operator==(
    const uchar1& a,
    uchar s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator==(
    const uchar3& a,
    uchar s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator==(
    uchar s,
    const uchar3& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator==(
    const uchar4& a,
    uchar s
    );

__device__ __forceinline__ uchar2
cv::cudev::operator==(
    uchar s,
    const uchar2& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator==(
    uchar s,
    const uchar4& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator==(
    const char2& a,
    char s
    );

__device__ __forceinline__ uchar1
cv::cudev::operator==(
    const char1& a,
    char s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator==(
    const char3& a,
    char s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator==(
    char s,
    const char3& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator==(
    char s,
    const char2& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator==(
    char s,
    const char4& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator==(
    char s,
    const char1& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator==(
    const char4& a,
    char s
    );

__device__ __forceinline__ uchar1
cv::cudev::operator==(
    ushort s,
    const ushort1& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator==(
    const ushort2& a,
    ushort s
    );

__device__ __forceinline__ uchar1
cv::cudev::operator==(
    const ushort1& a,
    ushort s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator==(
    const ushort3& a,
    ushort s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator==(
    ushort s,
    const ushort3& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator==(
    const ushort4& a,
    ushort s
    );

__device__ __forceinline__ uchar2
cv::cudev::operator==(
    ushort s,
    const ushort2& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator==(
    ushort s,
    const ushort4& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator==(
    const short4& a,
    short s
    );

__device__ __forceinline__ uchar1
cv::cudev::operator==(
    const short1& a,
    short s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator==(
    const short3& a,
    short s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator==(
    short s,
    const short3& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator==(
    short s,
    const short2& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator==(
    short s,
    const short4& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator==(
    short s,
    const short1& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator==(
    const short2& a,
    short s
    );

__device__ __forceinline__ uchar2
cv::cudev::operator==(
    const int2& a,
    int s
    );

__device__ __forceinline__ uchar1
cv::cudev::operator==(
    const int1& a,
    int s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator==(
    const int3& a,
    int s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator==(
    int s,
    const int3& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator==(
    int s,
    const int4& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator==(
    int s,
    const int2& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator==(
    const int4& a,
    int s
    );

__device__ __forceinline__ uchar1
cv::cudev::operator==(
    int s,
    const int1& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator==(
    const uint2& a,
    uint s
    );

__device__ __forceinline__ uchar1
cv::cudev::operator==(
    const uint1& a,
    uint s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator==(
    const uint3& a,
    uint s
    );

__device__ __forceinline__ uchar4
cv::cudev::operator==(
    const uint4& a,
    uint s
    );

__device__ __forceinline__ uchar1
cv::cudev::operator==(
    uint s,
    const uint1& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator==(
    uint s,
    const uint2& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator==(
    uint s,
    const uint3& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator==(
    uint s,
    const uint4& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator==(
    const float1& a,
    float s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator==(
    const float3& a,
    float s
    );

__device__ __forceinline__ uchar2
cv::cudev::operator==(
    const float2& a,
    float s
    );

__device__ __forceinline__ uchar2
cv::cudev::operator==(
    float s,
    const float2& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator==(
    float s,
    const float3& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator==(
    const float4& a,
    float s
    );

__device__ __forceinline__ uchar1
cv::cudev::operator==(
    float s,
    const float1& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator==(
    float s,
    const float4& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator==(
    double s,
    const double2& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator==(
    const double1& a,
    double s
    );

__device__ __forceinline__ uchar4
cv::cudev::operator==(
    const double4& a,
    double s
    );

__device__ __forceinline__ uchar2
cv::cudev::operator==(
    const double2& a,
    double s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator==(
    const double3& a,
    double s
    );

__device__ __forceinline__ uchar4
cv::cudev::operator==(
    double s,
    const double4& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator==(
    double s,
    const double3& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator==(
    double s,
    const double1& b
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, typename PtrTraits<Body>::ptr_type, greater<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator>(
    const Texture<T>& src1,
    const Expr<Body>& src2
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, Binder2nd<greater<T>>>>
cv::cudev::operator>(
    const Texture<T>& src,
    T val
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, typename PtrTraits<Texture<T>>::ptr_type, greater<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator>(
    const Expr<Body>& src1,
    const Texture<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, typename PtrTraits<Texture<T>>::ptr_type, greater<T>>>
cv::cudev::operator>(
    const Texture<T>& src1,
    const Texture<T>& src2
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, Binder2nd<greater<T>>>>
cv::cudev::operator>(
    const GpuMat_<T>& src,
    T val
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, typename PtrTraits<GlobPtrSz<T>>::ptr_type, greater<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator>(
    const Expr<Body>& src1,
    const GlobPtrSz<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, typename PtrTraits<GpuMat_<T>>::ptr_type, greater<T>>>
cv::cudev::operator>(
    const GpuMat_<T>& src1,
    const GpuMat_<T>& src2
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, typename PtrTraits<Body>::ptr_type, greater<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator>(
    const GpuMat_<T>& src1,
    const Expr<Body>& src2
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, Binder2nd<greater<T>>>>
cv::cudev::operator>(
    const GlobPtrSz<T>& src,
    T val
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, typename PtrTraits<GlobPtrSz<T>>::ptr_type, greater<T>>>
cv::cudev::operator>(
    const GpuMat_<T>& src1,
    const GlobPtrSz<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, typename PtrTraits<GpuMat_<T>>::ptr_type, greater<T>>>
cv::cudev::operator>(
    const GlobPtrSz<T>& src1,
    const GpuMat_<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, typename PtrTraits<Texture<T>>::ptr_type, greater<T>>>
cv::cudev::operator>(
    const GpuMat_<T>& src1,
    const Texture<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, typename PtrTraits<GlobPtrSz<T>>::ptr_type, greater<T>>>
cv::cudev::operator>(
    const GlobPtrSz<T>& src1,
    const GlobPtrSz<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, typename PtrTraits<Texture<T>>::ptr_type, greater<T>>>
cv::cudev::operator>(
    const GlobPtrSz<T>& src1,
    const Texture<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, typename PtrTraits<GlobPtrSz<T>>::ptr_type, greater<T>>>
cv::cudev::operator>(
    const Texture<T>& src1,
    const GlobPtrSz<T>& src2
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, Binder1st<greater<T>>>>
cv::cudev::operator>(
    T val,
    const GlobPtrSz<T>& src
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, Binder1st<greater<T>>>>
cv::cudev::operator>(
    T val,
    const Texture<T>& src
    );

template <
    class Body1,
    class Body2
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Body1>::ptr_type, typename PtrTraits<Body2>::ptr_type, greater<typename LargerType<typename PtrTraits<Body1>::value_type, typename PtrTraits<Body2>::value_type>::type>>>
cv::cudev::operator>(
    const Expr<Body1>& a,
    const Expr<Body2>& b
    );

template <class Body>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, Binder2nd<greater<typename Body::value_type>>>>
cv::cudev::operator>(
    const Expr<Body>& a,
    typename Body::value_type val
    );

template <class Body>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, Binder1st<greater<typename Body::value_type>>>>
cv::cudev::operator>(
    typename Body::value_type val,
    const Expr<Body>& a
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, Binder1st<greater<T>>>>
cv::cudev::operator>(
    T val,
    const GpuMat_<T>& src
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, typename PtrTraits<GpuMat_<T>>::ptr_type, greater<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator>(
    const Expr<Body>& src1,
    const GpuMat_<T>& src2
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, typename PtrTraits<Body>::ptr_type, greater<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator>(
    const GlobPtrSz<T>& src1,
    const Expr<Body>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, typename PtrTraits<GpuMat_<T>>::ptr_type, greater<T>>>
cv::cudev::operator>(
    const Texture<T>& src1,
    const GpuMat_<T>& src2
    );

__device__ __forceinline__ uchar3
cv::cudev::operator>(
    const uchar3& a,
    const uchar3& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator>(
    const uchar4& a,
    const uchar4& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator>(
    const uchar1& a,
    const uchar1& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator>(
    const uchar2& a,
    const uchar2& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator>(
    const char3& a,
    const char3& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator>(
    const char4& a,
    const char4& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator>(
    const char2& a,
    const char2& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator>(
    const char1& a,
    const char1& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator>(
    const ushort2& a,
    const ushort2& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator>(
    const ushort3& a,
    const ushort3& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator>(
    const ushort4& a,
    const ushort4& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator>(
    const ushort1& a,
    const ushort1& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator>(
    const short1& a,
    const short1& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator>(
    const short2& a,
    const short2& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator>(
    const short4& a,
    const short4& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator>(
    const short3& a,
    const short3& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator>(
    const int2& a,
    const int2& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator>(
    const int4& a,
    const int4& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator>(
    const int3& a,
    const int3& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator>(
    const int1& a,
    const int1& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator>(
    const uint1& a,
    const uint1& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator>(
    const uint3& a,
    const uint3& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator>(
    const uint4& a,
    const uint4& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator>(
    const uint2& a,
    const uint2& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator>(
    const float4& a,
    const float4& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator>(
    const float2& a,
    const float2& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator>(
    const float3& a,
    const float3& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator>(
    const float1& a,
    const float1& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator>(
    const double1& a,
    const double1& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator>(
    const double4& a,
    const double4& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator>(
    const double3& a,
    const double3& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator>(
    const double2& a,
    const double2& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator>(
    const uchar4& a,
    uchar s
    );

__device__ __forceinline__ uchar2
cv::cudev::operator>(
    const uchar2& a,
    uchar s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator>(
    const uchar3& a,
    uchar s
    );

__device__ __forceinline__ uchar1
cv::cudev::operator>(
    const uchar1& a,
    uchar s
    );

__device__ __forceinline__ uchar4
cv::cudev::operator>(
    uchar s,
    const uchar4& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator>(
    uchar s,
    const uchar1& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator>(
    uchar s,
    const uchar2& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator>(
    uchar s,
    const uchar3& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator>(
    char s,
    const char1& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator>(
    const char1& a,
    char s
    );

__device__ __forceinline__ uchar4
cv::cudev::operator>(
    const char4& a,
    char s
    );

__device__ __forceinline__ uchar4
cv::cudev::operator>(
    char s,
    const char4& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator>(
    const char2& a,
    char s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator>(
    const char3& a,
    char s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator>(
    char s,
    const char3& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator>(
    char s,
    const char2& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator>(
    ushort s,
    const ushort4& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator>(
    ushort s,
    const ushort3& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator>(
    const ushort2& a,
    ushort s
    );

__device__ __forceinline__ uchar1
cv::cudev::operator>(
    const ushort1& a,
    ushort s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator>(
    const ushort3& a,
    ushort s
    );

__device__ __forceinline__ uchar2
cv::cudev::operator>(
    ushort s,
    const ushort2& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator>(
    ushort s,
    const ushort1& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator>(
    const ushort4& a,
    ushort s
    );

__device__ __forceinline__ uchar1
cv::cudev::operator>(
    const short1& a,
    short s
    );

__device__ __forceinline__ uchar4
cv::cudev::operator>(
    const short4& a,
    short s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator>(
    const short3& a,
    short s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator>(
    short s,
    const short3& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator>(
    short s,
    const short4& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator>(
    short s,
    const short2& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator>(
    short s,
    const short1& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator>(
    const short2& a,
    short s
    );

__device__ __forceinline__ uchar4
cv::cudev::operator>(
    const int4& a,
    int s
    );

__device__ __forceinline__ uchar1
cv::cudev::operator>(
    int s,
    const int1& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator>(
    const int1& a,
    int s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator>(
    const int3& a,
    int s
    );

__device__ __forceinline__ uchar4
cv::cudev::operator>(
    int s,
    const int4& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator>(
    const int2& a,
    int s
    );

__device__ __forceinline__ uchar2
cv::cudev::operator>(
    int s,
    const int2& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator>(
    int s,
    const int3& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator>(
    const uint3& a,
    uint s
    );

__device__ __forceinline__ uchar4
cv::cudev::operator>(
    const uint4& a,
    uint s
    );

__device__ __forceinline__ uchar4
cv::cudev::operator>(
    uint s,
    const uint4& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator>(
    const uint1& a,
    uint s
    );

__device__ __forceinline__ uchar1
cv::cudev::operator>(
    uint s,
    const uint1& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator>(
    uint s,
    const uint3& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator>(
    uint s,
    const uint2& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator>(
    const uint2& a,
    uint s
    );

__device__ __forceinline__ uchar4
cv::cudev::operator>(
    float s,
    const float4& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator>(
    const float3& a,
    float s
    );

__device__ __forceinline__ uchar2
cv::cudev::operator>(
    const float2& a,
    float s
    );

__device__ __forceinline__ uchar1
cv::cudev::operator>(
    const float1& a,
    float s
    );

__device__ __forceinline__ uchar2
cv::cudev::operator>(
    float s,
    const float2& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator>(
    float s,
    const float3& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator>(
    float s,
    const float1& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator>(
    const float4& a,
    float s
    );

__device__ __forceinline__ uchar4
cv::cudev::operator>(
    double s,
    const double4& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator>(
    const double2& a,
    double s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator>(
    double s,
    const double3& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator>(
    const double3& a,
    double s
    );

__device__ __forceinline__ uchar4
cv::cudev::operator>(
    const double4& a,
    double s
    );

__device__ __forceinline__ uchar2
cv::cudev::operator>(
    double s,
    const double2& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator>(
    const double1& a,
    double s
    );

__device__ __forceinline__ uchar1
cv::cudev::operator>(
    double s,
    const double1& b
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, Binder2nd<greater_equal<T>>>>
cv::cudev::operator>=(
    const GlobPtrSz<T>& src,
    T val
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, Binder1st<greater_equal<T>>>>
cv::cudev::operator>=(
    T val,
    const GlobPtrSz<T>& src
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, typename PtrTraits<GpuMat_<T>>::ptr_type, greater_equal<T>>>
cv::cudev::operator>=(
    const Texture<T>& src1,
    const GpuMat_<T>& src2
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, typename PtrTraits<GlobPtrSz<T>>::ptr_type, greater_equal<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator>=(
    const Expr<Body>& src1,
    const GlobPtrSz<T>& src2
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, typename PtrTraits<Body>::ptr_type, greater_equal<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator>=(
    const GlobPtrSz<T>& src1,
    const Expr<Body>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, typename PtrTraits<GlobPtrSz<T>>::ptr_type, greater_equal<T>>>
cv::cudev::operator>=(
    const Texture<T>& src1,
    const GlobPtrSz<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, typename PtrTraits<Texture<T>>::ptr_type, greater_equal<T>>>
cv::cudev::operator>=(
    const GlobPtrSz<T>& src1,
    const Texture<T>& src2
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, typename PtrTraits<Body>::ptr_type, greater_equal<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator>=(
    const GpuMat_<T>& src1,
    const Expr<Body>& src2
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, typename PtrTraits<GpuMat_<T>>::ptr_type, greater_equal<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator>=(
    const Expr<Body>& src1,
    const GpuMat_<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, typename PtrTraits<GpuMat_<T>>::ptr_type, greater_equal<T>>>
cv::cudev::operator>=(
    const GpuMat_<T>& src1,
    const GpuMat_<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, typename PtrTraits<GpuMat_<T>>::ptr_type, greater_equal<T>>>
cv::cudev::operator>=(
    const GlobPtrSz<T>& src1,
    const GpuMat_<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, typename PtrTraits<GlobPtrSz<T>>::ptr_type, greater_equal<T>>>
cv::cudev::operator>=(
    const GpuMat_<T>& src1,
    const GlobPtrSz<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, typename PtrTraits<Texture<T>>::ptr_type, greater_equal<T>>>
cv::cudev::operator>=(
    const GpuMat_<T>& src1,
    const Texture<T>& src2
    );

template <class Body>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, Binder1st<greater_equal<typename Body::value_type>>>>
cv::cudev::operator>=(
    typename Body::value_type val,
    const Expr<Body>& a
    );

template <class Body>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, Binder2nd<greater_equal<typename Body::value_type>>>>
cv::cudev::operator>=(
    const Expr<Body>& a,
    typename Body::value_type val
    );

template <
    class Body1,
    class Body2
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Body1>::ptr_type, typename PtrTraits<Body2>::ptr_type, greater_equal<typename LargerType<typename PtrTraits<Body1>::value_type, typename PtrTraits<Body2>::value_type>::type>>>
cv::cudev::operator>=(
    const Expr<Body1>& a,
    const Expr<Body2>& b
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, Binder2nd<greater_equal<T>>>>
cv::cudev::operator>=(
    const GpuMat_<T>& src,
    T val
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, typename PtrTraits<GlobPtrSz<T>>::ptr_type, greater_equal<T>>>
cv::cudev::operator>=(
    const GlobPtrSz<T>& src1,
    const GlobPtrSz<T>& src2
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, Binder1st<greater_equal<T>>>>
cv::cudev::operator>=(
    T val,
    const GpuMat_<T>& src
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, Binder2nd<greater_equal<T>>>>
cv::cudev::operator>=(
    const Texture<T>& src,
    T val
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, typename PtrTraits<Texture<T>>::ptr_type, greater_equal<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator>=(
    const Expr<Body>& src1,
    const Texture<T>& src2
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, typename PtrTraits<Body>::ptr_type, greater_equal<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator>=(
    const Texture<T>& src1,
    const Expr<Body>& src2
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, Binder1st<greater_equal<T>>>>
cv::cudev::operator>=(
    T val,
    const Texture<T>& src
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, typename PtrTraits<Texture<T>>::ptr_type, greater_equal<T>>>
cv::cudev::operator>=(
    const Texture<T>& src1,
    const Texture<T>& src2
    );

__device__ __forceinline__ uchar2
cv::cudev::operator>=(
    const uchar2& a,
    const uchar2& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator>=(
    const uchar4& a,
    const uchar4& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator>=(
    const uchar1& a,
    const uchar1& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator>=(
    const uchar3& a,
    const uchar3& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator>=(
    const char2& a,
    const char2& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator>=(
    const char4& a,
    const char4& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator>=(
    const char1& a,
    const char1& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator>=(
    const char3& a,
    const char3& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator>=(
    const ushort2& a,
    const ushort2& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator>=(
    const ushort4& a,
    const ushort4& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator>=(
    const ushort3& a,
    const ushort3& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator>=(
    const ushort1& a,
    const ushort1& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator>=(
    const short2& a,
    const short2& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator>=(
    const short3& a,
    const short3& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator>=(
    const short4& a,
    const short4& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator>=(
    const short1& a,
    const short1& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator>=(
    const int4& a,
    const int4& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator>=(
    const int3& a,
    const int3& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator>=(
    const int2& a,
    const int2& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator>=(
    const int1& a,
    const int1& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator>=(
    const uint2& a,
    const uint2& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator>=(
    const uint4& a,
    const uint4& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator>=(
    const uint3& a,
    const uint3& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator>=(
    const uint1& a,
    const uint1& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator>=(
    const float2& a,
    const float2& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator>=(
    const float4& a,
    const float4& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator>=(
    const float3& a,
    const float3& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator>=(
    const float1& a,
    const float1& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator>=(
    const double4& a,
    const double4& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator>=(
    const double3& a,
    const double3& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator>=(
    const double2& a,
    const double2& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator>=(
    const double1& a,
    const double1& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator>=(
    uchar s,
    const uchar4& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator>=(
    uchar s,
    const uchar1& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator>=(
    uchar s,
    const uchar2& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator>=(
    const uchar2& a,
    uchar s
    );

__device__ __forceinline__ uchar1
cv::cudev::operator>=(
    const uchar1& a,
    uchar s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator>=(
    const uchar3& a,
    uchar s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator>=(
    uchar s,
    const uchar3& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator>=(
    const uchar4& a,
    uchar s
    );

__device__ __forceinline__ uchar4
cv::cudev::operator>=(
    char s,
    const char4& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator>=(
    const char1& a,
    char s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator>=(
    const char3& a,
    char s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator>=(
    char s,
    const char3& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator>=(
    const char2& a,
    char s
    );

__device__ __forceinline__ uchar4
cv::cudev::operator>=(
    const char4& a,
    char s
    );

__device__ __forceinline__ uchar1
cv::cudev::operator>=(
    char s,
    const char1& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator>=(
    char s,
    const char2& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator>=(
    const ushort2& a,
    ushort s
    );

__device__ __forceinline__ uchar2
cv::cudev::operator>=(
    ushort s,
    const ushort2& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator>=(
    ushort s,
    const ushort3& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator>=(
    ushort s,
    const ushort4& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator>=(
    const ushort1& a,
    ushort s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator>=(
    const ushort3& a,
    ushort s
    );

__device__ __forceinline__ uchar4
cv::cudev::operator>=(
    const ushort4& a,
    ushort s
    );

__device__ __forceinline__ uchar1
cv::cudev::operator>=(
    ushort s,
    const ushort1& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator>=(
    short s,
    const short2& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator>=(
    const short1& a,
    short s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator>=(
    const short3& a,
    short s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator>=(
    short s,
    const short3& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator>=(
    const short4& a,
    short s
    );

__device__ __forceinline__ uchar4
cv::cudev::operator>=(
    short s,
    const short4& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator>=(
    const short2& a,
    short s
    );

__device__ __forceinline__ uchar1
cv::cudev::operator>=(
    short s,
    const short1& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator>=(
    int s,
    const int4& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator>=(
    int s,
    const int3& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator>=(
    const int1& a,
    int s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator>=(
    const int3& a,
    int s
    );

__device__ __forceinline__ uchar2
cv::cudev::operator>=(
    const int2& a,
    int s
    );

__device__ __forceinline__ uchar4
cv::cudev::operator>=(
    const int4& a,
    int s
    );

__device__ __forceinline__ uchar2
cv::cudev::operator>=(
    int s,
    const int2& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator>=(
    int s,
    const int1& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator>=(
    const uint2& a,
    uint s
    );

__device__ __forceinline__ uchar1
cv::cudev::operator>=(
    uint s,
    const uint1& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator>=(
    uint s,
    const uint3& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator>=(
    const uint3& a,
    uint s
    );

__device__ __forceinline__ uchar4
cv::cudev::operator>=(
    const uint4& a,
    uint s
    );

__device__ __forceinline__ uchar1
cv::cudev::operator>=(
    const uint1& a,
    uint s
    );

__device__ __forceinline__ uchar4
cv::cudev::operator>=(
    uint s,
    const uint4& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator>=(
    uint s,
    const uint2& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator>=(
    float s,
    const float2& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator>=(
    float s,
    const float3& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator>=(
    float s,
    const float4& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator>=(
    const float2& a,
    float s
    );

__device__ __forceinline__ uchar1
cv::cudev::operator>=(
    const float1& a,
    float s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator>=(
    const float3& a,
    float s
    );

__device__ __forceinline__ uchar4
cv::cudev::operator>=(
    const float4& a,
    float s
    );

__device__ __forceinline__ uchar1
cv::cudev::operator>=(
    float s,
    const float1& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator>=(
    double s,
    const double2& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator>=(
    double s,
    const double4& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator>=(
    const double3& a,
    double s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator>=(
    double s,
    const double3& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator>=(
    const double1& a,
    double s
    );

__device__ __forceinline__ uchar4
cv::cudev::operator>=(
    const double4& a,
    double s
    );

__device__ __forceinline__ uchar2
cv::cudev::operator>=(
    const double2& a,
    double s
    );

__device__ __forceinline__ uchar1
cv::cudev::operator>=(
    double s,
    const double1& b
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, Binder1st<bit_rshift<T>>>>
cv::cudev::operator>>(
    T val,
    const GlobPtrSz<T>& src
    );

template <
    class Body1,
    class Body2
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Body1>::ptr_type, typename PtrTraits<Body2>::ptr_type, bit_rshift<typename LargerType<typename PtrTraits<Body1>::value_type, typename PtrTraits<Body2>::value_type>::type>>>
cv::cudev::operator>>(
    const Expr<Body1>& a,
    const Expr<Body2>& b
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, typename PtrTraits<GpuMat_<T>>::ptr_type, bit_rshift<T>>>
cv::cudev::operator>>(
    const GlobPtrSz<T>& src1,
    const GpuMat_<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, typename PtrTraits<GpuMat_<T>>::ptr_type, bit_rshift<T>>>
cv::cudev::operator>>(
    const GpuMat_<T>& src1,
    const GpuMat_<T>& src2
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, typename PtrTraits<Body>::ptr_type, bit_rshift<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator>>(
    const Texture<T>& src1,
    const Expr<Body>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, typename PtrTraits<Texture<T>>::ptr_type, bit_rshift<T>>>
cv::cudev::operator>>(
    const Texture<T>& src1,
    const Texture<T>& src2
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, Binder1st<bit_rshift<T>>>>
cv::cudev::operator>>(
    T val,
    const Texture<T>& src
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, Binder1st<bit_rshift<T>>>>
cv::cudev::operator>>(
    T val,
    const GpuMat_<T>& src
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, typename PtrTraits<Texture<T>>::ptr_type, bit_rshift<T>>>
cv::cudev::operator>>(
    const GpuMat_<T>& src1,
    const Texture<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, typename PtrTraits<GpuMat_<T>>::ptr_type, bit_rshift<T>>>
cv::cudev::operator>>(
    const Texture<T>& src1,
    const GpuMat_<T>& src2
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, typename PtrTraits<Body>::ptr_type, bit_rshift<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator>>(
    const GpuMat_<T>& src1,
    const Expr<Body>& src2
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, typename PtrTraits<GpuMat_<T>>::ptr_type, bit_rshift<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator>>(
    const Expr<Body>& src1,
    const GpuMat_<T>& src2
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, Binder2nd<bit_rshift<T>>>>
cv::cudev::operator>>(
    const GpuMat_<T>& src,
    T val
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, typename PtrTraits<GlobPtrSz<T>>::ptr_type, bit_rshift<T>>>
cv::cudev::operator>>(
    const GlobPtrSz<T>& src1,
    const GlobPtrSz<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, typename PtrTraits<Texture<T>>::ptr_type, bit_rshift<T>>>
cv::cudev::operator>>(
    const GlobPtrSz<T>& src1,
    const Texture<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, typename PtrTraits<GlobPtrSz<T>>::ptr_type, bit_rshift<T>>>
cv::cudev::operator>>(
    const Texture<T>& src1,
    const GlobPtrSz<T>& src2
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, typename PtrTraits<Body>::ptr_type, bit_rshift<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator>>(
    const GlobPtrSz<T>& src1,
    const Expr<Body>& src2
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, typename PtrTraits<GlobPtrSz<T>>::ptr_type, bit_rshift<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator>>(
    const Expr<Body>& src1,
    const GlobPtrSz<T>& src2
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, Binder2nd<bit_rshift<T>>>>
cv::cudev::operator>>(
    const GlobPtrSz<T>& src,
    T val
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, typename PtrTraits<GlobPtrSz<T>>::ptr_type, bit_rshift<T>>>
cv::cudev::operator>>(
    const GpuMat_<T>& src1,
    const GlobPtrSz<T>& src2
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, Binder2nd<bit_rshift<T>>>>
cv::cudev::operator>>(
    const Texture<T>& src,
    T val
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, typename PtrTraits<Texture<T>>::ptr_type, bit_rshift<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator>>(
    const Expr<Body>& src1,
    const Texture<T>& src2
    );

template <class Body>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, Binder1st<bit_rshift<typename Body::value_type>>>>
cv::cudev::operator>>(
    typename Body::value_type val,
    const Expr<Body>& a
    );

template <class Body>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, Binder2nd<bit_rshift<typename Body::value_type>>>>
cv::cudev::operator>>(
    const Expr<Body>& a,
    typename Body::value_type val
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, typename PtrTraits<GpuMat_<T>>::ptr_type, bit_xor<T>>>
cv::cudev::operator^(
    const GpuMat_<T>& src1,
    const GpuMat_<T>& src2
    );

template <class Body>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, Binder2nd<bit_xor<typename Body::value_type>>>>
cv::cudev::operator^(
    const Expr<Body>& a,
    typename Body::value_type val
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, typename PtrTraits<GlobPtrSz<T>>::ptr_type, bit_xor<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator^(
    const Expr<Body>& src1,
    const GlobPtrSz<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, typename PtrTraits<Texture<T>>::ptr_type, bit_xor<T>>>
cv::cudev::operator^(
    const Texture<T>& src1,
    const Texture<T>& src2
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, Binder2nd<bit_xor<T>>>>
cv::cudev::operator^(
    const Texture<T>& src,
    T val
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, typename PtrTraits<GlobPtrSz<T>>::ptr_type, bit_xor<T>>>
cv::cudev::operator^(
    const GpuMat_<T>& src1,
    const GlobPtrSz<T>& src2
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, typename PtrTraits<Body>::ptr_type, bit_xor<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator^(
    const Texture<T>& src1,
    const Expr<Body>& src2
    );

template <
    class Body1,
    class Body2
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Body1>::ptr_type, typename PtrTraits<Body2>::ptr_type, bit_xor<typename LargerType<typename PtrTraits<Body1>::value_type, typename PtrTraits<Body2>::value_type>::type>>>
cv::cudev::operator^(
    const Expr<Body1>& a,
    const Expr<Body2>& b
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, typename PtrTraits<Body>::ptr_type, bit_xor<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator^(
    const GlobPtrSz<T>& src1,
    const Expr<Body>& src2
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, Binder2nd<bit_xor<T>>>>
cv::cudev::operator^(
    const GpuMat_<T>& src,
    T val
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, typename PtrTraits<GpuMat_<T>>::ptr_type, bit_xor<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator^(
    const Expr<Body>& src1,
    const GpuMat_<T>& src2
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, Binder1st<bit_xor<T>>>>
cv::cudev::operator^(
    T val,
    const GlobPtrSz<T>& src
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, Binder2nd<bit_xor<T>>>>
cv::cudev::operator^(
    const GlobPtrSz<T>& src,
    T val
    );

template <class Body>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, Binder1st<bit_xor<typename Body::value_type>>>>
cv::cudev::operator^(
    typename Body::value_type val,
    const Expr<Body>& a
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, typename PtrTraits<GpuMat_<T>>::ptr_type, bit_xor<T>>>
cv::cudev::operator^(
    const Texture<T>& src1,
    const GpuMat_<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, typename PtrTraits<GpuMat_<T>>::ptr_type, bit_xor<T>>>
cv::cudev::operator^(
    const GlobPtrSz<T>& src1,
    const GpuMat_<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, typename PtrTraits<GlobPtrSz<T>>::ptr_type, bit_xor<T>>>
cv::cudev::operator^(
    const Texture<T>& src1,
    const GlobPtrSz<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, typename PtrTraits<Texture<T>>::ptr_type, bit_xor<T>>>
cv::cudev::operator^(
    const GlobPtrSz<T>& src1,
    const Texture<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, typename PtrTraits<GlobPtrSz<T>>::ptr_type, bit_xor<T>>>
cv::cudev::operator^(
    const GlobPtrSz<T>& src1,
    const GlobPtrSz<T>& src2
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, Binder1st<bit_xor<T>>>>
cv::cudev::operator^(
    T val,
    const GpuMat_<T>& src
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, typename PtrTraits<Texture<T>>::ptr_type, bit_xor<T>>>
cv::cudev::operator^(
    const GpuMat_<T>& src1,
    const Texture<T>& src2
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, typename PtrTraits<Texture<T>>::ptr_type, bit_xor<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator^(
    const Expr<Body>& src1,
    const Texture<T>& src2
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, typename PtrTraits<Body>::ptr_type, bit_xor<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator^(
    const GpuMat_<T>& src1,
    const Expr<Body>& src2
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, Binder1st<bit_xor<T>>>>
cv::cudev::operator^(
    T val,
    const Texture<T>& src
    );

__device__ __forceinline__ uchar1
cv::cudev::operator^(
    const uchar1& a,
    const uchar1& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator^(
    const uchar2& a,
    const uchar2& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator^(
    const uchar3& a,
    const uchar3& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator^(
    const uchar4& a,
    const uchar4& b
    );

__device__ __forceinline__ char1
cv::cudev::operator^(
    const char1& a,
    const char1& b
    );

__device__ __forceinline__ char2
cv::cudev::operator^(
    const char2& a,
    const char2& b
    );

__device__ __forceinline__ char4
cv::cudev::operator^(
    const char4& a,
    const char4& b
    );

__device__ __forceinline__ char3
cv::cudev::operator^(
    const char3& a,
    const char3& b
    );

__device__ __forceinline__ ushort1
cv::cudev::operator^(
    const ushort1& a,
    const ushort1& b
    );

__device__ __forceinline__ ushort4
cv::cudev::operator^(
    const ushort4& a,
    const ushort4& b
    );

__device__ __forceinline__ ushort2
cv::cudev::operator^(
    const ushort2& a,
    const ushort2& b
    );

__device__ __forceinline__ ushort3
cv::cudev::operator^(
    const ushort3& a,
    const ushort3& b
    );

__device__ __forceinline__ short1
cv::cudev::operator^(
    const short1& a,
    const short1& b
    );

__device__ __forceinline__ short2
cv::cudev::operator^(
    const short2& a,
    const short2& b
    );

__device__ __forceinline__ short4
cv::cudev::operator^(
    const short4& a,
    const short4& b
    );

__device__ __forceinline__ short3
cv::cudev::operator^(
    const short3& a,
    const short3& b
    );

__device__ __forceinline__ int1
cv::cudev::operator^(
    const int1& a,
    const int1& b
    );

__device__ __forceinline__ int4
cv::cudev::operator^(
    const int4& a,
    const int4& b
    );

__device__ __forceinline__ int2
cv::cudev::operator^(
    const int2& a,
    const int2& b
    );

__device__ __forceinline__ int3
cv::cudev::operator^(
    const int3& a,
    const int3& b
    );

__device__ __forceinline__ uint1
cv::cudev::operator^(
    const uint1& a,
    const uint1& b
    );

__device__ __forceinline__ uint3
cv::cudev::operator^(
    const uint3& a,
    const uint3& b
    );

__device__ __forceinline__ uint2
cv::cudev::operator^(
    const uint2& a,
    const uint2& b
    );

__device__ __forceinline__ uint4
cv::cudev::operator^(
    const uint4& a,
    const uint4& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator^(
    uchar s,
    const uchar3& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator^(
    const uchar3& a,
    uchar s
    );

__device__ __forceinline__ uchar4
cv::cudev::operator^(
    uchar s,
    const uchar4& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator^(
    uchar s,
    const uchar1& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator^(
    const uchar2& a,
    uchar s
    );

__device__ __forceinline__ uchar2
cv::cudev::operator^(
    uchar s,
    const uchar2& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator^(
    const uchar1& a,
    uchar s
    );

__device__ __forceinline__ uchar4
cv::cudev::operator^(
    const uchar4& a,
    uchar s
    );

__device__ __forceinline__ char3
cv::cudev::operator^(
    const char3& a,
    char s
    );

__device__ __forceinline__ char1
cv::cudev::operator^(
    const char1& a,
    char s
    );

__device__ __forceinline__ char1
cv::cudev::operator^(
    char s,
    const char1& b
    );

__device__ __forceinline__ char2
cv::cudev::operator^(
    char s,
    const char2& b
    );

__device__ __forceinline__ char4
cv::cudev::operator^(
    char s,
    const char4& b
    );

__device__ __forceinline__ char3
cv::cudev::operator^(
    char s,
    const char3& b
    );

__device__ __forceinline__ char2
cv::cudev::operator^(
    const char2& a,
    char s
    );

__device__ __forceinline__ char4
cv::cudev::operator^(
    const char4& a,
    char s
    );

__device__ __forceinline__ ushort1
cv::cudev::operator^(
    const ushort1& a,
    ushort s
    );

__device__ __forceinline__ ushort3
cv::cudev::operator^(
    ushort s,
    const ushort3& b
    );

__device__ __forceinline__ ushort4
cv::cudev::operator^(
    ushort s,
    const ushort4& b
    );

__device__ __forceinline__ ushort4
cv::cudev::operator^(
    const ushort4& a,
    ushort s
    );

__device__ __forceinline__ ushort2
cv::cudev::operator^(
    ushort s,
    const ushort2& b
    );

__device__ __forceinline__ ushort3
cv::cudev::operator^(
    const ushort3& a,
    ushort s
    );

__device__ __forceinline__ ushort2
cv::cudev::operator^(
    const ushort2& a,
    ushort s
    );

__device__ __forceinline__ ushort1
cv::cudev::operator^(
    ushort s,
    const ushort1& b
    );

__device__ __forceinline__ short2
cv::cudev::operator^(
    const short2& a,
    short s
    );

__device__ __forceinline__ short2
cv::cudev::operator^(
    short s,
    const short2& b
    );

__device__ __forceinline__ short1
cv::cudev::operator^(
    short s,
    const short1& b
    );

__device__ __forceinline__ short3
cv::cudev::operator^(
    short s,
    const short3& b
    );

__device__ __forceinline__ short3
cv::cudev::operator^(
    const short3& a,
    short s
    );

__device__ __forceinline__ short4
cv::cudev::operator^(
    const short4& a,
    short s
    );

__device__ __forceinline__ short4
cv::cudev::operator^(
    short s,
    const short4& b
    );

__device__ __forceinline__ short1
cv::cudev::operator^(
    const short1& a,
    short s
    );

__device__ __forceinline__ int4
cv::cudev::operator^(
    int s,
    const int4& b
    );

__device__ __forceinline__ int1
cv::cudev::operator^(
    int s,
    const int1& b
    );

__device__ __forceinline__ int2
cv::cudev::operator^(
    int s,
    const int2& b
    );

__device__ __forceinline__ int3
cv::cudev::operator^(
    const int3& a,
    int s
    );

__device__ __forceinline__ int3
cv::cudev::operator^(
    int s,
    const int3& b
    );

__device__ __forceinline__ int2
cv::cudev::operator^(
    const int2& a,
    int s
    );

__device__ __forceinline__ int1
cv::cudev::operator^(
    const int1& a,
    int s
    );

__device__ __forceinline__ int4
cv::cudev::operator^(
    const int4& a,
    int s
    );

__device__ __forceinline__ uint4
cv::cudev::operator^(
    const uint4& a,
    uint s
    );

__device__ __forceinline__ uint1
cv::cudev::operator^(
    const uint1& a,
    uint s
    );

__device__ __forceinline__ uint2
cv::cudev::operator^(
    const uint2& a,
    uint s
    );

__device__ __forceinline__ uint2
cv::cudev::operator^(
    uint s,
    const uint2& b
    );

__device__ __forceinline__ uint3
cv::cudev::operator^(
    uint s,
    const uint3& b
    );

__device__ __forceinline__ uint1
cv::cudev::operator^(
    uint s,
    const uint1& b
    );

__device__ __forceinline__ uint3
cv::cudev::operator^(
    const uint3& a,
    uint s
    );

__device__ __forceinline__ uint4
cv::cudev::operator^(
    uint s,
    const uint4& b
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, Binder2nd<bit_or<T>>>>
cv::cudev::operator|(
    const GlobPtrSz<T>& src,
    T val
    );

template <class Body>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, Binder1st<bit_or<typename Body::value_type>>>>
cv::cudev::operator|(
    typename Body::value_type val,
    const Expr<Body>& a
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, typename PtrTraits<GlobPtrSz<T>>::ptr_type, bit_or<T>>>
cv::cudev::operator|(
    const Texture<T>& src1,
    const GlobPtrSz<T>& src2
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, Binder2nd<bit_or<T>>>>
cv::cudev::operator|(
    const Texture<T>& src,
    T val
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, typename PtrTraits<Texture<T>>::ptr_type, bit_or<T>>>
cv::cudev::operator|(
    const Texture<T>& src1,
    const Texture<T>& src2
    );

template <
    class Body1,
    class Body2
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Body1>::ptr_type, typename PtrTraits<Body2>::ptr_type, bit_or<typename LargerType<typename PtrTraits<Body1>::value_type, typename PtrTraits<Body2>::value_type>::type>>>
cv::cudev::operator|(
    const Expr<Body1>& a,
    const Expr<Body2>& b
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, typename PtrTraits<Texture<T>>::ptr_type, bit_or<T>>>
cv::cudev::operator|(
    const GpuMat_<T>& src1,
    const Texture<T>& src2
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, typename PtrTraits<Body>::ptr_type, bit_or<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator|(
    const GlobPtrSz<T>& src1,
    const Expr<Body>& src2
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, typename PtrTraits<GpuMat_<T>>::ptr_type, bit_or<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator|(
    const Expr<Body>& src1,
    const GpuMat_<T>& src2
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, typename PtrTraits<Texture<T>>::ptr_type, bit_or<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator|(
    const Expr<Body>& src1,
    const Texture<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, typename PtrTraits<GpuMat_<T>>::ptr_type, bit_or<T>>>
cv::cudev::operator|(
    const GpuMat_<T>& src1,
    const GpuMat_<T>& src2
    );

template <class Body>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, Binder2nd<bit_or<typename Body::value_type>>>>
cv::cudev::operator|(
    const Expr<Body>& a,
    typename Body::value_type val
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, Binder2nd<bit_or<T>>>>
cv::cudev::operator|(
    const GpuMat_<T>& src,
    T val
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, typename PtrTraits<Body>::ptr_type, bit_or<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator|(
    const Texture<T>& src1,
    const Expr<Body>& src2
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, typename PtrTraits<GlobPtrSz<T>>::ptr_type, bit_or<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator|(
    const Expr<Body>& src1,
    const GlobPtrSz<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, typename PtrTraits<GlobPtrSz<T>>::ptr_type, bit_or<T>>>
cv::cudev::operator|(
    const GpuMat_<T>& src1,
    const GlobPtrSz<T>& src2
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, Binder1st<bit_or<T>>>>
cv::cudev::operator|(
    T val,
    const GlobPtrSz<T>& src
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, typename PtrTraits<GpuMat_<T>>::ptr_type, bit_or<T>>>
cv::cudev::operator|(
    const Texture<T>& src1,
    const GpuMat_<T>& src2
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, Binder1st<bit_or<T>>>>
cv::cudev::operator|(
    T val,
    const GpuMat_<T>& src
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, typename PtrTraits<GpuMat_<T>>::ptr_type, bit_or<T>>>
cv::cudev::operator|(
    const GlobPtrSz<T>& src1,
    const GpuMat_<T>& src2
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, typename PtrTraits<Body>::ptr_type, bit_or<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator|(
    const GpuMat_<T>& src1,
    const Expr<Body>& src2
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, Binder1st<bit_or<T>>>>
cv::cudev::operator|(
    T val,
    const Texture<T>& src
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, typename PtrTraits<Texture<T>>::ptr_type, bit_or<T>>>
cv::cudev::operator|(
    const GlobPtrSz<T>& src1,
    const Texture<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, typename PtrTraits<GlobPtrSz<T>>::ptr_type, bit_or<T>>>
cv::cudev::operator|(
    const GlobPtrSz<T>& src1,
    const GlobPtrSz<T>& src2
    );

__device__ __forceinline__ uchar1
cv::cudev::operator|(
    const uchar1& a,
    const uchar1& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator|(
    const uchar3& a,
    const uchar3& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator|(
    const uchar4& a,
    const uchar4& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator|(
    const uchar2& a,
    const uchar2& b
    );

__device__ __forceinline__ char1
cv::cudev::operator|(
    const char1& a,
    const char1& b
    );

__device__ __forceinline__ char2
cv::cudev::operator|(
    const char2& a,
    const char2& b
    );

__device__ __forceinline__ char4
cv::cudev::operator|(
    const char4& a,
    const char4& b
    );

__device__ __forceinline__ char3
cv::cudev::operator|(
    const char3& a,
    const char3& b
    );

__device__ __forceinline__ ushort3
cv::cudev::operator|(
    const ushort3& a,
    const ushort3& b
    );

__device__ __forceinline__ ushort2
cv::cudev::operator|(
    const ushort2& a,
    const ushort2& b
    );

__device__ __forceinline__ ushort4
cv::cudev::operator|(
    const ushort4& a,
    const ushort4& b
    );

__device__ __forceinline__ ushort1
cv::cudev::operator|(
    const ushort1& a,
    const ushort1& b
    );

__device__ __forceinline__ short1
cv::cudev::operator|(
    const short1& a,
    const short1& b
    );

__device__ __forceinline__ short2
cv::cudev::operator|(
    const short2& a,
    const short2& b
    );

__device__ __forceinline__ short4
cv::cudev::operator|(
    const short4& a,
    const short4& b
    );

__device__ __forceinline__ short3
cv::cudev::operator|(
    const short3& a,
    const short3& b
    );

__device__ __forceinline__ int1
cv::cudev::operator|(
    const int1& a,
    const int1& b
    );

__device__ __forceinline__ int4
cv::cudev::operator|(
    const int4& a,
    const int4& b
    );

__device__ __forceinline__ int2
cv::cudev::operator|(
    const int2& a,
    const int2& b
    );

__device__ __forceinline__ int3
cv::cudev::operator|(
    const int3& a,
    const int3& b
    );

__device__ __forceinline__ uint1
cv::cudev::operator|(
    const uint1& a,
    const uint1& b
    );

__device__ __forceinline__ uint4
cv::cudev::operator|(
    const uint4& a,
    const uint4& b
    );

__device__ __forceinline__ uint3
cv::cudev::operator|(
    const uint3& a,
    const uint3& b
    );

__device__ __forceinline__ uint2
cv::cudev::operator|(
    const uint2& a,
    const uint2& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator|(
    const uchar1& a,
    uchar s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator|(
    uchar s,
    const uchar3& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator|(
    const uchar2& a,
    uchar s
    );

__device__ __forceinline__ uchar2
cv::cudev::operator|(
    uchar s,
    const uchar2& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator|(
    uchar s,
    const uchar4& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator|(
    uchar s,
    const uchar1& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator|(
    const uchar4& a,
    uchar s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator|(
    const uchar3& a,
    uchar s
    );

__device__ __forceinline__ char3
cv::cudev::operator|(
    const char3& a,
    char s
    );

__device__ __forceinline__ char4
cv::cudev::operator|(
    const char4& a,
    char s
    );

__device__ __forceinline__ char3
cv::cudev::operator|(
    char s,
    const char3& b
    );

__device__ __forceinline__ char2
cv::cudev::operator|(
    char s,
    const char2& b
    );

__device__ __forceinline__ char4
cv::cudev::operator|(
    char s,
    const char4& b
    );

__device__ __forceinline__ char1
cv::cudev::operator|(
    const char1& a,
    char s
    );

__device__ __forceinline__ char2
cv::cudev::operator|(
    const char2& a,
    char s
    );

__device__ __forceinline__ char1
cv::cudev::operator|(
    char s,
    const char1& b
    );

__device__ __forceinline__ ushort3
cv::cudev::operator|(
    ushort s,
    const ushort3& b
    );

__device__ __forceinline__ ushort4
cv::cudev::operator|(
    ushort s,
    const ushort4& b
    );

__device__ __forceinline__ ushort4
cv::cudev::operator|(
    const ushort4& a,
    ushort s
    );

__device__ __forceinline__ ushort1
cv::cudev::operator|(
    const ushort1& a,
    ushort s
    );

__device__ __forceinline__ ushort3
cv::cudev::operator|(
    const ushort3& a,
    ushort s
    );

__device__ __forceinline__ ushort2
cv::cudev::operator|(
    ushort s,
    const ushort2& b
    );

__device__ __forceinline__ ushort2
cv::cudev::operator|(
    const ushort2& a,
    ushort s
    );

__device__ __forceinline__ ushort1
cv::cudev::operator|(
    ushort s,
    const ushort1& b
    );

__device__ __forceinline__ short4
cv::cudev::operator|(
    short s,
    const short4& b
    );

__device__ __forceinline__ short2
cv::cudev::operator|(
    const short2& a,
    short s
    );

__device__ __forceinline__ short3
cv::cudev::operator|(
    short s,
    const short3& b
    );

__device__ __forceinline__ short4
cv::cudev::operator|(
    const short4& a,
    short s
    );

__device__ __forceinline__ short2
cv::cudev::operator|(
    short s,
    const short2& b
    );

__device__ __forceinline__ short1
cv::cudev::operator|(
    short s,
    const short1& b
    );

__device__ __forceinline__ short3
cv::cudev::operator|(
    const short3& a,
    short s
    );

__device__ __forceinline__ short1
cv::cudev::operator|(
    const short1& a,
    short s
    );

__device__ __forceinline__ int2
cv::cudev::operator|(
    const int2& a,
    int s
    );

__device__ __forceinline__ int2
cv::cudev::operator|(
    int s,
    const int2& b
    );

__device__ __forceinline__ int3
cv::cudev::operator|(
    const int3& a,
    int s
    );

__device__ __forceinline__ int1
cv::cudev::operator|(
    const int1& a,
    int s
    );

__device__ __forceinline__ int4
cv::cudev::operator|(
    const int4& a,
    int s
    );

__device__ __forceinline__ int3
cv::cudev::operator|(
    int s,
    const int3& b
    );

__device__ __forceinline__ int1
cv::cudev::operator|(
    int s,
    const int1& b
    );

__device__ __forceinline__ int4
cv::cudev::operator|(
    int s,
    const int4& b
    );

__device__ __forceinline__ uint1
cv::cudev::operator|(
    const uint1& a,
    uint s
    );

__device__ __forceinline__ uint4
cv::cudev::operator|(
    uint s,
    const uint4& b
    );

__device__ __forceinline__ uint4
cv::cudev::operator|(
    const uint4& a,
    uint s
    );

__device__ __forceinline__ uint3
cv::cudev::operator|(
    uint s,
    const uint3& b
    );

__device__ __forceinline__ uint1
cv::cudev::operator|(
    uint s,
    const uint1& b
    );

__device__ __forceinline__ uint2
cv::cudev::operator|(
    const uint2& a,
    uint s
    );

__device__ __forceinline__ uint2
cv::cudev::operator|(
    uint s,
    const uint2& b
    );

__device__ __forceinline__ uint3
cv::cudev::operator|(
    const uint3& a,
    uint s
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, typename PtrTraits<GpuMat_<T>>::ptr_type, logical_or<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator||(
    const Expr<Body>& src1,
    const GpuMat_<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, typename PtrTraits<Texture<T>>::ptr_type, logical_or<T>>>
cv::cudev::operator||(
    const GlobPtrSz<T>& src1,
    const Texture<T>& src2
    );

template <class Body>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, Binder2nd<logical_or<typename Body::value_type>>>>
cv::cudev::operator||(
    const Expr<Body>& a,
    typename Body::value_type val
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, typename PtrTraits<Texture<T>>::ptr_type, logical_or<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator||(
    const Expr<Body>& src1,
    const Texture<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, typename PtrTraits<GlobPtrSz<T>>::ptr_type, logical_or<T>>>
cv::cudev::operator||(
    const GlobPtrSz<T>& src1,
    const GlobPtrSz<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, typename PtrTraits<GlobPtrSz<T>>::ptr_type, logical_or<T>>>
cv::cudev::operator||(
    const GpuMat_<T>& src1,
    const GlobPtrSz<T>& src2
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, typename PtrTraits<Body>::ptr_type, logical_or<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator||(
    const GlobPtrSz<T>& src1,
    const Expr<Body>& src2
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, typename PtrTraits<Body>::ptr_type, logical_or<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator||(
    const Texture<T>& src1,
    const Expr<Body>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, typename PtrTraits<GpuMat_<T>>::ptr_type, logical_or<T>>>
cv::cudev::operator||(
    const Texture<T>& src1,
    const GpuMat_<T>& src2
    );

template <class Body>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, Binder1st<logical_or<typename Body::value_type>>>>
cv::cudev::operator||(
    typename Body::value_type val,
    const Expr<Body>& a
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, Binder2nd<logical_or<T>>>>
cv::cudev::operator||(
    const Texture<T>& src,
    T val
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, Binder2nd<logical_or<T>>>>
cv::cudev::operator||(
    const GpuMat_<T>& src,
    T val
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, typename PtrTraits<GpuMat_<T>>::ptr_type, logical_or<T>>>
cv::cudev::operator||(
    const GpuMat_<T>& src1,
    const GpuMat_<T>& src2
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, Binder1st<logical_or<T>>>>
cv::cudev::operator||(
    T val,
    const Texture<T>& src
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, typename PtrTraits<GlobPtrSz<T>>::ptr_type, logical_or<T>>>
cv::cudev::operator||(
    const Texture<T>& src1,
    const GlobPtrSz<T>& src2
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, Binder1st<logical_or<T>>>>
cv::cudev::operator||(
    T val,
    const GlobPtrSz<T>& src
    );

template <
    class Body1,
    class Body2
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Body1>::ptr_type, typename PtrTraits<Body2>::ptr_type, logical_or<typename LargerType<typename PtrTraits<Body1>::value_type, typename PtrTraits<Body2>::value_type>::type>>>
cv::cudev::operator||(
    const Expr<Body1>& a,
    const Expr<Body2>& b
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, typename PtrTraits<Body>::ptr_type, logical_or<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator||(
    const GpuMat_<T>& src1,
    const Expr<Body>& src2
    );

template <
    typename T,
    class Body
    >
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, typename PtrTraits<GlobPtrSz<T>>::ptr_type, logical_or<typename LargerType<T, typename PtrTraits<Body>::value_type>::type>>>
cv::cudev::operator||(
    const Expr<Body>& src1,
    const GlobPtrSz<T>& src2
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, Binder1st<logical_or<T>>>>
cv::cudev::operator||(
    T val,
    const GpuMat_<T>& src
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, typename PtrTraits<GpuMat_<T>>::ptr_type, logical_or<T>>>
cv::cudev::operator||(
    const GlobPtrSz<T>& src1,
    const GpuMat_<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, typename PtrTraits<Texture<T>>::ptr_type, logical_or<T>>>
cv::cudev::operator||(
    const Texture<T>& src1,
    const Texture<T>& src2
    );

template <typename T>
__host__ Expr<BinaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, typename PtrTraits<Texture<T>>::ptr_type, logical_or<T>>>
cv::cudev::operator||(
    const GpuMat_<T>& src1,
    const Texture<T>& src2
    );

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, Binder2nd<logical_or<T>>>>
cv::cudev::operator||(
    const GlobPtrSz<T>& src,
    T val
    );

__device__ __forceinline__ uchar3
cv::cudev::operator||(
    const uchar3& a,
    const uchar3& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator||(
    const uchar1& a,
    const uchar1& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator||(
    const uchar4& a,
    const uchar4& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator||(
    const uchar2& a,
    const uchar2& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator||(
    const char2& a,
    const char2& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator||(
    const char1& a,
    const char1& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator||(
    const char3& a,
    const char3& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator||(
    const char4& a,
    const char4& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator||(
    const ushort4& a,
    const ushort4& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator||(
    const ushort2& a,
    const ushort2& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator||(
    const ushort1& a,
    const ushort1& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator||(
    const ushort3& a,
    const ushort3& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator||(
    const short1& a,
    const short1& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator||(
    const short4& a,
    const short4& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator||(
    const short2& a,
    const short2& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator||(
    const short3& a,
    const short3& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator||(
    const int4& a,
    const int4& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator||(
    const int1& a,
    const int1& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator||(
    const int2& a,
    const int2& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator||(
    const int3& a,
    const int3& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator||(
    const uint1& a,
    const uint1& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator||(
    const uint3& a,
    const uint3& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator||(
    const uint4& a,
    const uint4& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator||(
    const uint2& a,
    const uint2& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator||(
    const float4& a,
    const float4& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator||(
    const float2& a,
    const float2& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator||(
    const float3& a,
    const float3& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator||(
    const float1& a,
    const float1& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator||(
    const double1& a,
    const double1& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator||(
    const double2& a,
    const double2& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator||(
    const double4& a,
    const double4& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator||(
    const double3& a,
    const double3& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator||(
    const uchar1& a,
    uchar s
    );

__device__ __forceinline__ uchar4
cv::cudev::operator||(
    const uchar4& a,
    uchar s
    );

__device__ __forceinline__ uchar4
cv::cudev::operator||(
    uchar s,
    const uchar4& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator||(
    uchar s,
    const uchar2& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator||(
    const uchar3& a,
    uchar s
    );

__device__ __forceinline__ uchar1
cv::cudev::operator||(
    uchar s,
    const uchar1& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator||(
    uchar s,
    const uchar3& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator||(
    const uchar2& a,
    uchar s
    );

__device__ __forceinline__ uchar1
cv::cudev::operator||(
    char s,
    const char1& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator||(
    const char1& a,
    char s
    );

__device__ __forceinline__ uchar4
cv::cudev::operator||(
    char s,
    const char4& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator||(
    char s,
    const char3& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator||(
    const char3& a,
    char s
    );

__device__ __forceinline__ uchar4
cv::cudev::operator||(
    const char4& a,
    char s
    );

__device__ __forceinline__ uchar2
cv::cudev::operator||(
    const char2& a,
    char s
    );

__device__ __forceinline__ uchar2
cv::cudev::operator||(
    char s,
    const char2& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator||(
    ushort s,
    const ushort2& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator||(
    const ushort2& a,
    ushort s
    );

__device__ __forceinline__ uchar4
cv::cudev::operator||(
    ushort s,
    const ushort4& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator||(
    const ushort3& a,
    ushort s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator||(
    ushort s,
    const ushort3& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator||(
    const ushort1& a,
    ushort s
    );

__device__ __forceinline__ uchar1
cv::cudev::operator||(
    ushort s,
    const ushort1& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator||(
    const ushort4& a,
    ushort s
    );

__device__ __forceinline__ uchar4
cv::cudev::operator||(
    const short4& a,
    short s
    );

__device__ __forceinline__ uchar4
cv::cudev::operator||(
    short s,
    const short4& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator||(
    const short3& a,
    short s
    );

__device__ __forceinline__ uchar2
cv::cudev::operator||(
    const short2& a,
    short s
    );

__device__ __forceinline__ uchar1
cv::cudev::operator||(
    const short1& a,
    short s
    );

__device__ __forceinline__ uchar1
cv::cudev::operator||(
    short s,
    const short1& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator||(
    short s,
    const short2& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator||(
    short s,
    const short3& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator||(
    const int3& a,
    int s
    );

__device__ __forceinline__ uchar1
cv::cudev::operator||(
    const int1& a,
    int s
    );

__device__ __forceinline__ uchar4
cv::cudev::operator||(
    int s,
    const int4& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator||(
    int s,
    const int3& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator||(
    int s,
    const int2& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator||(
    int s,
    const int1& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator||(
    const int2& a,
    int s
    );

__device__ __forceinline__ uchar4
cv::cudev::operator||(
    const int4& a,
    int s
    );

__device__ __forceinline__ uchar4
cv::cudev::operator||(
    uint s,
    const uint4& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator||(
    const uint1& a,
    uint s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator||(
    uint s,
    const uint3& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator||(
    const uint3& a,
    uint s
    );

__device__ __forceinline__ uchar4
cv::cudev::operator||(
    const uint4& a,
    uint s
    );

__device__ __forceinline__ uchar2
cv::cudev::operator||(
    const uint2& a,
    uint s
    );

__device__ __forceinline__ uchar2
cv::cudev::operator||(
    uint s,
    const uint2& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator||(
    uint s,
    const uint1& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator||(
    float s,
    const float4& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator||(
    float s,
    const float1& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator||(
    const float4& a,
    float s
    );

__device__ __forceinline__ uchar2
cv::cudev::operator||(
    const float2& a,
    float s
    );

__device__ __forceinline__ uchar3
cv::cudev::operator||(
    float s,
    const float3& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator||(
    const float3& a,
    float s
    );

__device__ __forceinline__ uchar1
cv::cudev::operator||(
    const float1& a,
    float s
    );

__device__ __forceinline__ uchar2
cv::cudev::operator||(
    float s,
    const float2& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator||(
    const double3& a,
    double s
    );

__device__ __forceinline__ uchar2
cv::cudev::operator||(
    double s,
    const double2& b
    );

__device__ __forceinline__ uchar3
cv::cudev::operator||(
    double s,
    const double3& b
    );

__device__ __forceinline__ uchar1
cv::cudev::operator||(
    const double1& a,
    double s
    );

__device__ __forceinline__ uchar4
cv::cudev::operator||(
    const double4& a,
    double s
    );

__device__ __forceinline__ uchar1
cv::cudev::operator||(
    double s,
    const double1& b
    );

__device__ __forceinline__ uchar4
cv::cudev::operator||(
    double s,
    const double4& b
    );

__device__ __forceinline__ uchar2
cv::cudev::operator||(
    const double2& a,
    double s
    );

template <class Body>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, bit_not<typename Body::value_type>>>
cv::cudev::operator~(const Expr<Body>& src);

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T>>::ptr_type, bit_not<T>>>
cv::cudev::operator~(const GlobPtrSz<T>& src);

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<Texture<T>>::ptr_type, bit_not<T>>>
cv::cudev::operator~(const Texture<T>& src);

template <typename T>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<GpuMat_<T>>::ptr_type, bit_not<T>>>
cv::cudev::operator~(const GpuMat_<T>& src);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

static
__host__ PerspectiveMapPtrSz
cv::cudev::perspectiveMap(
    Size dstSize,
    const GpuMat_<float>& warpMat
    );

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, Binder2nd<pow_func<typename PtrTraits<SrcPtr>::value_type>>>>
cv::cudev::pow_(
    const SrcPtr& src,
    float power
    );

template <class SrcPtr>
__host__ Expr<PyrDownBody<SrcPtr>>
cv::cudev::pyrDown_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<PyrUpBody<SrcPtr>>
cv::cudev::pyrUp_(const SrcPtr& src);

template <
    class Reductor,
    class SrcPtr
    >
__host__ Expr<ReduceToColumnBody<Reductor, SrcPtr>>
cv::cudev::reduceToColumn_(const SrcPtr& src);

template <
    class Reductor,
    class SrcPtr
    >
__host__ Expr<ReduceToRowBody<Reductor, SrcPtr>>
cv::cudev::reduceToRow_(const SrcPtr& src);

template <
    class SrcPtr,
    class MapPtr
    >
__host__ Expr<RemapPtr1Sz<typename PtrTraits<SrcPtr>::ptr_type, typename PtrTraits<MapPtr>::ptr_type>>
cv::cudev::remap_(
    const SrcPtr& src,
    const MapPtr& map
    );

template <
    class SrcPtr,
    class MapXPtr,
    class MapYPtr
    >
__host__ Expr<RemapPtr2Sz<typename PtrTraits<SrcPtr>::ptr_type, typename PtrTraits<MapXPtr>::ptr_type, typename PtrTraits<MapYPtr>::ptr_type>>
cv::cudev::remap_(
    const SrcPtr& src,
    const MapXPtr& mapx,
    const MapYPtr& mapy
    );

template <
    class SrcPtr,
    class MapPtr
    >
__host__ RemapPtr1Sz<typename PtrTraits<SrcPtr>::ptr_type, typename PtrTraits<MapPtr>::ptr_type>
cv::cudev::remapPtr(
    const SrcPtr& src,
    const MapPtr& map
    );

template <
    class SrcPtr,
    class MapXPtr,
    class MapYPtr
    >
__host__ RemapPtr2Sz<typename PtrTraits<SrcPtr>::ptr_type, typename PtrTraits<MapXPtr>::ptr_type, typename PtrTraits<MapYPtr>::ptr_type>
cv::cudev::remapPtr(
    const SrcPtr& src,
    const MapXPtr& mapx,
    const MapYPtr& mapy
    );

template <
    int cn,
    typename T
    >
__host__ GpuMat_<typename MakeVec<typename VecTraits<T>::elem_type, cn>::type>
cv::cudev::reshape_(
    const GpuMat_<T>& mat,
    int rows = 0
    );

template <class SrcPtr>
__host__ Expr<ResizePtrSz<typename PtrTraits<SrcPtr>::ptr_type>>
cv::cudev::resize_(
    const SrcPtr& src,
    float fx,
    float fy
    );

template <class SrcPtr>
__host__ ResizePtrSz<typename PtrTraits<SrcPtr>::ptr_type>
cv::cudev::resizePtr(
    const SrcPtr& src,
    float fx,
    float fy
    );

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, RGB_to_GRAY_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::RGB_to_GRAY_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, RGB_to_HLS4_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::RGB_to_HLS4_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, RGB_to_HLS4_FULL_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::RGB_to_HLS4_FULL_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, RGB_to_HLS_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::RGB_to_HLS_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, RGB_to_HLS_FULL_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::RGB_to_HLS_FULL_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, RGB_to_HSV4_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::RGB_to_HSV4_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, RGB_to_HSV4_FULL_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::RGB_to_HSV4_FULL_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, RGB_to_HSV_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::RGB_to_HSV_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, RGB_to_HSV_FULL_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::RGB_to_HSV_FULL_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, RGB_to_Lab4_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::RGB_to_Lab4_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, RGB_to_Lab_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::RGB_to_Lab_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, RGB_to_Luv4_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::RGB_to_Luv4_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, RGB_to_Luv_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::RGB_to_Luv_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, RGB_to_XYZ4_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::RGB_to_XYZ4_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, RGB_to_XYZ_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::RGB_to_XYZ_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, RGB_to_YCrCb4_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::RGB_to_YCrCb4_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, RGB_to_YCrCb_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::RGB_to_YCrCb_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, RGB_to_YUV4_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::RGB_to_YUV4_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, RGB_to_YUV_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::RGB_to_YUV_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, RGBA_to_GRAY_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::RGBA_to_GRAY_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, RGBA_to_HLS4_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::RGBA_to_HLS4_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, RGBA_to_HLS4_FULL_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::RGBA_to_HLS4_FULL_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, RGBA_to_HLS_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::RGBA_to_HLS_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, RGBA_to_HLS_FULL_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::RGBA_to_HLS_FULL_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, RGBA_to_HSV4_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::RGBA_to_HSV4_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, RGBA_to_HSV4_FULL_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::RGBA_to_HSV4_FULL_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, RGBA_to_HSV_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::RGBA_to_HSV_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, RGBA_to_HSV_FULL_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::RGBA_to_HSV_FULL_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, RGBA_to_Lab4_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::RGBA_to_Lab4_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, RGBA_to_Lab_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::RGBA_to_Lab_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, RGBA_to_Luv4_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::RGBA_to_Luv4_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, RGBA_to_Luv_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::RGBA_to_Luv_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, RGBA_to_XYZ4_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::RGBA_to_XYZ4_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, RGBA_to_XYZ_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::RGBA_to_XYZ_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, RGBA_to_YCrCb4_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::RGBA_to_YCrCb4_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, RGBA_to_YCrCb_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::RGBA_to_YCrCb_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, RGBA_to_YUV4_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::RGBA_to_YUV4_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, RGBA_to_YUV_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::RGBA_to_YUV_(const SrcPtr& src);

template <typename T>
__device__ __forceinline__ T
cv::cudev::saturate_cast(uchar v);

template <typename T>
__device__ __forceinline__ T
cv::cudev::saturate_cast(schar v);

template <typename T>
__device__ __forceinline__ T
cv::cudev::saturate_cast(ushort v);

template <typename T>
__device__ __forceinline__ T
cv::cudev::saturate_cast(short v);

template <typename T>
__device__ __forceinline__ T
cv::cudev::saturate_cast(uint v);

template <typename T>
__device__ __forceinline__ T
cv::cudev::saturate_cast(int v);

template <typename T>
__device__ __forceinline__ T
cv::cudev::saturate_cast(float v);

template <typename T>
__device__ __forceinline__ T
cv::cudev::saturate_cast(double v);

template <typename T>
__device__ __forceinline__ T
cv::cudev::saturate_cast(const uchar1& v);

template <typename T>
__device__ __forceinline__ T
cv::cudev::saturate_cast(const char1& v);

template <typename T>
__device__ __forceinline__ T
cv::cudev::saturate_cast(const ushort1& v);

template <typename T>
__device__ __forceinline__ T
cv::cudev::saturate_cast(const short1& v);

template <typename T>
__device__ __forceinline__ T
cv::cudev::saturate_cast(const uint1& v);

template <typename T>
__device__ __forceinline__ T
cv::cudev::saturate_cast(const int1& v);

template <typename T>
__device__ __forceinline__ T
cv::cudev::saturate_cast(const float1& v);

template <typename T>
__device__ __forceinline__ T
cv::cudev::saturate_cast(const double1& v);

template <typename T>
__device__ __forceinline__ T
cv::cudev::saturate_cast(const uchar2& v);

template <typename T>
__device__ __forceinline__ T
cv::cudev::saturate_cast(const char2& v);

template <typename T>
__device__ __forceinline__ T
cv::cudev::saturate_cast(const ushort2& v);

template <typename T>
__device__ __forceinline__ T
cv::cudev::saturate_cast(const short2& v);

template <typename T>
__device__ __forceinline__ T
cv::cudev::saturate_cast(const uint2& v);

template <typename T>
__device__ __forceinline__ T
cv::cudev::saturate_cast(const int2& v);

template <typename T>
__device__ __forceinline__ T
cv::cudev::saturate_cast(const float2& v);

template <typename T>
__device__ __forceinline__ T
cv::cudev::saturate_cast(const double2& v);

template <typename T>
__device__ __forceinline__ T
cv::cudev::saturate_cast(const uchar3& v);

template <typename T>
__device__ __forceinline__ T
cv::cudev::saturate_cast(const char3& v);

template <typename T>
__device__ __forceinline__ T
cv::cudev::saturate_cast(const ushort3& v);

template <typename T>
__device__ __forceinline__ T
cv::cudev::saturate_cast(const short3& v);

template <typename T>
__device__ __forceinline__ T
cv::cudev::saturate_cast(const uint3& v);

template <typename T>
__device__ __forceinline__ T
cv::cudev::saturate_cast(const int3& v);

template <typename T>
__device__ __forceinline__ T
cv::cudev::saturate_cast(const float3& v);

template <typename T>
__device__ __forceinline__ T
cv::cudev::saturate_cast(const double3& v);

template <typename T>
__device__ __forceinline__ T
cv::cudev::saturate_cast(const uchar4& v);

template <typename T>
__device__ __forceinline__ T
cv::cudev::saturate_cast(const char4& v);

template <typename T>
__device__ __forceinline__ T
cv::cudev::saturate_cast(const ushort4& v);

template <typename T>
__device__ __forceinline__ T
cv::cudev::saturate_cast(const short4& v);

template <typename T>
__device__ __forceinline__ T
cv::cudev::saturate_cast(const uint4& v);

template <typename T>
__device__ __forceinline__ T
cv::cudev::saturate_cast(const int4& v);

template <typename T>
__device__ __forceinline__ T
cv::cudev::saturate_cast(const float4& v);

template <typename T>
__device__ __forceinline__ T
cv::cudev::saturate_cast(const double4& v);

__device__ __forceinline__ schar
cv::cudev::saturate_cast< schar >(uchar v);

__device__ __forceinline__ schar
cv::cudev::saturate_cast< schar >(short v);

__device__ __forceinline__ schar
cv::cudev::saturate_cast< schar >(ushort v);

__device__ __forceinline__ schar
cv::cudev::saturate_cast< schar >(int v);

__device__ __forceinline__ schar
cv::cudev::saturate_cast< schar >(uint v);

__device__ __forceinline__ schar
cv::cudev::saturate_cast< schar >(float v);

__device__ __forceinline__ schar
cv::cudev::saturate_cast< schar >(double v);

__device__ __forceinline__ short
cv::cudev::saturate_cast< short >(ushort v);

__device__ __forceinline__ short
cv::cudev::saturate_cast< short >(int v);

__device__ __forceinline__ short
cv::cudev::saturate_cast< short >(uint v);

__device__ __forceinline__ short
cv::cudev::saturate_cast< short >(float v);

__device__ __forceinline__ short
cv::cudev::saturate_cast< short >(double v);

__device__ __forceinline__ uchar
cv::cudev::saturate_cast< uchar >(schar v);

__device__ __forceinline__ uchar
cv::cudev::saturate_cast< uchar >(short v);

__device__ __forceinline__ uchar
cv::cudev::saturate_cast< uchar >(ushort v);

__device__ __forceinline__ uchar
cv::cudev::saturate_cast< uchar >(int v);

__device__ __forceinline__ uchar
cv::cudev::saturate_cast< uchar >(uint v);

__device__ __forceinline__ uchar
cv::cudev::saturate_cast< uchar >(float v);

__device__ __forceinline__ uchar
cv::cudev::saturate_cast< uchar >(double v);

__device__ __forceinline__ uint
cv::cudev::saturate_cast< uint >(schar v);

__device__ __forceinline__ uint
cv::cudev::saturate_cast< uint >(short v);

__device__ __forceinline__ uint
cv::cudev::saturate_cast< uint >(int v);

__device__ __forceinline__ uint
cv::cudev::saturate_cast< uint >(float v);

__device__ __forceinline__ uint
cv::cudev::saturate_cast< uint >(double v);

__device__ __forceinline__ ushort
cv::cudev::saturate_cast< ushort >(schar v);

__device__ __forceinline__ ushort
cv::cudev::saturate_cast< ushort >(short v);

__device__ __forceinline__ ushort
cv::cudev::saturate_cast< ushort >(int v);

__device__ __forceinline__ ushort
cv::cudev::saturate_cast< ushort >(uint v);

__device__ __forceinline__ ushort
cv::cudev::saturate_cast< ushort >(float v);

__device__ __forceinline__ ushort
cv::cudev::saturate_cast< ushort >(double v);

template <class SrcPtr>
__host__ Expr<ScharrXPtrSz<typename PtrTraits<SrcPtr>::ptr_type>>
cv::cudev::scharrX_(const SrcPtr& src);

template <class SrcPtr>
__host__ ScharrXPtrSz<typename PtrTraits<SrcPtr>::ptr_type>
cv::cudev::scharrXPtr(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<ScharrYPtrSz<typename PtrTraits<SrcPtr>::ptr_type>>
cv::cudev::scharrY_(const SrcPtr& src);

template <class SrcPtr>
__host__ ScharrYPtrSz<typename PtrTraits<SrcPtr>::ptr_type>
cv::cudev::scharrYPtr(const SrcPtr& src);

template <class Ptr2DSz>
__host__ PtrTraits<Ptr2DSz>::ptr_type
cv::cudev::shrinkPtr(const Ptr2DSz& ptr);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

template <class MaskPtr>
__host__ SingleMaskChannelsSz<typename PtrTraits<MaskPtr>::ptr_type>
cv::cudev::singleMaskChannels(
    const MaskPtr& mask,
    int channels
    );

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

template <typename T0>
__device__ __forceinline__ tuple<volatile T0*>
cv::cudev::smem_tuple(T0* t0);

template <
    typename T0,
    typename T1
    >
__device__ __forceinline__ tuple<volatile T0*, volatile T1*>
cv::cudev::smem_tuple(
    T0* t0,
    T1* t1
    );

template <
    typename T0,
    typename T1,
    typename T2
    >
__device__ __forceinline__ tuple<volatile T0*, volatile T1*, volatile T2*>
cv::cudev::smem_tuple(
    T0* t0,
    T1* t1,
    T2* t2
    );

template <
    typename T0,
    typename T1,
    typename T2,
    typename T3
    >
__device__ __forceinline__ tuple<volatile T0*, volatile T1*, volatile T2*, volatile T3*>
cv::cudev::smem_tuple(
    T0* t0,
    T1* t1,
    T2* t2,
    T3* t3
    );

template <
    typename T0,
    typename T1,
    typename T2,
    typename T3,
    typename T4
    >
__device__ __forceinline__ tuple<volatile T0*, volatile T1*, volatile T2*, volatile T3*, volatile T4*>
cv::cudev::smem_tuple(
    T0* t0,
    T1* t1,
    T2* t2,
    T3* t3,
    T4* t4
    );

template <
    typename T0,
    typename T1,
    typename T2,
    typename T3,
    typename T4,
    typename T5
    >
__device__ __forceinline__ tuple<volatile T0*, volatile T1*, volatile T2*, volatile T3*, volatile T4*, volatile T5*>
cv::cudev::smem_tuple(
    T0* t0,
    T1* t1,
    T2* t2,
    T3* t3,
    T4* t4,
    T5* t5
    );

template <
    typename T0,
    typename T1,
    typename T2,
    typename T3,
    typename T4,
    typename T5,
    typename T6
    >
__device__ __forceinline__ tuple<volatile T0*, volatile T1*, volatile T2*, volatile T3*, volatile T4*, volatile T5*, volatile T6*>
cv::cudev::smem_tuple(
    T0* t0,
    T1* t1,
    T2* t2,
    T3* t3,
    T4* t4,
    T5* t5,
    T6* t6
    );

template <
    typename T0,
    typename T1,
    typename T2,
    typename T3,
    typename T4,
    typename T5,
    typename T6,
    typename T7
    >
__device__ __forceinline__ tuple<volatile T0*, volatile T1*, volatile T2*, volatile T3*, volatile T4*, volatile T5*, volatile T6*, volatile T7*>
cv::cudev::smem_tuple(
    T0* t0,
    T1* t1,
    T2* t2,
    T3* t3,
    T4* t4,
    T5* t5,
    T6* t6,
    T7* t7
    );

template <
    typename T0,
    typename T1,
    typename T2,
    typename T3,
    typename T4,
    typename T5,
    typename T6,
    typename T7,
    typename T8
    >
__device__ __forceinline__ tuple<volatile T0*, volatile T1*, volatile T2*, volatile T3*, volatile T4*, volatile T5*, volatile T6*, volatile T7*, volatile T8*>
cv::cudev::smem_tuple(
    T0* t0,
    T1* t1,
    T2* t2,
    T3* t3,
    T4* t4,
    T5* t5,
    T6* t6,
    T7* t7,
    T8* t8
    );

template <
    typename T0,
    typename T1,
    typename T2,
    typename T3,
    typename T4,
    typename T5,
    typename T6,
    typename T7,
    typename T8,
    typename T9
    >
__device__ __forceinline__ tuple<volatile T0*, volatile T1*, volatile T2*, volatile T3*, volatile T4*, volatile T5*, volatile T6*, volatile T7*, volatile T8*, volatile T9*>
cv::cudev::smem_tuple(
    T0* t0,
    T1* t1,
    T2* t2,
    T3* t3,
    T4* t4,
    T5* t5,
    T6* t6,
    T7* t7,
    T8* t8,
    T9* t9
    );

template <class SrcPtr>
__host__ Expr<SobelXPtrSz<typename PtrTraits<SrcPtr>::ptr_type>>
cv::cudev::sobelX_(const SrcPtr& src);

template <class SrcPtr>
__host__ SobelXPtrSz<typename PtrTraits<SrcPtr>::ptr_type>
cv::cudev::sobelXPtr(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<SobelYPtrSz<typename PtrTraits<SrcPtr>::ptr_type>>
cv::cudev::sobelY_(const SrcPtr& src);

template <class SrcPtr>
__host__ SobelYPtrSz<typename PtrTraits<SrcPtr>::ptr_type>
cv::cudev::sobelYPtr(const SrcPtr& src);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

template <class SrcPtr>
__host__ Expr<SumExprBody<SrcPtr>>
cv::cudev::sum_(const SrcPtr& src);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

template <typename T>
__host__ __device__ ThreshBinaryFunc<T>
cv::cudev::thresh_binary_func(
    T thresh,
    T maxVal
    );

template <typename T>
__host__ __device__ ThreshBinaryInvFunc<T>
cv::cudev::thresh_binary_inv_func(
    T thresh,
    T maxVal
    );

template <typename T>
__host__ __device__ ThreshToZeroFunc<T>
cv::cudev::thresh_to_zero_func(T thresh);

template <typename T>
__host__ __device__ ThreshToZeroInvFunc<T>
cv::cudev::thresh_to_zero_inv_func(T thresh);

template <typename T>
__host__ __device__ ThreshTruncFunc<T>
cv::cudev::thresh_trunc_func(T thresh);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, ThreshBinaryFunc<typename PtrTraits<SrcPtr>::value_type>>>
cv::cudev::threshBinary_(
    const SrcPtr& src,
    typename PtrTraits<SrcPtr>::value_type thresh,
    typename PtrTraits<SrcPtr>::value_type maxVal
    );

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, ThreshBinaryInvFunc<typename PtrTraits<SrcPtr>::value_type>>>
cv::cudev::threshBinaryInv_(
    const SrcPtr& src,
    typename PtrTraits<SrcPtr>::value_type thresh,
    typename PtrTraits<SrcPtr>::value_type maxVal
    );

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

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

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

template <
    class SrcPtr,
    class Op
    >
__host__ UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, Op>
cv::cudev::transformPtr(
    const SrcPtr& src,
    const Op& op
    );

template <
    class Src1Ptr,
    class Src2Ptr,
    class Op
    >
__host__ BinaryTransformPtrSz<typename PtrTraits<Src1Ptr>::ptr_type, typename PtrTraits<Src2Ptr>::ptr_type, Op>
cv::cudev::transformPtr(
    const Src1Ptr& src1,
    const Src2Ptr& src2,
    const Op& op
    );

template <class SrcPtr>
__host__ Expr<TransposeBody<SrcPtr>>
cv::cudev::transpose_(const SrcPtr& src);

template <
    int n,
    class Op
    >
__host__ __device__ UnaryTupleAdapter<Op, n>
cv::cudev::unaryTupleAdapter(const Op& op);

__device__ __forceinline__ uint
cv::cudev::vabsdiff2(
    uint a,
    uint b
    );

__device__ __forceinline__ uint
cv::cudev::vabsdiff4(
    uint a,
    uint b
    );

__device__ __forceinline__ uint
cv::cudev::vadd2(
    uint a,
    uint b
    );

__device__ __forceinline__ uint
cv::cudev::vadd4(
    uint a,
    uint b
    );

__device__ __forceinline__ uint
cv::cudev::vavg2(
    uint a,
    uint b
    );

__device__ __forceinline__ uint
cv::cudev::vavg4(
    uint a,
    uint b
    );

__device__ __forceinline__ uint
cv::cudev::vavrg2(
    uint a,
    uint b
    );

__device__ __forceinline__ uint
cv::cudev::vavrg4(
    uint a,
    uint b
    );

__device__ __forceinline__ uint
cv::cudev::vcmpeq2(
    uint a,
    uint b
    );

__device__ __forceinline__ uint
cv::cudev::vcmpeq4(
    uint a,
    uint b
    );

__device__ __forceinline__ uint
cv::cudev::vcmpge2(
    uint a,
    uint b
    );

__device__ __forceinline__ uint
cv::cudev::vcmpge4(
    uint a,
    uint b
    );

__device__ __forceinline__ uint
cv::cudev::vcmpgt2(
    uint a,
    uint b
    );

__device__ __forceinline__ uint
cv::cudev::vcmpgt4(
    uint a,
    uint b
    );

__device__ __forceinline__ uint
cv::cudev::vcmple2(
    uint a,
    uint b
    );

__device__ __forceinline__ uint
cv::cudev::vcmple4(
    uint a,
    uint b
    );

__device__ __forceinline__ uint
cv::cudev::vcmplt2(
    uint a,
    uint b
    );

__device__ __forceinline__ uint
cv::cudev::vcmplt4(
    uint a,
    uint b
    );

__device__ __forceinline__ uint
cv::cudev::vcmpne2(
    uint a,
    uint b
    );

__device__ __forceinline__ uint
cv::cudev::vcmpne4(
    uint a,
    uint b
    );

__device__ __forceinline__ uint
cv::cudev::vmax2(
    uint a,
    uint b
    );

__device__ __forceinline__ uint
cv::cudev::vmax4(
    uint a,
    uint b
    );

__device__ __forceinline__ uint
cv::cudev::vmin2(
    uint a,
    uint b
    );

__device__ __forceinline__ uint
cv::cudev::vmin4(
    uint a,
    uint b
    );

__device__ __forceinline__ uint
cv::cudev::vseteq2(
    uint a,
    uint b
    );

__device__ __forceinline__ uint
cv::cudev::vseteq4(
    uint a,
    uint b
    );

__device__ __forceinline__ uint
cv::cudev::vsetge2(
    uint a,
    uint b
    );

__device__ __forceinline__ uint
cv::cudev::vsetge4(
    uint a,
    uint b
    );

__device__ __forceinline__ uint
cv::cudev::vsetgt2(
    uint a,
    uint b
    );

__device__ __forceinline__ uint
cv::cudev::vsetgt4(
    uint a,
    uint b
    );

__device__ __forceinline__ uint
cv::cudev::vsetle2(
    uint a,
    uint b
    );

__device__ __forceinline__ uint
cv::cudev::vsetle4(
    uint a,
    uint b
    );

__device__ __forceinline__ uint
cv::cudev::vsetlt2(
    uint a,
    uint b
    );

__device__ __forceinline__ uint
cv::cudev::vsetlt4(
    uint a,
    uint b
    );

__device__ __forceinline__ uint
cv::cudev::vsetne2(
    uint a,
    uint b
    );

__device__ __forceinline__ uint
cv::cudev::vsetne4(
    uint a,
    uint b
    );

__device__ __forceinline__ uint
cv::cudev::vsub2(
    uint a,
    uint b
    );

__device__ __forceinline__ uint
cv::cudev::vsub4(
    uint a,
    uint b
    );

template <class SrcPtr>
__host__ Expr<RemapPtr1Sz<typename PtrTraits<SrcPtr>::ptr_type, AffineMapPtr>>
cv::cudev::warpAffine_(
    const SrcPtr& src,
    Size dstSize,
    const GpuMat_<float>& warpMat
    );

template <class SrcPtr>
__host__ RemapPtr1Sz<typename PtrTraits<SrcPtr>::ptr_type, AffineMapPtr>
cv::cudev::warpAffinePtr(
    const SrcPtr& src,
    Size dstSize,
    const GpuMat_<float>& warpMat
    );

template <
    class InIt,
    class OutIt
    >
__device__ __forceinline__ OutIt
cv::cudev::warpCopy(
    InIt beg,
    InIt end,
    OutIt out
    );

template <
    class It,
    typename T
    >
__device__ __forceinline__ void
cv::cudev::warpFill(
    It beg,
    It end,
    const T& value
    );

template <class SrcPtr>
__host__ Expr<RemapPtr1Sz<typename PtrTraits<SrcPtr>::ptr_type, PerspectiveMapPtr>>
cv::cudev::warpPerspective_(
    const SrcPtr& src,
    Size dstSize,
    const GpuMat_<float>& warpMat
    );

template <class SrcPtr>
__host__ RemapPtr1Sz<typename PtrTraits<SrcPtr>::ptr_type, PerspectiveMapPtr>
cv::cudev::warpPerspectivePtr(
    const SrcPtr& src,
    Size dstSize,
    const GpuMat_<float>& warpMat
    );

template <
    typename T,
    class Op
    >
__device__ __forceinline__ void
cv::cudev::warpReduce(
    volatile T* smem,
    T& val,
    uint tid,
    const Op& op
    );

template <
    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::warpReduce(
    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 <
    typename K,
    typename V,
    class Cmp
    >
__device__ __forceinline__ void
cv::cudev::warpReduceKeyVal(
    volatile K* skeys,
    K& key,
    volatile V* svals,
    V& val,
    uint tid,
    const Cmp& cmp
    );

template <
    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::warpReduceKeyVal(
    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 <
    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::warpReduceKeyVal(
    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 <typename T>
__device__ __forceinline__ T
cv::cudev::warpScanExclusive(
    T data,
    volatile T* smem,
    uint tid
    );

template <typename T>
__device__ T
cv::cudev::warpScanInclusive(
    T data,
    volatile T* smem,
    uint tid
    );

template <
    class InIt,
    class OutIt,
    class UnOp
    >
__device__ __forceinline__ OutIt
cv::cudev::warpTransform(
    InIt beg,
    InIt end,
    OutIt out,
    const UnOp& op
    );

template <
    class InIt1,
    class InIt2,
    class OutIt,
    class BinOp
    >
__device__ __forceinline__ OutIt
cv::cudev::warpTransform(
    InIt1 beg1,
    InIt1 end1,
    InIt2 beg2,
    OutIt out,
    const BinOp& op
    );

template <
    typename OutIt,
    typename T
    >
__device__ __forceinline__ void
cv::cudev::warpYota(
    OutIt beg,
    OutIt end,
    T value
    );

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, XYZ4_to_BGR_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::XYZ4_to_BGR_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, XYZ4_to_BGRA_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::XYZ4_to_BGRA_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, XYZ4_to_RGB_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::XYZ4_to_RGB_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, XYZ4_to_RGBA_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::XYZ4_to_RGBA_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, XYZ_to_BGR_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::XYZ_to_BGR_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, XYZ_to_BGRA_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::XYZ_to_BGRA_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, XYZ_to_RGB_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::XYZ_to_RGB_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, XYZ_to_RGBA_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::XYZ_to_RGBA_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, YCrCb4_to_BGR_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::YCrCb4_to_BGR_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, YCrCb4_to_BGRA_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::YCrCb4_to_BGRA_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, YCrCb4_to_RGB_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::YCrCb4_to_RGB_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, YCrCb4_to_RGBA_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::YCrCb4_to_RGBA_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, YCrCb_to_BGR_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::YCrCb_to_BGR_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, YCrCb_to_BGRA_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::YCrCb_to_BGRA_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, YCrCb_to_RGB_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::YCrCb_to_RGB_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, YCrCb_to_RGBA_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::YCrCb_to_RGBA_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, YUV4_to_BGR_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::YUV4_to_BGR_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, YUV4_to_BGRA_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::YUV4_to_BGRA_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, YUV4_to_RGB_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::YUV4_to_RGB_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, YUV4_to_RGBA_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::YUV4_to_RGBA_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, YUV_to_BGR_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::YUV_to_BGR_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, YUV_to_BGRA_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::YUV_to_BGRA_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, YUV_to_RGB_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::YUV_to_RGB_(const SrcPtr& src);

template <class SrcPtr>
__host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, YUV_to_RGBA_func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>>>
cv::cudev::YUV_to_RGBA_(const SrcPtr& src);

template <
    class Ptr0,
    class Ptr1
    >
__host__ ZipPtrSz<tuple<typename PtrTraits<Ptr0>::ptr_type, typename PtrTraits<Ptr1>::ptr_type>>
cv::cudev::zipPtr(
    const Ptr0& ptr0,
    const Ptr1& ptr1
    );

template <
    class Ptr0,
    class Ptr1,
    class Ptr2
    >
__host__ ZipPtrSz<tuple<typename PtrTraits<Ptr0>::ptr_type, typename PtrTraits<Ptr1>::ptr_type, typename PtrTraits<Ptr2>::ptr_type>>
cv::cudev::zipPtr(
    const Ptr0& ptr0,
    const Ptr1& ptr1,
    const Ptr2& ptr2
    );

template <
    class Ptr0,
    class Ptr1,
    class Ptr2,
    class Ptr3
    >
__host__ ZipPtrSz<tuple<typename PtrTraits<Ptr0>::ptr_type, typename PtrTraits<Ptr1>::ptr_type, typename PtrTraits<Ptr2>::ptr_type, typename PtrTraits<Ptr3>::ptr_type>>
cv::cudev::zipPtr(
    const Ptr0& ptr0,
    const Ptr1& ptr1,
    const Ptr2& ptr2,
    const Ptr3& ptr3
    );

// macros

#define CV_CUDEV_ARCH

#define CV_CUDEV_BINARY_FUNCTION_INST( \
    name, \
    func \
    )

#define CV_CUDEV_EXPR_BINARY_FUNC(name)

#define CV_CUDEV_EXPR_BINOP_INST( \
    op, \
    functor \
    )

#define CV_CUDEV_EXPR_CVTCOLOR_INST(name)
#define CV_CUDEV_EXPR_UNARY_FUNC(name)

#define CV_CUDEV_EXPR_UNOP_INST( \
    op, \
    functor \
    )

#define CV_CUDEV_GRAY2RGB5x5_INST( \
    name, \
    green_bits \
    )

#define CV_CUDEV_GRAY2RGB_INST( \
    name, \
    dcn \
    )

#define CV_CUDEV_HLS2RGB_INST( \
    name, \
    scn, \
    dcn, \
    bidx \
    )

#define CV_CUDEV_HSV2RGB_INST( \
    name, \
    scn, \
    dcn, \
    bidx \
    )

#define CV_CUDEV_IMPLEMENT_SCALAR_BINARY_FUNC( \
    func_name, \
    func, \
    input_type, \
    scalar_type, \
    output_type \
    )

#define CV_CUDEV_IMPLEMENT_SCALAR_BINARY_OP( \
    op, \
    input_type, \
    scalar_type, \
    output_type \
    )

#define CV_CUDEV_IMPLEMENT_VEC_BINARY_FUNC( \
    func_name, \
    func, \
    input_type, \
    output_type \
    )

#define CV_CUDEV_IMPLEMENT_VEC_BINARY_OP( \
    op, \
    input_type, \
    output_type \
    )

#define CV_CUDEV_IMPLEMENT_VEC_UNARY_FUNC( \
    func_name, \
    func, \
    input_type, \
    output_type \
    )

#define CV_CUDEV_IMPLEMENT_VEC_UNARY_OP( \
    op, \
    input_type, \
    output_type \
    )

#define CV_CUDEV_Lab2RGB_INST( \
    name, \
    scn, \
    dcn, \
    sRGB, \
    blueIdx \
    )

#define CV_CUDEV_Luv2RGB_INST( \
    name, \
    scn, \
    dcn, \
    sRGB, \
    blueIdx \
    )

#define CV_CUDEV_MAKE_VEC_INST(elem_type)

#define CV_CUDEV_MINMAX_INST( \
    type, \
    maxop, \
    minop \
    )

#define CV_CUDEV_RGB2GRAY_INST( \
    name, \
    scn, \
    bidx \
    )

#define CV_CUDEV_RGB2HLS_INST( \
    name, \
    scn, \
    dcn, \
    bidx \
    )

#define CV_CUDEV_RGB2HSV_INST( \
    name, \
    scn, \
    dcn, \
    bidx \
    )

#define CV_CUDEV_RGB2Lab_INST( \
    name, \
    scn, \
    dcn, \
    sRGB, \
    blueIdx \
    )

#define CV_CUDEV_RGB2Luv_INST( \
    name, \
    scn, \
    dcn, \
    sRGB, \
    blueIdx \
    )

#define CV_CUDEV_RGB2RGB5x5_INST( \
    name, \
    scn, \
    bidx, \
    green_bits \
    )

#define CV_CUDEV_RGB2RGB_INST( \
    name, \
    scn, \
    dcn, \
    bidx \
    )

#define CV_CUDEV_RGB2XYZ_INST( \
    name, \
    scn, \
    dcn, \
    bidx \
    )

#define CV_CUDEV_RGB2YCrCb_INST( \
    name, \
    scn, \
    dcn, \
    bidx \
    )

#define CV_CUDEV_RGB2YUV_INST( \
    name, \
    scn, \
    dcn, \
    bidx \
    )

#define CV_CUDEV_RGB5x52GRAY_INST( \
    name, \
    green_bits \
    )

#define CV_CUDEV_RGB5x52RGB_INST( \
    name, \
    dcn, \
    bidx, \
    green_bits \
    )

#define CV_CUDEV_SAFE_CALL(expr)

#define CV_CUDEV_UNARY_FUNCTION_INST( \
    name, \
    func \
    )

#define CV_CUDEV_VEC_TRAITS_INST(type)

#define CV_CUDEV_XYZ2RGB_INST( \
    name, \
    scn, \
    dcn, \
    bidx \
    )

#define CV_CUDEV_YCrCb2RGB_INST( \
    name, \
    scn, \
    dcn, \
    bidx \
    )

#define CV_CUDEV_YUV2RGB_INST( \
    name, \
    scn, \
    dcn, \
    bidx \
    )

#define CV_LOG2_F
#define CV_PI_F

Detailed Documentation

Global Functions

template <
    int cn,
    typename T
    >
__host__ GpuMat_<typename MakeVec<typename VecTraits<T>::elem_type, cn>::type>
cv::cudev::reshape_(
    const GpuMat_<T>& mat,
    int rows = 0
    )

creates alternative GpuMat header for the same data, with different number of channels and/or different number of rows. see cvReshape.