mirror/opencv
1
0
Fork 0
mirror of https://github.com/opencv/opencv.git synced 2025-07-22 20:39:41 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity
f61db41d25
opencv/modules/cudev/include/opencv2/cudev/util/vec_traits.hpp
Maksim Shabunin ceb6e8bd94 Doxygen documentation: cuda
2014-12-01 15:47:13 +03:00

326 lines
12 KiB
C++
Raw Blame History

/*M///////////////////////////////////////////////////////////////////////////////////////
//
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
// By downloading, copying, installing or using the software you agree to this license.
// If you do not agree to this license, do not download, install,
// copy or use the software.
//
//
// License Agreement
// For Open Source Computer Vision Library
//
// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
// * Redistribution's of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
//
// * Redistribution's in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// * The name of the copyright holders may not be used to endorse or promote products
// derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// In no event shall the Intel Corporation or contributors be liable for any direct,
// indirect, incidental, special, exemplary, or consequential damages
// (including, but not limited to, procurement of substitute goods or services;
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//
//M*/
#pragma once
#ifndef __OPENCV_CUDEV_UTIL_VEC_TRAITS_HPP__
#define __OPENCV_CUDEV_UTIL_VEC_TRAITS_HPP__
#include "../common.hpp"
namespace cv { namespace cudev {
//! @addtogroup cudev
//! @{
// MakeVec
template<typename T, int CN> struct MakeVec;
#define CV_CUDEV_MAKE_VEC_INST(elem_type) \
template<> struct MakeVec<elem_type, 1> { typedef elem_type type; }; \
template<> struct MakeVec<elem_type, 2> { typedef elem_type ## 2 type; }; \
template<> struct MakeVec<elem_type, 3> { typedef elem_type ## 3 type; }; \
template<> struct MakeVec<elem_type, 4> { typedef elem_type ## 4 type; };
CV_CUDEV_MAKE_VEC_INST(uchar)
CV_CUDEV_MAKE_VEC_INST(ushort)
CV_CUDEV_MAKE_VEC_INST(short)
CV_CUDEV_MAKE_VEC_INST(int)
CV_CUDEV_MAKE_VEC_INST(uint)
CV_CUDEV_MAKE_VEC_INST(float)
CV_CUDEV_MAKE_VEC_INST(double)
#undef CV_CUDEV_MAKE_VEC_INST
template<> struct MakeVec<schar, 1> { typedef schar type; };
template<> struct MakeVec<schar, 2> { typedef char2 type; };
template<> struct MakeVec<schar, 3> { typedef char3 type; };
template<> struct MakeVec<schar, 4> { typedef char4 type; };
template<> struct MakeVec<bool, 1> { typedef uchar type; };
template<> struct MakeVec<bool, 2> { typedef uchar2 type; };
template<> struct MakeVec<bool, 3> { typedef uchar3 type; };
template<> struct MakeVec<bool, 4> { typedef uchar4 type; };
// VecTraits
template<typename T> struct VecTraits;
#define CV_CUDEV_VEC_TRAITS_INST(type) \
template <> struct VecTraits<type> \
{ \
typedef type elem_type; \
enum {cn=1}; \
__host__ __device__ __forceinline__ static type all(type v) {return v;} \
__host__ __device__ __forceinline__ static type make(type x) {return x;} \
__host__ __device__ __forceinline__ static type make(const type* v) {return *v;} \
}; \
template <> struct VecTraits<type ## 1> \
{ \
typedef type elem_type; \
enum {cn=1}; \
__host__ __device__ __forceinline__ static type ## 1 all(type v) {return make_ ## type ## 1(v);} \
__host__ __device__ __forceinline__ static type ## 1 make(type x) {return make_ ## type ## 1(x);} \
__host__ __device__ __forceinline__ static type ## 1 make(const type* v) {return make_ ## type ## 1(*v);} \
}; \
template <> struct VecTraits<type ## 2> \
{ \
typedef type elem_type; \
enum {cn=2}; \
__host__ __device__ __forceinline__ static type ## 2 all(type v) {return make_ ## type ## 2(v, v);} \
__host__ __device__ __forceinline__ static type ## 2 make(type x, type y) {return make_ ## type ## 2(x, y);} \
__host__ __device__ __forceinline__ static type ## 2 make(const type* v) {return make_ ## type ## 2(v[0], v[1]);} \
}; \
template <> struct VecTraits<type ## 3> \
{ \
typedef type elem_type; \
enum {cn=3}; \
__host__ __device__ __forceinline__ static type ## 3 all(type v) {return make_ ## type ## 3(v, v, v);} \
__host__ __device__ __forceinline__ static type ## 3 make(type x, type y, type z) {return make_ ## type ## 3(x, y, z);} \
__host__ __device__ __forceinline__ static type ## 3 make(const type* v) {return make_ ## type ## 3(v[0], v[1], v[2]);} \
}; \
template <> struct VecTraits<type ## 4> \
{ \
typedef type elem_type; \
enum {cn=4}; \
__host__ __device__ __forceinline__ static type ## 4 all(type v) {return make_ ## type ## 4(v, v, v, v);} \
__host__ __device__ __forceinline__ static type ## 4 make(type x, type y, type z, type w) {return make_ ## type ## 4(x, y, z, w);} \
__host__ __device__ __forceinline__ static type ## 4 make(const type* v) {return make_ ## type ## 4(v[0], v[1], v[2], v[3]);} \
};
CV_CUDEV_VEC_TRAITS_INST(uchar)
CV_CUDEV_VEC_TRAITS_INST(ushort)
CV_CUDEV_VEC_TRAITS_INST(short)
CV_CUDEV_VEC_TRAITS_INST(int)
CV_CUDEV_VEC_TRAITS_INST(uint)
CV_CUDEV_VEC_TRAITS_INST(float)
CV_CUDEV_VEC_TRAITS_INST(double)
#undef CV_CUDEV_VEC_TRAITS_INST
template<> struct VecTraits<schar>
{
typedef schar elem_type;
enum {cn=1};
__host__ __device__ __forceinline__ static schar all(schar v) {return v;}
__host__ __device__ __forceinline__ static schar make(schar x) {return x;}
__host__ __device__ __forceinline__ static schar make(const schar* x) {return *x;}
};
template<> struct VecTraits<char1>
{
typedef schar elem_type;
enum {cn=1};
__host__ __device__ __forceinline__ static char1 all(schar v) {return make_char1(v);}
__host__ __device__ __forceinline__ static char1 make(schar x) {return make_char1(x);}
__host__ __device__ __forceinline__ static char1 make(const schar* v) {return make_char1(v[0]);}
};
template<> struct VecTraits<char2>
{
typedef schar elem_type;
enum {cn=2};
__host__ __device__ __forceinline__ static char2 all(schar v) {return make_char2(v, v);}
__host__ __device__ __forceinline__ static char2 make(schar x, schar y) {return make_char2(x, y);}
__host__ __device__ __forceinline__ static char2 make(const schar* v) {return make_char2(v[0], v[1]);}
};
template<> struct VecTraits<char3>
{
typedef schar elem_type;
enum {cn=3};
__host__ __device__ __forceinline__ static char3 all(schar v) {return make_char3(v, v, v);}
__host__ __device__ __forceinline__ static char3 make(schar x, schar y, schar z) {return make_char3(x, y, z);}
__host__ __device__ __forceinline__ static char3 make(const schar* v) {return make_char3(v[0], v[1], v[2]);}
};
template<> struct VecTraits<char4>
{
typedef schar elem_type;
enum {cn=4};
__host__ __device__ __forceinline__ static char4 all(schar v) {return make_char4(v, v, v, v);}
__host__ __device__ __forceinline__ static char4 make(schar x, schar y, schar z, schar w) {return make_char4(x, y, z, w);}
__host__ __device__ __forceinline__ static char4 make(const schar* v) {return make_char4(v[0], v[1], v[2], v[3]);}
};
//! @}
}}
// DataType
namespace cv {
template <> class DataType<uint>
{
public:
typedef uint value_type;
typedef value_type work_type;
typedef value_type channel_type;
typedef value_type vec_type;
enum { generic_type = 0,
depth = CV_32S,
channels = 1,
fmt = (int)'i',
type = CV_MAKE_TYPE(depth, channels)
};
};
#define CV_CUDEV_DATA_TYPE_INST(_depth_type, _channel_num) \
template <> class DataType< _depth_type ## _channel_num > \
{ \
public: \
typedef _depth_type ## _channel_num value_type; \
typedef value_type work_type; \
typedef _depth_type channel_type; \
typedef value_type vec_type; \
enum { generic_type = 0, \
depth = DataType<channel_type>::depth, \
channels = _channel_num, \
fmt = DataType<channel_type>::fmt + ((channels - 1) << 8), \
type = CV_MAKE_TYPE(depth, channels) \
}; \
};
CV_CUDEV_DATA_TYPE_INST(uchar, 1)
CV_CUDEV_DATA_TYPE_INST(uchar, 2)
CV_CUDEV_DATA_TYPE_INST(uchar, 3)
CV_CUDEV_DATA_TYPE_INST(uchar, 4)
CV_CUDEV_DATA_TYPE_INST(ushort, 1)
CV_CUDEV_DATA_TYPE_INST(ushort, 2)
CV_CUDEV_DATA_TYPE_INST(ushort, 3)
CV_CUDEV_DATA_TYPE_INST(ushort, 4)
CV_CUDEV_DATA_TYPE_INST(short, 1)
CV_CUDEV_DATA_TYPE_INST(short, 2)
CV_CUDEV_DATA_TYPE_INST(short, 3)
CV_CUDEV_DATA_TYPE_INST(short, 4)
CV_CUDEV_DATA_TYPE_INST(int, 1)
CV_CUDEV_DATA_TYPE_INST(int, 2)
CV_CUDEV_DATA_TYPE_INST(int, 3)
CV_CUDEV_DATA_TYPE_INST(int, 4)
CV_CUDEV_DATA_TYPE_INST(uint, 1)
CV_CUDEV_DATA_TYPE_INST(uint, 2)
CV_CUDEV_DATA_TYPE_INST(uint, 3)
CV_CUDEV_DATA_TYPE_INST(uint, 4)
CV_CUDEV_DATA_TYPE_INST(float, 1)
CV_CUDEV_DATA_TYPE_INST(float, 2)
CV_CUDEV_DATA_TYPE_INST(float, 3)
CV_CUDEV_DATA_TYPE_INST(float, 4)
CV_CUDEV_DATA_TYPE_INST(double, 1)
CV_CUDEV_DATA_TYPE_INST(double, 2)
CV_CUDEV_DATA_TYPE_INST(double, 3)
CV_CUDEV_DATA_TYPE_INST(double, 4)
#undef CV_CUDEV_DATA_TYPE_INST
template<> class DataType<char1>
{
public:
typedef char1 value_type;
typedef value_type work_type;
typedef schar channel_type;
typedef value_type vec_type;
enum { generic_type = 0,
depth = DataType<channel_type>::depth,
channels = 1,
fmt = DataType<channel_type>::fmt + ((channels - 1) << 8),
type = CV_MAKE_TYPE(depth, channels)
};
};
template<> class DataType<char2>
{
public:
typedef char2 value_type;
typedef value_type work_type;
typedef schar channel_type;
typedef value_type vec_type;
enum { generic_type = 0,
depth = DataType<channel_type>::depth,
channels = 2,
fmt = DataType<channel_type>::fmt + ((channels - 1) << 8),
type = CV_MAKE_TYPE(depth, channels)
};
};
template<> class DataType<char3>
{
public:
typedef char3 value_type;
typedef value_type work_type;
typedef schar channel_type;
typedef value_type vec_type;
enum { generic_type = 0,
depth = DataType<channel_type>::depth,
channels = 3,
fmt = DataType<channel_type>::fmt + ((channels - 1) << 8),
type = CV_MAKE_TYPE(depth, channels)
};
};
template<> class DataType<char4>
{
public:
typedef char4 value_type;
typedef value_type work_type;
typedef schar channel_type;
typedef value_type vec_type;
enum { generic_type = 0,
depth = DataType<channel_type>::depth,
channels = 4,
fmt = DataType<channel_type>::fmt + ((channels - 1) << 8),
type = CV_MAKE_TYPE(depth, channels)
};
};
}
#endif
Reference in New Issue View Git Blame Copy Permalink