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

Move cv::Scalar_ to types.hpp

Browse Source
This commit is contained in:
Andrey Kamaev 2013-03-27 14:58:57 +04:00
parent 6ceca90c44
commit 5e7ab8baf3
13 changed files with 131 additions and 110 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
modules/calib3d/src/calibinit.cpp
View File

@ -1833,7 +1833,7 @@ cvDrawChessboardCorners( CvArr* _image, CvSize pattern_size,
if( !found )
{
CvScalar color = {{0,0,255}};
CvScalar color(0,0,255,0);
if( cn == 1 )
color = cvScalarAll(200);
color.val[0] *= scale;
@ -1860,13 +1860,13 @@ cvDrawChessboardCorners( CvArr* _image, CvSize pattern_size,
const int line_max = 7;
static const CvScalar line_colors[line_max] =
{
{{0,0,255}},
{{0,128,255}},
{{0,200,200}},
{{0,255,0}},
{{200,200,0}},
{{255,0,0}},
{{255,0,255}}
CvScalar(0,0,255),
CvScalar(0,128,255),
CvScalar(0,200,200),
CvScalar(0,255,0),
CvScalar(200,200,0),
CvScalar(255,0,0),
CvScalar(255,0,255)
};
for( y = 0, i = 0; y < pattern_size.height; y++ )

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

@ -455,8 +455,6 @@ public:
Vec cross(const Vec& v) const;
//! convertion to another data type
template<typename T2> operator Vec<T2, cn>() const;
//! conversion to 4-element CvScalar.
operator CvScalar() const;
/*! element access */
const _Tp& operator [](int i) const;
@ -503,43 +501,6 @@ typedef Vec<double, 4> Vec4d;
typedef Vec<double, 6> Vec6d;
//////////////////////////////// Scalar_ ///////////////////////////////
/*!
The template scalar class.
This is partially specialized cv::Vec class with the number of elements = 4, i.e. a short vector of four elements.
Normally, cv::Scalar ~ cv::Scalar_<double> is used.
*/
template<typename _Tp> class CV_EXPORTS Scalar_ : public Vec<_Tp, 4>
{
public:
//! various constructors
Scalar_();
Scalar_(_Tp v0, _Tp v1, _Tp v2=0, _Tp v3=0);
Scalar_(const CvScalar& s);
Scalar_(_Tp v0);
//! returns a scalar with all elements set to v0
static Scalar_<_Tp> all(_Tp v0);
//! conversion to the old-style CvScalar
operator CvScalar() const;
//! conversion to another data type
template<typename T2> operator Scalar_<T2>() const;
//! per-element product
Scalar_<_Tp> mul(const Scalar_<_Tp>& t, double scale=1 ) const;
// returns (v0, -v1, -v2, -v3)
Scalar_<_Tp> conj() const;
// returns true iff v1 == v2 == v3 == 0
bool isReal() const;
};
typedef Scalar_<double> Scalar;
CV_EXPORTS void scalarToRawData(const Scalar& s, void* buf, int type, int unroll_to=0);
@ -570,19 +531,6 @@ public:
};
template<typename _Tp> class DataType<Scalar_<_Tp> >
{
public:
typedef Scalar_<_Tp> value_type;
typedef Scalar_<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;
};
//////////////////// generic_type ref-counting pointer class for C/C++ objects ////////////////////////
/*!

20
modules/core/include/opencv2/core/operations.hpp
View File

@ -1171,15 +1171,6 @@ inline Vec<_Tp, cn>::operator Vec<T2, cn>() const
return v;
}
template<typename _Tp, int cn> inline Vec<_Tp, cn>::operator CvScalar() const
{
CvScalar s = {{0,0,0,0}};
int i;
for( i = 0; i < std::min(cn, 4); i++ ) s.val[i] = this->val[i];
for( ; i < 4; i++ ) s.val[i] = 0;
return s;
}
template<typename _Tp, int cn> inline const _Tp& Vec<_Tp, cn>::operator [](int i) const
{
CV_DbgAssert( (unsigned)i < (unsigned)cn );
@ -1894,12 +1885,11 @@ template<typename _Tp> inline Scalar_<_Tp>::Scalar_()
template<typename _Tp> inline Scalar_<_Tp>::Scalar_(_Tp v0, _Tp v1, _Tp v2, _Tp v3)
{ this->val[0] = v0; this->val[1] = v1; this->val[2] = v2; this->val[3] = v3; }
template<typename _Tp> inline Scalar_<_Tp>::Scalar_(const CvScalar& s)
template<typename _Tp> template<typename _Tp2, int cn> inline Scalar_<_Tp>::Scalar_(const Vec<_Tp2, cn>& v)
{
this->val[0] = saturate_cast<_Tp>(s.val[0]);
this->val[1] = saturate_cast<_Tp>(s.val[1]);
this->val[2] = saturate_cast<_Tp>(s.val[2]);
this->val[3] = saturate_cast<_Tp>(s.val[3]);
int i;
for( i = 0; i < (cn < 4 ? cn : 4); i++ ) this->val[i] = cv::saturate_cast<_Tp>(v.val[i]);
for( ; i < 4; i++ ) this->val[i] = 0;
}
template<typename _Tp> inline Scalar_<_Tp>::Scalar_(_Tp v0)
@ -1907,8 +1897,6 @@ template<typename _Tp> inline Scalar_<_Tp>::Scalar_(_Tp v0)
template<typename _Tp> inline Scalar_<_Tp> Scalar_<_Tp>::all(_Tp v0)
{ return Scalar_<_Tp>(v0, v0, v0, v0); }
template<typename _Tp> inline Scalar_<_Tp>::operator CvScalar() const
{ return cvScalar(this->val[0], this->val[1], this->val[2], this->val[3]); }
template<typename _Tp> template<typename T2> inline Scalar_<_Tp>::operator Scalar_<T2>() const
{

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

@ -521,6 +521,68 @@ public:
//////////////////////////////// Scalar_ ///////////////////////////////
/*!
The template scalar class.
This is partially specialized cv::Vec class with the number of elements = 4, i.e. a short vector of four elements.
Normally, cv::Scalar ~ cv::Scalar_<double> is used.
*/
template<typename _Tp> class CV_EXPORTS Scalar_ : public Vec<_Tp, 4>
{
public:
//! various constructors
Scalar_();
Scalar_(_Tp v0, _Tp v1, _Tp v2=0, _Tp v3=0);
Scalar_(_Tp v0);
template<typename _Tp2, int cn>
Scalar_(const Vec<_Tp2, cn>& v);
//! returns a scalar with all elements set to v0
static Scalar_<_Tp> all(_Tp v0);
//! conversion to another data type
template<typename T2> operator Scalar_<T2>() const;
//! per-element product
Scalar_<_Tp> mul(const Scalar_<_Tp>& t, double scale=1 ) const;
// returns (v0, -v1, -v2, -v3)
Scalar_<_Tp> conj() const;
// returns true iff v1 == v2 == v3 == 0
bool isReal() const;
};
/*!
\typedef
*/
typedef Scalar_<double> Scalar;
/*!
traits
*/
template<typename _Tp> class DataType< Scalar_<_Tp> >
{
public:
typedef Scalar_<_Tp> value_type;
typedef Scalar_<typename DataType<_Tp>::work_type> work_type;
typedef _Tp channel_type;
enum { generic_type = 0,
depth = DataType<channel_type>::value,
channels = 4,
fmt = DataType<channel_type>::fmt + ((channels - 1) << 8),
type = CV_MAKETYPE(depth, channels)
};
typedef Vec<channel_type, channels> vec_type;
};
/////////////////////////////// KeyPoint ////////////////////////////////
/*!

16
modules/core/include/opencv2/core/types_c.h
View File

@ -1014,6 +1014,22 @@ CV_INLINE CvSlice cvSlice( int start, int end )
typedef struct CvScalar
{
double val[4];
#ifdef __cplusplus
CvScalar() {}
CvScalar(double d0, double d1 = 0, double d2 = 0, double d3 = 0) { val[0] = d0; val[1] = d1; val[2] = d2; val[3] = d3; }
template<typename _Tp>
CvScalar(const cv::Scalar_<_Tp>& s) { val[0] = s.val[0]; val[1] = s.val[1]; val[2] = s.val[2]; val[3] = s.val[3]; }
template<typename _Tp>
operator cv::Scalar_<_Tp>() const { return cv::Scalar_<_Tp>(cv::saturate_cast<_Tp>(val[0]), cv::saturate_cast<_Tp>(val[1]), cv::saturate_cast<_Tp>(val[2]), cv::saturate_cast<_Tp>(val[3])); }
template<typename _Tp, int cn>
CvScalar(const cv::Vec<_Tp, cn>& v)
{
int i;
for( i = 0; i < (cn < 4 ? cn : 4); i++ ) val[i] = v.val[i];
for( ; i < 4; i++ ) val[i] = 0;
}
#endif
}
CvScalar;

8
modules/core/src/array.cpp
View File

@ -1910,7 +1910,7 @@ cvPtrND( const CvArr* arr, const int* idx, int* _type,
CV_IMPL CvScalar
cvGet1D( const CvArr* arr, int idx )
{
CvScalar scalar = {{0,0,0,0}};
CvScalar scalar(0);
int type = 0;
uchar* ptr;
@ -1945,7 +1945,7 @@ cvGet1D( const CvArr* arr, int idx )
CV_IMPL CvScalar
cvGet2D( const CvArr* arr, int y, int x )
{
CvScalar scalar = {{0,0,0,0}};
CvScalar scalar(0);
int type = 0;
uchar* ptr;
@ -1979,7 +1979,7 @@ cvGet2D( const CvArr* arr, int y, int x )
CV_IMPL CvScalar
cvGet3D( const CvArr* arr, int z, int y, int x )
{
CvScalar scalar = {{0,0,0,0}};
CvScalar scalar(0);
int type = 0;
uchar* ptr;
@ -2001,7 +2001,7 @@ cvGet3D( const CvArr* arr, int z, int y, int x )
CV_IMPL CvScalar
cvGetND( const CvArr* arr, const int* idx )
{
CvScalar scalar = {{0,0,0,0}};
CvScalar scalar(0);
int type = 0;
uchar* ptr;

2
modules/core/test/test_math.cpp
View File

@ -545,7 +545,7 @@ void Core_CrossProductTest::run_func()
void Core_CrossProductTest::prepare_to_validation( int )
{
CvScalar a = {{0,0,0,0}}, b = {{0,0,0,0}}, c = {{0,0,0,0}};
CvScalar a(0), b(0), c(0);
if( test_mat[INPUT][0].rows > 1 )
{

4
modules/imgproc/test/test_templmatch.cpp
View File

@ -192,8 +192,8 @@ static void cvTsMatchTemplate( const CvMat* img, const CvMat* templ, CvMat* resu
{
for( j = 0; j < result->cols; j++ )
{
CvScalar a_sum = {{ 0, 0, 0, 0 }}, a_sum2 = {{ 0, 0, 0, 0 }};
CvScalar ccorr = {{ 0, 0, 0, 0 }};
CvScalar a_sum(0), a_sum2(0);
CvScalar ccorr(0);
double value = 0.;
if( depth == CV_8U )

20
modules/legacy/src/3dtracker.cpp
View File

@ -322,16 +322,18 @@ static void DrawEtalon(IplImage *img, CvPoint2D32f *corners,
int i;
int x, y;
CvPoint prev_pt;
static const CvScalar rgb_colors[] = {
{{0,0,255}},
{{0,128,255}},
{{0,200,200}},
{{0,255,0}},
{{200,200,0}},
{{255,0,0}},
{{255,0,255}} };
static const CvScalar rgb_colors[] =
{
CvScalar(0,0,255),
CvScalar(0,128,255),
CvScalar(0,200,200),
CvScalar(0,255,0),
CvScalar(200,200,0),
CvScalar(255,0,0),
CvScalar(255,0,255)
};
static const CvScalar gray_colors[] = {
{{80}}, {{120}}, {{160}}, {{200}}, {{100}}, {{140}}, {{180}}
CvScalar(80), CvScalar(120), CvScalar(160), CvScalar(200), CvScalar(100), CvScalar(140), CvScalar(180)
};
const CvScalar* colors = img->nChannels == 3 ? rgb_colors : gray_colors;

14
modules/legacy/src/calibfilter.cpp
View File

@ -546,13 +546,13 @@ void CvCalibFilter::DrawPoints( CvMat** dstarr )
static const CvScalar line_colors[] =
{
{{0,0,255}},
{{0,128,255}},
{{0,200,200}},
{{0,255,0}},
{{200,200,0}},
{{255,0,0}},
{{255,0,255}}
CvScalar(0,0,255),
CvScalar(0,128,255),
CvScalar(0,200,200),
CvScalar(0,255,0),
CvScalar(200,200,0),
CvScalar(255,0,0),
CvScalar(255,0,255)
};
const int colorCount = sizeof(line_colors)/sizeof(line_colors[0]);

2
modules/legacy/src/subdiv2.cpp
View File

@ -833,7 +833,7 @@ draw_subdiv_facet( CvSubdiv2D * subdiv, IplImage * dst, IplImage * src, CvSubdiv
{
CvSubdiv2DPoint *pt = cvSubdiv2DEdgeDst( cvSubdiv2DRotateEdge( edge, 1 ));
CvPoint ip = cvPoint( cvRound( pt->pt.x ), cvRound( pt->pt.y ));
CvScalar color = {{0,0,0,0}};
CvScalar color(0);
//printf("count = %d, (%d,%d)\n", ip.x, ip.y );

5
modules/python/src2/cv2.cpp
View File

@ -684,6 +684,11 @@ static inline PyObject* pyopencv_from(const Vec3d& v)
return Py_BuildValue("(ddd)", v[0], v[1], v[2]);
}
static inline PyObject* pyopencv_from(const Vec2d& v)
{
return Py_BuildValue("(dd)", v[0], v[1]);
}
static inline PyObject* pyopencv_from(const Point2d& p)
{
return Py_BuildValue("(dd)", p.x, p.y);

20
samples/c/find_obj.cpp
View File

@ -231,17 +231,17 @@ int main(int argc, char** argv)
cvNamedWindow("Object", 1);
cvNamedWindow("Object Correspond", 1);
static CvScalar colors[] =
static cv::Scalar colors[] =
{
{{0,0,255}},
{{0,128,255}},
{{0,255,255}},
{{0,255,0}},
{{255,128,0}},
{{255,255,0}},
{{255,0,0}},
{{255,0,255}},
{{255,255,255}}
cv::Scalar(0,0,255),
cv::Scalar(0,128,255),
cv::Scalar(0,255,255),
cv::Scalar(0,255,0),
cv::Scalar(255,128,0),
cv::Scalar(255,255,0),
cv::Scalar(255,0,0),
cv::Scalar(255,0,255),
cv::Scalar(255,255,255)
};
IplImage* object_color = cvCreateImage(cvGetSize(object), 8, 3);