点阵完成，加入opencv
This commit is contained in:
417
3rdpart/OpenCV/include/opencv2/core/traits.hpp
Normal file
417
3rdpart/OpenCV/include/opencv2/core/traits.hpp
Normal file
@@ -0,0 +1,417 @@
|
||||
/*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*/
|
||||
|
||||
#ifndef OPENCV_CORE_TRAITS_HPP
|
||||
#define OPENCV_CORE_TRAITS_HPP
|
||||
|
||||
#include "opencv2/core/cvdef.h"
|
||||
|
||||
namespace cv
|
||||
{
|
||||
|
||||
//#define OPENCV_TRAITS_ENABLE_DEPRECATED
|
||||
|
||||
//! @addtogroup core_basic
|
||||
//! @{
|
||||
|
||||
/** @brief Template "trait" class for OpenCV primitive data types.
|
||||
|
||||
@note Deprecated. This is replaced by "single purpose" traits: traits::Type and traits::Depth
|
||||
|
||||
A primitive OpenCV data type is one of unsigned char, bool, signed char, unsigned short, signed
|
||||
short, int, float, double, or a tuple of values of one of these types, where all the values in the
|
||||
tuple have the same type. Any primitive type from the list can be defined by an identifier in the
|
||||
form CV_\<bit-depth\>{U|S|F}C(\<number_of_channels\>), for example: uchar \~ CV_8UC1, 3-element
|
||||
floating-point tuple \~ CV_32FC3, and so on. A universal OpenCV structure that is able to store a
|
||||
single instance of such a primitive data type is Vec. Multiple instances of such a type can be
|
||||
stored in a std::vector, Mat, Mat_, SparseMat, SparseMat_, or any other container that is able to
|
||||
store Vec instances.
|
||||
|
||||
The DataType class is basically used to provide a description of such primitive data types without
|
||||
adding any fields or methods to the corresponding classes (and it is actually impossible to add
|
||||
anything to primitive C/C++ data types). This technique is known in C++ as class traits. It is not
|
||||
DataType itself that is used but its specialized versions, such as:
|
||||
@code
|
||||
template<> class DataType<uchar>
|
||||
{
|
||||
typedef uchar value_type;
|
||||
typedef int work_type;
|
||||
typedef uchar channel_type;
|
||||
enum { channel_type = CV_8U, channels = 1, fmt='u', type = CV_8U };
|
||||
};
|
||||
...
|
||||
template<typename _Tp> DataType<std::complex<_Tp> >
|
||||
{
|
||||
typedef std::complex<_Tp> value_type;
|
||||
typedef std::complex<_Tp> work_type;
|
||||
typedef _Tp channel_type;
|
||||
// DataDepth is another helper trait class
|
||||
enum { depth = DataDepth<_Tp>::value, channels=2,
|
||||
fmt=(channels-1)*256+DataDepth<_Tp>::fmt,
|
||||
type=CV_MAKETYPE(depth, channels) };
|
||||
};
|
||||
...
|
||||
@endcode
|
||||
The main purpose of this class is to convert compilation-time type information to an
|
||||
OpenCV-compatible data type identifier, for example:
|
||||
@code
|
||||
// allocates a 30x40 floating-point matrix
|
||||
Mat A(30, 40, DataType<float>::type);
|
||||
|
||||
Mat B = Mat_<std::complex<double> >(3, 3);
|
||||
// the statement below will print 6, 2 , that is depth == CV_64F, channels == 2
|
||||
cout << B.depth() << ", " << B.channels() << endl;
|
||||
@endcode
|
||||
So, such traits are used to tell OpenCV which data type you are working with, even if such a type is
|
||||
not native to OpenCV. For example, the matrix B initialization above is compiled because OpenCV
|
||||
defines the proper specialized template class DataType\<complex\<_Tp\> \> . This mechanism is also
|
||||
useful (and used in OpenCV this way) for generic algorithms implementations.
|
||||
|
||||
@note Default values were dropped to stop confusing developers about using of unsupported types (see #7599)
|
||||
*/
|
||||
template<typename _Tp> class DataType
|
||||
{
|
||||
public:
|
||||
#ifdef OPENCV_TRAITS_ENABLE_DEPRECATED
|
||||
typedef _Tp value_type;
|
||||
typedef value_type work_type;
|
||||
typedef value_type channel_type;
|
||||
typedef value_type vec_type;
|
||||
enum { generic_type = 1,
|
||||
depth = -1,
|
||||
channels = 1,
|
||||
fmt = 0,
|
||||
type = CV_MAKETYPE(depth, channels)
|
||||
};
|
||||
#endif
|
||||
};
|
||||
|
||||
template<> class DataType<bool>
|
||||
{
|
||||
public:
|
||||
typedef bool value_type;
|
||||
typedef int work_type;
|
||||
typedef value_type channel_type;
|
||||
typedef value_type vec_type;
|
||||
enum { generic_type = 0,
|
||||
depth = CV_8U,
|
||||
channels = 1,
|
||||
fmt = (int)'u',
|
||||
type = CV_MAKETYPE(depth, channels)
|
||||
};
|
||||
};
|
||||
|
||||
template<> class DataType<uchar>
|
||||
{
|
||||
public:
|
||||
typedef uchar value_type;
|
||||
typedef int work_type;
|
||||
typedef value_type channel_type;
|
||||
typedef value_type vec_type;
|
||||
enum { generic_type = 0,
|
||||
depth = CV_8U,
|
||||
channels = 1,
|
||||
fmt = (int)'u',
|
||||
type = CV_MAKETYPE(depth, channels)
|
||||
};
|
||||
};
|
||||
|
||||
template<> class DataType<schar>
|
||||
{
|
||||
public:
|
||||
typedef schar value_type;
|
||||
typedef int work_type;
|
||||
typedef value_type channel_type;
|
||||
typedef value_type vec_type;
|
||||
enum { generic_type = 0,
|
||||
depth = CV_8S,
|
||||
channels = 1,
|
||||
fmt = (int)'c',
|
||||
type = CV_MAKETYPE(depth, channels)
|
||||
};
|
||||
};
|
||||
|
||||
template<> class DataType<char>
|
||||
{
|
||||
public:
|
||||
typedef schar value_type;
|
||||
typedef int work_type;
|
||||
typedef value_type channel_type;
|
||||
typedef value_type vec_type;
|
||||
enum { generic_type = 0,
|
||||
depth = CV_8S,
|
||||
channels = 1,
|
||||
fmt = (int)'c',
|
||||
type = CV_MAKETYPE(depth, channels)
|
||||
};
|
||||
};
|
||||
|
||||
template<> class DataType<ushort>
|
||||
{
|
||||
public:
|
||||
typedef ushort value_type;
|
||||
typedef int work_type;
|
||||
typedef value_type channel_type;
|
||||
typedef value_type vec_type;
|
||||
enum { generic_type = 0,
|
||||
depth = CV_16U,
|
||||
channels = 1,
|
||||
fmt = (int)'w',
|
||||
type = CV_MAKETYPE(depth, channels)
|
||||
};
|
||||
};
|
||||
|
||||
template<> class DataType<short>
|
||||
{
|
||||
public:
|
||||
typedef short value_type;
|
||||
typedef int work_type;
|
||||
typedef value_type channel_type;
|
||||
typedef value_type vec_type;
|
||||
enum { generic_type = 0,
|
||||
depth = CV_16S,
|
||||
channels = 1,
|
||||
fmt = (int)'s',
|
||||
type = CV_MAKETYPE(depth, channels)
|
||||
};
|
||||
};
|
||||
|
||||
template<> class DataType<int>
|
||||
{
|
||||
public:
|
||||
typedef int 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_MAKETYPE(depth, channels)
|
||||
};
|
||||
};
|
||||
|
||||
template<> class DataType<float>
|
||||
{
|
||||
public:
|
||||
typedef float value_type;
|
||||
typedef value_type work_type;
|
||||
typedef value_type channel_type;
|
||||
typedef value_type vec_type;
|
||||
enum { generic_type = 0,
|
||||
depth = CV_32F,
|
||||
channels = 1,
|
||||
fmt = (int)'f',
|
||||
type = CV_MAKETYPE(depth, channels)
|
||||
};
|
||||
};
|
||||
|
||||
template<> class DataType<double>
|
||||
{
|
||||
public:
|
||||
typedef double value_type;
|
||||
typedef value_type work_type;
|
||||
typedef value_type channel_type;
|
||||
typedef value_type vec_type;
|
||||
enum { generic_type = 0,
|
||||
depth = CV_64F,
|
||||
channels = 1,
|
||||
fmt = (int)'d',
|
||||
type = CV_MAKETYPE(depth, channels)
|
||||
};
|
||||
};
|
||||
|
||||
template<> class DataType<hfloat>
|
||||
{
|
||||
public:
|
||||
typedef hfloat value_type;
|
||||
typedef float work_type;
|
||||
typedef value_type channel_type;
|
||||
typedef value_type vec_type;
|
||||
enum { generic_type = 0,
|
||||
depth = CV_16F,
|
||||
channels = 1,
|
||||
fmt = (int)'h',
|
||||
type = CV_MAKETYPE(depth, channels)
|
||||
};
|
||||
};
|
||||
|
||||
/** @brief A helper class for cv::DataType
|
||||
|
||||
The class is specialized for each fundamental numerical data type supported by OpenCV. It provides
|
||||
DataDepth<T>::value constant.
|
||||
*/
|
||||
template<typename _Tp> class DataDepth
|
||||
{
|
||||
public:
|
||||
enum
|
||||
{
|
||||
value = DataType<_Tp>::depth,
|
||||
fmt = DataType<_Tp>::fmt
|
||||
};
|
||||
};
|
||||
|
||||
|
||||
#ifdef OPENCV_TRAITS_ENABLE_DEPRECATED
|
||||
|
||||
template<int _depth> class TypeDepth
|
||||
{
|
||||
#ifdef OPENCV_TRAITS_ENABLE_LEGACY_DEFAULTS
|
||||
enum { depth = CV_USRTYPE1 };
|
||||
typedef void value_type;
|
||||
#endif
|
||||
};
|
||||
|
||||
template<> class TypeDepth<CV_8U>
|
||||
{
|
||||
enum { depth = CV_8U };
|
||||
typedef uchar value_type;
|
||||
};
|
||||
|
||||
template<> class TypeDepth<CV_8S>
|
||||
{
|
||||
enum { depth = CV_8S };
|
||||
typedef schar value_type;
|
||||
};
|
||||
|
||||
template<> class TypeDepth<CV_16U>
|
||||
{
|
||||
enum { depth = CV_16U };
|
||||
typedef ushort value_type;
|
||||
};
|
||||
|
||||
template<> class TypeDepth<CV_16S>
|
||||
{
|
||||
enum { depth = CV_16S };
|
||||
typedef short value_type;
|
||||
};
|
||||
|
||||
template<> class TypeDepth<CV_32S>
|
||||
{
|
||||
enum { depth = CV_32S };
|
||||
typedef int value_type;
|
||||
};
|
||||
|
||||
template<> class TypeDepth<CV_32F>
|
||||
{
|
||||
enum { depth = CV_32F };
|
||||
typedef float value_type;
|
||||
};
|
||||
|
||||
template<> class TypeDepth<CV_64F>
|
||||
{
|
||||
enum { depth = CV_64F };
|
||||
typedef double value_type;
|
||||
};
|
||||
|
||||
template<> class TypeDepth<CV_16F>
|
||||
{
|
||||
enum { depth = CV_16F };
|
||||
typedef hfloat value_type;
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
//! @}
|
||||
|
||||
namespace traits {
|
||||
|
||||
namespace internal {
|
||||
#define CV_CREATE_MEMBER_CHECK(X) \
|
||||
template<typename T> class CheckMember_##X { \
|
||||
struct Fallback { int X; }; \
|
||||
struct Derived : T, Fallback { }; \
|
||||
template<typename U, U> struct Check; \
|
||||
typedef char CV_NO[1]; \
|
||||
typedef char CV_YES[2]; \
|
||||
template<typename U> static CV_NO & func(Check<int Fallback::*, &U::X> *); \
|
||||
template<typename U> static CV_YES & func(...); \
|
||||
public: \
|
||||
typedef CheckMember_##X type; \
|
||||
enum { value = sizeof(func<Derived>(0)) == sizeof(CV_YES) }; \
|
||||
};
|
||||
|
||||
CV_CREATE_MEMBER_CHECK(fmt)
|
||||
CV_CREATE_MEMBER_CHECK(type)
|
||||
|
||||
} // namespace internal
|
||||
|
||||
|
||||
template<typename T>
|
||||
struct Depth
|
||||
{ enum { value = DataType<T>::depth }; };
|
||||
|
||||
template<typename T>
|
||||
struct Type
|
||||
{ enum { value = DataType<T>::type }; };
|
||||
|
||||
/** Similar to traits::Type<T> but has value = -1 in case of unknown type (instead of compiler error) */
|
||||
template<typename T, bool available = internal::CheckMember_type< DataType<T> >::value >
|
||||
struct SafeType {};
|
||||
|
||||
template<typename T>
|
||||
struct SafeType<T, false>
|
||||
{ enum { value = -1 }; };
|
||||
|
||||
template<typename T>
|
||||
struct SafeType<T, true>
|
||||
{ enum { value = Type<T>::value }; };
|
||||
|
||||
|
||||
template<typename T, bool available = internal::CheckMember_fmt< DataType<T> >::value >
|
||||
struct SafeFmt {};
|
||||
|
||||
template<typename T>
|
||||
struct SafeFmt<T, false>
|
||||
{ enum { fmt = 0 }; };
|
||||
|
||||
template<typename T>
|
||||
struct SafeFmt<T, true>
|
||||
{ enum { fmt = DataType<T>::fmt }; };
|
||||
|
||||
|
||||
} // namespace
|
||||
|
||||
} // cv
|
||||
|
||||
#endif // OPENCV_CORE_TRAITS_HPP
|
||||
Reference in New Issue
Block a user