if( !found )
{
- CvScalar color = {{0,0,255}};
+ CvScalar color(0,0,255,0);
if( cn == 1 )
color = cvScalarAll(200);
color.val[0] *= scale;
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++ )
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;
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);
};
-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 ////////////////////////
/*!
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 );
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)
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
{
+//////////////////////////////// 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 ////////////////////////////////
/*!
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;
CV_IMPL CvScalar
cvGet1D( const CvArr* arr, int idx )
{
- CvScalar scalar = {{0,0,0,0}};
+ CvScalar scalar(0);
int type = 0;
uchar* ptr;
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;
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;
CV_IMPL CvScalar
cvGetND( const CvArr* arr, const int* idx )
{
- CvScalar scalar = {{0,0,0,0}};
+ CvScalar scalar(0);
int type = 0;
uchar* ptr;
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 )
{
{
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 )
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;
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]);
{
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 );
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);
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);