diff --git a/modules/core/include/opencv2/core.hpp b/modules/core/include/opencv2/core.hpp
index 319ffaf77..88687f358 100644
--- a/modules/core/include/opencv2/core.hpp
+++ b/modules/core/include/opencv2/core.hpp
@@ -241,27 +241,6 @@ public:
 
 /////////////////////// Vec (used as element of multi-channel images /////////////////////
 
-/*!
-  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 CV_EXPORTS DataDepth {};
-
-template<> class DataDepth<bool> { public: enum { value = CV_8U, fmt=(int)'u' }; };
-template<> class DataDepth<uchar> { public: enum { value = CV_8U, fmt=(int)'u' }; };
-template<> class DataDepth<schar> { public: enum { value = CV_8S, fmt=(int)'c' }; };
-template<> class DataDepth<char> { public: enum { value = CV_8S, fmt=(int)'c' }; };
-template<> class DataDepth<ushort> { public: enum { value = CV_16U, fmt=(int)'w' }; };
-template<> class DataDepth<short> { public: enum { value = CV_16S, fmt=(int)'s' }; };
-template<> class DataDepth<int> { public: enum { value = CV_32S, fmt=(int)'i' }; };
-// this is temporary solution to support 32-bit unsigned integers
-template<> class DataDepth<unsigned> { public: enum { value = CV_32S, fmt=(int)'i' }; };
-template<> class DataDepth<float> { public: enum { value = CV_32F, fmt=(int)'f' }; };
-template<> class DataDepth<double> { public: enum { value = CV_64F, fmt=(int)'d' }; };
-template<typename _Tp> class DataDepth<_Tp*> { public: enum { value = CV_USRTYPE1, fmt=(int)'r' }; };
-
 
 ////////////////////////////// Small Matrix ///////////////////////////
 
@@ -566,136 +545,6 @@ CV_EXPORTS void scalarToRawData(const Scalar& s, void* buf, int type, int unroll
 
 /////////////////////////////// DataType ////////////////////////////////
 
-/*!
-   Informative template class for OpenCV "scalars".
-
-   The class is specialized for each primitive numerical type supported by OpenCV (such as unsigned char or float),
-   as well as for more complex types, like cv::Complex<>, std::complex<>, cv::Vec<> etc.
-   The common property of all such types (called "scalars", do not confuse it with cv::Scalar_)
-   is that each of them is basically a tuple of numbers of the same type. Each "scalar" can be represented
-   by the depth id (CV_8U ... CV_64F) and the number of channels.
-   OpenCV matrices, 2D or nD, dense or sparse, can store "scalars",
-   as long as the number of channels does not exceed CV_CN_MAX.
-*/
-template<typename _Tp> class DataType
-{
-public:
-    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) };
-};
-
-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 = DataDepth<channel_type>::value, channels = 1,
-           fmt=DataDepth<channel_type>::fmt,
-           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 = DataDepth<channel_type>::value, channels = 1,
-           fmt=DataDepth<channel_type>::fmt,
-           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 = DataDepth<channel_type>::value, channels = 1,
-           fmt=DataDepth<channel_type>::fmt,
-           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 = DataDepth<channel_type>::value, channels = 1,
-           fmt=DataDepth<channel_type>::fmt,
-           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 = DataDepth<channel_type>::value, channels = 1,
-           fmt=DataDepth<channel_type>::fmt,
-           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 = DataDepth<channel_type>::value, channels = 1,
-           fmt=DataDepth<channel_type>::fmt,
-           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 = DataDepth<channel_type>::value, channels = 1,
-           fmt=DataDepth<channel_type>::fmt,
-           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 = DataDepth<channel_type>::value, channels = 1,
-           fmt=DataDepth<channel_type>::fmt,
-           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 = DataDepth<channel_type>::value, channels = 1,
-           fmt=DataDepth<channel_type>::fmt,
-           type = CV_MAKETYPE(depth, channels) };
-};
-
 template<typename _Tp, int m, int n> class DataType<Matx<_Tp, m, n> >
 {
 public:
@@ -720,77 +569,6 @@ public:
            type = CV_MAKETYPE(depth, channels) };
 };
 
-template<typename _Tp> class DataType<std::complex<_Tp> >
-{
-public:
-    typedef std::complex<_Tp> value_type;
-    typedef value_type work_type;
-    typedef _Tp channel_type;
-    enum { generic_type = 0, depth = DataDepth<channel_type>::value, channels = 2,
-           fmt = ((channels-1)<<8) + DataDepth<channel_type>::fmt,
-           type = CV_MAKETYPE(depth, channels) };
-    typedef Vec<channel_type, channels> vec_type;
-};
-
-template<typename _Tp> class DataType<Complex<_Tp> >
-{
-public:
-    typedef Complex<_Tp> value_type;
-    typedef value_type work_type;
-    typedef _Tp channel_type;
-    enum { generic_type = 0, depth = DataDepth<channel_type>::value, channels = 2,
-           fmt = ((channels-1)<<8) + DataDepth<channel_type>::fmt,
-           type = CV_MAKETYPE(depth, channels) };
-    typedef Vec<channel_type, channels> vec_type;
-};
-
-template<typename _Tp> class DataType<Point_<_Tp> >
-{
-public:
-    typedef Point_<_Tp> value_type;
-    typedef Point_<typename DataType<_Tp>::work_type> work_type;
-    typedef _Tp channel_type;
-    enum { generic_type = 0, depth = DataDepth<channel_type>::value, channels = 2,
-           fmt = ((channels-1)<<8) + DataDepth<channel_type>::fmt,
-           type = CV_MAKETYPE(depth, channels) };
-    typedef Vec<channel_type, channels> vec_type;
-};
-
-template<typename _Tp> class DataType<Point3_<_Tp> >
-{
-public:
-    typedef Point3_<_Tp> value_type;
-    typedef Point3_<typename DataType<_Tp>::work_type> work_type;
-    typedef _Tp channel_type;
-    enum { generic_type = 0, depth = DataDepth<channel_type>::value, channels = 3,
-           fmt = ((channels-1)<<8) + DataDepth<channel_type>::fmt,
-           type = CV_MAKETYPE(depth, channels) };
-    typedef Vec<channel_type, channels> vec_type;
-};
-
-template<typename _Tp> class DataType<Size_<_Tp> >
-{
-public:
-    typedef Size_<_Tp> value_type;
-    typedef Size_<typename DataType<_Tp>::work_type> work_type;
-    typedef _Tp channel_type;
-    enum { generic_type = 0, depth = DataDepth<channel_type>::value, channels = 2,
-           fmt = ((channels-1)<<8) + DataDepth<channel_type>::fmt,
-           type = CV_MAKETYPE(depth, channels) };
-    typedef Vec<channel_type, channels> vec_type;
-};
-
-template<typename _Tp> class DataType<Rect_<_Tp> >
-{
-public:
-    typedef Rect_<_Tp> value_type;
-    typedef Rect_<typename DataType<_Tp>::work_type> work_type;
-    typedef _Tp channel_type;
-    enum { generic_type = 0, depth = DataDepth<channel_type>::value, channels = 4,
-           fmt = ((channels-1)<<8) + DataDepth<channel_type>::fmt,
-           type = CV_MAKETYPE(depth, channels) };
-    typedef Vec<channel_type, channels> vec_type;
-};
 
 template<typename _Tp> class DataType<Scalar_<_Tp> >
 {
@@ -804,17 +582,6 @@ public:
     typedef Vec<channel_type, channels> vec_type;
 };
 
-template<> class DataType<Range>
-{
-public:
-    typedef Range value_type;
-    typedef value_type work_type;
-    typedef int channel_type;
-    enum { generic_type = 0, depth = DataDepth<channel_type>::value, channels = 2,
-           fmt = ((channels-1)<<8) + DataDepth<channel_type>::fmt,
-           type = CV_MAKETYPE(depth, channels) };
-    typedef Vec<channel_type, channels> vec_type;
-};
 
 //////////////////// generic_type ref-counting pointer class for C/C++ objects ////////////////////////
 
diff --git a/modules/core/include/opencv2/core/traits.hpp b/modules/core/include/opencv2/core/traits.hpp
new file mode 100644
index 000000000..045144408
--- /dev/null
+++ b/modules/core/include/opencv2/core/traits.hpp
@@ -0,0 +1,233 @@
+/*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"
+#include "opencv2/core/cvstd.hpp"
+
+namespace cv
+{
+
+/*!
+   Informative template class for OpenCV "scalars".
+
+   The class is specialized for each primitive numerical type supported by OpenCV (such as unsigned char or float),
+   as well as for more complex types, like cv::Complex<>, std::complex<>, cv::Vec<> etc.
+   The common property of all such types (called "scalars", do not confuse it with cv::Scalar_)
+   is that each of them is basically a tuple of numbers of the same type. Each "scalar" can be represented
+   by the depth id (CV_8U ... CV_64F) and the number of channels.
+   OpenCV matrices, 2D or nD, dense or sparse, can store "scalars",
+   as long as the number of channels does not exceed CV_CN_MAX.
+*/
+template<typename _Tp> class DataType
+{
+public:
+    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)
+         };
+};
+
+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)
+         };
+};
+
+
+/*!
+  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
+    };
+};
+
+} // cv
+
+#endif // __OPENCV_CORE_TRAITS_HPP__
diff --git a/modules/core/include/opencv2/core/types.hpp b/modules/core/include/opencv2/core/types.hpp
index 0bd072d70..84579b5dd 100644
--- a/modules/core/include/opencv2/core/types.hpp
+++ b/modules/core/include/opencv2/core/types.hpp
@@ -53,6 +53,7 @@
 
 #include "opencv2/core/cvdef.h"
 #include "opencv2/core/cvstd.hpp"
+#include "opencv2/core/traits.hpp"
 
 namespace cv
 {
@@ -150,6 +151,43 @@ public:
 typedef Complex<float> Complexf;
 typedef Complex<double> Complexd;
 
+/*!
+  traits
+*/
+#ifndef OPENCV_NOSTL
+template<typename _Tp> class DataType< std::complex<_Tp> >
+{
+public:
+    typedef std::complex<_Tp>  value_type;
+    typedef value_type         work_type;
+    typedef _Tp                channel_type;
+
+    enum { generic_type = 0,
+           depth        = DataType<channel_type>::depth,
+           channels     = 2,
+           fmt          = DataType<channel_type>::fmt + ((channels - 1) << 8),
+           type         = CV_MAKETYPE(depth, channels) };
+
+    typedef Vec<channel_type, channels> vec_type;
+};
+#endif // OPENCV_NOSTL
+
+template<typename _Tp> class DataType< Complex<_Tp> >
+{
+public:
+    typedef Complex<_Tp> value_type;
+    typedef value_type   work_type;
+    typedef _Tp          channel_type;
+
+    enum { generic_type = 0,
+           depth        = DataType<channel_type>::depth,
+           channels     = 2,
+           fmt          = DataType<channel_type>::fmt + ((channels - 1) << 8),
+           type         = CV_MAKETYPE(depth, channels) };
+
+    typedef Vec<channel_type, channels> vec_type;
+};
+
 
 
 //////////////////////////////// Point_ ////////////////////////////////
@@ -200,6 +238,26 @@ typedef Point_<float> Point2f;
 typedef Point_<double> Point2d;
 typedef Point2i Point;
 
+/*!
+  traits
+*/
+template<typename _Tp> class DataType< Point_<_Tp> >
+{
+public:
+    typedef Point_<_Tp>                               value_type;
+    typedef Point_<typename DataType<_Tp>::work_type> work_type;
+    typedef _Tp                                       channel_type;
+
+    enum { generic_type = 0,
+           depth        = DataType<channel_type>::depth,
+           channels     = 2,
+           fmt          = DataType<channel_type>::fmt + ((channels - 1) << 8),
+           type         = CV_MAKETYPE(depth, channels)
+         };
+
+    typedef Vec<channel_type, channels> vec_type;
+};
+
 
 
 //////////////////////////////// Point3_ ////////////////////////////////
@@ -247,6 +305,26 @@ typedef Point3_<int> Point3i;
 typedef Point3_<float> Point3f;
 typedef Point3_<double> Point3d;
 
+/*!
+  traits
+*/
+template<typename _Tp> class DataType< Point3_<_Tp> >
+{
+public:
+    typedef Point3_<_Tp>                               value_type;
+    typedef Point3_<typename DataType<_Tp>::work_type> work_type;
+    typedef _Tp                                        channel_type;
+
+    enum { generic_type = 0,
+           depth        = DataType<channel_type>::depth,
+           channels     = 3,
+           fmt          = DataType<channel_type>::fmt + ((channels - 1) << 8),
+           type         = CV_MAKETYPE(depth, channels)
+         };
+
+    typedef Vec<channel_type, channels> vec_type;
+};
+
 
 
 //////////////////////////////// Size_ ////////////////////////////////
@@ -285,6 +363,26 @@ typedef Size_<int> Size2i;
 typedef Size_<float> Size2f;
 typedef Size2i Size;
 
+/*!
+  traits
+*/
+template<typename _Tp> class DataType< Size_<_Tp> >
+{
+public:
+    typedef Size_<_Tp>                               value_type;
+    typedef Size_<typename DataType<_Tp>::work_type> work_type;
+    typedef _Tp                                      channel_type;
+
+    enum { generic_type = 0,
+           depth        = DataType<channel_type>::depth,
+           channels     = 2,
+           fmt          = DataType<channel_type>::fmt + ((channels - 1) << 8),
+           type         = CV_MAKETYPE(depth, channels)
+         };
+
+    typedef Vec<channel_type, channels> vec_type;
+};
+
 
 
 //////////////////////////////// Rect_ ////////////////////////////////
@@ -332,6 +430,26 @@ public:
 */
 typedef Rect_<int> Rect;
 
+/*!
+  traits
+*/
+template<typename _Tp> class DataType< Rect_<_Tp> >
+{
+public:
+    typedef Rect_<_Tp>                               value_type;
+    typedef Rect_<typename DataType<_Tp>::work_type> work_type;
+    typedef _Tp                                      channel_type;
+
+    enum { generic_type = 0,
+           depth        = DataType<channel_type>::depth,
+           channels     = 4,
+           fmt          = DataType<channel_type>::fmt + ((channels - 1) << 8),
+           type         = CV_MAKETYPE(depth, channels)
+         };
+
+    typedef Vec<channel_type, channels> vec_type;
+};
+
 
 
 ///////////////////////////// RotatedRect /////////////////////////////
@@ -374,15 +492,33 @@ class CV_EXPORTS Range
 public:
     Range();
     Range(int _start, int _end);
-    //Range(const CvSlice& slice);
     int size() const;
     bool empty() const;
     static Range all();
-    //operator CvSlice() const;
 
     int start, end;
 };
 
+/*!
+  traits
+*/
+template<> class DataType<Range>
+{
+public:
+    typedef Range      value_type;
+    typedef value_type work_type;
+    typedef int        channel_type;
+
+    enum { generic_type = 0,
+           depth        = DataType<channel_type>::depth,
+           channels     = 2,
+           fmt          = DataType<channel_type>::fmt + ((channels - 1) << 8),
+           type         = CV_MAKETYPE(depth, channels)
+         };
+
+    typedef Vec<channel_type, channels> vec_type;
+};
+
 
 
 /////////////////////////////// KeyPoint ////////////////////////////////
@@ -435,6 +571,27 @@ public:
     CV_PROP_RW int class_id; //!< object class (if the keypoints need to be clustered by an object they belong to)
 };
 
+/*!
+  traits
+*/
+template<> class DataType<KeyPoint>
+{
+public:
+    typedef KeyPoint      value_type;
+    typedef float         work_type;
+    typedef float         channel_type;
+
+    enum { generic_type = 0,
+           depth        = DataType<channel_type>::depth,
+           channels     = (int)(sizeof(value_type)/sizeof(channel_type)), // 7
+           fmt          = DataType<channel_type>::fmt + ((channels - 1) << 8),
+           type         = CV_MAKETYPE(depth, channels)
+         };
+
+    typedef Vec<channel_type, channels> vec_type;
+};
+
+
 inline KeyPoint::KeyPoint() : pt(0,0), size(0), angle(-1), response(0), octave(0), class_id(-1) {}
 inline KeyPoint::KeyPoint(Point2f _pt, float _size, float _angle, float _response, int _octave, int _class_id)
                 : pt(_pt), size(_size), angle(_angle), response(_response), octave(_octave), class_id(_class_id) {}
@@ -464,6 +621,26 @@ struct CV_EXPORTS_W_SIMPLE DMatch
     bool operator<(const DMatch &m) const;
 };
 
+/*!
+  traits
+*/
+template<> class DataType<DMatch>
+{
+public:
+    typedef DMatch      value_type;
+    typedef int         work_type;
+    typedef int         channel_type;
+
+    enum { generic_type = 0,
+           depth        = DataType<channel_type>::depth,
+           channels     = (int)(sizeof(value_type)/sizeof(channel_type)), // 4
+           fmt          = DataType<channel_type>::fmt + ((channels - 1) << 8),
+           type         = CV_MAKETYPE(depth, channels)
+         };
+
+    typedef Vec<channel_type, channels> vec_type;
+};
+
 inline DMatch::DMatch() : queryIdx(-1), trainIdx(-1), imgIdx(-1), distance(FLT_MAX) {}
 inline DMatch::DMatch(int _queryIdx, int _trainIdx, float _distance)
               : queryIdx(_queryIdx), trainIdx(_trainIdx), imgIdx(-1), distance(_distance) {}