1/*M/////////////////////////////////////////////////////////////////////////////////////// 2// 3// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. 4// 5// By downloading, copying, installing or using the software you agree to this license. 6// If you do not agree to this license, do not download, install, 7// copy or use the software. 8// 9// 10// License Agreement 11// For Open Source Computer Vision Library 12// 13// Copyright (C) 2000-2008, Intel Corporation, all rights reserved. 14// Copyright (C) 2009, Willow Garage Inc., all rights reserved. 15// Copyright (C) 2013, OpenCV Foundation, all rights reserved. 16// Third party copyrights are property of their respective owners. 17// 18// Redistribution and use in source and binary forms, with or without modification, 19// are permitted provided that the following conditions are met: 20// 21// * Redistribution's of source code must retain the above copyright notice, 22// this list of conditions and the following disclaimer. 23// 24// * Redistribution's in binary form must reproduce the above copyright notice, 25// this list of conditions and the following disclaimer in the documentation 26// and/or other materials provided with the distribution. 27// 28// * The name of the copyright holders may not be used to endorse or promote products 29// derived from this software without specific prior written permission. 30// 31// This software is provided by the copyright holders and contributors "as is" and 32// any express or implied warranties, including, but not limited to, the implied 33// warranties of merchantability and fitness for a particular purpose are disclaimed. 34// In no event shall the Intel Corporation or contributors be liable for any direct, 35// indirect, incidental, special, exemplary, or consequential damages 36// (including, but not limited to, procurement of substitute goods or services; 37// loss of use, data, or profits; or business interruption) however caused 38// and on any theory of liability, whether in contract, strict liability, 39// or tort (including negligence or otherwise) arising in any way out of 40// the use of this software, even if advised of the possibility of such damage. 41// 42//M*/ 43 44#pragma once 45 46#ifndef __OPENCV_CUDEV_UTIL_VEC_TRAITS_HPP__ 47#define __OPENCV_CUDEV_UTIL_VEC_TRAITS_HPP__ 48 49#include "../common.hpp" 50 51namespace cv { namespace cudev { 52 53//! @addtogroup cudev 54//! @{ 55 56// MakeVec 57 58template<typename T, int CN> struct MakeVec; 59 60#define CV_CUDEV_MAKE_VEC_INST(elem_type) \ 61 template<> struct MakeVec<elem_type, 1> { typedef elem_type type; }; \ 62 template<> struct MakeVec<elem_type, 2> { typedef elem_type ## 2 type; }; \ 63 template<> struct MakeVec<elem_type, 3> { typedef elem_type ## 3 type; }; \ 64 template<> struct MakeVec<elem_type, 4> { typedef elem_type ## 4 type; }; 65 66CV_CUDEV_MAKE_VEC_INST(uchar) 67CV_CUDEV_MAKE_VEC_INST(ushort) 68CV_CUDEV_MAKE_VEC_INST(short) 69CV_CUDEV_MAKE_VEC_INST(int) 70CV_CUDEV_MAKE_VEC_INST(uint) 71CV_CUDEV_MAKE_VEC_INST(float) 72CV_CUDEV_MAKE_VEC_INST(double) 73 74#undef CV_CUDEV_MAKE_VEC_INST 75 76template<> struct MakeVec<schar, 1> { typedef schar type; }; 77template<> struct MakeVec<schar, 2> { typedef char2 type; }; 78template<> struct MakeVec<schar, 3> { typedef char3 type; }; 79template<> struct MakeVec<schar, 4> { typedef char4 type; }; 80 81template<> struct MakeVec<bool, 1> { typedef uchar type; }; 82template<> struct MakeVec<bool, 2> { typedef uchar2 type; }; 83template<> struct MakeVec<bool, 3> { typedef uchar3 type; }; 84template<> struct MakeVec<bool, 4> { typedef uchar4 type; }; 85 86// VecTraits 87 88template<typename T> struct VecTraits; 89 90#define CV_CUDEV_VEC_TRAITS_INST(type) \ 91 template <> struct VecTraits<type> \ 92 { \ 93 typedef type elem_type; \ 94 enum {cn=1}; \ 95 __host__ __device__ __forceinline__ static type all(type v) {return v;} \ 96 __host__ __device__ __forceinline__ static type make(type x) {return x;} \ 97 __host__ __device__ __forceinline__ static type make(const type* v) {return *v;} \ 98 }; \ 99 template <> struct VecTraits<type ## 1> \ 100 { \ 101 typedef type elem_type; \ 102 enum {cn=1}; \ 103 __host__ __device__ __forceinline__ static type ## 1 all(type v) {return make_ ## type ## 1(v);} \ 104 __host__ __device__ __forceinline__ static type ## 1 make(type x) {return make_ ## type ## 1(x);} \ 105 __host__ __device__ __forceinline__ static type ## 1 make(const type* v) {return make_ ## type ## 1(*v);} \ 106 }; \ 107 template <> struct VecTraits<type ## 2> \ 108 { \ 109 typedef type elem_type; \ 110 enum {cn=2}; \ 111 __host__ __device__ __forceinline__ static type ## 2 all(type v) {return make_ ## type ## 2(v, v);} \ 112 __host__ __device__ __forceinline__ static type ## 2 make(type x, type y) {return make_ ## type ## 2(x, y);} \ 113 __host__ __device__ __forceinline__ static type ## 2 make(const type* v) {return make_ ## type ## 2(v[0], v[1]);} \ 114 }; \ 115 template <> struct VecTraits<type ## 3> \ 116 { \ 117 typedef type elem_type; \ 118 enum {cn=3}; \ 119 __host__ __device__ __forceinline__ static type ## 3 all(type v) {return make_ ## type ## 3(v, v, v);} \ 120 __host__ __device__ __forceinline__ static type ## 3 make(type x, type y, type z) {return make_ ## type ## 3(x, y, z);} \ 121 __host__ __device__ __forceinline__ static type ## 3 make(const type* v) {return make_ ## type ## 3(v[0], v[1], v[2]);} \ 122 }; \ 123 template <> struct VecTraits<type ## 4> \ 124 { \ 125 typedef type elem_type; \ 126 enum {cn=4}; \ 127 __host__ __device__ __forceinline__ static type ## 4 all(type v) {return make_ ## type ## 4(v, v, v, v);} \ 128 __host__ __device__ __forceinline__ static type ## 4 make(type x, type y, type z, type w) {return make_ ## type ## 4(x, y, z, w);} \ 129 __host__ __device__ __forceinline__ static type ## 4 make(const type* v) {return make_ ## type ## 4(v[0], v[1], v[2], v[3]);} \ 130 }; 131 132CV_CUDEV_VEC_TRAITS_INST(uchar) 133CV_CUDEV_VEC_TRAITS_INST(ushort) 134CV_CUDEV_VEC_TRAITS_INST(short) 135CV_CUDEV_VEC_TRAITS_INST(int) 136CV_CUDEV_VEC_TRAITS_INST(uint) 137CV_CUDEV_VEC_TRAITS_INST(float) 138CV_CUDEV_VEC_TRAITS_INST(double) 139 140#undef CV_CUDEV_VEC_TRAITS_INST 141 142template<> struct VecTraits<schar> 143{ 144 typedef schar elem_type; 145 enum {cn=1}; 146 __host__ __device__ __forceinline__ static schar all(schar v) {return v;} 147 __host__ __device__ __forceinline__ static schar make(schar x) {return x;} 148 __host__ __device__ __forceinline__ static schar make(const schar* x) {return *x;} 149}; 150template<> struct VecTraits<char1> 151{ 152 typedef schar elem_type; 153 enum {cn=1}; 154 __host__ __device__ __forceinline__ static char1 all(schar v) {return make_char1(v);} 155 __host__ __device__ __forceinline__ static char1 make(schar x) {return make_char1(x);} 156 __host__ __device__ __forceinline__ static char1 make(const schar* v) {return make_char1(v[0]);} 157}; 158template<> struct VecTraits<char2> 159{ 160 typedef schar elem_type; 161 enum {cn=2}; 162 __host__ __device__ __forceinline__ static char2 all(schar v) {return make_char2(v, v);} 163 __host__ __device__ __forceinline__ static char2 make(schar x, schar y) {return make_char2(x, y);} 164 __host__ __device__ __forceinline__ static char2 make(const schar* v) {return make_char2(v[0], v[1]);} 165}; 166template<> struct VecTraits<char3> 167{ 168 typedef schar elem_type; 169 enum {cn=3}; 170 __host__ __device__ __forceinline__ static char3 all(schar v) {return make_char3(v, v, v);} 171 __host__ __device__ __forceinline__ static char3 make(schar x, schar y, schar z) {return make_char3(x, y, z);} 172 __host__ __device__ __forceinline__ static char3 make(const schar* v) {return make_char3(v[0], v[1], v[2]);} 173}; 174template<> struct VecTraits<char4> 175{ 176 typedef schar elem_type; 177 enum {cn=4}; 178 __host__ __device__ __forceinline__ static char4 all(schar v) {return make_char4(v, v, v, v);} 179 __host__ __device__ __forceinline__ static char4 make(schar x, schar y, schar z, schar w) {return make_char4(x, y, z, w);} 180 __host__ __device__ __forceinline__ static char4 make(const schar* v) {return make_char4(v[0], v[1], v[2], v[3]);} 181}; 182 183//! @} 184 185}} 186 187// DataType 188 189namespace cv { 190 191template <> class DataType<uint> 192{ 193public: 194 typedef uint value_type; 195 typedef value_type work_type; 196 typedef value_type channel_type; 197 typedef value_type vec_type; 198 enum { generic_type = 0, 199 depth = CV_32S, 200 channels = 1, 201 fmt = (int)'i', 202 type = CV_MAKE_TYPE(depth, channels) 203 }; 204}; 205 206#define CV_CUDEV_DATA_TYPE_INST(_depth_type, _channel_num) \ 207 template <> class DataType< _depth_type ## _channel_num > \ 208 { \ 209 public: \ 210 typedef _depth_type ## _channel_num value_type; \ 211 typedef value_type work_type; \ 212 typedef _depth_type channel_type; \ 213 typedef value_type vec_type; \ 214 enum { generic_type = 0, \ 215 depth = DataType<channel_type>::depth, \ 216 channels = _channel_num, \ 217 fmt = DataType<channel_type>::fmt + ((channels - 1) << 8), \ 218 type = CV_MAKE_TYPE(depth, channels) \ 219 }; \ 220 }; 221 222CV_CUDEV_DATA_TYPE_INST(uchar, 1) 223CV_CUDEV_DATA_TYPE_INST(uchar, 2) 224CV_CUDEV_DATA_TYPE_INST(uchar, 3) 225CV_CUDEV_DATA_TYPE_INST(uchar, 4) 226 227CV_CUDEV_DATA_TYPE_INST(ushort, 1) 228CV_CUDEV_DATA_TYPE_INST(ushort, 2) 229CV_CUDEV_DATA_TYPE_INST(ushort, 3) 230CV_CUDEV_DATA_TYPE_INST(ushort, 4) 231 232CV_CUDEV_DATA_TYPE_INST(short, 1) 233CV_CUDEV_DATA_TYPE_INST(short, 2) 234CV_CUDEV_DATA_TYPE_INST(short, 3) 235CV_CUDEV_DATA_TYPE_INST(short, 4) 236 237CV_CUDEV_DATA_TYPE_INST(int, 1) 238CV_CUDEV_DATA_TYPE_INST(int, 2) 239CV_CUDEV_DATA_TYPE_INST(int, 3) 240CV_CUDEV_DATA_TYPE_INST(int, 4) 241 242CV_CUDEV_DATA_TYPE_INST(uint, 1) 243CV_CUDEV_DATA_TYPE_INST(uint, 2) 244CV_CUDEV_DATA_TYPE_INST(uint, 3) 245CV_CUDEV_DATA_TYPE_INST(uint, 4) 246 247CV_CUDEV_DATA_TYPE_INST(float, 1) 248CV_CUDEV_DATA_TYPE_INST(float, 2) 249CV_CUDEV_DATA_TYPE_INST(float, 3) 250CV_CUDEV_DATA_TYPE_INST(float, 4) 251 252CV_CUDEV_DATA_TYPE_INST(double, 1) 253CV_CUDEV_DATA_TYPE_INST(double, 2) 254CV_CUDEV_DATA_TYPE_INST(double, 3) 255CV_CUDEV_DATA_TYPE_INST(double, 4) 256 257#undef CV_CUDEV_DATA_TYPE_INST 258 259template<> class DataType<char1> 260{ 261public: 262 typedef char1 value_type; 263 typedef value_type work_type; 264 typedef schar channel_type; 265 typedef value_type vec_type; 266 267 enum { generic_type = 0, 268 depth = DataType<channel_type>::depth, 269 channels = 1, 270 fmt = DataType<channel_type>::fmt + ((channels - 1) << 8), 271 type = CV_MAKE_TYPE(depth, channels) 272 }; 273}; 274 275template<> class DataType<char2> 276{ 277public: 278 typedef char2 value_type; 279 typedef value_type work_type; 280 typedef schar channel_type; 281 typedef value_type vec_type; 282 283 enum { generic_type = 0, 284 depth = DataType<channel_type>::depth, 285 channels = 2, 286 fmt = DataType<channel_type>::fmt + ((channels - 1) << 8), 287 type = CV_MAKE_TYPE(depth, channels) 288 }; 289}; 290 291template<> class DataType<char3> 292{ 293public: 294 typedef char3 value_type; 295 typedef value_type work_type; 296 typedef schar channel_type; 297 typedef value_type vec_type; 298 299 enum { generic_type = 0, 300 depth = DataType<channel_type>::depth, 301 channels = 3, 302 fmt = DataType<channel_type>::fmt + ((channels - 1) << 8), 303 type = CV_MAKE_TYPE(depth, channels) 304 }; 305}; 306 307template<> class DataType<char4> 308{ 309public: 310 typedef char4 value_type; 311 typedef value_type work_type; 312 typedef schar channel_type; 313 typedef value_type vec_type; 314 315 enum { generic_type = 0, 316 depth = DataType<channel_type>::depth, 317 channels = 4, 318 fmt = DataType<channel_type>::fmt + ((channels - 1) << 8), 319 type = CV_MAKE_TYPE(depth, channels) 320 }; 321}; 322 323} 324 325#endif 326