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 #ifndef OPENCV_CORE_TRAITS_HPP 45 #define OPENCV_CORE_TRAITS_HPP 46 47 #include "opencv2/core/cvdef.h" 48 49 namespace cv 50 { 51 52 //#define OPENCV_TRAITS_ENABLE_DEPRECATED 53 54 //! @addtogroup core_basic 55 //! @{ 56 57 /** @brief Template "trait" class for OpenCV primitive data types. 58 59 @note Deprecated. This is replaced by "single purpose" traits: traits::Type and traits::Depth 60 61 A primitive OpenCV data type is one of unsigned char, bool, signed char, unsigned short, signed 62 short, int, float, double, or a tuple of values of one of these types, where all the values in the 63 tuple have the same type. Any primitive type from the list can be defined by an identifier in the 64 form CV_\<bit-depth\>{U|S|F}C(\<number_of_channels\>), for example: uchar \~ CV_8UC1, 3-element 65 floating-point tuple \~ CV_32FC3, and so on. A universal OpenCV structure that is able to store a 66 single instance of such a primitive data type is Vec. Multiple instances of such a type can be 67 stored in a std::vector, Mat, Mat_, SparseMat, SparseMat_, or any other container that is able to 68 store Vec instances. 69 70 The DataType class is basically used to provide a description of such primitive data types without 71 adding any fields or methods to the corresponding classes (and it is actually impossible to add 72 anything to primitive C/C++ data types). This technique is known in C++ as class traits. It is not 73 DataType itself that is used but its specialized versions, such as: 74 @code 75 template<> class DataType<uchar> 76 { 77 typedef uchar value_type; 78 typedef int work_type; 79 typedef uchar channel_type; 80 enum { channel_type = CV_8U, channels = 1, fmt='u', type = CV_8U }; 81 }; 82 ... 83 template<typename _Tp> DataType<std::complex<_Tp> > 84 { 85 typedef std::complex<_Tp> value_type; 86 typedef std::complex<_Tp> work_type; 87 typedef _Tp channel_type; 88 // DataDepth is another helper trait class 89 enum { depth = DataDepth<_Tp>::value, channels=2, 90 fmt=(channels-1)*256+DataDepth<_Tp>::fmt, 91 type=CV_MAKETYPE(depth, channels) }; 92 }; 93 ... 94 @endcode 95 The main purpose of this class is to convert compilation-time type information to an 96 OpenCV-compatible data type identifier, for example: 97 @code 98 // allocates a 30x40 floating-point matrix 99 Mat A(30, 40, DataType<float>::type); 100 101 Mat B = Mat_<std::complex<double> >(3, 3); 102 // the statement below will print 6, 2 , that is depth == CV_64F, channels == 2 103 cout << B.depth() << ", " << B.channels() << endl; 104 @endcode 105 So, such traits are used to tell OpenCV which data type you are working with, even if such a type is 106 not native to OpenCV. For example, the matrix B initialization above is compiled because OpenCV 107 defines the proper specialized template class DataType\<complex\<_Tp\> \> . This mechanism is also 108 useful (and used in OpenCV this way) for generic algorithms implementations. 109 110 @note Default values were dropped to stop confusing developers about using of unsupported types (see #7599) 111 */ 112 template<typename _Tp> class DataType 113 { 114 public: 115 #ifdef OPENCV_TRAITS_ENABLE_DEPRECATED 116 typedef _Tp value_type; 117 typedef value_type work_type; 118 typedef value_type channel_type; 119 typedef value_type vec_type; 120 enum { generic_type = 1, 121 depth = -1, 122 channels = 1, 123 fmt = 0, 124 type = CV_MAKETYPE(depth, channels) 125 }; 126 #endif 127 }; 128 129 template<> class DataType<bool> 130 { 131 public: 132 typedef bool value_type; 133 typedef int work_type; 134 typedef value_type channel_type; 135 typedef value_type vec_type; 136 enum { generic_type = 0, 137 depth = CV_8U, 138 channels = 1, 139 fmt = (int)'u', 140 type = CV_MAKETYPE(depth, channels) 141 }; 142 }; 143 144 template<> class DataType<uchar> 145 { 146 public: 147 typedef uchar value_type; 148 typedef int work_type; 149 typedef value_type channel_type; 150 typedef value_type vec_type; 151 enum { generic_type = 0, 152 depth = CV_8U, 153 channels = 1, 154 fmt = (int)'u', 155 type = CV_MAKETYPE(depth, channels) 156 }; 157 }; 158 159 template<> class DataType<schar> 160 { 161 public: 162 typedef schar value_type; 163 typedef int work_type; 164 typedef value_type channel_type; 165 typedef value_type vec_type; 166 enum { generic_type = 0, 167 depth = CV_8S, 168 channels = 1, 169 fmt = (int)'c', 170 type = CV_MAKETYPE(depth, channels) 171 }; 172 }; 173 174 template<> class DataType<char> 175 { 176 public: 177 typedef schar value_type; 178 typedef int work_type; 179 typedef value_type channel_type; 180 typedef value_type vec_type; 181 enum { generic_type = 0, 182 depth = CV_8S, 183 channels = 1, 184 fmt = (int)'c', 185 type = CV_MAKETYPE(depth, channels) 186 }; 187 }; 188 189 template<> class DataType<ushort> 190 { 191 public: 192 typedef ushort value_type; 193 typedef int work_type; 194 typedef value_type channel_type; 195 typedef value_type vec_type; 196 enum { generic_type = 0, 197 depth = CV_16U, 198 channels = 1, 199 fmt = (int)'w', 200 type = CV_MAKETYPE(depth, channels) 201 }; 202 }; 203 204 template<> class DataType<short> 205 { 206 public: 207 typedef short value_type; 208 typedef int work_type; 209 typedef value_type channel_type; 210 typedef value_type vec_type; 211 enum { generic_type = 0, 212 depth = CV_16S, 213 channels = 1, 214 fmt = (int)'s', 215 type = CV_MAKETYPE(depth, channels) 216 }; 217 }; 218 219 template<> class DataType<int> 220 { 221 public: 222 typedef int value_type; 223 typedef value_type work_type; 224 typedef value_type channel_type; 225 typedef value_type vec_type; 226 enum { generic_type = 0, 227 depth = CV_32S, 228 channels = 1, 229 fmt = (int)'i', 230 type = CV_MAKETYPE(depth, channels) 231 }; 232 }; 233 234 template<> class DataType<float> 235 { 236 public: 237 typedef float value_type; 238 typedef value_type work_type; 239 typedef value_type channel_type; 240 typedef value_type vec_type; 241 enum { generic_type = 0, 242 depth = CV_32F, 243 channels = 1, 244 fmt = (int)'f', 245 type = CV_MAKETYPE(depth, channels) 246 }; 247 }; 248 249 template<> class DataType<double> 250 { 251 public: 252 typedef double value_type; 253 typedef value_type work_type; 254 typedef value_type channel_type; 255 typedef value_type vec_type; 256 enum { generic_type = 0, 257 depth = CV_64F, 258 channels = 1, 259 fmt = (int)'d', 260 type = CV_MAKETYPE(depth, channels) 261 }; 262 }; 263 264 template<> class DataType<float16_t> 265 { 266 public: 267 typedef float16_t value_type; 268 typedef float work_type; 269 typedef value_type channel_type; 270 typedef value_type vec_type; 271 enum { generic_type = 0, 272 depth = CV_16F, 273 channels = 1, 274 fmt = (int)'h', 275 type = CV_MAKETYPE(depth, channels) 276 }; 277 }; 278 279 /** @brief A helper class for cv::DataType 280 281 The class is specialized for each fundamental numerical data type supported by OpenCV. It provides 282 DataDepth<T>::value constant. 283 */ 284 template<typename _Tp> class DataDepth 285 { 286 public: 287 enum 288 { 289 value = DataType<_Tp>::depth, 290 fmt = DataType<_Tp>::fmt 291 }; 292 }; 293 294 295 #ifdef OPENCV_TRAITS_ENABLE_DEPRECATED 296 297 template<int _depth> class TypeDepth 298 { 299 #ifdef OPENCV_TRAITS_ENABLE_LEGACY_DEFAULTS 300 enum { depth = CV_USRTYPE1 }; 301 typedef void value_type; 302 #endif 303 }; 304 305 template<> class TypeDepth<CV_8U> 306 { 307 enum { depth = CV_8U }; 308 typedef uchar value_type; 309 }; 310 311 template<> class TypeDepth<CV_8S> 312 { 313 enum { depth = CV_8S }; 314 typedef schar value_type; 315 }; 316 317 template<> class TypeDepth<CV_16U> 318 { 319 enum { depth = CV_16U }; 320 typedef ushort value_type; 321 }; 322 323 template<> class TypeDepth<CV_16S> 324 { 325 enum { depth = CV_16S }; 326 typedef short value_type; 327 }; 328 329 template<> class TypeDepth<CV_32S> 330 { 331 enum { depth = CV_32S }; 332 typedef int value_type; 333 }; 334 335 template<> class TypeDepth<CV_32F> 336 { 337 enum { depth = CV_32F }; 338 typedef float value_type; 339 }; 340 341 template<> class TypeDepth<CV_64F> 342 { 343 enum { depth = CV_64F }; 344 typedef double value_type; 345 }; 346 347 template<> class TypeDepth<CV_16F> 348 { 349 enum { depth = CV_16F }; 350 typedef float16_t value_type; 351 }; 352 353 #endif 354 355 //! @} 356 357 namespace traits { 358 359 namespace internal { 360 #define CV_CREATE_MEMBER_CHECK(X) \ 361 template<typename T> class CheckMember_##X { \ 362 struct Fallback { int X; }; \ 363 struct Derived : T, Fallback { }; \ 364 template<typename U, U> struct Check; \ 365 typedef char CV_NO[1]; \ 366 typedef char CV_YES[2]; \ 367 template<typename U> static CV_NO & func(Check<int Fallback::*, &U::X> *); \ 368 template<typename U> static CV_YES & func(...); \ 369 public: \ 370 typedef CheckMember_##X type; \ 371 enum { value = sizeof(func<Derived>(0)) == sizeof(CV_YES) }; \ 372 }; 373 374 CV_CREATE_MEMBER_CHECK(fmt) 375 CV_CREATE_MEMBER_CHECK(type) 376 377 } // namespace internal 378 379 380 template<typename T> 381 struct Depth 382 { enum { value = DataType<T>::depth }; }; 383 384 template<typename T> 385 struct Type 386 { enum { value = DataType<T>::type }; }; 387 388 /** Similar to traits::Type<T> but has value = -1 in case of unknown type (instead of compiler error) */ 389 template<typename T, bool available = internal::CheckMember_type< DataType<T> >::value > 390 struct SafeType {}; 391 392 template<typename T> 393 struct SafeType<T, false> 394 { enum { value = -1 }; }; 395 396 template<typename T> 397 struct SafeType<T, true> 398 { enum { value = Type<T>::value }; }; 399 400 401 template<typename T, bool available = internal::CheckMember_fmt< DataType<T> >::value > 402 struct SafeFmt {}; 403 404 template<typename T> 405 struct SafeFmt<T, false> 406 { enum { fmt = 0 }; }; 407 408 template<typename T> 409 struct SafeFmt<T, true> 410 { enum { fmt = DataType<T>::fmt }; }; 411 412 413 } // namespace 414 415 } // cv 416 417 #endif // OPENCV_CORE_TRAITS_HPP 418