OpenCV 4.5.3(日本語機械翻訳)
traits.hpp
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
56
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
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
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
374CV_CREATE_MEMBER_CHECK(fmt)
375CV_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
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
cv::DataDepth
A helper class for cv::DataType
Definition: traits.hpp:285
cv::DataType
Template "trait" class for OpenCV primitive data types.
Definition: traits.hpp:113
cv
"black box" representation of the file storage associated with a file on disk.
Definition: aruco.hpp:75
cv::traits::Depth
Definition: traits.hpp:382
cv::traits::SafeFmt
Definition: traits.hpp:402
cv::traits::SafeType
Definition: traits.hpp:390
cv::traits::Type
Definition: traits.hpp:386
構築: doxygen 1.9.2