diff --git a/apps/traincascade/imagestorage.cpp b/apps/traincascade/imagestorage.cpp index 53fddcc0da..a8426e074d 100644 --- a/apps/traincascade/imagestorage.cpp +++ b/apps/traincascade/imagestorage.cpp @@ -1,6 +1,7 @@ #include "opencv2/core.hpp" +#include "opencv2/imgproc.hpp" +#include "opencv2/highgui.hpp" -#include "cv.h" #include "imagestorage.h" #include #include diff --git a/include/opencv/cv.h b/include/opencv/cv.h index d239643b84..ce0d4e20f8 100644 --- a/include/opencv/cv.h +++ b/include/opencv/cv.h @@ -62,7 +62,6 @@ #include "opencv2/core/core_c.h" #include "opencv2/imgproc/imgproc_c.h" -#include "opencv2/imgproc.hpp" #include "opencv2/video.hpp" #include "opencv2/features2d.hpp" #include "opencv2/flann.hpp" diff --git a/include/opencv/cv.hpp b/include/opencv/cv.hpp index 6654dea562..f1c5a1d275 100644 --- a/include/opencv/cv.hpp +++ b/include/opencv/cv.hpp @@ -49,5 +49,7 @@ #include "cv.h" #include "opencv2/core.hpp" +#include "opencv2/imgproc.hpp" +#include "opencv2/highgui.hpp" #endif diff --git a/include/opencv/cvaux.h b/include/opencv/cvaux.h index 62c91dab4b..6f8077b949 100644 --- a/include/opencv/cvaux.h +++ b/include/opencv/cvaux.h @@ -48,7 +48,6 @@ #include "opencv2/core/core_c.h" #include "opencv2/imgproc/imgproc_c.h" -#include "opencv2/imgproc.hpp" #include "opencv2/video.hpp" #include "opencv2/features2d.hpp" #include "opencv2/calib3d.hpp" diff --git a/include/opencv/highgui.h b/include/opencv/highgui.h index 229436a75a..0261029c09 100644 --- a/include/opencv/highgui.h +++ b/include/opencv/highgui.h @@ -44,6 +44,5 @@ #include "opencv2/core/core_c.h" #include "opencv2/highgui/highgui_c.h" -#include "opencv2/highgui.hpp" #endif diff --git a/modules/gpu/perf/perf_imgproc.cpp b/modules/gpu/perf/perf_imgproc.cpp index eff2bfcf2e..8a8e604771 100644 --- a/modules/gpu/perf/perf_imgproc.cpp +++ b/modules/gpu/perf/perf_imgproc.cpp @@ -1815,12 +1815,17 @@ PERF_TEST_P(Sz_Dp_MinDist, ImgProc_HoughCircles, ////////////////////////////////////////////////////////////////////// // GeneralizedHough -CV_FLAGS(GHMethod, cv::GHT_POSITION, cv::GHT_SCALE, cv::GHT_ROTATION); +enum { GHT_POSITION = cv::GeneralizedHough::GHT_POSITION, + GHT_SCALE = cv::GeneralizedHough::GHT_SCALE, + GHT_ROTATION = cv::GeneralizedHough::GHT_ROTATION + }; + +CV_FLAGS(GHMethod, GHT_POSITION, GHT_SCALE, GHT_ROTATION); DEF_PARAM_TEST(Method_Sz, GHMethod, cv::Size); PERF_TEST_P(Method_Sz, ImgProc_GeneralizedHough, - Combine(Values(GHMethod(cv::GHT_POSITION), GHMethod(cv::GHT_POSITION | cv::GHT_SCALE), GHMethod(cv::GHT_POSITION | cv::GHT_ROTATION), GHMethod(cv::GHT_POSITION | cv::GHT_SCALE | cv::GHT_ROTATION)), + Combine(Values(GHMethod(GHT_POSITION), GHMethod(GHT_POSITION | GHT_SCALE), GHMethod(GHT_POSITION | GHT_ROTATION), GHMethod(GHT_POSITION | GHT_SCALE | GHT_ROTATION)), GPU_TYPICAL_MAT_SIZES)) { declare.time(10); @@ -1870,7 +1875,7 @@ PERF_TEST_P(Method_Sz, ImgProc_GeneralizedHough, cv::gpu::GpuMat posAndVotes; cv::Ptr d_hough = cv::gpu::GeneralizedHough_GPU::create(method); - if (method & cv::GHT_ROTATION) + if (method & GHT_ROTATION) { d_hough->set("maxAngle", 90.0); d_hough->set("angleStep", 2.0); @@ -1888,7 +1893,7 @@ PERF_TEST_P(Method_Sz, ImgProc_GeneralizedHough, cv::Mat positions; cv::Ptr hough = cv::GeneralizedHough::create(method); - if (method & cv::GHT_ROTATION) + if (method & GHT_ROTATION) { hough->set("maxAngle", 90.0); hough->set("angleStep", 2.0); diff --git a/modules/imgproc/include/opencv2/imgproc.hpp b/modules/imgproc/include/opencv2/imgproc.hpp index 8747a30116..16827201f8 100644 --- a/modules/imgproc/include/opencv2/imgproc.hpp +++ b/modules/imgproc/include/opencv2/imgproc.hpp @@ -43,10 +43,6 @@ #ifndef __OPENCV_IMGPROC_HPP__ #define __OPENCV_IMGPROC_HPP__ -#include "opencv2/imgproc/types_c.h" - -#ifdef __cplusplus - #include "opencv2/core.hpp" /*! \namespace cv @@ -55,15 +51,426 @@ namespace cv { -//! various border interpolation methods -enum { BORDER_REPLICATE=IPL_BORDER_REPLICATE, BORDER_CONSTANT=IPL_BORDER_CONSTANT, - BORDER_REFLECT=IPL_BORDER_REFLECT, BORDER_WRAP=IPL_BORDER_WRAP, - BORDER_REFLECT_101=IPL_BORDER_REFLECT_101, BORDER_REFLECT101=BORDER_REFLECT_101, - BORDER_TRANSPARENT=IPL_BORDER_TRANSPARENT, - BORDER_DEFAULT=BORDER_REFLECT_101, BORDER_ISOLATED=16 }; +//! Various border types, image boundaries are denoted with '|' +enum { + BORDER_CONSTANT = 0, // iiiiii|abcdefgh|iiiiiii with some specified 'i' + BORDER_REPLICATE = 1, // aaaaaa|abcdefgh|hhhhhhh + BORDER_REFLECT = 2, // fedcba|abcdefgh|hgfedcb + BORDER_WRAP = 3, // cdefgh|abcdefgh|abcdefg + BORDER_REFLECT_101 = 4, // gfedcb|abcdefgh|gfedcba + BORDER_TRANSPARENT = 5, // uvwxyz|absdefgh|ijklmno + + BORDER_REFLECT101 = BORDER_REFLECT_101, + BORDER_DEFAULT = BORDER_REFLECT_101, + BORDER_ISOLATED = 16 // do not look outside of ROI + }; + +//! type of the kernel +enum { KERNEL_GENERAL = 0, // the kernel is generic. No any type of symmetry or other properties. + KERNEL_SYMMETRICAL = 1, // kernel[i] == kernel[ksize-i-1] , and the anchor is at the center + KERNEL_ASYMMETRICAL = 2, // kernel[i] == -kernel[ksize-i-1] , and the anchor is at the center + KERNEL_SMOOTH = 4, // all the kernel elements are non-negative and summed to 1 + KERNEL_INTEGER = 8 // all the kernel coefficients are integer numbers + }; + +//! type of morphological operation +enum { MORPH_ERODE = 0, + MORPH_DILATE = 1, + MORPH_OPEN = 2, + MORPH_CLOSE = 3, + MORPH_GRADIENT = 4, + MORPH_TOPHAT = 5, + MORPH_BLACKHAT = 6 + }; + +//! shape of the structuring element +enum { MORPH_RECT = 0, + MORPH_CROSS = 1, + MORPH_ELLIPSE = 2 + }; + +//! interpolation algorithm +enum { INTER_NEAREST = 0, //!< nearest neighbor interpolation + INTER_LINEAR = 1, //!< bilinear interpolation + INTER_CUBIC = 2, //!< bicubic interpolation + INTER_AREA = 3, //!< area-based (or super) interpolation + INTER_LANCZOS4 = 4, //!< Lanczos interpolation over 8x8 neighborhood + + INTER_MAX = 7, //!< mask for interpolation codes + WARP_INVERSE_MAP = 16 + }; + +enum { INTER_BITS = 5, + INTER_BITS2 = INTER_BITS * 2, + INTER_TAB_SIZE = 1 << INTER_BITS, + INTER_TAB_SIZE2 = INTER_TAB_SIZE * INTER_TAB_SIZE + }; + +//! Distance types for Distance Transform and M-estimators +enum { DIST_USER = -1, // User defined distance + DIST_L1 = 1, // distance = |x1-x2| + |y1-y2| + DIST_L2 = 2, // the simple euclidean distance + DIST_C = 3, // distance = max(|x1-x2|,|y1-y2|) + DIST_L12 = 4, // L1-L2 metric: distance = 2(sqrt(1+x*x/2) - 1)) + DIST_FAIR = 5, // distance = c^2(|x|/c-log(1+|x|/c)), c = 1.3998 + DIST_WELSCH = 6, // distance = c^2/2(1-exp(-(x/c)^2)), c = 2.9846 + DIST_HUBER = 7 // distance = |x| threshold ? max_value : 0 + THRESH_BINARY_INV = 1, // value = value > threshold ? 0 : max_value + THRESH_TRUNC = 2, // value = value > threshold ? threshold : value + THRESH_TOZERO = 3, // value = value > threshold ? value : 0 + THRESH_TOZERO_INV = 4, // value = value > threshold ? 0 : value + THRESH_MASK = 7, + THRESH_OTSU = 8 // use Otsu algorithm to choose the optimal threshold value + }; + +//! adaptive threshold algorithm +enum { ADAPTIVE_THRESH_MEAN_C = 0, + ADAPTIVE_THRESH_GAUSSIAN_C = 1 + }; + +enum { PROJ_SPHERICAL_ORTHO = 0, + PROJ_SPHERICAL_EQRECT = 1 + }; + +//! class of the pixel in GrabCut algorithm +enum { GC_BGD = 0, //!< background + GC_FGD = 1, //!< foreground + GC_PR_BGD = 2, //!< most probably background + GC_PR_FGD = 3 //!< most probably foreground + }; + +//! GrabCut algorithm flags +enum { GC_INIT_WITH_RECT = 0, + GC_INIT_WITH_MASK = 1, + GC_EVAL = 2 +}; + +//! distanceTransform algorithm flags +enum { DIST_LABEL_CCOMP = 0, + DIST_LABEL_PIXEL = 1 + }; + +//! floodfill algorithm flags +enum { FLOODFILL_FIXED_RANGE = 1 << 16, + FLOODFILL_MASK_ONLY = 1 << 17 + }; + +//! type of the template matching operation +enum { TM_SQDIFF = 0, + TM_SQDIFF_NORMED = 1, + TM_CCORR = 2, + TM_CCORR_NORMED = 3, + TM_CCOEFF = 4, + TM_CCOEFF_NORMED = 5 + }; + +//! connected components algorithm output formats +enum { CC_STAT_LEFT = 0, + CC_STAT_TOP = 1, + CC_STAT_WIDTH = 2, + CC_STAT_HEIGHT = 3, + CC_STAT_AREA = 4, + CC_STAT_MAX = 5 + }; + +//! mode of the contour retrieval algorithm +enum { RETR_EXTERNAL = 0, //!< retrieve only the most external (top-level) contours + RETR_LIST = 1, //!< retrieve all the contours without any hierarchical information + RETR_CCOMP = 2, //!< retrieve the connected components (that can possibly be nested) + RETR_TREE = 3, //!< retrieve all the contours and the whole hierarchy + RETR_FLOODFILL = 4 + }; + +//! the contour approximation algorithm +enum { CHAIN_APPROX_NONE = 1, + CHAIN_APPROX_SIMPLE = 2, + CHAIN_APPROX_TC89_L1 = 3, + CHAIN_APPROX_TC89_KCOS = 4 + }; + +//! Variants of a Hough transform +enum { HOUGH_STANDARD = 0, + HOUGH_PROBABILISTIC = 1, + HOUGH_MULTI_SCALE = 2, + HOUGH_GRADIENT = 3 + }; + +//! Histogram comparison methods +enum { HISTCMP_CORREL = 0, + HISTCMP_CHISQR = 1, + HISTCMP_INTERSECT = 2, + HISTCMP_BHATTACHARYYA = 3, + HISTCMP_HELLINGER = HISTCMP_BHATTACHARYYA + }; + +//! the color conversion code +enum { COLOR_BGR2BGRA = 0, + COLOR_RGB2RGBA = COLOR_BGR2BGRA, + + COLOR_BGRA2BGR = 1, + COLOR_RGBA2RGB = COLOR_BGRA2BGR, + + COLOR_BGR2RGBA = 2, + COLOR_RGB2BGRA = COLOR_BGR2RGBA, + + COLOR_RGBA2BGR = 3, + COLOR_BGRA2RGB = COLOR_RGBA2BGR, + + COLOR_BGR2RGB = 4, + COLOR_RGB2BGR = COLOR_BGR2RGB, + + COLOR_BGRA2RGBA = 5, + COLOR_RGBA2BGRA = COLOR_BGRA2RGBA, + + COLOR_BGR2GRAY = 6, + COLOR_RGB2GRAY = 7, + COLOR_GRAY2BGR = 8, + COLOR_GRAY2RGB = COLOR_GRAY2BGR, + COLOR_GRAY2BGRA = 9, + COLOR_GRAY2RGBA = COLOR_GRAY2BGRA, + COLOR_BGRA2GRAY = 10, + COLOR_RGBA2GRAY = 11, + + COLOR_BGR2BGR565 = 12, + COLOR_RGB2BGR565 = 13, + COLOR_BGR5652BGR = 14, + COLOR_BGR5652RGB = 15, + COLOR_BGRA2BGR565 = 16, + COLOR_RGBA2BGR565 = 17, + COLOR_BGR5652BGRA = 18, + COLOR_BGR5652RGBA = 19, + + COLOR_GRAY2BGR565 = 20, + COLOR_BGR5652GRAY = 21, + + COLOR_BGR2BGR555 = 22, + COLOR_RGB2BGR555 = 23, + COLOR_BGR5552BGR = 24, + COLOR_BGR5552RGB = 25, + COLOR_BGRA2BGR555 = 26, + COLOR_RGBA2BGR555 = 27, + COLOR_BGR5552BGRA = 28, + COLOR_BGR5552RGBA = 29, + + COLOR_GRAY2BGR555 = 30, + COLOR_BGR5552GRAY = 31, + + COLOR_BGR2XYZ = 32, + COLOR_RGB2XYZ = 33, + COLOR_XYZ2BGR = 34, + COLOR_XYZ2RGB = 35, + + COLOR_BGR2YCrCb = 36, + COLOR_RGB2YCrCb = 37, + COLOR_YCrCb2BGR = 38, + COLOR_YCrCb2RGB = 39, + + COLOR_BGR2HSV = 40, + COLOR_RGB2HSV = 41, + + COLOR_BGR2Lab = 44, + COLOR_RGB2Lab = 45, + + COLOR_BGR2Luv = 50, + COLOR_RGB2Luv = 51, + COLOR_BGR2HLS = 52, + COLOR_RGB2HLS = 53, + + COLOR_HSV2BGR = 54, + COLOR_HSV2RGB = 55, + + COLOR_Lab2BGR = 56, + COLOR_Lab2RGB = 57, + COLOR_Luv2BGR = 58, + COLOR_Luv2RGB = 59, + COLOR_HLS2BGR = 60, + COLOR_HLS2RGB = 61, + + COLOR_BGR2HSV_FULL = 66, + COLOR_RGB2HSV_FULL = 67, + COLOR_BGR2HLS_FULL = 68, + COLOR_RGB2HLS_FULL = 69, + + COLOR_HSV2BGR_FULL = 70, + COLOR_HSV2RGB_FULL = 71, + COLOR_HLS2BGR_FULL = 72, + COLOR_HLS2RGB_FULL = 73, + + COLOR_LBGR2Lab = 74, + COLOR_LRGB2Lab = 75, + COLOR_LBGR2Luv = 76, + COLOR_LRGB2Luv = 77, + + COLOR_Lab2LBGR = 78, + COLOR_Lab2LRGB = 79, + COLOR_Luv2LBGR = 80, + COLOR_Luv2LRGB = 81, + + COLOR_BGR2YUV = 82, + COLOR_RGB2YUV = 83, + COLOR_YUV2BGR = 84, + COLOR_YUV2RGB = 85, + + // YUV 4:2:0 family to RGB + COLOR_YUV2RGB_NV12 = 90, + COLOR_YUV2BGR_NV12 = 91, + COLOR_YUV2RGB_NV21 = 92, + COLOR_YUV2BGR_NV21 = 93, + COLOR_YUV420sp2RGB = COLOR_YUV2RGB_NV21, + COLOR_YUV420sp2BGR = COLOR_YUV2BGR_NV21, + + COLOR_YUV2RGBA_NV12 = 94, + COLOR_YUV2BGRA_NV12 = 95, + COLOR_YUV2RGBA_NV21 = 96, + COLOR_YUV2BGRA_NV21 = 97, + COLOR_YUV420sp2RGBA = COLOR_YUV2RGBA_NV21, + COLOR_YUV420sp2BGRA = COLOR_YUV2BGRA_NV21, + + COLOR_YUV2RGB_YV12 = 98, + COLOR_YUV2BGR_YV12 = 99, + COLOR_YUV2RGB_IYUV = 100, + COLOR_YUV2BGR_IYUV = 101, + COLOR_YUV2RGB_I420 = COLOR_YUV2RGB_IYUV, + COLOR_YUV2BGR_I420 = COLOR_YUV2BGR_IYUV, + COLOR_YUV420p2RGB = COLOR_YUV2RGB_YV12, + COLOR_YUV420p2BGR = COLOR_YUV2BGR_YV12, + + COLOR_YUV2RGBA_YV12 = 102, + COLOR_YUV2BGRA_YV12 = 103, + COLOR_YUV2RGBA_IYUV = 104, + COLOR_YUV2BGRA_IYUV = 105, + COLOR_YUV2RGBA_I420 = COLOR_YUV2RGBA_IYUV, + COLOR_YUV2BGRA_I420 = COLOR_YUV2BGRA_IYUV, + COLOR_YUV420p2RGBA = COLOR_YUV2RGBA_YV12, + COLOR_YUV420p2BGRA = COLOR_YUV2BGRA_YV12, + + COLOR_YUV2GRAY_420 = 106, + COLOR_YUV2GRAY_NV21 = COLOR_YUV2GRAY_420, + COLOR_YUV2GRAY_NV12 = COLOR_YUV2GRAY_420, + COLOR_YUV2GRAY_YV12 = COLOR_YUV2GRAY_420, + COLOR_YUV2GRAY_IYUV = COLOR_YUV2GRAY_420, + COLOR_YUV2GRAY_I420 = COLOR_YUV2GRAY_420, + COLOR_YUV420sp2GRAY = COLOR_YUV2GRAY_420, + COLOR_YUV420p2GRAY = COLOR_YUV2GRAY_420, + + // YUV 4:2:2 family to RGB + COLOR_YUV2RGB_UYVY = 107, + COLOR_YUV2BGR_UYVY = 108, + //COLOR_YUV2RGB_VYUY = 109, + //COLOR_YUV2BGR_VYUY = 110, + COLOR_YUV2RGB_Y422 = COLOR_YUV2RGB_UYVY, + COLOR_YUV2BGR_Y422 = COLOR_YUV2BGR_UYVY, + COLOR_YUV2RGB_UYNV = COLOR_YUV2RGB_UYVY, + COLOR_YUV2BGR_UYNV = COLOR_YUV2BGR_UYVY, + + COLOR_YUV2RGBA_UYVY = 111, + COLOR_YUV2BGRA_UYVY = 112, + //COLOR_YUV2RGBA_VYUY = 113, + //COLOR_YUV2BGRA_VYUY = 114, + COLOR_YUV2RGBA_Y422 = COLOR_YUV2RGBA_UYVY, + COLOR_YUV2BGRA_Y422 = COLOR_YUV2BGRA_UYVY, + COLOR_YUV2RGBA_UYNV = COLOR_YUV2RGBA_UYVY, + COLOR_YUV2BGRA_UYNV = COLOR_YUV2BGRA_UYVY, + + COLOR_YUV2RGB_YUY2 = 115, + COLOR_YUV2BGR_YUY2 = 116, + COLOR_YUV2RGB_YVYU = 117, + COLOR_YUV2BGR_YVYU = 118, + COLOR_YUV2RGB_YUYV = COLOR_YUV2RGB_YUY2, + COLOR_YUV2BGR_YUYV = COLOR_YUV2BGR_YUY2, + COLOR_YUV2RGB_YUNV = COLOR_YUV2RGB_YUY2, + COLOR_YUV2BGR_YUNV = COLOR_YUV2BGR_YUY2, + + COLOR_YUV2RGBA_YUY2 = 119, + COLOR_YUV2BGRA_YUY2 = 120, + COLOR_YUV2RGBA_YVYU = 121, + COLOR_YUV2BGRA_YVYU = 122, + COLOR_YUV2RGBA_YUYV = COLOR_YUV2RGBA_YUY2, + COLOR_YUV2BGRA_YUYV = COLOR_YUV2BGRA_YUY2, + COLOR_YUV2RGBA_YUNV = COLOR_YUV2RGBA_YUY2, + COLOR_YUV2BGRA_YUNV = COLOR_YUV2BGRA_YUY2, + + COLOR_YUV2GRAY_UYVY = 123, + COLOR_YUV2GRAY_YUY2 = 124, + //CV_YUV2GRAY_VYUY = CV_YUV2GRAY_UYVY, + COLOR_YUV2GRAY_Y422 = COLOR_YUV2GRAY_UYVY, + COLOR_YUV2GRAY_UYNV = COLOR_YUV2GRAY_UYVY, + COLOR_YUV2GRAY_YVYU = COLOR_YUV2GRAY_YUY2, + COLOR_YUV2GRAY_YUYV = COLOR_YUV2GRAY_YUY2, + COLOR_YUV2GRAY_YUNV = COLOR_YUV2GRAY_YUY2, + + // alpha premultiplication + COLOR_RGBA2mRGBA = 125, + COLOR_mRGBA2RGBA = 126, + + // RGB to YUV 4:2:0 family + COLOR_RGB2YUV_I420 = 127, + COLOR_BGR2YUV_I420 = 128, + COLOR_RGB2YUV_IYUV = COLOR_RGB2YUV_I420, + COLOR_BGR2YUV_IYUV = COLOR_BGR2YUV_I420, + + COLOR_RGBA2YUV_I420 = 129, + COLOR_BGRA2YUV_I420 = 130, + COLOR_RGBA2YUV_IYUV = COLOR_RGBA2YUV_I420, + COLOR_BGRA2YUV_IYUV = COLOR_BGRA2YUV_I420, + COLOR_RGB2YUV_YV12 = 131, + COLOR_BGR2YUV_YV12 = 132, + COLOR_RGBA2YUV_YV12 = 133, + COLOR_BGRA2YUV_YV12 = 134, + + // Demosaicing + COLOR_BayerBG2BGR = 46, + COLOR_BayerGB2BGR = 47, + COLOR_BayerRG2BGR = 48, + COLOR_BayerGR2BGR = 49, + + COLOR_BayerBG2RGB = COLOR_BayerRG2BGR, + COLOR_BayerGB2RGB = COLOR_BayerGR2BGR, + COLOR_BayerRG2RGB = COLOR_BayerBG2BGR, + COLOR_BayerGR2RGB = COLOR_BayerGB2BGR, + + COLOR_BayerBG2GRAY = 86, + COLOR_BayerGB2GRAY = 87, + COLOR_BayerRG2GRAY = 88, + COLOR_BayerGR2GRAY = 89, + + // Demosaicing using Variable Number of Gradients + COLOR_BayerBG2BGR_VNG = 62, + COLOR_BayerGB2BGR_VNG = 63, + COLOR_BayerRG2BGR_VNG = 64, + COLOR_BayerGR2BGR_VNG = 65, + + COLOR_BayerBG2RGB_VNG = COLOR_BayerRG2BGR_VNG, + COLOR_BayerGB2RGB_VNG = COLOR_BayerGR2BGR_VNG, + COLOR_BayerRG2RGB_VNG = COLOR_BayerBG2BGR_VNG, + COLOR_BayerGR2RGB_VNG = COLOR_BayerGB2BGR_VNG, + + // Edge-Aware Demosaicing + COLOR_BayerBG2BGR_EA = 135, + COLOR_BayerGB2BGR_EA = 136, + COLOR_BayerRG2BGR_EA = 137, + COLOR_BayerGR2BGR_EA = 138, + + COLOR_BayerBG2RGB_EA = COLOR_BayerRG2BGR_EA, + COLOR_BayerGB2RGB_EA = COLOR_BayerGR2BGR_EA, + COLOR_BayerRG2RGB_EA = COLOR_BayerBG2BGR_EA, + COLOR_BayerGR2RGB_EA = COLOR_BayerGB2BGR_EA, + + + COLOR_COLORCVT_MAX = 139 +}; + -//! 1D interpolation function: returns coordinate of the "donor" pixel for the specified location p. -CV_EXPORTS_W int borderInterpolate( int p, int len, int borderType ); /*! The Base Class for 1D or Row-wise Filters @@ -82,9 +489,10 @@ public: //! the destructor virtual ~BaseRowFilter(); //! the filtering operator. Must be overrided in the derived classes. The horizontal border interpolation is done outside of the class. - virtual void operator()(const uchar* src, uchar* dst, - int width, int cn) = 0; - int ksize, anchor; + virtual void operator()(const uchar* src, uchar* dst, int width, int cn) = 0; + + int ksize; + int anchor; }; @@ -109,13 +517,15 @@ public: //! the destructor virtual ~BaseColumnFilter(); //! the filtering operator. Must be overrided in the derived classes. The vertical border interpolation is done outside of the class. - virtual void operator()(const uchar** src, uchar* dst, int dststep, - int dstcount, int width) = 0; + virtual void operator()(const uchar** src, uchar* dst, int dststep, int dstcount, int width) = 0; //! resets the internal buffers, if any virtual void reset(); - int ksize, anchor; + + int ksize; + int anchor; }; + /*! The Base Class for Non-Separable 2D Filters. @@ -135,14 +545,15 @@ public: //! the destructor virtual ~BaseFilter(); //! the filtering operator. The horizontal and the vertical border interpolation is done outside of the class. - virtual void operator()(const uchar** src, uchar* dst, int dststep, - int dstcount, int width, int cn) = 0; + virtual void operator()(const uchar** src, uchar* dst, int dststep, int dstcount, int width, int cn) = 0; //! resets the internal buffers, if any virtual void reset(); + Size ksize; Point anchor; }; + /*! The Main Class for Image Filtering. @@ -226,9 +637,9 @@ public: const Ptr& _rowFilter, const Ptr& _columnFilter, int srcType, int dstType, int bufType, - int _rowBorderType=BORDER_REPLICATE, - int _columnBorderType=-1, - const Scalar& _borderValue=Scalar()); + int _rowBorderType = BORDER_REPLICATE, + int _columnBorderType = -1, + const Scalar& _borderValue = Scalar()); //! the destructor virtual ~FilterEngine(); //! reinitializes the engine. The previously assigned filters are released. @@ -236,42 +647,52 @@ public: const Ptr& _rowFilter, const Ptr& _columnFilter, int srcType, int dstType, int bufType, - int _rowBorderType=BORDER_REPLICATE, int _columnBorderType=-1, - const Scalar& _borderValue=Scalar()); + int _rowBorderType = BORDER_REPLICATE, + int _columnBorderType = -1, + const Scalar& _borderValue = Scalar()); //! starts filtering of the specified ROI of an image of size wholeSize. - virtual int start(Size wholeSize, Rect roi, int maxBufRows=-1); + virtual int start(Size wholeSize, Rect roi, int maxBufRows = -1); //! starts filtering of the specified ROI of the specified image. - virtual int start(const Mat& src, const Rect& srcRoi=Rect(0,0,-1,-1), - bool isolated=false, int maxBufRows=-1); + virtual int start(const Mat& src, const Rect& srcRoi = Rect(0,0,-1,-1), + bool isolated = false, int maxBufRows = -1); //! processes the next srcCount rows of the image. virtual int proceed(const uchar* src, int srcStep, int srcCount, uchar* dst, int dstStep); //! applies filter to the specified ROI of the image. if srcRoi=(0,0,-1,-1), the whole image is filtered. virtual void apply( const Mat& src, Mat& dst, - const Rect& srcRoi=Rect(0,0,-1,-1), - Point dstOfs=Point(0,0), - bool isolated=false); + const Rect& srcRoi = Rect(0,0,-1,-1), + Point dstOfs = Point(0,0), + bool isolated = false); //! returns true if the filter is separable bool isSeparable() const { return (const BaseFilter*)filter2D == 0; } //! returns the number int remainingInputRows() const; int remainingOutputRows() const; - int srcType, dstType, bufType; + int srcType; + int dstType; + int bufType; Size ksize; Point anchor; int maxWidth; Size wholeSize; Rect roi; - int dx1, dx2; - int rowBorderType, columnBorderType; + int dx1; + int dx2; + int rowBorderType; + int columnBorderType; std::vector borderTab; int borderElemSize; std::vector ringBuf; std::vector srcRow; std::vector constBorderValue; std::vector constBorderRow; - int bufStep, startY, startY0, endY, rowCount, dstY; + int bufStep; + int startY; + int startY0; + int endY; + int rowCount; + int dstY; std::vector rows; Ptr filter2D; @@ -279,219 +700,6 @@ public: Ptr columnFilter; }; -//! type of the kernel -enum { KERNEL_GENERAL=0, KERNEL_SYMMETRICAL=1, KERNEL_ASYMMETRICAL=2, - KERNEL_SMOOTH=4, KERNEL_INTEGER=8 }; - -//! returns type (one of KERNEL_*) of 1D or 2D kernel specified by its coefficients. -CV_EXPORTS int getKernelType(InputArray kernel, Point anchor); - -//! returns the primitive row filter with the specified kernel -CV_EXPORTS Ptr getLinearRowFilter(int srcType, int bufType, - InputArray kernel, int anchor, - int symmetryType); - -//! returns the primitive column filter with the specified kernel -CV_EXPORTS Ptr getLinearColumnFilter(int bufType, int dstType, - InputArray kernel, int anchor, - int symmetryType, double delta=0, - int bits=0); - -//! returns 2D filter with the specified kernel -CV_EXPORTS Ptr getLinearFilter(int srcType, int dstType, - InputArray kernel, - Point anchor=Point(-1,-1), - double delta=0, int bits=0); - -//! returns the separable linear filter engine -CV_EXPORTS Ptr createSeparableLinearFilter(int srcType, int dstType, - InputArray rowKernel, InputArray columnKernel, - Point anchor=Point(-1,-1), double delta=0, - int rowBorderType=BORDER_DEFAULT, - int columnBorderType=-1, - const Scalar& borderValue=Scalar()); - -//! returns the non-separable linear filter engine -CV_EXPORTS Ptr createLinearFilter(int srcType, int dstType, - InputArray kernel, Point _anchor=Point(-1,-1), - double delta=0, int rowBorderType=BORDER_DEFAULT, - int columnBorderType=-1, const Scalar& borderValue=Scalar()); - -//! returns the Gaussian kernel with the specified parameters -CV_EXPORTS_W Mat getGaussianKernel( int ksize, double sigma, int ktype=CV_64F ); - -//! returns the Gaussian filter engine -CV_EXPORTS Ptr createGaussianFilter( int type, Size ksize, - double sigma1, double sigma2=0, - int borderType=BORDER_DEFAULT); -//! initializes kernels of the generalized Sobel operator -CV_EXPORTS_W void getDerivKernels( OutputArray kx, OutputArray ky, - int dx, int dy, int ksize, - bool normalize=false, int ktype=CV_32F ); -//! returns filter engine for the generalized Sobel operator -CV_EXPORTS Ptr createDerivFilter( int srcType, int dstType, - int dx, int dy, int ksize, - int borderType=BORDER_DEFAULT ); -//! returns horizontal 1D box filter -CV_EXPORTS Ptr getRowSumFilter(int srcType, int sumType, - int ksize, int anchor=-1); -//! returns vertical 1D box filter -CV_EXPORTS Ptr getColumnSumFilter( int sumType, int dstType, - int ksize, int anchor=-1, - double scale=1); -//! returns box filter engine -CV_EXPORTS Ptr createBoxFilter( int srcType, int dstType, Size ksize, - Point anchor=Point(-1,-1), - bool normalize=true, - int borderType=BORDER_DEFAULT); - -//! returns the Gabor kernel with the specified parameters -CV_EXPORTS_W Mat getGaborKernel( Size ksize, double sigma, double theta, double lambd, - double gamma, double psi=CV_PI*0.5, int ktype=CV_64F ); - -//! type of morphological operation -enum { MORPH_ERODE=CV_MOP_ERODE, MORPH_DILATE=CV_MOP_DILATE, - MORPH_OPEN=CV_MOP_OPEN, MORPH_CLOSE=CV_MOP_CLOSE, - MORPH_GRADIENT=CV_MOP_GRADIENT, MORPH_TOPHAT=CV_MOP_TOPHAT, - MORPH_BLACKHAT=CV_MOP_BLACKHAT }; - -//! returns horizontal 1D morphological filter -CV_EXPORTS Ptr getMorphologyRowFilter(int op, int type, int ksize, int anchor=-1); -//! returns vertical 1D morphological filter -CV_EXPORTS Ptr getMorphologyColumnFilter(int op, int type, int ksize, int anchor=-1); -//! returns 2D morphological filter -CV_EXPORTS Ptr getMorphologyFilter(int op, int type, InputArray kernel, - Point anchor=Point(-1,-1)); - -//! returns "magic" border value for erosion and dilation. It is automatically transformed to Scalar::all(-DBL_MAX) for dilation. -static inline Scalar morphologyDefaultBorderValue() { return Scalar::all(DBL_MAX); } - -//! returns morphological filter engine. Only MORPH_ERODE and MORPH_DILATE are supported. -CV_EXPORTS Ptr createMorphologyFilter(int op, int type, InputArray kernel, - Point anchor=Point(-1,-1), int rowBorderType=BORDER_CONSTANT, - int columnBorderType=-1, - const Scalar& borderValue=morphologyDefaultBorderValue()); - -//! shape of the structuring element -enum { MORPH_RECT=0, MORPH_CROSS=1, MORPH_ELLIPSE=2 }; -//! returns structuring element of the specified shape and size -CV_EXPORTS_W Mat getStructuringElement(int shape, Size ksize, Point anchor=Point(-1,-1)); - -template<> CV_EXPORTS void Ptr::delete_obj(); - -//! copies 2D array to a larger destination array with extrapolation of the outer part of src using the specified border mode -CV_EXPORTS_W void copyMakeBorder( InputArray src, OutputArray dst, - int top, int bottom, int left, int right, - int borderType, const Scalar& value=Scalar() ); - -//! smooths the image using median filter. -CV_EXPORTS_W void medianBlur( InputArray src, OutputArray dst, int ksize ); -//! smooths the image using Gaussian filter. -CV_EXPORTS_W void GaussianBlur( InputArray src, - OutputArray dst, Size ksize, - double sigmaX, double sigmaY=0, - int borderType=BORDER_DEFAULT ); -//! smooths the image using bilateral filter -CV_EXPORTS_W void bilateralFilter( InputArray src, OutputArray dst, int d, - double sigmaColor, double sigmaSpace, - int borderType=BORDER_DEFAULT ); -//! smooths the image using the box filter. Each pixel is processed in O(1) time -CV_EXPORTS_W void boxFilter( InputArray src, OutputArray dst, int ddepth, - Size ksize, Point anchor=Point(-1,-1), - bool normalize=true, - int borderType=BORDER_DEFAULT ); -//! a synonym for normalized box filter -CV_EXPORTS_W void blur( InputArray src, OutputArray dst, - Size ksize, Point anchor=Point(-1,-1), - int borderType=BORDER_DEFAULT ); - -//! applies non-separable 2D linear filter to the image -CV_EXPORTS_W void filter2D( InputArray src, OutputArray dst, int ddepth, - InputArray kernel, Point anchor=Point(-1,-1), - double delta=0, int borderType=BORDER_DEFAULT ); - -//! applies separable 2D linear filter to the image -CV_EXPORTS_W void sepFilter2D( InputArray src, OutputArray dst, int ddepth, - InputArray kernelX, InputArray kernelY, - Point anchor=Point(-1,-1), - double delta=0, int borderType=BORDER_DEFAULT ); - -//! applies generalized Sobel operator to the image -CV_EXPORTS_W void Sobel( InputArray src, OutputArray dst, int ddepth, - int dx, int dy, int ksize=3, - double scale=1, double delta=0, - int borderType=BORDER_DEFAULT ); - -//! applies the vertical or horizontal Scharr operator to the image -CV_EXPORTS_W void Scharr( InputArray src, OutputArray dst, int ddepth, - int dx, int dy, double scale=1, double delta=0, - int borderType=BORDER_DEFAULT ); - -//! applies Laplacian operator to the image -CV_EXPORTS_W void Laplacian( InputArray src, OutputArray dst, int ddepth, - int ksize=1, double scale=1, double delta=0, - int borderType=BORDER_DEFAULT ); - -//! applies Canny edge detector and produces the edge map. -CV_EXPORTS_W void Canny( InputArray image, OutputArray edges, - double threshold1, double threshold2, - int apertureSize=3, bool L2gradient=false ); - -//! computes minimum eigen value of 2x2 derivative covariation matrix at each pixel - the cornerness criteria -CV_EXPORTS_W void cornerMinEigenVal( InputArray src, OutputArray dst, - int blockSize, int ksize=3, - int borderType=BORDER_DEFAULT ); - -//! computes Harris cornerness criteria at each image pixel -CV_EXPORTS_W void cornerHarris( InputArray src, OutputArray dst, int blockSize, - int ksize, double k, - int borderType=BORDER_DEFAULT ); - -// low-level function for computing eigenvalues and eigenvectors of 2x2 matrices -CV_EXPORTS void eigen2x2( const float* a, float* e, int n ); - -//! computes both eigenvalues and the eigenvectors of 2x2 derivative covariation matrix at each pixel. The output is stored as 6-channel matrix. -CV_EXPORTS_W void cornerEigenValsAndVecs( InputArray src, OutputArray dst, - int blockSize, int ksize, - int borderType=BORDER_DEFAULT ); - -//! computes another complex cornerness criteria at each pixel -CV_EXPORTS_W void preCornerDetect( InputArray src, OutputArray dst, int ksize, - int borderType=BORDER_DEFAULT ); - -//! adjusts the corner locations with sub-pixel accuracy to maximize the certain cornerness criteria -CV_EXPORTS_W void cornerSubPix( InputArray image, InputOutputArray corners, - Size winSize, Size zeroZone, - TermCriteria criteria ); - -//! finds the strong enough corners where the cornerMinEigenVal() or cornerHarris() report the local maxima -CV_EXPORTS_W void goodFeaturesToTrack( InputArray image, OutputArray corners, - int maxCorners, double qualityLevel, double minDistance, - InputArray mask=noArray(), int blockSize=3, - bool useHarrisDetector=false, double k=0.04 ); - -//! finds lines in the black-n-white image using the standard or pyramid Hough transform -CV_EXPORTS_W void HoughLines( InputArray image, OutputArray lines, - double rho, double theta, int threshold, - double srn=0, double stn=0 ); - -//! finds line segments in the black-n-white image using probabalistic Hough transform -CV_EXPORTS_W void HoughLinesP( InputArray image, OutputArray lines, - double rho, double theta, int threshold, - double minLineLength=0, double maxLineGap=0 ); - -//! finds circles in the grayscale image using 2+1 gradient Hough transform -CV_EXPORTS_W void HoughCircles( InputArray image, OutputArray circles, - int method, double dp, double minDist, - double param1=100, double param2=100, - int minRadius=0, int maxRadius=0 ); - -enum -{ - GHT_POSITION = 0, - GHT_SCALE = 1, - GHT_ROTATION = 2 -}; //! finds arbitrary template in the grayscale image using Generalized Hough Transform //! Ballard, D.H. (1981). Generalizing the Hough transform to detect arbitrary shapes. Pattern Recognition 13 (2): 111-122. @@ -499,6 +707,11 @@ enum class CV_EXPORTS GeneralizedHough : public Algorithm { public: + enum { GHT_POSITION = 0, + GHT_SCALE = 1, + GHT_ROTATION = 2 + }; + static Ptr create(int method); virtual ~GeneralizedHough(); @@ -519,240 +732,11 @@ protected: virtual void releaseImpl() = 0; private: - Mat edges_, dx_, dy_; + Mat edges_; + Mat dx_; + Mat dy_; }; -//! erodes the image (applies the local minimum operator) -CV_EXPORTS_W void erode( InputArray src, OutputArray dst, InputArray kernel, - Point anchor=Point(-1,-1), int iterations=1, - int borderType=BORDER_CONSTANT, - const Scalar& borderValue=morphologyDefaultBorderValue() ); - -//! dilates the image (applies the local maximum operator) -CV_EXPORTS_W void dilate( InputArray src, OutputArray dst, InputArray kernel, - Point anchor=Point(-1,-1), int iterations=1, - int borderType=BORDER_CONSTANT, - const Scalar& borderValue=morphologyDefaultBorderValue() ); - -//! applies an advanced morphological operation to the image -CV_EXPORTS_W void morphologyEx( InputArray src, OutputArray dst, - int op, InputArray kernel, - Point anchor=Point(-1,-1), int iterations=1, - int borderType=BORDER_CONSTANT, - const Scalar& borderValue=morphologyDefaultBorderValue() ); - -//! interpolation algorithm -enum -{ - INTER_NEAREST=CV_INTER_NN, //!< nearest neighbor interpolation - INTER_LINEAR=CV_INTER_LINEAR, //!< bilinear interpolation - INTER_CUBIC=CV_INTER_CUBIC, //!< bicubic interpolation - INTER_AREA=CV_INTER_AREA, //!< area-based (or super) interpolation - INTER_LANCZOS4=CV_INTER_LANCZOS4, //!< Lanczos interpolation over 8x8 neighborhood - INTER_MAX=7, - WARP_INVERSE_MAP=CV_WARP_INVERSE_MAP -}; - -//! resizes the image -CV_EXPORTS_W void resize( InputArray src, OutputArray dst, - Size dsize, double fx=0, double fy=0, - int interpolation=INTER_LINEAR ); - -//! warps the image using affine transformation -CV_EXPORTS_W void warpAffine( InputArray src, OutputArray dst, - InputArray M, Size dsize, - int flags=INTER_LINEAR, - int borderMode=BORDER_CONSTANT, - const Scalar& borderValue=Scalar()); - -//! warps the image using perspective transformation -CV_EXPORTS_W void warpPerspective( InputArray src, OutputArray dst, - InputArray M, Size dsize, - int flags=INTER_LINEAR, - int borderMode=BORDER_CONSTANT, - const Scalar& borderValue=Scalar()); - -enum -{ - INTER_BITS=5, INTER_BITS2=INTER_BITS*2, - INTER_TAB_SIZE=(1< CV_EXPORTS void Ptr::delete_obj(); - -//! computes the joint dense histogram for a set of images. -CV_EXPORTS void calcHist( const Mat* images, int nimages, - const int* channels, InputArray mask, - OutputArray hist, int dims, const int* histSize, - const float** ranges, bool uniform=true, bool accumulate=false ); - -//! computes the joint sparse histogram for a set of images. -CV_EXPORTS void calcHist( const Mat* images, int nimages, - const int* channels, InputArray mask, - SparseMat& hist, int dims, - const int* histSize, const float** ranges, - bool uniform=true, bool accumulate=false ); - -CV_EXPORTS_W void calcHist( InputArrayOfArrays images, - const std::vector& channels, - InputArray mask, OutputArray hist, - const std::vector& histSize, - const std::vector& ranges, - bool accumulate=false ); - -//! computes back projection for the set of images -CV_EXPORTS void calcBackProject( const Mat* images, int nimages, - const int* channels, InputArray hist, - OutputArray backProject, const float** ranges, - double scale=1, bool uniform=true ); - -//! computes back projection for the set of images -CV_EXPORTS void calcBackProject( const Mat* images, int nimages, - const int* channels, const SparseMat& hist, - OutputArray backProject, const float** ranges, - double scale=1, bool uniform=true ); - -CV_EXPORTS_W void calcBackProject( InputArrayOfArrays images, const std::vector& channels, - InputArray hist, OutputArray dst, - const std::vector& ranges, - double scale ); - -/*CV_EXPORTS void calcBackProjectPatch( const Mat* images, int nimages, const int* channels, - InputArray hist, OutputArray dst, Size patchSize, - int method, double factor=1 ); - -CV_EXPORTS_W void calcBackProjectPatch( InputArrayOfArrays images, const std::vector& channels, - InputArray hist, OutputArray dst, Size patchSize, - int method, double factor=1 );*/ - -//! compares two histograms stored in dense arrays -CV_EXPORTS_W double compareHist( InputArray H1, InputArray H2, int method ); - -//! compares two histograms stored in sparse arrays -CV_EXPORTS double compareHist( const SparseMat& H1, const SparseMat& H2, int method ); - -//! normalizes the grayscale image brightness and contrast by normalizing its histogram -CV_EXPORTS_W void equalizeHist( InputArray src, OutputArray dst ); class CV_EXPORTS CLAHE : public Algorithm { @@ -767,330 +751,7 @@ public: virtual void collectGarbage() = 0; }; -CV_EXPORTS Ptr createCLAHE(double clipLimit = 40.0, Size tileGridSize = Size(8, 8)); -CV_EXPORTS float EMD( InputArray signature1, InputArray signature2, - int distType, InputArray cost=noArray(), - float* lowerBound=0, OutputArray flow=noArray() ); - -//! segments the image using watershed algorithm -CV_EXPORTS_W void watershed( InputArray image, InputOutputArray markers ); - -//! filters image using meanshift algorithm -CV_EXPORTS_W void pyrMeanShiftFiltering( InputArray src, OutputArray dst, - double sp, double sr, int maxLevel=1, - TermCriteria termcrit=TermCriteria( - TermCriteria::MAX_ITER+TermCriteria::EPS,5,1) ); - -//! class of the pixel in GrabCut algorithm -enum -{ - GC_BGD = 0, //!< background - GC_FGD = 1, //!< foreground - GC_PR_BGD = 2, //!< most probably background - GC_PR_FGD = 3 //!< most probably foreground -}; - -//! GrabCut algorithm flags -enum -{ - GC_INIT_WITH_RECT = 0, - GC_INIT_WITH_MASK = 1, - GC_EVAL = 2 -}; - -//! segments the image using GrabCut algorithm -CV_EXPORTS_W void grabCut( InputArray img, InputOutputArray mask, Rect rect, - InputOutputArray bgdModel, InputOutputArray fgdModel, - int iterCount, int mode = GC_EVAL ); - -enum -{ - DIST_LABEL_CCOMP = 0, - DIST_LABEL_PIXEL = 1 -}; - -//! builds the discrete Voronoi diagram -CV_EXPORTS_AS(distanceTransformWithLabels) void distanceTransform( InputArray src, OutputArray dst, - OutputArray labels, int distanceType, int maskSize, - int labelType=DIST_LABEL_CCOMP ); - -//! computes the distance transform map -CV_EXPORTS_W void distanceTransform( InputArray src, OutputArray dst, - int distanceType, int maskSize ); - -enum { FLOODFILL_FIXED_RANGE = 1 << 16, FLOODFILL_MASK_ONLY = 1 << 17 }; - -//! fills the semi-uniform image region starting from the specified seed point -CV_EXPORTS int floodFill( InputOutputArray image, - Point seedPoint, Scalar newVal, CV_OUT Rect* rect=0, - Scalar loDiff=Scalar(), Scalar upDiff=Scalar(), - int flags=4 ); - -//! fills the semi-uniform image region and/or the mask starting from the specified seed point -CV_EXPORTS_W int floodFill( InputOutputArray image, InputOutputArray mask, - Point seedPoint, Scalar newVal, CV_OUT Rect* rect=0, - Scalar loDiff=Scalar(), Scalar upDiff=Scalar(), - int flags=4 ); - - -enum -{ - COLOR_BGR2BGRA =0, - COLOR_RGB2RGBA =COLOR_BGR2BGRA, - - COLOR_BGRA2BGR =1, - COLOR_RGBA2RGB =COLOR_BGRA2BGR, - - COLOR_BGR2RGBA =2, - COLOR_RGB2BGRA =COLOR_BGR2RGBA, - - COLOR_RGBA2BGR =3, - COLOR_BGRA2RGB =COLOR_RGBA2BGR, - - COLOR_BGR2RGB =4, - COLOR_RGB2BGR =COLOR_BGR2RGB, - - COLOR_BGRA2RGBA =5, - COLOR_RGBA2BGRA =COLOR_BGRA2RGBA, - - COLOR_BGR2GRAY =6, - COLOR_RGB2GRAY =7, - COLOR_GRAY2BGR =8, - COLOR_GRAY2RGB =COLOR_GRAY2BGR, - COLOR_GRAY2BGRA =9, - COLOR_GRAY2RGBA =COLOR_GRAY2BGRA, - COLOR_BGRA2GRAY =10, - COLOR_RGBA2GRAY =11, - - COLOR_BGR2BGR565 =12, - COLOR_RGB2BGR565 =13, - COLOR_BGR5652BGR =14, - COLOR_BGR5652RGB =15, - COLOR_BGRA2BGR565 =16, - COLOR_RGBA2BGR565 =17, - COLOR_BGR5652BGRA =18, - COLOR_BGR5652RGBA =19, - - COLOR_GRAY2BGR565 =20, - COLOR_BGR5652GRAY =21, - - COLOR_BGR2BGR555 =22, - COLOR_RGB2BGR555 =23, - COLOR_BGR5552BGR =24, - COLOR_BGR5552RGB =25, - COLOR_BGRA2BGR555 =26, - COLOR_RGBA2BGR555 =27, - COLOR_BGR5552BGRA =28, - COLOR_BGR5552RGBA =29, - - COLOR_GRAY2BGR555 =30, - COLOR_BGR5552GRAY =31, - - COLOR_BGR2XYZ =32, - COLOR_RGB2XYZ =33, - COLOR_XYZ2BGR =34, - COLOR_XYZ2RGB =35, - - COLOR_BGR2YCrCb =36, - COLOR_RGB2YCrCb =37, - COLOR_YCrCb2BGR =38, - COLOR_YCrCb2RGB =39, - - COLOR_BGR2HSV =40, - COLOR_RGB2HSV =41, - - COLOR_BGR2Lab =44, - COLOR_RGB2Lab =45, - - COLOR_BayerBG2BGR =46, - COLOR_BayerGB2BGR =47, - COLOR_BayerRG2BGR =48, - COLOR_BayerGR2BGR =49, - - COLOR_BayerBG2RGB =COLOR_BayerRG2BGR, - COLOR_BayerGB2RGB =COLOR_BayerGR2BGR, - COLOR_BayerRG2RGB =COLOR_BayerBG2BGR, - COLOR_BayerGR2RGB =COLOR_BayerGB2BGR, - - COLOR_BGR2Luv =50, - COLOR_RGB2Luv =51, - COLOR_BGR2HLS =52, - COLOR_RGB2HLS =53, - - COLOR_HSV2BGR =54, - COLOR_HSV2RGB =55, - - COLOR_Lab2BGR =56, - COLOR_Lab2RGB =57, - COLOR_Luv2BGR =58, - COLOR_Luv2RGB =59, - COLOR_HLS2BGR =60, - COLOR_HLS2RGB =61, - - COLOR_BayerBG2BGR_VNG =62, - COLOR_BayerGB2BGR_VNG =63, - COLOR_BayerRG2BGR_VNG =64, - COLOR_BayerGR2BGR_VNG =65, - - COLOR_BayerBG2RGB_VNG =COLOR_BayerRG2BGR_VNG, - COLOR_BayerGB2RGB_VNG =COLOR_BayerGR2BGR_VNG, - COLOR_BayerRG2RGB_VNG =COLOR_BayerBG2BGR_VNG, - COLOR_BayerGR2RGB_VNG =COLOR_BayerGB2BGR_VNG, - - COLOR_BGR2HSV_FULL = 66, - COLOR_RGB2HSV_FULL = 67, - COLOR_BGR2HLS_FULL = 68, - COLOR_RGB2HLS_FULL = 69, - - COLOR_HSV2BGR_FULL = 70, - COLOR_HSV2RGB_FULL = 71, - COLOR_HLS2BGR_FULL = 72, - COLOR_HLS2RGB_FULL = 73, - - COLOR_LBGR2Lab = 74, - COLOR_LRGB2Lab = 75, - COLOR_LBGR2Luv = 76, - COLOR_LRGB2Luv = 77, - - COLOR_Lab2LBGR = 78, - COLOR_Lab2LRGB = 79, - COLOR_Luv2LBGR = 80, - COLOR_Luv2LRGB = 81, - - COLOR_BGR2YUV = 82, - COLOR_RGB2YUV = 83, - COLOR_YUV2BGR = 84, - COLOR_YUV2RGB = 85, - - COLOR_BayerBG2GRAY = 86, - COLOR_BayerGB2GRAY = 87, - COLOR_BayerRG2GRAY = 88, - COLOR_BayerGR2GRAY = 89, - - //YUV 4:2:0 formats family - COLOR_YUV2RGB_NV12 = 90, - COLOR_YUV2BGR_NV12 = 91, - COLOR_YUV2RGB_NV21 = 92, - COLOR_YUV2BGR_NV21 = 93, - COLOR_YUV420sp2RGB = COLOR_YUV2RGB_NV21, - COLOR_YUV420sp2BGR = COLOR_YUV2BGR_NV21, - - COLOR_YUV2RGBA_NV12 = 94, - COLOR_YUV2BGRA_NV12 = 95, - COLOR_YUV2RGBA_NV21 = 96, - COLOR_YUV2BGRA_NV21 = 97, - COLOR_YUV420sp2RGBA = COLOR_YUV2RGBA_NV21, - COLOR_YUV420sp2BGRA = COLOR_YUV2BGRA_NV21, - - COLOR_YUV2RGB_YV12 = 98, - COLOR_YUV2BGR_YV12 = 99, - COLOR_YUV2RGB_IYUV = 100, - COLOR_YUV2BGR_IYUV = 101, - COLOR_YUV2RGB_I420 = COLOR_YUV2RGB_IYUV, - COLOR_YUV2BGR_I420 = COLOR_YUV2BGR_IYUV, - COLOR_YUV420p2RGB = COLOR_YUV2RGB_YV12, - COLOR_YUV420p2BGR = COLOR_YUV2BGR_YV12, - - COLOR_YUV2RGBA_YV12 = 102, - COLOR_YUV2BGRA_YV12 = 103, - COLOR_YUV2RGBA_IYUV = 104, - COLOR_YUV2BGRA_IYUV = 105, - COLOR_YUV2RGBA_I420 = COLOR_YUV2RGBA_IYUV, - COLOR_YUV2BGRA_I420 = COLOR_YUV2BGRA_IYUV, - COLOR_YUV420p2RGBA = COLOR_YUV2RGBA_YV12, - COLOR_YUV420p2BGRA = COLOR_YUV2BGRA_YV12, - - COLOR_YUV2GRAY_420 = 106, - COLOR_YUV2GRAY_NV21 = COLOR_YUV2GRAY_420, - COLOR_YUV2GRAY_NV12 = COLOR_YUV2GRAY_420, - COLOR_YUV2GRAY_YV12 = COLOR_YUV2GRAY_420, - COLOR_YUV2GRAY_IYUV = COLOR_YUV2GRAY_420, - COLOR_YUV2GRAY_I420 = COLOR_YUV2GRAY_420, - COLOR_YUV420sp2GRAY = COLOR_YUV2GRAY_420, - COLOR_YUV420p2GRAY = COLOR_YUV2GRAY_420, - - //YUV 4:2:2 formats family - COLOR_YUV2RGB_UYVY = 107, - COLOR_YUV2BGR_UYVY = 108, - //COLOR_YUV2RGB_VYUY = 109, - //COLOR_YUV2BGR_VYUY = 110, - COLOR_YUV2RGB_Y422 = COLOR_YUV2RGB_UYVY, - COLOR_YUV2BGR_Y422 = COLOR_YUV2BGR_UYVY, - COLOR_YUV2RGB_UYNV = COLOR_YUV2RGB_UYVY, - COLOR_YUV2BGR_UYNV = COLOR_YUV2BGR_UYVY, - - COLOR_YUV2RGBA_UYVY = 111, - COLOR_YUV2BGRA_UYVY = 112, - //COLOR_YUV2RGBA_VYUY = 113, - //COLOR_YUV2BGRA_VYUY = 114, - COLOR_YUV2RGBA_Y422 = COLOR_YUV2RGBA_UYVY, - COLOR_YUV2BGRA_Y422 = COLOR_YUV2BGRA_UYVY, - COLOR_YUV2RGBA_UYNV = COLOR_YUV2RGBA_UYVY, - COLOR_YUV2BGRA_UYNV = COLOR_YUV2BGRA_UYVY, - - COLOR_YUV2RGB_YUY2 = 115, - COLOR_YUV2BGR_YUY2 = 116, - COLOR_YUV2RGB_YVYU = 117, - COLOR_YUV2BGR_YVYU = 118, - COLOR_YUV2RGB_YUYV = COLOR_YUV2RGB_YUY2, - COLOR_YUV2BGR_YUYV = COLOR_YUV2BGR_YUY2, - COLOR_YUV2RGB_YUNV = COLOR_YUV2RGB_YUY2, - COLOR_YUV2BGR_YUNV = COLOR_YUV2BGR_YUY2, - - COLOR_YUV2RGBA_YUY2 = 119, - COLOR_YUV2BGRA_YUY2 = 120, - COLOR_YUV2RGBA_YVYU = 121, - COLOR_YUV2BGRA_YVYU = 122, - COLOR_YUV2RGBA_YUYV = COLOR_YUV2RGBA_YUY2, - COLOR_YUV2BGRA_YUYV = COLOR_YUV2BGRA_YUY2, - COLOR_YUV2RGBA_YUNV = COLOR_YUV2RGBA_YUY2, - COLOR_YUV2BGRA_YUNV = COLOR_YUV2BGRA_YUY2, - - COLOR_YUV2GRAY_UYVY = 123, - COLOR_YUV2GRAY_YUY2 = 124, - //COLOR_YUV2GRAY_VYUY = COLOR_YUV2GRAY_UYVY, - COLOR_YUV2GRAY_Y422 = COLOR_YUV2GRAY_UYVY, - COLOR_YUV2GRAY_UYNV = COLOR_YUV2GRAY_UYVY, - COLOR_YUV2GRAY_YVYU = COLOR_YUV2GRAY_YUY2, - COLOR_YUV2GRAY_YUYV = COLOR_YUV2GRAY_YUY2, - COLOR_YUV2GRAY_YUNV = COLOR_YUV2GRAY_YUY2, - - // alpha premultiplication - COLOR_RGBA2mRGBA = 125, - COLOR_mRGBA2RGBA = 126, - - COLOR_RGB2YUV_I420 = 127, - COLOR_BGR2YUV_I420 = 128, - COLOR_RGB2YUV_IYUV = COLOR_RGB2YUV_I420, - COLOR_BGR2YUV_IYUV = COLOR_BGR2YUV_I420, - - COLOR_RGBA2YUV_I420 = 129, - COLOR_BGRA2YUV_I420 = 130, - COLOR_RGBA2YUV_IYUV = COLOR_RGBA2YUV_I420, - COLOR_BGRA2YUV_IYUV = COLOR_BGRA2YUV_I420, - COLOR_RGB2YUV_YV12 = 131, - COLOR_BGR2YUV_YV12 = 132, - COLOR_RGBA2YUV_YV12 = 133, - COLOR_BGRA2YUV_YV12 = 134, - - // Edge-Aware Demosaicing - COLOR_BayerBG2BGR_EA = 135, - COLOR_BayerGB2BGR_EA = 136, - COLOR_BayerRG2BGR_EA = 137, - COLOR_BayerGR2BGR_EA = 138, - - COLOR_BayerBG2RGB_EA = COLOR_BayerRG2BGR_EA, - COLOR_BayerGB2RGB_EA = COLOR_BayerGR2BGR_EA, - COLOR_BayerRG2RGB_EA = COLOR_BayerBG2BGR_EA, - COLOR_BayerGR2RGB_EA = COLOR_BayerGB2BGR_EA, - - COLOR_COLORCVT_MAX = 139 -}; - - -//! converts image from one color space to another -CV_EXPORTS_W void cvtColor( InputArray src, OutputArray dst, int code, int dstCn=0 ); //! raster image moments class CV_EXPORTS_W_MAP Moments @@ -1101,10 +762,10 @@ public: //! the full constructor Moments(double m00, double m10, double m01, double m20, double m11, double m02, double m30, double m21, double m12, double m03 ); - //! the conversion from CvMoments - Moments( const CvMoments& moments ); - //! the conversion to CvMoments - operator CvMoments() const; + ////! the conversion from CvMoments + //Moments( const CvMoments& moments ); + ////! the conversion to CvMoments + //operator CvMoments() const; //! spatial moments CV_PROP_RW double m00, m10, m01, m20, m11, m02, m30, m21, m12, m03; @@ -1114,127 +775,26 @@ public: CV_PROP_RW double nu20, nu11, nu02, nu30, nu21, nu12, nu03; }; -//! computes moments of the rasterized shape or a vector of points -CV_EXPORTS_W Moments moments( InputArray array, bool binaryImage=false ); - -//! computes 7 Hu invariants from the moments -CV_EXPORTS void HuMoments( const Moments& moments, double hu[7] ); -CV_EXPORTS_W void HuMoments( const Moments& m, OutputArray hu ); - -//! type of the template matching operation -enum { TM_SQDIFF=0, TM_SQDIFF_NORMED=1, TM_CCORR=2, TM_CCORR_NORMED=3, TM_CCOEFF=4, TM_CCOEFF_NORMED=5 }; - -//! computes the proximity map for the raster template and the image where the template is searched for -CV_EXPORTS_W void matchTemplate( InputArray image, InputArray templ, - OutputArray result, int method ); - -enum { CC_STAT_LEFT=0, CC_STAT_TOP=1, CC_STAT_WIDTH=2, CC_STAT_HEIGHT=3, CC_STAT_AREA=4, CC_STAT_MAX = 5}; - -// computes the connected components labeled image of boolean image ``image`` -// with 4 or 8 way connectivity - returns N, the total -// number of labels [0, N-1] where 0 represents the background label. -// ltype specifies the output label image type, an important -// consideration based on the total number of labels or -// alternatively the total number of pixels in the source image. -CV_EXPORTS_W int connectedComponents(InputArray image, OutputArray labels, - int connectivity = 8, int ltype=CV_32S); -CV_EXPORTS_W int connectedComponentsWithStats(InputArray image, OutputArray labels, - OutputArray stats, OutputArray centroids, - int connectivity = 8, int ltype=CV_32S); - -//! mode of the contour retrieval algorithm -enum -{ - RETR_EXTERNAL=CV_RETR_EXTERNAL, //!< retrieve only the most external (top-level) contours - RETR_LIST=CV_RETR_LIST, //!< retrieve all the contours without any hierarchical information - RETR_CCOMP=CV_RETR_CCOMP, //!< retrieve the connected components (that can possibly be nested) - RETR_TREE=CV_RETR_TREE, //!< retrieve all the contours and the whole hierarchy - RETR_FLOODFILL=CV_RETR_FLOODFILL -}; - -//! the contour approximation algorithm -enum -{ - CHAIN_APPROX_NONE=CV_CHAIN_APPROX_NONE, - CHAIN_APPROX_SIMPLE=CV_CHAIN_APPROX_SIMPLE, - CHAIN_APPROX_TC89_L1=CV_CHAIN_APPROX_TC89_L1, - CHAIN_APPROX_TC89_KCOS=CV_CHAIN_APPROX_TC89_KCOS -}; - -//! retrieves contours and the hierarchical information from black-n-white image. -CV_EXPORTS_W void findContours( InputOutputArray image, OutputArrayOfArrays contours, - OutputArray hierarchy, int mode, - int method, Point offset=Point()); - -//! retrieves contours from black-n-white image. -CV_EXPORTS void findContours( InputOutputArray image, OutputArrayOfArrays contours, - int mode, int method, Point offset=Point()); - -//! approximates contour or a curve using Douglas-Peucker algorithm -CV_EXPORTS_W void approxPolyDP( InputArray curve, - OutputArray approxCurve, - double epsilon, bool closed ); - -//! computes the contour perimeter (closed=true) or a curve length -CV_EXPORTS_W double arcLength( InputArray curve, bool closed ); -//! computes the bounding rectangle for a contour -CV_EXPORTS_W Rect boundingRect( InputArray points ); -//! computes the contour area -CV_EXPORTS_W double contourArea( InputArray contour, bool oriented=false ); -//! computes the minimal rotated rectangle for a set of points -CV_EXPORTS_W RotatedRect minAreaRect( InputArray points ); -//! computes the minimal enclosing circle for a set of points -CV_EXPORTS_W void minEnclosingCircle( InputArray points, - CV_OUT Point2f& center, CV_OUT float& radius ); -//! matches two contours using one of the available algorithms -CV_EXPORTS_W double matchShapes( InputArray contour1, InputArray contour2, - int method, double parameter ); -//! computes convex hull for a set of 2D points. -CV_EXPORTS_W void convexHull( InputArray points, OutputArray hull, - bool clockwise=false, bool returnPoints=true ); -//! computes the contour convexity defects -CV_EXPORTS_W void convexityDefects( InputArray contour, InputArray convexhull, OutputArray convexityDefects ); - -//! returns true if the contour is convex. Does not support contours with self-intersection -CV_EXPORTS_W bool isContourConvex( InputArray contour ); - -//! finds intersection of two convex polygons -CV_EXPORTS_W float intersectConvexConvex( InputArray _p1, InputArray _p2, - OutputArray _p12, bool handleNested=true ); - -//! fits ellipse to the set of 2D points -CV_EXPORTS_W RotatedRect fitEllipse( InputArray points ); - -//! fits line to the set of 2D points using M-estimator algorithm -CV_EXPORTS_W void fitLine( InputArray points, OutputArray line, int distType, - double param, double reps, double aeps ); -//! checks if the point is inside the contour. Optionally computes the signed distance from the point to the contour boundary -CV_EXPORTS_W double pointPolygonTest( InputArray contour, Point2f pt, bool measureDist ); - class CV_EXPORTS_W Subdiv2D { public: - enum - { - PTLOC_ERROR = -2, - PTLOC_OUTSIDE_RECT = -1, - PTLOC_INSIDE = 0, - PTLOC_VERTEX = 1, - PTLOC_ON_EDGE = 2 - }; + enum { PTLOC_ERROR = -2, + PTLOC_OUTSIDE_RECT = -1, + PTLOC_INSIDE = 0, + PTLOC_VERTEX = 1, + PTLOC_ON_EDGE = 2 + }; - enum - { - NEXT_AROUND_ORG = 0x00, - NEXT_AROUND_DST = 0x22, - PREV_AROUND_ORG = 0x11, - PREV_AROUND_DST = 0x33, - NEXT_AROUND_LEFT = 0x13, - NEXT_AROUND_RIGHT = 0x31, - PREV_AROUND_LEFT = 0x20, - PREV_AROUND_RIGHT = 0x02 - }; + enum { NEXT_AROUND_ORG = 0x00, + NEXT_AROUND_DST = 0x22, + PREV_AROUND_ORG = 0x11, + PREV_AROUND_DST = 0x33, + NEXT_AROUND_LEFT = 0x13, + NEXT_AROUND_RIGHT = 0x31, + PREV_AROUND_LEFT = 0x20, + PREV_AROUND_RIGHT = 0x02 + }; CV_WRAP Subdiv2D(); CV_WRAP Subdiv2D(Rect rect); @@ -1244,25 +804,25 @@ public: CV_WRAP void insert(const std::vector& ptvec); CV_WRAP int locate(Point2f pt, CV_OUT int& edge, CV_OUT int& vertex); - CV_WRAP int findNearest(Point2f pt, CV_OUT Point2f* nearestPt=0); + CV_WRAP int findNearest(Point2f pt, CV_OUT Point2f* nearestPt = 0); CV_WRAP void getEdgeList(CV_OUT std::vector& edgeList) const; CV_WRAP void getTriangleList(CV_OUT std::vector& triangleList) const; CV_WRAP void getVoronoiFacetList(const std::vector& idx, CV_OUT std::vector >& facetList, CV_OUT std::vector& facetCenters); - CV_WRAP Point2f getVertex(int vertex, CV_OUT int* firstEdge=0) const; + CV_WRAP Point2f getVertex(int vertex, CV_OUT int* firstEdge = 0) const; CV_WRAP int getEdge( int edge, int nextEdgeType ) const; CV_WRAP int nextEdge(int edge) const; CV_WRAP int rotateEdge(int edge, int rotate) const; CV_WRAP int symEdge(int edge) const; - CV_WRAP int edgeOrg(int edge, CV_OUT Point2f* orgpt=0) const; - CV_WRAP int edgeDst(int edge, CV_OUT Point2f* dstpt=0) const; + CV_WRAP int edgeOrg(int edge, CV_OUT Point2f* orgpt = 0) const; + CV_WRAP int edgeDst(int edge, CV_OUT Point2f* dstpt = 0) const; protected: int newEdge(); void deleteEdge(int edge); - int newPoint(Point2f pt, bool isvirtual, int firstEdge=0); + int newPoint(Point2f pt, bool isvirtual, int firstEdge = 0); void deletePoint(int vtx); void setEdgePoints( int edge, int orgPt, int dstPt ); void splice( int edgeA, int edgeB ); @@ -1279,15 +839,18 @@ protected: Vertex(Point2f pt, bool _isvirtual, int _firstEdge=0); bool isvirtual() const; bool isfree() const; + int firstEdge; int type; Point2f pt; }; + struct CV_EXPORTS QuadEdge { QuadEdge(); QuadEdge(int edgeidx); bool isfree() const; + int next[4]; int pt[4]; }; @@ -1303,13 +866,540 @@ protected: Point2f bottomRight; }; + + +//! returns type (one of KERNEL_*) of 1D or 2D kernel specified by its coefficients. +CV_EXPORTS int getKernelType(InputArray kernel, Point anchor); + +//! returns the primitive row filter with the specified kernel +CV_EXPORTS Ptr getLinearRowFilter(int srcType, int bufType, + InputArray kernel, int anchor, + int symmetryType); + +//! returns the primitive column filter with the specified kernel +CV_EXPORTS Ptr getLinearColumnFilter(int bufType, int dstType, + InputArray kernel, int anchor, + int symmetryType, double delta = 0, + int bits = 0); + +//! returns 2D filter with the specified kernel +CV_EXPORTS Ptr getLinearFilter(int srcType, int dstType, + InputArray kernel, + Point anchor = Point(-1,-1), + double delta = 0, int bits = 0); + +//! returns the separable linear filter engine +CV_EXPORTS Ptr createSeparableLinearFilter(int srcType, int dstType, + InputArray rowKernel, InputArray columnKernel, + Point anchor = Point(-1,-1), double delta = 0, + int rowBorderType = BORDER_DEFAULT, + int columnBorderType = -1, + const Scalar& borderValue = Scalar()); + +//! returns the non-separable linear filter engine +CV_EXPORTS Ptr createLinearFilter(int srcType, int dstType, + InputArray kernel, Point _anchor = Point(-1,-1), + double delta = 0, int rowBorderType = BORDER_DEFAULT, + int columnBorderType = -1, const Scalar& borderValue = Scalar()); + +//! returns the Gaussian kernel with the specified parameters +CV_EXPORTS_W Mat getGaussianKernel( int ksize, double sigma, int ktype = CV_64F ); + +//! returns the Gaussian filter engine +CV_EXPORTS Ptr createGaussianFilter( int type, Size ksize, + double sigma1, double sigma2 = 0, + int borderType = BORDER_DEFAULT); + +//! initializes kernels of the generalized Sobel operator +CV_EXPORTS_W void getDerivKernels( OutputArray kx, OutputArray ky, + int dx, int dy, int ksize, + bool normalize = false, int ktype = CV_32F ); + +//! returns filter engine for the generalized Sobel operator +CV_EXPORTS Ptr createDerivFilter( int srcType, int dstType, + int dx, int dy, int ksize, + int borderType = BORDER_DEFAULT ); + +//! returns horizontal 1D box filter +CV_EXPORTS Ptr getRowSumFilter(int srcType, int sumType, + int ksize, int anchor = -1); + +//! returns vertical 1D box filter +CV_EXPORTS Ptr getColumnSumFilter( int sumType, int dstType, + int ksize, int anchor = -1, + double scale = 1); +//! returns box filter engine +CV_EXPORTS Ptr createBoxFilter( int srcType, int dstType, Size ksize, + Point anchor = Point(-1,-1), + bool normalize = true, + int borderType = BORDER_DEFAULT); + +//! returns the Gabor kernel with the specified parameters +CV_EXPORTS_W Mat getGaborKernel( Size ksize, double sigma, double theta, double lambd, + double gamma, double psi = CV_PI*0.5, int ktype = CV_64F ); + +//! returns horizontal 1D morphological filter +CV_EXPORTS Ptr getMorphologyRowFilter(int op, int type, int ksize, int anchor = -1); + +//! returns vertical 1D morphological filter +CV_EXPORTS Ptr getMorphologyColumnFilter(int op, int type, int ksize, int anchor = -1); + +//! returns 2D morphological filter +CV_EXPORTS Ptr getMorphologyFilter(int op, int type, InputArray kernel, + Point anchor = Point(-1,-1)); + +//! returns "magic" border value for erosion and dilation. It is automatically transformed to Scalar::all(-DBL_MAX) for dilation. +static inline Scalar morphologyDefaultBorderValue() { return Scalar::all(DBL_MAX); } + +//! returns morphological filter engine. Only MORPH_ERODE and MORPH_DILATE are supported. +CV_EXPORTS Ptr createMorphologyFilter(int op, int type, InputArray kernel, + Point anchor = Point(-1,-1), int rowBorderType = BORDER_CONSTANT, + int columnBorderType = -1, const Scalar& borderValue = morphologyDefaultBorderValue()); + +//! returns structuring element of the specified shape and size +CV_EXPORTS_W Mat getStructuringElement(int shape, Size ksize, Point anchor = Point(-1,-1)); + +//! 1D interpolation function: returns coordinate of the "donor" pixel for the specified location p. +CV_EXPORTS_W int borderInterpolate( int p, int len, int borderType ); + +//! copies 2D array to a larger destination array with extrapolation of the outer part of src using the specified border mode +CV_EXPORTS_W void copyMakeBorder( InputArray src, OutputArray dst, + int top, int bottom, int left, int right, + int borderType, const Scalar& value = Scalar() ); + +//! smooths the image using median filter. +CV_EXPORTS_W void medianBlur( InputArray src, OutputArray dst, int ksize ); + +//! smooths the image using Gaussian filter. +CV_EXPORTS_W void GaussianBlur( InputArray src, OutputArray dst, Size ksize, + double sigmaX, double sigmaY = 0, + int borderType = BORDER_DEFAULT ); + +//! smooths the image using bilateral filter +CV_EXPORTS_W void bilateralFilter( InputArray src, OutputArray dst, int d, + double sigmaColor, double sigmaSpace, + int borderType = BORDER_DEFAULT ); + +//! smooths the image using the box filter. Each pixel is processed in O(1) time +CV_EXPORTS_W void boxFilter( InputArray src, OutputArray dst, int ddepth, + Size ksize, Point anchor = Point(-1,-1), + bool normalize = true, + int borderType = BORDER_DEFAULT ); + +//! a synonym for normalized box filter +CV_EXPORTS_W void blur( InputArray src, OutputArray dst, + Size ksize, Point anchor = Point(-1,-1), + int borderType = BORDER_DEFAULT ); + +//! applies non-separable 2D linear filter to the image +CV_EXPORTS_W void filter2D( InputArray src, OutputArray dst, int ddepth, + InputArray kernel, Point anchor = Point(-1,-1), + double delta = 0, int borderType = BORDER_DEFAULT ); + +//! applies separable 2D linear filter to the image +CV_EXPORTS_W void sepFilter2D( InputArray src, OutputArray dst, int ddepth, + InputArray kernelX, InputArray kernelY, + Point anchor = Point(-1,-1), + double delta = 0, int borderType = BORDER_DEFAULT ); + +//! applies generalized Sobel operator to the image +CV_EXPORTS_W void Sobel( InputArray src, OutputArray dst, int ddepth, + int dx, int dy, int ksize = 3, + double scale = 1, double delta = 0, + int borderType = BORDER_DEFAULT ); + +//! applies the vertical or horizontal Scharr operator to the image +CV_EXPORTS_W void Scharr( InputArray src, OutputArray dst, int ddepth, + int dx, int dy, double scale = 1, double delta = 0, + int borderType = BORDER_DEFAULT ); + +//! applies Laplacian operator to the image +CV_EXPORTS_W void Laplacian( InputArray src, OutputArray dst, int ddepth, + int ksize = 1, double scale = 1, double delta = 0, + int borderType = BORDER_DEFAULT ); + +//! applies Canny edge detector and produces the edge map. +CV_EXPORTS_W void Canny( InputArray image, OutputArray edges, + double threshold1, double threshold2, + int apertureSize = 3, bool L2gradient = false ); + +//! computes minimum eigen value of 2x2 derivative covariation matrix at each pixel - the cornerness criteria +CV_EXPORTS_W void cornerMinEigenVal( InputArray src, OutputArray dst, + int blockSize, int ksize = 3, + int borderType = BORDER_DEFAULT ); + +//! computes Harris cornerness criteria at each image pixel +CV_EXPORTS_W void cornerHarris( InputArray src, OutputArray dst, int blockSize, + int ksize, double k, + int borderType = BORDER_DEFAULT ); + +//! computes both eigenvalues and the eigenvectors of 2x2 derivative covariation matrix at each pixel. The output is stored as 6-channel matrix. +CV_EXPORTS_W void cornerEigenValsAndVecs( InputArray src, OutputArray dst, + int blockSize, int ksize, + int borderType = BORDER_DEFAULT ); + +//! computes another complex cornerness criteria at each pixel +CV_EXPORTS_W void preCornerDetect( InputArray src, OutputArray dst, int ksize, + int borderType = BORDER_DEFAULT ); + +//! adjusts the corner locations with sub-pixel accuracy to maximize the certain cornerness criteria +CV_EXPORTS_W void cornerSubPix( InputArray image, InputOutputArray corners, + Size winSize, Size zeroZone, + TermCriteria criteria ); + +//! finds the strong enough corners where the cornerMinEigenVal() or cornerHarris() report the local maxima +CV_EXPORTS_W void goodFeaturesToTrack( InputArray image, OutputArray corners, + int maxCorners, double qualityLevel, double minDistance, + InputArray mask = noArray(), int blockSize = 3, + bool useHarrisDetector = false, double k = 0.04 ); + +//! finds lines in the black-n-white image using the standard or pyramid Hough transform +CV_EXPORTS_W void HoughLines( InputArray image, OutputArray lines, + double rho, double theta, int threshold, + double srn = 0, double stn = 0 ); + +//! finds line segments in the black-n-white image using probabalistic Hough transform +CV_EXPORTS_W void HoughLinesP( InputArray image, OutputArray lines, + double rho, double theta, int threshold, + double minLineLength = 0, double maxLineGap = 0 ); + +//! finds circles in the grayscale image using 2+1 gradient Hough transform +CV_EXPORTS_W void HoughCircles( InputArray image, OutputArray circles, + int method, double dp, double minDist, + double param1 = 100, double param2 = 100, + int minRadius = 0, int maxRadius = 0 ); + +//! erodes the image (applies the local minimum operator) +CV_EXPORTS_W void erode( InputArray src, OutputArray dst, InputArray kernel, + Point anchor = Point(-1,-1), int iterations = 1, + int borderType = BORDER_CONSTANT, + const Scalar& borderValue = morphologyDefaultBorderValue() ); + +//! dilates the image (applies the local maximum operator) +CV_EXPORTS_W void dilate( InputArray src, OutputArray dst, InputArray kernel, + Point anchor = Point(-1,-1), int iterations = 1, + int borderType = BORDER_CONSTANT, + const Scalar& borderValue = morphologyDefaultBorderValue() ); + +//! applies an advanced morphological operation to the image +CV_EXPORTS_W void morphologyEx( InputArray src, OutputArray dst, + int op, InputArray kernel, + Point anchor = Point(-1,-1), int iterations = 1, + int borderType = BORDER_CONSTANT, + const Scalar& borderValue = morphologyDefaultBorderValue() ); + +//! resizes the image +CV_EXPORTS_W void resize( InputArray src, OutputArray dst, + Size dsize, double fx = 0, double fy = 0, + int interpolation = INTER_LINEAR ); + +//! warps the image using affine transformation +CV_EXPORTS_W void warpAffine( InputArray src, OutputArray dst, + InputArray M, Size dsize, + int flags = INTER_LINEAR, + int borderMode = BORDER_CONSTANT, + const Scalar& borderValue = Scalar()); + +//! warps the image using perspective transformation +CV_EXPORTS_W void warpPerspective( InputArray src, OutputArray dst, + InputArray M, Size dsize, + int flags = INTER_LINEAR, + int borderMode = BORDER_CONSTANT, + const Scalar& borderValue = Scalar()); + +//! warps the image using the precomputed maps. The maps are stored in either floating-point or integer fixed-point format +CV_EXPORTS_W void remap( InputArray src, OutputArray dst, + InputArray map1, InputArray map2, + int interpolation, int borderMode = BORDER_CONSTANT, + const Scalar& borderValue = Scalar()); + +//! converts maps for remap from floating-point to fixed-point format or backwards +CV_EXPORTS_W void convertMaps( InputArray map1, InputArray map2, + OutputArray dstmap1, OutputArray dstmap2, + int dstmap1type, bool nninterpolation = false ); + +//! returns 2x3 affine transformation matrix for the planar rotation. +CV_EXPORTS_W Mat getRotationMatrix2D( Point2f center, double angle, double scale ); + +//! returns 3x3 perspective transformation for the corresponding 4 point pairs. +CV_EXPORTS Mat getPerspectiveTransform( const Point2f src[], const Point2f dst[] ); + +//! returns 2x3 affine transformation for the corresponding 3 point pairs. +CV_EXPORTS Mat getAffineTransform( const Point2f src[], const Point2f dst[] ); + +//! computes 2x3 affine transformation matrix that is inverse to the specified 2x3 affine transformation. +CV_EXPORTS_W void invertAffineTransform( InputArray M, OutputArray iM ); + +CV_EXPORTS_W Mat getPerspectiveTransform( InputArray src, InputArray dst ); + +CV_EXPORTS_W Mat getAffineTransform( InputArray src, InputArray dst ); + +//! extracts rectangle from the image at sub-pixel location +CV_EXPORTS_W void getRectSubPix( InputArray image, Size patchSize, + Point2f center, OutputArray patch, int patchType = -1 ); + +//! computes the integral image +CV_EXPORTS_W void integral( InputArray src, OutputArray sum, int sdepth = -1 ); + +//! computes the integral image and integral for the squared image +CV_EXPORTS_AS(integral2) void integral( InputArray src, OutputArray sum, + OutputArray sqsum, int sdepth = -1 ); + +//! computes the integral image, integral for the squared image and the tilted integral image +CV_EXPORTS_AS(integral3) void integral( InputArray src, OutputArray sum, + OutputArray sqsum, OutputArray tilted, + int sdepth = -1 ); + +//! adds image to the accumulator (dst += src). Unlike cv::add, dst and src can have different types. +CV_EXPORTS_W void accumulate( InputArray src, InputOutputArray dst, + InputArray mask = noArray() ); + +//! adds squared src image to the accumulator (dst += src*src). +CV_EXPORTS_W void accumulateSquare( InputArray src, InputOutputArray dst, + InputArray mask = noArray() ); +//! adds product of the 2 images to the accumulator (dst += src1*src2). +CV_EXPORTS_W void accumulateProduct( InputArray src1, InputArray src2, + InputOutputArray dst, InputArray mask=noArray() ); + +//! updates the running average (dst = dst*(1-alpha) + src*alpha) +CV_EXPORTS_W void accumulateWeighted( InputArray src, InputOutputArray dst, + double alpha, InputArray mask = noArray() ); + +//! computes PSNR image/video quality metric +CV_EXPORTS_W double PSNR(InputArray src1, InputArray src2); + +CV_EXPORTS_W Point2d phaseCorrelate(InputArray src1, InputArray src2, + InputArray window = noArray(), CV_OUT double* response = 0); + +CV_EXPORTS_W void createHanningWindow(OutputArray dst, Size winSize, int type); + +//! applies fixed threshold to the image +CV_EXPORTS_W double threshold( InputArray src, OutputArray dst, + double thresh, double maxval, int type ); + + +//! applies variable (adaptive) threshold to the image +CV_EXPORTS_W void adaptiveThreshold( InputArray src, OutputArray dst, + double maxValue, int adaptiveMethod, + int thresholdType, int blockSize, double C ); + +//! smooths and downsamples the image +CV_EXPORTS_W void pyrDown( InputArray src, OutputArray dst, + const Size& dstsize = Size(), int borderType = BORDER_DEFAULT ); + +//! upsamples and smoothes the image +CV_EXPORTS_W void pyrUp( InputArray src, OutputArray dst, + const Size& dstsize = Size(), int borderType = BORDER_DEFAULT ); + +//! builds the gaussian pyramid using pyrDown() as a basic operation +CV_EXPORTS void buildPyramid( InputArray src, OutputArrayOfArrays dst, + int maxlevel, int borderType = BORDER_DEFAULT ); + +//! corrects lens distortion for the given camera matrix and distortion coefficients +CV_EXPORTS_W void undistort( InputArray src, OutputArray dst, + InputArray cameraMatrix, + InputArray distCoeffs, + InputArray newCameraMatrix = noArray() ); + +//! initializes maps for cv::remap() to correct lens distortion and optionally rectify the image +CV_EXPORTS_W void initUndistortRectifyMap( InputArray cameraMatrix, InputArray distCoeffs, + InputArray R, InputArray newCameraMatrix, + Size size, int m1type, OutputArray map1, OutputArray map2 ); + +//! initializes maps for cv::remap() for wide-angle +CV_EXPORTS_W float initWideAngleProjMap( InputArray cameraMatrix, InputArray distCoeffs, + Size imageSize, int destImageWidth, + int m1type, OutputArray map1, OutputArray map2, + int projType = PROJ_SPHERICAL_EQRECT, double alpha = 0); + +//! returns the default new camera matrix (by default it is the same as cameraMatrix unless centerPricipalPoint=true) +CV_EXPORTS_W Mat getDefaultNewCameraMatrix( InputArray cameraMatrix, Size imgsize = Size(), + bool centerPrincipalPoint = false ); + +//! returns points' coordinates after lens distortion correction +CV_EXPORTS_W void undistortPoints( InputArray src, OutputArray dst, + InputArray cameraMatrix, InputArray distCoeffs, + InputArray R = noArray(), InputArray P = noArray()); + +//! computes the joint dense histogram for a set of images. +CV_EXPORTS void calcHist( const Mat* images, int nimages, + const int* channels, InputArray mask, + OutputArray hist, int dims, const int* histSize, + const float** ranges, bool uniform = true, bool accumulate = false ); + +//! computes the joint sparse histogram for a set of images. +CV_EXPORTS void calcHist( const Mat* images, int nimages, + const int* channels, InputArray mask, + SparseMat& hist, int dims, + const int* histSize, const float** ranges, + bool uniform = true, bool accumulate = false ); + +CV_EXPORTS_W void calcHist( InputArrayOfArrays images, + const std::vector& channels, + InputArray mask, OutputArray hist, + const std::vector& histSize, + const std::vector& ranges, + bool accumulate = false ); + +//! computes back projection for the set of images +CV_EXPORTS void calcBackProject( const Mat* images, int nimages, + const int* channels, InputArray hist, + OutputArray backProject, const float** ranges, + double scale = 1, bool uniform = true ); + +//! computes back projection for the set of images +CV_EXPORTS void calcBackProject( const Mat* images, int nimages, + const int* channels, const SparseMat& hist, + OutputArray backProject, const float** ranges, + double scale = 1, bool uniform = true ); + +CV_EXPORTS_W void calcBackProject( InputArrayOfArrays images, const std::vector& channels, + InputArray hist, OutputArray dst, + const std::vector& ranges, + double scale ); + +//! compares two histograms stored in dense arrays +CV_EXPORTS_W double compareHist( InputArray H1, InputArray H2, int method ); + +//! compares two histograms stored in sparse arrays +CV_EXPORTS double compareHist( const SparseMat& H1, const SparseMat& H2, int method ); + +//! normalizes the grayscale image brightness and contrast by normalizing its histogram +CV_EXPORTS_W void equalizeHist( InputArray src, OutputArray dst ); + +CV_EXPORTS float EMD( InputArray signature1, InputArray signature2, + int distType, InputArray cost=noArray(), + float* lowerBound = 0, OutputArray flow = noArray() ); + +//! segments the image using watershed algorithm +CV_EXPORTS_W void watershed( InputArray image, InputOutputArray markers ); + +//! filters image using meanshift algorithm +CV_EXPORTS_W void pyrMeanShiftFiltering( InputArray src, OutputArray dst, + double sp, double sr, int maxLevel = 1, + TermCriteria termcrit=TermCriteria(TermCriteria::MAX_ITER+TermCriteria::EPS,5,1) ); + +//! segments the image using GrabCut algorithm +CV_EXPORTS_W void grabCut( InputArray img, InputOutputArray mask, Rect rect, + InputOutputArray bgdModel, InputOutputArray fgdModel, + int iterCount, int mode = GC_EVAL ); + + +//! builds the discrete Voronoi diagram +CV_EXPORTS_AS(distanceTransformWithLabels) void distanceTransform( InputArray src, OutputArray dst, + OutputArray labels, int distanceType, int maskSize, + int labelType = DIST_LABEL_CCOMP ); + +//! computes the distance transform map +CV_EXPORTS_W void distanceTransform( InputArray src, OutputArray dst, + int distanceType, int maskSize ); + + +//! fills the semi-uniform image region starting from the specified seed point +CV_EXPORTS int floodFill( InputOutputArray image, + Point seedPoint, Scalar newVal, CV_OUT Rect* rect = 0, + Scalar loDiff = Scalar(), Scalar upDiff = Scalar(), + int flags = 4 ); + +//! fills the semi-uniform image region and/or the mask starting from the specified seed point +CV_EXPORTS_W int floodFill( InputOutputArray image, InputOutputArray mask, + Point seedPoint, Scalar newVal, CV_OUT Rect* rect=0, + Scalar loDiff = Scalar(), Scalar upDiff = Scalar(), + int flags = 4 ); + +//! converts image from one color space to another +CV_EXPORTS_W void cvtColor( InputArray src, OutputArray dst, int code, int dstCn = 0 ); + // main function for all demosaicing procceses CV_EXPORTS_W void demosaicing(InputArray _src, OutputArray _dst, int code, int dcn = 0); -} +//! computes moments of the rasterized shape or a vector of points +CV_EXPORTS_W Moments moments( InputArray array, bool binaryImage = false ); -#endif /* __cplusplus */ +//! computes 7 Hu invariants from the moments +CV_EXPORTS void HuMoments( const Moments& moments, double hu[7] ); + +CV_EXPORTS_W void HuMoments( const Moments& m, OutputArray hu ); + +//! computes the proximity map for the raster template and the image where the template is searched for +CV_EXPORTS_W void matchTemplate( InputArray image, InputArray templ, + OutputArray result, int method ); + + +// computes the connected components labeled image of boolean image ``image`` +// with 4 or 8 way connectivity - returns N, the total +// number of labels [0, N-1] where 0 represents the background label. +// ltype specifies the output label image type, an important +// consideration based on the total number of labels or +// alternatively the total number of pixels in the source image. +CV_EXPORTS_W int connectedComponents(InputArray image, OutputArray labels, + int connectivity = 8, int ltype = CV_32S); + +CV_EXPORTS_W int connectedComponentsWithStats(InputArray image, OutputArray labels, + OutputArray stats, OutputArray centroids, + int connectivity = 8, int ltype = CV_32S); + + +//! retrieves contours and the hierarchical information from black-n-white image. +CV_EXPORTS_W void findContours( InputOutputArray image, OutputArrayOfArrays contours, + OutputArray hierarchy, int mode, + int method, Point offset = Point()); + +//! retrieves contours from black-n-white image. +CV_EXPORTS void findContours( InputOutputArray image, OutputArrayOfArrays contours, + int mode, int method, Point offset = Point()); + +//! approximates contour or a curve using Douglas-Peucker algorithm +CV_EXPORTS_W void approxPolyDP( InputArray curve, + OutputArray approxCurve, + double epsilon, bool closed ); + +//! computes the contour perimeter (closed=true) or a curve length +CV_EXPORTS_W double arcLength( InputArray curve, bool closed ); + +//! computes the bounding rectangle for a contour +CV_EXPORTS_W Rect boundingRect( InputArray points ); + +//! computes the contour area +CV_EXPORTS_W double contourArea( InputArray contour, bool oriented = false ); + +//! computes the minimal rotated rectangle for a set of points +CV_EXPORTS_W RotatedRect minAreaRect( InputArray points ); + +//! computes the minimal enclosing circle for a set of points +CV_EXPORTS_W void minEnclosingCircle( InputArray points, + CV_OUT Point2f& center, CV_OUT float& radius ); + +//! matches two contours using one of the available algorithms +CV_EXPORTS_W double matchShapes( InputArray contour1, InputArray contour2, + int method, double parameter ); + +//! computes convex hull for a set of 2D points. +CV_EXPORTS_W void convexHull( InputArray points, OutputArray hull, + bool clockwise = false, bool returnPoints = true ); + +//! computes the contour convexity defects +CV_EXPORTS_W void convexityDefects( InputArray contour, InputArray convexhull, OutputArray convexityDefects ); + +//! returns true if the contour is convex. Does not support contours with self-intersection +CV_EXPORTS_W bool isContourConvex( InputArray contour ); + +//! finds intersection of two convex polygons +CV_EXPORTS_W float intersectConvexConvex( InputArray _p1, InputArray _p2, + OutputArray _p12, bool handleNested = true ); + +//! fits ellipse to the set of 2D points +CV_EXPORTS_W RotatedRect fitEllipse( InputArray points ); + +//! fits line to the set of 2D points using M-estimator algorithm +CV_EXPORTS_W void fitLine( InputArray points, OutputArray line, int distType, + double param, double reps, double aeps ); + +//! checks if the point is inside the contour. Optionally computes the signed distance from the point to the contour boundary +CV_EXPORTS_W double pointPolygonTest( InputArray contour, Point2f pt, bool measureDist ); + +CV_EXPORTS Ptr createCLAHE(double clipLimit = 40.0, Size tileGridSize = Size(8, 8)); + +} // cv #endif - -/* End of file. */ diff --git a/modules/imgproc/include/opencv2/imgproc/types_c.h b/modules/imgproc/include/opencv2/imgproc/types_c.h index 8e65269866..5b89e2d7c1 100644 --- a/modules/imgproc/include/opencv2/imgproc/types_c.h +++ b/modules/imgproc/include/opencv2/imgproc/types_c.h @@ -45,6 +45,10 @@ #include "opencv2/core/core_c.h" +#ifdef __cplusplus +# include "opencv2/imgproc.hpp" +#endif + #ifdef __cplusplus extern "C" { #endif @@ -383,6 +387,24 @@ typedef struct CvMoments double m00, m10, m01, m20, m11, m02, m30, m21, m12, m03; /* spatial moments */ double mu20, mu11, mu02, mu30, mu21, mu12, mu03; /* central moments */ double inv_sqrt_m00; /* m00 != 0 ? 1/sqrt(m00) : 0 */ + +#ifdef __cplusplus + CvMoments(){} + CvMoments(const cv::Moments& m) + { + m00 = m.m00; m10 = m.m10; m01 = m.m01; + m20 = m.m20; m11 = m.m11; m02 = m.m02; + m30 = m.m30; m21 = m.m21; m12 = m.m12; m03 = m.m03; + mu20 = m.mu20; mu11 = m.mu11; mu02 = m.mu02; + mu30 = m.mu30; mu21 = m.mu21; mu12 = m.mu12; mu03 = m.mu03; + double am00 = std::abs(m.m00); + inv_sqrt_m00 = am00 > DBL_EPSILON ? 1./std::sqrt(am00) : 0; + } + operator cv::Moments() const + { + return cv::Moments(m00, m10, m01, m20, m11, m02, m30, m21, m12, m03); + } +#endif } CvMoments; diff --git a/modules/imgproc/perf/perf_cvt_color.cpp b/modules/imgproc/perf/perf_cvt_color.cpp index 2038fc88c9..b7eb71f2c9 100644 --- a/modules/imgproc/perf/perf_cvt_color.cpp +++ b/modules/imgproc/perf/perf_cvt_color.cpp @@ -9,114 +9,114 @@ using std::tr1::get; //extra color conversions supported implicitly enum { - CX_BGRA2HLS = CV_COLORCVT_MAX + CV_BGR2HLS, - CX_BGRA2HLS_FULL = CV_COLORCVT_MAX + CV_BGR2HLS_FULL, - CX_BGRA2HSV = CV_COLORCVT_MAX + CV_BGR2HSV, - CX_BGRA2HSV_FULL = CV_COLORCVT_MAX + CV_BGR2HSV_FULL, - CX_BGRA2Lab = CV_COLORCVT_MAX + CV_BGR2Lab, - CX_BGRA2Luv = CV_COLORCVT_MAX + CV_BGR2Luv, - CX_BGRA2XYZ = CV_COLORCVT_MAX + CV_BGR2XYZ, - CX_BGRA2YCrCb = CV_COLORCVT_MAX + CV_BGR2YCrCb, - CX_BGRA2YUV = CV_COLORCVT_MAX + CV_BGR2YUV, - CX_HLS2BGRA = CV_COLORCVT_MAX + CV_HLS2BGR, - CX_HLS2BGRA_FULL = CV_COLORCVT_MAX + CV_HLS2BGR_FULL, - CX_HLS2RGBA = CV_COLORCVT_MAX + CV_HLS2RGB, - CX_HLS2RGBA_FULL = CV_COLORCVT_MAX + CV_HLS2RGB_FULL, - CX_HSV2BGRA = CV_COLORCVT_MAX + CV_HSV2BGR, - CX_HSV2BGRA_FULL = CV_COLORCVT_MAX + CV_HSV2BGR_FULL, - CX_HSV2RGBA = CV_COLORCVT_MAX + CV_HSV2RGB, - CX_HSV2RGBA_FULL = CV_COLORCVT_MAX + CV_HSV2RGB_FULL, - CX_Lab2BGRA = CV_COLORCVT_MAX + CV_Lab2BGR, - CX_Lab2LBGRA = CV_COLORCVT_MAX + CV_Lab2LBGR, - CX_Lab2LRGBA = CV_COLORCVT_MAX + CV_Lab2LRGB, - CX_Lab2RGBA = CV_COLORCVT_MAX + CV_Lab2RGB, - CX_LBGRA2Lab = CV_COLORCVT_MAX + CV_LBGR2Lab, - CX_LBGRA2Luv = CV_COLORCVT_MAX + CV_LBGR2Luv, - CX_LRGBA2Lab = CV_COLORCVT_MAX + CV_LRGB2Lab, - CX_LRGBA2Luv = CV_COLORCVT_MAX + CV_LRGB2Luv, - CX_Luv2BGRA = CV_COLORCVT_MAX + CV_Luv2BGR, - CX_Luv2LBGRA = CV_COLORCVT_MAX + CV_Luv2LBGR, - CX_Luv2LRGBA = CV_COLORCVT_MAX + CV_Luv2LRGB, - CX_Luv2RGBA = CV_COLORCVT_MAX + CV_Luv2RGB, - CX_RGBA2HLS = CV_COLORCVT_MAX + CV_RGB2HLS, - CX_RGBA2HLS_FULL = CV_COLORCVT_MAX + CV_RGB2HLS_FULL, - CX_RGBA2HSV = CV_COLORCVT_MAX + CV_RGB2HSV, - CX_RGBA2HSV_FULL = CV_COLORCVT_MAX + CV_RGB2HSV_FULL, - CX_RGBA2Lab = CV_COLORCVT_MAX + CV_RGB2Lab, - CX_RGBA2Luv = CV_COLORCVT_MAX + CV_RGB2Luv, - CX_RGBA2XYZ = CV_COLORCVT_MAX + CV_RGB2XYZ, - CX_RGBA2YCrCb = CV_COLORCVT_MAX + CV_RGB2YCrCb, - CX_RGBA2YUV = CV_COLORCVT_MAX + CV_RGB2YUV, - CX_XYZ2BGRA = CV_COLORCVT_MAX + CV_XYZ2BGR, - CX_XYZ2RGBA = CV_COLORCVT_MAX + CV_XYZ2RGB, - CX_YCrCb2BGRA = CV_COLORCVT_MAX + CV_YCrCb2BGR, - CX_YCrCb2RGBA = CV_COLORCVT_MAX + CV_YCrCb2RGB, - CX_YUV2BGRA = CV_COLORCVT_MAX + CV_YUV2BGR, - CX_YUV2RGBA = CV_COLORCVT_MAX + CV_YUV2RGB + CX_BGRA2HLS = COLOR_COLORCVT_MAX + COLOR_BGR2HLS, + CX_BGRA2HLS_FULL = COLOR_COLORCVT_MAX + COLOR_BGR2HLS_FULL, + CX_BGRA2HSV = COLOR_COLORCVT_MAX + COLOR_BGR2HSV, + CX_BGRA2HSV_FULL = COLOR_COLORCVT_MAX + COLOR_BGR2HSV_FULL, + CX_BGRA2Lab = COLOR_COLORCVT_MAX + COLOR_BGR2Lab, + CX_BGRA2Luv = COLOR_COLORCVT_MAX + COLOR_BGR2Luv, + CX_BGRA2XYZ = COLOR_COLORCVT_MAX + COLOR_BGR2XYZ, + CX_BGRA2YCrCb = COLOR_COLORCVT_MAX + COLOR_BGR2YCrCb, + CX_BGRA2YUV = COLOR_COLORCVT_MAX + COLOR_BGR2YUV, + CX_HLS2BGRA = COLOR_COLORCVT_MAX + COLOR_HLS2BGR, + CX_HLS2BGRA_FULL = COLOR_COLORCVT_MAX + COLOR_HLS2BGR_FULL, + CX_HLS2RGBA = COLOR_COLORCVT_MAX + COLOR_HLS2RGB, + CX_HLS2RGBA_FULL = COLOR_COLORCVT_MAX + COLOR_HLS2RGB_FULL, + CX_HSV2BGRA = COLOR_COLORCVT_MAX + COLOR_HSV2BGR, + CX_HSV2BGRA_FULL = COLOR_COLORCVT_MAX + COLOR_HSV2BGR_FULL, + CX_HSV2RGBA = COLOR_COLORCVT_MAX + COLOR_HSV2RGB, + CX_HSV2RGBA_FULL = COLOR_COLORCVT_MAX + COLOR_HSV2RGB_FULL, + CX_Lab2BGRA = COLOR_COLORCVT_MAX + COLOR_Lab2BGR, + CX_Lab2LBGRA = COLOR_COLORCVT_MAX + COLOR_Lab2LBGR, + CX_Lab2LRGBA = COLOR_COLORCVT_MAX + COLOR_Lab2LRGB, + CX_Lab2RGBA = COLOR_COLORCVT_MAX + COLOR_Lab2RGB, + CX_LBGRA2Lab = COLOR_COLORCVT_MAX + COLOR_LBGR2Lab, + CX_LBGRA2Luv = COLOR_COLORCVT_MAX + COLOR_LBGR2Luv, + CX_LRGBA2Lab = COLOR_COLORCVT_MAX + COLOR_LRGB2Lab, + CX_LRGBA2Luv = COLOR_COLORCVT_MAX + COLOR_LRGB2Luv, + CX_Luv2BGRA = COLOR_COLORCVT_MAX + COLOR_Luv2BGR, + CX_Luv2LBGRA = COLOR_COLORCVT_MAX + COLOR_Luv2LBGR, + CX_Luv2LRGBA = COLOR_COLORCVT_MAX + COLOR_Luv2LRGB, + CX_Luv2RGBA = COLOR_COLORCVT_MAX + COLOR_Luv2RGB, + CX_RGBA2HLS = COLOR_COLORCVT_MAX + COLOR_RGB2HLS, + CX_RGBA2HLS_FULL = COLOR_COLORCVT_MAX + COLOR_RGB2HLS_FULL, + CX_RGBA2HSV = COLOR_COLORCVT_MAX + COLOR_RGB2HSV, + CX_RGBA2HSV_FULL = COLOR_COLORCVT_MAX + COLOR_RGB2HSV_FULL, + CX_RGBA2Lab = COLOR_COLORCVT_MAX + COLOR_RGB2Lab, + CX_RGBA2Luv = COLOR_COLORCVT_MAX + COLOR_RGB2Luv, + CX_RGBA2XYZ = COLOR_COLORCVT_MAX + COLOR_RGB2XYZ, + CX_RGBA2YCrCb = COLOR_COLORCVT_MAX + COLOR_RGB2YCrCb, + CX_RGBA2YUV = COLOR_COLORCVT_MAX + COLOR_RGB2YUV, + CX_XYZ2BGRA = COLOR_COLORCVT_MAX + COLOR_XYZ2BGR, + CX_XYZ2RGBA = COLOR_COLORCVT_MAX + COLOR_XYZ2RGB, + CX_YCrCb2BGRA = COLOR_COLORCVT_MAX + COLOR_YCrCb2BGR, + CX_YCrCb2RGBA = COLOR_COLORCVT_MAX + COLOR_YCrCb2RGB, + CX_YUV2BGRA = COLOR_COLORCVT_MAX + COLOR_YUV2BGR, + CX_YUV2RGBA = COLOR_COLORCVT_MAX + COLOR_YUV2RGB }; CV_ENUM(CvtMode, - CV_BGR2BGR555, CV_BGR2BGR565, CV_BGR2BGRA, CV_BGR2GRAY, - CV_BGR2HLS, CV_BGR2HLS_FULL, CV_BGR2HSV, CV_BGR2HSV_FULL, - CV_BGR2Lab, CV_BGR2Luv, CV_BGR2RGB, CV_BGR2RGBA, CV_BGR2XYZ, - CV_BGR2YCrCb, CV_BGR2YUV, CV_BGR5552BGR, CV_BGR5552BGRA, + COLOR_BGR2BGR555, COLOR_BGR2BGR565, COLOR_BGR2BGRA, COLOR_BGR2GRAY, + COLOR_BGR2HLS, COLOR_BGR2HLS_FULL, COLOR_BGR2HSV, COLOR_BGR2HSV_FULL, + COLOR_BGR2Lab, COLOR_BGR2Luv, COLOR_BGR2RGB, COLOR_BGR2RGBA, COLOR_BGR2XYZ, + COLOR_BGR2YCrCb, COLOR_BGR2YUV, COLOR_BGR5552BGR, COLOR_BGR5552BGRA, - CV_BGR5552GRAY, CV_BGR5552RGB, CV_BGR5552RGBA, CV_BGR5652BGR, - CV_BGR5652BGRA, CV_BGR5652GRAY, CV_BGR5652RGB, CV_BGR5652RGBA, + COLOR_BGR5552GRAY, COLOR_BGR5552RGB, COLOR_BGR5552RGBA, COLOR_BGR5652BGR, + COLOR_BGR5652BGRA, COLOR_BGR5652GRAY, COLOR_BGR5652RGB, COLOR_BGR5652RGBA, - CV_BGRA2BGR, CV_BGRA2BGR555, CV_BGRA2BGR565, CV_BGRA2GRAY, CV_BGRA2RGBA, + COLOR_BGRA2BGR, COLOR_BGRA2BGR555, COLOR_BGRA2BGR565, COLOR_BGRA2GRAY, COLOR_BGRA2RGBA, CX_BGRA2HLS, CX_BGRA2HLS_FULL, CX_BGRA2HSV, CX_BGRA2HSV_FULL, CX_BGRA2Lab, CX_BGRA2Luv, CX_BGRA2XYZ, CX_BGRA2YCrCb, CX_BGRA2YUV, - CV_GRAY2BGR, CV_GRAY2BGR555, CV_GRAY2BGR565, CV_GRAY2BGRA, + COLOR_GRAY2BGR, COLOR_GRAY2BGR555, COLOR_GRAY2BGR565, COLOR_GRAY2BGRA, - CV_HLS2BGR, CV_HLS2BGR_FULL, CV_HLS2RGB, CV_HLS2RGB_FULL, + COLOR_HLS2BGR, COLOR_HLS2BGR_FULL, COLOR_HLS2RGB, COLOR_HLS2RGB_FULL, CX_HLS2BGRA, CX_HLS2BGRA_FULL, CX_HLS2RGBA, CX_HLS2RGBA_FULL, - CV_HSV2BGR, CV_HSV2BGR_FULL, CV_HSV2RGB, CV_HSV2RGB_FULL, + COLOR_HSV2BGR, COLOR_HSV2BGR_FULL, COLOR_HSV2RGB, COLOR_HSV2RGB_FULL, CX_HSV2BGRA, CX_HSV2BGRA_FULL, CX_HSV2RGBA, CX_HSV2RGBA_FULL, - CV_Lab2BGR, CV_Lab2LBGR, CV_Lab2LRGB, CV_Lab2RGB, + COLOR_Lab2BGR, COLOR_Lab2LBGR, COLOR_Lab2LRGB, COLOR_Lab2RGB, CX_Lab2BGRA, CX_Lab2LBGRA, CX_Lab2LRGBA, CX_Lab2RGBA, - CV_LBGR2Lab, CV_LBGR2Luv, CV_LRGB2Lab, CV_LRGB2Luv, + COLOR_LBGR2Lab, COLOR_LBGR2Luv, COLOR_LRGB2Lab, COLOR_LRGB2Luv, CX_LBGRA2Lab, CX_LBGRA2Luv, CX_LRGBA2Lab, CX_LRGBA2Luv, - CV_Luv2BGR, CV_Luv2LBGR, CV_Luv2LRGB, CV_Luv2RGB, + COLOR_Luv2BGR, COLOR_Luv2LBGR, COLOR_Luv2LRGB, COLOR_Luv2RGB, CX_Luv2BGRA, CX_Luv2LBGRA, CX_Luv2LRGBA, CX_Luv2RGBA, - CV_RGB2BGR555, CV_RGB2BGR565, CV_RGB2GRAY, - CV_RGB2HLS, CV_RGB2HLS_FULL, CV_RGB2HSV, CV_RGB2HSV_FULL, - CV_RGB2Lab, CV_RGB2Luv, CV_RGB2XYZ, CV_RGB2YCrCb, CV_RGB2YUV, + COLOR_RGB2BGR555, COLOR_RGB2BGR565, COLOR_RGB2GRAY, + COLOR_RGB2HLS, COLOR_RGB2HLS_FULL, COLOR_RGB2HSV, COLOR_RGB2HSV_FULL, + COLOR_RGB2Lab, COLOR_RGB2Luv, COLOR_RGB2XYZ, COLOR_RGB2YCrCb, COLOR_RGB2YUV, - CV_RGBA2BGR, CV_RGBA2BGR555, CV_RGBA2BGR565, CV_RGBA2GRAY, + COLOR_RGBA2BGR, COLOR_RGBA2BGR555, COLOR_RGBA2BGR565, COLOR_RGBA2GRAY, CX_RGBA2HLS, CX_RGBA2HLS_FULL, CX_RGBA2HSV, CX_RGBA2HSV_FULL, CX_RGBA2Lab, CX_RGBA2Luv, CX_RGBA2XYZ, CX_RGBA2YCrCb, CX_RGBA2YUV, - CV_XYZ2BGR, CV_XYZ2RGB, CX_XYZ2BGRA, CX_XYZ2RGBA, + COLOR_XYZ2BGR, COLOR_XYZ2RGB, CX_XYZ2BGRA, CX_XYZ2RGBA, - CV_YCrCb2BGR, CV_YCrCb2RGB, CX_YCrCb2BGRA, CX_YCrCb2RGBA, - CV_YUV2BGR, CV_YUV2RGB, CX_YUV2BGRA, CX_YUV2RGBA + COLOR_YCrCb2BGR, COLOR_YCrCb2RGB, CX_YCrCb2BGRA, CX_YCrCb2RGBA, + COLOR_YUV2BGR, COLOR_YUV2RGB, CX_YUV2BGRA, CX_YUV2RGBA ) CV_ENUM(CvtModeBayer, - CV_BayerBG2BGR, CV_BayerBG2BGR_VNG, CV_BayerBG2GRAY, - CV_BayerGB2BGR, CV_BayerGB2BGR_VNG, CV_BayerGB2GRAY, - CV_BayerGR2BGR, CV_BayerGR2BGR_VNG, CV_BayerGR2GRAY, - CV_BayerRG2BGR, CV_BayerRG2BGR_VNG, CV_BayerRG2GRAY + COLOR_BayerBG2BGR, COLOR_BayerBG2BGR_VNG, COLOR_BayerBG2GRAY, + COLOR_BayerGB2BGR, COLOR_BayerGB2BGR_VNG, COLOR_BayerGB2GRAY, + COLOR_BayerGR2BGR, COLOR_BayerGR2BGR_VNG, COLOR_BayerGR2GRAY, + COLOR_BayerRG2BGR, COLOR_BayerRG2BGR_VNG, COLOR_BayerRG2GRAY ) -CV_ENUM(CvtMode2, CV_YUV2BGR_NV12, CV_YUV2BGRA_NV12, CV_YUV2RGB_NV12, CV_YUV2RGBA_NV12, CV_YUV2BGR_NV21, CV_YUV2BGRA_NV21, CV_YUV2RGB_NV21, CV_YUV2RGBA_NV21, - CV_YUV2BGR_YV12, CV_YUV2BGRA_YV12, CV_YUV2RGB_YV12, CV_YUV2RGBA_YV12, CV_YUV2BGR_IYUV, CV_YUV2BGRA_IYUV, CV_YUV2RGB_IYUV, CV_YUV2RGBA_IYUV, - COLOR_YUV2GRAY_420, CV_YUV2RGB_UYVY, CV_YUV2BGR_UYVY, CV_YUV2RGBA_UYVY, CV_YUV2BGRA_UYVY, CV_YUV2RGB_YUY2, CV_YUV2BGR_YUY2, CV_YUV2RGB_YVYU, - CV_YUV2BGR_YVYU, CV_YUV2RGBA_YUY2, CV_YUV2BGRA_YUY2, CV_YUV2RGBA_YVYU, CV_YUV2BGRA_YVYU) +CV_ENUM(CvtMode2, COLOR_YUV2BGR_NV12, COLOR_YUV2BGRA_NV12, COLOR_YUV2RGB_NV12, COLOR_YUV2RGBA_NV12, COLOR_YUV2BGR_NV21, COLOR_YUV2BGRA_NV21, COLOR_YUV2RGB_NV21, COLOR_YUV2RGBA_NV21, + COLOR_YUV2BGR_YV12, COLOR_YUV2BGRA_YV12, COLOR_YUV2RGB_YV12, COLOR_YUV2RGBA_YV12, COLOR_YUV2BGR_IYUV, COLOR_YUV2BGRA_IYUV, COLOR_YUV2RGB_IYUV, COLOR_YUV2RGBA_IYUV, + COLOR_YUV2GRAY_420, COLOR_YUV2RGB_UYVY, COLOR_YUV2BGR_UYVY, COLOR_YUV2RGBA_UYVY, COLOR_YUV2BGRA_UYVY, COLOR_YUV2RGB_YUY2, COLOR_YUV2BGR_YUY2, COLOR_YUV2RGB_YVYU, + COLOR_YUV2BGR_YVYU, COLOR_YUV2RGBA_YUY2, COLOR_YUV2BGRA_YUY2, COLOR_YUV2RGBA_YVYU, COLOR_YUV2BGRA_YVYU) -CV_ENUM(CvtMode3, CV_RGB2YUV_IYUV, CV_BGR2YUV_IYUV, CV_RGBA2YUV_IYUV, CV_BGRA2YUV_IYUV, - CV_RGB2YUV_YV12, CV_BGR2YUV_YV12, CV_RGBA2YUV_YV12, CV_BGRA2YUV_YV12) +CV_ENUM(CvtMode3, COLOR_RGB2YUV_IYUV, COLOR_BGR2YUV_IYUV, COLOR_RGBA2YUV_IYUV, COLOR_BGRA2YUV_IYUV, + COLOR_RGB2YUV_YV12, COLOR_BGR2YUV_YV12, COLOR_RGBA2YUV_YV12, COLOR_BGRA2YUV_YV12) struct ChPair { @@ -128,74 +128,74 @@ ChPair getConversionInfo(int cvtMode) { switch(cvtMode) { - case CV_BayerBG2GRAY: case CV_BayerGB2GRAY: - case CV_BayerGR2GRAY: case CV_BayerRG2GRAY: - case CV_YUV2GRAY_420: + case COLOR_BayerBG2GRAY: case COLOR_BayerGB2GRAY: + case COLOR_BayerGR2GRAY: case COLOR_BayerRG2GRAY: + case COLOR_YUV2GRAY_420: return ChPair(1,1); - case CV_GRAY2BGR555: case CV_GRAY2BGR565: + case COLOR_GRAY2BGR555: case COLOR_GRAY2BGR565: return ChPair(1,2); - case CV_BayerBG2BGR: case CV_BayerBG2BGR_VNG: - case CV_BayerGB2BGR: case CV_BayerGB2BGR_VNG: - case CV_BayerGR2BGR: case CV_BayerGR2BGR_VNG: - case CV_BayerRG2BGR: case CV_BayerRG2BGR_VNG: - case CV_GRAY2BGR: - case CV_YUV2BGR_NV12: case CV_YUV2RGB_NV12: - case CV_YUV2BGR_NV21: case CV_YUV2RGB_NV21: - case CV_YUV2BGR_YV12: case CV_YUV2RGB_YV12: - case CV_YUV2BGR_IYUV: case CV_YUV2RGB_IYUV: + case COLOR_BayerBG2BGR: case COLOR_BayerBG2BGR_VNG: + case COLOR_BayerGB2BGR: case COLOR_BayerGB2BGR_VNG: + case COLOR_BayerGR2BGR: case COLOR_BayerGR2BGR_VNG: + case COLOR_BayerRG2BGR: case COLOR_BayerRG2BGR_VNG: + case COLOR_GRAY2BGR: + case COLOR_YUV2BGR_NV12: case COLOR_YUV2RGB_NV12: + case COLOR_YUV2BGR_NV21: case COLOR_YUV2RGB_NV21: + case COLOR_YUV2BGR_YV12: case COLOR_YUV2RGB_YV12: + case COLOR_YUV2BGR_IYUV: case COLOR_YUV2RGB_IYUV: return ChPair(1,3); - case CV_GRAY2BGRA: - case CV_YUV2BGRA_NV12: case CV_YUV2RGBA_NV12: - case CV_YUV2BGRA_NV21: case CV_YUV2RGBA_NV21: - case CV_YUV2BGRA_YV12: case CV_YUV2RGBA_YV12: - case CV_YUV2BGRA_IYUV: case CV_YUV2RGBA_IYUV: + case COLOR_GRAY2BGRA: + case COLOR_YUV2BGRA_NV12: case COLOR_YUV2RGBA_NV12: + case COLOR_YUV2BGRA_NV21: case COLOR_YUV2RGBA_NV21: + case COLOR_YUV2BGRA_YV12: case COLOR_YUV2RGBA_YV12: + case COLOR_YUV2BGRA_IYUV: case COLOR_YUV2RGBA_IYUV: return ChPair(1,4); - case CV_BGR5552GRAY: case CV_BGR5652GRAY: + case COLOR_BGR5552GRAY: case COLOR_BGR5652GRAY: return ChPair(2,1); - case CV_BGR5552BGR: case CV_BGR5552RGB: - case CV_BGR5652BGR: case CV_BGR5652RGB: - case CV_YUV2RGB_UYVY: case CV_YUV2BGR_UYVY: - case CV_YUV2RGBA_UYVY: case CV_YUV2BGRA_UYVY: - case CV_YUV2RGB_YUY2: case CV_YUV2BGR_YUY2: - case CV_YUV2RGB_YVYU: case CV_YUV2BGR_YVYU: - case CV_YUV2RGBA_YUY2: case CV_YUV2BGRA_YUY2: - case CV_YUV2RGBA_YVYU: case CV_YUV2BGRA_YVYU: + case COLOR_BGR5552BGR: case COLOR_BGR5552RGB: + case COLOR_BGR5652BGR: case COLOR_BGR5652RGB: + case COLOR_YUV2RGB_UYVY: case COLOR_YUV2BGR_UYVY: + case COLOR_YUV2RGBA_UYVY: case COLOR_YUV2BGRA_UYVY: + case COLOR_YUV2RGB_YUY2: case COLOR_YUV2BGR_YUY2: + case COLOR_YUV2RGB_YVYU: case COLOR_YUV2BGR_YVYU: + case COLOR_YUV2RGBA_YUY2: case COLOR_YUV2BGRA_YUY2: + case COLOR_YUV2RGBA_YVYU: case COLOR_YUV2BGRA_YVYU: return ChPair(2,3); - case CV_BGR5552BGRA: case CV_BGR5552RGBA: - case CV_BGR5652BGRA: case CV_BGR5652RGBA: + case COLOR_BGR5552BGRA: case COLOR_BGR5552RGBA: + case COLOR_BGR5652BGRA: case COLOR_BGR5652RGBA: return ChPair(2,4); - case CV_BGR2GRAY: case CV_RGB2GRAY: - case CV_RGB2YUV_IYUV: case CV_RGB2YUV_YV12: - case CV_BGR2YUV_IYUV: case CV_BGR2YUV_YV12: + case COLOR_BGR2GRAY: case COLOR_RGB2GRAY: + case COLOR_RGB2YUV_IYUV: case COLOR_RGB2YUV_YV12: + case COLOR_BGR2YUV_IYUV: case COLOR_BGR2YUV_YV12: return ChPair(3,1); - case CV_BGR2BGR555: case CV_BGR2BGR565: - case CV_RGB2BGR555: case CV_RGB2BGR565: + case COLOR_BGR2BGR555: case COLOR_BGR2BGR565: + case COLOR_RGB2BGR555: case COLOR_RGB2BGR565: return ChPair(3,2); - case CV_BGR2HLS: case CV_BGR2HLS_FULL: - case CV_BGR2HSV: case CV_BGR2HSV_FULL: - case CV_BGR2Lab: case CV_BGR2Luv: - case CV_BGR2RGB: case CV_BGR2XYZ: - case CV_BGR2YCrCb: case CV_BGR2YUV: - case CV_HLS2BGR: case CV_HLS2BGR_FULL: - case CV_HLS2RGB: case CV_HLS2RGB_FULL: - case CV_HSV2BGR: case CV_HSV2BGR_FULL: - case CV_HSV2RGB: case CV_HSV2RGB_FULL: - case CV_Lab2BGR: case CV_Lab2LBGR: - case CV_Lab2LRGB: case CV_Lab2RGB: - case CV_LBGR2Lab: case CV_LBGR2Luv: - case CV_LRGB2Lab: case CV_LRGB2Luv: - case CV_Luv2BGR: case CV_Luv2LBGR: - case CV_Luv2LRGB: case CV_Luv2RGB: - case CV_RGB2HLS: case CV_RGB2HLS_FULL: - case CV_RGB2HSV: case CV_RGB2HSV_FULL: - case CV_RGB2Lab: case CV_RGB2Luv: - case CV_RGB2XYZ: case CV_RGB2YCrCb: - case CV_RGB2YUV: case CV_XYZ2BGR: - case CV_XYZ2RGB: case CV_YCrCb2BGR: - case CV_YCrCb2RGB: case CV_YUV2BGR: - case CV_YUV2RGB: + case COLOR_BGR2HLS: case COLOR_BGR2HLS_FULL: + case COLOR_BGR2HSV: case COLOR_BGR2HSV_FULL: + case COLOR_BGR2Lab: case COLOR_BGR2Luv: + case COLOR_BGR2RGB: case COLOR_BGR2XYZ: + case COLOR_BGR2YCrCb: case COLOR_BGR2YUV: + case COLOR_HLS2BGR: case COLOR_HLS2BGR_FULL: + case COLOR_HLS2RGB: case COLOR_HLS2RGB_FULL: + case COLOR_HSV2BGR: case COLOR_HSV2BGR_FULL: + case COLOR_HSV2RGB: case COLOR_HSV2RGB_FULL: + case COLOR_Lab2BGR: case COLOR_Lab2LBGR: + case COLOR_Lab2LRGB: case COLOR_Lab2RGB: + case COLOR_LBGR2Lab: case COLOR_LBGR2Luv: + case COLOR_LRGB2Lab: case COLOR_LRGB2Luv: + case COLOR_Luv2BGR: case COLOR_Luv2LBGR: + case COLOR_Luv2LRGB: case COLOR_Luv2RGB: + case COLOR_RGB2HLS: case COLOR_RGB2HLS_FULL: + case COLOR_RGB2HSV: case COLOR_RGB2HSV_FULL: + case COLOR_RGB2Lab: case COLOR_RGB2Luv: + case COLOR_RGB2XYZ: case COLOR_RGB2YCrCb: + case COLOR_RGB2YUV: case COLOR_XYZ2BGR: + case COLOR_XYZ2RGB: case COLOR_YCrCb2BGR: + case COLOR_YCrCb2RGB: case COLOR_YUV2BGR: + case COLOR_YUV2RGB: return ChPair(3,3); - case CV_BGR2BGRA: case CV_BGR2RGBA: + case COLOR_BGR2BGRA: case COLOR_BGR2RGBA: case CX_HLS2BGRA: case CX_HLS2BGRA_FULL: case CX_HLS2RGBA: case CX_HLS2RGBA_FULL: case CX_HSV2BGRA: case CX_HSV2BGRA_FULL: @@ -208,27 +208,27 @@ ChPair getConversionInfo(int cvtMode) case CX_YCrCb2BGRA: case CX_YCrCb2RGBA: case CX_YUV2BGRA: case CX_YUV2RGBA: return ChPair(3,4); - case CV_BGRA2GRAY: case CV_RGBA2GRAY: - case CV_RGBA2YUV_IYUV: case CV_RGBA2YUV_YV12: - case CV_BGRA2YUV_IYUV: case CV_BGRA2YUV_YV12: + case COLOR_BGRA2GRAY: case COLOR_RGBA2GRAY: + case COLOR_RGBA2YUV_IYUV: case COLOR_RGBA2YUV_YV12: + case COLOR_BGRA2YUV_IYUV: case COLOR_BGRA2YUV_YV12: return ChPair(4,1); - case CV_BGRA2BGR555: case CV_BGRA2BGR565: - case CV_RGBA2BGR555: case CV_RGBA2BGR565: + case COLOR_BGRA2BGR555: case COLOR_BGRA2BGR565: + case COLOR_RGBA2BGR555: case COLOR_RGBA2BGR565: return ChPair(4,2); - case CV_BGRA2BGR: case CX_BGRA2HLS: + case COLOR_BGRA2BGR: case CX_BGRA2HLS: case CX_BGRA2HLS_FULL: case CX_BGRA2HSV: case CX_BGRA2HSV_FULL: case CX_BGRA2Lab: case CX_BGRA2Luv: case CX_BGRA2XYZ: case CX_BGRA2YCrCb: case CX_BGRA2YUV: case CX_LBGRA2Lab: case CX_LBGRA2Luv: case CX_LRGBA2Lab: case CX_LRGBA2Luv: - case CV_RGBA2BGR: case CX_RGBA2HLS: + case COLOR_RGBA2BGR: case CX_RGBA2HLS: case CX_RGBA2HLS_FULL: case CX_RGBA2HSV: case CX_RGBA2HSV_FULL: case CX_RGBA2Lab: case CX_RGBA2Luv: case CX_RGBA2XYZ: case CX_RGBA2YCrCb: case CX_RGBA2YUV: return ChPair(4,3); - case CV_BGRA2RGBA: + case COLOR_BGRA2RGBA: return ChPair(4,4); default: ADD_FAILURE() << "Unknown conversion type"; @@ -250,7 +250,7 @@ PERF_TEST_P(Size_CvtMode, cvtColor8u, Size sz = get<0>(GetParam()); int mode = get<1>(GetParam()); ChPair ch = getConversionInfo(mode); - mode %= CV_COLORCVT_MAX; + mode %= COLOR_COLORCVT_MAX; Mat src(sz, CV_8UC(ch.scn)); Mat dst(sz, CV_8UC(ch.dcn)); @@ -276,7 +276,7 @@ PERF_TEST_P(Size_CvtMode_Bayer, cvtColorBayer8u, Size sz = get<0>(GetParam()); int mode = get<1>(GetParam()); ChPair ch = getConversionInfo(mode); - mode %= CV_COLORCVT_MAX; + mode %= COLOR_COLORCVT_MAX; Mat src(sz, CV_8UC(ch.scn)); Mat dst(sz, CV_8UC(ch.dcn)); diff --git a/modules/imgproc/perf/perf_matchTemplate.cpp b/modules/imgproc/perf/perf_matchTemplate.cpp index a89435b535..3ca94ddee7 100644 --- a/modules/imgproc/perf/perf_matchTemplate.cpp +++ b/modules/imgproc/perf/perf_matchTemplate.cpp @@ -6,7 +6,7 @@ using namespace perf; using std::tr1::make_tuple; using std::tr1::get; -CV_ENUM(MethodType, CV_TM_SQDIFF, CV_TM_SQDIFF_NORMED, CV_TM_CCORR, CV_TM_CCORR_NORMED, CV_TM_CCOEFF, CV_TM_CCOEFF_NORMED) +CV_ENUM(MethodType, TM_SQDIFF, TM_SQDIFF_NORMED, TM_CCORR, TM_CCORR_NORMED, TM_CCOEFF, TM_CCOEFF_NORMED) typedef std::tr1::tuple ImgSize_TmplSize_Method_t; typedef perf::TestBaseWithParam ImgSize_TmplSize_Method; @@ -39,9 +39,9 @@ PERF_TEST_P(ImgSize_TmplSize_Method, matchTemplateSmall, TEST_CYCLE() matchTemplate(img, tmpl, result, method); bool isNormed = - method == CV_TM_CCORR_NORMED || - method == CV_TM_SQDIFF_NORMED || - method == CV_TM_CCOEFF_NORMED; + method == TM_CCORR_NORMED || + method == TM_SQDIFF_NORMED || + method == TM_CCOEFF_NORMED; double eps = isNormed ? 1e-6 : 255 * 255 * tmpl.total() * 1e-6; @@ -73,9 +73,9 @@ PERF_TEST_P(ImgSize_TmplSize_Method, matchTemplateBig, TEST_CYCLE() matchTemplate(img, tmpl, result, method); bool isNormed = - method == CV_TM_CCORR_NORMED || - method == CV_TM_SQDIFF_NORMED || - method == CV_TM_CCOEFF_NORMED; + method == TM_CCORR_NORMED || + method == TM_SQDIFF_NORMED || + method == TM_CCOEFF_NORMED; double eps = isNormed ? 1e-6 : 255 * 255 * tmpl.total() * 1e-6; diff --git a/modules/imgproc/src/corner.cpp b/modules/imgproc/src/corner.cpp index fa3021ab8c..8f8c770068 100644 --- a/modules/imgproc/src/corner.cpp +++ b/modules/imgproc/src/corner.cpp @@ -162,7 +162,7 @@ calcHarris( const Mat& _cov, Mat& _dst, double k ) } -void eigen2x2( const float* cov, float* dst, int n ) +static void eigen2x2( const float* cov, float* dst, int n ) { for( int j = 0; j < n; j++ ) { diff --git a/modules/imgproc/src/histogram.cpp b/modules/imgproc/src/histogram.cpp index f768f5cdd5..6357147dfa 100644 --- a/modules/imgproc/src/histogram.cpp +++ b/modules/imgproc/src/histogram.cpp @@ -43,10 +43,6 @@ namespace cv { -template<> void Ptr::delete_obj() -{ cvReleaseHist(&obj); } - - ////////////////// Helper functions ////////////////////// static const size_t OUT_OF_RANGE = (size_t)1 << (sizeof(size_t)*8 - 2); diff --git a/modules/imgproc/src/moments.cpp b/modules/imgproc/src/moments.cpp index c5c9c218a5..edbc101014 100644 --- a/modules/imgproc/src/moments.cpp +++ b/modules/imgproc/src/moments.cpp @@ -354,25 +354,6 @@ Moments::Moments( double _m00, double _m10, double _m01, double _m20, double _m1 nu30 = mu30*s3; nu21 = mu21*s3; nu12 = mu12*s3; nu03 = mu03*s3; } -Moments::Moments( const CvMoments& m ) -{ - *this = Moments(m.m00, m.m10, m.m01, m.m20, m.m11, m.m02, m.m30, m.m21, m.m12, m.m03); -} - -Moments::operator CvMoments() const -{ - CvMoments m; - m.m00 = m00; m.m10 = m10; m.m01 = m01; - m.m20 = m20; m.m11 = m11; m.m02 = m02; - m.m30 = m30; m.m21 = m21; m.m12 = m12; m.m03 = m03; - m.mu20 = mu20; m.mu11 = mu11; m.mu02 = mu02; - m.mu30 = mu30; m.mu21 = mu21; m.mu12 = mu12; m.mu03 = mu03; - double am00 = std::abs(m00); - m.inv_sqrt_m00 = am00 > DBL_EPSILON ? 1./std::sqrt(am00) : 0; - - return m; -} - } diff --git a/modules/imgproc/src/morph.cpp b/modules/imgproc/src/morph.cpp index 4a939d9bb7..b4e08a6fb8 100644 --- a/modules/imgproc/src/morph.cpp +++ b/modules/imgproc/src/morph.cpp @@ -1191,9 +1191,6 @@ static void morphOp( int op, InputArray _src, OutputArray _dst, // f->apply( dst, dst ); } -template<> void Ptr::delete_obj() -{ cvReleaseStructuringElement(&obj); } - } void cv::erode( InputArray src, OutputArray dst, InputArray kernel, diff --git a/modules/legacy/include/opencv2/legacy.hpp b/modules/legacy/include/opencv2/legacy.hpp index 499566c054..29714f25eb 100644 --- a/modules/legacy/include/opencv2/legacy.hpp +++ b/modules/legacy/include/opencv2/legacy.hpp @@ -42,7 +42,6 @@ #ifndef __OPENCV_LEGACY_HPP__ #define __OPENCV_LEGACY_HPP__ -#include "opencv2/imgproc.hpp" #include "opencv2/imgproc/imgproc_c.h" #include "opencv2/features2d.hpp" #include "opencv2/calib3d.hpp" diff --git a/modules/legacy/include/opencv2/legacy/legacy.hpp b/modules/legacy/include/opencv2/legacy/legacy.hpp index fafad10a1c..adea8da005 100644 --- a/modules/legacy/include/opencv2/legacy/legacy.hpp +++ b/modules/legacy/include/opencv2/legacy/legacy.hpp @@ -45,4 +45,4 @@ #error this is a compatibility header which should not be used inside the OpenCV library #endif -#include "opencv2/legacy.hpp" \ No newline at end of file +#include "opencv2/legacy.hpp" diff --git a/modules/nonfree/test/test_detectors.cpp b/modules/nonfree/test/test_detectors.cpp index e675d3f99e..60d1bc1de3 100644 --- a/modules/nonfree/test/test_detectors.cpp +++ b/modules/nonfree/test/test_detectors.cpp @@ -113,7 +113,7 @@ void showOrig(const Mat& img, const vector& orig_pts) { Mat img_color; - cvtColor(img, img_color, CV_GRAY2BGR); + cvtColor(img, img_color, COLOR_GRAY2BGR); for(size_t i = 0; i < orig_pts.size(); ++i) circle(img_color, orig_pts[i].pt, (int)orig_pts[i].size/2, CV_RGB(0, 255, 0)); @@ -125,7 +125,7 @@ void show(const string& name, const Mat& new_img, const vector& new_pt { Mat new_img_color; - cvtColor(new_img, new_img_color, CV_GRAY2BGR); + cvtColor(new_img, new_img_color, COLOR_GRAY2BGR); for(size_t i = 0; i < transf_pts.size(); ++i) circle(new_img_color, transf_pts[i].pt, (int)transf_pts[i].size/2, CV_RGB(255, 0, 0)); diff --git a/modules/objdetect/test/test_cascadeandhog.cpp b/modules/objdetect/test/test_cascadeandhog.cpp index 9fb1006221..1366fa2f3b 100644 --- a/modules/objdetect/test/test_cascadeandhog.cpp +++ b/modules/objdetect/test/test_cascadeandhog.cpp @@ -434,7 +434,7 @@ int CV_CascadeDetectorTest::detectMultiScale_C( const string& filename, return cvtest::TS::FAIL_INVALID_TEST_DATA; } Mat grayImg; - cvtColor( img, grayImg, CV_BGR2GRAY ); + cvtColor( img, grayImg, COLOR_BGR2GRAY ); equalizeHist( grayImg, grayImg ); CvMat c_gray = grayImg; @@ -469,7 +469,7 @@ int CV_CascadeDetectorTest::detectMultiScale( int di, const Mat& img, return cvtest::TS::FAIL_INVALID_TEST_DATA; } Mat grayImg; - cvtColor( img, grayImg, CV_BGR2GRAY ); + cvtColor( img, grayImg, COLOR_BGR2GRAY ); equalizeHist( grayImg, grayImg ); cascade.detectMultiScale( grayImg, objects, 1.1, 3, flags[di] ); return cvtest::TS::OK; diff --git a/modules/ocl/include/opencv2/ocl/private/util.hpp b/modules/ocl/include/opencv2/ocl/private/util.hpp index 83992b1fd7..982084b7e0 100644 --- a/modules/ocl/include/opencv2/ocl/private/util.hpp +++ b/modules/ocl/include/opencv2/ocl/private/util.hpp @@ -46,14 +46,14 @@ #ifndef __OPENCV_OCL_PRIVATE_UTIL__ #define __OPENCV_OCL_PRIVATE_UTIL__ -#include "opencv2/ocl.hpp" - #if defined __APPLE__ #include #else #include #endif +#include "opencv2/ocl.hpp" + namespace cv { namespace ocl diff --git a/modules/ocl/perf/perf_color.cpp b/modules/ocl/perf/perf_color.cpp index e32a1839d8..1e05013aca 100644 --- a/modules/ocl/perf/perf_color.cpp +++ b/modules/ocl/perf/perf_color.cpp @@ -60,26 +60,26 @@ TEST(cvtColor) gen(src, size, size, all_type[j], 0, 256); SUBTEST << size << "x" << size << "; " << type_name[j] << " ; CV_RGBA2GRAY"; - cvtColor(src, dst, CV_RGBA2GRAY, 4); + cvtColor(src, dst, COLOR_RGBA2GRAY, 4); CPU_ON; - cvtColor(src, dst, CV_RGBA2GRAY, 4); + cvtColor(src, dst, COLOR_RGBA2GRAY, 4); CPU_OFF; d_src.upload(src); WARMUP_ON; - ocl::cvtColor(d_src, d_dst, CV_RGBA2GRAY, 4); + ocl::cvtColor(d_src, d_dst, COLOR_RGBA2GRAY, 4); WARMUP_OFF; GPU_ON; - ocl::cvtColor(d_src, d_dst, CV_RGBA2GRAY, 4); + ocl::cvtColor(d_src, d_dst, COLOR_RGBA2GRAY, 4); ; GPU_OFF; GPU_FULL_ON; d_src.upload(src); - ocl::cvtColor(d_src, d_dst, CV_RGBA2GRAY, 4); + ocl::cvtColor(d_src, d_dst, COLOR_RGBA2GRAY, 4); d_dst.download(dst); GPU_FULL_OFF; } diff --git a/modules/ocl/perf/perf_match_template.cpp b/modules/ocl/perf/perf_match_template.cpp index 2828efe01a..a0c94e8e47 100644 --- a/modules/ocl/perf/perf_match_template.cpp +++ b/modules/ocl/perf/perf_match_template.cpp @@ -75,10 +75,10 @@ TEST(matchTemplate) gen(templ, templ_size, templ_size, all_type[j], 0, 1); - matchTemplate(src, templ, dst, CV_TM_CCORR); + matchTemplate(src, templ, dst, TM_CCORR); CPU_ON; - matchTemplate(src, templ, dst, CV_TM_CCORR); + matchTemplate(src, templ, dst, TM_CCORR); CPU_OFF; ocl::oclMat d_src(src), d_templ, d_dst; @@ -86,18 +86,18 @@ TEST(matchTemplate) d_templ.upload(templ); WARMUP_ON; - ocl::matchTemplate(d_src, d_templ, d_dst, CV_TM_CCORR); + ocl::matchTemplate(d_src, d_templ, d_dst, TM_CCORR); WARMUP_OFF; GPU_ON; - ocl::matchTemplate(d_src, d_templ, d_dst, CV_TM_CCORR); + ocl::matchTemplate(d_src, d_templ, d_dst, TM_CCORR); ; GPU_OFF; GPU_FULL_ON; d_src.upload(src); d_templ.upload(templ); - ocl::matchTemplate(d_src, d_templ, d_dst, CV_TM_CCORR); + ocl::matchTemplate(d_src, d_templ, d_dst, TM_CCORR); d_dst.download(dst); GPU_FULL_OFF; } @@ -116,28 +116,28 @@ TEST(matchTemplate) gen(templ, templ_size, templ_size, all_type_8U[j], 0, 255); - matchTemplate(src, templ, dst, CV_TM_CCORR_NORMED); + matchTemplate(src, templ, dst, TM_CCORR_NORMED); CPU_ON; - matchTemplate(src, templ, dst, CV_TM_CCORR_NORMED); + matchTemplate(src, templ, dst, TM_CCORR_NORMED); CPU_OFF; ocl::oclMat d_src(src); ocl::oclMat d_templ(templ), d_dst; WARMUP_ON; - ocl::matchTemplate(d_src, d_templ, d_dst, CV_TM_CCORR_NORMED); + ocl::matchTemplate(d_src, d_templ, d_dst, TM_CCORR_NORMED); WARMUP_OFF; GPU_ON; - ocl::matchTemplate(d_src, d_templ, d_dst, CV_TM_CCORR_NORMED); + ocl::matchTemplate(d_src, d_templ, d_dst, TM_CCORR_NORMED); ; GPU_OFF; GPU_FULL_ON; d_src.upload(src); d_templ.upload(templ); - ocl::matchTemplate(d_src, d_templ, d_dst, CV_TM_CCORR_NORMED); + ocl::matchTemplate(d_src, d_templ, d_dst, TM_CCORR_NORMED); d_dst.download(dst); GPU_FULL_OFF; } diff --git a/modules/ocl/test/test_color.cpp b/modules/ocl/test/test_color.cpp index 202967b7a6..d70535dca5 100644 --- a/modules/ocl/test/test_color.cpp +++ b/modules/ocl/test/test_color.cpp @@ -44,6 +44,9 @@ //M*/ #include "precomp.hpp" + +using namespace cv; + #ifdef HAVE_OPENCL //#define MAT_DEBUG @@ -181,13 +184,13 @@ INSTANTIATE_TEST_CASE_P(OCL_ImgProc, CvtColor, testing::Combine( INSTANTIATE_TEST_CASE_P(OCL_ImgProc, CvtColor_YUV420, testing::Combine( testing::Values(cv::Size(128, 45), cv::Size(46, 132), cv::Size(1024, 1023)), - testing::Values((int)CV_YUV2RGBA_NV12, (int)CV_YUV2BGRA_NV12, (int)CV_YUV2RGB_NV12, (int)CV_YUV2BGR_NV12) + testing::Values((int)COLOR_YUV2RGBA_NV12, (int)COLOR_YUV2BGRA_NV12, (int)COLOR_YUV2RGB_NV12, (int)COLOR_YUV2BGR_NV12) )); INSTANTIATE_TEST_CASE_P(OCL_ImgProc, CvtColor_Gray2RGB, testing::Combine( DIFFERENT_SIZES, testing::Values(MatDepth(CV_8U), MatDepth(CV_16U), MatDepth(CV_32F)), - testing::Values((int)CV_GRAY2BGR, (int)CV_GRAY2BGRA, (int)CV_GRAY2RGB, (int)CV_GRAY2RGBA) + testing::Values((int)COLOR_GRAY2BGR, (int)COLOR_GRAY2BGRA, (int)COLOR_GRAY2RGB, (int)COLOR_GRAY2RGBA) )); } #endif diff --git a/modules/ocl/test/test_haar.cpp b/modules/ocl/test/test_haar.cpp index 6d2a912c24..b10d34b525 100644 --- a/modules/ocl/test/test_haar.cpp +++ b/modules/ocl/test/test_haar.cpp @@ -121,7 +121,7 @@ TEST_F(Haar, FaceDetect) Mat gray, smallImg(cvRound (img.rows / scale), cvRound(img.cols / scale), CV_8UC1 ); MemStorage storage(cvCreateMemStorage(0)); - cvtColor( img, gray, CV_BGR2GRAY ); + cvtColor( img, gray, COLOR_BGR2GRAY ); resize( gray, smallImg, smallImg.size(), 0, 0, INTER_LINEAR ); equalizeHist( smallImg, smallImg ); diff --git a/modules/ocl/test/test_hog.cpp b/modules/ocl/test/test_hog.cpp index 9c27c88032..f064ee3a76 100644 --- a/modules/ocl/test/test_hog.cpp +++ b/modules/ocl/test/test_hog.cpp @@ -44,7 +44,7 @@ //M*/ #include "precomp.hpp" -#include "opencv2/core.hpp" + using namespace std; #ifdef HAVE_OPENCL @@ -71,11 +71,11 @@ TEST_P(HOG, GetDescriptors) switch (type) { case CV_8UC1: - cv::cvtColor(img_rgb, img, CV_BGR2GRAY); + cv::cvtColor(img_rgb, img, cv::COLOR_BGR2GRAY); break; case CV_8UC4: default: - cv::cvtColor(img_rgb, img, CV_BGR2BGRA); + cv::cvtColor(img_rgb, img, cv::COLOR_BGR2BGRA); break; } cv::ocl::oclMat d_img(img); @@ -128,11 +128,11 @@ TEST_P(HOG, Detect) switch (type) { case CV_8UC1: - cv::cvtColor(img_rgb, img, CV_BGR2GRAY); + cv::cvtColor(img_rgb, img, cv::COLOR_BGR2GRAY); break; case CV_8UC4: default: - cv::cvtColor(img_rgb, img, CV_BGR2BGRA); + cv::cvtColor(img_rgb, img, cv::COLOR_BGR2BGRA); break; } cv::ocl::oclMat d_img(img); diff --git a/modules/ocl/test/utility.cpp b/modules/ocl/test/utility.cpp index 4b21081a8b..9873a88553 100644 --- a/modules/ocl/test/utility.cpp +++ b/modules/ocl/test/utility.cpp @@ -245,7 +245,7 @@ double checkNorm(const Mat &m1, const Mat &m2) double checkSimilarity(const Mat &m1, const Mat &m2) { Mat diff; - matchTemplate(m1, m2, diff, CV_TM_CCORR_NORMED); + matchTemplate(m1, m2, diff, TM_CCORR_NORMED); return std::abs(diff.at(0, 0) - 1.f); } diff --git a/modules/photo/src/denoising.cpp b/modules/photo/src/denoising.cpp index 299390f154..b2349ba273 100644 --- a/modules/photo/src/denoising.cpp +++ b/modules/photo/src/denoising.cpp @@ -93,7 +93,7 @@ void cv::fastNlMeansDenoisingColored( InputArray _src, OutputArray _dst, } Mat src_lab; - cvtColor(src, src_lab, CV_LBGR2Lab); + cvtColor(src, src_lab, COLOR_LBGR2Lab); Mat l(src.size(), CV_8U); Mat ab(src.size(), CV_8UC2); @@ -108,7 +108,7 @@ void cv::fastNlMeansDenoisingColored( InputArray _src, OutputArray _dst, Mat dst_lab(src.size(), src.type()); mixChannels(l_ab_denoised, 2, &dst_lab, 1, from_to, 3); - cvtColor(dst_lab, dst, CV_Lab2LBGR); + cvtColor(dst_lab, dst, COLOR_Lab2LBGR); } static void fastNlMeansDenoisingMultiCheckPreconditions( @@ -215,7 +215,7 @@ void cv::fastNlMeansDenoisingColoredMulti( InputArrayOfArrays _srcImgs, OutputAr src_lab[i] = Mat::zeros(srcImgs[0].size(), CV_8UC3); l[i] = Mat::zeros(srcImgs[0].size(), CV_8UC1); ab[i] = Mat::zeros(srcImgs[0].size(), CV_8UC2); - cvtColor(srcImgs[i], src_lab[i], CV_LBGR2Lab); + cvtColor(srcImgs[i], src_lab[i], COLOR_LBGR2Lab); Mat l_ab[] = { l[i], ab[i] }; mixChannels(&src_lab[i], 1, l_ab, 2, from_to, 3); @@ -236,7 +236,7 @@ void cv::fastNlMeansDenoisingColoredMulti( InputArrayOfArrays _srcImgs, OutputAr Mat dst_lab(srcImgs[0].size(), srcImgs[0].type()); mixChannels(l_ab_denoised, 2, &dst_lab, 1, from_to, 3); - cvtColor(dst_lab, dst, CV_Lab2LBGR); + cvtColor(dst_lab, dst, COLOR_Lab2LBGR); } diff --git a/modules/photo/src/inpaint.cpp b/modules/photo/src/inpaint.cpp index 672e6c05ab..ce05fc3d1a 100644 --- a/modules/photo/src/inpaint.cpp +++ b/modules/photo/src/inpaint.cpp @@ -716,6 +716,12 @@ icvNSInpaintFMM(const CvMat *f, CvMat *t, CvMat *out, int range, CvPriorityQueue }\ } +namespace cv { +template<> void cv::Ptr::delete_obj() +{ + cvReleaseStructuringElement(&obj); +} +} void cvInpaint( const CvArr* _input_img, const CvArr* _inpaint_mask, CvArr* _output_img, diff --git a/modules/photo/test/test_inpaint.cpp b/modules/photo/test/test_inpaint.cpp index 2bdb2ddaa5..ef7132d6da 100644 --- a/modules/photo/test/test_inpaint.cpp +++ b/modules/photo/test/test_inpaint.cpp @@ -78,7 +78,7 @@ void CV_InpaintTest::run( int ) mask.convertTo(inv_mask, CV_8UC3, -1.0, 255.0); Mat mask1ch; - cv::cvtColor(mask, mask1ch, CV_BGR2GRAY); + cv::cvtColor(mask, mask1ch, COLOR_BGR2GRAY); Mat test = orig.clone(); test.setTo(Scalar::all(255), mask1ch); diff --git a/modules/stitching/src/blenders.cpp b/modules/stitching/src/blenders.cpp index dc7d1da618..a91e39b480 100644 --- a/modules/stitching/src/blenders.cpp +++ b/modules/stitching/src/blenders.cpp @@ -425,7 +425,7 @@ void normalizeUsingWeightMap(const Mat& weight, Mat& src) void createWeightMap(const Mat &mask, float sharpness, Mat &weight) { CV_Assert(mask.type() == CV_8U); - distanceTransform(mask, weight, CV_DIST_L1, 3); + distanceTransform(mask, weight, DIST_L1, 3); threshold(weight * sharpness, weight, 1.f, 1.f, THRESH_TRUNC); } diff --git a/modules/stitching/src/matchers.cpp b/modules/stitching/src/matchers.cpp index b564193eb3..65f2a0030e 100644 --- a/modules/stitching/src/matchers.cpp +++ b/modules/stitching/src/matchers.cpp @@ -350,7 +350,7 @@ void SurfFeaturesFinder::find(const Mat &image, ImageFeatures &features) CV_Assert((image.type() == CV_8UC3) || (image.type() == CV_8UC1)); if(image.type() == CV_8UC3) { - cvtColor(image, gray_image, CV_BGR2GRAY); + cvtColor(image, gray_image, COLOR_BGR2GRAY); } else { @@ -382,9 +382,9 @@ void OrbFeaturesFinder::find(const Mat &image, ImageFeatures &features) CV_Assert((image.type() == CV_8UC3) || (image.type() == CV_8UC4) || (image.type() == CV_8UC1)); if (image.type() == CV_8UC3) { - cvtColor(image, gray_image, CV_BGR2GRAY); + cvtColor(image, gray_image, COLOR_BGR2GRAY); } else if (image.type() == CV_8UC4) { - cvtColor(image, gray_image, CV_BGRA2GRAY); + cvtColor(image, gray_image, COLOR_BGRA2GRAY); } else if (image.type() == CV_8UC1) { gray_image=image; } else { @@ -457,7 +457,7 @@ void SurfFeaturesFinderGpu::find(const Mat &image, ImageFeatures &features) image_.upload(image); ensureSizeIsEnough(image.size(), CV_8UC1, gray_image_); - cvtColor(image_, gray_image_, CV_BGR2GRAY); + cvtColor(image_, gray_image_, COLOR_BGR2GRAY); surf_.nOctaves = num_octaves_; surf_.nOctaveLayers = num_layers_; diff --git a/modules/stitching/src/seam_finders.cpp b/modules/stitching/src/seam_finders.cpp index d55fc70b78..3ecef1c787 100644 --- a/modules/stitching/src/seam_finders.cpp +++ b/modules/stitching/src/seam_finders.cpp @@ -139,8 +139,8 @@ void VoronoiSeamFinder::findInPair(size_t first, size_t second, Rect roi) Mat unique2 = submask2.clone(); unique2.setTo(0, collision); Mat dist1, dist2; - distanceTransform(unique1 == 0, dist1, CV_DIST_L1, 3); - distanceTransform(unique2 == 0, dist2, CV_DIST_L1, 3); + distanceTransform(unique1 == 0, dist1, DIST_L1, 3); + distanceTransform(unique2 == 0, dist2, DIST_L1, 3); Mat seam = dist1 < dist2; @@ -522,17 +522,17 @@ void DpSeamFinder::computeGradients(const Mat &image1, const Mat &image2) Mat gray; if (image1.channels() == 3) - cvtColor(image1, gray, CV_BGR2GRAY); + cvtColor(image1, gray, COLOR_BGR2GRAY); else if (image1.channels() == 4) - cvtColor(image1, gray, CV_BGRA2GRAY); + cvtColor(image1, gray, COLOR_BGRA2GRAY); Sobel(gray, gradx1_, CV_32F, 1, 0); Sobel(gray, grady1_, CV_32F, 0, 1); if (image2.channels() == 3) - cvtColor(image2, gray, CV_BGR2GRAY); + cvtColor(image2, gray, COLOR_BGR2GRAY); else if (image2.channels() == 4) - cvtColor(image2, gray, CV_BGRA2GRAY); + cvtColor(image2, gray, COLOR_BGRA2GRAY); Sobel(gray, gradx2_, CV_32F, 1, 0); Sobel(gray, grady2_, CV_32F, 0, 1); diff --git a/modules/ts/src/gpu_test.cpp b/modules/ts/src/gpu_test.cpp index 6f839c341c..4847dbc383 100644 --- a/modules/ts/src/gpu_test.cpp +++ b/modules/ts/src/gpu_test.cpp @@ -330,7 +330,7 @@ namespace cvtest double checkSimilarity(InputArray m1, InputArray m2) { Mat diff; - matchTemplate(getMat(m1), getMat(m2), diff, CV_TM_CCORR_NORMED); + matchTemplate(getMat(m1), getMat(m2), diff, TM_CCORR_NORMED); return std::abs(diff.at(0, 0) - 1.f); } diff --git a/modules/video/include/opencv2/video/tracking.hpp b/modules/video/include/opencv2/video/tracking.hpp index dbccfae748..af3c423f50 100644 --- a/modules/video/include/opencv2/video/tracking.hpp +++ b/modules/video/include/opencv2/video/tracking.hpp @@ -45,8 +45,10 @@ #ifdef __cplusplus # include "opencv2/core.hpp" +# include "opencv2/imgproc.hpp" #endif -#include "opencv2/imgproc.hpp" + +#include "opencv2/imgproc/imgproc_c.h" #ifdef __cplusplus extern "C" { diff --git a/samples/c/delaunay.c b/samples/c/delaunay.c index 21fe340a3a..1f09efef90 100644 --- a/samples/c/delaunay.c +++ b/samples/c/delaunay.c @@ -1,6 +1,6 @@ #include -#include -#include "opencv2/highgui/highgui.hpp" +#include +#include #include static void help( void ) diff --git a/samples/c/facedetect.cpp b/samples/c/facedetect.cpp index 8976a9cdcd..7d02ac95dd 100644 --- a/samples/c/facedetect.cpp +++ b/samples/c/facedetect.cpp @@ -207,7 +207,7 @@ void detectAndDraw( Mat& img, CascadeClassifier& cascade, CV_RGB(255,0,255)} ; Mat gray, smallImg( cvRound (img.rows/scale), cvRound(img.cols/scale), CV_8UC1 ); - cvtColor( img, gray, CV_BGR2GRAY ); + cvtColor( img, gray, COLOR_BGR2GRAY ); resize( gray, smallImg, smallImg.size(), 0, 0, INTER_LINEAR ); equalizeHist( smallImg, smallImg ); diff --git a/samples/c/polar_transforms.c b/samples/c/polar_transforms.c index d6915d488c..8ce4831637 100644 --- a/samples/c/polar_transforms.c +++ b/samples/c/polar_transforms.c @@ -1,7 +1,5 @@ -#include "opencv2/imgproc/imgproc.hpp" -#include "opencv2/highgui/highgui.hpp" - #include "opencv2/imgproc/imgproc_c.h" +#include "opencv2/highgui/highgui_c.h" #include #include diff --git a/samples/c/pyramid_segmentation.c b/samples/c/pyramid_segmentation.c index 780dc9f301..c15c7cd0c0 100644 --- a/samples/c/pyramid_segmentation.c +++ b/samples/c/pyramid_segmentation.c @@ -1,7 +1,6 @@ -#include "opencv2/imgproc/imgproc.hpp" -#include "opencv2/highgui/highgui.hpp" #include "opencv2/imgproc/imgproc_c.h" -#include "opencv2/legacy/legacy.hpp" +#include "opencv2/highgui/highgui_c.h" +#include "opencv2/legacy.hpp" #include static void help(void) diff --git a/samples/c/smiledetect.cpp b/samples/c/smiledetect.cpp index 214ae94127..07c482147f 100644 --- a/samples/c/smiledetect.cpp +++ b/samples/c/smiledetect.cpp @@ -167,7 +167,7 @@ void detectAndDraw( Mat& img, CascadeClassifier& cascade, CV_RGB(255,0,255)} ; Mat gray, smallImg( cvRound (img.rows/scale), cvRound(img.cols/scale), CV_8UC1 ); - cvtColor( img, gray, CV_BGR2GRAY ); + cvtColor( img, gray, COLOR_BGR2GRAY ); resize( gray, smallImg, smallImg.size(), 0, 0, INTER_LINEAR ); equalizeHist( smallImg, smallImg ); diff --git a/samples/cpp/3calibration.cpp b/samples/cpp/3calibration.cpp index 061e977952..24e9e2686e 100644 --- a/samples/cpp/3calibration.cpp +++ b/samples/cpp/3calibration.cpp @@ -271,7 +271,7 @@ int main( int argc, char** argv ) { vector ptvec; imageSize = view.size(); - cvtColor(view, viewGray, CV_BGR2GRAY); + cvtColor(view, viewGray, COLOR_BGR2GRAY); bool found = findChessboardCorners( view, boardSize, ptvec, CV_CALIB_CB_ADAPTIVE_THRESH ); drawChessboardCorners( view, boardSize, Mat(ptvec), found ); @@ -359,7 +359,7 @@ int main( int argc, char** argv ) continue; Mat rview = canvas.colRange(k2*imageSize.width, (k2+1)*imageSize.width); - remap(view, rview, map1[k1], map2[k1], CV_INTER_LINEAR); + remap(view, rview, map1[k1], map2[k1], INTER_LINEAR); } printf("%s %s %s\n", imageList[i*3].c_str(), imageList[i*3+1].c_str(), imageList[i*3+2].c_str()); resize( canvas, small_canvas, Size(1500, 1500/3) ); diff --git a/samples/cpp/build3dmodel.cpp b/samples/cpp/build3dmodel.cpp index 5535a5fb8c..7150064a47 100644 --- a/samples/cpp/build3dmodel.cpp +++ b/samples/cpp/build3dmodel.cpp @@ -509,7 +509,7 @@ static void build3dmodel( const Ptr& detector, for( size_t i = 0; i < nimages; i++ ) { Mat img = imread(imageList[i], 1), gray; - cvtColor(img, gray, CV_BGR2GRAY); + cvtColor(img, gray, COLOR_BGR2GRAY); vector keypoints; detector->detect(gray, keypoints); diff --git a/samples/cpp/calibration.cpp b/samples/cpp/calibration.cpp index 8cbf6c5387..8cb982912c 100644 --- a/samples/cpp/calibration.cpp +++ b/samples/cpp/calibration.cpp @@ -462,7 +462,7 @@ int main( int argc, char** argv ) flip( view, view, 0 ); vector pointbuf; - cvtColor(view, viewGray, CV_BGR2GRAY); + cvtColor(view, viewGray, COLOR_BGR2GRAY); bool found; switch( pattern ) diff --git a/samples/cpp/chamfer.cpp b/samples/cpp/chamfer.cpp index a7d3578d4d..ab211f33a5 100644 --- a/samples/cpp/chamfer.cpp +++ b/samples/cpp/chamfer.cpp @@ -41,7 +41,7 @@ int main( int argc, const char** argv ) return -1; } Mat cimg; - cvtColor(img, cimg, CV_GRAY2BGR); + cvtColor(img, cimg, COLOR_GRAY2BGR); // if the image and the template are not edge maps but normal grayscale images, // you might want to uncomment the lines below to produce the maps. You can also diff --git a/samples/cpp/detection_based_tracker_sample.cpp b/samples/cpp/detection_based_tracker_sample.cpp index 50dffea569..1debff7e3f 100644 --- a/samples/cpp/detection_based_tracker_sample.cpp +++ b/samples/cpp/detection_based_tracker_sample.cpp @@ -144,7 +144,7 @@ static int test_FaceDetector(int argc, char *argv[]) LOGD("\n\nSTEP n=%d from prev step %f ms\n", n, t_ms); m=images[n-1]; CV_Assert(! m.empty()); - cvtColor(m, gray, CV_BGR2GRAY); + cvtColor(m, gray, COLOR_BGR2GRAY); fd.process(gray); diff --git a/samples/cpp/distrans.cpp b/samples/cpp/distrans.cpp index 71ed71a984..1bd85bbc2b 100644 --- a/samples/cpp/distrans.cpp +++ b/samples/cpp/distrans.cpp @@ -7,10 +7,10 @@ using namespace std; using namespace cv; -int maskSize0 = CV_DIST_MASK_5; +int maskSize0 = DIST_MASK_5; int voronoiType = -1; int edgeThresh = 100; -int distType0 = CV_DIST_L1; +int distType0 = DIST_L1; // The output and temporary images Mat gray; @@ -31,8 +31,8 @@ static void onTrackbar( int, void* ) Scalar(255,0,255) }; - int maskSize = voronoiType >= 0 ? CV_DIST_MASK_5 : maskSize0; - int distType = voronoiType >= 0 ? CV_DIST_L2 : distType0; + int maskSize = voronoiType >= 0 ? DIST_MASK_5 : maskSize0; + int distType = voronoiType >= 0 ? DIST_L2 : distType0; Mat edge = gray >= edgeThresh, dist, labels, dist8u; @@ -140,17 +140,17 @@ int main( int argc, const char** argv ) voronoiType = -1; if( c == 'c' || c == 'C' ) - distType0 = CV_DIST_C; + distType0 = DIST_C; else if( c == '1' ) - distType0 = CV_DIST_L1; + distType0 = DIST_L1; else if( c == '2' ) - distType0 = CV_DIST_L2; + distType0 = DIST_L2; else if( c == '3' ) - maskSize0 = CV_DIST_MASK_3; + maskSize0 = DIST_MASK_3; else if( c == '5' ) - maskSize0 = CV_DIST_MASK_5; + maskSize0 = DIST_MASK_5; else if( c == '0' ) - maskSize0 = CV_DIST_MASK_PRECISE; + maskSize0 = DIST_MASK_PRECISE; else if( c == 'v' ) voronoiType = 0; else if( c == 'p' ) @@ -162,18 +162,18 @@ int main( int argc, const char** argv ) else if( voronoiType == 1 ) { voronoiType = -1; - maskSize0 = CV_DIST_MASK_3; - distType0 = CV_DIST_C; + maskSize0 = DIST_MASK_3; + distType0 = DIST_C; } - else if( distType0 == CV_DIST_C ) - distType0 = CV_DIST_L1; - else if( distType0 == CV_DIST_L1 ) - distType0 = CV_DIST_L2; - else if( maskSize0 == CV_DIST_MASK_3 ) - maskSize0 = CV_DIST_MASK_5; - else if( maskSize0 == CV_DIST_MASK_5 ) - maskSize0 = CV_DIST_MASK_PRECISE; - else if( maskSize0 == CV_DIST_MASK_PRECISE ) + else if( distType0 == DIST_C ) + distType0 = DIST_L1; + else if( distType0 == DIST_L1 ) + distType0 = DIST_L2; + else if( maskSize0 == DIST_MASK_3 ) + maskSize0 = DIST_MASK_5; + else if( maskSize0 == DIST_MASK_5 ) + maskSize0 = DIST_MASK_PRECISE; + else if( maskSize0 == DIST_MASK_PRECISE ) voronoiType = 0; } } diff --git a/samples/cpp/edge.cpp b/samples/cpp/edge.cpp index 0944c90ee2..262833c672 100644 --- a/samples/cpp/edge.cpp +++ b/samples/cpp/edge.cpp @@ -50,7 +50,7 @@ int main( int argc, const char** argv ) return -1; } cedge.create(image.size(), image.type()); - cvtColor(image, gray, CV_BGR2GRAY); + cvtColor(image, gray, COLOR_BGR2GRAY); // Create a window namedWindow("Edge map", 1); diff --git a/samples/cpp/ffilldemo.cpp b/samples/cpp/ffilldemo.cpp index a7fff778fd..bb207c307e 100644 --- a/samples/cpp/ffilldemo.cpp +++ b/samples/cpp/ffilldemo.cpp @@ -41,7 +41,7 @@ static void onMouse( int event, int x, int y, int, void* ) int lo = ffillMode == 0 ? 0 : loDiff; int up = ffillMode == 0 ? 0 : upDiff; int flags = connectivity + (newMaskVal << 8) + - (ffillMode == 1 ? CV_FLOODFILL_FIXED_RANGE : 0); + (ffillMode == 1 ? FLOODFILL_FIXED_RANGE : 0); int b = (unsigned)theRNG() & 255; int g = (unsigned)theRNG() & 255; int r = (unsigned)theRNG() & 255; @@ -53,7 +53,7 @@ static void onMouse( int event, int x, int y, int, void* ) if( useMask ) { - threshold(mask, mask, 1, 128, CV_THRESH_BINARY); + threshold(mask, mask, 1, 128, THRESH_BINARY); area = floodFill(dst, mask, seed, newVal, &ccomp, Scalar(lo, lo, lo), Scalar(up, up, up), flags); imshow( "mask", mask ); @@ -81,7 +81,7 @@ int main( int argc, char** argv ) } help(); image0.copyTo(image); - cvtColor(image0, gray, CV_BGR2GRAY); + cvtColor(image0, gray, COLOR_BGR2GRAY); mask.create(image0.rows+2, image0.cols+2, CV_8UC1); namedWindow( "image", 0 ); @@ -106,7 +106,7 @@ int main( int argc, char** argv ) if( isColor ) { cout << "Grayscale mode is set\n"; - cvtColor(image0, gray, CV_BGR2GRAY); + cvtColor(image0, gray, COLOR_BGR2GRAY); mask = Scalar::all(0); isColor = false; } @@ -135,7 +135,7 @@ int main( int argc, char** argv ) case 'r': cout << "Original image is restored\n"; image0.copyTo(image); - cvtColor(image, gray, CV_BGR2GRAY); + cvtColor(image, gray, COLOR_BGR2GRAY); mask = Scalar::all(0); break; case 's': diff --git a/samples/cpp/fitellipse.cpp b/samples/cpp/fitellipse.cpp index 55f9e4ab06..2fa62b8e46 100644 --- a/samples/cpp/fitellipse.cpp +++ b/samples/cpp/fitellipse.cpp @@ -64,7 +64,7 @@ void processImage(int /*h*/, void*) vector > contours; Mat bimage = image >= sliderPos; - findContours(bimage, contours, CV_RETR_LIST, CV_CHAIN_APPROX_NONE); + findContours(bimage, contours, RETR_LIST, CHAIN_APPROX_NONE); Mat cimage = Mat::zeros(bimage.size(), CV_8UC3); diff --git a/samples/cpp/houghcircles.cpp b/samples/cpp/houghcircles.cpp index bc53fd1249..b51faf53a5 100644 --- a/samples/cpp/houghcircles.cpp +++ b/samples/cpp/houghcircles.cpp @@ -27,10 +27,10 @@ int main(int argc, char** argv) Mat cimg; medianBlur(img, img, 5); - cvtColor(img, cimg, CV_GRAY2BGR); + cvtColor(img, cimg, COLOR_GRAY2BGR); vector circles; - HoughCircles(img, circles, CV_HOUGH_GRADIENT, 1, 10, + HoughCircles(img, circles, HOUGH_GRADIENT, 1, 10, 100, 30, 1, 30 // change the last two parameters // (min_radius & max_radius) to detect larger circles ); diff --git a/samples/cpp/houghlines.cpp b/samples/cpp/houghlines.cpp index b79ea2f5ff..7efb990e63 100644 --- a/samples/cpp/houghlines.cpp +++ b/samples/cpp/houghlines.cpp @@ -27,7 +27,7 @@ int main(int argc, char** argv) Mat dst, cdst; Canny(src, dst, 50, 200, 3); - cvtColor(dst, cdst, CV_GRAY2BGR); + cvtColor(dst, cdst, COLOR_GRAY2BGR); #if 0 vector lines; diff --git a/samples/cpp/image.cpp b/samples/cpp/image.cpp index 53b9bc1b9f..0e9ea9cf69 100644 --- a/samples/cpp/image.cpp +++ b/samples/cpp/image.cpp @@ -49,7 +49,7 @@ int main( int argc, char** argv ) return -1; Mat img_yuv; - cvtColor(img, img_yuv, CV_BGR2YCrCb); // convert image to YUV color space. The output image will be created automatically + cvtColor(img, img_yuv, COLOR_BGR2YCrCb); // convert image to YUV color space. The output image will be created automatically vector planes; // Vector is template vector class, similar to STL's vector. It can store matrices too. split(img_yuv, planes); // split the image into separate color planes @@ -107,7 +107,7 @@ int main( int argc, char** argv ) // now merge the results back merge(planes, img_yuv); // and produce the output RGB image - cvtColor(img_yuv, img, CV_YCrCb2BGR); + cvtColor(img_yuv, img, COLOR_YCrCb2BGR); // this is counterpart for cvNamedWindow namedWindow("image with grain", CV_WINDOW_AUTOSIZE); diff --git a/samples/cpp/laplace.cpp b/samples/cpp/laplace.cpp index 50cb8467ba..8bddeb820e 100644 --- a/samples/cpp/laplace.cpp +++ b/samples/cpp/laplace.cpp @@ -17,8 +17,10 @@ static void help() "./laplace [camera #, default 0]\n" << endl; } +enum {GAUSSIAN, BLUR, MEDIAN}; + int sigma = 3; -int smoothType = CV_GAUSSIAN; +int smoothType = GAUSSIAN; int main( int argc, char** argv ) { @@ -63,9 +65,9 @@ int main( int argc, char** argv ) break; int ksize = (sigma*5)|1; - if(smoothType == CV_GAUSSIAN) + if(smoothType == GAUSSIAN) GaussianBlur(frame, smoothed, Size(ksize, ksize), sigma, sigma); - else if(smoothType == CV_BLUR) + else if(smoothType == BLUR) blur(frame, smoothed, Size(ksize, ksize)); else medianBlur(frame, smoothed, ksize); @@ -76,7 +78,7 @@ int main( int argc, char** argv ) int c = waitKey(30); if( c == ' ' ) - smoothType = smoothType == CV_GAUSSIAN ? CV_BLUR : smoothType == CV_BLUR ? CV_MEDIAN : CV_GAUSSIAN; + smoothType = smoothType == GAUSSIAN ? BLUR : smoothType == BLUR ? MEDIAN : GAUSSIAN; if( c == 'q' || c == 'Q' || (c & 255) == 27 ) break; } diff --git a/samples/cpp/morphology2.cpp b/samples/cpp/morphology2.cpp index d4ab351545..3052f85d9a 100644 --- a/samples/cpp/morphology2.cpp +++ b/samples/cpp/morphology2.cpp @@ -37,9 +37,9 @@ static void OpenClose(int, void*) int an = n > 0 ? n : -n; Mat element = getStructuringElement(element_shape, Size(an*2+1, an*2+1), Point(an, an) ); if( n < 0 ) - morphologyEx(src, dst, CV_MOP_OPEN, element); + morphologyEx(src, dst, MORPH_OPEN, element); else - morphologyEx(src, dst, CV_MOP_CLOSE, element); + morphologyEx(src, dst, MORPH_CLOSE, element); imshow("Open/Close",dst); } diff --git a/samples/cpp/phase_corr.cpp b/samples/cpp/phase_corr.cpp index d9a1419a7c..97172adc38 100644 --- a/samples/cpp/phase_corr.cpp +++ b/samples/cpp/phase_corr.cpp @@ -13,7 +13,7 @@ int main(int, char* []) do { video >> frame; - cvtColor(frame, curr, CV_RGB2GRAY); + cvtColor(frame, curr, COLOR_RGB2GRAY); if(prev.empty()) { diff --git a/samples/cpp/rgbdodometry.cpp b/samples/cpp/rgbdodometry.cpp index 660eb31d02..0db2fab847 100644 --- a/samples/cpp/rgbdodometry.cpp +++ b/samples/cpp/rgbdodometry.cpp @@ -125,8 +125,8 @@ int main(int argc, char** argv) } Mat grayImage0, grayImage1, depthFlt0, depthFlt1/*in meters*/; - cvtColor( colorImage0, grayImage0, CV_BGR2GRAY ); - cvtColor( colorImage1, grayImage1, CV_BGR2GRAY ); + cvtColor( colorImage0, grayImage0, COLOR_BGR2GRAY ); + cvtColor( colorImage1, grayImage1, COLOR_BGR2GRAY ); depth0.convertTo( depthFlt0, CV_32FC1, 1./1000 ); depth1.convertTo( depthFlt1, CV_32FC1, 1./1000 ); diff --git a/samples/cpp/segment_objects.cpp b/samples/cpp/segment_objects.cpp index d70d0350b7..8555a0e602 100644 --- a/samples/cpp/segment_objects.cpp +++ b/samples/cpp/segment_objects.cpp @@ -30,7 +30,7 @@ static void refineSegments(const Mat& img, Mat& mask, Mat& dst) erode(temp, temp, Mat(), Point(-1,-1), niters*2); dilate(temp, temp, Mat(), Point(-1,-1), niters); - findContours( temp, contours, hierarchy, CV_RETR_CCOMP, CV_CHAIN_APPROX_SIMPLE ); + findContours( temp, contours, hierarchy, RETR_CCOMP, CHAIN_APPROX_SIMPLE ); dst = Mat::zeros(img.size(), CV_8UC3); diff --git a/samples/cpp/squares.cpp b/samples/cpp/squares.cpp index 13a9946673..11887c1ca0 100644 --- a/samples/cpp/squares.cpp +++ b/samples/cpp/squares.cpp @@ -83,7 +83,7 @@ static void findSquares( const Mat& image, vector >& squares ) } // find contours and store them all as a list - findContours(gray, contours, CV_RETR_LIST, CV_CHAIN_APPROX_SIMPLE); + findContours(gray, contours, RETR_LIST, CHAIN_APPROX_SIMPLE); vector approx; diff --git a/samples/cpp/stereo_calib.cpp b/samples/cpp/stereo_calib.cpp index 07621cef8c..57fde453cb 100644 --- a/samples/cpp/stereo_calib.cpp +++ b/samples/cpp/stereo_calib.cpp @@ -121,7 +121,7 @@ StereoCalib(const vector& imagelist, Size boardSize, bool useCalibrated= { cout << filename << endl; Mat cimg, cimg1; - cvtColor(img, cimg, CV_GRAY2BGR); + cvtColor(img, cimg, COLOR_GRAY2BGR); drawChessboardCorners(cimg, boardSize, corners, found); double sf = 640./MAX(img.rows, img.cols); resize(cimg, cimg1, Size(), sf, sf); @@ -304,10 +304,10 @@ StereoCalib(const vector& imagelist, Size boardSize, bool useCalibrated= for( k = 0; k < 2; k++ ) { Mat img = imread(goodImageList[i*2+k], 0), rimg, cimg; - remap(img, rimg, rmap[k][0], rmap[k][1], CV_INTER_LINEAR); - cvtColor(rimg, cimg, CV_GRAY2BGR); + remap(img, rimg, rmap[k][0], rmap[k][1], INTER_LINEAR); + cvtColor(rimg, cimg, COLOR_GRAY2BGR); Mat canvasPart = !isVerticalStereo ? canvas(Rect(w*k, 0, w, h)) : canvas(Rect(0, h*k, w, h)); - resize(cimg, canvasPart, canvasPart.size(), 0, 0, CV_INTER_AREA); + resize(cimg, canvasPart, canvasPart.size(), 0, 0, INTER_AREA); if( useCalibrated ) { Rect vroi(cvRound(validRoi[k].x*sf), cvRound(validRoi[k].y*sf), diff --git a/samples/cpp/tutorial_code/Histograms_Matching/EqualizeHist_Demo.cpp b/samples/cpp/tutorial_code/Histograms_Matching/EqualizeHist_Demo.cpp index 49e4be0e54..5b5d9899e8 100644 --- a/samples/cpp/tutorial_code/Histograms_Matching/EqualizeHist_Demo.cpp +++ b/samples/cpp/tutorial_code/Histograms_Matching/EqualizeHist_Demo.cpp @@ -31,7 +31,7 @@ int main( int, char** argv ) } /// Convert to grayscale - cvtColor( src, src, CV_BGR2GRAY ); + cvtColor( src, src, COLOR_BGR2GRAY ); /// Apply Histogram Equalization equalizeHist( src, dst ); diff --git a/samples/cpp/tutorial_code/Histograms_Matching/MatchTemplate_Demo.cpp b/samples/cpp/tutorial_code/Histograms_Matching/MatchTemplate_Demo.cpp index e3633576f8..ffbc30bb18 100644 --- a/samples/cpp/tutorial_code/Histograms_Matching/MatchTemplate_Demo.cpp +++ b/samples/cpp/tutorial_code/Histograms_Matching/MatchTemplate_Demo.cpp @@ -74,7 +74,7 @@ void MatchingMethod( int, void* ) /// For SQDIFF and SQDIFF_NORMED, the best matches are lower values. For all the other methods, the higher the better - if( match_method == CV_TM_SQDIFF || match_method == CV_TM_SQDIFF_NORMED ) + if( match_method == TM_SQDIFF || match_method == TM_SQDIFF_NORMED ) { matchLoc = minLoc; } else { matchLoc = maxLoc; } diff --git a/samples/cpp/tutorial_code/Histograms_Matching/calcBackProject_Demo1.cpp b/samples/cpp/tutorial_code/Histograms_Matching/calcBackProject_Demo1.cpp index f422603749..e4a0af84b3 100644 --- a/samples/cpp/tutorial_code/Histograms_Matching/calcBackProject_Demo1.cpp +++ b/samples/cpp/tutorial_code/Histograms_Matching/calcBackProject_Demo1.cpp @@ -28,7 +28,7 @@ int main( int, char** argv ) /// Read the image src = imread( argv[1], 1 ); /// Transform it to HSV - cvtColor( src, hsv, CV_BGR2HSV ); + cvtColor( src, hsv, COLOR_BGR2HSV ); /// Use only the Hue value hue.create( hsv.size(), hsv.depth() ); diff --git a/samples/cpp/tutorial_code/Histograms_Matching/calcBackProject_Demo2.cpp b/samples/cpp/tutorial_code/Histograms_Matching/calcBackProject_Demo2.cpp index 42dd01a671..c908cd83f1 100644 --- a/samples/cpp/tutorial_code/Histograms_Matching/calcBackProject_Demo2.cpp +++ b/samples/cpp/tutorial_code/Histograms_Matching/calcBackProject_Demo2.cpp @@ -31,7 +31,7 @@ int main( int, char** argv ) /// Read the image src = imread( argv[1], 1 ); /// Transform it to HSV - cvtColor( src, hsv, CV_BGR2HSV ); + cvtColor( src, hsv, COLOR_BGR2HSV ); /// Show the image namedWindow( window_image, CV_WINDOW_AUTOSIZE ); diff --git a/samples/cpp/tutorial_code/Histograms_Matching/compareHist_Demo.cpp b/samples/cpp/tutorial_code/Histograms_Matching/compareHist_Demo.cpp index b18aab2e8b..109f8131a3 100644 --- a/samples/cpp/tutorial_code/Histograms_Matching/compareHist_Demo.cpp +++ b/samples/cpp/tutorial_code/Histograms_Matching/compareHist_Demo.cpp @@ -33,9 +33,9 @@ int main( int argc, char** argv ) src_test2 = imread( argv[3], 1 ); /// Convert to HSV - cvtColor( src_base, hsv_base, CV_BGR2HSV ); - cvtColor( src_test1, hsv_test1, CV_BGR2HSV ); - cvtColor( src_test2, hsv_test2, CV_BGR2HSV ); + cvtColor( src_base, hsv_base, COLOR_BGR2HSV ); + cvtColor( src_test1, hsv_test1, COLOR_BGR2HSV ); + cvtColor( src_test2, hsv_test2, COLOR_BGR2HSV ); hsv_half_down = hsv_base( Range( hsv_base.rows/2, hsv_base.rows - 1 ), Range( 0, hsv_base.cols - 1 ) ); diff --git a/samples/cpp/tutorial_code/ImgProc/Threshold.cpp b/samples/cpp/tutorial_code/ImgProc/Threshold.cpp index 7505ec297b..7ba05db3c9 100644 --- a/samples/cpp/tutorial_code/ImgProc/Threshold.cpp +++ b/samples/cpp/tutorial_code/ImgProc/Threshold.cpp @@ -37,7 +37,7 @@ int main( int, char** argv ) src = imread( argv[1], 1 ); /// Convert the image to Gray - cvtColor( src, src_gray, CV_RGB2GRAY ); + cvtColor( src, src_gray, COLOR_RGB2GRAY ); /// Create a window to display results namedWindow( window_name, CV_WINDOW_AUTOSIZE ); diff --git a/samples/cpp/tutorial_code/ImgTrans/CannyDetector_Demo.cpp b/samples/cpp/tutorial_code/ImgTrans/CannyDetector_Demo.cpp index c798f2fb42..f1455094a7 100644 --- a/samples/cpp/tutorial_code/ImgTrans/CannyDetector_Demo.cpp +++ b/samples/cpp/tutorial_code/ImgTrans/CannyDetector_Demo.cpp @@ -58,7 +58,7 @@ int main( int, char** argv ) dst.create( src.size(), src.type() ); /// Convert the image to grayscale - cvtColor( src, src_gray, CV_BGR2GRAY ); + cvtColor( src, src_gray, COLOR_BGR2GRAY ); /// Create a window namedWindow( window_name, CV_WINDOW_AUTOSIZE ); diff --git a/samples/cpp/tutorial_code/ImgTrans/HoughCircle_Demo.cpp b/samples/cpp/tutorial_code/ImgTrans/HoughCircle_Demo.cpp index 5782e92a3c..09a6cefde2 100644 --- a/samples/cpp/tutorial_code/ImgTrans/HoughCircle_Demo.cpp +++ b/samples/cpp/tutorial_code/ImgTrans/HoughCircle_Demo.cpp @@ -26,7 +26,7 @@ int main(int, char** argv) { return -1; } /// Convert it to gray - cvtColor( src, src_gray, CV_BGR2GRAY ); + cvtColor( src, src_gray, COLOR_BGR2GRAY ); /// Reduce the noise so we avoid false circle detection GaussianBlur( src_gray, src_gray, Size(9, 9), 2, 2 ); @@ -34,7 +34,7 @@ int main(int, char** argv) vector circles; /// Apply the Hough Transform to find the circles - HoughCircles( src_gray, circles, CV_HOUGH_GRADIENT, 1, src_gray.rows/8, 200, 100, 0, 0 ); + HoughCircles( src_gray, circles, HOUGH_GRADIENT, 1, src_gray.rows/8, 200, 100, 0, 0 ); /// Draw the circles detected for( size_t i = 0; i < circles.size(); i++ ) diff --git a/samples/cpp/tutorial_code/ImgTrans/HoughLines_Demo.cpp b/samples/cpp/tutorial_code/ImgTrans/HoughLines_Demo.cpp index 561948a581..e4064e1aa7 100644 --- a/samples/cpp/tutorial_code/ImgTrans/HoughLines_Demo.cpp +++ b/samples/cpp/tutorial_code/ImgTrans/HoughLines_Demo.cpp @@ -46,7 +46,7 @@ int main( int, char** argv ) } /// Pass the image to gray - cvtColor( src, src_gray, CV_RGB2GRAY ); + cvtColor( src, src_gray, COLOR_RGB2GRAY ); /// Apply Canny edge detector Canny( src_gray, edges, 50, 200, 3 ); @@ -85,7 +85,7 @@ void help() void Standard_Hough( int, void* ) { vector s_lines; - cvtColor( edges, standard_hough, CV_GRAY2BGR ); + cvtColor( edges, standard_hough, COLOR_GRAY2BGR ); /// 1. Use Standard Hough Transform HoughLines( edges, s_lines, 1, CV_PI/180, min_threshold + s_trackbar, 0, 0 ); @@ -112,7 +112,7 @@ void Standard_Hough( int, void* ) void Probabilistic_Hough( int, void* ) { vector p_lines; - cvtColor( edges, probabilistic_hough, CV_GRAY2BGR ); + cvtColor( edges, probabilistic_hough, COLOR_GRAY2BGR ); /// 2. Use Probabilistic Hough Transform HoughLinesP( edges, p_lines, 1, CV_PI/180, min_threshold + p_trackbar, 30, 10 ); diff --git a/samples/cpp/tutorial_code/ImgTrans/Laplace_Demo.cpp b/samples/cpp/tutorial_code/ImgTrans/Laplace_Demo.cpp index 279dc6dcb6..f9033df471 100644 --- a/samples/cpp/tutorial_code/ImgTrans/Laplace_Demo.cpp +++ b/samples/cpp/tutorial_code/ImgTrans/Laplace_Demo.cpp @@ -34,7 +34,7 @@ int main( int, char** argv ) GaussianBlur( src, src, Size(3,3), 0, 0, BORDER_DEFAULT ); /// Convert the image to grayscale - cvtColor( src, src_gray, CV_RGB2GRAY ); + cvtColor( src, src_gray, COLOR_RGB2GRAY ); /// Create window namedWindow( window_name, CV_WINDOW_AUTOSIZE ); diff --git a/samples/cpp/tutorial_code/ImgTrans/Remap_Demo.cpp b/samples/cpp/tutorial_code/ImgTrans/Remap_Demo.cpp index 40e5118a6d..814a01c4c4 100644 --- a/samples/cpp/tutorial_code/ImgTrans/Remap_Demo.cpp +++ b/samples/cpp/tutorial_code/ImgTrans/Remap_Demo.cpp @@ -47,7 +47,7 @@ int main( int, char** argv ) /// Update map_x & map_y. Then apply remap update_map(); - remap( src, dst, map_x, map_y, CV_INTER_LINEAR, BORDER_CONSTANT, Scalar(0, 0, 0) ); + remap( src, dst, map_x, map_y, INTER_LINEAR, BORDER_CONSTANT, Scalar(0, 0, 0) ); // Display results imshow( remap_window, dst ); diff --git a/samples/cpp/tutorial_code/ImgTrans/Sobel_Demo.cpp b/samples/cpp/tutorial_code/ImgTrans/Sobel_Demo.cpp index 0ac9eb1a30..3a8130b332 100644 --- a/samples/cpp/tutorial_code/ImgTrans/Sobel_Demo.cpp +++ b/samples/cpp/tutorial_code/ImgTrans/Sobel_Demo.cpp @@ -33,7 +33,7 @@ int main( int, char** argv ) GaussianBlur( src, src, Size(3,3), 0, 0, BORDER_DEFAULT ); /// Convert it to gray - cvtColor( src, src_gray, CV_RGB2GRAY ); + cvtColor( src, src_gray, COLOR_RGB2GRAY ); /// Create window namedWindow( window_name, CV_WINDOW_AUTOSIZE ); diff --git a/samples/cpp/tutorial_code/ShapeDescriptors/findContours_demo.cpp b/samples/cpp/tutorial_code/ShapeDescriptors/findContours_demo.cpp index e301476ee7..01a4f1c73a 100644 --- a/samples/cpp/tutorial_code/ShapeDescriptors/findContours_demo.cpp +++ b/samples/cpp/tutorial_code/ShapeDescriptors/findContours_demo.cpp @@ -30,7 +30,7 @@ int main( int, char** argv ) src = imread( argv[1], 1 ); /// Convert image to gray and blur it - cvtColor( src, src_gray, CV_BGR2GRAY ); + cvtColor( src, src_gray, COLOR_BGR2GRAY ); blur( src_gray, src_gray, Size(3,3) ); /// Create Window @@ -57,7 +57,7 @@ void thresh_callback(int, void* ) /// Detect edges using canny Canny( src_gray, canny_output, thresh, thresh*2, 3 ); /// Find contours - findContours( canny_output, contours, hierarchy, CV_RETR_TREE, CV_CHAIN_APPROX_SIMPLE, Point(0, 0) ); + findContours( canny_output, contours, hierarchy, RETR_TREE, CHAIN_APPROX_SIMPLE, Point(0, 0) ); /// Draw contours Mat drawing = Mat::zeros( canny_output.size(), CV_8UC3 ); diff --git a/samples/cpp/tutorial_code/ShapeDescriptors/generalContours_demo1.cpp b/samples/cpp/tutorial_code/ShapeDescriptors/generalContours_demo1.cpp index b973cfd973..dfc27e56ce 100644 --- a/samples/cpp/tutorial_code/ShapeDescriptors/generalContours_demo1.cpp +++ b/samples/cpp/tutorial_code/ShapeDescriptors/generalContours_demo1.cpp @@ -30,7 +30,7 @@ int main( int, char** argv ) src = imread( argv[1], 1 ); /// Convert image to gray and blur it - cvtColor( src, src_gray, CV_BGR2GRAY ); + cvtColor( src, src_gray, COLOR_BGR2GRAY ); blur( src_gray, src_gray, Size(3,3) ); /// Create Window @@ -57,7 +57,7 @@ void thresh_callback(int, void* ) /// Detect edges using Threshold threshold( src_gray, threshold_output, thresh, 255, THRESH_BINARY ); /// Find contours - findContours( threshold_output, contours, hierarchy, CV_RETR_TREE, CV_CHAIN_APPROX_SIMPLE, Point(0, 0) ); + findContours( threshold_output, contours, hierarchy, RETR_TREE, CHAIN_APPROX_SIMPLE, Point(0, 0) ); /// Approximate contours to polygons + get bounding rects and circles vector > contours_poly( contours.size() ); diff --git a/samples/cpp/tutorial_code/ShapeDescriptors/generalContours_demo2.cpp b/samples/cpp/tutorial_code/ShapeDescriptors/generalContours_demo2.cpp index 70d8663c9b..cb93de231a 100644 --- a/samples/cpp/tutorial_code/ShapeDescriptors/generalContours_demo2.cpp +++ b/samples/cpp/tutorial_code/ShapeDescriptors/generalContours_demo2.cpp @@ -30,7 +30,7 @@ int main( int, char** argv ) src = imread( argv[1], 1 ); /// Convert image to gray and blur it - cvtColor( src, src_gray, CV_BGR2GRAY ); + cvtColor( src, src_gray, COLOR_BGR2GRAY ); blur( src_gray, src_gray, Size(3,3) ); /// Create Window @@ -57,7 +57,7 @@ void thresh_callback(int, void* ) /// Detect edges using Threshold threshold( src_gray, threshold_output, thresh, 255, THRESH_BINARY ); /// Find contours - findContours( threshold_output, contours, hierarchy, CV_RETR_TREE, CV_CHAIN_APPROX_SIMPLE, Point(0, 0) ); + findContours( threshold_output, contours, hierarchy, RETR_TREE, CHAIN_APPROX_SIMPLE, Point(0, 0) ); /// Find the rotated rectangles and ellipses for each contour vector minRect( contours.size() ); diff --git a/samples/cpp/tutorial_code/ShapeDescriptors/hull_demo.cpp b/samples/cpp/tutorial_code/ShapeDescriptors/hull_demo.cpp index 8fe5d5b075..35c6f4db39 100644 --- a/samples/cpp/tutorial_code/ShapeDescriptors/hull_demo.cpp +++ b/samples/cpp/tutorial_code/ShapeDescriptors/hull_demo.cpp @@ -30,7 +30,7 @@ int main( int, char** argv ) src = imread( argv[1], 1 ); /// Convert image to gray and blur it - cvtColor( src, src_gray, CV_BGR2GRAY ); + cvtColor( src, src_gray, COLOR_BGR2GRAY ); blur( src_gray, src_gray, Size(3,3) ); /// Create Window @@ -59,7 +59,7 @@ void thresh_callback(int, void* ) threshold( src_gray, threshold_output, thresh, 255, THRESH_BINARY ); /// Find contours - findContours( threshold_output, contours, hierarchy, CV_RETR_TREE, CV_CHAIN_APPROX_SIMPLE, Point(0, 0) ); + findContours( threshold_output, contours, hierarchy, RETR_TREE, CHAIN_APPROX_SIMPLE, Point(0, 0) ); /// Find the convex hull object for each contour vector >hull( contours.size() ); diff --git a/samples/cpp/tutorial_code/ShapeDescriptors/moments_demo.cpp b/samples/cpp/tutorial_code/ShapeDescriptors/moments_demo.cpp index efd3c63d9e..277a06040e 100644 --- a/samples/cpp/tutorial_code/ShapeDescriptors/moments_demo.cpp +++ b/samples/cpp/tutorial_code/ShapeDescriptors/moments_demo.cpp @@ -30,7 +30,7 @@ int main( int, char** argv ) src = imread( argv[1], 1 ); /// Convert image to gray and blur it - cvtColor( src, src_gray, CV_BGR2GRAY ); + cvtColor( src, src_gray, COLOR_BGR2GRAY ); blur( src_gray, src_gray, Size(3,3) ); /// Create Window @@ -57,7 +57,7 @@ void thresh_callback(int, void* ) /// Detect edges using canny Canny( src_gray, canny_output, thresh, thresh*2, 3 ); /// Find contours - findContours( canny_output, contours, hierarchy, CV_RETR_TREE, CV_CHAIN_APPROX_SIMPLE, Point(0, 0) ); + findContours( canny_output, contours, hierarchy, RETR_TREE, CHAIN_APPROX_SIMPLE, Point(0, 0) ); /// Get the moments vector mu(contours.size() ); diff --git a/samples/cpp/tutorial_code/TrackingMotion/cornerDetector_Demo.cpp b/samples/cpp/tutorial_code/TrackingMotion/cornerDetector_Demo.cpp index b4789e3345..7184f94877 100644 --- a/samples/cpp/tutorial_code/TrackingMotion/cornerDetector_Demo.cpp +++ b/samples/cpp/tutorial_code/TrackingMotion/cornerDetector_Demo.cpp @@ -40,7 +40,7 @@ int main( int, char** argv ) { /// Load source image and convert it to gray src = imread( argv[1], 1 ); - cvtColor( src, src_gray, CV_BGR2GRAY ); + cvtColor( src, src_gray, COLOR_BGR2GRAY ); /// Set some parameters int blockSize = 3; int apertureSize = 3; diff --git a/samples/cpp/tutorial_code/TrackingMotion/cornerHarris_Demo.cpp b/samples/cpp/tutorial_code/TrackingMotion/cornerHarris_Demo.cpp index 667ad7e32a..e77500bbfe 100644 --- a/samples/cpp/tutorial_code/TrackingMotion/cornerHarris_Demo.cpp +++ b/samples/cpp/tutorial_code/TrackingMotion/cornerHarris_Demo.cpp @@ -31,7 +31,7 @@ int main( int, char** argv ) { /// Load source image and convert it to gray src = imread( argv[1], 1 ); - cvtColor( src, src_gray, CV_BGR2GRAY ); + cvtColor( src, src_gray, COLOR_BGR2GRAY ); /// Create a window and a trackbar namedWindow( source_window, CV_WINDOW_AUTOSIZE ); diff --git a/samples/cpp/tutorial_code/TrackingMotion/cornerSubPix_Demo.cpp b/samples/cpp/tutorial_code/TrackingMotion/cornerSubPix_Demo.cpp index 3b538119e8..d59d258aaf 100644 --- a/samples/cpp/tutorial_code/TrackingMotion/cornerSubPix_Demo.cpp +++ b/samples/cpp/tutorial_code/TrackingMotion/cornerSubPix_Demo.cpp @@ -32,7 +32,7 @@ int main( int, char** argv ) { /// Load source image and convert it to gray src = imread( argv[1], 1 ); - cvtColor( src, src_gray, CV_BGR2GRAY ); + cvtColor( src, src_gray, COLOR_BGR2GRAY ); /// Create Window namedWindow( source_window, CV_WINDOW_AUTOSIZE ); diff --git a/samples/cpp/tutorial_code/TrackingMotion/goodFeaturesToTrack_Demo.cpp b/samples/cpp/tutorial_code/TrackingMotion/goodFeaturesToTrack_Demo.cpp index e399c0c8ee..0f852d28cc 100644 --- a/samples/cpp/tutorial_code/TrackingMotion/goodFeaturesToTrack_Demo.cpp +++ b/samples/cpp/tutorial_code/TrackingMotion/goodFeaturesToTrack_Demo.cpp @@ -32,7 +32,7 @@ int main( int, char** argv ) { /// Load source image and convert it to gray src = imread( argv[1], 1 ); - cvtColor( src, src_gray, CV_BGR2GRAY ); + cvtColor( src, src_gray, COLOR_BGR2GRAY ); /// Create Window namedWindow( source_window, CV_WINDOW_AUTOSIZE ); diff --git a/samples/cpp/tutorial_code/calib3d/camera_calibration/camera_calibration.cpp b/samples/cpp/tutorial_code/calib3d/camera_calibration/camera_calibration.cpp index aeac2c8237..9b28f9d2ee 100644 --- a/samples/cpp/tutorial_code/calib3d/camera_calibration/camera_calibration.cpp +++ b/samples/cpp/tutorial_code/calib3d/camera_calibration/camera_calibration.cpp @@ -291,7 +291,7 @@ int main(int argc, char* argv[]) if( s.calibrationPattern == Settings::CHESSBOARD) { Mat viewGray; - cvtColor(view, viewGray, CV_BGR2GRAY); + cvtColor(view, viewGray, COLOR_BGR2GRAY); cornerSubPix( viewGray, pointBuf, Size(11,11), Size(-1,-1), TermCriteria( CV_TERMCRIT_EPS+CV_TERMCRIT_ITER, 30, 0.1 )); } diff --git a/samples/cpp/tutorial_code/core/interoperability_with_OpenCV_1/interoperability_with_OpenCV_1.cpp b/samples/cpp/tutorial_code/core/interoperability_with_OpenCV_1/interoperability_with_OpenCV_1.cpp index dfb13bdf64..fd69228a03 100644 --- a/samples/cpp/tutorial_code/core/interoperability_with_OpenCV_1/interoperability_with_OpenCV_1.cpp +++ b/samples/cpp/tutorial_code/core/interoperability_with_OpenCV_1/interoperability_with_OpenCV_1.cpp @@ -46,7 +46,7 @@ int main( int argc, char** argv ) // convert image to YUV color space. The output image will be created automatically. Mat I_YUV; - cvtColor(I, I_YUV, CV_BGR2YCrCb); + cvtColor(I, I_YUV, COLOR_BGR2YCrCb); vector planes; // Use the STL's vector structure to store multiple Mat objects split(I_YUV, planes); // split the image into separate color planes (Y U V) @@ -115,7 +115,7 @@ int main( int argc, char** argv ) merge(planes, I_YUV); // now merge the results back - cvtColor(I_YUV, I, CV_YCrCb2BGR); // and produce the output RGB image + cvtColor(I_YUV, I, COLOR_YCrCb2BGR); // and produce the output RGB image namedWindow("image with grain", CV_WINDOW_AUTOSIZE); // use this to create images diff --git a/samples/cpp/tutorial_code/objectDetection/objectDetection.cpp b/samples/cpp/tutorial_code/objectDetection/objectDetection.cpp index 0f5cb6a445..7ada2777a8 100644 --- a/samples/cpp/tutorial_code/objectDetection/objectDetection.cpp +++ b/samples/cpp/tutorial_code/objectDetection/objectDetection.cpp @@ -68,7 +68,7 @@ void detectAndDisplay( Mat frame ) std::vector faces; Mat frame_gray; - cvtColor( frame, frame_gray, CV_BGR2GRAY ); + cvtColor( frame, frame_gray, COLOR_BGR2GRAY ); equalizeHist( frame_gray, frame_gray ); //-- Detect faces face_cascade.detectMultiScale( frame_gray, faces, 1.1, 2, 0|CV_HAAR_SCALE_IMAGE, Size(30, 30) ); diff --git a/samples/cpp/tutorial_code/objectDetection/objectDetection2.cpp b/samples/cpp/tutorial_code/objectDetection/objectDetection2.cpp index 8e9b9d3305..ffaf21123c 100644 --- a/samples/cpp/tutorial_code/objectDetection/objectDetection2.cpp +++ b/samples/cpp/tutorial_code/objectDetection/objectDetection2.cpp @@ -68,7 +68,7 @@ void detectAndDisplay( Mat frame ) std::vector faces; Mat frame_gray; - cvtColor( frame, frame_gray, CV_BGR2GRAY ); + cvtColor( frame, frame_gray, COLOR_BGR2GRAY ); equalizeHist( frame_gray, frame_gray ); //-- Detect faces diff --git a/samples/cpp/video_dmtx.cpp b/samples/cpp/video_dmtx.cpp index 10889248a7..c5eaf1e393 100644 --- a/samples/cpp/video_dmtx.cpp +++ b/samples/cpp/video_dmtx.cpp @@ -52,7 +52,7 @@ namespace if (frame.empty()) break; cv::Mat gray; - cv::cvtColor(frame,gray,CV_RGB2GRAY); + cv::cvtColor(frame,gray, COLOR_RGB2GRAY); vector codes; Mat corners; findDataMatrix(gray, codes, corners); diff --git a/samples/cpp/video_homography.cpp b/samples/cpp/video_homography.cpp index 01af565c46..c8388007dd 100644 --- a/samples/cpp/video_homography.cpp +++ b/samples/cpp/video_homography.cpp @@ -161,7 +161,7 @@ int main(int ac, char ** av) if (frame.empty()) break; - cvtColor(frame, gray, CV_RGB2GRAY); + cvtColor(frame, gray, COLOR_RGB2GRAY); detector.detect(gray, query_kpts); //Find interest points diff --git a/samples/cpp/watershed.cpp b/samples/cpp/watershed.cpp index 923b8bf839..7494754086 100644 --- a/samples/cpp/watershed.cpp +++ b/samples/cpp/watershed.cpp @@ -59,8 +59,8 @@ int main( int argc, char** argv ) namedWindow( "image", 1 ); img0.copyTo(img); - cvtColor(img, markerMask, CV_BGR2GRAY); - cvtColor(markerMask, imgGray, CV_GRAY2BGR); + cvtColor(img, markerMask, COLOR_BGR2GRAY); + cvtColor(markerMask, imgGray, COLOR_GRAY2BGR); markerMask = Scalar::all(0); imshow( "image", img ); setMouseCallback( "image", onMouse, 0 ); @@ -85,7 +85,7 @@ int main( int argc, char** argv ) vector > contours; vector hierarchy; - findContours(markerMask, contours, hierarchy, CV_RETR_CCOMP, CV_CHAIN_APPROX_SIMPLE); + findContours(markerMask, contours, hierarchy, RETR_CCOMP, CHAIN_APPROX_SIMPLE); if( contours.empty() ) continue; diff --git a/samples/gpu/cascadeclassifier.cpp b/samples/gpu/cascadeclassifier.cpp index dee9d16c72..4e01ba4c73 100644 --- a/samples/gpu/cascadeclassifier.cpp +++ b/samples/gpu/cascadeclassifier.cpp @@ -29,7 +29,7 @@ void convertAndResize(const T& src, T& gray, T& resized, double scale) { if (src.channels() == 3) { - cvtColor( src, gray, CV_BGR2GRAY ); + cvtColor( src, gray, COLOR_BGR2GRAY ); } else { @@ -272,7 +272,7 @@ int main(int argc, const char *argv[]) } cout << endl; - cvtColor(resized_cpu, frameDisp, CV_GRAY2BGR); + cvtColor(resized_cpu, frameDisp, COLOR_GRAY2BGR); displayState(frameDisp, helpScreen, useGPU, findLargestObject, filterRects, fps); imshow("result", frameDisp); diff --git a/samples/gpu/generalized_hough.cpp b/samples/gpu/generalized_hough.cpp index 3febbf0f5f..c8fae7c411 100644 --- a/samples/gpu/generalized_hough.cpp +++ b/samples/gpu/generalized_hough.cpp @@ -86,11 +86,11 @@ int main(int argc, const char* argv[]) Mat templ = loadImage(templName); Mat image = loadImage(imageName); - int method = GHT_POSITION; + int method = cv::GeneralizedHough::GHT_POSITION; if (estimateScale) - method += GHT_SCALE; + method += cv::GeneralizedHough::GHT_SCALE; if (estimateRotation) - method += GHT_ROTATION; + method += cv::GeneralizedHough::GHT_ROTATION; vector position; cv::TickMeter tm; diff --git a/samples/gpu/hog.cpp b/samples/gpu/hog.cpp index 59bddb187a..3e451e87fa 100644 --- a/samples/gpu/hog.cpp +++ b/samples/gpu/hog.cpp @@ -296,8 +296,8 @@ void App::run() workBegin(); // Change format of the image - if (make_gray) cvtColor(frame, img_aux, CV_BGR2GRAY); - else if (use_gpu) cvtColor(frame, img_aux, CV_BGR2BGRA); + if (make_gray) cvtColor(frame, img_aux, COLOR_BGR2GRAY); + else if (use_gpu) cvtColor(frame, img_aux, COLOR_BGR2BGRA); else frame.copyTo(img_aux); // Resize image @@ -351,8 +351,8 @@ void App::run() throw std::runtime_error("can't create video writer"); } - if (make_gray) cvtColor(img_to_show, img, CV_GRAY2BGR); - else cvtColor(img_to_show, img, CV_BGRA2BGR); + if (make_gray) cvtColor(img_to_show, img, COLOR_GRAY2BGR); + else cvtColor(img_to_show, img, COLOR_BGRA2BGR); video_writer << img; } diff --git a/samples/gpu/houghlines.cpp b/samples/gpu/houghlines.cpp index f104e16fa5..52c55994b1 100644 --- a/samples/gpu/houghlines.cpp +++ b/samples/gpu/houghlines.cpp @@ -34,7 +34,7 @@ int main(int argc, const char* argv[]) Canny(src, mask, 100, 200, 3); Mat dst_cpu; - cvtColor(mask, dst_cpu, CV_GRAY2BGR); + cvtColor(mask, dst_cpu, COLOR_GRAY2BGR); Mat dst_gpu = dst_cpu.clone(); vector lines_cpu; diff --git a/samples/gpu/morphology.cpp b/samples/gpu/morphology.cpp index 5863eac10f..13b15807a8 100644 --- a/samples/gpu/morphology.cpp +++ b/samples/gpu/morphology.cpp @@ -39,9 +39,9 @@ static void OpenClose(int, void*) int an = n > 0 ? n : -n; Mat element = getStructuringElement(element_shape, Size(an*2+1, an*2+1), Point(an, an) ); if( n < 0 ) - cv::gpu::morphologyEx(src, dst, CV_MOP_OPEN, element); + cv::gpu::morphologyEx(src, dst, MORPH_OPEN, element); else - cv::gpu::morphologyEx(src, dst, CV_MOP_CLOSE, element); + cv::gpu::morphologyEx(src, dst, MORPH_CLOSE, element); imshow("Open/Close",(Mat)dst); } @@ -84,7 +84,7 @@ int main( int argc, char** argv ) { // gpu support only 4th channel images GpuMat src4ch; - cv::gpu::cvtColor(src, src4ch, CV_BGR2BGRA); + cv::gpu::cvtColor(src, src4ch, COLOR_BGR2BGRA); src = src4ch; } diff --git a/samples/gpu/stereo_match.cpp b/samples/gpu/stereo_match.cpp index 4b849a8c03..edf8886ffa 100644 --- a/samples/gpu/stereo_match.cpp +++ b/samples/gpu/stereo_match.cpp @@ -163,8 +163,8 @@ void App::run() right_src = imread(p.right); if (left_src.empty()) throw runtime_error("can't open file \"" + p.left + "\""); if (right_src.empty()) throw runtime_error("can't open file \"" + p.right + "\""); - cvtColor(left_src, left, CV_BGR2GRAY); - cvtColor(right_src, right, CV_BGR2GRAY); + cvtColor(left_src, left, COLOR_BGR2GRAY); + cvtColor(right_src, right, COLOR_BGR2GRAY); d_left.upload(left); d_right.upload(right); @@ -193,8 +193,8 @@ void App::run() if (d_left.channels() > 1 || d_right.channels() > 1) { cout << "BM doesn't support color images\n"; - cvtColor(left_src, left, CV_BGR2GRAY); - cvtColor(right_src, right, CV_BGR2GRAY); + cvtColor(left_src, left, COLOR_BGR2GRAY); + cvtColor(right_src, right, COLOR_BGR2GRAY); cout << "image_channels: " << left.channels() << endl; d_left.upload(left); d_right.upload(right); @@ -262,8 +262,8 @@ void App::handleKey(char key) } else { - cvtColor(left_src, left, CV_BGR2GRAY); - cvtColor(right_src, right, CV_BGR2GRAY); + cvtColor(left_src, left, COLOR_BGR2GRAY); + cvtColor(right_src, right, COLOR_BGR2GRAY); } d_left.upload(left); d_right.upload(right); diff --git a/samples/ocl/facedetect.cpp b/samples/ocl/facedetect.cpp index df6308cb9e..b5bab18e86 100644 --- a/samples/ocl/facedetect.cpp +++ b/samples/ocl/facedetect.cpp @@ -197,7 +197,7 @@ void detectAndDraw( Mat& img, cv::ocl::oclMat image(img); cv::ocl::oclMat gray, smallImg( cvRound (img.rows/scale), cvRound(img.cols/scale), CV_8UC1 ); - cv::ocl::cvtColor( image, gray, CV_BGR2GRAY ); + cv::ocl::cvtColor( image, gray, COLOR_BGR2GRAY ); cv::ocl::resize( gray, smallImg, smallImg.size(), 0, 0, INTER_LINEAR ); cv::ocl::equalizeHist( smallImg, smallImg ); diff --git a/samples/ocl/hog.cpp b/samples/ocl/hog.cpp index c1623db8b9..a10ad94cd2 100644 --- a/samples/ocl/hog.cpp +++ b/samples/ocl/hog.cpp @@ -296,8 +296,8 @@ void App::run() workBegin(); // Change format of the image - if (make_gray) cvtColor(frame, img_aux, CV_BGR2GRAY); - else if (use_gpu) cvtColor(frame, img_aux, CV_BGR2BGRA); + if (make_gray) cvtColor(frame, img_aux, COLOR_BGR2GRAY); + else if (use_gpu) cvtColor(frame, img_aux, COLOR_BGR2BGRA); else frame.copyTo(img_aux); // Resize image @@ -351,8 +351,8 @@ void App::run() throw std::runtime_error("can't create video writer"); } - if (make_gray) cvtColor(img_to_show, img, CV_GRAY2BGR); - else cvtColor(img_to_show, img, CV_BGRA2BGR); + if (make_gray) cvtColor(img_to_show, img, COLOR_GRAY2BGR); + else cvtColor(img_to_show, img, COLOR_BGRA2BGR); video_writer << img; } diff --git a/samples/ocl/squares.cpp b/samples/ocl/squares.cpp index 6b184161f7..16a085538e 100644 --- a/samples/ocl/squares.cpp +++ b/samples/ocl/squares.cpp @@ -88,7 +88,7 @@ static void findSquares( const Mat& image, vector >& squares ) } // find contours and store them all as a list - findContours(gray, contours, CV_RETR_LIST, CV_CHAIN_APPROX_SIMPLE); + findContours(gray, contours, RETR_LIST, CHAIN_APPROX_SIMPLE); vector approx; diff --git a/samples/ocl/surf_matcher.cpp b/samples/ocl/surf_matcher.cpp index ea6ee97cb2..ba4bc102f1 100644 --- a/samples/ocl/surf_matcher.cpp +++ b/samples/ocl/surf_matcher.cpp @@ -89,12 +89,12 @@ int main(int argc, char* argv[]) if(argc != 5) { cpu_img1 = imread("o.png"); - cvtColor(cpu_img1, cpu_img1_grey, CV_BGR2GRAY); + cvtColor(cpu_img1, cpu_img1_grey, COLOR_BGR2GRAY); img1 = cpu_img1_grey; CV_Assert(!img1.empty()); cpu_img2 = imread("r2.png"); - cvtColor(cpu_img2, cpu_img2_grey, CV_BGR2GRAY); + cvtColor(cpu_img2, cpu_img2_grey, COLOR_BGR2GRAY); img2 = cpu_img2_grey; } else @@ -104,14 +104,14 @@ int main(int argc, char* argv[]) if (string(argv[i]) == "--left") { cpu_img1 = imread(argv[++i]); - cvtColor(cpu_img1, cpu_img1_grey, CV_BGR2GRAY); + cvtColor(cpu_img1, cpu_img1_grey, COLOR_BGR2GRAY); img1 = cpu_img1_grey; CV_Assert(!img1.empty()); } else if (string(argv[i]) == "--right") { cpu_img2 = imread(argv[++i]); - cvtColor(cpu_img2, cpu_img2_grey, CV_BGR2GRAY); + cvtColor(cpu_img2, cpu_img2_grey, COLOR_BGR2GRAY); img2 = cpu_img2_grey; } else if (string(argv[i]) == "--help")