generic-library/opencv
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Move most of the traits classes out of core.hpp

Browse Source
This commit is contained in:
Andrey Kamaev 2013-03-27 13:20:29 +04:00
parent 2249f19120
commit 6ceca90c44
3 changed files with 412 additions and 235 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

233
modules/core/include/opencv2/core.hpp
View File

@ -241,27 +241,6 @@ public:
/////////////////////// Vec (used as element of multi-channel images ///////////////////// /////////////////////// 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 /////////////////////////// ////////////////////////////// Small Matrix ///////////////////////////
@ -566,136 +545,6 @@ CV_EXPORTS void scalarToRawData(const Scalar& s, void* buf, int type, int unroll
/////////////////////////////// DataType //////////////////////////////// /////////////////////////////// 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> > template<typename _Tp, int m, int n> class DataType<Matx<_Tp, m, n> >
{ {
public: public:
@ -720,77 +569,6 @@ public:
type = CV_MAKETYPE(depth, channels) }; 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> > template<typename _Tp> class DataType<Scalar_<_Tp> >
{ {
@ -804,17 +582,6 @@ public:
typedef Vec<channel_type, channels> vec_type; 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 //////////////////////// //////////////////// generic_type ref-counting pointer class for C/C++ objects ////////////////////////

233
modules/core/include/opencv2/core/traits.hpp Normal file
View File

@ -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__

181
modules/core/include/opencv2/core/types.hpp
View File

@ -53,6 +53,7 @@
#include "opencv2/core/cvdef.h" #include "opencv2/core/cvdef.h"
#include "opencv2/core/cvstd.hpp" #include "opencv2/core/cvstd.hpp"
#include "opencv2/core/traits.hpp"
namespace cv namespace cv
{ {
@ -150,6 +151,43 @@ public:
typedef Complex<float> Complexf; typedef Complex<float> Complexf;
typedef Complex<double> Complexd; 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_ //////////////////////////////// //////////////////////////////// Point_ ////////////////////////////////
@ -200,6 +238,26 @@ typedef Point_<float> Point2f;
typedef Point_<double> Point2d; typedef Point_<double> Point2d;
typedef Point2i Point; 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_ //////////////////////////////// //////////////////////////////// Point3_ ////////////////////////////////
@ -247,6 +305,26 @@ typedef Point3_<int> Point3i;
typedef Point3_<float> Point3f; typedef Point3_<float> Point3f;
typedef Point3_<double> Point3d; 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_ //////////////////////////////// //////////////////////////////// Size_ ////////////////////////////////
@ -285,6 +363,26 @@ typedef Size_<int> Size2i;
typedef Size_<float> Size2f; typedef Size_<float> Size2f;
typedef Size2i Size; 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_ //////////////////////////////// //////////////////////////////// Rect_ ////////////////////////////////
@ -332,6 +430,26 @@ public:
*/ */
typedef Rect_<int> Rect; 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 ///////////////////////////// ///////////////////////////// RotatedRect /////////////////////////////
@ -374,15 +492,33 @@ class CV_EXPORTS Range
public: public:
Range(); Range();
Range(int _start, int _end); Range(int _start, int _end);
//Range(const CvSlice& slice);
int size() const; int size() const;
bool empty() const; bool empty() const;
static Range all(); static Range all();
//operator CvSlice() const;
int start, end; 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 //////////////////////////////// /////////////////////////////// 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) 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() : 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) 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) {} : 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; 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() : queryIdx(-1), trainIdx(-1), imgIdx(-1), distance(FLT_MAX) {}
inline DMatch::DMatch(int _queryIdx, int _trainIdx, float _distance) inline DMatch::DMatch(int _queryIdx, int _trainIdx, float _distance)
: queryIdx(_queryIdx), trainIdx(_trainIdx), imgIdx(-1), distance(_distance) {} : queryIdx(_queryIdx), trainIdx(_trainIdx), imgIdx(-1), distance(_distance) {}