Device layer#

Detailed Description#

Namespaces#

Classes#

Name	Description
`struct` `cv::cudev::abs_func`	View details
`struct` `cv::cudev::abs_func< double >`	View details
`struct` `cv::cudev::abs_func< float >`	View details
`struct` `cv::cudev::abs_func< schar >`	View details
`struct` `cv::cudev::abs_func< short >`	View details
`struct` `cv::cudev::abs_func< uchar >`	View details
`struct` `cv::cudev::abs_func< uint >`	View details
`struct` `cv::cudev::abs_func< ushort >`	View details
`struct` `cv::cudev::absdiff_func`	View details
`struct` `cv::cudev::AffineMapPtr`	View details
`struct` `cv::cudev::AffineMapPtrSz`	View details
`struct` `cv::cudev::ArrayWrapper`	View details
`struct` `cv::cudev::Avg`	View details
`struct` `cv::cudev::binary_function`	View details
`struct` `cv::cudev::BinaryNegate`	View details
`struct` `cv::cudev::BinaryTransformPtr`	View details
`struct` `cv::cudev::BinaryTransformPtrSz`	View details
`struct` `cv::cudev::BinaryTupleAdapter`	View details
`struct` `cv::cudev::Binder1st`	View details
`struct` `cv::cudev::Binder2nd`	View details
`struct` `cv::cudev::bit_and`	View details
`struct` `cv::cudev::bit_lshift`	View details
`struct` `cv::cudev::bit_not`	View details
`struct` `cv::cudev::bit_or`	View details
`struct` `cv::cudev::bit_rshift`	View details
`struct` `cv::cudev::bit_xor`	View details
`struct` `cv::cudev::Block`	View details
`struct` `cv::cudev::BrdBase`	View details
`struct` `cv::cudev::BrdConstant`	View details
`struct` `cv::cudev::BrdReflect`	View details
`struct` `cv::cudev::BrdReflect101`	View details
`struct` `cv::cudev::BrdReplicate`	View details
`struct` `cv::cudev::BrdWrap`	View details
`struct` `cv::cudev::CommonAreaInterPtr`	View details
`struct` `cv::cudev::CommonAreaInterPtrSz`	View details
`struct` `cv::cudev::ConstantPtr`	View details
`struct` `cv::cudev::ConstantPtrSz`	View details
`struct` `cv::cudev::ConvertTuple`	View details
`struct` `cv::cudev::CountNonZeroExprBody`	View details
`struct` `cv::cudev::CubicInterPtr`	View details
`struct` `cv::cudev::CubicInterPtrSz`	View details
`struct` `cv::cudev::DefaultCopyPolicy`	View details
`struct` `cv::cudev::DefaultGlobReducePolicy`	View details
`struct` `cv::cudev::DefaultHistogramPolicy`	View details
`struct` `cv::cudev::DefaultReduceToVecPolicy`	View details
`struct` `cv::cudev::DefaultSplitMergePolicy`	View details
`struct` `cv::cudev::DefaultTransformPolicy`	View details
`struct` `cv::cudev::DefaultTransposePolicy`	View details
`struct` `cv::cudev::DerivXPtr`	View details
`struct` `cv::cudev::DerivXPtrSz`	View details
`struct` `cv::cudev::DerivYPtr`	View details
`struct` `cv::cudev::DerivYPtrSz`	View details
`struct` `cv::cudev::direction_func`	View details
`struct` `cv::cudev::direction_interleaved_func`	View details
`struct` `cv::cudev::DisableIf`	View details
`struct` `cv::cudev::divides`	View details
`struct` `cv::cudev::DynamicSharedMem`	View details
`struct` `cv::cudev::DynamicSharedMem< double >`	View details
`struct` `cv::cudev::EnableIf`	View details
`struct` `cv::cudev::equal_to`	View details
`struct` `cv::cudev::Expr`	View details
`struct` `cv::cudev::FindMaxValExprBody`	View details
`struct` `cv::cudev::FindMinMaxValExprBody`	View details
`struct` `cv::cudev::FindMinValExprBody`	View details
`struct` `cv::cudev::GlobPtr`	Structure similar to cv::cudev::GlobPtrSz but containing only a pointer and row step. View details
`struct` `cv::cudev::GlobPtrSz`	Lightweight class encapsulating pitched memory on a GPU and passed to nvcc-compiled code (CUDA kernels). View details
`class` `cv::cudev::GpuMat_< typename T >`	View details
`struct` `cv::cudev::greater`	View details
`struct` `cv::cudev::greater_equal`	View details
`struct` `cv::cudev::HistogramBody`	View details
`struct` `cv::cudev::identity`	View details
`struct` `cv::cudev::InRangeComparator`	Functor that checks if a CUDA vector v is in the range between lowerb and upperb. View details
`struct` `cv::cudev::InRangeCopier`	Functor that copies a cv::Scalar into a CUDA vector, e.g. a uchar3. View details
`struct` `cv::cudev::InRangeFunc`	unary_function implementation of inRange View details
`struct` `cv::cudev::Int2Type`	View details
`struct` `cv::cudev::IntegerAreaInterPtr`	View details
`struct` `cv::cudev::IntegerAreaInterPtrSz`	View details
`struct` `cv::cudev::IntegralBody`	View details
`struct` `cv::cudev::IsBinaryFunction`	View details
`struct` `cv::cudev::IsPowerOf2`	View details
`struct` `cv::cudev::IsUnaryFunction`	View details
`struct` `cv::cudev::LaplacianPtr`	View details
`struct` `cv::cudev::LaplacianPtr< 1, SrcPtr >`	View details
`struct` `cv::cudev::LaplacianPtr< 3, SrcPtr >`	View details
`struct` `cv::cudev::LaplacianPtrSz`	View details
`struct` `cv::cudev::LargerType`	View details
`struct` `cv::cudev::less`	View details
`struct` `cv::cudev::less_equal`	View details
`struct` `cv::cudev::LinearInterPtr`	View details
`struct` `cv::cudev::LinearInterPtrSz`	View details
`struct` `cv::cudev::Log2`	View details
`struct` `cv::cudev::Log2< N, 0, COUNT >`	View details
`struct` `cv::cudev::logical_and`	View details
`struct` `cv::cudev::logical_not`	View details
`struct` `cv::cudev::logical_or`	View details
`struct` `cv::cudev::LutPtr`	View details
`struct` `cv::cudev::LutPtrSz`	View details
`struct` `cv::cudev::magnitude_direction_interleaved_func`	View details
`struct` `cv::cudev::magnitude_func`	View details
`struct` `cv::cudev::magnitude_interleaved_func`	View details
`struct` `cv::cudev::magnitude_sqr_func`	View details
`struct` `cv::cudev::magnitude_sqr_interleaved_func`	View details
`struct` `cv::cudev::MakeVec`	View details
`struct` `cv::cudev::MakeVec< bool, 1 >`	View details
`struct` `cv::cudev::MakeVec< bool, 2 >`	View details
`struct` `cv::cudev::MakeVec< bool, 3 >`	View details
`struct` `cv::cudev::MakeVec< bool, 4 >`	View details
`struct` `cv::cudev::MakeVec< schar, 1 >`	View details
`struct` `cv::cudev::MakeVec< schar, 2 >`	View details
`struct` `cv::cudev::MakeVec< schar, 3 >`	View details
`struct` `cv::cudev::MakeVec< schar, 4 >`	View details
`struct` `cv::cudev::Max`	View details
`struct` `cv::cudev::maximum`	View details
`struct` `cv::cudev::Min`	View details
`struct` `cv::cudev::minimum`	View details
`struct` `cv::cudev::minus`	View details
`struct` `cv::cudev::modulus`	View details
`struct` `cv::cudev::multiplies`	View details
`struct` `cv::cudev::NearestInterPtr`	View details
`struct` `cv::cudev::NearestInterPtrSz`	View details
`struct` `cv::cudev::negate`	View details
`struct` `cv::cudev::NormHamming`	View details
`struct` `cv::cudev::NormL1`	View details
`struct` `cv::cudev::NormL1< float >`	View details
`struct` `cv::cudev::NormL2`	View details
`struct` `cv::cudev::not_equal_to`	View details
`struct` `cv::cudev::NullType`	View details
`struct` `cv::cudev::numeric_limits`	View details
`struct` `cv::cudev::numeric_limits< bool >`	View details
`struct` `cv::cudev::numeric_limits< double >`	View details
`struct` `cv::cudev::numeric_limits< float >`	View details
`struct` `cv::cudev::numeric_limits< schar >`	View details
`struct` `cv::cudev::numeric_limits< short >`	View details
`struct` `cv::cudev::numeric_limits< uchar >`	View details
`struct` `cv::cudev::numeric_limits< uint >`	View details
`struct` `cv::cudev::numeric_limits< ushort >`	View details
`struct` `cv::cudev::PerspectiveMapPtr`	View details
`struct` `cv::cudev::PerspectiveMapPtrSz`	View details
`struct` `cv::cudev::plus`	View details
`struct` `cv::cudev::pow_func`	View details
`struct` `cv::cudev::pow_func< double >`	View details
`struct` `cv::cudev::project1st`	View details
`struct` `cv::cudev::project2nd`	View details
`struct` `cv::cudev::PtrTraits`	View details
`struct` `cv::cudev::PtrTraits< AffineMapPtrSz >`	View details
`struct` `cv::cudev::PtrTraits< BinaryTransformPtrSz< Src1Ptr, Src2Ptr, Op > >`	View details
`struct` `cv::cudev::PtrTraits< CommonAreaInterPtrSz< SrcPtr > >`	View details
`struct` `cv::cudev::PtrTraits< ConstantPtrSz< T > >`	View details
`struct` `cv::cudev::PtrTraits< CubicInterPtrSz< SrcPtr > >`	View details
`struct` `cv::cudev::PtrTraits< DerivXPtrSz< SrcPtr > >`	View details
`struct` `cv::cudev::PtrTraits< DerivYPtrSz< SrcPtr > >`	View details
`struct` `cv::cudev::PtrTraits< Expr< Body > >`	View details
`struct` `cv::cudev::PtrTraits< GlobPtrSz< T > >`	View details
`struct` `cv::cudev::PtrTraits< GpuMat_< T > >`	View details
`struct` `cv::cudev::PtrTraits< IntegerAreaInterPtrSz< SrcPtr > >`	View details
`struct` `cv::cudev::PtrTraits< LaplacianPtrSz< ksize, SrcPtr > >`	View details
`struct` `cv::cudev::PtrTraits< LinearInterPtrSz< SrcPtr > >`	View details
`struct` `cv::cudev::PtrTraits< LutPtrSz< SrcPtr, TablePtr > >`	View details
`struct` `cv::cudev::PtrTraits< NearestInterPtrSz< SrcPtr > >`	View details
`struct` `cv::cudev::PtrTraits< PerspectiveMapPtrSz >`	View details
`struct` `cv::cudev::PtrTraits< RemapPtr1Sz< SrcPtr, MapPtr > >`	View details
`struct` `cv::cudev::PtrTraits< RemapPtr2Sz< SrcPtr, MapXPtr, MapYPtr > >`	View details
`struct` `cv::cudev::PtrTraits< ResizePtrSz< SrcPtr > >`	View details
`struct` `cv::cudev::PtrTraits< ScharrXPtrSz< SrcPtr > >`	View details
`struct` `cv::cudev::PtrTraits< ScharrYPtrSz< SrcPtr > >`	View details
`struct` `cv::cudev::PtrTraits< SingleMaskChannelsSz< MaskPtr > >`	View details
`struct` `cv::cudev::PtrTraits< SobelXPtrSz< SrcPtr > >`	View details
`struct` `cv::cudev::PtrTraits< SobelYPtrSz< SrcPtr > >`	View details
`struct` `cv::cudev::PtrTraits< Texture< T, R > >`	View details
`struct` `cv::cudev::PtrTraits< UnaryTransformPtrSz< SrcPtr, Op > >`	View details
`struct` `cv::cudev::PtrTraits< ZipPtrSz< PtrTuple > >`	View details
`struct` `cv::cudev::PtrTraitsBase`	View details
`struct` `cv::cudev::PyrDownBody`	View details
`struct` `cv::cudev::PyrUpBody`	View details
`struct` `cv::cudev::ReduceToColumnBody`	View details
`struct` `cv::cudev::ReduceToRowBody`	View details
`struct` `cv::cudev::RemapPtr1`	View details
`struct` `cv::cudev::RemapPtr1Sz`	View details
`struct` `cv::cudev::RemapPtr2`	View details
`struct` `cv::cudev::RemapPtr2Sz`	View details
`struct` `cv::cudev::ResizePtr`	View details
`struct` `cv::cudev::ResizePtrSz`	View details
`struct` `cv::cudev::saturate_cast_fp16_func`	View details
`struct` `cv::cudev::saturate_cast_fp16_func< float, short >`	View details
`struct` `cv::cudev::saturate_cast_fp16_func< short, float >`	View details
`struct` `cv::cudev::saturate_cast_func`	View details
`struct` `cv::cudev::ScharrXPtr`	View details
`struct` `cv::cudev::ScharrXPtrSz`	View details
`struct` `cv::cudev::ScharrYPtr`	View details
`struct` `cv::cudev::ScharrYPtrSz`	View details
`struct` `cv::cudev::SelectIf`	View details
`struct` `cv::cudev::SelectIf< false, ThenType, ElseType >`	View details
`struct` `cv::cudev::SingleMaskChannels`	View details
`struct` `cv::cudev::SingleMaskChannelsSz`	View details
`struct` `cv::cudev::SobelXPtr`	View details
`struct` `cv::cudev::SobelXPtrSz`	View details
`struct` `cv::cudev::SobelYPtr`	View details
`struct` `cv::cudev::SobelYPtrSz`	View details
`struct` `cv::cudev::sqr_func`	View details
`struct` `cv::cudev::Sum`	View details
`struct` `cv::cudev::SumExprBody`	View details
`class` `cv::cudev::Texture< class T, class R >`	sharable smart CUDA texture object View details
`class` `cv::cudev::TextureOff< class T, class R >`	sharable smart CUDA texture object with offset TextureOff is a smart sharable wrapper for a cudaTextureObject_t handle which ensures that the handle is destroyed after use. View details
`struct` `cv::cudev::TextureOffPtr`	View details
`struct` `cv::cudev::TexturePtr`	Simple lightweight structures that encapsulate information about an image texture on the device. They are intended to be passed to nvcc-compiled code. View details
`struct` `cv::cudev::TexturePtr< uint64, R >`	View details
`struct` `cv::cudev::ThreshBinaryFunc`	View details
`struct` `cv::cudev::ThreshBinaryInvFunc`	View details
`struct` `cv::cudev::ThreshToZeroFunc`	View details
`struct` `cv::cudev::ThreshToZeroInvFunc`	View details
`struct` `cv::cudev::ThreshTruncFunc`	View details
`struct` `cv::cudev::TransposeBody`	View details
`struct` `cv::cudev::TupleTraits`	View details
`struct` `cv::cudev::TupleTraits< tuple< P0, P1, P2, P3, P4, P5, P6, P7, P8, P9 > >`	View details
`struct` `cv::cudev::TypesEquals`	View details
`struct` `cv::cudev::TypesEquals< A, A >`	View details
`struct` `cv::cudev::TypeTraits`	View details
`struct` `cv::cudev::unary_function`	View details
`struct` `cv::cudev::UnaryNegate`	View details
`struct` `cv::cudev::UnaryTransformPtr`	View details
`struct` `cv::cudev::UnaryTransformPtrSz`	View details
`struct` `cv::cudev::UnaryTupleAdapter`	View details
`class` `cv::cudev::UniqueTexture< class T, class R >`	non-copyable smart CUDA texture object View details
`struct` `cv::cudev::VecTraits`	View details
`struct` `cv::cudev::VecTraits< char1 >`	View details
`struct` `cv::cudev::VecTraits< char2 >`	View details
`struct` `cv::cudev::VecTraits< char3 >`	View details
`struct` `cv::cudev::VecTraits< char4 >`	View details
`struct` `cv::cudev::VecTraits< schar >`	View details
`struct` `cv::cudev::Warp`	View details
`struct` `cv::cudev::WithOutMask`	View details
`struct` `cv::cudev::ZipPtr`	View details
`struct` `cv::cudev::ZipPtr< tuple< Ptr0, Ptr1 > >`	View details
`struct` `cv::cudev::ZipPtr< tuple< Ptr0, Ptr1, Ptr2 > >`	View details
`struct` `cv::cudev::ZipPtr< tuple< Ptr0, Ptr1, Ptr2, Ptr3 > >`	View details
`struct` `cv::cudev::ZipPtrSz`	View details

Enumerations#

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

View details

Functions#

Return	Name	Description
	`cv::Texture()`
	`cv::Texture( const int rows_, const int cols_, T * data, const size_t step, const bool normalizedCoords = false, const cudaTextureFilterMode filterMode = cudaFilterModePoint, const cudaTextureAddressMode addressMode = cudaAddressModeClamp, const cudaTextureReadMode readMode = cudaReadModeElementType )`
	`cv::Texture( const size_t sizeInBytes, T * data, const bool normalizedCoords = false, const cudaTextureFilterMode filterMode = cudaFilterModePoint, const cudaTextureAddressMode addressMode = cudaAddressModeClamp, const cudaTextureReadMode readMode = cudaReadModeElementType )`
	`cv::Texture(const Texture & )`
	`cv::Texture( PtrStepSz< T > src, const bool normalizedCoords = false, const cudaTextureFilterMode filterMode = cudaFilterModePoint, const cudaTextureAddressMode addressMode = cudaAddressModeClamp, const cudaTextureReadMode readMode = cudaReadModeElementType )`
	`cv::Texture(Texture && )`
	`cv::TextureOff( const int rows, const int cols, T * data, const size_t step, const int yoff_ = 0, const int xoff_ = 0, const bool normalizedCoords = false, const cudaTextureFilterMode filterMode = cudaFilterModePoint, const cudaTextureAddressMode addressMode = cudaAddressModeClamp, const cudaTextureReadMode readMode = cudaReadModeElementType )`
	`cv::TextureOff(const TextureOff & )`
	`cv::TextureOff( PtrStepSz< T > src, const int yoff_ = 0, const int xoff_ = 0, const bool normalizedCoords = false, const cudaTextureFilterMode filterMode = cudaFilterModePoint, const cudaTextureAddressMode addressMode = cudaAddressModeClamp, const cudaTextureReadMode readMode = cudaReadModeElementType )`
	`cv::TextureOff(TextureOff && )`
	`cv::TextureOffPtr( const cudaTextureObject_t tex_, const int yoff_, const int xoff_ )`
	`cv::TexturePtr()`
	`cv::TexturePtr(const cudaTextureObject_t tex_)`
	`cv::TexturePtr()`
	`cv::TexturePtr(const cudaTextureObject_t tex_)`
	`cv::UniqueTexture()`
	`cv::UniqueTexture( const int rows, const int cols, T * data, const size_t step, const bool normalizedCoords = false, const cudaTextureFilterMode filterMode = cudaFilterModePoint, const cudaTextureAddressMode addressMode = cudaAddressModeClamp, const cudaTextureReadMode readMode = cudaReadModeElementType )`
	`cv::UniqueTexture( const size_t sizeInBytes, T * data, const bool normalizedCoords = false, const cudaTextureFilterMode filterMode = cudaFilterModePoint, const cudaTextureAddressMode addressMode = cudaAddressModeClamp, const cudaTextureReadMode readMode = cudaReadModeElementType )`
	`cv::UniqueTexture(UniqueTexture && other)`
	`cv::UniqueTexture(UniqueTexture & )`
	`cv::~UniqueTexture()`
`AffineMapPtrSz`	`cv::affineMap( Size dstSize, const GpuMat_< float > & warpMat )`
`double`	`cv::atomicAdd( double * address, double val )`
`float`	`cv::atomicAdd( float * address, float val )`
`int`	`cv::atomicAdd( int * address, int val )`
`uint`	`cv::atomicAdd( uint * address, uint val )`
`double`	`cv::atomicMax( double * address, double val )`
`float`	`cv::atomicMax( float * address, float val )`
`int`	`cv::atomicMax( int * address, int val )`
`uint`	`cv::atomicMax( uint * address, uint val )`
`double`	`cv::atomicMin( double * address, double val )`
`float`	`cv::atomicMin( float * address, float val )`
`int`	`cv::atomicMin( int * address, int val )`
`uint`	`cv::atomicMin( uint * address, uint val )`
`BinaryTupleAdapter< Op, n0, n1 >`	`cv::binaryTupleAdapter(const Op & op)`
`Binder1st< Op >`	`cv::bind1st( const Op & op, const typename Op::first_argument_type & arg1 )`
`Binder2nd< Op >`	`cv::bind2nd( const Op & op, const typename Op::second_argument_type & arg2 )`
`void`	`cv::blockCopy( InIt beg, InIt end, OutIt out )`
`void`	`cv::blockFill( It beg, It end, const T & value )`
`void`	`cv::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 )`
`void`	`cv::blockReduce( volatile T * smem, T & val, uint tid, const Op & op )`
`void`	`cv::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 )`
`void`	`cv::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 )`
`void`	`cv::blockReduceKeyVal( volatile K * skeys, K & key, volatile V * svals, V & val, uint tid, const Cmp & cmp )`
`T`	`cv::blockScanExclusive( T data, volatile T * smem, uint tid )`
`T`	`cv::blockScanInclusive( T data, volatile T * smem, uint tid )`
`void`	`cv::blockTransform( InIt beg, InIt end, OutIt out, const UnOp & op )`
`void`	`cv::blockTransform( InIt1 beg1, InIt1 end1, InIt2 beg2, OutIt out, const BinOp & op )`
`void`	`cv::blockYota( OutIt beg, OutIt end, T value )`
`BrdConstant< typename PtrTraits< SrcPtr >::ptr_type >`	`cv::brdConstant(const SrcPtr & src)`
`BrdConstant< typename PtrTraits< SrcPtr >::ptr_type >`	`cv::brdConstant( const SrcPtr & src, typename PtrTraits< SrcPtr >::value_type val )`
`BrdBase< BrdReflect, typename PtrTraits< SrcPtr >::ptr_type >`	`cv::brdReflect(const SrcPtr & src)`
`BrdBase< BrdReflect101, typename PtrTraits< SrcPtr >::ptr_type >`	`cv::brdReflect101(const SrcPtr & src)`
`BrdBase< BrdReplicate, typename PtrTraits< SrcPtr >::ptr_type >`	`cv::brdReplicate(const SrcPtr & src)`
`BrdBase< BrdWrap, typename PtrTraits< SrcPtr >::ptr_type >`	`cv::brdWrap(const SrcPtr & src)`
`D`	`cv::cast_fp16(T v)`
`short`	`cv::cast_fp16< float, short >(float v)`
`float`	`cv::cast_fp16< short, float >(short v)`
`void`	`cv::checkCudaError( cudaError_t err, const char * file, const int line, const char * func )`
`ConstantPtr< T >`	`cv::constantPtr(T value)`
`ConstantPtrSz< T >`	`cv::constantPtr( T value, int rows, int cols )`
`Expr< CountNonZeroExprBody< SrcPtr > >`	`cv::countNonZero_(const SrcPtr & src)`
`void`	`cv::create( const int rows, const int cols, T1 * data, const size_t step, const bool normalizedCoords, const cudaTextureFilterMode filterMode, const cudaTextureAddressMode addressMode, const cudaTextureReadMode readMode )`
`void`	`cv::create( const int rows, const int cols, uint64 * data, const size_t step, const bool normalizedCoords, const cudaTextureFilterMode filterMode, const cudaTextureAddressMode addressMode, const cudaTextureReadMode readMode )`
`void`	`cv::create( const size_t sizeInBytes, T1 * data, const bool normalizedCoords, const cudaTextureFilterMode filterMode, const cudaTextureAddressMode addressMode, const cudaTextureReadMode readMode )`
`void`	`cv::create( const size_t sizeInBytes, uint64 * data, const bool normalizedCoords, const cudaTextureFilterMode filterMode, const cudaTextureAddressMode addressMode, const cudaTextureReadMode readMode )`
`void`	`cv::createTextureObject( cudaResourceDesc texRes, const bool normalizedCoords, const cudaTextureFilterMode filterMode, const cudaTextureAddressMode addressMode, const cudaTextureReadMode readMode )`
	`cv::CV_CUDEV_GRAY2RGB5x5_INST( GRAY_to_BGR555 , 5 )`
	`cv::CV_CUDEV_Lab2RGB_INST( Lab_to_BGR , 3 , 3 , true , 0 )`
	`cv::CV_CUDEV_Lab2RGB_INST( Lab_to_BGRA , 3 , 4 , true , 0 )`
	`cv::CV_CUDEV_Lab2RGB_INST( Lab_to_LBGR , 3 , 3 , false , 0 )`
	`cv::CV_CUDEV_Lab2RGB_INST( Lab_to_LBGRA , 3 , 4 , false , 0 )`
	`cv::CV_CUDEV_Lab2RGB_INST( Lab_to_LRGB , 3 , 3 , false , 2 )`
	`cv::CV_CUDEV_Lab2RGB_INST( Lab_to_LRGBA , 3 , 4 , false , 2 )`
	`cv::CV_CUDEV_Lab2RGB_INST( Lab_to_RGB , 3 , 3 , true , 2 )`
	`cv::CV_CUDEV_Lab2RGB_INST( Lab_to_RGBA , 3 , 4 , true , 2 )`
	`cv::CV_CUDEV_Luv2RGB_INST( Luv_to_BGR , 3 , 3 , true , 0 )`
	`cv::CV_CUDEV_Luv2RGB_INST( Luv_to_BGRA , 3 , 4 , true , 0 )`
	`cv::CV_CUDEV_Luv2RGB_INST( Luv_to_LBGR , 3 , 3 , false , 0 )`
	`cv::CV_CUDEV_Luv2RGB_INST( Luv_to_LBGRA , 3 , 4 , false , 0 )`
	`cv::CV_CUDEV_Luv2RGB_INST( Luv_to_LRGB , 3 , 3 , false , 2 )`
	`cv::CV_CUDEV_Luv2RGB_INST( Luv_to_LRGBA , 3 , 4 , false , 2 )`
	`cv::CV_CUDEV_Luv2RGB_INST( Luv_to_RGB , 3 , 3 , true , 2 )`
	`cv::CV_CUDEV_Luv2RGB_INST( Luv_to_RGBA , 3 , 4 , true , 2 )`
	`cv::CV_CUDEV_RGB2Lab_INST( BGR_to_Lab , 3 , 3 , true , 0 )`
	`cv::CV_CUDEV_RGB2Lab_INST( BGR_to_Lab4 , 3 , 4 , true , 0 )`
	`cv::CV_CUDEV_RGB2Lab_INST( LBGR_to_Lab , 3 , 3 , false , 0 )`
	`cv::CV_CUDEV_RGB2Lab_INST( LBGR_to_Lab4 , 3 , 4 , false , 0 )`
	`cv::CV_CUDEV_RGB2Lab_INST( LRGB_to_Lab , 3 , 3 , false , 2 )`
	`cv::CV_CUDEV_RGB2Lab_INST( LRGB_to_Lab4 , 3 , 4 , false , 2 )`
	`cv::CV_CUDEV_RGB2Lab_INST( RGB_to_Lab , 3 , 3 , true , 2 )`
	`cv::CV_CUDEV_RGB2Lab_INST( RGB_to_Lab4 , 3 , 4 , true , 2 )`
	`cv::CV_CUDEV_RGB2Luv_INST( BGR_to_Luv , 3 , 3 , true , 0 )`
	`cv::CV_CUDEV_RGB2Luv_INST( BGR_to_Luv4 , 3 , 4 , true , 0 )`
	`cv::CV_CUDEV_RGB2Luv_INST( LBGR_to_Luv , 3 , 3 , false , 0 )`
	`cv::CV_CUDEV_RGB2Luv_INST( LBGR_to_Luv4 , 3 , 4 , false , 0 )`
	`cv::CV_CUDEV_RGB2Luv_INST( LRGB_to_Luv , 3 , 3 , false , 2 )`
	`cv::CV_CUDEV_RGB2Luv_INST( LRGB_to_Luv4 , 3 , 4 , false , 2 )`
	`cv::CV_CUDEV_RGB2Luv_INST( RGB_to_Luv , 3 , 3 , true , 2 )`
	`cv::CV_CUDEV_RGB2Luv_INST( RGB_to_Luv4 , 3 , 4 , true , 2 )`
	`cv::CV_CUDEV_RGB2RGB5x5_INST( BGR_to_BGR555 , 3 , 0 , 5 )`
	`cv::CV_CUDEV_RGB2RGB5x5_INST( BGRA_to_BGR555 , 4 , 0 , 5 )`
	`cv::CV_CUDEV_RGB2RGB5x5_INST( RGB_to_BGR555 , 3 , 2 , 5 )`
	`cv::CV_CUDEV_RGB2RGB5x5_INST( RGBA_to_BGR555 , 4 , 2 , 5 )`
	`cv::CV_CUDEV_RGB2YCrCb_INST( BGR_to_YCrCb , 3 , 3 , 0 )`
	`cv::CV_CUDEV_RGB2YCrCb_INST( BGR_to_YCrCb4 , 3 , 4 , 0 )`
	`cv::CV_CUDEV_RGB2YCrCb_INST( RGB_to_YCrCb , 3 , 3 , 2 )`
	`cv::CV_CUDEV_RGB2YCrCb_INST( RGB_to_YCrCb4 , 3 , 4 , 2 )`
	`cv::CV_CUDEV_RGB5x52GRAY_INST( BGR555_to_GRAY , 5 )`
	`cv::CV_CUDEV_RGB5x52RGB_INST( BGR555_to_BGR , 3 , 0 , 5 )`
	`cv::CV_CUDEV_RGB5x52RGB_INST( BGR555_to_BGRA , 4 , 0 , 5 )`
	`cv::CV_CUDEV_RGB5x52RGB_INST( BGR555_to_RGB , 3 , 2 , 5 )`
	`cv::CV_CUDEV_RGB5x52RGB_INST( BGR555_to_RGBA , 4 , 2 , 5 )`
	`cv::CV_CUDEV_YCrCb2RGB_INST( YCrCb4_to_BGR , 4 , 3 , 0 )`
	`cv::CV_CUDEV_YCrCb2RGB_INST( YCrCb4_to_RGB , 4 , 3 , 2 )`
	`cv::CV_CUDEV_YCrCb2RGB_INST( YCrCb_to_BGR , 3 , 3 , 0 )`
	`cv::CV_CUDEV_YCrCb2RGB_INST( YCrCb_to_RGB , 3 , 3 , 2 )`
`Expr< UnaryTransformPtrSz< typename PtrTraits< SrcPtr >::ptr_type, saturate_cast_func< typename PtrTraits< SrcPtr >::value_type, D > > >`	`cv::cvt_(const SrcPtr & src)`
`Expr< DerivXPtrSz< typename PtrTraits< SrcPtr >::ptr_type > >`	`cv::derivX_(const SrcPtr & src)`
`DerivXPtrSz< typename PtrTraits< SrcPtr >::ptr_type >`	`cv::derivXPtr(const SrcPtr & src)`
`Expr< DerivYPtrSz< typename PtrTraits< SrcPtr >::ptr_type > >`	`cv::derivY_(const SrcPtr & src)`
`DerivYPtrSz< typename PtrTraits< SrcPtr >::ptr_type >`	`cv::derivYPtr(const SrcPtr & src)`
`int`	`cv::divUp( int total, int grain )`
`cudaTextureObject_t`	`cv::get()`
`int`	`cv::getCols(const Ptr2DSz & ptr)`
`int`	`cv::getRows(const Ptr2DSz & ptr)`
`GlobPtrSz< T >`	`cv::globPtr(const GpuMat & mat)`
`GlobPtrSz< T >`	`cv::globPtr(const GpuMat_< T > & mat)`
`GlobPtr< T >`	`cv::globPtr( T * data, size_t step )`
`GlobPtrSz< T >`	`cv::globPtr( T * data, size_t step, int rows, int cols )`
`void`	`cv::gridCalcSum( const SrcPtr & src, GpuMat_< ResType > & dst, const MaskPtr & mask, Stream & stream = Stream::Null() )`
`void`	`cv::gridCalcSum( const SrcPtr & src, GpuMat_< ResType > & dst, Stream & stream = Stream::Null() )`
`void`	`cv::gridCalcSum_( const SrcPtr & src, GpuMat_< ResType > & dst, const MaskPtr & mask, Stream & stream = Stream::Null() )`
`void`	`cv::gridCalcSum_( const SrcPtr & src, GpuMat_< ResType > & dst, Stream & stream = Stream::Null() )`
`void`	`cv::gridCopy( const SrcPtr & src, const GlobPtrSz< DstType > & dst, const MaskPtr & mask, Stream & stream = Stream::Null() )`
`void`	`cv::gridCopy( const SrcPtr & src, const GlobPtrSz< DstType > & dst, Stream & stream = Stream::Null() )`
`void`	`cv::gridCopy( const SrcPtr & src, GpuMat_< DstType > & dst, const MaskPtr & mask, Stream & stream = Stream::Null() )`
`void`	`cv::gridCopy( const SrcPtr & src, GpuMat_< DstType > & dst, Stream & stream = Stream::Null() )`
`void`	`cv::gridCopy( const SrcPtrTuple & src, const tuple< GlobPtrSz< D0 >, GlobPtrSz< D1 > > & dst, const MaskPtr & mask, Stream & stream = Stream::Null() )`
`void`	`cv::gridCopy( const SrcPtrTuple & src, const tuple< GlobPtrSz< D0 >, GlobPtrSz< D1 > > & dst, Stream & stream = Stream::Null() )`
`void`	`cv::gridCopy( const SrcPtrTuple & src, const tuple< GlobPtrSz< D0 >, GlobPtrSz< D1 >, GlobPtrSz< D2 > > & dst, const MaskPtr & mask, Stream & stream = Stream::Null() )`
`void`	`cv::gridCopy( const SrcPtrTuple & src, const tuple< GlobPtrSz< D0 >, GlobPtrSz< D1 >, GlobPtrSz< D2 > > & dst, Stream & stream = Stream::Null() )`
`void`	`cv::gridCopy( const SrcPtrTuple & src, const tuple< GlobPtrSz< D0 >, GlobPtrSz< D1 >, GlobPtrSz< D2 >, GlobPtrSz< D3 > > & dst, const MaskPtr & mask, Stream & stream = Stream::Null() )`
`void`	`cv::gridCopy( const SrcPtrTuple & src, const tuple< GpuMat_< D0 > &, GpuMat_< D1 > & > & dst, const MaskPtr & mask, Stream & stream = Stream::Null() )`
`void`	`cv::gridCopy( const SrcPtrTuple & src, const tuple< GpuMat_< D0 > &, GpuMat_< D1 > & > & dst, Stream & stream = Stream::Null() )`
`void`	`cv::gridCopy( const SrcPtrTuple & src, const tuple< GpuMat_< D0 > &, GpuMat_< D1 > &, GpuMat_< D2 > & > & dst, const MaskPtr & mask, Stream & stream = Stream::Null() )`
`void`	`cv::gridCopy( const SrcPtrTuple & src, const tuple< GpuMat_< D0 > &, GpuMat_< D1 > &, GpuMat_< D2 > & > & dst, Stream & stream = Stream::Null() )`
`void`	`cv::gridCopy( const SrcPtrTuple & src, const tuple< GpuMat_< D0 > &, GpuMat_< D1 > &, GpuMat_< D2 > &, GpuMat_< D3 > & > & dst, const MaskPtr & mask, Stream & stream = Stream::Null() )`
`void`	`cv::gridCopy_( const SrcPtr & src, const GlobPtrSz< DstType > & dst, const MaskPtr & mask, Stream & stream = Stream::Null() )`
`void`	`cv::gridCopy_( const SrcPtr & src, const GlobPtrSz< DstType > & dst, Stream & stream = Stream::Null() )`
`void`	`cv::gridCopy_( const SrcPtr & src, GpuMat_< DstType > & dst, const MaskPtr & mask, Stream & stream = Stream::Null() )`
`void`	`cv::gridCopy_( const SrcPtr & src, GpuMat_< DstType > & dst, Stream & stream = Stream::Null() )`
`void`	`cv::gridCopy_( const SrcPtrTuple & src, const tuple< GlobPtrSz< D0 >, GlobPtrSz< D1 > > & dst, const MaskPtr & mask, Stream & stream = Stream::Null() )`
`void`	`cv::gridCopy_( const SrcPtrTuple & src, const tuple< GlobPtrSz< D0 >, GlobPtrSz< D1 > > & dst, Stream & stream = Stream::Null() )`
`void`	`cv::gridCopy_( const SrcPtrTuple & src, const tuple< GlobPtrSz< D0 >, GlobPtrSz< D1 >, GlobPtrSz< D2 > > & dst, const MaskPtr & mask, Stream & stream = Stream::Null() )`
`void`	`cv::gridCopy_( const SrcPtrTuple & src, const tuple< GlobPtrSz< D0 >, GlobPtrSz< D1 >, GlobPtrSz< D2 > > & dst, Stream & stream = Stream::Null() )`
`void`	`cv::gridCopy_( const SrcPtrTuple & src, const tuple< GlobPtrSz< D0 >, GlobPtrSz< D1 >, GlobPtrSz< D2 >, GlobPtrSz< D3 > > & dst, const MaskPtr & mask, Stream & stream = Stream::Null() )`
`void`	`cv::gridCopy_( const SrcPtrTuple & src, const tuple< GlobPtrSz< D0 >, GlobPtrSz< D1 >, GlobPtrSz< D2 >, GlobPtrSz< D3 > > & dst, Stream & stream = Stream::Null() )`
`void`	`cv::gridCopy_( const SrcPtrTuple & src, const tuple< GlobPtrSz< D0 >, GlobPtrSz< D1 >, GlobPtrSz< D2 >, GlobPtrSz< D3 > > & dst, Stream & stream = Stream::Null() )`
`void`	`cv::gridCopy_( const SrcPtrTuple & src, const tuple< GpuMat_< D0 > &, GpuMat_< D1 > & > & dst, const MaskPtr & mask, Stream & stream = Stream::Null() )`
`void`	`cv::gridCopy_( const SrcPtrTuple & src, const tuple< GpuMat_< D0 > &, GpuMat_< D1 > & > & dst, Stream & stream = Stream::Null() )`
`void`	`cv::gridCopy_( const SrcPtrTuple & src, const tuple< GpuMat_< D0 > &, GpuMat_< D1 > &, GpuMat_< D2 > & > & dst, const MaskPtr & mask, Stream & stream = Stream::Null() )`
`void`	`cv::gridCopy_( const SrcPtrTuple & src, const tuple< GpuMat_< D0 > &, GpuMat_< D1 > &, GpuMat_< D2 > & > & dst, Stream & stream = Stream::Null() )`
`void`	`cv::gridCopy_( const SrcPtrTuple & src, const tuple< GpuMat_< D0 > &, GpuMat_< D1 > &, GpuMat_< D2 > &, GpuMat_< D3 > & > & dst, const MaskPtr & mask, Stream & stream = Stream::Null() )`
`void`	`cv::gridCopy_( const SrcPtrTuple & src, const tuple< GpuMat_< D0 > &, GpuMat_< D1 > &, GpuMat_< D2 > &, GpuMat_< D3 > & > & dst, Stream & stream = Stream::Null() )`
`void`	`cv::gridCopy_( const SrcPtrTuple & src, const tuple< GpuMat_< D0 > &, GpuMat_< D1 > &, GpuMat_< D2 > &, GpuMat_< D3 > & > & dst, Stream & stream = Stream::Null() )`
`void`	`cv::gridCountNonZero( const SrcPtr & src, GpuMat_< ResType > & dst, const MaskPtr & mask, Stream & stream = Stream::Null() )`
`void`	`cv::gridCountNonZero( const SrcPtr & src, GpuMat_< ResType > & dst, Stream & stream = Stream::Null() )`
`void`	`cv::gridCountNonZero_( const SrcPtr & src, GpuMat_< ResType > & dst, const MaskPtr & mask, Stream & stream = Stream::Null() )`
`void`	`cv::gridCountNonZero_( const SrcPtr & src, GpuMat_< ResType > & dst, Stream & stream = Stream::Null() )`
`void`	`cv::gridFindMaxVal( const SrcPtr & src, GpuMat_< ResType > & dst, const MaskPtr & mask, Stream & stream = Stream::Null() )`
`void`	`cv::gridFindMaxVal( const SrcPtr & src, GpuMat_< ResType > & dst, Stream & stream = Stream::Null() )`
`void`	`cv::gridFindMaxVal_( const SrcPtr & src, GpuMat_< ResType > & dst, const MaskPtr & mask, Stream & stream = Stream::Null() )`
`void`	`cv::gridFindMaxVal_( const SrcPtr & src, GpuMat_< ResType > & dst, Stream & stream = Stream::Null() )`
`void`	`cv::gridFindMinMaxVal( const SrcPtr & src, GpuMat_< ResType > & dst, const MaskPtr & mask, Stream & stream = Stream::Null() )`
`void`	`cv::gridFindMinMaxVal( const SrcPtr & src, GpuMat_< ResType > & dst, Stream & stream = Stream::Null() )`
`void`	`cv::gridFindMinMaxVal_( const SrcPtr & src, GpuMat_< ResType > & dst, const MaskPtr & mask, Stream & stream = Stream::Null() )`
`void`	`cv::gridFindMinMaxVal_( const SrcPtr & src, GpuMat_< ResType > & dst, Stream & stream = Stream::Null() )`
`void`	`cv::gridFindMinVal( const SrcPtr & src, GpuMat_< ResType > & dst, const MaskPtr & mask, Stream & stream = Stream::Null() )`
`void`	`cv::gridFindMinVal( const SrcPtr & src, GpuMat_< ResType > & dst, Stream & stream = Stream::Null() )`
`void`	`cv::gridFindMinVal_( const SrcPtr & src, GpuMat_< ResType > & dst, const MaskPtr & mask, Stream & stream = Stream::Null() )`
`void`	`cv::gridFindMinVal_( const SrcPtr & src, GpuMat_< ResType > & dst, Stream & stream = Stream::Null() )`
`void`	`cv::gridHistogram( const SrcPtr & src, GpuMat_< ResType > & dst, const MaskPtr & mask, Stream & stream = Stream::Null() )`
`void`	`cv::gridHistogram( const SrcPtr & src, GpuMat_< ResType > & dst, Stream & stream = Stream::Null() )`
`void`	`cv::gridHistogram_( const SrcPtr & src, GpuMat_< ResType > & dst, const MaskPtr & mask, Stream & stream = Stream::Null() )`
`void`	`cv::gridHistogram_( const SrcPtr & src, GpuMat_< ResType > & dst, Stream & stream = Stream::Null() )`
`void`	`cv::gridIntegral( const SrcPtr & src, GpuMat_< DstType > & dst, Stream & stream = Stream::Null() )`
`void`	`cv::gridMerge( const SrcPtrTuple & src, const GlobPtrSz< DstType > & dst, const MaskPtr & mask, Stream & stream = Stream::Null() )`
`void`	`cv::gridMerge( const SrcPtrTuple & src, const GlobPtrSz< DstType > & dst, Stream & stream = Stream::Null() )`
`void`	`cv::gridMerge( const SrcPtrTuple & src, GpuMat_< DstType > & dst, const MaskPtr & mask, Stream & stream = Stream::Null() )`
`void`	`cv::gridMerge( const SrcPtrTuple & src, GpuMat_< DstType > & dst, Stream & stream = Stream::Null() )`
`void`	`cv::gridMerge( const std::array< ArrayType, ArraySize > & src, const GlobPtrSz< DstType > & dst, const MaskPtr & mask, Stream & stream = Stream::Null() )`
`void`	`cv::gridMerge( const std::array< ArrayType, ArraySize > & src, const GlobPtrSz< DstType > & dst, Stream & stream = Stream::Null() )`
`void`	`cv::gridMerge( const std::array< ArrayType, ArraySize > & src, GpuMat_< DstType > & dst, Stream & stream = Stream::Null() )`
`void`	`cv::gridMerge_( const SrcPtrTuple & src, const GlobPtrSz< DstType > & dst, const MaskPtr & mask, Stream & stream = Stream::Null() )`
`void`	`cv::gridMerge_( const SrcPtrTuple & src, const GlobPtrSz< DstType > & dst, Stream & stream = Stream::Null() )`
`void`	`cv::gridMerge_( const SrcPtrTuple & src, GpuMat_< DstType > & dst, const MaskPtr & mask, Stream & stream = Stream::Null() )`
`void`	`cv::gridMerge_( const SrcPtrTuple & src, GpuMat_< DstType > & dst, Stream & stream = Stream::Null() )`
`void`	`cv::gridMergeArray( const std::array< ArrayType, ArraySize > & src, GpuMat_< DstType > & dst, const MaskPtr & mask, Stream & stream = Stream::Null() )`
`void`	`cv::gridMergeArray_( const std::array< ArrayType, ArraySize > & src, const GlobPtrSz< DstType > & dst, const MaskPtr & mask, Stream & stream = Stream::Null() )`
`void`	`cv::gridMergeArray_( const std::array< ArrayType, ArraySize > & src, const GlobPtrSz< DstType > & dst, Stream & stream = Stream::Null() )`
`void`	`cv::gridMergeArray_( const std::array< ArrayType, ArraySize > & src, GpuMat_< DstType > & dst, const MaskPtr & mask, Stream & stream = Stream::Null() )`
`void`	`cv::gridMergeArray_( const std::array< ArrayType, ArraySize > & src, GpuMat_< DstType > & dst, Stream & stream = Stream::Null() )`
`void`	`cv::gridMinMaxLoc( const SrcPtr & src, GpuMat_< ResType > & valBuf, GpuMat_< int > & locBuf, const MaskPtr & mask, Stream & stream = Stream::Null() )`
`void`	`cv::gridMinMaxLoc( const SrcPtr & src, GpuMat_< ResType > & valBuf, GpuMat_< int > & locBuf, Stream & stream = Stream::Null() )`
`void`	`cv::gridMinMaxLoc_( const SrcPtr & src, GpuMat_< ResType > & valBuf, GpuMat_< int > & locBuf, const MaskPtr & mask, Stream & stream = Stream::Null() )`
`void`	`cv::gridMinMaxLoc_( const SrcPtr & src, GpuMat_< ResType > & valBuf, GpuMat_< int > & locBuf, Stream & stream = Stream::Null() )`
`void`	`cv::gridPyrDown( const SrcPtr & src, GpuMat_< DstType > & dst, Stream & stream = Stream::Null() )`
`void`	`cv::gridPyrDown_( const SrcPtr & src, GpuMat_< DstType > & dst, Stream & stream = Stream::Null() )`
`void`	`cv::gridPyrUp( const SrcPtr & src, GpuMat_< DstType > & dst, Stream & stream = Stream::Null() )`
`void`	`cv::gridReduceToColumn( const SrcPtr & src, GpuMat_< ResType > & dst, const MaskPtr & mask, Stream & stream = Stream::Null() )`
`void`	`cv::gridReduceToColumn( const SrcPtr & src, GpuMat_< ResType > & dst, Stream & stream = Stream::Null() )`
`void`	`cv::gridReduceToColumn_( const SrcPtr & src, GpuMat_< ResType > & dst, const MaskPtr & mask, Stream & stream = Stream::Null() )`
`void`	`cv::gridReduceToColumn_( const SrcPtr & src, GpuMat_< ResType > & dst, Stream & stream = Stream::Null() )`
`void`	`cv::gridReduceToRow( const SrcPtr & src, GpuMat_< ResType > & dst, const MaskPtr & mask, Stream & stream = Stream::Null() )`
`void`	`cv::gridReduceToRow( const SrcPtr & src, GpuMat_< ResType > & dst, Stream & stream = Stream::Null() )`
`void`	`cv::gridSplit( const SrcPtr & src, const tuple< GpuMat_< DstType > &, GpuMat_< DstType > & > & dst, const MaskPtr & mask, Stream & stream = Stream::Null() )`
`void`	`cv::gridSplit( const SrcPtr & src, const tuple< GpuMat_< DstType > &, GpuMat_< DstType > & > & dst, Stream & stream = Stream::Null() )`
`void`	`cv::gridSplit( const SrcPtr & src, const tuple< GpuMat_< DstType > &, GpuMat_< DstType > &, GpuMat_< DstType > & > & dst, const MaskPtr & mask, Stream & stream = Stream::Null() )`
`void`	`cv::gridSplit( const SrcPtr & src, const tuple< GpuMat_< DstType > &, GpuMat_< DstType > &, GpuMat_< DstType > & > & dst, Stream & stream = Stream::Null() )`
`void`	`cv::gridSplit( const SrcPtr & src, const tuple< GpuMat_< DstType > &, GpuMat_< DstType > &, GpuMat_< DstType > &, GpuMat_< DstType > & > & dst, const MaskPtr & mask, Stream & stream = Stream::Null() )`
`void`	`cv::gridSplit( const SrcPtr & src, const tuple< GpuMat_< DstType > &, GpuMat_< DstType > &, GpuMat_< DstType > &, GpuMat_< DstType > & > & dst, Stream & stream = Stream::Null() )`
`void`	`cv::gridSplit( const SrcPtr & src, GlobPtrSz< DstType >(&)[COUNT] dst, const MaskPtr & mask, Stream & stream = Stream::Null() )`
`void`	`cv::gridSplit( const SrcPtr & src, GlobPtrSz< DstType >(&)[COUNT] dst, Stream & stream = Stream::Null() )`
`void`	`cv::gridSplit( const SrcPtr & src, GpuMat_< DstType >(&)[COUNT] dst, const MaskPtr & mask, Stream & stream = Stream::Null() )`
`void`	`cv::gridSplit( const SrcPtr & src, GpuMat_< DstType >(&)[COUNT] dst, Stream & stream = Stream::Null() )`
`void`	`cv::gridSplit_( const SrcPtr & src, const tuple< GpuMat_< DstType > &, GpuMat_< DstType > & > & dst, const MaskPtr & mask, Stream & stream = Stream::Null() )`
`void`	`cv::gridSplit_( const SrcPtr & src, const tuple< GpuMat_< DstType > &, GpuMat_< DstType > & > & dst, Stream & stream = Stream::Null() )`
`void`	`cv::gridSplit_( const SrcPtr & src, const tuple< GpuMat_< DstType > &, GpuMat_< DstType > &, GpuMat_< DstType > & > & dst, const MaskPtr & mask, Stream & stream = Stream::Null() )`
`void`	`cv::gridSplit_( const SrcPtr & src, const tuple< GpuMat_< DstType > &, GpuMat_< DstType > &, GpuMat_< DstType > & > & dst, Stream & stream = Stream::Null() )`
`void`	`cv::gridSplit_( const SrcPtr & src, const tuple< GpuMat_< DstType > &, GpuMat_< DstType > &, GpuMat_< DstType > &, GpuMat_< DstType > & > & dst, const MaskPtr & mask, Stream & stream = Stream::Null() )`
`void`	`cv::gridSplit_( const SrcPtr & src, const tuple< GpuMat_< DstType > &, GpuMat_< DstType > &, GpuMat_< DstType > &, GpuMat_< DstType > & > & dst, Stream & stream = Stream::Null() )`
`void`	`cv::gridSplit_( const SrcPtr & src, GlobPtrSz< DstType >(&)[2] dst, const MaskPtr & mask, Stream & stream = Stream::Null() )`
`void`	`cv::gridSplit_( const SrcPtr & src, GlobPtrSz< DstType >(&)[2] dst, Stream & stream = Stream::Null() )`
`void`	`cv::gridSplit_( const SrcPtr & src, GlobPtrSz< DstType >(&)[3] dst, const MaskPtr & mask, Stream & stream = Stream::Null() )`
`void`	`cv::gridSplit_( const SrcPtr & src, GlobPtrSz< DstType >(&)[3] dst, Stream & stream = Stream::Null() )`
`void`	`cv::gridSplit_( const SrcPtr & src, GlobPtrSz< DstType >(&)[4] dst, const MaskPtr & mask, Stream & stream = Stream::Null() )`
`void`	`cv::gridSplit_( const SrcPtr & src, GlobPtrSz< DstType >(&)[4] dst, Stream & stream = Stream::Null() )`
`void`	`cv::gridSplit_( const SrcPtr & src, GpuMat_< DstType >(&)[2] dst, const MaskPtr & mask, Stream & stream = Stream::Null() )`
`void`	`cv::gridSplit_( const SrcPtr & src, GpuMat_< DstType >(&)[2] dst, Stream & stream = Stream::Null() )`
`void`	`cv::gridSplit_( const SrcPtr & src, GpuMat_< DstType >(&)[3] dst, const MaskPtr & mask, Stream & stream = Stream::Null() )`
`void`	`cv::gridSplit_( const SrcPtr & src, GpuMat_< DstType >(&)[3] dst, Stream & stream = Stream::Null() )`
`void`	`cv::gridSplit_( const SrcPtr & src, GpuMat_< DstType >(&)[4] dst, const MaskPtr & mask, Stream & stream = Stream::Null() )`
`void`	`cv::gridSplit_( const SrcPtr & src, GpuMat_< DstType >(&)[4] dst, Stream & stream = Stream::Null() )`
`void`	`cv::gridTransformBinary( const SrcPtr1 & src1, const SrcPtr2 & src2, const GlobPtrSz< DstType > & dst, const Op & op, const MaskPtr & mask, Stream & stream = Stream::Null() )`
`void`	`cv::gridTransformBinary( const SrcPtr1 & src1, const SrcPtr2 & src2, const GlobPtrSz< DstType > & dst, const Op & op, Stream & stream = Stream::Null() )`
`void`	`cv::gridTransformBinary( const SrcPtr1 & src1, const SrcPtr2 & src2, const GlobPtrSz< DstType1 > & dst1, const GlobPtrSz< DstType2 > & dst2, const Op1 & op1, const Op2 & op2, Stream & stream = Stream::Null() )`
`void`	`cv::gridTransformBinary( const SrcPtr1 & src1, const SrcPtr2 & src2, const GlobPtrSz< DstType2 > & dst1, const GlobPtrSz< DstType2 > & dst2, const Op1 & op1, const Op2 & op2, const MaskPtr & mask, Stream & stream = Stream::Null() )`
`void`	`cv::gridTransformBinary( const SrcPtr1 & src1, const SrcPtr2 & src2, GpuMat_< DstType > & dst, const Op & op, const MaskPtr & mask, Stream & stream = Stream::Null() )`
`void`	`cv::gridTransformBinary( const SrcPtr1 & src1, const SrcPtr2 & src2, GpuMat_< DstType > & dst, const Op & op, Stream & stream = Stream::Null() )`
`void`	`cv::gridTransformBinary( const SrcPtr1 & src1, const SrcPtr2 & src2, GpuMat_< DstType1 > & dst1, GpuMat_< DstType2 > & dst2, const Op1 & op1, const Op2 & op2, const MaskPtr & mask, Stream & stream = Stream::Null() )`
`void`	`cv::gridTransformBinary( const SrcPtr1 & src1, const SrcPtr2 & src2, GpuMat_< DstType1 > & dst1, GpuMat_< DstType2 > & dst2, const Op1 & op1, const Op2 & op2, Stream & stream = Stream::Null() )`
`void`	`cv::gridTransformBinary_( const SrcPtr1 & src1, const SrcPtr2 & src2, const GlobPtrSz< DstType > & dst, const BinOp & op, const MaskPtr & mask, Stream & stream = Stream::Null() )`
`void`	`cv::gridTransformBinary_( const SrcPtr1 & src1, const SrcPtr2 & src2, const GlobPtrSz< DstType > & dst, const BinOp & op, Stream & stream = Stream::Null() )`
`void`	`cv::gridTransformBinary_( const SrcPtr1 & src1, const SrcPtr2 & src2, const GlobPtrSz< DstType1 > & dst1, const GlobPtrSz< DstType2 > & dst2, const BinOp1 & op1, const BinOp2 & op2, const MaskPtr & mask, Stream & stream = Stream::Null() )`
`void`	`cv::gridTransformBinary_( const SrcPtr1 & src1, const SrcPtr2 & src2, const GlobPtrSz< DstType1 > & dst1, const GlobPtrSz< DstType2 > & dst2, const BinOp1 & op1, const BinOp2 & op2, Stream & stream = Stream::Null() )`
`void`	`cv::gridTransformBinary_( const SrcPtr1 & src1, const SrcPtr2 & src2, GpuMat_< DstType > & dst, const BinOp & op, const MaskPtr & mask, Stream & stream = Stream::Null() )`
`void`	`cv::gridTransformBinary_( const SrcPtr1 & src1, const SrcPtr2 & src2, GpuMat_< DstType > & dst, const BinOp & op, Stream & stream = Stream::Null() )`
`void`	`cv::gridTransformBinary_( const SrcPtr1 & src1, const SrcPtr2 & src2, GpuMat_< DstType1 > & dst1, GpuMat_< DstType2 > & dst2, const BinOp1 & op1, const BinOp2 & op2, const MaskPtr & mask, Stream & stream = Stream::Null() )`
`void`	`cv::gridTransformBinary_( const SrcPtr1 & src1, const SrcPtr2 & src2, GpuMat_< DstType1 > & dst1, GpuMat_< DstType2 > & dst2, const BinOp1 & op1, const BinOp2 & op2, Stream & stream = Stream::Null() )`
`void`	`cv::gridTransformTuple( const SrcPtr & src, const tuple< GlobPtrSz< D0 >, GlobPtrSz< D1 > > & dst, const OpTuple & op, const MaskPtr & mask, Stream & stream = Stream::Null() )`
`void`	`cv::gridTransformTuple( const SrcPtr & src, const tuple< GlobPtrSz< D0 >, GlobPtrSz< D1 > > & dst, const OpTuple & op, Stream & stream = Stream::Null() )`
`void`	`cv::gridTransformTuple( const SrcPtr & src, const tuple< GlobPtrSz< D0 >, GlobPtrSz< D1 >, GlobPtrSz< D2 > > & dst, const OpTuple & op, const MaskPtr & mask, Stream & stream = Stream::Null() )`
`void`	`cv::gridTransformTuple( const SrcPtr & src, const tuple< GlobPtrSz< D0 >, GlobPtrSz< D1 >, GlobPtrSz< D2 > > & dst, const OpTuple & op, Stream & stream = Stream::Null() )`
`void`	`cv::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() )`
`void`	`cv::gridTransformTuple( const SrcPtr & src, const tuple< GlobPtrSz< D0 >, GlobPtrSz< D1 >, GlobPtrSz< D2 >, GlobPtrSz< D3 > > & dst, const OpTuple & op, Stream & stream = Stream::Null() )`
`void`	`cv::gridTransformTuple( const SrcPtr & src, const tuple< GpuMat_< D0 > &, GpuMat_< D1 > & > & dst, const OpTuple & op, const MaskPtr & mask, Stream & stream = Stream::Null() )`
`void`	`cv::gridTransformTuple( const SrcPtr & src, const tuple< GpuMat_< D0 > &, GpuMat_< D1 > & > & dst, const OpTuple & op, Stream & stream = Stream::Null() )`
`void`	`cv::gridTransformTuple( const SrcPtr & src, const tuple< GpuMat_< D0 > &, GpuMat_< D1 > &, GpuMat_< D2 > & > & dst, const OpTuple & op, const MaskPtr & mask, Stream & stream = Stream::Null() )`
`void`	`cv::gridTransformTuple( const SrcPtr & src, const tuple< GpuMat_< D0 > &, GpuMat_< D1 > &, GpuMat_< D2 > & > & dst, const OpTuple & op, Stream & stream = Stream::Null() )`
`void`	`cv::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() )`
`void`	`cv::gridTransformTuple( const SrcPtr & src, const tuple< GpuMat_< D0 > &, GpuMat_< D1 > &, GpuMat_< D2 > &, GpuMat_< D3 > & > & dst, const OpTuple & op, Stream & stream = Stream::Null() )`
`void`	`cv::gridTransformTuple_( const SrcPtr & src, const tuple< GlobPtrSz< D0 >, GlobPtrSz< D1 > > & dst, const OpTuple & op, const MaskPtr & mask, Stream & stream = Stream::Null() )`
`void`	`cv::gridTransformTuple_( const SrcPtr & src, const tuple< GlobPtrSz< D0 >, GlobPtrSz< D1 > > & dst, const OpTuple & op, Stream & stream = Stream::Null() )`
`void`	`cv::gridTransformTuple_( const SrcPtr & src, const tuple< GlobPtrSz< D0 >, GlobPtrSz< D1 >, GlobPtrSz< D2 > > & dst, const OpTuple & op, const MaskPtr & mask, Stream & stream = Stream::Null() )`
`void`	`cv::gridTransformTuple_( const SrcPtr & src, const tuple< GlobPtrSz< D0 >, GlobPtrSz< D1 >, GlobPtrSz< D2 > > & dst, const OpTuple & op, Stream & stream = Stream::Null() )`
`void`	`cv::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() )`
`void`	`cv::gridTransformTuple_( const SrcPtr & src, const tuple< GlobPtrSz< D0 >, GlobPtrSz< D1 >, GlobPtrSz< D2 >, GlobPtrSz< D3 > > & dst, const OpTuple & op, Stream & stream = Stream::Null() )`
`void`	`cv::gridTransformTuple_( const SrcPtr & src, const tuple< GpuMat_< D0 > &, GpuMat_< D1 > & > & dst, const OpTuple & op, const MaskPtr & mask, Stream & stream = Stream::Null() )`
`void`	`cv::gridTransformTuple_( const SrcPtr & src, const tuple< GpuMat_< D0 > &, GpuMat_< D1 > & > & dst, const OpTuple & op, Stream & stream = Stream::Null() )`
`void`	`cv::gridTransformTuple_( const SrcPtr & src, const tuple< GpuMat_< D0 > &, GpuMat_< D1 > &, GpuMat_< D2 > & > & dst, const OpTuple & op, const MaskPtr & mask, Stream & stream = Stream::Null() )`
`void`	`cv::gridTransformTuple_( const SrcPtr & src, const tuple< GpuMat_< D0 > &, GpuMat_< D1 > &, GpuMat_< D2 > & > & dst, const OpTuple & op, Stream & stream = Stream::Null() )`
`void`	`cv::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() )`
`void`	`cv::gridTransformTuple_( const SrcPtr & src, const tuple< GpuMat_< D0 > &, GpuMat_< D1 > &, GpuMat_< D2 > &, GpuMat_< D3 > & > & dst, const OpTuple & op, Stream & stream = Stream::Null() )`
`void`	`cv::gridTransformUnary( const SrcPtr & src, const GlobPtrSz< DstType > & dst, const Op & op, const MaskPtr & mask, Stream & stream = Stream::Null() )`
`void`	`cv::gridTransformUnary( const SrcPtr & src, const GlobPtrSz< DstType > & dst, const Op & op, Stream & stream = Stream::Null() )`
`void`	`cv::gridTransformUnary( const SrcPtr & src, GpuMat_< DstType > & dst, const Op & op, const MaskPtr & mask, Stream & stream = Stream::Null() )`
`void`	`cv::gridTransformUnary( const SrcPtr & src, GpuMat_< DstType > & dst, const Op & op, Stream & stream = Stream::Null() )`
`void`	`cv::gridTransformUnary_( const SrcPtr & src, const GlobPtrSz< DstType > & dst, const UnOp & op, const MaskPtr & mask, Stream & stream = Stream::Null() )`
`void`	`cv::gridTransformUnary_( const SrcPtr & src, const GlobPtrSz< DstType > & dst, const UnOp & op, Stream & stream = Stream::Null() )`
`void`	`cv::gridTransformUnary_( const SrcPtr & src, GpuMat_< DstType > & dst, const UnOp & op, const MaskPtr & mask, Stream & stream = Stream::Null() )`
`void`	`cv::gridTransformUnary_( const SrcPtr & src, GpuMat_< DstType > & dst, const UnOp & op, Stream & stream = Stream::Null() )`
`void`	`cv::gridTranspose( const SrcPtr & src, const GlobPtrSz< DstType > & dst, Stream & stream = Stream::Null() )`
`void`	`cv::gridTranspose( const SrcPtr & src, GpuMat_< DstType > & dst, Stream & stream = Stream::Null() )`
`void`	`cv::gridTranspose_( const SrcPtr & src, const GlobPtrSz< DstType > & dst, Stream & stream = Stream::Null() )`
`void`	`cv::gridTranspose_( const SrcPtr & src, GpuMat_< DstType > & dst, Stream & stream = Stream::Null() )`
`Expr< HistogramBody< BIN_COUNT, SrcPtr > >`	`cv::histogram_(const SrcPtr & src)`
`Expr< IntegralBody< SrcPtr > >`	`cv::integral_(const SrcPtr & src)`
`IntegerAreaInterPtrSz< typename PtrTraits< SrcPtr >::ptr_type >`	`cv::interArea( const SrcPtr & src, Size areaSize )`
`CommonAreaInterPtrSz< typename PtrTraits< SrcPtr >::ptr_type >`	`cv::interArea( const SrcPtr & src, Size2f areaSize )`
`CubicInterPtrSz< typename PtrTraits< SrcPtr >::ptr_type >`	`cv::interCubic(const SrcPtr & src)`
`LinearInterPtrSz< typename PtrTraits< SrcPtr >::ptr_type >`	`cv::interLinear(const SrcPtr & src)`
`NearestInterPtrSz< typename PtrTraits< SrcPtr >::ptr_type >`	`cv::interNearest(const SrcPtr & src)`
`Expr< LaplacianPtrSz< ksize, typename PtrTraits< SrcPtr >::ptr_type > >`	`cv::laplacian_(const SrcPtr & src)`
`LaplacianPtrSz< ksize, typename PtrTraits< SrcPtr >::ptr_type >`	`cv::laplacianPtr(const SrcPtr & src)`
`Expr< LutPtrSz< typename PtrTraits< SrcPtr >::ptr_type, typename PtrTraits< TablePtr >::ptr_type > >`	`cv::lut_( const SrcPtr & src, const TablePtr & tbl )`
`LutPtrSz< typename PtrTraits< SrcPtr >::ptr_type, typename PtrTraits< TablePtr >::ptr_type >`	`cv::lutPtr( const SrcPtr & src, const TablePtr & tbl )`
`Expr< Body >`	`cv::makeExpr(const Body & body)`
`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::max_( const SrcPtr1 & src1, const SrcPtr2 & src2 )`
`Expr< FindMaxValExprBody< SrcPtr > >`	`cv::maxVal_(const SrcPtr & src)`
`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::min_( const SrcPtr1 & src1, const SrcPtr2 & src2 )`
`Expr< FindMinMaxValExprBody< SrcPtr > >`	`cv::minMaxVal_(const SrcPtr & src)`
`Expr< FindMinValExprBody< SrcPtr > >`	`cv::minVal_(const SrcPtr & src)`
`UnaryNegate< Predicate >`	`cv::not1(const Predicate & pred)`
`BinaryNegate< Predicate >`	`cv::not2(const Predicate & pred)`
	`cv::operator bool()`
	`cv::operator bool()`
	`cv::operator TextureOffPtr< T, R >()`
	`cv::operator TexturePtr< T, R >()`
`R`	`cv::operator()( index_type y, index_type x )`
`R`	`cv::operator()(index_type x)`
`R`	`cv::operator()( index_type y, index_type x )`
`R`	`cv::operator()(index_type x)`
`R`	`cv::operator()( index_type y, index_type x )`
`Texture &`	`cv::operator=(const Texture & )`
`Texture &`	`cv::operator=(Texture && )`
`TextureOff &`	`cv::operator=(const TextureOff & )`
`TextureOff &`	`cv::operator=(TextureOff && )`
`UniqueTexture &`	`cv::operator=(const UniqueTexture & )`
`UniqueTexture &`	`cv::operator=(UniqueTexture && other)`
`PerspectiveMapPtrSz`	`cv::perspectiveMap( Size dstSize, const GpuMat_< float > & warpMat )`
`Expr< UnaryTransformPtrSz< typename PtrTraits< SrcPtr >::ptr_type, Binder2nd< pow_func< typename PtrTraits< SrcPtr >::value_type > > > >`	`cv::pow_( const SrcPtr & src, float power )`
`Expr< PyrDownBody< SrcPtr > >`	`cv::pyrDown_(const SrcPtr & src)`
`Expr< PyrUpBody< SrcPtr > >`	`cv::pyrUp_(const SrcPtr & src)`
`Expr< ReduceToColumnBody< Reductor, SrcPtr > >`	`cv::reduceToColumn_(const SrcPtr & src)`
`Expr< ReduceToRowBody< Reductor, SrcPtr > >`	`cv::reduceToRow_(const SrcPtr & src)`
`Expr< RemapPtr1Sz< typename PtrTraits< SrcPtr >::ptr_type, typename PtrTraits< MapPtr >::ptr_type > >`	`cv::remap_( const SrcPtr & src, const MapPtr & map )`
`Expr< RemapPtr2Sz< typename PtrTraits< SrcPtr >::ptr_type, typename PtrTraits< MapXPtr >::ptr_type, typename PtrTraits< MapYPtr >::ptr_type > >`	`cv::remap_( const SrcPtr & src, const MapXPtr & mapx, const MapYPtr & mapy )`
`RemapPtr1Sz< typename PtrTraits< SrcPtr >::ptr_type, typename PtrTraits< MapPtr >::ptr_type >`	`cv::remapPtr( const SrcPtr & src, const MapPtr & map )`
`RemapPtr2Sz< typename PtrTraits< SrcPtr >::ptr_type, typename PtrTraits< MapXPtr >::ptr_type, typename PtrTraits< MapYPtr >::ptr_type >`	`cv::remapPtr( const SrcPtr & src, const MapXPtr & mapx, const MapYPtr & mapy )`
`GpuMat_< typename MakeVec< typename VecTraits< T >::elem_type, cn >::type >`	`cv::reshape_( const GpuMat_< T > & mat, int rows = 0 )`
`Expr< ResizePtrSz< typename PtrTraits< SrcPtr >::ptr_type > >`	`cv::resize_( const SrcPtr & src, float fx, float fy )`
`ResizePtrSz< typename PtrTraits< SrcPtr >::ptr_type >`	`cv::resizePtr( const SrcPtr & src, float fx, float fy )`
`T`	`cv::saturate_cast(const char1 & v)`
`T`	`cv::saturate_cast(const char2 & v)`
`T`	`cv::saturate_cast(const char3 & v)`
`T`	`cv::saturate_cast(const char4 & v)`
`T`	`cv::saturate_cast(const double1 & v)`
`T`	`cv::saturate_cast(const double2 & v)`
`T`	`cv::saturate_cast(const double3 & v)`
`T`	`cv::saturate_cast(const double4 & v)`
`T`	`cv::saturate_cast(const float1 & v)`
`T`	`cv::saturate_cast(const float2 & v)`
`T`	`cv::saturate_cast(const float3 & v)`
`T`	`cv::saturate_cast(const float4 & v)`
`T`	`cv::saturate_cast(const int1 & v)`
`T`	`cv::saturate_cast(const int2 & v)`
`T`	`cv::saturate_cast(const int3 & v)`
`T`	`cv::saturate_cast(const int4 & v)`
`T`	`cv::saturate_cast(const short1 & v)`
`T`	`cv::saturate_cast(const short2 & v)`
`T`	`cv::saturate_cast(const short3 & v)`
`T`	`cv::saturate_cast(const short4 & v)`
`T`	`cv::saturate_cast(const uchar1 & v)`
`T`	`cv::saturate_cast(const uchar2 & v)`
`T`	`cv::saturate_cast(const uchar3 & v)`
`T`	`cv::saturate_cast(const uchar4 & v)`
`T`	`cv::saturate_cast(const uint1 & v)`
`T`	`cv::saturate_cast(const uint2 & v)`
`T`	`cv::saturate_cast(const uint3 & v)`
`T`	`cv::saturate_cast(const uint4 & v)`
`T`	`cv::saturate_cast(const ushort1 & v)`
`T`	`cv::saturate_cast(const ushort2 & v)`
`T`	`cv::saturate_cast(const ushort3 & v)`
`T`	`cv::saturate_cast(const ushort4 & v)`
`T`	`cv::saturate_cast(double v)`
`T`	`cv::saturate_cast(float v)`
`T`	`cv::saturate_cast(int v)`
`T`	`cv::saturate_cast(schar v)`
`T`	`cv::saturate_cast(short v)`
`T`	`cv::saturate_cast(signed long long v)`
`T`	`cv::saturate_cast(signed long v)`
`T`	`cv::saturate_cast(uchar v)`
`T`	`cv::saturate_cast(uint v)`
`T`	`cv::saturate_cast(unsigned long long v)`
`T`	`cv::saturate_cast(unsigned long v)`
`T`	`cv::saturate_cast(ushort v)`
`schar`	`cv::saturate_cast< schar >(double v)`
`schar`	`cv::saturate_cast< schar >(float v)`
`schar`	`cv::saturate_cast< schar >(int v)`
`schar`	`cv::saturate_cast< schar >(short v)`
`schar`	`cv::saturate_cast< schar >(uchar v)`
`schar`	`cv::saturate_cast< schar >(uint v)`
`schar`	`cv::saturate_cast< schar >(ushort v)`
`short`	`cv::saturate_cast< short >(double v)`
`short`	`cv::saturate_cast< short >(float v)`
`short`	`cv::saturate_cast< short >(int v)`
`short`	`cv::saturate_cast< short >(uint v)`
`short`	`cv::saturate_cast< short >(ushort v)`
`uchar`	`cv::saturate_cast< uchar >(double v)`
`uchar`	`cv::saturate_cast< uchar >(float v)`
`uchar`	`cv::saturate_cast< uchar >(int v)`
`uchar`	`cv::saturate_cast< uchar >(schar v)`
`uchar`	`cv::saturate_cast< uchar >(short v)`
`uchar`	`cv::saturate_cast< uchar >(uint v)`
`uchar`	`cv::saturate_cast< uchar >(ushort v)`
`uint`	`cv::saturate_cast< uint >(double v)`
`uint`	`cv::saturate_cast< uint >(float v)`
`uint`	`cv::saturate_cast< uint >(int v)`
`uint`	`cv::saturate_cast< uint >(schar v)`
`uint`	`cv::saturate_cast< uint >(short v)`
`ushort`	`cv::saturate_cast< ushort >(double v)`
`ushort`	`cv::saturate_cast< ushort >(float v)`
`ushort`	`cv::saturate_cast< ushort >(int v)`
`ushort`	`cv::saturate_cast< ushort >(schar v)`
`ushort`	`cv::saturate_cast< ushort >(short v)`
`ushort`	`cv::saturate_cast< ushort >(uint v)`
`Expr< ScharrXPtrSz< typename PtrTraits< SrcPtr >::ptr_type > >`	`cv::scharrX_(const SrcPtr & src)`
`ScharrXPtrSz< typename PtrTraits< SrcPtr >::ptr_type >`	`cv::scharrXPtr(const SrcPtr & src)`
`Expr< ScharrYPtrSz< typename PtrTraits< SrcPtr >::ptr_type > >`	`cv::scharrY_(const SrcPtr & src)`
`ScharrYPtrSz< typename PtrTraits< SrcPtr >::ptr_type >`	`cv::scharrYPtr(const SrcPtr & src)`
`PtrTraits< Ptr2DSz >::ptr_type`	`cv::shrinkPtr(const Ptr2DSz & ptr)`
`SingleMaskChannelsSz< typename PtrTraits< MaskPtr >::ptr_type >`	`cv::singleMaskChannels( const MaskPtr & mask, int channels )`
`tuple< volatile T0 * >`	`cv::smem_tuple(T0 * t0)`
`tuple< volatile T0 , volatile T1 >`	`cv::smem_tuple( T0 * t0, T1 * t1 )`
`tuple< volatile T0 , volatile T1 , volatile T2 * >`	`cv::smem_tuple( T0 * t0, T1 * t1, T2 * t2 )`
`tuple< volatile T0 , volatile T1 , volatile T2 , volatile T3 >`	`cv::smem_tuple( T0 * t0, T1 * t1, T2 * t2, T3 * t3 )`
`tuple< volatile T0 , volatile T1 , volatile T2 , volatile T3 , volatile T4 * >`	`cv::smem_tuple( T0 * t0, T1 * t1, T2 * t2, T3 * t3, T4 * t4 )`
`tuple< volatile T0 , volatile T1 , volatile T2 , volatile T3 , volatile T4 , volatile T5 >`	`cv::smem_tuple( T0 * t0, T1 * t1, T2 * t2, T3 * t3, T4 * t4, T5 * t5 )`
`tuple< volatile T0 , volatile T1 , volatile T2 , volatile T3 , volatile T4 , volatile T5 , volatile T6 * >`	`cv::smem_tuple( T0 * t0, T1 * t1, T2 * t2, T3 * t3, T4 * t4, T5 * t5, T6 * t6 )`
`tuple< volatile T0 , volatile T1 , volatile T2 , volatile T3 , volatile T4 , volatile T5 , volatile T6 , volatile T7 >`	`cv::smem_tuple( T0 * t0, T1 * t1, T2 * t2, T3 * t3, T4 * t4, T5 * t5, T6 * t6, T7 * t7 )`
`tuple< volatile T0 , volatile T1 , volatile T2 , volatile T3 , volatile T4 , volatile T5 , volatile T6 , volatile T7 , volatile T8 * >`	`cv::smem_tuple( T0 * t0, T1 * t1, T2 * t2, T3 * t3, T4 * t4, T5 * t5, T6 * t6, T7 * t7, T8 * t8 )`
`tuple< volatile T0 , volatile T1 , volatile T2 , volatile T3 , volatile T4 , volatile T5 , volatile T6 , volatile T7 , volatile T8 , volatile T9 >`	`cv::smem_tuple( T0 * t0, T1 * t1, T2 * t2, T3 * t3, T4 * t4, T5 * t5, T6 * t6, T7 * t7, T8 * t8, T9 * t9 )`
`Expr< SobelXPtrSz< typename PtrTraits< SrcPtr >::ptr_type > >`	`cv::sobelX_(const SrcPtr & src)`
`SobelXPtrSz< typename PtrTraits< SrcPtr >::ptr_type >`	`cv::sobelXPtr(const SrcPtr & src)`
`Expr< SobelYPtrSz< typename PtrTraits< SrcPtr >::ptr_type > >`	`cv::sobelY_(const SrcPtr & src)`
`SobelYPtrSz< typename PtrTraits< SrcPtr >::ptr_type >`	`cv::sobelYPtr(const SrcPtr & src)`
`Expr< SumExprBody< SrcPtr > >`	`cv::sum_(const SrcPtr & src)`
`ThreshBinaryFunc< T >`	`cv::thresh_binary_func( T thresh, T maxVal )`
`ThreshBinaryInvFunc< T >`	`cv::thresh_binary_inv_func( T thresh, T maxVal )`
`ThreshToZeroFunc< T >`	`cv::thresh_to_zero_func(T thresh)`
`ThreshToZeroInvFunc< T >`	`cv::thresh_to_zero_inv_func(T thresh)`
`ThreshTruncFunc< T >`	`cv::thresh_trunc_func(T thresh)`
`Expr< UnaryTransformPtrSz< typename PtrTraits< SrcPtr >::ptr_type, ThreshBinaryFunc< typename PtrTraits< SrcPtr >::value_type > > >`	`cv::threshBinary_( const SrcPtr & src, typename PtrTraits< SrcPtr >::value_type thresh, typename PtrTraits< SrcPtr >::value_type maxVal )`
`Expr< UnaryTransformPtrSz< typename PtrTraits< SrcPtr >::ptr_type, ThreshBinaryInvFunc< typename PtrTraits< SrcPtr >::value_type > > >`	`cv::threshBinaryInv_( const SrcPtr & src, typename PtrTraits< SrcPtr >::value_type thresh, typename PtrTraits< SrcPtr >::value_type maxVal )`
`Expr< UnaryTransformPtrSz< typename PtrTraits< SrcPtr >::ptr_type, ThreshToZeroFunc< typename PtrTraits< SrcPtr >::value_type > > >`	`cv::threshToZero_( const SrcPtr & src, typename PtrTraits< SrcPtr >::value_type thresh )`
`Expr< UnaryTransformPtrSz< typename PtrTraits< SrcPtr >::ptr_type, ThreshToZeroInvFunc< typename PtrTraits< SrcPtr >::value_type > > >`	`cv::threshToZeroInv_( const SrcPtr & src, typename PtrTraits< SrcPtr >::value_type thresh )`
`Expr< UnaryTransformPtrSz< typename PtrTraits< SrcPtr >::ptr_type, ThreshTruncFunc< typename PtrTraits< SrcPtr >::value_type > > >`	`cv::threshTrunc_( const SrcPtr & src, typename PtrTraits< SrcPtr >::value_type thresh )`
`BinaryTransformPtrSz< typename PtrTraits< Src1Ptr >::ptr_type, typename PtrTraits< Src2Ptr >::ptr_type, Op >`	`cv::transformPtr( const Src1Ptr & src1, const Src2Ptr & src2, const Op & op )`
`UnaryTransformPtrSz< typename PtrTraits< SrcPtr >::ptr_type, Op >`	`cv::transformPtr( const SrcPtr & src, const Op & op )`
`Expr< TransposeBody< SrcPtr > >`	`cv::transpose_(const SrcPtr & src)`
`UnaryTupleAdapter< Op, n >`	`cv::unaryTupleAdapter(const Op & op)`
`uint`	`cv::vabsdiff2( uint a, uint b )`
`uint`	`cv::vabsdiff4( uint a, uint b )`
`uint`	`cv::vadd2( uint a, uint b )`
`uint`	`cv::vadd4( uint a, uint b )`
`uint`	`cv::vavg2( uint a, uint b )`
`uint`	`cv::vavg4( uint a, uint b )`
`uint`	`cv::vavrg2( uint a, uint b )`
`uint`	`cv::vavrg4( uint a, uint b )`
`uint`	`cv::vcmpeq2( uint a, uint b )`
`uint`	`cv::vcmpeq4( uint a, uint b )`
`uint`	`cv::vcmpge2( uint a, uint b )`
`uint`	`cv::vcmpge4( uint a, uint b )`
`uint`	`cv::vcmpgt2( uint a, uint b )`
`uint`	`cv::vcmpgt4( uint a, uint b )`
`uint`	`cv::vcmple2( uint a, uint b )`
`uint`	`cv::vcmple4( uint a, uint b )`
`uint`	`cv::vcmplt2( uint a, uint b )`
`uint`	`cv::vcmplt4( uint a, uint b )`
`uint`	`cv::vcmpne2( uint a, uint b )`
`uint`	`cv::vcmpne4( uint a, uint b )`
`uint`	`cv::vmax2( uint a, uint b )`
`uint`	`cv::vmax4( uint a, uint b )`
`uint`	`cv::vmin2( uint a, uint b )`
`uint`	`cv::vmin4( uint a, uint b )`
`uint`	`cv::vseteq2( uint a, uint b )`
`uint`	`cv::vseteq4( uint a, uint b )`
`uint`	`cv::vsetge2( uint a, uint b )`
`uint`	`cv::vsetge4( uint a, uint b )`
`uint`	`cv::vsetgt2( uint a, uint b )`
`uint`	`cv::vsetgt4( uint a, uint b )`
`uint`	`cv::vsetle2( uint a, uint b )`
`uint`	`cv::vsetle4( uint a, uint b )`
`uint`	`cv::vsetlt2( uint a, uint b )`
`uint`	`cv::vsetlt4( uint a, uint b )`
`uint`	`cv::vsetne2( uint a, uint b )`
`uint`	`cv::vsetne4( uint a, uint b )`
`uint`	`cv::vsub2( uint a, uint b )`
`uint`	`cv::vsub4( uint a, uint b )`
`Expr< RemapPtr1Sz< typename PtrTraits< SrcPtr >::ptr_type, AffineMapPtr > >`	`cv::warpAffine_( const SrcPtr & src, Size dstSize, const GpuMat_< float > & warpMat )`
`RemapPtr1Sz< typename PtrTraits< SrcPtr >::ptr_type, AffineMapPtr >`	`cv::warpAffinePtr( const SrcPtr & src, Size dstSize, const GpuMat_< float > & warpMat )`
`OutIt`	`cv::warpCopy( InIt beg, InIt end, OutIt out )`
`void`	`cv::warpFill( It beg, It end, const T & value )`
`Expr< RemapPtr1Sz< typename PtrTraits< SrcPtr >::ptr_type, PerspectiveMapPtr > >`	`cv::warpPerspective_( const SrcPtr & src, Size dstSize, const GpuMat_< float > & warpMat )`
`RemapPtr1Sz< typename PtrTraits< SrcPtr >::ptr_type, PerspectiveMapPtr >`	`cv::warpPerspectivePtr( const SrcPtr & src, Size dstSize, const GpuMat_< float > & warpMat )`
`void`	`cv::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 )`
`void`	`cv::warpReduce( volatile T * smem, T & val, uint tid, const Op & op )`
`void`	`cv::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 )`
`void`	`cv::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 )`
`void`	`cv::warpReduceKeyVal( volatile K * skeys, K & key, volatile V * svals, V & val, uint tid, const Cmp & cmp )`
`T`	`cv::warpScanExclusive( T data, volatile T * smem, uint tid )`
`T`	`cv::warpScanInclusive( T data, volatile T * smem, uint tid )`
`OutIt`	`cv::warpTransform( InIt beg, InIt end, OutIt out, const UnOp & op )`
`OutIt`	`cv::warpTransform( InIt1 beg1, InIt1 end1, InIt2 beg2, OutIt out, const BinOp & op )`
`void`	`cv::warpYota( OutIt beg, OutIt end, T value )`
`ZipPtrSz< tuple< typename PtrTraits< Ptr0 >::ptr_type, typename PtrTraits< Ptr1 >::ptr_type > >`	`cv::zipPtr( const Ptr0 & ptr0, const Ptr1 & ptr1 )`
`ZipPtrSz< tuple< typename PtrTraits< Ptr0 >::ptr_type, typename PtrTraits< Ptr1 >::ptr_type, typename PtrTraits< Ptr2 >::ptr_type > >`	`cv::zipPtr( const Ptr0 & ptr0, const Ptr1 & ptr1, const Ptr2 & ptr2 )`
`ZipPtrSz< tuple< typename PtrTraits< Ptr0 >::ptr_type, typename PtrTraits< Ptr1 >::ptr_type, typename PtrTraits< Ptr2 >::ptr_type, typename PtrTraits< Ptr3 >::ptr_type > >`	`cv::zipPtr( const Ptr0 & ptr0, const Ptr1 & ptr1, const Ptr2 & ptr2, const Ptr3 & ptr3 )`

Variables#

Type	Name	Description
`int`	`cols`
	`false`
`T *`	`internalSrc`
`int`	`rows`
`cudaTextureObject_t`	`tex`
`cudaTextureObject_t`	`tex`
`cudaTextureObject_t`	`tex`
`cudaTextureObject_t`	`tex`
`std::shared_ptr< UniqueTexture< T, R > >`	`texture`
`std::shared_ptr< UniqueTexture< T, R > >`	`texture`
	`true`
`int`	`xoff`
`int`	`xoff`
`int`	`yoff`
`int`	`yoff`

Typedef Documentation#

elem_type#

typedef R cv::cudev::TextureOffPtr::elem_type

#include <opencv2/cudev/ptr2d/texture.hpp>

elem_type#

typedef R cv::cudev::TexturePtr::elem_type

#include <opencv2/cudev/ptr2d/texture.hpp>

index_type#

typedef float cv::cudev::TextureOffPtr::index_type

#include <opencv2/cudev/ptr2d/texture.hpp>

index_type#

typedef float cv::cudev::TexturePtr::index_type

#include <opencv2/cudev/ptr2d/texture.hpp>

index_type#

typedef float cv::cudev::TexturePtr< uint64, R >::index_type

#include <opencv2/cudev/ptr2d/texture.hpp>

value_type#

typedef R cv::cudev::TexturePtr::value_type

#include <opencv2/cudev/ptr2d/texture.hpp>

Enumeration Type Documentation#

enum#

#include <opencv2/cudev/warp/warp.hpp>

Enumerator:

LOG_WARP_SIZE

WARP_SIZE

Function Documentation#

affineMap()#

static AffineMapPtrSz cv::cudev::affineMap(
Size dstSize,
const GpuMat_< float > & warpMat )

#include <opencv2/cudev/ptr2d/warping.hpp>

Here is the call graph for this function:

atomicAdd()#

static double cv::cudev::atomicAdd(
double * address,
double val )

#include <opencv2/cudev/util/atomic.hpp>

atomicAdd()#

float cv::cudev::atomicAdd(
float * address,
float val )

#include <opencv2/cudev/util/atomic.hpp>

atomicAdd()#

int cv::cudev::atomicAdd(
int * address,
int val )

#include <opencv2/cudev/util/atomic.hpp>

atomicAdd()#

uint cv::cudev::atomicAdd(
uint * address,
uint val )

#include <opencv2/cudev/util/atomic.hpp>

atomicMax()#

static double cv::cudev::atomicMax(
double * address,
double val )

#include <opencv2/cudev/util/atomic.hpp>

atomicMax()#

static float cv::cudev::atomicMax(
float * address,
float val )

#include <opencv2/cudev/util/atomic.hpp>

atomicMax()#

int cv::cudev::atomicMax(
int * address,
int val )

#include <opencv2/cudev/util/atomic.hpp>

atomicMax()#

uint cv::cudev::atomicMax(
uint * address,
uint val )

#include <opencv2/cudev/util/atomic.hpp>

atomicMin()#

static double cv::cudev::atomicMin(
double * address,
double val )

#include <opencv2/cudev/util/atomic.hpp>

atomicMin()#

static float cv::cudev::atomicMin(
float * address,
float val )

#include <opencv2/cudev/util/atomic.hpp>

atomicMin()#

int cv::cudev::atomicMin(
int * address,
int val )

#include <opencv2/cudev/util/atomic.hpp>

atomicMin()#

uint cv::cudev::atomicMin(
uint * address,
uint val )

#include <opencv2/cudev/util/atomic.hpp>

binaryTupleAdapter()#

template<int n0, int n1, class Op>
BinaryTupleAdapter< Op, n0, n1 > cv::cudev::binaryTupleAdapter(const Op & op)

#include <opencv2/cudev/functional/tuple_adapter.hpp>

bind1st()#

template<class Op>
Binder1st< Op > cv::cudev::bind1st(
const Op & op,
const typename Op::first_argument_type & arg1 )

#include <opencv2/cudev/functional/functional.hpp>

bind2nd()#

template<class Op>
Binder2nd< Op > cv::cudev::bind2nd(
const Op & op,
const typename Op::second_argument_type & arg2 )

#include <opencv2/cudev/functional/functional.hpp>

blockCopy()#

template<class InIt, class OutIt>
static void cv::cudev::blockCopy(
InIt beg,
InIt end,
OutIt out )

#include <opencv2/cudev/block/block.hpp>

Here is the call graph for this function:

blockFill()#

template<class It, typename T>
static void cv::cudev::blockFill(
It beg,
It end,
const T & value )

#include <opencv2/cudev/block/block.hpp>

Here is the call graph for this function:

blockReduce()#

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>
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 )

#include <opencv2/cudev/block/reduce.hpp>

Here is the call graph for this function:

blockReduce()#

template<int N, typename T, class Op>
void cv::cudev::blockReduce(
volatile T * smem,
T & val,
uint tid,
const Op & op )

#include <opencv2/cudev/block/reduce.hpp>

Here is the call graph for this function:

blockReduceKeyVal()#

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>
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 )

#include <opencv2/cudev/block/reduce.hpp>

Here is the call graph for this function:

blockReduceKeyVal()#

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>
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 )

#include <opencv2/cudev/block/reduce.hpp>

Here is the call graph for this function:

blockReduceKeyVal()#

template<int N, typename K, typename V, class Cmp>
void cv::cudev::blockReduceKeyVal(
volatile K * skeys,
K & key,
volatile V * svals,
V & val,
uint tid,
const Cmp & cmp )

#include <opencv2/cudev/block/reduce.hpp>

Here is the call graph for this function:

blockScanInclusive()#

template<int THREADS_NUM, typename T>
T cv::cudev::blockScanInclusive(
T data,
volatile T * smem,
uint tid )

#include <opencv2/cudev/block/scan.hpp>

Here is the call graph for this function:

blockTransform()#

template<class InIt, class OutIt, class UnOp>
static void cv::cudev::blockTransform(
InIt beg,
InIt end,
OutIt out,
const UnOp & op )

#include <opencv2/cudev/block/block.hpp>

Here is the call graph for this function:

blockTransform()#

template<class InIt1, class InIt2, class OutIt, class BinOp>
static void cv::cudev::blockTransform(
InIt1 beg1,
InIt1 end1,
InIt2 beg2,
OutIt out,
const BinOp & op )

#include <opencv2/cudev/block/block.hpp>

Here is the call graph for this function:

blockYota()#

template<class OutIt, typename T>
static void cv::cudev::blockYota(
OutIt beg,
OutIt end,
T value )

#include <opencv2/cudev/block/block.hpp>

Here is the call graph for this function:

cast_fp16()#

template<typename T, typename D>
D cv::cudev::cast_fp16(T v)

#include <opencv2/cudev/util/saturate_cast.hpp>

checkCudaError()#

void cv::cudev::checkCudaError(
cudaError_t err,
const char * file,
const int line,
const char * func )

#include <opencv2/cudev/common.hpp>

Here is the call graph for this function:

constantPtr()#

template<typename T>
ConstantPtr< T > cv::cudev::constantPtr(T value)

#include <opencv2/cudev/ptr2d/constant.hpp>

constantPtr()#

template<typename T>
ConstantPtrSz< T > cv::cudev::constantPtr(
T value,
int rows,
int cols )

#include <opencv2/cudev/ptr2d/constant.hpp>

countNonZero_()#

template<class SrcPtr>
Expr< CountNonZeroExprBody< SrcPtr > > cv::cudev::countNonZero_(const SrcPtr & src)

#include <opencv2/cudev/expr/reduction.hpp>

Here is the call graph for this function:

CV_CUDEV_GRAY2RGB5x5_INST()#

cv::cudev::CV_CUDEV_GRAY2RGB5x5_INST(
GRAY_to_BGR555 ,
5 )

#include <opencv2/cudev/functional/color_cvt.hpp>

CV_CUDEV_Lab2RGB_INST()#

cv::cudev::CV_CUDEV_Lab2RGB_INST(
Lab_to_BGR ,
3 ,
3 ,
true ,
0 )

#include <opencv2/cudev/functional/color_cvt.hpp>

CV_CUDEV_Lab2RGB_INST()#

cv::cudev::CV_CUDEV_Lab2RGB_INST(
Lab_to_BGRA ,
3 ,
4 ,
true ,
0 )

#include <opencv2/cudev/functional/color_cvt.hpp>

CV_CUDEV_Lab2RGB_INST()#

cv::cudev::CV_CUDEV_Lab2RGB_INST(
Lab_to_LBGR ,
3 ,
3 ,
false ,
0 )

#include <opencv2/cudev/functional/color_cvt.hpp>

CV_CUDEV_Lab2RGB_INST()#

cv::cudev::CV_CUDEV_Lab2RGB_INST(
Lab_to_LBGRA ,
3 ,
4 ,
false ,
0 )

#include <opencv2/cudev/functional/color_cvt.hpp>

CV_CUDEV_Lab2RGB_INST()#

cv::cudev::CV_CUDEV_Lab2RGB_INST(
Lab_to_LRGB ,
3 ,
3 ,
false ,
2 )

#include <opencv2/cudev/functional/color_cvt.hpp>

CV_CUDEV_Lab2RGB_INST()#

cv::cudev::CV_CUDEV_Lab2RGB_INST(
Lab_to_LRGBA ,
3 ,
4 ,
false ,
2 )

#include <opencv2/cudev/functional/color_cvt.hpp>

CV_CUDEV_Lab2RGB_INST()#

cv::cudev::CV_CUDEV_Lab2RGB_INST(
Lab_to_RGB ,
3 ,
3 ,
true ,
2 )

#include <opencv2/cudev/functional/color_cvt.hpp>

CV_CUDEV_Lab2RGB_INST()#

cv::cudev::CV_CUDEV_Lab2RGB_INST(
Lab_to_RGBA ,
3 ,
4 ,
true ,
2 )

#include <opencv2/cudev/functional/color_cvt.hpp>

CV_CUDEV_Luv2RGB_INST()#

cv::cudev::CV_CUDEV_Luv2RGB_INST(
Luv_to_BGR ,
3 ,
3 ,
true ,
0 )

#include <opencv2/cudev/functional/color_cvt.hpp>

CV_CUDEV_Luv2RGB_INST()#

cv::cudev::CV_CUDEV_Luv2RGB_INST(
Luv_to_BGRA ,
3 ,
4 ,
true ,
0 )

#include <opencv2/cudev/functional/color_cvt.hpp>

CV_CUDEV_Luv2RGB_INST()#

cv::cudev::CV_CUDEV_Luv2RGB_INST(
Luv_to_LBGR ,
3 ,
3 ,
false ,
0 )

#include <opencv2/cudev/functional/color_cvt.hpp>

CV_CUDEV_Luv2RGB_INST()#

cv::cudev::CV_CUDEV_Luv2RGB_INST(
Luv_to_LBGRA ,
3 ,
4 ,
false ,
0 )

#include <opencv2/cudev/functional/color_cvt.hpp>

CV_CUDEV_Luv2RGB_INST()#

cv::cudev::CV_CUDEV_Luv2RGB_INST(
Luv_to_LRGB ,
3 ,
3 ,
false ,
2 )

#include <opencv2/cudev/functional/color_cvt.hpp>

CV_CUDEV_Luv2RGB_INST()#

cv::cudev::CV_CUDEV_Luv2RGB_INST(
Luv_to_LRGBA ,
3 ,
4 ,
false ,
2 )

#include <opencv2/cudev/functional/color_cvt.hpp>

CV_CUDEV_Luv2RGB_INST()#

cv::cudev::CV_CUDEV_Luv2RGB_INST(
Luv_to_RGB ,
3 ,
3 ,
true ,
2 )

#include <opencv2/cudev/functional/color_cvt.hpp>

CV_CUDEV_Luv2RGB_INST()#

cv::cudev::CV_CUDEV_Luv2RGB_INST(
Luv_to_RGBA ,
3 ,
4 ,
true ,
2 )

#include <opencv2/cudev/functional/color_cvt.hpp>

CV_CUDEV_RGB2Lab_INST()#

cv::cudev::CV_CUDEV_RGB2Lab_INST(
BGR_to_Lab ,
3 ,
3 ,
true ,
0 )

#include <opencv2/cudev/functional/color_cvt.hpp>

CV_CUDEV_RGB2Lab_INST()#

cv::cudev::CV_CUDEV_RGB2Lab_INST(
BGR_to_Lab4 ,
3 ,
4 ,
true ,
0 )

#include <opencv2/cudev/functional/color_cvt.hpp>

CV_CUDEV_RGB2Lab_INST()#

cv::cudev::CV_CUDEV_RGB2Lab_INST(
LBGR_to_Lab ,
3 ,
3 ,
false ,
0 )

#include <opencv2/cudev/functional/color_cvt.hpp>

CV_CUDEV_RGB2Lab_INST()#

cv::cudev::CV_CUDEV_RGB2Lab_INST(
LBGR_to_Lab4 ,
3 ,
4 ,
false ,
0 )

#include <opencv2/cudev/functional/color_cvt.hpp>

CV_CUDEV_RGB2Lab_INST()#

cv::cudev::CV_CUDEV_RGB2Lab_INST(
LRGB_to_Lab ,
3 ,
3 ,
false ,
2 )

#include <opencv2/cudev/functional/color_cvt.hpp>

CV_CUDEV_RGB2Lab_INST()#

cv::cudev::CV_CUDEV_RGB2Lab_INST(
LRGB_to_Lab4 ,
3 ,
4 ,
false ,
2 )

#include <opencv2/cudev/functional/color_cvt.hpp>

CV_CUDEV_RGB2Lab_INST()#

cv::cudev::CV_CUDEV_RGB2Lab_INST(
RGB_to_Lab ,
3 ,
3 ,
true ,
2 )

#include <opencv2/cudev/functional/color_cvt.hpp>

CV_CUDEV_RGB2Lab_INST()#

cv::cudev::CV_CUDEV_RGB2Lab_INST(
RGB_to_Lab4 ,
3 ,
4 ,
true ,
2 )

#include <opencv2/cudev/functional/color_cvt.hpp>

CV_CUDEV_RGB2Luv_INST()#

cv::cudev::CV_CUDEV_RGB2Luv_INST(
BGR_to_Luv ,
3 ,
3 ,
true ,
0 )

#include <opencv2/cudev/functional/color_cvt.hpp>

CV_CUDEV_RGB2Luv_INST()#

cv::cudev::CV_CUDEV_RGB2Luv_INST(
BGR_to_Luv4 ,
3 ,
4 ,
true ,
0 )

#include <opencv2/cudev/functional/color_cvt.hpp>

CV_CUDEV_RGB2Luv_INST()#

cv::cudev::CV_CUDEV_RGB2Luv_INST(
LBGR_to_Luv ,
3 ,
3 ,
false ,
0 )

#include <opencv2/cudev/functional/color_cvt.hpp>

CV_CUDEV_RGB2Luv_INST()#

cv::cudev::CV_CUDEV_RGB2Luv_INST(
LBGR_to_Luv4 ,
3 ,
4 ,
false ,
0 )

#include <opencv2/cudev/functional/color_cvt.hpp>

CV_CUDEV_RGB2Luv_INST()#

cv::cudev::CV_CUDEV_RGB2Luv_INST(
LRGB_to_Luv ,
3 ,
3 ,
false ,
2 )

#include <opencv2/cudev/functional/color_cvt.hpp>

CV_CUDEV_RGB2Luv_INST()#

cv::cudev::CV_CUDEV_RGB2Luv_INST(
LRGB_to_Luv4 ,
3 ,
4 ,
false ,
2 )

#include <opencv2/cudev/functional/color_cvt.hpp>

CV_CUDEV_RGB2Luv_INST()#

cv::cudev::CV_CUDEV_RGB2Luv_INST(
RGB_to_Luv ,
3 ,
3 ,
true ,
2 )

#include <opencv2/cudev/functional/color_cvt.hpp>

CV_CUDEV_RGB2Luv_INST()#

cv::cudev::CV_CUDEV_RGB2Luv_INST(
RGB_to_Luv4 ,
3 ,
4 ,
true ,
2 )

#include <opencv2/cudev/functional/color_cvt.hpp>

CV_CUDEV_RGB2RGB5x5_INST()#

cv::cudev::CV_CUDEV_RGB2RGB5x5_INST(
BGR_to_BGR555 ,
3 ,
0 ,
5 )

#include <opencv2/cudev/functional/color_cvt.hpp>

CV_CUDEV_RGB2RGB5x5_INST()#

cv::cudev::CV_CUDEV_RGB2RGB5x5_INST(
BGRA_to_BGR555 ,
4 ,
0 ,
5 )

#include <opencv2/cudev/functional/color_cvt.hpp>

CV_CUDEV_RGB2RGB5x5_INST()#

cv::cudev::CV_CUDEV_RGB2RGB5x5_INST(
RGB_to_BGR555 ,
3 ,
2 ,
5 )

#include <opencv2/cudev/functional/color_cvt.hpp>

CV_CUDEV_RGB2RGB5x5_INST()#

cv::cudev::CV_CUDEV_RGB2RGB5x5_INST(
RGBA_to_BGR555 ,
4 ,
2 ,
5 )

#include <opencv2/cudev/functional/color_cvt.hpp>

CV_CUDEV_RGB2YCrCb_INST()#

cv::cudev::CV_CUDEV_RGB2YCrCb_INST(
BGR_to_YCrCb ,
3 ,
3 ,
0 )

#include <opencv2/cudev/functional/color_cvt.hpp>

CV_CUDEV_RGB2YCrCb_INST()#

cv::cudev::CV_CUDEV_RGB2YCrCb_INST(
BGR_to_YCrCb4 ,
3 ,
4 ,
0 )

#include <opencv2/cudev/functional/color_cvt.hpp>

CV_CUDEV_RGB2YCrCb_INST()#

cv::cudev::CV_CUDEV_RGB2YCrCb_INST(
RGB_to_YCrCb ,
3 ,
3 ,
2 )

#include <opencv2/cudev/functional/color_cvt.hpp>

CV_CUDEV_RGB2YCrCb_INST()#

cv::cudev::CV_CUDEV_RGB2YCrCb_INST(
RGB_to_YCrCb4 ,
3 ,
4 ,
2 )

#include <opencv2/cudev/functional/color_cvt.hpp>

CV_CUDEV_RGB5x52GRAY_INST()#

cv::cudev::CV_CUDEV_RGB5x52GRAY_INST(
BGR555_to_GRAY ,
5 )

#include <opencv2/cudev/functional/color_cvt.hpp>

CV_CUDEV_RGB5x52RGB_INST()#

cv::cudev::CV_CUDEV_RGB5x52RGB_INST(
BGR555_to_BGR ,
3 ,
0 ,
5 )

#include <opencv2/cudev/functional/color_cvt.hpp>

CV_CUDEV_RGB5x52RGB_INST()#

cv::cudev::CV_CUDEV_RGB5x52RGB_INST(
BGR555_to_BGRA ,
4 ,
0 ,
5 )

#include <opencv2/cudev/functional/color_cvt.hpp>

CV_CUDEV_RGB5x52RGB_INST()#

cv::cudev::CV_CUDEV_RGB5x52RGB_INST(
BGR555_to_RGB ,
3 ,
2 ,
5 )

#include <opencv2/cudev/functional/color_cvt.hpp>

CV_CUDEV_RGB5x52RGB_INST()#

cv::cudev::CV_CUDEV_RGB5x52RGB_INST(
BGR555_to_RGBA ,
4 ,
2 ,
5 )

#include <opencv2/cudev/functional/color_cvt.hpp>

CV_CUDEV_YCrCb2RGB_INST()#

cv::cudev::CV_CUDEV_YCrCb2RGB_INST(
YCrCb4_to_BGR ,
4 ,
3 ,
0 )

#include <opencv2/cudev/functional/color_cvt.hpp>

CV_CUDEV_YCrCb2RGB_INST()#

cv::cudev::CV_CUDEV_YCrCb2RGB_INST(
YCrCb4_to_RGB ,
4 ,
3 ,
2 )

#include <opencv2/cudev/functional/color_cvt.hpp>

CV_CUDEV_YCrCb2RGB_INST()#

cv::cudev::CV_CUDEV_YCrCb2RGB_INST(
YCrCb_to_BGR ,
3 ,
3 ,
0 )

#include <opencv2/cudev/functional/color_cvt.hpp>

CV_CUDEV_YCrCb2RGB_INST()#

cv::cudev::CV_CUDEV_YCrCb2RGB_INST(
YCrCb_to_RGB ,
3 ,
3 ,
2 )

#include <opencv2/cudev/functional/color_cvt.hpp>

divUp()#

int cv::cudev::divUp(
int total,
int grain )

#include <opencv2/cudev/common.hpp>

getCols()#

template<class Ptr2DSz>
int cv::cudev::getCols(const Ptr2DSz & ptr)

#include <opencv2/cudev/ptr2d/traits.hpp>

Here is the call graph for this function:

getRows()#

template<class Ptr2DSz>
int cv::cudev::getRows(const Ptr2DSz & ptr)

#include <opencv2/cudev/ptr2d/traits.hpp>

Here is the call graph for this function:

globPtr()#

template<typename T>
GlobPtrSz< T > cv::cudev::globPtr(const GpuMat & mat)

#include <opencv2/cudev/ptr2d/glob.hpp>

globPtr()#

template<typename T>
GlobPtrSz< T > cv::cudev::globPtr(const GpuMat_< T > & mat)

#include <opencv2/cudev/ptr2d/glob.hpp>

globPtr()#

template<typename T>
GlobPtr< T > cv::cudev::globPtr(
T * data,
size_t step )

#include <opencv2/cudev/ptr2d/glob.hpp>

globPtr()#

template<typename T>
GlobPtrSz< T > cv::cudev::globPtr(
T * data,
size_t step,
int rows,
int cols )

#include <opencv2/cudev/ptr2d/glob.hpp>

histogram_()#

template<int BIN_COUNT, class SrcPtr>
Expr< HistogramBody< BIN_COUNT, SrcPtr > > cv::cudev::histogram_(const SrcPtr & src)

#include <opencv2/cudev/expr/reduction.hpp>

Here is the call graph for this function:

integral_()#

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

#include <opencv2/cudev/expr/reduction.hpp>

Here is the call graph for this function:

makeExpr()#

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

#include <opencv2/cudev/expr/expr.hpp>

maxVal_()#

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

#include <opencv2/cudev/expr/reduction.hpp>

Here is the call graph for this function:

minMaxVal_()#

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

#include <opencv2/cudev/expr/reduction.hpp>

Here is the call graph for this function:

minVal_()#

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

#include <opencv2/cudev/expr/reduction.hpp>

Here is the call graph for this function:

not1()#

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

#include <opencv2/cudev/functional/functional.hpp>

not2()#

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

#include <opencv2/cudev/functional/functional.hpp>

perspectiveMap()#

static PerspectiveMapPtrSz cv::cudev::perspectiveMap(
Size dstSize,
const GpuMat_< float > & warpMat )

#include <opencv2/cudev/ptr2d/warping.hpp>

Here is the call graph for this function:

pyrDown_()#

template<class SrcPtr>
Expr< PyrDownBody< SrcPtr > > cv::cudev::pyrDown_(const SrcPtr & src)

#include <opencv2/cudev/expr/warping.hpp>

Here is the call graph for this function:

pyrUp_()#

template<class SrcPtr>
Expr< PyrUpBody< SrcPtr > > cv::cudev::pyrUp_(const SrcPtr & src)

#include <opencv2/cudev/expr/warping.hpp>

Here is the call graph for this function:

reduceToColumn_()#

template<class Reductor, class SrcPtr>
Expr< ReduceToColumnBody< Reductor, SrcPtr > > cv::cudev::reduceToColumn_(const SrcPtr & src)

#include <opencv2/cudev/expr/reduction.hpp>

Here is the call graph for this function:

reduceToRow_()#

template<class Reductor, class SrcPtr>
Expr< ReduceToRowBody< Reductor, SrcPtr > > cv::cudev::reduceToRow_(const SrcPtr & src)

#include <opencv2/cudev/expr/reduction.hpp>

Here is the call graph for this function:

reshape_()#

template<int cn, typename T>
GpuMat_< typename MakeVec< typename VecTraits< T >::elem_type, cn >::type > cv::cudev::reshape_(
const GpuMat_< T > & mat,
int rows = 0 )

#include <opencv2/cudev/ptr2d/gpumat.hpp>

creates alternative GpuMat header for the same data, with different number of channels and/or different number of rows. see cvReshape.

Here is the call graph for this function:

saturate_cast()#

template<typename T>
T cv::cudev::saturate_cast(const char1 & v)

#include <opencv2/cudev/util/vec_math.hpp>

saturate_cast()#

template<typename T>
T cv::cudev::saturate_cast(const char2 & v)

#include <opencv2/cudev/util/vec_math.hpp>

saturate_cast()#

template<typename T>
T cv::cudev::saturate_cast(const char3 & v)

#include <opencv2/cudev/util/vec_math.hpp>

saturate_cast()#

template<typename T>
T cv::cudev::saturate_cast(const char4 & v)

#include <opencv2/cudev/util/vec_math.hpp>

saturate_cast()#

template<typename T>
T cv::cudev::saturate_cast(const double1 & v)

#include <opencv2/cudev/util/vec_math.hpp>

saturate_cast()#

template<typename T>
T cv::cudev::saturate_cast(const double2 & v)

#include <opencv2/cudev/util/vec_math.hpp>

saturate_cast()#

template<typename T>
T cv::cudev::saturate_cast(const double3 & v)

#include <opencv2/cudev/util/vec_math.hpp>

saturate_cast()#

template<typename T>
T cv::cudev::saturate_cast(const double4 & v)

#include <opencv2/cudev/util/vec_math.hpp>

saturate_cast()#

template<typename T>
T cv::cudev::saturate_cast(const float1 & v)

#include <opencv2/cudev/util/vec_math.hpp>

saturate_cast()#

template<typename T>
T cv::cudev::saturate_cast(const float2 & v)

#include <opencv2/cudev/util/vec_math.hpp>

saturate_cast()#

template<typename T>
T cv::cudev::saturate_cast(const float3 & v)

#include <opencv2/cudev/util/vec_math.hpp>

saturate_cast()#

template<typename T>
T cv::cudev::saturate_cast(const float4 & v)

#include <opencv2/cudev/util/vec_math.hpp>

saturate_cast()#

template<typename T>
T cv::cudev::saturate_cast(const int1 & v)

#include <opencv2/cudev/util/vec_math.hpp>

saturate_cast()#

template<typename T>
T cv::cudev::saturate_cast(const int2 & v)

#include <opencv2/cudev/util/vec_math.hpp>

saturate_cast()#

template<typename T>
T cv::cudev::saturate_cast(const int3 & v)

#include <opencv2/cudev/util/vec_math.hpp>

saturate_cast()#

template<typename T>
T cv::cudev::saturate_cast(const int4 & v)

#include <opencv2/cudev/util/vec_math.hpp>

saturate_cast()#

template<typename T>
T cv::cudev::saturate_cast(const short1 & v)

#include <opencv2/cudev/util/vec_math.hpp>

saturate_cast()#

template<typename T>
T cv::cudev::saturate_cast(const short2 & v)

#include <opencv2/cudev/util/vec_math.hpp>

saturate_cast()#

template<typename T>
T cv::cudev::saturate_cast(const short3 & v)

#include <opencv2/cudev/util/vec_math.hpp>

saturate_cast()#

template<typename T>
T cv::cudev::saturate_cast(const short4 & v)

#include <opencv2/cudev/util/vec_math.hpp>

saturate_cast()#

template<typename T>
T cv::cudev::saturate_cast(const uchar1 & v)

#include <opencv2/cudev/util/vec_math.hpp>

saturate_cast()#

template<typename T>
T cv::cudev::saturate_cast(const uchar2 & v)

#include <opencv2/cudev/util/vec_math.hpp>

saturate_cast()#

template<typename T>
T cv::cudev::saturate_cast(const uchar3 & v)

#include <opencv2/cudev/util/vec_math.hpp>

saturate_cast()#

template<typename T>
T cv::cudev::saturate_cast(const uchar4 & v)

#include <opencv2/cudev/util/vec_math.hpp>

saturate_cast()#

template<typename T>
T cv::cudev::saturate_cast(const uint1 & v)

#include <opencv2/cudev/util/vec_math.hpp>

saturate_cast()#

template<typename T>
T cv::cudev::saturate_cast(const uint2 & v)

#include <opencv2/cudev/util/vec_math.hpp>

saturate_cast()#

template<typename T>
T cv::cudev::saturate_cast(const uint3 & v)

#include <opencv2/cudev/util/vec_math.hpp>

saturate_cast()#

template<typename T>
T cv::cudev::saturate_cast(const uint4 & v)

#include <opencv2/cudev/util/vec_math.hpp>

saturate_cast()#

template<typename T>
T cv::cudev::saturate_cast(const ushort1 & v)

#include <opencv2/cudev/util/vec_math.hpp>

saturate_cast()#

template<typename T>
T cv::cudev::saturate_cast(const ushort2 & v)

#include <opencv2/cudev/util/vec_math.hpp>

saturate_cast()#

template<typename T>
T cv::cudev::saturate_cast(const ushort3 & v)

#include <opencv2/cudev/util/vec_math.hpp>

saturate_cast()#

template<typename T>
T cv::cudev::saturate_cast(const ushort4 & v)

#include <opencv2/cudev/util/vec_math.hpp>

saturate_cast()#

template<typename T>
T cv::cudev::saturate_cast(double v)

#include <opencv2/cudev/util/saturate_cast.hpp>

saturate_cast()#

template<typename T>
T cv::cudev::saturate_cast(float v)

#include <opencv2/cudev/util/saturate_cast.hpp>

saturate_cast()#

template<typename T>
T cv::cudev::saturate_cast(int v)

#include <opencv2/cudev/util/saturate_cast.hpp>

saturate_cast()#

template<typename T>
T cv::cudev::saturate_cast(schar v)

#include <opencv2/cudev/util/saturate_cast.hpp>

saturate_cast()#

template<typename T>
T cv::cudev::saturate_cast(short v)

#include <opencv2/cudev/util/saturate_cast.hpp>

saturate_cast()#

template<typename T>
T cv::cudev::saturate_cast(signed long long v)

#include <opencv2/cudev/util/saturate_cast.hpp>

saturate_cast()#

template<typename T>
T cv::cudev::saturate_cast(signed long v)

#include <opencv2/cudev/util/saturate_cast.hpp>

saturate_cast()#

template<typename T>
T cv::cudev::saturate_cast(uchar v)

#include <opencv2/cudev/util/saturate_cast.hpp>

saturate_cast()#

template<typename T>
T cv::cudev::saturate_cast(uint v)

#include <opencv2/cudev/util/saturate_cast.hpp>

saturate_cast()#

template<typename T>
T cv::cudev::saturate_cast(unsigned long long v)

#include <opencv2/cudev/util/saturate_cast.hpp>

saturate_cast()#

template<typename T>
T cv::cudev::saturate_cast(unsigned long v)

#include <opencv2/cudev/util/saturate_cast.hpp>

saturate_cast()#

template<typename T>
T cv::cudev::saturate_cast(ushort v)

#include <opencv2/cudev/util/saturate_cast.hpp>

shrinkPtr()#

template<class Ptr2DSz>
PtrTraits< Ptr2DSz >::ptr_type cv::cudev::shrinkPtr(const Ptr2DSz & ptr)

#include <opencv2/cudev/ptr2d/traits.hpp>

Here is the call graph for this function:

smem_tuple()#

template<typename T0>
tuple< volatile T0 * > cv::cudev::smem_tuple(T0 * t0)

#include <opencv2/cudev/warp/reduce.hpp>

smem_tuple()#

template<typename T0, typename T1>
tuple< volatile T0 *, volatile T1 * > cv::cudev::smem_tuple(
T0 * t0,
T1 * t1 )

#include <opencv2/cudev/warp/reduce.hpp>

smem_tuple()#

template<typename T0, typename T1, typename T2>
tuple< volatile T0 *, volatile T1 *, volatile T2 * > cv::cudev::smem_tuple(
T0 * t0,
T1 * t1,
T2 * t2 )

#include <opencv2/cudev/warp/reduce.hpp>

smem_tuple()#

template<typename T0, typename T1, typename T2, typename T3>
tuple< volatile T0 *, volatile T1 *, volatile T2 *, volatile T3 * > cv::cudev::smem_tuple(
T0 * t0,
T1 * t1,
T2 * t2,
T3 * t3 )

#include <opencv2/cudev/warp/reduce.hpp>

smem_tuple()#

template<typename T0, typename T1, typename T2, typename T3, typename T4>
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 )

#include <opencv2/cudev/warp/reduce.hpp>

smem_tuple()#

template<typename T0, typename T1, typename T2, typename T3, typename T4, typename T5>
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 )

#include <opencv2/cudev/warp/reduce.hpp>

smem_tuple()#

template<typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
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 )

#include <opencv2/cudev/warp/reduce.hpp>

smem_tuple()#

template<typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
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 )

#include <opencv2/cudev/warp/reduce.hpp>

smem_tuple()#

template<typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
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 )

#include <opencv2/cudev/warp/reduce.hpp>

smem_tuple()#

template<typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
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 )

#include <opencv2/cudev/warp/reduce.hpp>

sum_()#

template<class SrcPtr>
Expr< SumExprBody< SrcPtr > > cv::cudev::sum_(const SrcPtr & src)

#include <opencv2/cudev/expr/reduction.hpp>

Here is the call graph for this function:

thresh_binary_func()#

template<typename T>
ThreshBinaryFunc< T > cv::cudev::thresh_binary_func(
T thresh,
T maxVal )

#include <opencv2/cudev/functional/functional.hpp>

thresh_binary_inv_func()#

template<typename T>
ThreshBinaryInvFunc< T > cv::cudev::thresh_binary_inv_func(
T thresh,
T maxVal )

#include <opencv2/cudev/functional/functional.hpp>

thresh_to_zero_func()#

template<typename T>
ThreshToZeroFunc< T > cv::cudev::thresh_to_zero_func(T thresh)

#include <opencv2/cudev/functional/functional.hpp>

thresh_to_zero_inv_func()#

template<typename T>
ThreshToZeroInvFunc< T > cv::cudev::thresh_to_zero_inv_func(T thresh)

#include <opencv2/cudev/functional/functional.hpp>

thresh_trunc_func()#

template<typename T>
ThreshTruncFunc< T > cv::cudev::thresh_trunc_func(T thresh)

#include <opencv2/cudev/functional/functional.hpp>

transpose_()#

template<class SrcPtr>
Expr< TransposeBody< SrcPtr > > cv::cudev::transpose_(const SrcPtr & src)

#include <opencv2/cudev/expr/warping.hpp>

Here is the call graph for this function:

unaryTupleAdapter()#

template<int n, class Op>
UnaryTupleAdapter< Op, n > cv::cudev::unaryTupleAdapter(const Op & op)

#include <opencv2/cudev/functional/tuple_adapter.hpp>

vabsdiff2()#

uint cv::cudev::vabsdiff2(
uint a,
uint b )

#include <opencv2/cudev/util/simd_functions.hpp>

Here is the call graph for this function:

vabsdiff4()#

uint cv::cudev::vabsdiff4(
uint a,
uint b )

#include <opencv2/cudev/util/simd_functions.hpp>

Here is the call graph for this function:

vadd2()#

uint cv::cudev::vadd2(
uint a,
uint b )

#include <opencv2/cudev/util/simd_functions.hpp>

vadd4()#

uint cv::cudev::vadd4(
uint a,
uint b )

#include <opencv2/cudev/util/simd_functions.hpp>

vavg2()#

uint cv::cudev::vavg2(
uint a,
uint b )

#include <opencv2/cudev/util/simd_functions.hpp>

vavg4()#

uint cv::cudev::vavg4(
uint a,
uint b )

#include <opencv2/cudev/util/simd_functions.hpp>

vavrg2()#

uint cv::cudev::vavrg2(
uint a,
uint b )

#include <opencv2/cudev/util/simd_functions.hpp>

vavrg4()#

uint cv::cudev::vavrg4(
uint a,
uint b )

#include <opencv2/cudev/util/simd_functions.hpp>

vcmpeq2()#

uint cv::cudev::vcmpeq2(
uint a,
uint b )

#include <opencv2/cudev/util/simd_functions.hpp>

Here is the call graph for this function:

vcmpeq4()#

uint cv::cudev::vcmpeq4(
uint a,
uint b )

#include <opencv2/cudev/util/simd_functions.hpp>

Here is the call graph for this function:

vcmpge2()#

uint cv::cudev::vcmpge2(
uint a,
uint b )

#include <opencv2/cudev/util/simd_functions.hpp>

Here is the call graph for this function:

vcmpge4()#

uint cv::cudev::vcmpge4(
uint a,
uint b )

#include <opencv2/cudev/util/simd_functions.hpp>

Here is the call graph for this function:

vcmpgt2()#

uint cv::cudev::vcmpgt2(
uint a,
uint b )

#include <opencv2/cudev/util/simd_functions.hpp>

Here is the call graph for this function:

vcmpgt4()#

uint cv::cudev::vcmpgt4(
uint a,
uint b )

#include <opencv2/cudev/util/simd_functions.hpp>

Here is the call graph for this function:

vcmple2()#

uint cv::cudev::vcmple2(
uint a,
uint b )

#include <opencv2/cudev/util/simd_functions.hpp>

Here is the call graph for this function:

vcmple4()#

uint cv::cudev::vcmple4(
uint a,
uint b )

#include <opencv2/cudev/util/simd_functions.hpp>

Here is the call graph for this function:

vcmplt2()#

uint cv::cudev::vcmplt2(
uint a,
uint b )

#include <opencv2/cudev/util/simd_functions.hpp>

Here is the call graph for this function:

vcmplt4()#

uint cv::cudev::vcmplt4(
uint a,
uint b )

#include <opencv2/cudev/util/simd_functions.hpp>

Here is the call graph for this function:

vcmpne2()#

uint cv::cudev::vcmpne2(
uint a,
uint b )

#include <opencv2/cudev/util/simd_functions.hpp>

Here is the call graph for this function:

vcmpne4()#

uint cv::cudev::vcmpne4(
uint a,
uint b )

#include <opencv2/cudev/util/simd_functions.hpp>

Here is the call graph for this function:

vmax2()#

uint cv::cudev::vmax2(
uint a,
uint b )

#include <opencv2/cudev/util/simd_functions.hpp>

Here is the call graph for this function:

vmax4()#

uint cv::cudev::vmax4(
uint a,
uint b )

#include <opencv2/cudev/util/simd_functions.hpp>

Here is the call graph for this function:

vmin2()#

uint cv::cudev::vmin2(
uint a,
uint b )

#include <opencv2/cudev/util/simd_functions.hpp>

Here is the call graph for this function:

vmin4()#

uint cv::cudev::vmin4(
uint a,
uint b )

#include <opencv2/cudev/util/simd_functions.hpp>

Here is the call graph for this function:

vseteq2()#

uint cv::cudev::vseteq2(
uint a,
uint b )

#include <opencv2/cudev/util/simd_functions.hpp>

vseteq4()#

uint cv::cudev::vseteq4(
uint a,
uint b )

#include <opencv2/cudev/util/simd_functions.hpp>

vsetge2()#

uint cv::cudev::vsetge2(
uint a,
uint b )

#include <opencv2/cudev/util/simd_functions.hpp>

Here is the call graph for this function:

vsetge4()#

uint cv::cudev::vsetge4(
uint a,
uint b )

#include <opencv2/cudev/util/simd_functions.hpp>

Here is the call graph for this function:

vsetgt2()#

uint cv::cudev::vsetgt2(
uint a,
uint b )

#include <opencv2/cudev/util/simd_functions.hpp>

Here is the call graph for this function:

vsetgt4()#

uint cv::cudev::vsetgt4(
uint a,
uint b )

#include <opencv2/cudev/util/simd_functions.hpp>

Here is the call graph for this function:

vsetle2()#

uint cv::cudev::vsetle2(
uint a,
uint b )

#include <opencv2/cudev/util/simd_functions.hpp>

Here is the call graph for this function:

vsetle4()#

uint cv::cudev::vsetle4(
uint a,
uint b )

#include <opencv2/cudev/util/simd_functions.hpp>

Here is the call graph for this function:

vsetlt2()#

uint cv::cudev::vsetlt2(
uint a,
uint b )

#include <opencv2/cudev/util/simd_functions.hpp>

Here is the call graph for this function:

vsetlt4()#

uint cv::cudev::vsetlt4(
uint a,
uint b )

#include <opencv2/cudev/util/simd_functions.hpp>

Here is the call graph for this function:

vsetne2()#

uint cv::cudev::vsetne2(
uint a,
uint b )

#include <opencv2/cudev/util/simd_functions.hpp>

vsetne4()#

uint cv::cudev::vsetne4(
uint a,
uint b )

#include <opencv2/cudev/util/simd_functions.hpp>

vsub2()#

uint cv::cudev::vsub2(
uint a,
uint b )

#include <opencv2/cudev/util/simd_functions.hpp>

vsub4()#

uint cv::cudev::vsub4(
uint a,
uint b )

#include <opencv2/cudev/util/simd_functions.hpp>

warpCopy()#

template<class InIt, class OutIt>
OutIt cv::cudev::warpCopy(
InIt beg,
InIt end,
OutIt out )

#include <opencv2/cudev/warp/warp.hpp>

Here is the call graph for this function:

warpFill()#

template<class It, typename T>
void cv::cudev::warpFill(
It beg,
It end,
const T & value )

#include <opencv2/cudev/warp/warp.hpp>

Here is the call graph for this function:

warpReduce()#

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>
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 )

#include <opencv2/cudev/warp/reduce.hpp>

Here is the call graph for this function:

warpReduce()#

template<typename T, class Op>
void cv::cudev::warpReduce(
volatile T * smem,
T & val,
uint tid,
const Op & op )

#include <opencv2/cudev/warp/reduce.hpp>

Here is the call graph for this function:

warpReduceKeyVal()#

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>
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 )

#include <opencv2/cudev/warp/reduce.hpp>

Here is the call graph for this function:

warpReduceKeyVal()#

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>
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 )

#include <opencv2/cudev/warp/reduce.hpp>

Here is the call graph for this function:

warpReduceKeyVal()#

template<typename K, typename V, class Cmp>
void cv::cudev::warpReduceKeyVal(
volatile K * skeys,
K & key,
volatile V * svals,
V & val,
uint tid,
const Cmp & cmp )

#include <opencv2/cudev/warp/reduce.hpp>

Here is the call graph for this function:

warpScanExclusive()#

template<typename T>
T cv::cudev::warpScanExclusive(
T data,
volatile T * smem,
uint tid )

#include <opencv2/cudev/warp/scan.hpp>

Here is the call graph for this function:

warpScanInclusive()#

template<typename T>
T cv::cudev::warpScanInclusive(
T data,
volatile T * smem,
uint tid )

#include <opencv2/cudev/warp/scan.hpp>

Here is the call graph for this function:

warpTransform()#

template<class InIt, class OutIt, class UnOp>
OutIt cv::cudev::warpTransform(
InIt beg,
InIt end,
OutIt out,
const UnOp & op )

#include <opencv2/cudev/warp/warp.hpp>

Here is the call graph for this function:

warpTransform()#

template<class InIt1, class InIt2, class OutIt, class BinOp>
OutIt cv::cudev::warpTransform(
InIt1 beg1,
InIt1 end1,
InIt2 beg2,
OutIt out,
const BinOp & op )

#include <opencv2/cudev/warp/warp.hpp>

Here is the call graph for this function:

warpYota()#

template<typename OutIt, typename T>
void cv::cudev::warpYota(
OutIt beg,
OutIt end,
T value )

#include <opencv2/cudev/warp/warp.hpp>

Here is the call graph for this function:

Variable Documentation#

false#

cv::cudev::false

#include <opencv2/cudev/functional/color_cvt.hpp>

true#

cv::cudev::true

#include <opencv2/cudev/functional/color_cvt.hpp>

Macro Definition Documentation#

CV_CUDEV_ARCH#

#define CV_CUDEV_ARCH

#include <opencv2/cudev/common.hpp>

Value:

CV_CUDEV_BINARY_FUNCTION_INST#

#define CV_CUDEV_BINARY_FUNCTION_INST(name, func)

#include <opencv2/cudev/functional/functional.hpp>

CV_CUDEV_EXPR_BINARY_FUNC#

#define CV_CUDEV_EXPR_BINARY_FUNC(name)

#include <opencv2/cudev/expr/binary_func.hpp>

Value:

template <class SrcPtr1, class SrcPtr2> \
    __host__ Expr<BinaryTransformPtrSz<typename PtrTraits<SrcPtr1>::ptr_type, typename PtrTraits<SrcPtr2>::ptr_type, name ## _func<typename LargerType<typename PtrTraits<SrcPtr1>::value_type, typename PtrTraits<SrcPtr2>::value_type>::type> > > \
    name ## _(const SrcPtr1& src1, const SrcPtr2& src2) \
    { \
        return makeExpr(transformPtr(src1, src2, name ## _func<typename LargerType<typename PtrTraits<SrcPtr1>::value_type, typename PtrTraits<SrcPtr2>::value_type>::type>())); \
    }

CV_CUDEV_EXPR_BINOP_INST#

#define CV_CUDEV_EXPR_BINOP_INST(op, functor)

#include <opencv2/cudev/expr/binary_op.hpp>

CV_CUDEV_EXPR_CVTCOLOR_INST#

#define CV_CUDEV_EXPR_CVTCOLOR_INST(name)

#include <opencv2/cudev/expr/color.hpp>

Value:

template <class SrcPtr> \
    __host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, name ## _func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type> > > \
    name ## _(const SrcPtr& src) \
    { \
        return makeExpr(transformPtr(src, name ## _func<typename VecTraits<typename PtrTraits<SrcPtr>::value_type>::elem_type>())); \
    }

CV_CUDEV_EXPR_UNARY_FUNC#

#define CV_CUDEV_EXPR_UNARY_FUNC(name)

#include <opencv2/cudev/expr/unary_func.hpp>

Value:

template <class SrcPtr> \
    __host__ Expr<UnaryTransformPtrSz<typename PtrTraits<SrcPtr>::ptr_type, name ## _func<typename PtrTraits<SrcPtr>::value_type> > > \
    name ## _(const SrcPtr& src) \
    { \
        return makeExpr(transformPtr(src, name ## _func<typename PtrTraits<SrcPtr>::value_type>())); \
    }

CV_CUDEV_EXPR_UNOP_INST#

#define CV_CUDEV_EXPR_UNOP_INST(op, functor)

#include <opencv2/cudev/expr/unary_op.hpp>

Value:

template <typename T> \
    __host__ Expr<UnaryTransformPtrSz<typename PtrTraits<GpuMat_<T> >::ptr_type, functor<T> > > \
    operator op(const GpuMat_<T>& src) \
    { \
        return makeExpr(transformPtr(src, functor<T>())); \
    } \
    template <typename T> \
    __host__ Expr<UnaryTransformPtrSz<typename PtrTraits<GlobPtrSz<T> >::ptr_type, functor<T> > > \
    operator op(const GlobPtrSz<T>& src) \
    { \
        return makeExpr(transformPtr(src, functor<T>())); \
    } \
    template <typename T> \
    __host__ Expr<UnaryTransformPtrSz<typename PtrTraits<Texture<T> >::ptr_type, functor<T> > > \
    operator op(const Texture<T>& src) \
    { \
        return makeExpr(transformPtr(src, functor<T>())); \
    } \
    template <class Body> \
    __host__ Expr<UnaryTransformPtrSz<typename PtrTraits<Body>::ptr_type, functor<typename Body::value_type> > > \
    operator op(const Expr<Body>& src) \
    { \
        return makeExpr(transformPtr(src.body, functor<typename Body::value_type>())); \
    }

CV_CUDEV_GRAY2RGB5x5_INST#

#define CV_CUDEV_GRAY2RGB5x5_INST(name, green_bits)

#include <opencv2/cudev/functional/color_cvt.hpp>

Value:

typedef cv::cudev::color_cvt_detail::Gray2RGB5x5<green_bits> name ## _func;

CV_CUDEV_GRAY2RGB_INST#

#define CV_CUDEV_GRAY2RGB_INST(name, dcn)

#include <opencv2/cudev/functional/color_cvt.hpp>

Value:

template <typename SrcDepth> struct name ## _func : cv::cudev::color_cvt_detail::Gray2RGB<SrcDepth, dcn> \
    { \
    };

CV_CUDEV_HLS2RGB_INST#

#define CV_CUDEV_HLS2RGB_INST(name, scn, dcn, bidx)

#include <opencv2/cudev/functional/color_cvt.hpp>

Value:

template <typename SrcDepth> struct name ## _func : cv::cudev::color_cvt_detail::HLS2RGB<SrcDepth, scn, dcn, bidx, 180> \
    { \
    }; \
    template <typename SrcDepth> struct name ## _FULL ## _func : cv::cudev::color_cvt_detail::HLS2RGB<SrcDepth, scn, dcn, bidx, 255> \
    { \
    }; \
    template <> struct name ## _func<float> : cv::cudev::color_cvt_detail::HLS2RGB<float, scn, dcn, bidx, 360> \
    { \
    }; \
    template <> struct name ## _FULL ## _func<float> : cv::cudev::color_cvt_detail::HLS2RGB<float, scn, dcn, bidx, 360> \
    { \
    };

CV_CUDEV_HSV2RGB_INST#

#define CV_CUDEV_HSV2RGB_INST(name, scn, dcn, bidx)

#include <opencv2/cudev/functional/color_cvt.hpp>

Value:

template <typename SrcDepth> struct name ## _func : cv::cudev::color_cvt_detail::HSV2RGB<SrcDepth, scn, dcn, bidx, 180> \
    { \
    }; \
    template <typename SrcDepth> struct name ## _FULL ## _func : cv::cudev::color_cvt_detail::HSV2RGB<SrcDepth, scn, dcn, bidx, 255> \
    { \
    }; \
    template <> struct name ## _func<float> : cv::cudev::color_cvt_detail::HSV2RGB<float, scn, dcn, bidx, 360> \
    { \
    }; \
    template <> struct name ## _FULL ## _func<float> : cv::cudev::color_cvt_detail::HSV2RGB<float, scn, dcn, bidx, 360> \
    { \
    };

CV_CUDEV_IMPLEMENT_SCALAR_BINARY_FUNC#

#define CV_CUDEV_IMPLEMENT_SCALAR_BINARY_FUNC(func_name, func, input_type, scalar_type, output_type)

#include <opencv2/cudev/util/vec_math.hpp>

CV_CUDEV_IMPLEMENT_SCALAR_BINARY_OP#

#define CV_CUDEV_IMPLEMENT_SCALAR_BINARY_OP(op, input_type, scalar_type, output_type)

#include <opencv2/cudev/util/vec_math.hpp>

CV_CUDEV_IMPLEMENT_VEC_BINARY_FUNC#

#define CV_CUDEV_IMPLEMENT_VEC_BINARY_FUNC(func_name, func, input_type, output_type)

#include <opencv2/cudev/util/vec_math.hpp>

Value:

__device__ __forceinline__ output_type ## 1 func_name(const input_type ## 1 & a, const input_type ## 1 & b) \
    { \
        return VecTraits<output_type ## 1>::make(func (a.x, b.x)); \
    } \
    __device__ __forceinline__ output_type ## 2 func_name(const input_type ## 2 & a, const input_type ## 2 & b) \
    { \
        return VecTraits<output_type ## 2>::make(func (a.x, b.x), func (a.y, b.y)); \
    } \
    __device__ __forceinline__ output_type ## 3 func_name(const input_type ## 3 & a, const input_type ## 3 & b) \
    { \
        return VecTraits<output_type ## 3>::make(func (a.x, b.x), func (a.y, b.y), func (a.z, b.z)); \
    } \
    __device__ __forceinline__ output_type ## 4 func_name(const input_type ## 4 & a, const input_type ## 4 & b) \
    { \
        return VecTraits<output_type ## 4>::make(func (a.x, b.x), func (a.y, b.y), func (a.z, b.z), func (a.w, b.w)); \
    }

CV_CUDEV_IMPLEMENT_VEC_BINARY_OP#

#define CV_CUDEV_IMPLEMENT_VEC_BINARY_OP(op, input_type, output_type)

#include <opencv2/cudev/util/vec_math.hpp>

Value:

__device__ __forceinline__ output_type ## 1 operator op(const input_type ## 1 & a, const input_type ## 1 & b) \
    { \
        return VecTraits<output_type ## 1>::make(a.x op b.x); \
    } \
    __device__ __forceinline__ output_type ## 2 operator op(const input_type ## 2 & a, const input_type ## 2 & b) \
    { \
        return VecTraits<output_type ## 2>::make(a.x op b.x, a.y op b.y); \
    } \
    __device__ __forceinline__ output_type ## 3 operator op(const input_type ## 3 & a, const input_type ## 3 & b) \
    { \
        return VecTraits<output_type ## 3>::make(a.x op b.x, a.y op b.y, a.z op b.z); \
    } \
    __device__ __forceinline__ output_type ## 4 operator op(const input_type ## 4 & a, const input_type ## 4 & b) \
    { \
        return VecTraits<output_type ## 4>::make(a.x op b.x, a.y op b.y, a.z op b.z, a.w op b.w); \
    }

CV_CUDEV_IMPLEMENT_VEC_UNARY_FUNC#

#define CV_CUDEV_IMPLEMENT_VEC_UNARY_FUNC(func_name, func, input_type, output_type)

#include <opencv2/cudev/util/vec_math.hpp>

Value:

__device__ __forceinline__ output_type ## 1 func_name(const input_type ## 1 & a) \
    { \
        return VecTraits<output_type ## 1>::make(func (a.x)); \
    } \
    __device__ __forceinline__ output_type ## 2 func_name(const input_type ## 2 & a) \
    { \
        return VecTraits<output_type ## 2>::make(func (a.x), func (a.y)); \
    } \
    __device__ __forceinline__ output_type ## 3 func_name(const input_type ## 3 & a) \
    { \
        return VecTraits<output_type ## 3>::make(func (a.x), func (a.y), func (a.z)); \
    } \
    __device__ __forceinline__ output_type ## 4 func_name(const input_type ## 4 & a) \
    { \
        return VecTraits<output_type ## 4>::make(func (a.x), func (a.y), func (a.z), func (a.w)); \
    }

CV_CUDEV_IMPLEMENT_VEC_UNARY_OP#

#define CV_CUDEV_IMPLEMENT_VEC_UNARY_OP(op, input_type, output_type)

#include <opencv2/cudev/util/vec_math.hpp>

Value:

__device__ __forceinline__ output_type ## 1 operator op(const input_type ## 1 & a) \
    { \
        return VecTraits<output_type ## 1>::make(op (a.x)); \
    } \
    __device__ __forceinline__ output_type ## 2 operator op(const input_type ## 2 & a) \
    { \
        return VecTraits<output_type ## 2>::make(op (a.x), op (a.y)); \
    } \
    __device__ __forceinline__ output_type ## 3 operator op(const input_type ## 3 & a) \
    { \
        return VecTraits<output_type ## 3>::make(op (a.x), op (a.y), op (a.z)); \
    } \
    __device__ __forceinline__ output_type ## 4 operator op(const input_type ## 4 & a) \
    { \
        return VecTraits<output_type ## 4>::make(op (a.x), op (a.y), op (a.z), op (a.w)); \
    }

CV_CUDEV_Lab2RGB_INST#

#define CV_CUDEV_Lab2RGB_INST(name, scn, dcn, sRGB, blueIdx)

#include <opencv2/cudev/functional/color_cvt.hpp>

Value:

template <typename SrcDepth

Device layer#

Detailed Description#

Namespaces#

Classes#

Enumerations#

Functions#

Variables#

Typedef Documentation#

elem_type#

elem_type#

index_type#

index_type#

index_type#

value_type#

Enumeration Type Documentation#

enum#

Function Documentation#

affineMap()#

atomicAdd()#

atomicAdd()#

atomicAdd()#

atomicAdd()#

atomicMax()#

atomicMax()#

atomicMax()#

atomicMax()#

atomicMin()#

atomicMin()#

atomicMin()#

atomicMin()#

binaryTupleAdapter()#

bind1st()#

bind2nd()#

blockCopy()#

blockFill()#

blockReduce()#

blockReduce()#

blockReduceKeyVal()#

blockReduceKeyVal()#

blockReduceKeyVal()#

blockScanExclusive()#

blockScanInclusive()#

blockTransform()#

blockTransform()#

blockYota()#

brdConstant()#

brdConstant()#

brdReflect()#

brdReflect101()#

brdReplicate()#

brdWrap()#

cast_fp16()#

checkCudaError()#

constantPtr()#

constantPtr()#

countNonZero_()#

CV_CUDEV_GRAY2RGB5x5_INST()#

CV_CUDEV_Lab2RGB_INST()#

CV_CUDEV_Lab2RGB_INST()#

CV_CUDEV_Lab2RGB_INST()#

CV_CUDEV_Lab2RGB_INST()#

CV_CUDEV_Lab2RGB_INST()#

CV_CUDEV_Lab2RGB_INST()#

CV_CUDEV_Lab2RGB_INST()#

CV_CUDEV_Lab2RGB_INST()#

CV_CUDEV_Luv2RGB_INST()#

CV_CUDEV_Luv2RGB_INST()#

CV_CUDEV_Luv2RGB_INST()#

CV_CUDEV_Luv2RGB_INST()#

CV_CUDEV_Luv2RGB_INST()#

CV_CUDEV_Luv2RGB_INST()#

CV_CUDEV_Luv2RGB_INST()#

CV_CUDEV_Luv2RGB_INST()#

CV_CUDEV_RGB2Lab_INST()#

CV_CUDEV_RGB2Lab_INST()#

CV_CUDEV_RGB2Lab_INST()#

CV_CUDEV_RGB2Lab_INST()#

CV_CUDEV_RGB2Lab_INST()#

CV_CUDEV_RGB2Lab_INST()#

CV_CUDEV_RGB2Lab_INST()#