Move cv::Size_

modules/core/include/opencv2/core.hpp

@@ -524,41 +524,6 @@ typedef Vec<double, 4> Vec4d;
 typedef Vec<double, 6> Vec6d;
 
 
-//////////////////////////////// Size_ ////////////////////////////////
-
-/*!
-  The 2D size class
-
-  The class represents the size of a 2D rectangle, image size, matrix size etc.
-  Normally, cv::Size ~ cv::Size_<int> is used.
-*/
-template<typename _Tp> class CV_EXPORTS Size_
-{
-public:
-    typedef _Tp value_type;
-
-    //! various constructors
-    Size_();
-    Size_(_Tp _width, _Tp _height);
-    Size_(const Size_& sz);
-    Size_(const CvSize& sz);
-    Size_(const CvSize2D32f& sz);
-    Size_(const Point_<_Tp>& pt);
-
-    Size_& operator = (const Size_& sz);
-    //! the area (width*height)
-    _Tp area() const;
-
-    //! conversion of another data type.
-    template<typename _Tp2> operator Size_<_Tp2>() const;
-
-    //! conversion to the old-style OpenCV types
-    operator CvSize() const;
-    operator CvSize2D32f() const;
-
-    _Tp width, height; // the width and the height
-};
-
 //////////////////////////////// Rect_ ////////////////////////////////
 
 /*!
@@ -608,10 +573,7 @@ public:
 
   shorter aliases for the most popular cv::Point_<>, cv::Size_<> and cv::Rect_<> specializations
 */
-typedef Size_<int> Size2i;
-typedef Size2i Size;
 typedef Rect_<int> Rect;
-typedef Size_<float> Size2f;
 
 
 /*!

modules/core/include/opencv2/core/operations.hpp

@@ -1754,18 +1754,10 @@ template<typename _Tp> inline Size_<_Tp>::Size_(_Tp _width, _Tp _height)
     : width(_width), height(_height) {}
 template<typename _Tp> inline Size_<_Tp>::Size_(const Size_& sz)
     : width(sz.width), height(sz.height) {}
-template<typename _Tp> inline Size_<_Tp>::Size_(const CvSize& sz)
-    : width(saturate_cast<_Tp>(sz.width)), height(saturate_cast<_Tp>(sz.height)) {}
-template<typename _Tp> inline Size_<_Tp>::Size_(const CvSize2D32f& sz)
-    : width(saturate_cast<_Tp>(sz.width)), height(saturate_cast<_Tp>(sz.height)) {}
 template<typename _Tp> inline Size_<_Tp>::Size_(const Point_<_Tp>& pt) : width(pt.x), height(pt.y) {}
 
 template<typename _Tp> template<typename _Tp2> inline Size_<_Tp>::operator Size_<_Tp2>() const
 { return Size_<_Tp2>(saturate_cast<_Tp2>(width), saturate_cast<_Tp2>(height)); }
-template<typename _Tp> inline Size_<_Tp>::operator CvSize() const
-{ return cvSize(saturate_cast<int>(width), saturate_cast<int>(height)); }
-template<typename _Tp> inline Size_<_Tp>::operator CvSize2D32f() const
-{ return cvSize2D32f((float)width, (float)height); }
 
 template<typename _Tp> inline Size_<_Tp>& Size_<_Tp>::operator = (const Size_<_Tp>& sz)
 { width = sz.width; height = sz.height; return *this; }

modules/core/include/opencv2/core/types.hpp

@@ -246,6 +246,44 @@ typedef Point3_<int> Point3i;
 typedef Point3_<float> Point3f;
 typedef Point3_<double> Point3d;
 
+
+
+//////////////////////////////// Size_ ////////////////////////////////
+
+/*!
+  The 2D size class
+
+  The class represents the size of a 2D rectangle, image size, matrix size etc.
+  Normally, cv::Size ~ cv::Size_<int> is used.
+*/
+template<typename _Tp> class CV_EXPORTS Size_
+{
+public:
+    typedef _Tp value_type;
+
+    //! various constructors
+    Size_();
+    Size_(_Tp _width, _Tp _height);
+    Size_(const Size_& sz);
+    Size_(const Point_<_Tp>& pt);
+
+    Size_& operator = (const Size_& sz);
+    //! the area (width*height)
+    _Tp area() const;
+
+    //! conversion of another data type.
+    template<typename _Tp2> operator Size_<_Tp2>() const;
+
+    _Tp width, height; // the width and the height
+};
+
+/*!
+  \typedef
+*/
+typedef Size_<int> Size2i;
+typedef Size_<float> Size2f;
+typedef Size2i Size;
+
 } // cv
 
 #endif //__OPENCV_CORE_TYPES_HPP__

modules/core/include/opencv2/core/types_c.h

@@ -894,6 +894,14 @@ typedef struct CvSize
 {
     int width;
     int height;
+
+#ifdef __cplusplus
+    CvSize(int w = 0, int h = 0): width(w), height(h) {}
+    template<typename _Tp>
+    CvSize(const cv::Size_<_Tp>& sz): width(cv::saturate_cast<int>(sz.width)), height(cv::saturate_cast<int>(sz.height)) {}
+    template<typename _Tp>
+    operator cv::Size_<_Tp>() const { return cv::Size_<_Tp>(cv::saturate_cast<_Tp>(width), cv::saturate_cast<_Tp>(height)); }
+#endif
 }
 CvSize;
 
@@ -911,6 +919,14 @@ typedef struct CvSize2D32f
 {
     float width;
     float height;
+
+#ifdef __cplusplus
+    CvSize2D32f(float w = 0, float h = 0): width(w), height(h) {}
+    template<typename _Tp>
+    CvSize2D32f(const cv::Size_<_Tp>& sz): width(cv::saturate_cast<float>(sz.width)), height(cv::saturate_cast<float>(sz.height)) {}
+    template<typename _Tp>
+    operator cv::Size_<_Tp>() const { return cv::Size_<_Tp>(cv::saturate_cast<_Tp>(width), cv::saturate_cast<_Tp>(height)); }
+#endif
 }
 CvSize2D32f;
 

modules/core/src/array.cpp

@@ -1210,7 +1210,7 @@ cvGetDimSize( const CvArr* arr, int index )
 CV_IMPL CvSize
 cvGetSize( const CvArr* arr )
 {
-    CvSize size = { 0, 0 };
+    CvSize size;
 
     if( CV_IS_MAT_HDR_Z( arr ))
     {

modules/highgui/src/utils.cpp

@@ -641,7 +641,7 @@ cvConvertImage( const CvArr* srcarr, CvArr* dstarr, int flags )
         uchar *s = src->data.ptr, *d = dst->data.ptr;
         int s_step = src->step, d_step = dst->step;
         int code = src_cn*10 + dst_cn;
-        CvSize size = { src->cols, src->rows };
+        CvSize size(src->cols, src->rows);
 
         if( CV_IS_MAT_CONT(src->type & dst->type) )
         {

modules/legacy/src/optflowbm.cpp

@@ -75,11 +75,10 @@ cvCalcOpticalFlowBM( const void* srcarrA, const void* srcarrB,
     if( !CV_ARE_TYPES_EQ( velx, vely ))
         CV_Error( CV_StsUnmatchedFormats, "Destination images have different formats" );
 
-    CvSize velSize =
+    CvSize velSize(
-    {
         (srcA->width - blockSize.width + shiftSize.width)/shiftSize.width,
         (srcA->height - blockSize.height + shiftSize.height)/shiftSize.height
-    };
+    );
 
     if( !CV_ARE_SIZES_EQ( srcA, srcB ) ||
         !CV_ARE_SIZES_EQ( velx, vely ) ||

modules/legacy/src/pyrsegmentation.cpp

@@ -287,7 +287,7 @@ icvPyrSegmentation8uC1R( uchar * src_image, int src_step,
     /* calculate initial pyramid */
     for( l = 1; l <= level; l++ )
     {
-        CvSize dst_size = { size.width/2+1, size.height/2+1 };
+        CvSize dst_size(size.width/2+1, size.height/2+1);
         CvMat prev_level = cvMat( size.height, size.width, CV_32FC1 );
         CvMat next_level = cvMat( dst_size.height, dst_size.width, CV_32FC1 );
 
@@ -706,7 +706,7 @@ icvPyrSegmentation8uC3R( uchar * src_image, int src_step,
     /* calculate initial pyramid */
     for( l = 1; l <= level; l++ )
     {
-        CvSize dst_size = { size.width/2 + 1, size.height/2 + 1 };
+        CvSize dst_size(size.width/2 + 1, size.height/2 + 1);
         CvMat prev_level = cvMat( size.height, size.width, CV_32FC3 );
         CvMat next_level = cvMat( dst_size.height, dst_size.width, CV_32FC3 );
 

modules/legacy/src/testseq.cpp

@@ -850,13 +850,13 @@ CvTestSeq* cvCreateTestSeq(char* pConfigfile, char** videos, int numvideo, float
     {   /* Calculate elements and image size and video length: */
         CvTestSeqElem*  p = pTS->pElemList;
         int             num = 0;
-        CvSize          MaxSize = {0,0};
+        CvSize          MaxSize;
         int             MaxFN = 0;
 
         for(p = pTS->pElemList; p; p=p->next, num++)
         {
             int     FN = p->FrameBegin+p->FrameNum;
-            CvSize  S = {0,0};
+            CvSize  S;
 
             if(p->pImg && p->BG)
             {

modules/legacy/src/vecfacetracking.cpp

@@ -157,7 +157,7 @@ struct CvFaceTracker
     };
     int InitNextImage(IplImage* img)
     {
-        CvSize sz = {img->width, img->height};
+        CvSize sz(img->width, img->height);
         ReallocImage(&imgGray, sz, 1);
         ReallocImage(&imgThresh, sz, 1);
         ptRotate = face[MOUTH].ptCenter;

modules/legacy/test/test_pyrsegmentation.cpp

@@ -86,7 +86,7 @@ void CV_PyrSegmentationTest::run( int /*start_from*/ )
     int i, j, iter;
 
     IplImage *image, *image_f, *image_s;
-    CvSize size = {128, 128};
+    CvSize size(128, 128);
     const int threshold1 = 50, threshold2 = 50;
 
     rect[1].width = size.width;

modules/objdetect/src/haar.cpp

@@ -1569,10 +1569,10 @@ cvHaarDetectObjectsForROC( const CvArr* _img,
 
         for( factor = 1; ; factor *= scaleFactor )
         {
-            CvSize winSize = { cvRound(winSize0.width*factor),
+            CvSize winSize(cvRound(winSize0.width*factor),
-                                cvRound(winSize0.height*factor) };
+                                cvRound(winSize0.height*factor));
-            CvSize sz = { cvRound( img->cols/factor ), cvRound( img->rows/factor ) };
+            CvSize sz(cvRound( img->cols/factor ), cvRound( img->rows/factor ));
-            CvSize sz1 = { sz.width - winSize0.width + 1, sz.height - winSize0.height + 1 };
+            CvSize sz1(sz.width - winSize0.width + 1, sz.height - winSize0.height + 1);
 
             CvRect equRect = { icv_object_win_border, icv_object_win_border,
                 winSize0.width - icv_object_win_border*2,
@@ -1656,8 +1656,8 @@ cvHaarDetectObjectsForROC( const CvArr* _img,
         for( ; n_factors-- > 0; factor *= scaleFactor )
         {
             const double ystep = std::max( 2., factor );
-            CvSize winSize = { cvRound( cascade->orig_window_size.width * factor ),
+            CvSize winSize(cvRound( cascade->orig_window_size.width * factor ),
-                                cvRound( cascade->orig_window_size.height * factor )};
+                                cvRound( cascade->orig_window_size.height * factor ));
             CvRect equRect = { 0, 0, 0, 0 };
             int *p[4] = {0,0,0,0};
             int *pq[4] = {0,0,0,0};