opencv_imgproc (JavaCPP Presets for OpenCV 3.1.0-1.2 API)

java.lang.Object
- org.bytedeco.javacpp.presets.opencv_imgproc
- - org.bytedeco.javacpp.helper.opencv_imgproc
  - - org.bytedeco.javacpp.opencv_imgproc

All Implemented Interfaces:: InfoMapper

public class opencv_imgproc
extends opencv_imgproc

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`opencv_imgproc.CLAHE`
`static class`	`opencv_imgproc.CvChainPtReader` Freeman chain reader state
`static class`	`opencv_imgproc.CvConnectedComp` Connected component structure
`static class`	`opencv_imgproc.CvContourScanner`
`static class`	`opencv_imgproc.CvConvexityDefect` Convexity defect
`static class`	`opencv_imgproc.CvDistanceFunction`
`static class`	`opencv_imgproc.CvFeatureTree`
`static class`	`opencv_imgproc.CvFont` Font structure
`static class`	`opencv_imgproc.CvHuMoments` Hu invariants
`static class`	`opencv_imgproc.CvLSH`
`static class`	`opencv_imgproc.CvLSHOperations`
`static class`	`opencv_imgproc.CvMoments` Spatial and central moments
`static class`	`opencv_imgproc.GeneralizedHough` finds arbitrary template in the grayscale image using Generalized Hough Transform
`static class`	`opencv_imgproc.GeneralizedHoughBallard` Ballard, D.H.
`static class`	`opencv_imgproc.GeneralizedHoughGuil` Guil, N., GonzÃ¡lez-Linares, J.M.
`static class`	`opencv_imgproc.LineIterator` \brief Line iterator
`static class`	`opencv_imgproc.LineSegmentDetector` \brief Line segment detector class
`static class`	`opencv_imgproc.Subdiv2D`

Nested classes/interfaces inherited from class org.bytedeco.javacpp.helper.opencv_imgproc
opencv_imgproc.AbstractCvHistogram, opencv_imgproc.AbstractCvMoments, opencv_imgproc.AbstractIplConvKernel

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`ADAPTIVE_THRESH_GAUSSIAN_C` enum cv::AdaptiveThresholdTypes
`static int`	`ADAPTIVE_THRESH_MEAN_C` enum cv::AdaptiveThresholdTypes
`static int`	`CC_STAT_AREA` enum cv::ConnectedComponentsTypes
`static int`	`CC_STAT_HEIGHT` enum cv::ConnectedComponentsTypes
`static int`	`CC_STAT_LEFT` enum cv::ConnectedComponentsTypes
`static int`	`CC_STAT_MAX` enum cv::ConnectedComponentsTypes
`static int`	`CC_STAT_TOP` enum cv::ConnectedComponentsTypes
`static int`	`CC_STAT_WIDTH` enum cv::ConnectedComponentsTypes
`static int`	`CHAIN_APPROX_NONE` enum cv::ContourApproximationModes
`static int`	`CHAIN_APPROX_SIMPLE` enum cv::ContourApproximationModes
`static int`	`CHAIN_APPROX_TC89_KCOS` enum cv::ContourApproximationModes
`static int`	`CHAIN_APPROX_TC89_L1` enum cv::ContourApproximationModes
`static int`	`COLOR_BayerBG2BGR` enum cv::ColorConversionCodes
`static int`	`COLOR_BayerBG2BGR_EA` enum cv::ColorConversionCodes
`static int`	`COLOR_BayerBG2BGR_VNG` enum cv::ColorConversionCodes
`static int`	`COLOR_BayerBG2GRAY` enum cv::ColorConversionCodes
`static int`	`COLOR_BayerBG2RGB` enum cv::ColorConversionCodes
`static int`	`COLOR_BayerBG2RGB_EA` enum cv::ColorConversionCodes
`static int`	`COLOR_BayerBG2RGB_VNG` enum cv::ColorConversionCodes
`static int`	`COLOR_BayerGB2BGR` enum cv::ColorConversionCodes
`static int`	`COLOR_BayerGB2BGR_EA` enum cv::ColorConversionCodes
`static int`	`COLOR_BayerGB2BGR_VNG` enum cv::ColorConversionCodes
`static int`	`COLOR_BayerGB2GRAY` enum cv::ColorConversionCodes
`static int`	`COLOR_BayerGB2RGB` enum cv::ColorConversionCodes
`static int`	`COLOR_BayerGB2RGB_EA` enum cv::ColorConversionCodes
`static int`	`COLOR_BayerGB2RGB_VNG` enum cv::ColorConversionCodes
`static int`	`COLOR_BayerGR2BGR` enum cv::ColorConversionCodes
`static int`	`COLOR_BayerGR2BGR_EA` enum cv::ColorConversionCodes
`static int`	`COLOR_BayerGR2BGR_VNG` enum cv::ColorConversionCodes
`static int`	`COLOR_BayerGR2GRAY` enum cv::ColorConversionCodes
`static int`	`COLOR_BayerGR2RGB` enum cv::ColorConversionCodes
`static int`	`COLOR_BayerGR2RGB_EA` enum cv::ColorConversionCodes
`static int`	`COLOR_BayerGR2RGB_VNG` enum cv::ColorConversionCodes
`static int`	`COLOR_BayerRG2BGR` enum cv::ColorConversionCodes
`static int`	`COLOR_BayerRG2BGR_EA` enum cv::ColorConversionCodes
`static int`	`COLOR_BayerRG2BGR_VNG` enum cv::ColorConversionCodes
`static int`	`COLOR_BayerRG2GRAY` enum cv::ColorConversionCodes
`static int`	`COLOR_BayerRG2RGB` enum cv::ColorConversionCodes
`static int`	`COLOR_BayerRG2RGB_EA` enum cv::ColorConversionCodes
`static int`	`COLOR_BayerRG2RGB_VNG` enum cv::ColorConversionCodes
`static int`	`COLOR_BGR2BGR555` enum cv::ColorConversionCodes
`static int`	`COLOR_BGR2BGR565` enum cv::ColorConversionCodes
`static int`	`COLOR_BGR2BGRA` enum cv::ColorConversionCodes
`static int`	`COLOR_BGR2GRAY` enum cv::ColorConversionCodes
`static int`	`COLOR_BGR2HLS` enum cv::ColorConversionCodes
`static int`	`COLOR_BGR2HLS_FULL` enum cv::ColorConversionCodes
`static int`	`COLOR_BGR2HSV` enum cv::ColorConversionCodes
`static int`	`COLOR_BGR2HSV_FULL` enum cv::ColorConversionCodes
`static int`	`COLOR_BGR2Lab` enum cv::ColorConversionCodes
`static int`	`COLOR_BGR2Luv` enum cv::ColorConversionCodes
`static int`	`COLOR_BGR2RGB` enum cv::ColorConversionCodes
`static int`	`COLOR_BGR2RGBA` enum cv::ColorConversionCodes
`static int`	`COLOR_BGR2XYZ` enum cv::ColorConversionCodes
`static int`	`COLOR_BGR2YCrCb` enum cv::ColorConversionCodes
`static int`	`COLOR_BGR2YUV` enum cv::ColorConversionCodes
`static int`	`COLOR_BGR2YUV_I420` enum cv::ColorConversionCodes
`static int`	`COLOR_BGR2YUV_IYUV` enum cv::ColorConversionCodes
`static int`	`COLOR_BGR2YUV_YV12` enum cv::ColorConversionCodes
`static int`	`COLOR_BGR5552BGR` enum cv::ColorConversionCodes
`static int`	`COLOR_BGR5552BGRA` enum cv::ColorConversionCodes
`static int`	`COLOR_BGR5552GRAY` enum cv::ColorConversionCodes
`static int`	`COLOR_BGR5552RGB` enum cv::ColorConversionCodes
`static int`	`COLOR_BGR5552RGBA` enum cv::ColorConversionCodes
`static int`	`COLOR_BGR5652BGR` enum cv::ColorConversionCodes
`static int`	`COLOR_BGR5652BGRA` enum cv::ColorConversionCodes
`static int`	`COLOR_BGR5652GRAY` enum cv::ColorConversionCodes
`static int`	`COLOR_BGR5652RGB` enum cv::ColorConversionCodes
`static int`	`COLOR_BGR5652RGBA` enum cv::ColorConversionCodes
`static int`	`COLOR_BGRA2BGR` enum cv::ColorConversionCodes
`static int`	`COLOR_BGRA2BGR555` enum cv::ColorConversionCodes
`static int`	`COLOR_BGRA2BGR565` enum cv::ColorConversionCodes
`static int`	`COLOR_BGRA2GRAY` enum cv::ColorConversionCodes
`static int`	`COLOR_BGRA2RGB` enum cv::ColorConversionCodes
`static int`	`COLOR_BGRA2RGBA` enum cv::ColorConversionCodes
`static int`	`COLOR_BGRA2YUV_I420` enum cv::ColorConversionCodes
`static int`	`COLOR_BGRA2YUV_IYUV` enum cv::ColorConversionCodes
`static int`	`COLOR_BGRA2YUV_YV12` enum cv::ColorConversionCodes
`static int`	`COLOR_COLORCVT_MAX` enum cv::ColorConversionCodes
`static int`	`COLOR_GRAY2BGR` enum cv::ColorConversionCodes
`static int`	`COLOR_GRAY2BGR555` enum cv::ColorConversionCodes
`static int`	`COLOR_GRAY2BGR565` enum cv::ColorConversionCodes
`static int`	`COLOR_GRAY2BGRA` enum cv::ColorConversionCodes
`static int`	`COLOR_GRAY2RGB` enum cv::ColorConversionCodes
`static int`	`COLOR_GRAY2RGBA` enum cv::ColorConversionCodes
`static int`	`COLOR_HLS2BGR` enum cv::ColorConversionCodes
`static int`	`COLOR_HLS2BGR_FULL` enum cv::ColorConversionCodes
`static int`	`COLOR_HLS2RGB` enum cv::ColorConversionCodes
`static int`	`COLOR_HLS2RGB_FULL` enum cv::ColorConversionCodes
`static int`	`COLOR_HSV2BGR` enum cv::ColorConversionCodes
`static int`	`COLOR_HSV2BGR_FULL` enum cv::ColorConversionCodes
`static int`	`COLOR_HSV2RGB` enum cv::ColorConversionCodes
`static int`	`COLOR_HSV2RGB_FULL` enum cv::ColorConversionCodes
`static int`	`COLOR_Lab2BGR` enum cv::ColorConversionCodes
`static int`	`COLOR_Lab2LBGR` enum cv::ColorConversionCodes
`static int`	`COLOR_Lab2LRGB` enum cv::ColorConversionCodes
`static int`	`COLOR_Lab2RGB` enum cv::ColorConversionCodes
`static int`	`COLOR_LBGR2Lab` enum cv::ColorConversionCodes
`static int`	`COLOR_LBGR2Luv` enum cv::ColorConversionCodes
`static int`	`COLOR_LRGB2Lab` enum cv::ColorConversionCodes
`static int`	`COLOR_LRGB2Luv` enum cv::ColorConversionCodes
`static int`	`COLOR_Luv2BGR` enum cv::ColorConversionCodes
`static int`	`COLOR_Luv2LBGR` enum cv::ColorConversionCodes
`static int`	`COLOR_Luv2LRGB` enum cv::ColorConversionCodes
`static int`	`COLOR_Luv2RGB` enum cv::ColorConversionCodes
`static int`	`COLOR_mRGBA2RGBA` enum cv::ColorConversionCodes
`static int`	`COLOR_RGB2BGR` enum cv::ColorConversionCodes
`static int`	`COLOR_RGB2BGR555` enum cv::ColorConversionCodes
`static int`	`COLOR_RGB2BGR565` enum cv::ColorConversionCodes
`static int`	`COLOR_RGB2BGRA` enum cv::ColorConversionCodes
`static int`	`COLOR_RGB2GRAY` enum cv::ColorConversionCodes
`static int`	`COLOR_RGB2HLS` enum cv::ColorConversionCodes
`static int`	`COLOR_RGB2HLS_FULL` enum cv::ColorConversionCodes
`static int`	`COLOR_RGB2HSV` enum cv::ColorConversionCodes
`static int`	`COLOR_RGB2HSV_FULL` enum cv::ColorConversionCodes
`static int`	`COLOR_RGB2Lab` enum cv::ColorConversionCodes
`static int`	`COLOR_RGB2Luv` enum cv::ColorConversionCodes
`static int`	`COLOR_RGB2RGBA` enum cv::ColorConversionCodes
`static int`	`COLOR_RGB2XYZ` enum cv::ColorConversionCodes
`static int`	`COLOR_RGB2YCrCb` enum cv::ColorConversionCodes
`static int`	`COLOR_RGB2YUV` enum cv::ColorConversionCodes
`static int`	`COLOR_RGB2YUV_I420` enum cv::ColorConversionCodes
`static int`	`COLOR_RGB2YUV_IYUV` enum cv::ColorConversionCodes
`static int`	`COLOR_RGB2YUV_YV12` enum cv::ColorConversionCodes
`static int`	`COLOR_RGBA2BGR` enum cv::ColorConversionCodes
`static int`	`COLOR_RGBA2BGR555` enum cv::ColorConversionCodes
`static int`	`COLOR_RGBA2BGR565` enum cv::ColorConversionCodes
`static int`	`COLOR_RGBA2BGRA` enum cv::ColorConversionCodes
`static int`	`COLOR_RGBA2GRAY` enum cv::ColorConversionCodes
`static int`	`COLOR_RGBA2mRGBA` enum cv::ColorConversionCodes
`static int`	`COLOR_RGBA2RGB` enum cv::ColorConversionCodes
`static int`	`COLOR_RGBA2YUV_I420` enum cv::ColorConversionCodes
`static int`	`COLOR_RGBA2YUV_IYUV` enum cv::ColorConversionCodes
`static int`	`COLOR_RGBA2YUV_YV12` enum cv::ColorConversionCodes
`static int`	`COLOR_XYZ2BGR` enum cv::ColorConversionCodes
`static int`	`COLOR_XYZ2RGB` enum cv::ColorConversionCodes
`static int`	`COLOR_YCrCb2BGR` enum cv::ColorConversionCodes
`static int`	`COLOR_YCrCb2RGB` enum cv::ColorConversionCodes
`static int`	`COLOR_YUV2BGR` enum cv::ColorConversionCodes
`static int`	`COLOR_YUV2BGR_I420` enum cv::ColorConversionCodes
`static int`	`COLOR_YUV2BGR_IYUV` enum cv::ColorConversionCodes
`static int`	`COLOR_YUV2BGR_NV12` enum cv::ColorConversionCodes
`static int`	`COLOR_YUV2BGR_NV21` enum cv::ColorConversionCodes
`static int`	`COLOR_YUV2BGR_UYNV` enum cv::ColorConversionCodes
`static int`	`COLOR_YUV2BGR_UYVY` enum cv::ColorConversionCodes
`static int`	`COLOR_YUV2BGR_Y422` enum cv::ColorConversionCodes
`static int`	`COLOR_YUV2BGR_YUNV` enum cv::ColorConversionCodes
`static int`	`COLOR_YUV2BGR_YUY2` enum cv::ColorConversionCodes
`static int`	`COLOR_YUV2BGR_YUYV` enum cv::ColorConversionCodes
`static int`	`COLOR_YUV2BGR_YV12` enum cv::ColorConversionCodes
`static int`	`COLOR_YUV2BGR_YVYU` enum cv::ColorConversionCodes
`static int`	`COLOR_YUV2BGRA_I420` enum cv::ColorConversionCodes
`static int`	`COLOR_YUV2BGRA_IYUV` enum cv::ColorConversionCodes
`static int`	`COLOR_YUV2BGRA_NV12` enum cv::ColorConversionCodes
`static int`	`COLOR_YUV2BGRA_NV21` enum cv::ColorConversionCodes
`static int`	`COLOR_YUV2BGRA_UYNV` enum cv::ColorConversionCodes
`static int`	`COLOR_YUV2BGRA_UYVY` enum cv::ColorConversionCodes
`static int`	`COLOR_YUV2BGRA_Y422` enum cv::ColorConversionCodes
`static int`	`COLOR_YUV2BGRA_YUNV` enum cv::ColorConversionCodes
`static int`	`COLOR_YUV2BGRA_YUY2` enum cv::ColorConversionCodes
`static int`	`COLOR_YUV2BGRA_YUYV` enum cv::ColorConversionCodes
`static int`	`COLOR_YUV2BGRA_YV12` enum cv::ColorConversionCodes
`static int`	`COLOR_YUV2BGRA_YVYU` enum cv::ColorConversionCodes
`static int`	`COLOR_YUV2GRAY_420` enum cv::ColorConversionCodes
`static int`	`COLOR_YUV2GRAY_I420` enum cv::ColorConversionCodes
`static int`	`COLOR_YUV2GRAY_IYUV` enum cv::ColorConversionCodes
`static int`	`COLOR_YUV2GRAY_NV12` enum cv::ColorConversionCodes
`static int`	`COLOR_YUV2GRAY_NV21` enum cv::ColorConversionCodes
`static int`	`COLOR_YUV2GRAY_UYNV` enum cv::ColorConversionCodes
`static int`	`COLOR_YUV2GRAY_UYVY` enum cv::ColorConversionCodes
`static int`	`COLOR_YUV2GRAY_Y422` enum cv::ColorConversionCodes
`static int`	`COLOR_YUV2GRAY_YUNV` enum cv::ColorConversionCodes
`static int`	`COLOR_YUV2GRAY_YUY2` enum cv::ColorConversionCodes
`static int`	`COLOR_YUV2GRAY_YUYV` enum cv::ColorConversionCodes
`static int`	`COLOR_YUV2GRAY_YV12` enum cv::ColorConversionCodes
`static int`	`COLOR_YUV2GRAY_YVYU` enum cv::ColorConversionCodes
`static int`	`COLOR_YUV2RGB` enum cv::ColorConversionCodes
`static int`	`COLOR_YUV2RGB_I420` enum cv::ColorConversionCodes
`static int`	`COLOR_YUV2RGB_IYUV` enum cv::ColorConversionCodes
`static int`	`COLOR_YUV2RGB_NV12` enum cv::ColorConversionCodes
`static int`	`COLOR_YUV2RGB_NV21` enum cv::ColorConversionCodes
`static int`	`COLOR_YUV2RGB_UYNV` enum cv::ColorConversionCodes
`static int`	`COLOR_YUV2RGB_UYVY` enum cv::ColorConversionCodes
`static int`	`COLOR_YUV2RGB_Y422` enum cv::ColorConversionCodes
`static int`	`COLOR_YUV2RGB_YUNV` enum cv::ColorConversionCodes
`static int`	`COLOR_YUV2RGB_YUY2` enum cv::ColorConversionCodes
`static int`	`COLOR_YUV2RGB_YUYV` enum cv::ColorConversionCodes
`static int`	`COLOR_YUV2RGB_YV12` enum cv::ColorConversionCodes
`static int`	`COLOR_YUV2RGB_YVYU` enum cv::ColorConversionCodes
`static int`	`COLOR_YUV2RGBA_I420` enum cv::ColorConversionCodes
`static int`	`COLOR_YUV2RGBA_IYUV` enum cv::ColorConversionCodes
`static int`	`COLOR_YUV2RGBA_NV12` enum cv::ColorConversionCodes
`static int`	`COLOR_YUV2RGBA_NV21` enum cv::ColorConversionCodes
`static int`	`COLOR_YUV2RGBA_UYNV` enum cv::ColorConversionCodes
`static int`	`COLOR_YUV2RGBA_UYVY` enum cv::ColorConversionCodes
`static int`	`COLOR_YUV2RGBA_Y422` enum cv::ColorConversionCodes
`static int`	`COLOR_YUV2RGBA_YUNV` enum cv::ColorConversionCodes
`static int`	`COLOR_YUV2RGBA_YUY2` enum cv::ColorConversionCodes
`static int`	`COLOR_YUV2RGBA_YUYV` enum cv::ColorConversionCodes
`static int`	`COLOR_YUV2RGBA_YV12` enum cv::ColorConversionCodes
`static int`	`COLOR_YUV2RGBA_YVYU` enum cv::ColorConversionCodes
`static int`	`COLOR_YUV420p2BGR` enum cv::ColorConversionCodes
`static int`	`COLOR_YUV420p2BGRA` enum cv::ColorConversionCodes
`static int`	`COLOR_YUV420p2GRAY` enum cv::ColorConversionCodes
`static int`	`COLOR_YUV420p2RGB` enum cv::ColorConversionCodes
`static int`	`COLOR_YUV420p2RGBA` enum cv::ColorConversionCodes
`static int`	`COLOR_YUV420sp2BGR` enum cv::ColorConversionCodes
`static int`	`COLOR_YUV420sp2BGRA` enum cv::ColorConversionCodes
`static int`	`COLOR_YUV420sp2GRAY` enum cv::ColorConversionCodes
`static int`	`COLOR_YUV420sp2RGB` enum cv::ColorConversionCodes
`static int`	`COLOR_YUV420sp2RGBA` enum cv::ColorConversionCodes
`static int`	`COLORMAP_AUTUMN` enum cv::ColormapTypes
`static int`	`COLORMAP_BONE` enum cv::ColormapTypes
`static int`	`COLORMAP_COOL` enum cv::ColormapTypes
`static int`	`COLORMAP_HOT` enum cv::ColormapTypes
`static int`	`COLORMAP_HSV` enum cv::ColormapTypes
`static int`	`COLORMAP_JET` enum cv::ColormapTypes
`static int`	`COLORMAP_OCEAN` enum cv::ColormapTypes
`static int`	`COLORMAP_PARULA` enum cv::ColormapTypes
`static int`	`COLORMAP_PINK` enum cv::ColormapTypes
`static int`	`COLORMAP_RAINBOW` enum cv::ColormapTypes
`static int`	`COLORMAP_SPRING` enum cv::ColormapTypes
`static int`	`COLORMAP_SUMMER` enum cv::ColormapTypes
`static int`	`COLORMAP_WINTER` enum cv::ColormapTypes
`static int`	`CV_AA`
`static int`	`CV_ADAPTIVE_THRESH_GAUSSIAN_C` enum
`static int`	`CV_ADAPTIVE_THRESH_MEAN_C` enum
`static int`	`CV_BayerBG2BGR` enum
`static int`	`CV_BayerBG2BGR_EA` enum
`static int`	`CV_BayerBG2BGR_VNG` enum
`static int`	`CV_BayerBG2GRAY` enum
`static int`	`CV_BayerBG2RGB` enum
`static int`	`CV_BayerBG2RGB_EA` enum
`static int`	`CV_BayerBG2RGB_VNG` enum
`static int`	`CV_BayerGB2BGR` enum
`static int`	`CV_BayerGB2BGR_EA` enum
`static int`	`CV_BayerGB2BGR_VNG` enum
`static int`	`CV_BayerGB2GRAY` enum
`static int`	`CV_BayerGB2RGB` enum
`static int`	`CV_BayerGB2RGB_EA` enum
`static int`	`CV_BayerGB2RGB_VNG` enum
`static int`	`CV_BayerGR2BGR` enum
`static int`	`CV_BayerGR2BGR_EA` enum
`static int`	`CV_BayerGR2BGR_VNG` enum
`static int`	`CV_BayerGR2GRAY` enum
`static int`	`CV_BayerGR2RGB` enum
`static int`	`CV_BayerGR2RGB_EA` enum
`static int`	`CV_BayerGR2RGB_VNG` enum
`static int`	`CV_BayerRG2BGR` enum
`static int`	`CV_BayerRG2BGR_EA` enum
`static int`	`CV_BayerRG2BGR_VNG` enum
`static int`	`CV_BayerRG2GRAY` enum
`static int`	`CV_BayerRG2RGB` enum
`static int`	`CV_BayerRG2RGB_EA` enum
`static int`	`CV_BayerRG2RGB_VNG` enum
`static int`	`CV_BGR2BGR555` enum
`static int`	`CV_BGR2BGR565` enum
`static int`	`CV_BGR2BGRA` enum
`static int`	`CV_BGR2GRAY` enum
`static int`	`CV_BGR2HLS` enum
`static int`	`CV_BGR2HLS_FULL` enum
`static int`	`CV_BGR2HSV` enum
`static int`	`CV_BGR2HSV_FULL` enum
`static int`	`CV_BGR2Lab` enum
`static int`	`CV_BGR2Luv` enum
`static int`	`CV_BGR2RGB` enum
`static int`	`CV_BGR2RGBA` enum
`static int`	`CV_BGR2XYZ` enum
`static int`	`CV_BGR2YCrCb` enum
`static int`	`CV_BGR2YUV` enum
`static int`	`CV_BGR2YUV_I420` enum
`static int`	`CV_BGR2YUV_IYUV` enum
`static int`	`CV_BGR2YUV_YV12` enum
`static int`	`CV_BGR5552BGR` enum
`static int`	`CV_BGR5552BGRA` enum
`static int`	`CV_BGR5552GRAY` enum
`static int`	`CV_BGR5552RGB` enum
`static int`	`CV_BGR5552RGBA` enum
`static int`	`CV_BGR5652BGR` enum
`static int`	`CV_BGR5652BGRA` enum
`static int`	`CV_BGR5652GRAY` enum
`static int`	`CV_BGR5652RGB` enum
`static int`	`CV_BGR5652RGBA` enum
`static int`	`CV_BGRA2BGR` enum
`static int`	`CV_BGRA2BGR555` enum
`static int`	`CV_BGRA2BGR565` enum
`static int`	`CV_BGRA2GRAY` enum
`static int`	`CV_BGRA2RGB` enum
`static int`	`CV_BGRA2RGBA` enum
`static int`	`CV_BGRA2YUV_I420` enum
`static int`	`CV_BGRA2YUV_IYUV` enum
`static int`	`CV_BGRA2YUV_YV12` enum
`static int`	`CV_BILATERAL` enum SmoothMethod_c
`static int`	`CV_BLUR` enum SmoothMethod_c
`static int`	`CV_BLUR_NO_SCALE` enum SmoothMethod_c
`static int`	`CV_CANNY_L2_GRADIENT` enum
`static int`	`CV_CHAIN_APPROX_NONE` enum
`static int`	`CV_CHAIN_APPROX_SIMPLE` enum
`static int`	`CV_CHAIN_APPROX_TC89_KCOS` enum
`static int`	`CV_CHAIN_APPROX_TC89_L1` enum
`static int`	`CV_CHAIN_CODE` enum
`static int`	`CV_CLOCKWISE` enum
`static int`	`CV_COLORCVT_MAX` enum
`static int`	`CV_COMP_BHATTACHARYYA` enum
`static int`	`CV_COMP_CHISQR` enum
`static int`	`CV_COMP_CHISQR_ALT` enum
`static int`	`CV_COMP_CORREL` enum
`static int`	`CV_COMP_HELLINGER` enum
`static int`	`CV_COMP_INTERSECT` enum
`static int`	`CV_COMP_KL_DIV` enum
`static int`	`CV_CONTOURS_MATCH_I1` enum ShapeMatchModes
`static int`	`CV_CONTOURS_MATCH_I2` enum ShapeMatchModes
`static int`	`CV_CONTOURS_MATCH_I3` enum ShapeMatchModes
`static int`	`CV_COUNTER_CLOCKWISE` enum
`static int`	`CV_DIST_C` enum
`static int`	`CV_DIST_FAIR` enum
`static int`	`CV_DIST_HUBER` enum
`static int`	`CV_DIST_L1` enum
`static int`	`CV_DIST_L12` enum
`static int`	`CV_DIST_L2` enum
`static int`	`CV_DIST_LABEL_CCOMP` enum
`static int`	`CV_DIST_LABEL_PIXEL` enum
`static int`	`CV_DIST_MASK_3` enum
`static int`	`CV_DIST_MASK_5` enum
`static int`	`CV_DIST_MASK_PRECISE` enum
`static int`	`CV_DIST_USER` enum
`static int`	`CV_DIST_WELSCH` enum
`static int`	`CV_FILLED` \ Drawing functions work with images/matrices of arbitrary type.
`static int`	`CV_FLOODFILL_FIXED_RANGE` enum
`static int`	`CV_FLOODFILL_MASK_ONLY` enum
`static int`	`CV_FONT_HERSHEY_COMPLEX`
`static int`	`CV_FONT_HERSHEY_COMPLEX_SMALL`
`static int`	`CV_FONT_HERSHEY_DUPLEX`
`static int`	`CV_FONT_HERSHEY_PLAIN`
`static int`	`CV_FONT_HERSHEY_SCRIPT_COMPLEX`
`static int`	`CV_FONT_HERSHEY_SCRIPT_SIMPLEX`
`static int`	`CV_FONT_HERSHEY_SIMPLEX`
`static int`	`CV_FONT_HERSHEY_TRIPLEX`
`static int`	`CV_FONT_ITALIC`
`static int`	`CV_FONT_VECTOR0`
`static int`	`CV_GAUSSIAN` enum SmoothMethod_c
`static int`	`CV_GAUSSIAN_5x5` enum
`static int`	`CV_GRAY2BGR` enum
`static int`	`CV_GRAY2BGR555` enum
`static int`	`CV_GRAY2BGR565` enum
`static int`	`CV_GRAY2BGRA` enum
`static int`	`CV_GRAY2RGB` enum
`static int`	`CV_GRAY2RGBA` enum
`static int`	`CV_HLS2BGR` enum
`static int`	`CV_HLS2BGR_FULL` enum
`static int`	`CV_HLS2RGB` enum
`static int`	`CV_HLS2RGB_FULL` enum
`static int`	`CV_HOUGH_GRADIENT` enum
`static int`	`CV_HOUGH_MULTI_SCALE` enum
`static int`	`CV_HOUGH_PROBABILISTIC` enum
`static int`	`CV_HOUGH_STANDARD` enum
`static int`	`CV_HSV2BGR` enum
`static int`	`CV_HSV2BGR_FULL` enum
`static int`	`CV_HSV2RGB` enum
`static int`	`CV_HSV2RGB_FULL` enum
`static int`	`CV_INTER_AREA` enum
`static int`	`CV_INTER_CUBIC` enum
`static int`	`CV_INTER_LANCZOS4` enum
`static int`	`CV_INTER_LINEAR` enum
`static int`	`CV_INTER_NN` enum
`static int`	`CV_Lab2BGR` enum
`static int`	`CV_Lab2LBGR` enum
`static int`	`CV_Lab2LRGB` enum
`static int`	`CV_Lab2RGB` enum
`static int`	`CV_LBGR2Lab` enum
`static int`	`CV_LBGR2Luv` enum
`static int`	`CV_LINK_RUNS` enum
`static int`	`CV_LRGB2Lab` enum
`static int`	`CV_LRGB2Luv` enum
`static int`	`CV_Luv2BGR` enum
`static int`	`CV_Luv2LBGR` enum
`static int`	`CV_Luv2LRGB` enum
`static int`	`CV_Luv2RGB` enum
`static int`	`CV_MAX_SOBEL_KSIZE` enum
`static int`	`CV_MEDIAN` enum SmoothMethod_c
`static int`	`CV_MOP_BLACKHAT` enum
`static int`	`CV_MOP_CLOSE` enum
`static int`	`CV_MOP_DILATE` enum
`static int`	`CV_MOP_ERODE` enum
`static int`	`CV_MOP_GRADIENT` enum
`static int`	`CV_MOP_OPEN` enum
`static int`	`CV_MOP_TOPHAT` enum
`static int`	`CV_mRGBA2RGBA` enum
`static int`	`CV_POLY_APPROX_DP` enum
`static int`	`CV_RETR_CCOMP` enum
`static int`	`CV_RETR_EXTERNAL` enum
`static int`	`CV_RETR_FLOODFILL` enum
`static int`	`CV_RETR_LIST` enum
`static int`	`CV_RETR_TREE` enum
`static int`	`CV_RGB2BGR` enum
`static int`	`CV_RGB2BGR555` enum
`static int`	`CV_RGB2BGR565` enum
`static int`	`CV_RGB2BGRA` enum
`static int`	`CV_RGB2GRAY` enum
`static int`	`CV_RGB2HLS` enum
`static int`	`CV_RGB2HLS_FULL` enum
`static int`	`CV_RGB2HSV` enum
`static int`	`CV_RGB2HSV_FULL` enum
`static int`	`CV_RGB2Lab` enum
`static int`	`CV_RGB2Luv` enum
`static int`	`CV_RGB2RGBA` enum
`static int`	`CV_RGB2XYZ` enum
`static int`	`CV_RGB2YCrCb` enum
`static int`	`CV_RGB2YUV` enum
`static int`	`CV_RGB2YUV_I420` enum
`static int`	`CV_RGB2YUV_IYUV` enum
`static int`	`CV_RGB2YUV_YV12` enum
`static int`	`CV_RGBA2BGR` enum
`static int`	`CV_RGBA2BGR555` enum
`static int`	`CV_RGBA2BGR565` enum
`static int`	`CV_RGBA2BGRA` enum
`static int`	`CV_RGBA2GRAY` enum
`static int`	`CV_RGBA2mRGBA` enum
`static int`	`CV_RGBA2RGB` enum
`static int`	`CV_RGBA2YUV_I420` enum
`static int`	`CV_RGBA2YUV_IYUV` enum
`static int`	`CV_RGBA2YUV_YV12` enum
`static int`	`CV_SCHARR` enum
`static int`	`CV_SHAPE_CROSS` enum MorphShapes_c
`static int`	`CV_SHAPE_CUSTOM` enum MorphShapes_c
`static int`	`CV_SHAPE_ELLIPSE` enum MorphShapes_c
`static int`	`CV_SHAPE_RECT` enum MorphShapes_c
`static int`	`CV_THRESH_BINARY` enum
`static int`	`CV_THRESH_BINARY_INV` enum
`static int`	`CV_THRESH_MASK` enum
`static int`	`CV_THRESH_OTSU` enum
`static int`	`CV_THRESH_TOZERO` enum
`static int`	`CV_THRESH_TOZERO_INV` enum
`static int`	`CV_THRESH_TRIANGLE` enum
`static int`	`CV_THRESH_TRUNC` enum
`static int`	`CV_TM_CCOEFF` enum
`static int`	`CV_TM_CCOEFF_NORMED` enum
`static int`	`CV_TM_CCORR` enum
`static int`	`CV_TM_CCORR_NORMED` enum
`static int`	`CV_TM_SQDIFF` enum
`static int`	`CV_TM_SQDIFF_NORMED` enum
`static int`	`CV_WARP_FILL_OUTLIERS` enum
`static int`	`CV_WARP_INVERSE_MAP` enum
`static int`	`CV_XYZ2BGR` enum
`static int`	`CV_XYZ2RGB` enum
`static int`	`CV_YCrCb2BGR` enum
`static int`	`CV_YCrCb2RGB` enum
`static int`	`CV_YUV2BGR` enum
`static int`	`CV_YUV2BGR_I420` enum
`static int`	`CV_YUV2BGR_IYUV` enum
`static int`	`CV_YUV2BGR_NV12` enum
`static int`	`CV_YUV2BGR_NV21` enum
`static int`	`CV_YUV2BGR_UYNV` enum
`static int`	`CV_YUV2BGR_UYVY` enum
`static int`	`CV_YUV2BGR_Y422` enum
`static int`	`CV_YUV2BGR_YUNV` enum
`static int`	`CV_YUV2BGR_YUY2` enum
`static int`	`CV_YUV2BGR_YUYV` enum
`static int`	`CV_YUV2BGR_YV12` enum
`static int`	`CV_YUV2BGR_YVYU` enum
`static int`	`CV_YUV2BGRA_I420` enum
`static int`	`CV_YUV2BGRA_IYUV` enum
`static int`	`CV_YUV2BGRA_NV12` enum
`static int`	`CV_YUV2BGRA_NV21` enum
`static int`	`CV_YUV2BGRA_UYNV` enum
`static int`	`CV_YUV2BGRA_UYVY` enum
`static int`	`CV_YUV2BGRA_Y422` enum
`static int`	`CV_YUV2BGRA_YUNV` enum
`static int`	`CV_YUV2BGRA_YUY2` enum
`static int`	`CV_YUV2BGRA_YUYV` enum
`static int`	`CV_YUV2BGRA_YV12` enum
`static int`	`CV_YUV2BGRA_YVYU` enum
`static int`	`CV_YUV2GRAY_420` enum
`static int`	`CV_YUV2GRAY_I420` enum
`static int`	`CV_YUV2GRAY_IYUV` enum
`static int`	`CV_YUV2GRAY_NV12` enum
`static int`	`CV_YUV2GRAY_NV21` enum
`static int`	`CV_YUV2GRAY_UYNV` enum
`static int`	`CV_YUV2GRAY_UYVY` enum
`static int`	`CV_YUV2GRAY_Y422` enum
`static int`	`CV_YUV2GRAY_YUNV` enum
`static int`	`CV_YUV2GRAY_YUY2` enum
`static int`	`CV_YUV2GRAY_YUYV` enum
`static int`	`CV_YUV2GRAY_YV12` enum
`static int`	`CV_YUV2GRAY_YVYU` enum
`static int`	`CV_YUV2RGB` enum
`static int`	`CV_YUV2RGB_I420` enum
`static int`	`CV_YUV2RGB_IYUV` enum
`static int`	`CV_YUV2RGB_NV12` enum
`static int`	`CV_YUV2RGB_NV21` enum
`static int`	`CV_YUV2RGB_UYNV` enum
`static int`	`CV_YUV2RGB_UYVY` enum
`static int`	`CV_YUV2RGB_Y422` enum
`static int`	`CV_YUV2RGB_YUNV` enum
`static int`	`CV_YUV2RGB_YUY2` enum
`static int`	`CV_YUV2RGB_YUYV` enum
`static int`	`CV_YUV2RGB_YV12` enum
`static int`	`CV_YUV2RGB_YVYU` enum
`static int`	`CV_YUV2RGBA_I420` enum
`static int`	`CV_YUV2RGBA_IYUV` enum
`static int`	`CV_YUV2RGBA_NV12` enum
`static int`	`CV_YUV2RGBA_NV21` enum
`static int`	`CV_YUV2RGBA_UYNV` enum
`static int`	`CV_YUV2RGBA_UYVY` enum
`static int`	`CV_YUV2RGBA_Y422` enum
`static int`	`CV_YUV2RGBA_YUNV` enum
`static int`	`CV_YUV2RGBA_YUY2` enum
`static int`	`CV_YUV2RGBA_YUYV` enum
`static int`	`CV_YUV2RGBA_YV12` enum
`static int`	`CV_YUV2RGBA_YVYU` enum
`static int`	`CV_YUV420p2BGR` enum
`static int`	`CV_YUV420p2BGRA` enum
`static int`	`CV_YUV420p2GRAY` enum
`static int`	`CV_YUV420p2RGB` enum
`static int`	`CV_YUV420p2RGBA` enum
`static int`	`CV_YUV420sp2BGR` enum
`static int`	`CV_YUV420sp2BGRA` enum
`static int`	`CV_YUV420sp2GRAY` enum
`static int`	`CV_YUV420sp2RGB` enum
`static int`	`CV_YUV420sp2RGBA` enum
`static int`	`DIST_C` enum cv::DistanceTypes
`static int`	`DIST_FAIR` enum cv::DistanceTypes
`static int`	`DIST_HUBER` enum cv::DistanceTypes
`static int`	`DIST_L1` enum cv::DistanceTypes
`static int`	`DIST_L12` enum cv::DistanceTypes
`static int`	`DIST_L2` enum cv::DistanceTypes
`static int`	`DIST_LABEL_CCOMP` enum cv::DistanceTransformLabelTypes
`static int`	`DIST_LABEL_PIXEL` enum cv::DistanceTransformLabelTypes
`static int`	`DIST_MASK_3` enum cv::DistanceTransformMasks
`static int`	`DIST_MASK_5` enum cv::DistanceTransformMasks
`static int`	`DIST_MASK_PRECISE` enum cv::DistanceTransformMasks
`static int`	`DIST_USER` enum cv::DistanceTypes
`static int`	`DIST_WELSCH` enum cv::DistanceTypes
`static int`	`FLOODFILL_FIXED_RANGE` enum cv::FloodFillFlags
`static int`	`FLOODFILL_MASK_ONLY` enum cv::FloodFillFlags
`static int`	`GC_BGD` enum cv::GrabCutClasses
`static int`	`GC_EVAL` enum cv::GrabCutModes
`static int`	`GC_FGD` enum cv::GrabCutClasses
`static int`	`GC_INIT_WITH_MASK` enum cv::GrabCutModes
`static int`	`GC_INIT_WITH_RECT` enum cv::GrabCutModes
`static int`	`GC_PR_BGD` enum cv::GrabCutClasses
`static int`	`GC_PR_FGD` enum cv::GrabCutClasses
`static int`	`HISTCMP_BHATTACHARYYA` enum cv::HistCompMethods
`static int`	`HISTCMP_CHISQR` enum cv::HistCompMethods
`static int`	`HISTCMP_CHISQR_ALT` enum cv::HistCompMethods
`static int`	`HISTCMP_CORREL` enum cv::HistCompMethods
`static int`	`HISTCMP_HELLINGER` enum cv::HistCompMethods
`static int`	`HISTCMP_INTERSECT` enum cv::HistCompMethods
`static int`	`HISTCMP_KL_DIV` enum cv::HistCompMethods
`static int`	`HOUGH_GRADIENT` enum cv::HoughModes
`static int`	`HOUGH_MULTI_SCALE` enum cv::HoughModes
`static int`	`HOUGH_PROBABILISTIC` enum cv::HoughModes
`static int`	`HOUGH_STANDARD` enum cv::HoughModes
`static int`	`INTER_AREA` enum cv::InterpolationFlags
`static int`	`INTER_BITS` enum cv::InterpolationMasks
`static int`	`INTER_BITS2` enum cv::InterpolationMasks
`static int`	`INTER_CUBIC` enum cv::InterpolationFlags
`static int`	`INTER_LANCZOS4` enum cv::InterpolationFlags
`static int`	`INTER_LINEAR` enum cv::InterpolationFlags
`static int`	`INTER_MAX` enum cv::InterpolationFlags
`static int`	`INTER_NEAREST` enum cv::InterpolationFlags
`static int`	`INTER_TAB_SIZE` enum cv::InterpolationMasks
`static int`	`INTER_TAB_SIZE2` enum cv::InterpolationMasks
`static int`	`INTERSECT_FULL` enum cv::RectanglesIntersectTypes
`static int`	`INTERSECT_NONE` enum cv::RectanglesIntersectTypes
`static int`	`INTERSECT_PARTIAL` enum cv::RectanglesIntersectTypes
`static int`	`LSD_REFINE_ADV` enum cv::LineSegmentDetectorModes
`static int`	`LSD_REFINE_NONE` enum cv::LineSegmentDetectorModes
`static int`	`LSD_REFINE_STD` enum cv::LineSegmentDetectorModes
`static int`	`MARKER_CROSS` enum cv::MarkerTypes
`static int`	`MARKER_DIAMOND` enum cv::MarkerTypes
`static int`	`MARKER_SQUARE` enum cv::MarkerTypes
`static int`	`MARKER_STAR` enum cv::MarkerTypes
`static int`	`MARKER_TILTED_CROSS` enum cv::MarkerTypes
`static int`	`MARKER_TRIANGLE_DOWN` enum cv::MarkerTypes
`static int`	`MARKER_TRIANGLE_UP` enum cv::MarkerTypes
`static int`	`MORPH_BLACKHAT` enum cv::MorphTypes
`static int`	`MORPH_CLOSE` enum cv::MorphTypes
`static int`	`MORPH_CROSS` enum cv::MorphShapes
`static int`	`MORPH_DILATE` enum cv::MorphTypes
`static int`	`MORPH_ELLIPSE` enum cv::MorphShapes
`static int`	`MORPH_ERODE` enum cv::MorphTypes
`static int`	`MORPH_GRADIENT` enum cv::MorphTypes
`static int`	`MORPH_HITMISS` enum cv::MorphTypes
`static int`	`MORPH_OPEN` enum cv::MorphTypes
`static int`	`MORPH_RECT` enum cv::MorphShapes
`static int`	`MORPH_TOPHAT` enum cv::MorphTypes
`static int`	`PROJ_SPHERICAL_EQRECT` enum cv::UndistortTypes
`static int`	`PROJ_SPHERICAL_ORTHO` enum cv::UndistortTypes
`static int`	`RETR_CCOMP` enum cv::RetrievalModes
`static int`	`RETR_EXTERNAL` enum cv::RetrievalModes
`static int`	`RETR_FLOODFILL` enum cv::RetrievalModes
`static int`	`RETR_LIST` enum cv::RetrievalModes
`static int`	`RETR_TREE` enum cv::RetrievalModes
`static int`	`THRESH_BINARY` enum cv::ThresholdTypes
`static int`	`THRESH_BINARY_INV` enum cv::ThresholdTypes
`static int`	`THRESH_MASK` enum cv::ThresholdTypes
`static int`	`THRESH_OTSU` enum cv::ThresholdTypes
`static int`	`THRESH_TOZERO` enum cv::ThresholdTypes
`static int`	`THRESH_TOZERO_INV` enum cv::ThresholdTypes
`static int`	`THRESH_TRIANGLE` enum cv::ThresholdTypes
`static int`	`THRESH_TRUNC` enum cv::ThresholdTypes
`static int`	`TM_CCOEFF` enum cv::TemplateMatchModes
`static int`	`TM_CCOEFF_NORMED` enum cv::TemplateMatchModes
`static int`	`TM_CCORR` enum cv::TemplateMatchModes
`static int`	`TM_CCORR_NORMED` enum cv::TemplateMatchModes
`static int`	`TM_SQDIFF` enum cv::TemplateMatchModes
`static int`	`TM_SQDIFF_NORMED` enum cv::TemplateMatchModes
`static int`	`WARP_FILL_OUTLIERS` enum cv::InterpolationFlags
`static int`	`WARP_INVERSE_MAP` enum cv::InterpolationFlags

Constructor Summary

Constructors
Constructor and Description

opencv_imgproc()

Constructors
Constructor and Description
`opencv_imgproc()`

Method Summary

Methods
Modifier and Type	Method and Description
`static void`	`accumulate(opencv_core.Mat src, opencv_core.Mat dst)`
`static void`	`accumulate(opencv_core.Mat src, opencv_core.Mat dst, opencv_core.Mat mask)` \} imgproc_misc
`static void`	`accumulateProduct(opencv_core.Mat src1, opencv_core.Mat src2, opencv_core.Mat dst)`
`static void`	`accumulateProduct(opencv_core.Mat src1, opencv_core.Mat src2, opencv_core.Mat dst, opencv_core.Mat mask)` \brief Adds the per-element product of two input images to the accumulator.
`static void`	`accumulateSquare(opencv_core.Mat src, opencv_core.Mat dst)`
`static void`	`accumulateSquare(opencv_core.Mat src, opencv_core.Mat dst, opencv_core.Mat mask)` \brief Adds the square of a source image to the accumulator.
`static void`	`accumulateWeighted(opencv_core.Mat src, opencv_core.Mat dst, double alpha)`
`static void`	`accumulateWeighted(opencv_core.Mat src, opencv_core.Mat dst, double alpha, opencv_core.Mat mask)` \brief Updates a running average.
`static void`	`adaptiveThreshold(opencv_core.Mat src, opencv_core.Mat dst, double maxValue, int adaptiveMethod, int thresholdType, int blockSize, double C)` \brief Applies an adaptive threshold to an array.
`static void`	`applyColorMap(opencv_core.Mat src, opencv_core.Mat dst, int colormap)` \brief Applies a GNU Octave/MATLAB equivalent colormap on a given image.
`static void`	`approxPolyDP(opencv_core.Mat curve, opencv_core.Mat approxCurve, double epsilon, boolean closed)` \brief Approximates a polygonal curve(s) with the specified precision.
`static double`	`arcLength(opencv_core.Mat curve, boolean closed)` \brief Calculates a contour perimeter or a curve length.
`static void`	`arrowedLine(opencv_core.Mat img, opencv_core.Point pt1, opencv_core.Point pt2, opencv_core.Scalar color)`
`static void`	`arrowedLine(opencv_core.Mat img, opencv_core.Point pt1, opencv_core.Point pt2, opencv_core.Scalar color, int thickness, int line_type, int shift, double tipLength)` \brief Draws a arrow segment pointing from the first point to the second one.
`static void`	`bilateralFilter(opencv_core.Mat src, opencv_core.Mat dst, int d, double sigmaColor, double sigmaSpace)`
`static void`	`bilateralFilter(opencv_core.Mat src, opencv_core.Mat dst, int d, double sigmaColor, double sigmaSpace, int borderType)` \brief Applies the bilateral filter to an image.
`static void`	`blendLinear(opencv_core.Mat src1, opencv_core.Mat src2, opencv_core.Mat weights1, opencv_core.Mat weights2, opencv_core.Mat dst)` Performs linear blending of two images
`static void`	`blur(opencv_core.Mat src, opencv_core.Mat dst, opencv_core.Size ksize)`
`static void`	`blur(opencv_core.Mat src, opencv_core.Mat dst, opencv_core.Size ksize, opencv_core.Point anchor, int borderType)` \brief Blurs an image using the normalized box filter.
`static opencv_core.Rect`	`boundingRect(opencv_core.Mat points)` \brief Calculates the up-right bounding rectangle of a point set.
`static void`	`boxFilter(opencv_core.Mat src, opencv_core.Mat dst, int ddepth, opencv_core.Size ksize)`
`static void`	`boxFilter(opencv_core.Mat src, opencv_core.Mat dst, int ddepth, opencv_core.Size ksize, opencv_core.Point anchor, boolean normalize, int borderType)` \brief Blurs an image using the box filter.
`static void`	`boxPoints(opencv_core.RotatedRect box, opencv_core.Mat points)` \brief Finds the four vertices of a rotated rect.
`static void`	`buildPyramid(opencv_core.Mat src, opencv_core.MatVector dst, int maxlevel)`
`static void`	`buildPyramid(opencv_core.Mat src, opencv_core.MatVector dst, int maxlevel, int borderType)` \brief Constructs the Gaussian pyramid for an image.
`static void`	`calcBackProject(opencv_core.Mat images, int nimages, int[] channels, opencv_core.Mat hist, opencv_core.Mat backProject, float[] ranges)`
`static void`	`calcBackProject(opencv_core.Mat images, int nimages, int[] channels, opencv_core.Mat hist, opencv_core.Mat backProject, float[] ranges, double scale, boolean uniform)`
`static void`	`calcBackProject(opencv_core.Mat images, int nimages, int[] channels, opencv_core.SparseMat hist, opencv_core.Mat backProject, float[] ranges)`
`static void`	`calcBackProject(opencv_core.Mat images, int nimages, int[] channels, opencv_core.SparseMat hist, opencv_core.Mat backProject, float[] ranges, double scale, boolean uniform)`
`static void`	`calcBackProject(opencv_core.Mat images, int nimages, IntBuffer channels, opencv_core.Mat hist, opencv_core.Mat backProject, FloatBuffer ranges)`
`static void`	`calcBackProject(opencv_core.Mat images, int nimages, IntBuffer channels, opencv_core.Mat hist, opencv_core.Mat backProject, FloatBuffer ranges, double scale, boolean uniform)`
`static void`	`calcBackProject(opencv_core.Mat images, int nimages, IntBuffer channels, opencv_core.SparseMat hist, opencv_core.Mat backProject, FloatBuffer ranges)`
`static void`	`calcBackProject(opencv_core.Mat images, int nimages, IntBuffer channels, opencv_core.SparseMat hist, opencv_core.Mat backProject, FloatBuffer ranges, double scale, boolean uniform)`
`static void`	`calcBackProject(opencv_core.Mat images, int nimages, IntPointer channels, opencv_core.Mat hist, opencv_core.Mat backProject, FloatPointer ranges)`
`static void`	`calcBackProject(opencv_core.Mat images, int nimages, IntPointer channels, opencv_core.Mat hist, opencv_core.Mat backProject, FloatPointer ranges, double scale, boolean uniform)`
`static void`	`calcBackProject(opencv_core.Mat images, int nimages, IntPointer channels, opencv_core.Mat hist, opencv_core.Mat backProject, PointerPointer ranges, double scale, boolean uniform)` \brief Calculates the back projection of a histogram.
`static void`	`calcBackProject(opencv_core.Mat images, int nimages, IntPointer channels, opencv_core.SparseMat hist, opencv_core.Mat backProject, FloatPointer ranges)`
`static void`	`calcBackProject(opencv_core.Mat images, int nimages, IntPointer channels, opencv_core.SparseMat hist, opencv_core.Mat backProject, FloatPointer ranges, double scale, boolean uniform)`
`static void`	`calcBackProject(opencv_core.Mat images, int nimages, IntPointer channels, opencv_core.SparseMat hist, opencv_core.Mat backProject, PointerPointer ranges, double scale, boolean uniform)` \overload
`static void`	`calcBackProject(opencv_core.MatVector images, int[] channels, opencv_core.Mat hist, opencv_core.Mat dst, float[] ranges, double scale)`
`static void`	`calcBackProject(opencv_core.MatVector images, IntBuffer channels, opencv_core.Mat hist, opencv_core.Mat dst, FloatBuffer ranges, double scale)`
`static void`	`calcBackProject(opencv_core.MatVector images, IntPointer channels, opencv_core.Mat hist, opencv_core.Mat dst, FloatPointer ranges, double scale)` \overload
`static void`	`calcHist(opencv_core.Mat images, int nimages, int[] channels, opencv_core.Mat mask, opencv_core.Mat hist, int dims, int[] histSize, float[] ranges)`
`static void`	`calcHist(opencv_core.Mat images, int nimages, int[] channels, opencv_core.Mat mask, opencv_core.Mat hist, int dims, int[] histSize, float[] ranges, boolean uniform, boolean accumulate)`
`static void`	`calcHist(opencv_core.Mat images, int nimages, int[] channels, opencv_core.Mat mask, opencv_core.SparseMat hist, int dims, int[] histSize, float[] ranges)`
`static void`	`calcHist(opencv_core.Mat images, int nimages, int[] channels, opencv_core.Mat mask, opencv_core.SparseMat hist, int dims, int[] histSize, float[] ranges, boolean uniform, boolean accumulate)`
`static void`	`calcHist(opencv_core.Mat images, int nimages, IntBuffer channels, opencv_core.Mat mask, opencv_core.Mat hist, int dims, IntBuffer histSize, FloatBuffer ranges)`
`static void`	`calcHist(opencv_core.Mat images, int nimages, IntBuffer channels, opencv_core.Mat mask, opencv_core.Mat hist, int dims, IntBuffer histSize, FloatBuffer ranges, boolean uniform, boolean accumulate)`
`static void`	`calcHist(opencv_core.Mat images, int nimages, IntBuffer channels, opencv_core.Mat mask, opencv_core.SparseMat hist, int dims, IntBuffer histSize, FloatBuffer ranges)`
`static void`	`calcHist(opencv_core.Mat images, int nimages, IntBuffer channels, opencv_core.Mat mask, opencv_core.SparseMat hist, int dims, IntBuffer histSize, FloatBuffer ranges, boolean uniform, boolean accumulate)`
`static void`	`calcHist(opencv_core.Mat images, int nimages, IntPointer channels, opencv_core.Mat mask, opencv_core.Mat hist, int dims, IntPointer histSize, FloatPointer ranges)`
`static void`	`calcHist(opencv_core.Mat images, int nimages, IntPointer channels, opencv_core.Mat mask, opencv_core.Mat hist, int dims, IntPointer histSize, FloatPointer ranges, boolean uniform, boolean accumulate)`
`static void`	`calcHist(opencv_core.Mat images, int nimages, IntPointer channels, opencv_core.Mat mask, opencv_core.Mat hist, int dims, IntPointer histSize, PointerPointer ranges, boolean uniform, boolean accumulate)` \brief Calculates a histogram of a set of arrays.
`static void`	`calcHist(opencv_core.Mat images, int nimages, IntPointer channels, opencv_core.Mat mask, opencv_core.SparseMat hist, int dims, IntPointer histSize, FloatPointer ranges)`
`static void`	`calcHist(opencv_core.Mat images, int nimages, IntPointer channels, opencv_core.Mat mask, opencv_core.SparseMat hist, int dims, IntPointer histSize, FloatPointer ranges, boolean uniform, boolean accumulate)`
`static void`	`calcHist(opencv_core.Mat images, int nimages, IntPointer channels, opencv_core.Mat mask, opencv_core.SparseMat hist, int dims, IntPointer histSize, PointerPointer ranges, boolean uniform, boolean accumulate)` \overload
`static void`	`calcHist(opencv_core.MatVector images, int[] channels, opencv_core.Mat mask, opencv_core.Mat hist, int[] histSize, float[] ranges)`
`static void`	`calcHist(opencv_core.MatVector images, int[] channels, opencv_core.Mat mask, opencv_core.Mat hist, int[] histSize, float[] ranges, boolean accumulate)`
`static void`	`calcHist(opencv_core.MatVector images, IntBuffer channels, opencv_core.Mat mask, opencv_core.Mat hist, IntBuffer histSize, FloatBuffer ranges)`
`static void`	`calcHist(opencv_core.MatVector images, IntBuffer channels, opencv_core.Mat mask, opencv_core.Mat hist, IntBuffer histSize, FloatBuffer ranges, boolean accumulate)`
`static void`	`calcHist(opencv_core.MatVector images, IntPointer channels, opencv_core.Mat mask, opencv_core.Mat hist, IntPointer histSize, FloatPointer ranges)`
`static void`	`calcHist(opencv_core.MatVector images, IntPointer channels, opencv_core.Mat mask, opencv_core.Mat hist, IntPointer histSize, FloatPointer ranges, boolean accumulate)` \overload
`static void`	`Canny(opencv_core.Mat image, opencv_core.Mat edges, double threshold1, double threshold2)`
`static void`	`Canny(opencv_core.Mat image, opencv_core.Mat edges, double threshold1, double threshold2, int apertureSize, boolean L2gradient)` \brief Finds edges in an image using the Canny algorithm \cite Canny86 .
`static void`	`circle(opencv_core.Mat img, opencv_core.Point center, int radius, opencv_core.Scalar color)`
`static void`	`circle(opencv_core.Mat img, opencv_core.Point center, int radius, opencv_core.Scalar color, int thickness, int lineType, int shift)` \brief Draws a circle.
`static boolean`	`clipLine(opencv_core.Rect imgRect, opencv_core.Point pt1, opencv_core.Point pt2)` \overload
`static boolean`	`clipLine(opencv_core.Size imgSize, opencv_core.Point pt1, opencv_core.Point pt2)` \brief Clips the line against the image rectangle.
`static double`	`compareHist(opencv_core.Mat H1, opencv_core.Mat H2, int method)` \brief Compares two histograms.
`static double`	`compareHist(opencv_core.SparseMat H1, opencv_core.SparseMat H2, int method)` \overload
`static int`	`connectedComponents(opencv_core.Mat image, opencv_core.Mat labels)`
`static int`	`connectedComponents(opencv_core.Mat image, opencv_core.Mat labels, int connectivity, int ltype)` \}
`static int`	`connectedComponentsWithStats(opencv_core.Mat image, opencv_core.Mat labels, opencv_core.Mat stats, opencv_core.Mat centroids)`
`static int`	`connectedComponentsWithStats(opencv_core.Mat image, opencv_core.Mat labels, opencv_core.Mat stats, opencv_core.Mat centroids, int connectivity, int ltype)` \overload
`static double`	`contourArea(opencv_core.Mat contour)`
`static double`	`contourArea(opencv_core.Mat contour, boolean oriented)` \brief Calculates a contour area.
`static void`	`convertMaps(opencv_core.Mat map1, opencv_core.Mat map2, opencv_core.Mat dstmap1, opencv_core.Mat dstmap2, int dstmap1type)`
`static void`	`convertMaps(opencv_core.Mat map1, opencv_core.Mat map2, opencv_core.Mat dstmap1, opencv_core.Mat dstmap2, int dstmap1type, boolean nninterpolation)` \brief Converts image transformation maps from one representation to another.
`static void`	`convexHull(opencv_core.Mat points, opencv_core.Mat hull)`
`static void`	`convexHull(opencv_core.Mat points, opencv_core.Mat hull, boolean clockwise, boolean returnPoints)` \brief Finds the convex hull of a point set.
`static void`	`convexityDefects(opencv_core.Mat contour, opencv_core.Mat convexhull, opencv_core.Mat convexityDefects)` \brief Finds the convexity defects of a contour.
`static void`	`cornerEigenValsAndVecs(opencv_core.Mat src, opencv_core.Mat dst, int blockSize, int ksize)`
`static void`	`cornerEigenValsAndVecs(opencv_core.Mat src, opencv_core.Mat dst, int blockSize, int ksize, int borderType)` \brief Calculates eigenvalues and eigenvectors of image blocks for corner detection.
`static void`	`cornerHarris(opencv_core.Mat src, opencv_core.Mat dst, int blockSize, int ksize, double k)`
`static void`	`cornerHarris(opencv_core.Mat src, opencv_core.Mat dst, int blockSize, int ksize, double k, int borderType)` \brief Harris corner detector.
`static void`	`cornerMinEigenVal(opencv_core.Mat src, opencv_core.Mat dst, int blockSize)`
`static void`	`cornerMinEigenVal(opencv_core.Mat src, opencv_core.Mat dst, int blockSize, int ksize, int borderType)` \brief Calculates the minimal eigenvalue of gradient matrices for corner detection.
`static void`	`cornerSubPix(opencv_core.Mat image, opencv_core.Mat corners, opencv_core.Size winSize, opencv_core.Size zeroZone, opencv_core.TermCriteria criteria)` \brief Refines the corner locations.
`static opencv_imgproc.CLAHE`	`createCLAHE()`
`static opencv_imgproc.CLAHE`	`createCLAHE(double clipLimit, opencv_core.Size tileGridSize)` \} imgproc_shape
`static opencv_imgproc.GeneralizedHoughBallard`	`createGeneralizedHoughBallard()` Ballard, D.H.
`static opencv_imgproc.GeneralizedHoughGuil`	`createGeneralizedHoughGuil()` Guil, N., GonzÃ¡lez-Linares, J.M.
`static void`	`createHanningWindow(opencv_core.Mat dst, opencv_core.Size winSize, int type)` \brief This function computes a Hanning window coefficients in two dimensions.
`static opencv_imgproc.LineSegmentDetector`	`createLineSegmentDetector()`
`static opencv_imgproc.LineSegmentDetector`	`createLineSegmentDetector(int _refine, double _scale, double _sigma_scale, double _quant, double _ang_th, double _log_eps, double _density_th, int _n_bins)` \brief Creates a smart pointer to a LineSegmentDetector object and initializes it.
`static opencv_core.CvMat`	`cv2DRotationMatrix(float[] center, double angle, double scale, opencv_core.CvMat map_matrix)`
`static opencv_core.CvMat`	`cv2DRotationMatrix(FloatBuffer center, double angle, double scale, opencv_core.CvMat map_matrix)`
`static opencv_core.CvMat`	`cv2DRotationMatrix(opencv_core.CvPoint2D32f center, double angle, double scale, opencv_core.CvMat map_matrix)` \brief Computes rotation_matrix matrix
`static void`	`cvAcc(opencv_core.CvArr image, opencv_core.CvArr sum)`
`static void`	`cvAcc(opencv_core.CvArr image, opencv_core.CvArr sum, opencv_core.CvArr mask)` \brief Adds image to accumulator
`static void`	`cvAdaptiveThreshold(opencv_core.CvArr src, opencv_core.CvArr dst, double max_value)`
`static void`	`cvAdaptiveThreshold(opencv_core.CvArr src, opencv_core.CvArr dst, double max_value, int adaptive_method, int threshold_type, int block_size, double param1)` \brief Applies adaptive threshold to grayscale image.
`static opencv_core.CvSeq`	`cvApproxChains(opencv_core.CvSeq src_seq, opencv_core.CvMemStorage storage)`
`static opencv_core.CvSeq`	`cvApproxChains(opencv_core.CvSeq src_seq, opencv_core.CvMemStorage storage, int method, double parameter, int minimal_perimeter, int recursive)` \brief Approximates Freeman chain(s) with a polygonal curve.
`static opencv_core.CvSeq`	`cvApproxPoly(Pointer src_seq, int header_size, opencv_core.CvMemStorage storage, int method, double eps)`
`static opencv_core.CvSeq`	`cvApproxPoly(Pointer src_seq, int header_size, opencv_core.CvMemStorage storage, int method, double eps, int recursive)` \brief Approximates a single polygonal curve (contour) or a tree of polygonal curves (contours)
`static double`	`cvArcLength(Pointer curve)`
`static double`	`cvArcLength(Pointer curve, opencv_core.CvSlice slice, int is_closed)` \brief Calculates perimeter of a contour or length of a part of contour
`static opencv_core.CvRect`	`cvBoundingRect(opencv_core.CvArr points)`
`static opencv_core.CvRect`	`cvBoundingRect(opencv_core.CvArr points, int update)` \brief Calculates contour bounding rectangle (update=1) or just retrieves pre-calculated rectangle (update=0)
`static void`	`cvBoxPoints(opencv_core.CvBox2D box, float[] pt)`
`static void`	`cvBoxPoints(opencv_core.CvBox2D box, FloatBuffer pt)`
`static void`	`cvBoxPoints(opencv_core.CvBox2D box, opencv_core.CvPoint2D32f pt)` \brief Finds coordinates of the box vertices
`static void`	`cvCalcArrBackProject(opencv_core.CvArr image, opencv_core.CvArr dst, opencv_core.CvHistogram hist)`
`static void`	`cvCalcArrBackProject(PointerPointer image, opencv_core.CvArr dst, opencv_core.CvHistogram hist)` \brief Calculates back project
`static void`	`cvCalcArrBackProjectPatch(opencv_core.CvArr image, opencv_core.CvArr dst, opencv_core.CvSize range, opencv_core.CvHistogram hist, int method, double factor)`
`static void`	`cvCalcArrBackProjectPatch(PointerPointer image, opencv_core.CvArr dst, opencv_core.CvSize range, opencv_core.CvHistogram hist, int method, double factor)` \brief Locates a template within an image by using a histogram comparison.
`static void`	`cvCalcArrHist(opencv_core.CvArr arr, opencv_core.CvHistogram hist)`
`static void`	`cvCalcArrHist(opencv_core.CvArr arr, opencv_core.CvHistogram hist, int accumulate, opencv_core.CvArr mask)`
`static void`	`cvCalcArrHist(PointerPointer arr, opencv_core.CvHistogram hist, int accumulate, opencv_core.CvArr mask)` \brief Calculates array histogram
`static void`	`cvCalcBackProject(opencv_core.IplImage image, opencv_core.CvArr dst, opencv_core.CvHistogram hist)`
`static void`	`cvCalcBackProject(PointerPointer image, opencv_core.CvArr dst, opencv_core.CvHistogram hist)`
`static void`	`cvCalcBackProjectPatch(opencv_core.IplImage image, opencv_core.CvArr dst, opencv_core.CvSize range, opencv_core.CvHistogram hist, int method, double factor)`
`static void`	`cvCalcBackProjectPatch(PointerPointer image, opencv_core.CvArr dst, opencv_core.CvSize range, opencv_core.CvHistogram hist, int method, double factor)`
`static void`	`cvCalcBayesianProb(opencv_core.CvHistogram src, int number, opencv_core.CvHistogram dst)`
`static void`	`cvCalcBayesianProb(PointerPointer src, int number, PointerPointer dst)` \brief Calculates bayesian probabilistic histograms (each or src and dst is an array of _number_ histograms
`static float`	`cvCalcEMD2(opencv_core.CvArr signature1, opencv_core.CvArr signature2, int distance_type)`
`static float`	`cvCalcEMD2(opencv_core.CvArr signature1, opencv_core.CvArr signature2, int distance_type, opencv_imgproc.CvDistanceFunction distance_func, opencv_core.CvArr cost_matrix, opencv_core.CvArr flow, float[] lower_bound, Pointer userdata)`
`static float`	`cvCalcEMD2(opencv_core.CvArr signature1, opencv_core.CvArr signature2, int distance_type, opencv_imgproc.CvDistanceFunction distance_func, opencv_core.CvArr cost_matrix, opencv_core.CvArr flow, FloatBuffer lower_bound, Pointer userdata)`
`static float`	`cvCalcEMD2(opencv_core.CvArr signature1, opencv_core.CvArr signature2, int distance_type, opencv_imgproc.CvDistanceFunction distance_func, opencv_core.CvArr cost_matrix, opencv_core.CvArr flow, FloatPointer lower_bound, Pointer userdata)` \brief Computes earth mover distance between two weighted point sets (called signatures)
`static void`	`cvCalcHist(opencv_core.IplImage image, opencv_core.CvHistogram hist)`
`static void`	`cvCalcHist(opencv_core.IplImage image, opencv_core.CvHistogram hist, int accumulate, opencv_core.CvArr mask)`
`static void`	`cvCalcHist(PointerPointer image, opencv_core.CvHistogram hist, int accumulate, opencv_core.CvArr mask)` \overload
`static void`	`cvCalcProbDensity(opencv_core.CvHistogram hist1, opencv_core.CvHistogram hist2, opencv_core.CvHistogram dst_hist)`
`static void`	`cvCalcProbDensity(opencv_core.CvHistogram hist1, opencv_core.CvHistogram hist2, opencv_core.CvHistogram dst_hist, double scale)` \brief Divides one histogram by another.
`static void`	`cvCanny(opencv_core.CvArr image, opencv_core.CvArr edges, double threshold1, double threshold2)`
`static void`	`cvCanny(opencv_core.CvArr image, opencv_core.CvArr edges, double threshold1, double threshold2, int aperture_size)` \brief Runs canny edge detector
`static int`	`cvCheckContourConvexity(opencv_core.CvArr contour)` \brief Checks whether the contour is convex or not (returns 1 if convex, 0 if not)
`static void`	`cvCircle(opencv_core.CvArr img, int[] center, int radius, opencv_core.CvScalar color)`
`static void`	`cvCircle(opencv_core.CvArr img, int[] center, int radius, opencv_core.CvScalar color, int thickness, int line_type, int shift)`
`static void`	`cvCircle(opencv_core.CvArr img, IntBuffer center, int radius, opencv_core.CvScalar color)`
`static void`	`cvCircle(opencv_core.CvArr img, IntBuffer center, int radius, opencv_core.CvScalar color, int thickness, int line_type, int shift)`
`static void`	`cvCircle(opencv_core.CvArr img, opencv_core.CvPoint center, int radius, opencv_core.CvScalar color)`
`static void`	`cvCircle(opencv_core.CvArr img, opencv_core.CvPoint center, int radius, opencv_core.CvScalar color, int thickness, int line_type, int shift)` \brief Draws a circle with specified center and radius.
`static void`	`cvClearHist(opencv_core.CvHistogram hist)` \brief Clears the histogram.
`static int`	`cvClipLine(opencv_core.CvSize img_size, int[] pt1, int[] pt2)`
`static int`	`cvClipLine(opencv_core.CvSize img_size, IntBuffer pt1, IntBuffer pt2)`
`static int`	`cvClipLine(opencv_core.CvSize img_size, opencv_core.CvPoint pt1, opencv_core.CvPoint pt2)` \brief Clips the line segment connecting pt1 and pt2 by the rectangular window
`static opencv_core.CvScalar`	`cvColorToScalar(double packed_color, int arrtype)` \brief Unpacks color value
`static double`	`cvCompareHist(opencv_core.CvHistogram hist1, opencv_core.CvHistogram hist2, int method)` Compares two histogram
`static double`	`cvContourArea(opencv_core.CvArr contour)`
`static double`	`cvContourArea(opencv_core.CvArr contour, opencv_core.CvSlice slice, int oriented)` \brief Calculates area of a contour or contour segment
`static double`	`cvContourPerimeter(Pointer contour)` same as cvArcLength for closed contour
`static void`	`cvConvertMaps(opencv_core.CvArr mapx, opencv_core.CvArr mapy, opencv_core.CvArr mapxy, opencv_core.CvArr mapalpha)` \brief Converts mapx & mapy from floating-point to integer formats for cvRemap
`static opencv_core.CvSeq`	`cvConvexHull2(opencv_core.CvArr input)`
`static opencv_core.CvSeq`	`cvConvexHull2(opencv_core.CvArr input, Pointer hull_storage, int orientation, int return_points)` \brief Calculates exact convex hull of 2d point set
`static opencv_core.CvSeq`	`cvConvexityDefects(opencv_core.CvArr contour, opencv_core.CvArr convexhull)`
`static opencv_core.CvSeq`	`cvConvexityDefects(opencv_core.CvArr contour, opencv_core.CvArr convexhull, opencv_core.CvMemStorage storage)` \brief Finds convexity defects for the contour
`static void`	`cvCopyHist(opencv_core.CvHistogram src, opencv_core.CvHistogram dst)`
`static void`	`cvCopyHist(opencv_core.CvHistogram src, PointerPointer dst)` \brief Copies a histogram.
`static void`	`cvCopyMakeBorder(opencv_core.CvArr src, opencv_core.CvArr dst, int[] offset, int bordertype)`
`static void`	`cvCopyMakeBorder(opencv_core.CvArr src, opencv_core.CvArr dst, int[] offset, int bordertype, opencv_core.CvScalar value)`
`static void`	`cvCopyMakeBorder(opencv_core.CvArr src, opencv_core.CvArr dst, IntBuffer offset, int bordertype)`
`static void`	`cvCopyMakeBorder(opencv_core.CvArr src, opencv_core.CvArr dst, IntBuffer offset, int bordertype, opencv_core.CvScalar value)`
`static void`	`cvCopyMakeBorder(opencv_core.CvArr src, opencv_core.CvArr dst, opencv_core.CvPoint offset, int bordertype)`
`static void`	`cvCopyMakeBorder(opencv_core.CvArr src, opencv_core.CvArr dst, opencv_core.CvPoint offset, int bordertype, opencv_core.CvScalar value)` Copies source 2D array inside of the larger destination array and makes a border of the specified type (IPL_BORDER_*) around the copied area.
`static void`	`cvCornerEigenValsAndVecs(opencv_core.CvArr image, opencv_core.CvArr eigenvv, int block_size)`
`static void`	`cvCornerEigenValsAndVecs(opencv_core.CvArr image, opencv_core.CvArr eigenvv, int block_size, int aperture_size)` \brief Calculates eigen values and vectors of 2x2 gradient covariation matrix at every image pixel
`static void`	`cvCornerHarris(opencv_core.CvArr image, opencv_core.CvArr harris_response, int block_size)`
`static void`	`cvCornerHarris(opencv_core.CvArr image, opencv_core.CvArr harris_response, int block_size, int aperture_size, double k)` \brief Harris corner detector:
`static void`	`cvCornerMinEigenVal(opencv_core.CvArr image, opencv_core.CvArr eigenval, int block_size)`
`static void`	`cvCornerMinEigenVal(opencv_core.CvArr image, opencv_core.CvArr eigenval, int block_size, int aperture_size)` \brief Calculates minimal eigenvalue for 2x2 gradient covariation matrix at every image pixel
`static opencv_core.CvHistogram`	`cvCreateHist(int dims, int[] sizes, int type)`
`static opencv_core.CvHistogram`	`cvCreateHist(int dims, int[] sizes, int type, float[] ranges, int uniform)`
`static opencv_core.CvHistogram`	`cvCreateHist(int dims, IntBuffer sizes, int type)`
`static opencv_core.CvHistogram`	`cvCreateHist(int dims, IntBuffer sizes, int type, FloatBuffer ranges, int uniform)`
`static opencv_core.CvHistogram`	`cvCreateHist(int dims, IntPointer sizes, int type)`
`static opencv_core.CvHistogram`	`cvCreateHist(int dims, IntPointer sizes, int type, FloatPointer ranges, int uniform)`
`static opencv_core.CvHistogram`	`cvCreateHist(int dims, IntPointer sizes, int type, PointerPointer ranges, int uniform)` \brief Creates a histogram.
`static opencv_core.CvMat`	`cvCreatePyramid(opencv_core.CvArr img, int extra_layers, double rate)`
`static PointerPointer`	`cvCreatePyramid(opencv_core.CvArr img, int extra_layers, double rate, opencv_core.CvSize layer_sizes, opencv_core.CvArr bufarr, int calc, int filter)` \brief Builds pyramid for an image
`static opencv_core.IplConvKernel`	`cvCreateStructuringElementEx(int cols, int rows, int anchor_x, int anchor_y, int shape)`
`static opencv_core.IplConvKernel`	`cvCreateStructuringElementEx(int cols, int rows, int anchor_x, int anchor_y, int shape, int[] values)`
`static opencv_core.IplConvKernel`	`cvCreateStructuringElementEx(int cols, int rows, int anchor_x, int anchor_y, int shape, IntBuffer values)`
`static opencv_core.IplConvKernel`	`cvCreateStructuringElementEx(int cols, int rows, int anchor_x, int anchor_y, int shape, IntPointer values)` \brief Returns a structuring element of the specified size and shape for morphological operations.
`static void`	`cvCvtColor(opencv_core.CvArr src, opencv_core.CvArr dst, int code)` \brief Converts input array pixels from one color space to another
`static void`	`cvDilate(opencv_core.CvArr src, opencv_core.CvArr dst)`
`static void`	`cvDilate(opencv_core.CvArr src, opencv_core.CvArr dst, opencv_core.IplConvKernel element, int iterations)` \brief dilates input image (applies maximum filter) one or more times.
`static void`	`cvDistTransform(opencv_core.CvArr src, opencv_core.CvArr dst)`
`static void`	`cvDistTransform(opencv_core.CvArr src, opencv_core.CvArr dst, int distance_type, int mask_size, float[] mask, opencv_core.CvArr labels, int labelType)`
`static void`	`cvDistTransform(opencv_core.CvArr src, opencv_core.CvArr dst, int distance_type, int mask_size, FloatBuffer mask, opencv_core.CvArr labels, int labelType)`
`static void`	`cvDistTransform(opencv_core.CvArr src, opencv_core.CvArr dst, int distance_type, int mask_size, FloatPointer mask, opencv_core.CvArr labels, int labelType)` \brief Applies distance transform to binary image
`static void`	`cvDrawCircle(opencv_core.CvArr arg1, int[] arg2, int arg3, opencv_core.CvScalar arg4, int arg5, int arg6, int arg7)`
`static void`	`cvDrawCircle(opencv_core.CvArr arg1, IntBuffer arg2, int arg3, opencv_core.CvScalar arg4, int arg5, int arg6, int arg7)`
`static void`	`cvDrawCircle(opencv_core.CvArr arg1, opencv_core.CvPoint arg2, int arg3, opencv_core.CvScalar arg4, int arg5, int arg6, int arg7)`
`static void`	`cvDrawContours(opencv_core.CvArr img, opencv_core.CvSeq contour, opencv_core.CvScalar external_color, opencv_core.CvScalar hole_color, int max_level)`
`static void`	`cvDrawContours(opencv_core.CvArr img, opencv_core.CvSeq contour, opencv_core.CvScalar external_color, opencv_core.CvScalar hole_color, int max_level, int thickness, int line_type, int[] offset)`
`static void`	`cvDrawContours(opencv_core.CvArr img, opencv_core.CvSeq contour, opencv_core.CvScalar external_color, opencv_core.CvScalar hole_color, int max_level, int thickness, int line_type, IntBuffer offset)`
`static void`	`cvDrawContours(opencv_core.CvArr img, opencv_core.CvSeq contour, opencv_core.CvScalar external_color, opencv_core.CvScalar hole_color, int max_level, int thickness, int line_type, opencv_core.CvPoint offset)` \brief Draws contour outlines or filled interiors on the image
`static void`	`cvDrawEllipse(opencv_core.CvArr arg1, int[] arg2, opencv_core.CvSize arg3, double arg4, double arg5, double arg6, opencv_core.CvScalar arg7, int arg8, int arg9, int arg10)`
`static void`	`cvDrawEllipse(opencv_core.CvArr arg1, IntBuffer arg2, opencv_core.CvSize arg3, double arg4, double arg5, double arg6, opencv_core.CvScalar arg7, int arg8, int arg9, int arg10)`
`static void`	`cvDrawEllipse(opencv_core.CvArr arg1, opencv_core.CvPoint arg2, opencv_core.CvSize arg3, double arg4, double arg5, double arg6, opencv_core.CvScalar arg7, int arg8, int arg9, int arg10)`
`static void`	`cvDrawLine(opencv_core.CvArr arg1, int[] arg2, int[] arg3, opencv_core.CvScalar arg4, int arg5, int arg6, int arg7)`
`static void`	`cvDrawLine(opencv_core.CvArr arg1, IntBuffer arg2, IntBuffer arg3, opencv_core.CvScalar arg4, int arg5, int arg6, int arg7)`
`static void`	`cvDrawLine(opencv_core.CvArr arg1, opencv_core.CvPoint arg2, opencv_core.CvPoint arg3, opencv_core.CvScalar arg4, int arg5, int arg6, int arg7)`
`static void`	`cvDrawPolyLine(opencv_core.CvArr arg1, int[] arg2, int[] arg3, int arg4, int arg5, opencv_core.CvScalar arg6, int arg7, int arg8, int arg9)`
`static void`	`cvDrawPolyLine(opencv_core.CvArr arg1, IntBuffer arg2, IntBuffer arg3, int arg4, int arg5, opencv_core.CvScalar arg6, int arg7, int arg8, int arg9)`
`static void`	`cvDrawPolyLine(opencv_core.CvArr arg1, opencv_core.CvPoint arg2, IntPointer arg3, int arg4, int arg5, opencv_core.CvScalar arg6, int arg7, int arg8, int arg9)`
`static void`	`cvDrawPolyLine(opencv_core.CvArr arg1, PointerPointer arg2, IntPointer arg3, int arg4, int arg5, opencv_core.CvScalar arg6, int arg7, int arg8, int arg9)`
`static void`	`cvDrawRect(opencv_core.CvArr arg1, int[] arg2, int[] arg3, opencv_core.CvScalar arg4, int arg5, int arg6, int arg7)`
`static void`	`cvDrawRect(opencv_core.CvArr arg1, IntBuffer arg2, IntBuffer arg3, opencv_core.CvScalar arg4, int arg5, int arg6, int arg7)`
`static void`	`cvDrawRect(opencv_core.CvArr arg1, opencv_core.CvPoint arg2, opencv_core.CvPoint arg3, opencv_core.CvScalar arg4, int arg5, int arg6, int arg7)`
`static void`	`cvEllipse(opencv_core.CvArr img, int[] center, opencv_core.CvSize axes, double angle, double start_angle, double end_angle, opencv_core.CvScalar color)`
`static void`	`cvEllipse(opencv_core.CvArr img, int[] center, opencv_core.CvSize axes, double angle, double start_angle, double end_angle, opencv_core.CvScalar color, int thickness, int line_type, int shift)`
`static void`	`cvEllipse(opencv_core.CvArr img, IntBuffer center, opencv_core.CvSize axes, double angle, double start_angle, double end_angle, opencv_core.CvScalar color)`
`static void`	`cvEllipse(opencv_core.CvArr img, IntBuffer center, opencv_core.CvSize axes, double angle, double start_angle, double end_angle, opencv_core.CvScalar color, int thickness, int line_type, int shift)`
`static void`	`cvEllipse(opencv_core.CvArr img, opencv_core.CvPoint center, opencv_core.CvSize axes, double angle, double start_angle, double end_angle, opencv_core.CvScalar color)`
`static void`	`cvEllipse(opencv_core.CvArr img, opencv_core.CvPoint center, opencv_core.CvSize axes, double angle, double start_angle, double end_angle, opencv_core.CvScalar color, int thickness, int line_type, int shift)` \brief Draws ellipse outline, filled ellipse, elliptic arc or filled elliptic sector
`static int`	`cvEllipse2Poly(int[] center, opencv_core.CvSize axes, int angle, int arc_start, int arc_end, int[] pts, int delta)`
`static int`	`cvEllipse2Poly(IntBuffer center, opencv_core.CvSize axes, int angle, int arc_start, int arc_end, IntBuffer pts, int delta)`
`static int`	`cvEllipse2Poly(opencv_core.CvPoint center, opencv_core.CvSize axes, int angle, int arc_start, int arc_end, opencv_core.CvPoint pts, int delta)` \brief Returns the polygon points which make up the given ellipse.
`static void`	`cvEllipseBox(opencv_core.CvArr img, opencv_core.CvBox2D box, opencv_core.CvScalar color)`
`static void`	`cvEllipseBox(opencv_core.CvArr img, opencv_core.CvBox2D box, opencv_core.CvScalar color, int thickness, int line_type, int shift)`
`static opencv_core.CvSeq`	`cvEndFindContours(opencv_imgproc.CvContourScanner scanner)` \brief Releases contour scanner and returns pointer to the first outer contour
`static void`	`cvEqualizeHist(opencv_core.CvArr src, opencv_core.CvArr dst)` \brief equalizes histogram of 8-bit single-channel image
`static void`	`cvErode(opencv_core.CvArr src, opencv_core.CvArr dst)`
`static void`	`cvErode(opencv_core.CvArr src, opencv_core.CvArr dst, opencv_core.IplConvKernel element, int iterations)` \brief erodes input image (applies minimum filter) one or more times.
`static void`	`cvFillConvexPoly(opencv_core.CvArr img, int[] pts, int npts, opencv_core.CvScalar color)`
`static void`	`cvFillConvexPoly(opencv_core.CvArr img, int[] pts, int npts, opencv_core.CvScalar color, int line_type, int shift)`
`static void`	`cvFillConvexPoly(opencv_core.CvArr img, IntBuffer pts, int npts, opencv_core.CvScalar color)`
`static void`	`cvFillConvexPoly(opencv_core.CvArr img, IntBuffer pts, int npts, opencv_core.CvScalar color, int line_type, int shift)`
`static void`	`cvFillConvexPoly(opencv_core.CvArr img, opencv_core.CvPoint pts, int npts, opencv_core.CvScalar color)`
`static void`	`cvFillConvexPoly(opencv_core.CvArr img, opencv_core.CvPoint pts, int npts, opencv_core.CvScalar color, int line_type, int shift)` \brief Fills convex or monotonous polygon.
`static void`	`cvFillPoly(opencv_core.CvArr img, int[] pts, int[] npts, int contours, opencv_core.CvScalar color)`
`static void`	`cvFillPoly(opencv_core.CvArr img, int[] pts, int[] npts, int contours, opencv_core.CvScalar color, int line_type, int shift)`
`static void`	`cvFillPoly(opencv_core.CvArr img, IntBuffer pts, IntBuffer npts, int contours, opencv_core.CvScalar color)`
`static void`	`cvFillPoly(opencv_core.CvArr img, IntBuffer pts, IntBuffer npts, int contours, opencv_core.CvScalar color, int line_type, int shift)`
`static void`	`cvFillPoly(opencv_core.CvArr img, opencv_core.CvPoint pts, IntPointer npts, int contours, opencv_core.CvScalar color)`
`static void`	`cvFillPoly(opencv_core.CvArr img, opencv_core.CvPoint pts, IntPointer npts, int contours, opencv_core.CvScalar color, int line_type, int shift)`
`static void`	`cvFillPoly(opencv_core.CvArr img, PointerPointer pts, IntPointer npts, int contours, opencv_core.CvScalar color, int line_type, int shift)` \brief Fills an area bounded by one or more arbitrary polygons
`static void`	`cvFilter2D(opencv_core.CvArr src, opencv_core.CvArr dst, opencv_core.CvMat kernel)`
`static void`	`cvFilter2D(opencv_core.CvArr src, opencv_core.CvArr dst, opencv_core.CvMat kernel, int[] anchor)`
`static void`	`cvFilter2D(opencv_core.CvArr src, opencv_core.CvArr dst, opencv_core.CvMat kernel, IntBuffer anchor)`
`static void`	`cvFilter2D(opencv_core.CvArr src, opencv_core.CvArr dst, opencv_core.CvMat kernel, opencv_core.CvPoint anchor)` \brief Convolves an image with the kernel.
`static int`	`cvFindContours(opencv_core.CvArr image, opencv_core.CvMemStorage storage, opencv_core.CvSeq first_contour)`
`static int`	`cvFindContours(opencv_core.CvArr image, opencv_core.CvMemStorage storage, opencv_core.CvSeq first_contour, int header_size, int mode, int method, int[] offset)`
`static int`	`cvFindContours(opencv_core.CvArr image, opencv_core.CvMemStorage storage, opencv_core.CvSeq first_contour, int header_size, int mode, int method, IntBuffer offset)`
`static int`	`cvFindContours(opencv_core.CvArr image, opencv_core.CvMemStorage storage, opencv_core.CvSeq first_contour, int header_size, int mode, int method, opencv_core.CvPoint offset)`
`static int`	`cvFindContours(opencv_core.CvArr image, opencv_core.CvMemStorage storage, PointerPointer first_contour, int header_size, int mode, int method, opencv_core.CvPoint offset)` \brief Retrieves outer and optionally inner boundaries of white (non-zero) connected components in the black (zero) background
`static void`	`cvFindCornerSubPix(opencv_core.CvArr image, float[] corners, int count, opencv_core.CvSize win, opencv_core.CvSize zero_zone, opencv_core.CvTermCriteria criteria)`
`static void`	`cvFindCornerSubPix(opencv_core.CvArr image, FloatBuffer corners, int count, opencv_core.CvSize win, opencv_core.CvSize zero_zone, opencv_core.CvTermCriteria criteria)`
`static void`	`cvFindCornerSubPix(opencv_core.CvArr image, opencv_core.CvPoint2D32f corners, int count, opencv_core.CvSize win, opencv_core.CvSize zero_zone, opencv_core.CvTermCriteria criteria)` \brief Adjust corner position using some sort of gradient search
`static opencv_core.CvSeq`	`cvFindNextContour(opencv_imgproc.CvContourScanner scanner)` \brief Retrieves next contour
`static opencv_core.CvBox2D`	`cvFitEllipse2(opencv_core.CvArr points)` \brief Fits ellipse into a set of 2d points
`static void`	`cvFitLine(opencv_core.CvArr points, int dist_type, double param, double reps, double aeps, float[] line)`
`static void`	`cvFitLine(opencv_core.CvArr points, int dist_type, double param, double reps, double aeps, FloatBuffer line)`
`static void`	`cvFitLine(opencv_core.CvArr points, int dist_type, double param, double reps, double aeps, FloatPointer line)` \brief Fits a line into set of 2d or 3d points in a robust way (M-estimator technique)
`static void`	`cvFloodFill(opencv_core.CvArr image, int[] seed_point, opencv_core.CvScalar new_val)`
`static void`	`cvFloodFill(opencv_core.CvArr image, int[] seed_point, opencv_core.CvScalar new_val, opencv_core.CvScalar lo_diff, opencv_core.CvScalar up_diff, opencv_imgproc.CvConnectedComp comp, int flags, opencv_core.CvArr mask)`
`static void`	`cvFloodFill(opencv_core.CvArr image, IntBuffer seed_point, opencv_core.CvScalar new_val)`
`static void`	`cvFloodFill(opencv_core.CvArr image, IntBuffer seed_point, opencv_core.CvScalar new_val, opencv_core.CvScalar lo_diff, opencv_core.CvScalar up_diff, opencv_imgproc.CvConnectedComp comp, int flags, opencv_core.CvArr mask)`
`static void`	`cvFloodFill(opencv_core.CvArr image, opencv_core.CvPoint seed_point, opencv_core.CvScalar new_val)`
`static void`	`cvFloodFill(opencv_core.CvArr image, opencv_core.CvPoint seed_point, opencv_core.CvScalar new_val, opencv_core.CvScalar lo_diff, opencv_core.CvScalar up_diff, opencv_imgproc.CvConnectedComp comp, int flags, opencv_core.CvArr mask)` \brief Fills the connected component until the color difference gets large enough
`static opencv_imgproc.CvFont`	`cvFont(double scale)`
`static opencv_imgproc.CvFont`	`cvFont(double scale, int thickness)`
`static opencv_core.CvMat`	`cvGetAffineTransform(float[] src, float[] dst, opencv_core.CvMat map_matrix)`
`static opencv_core.CvMat`	`cvGetAffineTransform(FloatBuffer src, FloatBuffer dst, opencv_core.CvMat map_matrix)`
`static opencv_core.CvMat`	`cvGetAffineTransform(opencv_core.CvPoint2D32f src, opencv_core.CvPoint2D32f dst, opencv_core.CvMat map_matrix)` \brief Computes affine transform matrix for mapping src[i] to dst[i] (i=0,1,2)
`static double`	`cvGetCentralMoment(opencv_imgproc.CvMoments moments, int x_order, int y_order)` \brief Retrieve central moments
`static void`	`cvGetHuMoments(opencv_imgproc.CvMoments moments, opencv_imgproc.CvHuMoments hu_moments)` \brief Calculates 7 Hu's invariants from precalculated spatial and central moments
`static void`	`cvGetMinMaxHistValue(opencv_core.CvHistogram hist, float[] min_value, float[] max_value)`
`static void`	`cvGetMinMaxHistValue(opencv_core.CvHistogram hist, float[] min_value, float[] max_value, int[] min_idx, int[] max_idx)`
`static void`	`cvGetMinMaxHistValue(opencv_core.CvHistogram hist, FloatBuffer min_value, FloatBuffer max_value)`
`static void`	`cvGetMinMaxHistValue(opencv_core.CvHistogram hist, FloatBuffer min_value, FloatBuffer max_value, IntBuffer min_idx, IntBuffer max_idx)`
`static void`	`cvGetMinMaxHistValue(opencv_core.CvHistogram hist, FloatPointer min_value, FloatPointer max_value)`
`static void`	`cvGetMinMaxHistValue(opencv_core.CvHistogram hist, FloatPointer min_value, FloatPointer max_value, IntPointer min_idx, IntPointer max_idx)` \brief Finds the minimum and maximum histogram bins.
`static double`	`cvGetNormalizedCentralMoment(opencv_imgproc.CvMoments moments, int x_order, int y_order)` \brief Retrieve normalized central moments
`static opencv_core.CvMat`	`cvGetPerspectiveTransform(float[] src, float[] dst, opencv_core.CvMat map_matrix)`
`static opencv_core.CvMat`	`cvGetPerspectiveTransform(FloatBuffer src, FloatBuffer dst, opencv_core.CvMat map_matrix)`
`static opencv_core.CvMat`	`cvGetPerspectiveTransform(opencv_core.CvPoint2D32f src, opencv_core.CvPoint2D32f dst, opencv_core.CvMat map_matrix)` \brief Computes perspective transform matrix for mapping src[i] to dst[i] (i=0,1,2,3)
`static void`	`cvGetQuadrangleSubPix(opencv_core.CvArr src, opencv_core.CvArr dst, opencv_core.CvMat map_matrix)` \brief Retrieves quadrangle from the input array.
`static void`	`cvGetRectSubPix(opencv_core.CvArr src, opencv_core.CvArr dst, float[] center)`
`static void`	`cvGetRectSubPix(opencv_core.CvArr src, opencv_core.CvArr dst, FloatBuffer center)`
`static void`	`cvGetRectSubPix(opencv_core.CvArr src, opencv_core.CvArr dst, opencv_core.CvPoint2D32f center)` \brief Retrieves the rectangular image region with specified center from the input array.
`static double`	`cvGetSpatialMoment(opencv_imgproc.CvMoments moments, int x_order, int y_order)` \brief Retrieve spatial moments
`static void`	`cvGetTextSize(BytePointer text_string, opencv_imgproc.CvFont font, opencv_core.CvSize text_size, int[] baseline)`
`static void`	`cvGetTextSize(BytePointer text_string, opencv_imgproc.CvFont font, opencv_core.CvSize text_size, IntBuffer baseline)`
`static void`	`cvGetTextSize(BytePointer text_string, opencv_imgproc.CvFont font, opencv_core.CvSize text_size, IntPointer baseline)` \brief Calculates bounding box of text stroke (useful for alignment)
`static void`	`cvGetTextSize(String text_string, opencv_imgproc.CvFont font, opencv_core.CvSize text_size, int[] baseline)`
`static void`	`cvGetTextSize(String text_string, opencv_imgproc.CvFont font, opencv_core.CvSize text_size, IntBuffer baseline)`
`static void`	`cvGetTextSize(String text_string, opencv_imgproc.CvFont font, opencv_core.CvSize text_size, IntPointer baseline)`
`static void`	`cvGoodFeaturesToTrack(opencv_core.CvArr image, opencv_core.CvArr eig_image, opencv_core.CvArr temp_image, float[] corners, int[] corner_count, double quality_level, double min_distance)`
`static void`	`cvGoodFeaturesToTrack(opencv_core.CvArr image, opencv_core.CvArr eig_image, opencv_core.CvArr temp_image, float[] corners, int[] corner_count, double quality_level, double min_distance, opencv_core.CvArr mask, int block_size, int use_harris, double k)`
`static void`	`cvGoodFeaturesToTrack(opencv_core.CvArr image, opencv_core.CvArr eig_image, opencv_core.CvArr temp_image, FloatBuffer corners, IntBuffer corner_count, double quality_level, double min_distance)`
`static void`	`cvGoodFeaturesToTrack(opencv_core.CvArr image, opencv_core.CvArr eig_image, opencv_core.CvArr temp_image, FloatBuffer corners, IntBuffer corner_count, double quality_level, double min_distance, opencv_core.CvArr mask, int block_size, int use_harris, double k)`
`static void`	`cvGoodFeaturesToTrack(opencv_core.CvArr image, opencv_core.CvArr eig_image, opencv_core.CvArr temp_image, opencv_core.CvPoint2D32f corners, IntPointer corner_count, double quality_level, double min_distance)`
`static void`	`cvGoodFeaturesToTrack(opencv_core.CvArr image, opencv_core.CvArr eig_image, opencv_core.CvArr temp_image, opencv_core.CvPoint2D32f corners, IntPointer corner_count, double quality_level, double min_distance, opencv_core.CvArr mask, int block_size, int use_harris, double k)` \brief Finds a sparse set of points within the selected region that seem to be easy to track
`static opencv_core.CvSeq`	`cvHoughCircles(opencv_core.CvArr image, Pointer circle_storage, int method, double dp, double min_dist)`
`static opencv_core.CvSeq`	`cvHoughCircles(opencv_core.CvArr image, Pointer circle_storage, int method, double dp, double min_dist, double param1, double param2, int min_radius, int max_radius)` \brief Finds circles in the image
`static opencv_core.CvSeq`	`cvHoughLines2(opencv_core.CvArr image, Pointer line_storage, int method, double rho, double theta, int threshold)`
`static opencv_core.CvSeq`	`cvHoughLines2(opencv_core.CvArr image, Pointer line_storage, int method, double rho, double theta, int threshold, double param1, double param2, double min_theta, double max_theta)` \brief Finds lines on binary image using one of several methods.
`static void`	`cvInitFont(opencv_imgproc.CvFont font, int font_face, double hscale, double vscale)`
`static void`	`cvInitFont(opencv_imgproc.CvFont font, int font_face, double hscale, double vscale, double shear, int thickness, int line_type)` \brief Initializes font structure (OpenCV 1.x API).
`static int`	`cvInitLineIterator(opencv_core.CvArr image, int[] pt1, int[] pt2, opencv_core.CvLineIterator line_iterator)`
`static int`	`cvInitLineIterator(opencv_core.CvArr image, int[] pt1, int[] pt2, opencv_core.CvLineIterator line_iterator, int connectivity, int left_to_right)`
`static int`	`cvInitLineIterator(opencv_core.CvArr image, IntBuffer pt1, IntBuffer pt2, opencv_core.CvLineIterator line_iterator)`
`static int`	`cvInitLineIterator(opencv_core.CvArr image, IntBuffer pt1, IntBuffer pt2, opencv_core.CvLineIterator line_iterator, int connectivity, int left_to_right)`
`static int`	`cvInitLineIterator(opencv_core.CvArr image, opencv_core.CvPoint pt1, opencv_core.CvPoint pt2, opencv_core.CvLineIterator line_iterator)`
`static int`	`cvInitLineIterator(opencv_core.CvArr image, opencv_core.CvPoint pt1, opencv_core.CvPoint pt2, opencv_core.CvLineIterator line_iterator, int connectivity, int left_to_right)` \brief Initializes line iterator.
`static void`	`cvInitUndistortMap(opencv_core.CvMat camera_matrix, opencv_core.CvMat distortion_coeffs, opencv_core.CvArr mapx, opencv_core.CvArr mapy)` \brief Computes transformation map from intrinsic camera parameters that can used by cvRemap
`static void`	`cvInitUndistortRectifyMap(opencv_core.CvMat camera_matrix, opencv_core.CvMat dist_coeffs, opencv_core.CvMat R, opencv_core.CvMat new_camera_matrix, opencv_core.CvArr mapx, opencv_core.CvArr mapy)` \brief Computes undistortion+rectification map for a head of stereo camera
`static void`	`cvIntegral(opencv_core.CvArr image, opencv_core.CvArr sum)`
`static void`	`cvIntegral(opencv_core.CvArr image, opencv_core.CvArr sum, opencv_core.CvArr sqsum, opencv_core.CvArr tilted_sum)` \brief Finds integral image: SUM(X,Y) = sum(x
`static void`	`cvLaplace(opencv_core.CvArr src, opencv_core.CvArr dst)`
`static void`	`cvLaplace(opencv_core.CvArr src, opencv_core.CvArr dst, int aperture_size)` \brief Calculates the image Laplacian: (d2/dx + d2/dy)I
`static void`	`cvLine(opencv_core.CvArr img, int[] pt1, int[] pt2, opencv_core.CvScalar color)`
`static void`	`cvLine(opencv_core.CvArr img, int[] pt1, int[] pt2, opencv_core.CvScalar color, int thickness, int line_type, int shift)`
`static void`	`cvLine(opencv_core.CvArr img, IntBuffer pt1, IntBuffer pt2, opencv_core.CvScalar color)`
`static void`	`cvLine(opencv_core.CvArr img, IntBuffer pt1, IntBuffer pt2, opencv_core.CvScalar color, int thickness, int line_type, int shift)`
`static void`	`cvLine(opencv_core.CvArr img, opencv_core.CvPoint pt1, opencv_core.CvPoint pt2, opencv_core.CvScalar color)`
`static void`	`cvLine(opencv_core.CvArr img, opencv_core.CvPoint pt1, opencv_core.CvPoint pt2, opencv_core.CvScalar color, int thickness, int line_type, int shift)` \brief Draws 4-connected, 8-connected or antialiased line segment connecting two points
`static void`	`cvLinearPolar(opencv_core.CvArr src, opencv_core.CvArr dst, float[] center, double maxRadius)`
`static void`	`cvLinearPolar(opencv_core.CvArr src, opencv_core.CvArr dst, float[] center, double maxRadius, int flags)`
`static void`	`cvLinearPolar(opencv_core.CvArr src, opencv_core.CvArr dst, FloatBuffer center, double maxRadius)`
`static void`	`cvLinearPolar(opencv_core.CvArr src, opencv_core.CvArr dst, FloatBuffer center, double maxRadius, int flags)`
`static void`	`cvLinearPolar(opencv_core.CvArr src, opencv_core.CvArr dst, opencv_core.CvPoint2D32f center, double maxRadius)`
`static void`	`cvLinearPolar(opencv_core.CvArr src, opencv_core.CvArr dst, opencv_core.CvPoint2D32f center, double maxRadius, int flags)` Performs forward or inverse linear-polar image transform
`static void`	`cvLogPolar(opencv_core.CvArr src, opencv_core.CvArr dst, float[] center, double M)`
`static void`	`cvLogPolar(opencv_core.CvArr src, opencv_core.CvArr dst, float[] center, double M, int flags)`
`static void`	`cvLogPolar(opencv_core.CvArr src, opencv_core.CvArr dst, FloatBuffer center, double M)`
`static void`	`cvLogPolar(opencv_core.CvArr src, opencv_core.CvArr dst, FloatBuffer center, double M, int flags)`
`static void`	`cvLogPolar(opencv_core.CvArr src, opencv_core.CvArr dst, opencv_core.CvPoint2D32f center, double M)`
`static void`	`cvLogPolar(opencv_core.CvArr src, opencv_core.CvArr dst, opencv_core.CvPoint2D32f center, double M, int flags)` \brief Performs forward or inverse log-polar image transform
`static opencv_core.CvHistogram`	`cvMakeHistHeaderForArray(int dims, int[] sizes, opencv_core.CvHistogram hist, float[] data)`
`static opencv_core.CvHistogram`	`cvMakeHistHeaderForArray(int dims, int[] sizes, opencv_core.CvHistogram hist, float[] data, float[] ranges, int uniform)`
`static opencv_core.CvHistogram`	`cvMakeHistHeaderForArray(int dims, IntBuffer sizes, opencv_core.CvHistogram hist, FloatBuffer data)`
`static opencv_core.CvHistogram`	`cvMakeHistHeaderForArray(int dims, IntBuffer sizes, opencv_core.CvHistogram hist, FloatBuffer data, FloatBuffer ranges, int uniform)`
`static opencv_core.CvHistogram`	`cvMakeHistHeaderForArray(int dims, IntPointer sizes, opencv_core.CvHistogram hist, FloatPointer data)`
`static opencv_core.CvHistogram`	`cvMakeHistHeaderForArray(int dims, IntPointer sizes, opencv_core.CvHistogram hist, FloatPointer data, FloatPointer ranges, int uniform)`
`static opencv_core.CvHistogram`	`cvMakeHistHeaderForArray(int dims, IntPointer sizes, opencv_core.CvHistogram hist, FloatPointer data, PointerPointer ranges, int uniform)` \brief Makes a histogram out of an array.
`static double`	`cvMatchShapes(Pointer object1, Pointer object2, int method)`
`static double`	`cvMatchShapes(Pointer object1, Pointer object2, int method, double parameter)` \brief Compares two contours by matching their moments
`static void`	`cvMatchTemplate(opencv_core.CvArr image, opencv_core.CvArr templ, opencv_core.CvArr result, int method)` \brief Measures similarity between template and overlapped windows in the source image and fills the resultant image with the measurements
`static opencv_core.CvRect`	`cvMaxRect(opencv_core.CvRect rect1, opencv_core.CvRect rect2)` \brief Finds minimum rectangle containing two given rectangles
`static opencv_core.CvBox2D`	`cvMinAreaRect2(opencv_core.CvArr points)`
`static opencv_core.CvBox2D`	`cvMinAreaRect2(opencv_core.CvArr points, opencv_core.CvMemStorage storage)` \brief Finds minimum area rotated rectangle bounding a set of points
`static int`	`cvMinEnclosingCircle(opencv_core.CvArr points, float[] center, float[] radius)`
`static int`	`cvMinEnclosingCircle(opencv_core.CvArr points, FloatBuffer center, FloatBuffer radius)`
`static int`	`cvMinEnclosingCircle(opencv_core.CvArr points, opencv_core.CvPoint2D32f center, FloatPointer radius)` \brief Finds minimum enclosing circle for a set of points
`static void`	`cvMoments(opencv_core.CvArr arr, opencv_imgproc.CvMoments moments)`
`static void`	`cvMoments(opencv_core.CvArr arr, opencv_imgproc.CvMoments moments, int binary)` \brief Calculates all spatial and central moments up to the 3rd order
`static void`	`cvMorphologyEx(opencv_core.CvArr src, opencv_core.CvArr dst, opencv_core.CvArr temp, opencv_core.IplConvKernel element, int operation)`
`static void`	`cvMorphologyEx(opencv_core.CvArr src, opencv_core.CvArr dst, opencv_core.CvArr temp, opencv_core.IplConvKernel element, int operation, int iterations)` \brief Performs complex morphological transformation
`static void`	`cvMultiplyAcc(opencv_core.CvArr image1, opencv_core.CvArr image2, opencv_core.CvArr acc)`
`static void`	`cvMultiplyAcc(opencv_core.CvArr image1, opencv_core.CvArr image2, opencv_core.CvArr acc, opencv_core.CvArr mask)` \brief Adds a product of two images to accumulator
`static void`	`cvNormalizeHist(opencv_core.CvHistogram hist, double factor)` \brief Normalizes the histogram.
`static double`	`cvPointPolygonTest(opencv_core.CvArr contour, float[] pt, int measure_dist)`
`static double`	`cvPointPolygonTest(opencv_core.CvArr contour, FloatBuffer pt, int measure_dist)`
`static double`	`cvPointPolygonTest(opencv_core.CvArr contour, opencv_core.CvPoint2D32f pt, int measure_dist)` \brief Checks whether the point is inside polygon, outside, on an edge (at a vertex).
`static opencv_core.CvSeq`	`cvPointSeqFromMat(int seq_kind, opencv_core.CvArr mat, opencv_core.CvContour contour_header, opencv_core.CvSeqBlock block)` \brief Initializes sequence header for a matrix (column or row vector) of points
`static void`	`cvPolyLine(opencv_core.CvArr img, int[] pts, int[] npts, int contours, int is_closed, opencv_core.CvScalar color)`
`static void`	`cvPolyLine(opencv_core.CvArr img, int[] pts, int[] npts, int contours, int is_closed, opencv_core.CvScalar color, int thickness, int line_type, int shift)`
`static void`	`cvPolyLine(opencv_core.CvArr img, IntBuffer pts, IntBuffer npts, int contours, int is_closed, opencv_core.CvScalar color)`
`static void`	`cvPolyLine(opencv_core.CvArr img, IntBuffer pts, IntBuffer npts, int contours, int is_closed, opencv_core.CvScalar color, int thickness, int line_type, int shift)`
`static void`	`cvPolyLine(opencv_core.CvArr img, opencv_core.CvPoint pts, IntPointer npts, int contours, int is_closed, opencv_core.CvScalar color)`
`static void`	`cvPolyLine(opencv_core.CvArr img, opencv_core.CvPoint pts, IntPointer npts, int contours, int is_closed, opencv_core.CvScalar color, int thickness, int line_type, int shift)`
`static void`	`cvPolyLine(opencv_core.CvArr img, PointerPointer pts, IntPointer npts, int contours, int is_closed, opencv_core.CvScalar color, int thickness, int line_type, int shift)` \brief Draws one or more polygonal curves
`static void`	`cvPreCornerDetect(opencv_core.CvArr image, opencv_core.CvArr corners)`
`static void`	`cvPreCornerDetect(opencv_core.CvArr image, opencv_core.CvArr corners, int aperture_size)` \brief Calculates constraint image for corner detection
`static void`	`cvPutText(opencv_core.CvArr img, BytePointer text, int[] org, opencv_imgproc.CvFont font, opencv_core.CvScalar color)`
`static void`	`cvPutText(opencv_core.CvArr img, BytePointer text, IntBuffer org, opencv_imgproc.CvFont font, opencv_core.CvScalar color)`
`static void`	`cvPutText(opencv_core.CvArr img, BytePointer text, opencv_core.CvPoint org, opencv_imgproc.CvFont font, opencv_core.CvScalar color)` \brief Renders text stroke with specified font and color at specified location.
`static void`	`cvPutText(opencv_core.CvArr img, String text, int[] org, opencv_imgproc.CvFont font, opencv_core.CvScalar color)`
`static void`	`cvPutText(opencv_core.CvArr img, String text, IntBuffer org, opencv_imgproc.CvFont font, opencv_core.CvScalar color)`
`static void`	`cvPutText(opencv_core.CvArr img, String text, opencv_core.CvPoint org, opencv_imgproc.CvFont font, opencv_core.CvScalar color)`
`static void`	`cvPyrDown(opencv_core.CvArr src, opencv_core.CvArr dst)`
`static void`	`cvPyrDown(opencv_core.CvArr src, opencv_core.CvArr dst, int filter)` \brief Smoothes the input image with gaussian kernel and then down-samples it.
`static void`	`cvPyrMeanShiftFiltering(opencv_core.CvArr src, opencv_core.CvArr dst, double sp, double sr)`
`static void`	`cvPyrMeanShiftFiltering(opencv_core.CvArr src, opencv_core.CvArr dst, double sp, double sr, int max_level, opencv_core.CvTermCriteria termcrit)` \brief Filters image using meanshift algorithm
`static void`	`cvPyrUp(opencv_core.CvArr src, opencv_core.CvArr dst)`
`static void`	`cvPyrUp(opencv_core.CvArr src, opencv_core.CvArr dst, int filter)` \brief Up-samples image and smoothes the result with gaussian kernel.
`static opencv_core.CvPoint`	`cvReadChainPoint(opencv_imgproc.CvChainPtReader reader)` \brief Retrieves the next chain point
`static void`	`cvRectangle(opencv_core.CvArr img, int[] pt1, int[] pt2, opencv_core.CvScalar color)`
`static void`	`cvRectangle(opencv_core.CvArr img, int[] pt1, int[] pt2, opencv_core.CvScalar color, int thickness, int line_type, int shift)`
`static void`	`cvRectangle(opencv_core.CvArr img, IntBuffer pt1, IntBuffer pt2, opencv_core.CvScalar color)`
`static void`	`cvRectangle(opencv_core.CvArr img, IntBuffer pt1, IntBuffer pt2, opencv_core.CvScalar color, int thickness, int line_type, int shift)`
`static void`	`cvRectangle(opencv_core.CvArr img, opencv_core.CvPoint pt1, opencv_core.CvPoint pt2, opencv_core.CvScalar color)`
`static void`	`cvRectangle(opencv_core.CvArr img, opencv_core.CvPoint pt1, opencv_core.CvPoint pt2, opencv_core.CvScalar color, int thickness, int line_type, int shift)` \brief Draws a rectangle given two opposite corners of the rectangle (pt1 & pt2)
`static void`	`cvRectangleR(opencv_core.CvArr img, opencv_core.CvRect r, opencv_core.CvScalar color)`
`static void`	`cvRectangleR(opencv_core.CvArr img, opencv_core.CvRect r, opencv_core.CvScalar color, int thickness, int line_type, int shift)` \brief Draws a rectangle specified by a CvRect structure
`static void`	`cvReleaseHist(opencv_core.CvHistogram hist)`
`static void`	`cvReleaseHist(PointerPointer hist)` \brief Releases the histogram.
`static void`	`cvReleasePyramid(PointerPointer pyramid, int extra_layers)` \brief Releases pyramid
`static void`	`cvReleaseStructuringElement(opencv_core.IplConvKernel element)`
`static void`	`cvReleaseStructuringElement(PointerPointer element)` \brief releases structuring element
`static void`	`cvRemap(opencv_core.CvArr src, opencv_core.CvArr dst, opencv_core.CvArr mapx, opencv_core.CvArr mapy)`
`static void`	`cvRemap(opencv_core.CvArr src, opencv_core.CvArr dst, opencv_core.CvArr mapx, opencv_core.CvArr mapy, int flags, opencv_core.CvScalar fillval)` \brief Performs generic geometric transformation using the specified coordinate maps
`static void`	`cvResize(opencv_core.CvArr src, opencv_core.CvArr dst)`
`static void`	`cvResize(opencv_core.CvArr src, opencv_core.CvArr dst, int interpolation)` \brief Resizes image (input array is resized to fit the destination array)
`static void`	`cvRunningAvg(opencv_core.CvArr image, opencv_core.CvArr acc, double alpha)`
`static void`	`cvRunningAvg(opencv_core.CvArr image, opencv_core.CvArr acc, double alpha, opencv_core.CvArr mask)` \brief Adds image to accumulator with weights: acc = acc(1-alpha) + imagealpha
`static int`	`cvSampleLine(opencv_core.CvArr image, int[] pt1, int[] pt2, Pointer buffer)`
`static int`	`cvSampleLine(opencv_core.CvArr image, int[] pt1, int[] pt2, Pointer buffer, int connectivity)`
`static int`	`cvSampleLine(opencv_core.CvArr image, IntBuffer pt1, IntBuffer pt2, Pointer buffer)`
`static int`	`cvSampleLine(opencv_core.CvArr image, IntBuffer pt1, IntBuffer pt2, Pointer buffer, int connectivity)`
`static int`	`cvSampleLine(opencv_core.CvArr image, opencv_core.CvPoint pt1, opencv_core.CvPoint pt2, Pointer buffer)`
`static int`	`cvSampleLine(opencv_core.CvArr image, opencv_core.CvPoint pt1, opencv_core.CvPoint pt2, Pointer buffer, int connectivity)` \brief Fetches pixels that belong to the specified line segment and stores them to the buffer.
`static void`	`cvSetHistBinRanges(opencv_core.CvHistogram hist, float[] ranges)`
`static void`	`cvSetHistBinRanges(opencv_core.CvHistogram hist, float[] ranges, int uniform)`
`static void`	`cvSetHistBinRanges(opencv_core.CvHistogram hist, FloatBuffer ranges)`
`static void`	`cvSetHistBinRanges(opencv_core.CvHistogram hist, FloatBuffer ranges, int uniform)`
`static void`	`cvSetHistBinRanges(opencv_core.CvHistogram hist, FloatPointer ranges)`
`static void`	`cvSetHistBinRanges(opencv_core.CvHistogram hist, FloatPointer ranges, int uniform)`
`static void`	`cvSetHistBinRanges(opencv_core.CvHistogram hist, PointerPointer ranges, int uniform)` \brief Sets the bounds of the histogram bins.
`static void`	`cvSmooth(opencv_core.CvArr src, opencv_core.CvArr dst)`
`static void`	`cvSmooth(opencv_core.CvArr src, opencv_core.CvArr dst, int smoothtype, int size1, int size2, double sigma1, double sigma2)` \brief Smooths the image in one of several ways.
`static void`	`cvSobel(opencv_core.CvArr src, opencv_core.CvArr dst, int xorder, int yorder)`
`static void`	`cvSobel(opencv_core.CvArr src, opencv_core.CvArr dst, int xorder, int yorder, int aperture_size)` \brief Calculates an image derivative using generalized Sobel
`static void`	`cvSquareAcc(opencv_core.CvArr image, opencv_core.CvArr sqsum)`
`static void`	`cvSquareAcc(opencv_core.CvArr image, opencv_core.CvArr sqsum, opencv_core.CvArr mask)` \brief Adds squared image to accumulator
`static opencv_imgproc.CvContourScanner`	`cvStartFindContours(opencv_core.CvArr image, opencv_core.CvMemStorage storage)`
`static opencv_imgproc.CvContourScanner`	`cvStartFindContours(opencv_core.CvArr image, opencv_core.CvMemStorage storage, int header_size, int mode, int method, int[] offset)`
`static opencv_imgproc.CvContourScanner`	`cvStartFindContours(opencv_core.CvArr image, opencv_core.CvMemStorage storage, int header_size, int mode, int method, IntBuffer offset)`
`static opencv_imgproc.CvContourScanner`	`cvStartFindContours(opencv_core.CvArr image, opencv_core.CvMemStorage storage, int header_size, int mode, int method, opencv_core.CvPoint offset)` \brief Initializes contour retrieving process.
`static void`	`cvStartReadChainPoints(opencv_core.CvChain chain, opencv_imgproc.CvChainPtReader reader)` \brief Initializes Freeman chain reader.
`static void`	`cvSubstituteContour(opencv_imgproc.CvContourScanner scanner, opencv_core.CvSeq new_contour)` \brief Substitutes the last retrieved contour with the new one
`static void`	`cvtColor(opencv_core.Mat src, opencv_core.Mat dst, int code)`
`static void`	`cvtColor(opencv_core.Mat src, opencv_core.Mat dst, int code, int dstCn)` \brief Converts an image from one color space to another.
`static void`	`cvThreshHist(opencv_core.CvHistogram hist, double threshold)` \brief Thresholds the histogram.
`static double`	`cvThreshold(opencv_core.CvArr src, opencv_core.CvArr dst, double threshold, double max_value, int threshold_type)` \brief Applies fixed-level threshold to grayscale image.
`static void`	`cvUndistort2(opencv_core.CvArr src, opencv_core.CvArr dst, opencv_core.CvMat camera_matrix, opencv_core.CvMat distortion_coeffs)`
`static void`	`cvUndistort2(opencv_core.CvArr src, opencv_core.CvArr dst, opencv_core.CvMat camera_matrix, opencv_core.CvMat distortion_coeffs, opencv_core.CvMat new_camera_matrix)` \brief Transforms the input image to compensate lens distortion
`static void`	`cvUndistortPoints(opencv_core.CvMat src, opencv_core.CvMat dst, opencv_core.CvMat camera_matrix, opencv_core.CvMat dist_coeffs)`
`static void`	`cvUndistortPoints(opencv_core.CvMat src, opencv_core.CvMat dst, opencv_core.CvMat camera_matrix, opencv_core.CvMat dist_coeffs, opencv_core.CvMat R, opencv_core.CvMat P)` \brief Computes the original (undistorted) feature coordinates from the observed (distorted) coordinates
`static void`	`cvWarpAffine(opencv_core.CvArr src, opencv_core.CvArr dst, opencv_core.CvMat map_matrix)`
`static void`	`cvWarpAffine(opencv_core.CvArr src, opencv_core.CvArr dst, opencv_core.CvMat map_matrix, int flags, opencv_core.CvScalar fillval)` \brief Warps image with affine transform \note ::cvGetQuadrangleSubPix is similar to ::cvWarpAffine, but the outliers are extrapolated using replication border mode.
`static void`	`cvWarpPerspective(opencv_core.CvArr src, opencv_core.CvArr dst, opencv_core.CvMat map_matrix)`
`static void`	`cvWarpPerspective(opencv_core.CvArr src, opencv_core.CvArr dst, opencv_core.CvMat map_matrix, int flags, opencv_core.CvScalar fillval)` \brief Warps image with perspective (projective) transform
`static void`	`cvWatershed(opencv_core.CvArr image, opencv_core.CvArr markers)` \brief Segments image using seed "markers"
`static void`	`demosaicing(opencv_core.Mat _src, opencv_core.Mat _dst, int code)`
`static void`	`demosaicing(opencv_core.Mat _src, opencv_core.Mat _dst, int code, int dcn)` \} imgproc_misc
`static void`	`dilate(opencv_core.Mat src, opencv_core.Mat dst, opencv_core.Mat kernel)`
`static void`	`dilate(opencv_core.Mat src, opencv_core.Mat dst, opencv_core.Mat kernel, opencv_core.Point anchor, int iterations, int borderType, opencv_core.Scalar borderValue)` \brief Dilates an image by using a specific structuring element.
`static void`	`distanceTransform(opencv_core.Mat src, opencv_core.Mat dst, int distanceType, int maskSize)`
`static void`	`distanceTransform(opencv_core.Mat src, opencv_core.Mat dst, int distanceType, int maskSize, int dstType)` \overload
`static void`	`distanceTransformWithLabels(opencv_core.Mat src, opencv_core.Mat dst, opencv_core.Mat labels, int distanceType, int maskSize)`
`static void`	`distanceTransformWithLabels(opencv_core.Mat src, opencv_core.Mat dst, opencv_core.Mat labels, int distanceType, int maskSize, int labelType)` \brief Calculates the distance to the closest zero pixel for each pixel of the source image.
`static void`	`drawContours(opencv_core.Mat image, opencv_core.MatVector contours, int contourIdx, opencv_core.Scalar color)`
`static void`	`drawContours(opencv_core.Mat image, opencv_core.MatVector contours, int contourIdx, opencv_core.Scalar color, int thickness, int lineType, opencv_core.Mat hierarchy, int maxLevel, opencv_core.Point offset)` \brief Draws contours outlines or filled contours.
`static void`	`drawMarker(opencv_core.Mat img, opencv_core.Point position, opencv_core.Scalar color)`
`static void`	`drawMarker(opencv_core.Mat img, opencv_core.Point position, opencv_core.Scalar color, int markerType, int markerSize, int thickness, int line_type)` \brief Draws a marker on a predefined position in an image.
`static void`	`ellipse(opencv_core.Mat img, opencv_core.Point center, opencv_core.Size axes, double angle, double startAngle, double endAngle, opencv_core.Scalar color)`
`static void`	`ellipse(opencv_core.Mat img, opencv_core.Point center, opencv_core.Size axes, double angle, double startAngle, double endAngle, opencv_core.Scalar color, int thickness, int lineType, int shift)` \brief Draws a simple or thick elliptic arc or fills an ellipse sector.
`static void`	`ellipse(opencv_core.Mat img, opencv_core.RotatedRect box, opencv_core.Scalar color)`
`static void`	`ellipse(opencv_core.Mat img, opencv_core.RotatedRect box, opencv_core.Scalar color, int thickness, int lineType)` \overload
`static void`	`ellipse2Poly(opencv_core.Point center, opencv_core.Size axes, int angle, int arcStart, int arcEnd, int delta, opencv_core.PointVector pts)` \brief Approximates an elliptic arc with a polyline.
`static float`	`EMD(opencv_core.Mat signature1, opencv_core.Mat signature2, int distType)`
`static float`	`EMD(opencv_core.Mat signature1, opencv_core.Mat signature2, int distType, opencv_core.Mat cost, float[] lowerBound, opencv_core.Mat flow)`
`static float`	`EMD(opencv_core.Mat signature1, opencv_core.Mat signature2, int distType, opencv_core.Mat cost, FloatBuffer lowerBound, opencv_core.Mat flow)`
`static float`	`EMD(opencv_core.Mat signature1, opencv_core.Mat signature2, int distType, opencv_core.Mat cost, FloatPointer lowerBound, opencv_core.Mat flow)` \brief Computes the "minimal work" distance between two weighted point configurations.
`static void`	`equalizeHist(opencv_core.Mat src, opencv_core.Mat dst)` \brief Equalizes the histogram of a grayscale image.
`static void`	`erode(opencv_core.Mat src, opencv_core.Mat dst, opencv_core.Mat kernel)`
`static void`	`erode(opencv_core.Mat src, opencv_core.Mat dst, opencv_core.Mat kernel, opencv_core.Point anchor, int iterations, int borderType, opencv_core.Scalar borderValue)` \brief Erodes an image by using a specific structuring element.
`static void`	`fillConvexPoly(opencv_core.Mat img, opencv_core.Mat points, opencv_core.Scalar color)`
`static void`	`fillConvexPoly(opencv_core.Mat img, opencv_core.Mat points, opencv_core.Scalar color, int lineType, int shift)` \brief Fills a convex polygon.
`static void`	`fillConvexPoly(opencv_core.Mat img, opencv_core.Point pts, int npts, opencv_core.Scalar color)`
`static void`	`fillConvexPoly(opencv_core.Mat img, opencv_core.Point pts, int npts, opencv_core.Scalar color, int lineType, int shift)` \overload
`static void`	`fillPoly(opencv_core.Mat img, opencv_core.MatVector pts, opencv_core.Scalar color)`
`static void`	`fillPoly(opencv_core.Mat img, opencv_core.MatVector pts, opencv_core.Scalar color, int lineType, int shift, opencv_core.Point offset)` \brief Fills the area bounded by one or more polygons.
`static void`	`fillPoly(opencv_core.Mat img, opencv_core.Point pts, int[] npts, int ncontours, opencv_core.Scalar color)`
`static void`	`fillPoly(opencv_core.Mat img, opencv_core.Point pts, int[] npts, int ncontours, opencv_core.Scalar color, int lineType, int shift, opencv_core.Point offset)`
`static void`	`fillPoly(opencv_core.Mat img, opencv_core.Point pts, IntBuffer npts, int ncontours, opencv_core.Scalar color)`
`static void`	`fillPoly(opencv_core.Mat img, opencv_core.Point pts, IntBuffer npts, int ncontours, opencv_core.Scalar color, int lineType, int shift, opencv_core.Point offset)`
`static void`	`fillPoly(opencv_core.Mat img, opencv_core.Point pts, IntPointer npts, int ncontours, opencv_core.Scalar color)`
`static void`	`fillPoly(opencv_core.Mat img, opencv_core.Point pts, IntPointer npts, int ncontours, opencv_core.Scalar color, int lineType, int shift, opencv_core.Point offset)`
`static void`	`fillPoly(opencv_core.Mat img, PointerPointer pts, IntPointer npts, int ncontours, opencv_core.Scalar color, int lineType, int shift, opencv_core.Point offset)` \overload
`static void`	`filter2D(opencv_core.Mat src, opencv_core.Mat dst, int ddepth, opencv_core.Mat kernel)`
`static void`	`filter2D(opencv_core.Mat src, opencv_core.Mat dst, int ddepth, opencv_core.Mat kernel, opencv_core.Point anchor, double delta, int borderType)` \brief Convolves an image with the kernel.
`static void`	`findContours(opencv_core.Mat image, opencv_core.MatVector contours, int mode, int method)`
`static void`	`findContours(opencv_core.Mat image, opencv_core.MatVector contours, int mode, int method, opencv_core.Point offset)` \overload
`static void`	`findContours(opencv_core.Mat image, opencv_core.MatVector contours, opencv_core.Mat hierarchy, int mode, int method)`
`static void`	`findContours(opencv_core.Mat image, opencv_core.MatVector contours, opencv_core.Mat hierarchy, int mode, int method, opencv_core.Point offset)` \brief Finds contours in a binary image.
`static opencv_core.RotatedRect`	`fitEllipse(opencv_core.Mat points)` \brief Fits an ellipse around a set of 2D points.
`static void`	`fitLine(opencv_core.Mat points, opencv_core.Mat line, int distType, double param, double reps, double aeps)` \brief Fits a line to a 2D or 3D point set.
`static int`	`floodFill(opencv_core.Mat image, opencv_core.Mat mask, opencv_core.Point seedPoint, opencv_core.Scalar newVal)`
`static int`	`floodFill(opencv_core.Mat image, opencv_core.Mat mask, opencv_core.Point seedPoint, opencv_core.Scalar newVal, opencv_core.Rect rect, opencv_core.Scalar loDiff, opencv_core.Scalar upDiff, int flags)` \brief Fills a connected component with the given color.
`static int`	`floodFill(opencv_core.Mat image, opencv_core.Point seedPoint, opencv_core.Scalar newVal)`
`static int`	`floodFill(opencv_core.Mat image, opencv_core.Point seedPoint, opencv_core.Scalar newVal, opencv_core.Rect rect, opencv_core.Scalar loDiff, opencv_core.Scalar upDiff, int flags)` \overload
`static void`	`GaussianBlur(opencv_core.Mat src, opencv_core.Mat dst, opencv_core.Size ksize, double sigmaX)`
`static void`	`GaussianBlur(opencv_core.Mat src, opencv_core.Mat dst, opencv_core.Size ksize, double sigmaX, double sigmaY, int borderType)` \brief Blurs an image using a Gaussian filter.
`static opencv_core.Mat`	`getAffineTransform(opencv_core.Mat src, opencv_core.Mat dst)`
`static opencv_core.Mat`	`getAffineTransform(opencv_core.Point2f src, opencv_core.Point2f dst)` \brief Calculates an affine transform from three pairs of the corresponding points.
`static opencv_core.Mat`	`getDefaultNewCameraMatrix(opencv_core.Mat cameraMatrix)`
`static opencv_core.Mat`	`getDefaultNewCameraMatrix(opencv_core.Mat cameraMatrix, opencv_core.Size imgsize, boolean centerPrincipalPoint)` \brief Returns the default new camera matrix.
`static void`	`getDerivKernels(opencv_core.Mat kx, opencv_core.Mat ky, int dx, int dy, int ksize)`
`static void`	`getDerivKernels(opencv_core.Mat kx, opencv_core.Mat ky, int dx, int dy, int ksize, boolean normalize, int ktype)` \brief Returns filter coefficients for computing spatial image derivatives.
`static opencv_core.Mat`	`getGaborKernel(opencv_core.Size ksize, double sigma, double theta, double lambd, double gamma)`
`static opencv_core.Mat`	`getGaborKernel(opencv_core.Size ksize, double sigma, double theta, double lambd, double gamma, double psi, int ktype)` \brief Returns Gabor filter coefficients.
`static opencv_core.Mat`	`getGaussianKernel(int ksize, double sigma)`
`static opencv_core.Mat`	`getGaussianKernel(int ksize, double sigma, int ktype)` \} imgproc_feature
`static opencv_core.Mat`	`getPerspectiveTransform(opencv_core.Mat src, opencv_core.Mat dst)` \brief Calculates a perspective transform from four pairs of the corresponding points.
`static opencv_core.Mat`	`getPerspectiveTransform(opencv_core.Point2f src, opencv_core.Point2f dst)` returns 3x3 perspective transformation for the corresponding 4 point pairs.
`static void`	`getRectSubPix(opencv_core.Mat image, opencv_core.Size patchSize, opencv_core.Point2f center, opencv_core.Mat patch)`
`static void`	`getRectSubPix(opencv_core.Mat image, opencv_core.Size patchSize, opencv_core.Point2f center, opencv_core.Mat patch, int patchType)` \brief Retrieves a pixel rectangle from an image with sub-pixel accuracy.
`static opencv_core.Mat`	`getRotationMatrix2D(opencv_core.Point2f center, double angle, double scale)` \brief Calculates an affine matrix of 2D rotation.
`static opencv_core.Mat`	`getStructuringElement(int shape, opencv_core.Size ksize)`
`static opencv_core.Mat`	`getStructuringElement(int shape, opencv_core.Size ksize, opencv_core.Point anchor)` \brief Returns a structuring element of the specified size and shape for morphological operations.
`static opencv_core.Size`	`getTextSize(BytePointer text, int fontFace, double fontScale, int thickness, int[] baseLine)`
`static opencv_core.Size`	`getTextSize(BytePointer text, int fontFace, double fontScale, int thickness, IntBuffer baseLine)`
`static opencv_core.Size`	`getTextSize(BytePointer text, int fontFace, double fontScale, int thickness, IntPointer baseLine)` \brief Calculates the width and height of a text string.
`static opencv_core.Size`	`getTextSize(String text, int fontFace, double fontScale, int thickness, int[] baseLine)`
`static opencv_core.Size`	`getTextSize(String text, int fontFace, double fontScale, int thickness, IntBuffer baseLine)`
`static opencv_core.Size`	`getTextSize(String text, int fontFace, double fontScale, int thickness, IntPointer baseLine)`
`static void`	`goodFeaturesToTrack(opencv_core.Mat image, opencv_core.Mat corners, int maxCorners, double qualityLevel, double minDistance)`
`static void`	`goodFeaturesToTrack(opencv_core.Mat image, opencv_core.Mat corners, int maxCorners, double qualityLevel, double minDistance, opencv_core.Mat mask, int blockSize, boolean useHarrisDetector, double k)` \brief Determines strong corners on an image.
`static void`	`grabCut(opencv_core.Mat img, opencv_core.Mat mask, opencv_core.Rect rect, opencv_core.Mat bgdModel, opencv_core.Mat fgdModel, int iterCount)`
`static void`	`grabCut(opencv_core.Mat img, opencv_core.Mat mask, opencv_core.Rect rect, opencv_core.Mat bgdModel, opencv_core.Mat fgdModel, int iterCount, int mode)` \brief Runs the GrabCut algorithm.
`static void`	`HoughCircles(opencv_core.Mat image, opencv_core.Mat circles, int method, double dp, double minDist)`
`static void`	`HoughCircles(opencv_core.Mat image, opencv_core.Mat circles, int method, double dp, double minDist, double param1, double param2, int minRadius, int maxRadius)` \brief Finds circles in a grayscale image using the Hough transform.
`static void`	`HoughLines(opencv_core.Mat image, opencv_core.Mat lines, double rho, double theta, int threshold)`
`static void`	`HoughLines(opencv_core.Mat image, opencv_core.Mat lines, double rho, double theta, int threshold, double srn, double stn, double min_theta, double max_theta)` \brief Finds lines in a binary image using the standard Hough transform.
`static void`	`HoughLinesP(opencv_core.Mat image, opencv_core.Mat lines, double rho, double theta, int threshold)`
`static void`	`HoughLinesP(opencv_core.Mat image, opencv_core.Mat lines, double rho, double theta, int threshold, double minLineLength, double maxLineGap)` \brief Finds line segments in a binary image using the probabilistic Hough transform.
`static void`	`HuMoments(opencv_core.Moments moments, double[] hu)`
`static void`	`HuMoments(opencv_core.Moments moments, DoubleBuffer hu)`
`static void`	`HuMoments(opencv_core.Moments moments, DoublePointer hu)` \brief Calculates seven Hu invariants.
`static void`	`HuMoments(opencv_core.Moments m, opencv_core.Mat hu)` \overload
`static void`	`initUndistortRectifyMap(opencv_core.Mat cameraMatrix, opencv_core.Mat distCoeffs, opencv_core.Mat R, opencv_core.Mat newCameraMatrix, opencv_core.Size size, int m1type, opencv_core.Mat map1, opencv_core.Mat map2)` \brief Computes the undistortion and rectification transformation map.
`static float`	`initWideAngleProjMap(opencv_core.Mat cameraMatrix, opencv_core.Mat distCoeffs, opencv_core.Size imageSize, int destImageWidth, int m1type, opencv_core.Mat map1, opencv_core.Mat map2)`
`static float`	`initWideAngleProjMap(opencv_core.Mat cameraMatrix, opencv_core.Mat distCoeffs, opencv_core.Size imageSize, int destImageWidth, int m1type, opencv_core.Mat map1, opencv_core.Mat map2, int projType, double alpha)` initializes maps for cv::remap() for wide-angle
`static void`	`integral(opencv_core.Mat src, opencv_core.Mat sum)`
`static void`	`integral(opencv_core.Mat src, opencv_core.Mat sum, int sdepth)` \} imgproc_transform
`static void`	`integral2(opencv_core.Mat src, opencv_core.Mat sum, opencv_core.Mat sqsum)`
`static void`	`integral2(opencv_core.Mat src, opencv_core.Mat sum, opencv_core.Mat sqsum, int sdepth, int sqdepth)` \overload
`static void`	`integral3(opencv_core.Mat src, opencv_core.Mat sum, opencv_core.Mat sqsum, opencv_core.Mat tilted)`
`static void`	`integral3(opencv_core.Mat src, opencv_core.Mat sum, opencv_core.Mat sqsum, opencv_core.Mat tilted, int sdepth, int sqdepth)` \brief Calculates the integral of an image.
`static float`	`intersectConvexConvex(opencv_core.Mat _p1, opencv_core.Mat _p2, opencv_core.Mat _p12)`
`static float`	`intersectConvexConvex(opencv_core.Mat _p1, opencv_core.Mat _p2, opencv_core.Mat _p12, boolean handleNested)` finds intersection of two convex polygons
`static void`	`invertAffineTransform(opencv_core.Mat M, opencv_core.Mat iM)` \brief Inverts an affine transformation.
`static boolean`	`isContourConvex(opencv_core.Mat contour)` \brief Tests a contour convexity.
`static void`	`Laplacian(opencv_core.Mat src, opencv_core.Mat dst, int ddepth)`
`static void`	`Laplacian(opencv_core.Mat src, opencv_core.Mat dst, int ddepth, int ksize, double scale, double delta, int borderType)` \brief Calculates the Laplacian of an image.
`static void`	`line(opencv_core.Mat img, opencv_core.Point pt1, opencv_core.Point pt2, opencv_core.Scalar color)`
`static void`	`line(opencv_core.Mat img, opencv_core.Point pt1, opencv_core.Point pt2, opencv_core.Scalar color, int thickness, int lineType, int shift)` \} imgproc_colormap
`static void`	`linearPolar(opencv_core.Mat src, opencv_core.Mat dst, opencv_core.Point2f center, double maxRadius, int flags)` \brief Remaps an image to polar space.
`static void`	`logPolar(opencv_core.Mat src, opencv_core.Mat dst, opencv_core.Point2f center, double M, int flags)` \brief Remaps an image to log-polar space.
`static double`	`matchShapes(opencv_core.Mat contour1, opencv_core.Mat contour2, int method, double parameter)` \brief Compares two shapes.
`static void`	`matchTemplate(opencv_core.Mat image, opencv_core.Mat templ, opencv_core.Mat result, int method)`
`static void`	`matchTemplate(opencv_core.Mat image, opencv_core.Mat templ, opencv_core.Mat result, int method, opencv_core.Mat mask)` \brief Compares a template against overlapped image regions.
`static void`	`medianBlur(opencv_core.Mat src, opencv_core.Mat dst, int ksize)` \brief Blurs an image using the median filter.
`static opencv_core.RotatedRect`	`minAreaRect(opencv_core.Mat points)` \brief Finds a rotated rectangle of the minimum area enclosing the input 2D point set.
`static void`	`minEnclosingCircle(opencv_core.Mat points, opencv_core.Point2f center, float[] radius)`
`static void`	`minEnclosingCircle(opencv_core.Mat points, opencv_core.Point2f center, FloatBuffer radius)`
`static void`	`minEnclosingCircle(opencv_core.Mat points, opencv_core.Point2f center, FloatPointer radius)` \brief Finds a circle of the minimum area enclosing a 2D point set.
`static double`	`minEnclosingTriangle(opencv_core.Mat points, opencv_core.Mat triangle)` \brief Finds a triangle of minimum area enclosing a 2D point set and returns its area.
`static opencv_core.Moments`	`moments(opencv_core.Mat array)`
`static opencv_core.Moments`	`moments(opencv_core.Mat array, boolean binaryImage)` \addtogroup imgproc_shape \{
`static opencv_core.Scalar`	`morphologyDefaultBorderValue()` returns "magic" border value for erosion and dilation.
`static void`	`morphologyEx(opencv_core.Mat src, opencv_core.Mat dst, int op, opencv_core.Mat kernel)`
`static void`	`morphologyEx(opencv_core.Mat src, opencv_core.Mat dst, int op, opencv_core.Mat kernel, opencv_core.Point anchor, int iterations, int borderType, opencv_core.Scalar borderValue)` \brief Performs advanced morphological transformations.
`static opencv_core.Point2d`	`phaseCorrelate(opencv_core.Mat src1, opencv_core.Mat src2)`
`static opencv_core.Point2d`	`phaseCorrelate(opencv_core.Mat src1, opencv_core.Mat src2, opencv_core.Mat window, double[] response)`
`static opencv_core.Point2d`	`phaseCorrelate(opencv_core.Mat src1, opencv_core.Mat src2, opencv_core.Mat window, DoubleBuffer response)`
`static opencv_core.Point2d`	`phaseCorrelate(opencv_core.Mat src1, opencv_core.Mat src2, opencv_core.Mat window, DoublePointer response)` \brief The function is used to detect translational shifts that occur between two images.
`static double`	`pointPolygonTest(opencv_core.Mat contour, opencv_core.Point2f pt, boolean measureDist)` \brief Performs a point-in-contour test.
`static void`	`polylines(opencv_core.Mat img, opencv_core.MatVector pts, boolean isClosed, opencv_core.Scalar color)`
`static void`	`polylines(opencv_core.Mat img, opencv_core.MatVector pts, boolean isClosed, opencv_core.Scalar color, int thickness, int lineType, int shift)` \brief Draws several polygonal curves.
`static void`	`polylines(opencv_core.Mat img, opencv_core.Point pts, int[] npts, int ncontours, boolean isClosed, opencv_core.Scalar color)`
`static void`	`polylines(opencv_core.Mat img, opencv_core.Point pts, int[] npts, int ncontours, boolean isClosed, opencv_core.Scalar color, int thickness, int lineType, int shift)`
`static void`	`polylines(opencv_core.Mat img, opencv_core.Point pts, IntBuffer npts, int ncontours, boolean isClosed, opencv_core.Scalar color)`
`static void`	`polylines(opencv_core.Mat img, opencv_core.Point pts, IntBuffer npts, int ncontours, boolean isClosed, opencv_core.Scalar color, int thickness, int lineType, int shift)`
`static void`	`polylines(opencv_core.Mat img, opencv_core.Point pts, IntPointer npts, int ncontours, boolean isClosed, opencv_core.Scalar color)`
`static void`	`polylines(opencv_core.Mat img, opencv_core.Point pts, IntPointer npts, int ncontours, boolean isClosed, opencv_core.Scalar color, int thickness, int lineType, int shift)`
`static void`	`polylines(opencv_core.Mat img, PointerPointer pts, IntPointer npts, int ncontours, boolean isClosed, opencv_core.Scalar color, int thickness, int lineType, int shift)` \overload
`static void`	`preCornerDetect(opencv_core.Mat src, opencv_core.Mat dst, int ksize)`
`static void`	`preCornerDetect(opencv_core.Mat src, opencv_core.Mat dst, int ksize, int borderType)` \brief Calculates a feature map for corner detection.
`static void`	`putText(opencv_core.Mat img, BytePointer text, opencv_core.Point org, int fontFace, double fontScale, opencv_core.Scalar color)`
`static void`	`putText(opencv_core.Mat img, BytePointer text, opencv_core.Point org, int fontFace, double fontScale, opencv_core.Scalar color, int thickness, int lineType, boolean bottomLeftOrigin)` \brief Draws a text string.
`static void`	`putText(opencv_core.Mat img, String text, opencv_core.Point org, int fontFace, double fontScale, opencv_core.Scalar color)`
`static void`	`putText(opencv_core.Mat img, String text, opencv_core.Point org, int fontFace, double fontScale, opencv_core.Scalar color, int thickness, int lineType, boolean bottomLeftOrigin)`
`static void`	`pyrDown(opencv_core.Mat src, opencv_core.Mat dst)`
`static void`	`pyrDown(opencv_core.Mat src, opencv_core.Mat dst, opencv_core.Size dstsize, int borderType)` \} imgproc_misc
`static void`	`pyrMeanShiftFiltering(opencv_core.Mat src, opencv_core.Mat dst, double sp, double sr)`
`static void`	`pyrMeanShiftFiltering(opencv_core.Mat src, opencv_core.Mat dst, double sp, double sr, int maxLevel, opencv_core.TermCriteria termcrit)` \addtogroup imgproc_filter \{
`static void`	`pyrUp(opencv_core.Mat src, opencv_core.Mat dst)`
`static void`	`pyrUp(opencv_core.Mat src, opencv_core.Mat dst, opencv_core.Size dstsize, int borderType)` \brief Upsamples an image and then blurs it.
`static void`	`rectangle(opencv_core.Mat img, opencv_core.Point pt1, opencv_core.Point pt2, opencv_core.Scalar color)`
`static void`	`rectangle(opencv_core.Mat img, opencv_core.Point pt1, opencv_core.Point pt2, opencv_core.Scalar color, int thickness, int lineType, int shift)` \brief Draws a simple, thick, or filled up-right rectangle.
`static void`	`rectangle(opencv_core.Mat img, opencv_core.Rect rec, opencv_core.Scalar color)`
`static void`	`rectangle(opencv_core.Mat img, opencv_core.Rect rec, opencv_core.Scalar color, int thickness, int lineType, int shift)` \overload
`static void`	`remap(opencv_core.Mat src, opencv_core.Mat dst, opencv_core.Mat map1, opencv_core.Mat map2, int interpolation)`
`static void`	`remap(opencv_core.Mat src, opencv_core.Mat dst, opencv_core.Mat map1, opencv_core.Mat map2, int interpolation, int borderMode, opencv_core.Scalar borderValue)` \brief Applies a generic geometrical transformation to an image.
`static void`	`resize(opencv_core.Mat src, opencv_core.Mat dst, opencv_core.Size dsize)`
`static void`	`resize(opencv_core.Mat src, opencv_core.Mat dst, opencv_core.Size dsize, double fx, double fy, int interpolation)` \} imgproc_filter
`static int`	`rotatedRectangleIntersection(opencv_core.RotatedRect rect1, opencv_core.RotatedRect rect2, opencv_core.Mat intersectingRegion)` \brief Finds out if there is any intersection between two rotated rectangles.
`static void`	`Scharr(opencv_core.Mat src, opencv_core.Mat dst, int ddepth, int dx, int dy)`
`static void`	`Scharr(opencv_core.Mat src, opencv_core.Mat dst, int ddepth, int dx, int dy, double scale, double delta, int borderType)` \brief Calculates the first x- or y- image derivative using Scharr operator.
`static void`	`sepFilter2D(opencv_core.Mat src, opencv_core.Mat dst, int ddepth, opencv_core.Mat kernelX, opencv_core.Mat kernelY)`
`static void`	`sepFilter2D(opencv_core.Mat src, opencv_core.Mat dst, int ddepth, opencv_core.Mat kernelX, opencv_core.Mat kernelY, opencv_core.Point anchor, double delta, int borderType)` \brief Applies a separable linear filter to an image.
`static void`	`Sobel(opencv_core.Mat src, opencv_core.Mat dst, int ddepth, int dx, int dy)`
`static void`	`Sobel(opencv_core.Mat src, opencv_core.Mat dst, int ddepth, int dx, int dy, int ksize, double scale, double delta, int borderType)` \brief Calculates the first, second, third, or mixed image derivatives using an extended Sobel operator.
`static void`	`spatialGradient(opencv_core.Mat src, opencv_core.Mat dx, opencv_core.Mat dy)`
`static void`	`spatialGradient(opencv_core.Mat src, opencv_core.Mat dx, opencv_core.Mat dy, int ksize, int borderType)` \brief Calculates the first order image derivative in both x and y using a Sobel operator
`static void`	`sqrBoxFilter(opencv_core.Mat _src, opencv_core.Mat _dst, int ddepth, opencv_core.Size ksize)`
`static void`	`sqrBoxFilter(opencv_core.Mat _src, opencv_core.Mat _dst, int ddepth, opencv_core.Size ksize, opencv_core.Point anchor, boolean normalize, int borderType)` \brief Calculates the normalized sum of squares of the pixel values overlapping the filter.
`static double`	`threshold(opencv_core.Mat src, opencv_core.Mat dst, double thresh, double maxval, int type)` \} imgproc_motion
`static void`	`undistort(opencv_core.Mat src, opencv_core.Mat dst, opencv_core.Mat cameraMatrix, opencv_core.Mat distCoeffs)`
`static void`	`undistort(opencv_core.Mat src, opencv_core.Mat dst, opencv_core.Mat cameraMatrix, opencv_core.Mat distCoeffs, opencv_core.Mat newCameraMatrix)` \} imgproc_filter
`static void`	`undistortPoints(opencv_core.Mat src, opencv_core.Mat dst, opencv_core.Mat cameraMatrix, opencv_core.Mat distCoeffs)`
`static void`	`undistortPoints(opencv_core.Mat src, opencv_core.Mat dst, opencv_core.Mat cameraMatrix, opencv_core.Mat distCoeffs, opencv_core.Mat R, opencv_core.Mat P)` \brief Computes the ideal point coordinates from the observed point coordinates.
`static void`	`warpAffine(opencv_core.Mat src, opencv_core.Mat dst, opencv_core.Mat M, opencv_core.Size dsize)`
`static void`	`warpAffine(opencv_core.Mat src, opencv_core.Mat dst, opencv_core.Mat M, opencv_core.Size dsize, int flags, int borderMode, opencv_core.Scalar borderValue)` \brief Applies an affine transformation to an image.
`static void`	`warpPerspective(opencv_core.Mat src, opencv_core.Mat dst, opencv_core.Mat M, opencv_core.Size dsize)`
`static void`	`warpPerspective(opencv_core.Mat src, opencv_core.Mat dst, opencv_core.Mat M, opencv_core.Size dsize, int flags, int borderMode, opencv_core.Scalar borderValue)` \brief Applies a perspective transformation to an image.
`static void`	`watershed(opencv_core.Mat image, opencv_core.Mat markers)` \brief Performs a marker-based image segmentation using the watershed algorithm.

Methods inherited from class org.bytedeco.javacpp.helper.opencv_imgproc
cvCalcArrBackProject, cvCalcArrBackProjectPatch, cvCalcArrHist, cvCalcBackProject, cvCalcBackProject, cvCalcBackProjectPatch, cvCalcBackProjectPatch, cvCalcHist, cvCalcHist, cvCreateHist, cvDrawContours, cvDrawPolyLine, cvFillPoly, cvFindContours, cvMakeHistHeaderForArray, cvMakeHistHeaderForArray, cvPolyLine, cvSetHistBinRanges, cvStartFindContours

Methods inherited from class org.bytedeco.javacpp.presets.opencv_imgproc
map

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail
- CV_BLUR_NO_SCALE
```
public static final int CV_BLUR_NO_SCALE
```
  enum SmoothMethod_c
  
  See Also:
  Constant Field Values
- CV_BLUR
```
public static final int CV_BLUR
```
  enum SmoothMethod_c
  
  See Also:
  Constant Field Values
- CV_GAUSSIAN
```
public static final int CV_GAUSSIAN
```
  enum SmoothMethod_c
  
  See Also:
  Constant Field Values
- CV_MEDIAN
```
public static final int CV_MEDIAN
```
  enum SmoothMethod_c
  
  See Also:
  Constant Field Values
- CV_BILATERAL
```
public static final int CV_BILATERAL
```
  enum SmoothMethod_c
  
  See Also:
  Constant Field Values
- CV_GAUSSIAN_5x5
```
public static final int CV_GAUSSIAN_5x5
```
  enum
  
  See Also:
  Constant Field Values
- CV_SCHARR
```
public static final int CV_SCHARR
```
  enum
  
  See Also:
  Constant Field Values
- CV_MAX_SOBEL_KSIZE
```
public static final int CV_MAX_SOBEL_KSIZE
```
  enum
  
  See Also:
  Constant Field Values
- CV_BGR2BGRA
```
public static final int CV_BGR2BGRA
```
  enum
  
  See Also:
  Constant Field Values
- CV_RGB2RGBA
```
public static final int CV_RGB2RGBA
```
  enum
  
  See Also:
  Constant Field Values
- CV_BGRA2BGR
```
public static final int CV_BGRA2BGR
```
  enum
  
  See Also:
  Constant Field Values
- CV_RGBA2RGB
```
public static final int CV_RGBA2RGB
```
  enum
  
  See Also:
  Constant Field Values
- CV_BGR2RGBA
```
public static final int CV_BGR2RGBA
```
  enum
  
  See Also:
  Constant Field Values
- CV_RGB2BGRA
```
public static final int CV_RGB2BGRA
```
  enum
  
  See Also:
  Constant Field Values
- CV_RGBA2BGR
```
public static final int CV_RGBA2BGR
```
  enum
  
  See Also:
  Constant Field Values
- CV_BGRA2RGB
```
public static final int CV_BGRA2RGB
```
  enum
  
  See Also:
  Constant Field Values
- CV_BGR2RGB
```
public static final int CV_BGR2RGB
```
  enum
  
  See Also:
  Constant Field Values
- CV_RGB2BGR
```
public static final int CV_RGB2BGR
```
  enum
  
  See Also:
  Constant Field Values
- CV_BGRA2RGBA
```
public static final int CV_BGRA2RGBA
```
  enum
  
  See Also:
  Constant Field Values
- CV_RGBA2BGRA
```
public static final int CV_RGBA2BGRA
```
  enum
  
  See Also:
  Constant Field Values
- CV_BGR2GRAY
```
public static final int CV_BGR2GRAY
```
  enum
  
  See Also:
  Constant Field Values
- CV_RGB2GRAY
```
public static final int CV_RGB2GRAY
```
  enum
  
  See Also:
  Constant Field Values
- CV_GRAY2BGR
```
public static final int CV_GRAY2BGR
```
  enum
  
  See Also:
  Constant Field Values
- CV_GRAY2RGB
```
public static final int CV_GRAY2RGB
```
  enum
  
  See Also:
  Constant Field Values
- CV_GRAY2BGRA
```
public static final int CV_GRAY2BGRA
```
  enum
  
  See Also:
  Constant Field Values
- CV_GRAY2RGBA
```
public static final int CV_GRAY2RGBA
```
  enum
  
  See Also:
  Constant Field Values
- CV_BGRA2GRAY
```
public static final int CV_BGRA2GRAY
```
  enum
  
  See Also:
  Constant Field Values
- CV_RGBA2GRAY
```
public static final int CV_RGBA2GRAY
```
  enum
  
  See Also:
  Constant Field Values
- CV_BGR2BGR565
```
public static final int CV_BGR2BGR565
```
  enum
  
  See Also:
  Constant Field Values
- CV_RGB2BGR565
```
public static final int CV_RGB2BGR565
```
  enum
  
  See Also:
  Constant Field Values
- CV_BGR5652BGR
```
public static final int CV_BGR5652BGR
```
  enum
  
  See Also:
  Constant Field Values
- CV_BGR5652RGB
```
public static final int CV_BGR5652RGB
```
  enum
  
  See Also:
  Constant Field Values
- CV_BGRA2BGR565
```
public static final int CV_BGRA2BGR565
```
  enum
  
  See Also:
  Constant Field Values
- CV_RGBA2BGR565
```
public static final int CV_RGBA2BGR565
```
  enum
  
  See Also:
  Constant Field Values
- CV_BGR5652BGRA
```
public static final int CV_BGR5652BGRA
```
  enum
  
  See Also:
  Constant Field Values
- CV_BGR5652RGBA
```
public static final int CV_BGR5652RGBA
```
  enum
  
  See Also:
  Constant Field Values
- CV_GRAY2BGR565
```
public static final int CV_GRAY2BGR565
```
  enum
  
  See Also:
  Constant Field Values
- CV_BGR5652GRAY
```
public static final int CV_BGR5652GRAY
```
  enum
  
  See Also:
  Constant Field Values
- CV_BGR2BGR555
```
public static final int CV_BGR2BGR555
```
  enum
  
  See Also:
  Constant Field Values
- CV_RGB2BGR555
```
public static final int CV_RGB2BGR555
```
  enum
  
  See Also:
  Constant Field Values
- CV_BGR5552BGR
```
public static final int CV_BGR5552BGR
```
  enum
  
  See Also:
  Constant Field Values
- CV_BGR5552RGB
```
public static final int CV_BGR5552RGB
```
  enum
  
  See Also:
  Constant Field Values
- CV_BGRA2BGR555
```
public static final int CV_BGRA2BGR555
```
  enum
  
  See Also:
  Constant Field Values
- CV_RGBA2BGR555
```
public static final int CV_RGBA2BGR555
```
  enum
  
  See Also:
  Constant Field Values
- CV_BGR5552BGRA
```
public static final int CV_BGR5552BGRA
```
  enum
  
  See Also:
  Constant Field Values
- CV_BGR5552RGBA
```
public static final int CV_BGR5552RGBA
```
  enum
  
  See Also:
  Constant Field Values
- CV_GRAY2BGR555
```
public static final int CV_GRAY2BGR555
```
  enum
  
  See Also:
  Constant Field Values
- CV_BGR5552GRAY
```
public static final int CV_BGR5552GRAY
```
  enum
  
  See Also:
  Constant Field Values
- CV_BGR2XYZ
```
public static final int CV_BGR2XYZ
```
  enum
  
  See Also:
  Constant Field Values
- CV_RGB2XYZ
```
public static final int CV_RGB2XYZ
```
  enum
  
  See Also:
  Constant Field Values
- CV_XYZ2BGR
```
public static final int CV_XYZ2BGR
```
  enum
  
  See Also:
  Constant Field Values
- CV_XYZ2RGB
```
public static final int CV_XYZ2RGB
```
  enum
  
  See Also:
  Constant Field Values
- CV_BGR2YCrCb
```
public static final int CV_BGR2YCrCb
```
  enum
  
  See Also:
  Constant Field Values
- CV_RGB2YCrCb
```
public static final int CV_RGB2YCrCb
```
  enum
  
  See Also:
  Constant Field Values
- CV_YCrCb2BGR
```
public static final int CV_YCrCb2BGR
```
  enum
  
  See Also:
  Constant Field Values
- CV_YCrCb2RGB
```
public static final int CV_YCrCb2RGB
```
  enum
  
  See Also:
  Constant Field Values
- CV_BGR2HSV
```
public static final int CV_BGR2HSV
```
  enum
  
  See Also:
  Constant Field Values
- CV_RGB2HSV
```
public static final int CV_RGB2HSV
```
  enum
  
  See Also:
  Constant Field Values
- CV_BGR2Lab
```
public static final int CV_BGR2Lab
```
  enum
  
  See Also:
  Constant Field Values
- CV_RGB2Lab
```
public static final int CV_RGB2Lab
```
  enum
  
  See Also:
  Constant Field Values
- CV_BayerBG2BGR
```
public static final int CV_BayerBG2BGR
```
  enum
  
  See Also:
  Constant Field Values
- CV_BayerGB2BGR
```
public static final int CV_BayerGB2BGR
```
  enum
  
  See Also:
  Constant Field Values
- CV_BayerRG2BGR
```
public static final int CV_BayerRG2BGR
```
  enum
  
  See Also:
  Constant Field Values
- CV_BayerGR2BGR
```
public static final int CV_BayerGR2BGR
```
  enum
  
  See Also:
  Constant Field Values
- CV_BayerBG2RGB
```
public static final int CV_BayerBG2RGB
```
  enum
  
  See Also:
  Constant Field Values
- CV_BayerGB2RGB
```
public static final int CV_BayerGB2RGB
```
  enum
  
  See Also:
  Constant Field Values
- CV_BayerRG2RGB
```
public static final int CV_BayerRG2RGB
```
  enum
  
  See Also:
  Constant Field Values
- CV_BayerGR2RGB
```
public static final int CV_BayerGR2RGB
```
  enum
  
  See Also:
  Constant Field Values
- CV_BGR2Luv
```
public static final int CV_BGR2Luv
```
  enum
  
  See Also:
  Constant Field Values
- CV_RGB2Luv
```
public static final int CV_RGB2Luv
```
  enum
  
  See Also:
  Constant Field Values
- CV_BGR2HLS
```
public static final int CV_BGR2HLS
```
  enum
  
  See Also:
  Constant Field Values
- CV_RGB2HLS
```
public static final int CV_RGB2HLS
```
  enum
  
  See Also:
  Constant Field Values
- CV_HSV2BGR
```
public static final int CV_HSV2BGR
```
  enum
  
  See Also:
  Constant Field Values
- CV_HSV2RGB
```
public static final int CV_HSV2RGB
```
  enum
  
  See Also:
  Constant Field Values
- CV_Lab2BGR
```
public static final int CV_Lab2BGR
```
  enum
  
  See Also:
  Constant Field Values
- CV_Lab2RGB
```
public static final int CV_Lab2RGB
```
  enum
  
  See Also:
  Constant Field Values
- CV_Luv2BGR
```
public static final int CV_Luv2BGR
```
  enum
  
  See Also:
  Constant Field Values
- CV_Luv2RGB
```
public static final int CV_Luv2RGB
```
  enum
  
  See Also:
  Constant Field Values
- CV_HLS2BGR
```
public static final int CV_HLS2BGR
```
  enum
  
  See Also:
  Constant Field Values
- CV_HLS2RGB
```
public static final int CV_HLS2RGB
```
  enum
  
  See Also:
  Constant Field Values
- CV_BayerBG2BGR_VNG
```
public static final int CV_BayerBG2BGR_VNG
```
  enum
  
  See Also:
  Constant Field Values
- CV_BayerGB2BGR_VNG
```
public static final int CV_BayerGB2BGR_VNG
```
  enum
  
  See Also:
  Constant Field Values
- CV_BayerRG2BGR_VNG
```
public static final int CV_BayerRG2BGR_VNG
```
  enum
  
  See Also:
  Constant Field Values
- CV_BayerGR2BGR_VNG
```
public static final int CV_BayerGR2BGR_VNG
```
  enum
  
  See Also:
  Constant Field Values
- CV_BayerBG2RGB_VNG
```
public static final int CV_BayerBG2RGB_VNG
```
  enum
  
  See Also:
  Constant Field Values
- CV_BayerGB2RGB_VNG
```
public static final int CV_BayerGB2RGB_VNG
```
  enum
  
  See Also:
  Constant Field Values
- CV_BayerRG2RGB_VNG
```
public static final int CV_BayerRG2RGB_VNG
```
  enum
  
  See Also:
  Constant Field Values
- CV_BayerGR2RGB_VNG
```
public static final int CV_BayerGR2RGB_VNG
```
  enum
  
  See Also:
  Constant Field Values
- CV_BGR2HSV_FULL
```
public static final int CV_BGR2HSV_FULL
```
  enum
  
  See Also:
  Constant Field Values
- CV_RGB2HSV_FULL
```
public static final int CV_RGB2HSV_FULL
```
  enum
  
  See Also:
  Constant Field Values
- CV_BGR2HLS_FULL
```
public static final int CV_BGR2HLS_FULL
```
  enum
  
  See Also:
  Constant Field Values
- CV_RGB2HLS_FULL
```
public static final int CV_RGB2HLS_FULL
```
  enum
  
  See Also:
  Constant Field Values
- CV_HSV2BGR_FULL
```
public static final int CV_HSV2BGR_FULL
```
  enum
  
  See Also:
  Constant Field Values
- CV_HSV2RGB_FULL
```
public static final int CV_HSV2RGB_FULL
```
  enum
  
  See Also:
  Constant Field Values
- CV_HLS2BGR_FULL
```
public static final int CV_HLS2BGR_FULL
```
  enum
  
  See Also:
  Constant Field Values
- CV_HLS2RGB_FULL
```
public static final int CV_HLS2RGB_FULL
```
  enum
  
  See Also:
  Constant Field Values
- CV_LBGR2Lab
```
public static final int CV_LBGR2Lab
```
  enum
  
  See Also:
  Constant Field Values
- CV_LRGB2Lab
```
public static final int CV_LRGB2Lab
```
  enum
  
  See Also:
  Constant Field Values
- CV_LBGR2Luv
```
public static final int CV_LBGR2Luv
```
  enum
  
  See Also:
  Constant Field Values
- CV_LRGB2Luv
```
public static final int CV_LRGB2Luv
```
  enum
  
  See Also:
  Constant Field Values
- CV_Lab2LBGR
```
public static final int CV_Lab2LBGR
```
  enum
  
  See Also:
  Constant Field Values
- CV_Lab2LRGB
```
public static final int CV_Lab2LRGB
```
  enum
  
  See Also:
  Constant Field Values
- CV_Luv2LBGR
```
public static final int CV_Luv2LBGR
```
  enum
  
  See Also:
  Constant Field Values
- CV_Luv2LRGB
```
public static final int CV_Luv2LRGB
```
  enum
  
  See Also:
  Constant Field Values
- CV_BGR2YUV
```
public static final int CV_BGR2YUV
```
  enum
  
  See Also:
  Constant Field Values
- CV_RGB2YUV
```
public static final int CV_RGB2YUV
```
  enum
  
  See Also:
  Constant Field Values
- CV_YUV2BGR
```
public static final int CV_YUV2BGR
```
  enum
  
  See Also:
  Constant Field Values
- CV_YUV2RGB
```
public static final int CV_YUV2RGB
```
  enum
  
  See Also:
  Constant Field Values
- CV_BayerBG2GRAY
```
public static final int CV_BayerBG2GRAY
```
  enum
  
  See Also:
  Constant Field Values
- CV_BayerGB2GRAY
```
public static final int CV_BayerGB2GRAY
```
  enum
  
  See Also:
  Constant Field Values
- CV_BayerRG2GRAY
```
public static final int CV_BayerRG2GRAY
```
  enum
  
  See Also:
  Constant Field Values
- CV_BayerGR2GRAY
```
public static final int CV_BayerGR2GRAY
```
  enum
  
  See Also:
  Constant Field Values
- CV_YUV2RGB_NV12
```
public static final int CV_YUV2RGB_NV12
```
  enum
  
  See Also:
  Constant Field Values
- CV_YUV2BGR_NV12
```
public static final int CV_YUV2BGR_NV12
```
  enum
  
  See Also:
  Constant Field Values
- CV_YUV2RGB_NV21
```
public static final int CV_YUV2RGB_NV21
```
  enum
  
  See Also:
  Constant Field Values
- CV_YUV2BGR_NV21
```
public static final int CV_YUV2BGR_NV21
```
  enum
  
  See Also:
  Constant Field Values
- CV_YUV420sp2RGB
```
public static final int CV_YUV420sp2RGB
```
  enum
  
  See Also:
  Constant Field Values
- CV_YUV420sp2BGR
```
public static final int CV_YUV420sp2BGR
```
  enum
  
  See Also:
  Constant Field Values
- CV_YUV2RGBA_NV12
```
public static final int CV_YUV2RGBA_NV12
```
  enum
  
  See Also:
  Constant Field Values
- CV_YUV2BGRA_NV12
```
public static final int CV_YUV2BGRA_NV12
```
  enum
  
  See Also:
  Constant Field Values
- CV_YUV2RGBA_NV21
```
public static final int CV_YUV2RGBA_NV21
```
  enum
  
  See Also:
  Constant Field Values
- CV_YUV2BGRA_NV21
```
public static final int CV_YUV2BGRA_NV21
```
  enum
  
  See Also:
  Constant Field Values
- CV_YUV420sp2RGBA
```
public static final int CV_YUV420sp2RGBA
```
  enum
  
  See Also:
  Constant Field Values
- CV_YUV420sp2BGRA
```
public static final int CV_YUV420sp2BGRA
```
  enum
  
  See Also:
  Constant Field Values
- CV_YUV2RGB_YV12
```
public static final int CV_YUV2RGB_YV12
```
  enum
  
  See Also:
  Constant Field Values
- CV_YUV2BGR_YV12
```
public static final int CV_YUV2BGR_YV12
```
  enum
  
  See Also:
  Constant Field Values
- CV_YUV2RGB_IYUV
```
public static final int CV_YUV2RGB_IYUV
```
  enum
  
  See Also:
  Constant Field Values
- CV_YUV2BGR_IYUV
```
public static final int CV_YUV2BGR_IYUV
```
  enum
  
  See Also:
  Constant Field Values
- CV_YUV2RGB_I420
```
public static final int CV_YUV2RGB_I420
```
  enum
  
  See Also:
  Constant Field Values
- CV_YUV2BGR_I420
```
public static final int CV_YUV2BGR_I420
```
  enum
  
  See Also:
  Constant Field Values
- CV_YUV420p2RGB
```
public static final int CV_YUV420p2RGB
```
  enum
  
  See Also:
  Constant Field Values
- CV_YUV420p2BGR
```
public static final int CV_YUV420p2BGR
```
  enum
  
  See Also:
  Constant Field Values
- CV_YUV2RGBA_YV12
```
public static final int CV_YUV2RGBA_YV12
```
  enum
  
  See Also:
  Constant Field Values
- CV_YUV2BGRA_YV12
```
public static final int CV_YUV2BGRA_YV12
```
  enum
  
  See Also:
  Constant Field Values
- CV_YUV2RGBA_IYUV
```
public static final int CV_YUV2RGBA_IYUV
```
  enum
  
  See Also:
  Constant Field Values
- CV_YUV2BGRA_IYUV
```
public static final int CV_YUV2BGRA_IYUV
```
  enum
  
  See Also:
  Constant Field Values
- CV_YUV2RGBA_I420
```
public static final int CV_YUV2RGBA_I420
```
  enum
  
  See Also:
  Constant Field Values
- CV_YUV2BGRA_I420
```
public static final int CV_YUV2BGRA_I420
```
  enum
  
  See Also:
  Constant Field Values
- CV_YUV420p2RGBA
```
public static final int CV_YUV420p2RGBA
```
  enum
  
  See Also:
  Constant Field Values
- CV_YUV420p2BGRA
```
public static final int CV_YUV420p2BGRA
```
  enum
  
  See Also:
  Constant Field Values
- CV_YUV2GRAY_420
```
public static final int CV_YUV2GRAY_420
```
  enum
  
  See Also:
  Constant Field Values
- CV_YUV2GRAY_NV21
```
public static final int CV_YUV2GRAY_NV21
```
  enum
  
  See Also:
  Constant Field Values
- CV_YUV2GRAY_NV12
```
public static final int CV_YUV2GRAY_NV12
```
  enum
  
  See Also:
  Constant Field Values
- CV_YUV2GRAY_YV12
```
public static final int CV_YUV2GRAY_YV12
```
  enum
  
  See Also:
  Constant Field Values
- CV_YUV2GRAY_IYUV
```
public static final int CV_YUV2GRAY_IYUV
```
  enum
  
  See Also:
  Constant Field Values
- CV_YUV2GRAY_I420
```
public static final int CV_YUV2GRAY_I420
```
  enum
  
  See Also:
  Constant Field Values
- CV_YUV420sp2GRAY
```
public static final int CV_YUV420sp2GRAY
```
  enum
  
  See Also:
  Constant Field Values
- CV_YUV420p2GRAY
```
public static final int CV_YUV420p2GRAY
```
  enum
  
  See Also:
  Constant Field Values
- CV_YUV2RGB_UYVY
```
public static final int CV_YUV2RGB_UYVY
```
  enum
  
  See Also:
  Constant Field Values
- CV_YUV2BGR_UYVY
```
public static final int CV_YUV2BGR_UYVY
```
  enum
  
  See Also:
  Constant Field Values
- CV_YUV2RGB_Y422
```
public static final int CV_YUV2RGB_Y422
```
  enum
  
  See Also:
  Constant Field Values
- CV_YUV2BGR_Y422
```
public static final int CV_YUV2BGR_Y422
```
  enum
  
  See Also:
  Constant Field Values
- CV_YUV2RGB_UYNV
```
public static final int CV_YUV2RGB_UYNV
```
  enum
  
  See Also:
  Constant Field Values
- CV_YUV2BGR_UYNV
```
public static final int CV_YUV2BGR_UYNV
```
  enum
  
  See Also:
  Constant Field Values
- CV_YUV2RGBA_UYVY
```
public static final int CV_YUV2RGBA_UYVY
```
  enum
  
  See Also:
  Constant Field Values
- CV_YUV2BGRA_UYVY
```
public static final int CV_YUV2BGRA_UYVY
```
  enum
  
  See Also:
  Constant Field Values
- CV_YUV2RGBA_Y422
```
public static final int CV_YUV2RGBA_Y422
```
  enum
  
  See Also:
  Constant Field Values
- CV_YUV2BGRA_Y422
```
public static final int CV_YUV2BGRA_Y422
```
  enum
  
  See Also:
  Constant Field Values
- CV_YUV2RGBA_UYNV
```
public static final int CV_YUV2RGBA_UYNV
```
  enum
  
  See Also:
  Constant Field Values
- CV_YUV2BGRA_UYNV
```
public static final int CV_YUV2BGRA_UYNV
```
  enum
  
  See Also:
  Constant Field Values
- CV_YUV2RGB_YUY2
```
public static final int CV_YUV2RGB_YUY2
```
  enum
  
  See Also:
  Constant Field Values
- CV_YUV2BGR_YUY2
```
public static final int CV_YUV2BGR_YUY2
```
  enum
  
  See Also:
  Constant Field Values
- CV_YUV2RGB_YVYU
```
public static final int CV_YUV2RGB_YVYU
```
  enum
  
  See Also:
  Constant Field Values
- CV_YUV2BGR_YVYU
```
public static final int CV_YUV2BGR_YVYU
```
  enum
  
  See Also:
  Constant Field Values
- CV_YUV2RGB_YUYV
```
public static final int CV_YUV2RGB_YUYV
```
  enum
  
  See Also:
  Constant Field Values
- CV_YUV2BGR_YUYV
```
public static final int CV_YUV2BGR_YUYV
```
  enum
  
  See Also:
  Constant Field Values
- CV_YUV2RGB_YUNV
```
public static final int CV_YUV2RGB_YUNV
```
  enum
  
  See Also:
  Constant Field Values
- CV_YUV2BGR_YUNV
```
public static final int CV_YUV2BGR_YUNV
```
  enum
  
  See Also:
  Constant Field Values
- CV_YUV2RGBA_YUY2
```
public static final int CV_YUV2RGBA_YUY2
```
  enum
  
  See Also:
  Constant Field Values
- CV_YUV2BGRA_YUY2
```
public static final int CV_YUV2BGRA_YUY2
```
  enum
  
  See Also:
  Constant Field Values
- CV_YUV2RGBA_YVYU
```
public static final int CV_YUV2RGBA_YVYU
```
  enum
  
  See Also:
  Constant Field Values
- CV_YUV2BGRA_YVYU
```
public static final int CV_YUV2BGRA_YVYU
```
  enum
  
  See Also:
  Constant Field Values
- CV_YUV2RGBA_YUYV
```
public static final int CV_YUV2RGBA_YUYV
```
  enum
  
  See Also:
  Constant Field Values
- CV_YUV2BGRA_YUYV
```
public static final int CV_YUV2BGRA_YUYV
```
  enum
  
  See Also:
  Constant Field Values
- CV_YUV2RGBA_YUNV
```
public static final int CV_YUV2RGBA_YUNV
```
  enum
  
  See Also:
  Constant Field Values
- CV_YUV2BGRA_YUNV
```
public static final int CV_YUV2BGRA_YUNV
```
  enum
  
  See Also:
  Constant Field Values
- CV_YUV2GRAY_UYVY
```
public static final int CV_YUV2GRAY_UYVY
```
  enum
  
  See Also:
  Constant Field Values
- CV_YUV2GRAY_YUY2
```
public static final int CV_YUV2GRAY_YUY2
```
  enum
  
  See Also:
  Constant Field Values
- CV_YUV2GRAY_Y422
```
public static final int CV_YUV2GRAY_Y422
```
  enum
  
  See Also:
  Constant Field Values
- CV_YUV2GRAY_UYNV
```
public static final int CV_YUV2GRAY_UYNV
```
  enum
  
  See Also:
  Constant Field Values
- CV_YUV2GRAY_YVYU
```
public static final int CV_YUV2GRAY_YVYU
```
  enum
  
  See Also:
  Constant Field Values
- CV_YUV2GRAY_YUYV
```
public static final int CV_YUV2GRAY_YUYV
```
  enum
  
  See Also:
  Constant Field Values
- CV_YUV2GRAY_YUNV
```
public static final int CV_YUV2GRAY_YUNV
```
  enum
  
  See Also:
  Constant Field Values
- CV_RGBA2mRGBA
```
public static final int CV_RGBA2mRGBA
```
  enum
  
  See Also:
  Constant Field Values
- CV_mRGBA2RGBA
```
public static final int CV_mRGBA2RGBA
```
  enum
  
  See Also:
  Constant Field Values
- CV_RGB2YUV_I420
```
public static final int CV_RGB2YUV_I420
```
  enum
  
  See Also:
  Constant Field Values
- CV_BGR2YUV_I420
```
public static final int CV_BGR2YUV_I420
```
  enum
  
  See Also:
  Constant Field Values
- CV_RGB2YUV_IYUV
```
public static final int CV_RGB2YUV_IYUV
```
  enum
  
  See Also:
  Constant Field Values
- CV_BGR2YUV_IYUV
```
public static final int CV_BGR2YUV_IYUV
```
  enum
  
  See Also:
  Constant Field Values
- CV_RGBA2YUV_I420
```
public static final int CV_RGBA2YUV_I420
```
  enum
  
  See Also:
  Constant Field Values
- CV_BGRA2YUV_I420
```
public static final int CV_BGRA2YUV_I420
```
  enum
  
  See Also:
  Constant Field Values
- CV_RGBA2YUV_IYUV
```
public static final int CV_RGBA2YUV_IYUV
```
  enum
  
  See Also:
  Constant Field Values
- CV_BGRA2YUV_IYUV
```
public static final int CV_BGRA2YUV_IYUV
```
  enum
  
  See Also:
  Constant Field Values
- CV_RGB2YUV_YV12
```
public static final int CV_RGB2YUV_YV12
```
  enum
  
  See Also:
  Constant Field Values
- CV_BGR2YUV_YV12
```
public static final int CV_BGR2YUV_YV12
```
  enum
  
  See Also:
  Constant Field Values
- CV_RGBA2YUV_YV12
```
public static final int CV_RGBA2YUV_YV12
```
  enum
  
  See Also:
  Constant Field Values
- CV_BGRA2YUV_YV12
```
public static final int CV_BGRA2YUV_YV12
```
  enum
  
  See Also:
  Constant Field Values
- CV_BayerBG2BGR_EA
```
public static final int CV_BayerBG2BGR_EA
```
  enum
  
  See Also:
  Constant Field Values
- CV_BayerGB2BGR_EA
```
public static final int CV_BayerGB2BGR_EA
```
  enum
  
  See Also:
  Constant Field Values
- CV_BayerRG2BGR_EA
```
public static final int CV_BayerRG2BGR_EA
```
  enum
  
  See Also:
  Constant Field Values
- CV_BayerGR2BGR_EA
```
public static final int CV_BayerGR2BGR_EA
```
  enum
  
  See Also:
  Constant Field Values
- CV_BayerBG2RGB_EA
```
public static final int CV_BayerBG2RGB_EA
```
  enum
  
  See Also:
  Constant Field Values
- CV_BayerGB2RGB_EA
```
public static final int CV_BayerGB2RGB_EA
```
  enum
  
  See Also:
  Constant Field Values
- CV_BayerRG2RGB_EA
```
public static final int CV_BayerRG2RGB_EA
```
  enum
  
  See Also:
  Constant Field Values
- CV_BayerGR2RGB_EA
```
public static final int CV_BayerGR2RGB_EA
```
  enum
  
  See Also:
  Constant Field Values
- CV_COLORCVT_MAX
```
public static final int CV_COLORCVT_MAX
```
  enum
  
  See Also:
  Constant Field Values
- CV_INTER_NN
```
public static final int CV_INTER_NN
```
  enum
  
  See Also:
  Constant Field Values
- CV_INTER_LINEAR
```
public static final int CV_INTER_LINEAR
```
  enum
  
  See Also:
  Constant Field Values
- CV_INTER_CUBIC
```
public static final int CV_INTER_CUBIC
```
  enum
  
  See Also:
  Constant Field Values
- CV_INTER_AREA
```
public static final int CV_INTER_AREA
```
  enum
  
  See Also:
  Constant Field Values
- CV_INTER_LANCZOS4
```
public static final int CV_INTER_LANCZOS4
```
  enum
  
  See Also:
  Constant Field Values
- CV_WARP_FILL_OUTLIERS
```
public static final int CV_WARP_FILL_OUTLIERS
```
  enum
  
  See Also:
  Constant Field Values
- CV_WARP_INVERSE_MAP
```
public static final int CV_WARP_INVERSE_MAP
```
  enum
  
  See Also:
  Constant Field Values
- CV_SHAPE_RECT
```
public static final int CV_SHAPE_RECT
```
  enum MorphShapes_c
  
  See Also:
  Constant Field Values
- CV_SHAPE_CROSS
```
public static final int CV_SHAPE_CROSS
```
  enum MorphShapes_c
  
  See Also:
  Constant Field Values
- CV_SHAPE_ELLIPSE
```
public static final int CV_SHAPE_ELLIPSE
```
  enum MorphShapes_c
  
  See Also:
  Constant Field Values
- CV_SHAPE_CUSTOM
```
public static final int CV_SHAPE_CUSTOM
```
  enum MorphShapes_c
  
  See Also:
  Constant Field Values
- CV_MOP_ERODE
```
public static final int CV_MOP_ERODE
```
  enum
  
  See Also:
  Constant Field Values
- CV_MOP_DILATE
```
public static final int CV_MOP_DILATE
```
  enum
  
  See Also:
  Constant Field Values
- CV_MOP_OPEN
```
public static final int CV_MOP_OPEN
```
  enum
  
  See Also:
  Constant Field Values
- CV_MOP_CLOSE
```
public static final int CV_MOP_CLOSE
```
  enum
  
  See Also:
  Constant Field Values
- CV_MOP_GRADIENT
```
public static final int CV_MOP_GRADIENT
```
  enum
  
  See Also:
  Constant Field Values
- CV_MOP_TOPHAT
```
public static final int CV_MOP_TOPHAT
```
  enum
  
  See Also:
  Constant Field Values
- CV_MOP_BLACKHAT
```
public static final int CV_MOP_BLACKHAT
```
  enum
  
  See Also:
  Constant Field Values
- CV_TM_SQDIFF
```
public static final int CV_TM_SQDIFF
```
  enum
  
  See Also:
  Constant Field Values
- CV_TM_SQDIFF_NORMED
```
public static final int CV_TM_SQDIFF_NORMED
```
  enum
  
  See Also:
  Constant Field Values
- CV_TM_CCORR
```
public static final int CV_TM_CCORR
```
  enum
  
  See Also:
  Constant Field Values
- CV_TM_CCORR_NORMED
```
public static final int CV_TM_CCORR_NORMED
```
  enum
  
  See Also:
  Constant Field Values
- CV_TM_CCOEFF
```
public static final int CV_TM_CCOEFF
```
  enum
  
  See Also:
  Constant Field Values
- CV_TM_CCOEFF_NORMED
```
public static final int CV_TM_CCOEFF_NORMED
```
  enum
  
  See Also:
  Constant Field Values
- CV_RETR_EXTERNAL
```
public static final int CV_RETR_EXTERNAL
```
  enum
  
  See Also:
  Constant Field Values
- CV_RETR_LIST
```
public static final int CV_RETR_LIST
```
  enum
  
  See Also:
  Constant Field Values
- CV_RETR_CCOMP
```
public static final int CV_RETR_CCOMP
```
  enum
  
  See Also:
  Constant Field Values
- CV_RETR_TREE
```
public static final int CV_RETR_TREE
```
  enum
  
  See Also:
  Constant Field Values
- CV_RETR_FLOODFILL
```
public static final int CV_RETR_FLOODFILL
```
  enum
  
  See Also:
  Constant Field Values
- CV_CHAIN_CODE
```
public static final int CV_CHAIN_CODE
```
  enum
  
  See Also:
  Constant Field Values
- CV_CHAIN_APPROX_NONE
```
public static final int CV_CHAIN_APPROX_NONE
```
  enum
  
  See Also:
  Constant Field Values
- CV_CHAIN_APPROX_SIMPLE
```
public static final int CV_CHAIN_APPROX_SIMPLE
```
  enum
  
  See Also:
  Constant Field Values
- CV_CHAIN_APPROX_TC89_L1
```
public static final int CV_CHAIN_APPROX_TC89_L1
```
  enum
  
  See Also:
  Constant Field Values
- CV_CHAIN_APPROX_TC89_KCOS
```
public static final int CV_CHAIN_APPROX_TC89_KCOS
```
  enum
  
  See Also:
  Constant Field Values
- CV_LINK_RUNS
```
public static final int CV_LINK_RUNS
```
  enum
  
  See Also:
  Constant Field Values
- CV_POLY_APPROX_DP
```
public static final int CV_POLY_APPROX_DP
```
  enum
  
  See Also:
  Constant Field Values
- CV_CONTOURS_MATCH_I1
```
public static final int CV_CONTOURS_MATCH_I1
```
  enum ShapeMatchModes
  
  See Also:
  Constant Field Values
- CV_CONTOURS_MATCH_I2
```
public static final int CV_CONTOURS_MATCH_I2
```
  enum ShapeMatchModes
  
  See Also:
  Constant Field Values
- CV_CONTOURS_MATCH_I3
```
public static final int CV_CONTOURS_MATCH_I3
```
  enum ShapeMatchModes
  
  See Also:
  Constant Field Values
- CV_CLOCKWISE
```
public static final int CV_CLOCKWISE
```
  enum
  
  See Also:
  Constant Field Values
- CV_COUNTER_CLOCKWISE
```
public static final int CV_COUNTER_CLOCKWISE
```
  enum
  
  See Also:
  Constant Field Values
- CV_COMP_CORREL
```
public static final int CV_COMP_CORREL
```
  enum
  
  See Also:
  Constant Field Values
- CV_COMP_CHISQR
```
public static final int CV_COMP_CHISQR
```
  enum
  
  See Also:
  Constant Field Values
- CV_COMP_INTERSECT
```
public static final int CV_COMP_INTERSECT
```
  enum
  
  See Also:
  Constant Field Values
- CV_COMP_BHATTACHARYYA
```
public static final int CV_COMP_BHATTACHARYYA
```
  enum
  
  See Also:
  Constant Field Values
- CV_COMP_HELLINGER
```
public static final int CV_COMP_HELLINGER
```
  enum
  
  See Also:
  Constant Field Values
- CV_COMP_CHISQR_ALT
```
public static final int CV_COMP_CHISQR_ALT
```
  enum
  
  See Also:
  Constant Field Values
- CV_COMP_KL_DIV
```
public static final int CV_COMP_KL_DIV
```
  enum
  
  See Also:
  Constant Field Values
- CV_DIST_MASK_3
```
public static final int CV_DIST_MASK_3
```
  enum
  
  See Also:
  Constant Field Values
- CV_DIST_MASK_5
```
public static final int CV_DIST_MASK_5
```
  enum
  
  See Also:
  Constant Field Values
- CV_DIST_MASK_PRECISE
```
public static final int CV_DIST_MASK_PRECISE
```
  enum
  
  See Also:
  Constant Field Values
- CV_DIST_LABEL_CCOMP
```
public static final int CV_DIST_LABEL_CCOMP
```
  enum
  
  See Also:
  Constant Field Values
- CV_DIST_LABEL_PIXEL
```
public static final int CV_DIST_LABEL_PIXEL
```
  enum
  
  See Also:
  Constant Field Values
- CV_DIST_USER
```
public static final int CV_DIST_USER
```
  enum
  
  See Also:
  Constant Field Values
- CV_DIST_L1
```
public static final int CV_DIST_L1
```
  enum
  
  See Also:
  Constant Field Values
- CV_DIST_L2
```
public static final int CV_DIST_L2
```
  enum
  
  See Also:
  Constant Field Values
- CV_DIST_C
```
public static final int CV_DIST_C
```
  enum
  
  See Also:
  Constant Field Values
- CV_DIST_L12
```
public static final int CV_DIST_L12
```
  enum
  
  See Also:
  Constant Field Values
- CV_DIST_FAIR
```
public static final int CV_DIST_FAIR
```
  enum
  
  See Also:
  Constant Field Values
- CV_DIST_WELSCH
```
public static final int CV_DIST_WELSCH
```
  enum
  
  See Also:
  Constant Field Values
- CV_DIST_HUBER
```
public static final int CV_DIST_HUBER
```
  enum
  
  See Also:
  Constant Field Values
- CV_THRESH_BINARY
```
public static final int CV_THRESH_BINARY
```
  enum
  
  See Also:
  Constant Field Values
- CV_THRESH_BINARY_INV
```
public static final int CV_THRESH_BINARY_INV
```
  enum
  
  See Also:
  Constant Field Values
- CV_THRESH_TRUNC
```
public static final int CV_THRESH_TRUNC
```
  enum
  
  See Also:
  Constant Field Values
- CV_THRESH_TOZERO
```
public static final int CV_THRESH_TOZERO
```
  enum
  
  See Also:
  Constant Field Values
- CV_THRESH_TOZERO_INV
```
public static final int CV_THRESH_TOZERO_INV
```
  enum
  
  See Also:
  Constant Field Values
- CV_THRESH_MASK
```
public static final int CV_THRESH_MASK
```
  enum
  
  See Also:
  Constant Field Values
- CV_THRESH_OTSU
```
public static final int CV_THRESH_OTSU
```
  enum
  
  See Also:
  Constant Field Values
- CV_THRESH_TRIANGLE
```
public static final int CV_THRESH_TRIANGLE
```
  enum
  
  See Also:
  Constant Field Values
- CV_ADAPTIVE_THRESH_MEAN_C
```
public static final int CV_ADAPTIVE_THRESH_MEAN_C
```
  enum
  
  See Also:
  Constant Field Values
- CV_ADAPTIVE_THRESH_GAUSSIAN_C
```
public static final int CV_ADAPTIVE_THRESH_GAUSSIAN_C
```
  enum
  
  See Also:
  Constant Field Values
- CV_FLOODFILL_FIXED_RANGE
```
public static final int CV_FLOODFILL_FIXED_RANGE
```
  enum
  
  See Also:
  Constant Field Values
- CV_FLOODFILL_MASK_ONLY
```
public static final int CV_FLOODFILL_MASK_ONLY
```
  enum
  
  See Also:
  Constant Field Values
- CV_CANNY_L2_GRADIENT
```
public static final int CV_CANNY_L2_GRADIENT
```
  enum
  
  See Also:
  Constant Field Values
- CV_HOUGH_STANDARD
```
public static final int CV_HOUGH_STANDARD
```
  enum
  
  See Also:
  Constant Field Values
- CV_HOUGH_PROBABILISTIC
```
public static final int CV_HOUGH_PROBABILISTIC
```
  enum
  
  See Also:
  Constant Field Values
- CV_HOUGH_MULTI_SCALE
```
public static final int CV_HOUGH_MULTI_SCALE
```
  enum
  
  See Also:
  Constant Field Values
- CV_HOUGH_GRADIENT
```
public static final int CV_HOUGH_GRADIENT
```
  enum
  
  See Also:
  Constant Field Values
- CV_FILLED
```
public static final int CV_FILLED
```
  \ Drawing functions work with images/matrices of arbitrary type. * For color images the channel order is BGR[A] * Antialiasing is supported only for 8-bit image now. * All the functions include parameter color that means rgb value (that may be * constructed with CV_RGB macro) for color images and brightness * for grayscale images. * If a drawn figure is partially or completely outside of the image, it is clipped.* \
  
  See Also:
  Constant Field Values
- CV_AA
```
public static final int CV_AA
```
  See Also:
  Constant Field Values
- CV_FONT_HERSHEY_SIMPLEX
```
public static final int CV_FONT_HERSHEY_SIMPLEX
```
  See Also:
  Constant Field Values
- CV_FONT_HERSHEY_PLAIN
```
public static final int CV_FONT_HERSHEY_PLAIN
```
  See Also:
  Constant Field Values
- CV_FONT_HERSHEY_DUPLEX
```
public static final int CV_FONT_HERSHEY_DUPLEX
```
  See Also:
  Constant Field Values
- CV_FONT_HERSHEY_COMPLEX
```
public static final int CV_FONT_HERSHEY_COMPLEX
```
  See Also:
  Constant Field Values
- CV_FONT_HERSHEY_TRIPLEX
```
public static final int CV_FONT_HERSHEY_TRIPLEX
```
  See Also:
  Constant Field Values
- CV_FONT_HERSHEY_COMPLEX_SMALL
```
public static final int CV_FONT_HERSHEY_COMPLEX_SMALL
```
  See Also:
  Constant Field Values
- CV_FONT_HERSHEY_SCRIPT_SIMPLEX
```
public static final int CV_FONT_HERSHEY_SCRIPT_SIMPLEX
```
  See Also:
  Constant Field Values
- CV_FONT_HERSHEY_SCRIPT_COMPLEX
```
public static final int CV_FONT_HERSHEY_SCRIPT_COMPLEX
```
  See Also:
  Constant Field Values
- CV_FONT_ITALIC
```
public static final int CV_FONT_ITALIC
```
  See Also:
  Constant Field Values
- CV_FONT_VECTOR0
```
public static final int CV_FONT_VECTOR0
```
  See Also:
  Constant Field Values
- MORPH_ERODE
```
public static final int MORPH_ERODE
```
  enum cv::MorphTypes
  
  See Also:
  Constant Field Values
- MORPH_DILATE
```
public static final int MORPH_DILATE
```
  enum cv::MorphTypes
  
  See Also:
  Constant Field Values
- MORPH_OPEN
```
public static final int MORPH_OPEN
```
  enum cv::MorphTypes
  
  See Also:
  Constant Field Values
- MORPH_CLOSE
```
public static final int MORPH_CLOSE
```
  enum cv::MorphTypes
  
  See Also:
  Constant Field Values
- MORPH_GRADIENT
```
public static final int MORPH_GRADIENT
```
  enum cv::MorphTypes
  
  See Also:
  Constant Field Values
- MORPH_TOPHAT
```
public static final int MORPH_TOPHAT
```
  enum cv::MorphTypes
  
  See Also:
  Constant Field Values
- MORPH_BLACKHAT
```
public static final int MORPH_BLACKHAT
```
  enum cv::MorphTypes
  
  See Also:
  Constant Field Values
- MORPH_HITMISS
```
public static final int MORPH_HITMISS
```
  enum cv::MorphTypes
  
  See Also:
  Constant Field Values
- MORPH_RECT
```
public static final int MORPH_RECT
```
  enum cv::MorphShapes
  
  See Also:
  Constant Field Values
- MORPH_CROSS
```
public static final int MORPH_CROSS
```
  enum cv::MorphShapes
  
  See Also:
  Constant Field Values
- MORPH_ELLIPSE
```
public static final int MORPH_ELLIPSE
```
  enum cv::MorphShapes
  
  See Also:
  Constant Field Values
- INTER_NEAREST
```
public static final int INTER_NEAREST
```
  enum cv::InterpolationFlags
  
  See Also:
  Constant Field Values
- INTER_LINEAR
```
public static final int INTER_LINEAR
```
  enum cv::InterpolationFlags
  
  See Also:
  Constant Field Values
- INTER_CUBIC
```
public static final int INTER_CUBIC
```
  enum cv::InterpolationFlags
  
  See Also:
  Constant Field Values
- INTER_AREA
```
public static final int INTER_AREA
```
  enum cv::InterpolationFlags
  
  See Also:
  Constant Field Values
- INTER_LANCZOS4
```
public static final int INTER_LANCZOS4
```
  enum cv::InterpolationFlags
  
  See Also:
  Constant Field Values
- INTER_MAX
```
public static final int INTER_MAX
```
  enum cv::InterpolationFlags
  
  See Also:
  Constant Field Values
- WARP_FILL_OUTLIERS
```
public static final int WARP_FILL_OUTLIERS
```
  enum cv::InterpolationFlags
  
  See Also:
  Constant Field Values
- WARP_INVERSE_MAP
```
public static final int WARP_INVERSE_MAP
```
  enum cv::InterpolationFlags
  
  See Also:
  Constant Field Values
- INTER_BITS
```
public static final int INTER_BITS
```
  enum cv::InterpolationMasks
  
  See Also:
  Constant Field Values
- INTER_BITS2
```
public static final int INTER_BITS2
```
  enum cv::InterpolationMasks
  
  See Also:
  Constant Field Values
- INTER_TAB_SIZE
```
public static final int INTER_TAB_SIZE
```
  enum cv::InterpolationMasks
  
  See Also:
  Constant Field Values
- INTER_TAB_SIZE2
```
public static final int INTER_TAB_SIZE2
```
  enum cv::InterpolationMasks
  
  See Also:
  Constant Field Values
- DIST_USER
```
public static final int DIST_USER
```
  enum cv::DistanceTypes
  
  See Also:
  Constant Field Values
- DIST_L1
```
public static final int DIST_L1
```
  enum cv::DistanceTypes
  
  See Also:
  Constant Field Values
- DIST_L2
```
public static final int DIST_L2
```
  enum cv::DistanceTypes
  
  See Also:
  Constant Field Values
- DIST_C
```
public static final int DIST_C
```
  enum cv::DistanceTypes
  
  See Also:
  Constant Field Values
- DIST_L12
```
public static final int DIST_L12
```
  enum cv::DistanceTypes
  
  See Also:
  Constant Field Values
- DIST_FAIR
```
public static final int DIST_FAIR
```
  enum cv::DistanceTypes
  
  See Also:
  Constant Field Values
- DIST_WELSCH
```
public static final int DIST_WELSCH
```
  enum cv::DistanceTypes
  
  See Also:
  Constant Field Values
- DIST_HUBER
```
public static final int DIST_HUBER
```
  enum cv::DistanceTypes
  
  See Also:
  Constant Field Values
- DIST_MASK_3
```
public static final int DIST_MASK_3
```
  enum cv::DistanceTransformMasks
  
  See Also:
  Constant Field Values
- DIST_MASK_5
```
public static final int DIST_MASK_5
```
  enum cv::DistanceTransformMasks
  
  See Also:
  Constant Field Values
- DIST_MASK_PRECISE
```
public static final int DIST_MASK_PRECISE
```
  enum cv::DistanceTransformMasks
  
  See Also:
  Constant Field Values
- THRESH_BINARY
```
public static final int THRESH_BINARY
```
  enum cv::ThresholdTypes
  
  See Also:
  Constant Field Values
- THRESH_BINARY_INV
```
public static final int THRESH_BINARY_INV
```
  enum cv::ThresholdTypes
  
  See Also:
  Constant Field Values
- THRESH_TRUNC
```
public static final int THRESH_TRUNC
```
  enum cv::ThresholdTypes
  
  See Also:
  Constant Field Values
- THRESH_TOZERO
```
public static final int THRESH_TOZERO
```
  enum cv::ThresholdTypes
  
  See Also:
  Constant Field Values
- THRESH_TOZERO_INV
```
public static final int THRESH_TOZERO_INV
```
  enum cv::ThresholdTypes
  
  See Also:
  Constant Field Values
- THRESH_MASK
```
public static final int THRESH_MASK
```
  enum cv::ThresholdTypes
  
  See Also:
  Constant Field Values
- THRESH_OTSU
```
public static final int THRESH_OTSU
```
  enum cv::ThresholdTypes
  
  See Also:
  Constant Field Values
- THRESH_TRIANGLE
```
public static final int THRESH_TRIANGLE
```
  enum cv::ThresholdTypes
  
  See Also:
  Constant Field Values
- ADAPTIVE_THRESH_MEAN_C
```
public static final int ADAPTIVE_THRESH_MEAN_C
```
  enum cv::AdaptiveThresholdTypes
  
  See Also:
  Constant Field Values
- ADAPTIVE_THRESH_GAUSSIAN_C
```
public static final int ADAPTIVE_THRESH_GAUSSIAN_C
```
  enum cv::AdaptiveThresholdTypes
  
  See Also:
  Constant Field Values
- PROJ_SPHERICAL_ORTHO
```
public static final int PROJ_SPHERICAL_ORTHO
```
  enum cv::UndistortTypes
  
  See Also:
  Constant Field Values
- PROJ_SPHERICAL_EQRECT
```
public static final int PROJ_SPHERICAL_EQRECT
```
  enum cv::UndistortTypes
  
  See Also:
  Constant Field Values
- GC_BGD
```
public static final int GC_BGD
```
  enum cv::GrabCutClasses
  
  See Also:
  Constant Field Values
- GC_FGD
```
public static final int GC_FGD
```
  enum cv::GrabCutClasses
  
  See Also:
  Constant Field Values
- GC_PR_BGD
```
public static final int GC_PR_BGD
```
  enum cv::GrabCutClasses
  
  See Also:
  Constant Field Values
- GC_PR_FGD
```
public static final int GC_PR_FGD
```
  enum cv::GrabCutClasses
  
  See Also:
  Constant Field Values
- GC_INIT_WITH_RECT
```
public static final int GC_INIT_WITH_RECT
```
  enum cv::GrabCutModes
  
  See Also:
  Constant Field Values
- GC_INIT_WITH_MASK
```
public static final int GC_INIT_WITH_MASK
```
  enum cv::GrabCutModes
  
  See Also:
  Constant Field Values
- GC_EVAL
```
public static final int GC_EVAL
```
  enum cv::GrabCutModes
  
  See Also:
  Constant Field Values
- DIST_LABEL_CCOMP
```
public static final int DIST_LABEL_CCOMP
```
  enum cv::DistanceTransformLabelTypes
  
  See Also:
  Constant Field Values
- DIST_LABEL_PIXEL
```
public static final int DIST_LABEL_PIXEL
```
  enum cv::DistanceTransformLabelTypes
  
  See Also:
  Constant Field Values
- FLOODFILL_FIXED_RANGE
```
public static final int FLOODFILL_FIXED_RANGE
```
  enum cv::FloodFillFlags
  
  See Also:
  Constant Field Values
- FLOODFILL_MASK_ONLY
```
public static final int FLOODFILL_MASK_ONLY
```
  enum cv::FloodFillFlags
  
  See Also:
  Constant Field Values
- CC_STAT_LEFT
```
public static final int CC_STAT_LEFT
```
  enum cv::ConnectedComponentsTypes
  
  See Also:
  Constant Field Values
- CC_STAT_TOP
```
public static final int CC_STAT_TOP
```
  enum cv::ConnectedComponentsTypes
  
  See Also:
  Constant Field Values
- CC_STAT_WIDTH
```
public static final int CC_STAT_WIDTH
```
  enum cv::ConnectedComponentsTypes
  
  See Also:
  Constant Field Values
- CC_STAT_HEIGHT
```
public static final int CC_STAT_HEIGHT
```
  enum cv::ConnectedComponentsTypes
  
  See Also:
  Constant Field Values
- CC_STAT_AREA
```
public static final int CC_STAT_AREA
```
  enum cv::ConnectedComponentsTypes
  
  See Also:
  Constant Field Values
- CC_STAT_MAX
```
public static final int CC_STAT_MAX
```
  enum cv::ConnectedComponentsTypes
  
  See Also:
  Constant Field Values
- RETR_EXTERNAL
```
public static final int RETR_EXTERNAL
```
  enum cv::RetrievalModes
  
  See Also:
  Constant Field Values
- RETR_LIST
```
public static final int RETR_LIST
```
  enum cv::RetrievalModes
  
  See Also:
  Constant Field Values
- RETR_CCOMP
```
public static final int RETR_CCOMP
```
  enum cv::RetrievalModes
  
  See Also:
  Constant Field Values
- RETR_TREE
```
public static final int RETR_TREE
```
  enum cv::RetrievalModes
  
  See Also:
  Constant Field Values
- RETR_FLOODFILL
```
public static final int RETR_FLOODFILL
```
  enum cv::RetrievalModes
  
  See Also:
  Constant Field Values
- CHAIN_APPROX_NONE
```
public static final int CHAIN_APPROX_NONE
```
  enum cv::ContourApproximationModes
  
  See Also:
  Constant Field Values
- CHAIN_APPROX_SIMPLE
```
public static final int CHAIN_APPROX_SIMPLE
```
  enum cv::ContourApproximationModes
  
  See Also:
  Constant Field Values
- CHAIN_APPROX_TC89_L1
```
public static final int CHAIN_APPROX_TC89_L1
```
  enum cv::ContourApproximationModes
  
  See Also:
  Constant Field Values
- CHAIN_APPROX_TC89_KCOS
```
public static final int CHAIN_APPROX_TC89_KCOS
```
  enum cv::ContourApproximationModes
  
  See Also:
  Constant Field Values
- HOUGH_STANDARD
```
public static final int HOUGH_STANDARD
```
  enum cv::HoughModes
  
  See Also:
  Constant Field Values
- HOUGH_PROBABILISTIC
```
public static final int HOUGH_PROBABILISTIC
```
  enum cv::HoughModes
  
  See Also:
  Constant Field Values
- HOUGH_MULTI_SCALE
```
public static final int HOUGH_MULTI_SCALE
```
  enum cv::HoughModes
  
  See Also:
  Constant Field Values
- HOUGH_GRADIENT
```
public static final int HOUGH_GRADIENT
```
  enum cv::HoughModes
  
  See Also:
  Constant Field Values
- LSD_REFINE_NONE
```
public static final int LSD_REFINE_NONE
```
  enum cv::LineSegmentDetectorModes
  
  See Also:
  Constant Field Values
- LSD_REFINE_STD
```
public static final int LSD_REFINE_STD
```
  enum cv::LineSegmentDetectorModes
  
  See Also:
  Constant Field Values
- LSD_REFINE_ADV
```
public static final int LSD_REFINE_ADV
```
  enum cv::LineSegmentDetectorModes
  
  See Also:
  Constant Field Values
- HISTCMP_CORREL
```
public static final int HISTCMP_CORREL
```
  enum cv::HistCompMethods
  
  See Also:
  Constant Field Values
- HISTCMP_CHISQR
```
public static final int HISTCMP_CHISQR
```
  enum cv::HistCompMethods
  
  See Also:
  Constant Field Values
- HISTCMP_INTERSECT
```
public static final int HISTCMP_INTERSECT
```
  enum cv::HistCompMethods
  
  See Also:
  Constant Field Values
- HISTCMP_BHATTACHARYYA
```
public static final int HISTCMP_BHATTACHARYYA
```
  enum cv::HistCompMethods
  
  See Also:
  Constant Field Values
- HISTCMP_HELLINGER
```
public static final int HISTCMP_HELLINGER
```
  enum cv::HistCompMethods
  
  See Also:
  Constant Field Values
- HISTCMP_CHISQR_ALT
```
public static final int HISTCMP_CHISQR_ALT
```
  enum cv::HistCompMethods
  
  See Also:
  Constant Field Values
- HISTCMP_KL_DIV
```
public static final int HISTCMP_KL_DIV
```
  enum cv::HistCompMethods
  
  See Also:
  Constant Field Values
- COLOR_BGR2BGRA
```
public static final int COLOR_BGR2BGRA
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_RGB2RGBA
```
public static final int COLOR_RGB2RGBA
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_BGRA2BGR
```
public static final int COLOR_BGRA2BGR
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_RGBA2RGB
```
public static final int COLOR_RGBA2RGB
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_BGR2RGBA
```
public static final int COLOR_BGR2RGBA
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_RGB2BGRA
```
public static final int COLOR_RGB2BGRA
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_RGBA2BGR
```
public static final int COLOR_RGBA2BGR
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_BGRA2RGB
```
public static final int COLOR_BGRA2RGB
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_BGR2RGB
```
public static final int COLOR_BGR2RGB
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_RGB2BGR
```
public static final int COLOR_RGB2BGR
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_BGRA2RGBA
```
public static final int COLOR_BGRA2RGBA
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_RGBA2BGRA
```
public static final int COLOR_RGBA2BGRA
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_BGR2GRAY
```
public static final int COLOR_BGR2GRAY
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_RGB2GRAY
```
public static final int COLOR_RGB2GRAY
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_GRAY2BGR
```
public static final int COLOR_GRAY2BGR
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_GRAY2RGB
```
public static final int COLOR_GRAY2RGB
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_GRAY2BGRA
```
public static final int COLOR_GRAY2BGRA
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_GRAY2RGBA
```
public static final int COLOR_GRAY2RGBA
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_BGRA2GRAY
```
public static final int COLOR_BGRA2GRAY
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_RGBA2GRAY
```
public static final int COLOR_RGBA2GRAY
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_BGR2BGR565
```
public static final int COLOR_BGR2BGR565
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_RGB2BGR565
```
public static final int COLOR_RGB2BGR565
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_BGR5652BGR
```
public static final int COLOR_BGR5652BGR
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_BGR5652RGB
```
public static final int COLOR_BGR5652RGB
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_BGRA2BGR565
```
public static final int COLOR_BGRA2BGR565
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_RGBA2BGR565
```
public static final int COLOR_RGBA2BGR565
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_BGR5652BGRA
```
public static final int COLOR_BGR5652BGRA
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_BGR5652RGBA
```
public static final int COLOR_BGR5652RGBA
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_GRAY2BGR565
```
public static final int COLOR_GRAY2BGR565
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_BGR5652GRAY
```
public static final int COLOR_BGR5652GRAY
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_BGR2BGR555
```
public static final int COLOR_BGR2BGR555
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_RGB2BGR555
```
public static final int COLOR_RGB2BGR555
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_BGR5552BGR
```
public static final int COLOR_BGR5552BGR
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_BGR5552RGB
```
public static final int COLOR_BGR5552RGB
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_BGRA2BGR555
```
public static final int COLOR_BGRA2BGR555
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_RGBA2BGR555
```
public static final int COLOR_RGBA2BGR555
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_BGR5552BGRA
```
public static final int COLOR_BGR5552BGRA
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_BGR5552RGBA
```
public static final int COLOR_BGR5552RGBA
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_GRAY2BGR555
```
public static final int COLOR_GRAY2BGR555
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_BGR5552GRAY
```
public static final int COLOR_BGR5552GRAY
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_BGR2XYZ
```
public static final int COLOR_BGR2XYZ
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_RGB2XYZ
```
public static final int COLOR_RGB2XYZ
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_XYZ2BGR
```
public static final int COLOR_XYZ2BGR
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_XYZ2RGB
```
public static final int COLOR_XYZ2RGB
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_BGR2YCrCb
```
public static final int COLOR_BGR2YCrCb
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_RGB2YCrCb
```
public static final int COLOR_RGB2YCrCb
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_YCrCb2BGR
```
public static final int COLOR_YCrCb2BGR
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_YCrCb2RGB
```
public static final int COLOR_YCrCb2RGB
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_BGR2HSV
```
public static final int COLOR_BGR2HSV
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_RGB2HSV
```
public static final int COLOR_RGB2HSV
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_BGR2Lab
```
public static final int COLOR_BGR2Lab
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_RGB2Lab
```
public static final int COLOR_RGB2Lab
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_BGR2Luv
```
public static final int COLOR_BGR2Luv
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_RGB2Luv
```
public static final int COLOR_RGB2Luv
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_BGR2HLS
```
public static final int COLOR_BGR2HLS
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_RGB2HLS
```
public static final int COLOR_RGB2HLS
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_HSV2BGR
```
public static final int COLOR_HSV2BGR
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_HSV2RGB
```
public static final int COLOR_HSV2RGB
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_Lab2BGR
```
public static final int COLOR_Lab2BGR
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_Lab2RGB
```
public static final int COLOR_Lab2RGB
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_Luv2BGR
```
public static final int COLOR_Luv2BGR
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_Luv2RGB
```
public static final int COLOR_Luv2RGB
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_HLS2BGR
```
public static final int COLOR_HLS2BGR
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_HLS2RGB
```
public static final int COLOR_HLS2RGB
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_BGR2HSV_FULL
```
public static final int COLOR_BGR2HSV_FULL
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_RGB2HSV_FULL
```
public static final int COLOR_RGB2HSV_FULL
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_BGR2HLS_FULL
```
public static final int COLOR_BGR2HLS_FULL
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_RGB2HLS_FULL
```
public static final int COLOR_RGB2HLS_FULL
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_HSV2BGR_FULL
```
public static final int COLOR_HSV2BGR_FULL
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_HSV2RGB_FULL
```
public static final int COLOR_HSV2RGB_FULL
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_HLS2BGR_FULL
```
public static final int COLOR_HLS2BGR_FULL
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_HLS2RGB_FULL
```
public static final int COLOR_HLS2RGB_FULL
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_LBGR2Lab
```
public static final int COLOR_LBGR2Lab
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_LRGB2Lab
```
public static final int COLOR_LRGB2Lab
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_LBGR2Luv
```
public static final int COLOR_LBGR2Luv
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_LRGB2Luv
```
public static final int COLOR_LRGB2Luv
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_Lab2LBGR
```
public static final int COLOR_Lab2LBGR
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_Lab2LRGB
```
public static final int COLOR_Lab2LRGB
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_Luv2LBGR
```
public static final int COLOR_Luv2LBGR
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_Luv2LRGB
```
public static final int COLOR_Luv2LRGB
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_BGR2YUV
```
public static final int COLOR_BGR2YUV
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_RGB2YUV
```
public static final int COLOR_RGB2YUV
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_YUV2BGR
```
public static final int COLOR_YUV2BGR
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_YUV2RGB
```
public static final int COLOR_YUV2RGB
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_YUV2RGB_NV12
```
public static final int COLOR_YUV2RGB_NV12
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_YUV2BGR_NV12
```
public static final int COLOR_YUV2BGR_NV12
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_YUV2RGB_NV21
```
public static final int COLOR_YUV2RGB_NV21
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_YUV2BGR_NV21
```
public static final int COLOR_YUV2BGR_NV21
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_YUV420sp2RGB
```
public static final int COLOR_YUV420sp2RGB
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_YUV420sp2BGR
```
public static final int COLOR_YUV420sp2BGR
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_YUV2RGBA_NV12
```
public static final int COLOR_YUV2RGBA_NV12
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_YUV2BGRA_NV12
```
public static final int COLOR_YUV2BGRA_NV12
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_YUV2RGBA_NV21
```
public static final int COLOR_YUV2RGBA_NV21
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_YUV2BGRA_NV21
```
public static final int COLOR_YUV2BGRA_NV21
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_YUV420sp2RGBA
```
public static final int COLOR_YUV420sp2RGBA
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_YUV420sp2BGRA
```
public static final int COLOR_YUV420sp2BGRA
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_YUV2RGB_YV12
```
public static final int COLOR_YUV2RGB_YV12
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_YUV2BGR_YV12
```
public static final int COLOR_YUV2BGR_YV12
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_YUV2RGB_IYUV
```
public static final int COLOR_YUV2RGB_IYUV
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_YUV2BGR_IYUV
```
public static final int COLOR_YUV2BGR_IYUV
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_YUV2RGB_I420
```
public static final int COLOR_YUV2RGB_I420
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_YUV2BGR_I420
```
public static final int COLOR_YUV2BGR_I420
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_YUV420p2RGB
```
public static final int COLOR_YUV420p2RGB
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_YUV420p2BGR
```
public static final int COLOR_YUV420p2BGR
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_YUV2RGBA_YV12
```
public static final int COLOR_YUV2RGBA_YV12
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_YUV2BGRA_YV12
```
public static final int COLOR_YUV2BGRA_YV12
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_YUV2RGBA_IYUV
```
public static final int COLOR_YUV2RGBA_IYUV
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_YUV2BGRA_IYUV
```
public static final int COLOR_YUV2BGRA_IYUV
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_YUV2RGBA_I420
```
public static final int COLOR_YUV2RGBA_I420
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_YUV2BGRA_I420
```
public static final int COLOR_YUV2BGRA_I420
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_YUV420p2RGBA
```
public static final int COLOR_YUV420p2RGBA
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_YUV420p2BGRA
```
public static final int COLOR_YUV420p2BGRA
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_YUV2GRAY_420
```
public static final int COLOR_YUV2GRAY_420
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_YUV2GRAY_NV21
```
public static final int COLOR_YUV2GRAY_NV21
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_YUV2GRAY_NV12
```
public static final int COLOR_YUV2GRAY_NV12
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_YUV2GRAY_YV12
```
public static final int COLOR_YUV2GRAY_YV12
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_YUV2GRAY_IYUV
```
public static final int COLOR_YUV2GRAY_IYUV
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_YUV2GRAY_I420
```
public static final int COLOR_YUV2GRAY_I420
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_YUV420sp2GRAY
```
public static final int COLOR_YUV420sp2GRAY
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_YUV420p2GRAY
```
public static final int COLOR_YUV420p2GRAY
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_YUV2RGB_UYVY
```
public static final int COLOR_YUV2RGB_UYVY
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_YUV2BGR_UYVY
```
public static final int COLOR_YUV2BGR_UYVY
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_YUV2RGB_Y422
```
public static final int COLOR_YUV2RGB_Y422
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_YUV2BGR_Y422
```
public static final int COLOR_YUV2BGR_Y422
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_YUV2RGB_UYNV
```
public static final int COLOR_YUV2RGB_UYNV
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_YUV2BGR_UYNV
```
public static final int COLOR_YUV2BGR_UYNV
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_YUV2RGBA_UYVY
```
public static final int COLOR_YUV2RGBA_UYVY
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_YUV2BGRA_UYVY
```
public static final int COLOR_YUV2BGRA_UYVY
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_YUV2RGBA_Y422
```
public static final int COLOR_YUV2RGBA_Y422
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_YUV2BGRA_Y422
```
public static final int COLOR_YUV2BGRA_Y422
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_YUV2RGBA_UYNV
```
public static final int COLOR_YUV2RGBA_UYNV
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_YUV2BGRA_UYNV
```
public static final int COLOR_YUV2BGRA_UYNV
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_YUV2RGB_YUY2
```
public static final int COLOR_YUV2RGB_YUY2
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_YUV2BGR_YUY2
```
public static final int COLOR_YUV2BGR_YUY2
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_YUV2RGB_YVYU
```
public static final int COLOR_YUV2RGB_YVYU
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_YUV2BGR_YVYU
```
public static final int COLOR_YUV2BGR_YVYU
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_YUV2RGB_YUYV
```
public static final int COLOR_YUV2RGB_YUYV
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_YUV2BGR_YUYV
```
public static final int COLOR_YUV2BGR_YUYV
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_YUV2RGB_YUNV
```
public static final int COLOR_YUV2RGB_YUNV
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_YUV2BGR_YUNV
```
public static final int COLOR_YUV2BGR_YUNV
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_YUV2RGBA_YUY2
```
public static final int COLOR_YUV2RGBA_YUY2
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_YUV2BGRA_YUY2
```
public static final int COLOR_YUV2BGRA_YUY2
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_YUV2RGBA_YVYU
```
public static final int COLOR_YUV2RGBA_YVYU
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_YUV2BGRA_YVYU
```
public static final int COLOR_YUV2BGRA_YVYU
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_YUV2RGBA_YUYV
```
public static final int COLOR_YUV2RGBA_YUYV
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_YUV2BGRA_YUYV
```
public static final int COLOR_YUV2BGRA_YUYV
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_YUV2RGBA_YUNV
```
public static final int COLOR_YUV2RGBA_YUNV
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_YUV2BGRA_YUNV
```
public static final int COLOR_YUV2BGRA_YUNV
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_YUV2GRAY_UYVY
```
public static final int COLOR_YUV2GRAY_UYVY
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_YUV2GRAY_YUY2
```
public static final int COLOR_YUV2GRAY_YUY2
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_YUV2GRAY_Y422
```
public static final int COLOR_YUV2GRAY_Y422
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_YUV2GRAY_UYNV
```
public static final int COLOR_YUV2GRAY_UYNV
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_YUV2GRAY_YVYU
```
public static final int COLOR_YUV2GRAY_YVYU
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_YUV2GRAY_YUYV
```
public static final int COLOR_YUV2GRAY_YUYV
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_YUV2GRAY_YUNV
```
public static final int COLOR_YUV2GRAY_YUNV
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_RGBA2mRGBA
```
public static final int COLOR_RGBA2mRGBA
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_mRGBA2RGBA
```
public static final int COLOR_mRGBA2RGBA
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_RGB2YUV_I420
```
public static final int COLOR_RGB2YUV_I420
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_BGR2YUV_I420
```
public static final int COLOR_BGR2YUV_I420
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_RGB2YUV_IYUV
```
public static final int COLOR_RGB2YUV_IYUV
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_BGR2YUV_IYUV
```
public static final int COLOR_BGR2YUV_IYUV
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_RGBA2YUV_I420
```
public static final int COLOR_RGBA2YUV_I420
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_BGRA2YUV_I420
```
public static final int COLOR_BGRA2YUV_I420
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_RGBA2YUV_IYUV
```
public static final int COLOR_RGBA2YUV_IYUV
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_BGRA2YUV_IYUV
```
public static final int COLOR_BGRA2YUV_IYUV
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_RGB2YUV_YV12
```
public static final int COLOR_RGB2YUV_YV12
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_BGR2YUV_YV12
```
public static final int COLOR_BGR2YUV_YV12
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_RGBA2YUV_YV12
```
public static final int COLOR_RGBA2YUV_YV12
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_BGRA2YUV_YV12
```
public static final int COLOR_BGRA2YUV_YV12
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_BayerBG2BGR
```
public static final int COLOR_BayerBG2BGR
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_BayerGB2BGR
```
public static final int COLOR_BayerGB2BGR
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_BayerRG2BGR
```
public static final int COLOR_BayerRG2BGR
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_BayerGR2BGR
```
public static final int COLOR_BayerGR2BGR
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_BayerBG2RGB
```
public static final int COLOR_BayerBG2RGB
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_BayerGB2RGB
```
public static final int COLOR_BayerGB2RGB
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_BayerRG2RGB
```
public static final int COLOR_BayerRG2RGB
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_BayerGR2RGB
```
public static final int COLOR_BayerGR2RGB
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_BayerBG2GRAY
```
public static final int COLOR_BayerBG2GRAY
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_BayerGB2GRAY
```
public static final int COLOR_BayerGB2GRAY
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_BayerRG2GRAY
```
public static final int COLOR_BayerRG2GRAY
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_BayerGR2GRAY
```
public static final int COLOR_BayerGR2GRAY
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_BayerBG2BGR_VNG
```
public static final int COLOR_BayerBG2BGR_VNG
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_BayerGB2BGR_VNG
```
public static final int COLOR_BayerGB2BGR_VNG
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_BayerRG2BGR_VNG
```
public static final int COLOR_BayerRG2BGR_VNG
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_BayerGR2BGR_VNG
```
public static final int COLOR_BayerGR2BGR_VNG
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_BayerBG2RGB_VNG
```
public static final int COLOR_BayerBG2RGB_VNG
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_BayerGB2RGB_VNG
```
public static final int COLOR_BayerGB2RGB_VNG
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_BayerRG2RGB_VNG
```
public static final int COLOR_BayerRG2RGB_VNG
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_BayerGR2RGB_VNG
```
public static final int COLOR_BayerGR2RGB_VNG
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_BayerBG2BGR_EA
```
public static final int COLOR_BayerBG2BGR_EA
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_BayerGB2BGR_EA
```
public static final int COLOR_BayerGB2BGR_EA
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_BayerRG2BGR_EA
```
public static final int COLOR_BayerRG2BGR_EA
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_BayerGR2BGR_EA
```
public static final int COLOR_BayerGR2BGR_EA
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_BayerBG2RGB_EA
```
public static final int COLOR_BayerBG2RGB_EA
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_BayerGB2RGB_EA
```
public static final int COLOR_BayerGB2RGB_EA
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_BayerRG2RGB_EA
```
public static final int COLOR_BayerRG2RGB_EA
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_BayerGR2RGB_EA
```
public static final int COLOR_BayerGR2RGB_EA
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- COLOR_COLORCVT_MAX
```
public static final int COLOR_COLORCVT_MAX
```
  enum cv::ColorConversionCodes
  
  See Also:
  Constant Field Values
- INTERSECT_NONE
```
public static final int INTERSECT_NONE
```
  enum cv::RectanglesIntersectTypes
  
  See Also:
  Constant Field Values
- INTERSECT_PARTIAL
```
public static final int INTERSECT_PARTIAL
```
  enum cv::RectanglesIntersectTypes
  
  See Also:
  Constant Field Values
- INTERSECT_FULL
```
public static final int INTERSECT_FULL
```
  enum cv::RectanglesIntersectTypes
  
  See Also:
  Constant Field Values
- TM_SQDIFF
```
public static final int TM_SQDIFF
```
  enum cv::TemplateMatchModes
  
  See Also:
  Constant Field Values
- TM_SQDIFF_NORMED
```
public static final int TM_SQDIFF_NORMED
```
  enum cv::TemplateMatchModes
  
  See Also:
  Constant Field Values
- TM_CCORR
```
public static final int TM_CCORR
```
  enum cv::TemplateMatchModes
  
  See Also:
  Constant Field Values
- TM_CCORR_NORMED
```
public static final int TM_CCORR_NORMED
```
  enum cv::TemplateMatchModes
  
  See Also:
  Constant Field Values
- TM_CCOEFF
```
public static final int TM_CCOEFF
```
  enum cv::TemplateMatchModes
  
  See Also:
  Constant Field Values
- TM_CCOEFF_NORMED
```
public static final int TM_CCOEFF_NORMED
```
  enum cv::TemplateMatchModes
  
  See Also:
  Constant Field Values
- COLORMAP_AUTUMN
```
public static final int COLORMAP_AUTUMN
```
  enum cv::ColormapTypes
  
  See Also:
  Constant Field Values
- COLORMAP_BONE
```
public static final int COLORMAP_BONE
```
  enum cv::ColormapTypes
  
  See Also:
  Constant Field Values
- COLORMAP_JET
```
public static final int COLORMAP_JET
```
  enum cv::ColormapTypes
  
  See Also:
  Constant Field Values
- COLORMAP_WINTER
```
public static final int COLORMAP_WINTER
```
  enum cv::ColormapTypes
  
  See Also:
  Constant Field Values
- COLORMAP_RAINBOW
```
public static final int COLORMAP_RAINBOW
```
  enum cv::ColormapTypes
  
  See Also:
  Constant Field Values
- COLORMAP_OCEAN
```
public static final int COLORMAP_OCEAN
```
  enum cv::ColormapTypes
  
  See Also:
  Constant Field Values
- COLORMAP_SUMMER
```
public static final int COLORMAP_SUMMER
```
  enum cv::ColormapTypes
  
  See Also:
  Constant Field Values
- COLORMAP_SPRING
```
public static final int COLORMAP_SPRING
```
  enum cv::ColormapTypes
  
  See Also:
  Constant Field Values
- COLORMAP_COOL
```
public static final int COLORMAP_COOL
```
  enum cv::ColormapTypes
  
  See Also:
  Constant Field Values
- COLORMAP_HSV
```
public static final int COLORMAP_HSV
```
  enum cv::ColormapTypes
  
  See Also:
  Constant Field Values
- COLORMAP_PINK
```
public static final int COLORMAP_PINK
```
  enum cv::ColormapTypes
  
  See Also:
  Constant Field Values
- COLORMAP_HOT
```
public static final int COLORMAP_HOT
```
  enum cv::ColormapTypes
  
  See Also:
  Constant Field Values
- COLORMAP_PARULA
```
public static final int COLORMAP_PARULA
```
  enum cv::ColormapTypes
  
  See Also:
  Constant Field Values
- MARKER_CROSS
```
public static final int MARKER_CROSS
```
  enum cv::MarkerTypes
  
  See Also:
  Constant Field Values
- MARKER_TILTED_CROSS
```
public static final int MARKER_TILTED_CROSS
```
  enum cv::MarkerTypes
  
  See Also:
  Constant Field Values
- MARKER_STAR
```
public static final int MARKER_STAR
```
  enum cv::MarkerTypes
  
  See Also:
  Constant Field Values
- MARKER_DIAMOND
```
public static final int MARKER_DIAMOND
```
  enum cv::MarkerTypes
  
  See Also:
  Constant Field Values
- MARKER_SQUARE
```
public static final int MARKER_SQUARE
```
  enum cv::MarkerTypes
  
  See Also:
  Constant Field Values
- MARKER_TRIANGLE_UP
```
public static final int MARKER_TRIANGLE_UP
```
  enum cv::MarkerTypes
  
  See Also:
  Constant Field Values
- MARKER_TRIANGLE_DOWN
```
public static final int MARKER_TRIANGLE_DOWN
```
  enum cv::MarkerTypes
  
  See Also:
  Constant Field Values

Constructor Detail
- opencv_imgproc
```
public opencv_imgproc()
```

Method Detail

cvAcc

public static void cvAcc(@Const
         opencv_core.CvArr image,
         opencv_core.CvArr sum,
         @Const
         opencv_core.CvArr mask)

\brief Adds image to accumulator

See Also:: cv::accumulate

cvAcc

public static void cvAcc(@Const
         opencv_core.CvArr image,
         opencv_core.CvArr sum)

cvSquareAcc

public static void cvSquareAcc(@Const
               opencv_core.CvArr image,
               opencv_core.CvArr sqsum,
               @Const
               opencv_core.CvArr mask)

\brief Adds squared image to accumulator

See Also:: cv::accumulateSquare

cvSquareAcc

public static void cvSquareAcc(@Const
               opencv_core.CvArr image,
               opencv_core.CvArr sqsum)

cvMultiplyAcc

public static void cvMultiplyAcc(@Const
                 opencv_core.CvArr image1,
                 @Const
                 opencv_core.CvArr image2,
                 opencv_core.CvArr acc,
                 @Const
                 opencv_core.CvArr mask)

\brief Adds a product of two images to accumulator

See Also:: cv::accumulateProduct

cvMultiplyAcc

public static void cvMultiplyAcc(@Const
                 opencv_core.CvArr image1,
                 @Const
                 opencv_core.CvArr image2,
                 opencv_core.CvArr acc)

cvRunningAvg

public static void cvRunningAvg(@Const
                opencv_core.CvArr image,
                opencv_core.CvArr acc,
                double alpha,
                @Const
                opencv_core.CvArr mask)

\brief Adds image to accumulator with weights: acc = acc*(1-alpha) + image*alpha

See Also:: cv::accumulateWeighted

cvRunningAvg

public static void cvRunningAvg(@Const
                opencv_core.CvArr image,
                opencv_core.CvArr acc,
                double alpha)

cvCopyMakeBorder

public static void cvCopyMakeBorder(@Const
                    opencv_core.CvArr src,
                    opencv_core.CvArr dst,
                    @ByVal
                    opencv_core.CvPoint offset,
                    int bordertype,
                    @ByVal(nullValue="cvScalarAll(0)")
                    opencv_core.CvScalar value)

Copies source 2D array inside of the larger destination array and makes a border of the specified type (IPL_BORDER_*) around the copied area.

cvCopyMakeBorder

public static void cvCopyMakeBorder(@Const
                    opencv_core.CvArr src,
                    opencv_core.CvArr dst,
                    @ByVal
                    opencv_core.CvPoint offset,
                    int bordertype)

cvCopyMakeBorder

public static void cvCopyMakeBorder(@Const
                    opencv_core.CvArr src,
                    opencv_core.CvArr dst,
                    @ByVal@Cast(value="CvPoint*")
                    IntBuffer offset,
                    int bordertype,
                    @ByVal(nullValue="cvScalarAll(0)")
                    opencv_core.CvScalar value)

cvCopyMakeBorder

public static void cvCopyMakeBorder(@Const
                    opencv_core.CvArr src,
                    opencv_core.CvArr dst,
                    @ByVal@Cast(value="CvPoint*")
                    IntBuffer offset,
                    int bordertype)

cvCopyMakeBorder

public static void cvCopyMakeBorder(@Const
                    opencv_core.CvArr src,
                    opencv_core.CvArr dst,
                    @ByVal@Cast(value="CvPoint*")
                    int[] offset,
                    int bordertype,
                    @ByVal(nullValue="cvScalarAll(0)")
                    opencv_core.CvScalar value)

cvCopyMakeBorder

public static void cvCopyMakeBorder(@Const
                    opencv_core.CvArr src,
                    opencv_core.CvArr dst,
                    @ByVal@Cast(value="CvPoint*")
                    int[] offset,
                    int bordertype)

cvSmooth
```
public static void cvSmooth(@Const
            opencv_core.CvArr src,
            opencv_core.CvArr dst,
            int smoothtype,
            int size1,
            int size2,
            double sigma1,
            double sigma2)
```
\brief Smooths the image in one of several ways.

Parameters:
src - The source image
dst - The destination image
smoothtype - Type of the smoothing, see SmoothMethod_c
size1 - The first parameter of the smoothing operation, the aperture width. Must be a positive odd number (1, 3, 5, ...)
size2 - The second parameter of the smoothing operation, the aperture height. Ignored by CV_MEDIAN and CV_BILATERAL methods. In the case of simple scaled/non-scaled and Gaussian blur if size2 is zero, it is set to size1. Otherwise it must be a positive odd number.
sigma1 - In the case of a Gaussian parameter this parameter may specify Gaussian \f$\sigma\f$ (standard deviation). If it is zero, it is calculated from the kernel size: \f[\sigma = 0.3 (n/2 - 1) + 0.8 \quad \text{where} \quad n= \begin{array}{l l} \mbox{\texttt{size1} for horizontal kernel} \\ \mbox{\texttt{size2} for vertical kernel} \end{array}\f] Using standard sigma for small kernels ( \f$3\times 3\f$ to \f$7\times 7\f$ ) gives better speed. If sigma1 is not zero, while size1 and size2 are zeros, the kernel size is calculated from the sigma (to provide accurate enough operation).
sigma2 - additional parameter for bilateral filtering
See Also:
cv::GaussianBlur, cv::blur, cv::medianBlur, cv::bilateralFilter.

cvSmooth

public static void cvSmooth(@Const
            opencv_core.CvArr src,
            opencv_core.CvArr dst)

cvFilter2D
```
public static void cvFilter2D(@Const
              opencv_core.CvArr src,
              opencv_core.CvArr dst,
              @Const
              opencv_core.CvMat kernel,
              @ByVal(nullValue="cvPoint(-1,-1)")
              opencv_core.CvPoint anchor)
```
\brief Convolves an image with the kernel.

Parameters:
src - input image.
dst - output image of the same size and the same number of channels as src.
kernel - convolution kernel (or rather a correlation kernel), a single-channel floating point matrix; if you want to apply different kernels to different channels, split the image into separate color planes using split and process them individually.
anchor - anchor of the kernel that indicates the relative position of a filtered point within the kernel; the anchor should lie within the kernel; default value (-1,-1) means that the anchor is at the kernel center.
See Also:
cv::filter2D

cvFilter2D

public static void cvFilter2D(@Const
              opencv_core.CvArr src,
              opencv_core.CvArr dst,
              @Const
              opencv_core.CvMat kernel)

cvFilter2D

public static void cvFilter2D(@Const
              opencv_core.CvArr src,
              opencv_core.CvArr dst,
              @Const
              opencv_core.CvMat kernel,
              @ByVal(nullValue="cvPoint(-1,-1)")@Cast(value="CvPoint*")
              IntBuffer anchor)

cvFilter2D

public static void cvFilter2D(@Const
              opencv_core.CvArr src,
              opencv_core.CvArr dst,
              @Const
              opencv_core.CvMat kernel,
              @ByVal(nullValue="cvPoint(-1,-1)")@Cast(value="CvPoint*")
              int[] anchor)

cvIntegral

public static void cvIntegral(@Const
              opencv_core.CvArr image,
              opencv_core.CvArr sum,
              opencv_core.CvArr sqsum,
              opencv_core.CvArr tilted_sum)

\brief Finds integral image: SUM(X,Y) = sum(x

See Also:: cv::integral

cvIntegral

public static void cvIntegral(@Const
              opencv_core.CvArr image,
              opencv_core.CvArr sum)

cvPyrDown
```
public static void cvPyrDown(@Const
             opencv_core.CvArr src,
             opencv_core.CvArr dst,
             int filter)
```
\brief Smoothes the input image with gaussian kernel and then down-samples it.
dst_width = floor(src_width/2)[+1], dst_height = floor(src_height/2)[+1]

See Also:
cv::pyrDown

cvPyrDown

public static void cvPyrDown(@Const
             opencv_core.CvArr src,
             opencv_core.CvArr dst)

cvPyrUp

public static void cvPyrUp(@Const
           opencv_core.CvArr src,
           opencv_core.CvArr dst,
           int filter)

\brief Up-samples image and smoothes the result with gaussian kernel.

dst_width = src_width*2, dst_height = src_height*2

See Also:: cv::pyrUp

cvPyrUp

public static void cvPyrUp(@Const
           opencv_core.CvArr src,
           opencv_core.CvArr dst)

cvCreatePyramid

@Cast(value="CvMat**")
public static PointerPointer cvCreatePyramid(@Const
                                       opencv_core.CvArr img,
                                       int extra_layers,
                                       double rate,
                                       @Const
                                       opencv_core.CvSize layer_sizes,
                                       opencv_core.CvArr bufarr,
                                       int calc,
                                       int filter)

\brief Builds pyramid for an image

See Also:: buildPyramid

cvCreatePyramid

@ByPtrPtr
public static opencv_core.CvMat cvCreatePyramid(@Const
                                         opencv_core.CvArr img,
                                         int extra_layers,
                                         double rate)

cvReleasePyramid

public static void cvReleasePyramid(@Cast(value="CvMat***")
                    PointerPointer pyramid,
                    int extra_layers)

\brief Releases pyramid

cvPyrMeanShiftFiltering

public static void cvPyrMeanShiftFiltering(@Const
                           opencv_core.CvArr src,
                           opencv_core.CvArr dst,
                           double sp,
                           double sr,
                           int max_level,
                           @ByVal(nullValue="cvTermCriteria(CV_TERMCRIT_ITER+CV_TERMCRIT_EPS,5,1)")
                           opencv_core.CvTermCriteria termcrit)

\brief Filters image using meanshift algorithm

See Also:: cv::pyrMeanShiftFiltering

cvPyrMeanShiftFiltering

public static void cvPyrMeanShiftFiltering(@Const
                           opencv_core.CvArr src,
                           opencv_core.CvArr dst,
                           double sp,
                           double sr)

cvWatershed

public static void cvWatershed(@Const
               opencv_core.CvArr image,
               opencv_core.CvArr markers)

\brief Segments image using seed "markers"

See Also:: cv::watershed

cvSobel
```
public static void cvSobel(@Const
           opencv_core.CvArr src,
           opencv_core.CvArr dst,
           int xorder,
           int yorder,
           int aperture_size)
```
\brief Calculates an image derivative using generalized Sobel
(aperture_size = 1,3,5,7) or Scharr (aperture_size = -1) operator. Scharr can be used only for the first dx or dy derivative

See Also:
cv::Sobel

cvSobel

public static void cvSobel(@Const
           opencv_core.CvArr src,
           opencv_core.CvArr dst,
           int xorder,
           int yorder)

cvLaplace

public static void cvLaplace(@Const
             opencv_core.CvArr src,
             opencv_core.CvArr dst,
             int aperture_size)

\brief Calculates the image Laplacian: (d2/dx + d2/dy)I

See Also:: cv::Laplacian

cvLaplace

public static void cvLaplace(@Const
             opencv_core.CvArr src,
             opencv_core.CvArr dst)

cvCvtColor

public static void cvCvtColor(@Const
              opencv_core.CvArr src,
              opencv_core.CvArr dst,
              int code)

\brief Converts input array pixels from one color space to another

See Also:: cv::cvtColor

cvResize

public static void cvResize(@Const
            opencv_core.CvArr src,
            opencv_core.CvArr dst,
            int interpolation)

\brief Resizes image (input array is resized to fit the destination array)

See Also:: cv::resize

cvResize

public static void cvResize(@Const
            opencv_core.CvArr src,
            opencv_core.CvArr dst)

cvWarpAffine

public static void cvWarpAffine(@Const
                opencv_core.CvArr src,
                opencv_core.CvArr dst,
                @Const
                opencv_core.CvMat map_matrix,
                int flags,
                @ByVal(nullValue="cvScalarAll(0)")
                opencv_core.CvScalar fillval)

\brief Warps image with affine transform \note ::cvGetQuadrangleSubPix is similar to ::cvWarpAffine, but the outliers are extrapolated using replication border mode.

See Also:: cv::warpAffine

cvWarpAffine

public static void cvWarpAffine(@Const
                opencv_core.CvArr src,
                opencv_core.CvArr dst,
                @Const
                opencv_core.CvMat map_matrix)

cvGetAffineTransform

public static opencv_core.CvMat cvGetAffineTransform(@Const
                                     opencv_core.CvPoint2D32f src,
                                     @Const
                                     opencv_core.CvPoint2D32f dst,
                                     opencv_core.CvMat map_matrix)

\brief Computes affine transform matrix for mapping src[i] to dst[i] (i=0,1,2)

See Also:: cv::getAffineTransform

cvGetAffineTransform

public static opencv_core.CvMat cvGetAffineTransform(@Cast(value="const CvPoint2D32f*")
                                     FloatBuffer src,
                                     @Cast(value="const CvPoint2D32f*")
                                     FloatBuffer dst,
                                     opencv_core.CvMat map_matrix)

cvGetAffineTransform

public static opencv_core.CvMat cvGetAffineTransform(@Cast(value="const CvPoint2D32f*")
                                     float[] src,
                                     @Cast(value="const CvPoint2D32f*")
                                     float[] dst,
                                     opencv_core.CvMat map_matrix)

cv2DRotationMatrix

public static opencv_core.CvMat cv2DRotationMatrix(@ByVal
                                   opencv_core.CvPoint2D32f center,
                                   double angle,
                                   double scale,
                                   opencv_core.CvMat map_matrix)

\brief Computes rotation_matrix matrix

See Also:: cv::getRotationMatrix2D

cv2DRotationMatrix

public static opencv_core.CvMat cv2DRotationMatrix(@ByVal@Cast(value="CvPoint2D32f*")
                                   FloatBuffer center,
                                   double angle,
                                   double scale,
                                   opencv_core.CvMat map_matrix)

cv2DRotationMatrix

public static opencv_core.CvMat cv2DRotationMatrix(@ByVal@Cast(value="CvPoint2D32f*")
                                   float[] center,
                                   double angle,
                                   double scale,
                                   opencv_core.CvMat map_matrix)

cvWarpPerspective

public static void cvWarpPerspective(@Const
                     opencv_core.CvArr src,
                     opencv_core.CvArr dst,
                     @Const
                     opencv_core.CvMat map_matrix,
                     int flags,
                     @ByVal(nullValue="cvScalarAll(0)")
                     opencv_core.CvScalar fillval)

\brief Warps image with perspective (projective) transform

See Also:: cv::warpPerspective

cvWarpPerspective

public static void cvWarpPerspective(@Const
                     opencv_core.CvArr src,
                     opencv_core.CvArr dst,
                     @Const
                     opencv_core.CvMat map_matrix)

cvGetPerspectiveTransform

public static opencv_core.CvMat cvGetPerspectiveTransform(@Const
                                          opencv_core.CvPoint2D32f src,
                                          @Const
                                          opencv_core.CvPoint2D32f dst,
                                          opencv_core.CvMat map_matrix)

\brief Computes perspective transform matrix for mapping src[i] to dst[i] (i=0,1,2,3)

See Also:: cv::getPerspectiveTransform

cvGetPerspectiveTransform

public static opencv_core.CvMat cvGetPerspectiveTransform(@Cast(value="const CvPoint2D32f*")
                                          FloatBuffer src,
                                          @Cast(value="const CvPoint2D32f*")
                                          FloatBuffer dst,
                                          opencv_core.CvMat map_matrix)

cvGetPerspectiveTransform

public static opencv_core.CvMat cvGetPerspectiveTransform(@Cast(value="const CvPoint2D32f*")
                                          float[] src,
                                          @Cast(value="const CvPoint2D32f*")
                                          float[] dst,
                                          opencv_core.CvMat map_matrix)

cvRemap

public static void cvRemap(@Const
           opencv_core.CvArr src,
           opencv_core.CvArr dst,
           @Const
           opencv_core.CvArr mapx,
           @Const
           opencv_core.CvArr mapy,
           int flags,
           @ByVal(nullValue="cvScalarAll(0)")
           opencv_core.CvScalar fillval)

\brief Performs generic geometric transformation using the specified coordinate maps

See Also:: cv::remap

cvRemap

public static void cvRemap(@Const
           opencv_core.CvArr src,
           opencv_core.CvArr dst,
           @Const
           opencv_core.CvArr mapx,
           @Const
           opencv_core.CvArr mapy)

cvConvertMaps

public static void cvConvertMaps(@Const
                 opencv_core.CvArr mapx,
                 @Const
                 opencv_core.CvArr mapy,
                 opencv_core.CvArr mapxy,
                 opencv_core.CvArr mapalpha)

\brief Converts mapx & mapy from floating-point to integer formats for cvRemap

See Also:: cv::convertMaps

cvLogPolar

public static void cvLogPolar(@Const
              opencv_core.CvArr src,
              opencv_core.CvArr dst,
              @ByVal
              opencv_core.CvPoint2D32f center,
              double M,
              int flags)

\brief Performs forward or inverse log-polar image transform

See Also:: cv::logPolar

cvLogPolar

public static void cvLogPolar(@Const
              opencv_core.CvArr src,
              opencv_core.CvArr dst,
              @ByVal
              opencv_core.CvPoint2D32f center,
              double M)

cvLogPolar

public static void cvLogPolar(@Const
              opencv_core.CvArr src,
              opencv_core.CvArr dst,
              @ByVal@Cast(value="CvPoint2D32f*")
              FloatBuffer center,
              double M,
              int flags)

cvLogPolar

public static void cvLogPolar(@Const
              opencv_core.CvArr src,
              opencv_core.CvArr dst,
              @ByVal@Cast(value="CvPoint2D32f*")
              FloatBuffer center,
              double M)

cvLogPolar

public static void cvLogPolar(@Const
              opencv_core.CvArr src,
              opencv_core.CvArr dst,
              @ByVal@Cast(value="CvPoint2D32f*")
              float[] center,
              double M,
              int flags)

cvLogPolar

public static void cvLogPolar(@Const
              opencv_core.CvArr src,
              opencv_core.CvArr dst,
              @ByVal@Cast(value="CvPoint2D32f*")
              float[] center,
              double M)

cvLinearPolar

public static void cvLinearPolar(@Const
                 opencv_core.CvArr src,
                 opencv_core.CvArr dst,
                 @ByVal
                 opencv_core.CvPoint2D32f center,
                 double maxRadius,
                 int flags)

Performs forward or inverse linear-polar image transform

See Also:: cv::linearPolar

cvLinearPolar

public static void cvLinearPolar(@Const
                 opencv_core.CvArr src,
                 opencv_core.CvArr dst,
                 @ByVal
                 opencv_core.CvPoint2D32f center,
                 double maxRadius)

cvLinearPolar

public static void cvLinearPolar(@Const
                 opencv_core.CvArr src,
                 opencv_core.CvArr dst,
                 @ByVal@Cast(value="CvPoint2D32f*")
                 FloatBuffer center,
                 double maxRadius,
                 int flags)

cvLinearPolar

public static void cvLinearPolar(@Const
                 opencv_core.CvArr src,
                 opencv_core.CvArr dst,
                 @ByVal@Cast(value="CvPoint2D32f*")
                 FloatBuffer center,
                 double maxRadius)

cvLinearPolar

public static void cvLinearPolar(@Const
                 opencv_core.CvArr src,
                 opencv_core.CvArr dst,
                 @ByVal@Cast(value="CvPoint2D32f*")
                 float[] center,
                 double maxRadius,
                 int flags)

cvLinearPolar

public static void cvLinearPolar(@Const
                 opencv_core.CvArr src,
                 opencv_core.CvArr dst,
                 @ByVal@Cast(value="CvPoint2D32f*")
                 float[] center,
                 double maxRadius)

cvUndistort2

public static void cvUndistort2(@Const
                opencv_core.CvArr src,
                opencv_core.CvArr dst,
                @Const
                opencv_core.CvMat camera_matrix,
                @Const
                opencv_core.CvMat distortion_coeffs,
                @Const
                opencv_core.CvMat new_camera_matrix)

\brief Transforms the input image to compensate lens distortion

See Also:: cv::undistort

cvUndistort2

public static void cvUndistort2(@Const
                opencv_core.CvArr src,
                opencv_core.CvArr dst,
                @Const
                opencv_core.CvMat camera_matrix,
                @Const
                opencv_core.CvMat distortion_coeffs)

cvInitUndistortMap

public static void cvInitUndistortMap(@Const
                      opencv_core.CvMat camera_matrix,
                      @Const
                      opencv_core.CvMat distortion_coeffs,
                      opencv_core.CvArr mapx,
                      opencv_core.CvArr mapy)

\brief Computes transformation map from intrinsic camera parameters that can used by cvRemap

cvInitUndistortRectifyMap

public static void cvInitUndistortRectifyMap(@Const
                             opencv_core.CvMat camera_matrix,
                             @Const
                             opencv_core.CvMat dist_coeffs,
                             @Const
                             opencv_core.CvMat R,
                             @Const
                             opencv_core.CvMat new_camera_matrix,
                             opencv_core.CvArr mapx,
                             opencv_core.CvArr mapy)

\brief Computes undistortion+rectification map for a head of stereo camera

See Also:: cv::initUndistortRectifyMap

cvUndistortPoints

public static void cvUndistortPoints(@Const
                     opencv_core.CvMat src,
                     opencv_core.CvMat dst,
                     @Const
                     opencv_core.CvMat camera_matrix,
                     @Const
                     opencv_core.CvMat dist_coeffs,
                     @Const
                     opencv_core.CvMat R,
                     @Const
                     opencv_core.CvMat P)

\brief Computes the original (undistorted) feature coordinates from the observed (distorted) coordinates

See Also:: cv::undistortPoints

cvUndistortPoints

public static void cvUndistortPoints(@Const
                     opencv_core.CvMat src,
                     opencv_core.CvMat dst,
                     @Const
                     opencv_core.CvMat camera_matrix,
                     @Const
                     opencv_core.CvMat dist_coeffs)

cvCreateStructuringElementEx
```
public static opencv_core.IplConvKernel cvCreateStructuringElementEx(int cols,
                                                     int rows,
                                                     int anchor_x,
                                                     int anchor_y,
                                                     int shape,
                                                     IntPointer values)
```
\brief Returns a structuring element of the specified size and shape for morphological operations.
\note the created structuring element IplConvKernel\* element must be released in the end using cvReleaseStructuringElement(&element).

Parameters:
cols - Width of the structuring element
rows - Height of the structuring element
anchor_x - x-coordinate of the anchor
anchor_y - y-coordinate of the anchor
shape - element shape that could be one of the cv::MorphShapes_c
values - integer array of cols*rows elements that specifies the custom shape of the structuring element, when shape=CV_SHAPE_CUSTOM.
See Also:
cv::getStructuringElement

cvCreateStructuringElementEx

public static opencv_core.IplConvKernel cvCreateStructuringElementEx(int cols,
                                                     int rows,
                                                     int anchor_x,
                                                     int anchor_y,
                                                     int shape)

cvCreateStructuringElementEx

public static opencv_core.IplConvKernel cvCreateStructuringElementEx(int cols,
                                                     int rows,
                                                     int anchor_x,
                                                     int anchor_y,
                                                     int shape,
                                                     IntBuffer values)

cvCreateStructuringElementEx

public static opencv_core.IplConvKernel cvCreateStructuringElementEx(int cols,
                                                     int rows,
                                                     int anchor_x,
                                                     int anchor_y,
                                                     int shape,
                                                     int[] values)

cvReleaseStructuringElement

public static void cvReleaseStructuringElement(@Cast(value="IplConvKernel**")
                               PointerPointer element)

\brief releases structuring element

See Also:: cvCreateStructuringElementEx

cvReleaseStructuringElement

public static void cvReleaseStructuringElement(@ByPtrPtr
                               opencv_core.IplConvKernel element)

cvErode

public static void cvErode(@Const
           opencv_core.CvArr src,
           opencv_core.CvArr dst,
           opencv_core.IplConvKernel element,
           int iterations)

\brief erodes input image (applies minimum filter) one or more times. If element pointer is NULL, 3x3 rectangular element is used

See Also:: cv::erode

cvErode

public static void cvErode(@Const
           opencv_core.CvArr src,
           opencv_core.CvArr dst)

cvDilate

public static void cvDilate(@Const
            opencv_core.CvArr src,
            opencv_core.CvArr dst,
            opencv_core.IplConvKernel element,
            int iterations)

\brief dilates input image (applies maximum filter) one or more times.

If element pointer is NULL, 3x3 rectangular element is used

See Also:: cv::dilate

cvDilate

public static void cvDilate(@Const
            opencv_core.CvArr src,
            opencv_core.CvArr dst)

cvMorphologyEx

public static void cvMorphologyEx(@Const
                  opencv_core.CvArr src,
                  opencv_core.CvArr dst,
                  opencv_core.CvArr temp,
                  opencv_core.IplConvKernel element,
                  int operation,
                  int iterations)

\brief Performs complex morphological transformation

See Also:: cv::morphologyEx

cvMorphologyEx

public static void cvMorphologyEx(@Const
                  opencv_core.CvArr src,
                  opencv_core.CvArr dst,
                  opencv_core.CvArr temp,
                  opencv_core.IplConvKernel element,
                  int operation)

cvMoments

public static void cvMoments(@Const
             opencv_core.CvArr arr,
             opencv_imgproc.CvMoments moments,
             int binary)

\brief Calculates all spatial and central moments up to the 3rd order

See Also:: cv::moments

cvMoments

public static void cvMoments(@Const
             opencv_core.CvArr arr,
             opencv_imgproc.CvMoments moments)

cvGetSpatialMoment

public static double cvGetSpatialMoment(opencv_imgproc.CvMoments moments,
                        int x_order,
                        int y_order)

\brief Retrieve spatial moments

cvGetCentralMoment

public static double cvGetCentralMoment(opencv_imgproc.CvMoments moments,
                        int x_order,
                        int y_order)

\brief Retrieve central moments

cvGetNormalizedCentralMoment

public static double cvGetNormalizedCentralMoment(opencv_imgproc.CvMoments moments,
                                  int x_order,
                                  int y_order)

\brief Retrieve normalized central moments

cvGetHuMoments

public static void cvGetHuMoments(opencv_imgproc.CvMoments moments,
                  opencv_imgproc.CvHuMoments hu_moments)

\brief Calculates 7 Hu's invariants from precalculated spatial and central moments

See Also:: cv::HuMoments

cvSampleLine

public static int cvSampleLine(@Const
               opencv_core.CvArr image,
               @ByVal
               opencv_core.CvPoint pt1,
               @ByVal
               opencv_core.CvPoint pt2,
               Pointer buffer,
               int connectivity)

\brief Fetches pixels that belong to the specified line segment and stores them to the buffer.

Returns the number of retrieved points.

See Also:: cv::LineSegmentDetector

cvSampleLine

public static int cvSampleLine(@Const
               opencv_core.CvArr image,
               @ByVal
               opencv_core.CvPoint pt1,
               @ByVal
               opencv_core.CvPoint pt2,
               Pointer buffer)

cvSampleLine

public static int cvSampleLine(@Const
               opencv_core.CvArr image,
               @ByVal@Cast(value="CvPoint*")
               IntBuffer pt1,
               @ByVal@Cast(value="CvPoint*")
               IntBuffer pt2,
               Pointer buffer,
               int connectivity)

cvSampleLine

public static int cvSampleLine(@Const
               opencv_core.CvArr image,
               @ByVal@Cast(value="CvPoint*")
               IntBuffer pt1,
               @ByVal@Cast(value="CvPoint*")
               IntBuffer pt2,
               Pointer buffer)

cvSampleLine

public static int cvSampleLine(@Const
               opencv_core.CvArr image,
               @ByVal@Cast(value="CvPoint*")
               int[] pt1,
               @ByVal@Cast(value="CvPoint*")
               int[] pt2,
               Pointer buffer,
               int connectivity)

cvSampleLine

public static int cvSampleLine(@Const
               opencv_core.CvArr image,
               @ByVal@Cast(value="CvPoint*")
               int[] pt1,
               @ByVal@Cast(value="CvPoint*")
               int[] pt2,
               Pointer buffer)

cvGetRectSubPix

public static void cvGetRectSubPix(@Const
                   opencv_core.CvArr src,
                   opencv_core.CvArr dst,
                   @ByVal
                   opencv_core.CvPoint2D32f center)

\brief Retrieves the rectangular image region with specified center from the input array.

dst(x,y) <- src(x + center.x - dst_width/2, y + center.y - dst_height/2). Values of pixels with fractional coordinates are retrieved using bilinear interpolation

See Also:: cv::getRectSubPix

cvGetRectSubPix

public static void cvGetRectSubPix(@Const
                   opencv_core.CvArr src,
                   opencv_core.CvArr dst,
                   @ByVal@Cast(value="CvPoint2D32f*")
                   FloatBuffer center)

cvGetRectSubPix

public static void cvGetRectSubPix(@Const
                   opencv_core.CvArr src,
                   opencv_core.CvArr dst,
                   @ByVal@Cast(value="CvPoint2D32f*")
                   float[] center)

cvGetQuadrangleSubPix

public static void cvGetQuadrangleSubPix(@Const
                         opencv_core.CvArr src,
                         opencv_core.CvArr dst,
                         @Const
                         opencv_core.CvMat map_matrix)

\brief Retrieves quadrangle from the input array.

matrixarr = ( a11 a12 | b1 ) dst(x,y) <- src(A[x y]' + b) ( a21 a22 | b2 ) (bilinear interpolation is used to retrieve pixels with fractional coordinates)

See Also:: cvWarpAffine

cvMatchTemplate

public static void cvMatchTemplate(@Const
                   opencv_core.CvArr image,
                   @Const
                   opencv_core.CvArr templ,
                   opencv_core.CvArr result,
                   int method)

\brief Measures similarity between template and overlapped windows in the source image and fills the resultant image with the measurements

See Also:: cv::matchTemplate

cvCalcEMD2

public static float cvCalcEMD2(@Const
               opencv_core.CvArr signature1,
               @Const
               opencv_core.CvArr signature2,
               int distance_type,
               opencv_imgproc.CvDistanceFunction distance_func,
               @Const
               opencv_core.CvArr cost_matrix,
               opencv_core.CvArr flow,
               FloatPointer lower_bound,
               Pointer userdata)

\brief Computes earth mover distance between two weighted point sets (called signatures)

See Also:: cv::EMD

cvCalcEMD2

public static float cvCalcEMD2(@Const
               opencv_core.CvArr signature1,
               @Const
               opencv_core.CvArr signature2,
               int distance_type)

cvCalcEMD2

public static float cvCalcEMD2(@Const
               opencv_core.CvArr signature1,
               @Const
               opencv_core.CvArr signature2,
               int distance_type,
               opencv_imgproc.CvDistanceFunction distance_func,
               @Const
               opencv_core.CvArr cost_matrix,
               opencv_core.CvArr flow,
               FloatBuffer lower_bound,
               Pointer userdata)

cvCalcEMD2

public static float cvCalcEMD2(@Const
               opencv_core.CvArr signature1,
               @Const
               opencv_core.CvArr signature2,
               int distance_type,
               opencv_imgproc.CvDistanceFunction distance_func,
               @Const
               opencv_core.CvArr cost_matrix,
               opencv_core.CvArr flow,
               float[] lower_bound,
               Pointer userdata)

cvFindContours

public static int cvFindContours(opencv_core.CvArr image,
                 opencv_core.CvMemStorage storage,
                 @Cast(value="CvSeq**")
                 PointerPointer first_contour,
                 int header_size,
                 int mode,
                 int method,
                 @ByVal(nullValue="cvPoint(0,0)")
                 opencv_core.CvPoint offset)

\brief Retrieves outer and optionally inner boundaries of white (non-zero) connected components in the black (zero) background

See Also:: cv::findContours, cvStartFindContours, cvFindNextContour, cvSubstituteContour, cvEndFindContours

cvFindContours

public static int cvFindContours(opencv_core.CvArr image,
                 opencv_core.CvMemStorage storage,
                 @ByPtrPtr
                 opencv_core.CvSeq first_contour)

cvFindContours

public static int cvFindContours(opencv_core.CvArr image,
                 opencv_core.CvMemStorage storage,
                 @ByPtrPtr
                 opencv_core.CvSeq first_contour,
                 int header_size,
                 int mode,
                 int method,
                 @ByVal(nullValue="cvPoint(0,0)")
                 opencv_core.CvPoint offset)

cvFindContours

public static int cvFindContours(opencv_core.CvArr image,
                 opencv_core.CvMemStorage storage,
                 @ByPtrPtr
                 opencv_core.CvSeq first_contour,
                 int header_size,
                 int mode,
                 int method,
                 @ByVal(nullValue="cvPoint(0,0)")@Cast(value="CvPoint*")
                 IntBuffer offset)

cvFindContours

public static int cvFindContours(opencv_core.CvArr image,
                 opencv_core.CvMemStorage storage,
                 @ByPtrPtr
                 opencv_core.CvSeq first_contour,
                 int header_size,
                 int mode,
                 int method,
                 @ByVal(nullValue="cvPoint(0,0)")@Cast(value="CvPoint*")
                 int[] offset)

cvStartFindContours

public static opencv_imgproc.CvContourScanner cvStartFindContours(opencv_core.CvArr image,
                                                  opencv_core.CvMemStorage storage,
                                                  int header_size,
                                                  int mode,
                                                  int method,
                                                  @ByVal(nullValue="cvPoint(0,0)")
                                                  opencv_core.CvPoint offset)

\brief Initializes contour retrieving process.

Calls cvStartFindContours. Calls cvFindNextContour until null pointer is returned or some other condition becomes true. Calls cvEndFindContours at the end.

See Also:: cvFindContours

cvStartFindContours

public static opencv_imgproc.CvContourScanner cvStartFindContours(opencv_core.CvArr image,
                                                  opencv_core.CvMemStorage storage)

cvStartFindContours

public static opencv_imgproc.CvContourScanner cvStartFindContours(opencv_core.CvArr image,
                                                  opencv_core.CvMemStorage storage,
                                                  int header_size,
                                                  int mode,
                                                  int method,
                                                  @ByVal(nullValue="cvPoint(0,0)")@Cast(value="CvPoint*")
                                                  IntBuffer offset)

cvStartFindContours

public static opencv_imgproc.CvContourScanner cvStartFindContours(opencv_core.CvArr image,
                                                  opencv_core.CvMemStorage storage,
                                                  int header_size,
                                                  int mode,
                                                  int method,
                                                  @ByVal(nullValue="cvPoint(0,0)")@Cast(value="CvPoint*")
                                                  int[] offset)

cvFindNextContour

public static opencv_core.CvSeq cvFindNextContour(opencv_imgproc.CvContourScanner scanner)

\brief Retrieves next contour

See Also:: cvFindContours

cvSubstituteContour
```
public static void cvSubstituteContour(opencv_imgproc.CvContourScanner scanner,
                       opencv_core.CvSeq new_contour)
```
\brief Substitutes the last retrieved contour with the new one
(if the substitutor is null, the last retrieved contour is removed from the tree)

See Also:
cvFindContours

cvEndFindContours

public static opencv_core.CvSeq cvEndFindContours(@ByPtrPtr
                                  opencv_imgproc.CvContourScanner scanner)

\brief Releases contour scanner and returns pointer to the first outer contour

See Also:: cvFindContours

cvApproxChains
```
public static opencv_core.CvSeq cvApproxChains(opencv_core.CvSeq src_seq,
                               opencv_core.CvMemStorage storage,
                               int method,
                               double parameter,
                               int minimal_perimeter,
                               int recursive)
```
\brief Approximates Freeman chain(s) with a polygonal curve.
This is a standalone contour approximation routine, not represented in the new interface. When cvFindContours retrieves contours as Freeman chains, it calls the function to get approximated contours, represented as polygons.

Parameters:
src_seq - Pointer to the approximated Freeman chain that can refer to other chains.
storage - Storage location for the resulting polylines.
method - Approximation method (see the description of the function :ocvFindContours ).
parameter - Method parameter (not used now).
minimal_perimeter - Approximates only those contours whose perimeters are not less than minimal_perimeter . Other chains are removed from the resulting structure.
recursive - Recursion flag. If it is non-zero, the function approximates all chains that can be obtained from chain by using the h_next or v_next links. Otherwise, the single input chain is approximated.
See Also:
cvStartReadChainPoints, cvReadChainPoint

cvApproxChains

public static opencv_core.CvSeq cvApproxChains(opencv_core.CvSeq src_seq,
                               opencv_core.CvMemStorage storage)

cvStartReadChainPoints
```
public static void cvStartReadChainPoints(opencv_core.CvChain chain,
                          opencv_imgproc.CvChainPtReader reader)
```
\brief Initializes Freeman chain reader.
The reader is used to iteratively get coordinates of all the chain points. If the Freeman codes should be read as is, a simple sequence reader should be used

See Also:
cvApproxChains

cvReadChainPoint

@ByVal
public static opencv_core.CvPoint cvReadChainPoint(opencv_imgproc.CvChainPtReader reader)

\brief Retrieves the next chain point

See Also:: cvApproxChains

cvApproxPoly

public static opencv_core.CvSeq cvApproxPoly(@Const
                             Pointer src_seq,
                             int header_size,
                             opencv_core.CvMemStorage storage,
                             int method,
                             double eps,
                             int recursive)

\brief Approximates a single polygonal curve (contour) or a tree of polygonal curves (contours)

See Also:: cv::approxPolyDP

cvApproxPoly

public static opencv_core.CvSeq cvApproxPoly(@Const
                             Pointer src_seq,
                             int header_size,
                             opencv_core.CvMemStorage storage,
                             int method,
                             double eps)

cvArcLength

public static double cvArcLength(@Const
                 Pointer curve,
                 @ByVal(nullValue="CV_WHOLE_SEQ")
                 opencv_core.CvSlice slice,
                 int is_closed)

\brief Calculates perimeter of a contour or length of a part of contour

See Also:: cv::arcLength

cvArcLength

public static double cvArcLength(@Const
                 Pointer curve)

cvContourPerimeter

public static double cvContourPerimeter(@Const
                        Pointer contour)

same as cvArcLength for closed contour

cvBoundingRect
```
@ByVal
public static opencv_core.CvRect cvBoundingRect(opencv_core.CvArr points,
                                      int update)
```
\brief Calculates contour bounding rectangle (update=1) or just retrieves pre-calculated rectangle (update=0)

See Also:
cv::boundingRect

cvBoundingRect

@ByVal
public static opencv_core.CvRect cvBoundingRect(opencv_core.CvArr points)

cvContourArea

public static double cvContourArea(@Const
                   opencv_core.CvArr contour,
                   @ByVal(nullValue="CV_WHOLE_SEQ")
                   opencv_core.CvSlice slice,
                   int oriented)

\brief Calculates area of a contour or contour segment

See Also:: cv::contourArea

cvContourArea

public static double cvContourArea(@Const
                   opencv_core.CvArr contour)

cvMinAreaRect2

@ByVal
public static opencv_core.CvBox2D cvMinAreaRect2(@Const
                                       opencv_core.CvArr points,
                                       opencv_core.CvMemStorage storage)

\brief Finds minimum area rotated rectangle bounding a set of points

See Also:: cv::minAreaRect

cvMinAreaRect2

@ByVal
public static opencv_core.CvBox2D cvMinAreaRect2(@Const
                                       opencv_core.CvArr points)

cvMinEnclosingCircle

public static int cvMinEnclosingCircle(@Const
                       opencv_core.CvArr points,
                       opencv_core.CvPoint2D32f center,
                       FloatPointer radius)

\brief Finds minimum enclosing circle for a set of points

See Also:: cv::minEnclosingCircle

cvMinEnclosingCircle

public static int cvMinEnclosingCircle(@Const
                       opencv_core.CvArr points,
                       @Cast(value="CvPoint2D32f*")
                       FloatBuffer center,
                       FloatBuffer radius)

cvMinEnclosingCircle

public static int cvMinEnclosingCircle(@Const
                       opencv_core.CvArr points,
                       @Cast(value="CvPoint2D32f*")
                       float[] center,
                       float[] radius)

cvMatchShapes

public static double cvMatchShapes(@Const
                   Pointer object1,
                   @Const
                   Pointer object2,
                   int method,
                   double parameter)

\brief Compares two contours by matching their moments

See Also:: cv::matchShapes

cvMatchShapes

public static double cvMatchShapes(@Const
                   Pointer object1,
                   @Const
                   Pointer object2,
                   int method)

cvConvexHull2

public static opencv_core.CvSeq cvConvexHull2(@Const
                              opencv_core.CvArr input,
                              Pointer hull_storage,
                              int orientation,
                              int return_points)

\brief Calculates exact convex hull of 2d point set

See Also:: cv::convexHull

cvConvexHull2

public static opencv_core.CvSeq cvConvexHull2(@Const
                              opencv_core.CvArr input)

cvCheckContourConvexity

public static int cvCheckContourConvexity(@Const
                          opencv_core.CvArr contour)

\brief Checks whether the contour is convex or not (returns 1 if convex, 0 if not)

See Also:: cv::isContourConvex

cvConvexityDefects

public static opencv_core.CvSeq cvConvexityDefects(@Const
                                   opencv_core.CvArr contour,
                                   @Const
                                   opencv_core.CvArr convexhull,
                                   opencv_core.CvMemStorage storage)

\brief Finds convexity defects for the contour

See Also:: cv::convexityDefects

cvConvexityDefects

public static opencv_core.CvSeq cvConvexityDefects(@Const
                                   opencv_core.CvArr contour,
                                   @Const
                                   opencv_core.CvArr convexhull)

cvFitEllipse2

@ByVal
public static opencv_core.CvBox2D cvFitEllipse2(@Const
                                      opencv_core.CvArr points)

\brief Fits ellipse into a set of 2d points

See Also:: cv::fitEllipse

cvMaxRect

@ByVal
public static opencv_core.CvRect cvMaxRect(@Const
                                 opencv_core.CvRect rect1,
                                 @Const
                                 opencv_core.CvRect rect2)

\brief Finds minimum rectangle containing two given rectangles

cvBoxPoints

public static void cvBoxPoints(@ByVal
               opencv_core.CvBox2D box,
               opencv_core.CvPoint2D32f pt)

\brief Finds coordinates of the box vertices

cvBoxPoints

public static void cvBoxPoints(@ByVal
               opencv_core.CvBox2D box,
               @Cast(value="CvPoint2D32f*")
               FloatBuffer pt)

cvBoxPoints

public static void cvBoxPoints(@ByVal
               opencv_core.CvBox2D box,
               @Cast(value="CvPoint2D32f*")
               float[] pt)

cvPointSeqFromMat

public static opencv_core.CvSeq cvPointSeqFromMat(int seq_kind,
                                  @Const
                                  opencv_core.CvArr mat,
                                  opencv_core.CvContour contour_header,
                                  opencv_core.CvSeqBlock block)

\brief Initializes sequence header for a matrix (column or row vector) of points

a wrapper for cvMakeSeqHeaderForArray (it does not initialize bounding rectangle!!!)

cvPointPolygonTest

public static double cvPointPolygonTest(@Const
                        opencv_core.CvArr contour,
                        @ByVal
                        opencv_core.CvPoint2D32f pt,
                        int measure_dist)

\brief Checks whether the point is inside polygon, outside, on an edge (at a vertex).

Returns positive, negative or zero value, correspondingly. Optionally, measures a signed distance between the point and the nearest polygon edge (measure_dist=1)

See Also:: cv::pointPolygonTest

cvPointPolygonTest

public static double cvPointPolygonTest(@Const
                        opencv_core.CvArr contour,
                        @ByVal@Cast(value="CvPoint2D32f*")
                        FloatBuffer pt,
                        int measure_dist)

cvPointPolygonTest

public static double cvPointPolygonTest(@Const
                        opencv_core.CvArr contour,
                        @ByVal@Cast(value="CvPoint2D32f*")
                        float[] pt,
                        int measure_dist)

cvCreateHist
```
public static opencv_core.CvHistogram cvCreateHist(int dims,
                                   IntPointer sizes,
                                   int type,
                                   @Cast(value="float**")
                                   PointerPointer ranges,
                                   int uniform)
```
\brief Creates a histogram.
The function creates a histogram of the specified size and returns a pointer to the created histogram. If the array ranges is 0, the histogram bin ranges must be specified later via the function cvSetHistBinRanges. Though cvCalcHist and cvCalcBackProject may process 8-bit images without setting bin ranges, they assume they are equally spaced in 0 to 255 bins.

Parameters:
dims - Number of histogram dimensions.
sizes - Array of the histogram dimension sizes.
type - Histogram representation format. CV_HIST_ARRAY means that the histogram data is represented as a multi-dimensional dense array CvMatND. CV_HIST_SPARSE means that histogram data is represented as a multi-dimensional sparse array CvSparseMat.
ranges - Array of ranges for the histogram bins. Its meaning depends on the uniform parameter value. The ranges are used when the histogram is calculated or backprojected to determine which histogram bin corresponds to which value/tuple of values from the input image(s).
uniform - Uniformity flag. If not zero, the histogram has evenly spaced bins and for every \f$0<=i

cvCreateHist

public static opencv_core.CvHistogram cvCreateHist(int dims,
                                   IntPointer sizes,
                                   int type)

cvCreateHist

public static opencv_core.CvHistogram cvCreateHist(int dims,
                                   IntPointer sizes,
                                   int type,
                                   @ByPtrPtr
                                   FloatPointer ranges,
                                   int uniform)

cvCreateHist

public static opencv_core.CvHistogram cvCreateHist(int dims,
                                   IntBuffer sizes,
                                   int type,
                                   @ByPtrPtr
                                   FloatBuffer ranges,
                                   int uniform)

cvCreateHist

public static opencv_core.CvHistogram cvCreateHist(int dims,
                                   IntBuffer sizes,
                                   int type)

cvCreateHist

public static opencv_core.CvHistogram cvCreateHist(int dims,
                                   int[] sizes,
                                   int type,
                                   @ByPtrPtr
                                   float[] ranges,
                                   int uniform)

cvCreateHist

public static opencv_core.CvHistogram cvCreateHist(int dims,
                                   int[] sizes,
                                   int type)

cvSetHistBinRanges
```
public static void cvSetHistBinRanges(opencv_core.CvHistogram hist,
                      @Cast(value="float**")
                      PointerPointer ranges,
                      int uniform)
```
\brief Sets the bounds of the histogram bins.
This is a standalone function for setting bin ranges in the histogram. For a more detailed description of the parameters ranges and uniform, see the :ocvCalcHist function that can initialize the ranges as well. Ranges for the histogram bins must be set before the histogram is calculated or the backproject of the histogram is calculated.

Parameters:
hist - Histogram.
ranges - Array of bin ranges arrays. See :ocvCreateHist for details.
uniform - Uniformity flag. See :ocvCreateHist for details.

cvSetHistBinRanges

public static void cvSetHistBinRanges(opencv_core.CvHistogram hist,
                      @ByPtrPtr
                      FloatPointer ranges)

cvSetHistBinRanges

public static void cvSetHistBinRanges(opencv_core.CvHistogram hist,
                      @ByPtrPtr
                      FloatPointer ranges,
                      int uniform)

cvSetHistBinRanges

public static void cvSetHistBinRanges(opencv_core.CvHistogram hist,
                      @ByPtrPtr
                      FloatBuffer ranges,
                      int uniform)

cvSetHistBinRanges

public static void cvSetHistBinRanges(opencv_core.CvHistogram hist,
                      @ByPtrPtr
                      FloatBuffer ranges)

cvSetHistBinRanges

public static void cvSetHistBinRanges(opencv_core.CvHistogram hist,
                      @ByPtrPtr
                      float[] ranges,
                      int uniform)

cvSetHistBinRanges

public static void cvSetHistBinRanges(opencv_core.CvHistogram hist,
                      @ByPtrPtr
                      float[] ranges)

cvMakeHistHeaderForArray

public static opencv_core.CvHistogram cvMakeHistHeaderForArray(int dims,
                                               IntPointer sizes,
                                               opencv_core.CvHistogram hist,
                                               FloatPointer data,
                                               @Cast(value="float**")
                                               PointerPointer ranges,
                                               int uniform)

\brief Makes a histogram out of an array.

The function initializes the histogram, whose header and bins are allocated by the user. cvReleaseHist does not need to be called afterwards. Only dense histograms can be initialized this way. The function returns hist.

Parameters:: dims - Number of the histogram dimensions.; sizes - Array of the histogram dimension sizes.; hist - Histogram header initialized by the function.; data - Array used to store histogram bins.; ranges - Histogram bin ranges. See cvCreateHist for details.; uniform - Uniformity flag. See cvCreateHist for details.

cvMakeHistHeaderForArray

public static opencv_core.CvHistogram cvMakeHistHeaderForArray(int dims,
                                               IntPointer sizes,
                                               opencv_core.CvHistogram hist,
                                               FloatPointer data)

cvMakeHistHeaderForArray

public static opencv_core.CvHistogram cvMakeHistHeaderForArray(int dims,
                                               IntPointer sizes,
                                               opencv_core.CvHistogram hist,
                                               FloatPointer data,
                                               @ByPtrPtr
                                               FloatPointer ranges,
                                               int uniform)

cvMakeHistHeaderForArray

public static opencv_core.CvHistogram cvMakeHistHeaderForArray(int dims,
                                               IntBuffer sizes,
                                               opencv_core.CvHistogram hist,
                                               FloatBuffer data,
                                               @ByPtrPtr
                                               FloatBuffer ranges,
                                               int uniform)

cvMakeHistHeaderForArray

public static opencv_core.CvHistogram cvMakeHistHeaderForArray(int dims,
                                               IntBuffer sizes,
                                               opencv_core.CvHistogram hist,
                                               FloatBuffer data)

cvMakeHistHeaderForArray

public static opencv_core.CvHistogram cvMakeHistHeaderForArray(int dims,
                                               int[] sizes,
                                               opencv_core.CvHistogram hist,
                                               float[] data,
                                               @ByPtrPtr
                                               float[] ranges,
                                               int uniform)

cvMakeHistHeaderForArray

public static opencv_core.CvHistogram cvMakeHistHeaderForArray(int dims,
                                               int[] sizes,
                                               opencv_core.CvHistogram hist,
                                               float[] data)

cvReleaseHist
```
public static void cvReleaseHist(@Cast(value="CvHistogram**")
                 PointerPointer hist)
```
\brief Releases the histogram.
The function releases the histogram (header and the data). The pointer to the histogram is cleared by the function. If \*hist pointer is already NULL, the function does nothing.

Parameters:
hist - Double pointer to the released histogram.

cvReleaseHist

public static void cvReleaseHist(@ByPtrPtr
                 opencv_core.CvHistogram hist)

cvClearHist
```
public static void cvClearHist(opencv_core.CvHistogram hist)
```
\brief Clears the histogram.
The function sets all of the histogram bins to 0 in case of a dense histogram and removes all histogram bins in case of a sparse array.

Parameters:
hist - Histogram.

cvGetMinMaxHistValue
```
public static void cvGetMinMaxHistValue(@Const
                        opencv_core.CvHistogram hist,
                        FloatPointer min_value,
                        FloatPointer max_value,
                        IntPointer min_idx,
                        IntPointer max_idx)
```
\brief Finds the minimum and maximum histogram bins.
The function finds the minimum and maximum histogram bins and their positions. All of output arguments are optional. Among several extremas with the same value the ones with the minimum index (in the lexicographical order) are returned. In case of several maximums or minimums, the earliest in the lexicographical order (extrema locations) is returned.

Parameters:
hist - Histogram.
min_value - Pointer to the minimum value of the histogram.
max_value - Pointer to the maximum value of the histogram.
min_idx - Pointer to the array of coordinates for the minimum.
max_idx - Pointer to the array of coordinates for the maximum.

cvGetMinMaxHistValue

public static void cvGetMinMaxHistValue(@Const
                        opencv_core.CvHistogram hist,
                        FloatPointer min_value,
                        FloatPointer max_value)

cvGetMinMaxHistValue

public static void cvGetMinMaxHistValue(@Const
                        opencv_core.CvHistogram hist,
                        FloatBuffer min_value,
                        FloatBuffer max_value,
                        IntBuffer min_idx,
                        IntBuffer max_idx)

cvGetMinMaxHistValue

public static void cvGetMinMaxHistValue(@Const
                        opencv_core.CvHistogram hist,
                        FloatBuffer min_value,
                        FloatBuffer max_value)

cvGetMinMaxHistValue

public static void cvGetMinMaxHistValue(@Const
                        opencv_core.CvHistogram hist,
                        float[] min_value,
                        float[] max_value,
                        int[] min_idx,
                        int[] max_idx)

cvGetMinMaxHistValue

public static void cvGetMinMaxHistValue(@Const
                        opencv_core.CvHistogram hist,
                        float[] min_value,
                        float[] max_value)

cvNormalizeHist
```
public static void cvNormalizeHist(opencv_core.CvHistogram hist,
                   double factor)
```
\brief Normalizes the histogram.
The function normalizes the histogram bins by scaling them so that the sum of the bins becomes equal to factor.

Parameters:
hist - Pointer to the histogram.
factor - Normalization factor.

cvThreshHist
```
public static void cvThreshHist(opencv_core.CvHistogram hist,
                double threshold)
```
\brief Thresholds the histogram.
The function clears histogram bins that are below the specified threshold.

Parameters:
hist - Pointer to the histogram.
threshold - Threshold level.

cvCompareHist

public static double cvCompareHist(@Const
                   opencv_core.CvHistogram hist1,
                   @Const
                   opencv_core.CvHistogram hist2,
                   int method)

Compares two histogram

cvCopyHist
```
public static void cvCopyHist(@Const
              opencv_core.CvHistogram src,
              @Cast(value="CvHistogram**")
              PointerPointer dst)
```
\brief Copies a histogram.
The function makes a copy of the histogram. If the second histogram pointer \*dst is NULL, a new histogram of the same size as src is created. Otherwise, both histograms must have equal types and sizes. Then the function copies the bin values of the source histogram to the destination histogram and sets the same bin value ranges as in src.

Parameters:
src - Source histogram.
dst - Pointer to the destination histogram.

cvCopyHist

public static void cvCopyHist(@Const
              opencv_core.CvHistogram src,
              @ByPtrPtr
              opencv_core.CvHistogram dst)

cvCalcBayesianProb

public static void cvCalcBayesianProb(@Cast(value="CvHistogram**")
                      PointerPointer src,
                      int number,
                      @Cast(value="CvHistogram**")
                      PointerPointer dst)

\brief Calculates bayesian probabilistic histograms (each or src and dst is an array of _number_ histograms

cvCalcBayesianProb

public static void cvCalcBayesianProb(@ByPtrPtr
                      opencv_core.CvHistogram src,
                      int number,
                      @ByPtrPtr
                      opencv_core.CvHistogram dst)

cvCalcArrHist

public static void cvCalcArrHist(@Cast(value="CvArr**")
                 PointerPointer arr,
                 opencv_core.CvHistogram hist,
                 int accumulate,
                 @Const
                 opencv_core.CvArr mask)

\brief Calculates array histogram

See Also:: cv::calcHist

cvCalcArrHist

public static void cvCalcArrHist(@ByPtrPtr
                 opencv_core.CvArr arr,
                 opencv_core.CvHistogram hist)

cvCalcArrHist

public static void cvCalcArrHist(@ByPtrPtr
                 opencv_core.CvArr arr,
                 opencv_core.CvHistogram hist,
                 int accumulate,
                 @Const
                 opencv_core.CvArr mask)

cvCalcHist

public static void cvCalcHist(@Cast(value="IplImage**")
              PointerPointer image,
              opencv_core.CvHistogram hist,
              int accumulate,
              @Const
              opencv_core.CvArr mask)

\overload

cvCalcHist

public static void cvCalcHist(@ByPtrPtr
              opencv_core.IplImage image,
              opencv_core.CvHistogram hist)

cvCalcHist

public static void cvCalcHist(@ByPtrPtr
              opencv_core.IplImage image,
              opencv_core.CvHistogram hist,
              int accumulate,
              @Const
              opencv_core.CvArr mask)

cvCalcArrBackProject

public static void cvCalcArrBackProject(@Cast(value="CvArr**")
                        PointerPointer image,
                        opencv_core.CvArr dst,
                        @Const
                        opencv_core.CvHistogram hist)

\brief Calculates back project

See Also:: cvCalcBackProject, cv::calcBackProject

cvCalcArrBackProject

public static void cvCalcArrBackProject(@ByPtrPtr
                        opencv_core.CvArr image,
                        opencv_core.CvArr dst,
                        @Const
                        opencv_core.CvHistogram hist)

cvCalcBackProject

public static void cvCalcBackProject(@Cast(value="IplImage**")
                     PointerPointer image,
                     opencv_core.CvArr dst,
                     opencv_core.CvHistogram hist)

cvCalcBackProject

public static void cvCalcBackProject(@ByPtrPtr
                     opencv_core.IplImage image,
                     opencv_core.CvArr dst,
                     opencv_core.CvHistogram hist)

cvCalcArrBackProjectPatch
```
public static void cvCalcArrBackProjectPatch(@Cast(value="CvArr**")
                             PointerPointer image,
                             opencv_core.CvArr dst,
                             @ByVal
                             opencv_core.CvSize range,
                             opencv_core.CvHistogram hist,
                             int method,
                             double factor)
```
\brief Locates a template within an image by using a histogram comparison.
The function calculates the back projection by comparing histograms of the source image patches with the given histogram. The function is similar to matchTemplate, but instead of comparing the raster patch with all its possible positions within the search window, the function CalcBackProjectPatch compares histograms. See the algorithm diagram below:
![image](pics/backprojectpatch.png)

Parameters:
image - Source images (though, you may pass CvMat\*\* as well).
dst - Destination image.
range -
hist - Histogram.
method - Comparison method passed to cvCompareHist (see the function description).
factor - Normalization factor for histograms that affects the normalization scale of the destination image. Pass 1 if not sure.
See Also:
cvCalcBackProjectPatch

cvCalcArrBackProjectPatch

public static void cvCalcArrBackProjectPatch(@ByPtrPtr
                             opencv_core.CvArr image,
                             opencv_core.CvArr dst,
                             @ByVal
                             opencv_core.CvSize range,
                             opencv_core.CvHistogram hist,
                             int method,
                             double factor)

cvCalcBackProjectPatch

public static void cvCalcBackProjectPatch(@Cast(value="IplImage**")
                          PointerPointer image,
                          opencv_core.CvArr dst,
                          @ByVal
                          opencv_core.CvSize range,
                          opencv_core.CvHistogram hist,
                          int method,
                          double factor)

cvCalcBackProjectPatch

public static void cvCalcBackProjectPatch(@ByPtrPtr
                          opencv_core.IplImage image,
                          opencv_core.CvArr dst,
                          @ByVal
                          opencv_core.CvSize range,
                          opencv_core.CvHistogram hist,
                          int method,
                          double factor)

cvCalcProbDensity
```
public static void cvCalcProbDensity(@Const
                     opencv_core.CvHistogram hist1,
                     @Const
                     opencv_core.CvHistogram hist2,
                     opencv_core.CvHistogram dst_hist,
                     double scale)
```
\brief Divides one histogram by another.
The function calculates the object probability density from two histograms as:
\f[\texttt{disthist} (I)= \forkthree{0}{if $\texttt{hist1}(I)=0$}{\texttt{scale}}{if $\texttt{hist1}(I) \ne 0$ and $\texttt{hist2}(I) > \texttt{hist1}(I)$}{\frac{\texttt{hist2}(I) \cdot \texttt{scale}}{\texttt{hist1}(I)}}{if $\texttt{hist1}(I) \ne 0$ and $\texttt{hist2}(I) \le \texttt{hist1}(I)$}\f]

Parameters:
hist1 - First histogram (the divisor).
hist2 - Second histogram.
dst_hist - Destination histogram.
scale - Scale factor for the destination histogram.

cvCalcProbDensity

public static void cvCalcProbDensity(@Const
                     opencv_core.CvHistogram hist1,
                     @Const
                     opencv_core.CvHistogram hist2,
                     opencv_core.CvHistogram dst_hist)

cvEqualizeHist

public static void cvEqualizeHist(@Const
                  opencv_core.CvArr src,
                  opencv_core.CvArr dst)

\brief equalizes histogram of 8-bit single-channel image

See Also:: cv::equalizeHist

cvDistTransform

public static void cvDistTransform(@Const
                   opencv_core.CvArr src,
                   opencv_core.CvArr dst,
                   int distance_type,
                   int mask_size,
                   @Const
                   FloatPointer mask,
                   opencv_core.CvArr labels,
                   int labelType)

\brief Applies distance transform to binary image

See Also:: cv::distanceTransform

cvDistTransform

public static void cvDistTransform(@Const
                   opencv_core.CvArr src,
                   opencv_core.CvArr dst)

cvDistTransform

public static void cvDistTransform(@Const
                   opencv_core.CvArr src,
                   opencv_core.CvArr dst,
                   int distance_type,
                   int mask_size,
                   @Const
                   FloatBuffer mask,
                   opencv_core.CvArr labels,
                   int labelType)

cvDistTransform

public static void cvDistTransform(@Const
                   opencv_core.CvArr src,
                   opencv_core.CvArr dst,
                   int distance_type,
                   int mask_size,
                   @Const
                   float[] mask,
                   opencv_core.CvArr labels,
                   int labelType)

cvThreshold

public static double cvThreshold(@Const
                 opencv_core.CvArr src,
                 opencv_core.CvArr dst,
                 double threshold,
                 double max_value,
                 int threshold_type)

\brief Applies fixed-level threshold to grayscale image.

This is a basic operation applied before retrieving contours

See Also:: cv::threshold

cvAdaptiveThreshold

public static void cvAdaptiveThreshold(@Const
                       opencv_core.CvArr src,
                       opencv_core.CvArr dst,
                       double max_value,
                       int adaptive_method,
                       int threshold_type,
                       int block_size,
                       double param1)

\brief Applies adaptive threshold to grayscale image.

The two parameters for methods CV_ADAPTIVE_THRESH_MEAN_C and CV_ADAPTIVE_THRESH_GAUSSIAN_C are: neighborhood size (3, 5, 7 etc.), and a constant subtracted from mean (...,-3,-2,-1,0,1,2,3,...)

See Also:: cv::adaptiveThreshold

cvAdaptiveThreshold

public static void cvAdaptiveThreshold(@Const
                       opencv_core.CvArr src,
                       opencv_core.CvArr dst,
                       double max_value)

cvFloodFill

public static void cvFloodFill(opencv_core.CvArr image,
               @ByVal
               opencv_core.CvPoint seed_point,
               @ByVal
               opencv_core.CvScalar new_val,
               @ByVal(nullValue="cvScalarAll(0)")
               opencv_core.CvScalar lo_diff,
               @ByVal(nullValue="cvScalarAll(0)")
               opencv_core.CvScalar up_diff,
               opencv_imgproc.CvConnectedComp comp,
               int flags,
               opencv_core.CvArr mask)

\brief Fills the connected component until the color difference gets large enough

See Also:: cv::floodFill

cvFloodFill

public static void cvFloodFill(opencv_core.CvArr image,
               @ByVal
               opencv_core.CvPoint seed_point,
               @ByVal
               opencv_core.CvScalar new_val)

cvFloodFill

public static void cvFloodFill(opencv_core.CvArr image,
               @ByVal@Cast(value="CvPoint*")
               IntBuffer seed_point,
               @ByVal
               opencv_core.CvScalar new_val,
               @ByVal(nullValue="cvScalarAll(0)")
               opencv_core.CvScalar lo_diff,
               @ByVal(nullValue="cvScalarAll(0)")
               opencv_core.CvScalar up_diff,
               opencv_imgproc.CvConnectedComp comp,
               int flags,
               opencv_core.CvArr mask)

cvFloodFill

public static void cvFloodFill(opencv_core.CvArr image,
               @ByVal@Cast(value="CvPoint*")
               IntBuffer seed_point,
               @ByVal
               opencv_core.CvScalar new_val)

cvFloodFill

public static void cvFloodFill(opencv_core.CvArr image,
               @ByVal@Cast(value="CvPoint*")
               int[] seed_point,
               @ByVal
               opencv_core.CvScalar new_val,
               @ByVal(nullValue="cvScalarAll(0)")
               opencv_core.CvScalar lo_diff,
               @ByVal(nullValue="cvScalarAll(0)")
               opencv_core.CvScalar up_diff,
               opencv_imgproc.CvConnectedComp comp,
               int flags,
               opencv_core.CvArr mask)

cvFloodFill

public static void cvFloodFill(opencv_core.CvArr image,
               @ByVal@Cast(value="CvPoint*")
               int[] seed_point,
               @ByVal
               opencv_core.CvScalar new_val)

cvCanny

public static void cvCanny(@Const
           opencv_core.CvArr image,
           opencv_core.CvArr edges,
           double threshold1,
           double threshold2,
           int aperture_size)

\brief Runs canny edge detector

See Also:: cv::Canny

cvCanny

public static void cvCanny(@Const
           opencv_core.CvArr image,
           opencv_core.CvArr edges,
           double threshold1,
           double threshold2)

cvPreCornerDetect

public static void cvPreCornerDetect(@Const
                     opencv_core.CvArr image,
                     opencv_core.CvArr corners,
                     int aperture_size)

\brief Calculates constraint image for corner detection

Dx^2 * Dyy + Dxx * Dy^2 - 2 * Dx * Dy * Dxy. Applying threshold to the result gives coordinates of corners

See Also:: cv::preCornerDetect

cvPreCornerDetect

public static void cvPreCornerDetect(@Const
                     opencv_core.CvArr image,
                     opencv_core.CvArr corners)

cvCornerEigenValsAndVecs

public static void cvCornerEigenValsAndVecs(@Const
                            opencv_core.CvArr image,
                            opencv_core.CvArr eigenvv,
                            int block_size,
                            int aperture_size)

\brief Calculates eigen values and vectors of 2x2 gradient covariation matrix at every image pixel

See Also:: cv::cornerEigenValsAndVecs

cvCornerEigenValsAndVecs

public static void cvCornerEigenValsAndVecs(@Const
                            opencv_core.CvArr image,
                            opencv_core.CvArr eigenvv,
                            int block_size)

cvCornerMinEigenVal

public static void cvCornerMinEigenVal(@Const
                       opencv_core.CvArr image,
                       opencv_core.CvArr eigenval,
                       int block_size,
                       int aperture_size)

\brief Calculates minimal eigenvalue for 2x2 gradient covariation matrix at every image pixel

See Also:: cv::cornerMinEigenVal

cvCornerMinEigenVal

public static void cvCornerMinEigenVal(@Const
                       opencv_core.CvArr image,
                       opencv_core.CvArr eigenval,
                       int block_size)

cvCornerHarris

public static void cvCornerHarris(@Const
                  opencv_core.CvArr image,
                  opencv_core.CvArr harris_response,
                  int block_size,
                  int aperture_size,
                  double k)

\brief Harris corner detector:

Calculates det(M) - k*(trace(M)^2), where M is 2x2 gradient covariation matrix for each pixel

See Also:: cv::cornerHarris

cvCornerHarris

public static void cvCornerHarris(@Const
                  opencv_core.CvArr image,
                  opencv_core.CvArr harris_response,
                  int block_size)

cvFindCornerSubPix

public static void cvFindCornerSubPix(@Const
                      opencv_core.CvArr image,
                      opencv_core.CvPoint2D32f corners,
                      int count,
                      @ByVal
                      opencv_core.CvSize win,
                      @ByVal
                      opencv_core.CvSize zero_zone,
                      @ByVal
                      opencv_core.CvTermCriteria criteria)

\brief Adjust corner position using some sort of gradient search

See Also:: cv::cornerSubPix

cvFindCornerSubPix

public static void cvFindCornerSubPix(@Const
                      opencv_core.CvArr image,
                      @Cast(value="CvPoint2D32f*")
                      FloatBuffer corners,
                      int count,
                      @ByVal
                      opencv_core.CvSize win,
                      @ByVal
                      opencv_core.CvSize zero_zone,
                      @ByVal
                      opencv_core.CvTermCriteria criteria)

cvFindCornerSubPix

public static void cvFindCornerSubPix(@Const
                      opencv_core.CvArr image,
                      @Cast(value="CvPoint2D32f*")
                      float[] corners,
                      int count,
                      @ByVal
                      opencv_core.CvSize win,
                      @ByVal
                      opencv_core.CvSize zero_zone,
                      @ByVal
                      opencv_core.CvTermCriteria criteria)

cvGoodFeaturesToTrack

public static void cvGoodFeaturesToTrack(@Const
                         opencv_core.CvArr image,
                         opencv_core.CvArr eig_image,
                         opencv_core.CvArr temp_image,
                         opencv_core.CvPoint2D32f corners,
                         IntPointer corner_count,
                         double quality_level,
                         double min_distance,
                         @Const
                         opencv_core.CvArr mask,
                         int block_size,
                         int use_harris,
                         double k)

\brief Finds a sparse set of points within the selected region that seem to be easy to track

See Also:: cv::goodFeaturesToTrack

cvGoodFeaturesToTrack

public static void cvGoodFeaturesToTrack(@Const
                         opencv_core.CvArr image,
                         opencv_core.CvArr eig_image,
                         opencv_core.CvArr temp_image,
                         opencv_core.CvPoint2D32f corners,
                         IntPointer corner_count,
                         double quality_level,
                         double min_distance)

cvGoodFeaturesToTrack

public static void cvGoodFeaturesToTrack(@Const
                         opencv_core.CvArr image,
                         opencv_core.CvArr eig_image,
                         opencv_core.CvArr temp_image,
                         @Cast(value="CvPoint2D32f*")
                         FloatBuffer corners,
                         IntBuffer corner_count,
                         double quality_level,
                         double min_distance,
                         @Const
                         opencv_core.CvArr mask,
                         int block_size,
                         int use_harris,
                         double k)

cvGoodFeaturesToTrack

public static void cvGoodFeaturesToTrack(@Const
                         opencv_core.CvArr image,
                         opencv_core.CvArr eig_image,
                         opencv_core.CvArr temp_image,
                         @Cast(value="CvPoint2D32f*")
                         FloatBuffer corners,
                         IntBuffer corner_count,
                         double quality_level,
                         double min_distance)

cvGoodFeaturesToTrack

public static void cvGoodFeaturesToTrack(@Const
                         opencv_core.CvArr image,
                         opencv_core.CvArr eig_image,
                         opencv_core.CvArr temp_image,
                         @Cast(value="CvPoint2D32f*")
                         float[] corners,
                         int[] corner_count,
                         double quality_level,
                         double min_distance,
                         @Const
                         opencv_core.CvArr mask,
                         int block_size,
                         int use_harris,
                         double k)

cvGoodFeaturesToTrack

public static void cvGoodFeaturesToTrack(@Const
                         opencv_core.CvArr image,
                         opencv_core.CvArr eig_image,
                         opencv_core.CvArr temp_image,
                         @Cast(value="CvPoint2D32f*")
                         float[] corners,
                         int[] corner_count,
                         double quality_level,
                         double min_distance)

cvHoughLines2

public static opencv_core.CvSeq cvHoughLines2(opencv_core.CvArr image,
                              Pointer line_storage,
                              int method,
                              double rho,
                              double theta,
                              int threshold,
                              double param1,
                              double param2,
                              double min_theta,
                              double max_theta)

\brief Finds lines on binary image using one of several methods.

line_storage is either memory storage or 1 x _max number of lines_ CvMat, its number of columns is changed by the function. method is one of CV_HOUGH_*; rho, theta and threshold are used for each of those methods; param1 ~ line length, param2 ~ line gap - for probabilistic, param1 ~ srn, param2 ~ stn - for multi-scale

See Also:: cv::HoughLines

cvHoughLines2

public static opencv_core.CvSeq cvHoughLines2(opencv_core.CvArr image,
                              Pointer line_storage,
                              int method,
                              double rho,
                              double theta,
                              int threshold)

cvHoughCircles

public static opencv_core.CvSeq cvHoughCircles(opencv_core.CvArr image,
                               Pointer circle_storage,
                               int method,
                               double dp,
                               double min_dist,
                               double param1,
                               double param2,
                               int min_radius,
                               int max_radius)

\brief Finds circles in the image

See Also:: cv::HoughCircles

cvHoughCircles

public static opencv_core.CvSeq cvHoughCircles(opencv_core.CvArr image,
                               Pointer circle_storage,
                               int method,
                               double dp,
                               double min_dist)

cvFitLine

public static void cvFitLine(@Const
             opencv_core.CvArr points,
             int dist_type,
             double param,
             double reps,
             double aeps,
             FloatPointer line)

\brief Fits a line into set of 2d or 3d points in a robust way (M-estimator technique)

See Also:: cv::fitLine

cvFitLine

public static void cvFitLine(@Const
             opencv_core.CvArr points,
             int dist_type,
             double param,
             double reps,
             double aeps,
             FloatBuffer line)

cvFitLine

public static void cvFitLine(@Const
             opencv_core.CvArr points,
             int dist_type,
             double param,
             double reps,
             double aeps,
             float[] line)

cvLine

public static void cvLine(opencv_core.CvArr img,
          @ByVal
          opencv_core.CvPoint pt1,
          @ByVal
          opencv_core.CvPoint pt2,
          @ByVal
          opencv_core.CvScalar color,
          int thickness,
          int line_type,
          int shift)

\brief Draws 4-connected, 8-connected or antialiased line segment connecting two points

See Also:: cv::line

cvLine

public static void cvLine(opencv_core.CvArr img,
          @ByVal
          opencv_core.CvPoint pt1,
          @ByVal
          opencv_core.CvPoint pt2,
          @ByVal
          opencv_core.CvScalar color)

cvLine

public static void cvLine(opencv_core.CvArr img,
          @ByVal@Cast(value="CvPoint*")
          IntBuffer pt1,
          @ByVal@Cast(value="CvPoint*")
          IntBuffer pt2,
          @ByVal
          opencv_core.CvScalar color,
          int thickness,
          int line_type,
          int shift)

cvLine

public static void cvLine(opencv_core.CvArr img,
          @ByVal@Cast(value="CvPoint*")
          IntBuffer pt1,
          @ByVal@Cast(value="CvPoint*")
          IntBuffer pt2,
          @ByVal
          opencv_core.CvScalar color)

cvLine

public static void cvLine(opencv_core.CvArr img,
          @ByVal@Cast(value="CvPoint*")
          int[] pt1,
          @ByVal@Cast(value="CvPoint*")
          int[] pt2,
          @ByVal
          opencv_core.CvScalar color,
          int thickness,
          int line_type,
          int shift)

cvLine

public static void cvLine(opencv_core.CvArr img,
          @ByVal@Cast(value="CvPoint*")
          int[] pt1,
          @ByVal@Cast(value="CvPoint*")
          int[] pt2,
          @ByVal
          opencv_core.CvScalar color)

cvRectangle

public static void cvRectangle(opencv_core.CvArr img,
               @ByVal
               opencv_core.CvPoint pt1,
               @ByVal
               opencv_core.CvPoint pt2,
               @ByVal
               opencv_core.CvScalar color,
               int thickness,
               int line_type,
               int shift)

\brief Draws a rectangle given two opposite corners of the rectangle (pt1 & pt2)

if thickness<0 (e.g. thickness == CV_FILLED), the filled box is drawn

See Also:: cv::rectangle

cvRectangle

public static void cvRectangle(opencv_core.CvArr img,
               @ByVal
               opencv_core.CvPoint pt1,
               @ByVal
               opencv_core.CvPoint pt2,
               @ByVal
               opencv_core.CvScalar color)

cvRectangle

public static void cvRectangle(opencv_core.CvArr img,
               @ByVal@Cast(value="CvPoint*")
               IntBuffer pt1,
               @ByVal@Cast(value="CvPoint*")
               IntBuffer pt2,
               @ByVal
               opencv_core.CvScalar color,
               int thickness,
               int line_type,
               int shift)

cvRectangle

public static void cvRectangle(opencv_core.CvArr img,
               @ByVal@Cast(value="CvPoint*")
               IntBuffer pt1,
               @ByVal@Cast(value="CvPoint*")
               IntBuffer pt2,
               @ByVal
               opencv_core.CvScalar color)

cvRectangle

public static void cvRectangle(opencv_core.CvArr img,
               @ByVal@Cast(value="CvPoint*")
               int[] pt1,
               @ByVal@Cast(value="CvPoint*")
               int[] pt2,
               @ByVal
               opencv_core.CvScalar color,
               int thickness,
               int line_type,
               int shift)

cvRectangle

public static void cvRectangle(opencv_core.CvArr img,
               @ByVal@Cast(value="CvPoint*")
               int[] pt1,
               @ByVal@Cast(value="CvPoint*")
               int[] pt2,
               @ByVal
               opencv_core.CvScalar color)

cvRectangleR

public static void cvRectangleR(opencv_core.CvArr img,
                @ByVal
                opencv_core.CvRect r,
                @ByVal
                opencv_core.CvScalar color,
                int thickness,
                int line_type,
                int shift)

\brief Draws a rectangle specified by a CvRect structure

See Also:: cv::rectangle

cvRectangleR

public static void cvRectangleR(opencv_core.CvArr img,
                @ByVal
                opencv_core.CvRect r,
                @ByVal
                opencv_core.CvScalar color)

cvCircle

public static void cvCircle(opencv_core.CvArr img,
            @ByVal
            opencv_core.CvPoint center,
            int radius,
            @ByVal
            opencv_core.CvScalar color,
            int thickness,
            int line_type,
            int shift)

\brief Draws a circle with specified center and radius.

Thickness works in the same way as with cvRectangle

See Also:: cv::circle

cvCircle

public static void cvCircle(opencv_core.CvArr img,
            @ByVal
            opencv_core.CvPoint center,
            int radius,
            @ByVal
            opencv_core.CvScalar color)

cvCircle

public static void cvCircle(opencv_core.CvArr img,
            @ByVal@Cast(value="CvPoint*")
            IntBuffer center,
            int radius,
            @ByVal
            opencv_core.CvScalar color,
            int thickness,
            int line_type,
            int shift)

cvCircle

public static void cvCircle(opencv_core.CvArr img,
            @ByVal@Cast(value="CvPoint*")
            IntBuffer center,
            int radius,
            @ByVal
            opencv_core.CvScalar color)

cvCircle

public static void cvCircle(opencv_core.CvArr img,
            @ByVal@Cast(value="CvPoint*")
            int[] center,
            int radius,
            @ByVal
            opencv_core.CvScalar color,
            int thickness,
            int line_type,
            int shift)

cvCircle

public static void cvCircle(opencv_core.CvArr img,
            @ByVal@Cast(value="CvPoint*")
            int[] center,
            int radius,
            @ByVal
            opencv_core.CvScalar color)

cvEllipse

public static void cvEllipse(opencv_core.CvArr img,
             @ByVal
             opencv_core.CvPoint center,
             @ByVal
             opencv_core.CvSize axes,
             double angle,
             double start_angle,
             double end_angle,
             @ByVal
             opencv_core.CvScalar color,
             int thickness,
             int line_type,
             int shift)

\brief Draws ellipse outline, filled ellipse, elliptic arc or filled elliptic sector

depending on _thickness_, _start_angle_ and _end_angle_ parameters. The resultant figure is rotated by _angle_. All the angles are in degrees

See Also:: cv::ellipse

cvEllipse

public static void cvEllipse(opencv_core.CvArr img,
             @ByVal
             opencv_core.CvPoint center,
             @ByVal
             opencv_core.CvSize axes,
             double angle,
             double start_angle,
             double end_angle,
             @ByVal
             opencv_core.CvScalar color)

cvEllipse

public static void cvEllipse(opencv_core.CvArr img,
             @ByVal@Cast(value="CvPoint*")
             IntBuffer center,
             @ByVal
             opencv_core.CvSize axes,
             double angle,
             double start_angle,
             double end_angle,
             @ByVal
             opencv_core.CvScalar color,
             int thickness,
             int line_type,
             int shift)

cvEllipse

public static void cvEllipse(opencv_core.CvArr img,
             @ByVal@Cast(value="CvPoint*")
             IntBuffer center,
             @ByVal
             opencv_core.CvSize axes,
             double angle,
             double start_angle,
             double end_angle,
             @ByVal
             opencv_core.CvScalar color)

cvEllipse

public static void cvEllipse(opencv_core.CvArr img,
             @ByVal@Cast(value="CvPoint*")
             int[] center,
             @ByVal
             opencv_core.CvSize axes,
             double angle,
             double start_angle,
             double end_angle,
             @ByVal
             opencv_core.CvScalar color,
             int thickness,
             int line_type,
             int shift)

cvEllipse

public static void cvEllipse(opencv_core.CvArr img,
             @ByVal@Cast(value="CvPoint*")
             int[] center,
             @ByVal
             opencv_core.CvSize axes,
             double angle,
             double start_angle,
             double end_angle,
             @ByVal
             opencv_core.CvScalar color)

cvEllipseBox

public static void cvEllipseBox(opencv_core.CvArr img,
                @ByVal
                opencv_core.CvBox2D box,
                @ByVal
                opencv_core.CvScalar color,
                int thickness,
                int line_type,
                int shift)

cvEllipseBox

public static void cvEllipseBox(opencv_core.CvArr img,
                @ByVal
                opencv_core.CvBox2D box,
                @ByVal
                opencv_core.CvScalar color)

cvFillConvexPoly

public static void cvFillConvexPoly(opencv_core.CvArr img,
                    @Const
                    opencv_core.CvPoint pts,
                    int npts,
                    @ByVal
                    opencv_core.CvScalar color,
                    int line_type,
                    int shift)

\brief Fills convex or monotonous polygon.

See Also:: cv::fillConvexPoly

cvFillConvexPoly

public static void cvFillConvexPoly(opencv_core.CvArr img,
                    @Const
                    opencv_core.CvPoint pts,
                    int npts,
                    @ByVal
                    opencv_core.CvScalar color)

cvFillConvexPoly

public static void cvFillConvexPoly(opencv_core.CvArr img,
                    @Cast(value="const CvPoint*")
                    IntBuffer pts,
                    int npts,
                    @ByVal
                    opencv_core.CvScalar color,
                    int line_type,
                    int shift)

cvFillConvexPoly

public static void cvFillConvexPoly(opencv_core.CvArr img,
                    @Cast(value="const CvPoint*")
                    IntBuffer pts,
                    int npts,
                    @ByVal
                    opencv_core.CvScalar color)

cvFillConvexPoly

public static void cvFillConvexPoly(opencv_core.CvArr img,
                    @Cast(value="const CvPoint*")
                    int[] pts,
                    int npts,
                    @ByVal
                    opencv_core.CvScalar color,
                    int line_type,
                    int shift)

cvFillConvexPoly

public static void cvFillConvexPoly(opencv_core.CvArr img,
                    @Cast(value="const CvPoint*")
                    int[] pts,
                    int npts,
                    @ByVal
                    opencv_core.CvScalar color)

cvFillPoly

public static void cvFillPoly(opencv_core.CvArr img,
              @Cast(value="CvPoint**")
              PointerPointer pts,
              @Const
              IntPointer npts,
              int contours,
              @ByVal
              opencv_core.CvScalar color,
              int line_type,
              int shift)

\brief Fills an area bounded by one or more arbitrary polygons

See Also:: cv::fillPoly

cvFillPoly

public static void cvFillPoly(opencv_core.CvArr img,
              @ByPtrPtr
              opencv_core.CvPoint pts,
              @Const
              IntPointer npts,
              int contours,
              @ByVal
              opencv_core.CvScalar color)

cvFillPoly

public static void cvFillPoly(opencv_core.CvArr img,
              @ByPtrPtr
              opencv_core.CvPoint pts,
              @Const
              IntPointer npts,
              int contours,
              @ByVal
              opencv_core.CvScalar color,
              int line_type,
              int shift)

cvFillPoly

public static void cvFillPoly(opencv_core.CvArr img,
              @Cast(value="CvPoint**")@ByPtrPtr
              IntBuffer pts,
              @Const
              IntBuffer npts,
              int contours,
              @ByVal
              opencv_core.CvScalar color,
              int line_type,
              int shift)

cvFillPoly

public static void cvFillPoly(opencv_core.CvArr img,
              @Cast(value="CvPoint**")@ByPtrPtr
              IntBuffer pts,
              @Const
              IntBuffer npts,
              int contours,
              @ByVal
              opencv_core.CvScalar color)

cvFillPoly

public static void cvFillPoly(opencv_core.CvArr img,
              @Cast(value="CvPoint**")@ByPtrPtr
              int[] pts,
              @Const
              int[] npts,
              int contours,
              @ByVal
              opencv_core.CvScalar color,
              int line_type,
              int shift)

cvFillPoly

public static void cvFillPoly(opencv_core.CvArr img,
              @Cast(value="CvPoint**")@ByPtrPtr
              int[] pts,
              @Const
              int[] npts,
              int contours,
              @ByVal
              opencv_core.CvScalar color)

cvPolyLine

public static void cvPolyLine(opencv_core.CvArr img,
              @Cast(value="CvPoint**")
              PointerPointer pts,
              @Const
              IntPointer npts,
              int contours,
              int is_closed,
              @ByVal
              opencv_core.CvScalar color,
              int thickness,
              int line_type,
              int shift)

\brief Draws one or more polygonal curves

See Also:: cv::polylines

cvPolyLine

public static void cvPolyLine(opencv_core.CvArr img,
              @ByPtrPtr
              opencv_core.CvPoint pts,
              @Const
              IntPointer npts,
              int contours,
              int is_closed,
              @ByVal
              opencv_core.CvScalar color)

cvPolyLine

public static void cvPolyLine(opencv_core.CvArr img,
              @ByPtrPtr
              opencv_core.CvPoint pts,
              @Const
              IntPointer npts,
              int contours,
              int is_closed,
              @ByVal
              opencv_core.CvScalar color,
              int thickness,
              int line_type,
              int shift)

cvPolyLine

public static void cvPolyLine(opencv_core.CvArr img,
              @Cast(value="CvPoint**")@ByPtrPtr
              IntBuffer pts,
              @Const
              IntBuffer npts,
              int contours,
              int is_closed,
              @ByVal
              opencv_core.CvScalar color,
              int thickness,
              int line_type,
              int shift)

cvPolyLine

public static void cvPolyLine(opencv_core.CvArr img,
              @Cast(value="CvPoint**")@ByPtrPtr
              IntBuffer pts,
              @Const
              IntBuffer npts,
              int contours,
              int is_closed,
              @ByVal
              opencv_core.CvScalar color)

cvPolyLine

public static void cvPolyLine(opencv_core.CvArr img,
              @Cast(value="CvPoint**")@ByPtrPtr
              int[] pts,
              @Const
              int[] npts,
              int contours,
              int is_closed,
              @ByVal
              opencv_core.CvScalar color,
              int thickness,
              int line_type,
              int shift)

cvPolyLine

public static void cvPolyLine(opencv_core.CvArr img,
              @Cast(value="CvPoint**")@ByPtrPtr
              int[] pts,
              @Const
              int[] npts,
              int contours,
              int is_closed,
              @ByVal
              opencv_core.CvScalar color)

cvDrawRect

public static void cvDrawRect(opencv_core.CvArr arg1,
              @ByVal
              opencv_core.CvPoint arg2,
              @ByVal
              opencv_core.CvPoint arg3,
              @ByVal
              opencv_core.CvScalar arg4,
              int arg5,
              int arg6,
              int arg7)

cvDrawRect

public static void cvDrawRect(opencv_core.CvArr arg1,
              @ByVal@Cast(value="CvPoint*")
              IntBuffer arg2,
              @ByVal@Cast(value="CvPoint*")
              IntBuffer arg3,
              @ByVal
              opencv_core.CvScalar arg4,
              int arg5,
              int arg6,
              int arg7)

cvDrawRect

public static void cvDrawRect(opencv_core.CvArr arg1,
              @ByVal@Cast(value="CvPoint*")
              int[] arg2,
              @ByVal@Cast(value="CvPoint*")
              int[] arg3,
              @ByVal
              opencv_core.CvScalar arg4,
              int arg5,
              int arg6,
              int arg7)

cvDrawLine

public static void cvDrawLine(opencv_core.CvArr arg1,
              @ByVal
              opencv_core.CvPoint arg2,
              @ByVal
              opencv_core.CvPoint arg3,
              @ByVal
              opencv_core.CvScalar arg4,
              int arg5,
              int arg6,
              int arg7)

cvDrawLine

public static void cvDrawLine(opencv_core.CvArr arg1,
              @ByVal@Cast(value="CvPoint*")
              IntBuffer arg2,
              @ByVal@Cast(value="CvPoint*")
              IntBuffer arg3,
              @ByVal
              opencv_core.CvScalar arg4,
              int arg5,
              int arg6,
              int arg7)

cvDrawLine

public static void cvDrawLine(opencv_core.CvArr arg1,
              @ByVal@Cast(value="CvPoint*")
              int[] arg2,
              @ByVal@Cast(value="CvPoint*")
              int[] arg3,
              @ByVal
              opencv_core.CvScalar arg4,
              int arg5,
              int arg6,
              int arg7)

cvDrawCircle

public static void cvDrawCircle(opencv_core.CvArr arg1,
                @ByVal
                opencv_core.CvPoint arg2,
                int arg3,
                @ByVal
                opencv_core.CvScalar arg4,
                int arg5,
                int arg6,
                int arg7)

cvDrawCircle

public static void cvDrawCircle(opencv_core.CvArr arg1,
                @ByVal@Cast(value="CvPoint*")
                IntBuffer arg2,
                int arg3,
                @ByVal
                opencv_core.CvScalar arg4,
                int arg5,
                int arg6,
                int arg7)

cvDrawCircle

public static void cvDrawCircle(opencv_core.CvArr arg1,
                @ByVal@Cast(value="CvPoint*")
                int[] arg2,
                int arg3,
                @ByVal
                opencv_core.CvScalar arg4,
                int arg5,
                int arg6,
                int arg7)

cvDrawEllipse

public static void cvDrawEllipse(opencv_core.CvArr arg1,
                 @ByVal
                 opencv_core.CvPoint arg2,
                 @ByVal
                 opencv_core.CvSize arg3,
                 double arg4,
                 double arg5,
                 double arg6,
                 @ByVal
                 opencv_core.CvScalar arg7,
                 int arg8,
                 int arg9,
                 int arg10)

cvDrawEllipse

public static void cvDrawEllipse(opencv_core.CvArr arg1,
                 @ByVal@Cast(value="CvPoint*")
                 IntBuffer arg2,
                 @ByVal
                 opencv_core.CvSize arg3,
                 double arg4,
                 double arg5,
                 double arg6,
                 @ByVal
                 opencv_core.CvScalar arg7,
                 int arg8,
                 int arg9,
                 int arg10)

cvDrawEllipse

public static void cvDrawEllipse(opencv_core.CvArr arg1,
                 @ByVal@Cast(value="CvPoint*")
                 int[] arg2,
                 @ByVal
                 opencv_core.CvSize arg3,
                 double arg4,
                 double arg5,
                 double arg6,
                 @ByVal
                 opencv_core.CvScalar arg7,
                 int arg8,
                 int arg9,
                 int arg10)

cvDrawPolyLine

public static void cvDrawPolyLine(opencv_core.CvArr arg1,
                  @Cast(value="CvPoint**")
                  PointerPointer arg2,
                  IntPointer arg3,
                  int arg4,
                  int arg5,
                  @ByVal
                  opencv_core.CvScalar arg6,
                  int arg7,
                  int arg8,
                  int arg9)

cvDrawPolyLine

public static void cvDrawPolyLine(opencv_core.CvArr arg1,
                  @ByPtrPtr
                  opencv_core.CvPoint arg2,
                  IntPointer arg3,
                  int arg4,
                  int arg5,
                  @ByVal
                  opencv_core.CvScalar arg6,
                  int arg7,
                  int arg8,
                  int arg9)

cvDrawPolyLine

public static void cvDrawPolyLine(opencv_core.CvArr arg1,
                  @Cast(value="CvPoint**")@ByPtrPtr
                  IntBuffer arg2,
                  IntBuffer arg3,
                  int arg4,
                  int arg5,
                  @ByVal
                  opencv_core.CvScalar arg6,
                  int arg7,
                  int arg8,
                  int arg9)

cvDrawPolyLine

public static void cvDrawPolyLine(opencv_core.CvArr arg1,
                  @Cast(value="CvPoint**")@ByPtrPtr
                  int[] arg2,
                  int[] arg3,
                  int arg4,
                  int arg5,
                  @ByVal
                  opencv_core.CvScalar arg6,
                  int arg7,
                  int arg8,
                  int arg9)

cvClipLine

public static int cvClipLine(@ByVal
             opencv_core.CvSize img_size,
             opencv_core.CvPoint pt1,
             opencv_core.CvPoint pt2)

\brief Clips the line segment connecting *pt1 and *pt2 by the rectangular window

(0<=x

See Also:: cv::clipLine

cvClipLine

public static int cvClipLine(@ByVal
             opencv_core.CvSize img_size,
             @Cast(value="CvPoint*")
             IntBuffer pt1,
             @Cast(value="CvPoint*")
             IntBuffer pt2)

cvClipLine

public static int cvClipLine(@ByVal
             opencv_core.CvSize img_size,
             @Cast(value="CvPoint*")
             int[] pt1,
             @Cast(value="CvPoint*")
             int[] pt2)

cvInitLineIterator

public static int cvInitLineIterator(@Const
                     opencv_core.CvArr image,
                     @ByVal
                     opencv_core.CvPoint pt1,
                     @ByVal
                     opencv_core.CvPoint pt2,
                     opencv_core.CvLineIterator line_iterator,
                     int connectivity,
                     int left_to_right)

\brief Initializes line iterator.

Initially, line_iterator->ptr will point to pt1 (or pt2, see left_to_right description) location in the image. Returns the number of pixels on the line between the ending points.

See Also:: cv::LineIterator

cvInitLineIterator

public static int cvInitLineIterator(@Const
                     opencv_core.CvArr image,
                     @ByVal
                     opencv_core.CvPoint pt1,
                     @ByVal
                     opencv_core.CvPoint pt2,
                     opencv_core.CvLineIterator line_iterator)

cvInitLineIterator

public static int cvInitLineIterator(@Const
                     opencv_core.CvArr image,
                     @ByVal@Cast(value="CvPoint*")
                     IntBuffer pt1,
                     @ByVal@Cast(value="CvPoint*")
                     IntBuffer pt2,
                     opencv_core.CvLineIterator line_iterator,
                     int connectivity,
                     int left_to_right)

cvInitLineIterator

public static int cvInitLineIterator(@Const
                     opencv_core.CvArr image,
                     @ByVal@Cast(value="CvPoint*")
                     IntBuffer pt1,
                     @ByVal@Cast(value="CvPoint*")
                     IntBuffer pt2,
                     opencv_core.CvLineIterator line_iterator)

cvInitLineIterator

public static int cvInitLineIterator(@Const
                     opencv_core.CvArr image,
                     @ByVal@Cast(value="CvPoint*")
                     int[] pt1,
                     @ByVal@Cast(value="CvPoint*")
                     int[] pt2,
                     opencv_core.CvLineIterator line_iterator,
                     int connectivity,
                     int left_to_right)

cvInitLineIterator

public static int cvInitLineIterator(@Const
                     opencv_core.CvArr image,
                     @ByVal@Cast(value="CvPoint*")
                     int[] pt1,
                     @ByVal@Cast(value="CvPoint*")
                     int[] pt2,
                     opencv_core.CvLineIterator line_iterator)

cvInitFont
```
public static void cvInitFont(opencv_imgproc.CvFont font,
              int font_face,
              double hscale,
              double vscale,
              double shear,
              int thickness,
              int line_type)
```
\brief Initializes font structure (OpenCV 1.x API).
The function initializes the font structure that can be passed to text rendering functions.

Parameters:
font - Pointer to the font structure initialized by the function
font_face - Font name identifier. See cv::HersheyFonts and corresponding old CV_* identifiers.
hscale - Horizontal scale. If equal to 1.0f , the characters have the original width depending on the font type. If equal to 0.5f , the characters are of half the original width.
vscale - Vertical scale. If equal to 1.0f , the characters have the original height depending on the font type. If equal to 0.5f , the characters are of half the original height.
shear - Approximate tangent of the character slope relative to the vertical line. A zero value means a non-italic font, 1.0f means about a 45 degree slope, etc.
thickness - Thickness of the text strokes
line_type - Type of the strokes, see line description
\sa cvPutText

cvInitFont

public static void cvInitFont(opencv_imgproc.CvFont font,
              int font_face,
              double hscale,
              double vscale)

cvFont

@ByVal
public static opencv_imgproc.CvFont cvFont(double scale,
                                 int thickness)

cvFont

@ByVal
public static opencv_imgproc.CvFont cvFont(double scale)

cvPutText

public static void cvPutText(opencv_core.CvArr img,
             @Cast(value="const char*")
             BytePointer text,
             @ByVal
             opencv_core.CvPoint org,
             @Const
             opencv_imgproc.CvFont font,
             @ByVal
             opencv_core.CvScalar color)

\brief Renders text stroke with specified font and color at specified location. CvFont should be initialized with cvInitFont

See Also:: cvInitFont, cvGetTextSize, cvFont, cv::putText

cvPutText

public static void cvPutText(opencv_core.CvArr img,
             String text,
             @ByVal@Cast(value="CvPoint*")
             IntBuffer org,
             @Const
             opencv_imgproc.CvFont font,
             @ByVal
             opencv_core.CvScalar color)

cvPutText

public static void cvPutText(opencv_core.CvArr img,
             @Cast(value="const char*")
             BytePointer text,
             @ByVal@Cast(value="CvPoint*")
             int[] org,
             @Const
             opencv_imgproc.CvFont font,
             @ByVal
             opencv_core.CvScalar color)

cvPutText

public static void cvPutText(opencv_core.CvArr img,
             String text,
             @ByVal
             opencv_core.CvPoint org,
             @Const
             opencv_imgproc.CvFont font,
             @ByVal
             opencv_core.CvScalar color)

cvPutText

public static void cvPutText(opencv_core.CvArr img,
             @Cast(value="const char*")
             BytePointer text,
             @ByVal@Cast(value="CvPoint*")
             IntBuffer org,
             @Const
             opencv_imgproc.CvFont font,
             @ByVal
             opencv_core.CvScalar color)

cvPutText

public static void cvPutText(opencv_core.CvArr img,
             String text,
             @ByVal@Cast(value="CvPoint*")
             int[] org,
             @Const
             opencv_imgproc.CvFont font,
             @ByVal
             opencv_core.CvScalar color)

cvGetTextSize

public static void cvGetTextSize(@Cast(value="const char*")
                 BytePointer text_string,
                 @Const
                 opencv_imgproc.CvFont font,
                 opencv_core.CvSize text_size,
                 IntPointer baseline)

\brief Calculates bounding box of text stroke (useful for alignment)

See Also:: cv::getTextSize

cvGetTextSize

public static void cvGetTextSize(String text_string,
                 @Const
                 opencv_imgproc.CvFont font,
                 opencv_core.CvSize text_size,
                 IntBuffer baseline)

cvGetTextSize

public static void cvGetTextSize(@Cast(value="const char*")
                 BytePointer text_string,
                 @Const
                 opencv_imgproc.CvFont font,
                 opencv_core.CvSize text_size,
                 int[] baseline)

cvGetTextSize

public static void cvGetTextSize(String text_string,
                 @Const
                 opencv_imgproc.CvFont font,
                 opencv_core.CvSize text_size,
                 IntPointer baseline)

cvGetTextSize

public static void cvGetTextSize(@Cast(value="const char*")
                 BytePointer text_string,
                 @Const
                 opencv_imgproc.CvFont font,
                 opencv_core.CvSize text_size,
                 IntBuffer baseline)

cvGetTextSize

public static void cvGetTextSize(String text_string,
                 @Const
                 opencv_imgproc.CvFont font,
                 opencv_core.CvSize text_size,
                 int[] baseline)

cvColorToScalar
```
@ByVal
public static opencv_core.CvScalar cvColorToScalar(double packed_color,
                                         int arrtype)
```
\brief Unpacks color value
if arrtype is CV_8UC?, _color_ is treated as packed color value, otherwise the first channels (depending on arrtype) of destination scalar are set to the same value = _color_

cvEllipse2Poly
```
public static int cvEllipse2Poly(@ByVal
                 opencv_core.CvPoint center,
                 @ByVal
                 opencv_core.CvSize axes,
                 int angle,
                 int arc_start,
                 int arc_end,
                 opencv_core.CvPoint pts,
                 int delta)
```
\brief Returns the polygon points which make up the given ellipse.
The ellipse is define by the box of size 'axes' rotated 'angle' around the 'center'. A partial sweep of the ellipse arc can be done by spcifying arc_start and arc_end to be something other than 0 and 360, respectively. The input array 'pts' must be large enough to hold the result. The total number of points stored into 'pts' is returned by this function.

See Also:
cv::ellipse2Poly

cvEllipse2Poly

public static int cvEllipse2Poly(@ByVal@Cast(value="CvPoint*")
                 IntBuffer center,
                 @ByVal
                 opencv_core.CvSize axes,
                 int angle,
                 int arc_start,
                 int arc_end,
                 @Cast(value="CvPoint*")
                 IntBuffer pts,
                 int delta)

cvEllipse2Poly

public static int cvEllipse2Poly(@ByVal@Cast(value="CvPoint*")
                 int[] center,
                 @ByVal
                 opencv_core.CvSize axes,
                 int angle,
                 int arc_start,
                 int arc_end,
                 @Cast(value="CvPoint*")
                 int[] pts,
                 int delta)

cvDrawContours

public static void cvDrawContours(opencv_core.CvArr img,
                  opencv_core.CvSeq contour,
                  @ByVal
                  opencv_core.CvScalar external_color,
                  @ByVal
                  opencv_core.CvScalar hole_color,
                  int max_level,
                  int thickness,
                  int line_type,
                  @ByVal(nullValue="cvPoint(0,0)")
                  opencv_core.CvPoint offset)

\brief Draws contour outlines or filled interiors on the image

See Also:: cv::drawContours

cvDrawContours

public static void cvDrawContours(opencv_core.CvArr img,
                  opencv_core.CvSeq contour,
                  @ByVal
                  opencv_core.CvScalar external_color,
                  @ByVal
                  opencv_core.CvScalar hole_color,
                  int max_level)

cvDrawContours

public static void cvDrawContours(opencv_core.CvArr img,
                  opencv_core.CvSeq contour,
                  @ByVal
                  opencv_core.CvScalar external_color,
                  @ByVal
                  opencv_core.CvScalar hole_color,
                  int max_level,
                  int thickness,
                  int line_type,
                  @ByVal(nullValue="cvPoint(0,0)")@Cast(value="CvPoint*")
                  IntBuffer offset)

cvDrawContours

public static void cvDrawContours(opencv_core.CvArr img,
                  opencv_core.CvSeq contour,
                  @ByVal
                  opencv_core.CvScalar external_color,
                  @ByVal
                  opencv_core.CvScalar hole_color,
                  int max_level,
                  int thickness,
                  int line_type,
                  @ByVal(nullValue="cvPoint(0,0)")@Cast(value="CvPoint*")
                  int[] offset)

createLineSegmentDetector

@Namespace(value="cv")
@opencv_core.Ptr
public static opencv_imgproc.LineSegmentDetector createLineSegmentDetector(int _refine,
                                                                                          double _scale,
                                                                                          double _sigma_scale,
                                                                                          double _quant,
                                                                                          double _ang_th,
                                                                                          double _log_eps,
                                                                                          double _density_th,
                                                                                          int _n_bins)

\brief Creates a smart pointer to a LineSegmentDetector object and initializes it.

The LineSegmentDetector algorithm is defined using the standard values. Only advanced users may want to edit those, as to tailor it for their own application.

Parameters:: _refine - The way found lines will be refined, see cv::LineSegmentDetectorModes; _scale - The scale of the image that will be used to find the lines. Range (0..1].; _sigma_scale - Sigma for Gaussian filter. It is computed as sigma = _sigma_scale/_scale.; _quant - Bound to the quantization error on the gradient norm.; _ang_th - Gradient angle tolerance in degrees.; _log_eps - Detection threshold: -log10(NFA) \> log_eps. Used only when advancent refinement is chosen.; _density_th - Minimal density of aligned region points in the enclosing rectangle.; _n_bins - Number of bins in pseudo-ordering of gradient modulus.

createLineSegmentDetector

@Namespace(value="cv")
@opencv_core.Ptr
public static opencv_imgproc.LineSegmentDetector createLineSegmentDetector()

getGaussianKernel
```
@Namespace(value="cv")
@ByVal
public static opencv_core.Mat getGaussianKernel(int ksize,
                                                     double sigma,
                                                     int ktype)
```
\} imgproc_feature
\addtogroup imgproc_filter \{
/** \brief Returns Gaussian filter coefficients.
The function computes and returns the \f$\texttt{ksize} \times 1\f$ matrix of Gaussian filter coefficients:
\f[G_i= \alpha *e^{-(i-( \texttt{ksize} -1)/2)^2/(2* \texttt{sigma}^2)},\f]
where \f$i=0..\texttt{ksize}-1\f$ and \f$\alpha\f$ is the scale factor chosen so that \f$\sum_i G_i=1\f$.
Two of such generated kernels can be passed to sepFilter2D. Those functions automatically recognize smoothing kernels (a symmetrical kernel with sum of weights equal to 1) and handle them accordingly. You may also use the higher-level GaussianBlur.

Parameters:
ksize - Aperture size. It should be odd ( \f$\texttt{ksize} \mod 2 = 1\f$ ) and positive.
sigma - Gaussian standard deviation. If it is non-positive, it is computed from ksize as sigma = 0.3\*((ksize-1)\*0.5 - 1) + 0.8.
ktype - Type of filter coefficients. It can be CV_32F or CV_64F . \sa sepFilter2D, getDerivKernels, getStructuringElement, GaussianBlur

getGaussianKernel

@Namespace(value="cv")
@ByVal
public static opencv_core.Mat getGaussianKernel(int ksize,
                                                     double sigma)

getDerivKernels
```
@Namespace(value="cv")
public static void getDerivKernels(@ByVal
                                  opencv_core.Mat kx,
                                  @ByVal
                                  opencv_core.Mat ky,
                                  int dx,
                                  int dy,
                                  int ksize,
                                  @Cast(value="bool")
                                  boolean normalize,
                                  int ktype)
```
\brief Returns filter coefficients for computing spatial image derivatives.
The function computes and returns the filter coefficients for spatial image derivatives. When ksize=CV_SCHARR, the Scharr \f$3 \times 3\f$ kernels are generated (see cv::Scharr). Otherwise, Sobel kernels are generated (see cv::Sobel). The filters are normally passed to sepFilter2D or to

Parameters:
kx - Output matrix of row filter coefficients. It has the type ktype .
ky - Output matrix of column filter coefficients. It has the type ktype .
dx - Derivative order in respect of x.
dy - Derivative order in respect of y.
ksize - Aperture size. It can be CV_SCHARR, 1, 3, 5, or 7.
normalize - Flag indicating whether to normalize (scale down) the filter coefficients or not. Theoretically, the coefficients should have the denominator \f$=2^{ksize*2-dx-dy-2}\f$. If you are going to filter floating-point images, you are likely to use the normalized kernels. But if you compute derivatives of an 8-bit image, store the results in a 16-bit image, and wish to preserve all the fractional bits, you may want to set normalize=false .
ktype - Type of filter coefficients. It can be CV_32f or CV_64F .

getDerivKernels

@Namespace(value="cv")
public static void getDerivKernels(@ByVal
                                  opencv_core.Mat kx,
                                  @ByVal
                                  opencv_core.Mat ky,
                                  int dx,
                                  int dy,
                                  int ksize)

getGaborKernel

@Namespace(value="cv")
@ByVal
public static opencv_core.Mat getGaborKernel(@ByVal
                                                  opencv_core.Size ksize,
                                                  double sigma,
                                                  double theta,
                                                  double lambd,
                                                  double gamma,
                                                  double psi,
                                                  int ktype)

\brief Returns Gabor filter coefficients.

For more details about gabor filter equations and parameters, see: [Gabor Filter](http://en.wikipedia.org/wiki/Gabor_filter).

Parameters:: ksize - Size of the filter returned.; sigma - Standard deviation of the gaussian envelope.; theta - Orientation of the normal to the parallel stripes of a Gabor function.; lambd - Wavelength of the sinusoidal factor.; gamma - Spatial aspect ratio.; psi - Phase offset.; ktype - Type of filter coefficients. It can be CV_32F or CV_64F .

getGaborKernel

@Namespace(value="cv")
@ByVal
public static opencv_core.Mat getGaborKernel(@ByVal
                                                  opencv_core.Size ksize,
                                                  double sigma,
                                                  double theta,
                                                  double lambd,
                                                  double gamma)

morphologyDefaultBorderValue
```
@Namespace(value="cv")
@ByVal
public static opencv_core.Scalar morphologyDefaultBorderValue()
```
returns "magic" border value for erosion and dilation. It is automatically transformed to Scalar::all(-DBL_MAX) for dilation.

getStructuringElement
```
@Namespace(value="cv")
@ByVal
public static opencv_core.Mat getStructuringElement(int shape,
                                                         @ByVal
                                                         opencv_core.Size ksize,
                                                         @ByVal(nullValue="cv::Point(-1,-1)")
                                                         opencv_core.Point anchor)
```
\brief Returns a structuring element of the specified size and shape for morphological operations.
The function constructs and returns the structuring element that can be further passed to cv::erode, cv::dilate or cv::morphologyEx. But you can also construct an arbitrary binary mask yourself and use it as the structuring element.

Parameters:
shape - Element shape that could be one of cv::MorphShapes
ksize - Size of the structuring element.
anchor - Anchor position within the element. The default value \f$(-1, -1)\f$ means that the anchor is at the center. Note that only the shape of a cross-shaped element depends on the anchor position. In other cases the anchor just regulates how much the result of the morphological operation is shifted.

getStructuringElement

@Namespace(value="cv")
@ByVal
public static opencv_core.Mat getStructuringElement(int shape,
                                                         @ByVal
                                                         opencv_core.Size ksize)

medianBlur
```
@Namespace(value="cv")
public static void medianBlur(@ByVal
                             opencv_core.Mat src,
                             @ByVal
                             opencv_core.Mat dst,
                             int ksize)
```
\brief Blurs an image using the median filter.
The function smoothes an image using the median filter with the \f$\texttt{ksize} \times \texttt{ksize}\f$ aperture. Each channel of a multi-channel image is processed independently. In-place operation is supported.

Parameters:
src - input 1-, 3-, or 4-channel image; when ksize is 3 or 5, the image depth should be CV_8U, CV_16U, or CV_32F, for larger aperture sizes, it can only be CV_8U.
dst - destination array of the same size and type as src.
ksize - aperture linear size; it must be odd and greater than 1, for example: 3, 5, 7 ... \sa bilateralFilter, blur, boxFilter, GaussianBlur

GaussianBlur
```
@Namespace(value="cv")
public static void GaussianBlur(@ByVal
                               opencv_core.Mat src,
                               @ByVal
                               opencv_core.Mat dst,
                               @ByVal
                               opencv_core.Size ksize,
                               double sigmaX,
                               double sigmaY,
                               int borderType)
```
\brief Blurs an image using a Gaussian filter.
The function convolves the source image with the specified Gaussian kernel. In-place filtering is supported.

Parameters:
src - input image; the image can have any number of channels, which are processed independently, but the depth should be CV_8U, CV_16U, CV_16S, CV_32F or CV_64F.
dst - output image of the same size and type as src.
ksize - Gaussian kernel size. ksize.width and ksize.height can differ but they both must be positive and odd. Or, they can be zero's and then they are computed from sigma.
sigmaX - Gaussian kernel standard deviation in X direction.
sigmaY - Gaussian kernel standard deviation in Y direction; if sigmaY is zero, it is set to be equal to sigmaX, if both sigmas are zeros, they are computed from ksize.width and ksize.height, respectively (see cv::getGaussianKernel for details); to fully control the result regardless of possible future modifications of all this semantics, it is recommended to specify all of ksize, sigmaX, and sigmaY.
borderType - pixel extrapolation method, see cv::BorderTypes
\sa sepFilter2D, filter2D, blur, boxFilter, bilateralFilter, medianBlur

GaussianBlur

@Namespace(value="cv")
public static void GaussianBlur(@ByVal
                               opencv_core.Mat src,
                               @ByVal
                               opencv_core.Mat dst,
                               @ByVal
                               opencv_core.Size ksize,
                               double sigmaX)

bilateralFilter
```
@Namespace(value="cv")
public static void bilateralFilter(@ByVal
                                  opencv_core.Mat src,
                                  @ByVal
                                  opencv_core.Mat dst,
                                  int d,
                                  double sigmaColor,
                                  double sigmaSpace,
                                  int borderType)
```
\brief Applies the bilateral filter to an image.
The function applies bilateral filtering to the input image, as described in http://www.dai.ed.ac.uk/CVonline/LOCAL_COPIES/MANDUCHI1/Bilateral_Filtering.html bilateralFilter can reduce unwanted noise very well while keeping edges fairly sharp. However, it is very slow compared to most filters.
_Sigma values_: For simplicity, you can set the 2 sigma values to be the same. If they are small (\< 10), the filter will not have much effect, whereas if they are large (\> 150), they will have a very strong effect, making the image look "cartoonish".
_Filter size_: Large filters (d \> 5) are very slow, so it is recommended to use d=5 for real-time applications, and perhaps d=9 for offline applications that need heavy noise filtering.
This filter does not work inplace.

Parameters:
src - Source 8-bit or floating-point, 1-channel or 3-channel image.
dst - Destination image of the same size and type as src .
d - Diameter of each pixel neighborhood that is used during filtering. If it is non-positive, it is computed from sigmaSpace.
sigmaColor - Filter sigma in the color space. A larger value of the parameter means that farther colors within the pixel neighborhood (see sigmaSpace) will be mixed together, resulting in larger areas of semi-equal color.
sigmaSpace - Filter sigma in the coordinate space. A larger value of the parameter means that farther pixels will influence each other as long as their colors are close enough (see sigmaColor ). When d\>0, it specifies the neighborhood size regardless of sigmaSpace. Otherwise, d is proportional to sigmaSpace.
borderType - border mode used to extrapolate pixels outside of the image, see cv::BorderTypes

bilateralFilter

@Namespace(value="cv")
public static void bilateralFilter(@ByVal
                                  opencv_core.Mat src,
                                  @ByVal
                                  opencv_core.Mat dst,
                                  int d,
                                  double sigmaColor,
                                  double sigmaSpace)

boxFilter
```
@Namespace(value="cv")
public static void boxFilter(@ByVal
                            opencv_core.Mat src,
                            @ByVal
                            opencv_core.Mat dst,
                            int ddepth,
                            @ByVal
                            opencv_core.Size ksize,
                            @ByVal(nullValue="cv::Point(-1,-1)")
                            opencv_core.Point anchor,
                            @Cast(value="bool")
                            boolean normalize,
                            int borderType)
```
\brief Blurs an image using the box filter.
The function smoothes an image using the kernel:
\f[\texttt{K} = \alpha \begin{bmatrix} 1 & 1 & 1 & \cdots & 1 & 1 \\ 1 & 1 & 1 & \cdots & 1 & 1 \\ \hdotsfor{6} \\ 1 & 1 & 1 & \cdots & 1 & 1 \end{bmatrix}\f]
where
\f[\alpha = \fork{\frac{1}{\texttt{ksize.width*ksize.height}}}{when \texttt{normalize=true}}{1}{otherwise}\f]
Unnormalized box filter is useful for computing various integral characteristics over each pixel neighborhood, such as covariance matrices of image derivatives (used in dense optical flow algorithms, and so on). If you need to compute pixel sums over variable-size windows, use cv::integral.

Parameters:
src - input image.
dst - output image of the same size and type as src.
ddepth - the output image depth (-1 to use src.depth()).
ksize - blurring kernel size.
anchor - anchor point; default value Point(-1,-1) means that the anchor is at the kernel center.
normalize - flag, specifying whether the kernel is normalized by its area or not.
borderType - border mode used to extrapolate pixels outside of the image, see cv::BorderTypes \sa blur, bilateralFilter, GaussianBlur, medianBlur, integral

boxFilter

@Namespace(value="cv")
public static void boxFilter(@ByVal
                            opencv_core.Mat src,
                            @ByVal
                            opencv_core.Mat dst,
                            int ddepth,
                            @ByVal
                            opencv_core.Size ksize)

sqrBoxFilter
```
@Namespace(value="cv")
public static void sqrBoxFilter(@ByVal
                               opencv_core.Mat _src,
                               @ByVal
                               opencv_core.Mat _dst,
                               int ddepth,
                               @ByVal
                               opencv_core.Size ksize,
                               @ByVal(nullValue="cv::Point(-1, -1)")
                               opencv_core.Point anchor,
                               @Cast(value="bool")
                               boolean normalize,
                               int borderType)
```
\brief Calculates the normalized sum of squares of the pixel values overlapping the filter.
For every pixel \f$ (x, y) \f$ in the source image, the function calculates the sum of squares of those neighboring pixel values which overlap the filter placed over the pixel \f$ (x, y) \f$.
The unnormalized square box filter can be useful in computing local image statistics such as the the local variance and standard deviation around the neighborhood of a pixel.

Parameters:
_src - input image
_dst - output image of the same size and type as _src
ddepth - the output image depth (-1 to use src.depth())
ksize - kernel size
anchor - kernel anchor point. The default value of Point(-1, -1) denotes that the anchor is at the kernel center.
normalize - flag, specifying whether the kernel is to be normalized by it's area or not.
borderType - border mode used to extrapolate pixels outside of the image, see cv::BorderTypes \sa boxFilter

sqrBoxFilter

@Namespace(value="cv")
public static void sqrBoxFilter(@ByVal
                               opencv_core.Mat _src,
                               @ByVal
                               opencv_core.Mat _dst,
                               int ddepth,
                               @ByVal
                               opencv_core.Size ksize)

blur
```
@Namespace(value="cv")
public static void blur(@ByVal
                       opencv_core.Mat src,
                       @ByVal
                       opencv_core.Mat dst,
                       @ByVal
                       opencv_core.Size ksize,
                       @ByVal(nullValue="cv::Point(-1,-1)")
                       opencv_core.Point anchor,
                       int borderType)
```
\brief Blurs an image using the normalized box filter.
The function smoothes an image using the kernel:
\f[\texttt{K} = \frac{1}{\texttt{ksize.width*ksize.height}} \begin{bmatrix} 1 & 1 & 1 & \cdots & 1 & 1 \\ 1 & 1 & 1 & \cdots & 1 & 1 \\ \hdotsfor{6} \\ 1 & 1 & 1 & \cdots & 1 & 1 \\ \end{bmatrix}\f]
The call blur(src, dst, ksize, anchor, borderType) is equivalent to boxFilter(src, dst, src.type(), anchor, true, borderType).

Parameters:
src - input image; it can have any number of channels, which are processed independently, but the depth should be CV_8U, CV_16U, CV_16S, CV_32F or CV_64F.
dst - output image of the same size and type as src.
ksize - blurring kernel size.
anchor - anchor point; default value Point(-1,-1) means that the anchor is at the kernel center.
borderType - border mode used to extrapolate pixels outside of the image, see cv::BorderTypes \sa boxFilter, bilateralFilter, GaussianBlur, medianBlur

blur

@Namespace(value="cv")
public static void blur(@ByVal
                       opencv_core.Mat src,
                       @ByVal
                       opencv_core.Mat dst,
                       @ByVal
                       opencv_core.Size ksize)

filter2D
```
@Namespace(value="cv")
public static void filter2D(@ByVal
                           opencv_core.Mat src,
                           @ByVal
                           opencv_core.Mat dst,
                           int ddepth,
                           @ByVal
                           opencv_core.Mat kernel,
                           @ByVal(nullValue="cv::Point(-1,-1)")
                           opencv_core.Point anchor,
                           double delta,
                           int borderType)
```
\brief Convolves an image with the kernel.
The function applies an arbitrary linear filter to an image. In-place operation is supported. When the aperture is partially outside the image, the function interpolates outlier pixel values according to the specified border mode.
The function does actually compute correlation, not the convolution:
\f[\texttt{dst} (x,y) = \sum _{ \stackrel{0\leq x' < \texttt{kernel.cols},}{0\leq y' < \texttt{kernel.rows}} } \texttt{kernel} (x',y')* \texttt{src} (x+x'- \texttt{anchor.x} ,y+y'- \texttt{anchor.y} )\f]
That is, the kernel is not mirrored around the anchor point. If you need a real convolution, flip the kernel using cv::flip and set the new anchor to (kernel.cols - anchor.x - 1, kernel.rows - anchor.y - 1).
The function uses the DFT-based algorithm in case of sufficiently large kernels (~11 x 11 or larger) and the direct algorithm for small kernels.

Parameters:
src - input image.
dst - output image of the same size and the same number of channels as src.
ddepth - desired depth of the destination image, see \ref filter_depths "combinations"
kernel - convolution kernel (or rather a correlation kernel), a single-channel floating point matrix; if you want to apply different kernels to different channels, split the image into separate color planes using split and process them individually.
anchor - anchor of the kernel that indicates the relative position of a filtered point within the kernel; the anchor should lie within the kernel; default value (-1,-1) means that the anchor is at the kernel center.
delta - optional value added to the filtered pixels before storing them in dst.
borderType - pixel extrapolation method, see cv::BorderTypes \sa sepFilter2D, dft, matchTemplate

filter2D

@Namespace(value="cv")
public static void filter2D(@ByVal
                           opencv_core.Mat src,
                           @ByVal
                           opencv_core.Mat dst,
                           int ddepth,
                           @ByVal
                           opencv_core.Mat kernel)

sepFilter2D

@Namespace(value="cv")
public static void sepFilter2D(@ByVal
                              opencv_core.Mat src,
                              @ByVal
                              opencv_core.Mat dst,
                              int ddepth,
                              @ByVal
                              opencv_core.Mat kernelX,
                              @ByVal
                              opencv_core.Mat kernelY,
                              @ByVal(nullValue="cv::Point(-1,-1)")
                              opencv_core.Point anchor,
                              double delta,
                              int borderType)

\brief Applies a separable linear filter to an image.

The function applies a separable linear filter to the image. That is, first, every row of src is filtered with the 1D kernel kernelX. Then, every column of the result is filtered with the 1D kernel kernelY. The final result shifted by delta is stored in dst .

Parameters:: src - Source image.; dst - Destination image of the same size and the same number of channels as src .; ddepth - Destination image depth, see \ref filter_depths "combinations"; kernelX - Coefficients for filtering each row.; kernelY - Coefficients for filtering each column.; anchor - Anchor position within the kernel. The default value \f$(-1,-1)\f$ means that the anchor is at the kernel center.; delta - Value added to the filtered results before storing them.; borderType - Pixel extrapolation method, see cv::BorderTypes \sa filter2D, Sobel, GaussianBlur, boxFilter, blur

sepFilter2D

@Namespace(value="cv")
public static void sepFilter2D(@ByVal
                              opencv_core.Mat src,
                              @ByVal
                              opencv_core.Mat dst,
                              int ddepth,
                              @ByVal
                              opencv_core.Mat kernelX,
                              @ByVal
                              opencv_core.Mat kernelY)

Sobel
```
@Namespace(value="cv")
public static void Sobel(@ByVal
                        opencv_core.Mat src,
                        @ByVal
                        opencv_core.Mat dst,
                        int ddepth,
                        int dx,
                        int dy,
                        int ksize,
                        double scale,
                        double delta,
                        int borderType)
```
\brief Calculates the first, second, third, or mixed image derivatives using an extended Sobel operator.
In all cases except one, the \f$\texttt{ksize} \times \texttt{ksize}\f$ separable kernel is used to calculate the derivative. When \f$\texttt{ksize = 1}\f$, the \f$3 \times 1\f$ or \f$1 \times 3\f$ kernel is used (that is, no Gaussian smoothing is done). ksize = 1 can only be used for the first or the second x- or y- derivatives.
There is also the special value ksize = CV_SCHARR (-1) that corresponds to the \f$3\times3\f$ Scharr filter that may give more accurate results than the \f$3\times3\f$ Sobel. The Scharr aperture is
\f[\vecthreethree{-3}{0}{3}{-10}{0}{10}{-3}{0}{3}\f]
for the x-derivative, or transposed for the y-derivative.
The function calculates an image derivative by convolving the image with the appropriate kernel:
\f[\texttt{dst} = \frac{\partial^{xorder+yorder} \texttt{src}}{\partial x^{xorder} \partial y^{yorder}}\f]
The Sobel operators combine Gaussian smoothing and differentiation, so the result is more or less resistant to the noise. Most often, the function is called with ( xorder = 1, yorder = 0, ksize = 3) or ( xorder = 0, yorder = 1, ksize = 3) to calculate the first x- or y- image derivative. The first case corresponds to a kernel of:
\f[\vecthreethree{-1}{0}{1}{-2}{0}{2}{-1}{0}{1}\f]
The second case corresponds to a kernel of:
\f[\vecthreethree{-1}{-2}{-1}{0}{0}{0}{1}{2}{1}\f]

Parameters:
src - input image.
dst - output image of the same size and the same number of channels as src .
ddepth - output image depth, see \ref filter_depths "combinations"; in the case of 8-bit input images it will result in truncated derivatives.
dx - order of the derivative x.
dy - order of the derivative y.
ksize - size of the extended Sobel kernel; it must be 1, 3, 5, or 7.
scale - optional scale factor for the computed derivative values; by default, no scaling is applied (see cv::getDerivKernels for details).
delta - optional delta value that is added to the results prior to storing them in dst.
borderType - pixel extrapolation method, see cv::BorderTypes \sa Scharr, Laplacian, sepFilter2D, filter2D, GaussianBlur, cartToPolar

Sobel

@Namespace(value="cv")
public static void Sobel(@ByVal
                        opencv_core.Mat src,
                        @ByVal
                        opencv_core.Mat dst,
                        int ddepth,
                        int dx,
                        int dy)

spatialGradient

@Namespace(value="cv")
public static void spatialGradient(@ByVal
                                  opencv_core.Mat src,
                                  @ByVal
                                  opencv_core.Mat dx,
                                  @ByVal
                                  opencv_core.Mat dy,
                                  int ksize,
                                  int borderType)

\brief Calculates the first order image derivative in both x and y using a Sobel operator

Equivalent to calling:

Sobel( src, dx, CV_16SC1, 1, 0, 3 );
Sobel( src, dy, CV_16SC1, 0, 1, 3 );

Parameters:: src - input image.; dx - output image with first-order derivative in x.; dy - output image with first-order derivative in y.; ksize - size of Sobel kernel. It must be 3.; borderType - pixel extrapolation method, see cv::BorderTypes
\sa Sobel

spatialGradient

@Namespace(value="cv")
public static void spatialGradient(@ByVal
                                  opencv_core.Mat src,
                                  @ByVal
                                  opencv_core.Mat dx,
                                  @ByVal
                                  opencv_core.Mat dy)

Scharr
```
@Namespace(value="cv")
public static void Scharr(@ByVal
                         opencv_core.Mat src,
                         @ByVal
                         opencv_core.Mat dst,
                         int ddepth,
                         int dx,
                         int dy,
                         double scale,
                         double delta,
                         int borderType)
```
\brief Calculates the first x- or y- image derivative using Scharr operator.
The function computes the first x- or y- spatial image derivative using the Scharr operator. The call
\f[\texttt{Scharr(src, dst, ddepth, dx, dy, scale, delta, borderType)}\f]
is equivalent to
\f[\texttt{Sobel(src, dst, ddepth, dx, dy, CV\_SCHARR, scale, delta, borderType)} .\f]

Parameters:
src - input image.
dst - output image of the same size and the same number of channels as src.
ddepth - output image depth, see \ref filter_depths "combinations"
dx - order of the derivative x.
dy - order of the derivative y.
scale - optional scale factor for the computed derivative values; by default, no scaling is applied (see getDerivKernels for details).
delta - optional delta value that is added to the results prior to storing them in dst.
borderType - pixel extrapolation method, see cv::BorderTypes \sa cartToPolar

Scharr

@Namespace(value="cv")
public static void Scharr(@ByVal
                         opencv_core.Mat src,
                         @ByVal
                         opencv_core.Mat dst,
                         int ddepth,
                         int dx,
                         int dy)

Laplacian
```
@Namespace(value="cv")
public static void Laplacian(@ByVal
                            opencv_core.Mat src,
                            @ByVal
                            opencv_core.Mat dst,
                            int ddepth,
                            int ksize,
                            double scale,
                            double delta,
                            int borderType)
```
\brief Calculates the Laplacian of an image.
The function calculates the Laplacian of the source image by adding up the second x and y derivatives calculated using the Sobel operator:
\f[\texttt{dst} = \Delta \texttt{src} = \frac{\partial^2 \texttt{src}}{\partial x^2} + \frac{\partial^2 \texttt{src}}{\partial y^2}\f]
This is done when ksize > 1. When ksize == 1, the Laplacian is computed by filtering the image with the following \f$3 \times 3\f$ aperture:
\f[\vecthreethree {0}{1}{0}{1}{-4}{1}{0}{1}{0}\f]

Parameters:
src - Source image.
dst - Destination image of the same size and the same number of channels as src .
ddepth - Desired depth of the destination image.
ksize - Aperture size used to compute the second-derivative filters. See getDerivKernels for details. The size must be positive and odd.
scale - Optional scale factor for the computed Laplacian values. By default, no scaling is applied. See getDerivKernels for details.
delta - Optional delta value that is added to the results prior to storing them in dst .
borderType - Pixel extrapolation method, see cv::BorderTypes \sa Sobel, Scharr

Laplacian

@Namespace(value="cv")
public static void Laplacian(@ByVal
                            opencv_core.Mat src,
                            @ByVal
                            opencv_core.Mat dst,
                            int ddepth)

Canny
```
@Namespace(value="cv")
public static void Canny(@ByVal
                        opencv_core.Mat image,
                        @ByVal
                        opencv_core.Mat edges,
                        double threshold1,
                        double threshold2,
                        int apertureSize,
                        @Cast(value="bool")
                        boolean L2gradient)
```
\brief Finds edges in an image using the Canny algorithm \cite Canny86 .
The function finds edges in the input image image and marks them in the output map edges using the Canny algorithm. The smallest value between threshold1 and threshold2 is used for edge linking. The largest value is used to find initial segments of strong edges. See

Parameters:
image - 8-bit input image.
edges - output edge map; single channels 8-bit image, which has the same size as image .
threshold1 - first threshold for the hysteresis procedure.
threshold2 - second threshold for the hysteresis procedure.
apertureSize - aperture size for the Sobel operator.
L2gradient - a flag, indicating whether a more accurate \f$L_2\f$ norm \f$=\sqrt{(dI/dx)^2 + (dI/dy)^2}\f$ should be used to calculate the image gradient magnitude ( L2gradient=true ), or whether the default \f$L_1\f$ norm \f$=|dI/dx|+|dI/dy|\f$ is enough ( L2gradient=false ).

Canny

@Namespace(value="cv")
public static void Canny(@ByVal
                        opencv_core.Mat image,
                        @ByVal
                        opencv_core.Mat edges,
                        double threshold1,
                        double threshold2)

cornerMinEigenVal
```
@Namespace(value="cv")
public static void cornerMinEigenVal(@ByVal
                                    opencv_core.Mat src,
                                    @ByVal
                                    opencv_core.Mat dst,
                                    int blockSize,
                                    int ksize,
                                    int borderType)
```
\brief Calculates the minimal eigenvalue of gradient matrices for corner detection.
The function is similar to cornerEigenValsAndVecs but it calculates and stores only the minimal eigenvalue of the covariance matrix of derivatives, that is, \f$\min(\lambda_1, \lambda_2)\f$ in terms of the formulae in the cornerEigenValsAndVecs description.

Parameters:
src - Input single-channel 8-bit or floating-point image.
dst - Image to store the minimal eigenvalues. It has the type CV_32FC1 and the same size as src .
blockSize - Neighborhood size (see the details on cornerEigenValsAndVecs ).
ksize - Aperture parameter for the Sobel operator.
borderType - Pixel extrapolation method. See cv::BorderTypes.

cornerMinEigenVal

@Namespace(value="cv")
public static void cornerMinEigenVal(@ByVal
                                    opencv_core.Mat src,
                                    @ByVal
                                    opencv_core.Mat dst,
                                    int blockSize)

cornerHarris
```
@Namespace(value="cv")
public static void cornerHarris(@ByVal
                               opencv_core.Mat src,
                               @ByVal
                               opencv_core.Mat dst,
                               int blockSize,
                               int ksize,
                               double k,
                               int borderType)
```
\brief Harris corner detector.
The function runs the Harris corner detector on the image. Similarly to cornerMinEigenVal and cornerEigenValsAndVecs , for each pixel \f$(x, y)\f$ it calculates a \f$2\times2\f$ gradient covariance matrix \f$M^{(x,y)}\f$ over a \f$\texttt{blockSize} \times \texttt{blockSize}\f$ neighborhood. Then, it computes the following characteristic:
\f[\texttt{dst} (x,y) = \mathrm{det} M^{(x,y)} - k \cdot \left ( \mathrm{tr} M^{(x,y)} \right )^2\f]
Corners in the image can be found as the local maxima of this response map.

Parameters:
src - Input single-channel 8-bit or floating-point image.
dst - Image to store the Harris detector responses. It has the type CV_32FC1 and the same size as src .
blockSize - Neighborhood size (see the details on cornerEigenValsAndVecs ).
ksize - Aperture parameter for the Sobel operator.
k - Harris detector free parameter. See the formula below.
borderType - Pixel extrapolation method. See cv::BorderTypes.

cornerHarris

@Namespace(value="cv")
public static void cornerHarris(@ByVal
                               opencv_core.Mat src,
                               @ByVal
                               opencv_core.Mat dst,
                               int blockSize,
                               int ksize,
                               double k)

cornerEigenValsAndVecs
```
@Namespace(value="cv")
public static void cornerEigenValsAndVecs(@ByVal
                                         opencv_core.Mat src,
                                         @ByVal
                                         opencv_core.Mat dst,
                                         int blockSize,
                                         int ksize,
                                         int borderType)
```
\brief Calculates eigenvalues and eigenvectors of image blocks for corner detection.
For every pixel \f$p\f$ , the function cornerEigenValsAndVecs considers a blockSize \f$\times\f$ blockSize neighborhood \f$S(p)\f$ . It calculates the covariation matrix of derivatives over the neighborhood as:
\f[M = \begin{bmatrix} \sum _{S(p)}(dI/dx)^2 & \sum _{S(p)}dI/dx dI/dy \\ \sum _{S(p)}dI/dx dI/dy & \sum _{S(p)}(dI/dy)^2 \end{bmatrix}\f]
where the derivatives are computed using the Sobel operator.
After that, it finds eigenvectors and eigenvalues of \f$M\f$ and stores them in the destination image as \f$(\lambda_1, \lambda_2, x_1, y_1, x_2, y_2)\f$ where
- \f$\lambda_1, \lambda_2\f$ are the non-sorted eigenvalues of \f$M\f$ - \f$x_1, y_1\f$ are the eigenvectors corresponding to \f$\lambda_1\f$ - \f$x_2, y_2\f$ are the eigenvectors corresponding to \f$\lambda_2\f$
The output of the function can be used for robust edge or corner detection.

Parameters:
src - Input single-channel 8-bit or floating-point image.
dst - Image to store the results. It has the same size as src and the type CV_32FC(6) .
blockSize - Neighborhood size (see details below).
ksize - Aperture parameter for the Sobel operator.
borderType - Pixel extrapolation method. See cv::BorderTypes.
\sa cornerMinEigenVal, cornerHarris, preCornerDetect

cornerEigenValsAndVecs

@Namespace(value="cv")
public static void cornerEigenValsAndVecs(@ByVal
                                         opencv_core.Mat src,
                                         @ByVal
                                         opencv_core.Mat dst,
                                         int blockSize,
                                         int ksize)

preCornerDetect
```
@Namespace(value="cv")
public static void preCornerDetect(@ByVal
                                  opencv_core.Mat src,
                                  @ByVal
                                  opencv_core.Mat dst,
                                  int ksize,
                                  int borderType)
```
\brief Calculates a feature map for corner detection.
The function calculates the complex spatial derivative-based function of the source image
\f[\texttt{dst} = (D_x \texttt{src} )^2 \cdot D_{yy} \texttt{src} + (D_y \texttt{src} )^2 \cdot D_{xx} \texttt{src} - 2 D_x \texttt{src} \cdot D_y \texttt{src} \cdot D_{xy} \texttt{src}\f]
where \f$D_x\f$,\f$D_y\f$ are the first image derivatives, \f$D_{xx}\f$,\f$D_{yy}\f$ are the second image derivatives, and \f$D_{xy}\f$ is the mixed derivative.
The corners can be found as local maximums of the functions, as shown below:
```
Mat corners, dilated_corners;
    preCornerDetect(image, corners, 3);
    // dilation with 3x3 rectangular structuring element
    dilate(corners, dilated_corners, Mat(), 1);
    Mat corner_mask = corners == dilated_corners;
```
Parameters:
src - Source single-channel 8-bit of floating-point image.
dst - Output image that has the type CV_32F and the same size as src .
ksize - %Aperture size of the Sobel .
borderType - Pixel extrapolation method. See cv::BorderTypes.

preCornerDetect

@Namespace(value="cv")
public static void preCornerDetect(@ByVal
                                  opencv_core.Mat src,
                                  @ByVal
                                  opencv_core.Mat dst,
                                  int ksize)

cornerSubPix
```
@Namespace(value="cv")
public static void cornerSubPix(@ByVal
                               opencv_core.Mat image,
                               @ByVal
                               opencv_core.Mat corners,
                               @ByVal
                               opencv_core.Size winSize,
                               @ByVal
                               opencv_core.Size zeroZone,
                               @ByVal
                               opencv_core.TermCriteria criteria)
```
\brief Refines the corner locations.
The function iterates to find the sub-pixel accurate location of corners or radial saddle points, as shown on the figure below.
![image](pics/cornersubpix.png)
Sub-pixel accurate corner locator is based on the observation that every vector from the center \f$q\f$ to a point \f$p\f$ located within a neighborhood of \f$q\f$ is orthogonal to the image gradient at \f$p\f$ subject to image and measurement noise. Consider the expression:
\f[\epsilon _i = {DI_{p_i}}^T \cdot (q - p_i)\f]
where \f${DI_{p_i}}\f$ is an image gradient at one of the points \f$p_i\f$ in a neighborhood of \f$q\f$ . The value of \f$q\f$ is to be found so that \f$\epsilon_i\f$ is minimized. A system of equations may be set up with \f$\epsilon_i\f$ set to zero:
\f[\sum _i(DI_{p_i} \cdot {DI_{p_i}}^T) - \sum _i(DI_{p_i} \cdot {DI_{p_i}}^T \cdot p_i)\f]
where the gradients are summed within a neighborhood ("search window") of \f$q\f$ . Calling the first gradient term \f$G\f$ and the second gradient term \f$b\f$ gives:
\f[q = G^{-1} \cdot b\f]
The algorithm sets the center of the neighborhood window at this new center \f$q\f$ and then iterates until the center stays within a set threshold.

Parameters:
image - Input image.
corners - Initial coordinates of the input corners and refined coordinates provided for output.
winSize - Half of the side length of the search window. For example, if winSize=Size(5,5) , then a \f$5*2+1 \times 5*2+1 = 11 \times 11\f$ search window is used.
zeroZone - Half of the size of the dead region in the middle of the search zone over which the summation in the formula below is not done. It is used sometimes to avoid possible singularities of the autocorrelation matrix. The value of (-1,-1) indicates that there is no such a size.
criteria - Criteria for termination of the iterative process of corner refinement. That is, the process of corner position refinement stops either after criteria.maxCount iterations or when the corner position moves by less than criteria.epsilon on some iteration.

goodFeaturesToTrack
```
@Namespace(value="cv")
public static void goodFeaturesToTrack(@ByVal
                                      opencv_core.Mat image,
                                      @ByVal
                                      opencv_core.Mat corners,
                                      int maxCorners,
                                      double qualityLevel,
                                      double minDistance,
                                      @ByVal(nullValue="cv::noArray()")
                                      opencv_core.Mat mask,
                                      int blockSize,
                                      @Cast(value="bool")
                                      boolean useHarrisDetector,
                                      double k)
```
\brief Determines strong corners on an image.
The function finds the most prominent corners in the image or in the specified image region, as described in \cite Shi94
- Function calculates the corner quality measure at every source image pixel using the cornerMinEigenVal or cornerHarris . - Function performs a non-maximum suppression (the local maximums in *3 x 3* neighborhood are retained). - The corners with the minimal eigenvalue less than \f$\texttt{qualityLevel} \cdot \max_{x,y} qualityMeasureMap(x,y)\f$ are rejected. - The remaining corners are sorted by the quality measure in the descending order. - Function throws away each corner for which there is a stronger corner at a distance less than maxDistance.
The function can be used to initialize a point-based tracker of an object.
\note If the function is called with different values A and B of the parameter qualityLevel , and A \> B, the vector of returned corners with qualityLevel=A will be the prefix of the output vector with qualityLevel=B .

Parameters:
image - Input 8-bit or floating-point 32-bit, single-channel image.
corners - Output vector of detected corners.
maxCorners - Maximum number of corners to return. If there are more corners than are found, the strongest of them is returned.
qualityLevel - Parameter characterizing the minimal accepted quality of image corners. The parameter value is multiplied by the best corner quality measure, which is the minimal eigenvalue (see cornerMinEigenVal ) or the Harris function response (see cornerHarris ). The corners with the quality measure less than the product are rejected. For example, if the best corner has the quality measure = 1500, and the qualityLevel=0.01 , then all the corners with the quality measure less than 15 are rejected.
minDistance - Minimum possible Euclidean distance between the returned corners.
mask - Optional region of interest. If the image is not empty (it needs to have the type CV_8UC1 and the same size as image ), it specifies the region in which the corners are detected.
blockSize - Size of an average block for computing a derivative covariation matrix over each pixel neighborhood. See cornerEigenValsAndVecs .
useHarrisDetector - Parameter indicating whether to use a Harris detector (see cornerHarris) or cornerMinEigenVal.
k - Free parameter of the Harris detector.
\sa cornerMinEigenVal, cornerHarris, calcOpticalFlowPyrLK, estimateRigidTransform,

goodFeaturesToTrack

@Namespace(value="cv")
public static void goodFeaturesToTrack(@ByVal
                                      opencv_core.Mat image,
                                      @ByVal
                                      opencv_core.Mat corners,
                                      int maxCorners,
                                      double qualityLevel,
                                      double minDistance)

HoughLines
```
@Namespace(value="cv")
public static void HoughLines(@ByVal
                             opencv_core.Mat image,
                             @ByVal
                             opencv_core.Mat lines,
                             double rho,
                             double theta,
                             int threshold,
                             double srn,
                             double stn,
                             double min_theta,
                             double max_theta)
```
\brief Finds lines in a binary image using the standard Hough transform.
The function implements the standard or standard multi-scale Hough transform algorithm for line detection. See for a good explanation of Hough transform.

Parameters:
image - 8-bit, single-channel binary source image. The image may be modified by the function.
lines - Output vector of lines. Each line is represented by a two-element vector \f$(\rho, \theta)\f$ . \f$\rho\f$ is the distance from the coordinate origin \f$(0,0)\f$ (top-left corner of the image). \f$\theta\f$ is the line rotation angle in radians ( \f$0 \sim \textrm{vertical line}, \pi/2 \sim \textrm{horizontal line}\f$ ).
rho - Distance resolution of the accumulator in pixels.
theta - Angle resolution of the accumulator in radians.
threshold - Accumulator threshold parameter. Only those lines are returned that get enough votes ( \f$>\texttt{threshold}\f$ ).
srn - For the multi-scale Hough transform, it is a divisor for the distance resolution rho . The coarse accumulator distance resolution is rho and the accurate accumulator resolution is rho/srn . If both srn=0 and stn=0 , the classical Hough transform is used. Otherwise, both these parameters should be positive.
stn - For the multi-scale Hough transform, it is a divisor for the distance resolution theta.
min_theta - For standard and multi-scale Hough transform, minimum angle to check for lines. Must fall between 0 and max_theta.
max_theta - For standard and multi-scale Hough transform, maximum angle to check for lines. Must fall between min_theta and CV_PI.

HoughLines

@Namespace(value="cv")
public static void HoughLines(@ByVal
                             opencv_core.Mat image,
                             @ByVal
                             opencv_core.Mat lines,
                             double rho,
                             double theta,
                             int threshold)

HoughLinesP

@Namespace(value="cv")
public static void HoughLinesP(@ByVal
                              opencv_core.Mat image,
                              @ByVal
                              opencv_core.Mat lines,
                              double rho,
                              double theta,
                              int threshold,
                              double minLineLength,
                              double maxLineGap)

\brief Finds line segments in a binary image using the probabilistic Hough transform.

The function implements the probabilistic Hough transform algorithm for line detection, described in \cite Matas00

See the line detection example below:

#include <opencv2/imgproc.hpp>
    #include <opencv2/highgui.hpp>

    using namespace cv;
    using namespace std;

    int main(int argc, char** argv)
    {
        Mat src, dst, color_dst;
        if( argc != 2 || !(src=imread(argv[1], 0)).data)
            return -1;

        Canny( src, dst, 50, 200, 3 );
        cvtColor( dst, color_dst, COLOR_GRAY2BGR );

    #if 0
        vector<Vec2f> lines;
        HoughLines( dst, lines, 1, CV_PI/180, 100 );

        for( size_t i = 0; i < lines.size(); i++ )
        {
            float rho = lines[i][0];
            float theta = lines[i][1];
            double a = cos(theta), b = sin(theta);
            double x0 = a*rho, y0 = b*rho;
            Point pt1(cvRound(x0 + 1000*(-b)),
                      cvRound(y0 + 1000*(a)));
            Point pt2(cvRound(x0 - 1000*(-b)),
                      cvRound(y0 - 1000*(a)));
            line( color_dst, pt1, pt2, Scalar(0,0,255), 3, 8 );
        }
    #else
        vector<Vec4i> lines;
        HoughLinesP( dst, lines, 1, CV_PI/180, 80, 30, 10 );
        for( size_t i = 0; i < lines.size(); i++ )
        {
            line( color_dst, Point(lines[i][0], lines[i][1]),
                Point(lines[i][2], lines[i][3]), Scalar(0,0,255), 3, 8 );
        }
    #endif
        namedWindow( "Source", 1 );
        imshow( "Source", src );

        namedWindow( "Detected Lines", 1 );
        imshow( "Detected Lines", color_dst );

        waitKey(0);
        return 0;
    }

This is a sample picture the function parameters have been tuned for:

![image](pics/building.jpg)

And this is the output of the above program in case of the probabilistic Hough transform:

![image](pics/houghp.png)

Parameters:: image - 8-bit, single-channel binary source image. The image may be modified by the function.; lines - Output vector of lines. Each line is represented by a 4-element vector \f$(x_1, y_1, x_2, y_2)\f$ , where \f$(x_1,y_1)\f$ and \f$(x_2, y_2)\f$ are the ending points of each detected line segment.; rho - Distance resolution of the accumulator in pixels.; theta - Angle resolution of the accumulator in radians.; threshold - Accumulator threshold parameter. Only those lines are returned that get enough votes ( \f$>\texttt{threshold}\f$ ).; minLineLength - Minimum line length. Line segments shorter than that are rejected.; maxLineGap - Maximum allowed gap between points on the same line to link them.
\sa LineSegmentDetector

HoughLinesP

@Namespace(value="cv")
public static void HoughLinesP(@ByVal
                              opencv_core.Mat image,
                              @ByVal
                              opencv_core.Mat lines,
                              double rho,
                              double theta,
                              int threshold)

HoughCircles
```
@Namespace(value="cv")
public static void HoughCircles(@ByVal
                               opencv_core.Mat image,
                               @ByVal
                               opencv_core.Mat circles,
                               int method,
                               double dp,
                               double minDist,
                               double param1,
                               double param2,
                               int minRadius,
                               int maxRadius)
```
\brief Finds circles in a grayscale image using the Hough transform.
The function finds circles in a grayscale image using a modification of the Hough transform.
Example: :
```
#include <opencv2/imgproc.hpp>
    #include <opencv2/highgui.hpp>
    #include <math.h>

    using namespace cv;
    using namespace std;

    int main(int argc, char** argv)
    {
        Mat img, gray;
        if( argc != 2 || !(img=imread(argv[1], 1)).data)
            return -1;
        cvtColor(img, gray, COLOR_BGR2GRAY);
        // smooth it, otherwise a lot of false circles may be detected
        GaussianBlur( gray, gray, Size(9, 9), 2, 2 );
        vector<Vec3f> circles;
        HoughCircles(gray, circles, HOUGH_GRADIENT,
                     2, gray.rows/4, 200, 100 );
        for( size_t i = 0; i < circles.size(); i++ )
        {
             Point center(cvRound(circles[i][0]), cvRound(circles[i][1]));
             int radius = cvRound(circles[i][2]);
             // draw the circle center
             circle( img, center, 3, Scalar(0,255,0), -1, 8, 0 );
             // draw the circle outline
             circle( img, center, radius, Scalar(0,0,255), 3, 8, 0 );
        }
        namedWindow( "circles", 1 );
        imshow( "circles", img );

        waitKey(0);
        return 0;
    }
```
\note Usually the function detects the centers of circles well. However, it may fail to find correct radii. You can assist to the function by specifying the radius range ( minRadius and maxRadius ) if you know it. Or, you may ignore the returned radius, use only the center, and find the correct radius using an additional procedure.
Parameters:
image - 8-bit, single-channel, grayscale input image.
circles - Output vector of found circles. Each vector is encoded as a 3-element floating-point vector \f$(x, y, radius)\f$ .
method - Detection method, see cv::HoughModes. Currently, the only implemented method is HOUGH_GRADIENT
dp - Inverse ratio of the accumulator resolution to the image resolution. For example, if dp=1 , the accumulator has the same resolution as the input image. If dp=2 , the accumulator has half as big width and height.
minDist - Minimum distance between the centers of the detected circles. If the parameter is too small, multiple neighbor circles may be falsely detected in addition to a true one. If it is too large, some circles may be missed.
param1 - First method-specific parameter. In case of CV_HOUGH_GRADIENT , it is the higher threshold of the two passed to the Canny edge detector (the lower one is twice smaller).
param2 - Second method-specific parameter. In case of CV_HOUGH_GRADIENT , it is the accumulator threshold for the circle centers at the detection stage. The smaller it is, the more false circles may be detected. Circles, corresponding to the larger accumulator values, will be returned first.
minRadius - Minimum circle radius.
maxRadius - Maximum circle radius.
\sa fitEllipse, minEnclosingCircle

HoughCircles

@Namespace(value="cv")
public static void HoughCircles(@ByVal
                               opencv_core.Mat image,
                               @ByVal
                               opencv_core.Mat circles,
                               int method,
                               double dp,
                               double minDist)

erode
```
@Namespace(value="cv")
public static void erode(@ByVal
                        opencv_core.Mat src,
                        @ByVal
                        opencv_core.Mat dst,
                        @ByVal
                        opencv_core.Mat kernel,
                        @ByVal(nullValue="cv::Point(-1,-1)")
                        opencv_core.Point anchor,
                        int iterations,
                        int borderType,
                        @Const@ByRef(nullValue="cv::morphologyDefaultBorderValue()")
                        opencv_core.Scalar borderValue)
```
\brief Erodes an image by using a specific structuring element.
The function erodes the source image using the specified structuring element that determines the shape of a pixel neighborhood over which the minimum is taken:
\f[\texttt{dst} (x,y) = \min _{(x',y'): \, \texttt{element} (x',y') \ne0 } \texttt{src} (x+x',y+y')\f]
The function supports the in-place mode. Erosion can be applied several ( iterations ) times. In case of multi-channel images, each channel is processed independently.

Parameters:
src - input image; the number of channels can be arbitrary, but the depth should be one of CV_8U, CV_16U, CV_16S, CV_32F or CV_64F.
dst - output image of the same size and type as src.
kernel - structuring element used for erosion; if element=Mat(), a 3 x 3 rectangular structuring element is used. Kernel can be created using getStructuringElement.
anchor - position of the anchor within the element; default value (-1, -1) means that the anchor is at the element center.
iterations - number of times erosion is applied.
borderType - pixel extrapolation method, see cv::BorderTypes
borderValue - border value in case of a constant border \sa dilate, morphologyEx, getStructuringElement

erode

@Namespace(value="cv")
public static void erode(@ByVal
                        opencv_core.Mat src,
                        @ByVal
                        opencv_core.Mat dst,
                        @ByVal
                        opencv_core.Mat kernel)

dilate
```
@Namespace(value="cv")
public static void dilate(@ByVal
                         opencv_core.Mat src,
                         @ByVal
                         opencv_core.Mat dst,
                         @ByVal
                         opencv_core.Mat kernel,
                         @ByVal(nullValue="cv::Point(-1,-1)")
                         opencv_core.Point anchor,
                         int iterations,
                         int borderType,
                         @Const@ByRef(nullValue="cv::morphologyDefaultBorderValue()")
                         opencv_core.Scalar borderValue)
```
\brief Dilates an image by using a specific structuring element.
The function dilates the source image using the specified structuring element that determines the shape of a pixel neighborhood over which the maximum is taken: \f[\texttt{dst} (x,y) = \max _{(x',y'): \, \texttt{element} (x',y') \ne0 } \texttt{src} (x+x',y+y')\f]
The function supports the in-place mode. Dilation can be applied several ( iterations ) times. In case of multi-channel images, each channel is processed independently.

Parameters:
src - input image; the number of channels can be arbitrary, but the depth should be one of CV_8U, CV_16U, CV_16S, CV_32F or CV_64F.
dst - output image of the same size and type as src\{@code .
kernel - structuring element used for dilation; if elemenat=Mat(), a 3 x 3 rectangular structuring element is used. Kernel can be created using getStructuringElement
anchor - position of the anchor within the element; default value (-1, -1) means that the anchor is at the element center.
iterations - number of times dilation is applied.
borderType - pixel extrapolation method, see cv::BorderTypes
borderValue - border value in case of a constant border

dilate

@Namespace(value="cv")
public static void dilate(@ByVal
                         opencv_core.Mat src,
                         @ByVal
                         opencv_core.Mat dst,
                         @ByVal
                         opencv_core.Mat kernel)

morphologyEx

@Namespace(value="cv")
public static void morphologyEx(@ByVal
                               opencv_core.Mat src,
                               @ByVal
                               opencv_core.Mat dst,
                               int op,
                               @ByVal
                               opencv_core.Mat kernel,
                               @ByVal(nullValue="cv::Point(-1,-1)")
                               opencv_core.Point anchor,
                               int iterations,
                               int borderType,
                               @Const@ByRef(nullValue="cv::morphologyDefaultBorderValue()")
                               opencv_core.Scalar borderValue)

\brief Performs advanced morphological transformations.

The function morphologyEx can perform advanced morphological transformations using an erosion and dilation as basic operations.

Any of the operations can be done in-place. In case of multi-channel images, each channel is processed independently.

Parameters:: src - Source image. The number of channels can be arbitrary. The depth should be one of CV_8U, CV_16U, CV_16S, CV_32F or CV_64F.; dst - Destination image of the same size and type as source image.; op - Type of a morphological operation, see cv::MorphTypes; kernel - Structuring element. It can be created using cv::getStructuringElement.; anchor - Anchor position with the kernel. Negative values mean that the anchor is at the kernel center.; iterations - Number of times erosion and dilation are applied.; borderType - Pixel extrapolation method, see cv::BorderTypes; borderValue - Border value in case of a constant border. The default value has a special meaning. \sa dilate, erode, getStructuringElement

morphologyEx

@Namespace(value="cv")
public static void morphologyEx(@ByVal
                               opencv_core.Mat src,
                               @ByVal
                               opencv_core.Mat dst,
                               int op,
                               @ByVal
                               opencv_core.Mat kernel)

resize
```
@Namespace(value="cv")
public static void resize(@ByVal
                         opencv_core.Mat src,
                         @ByVal
                         opencv_core.Mat dst,
                         @ByVal
                         opencv_core.Size dsize,
                         double fx,
                         double fy,
                         int interpolation)
```
\} imgproc_filter
\addtogroup imgproc_transform \{
/** \brief Resizes an image.
The function resize resizes the image src down to or up to the specified size. Note that the initial dst type or size are not taken into account. Instead, the size and type are derived from the src,dsize,fx, and fy. If you want to resize src so that it fits the pre-created dst, you may call the function as follows:
```
// explicitly specify dsize=dst.size(); fx and fy will be computed from that.
    resize(src, dst, dst.size(), 0, 0, interpolation);
```
If you want to decimate the image by factor of 2 in each direction, you can call the function this way:
```
// specify fx and fy and let the function compute the destination image size.
    resize(src, dst, Size(), 0.5, 0.5, interpolation);
```
To shrink an image, it will generally look best with cv::INTER_AREA interpolation, whereas to enlarge an image, it will generally look best with cv::INTER_CUBIC (slow) or cv::INTER_LINEAR (faster but still looks OK).
Parameters:
src - input image.
dst - output image; it has the size dsize (when it is non-zero) or the size computed from src.size(), fx, and fy; the type of dst is the same as of src.
dsize - output image size; if it equals zero, it is computed as: \f[\texttt{dsize = Size(round(fx*src.cols), round(fy*src.rows))}\f] Either dsize or both fx and fy must be non-zero.
fx - scale factor along the horizontal axis; when it equals 0, it is computed as \f[\texttt{(double)dsize.width/src.cols}\f]
fy - scale factor along the vertical axis; when it equals 0, it is computed as \f[\texttt{(double)dsize.height/src.rows}\f]
interpolation - interpolation method, see cv::InterpolationFlags
\sa warpAffine, warpPerspective, remap

resize

@Namespace(value="cv")
public static void resize(@ByVal
                         opencv_core.Mat src,
                         @ByVal
                         opencv_core.Mat dst,
                         @ByVal
                         opencv_core.Size dsize)

warpAffine
```
@Namespace(value="cv")
public static void warpAffine(@ByVal
                             opencv_core.Mat src,
                             @ByVal
                             opencv_core.Mat dst,
                             @ByVal
                             opencv_core.Mat M,
                             @ByVal
                             opencv_core.Size dsize,
                             int flags,
                             int borderMode,
                             @Const@ByRef(nullValue="cv::Scalar()")
                             opencv_core.Scalar borderValue)
```
\brief Applies an affine transformation to an image.
The function warpAffine transforms the source image using the specified matrix:
\f[\texttt{dst} (x,y) = \texttt{src} ( \texttt{M} _{11} x + \texttt{M} _{12} y + \texttt{M} _{13}, \texttt{M} _{21} x + \texttt{M} _{22} y + \texttt{M} _{23})\f]
when the flag WARP_INVERSE_MAP is set. Otherwise, the transformation is first inverted with cv::invertAffineTransform and then put in the formula above instead of M. The function cannot operate in-place.

Parameters:
src - input image.
dst - output image that has the size dsize and the same type as src .
M - \f$2\times 3\f$ transformation matrix.
dsize - size of the output image.
flags - combination of interpolation methods (see cv::InterpolationFlags) and the optional flag WARP_INVERSE_MAP that means that M is the inverse transformation ( \f$\texttt{dst}\rightarrow\texttt{src}\f$ ).
borderMode - pixel extrapolation method (see cv::BorderTypes); when borderMode=BORDER_TRANSPARENT, it means that the pixels in the destination image corresponding to the "outliers" in the source image are not modified by the function.
borderValue - value used in case of a constant border; by default, it is 0.
\sa warpPerspective, resize, remap, getRectSubPix, transform

warpAffine

@Namespace(value="cv")
public static void warpAffine(@ByVal
                             opencv_core.Mat src,
                             @ByVal
                             opencv_core.Mat dst,
                             @ByVal
                             opencv_core.Mat M,
                             @ByVal
                             opencv_core.Size dsize)

warpPerspective
```
@Namespace(value="cv")
public static void warpPerspective(@ByVal
                                  opencv_core.Mat src,
                                  @ByVal
                                  opencv_core.Mat dst,
                                  @ByVal
                                  opencv_core.Mat M,
                                  @ByVal
                                  opencv_core.Size dsize,
                                  int flags,
                                  int borderMode,
                                  @Const@ByRef(nullValue="cv::Scalar()")
                                  opencv_core.Scalar borderValue)
```
\brief Applies a perspective transformation to an image.
The function warpPerspective transforms the source image using the specified matrix:
\f[\texttt{dst} (x,y) = \texttt{src} \left ( \frac{M_{11} x + M_{12} y + M_{13}}{M_{31} x + M_{32} y + M_{33}} , \frac{M_{21} x + M_{22} y + M_{23}}{M_{31} x + M_{32} y + M_{33}} \right )\f]
when the flag WARP_INVERSE_MAP is set. Otherwise, the transformation is first inverted with invert and then put in the formula above instead of M. The function cannot operate in-place.

Parameters:
src - input image.
dst - output image that has the size dsize and the same type as src .
M - \f$3\times 3\f$ transformation matrix.
dsize - size of the output image.
flags - combination of interpolation methods (INTER_LINEAR or INTER_NEAREST) and the optional flag WARP_INVERSE_MAP, that sets M as the inverse transformation ( \f$\texttt{dst}\rightarrow\texttt{src}\f$ ).
borderMode - pixel extrapolation method (BORDER_CONSTANT or BORDER_REPLICATE).
borderValue - value used in case of a constant border; by default, it equals 0.
\sa warpAffine, resize, remap, getRectSubPix, perspectiveTransform

warpPerspective

@Namespace(value="cv")
public static void warpPerspective(@ByVal
                                  opencv_core.Mat src,
                                  @ByVal
                                  opencv_core.Mat dst,
                                  @ByVal
                                  opencv_core.Mat M,
                                  @ByVal
                                  opencv_core.Size dsize)

remap
```
@Namespace(value="cv")
public static void remap(@ByVal
                        opencv_core.Mat src,
                        @ByVal
                        opencv_core.Mat dst,
                        @ByVal
                        opencv_core.Mat map1,
                        @ByVal
                        opencv_core.Mat map2,
                        int interpolation,
                        int borderMode,
                        @Const@ByRef(nullValue="cv::Scalar()")
                        opencv_core.Scalar borderValue)
```
\brief Applies a generic geometrical transformation to an image.
The function remap transforms the source image using the specified map:
\f[\texttt{dst} (x,y) = \texttt{src} (map_x(x,y),map_y(x,y))\f]
where values of pixels with non-integer coordinates are computed using one of available interpolation methods. \f$map_x\f$ and \f$map_y\f$ can be encoded as separate floating-point maps in \f$map_1\f$ and \f$map_2\f$ respectively, or interleaved floating-point maps of \f$(x,y)\f$ in \f$map_1\f$, or fixed-point maps created by using convertMaps. The reason you might want to convert from floating to fixed-point representations of a map is that they can yield much faster (\~2x) remapping operations. In the converted case, \f$map_1\f$ contains pairs (cvFloor(x), cvFloor(y)) and \f$map_2\f$ contains indices in a table of interpolation coefficients.
This function cannot operate in-place.

Parameters:
src - Source image.
dst - Destination image. It has the same size as map1 and the same type as src .
map1 - The first map of either (x,y) points or just x values having the type CV_16SC2 , CV_32FC1, or CV_32FC2. See convertMaps for details on converting a floating point representation to fixed-point for speed.
map2 - The second map of y values having the type CV_16UC1, CV_32FC1, or none (empty map if map1 is (x,y) points), respectively.
interpolation - Interpolation method (see cv::InterpolationFlags). The method INTER_AREA is not supported by this function.
borderMode - Pixel extrapolation method (see cv::BorderTypes). When borderMode=BORDER_TRANSPARENT, it means that the pixels in the destination image that corresponds to the "outliers" in the source image are not modified by the function.
borderValue - Value used in case of a constant border. By default, it is 0.

remap

@Namespace(value="cv")
public static void remap(@ByVal
                        opencv_core.Mat src,
                        @ByVal
                        opencv_core.Mat dst,
                        @ByVal
                        opencv_core.Mat map1,
                        @ByVal
                        opencv_core.Mat map2,
                        int interpolation)

convertMaps
```
@Namespace(value="cv")
public static void convertMaps(@ByVal
                              opencv_core.Mat map1,
                              @ByVal
                              opencv_core.Mat map2,
                              @ByVal
                              opencv_core.Mat dstmap1,
                              @ByVal
                              opencv_core.Mat dstmap2,
                              int dstmap1type,
                              @Cast(value="bool")
                              boolean nninterpolation)
```
\brief Converts image transformation maps from one representation to another.
The function converts a pair of maps for remap from one representation to another. The following options ( (map1.type(), map2.type()) \f$\rightarrow\f$ (dstmap1.type(), dstmap2.type()) ) are supported:
- \f$\texttt{(CV\_32FC1, CV\_32FC1)} \rightarrow \texttt{(CV\_16SC2, CV\_16UC1)}\f$. This is the most frequently used conversion operation, in which the original floating-point maps (see remap ) are converted to a more compact and much faster fixed-point representation. The first output array contains the rounded coordinates and the second array (created only when nninterpolation=false ) contains indices in the interpolation tables.
- \f$\texttt{(CV\_32FC2)} \rightarrow \texttt{(CV\_16SC2, CV\_16UC1)}\f$. The same as above but the original maps are stored in one 2-channel matrix.
- Reverse conversion. Obviously, the reconstructed floating-point maps will not be exactly the same as the originals.

Parameters:
map1 - The first input map of type CV_16SC2, CV_32FC1, or CV_32FC2 .
map2 - The second input map of type CV_16UC1, CV_32FC1, or none (empty matrix), respectively.
dstmap1 - The first output map that has the type dstmap1type and the same size as src .
dstmap2 - The second output map.
dstmap1type - Type of the first output map that should be CV_16SC2, CV_32FC1, or CV_32FC2 .
nninterpolation - Flag indicating whether the fixed-point maps are used for the nearest-neighbor or for a more complex interpolation.
\sa remap, undistort, initUndistortRectifyMap

convertMaps

@Namespace(value="cv")
public static void convertMaps(@ByVal
                              opencv_core.Mat map1,
                              @ByVal
                              opencv_core.Mat map2,
                              @ByVal
                              opencv_core.Mat dstmap1,
                              @ByVal
                              opencv_core.Mat dstmap2,
                              int dstmap1type)

getRotationMatrix2D
```
@Namespace(value="cv")
@ByVal
public static opencv_core.Mat getRotationMatrix2D(@ByVal
                                                       opencv_core.Point2f center,
                                                       double angle,
                                                       double scale)
```
\brief Calculates an affine matrix of 2D rotation.
The function calculates the following matrix:
\f[\begin{bmatrix} \alpha & \beta & (1- \alpha ) \cdot \texttt{center.x} - \beta \cdot \texttt{center.y} \\ - \beta & \alpha & \beta \cdot \texttt{center.x} + (1- \alpha ) \cdot \texttt{center.y} \end{bmatrix}\f]
where
\f[\begin{array}{l} \alpha = \texttt{scale} \cdot \cos \texttt{angle} , \\ \beta = \texttt{scale} \cdot \sin \texttt{angle} \end{array}\f]
The transformation maps the rotation center to itself. If this is not the target, adjust the shift.

Parameters:
center - Center of the rotation in the source image.
angle - Rotation angle in degrees. Positive values mean counter-clockwise rotation (the coordinate origin is assumed to be the top-left corner).
scale - Isotropic scale factor.
\sa getAffineTransform, warpAffine, transform

getPerspectiveTransform

@Namespace(value="cv")
@ByVal
public static opencv_core.Mat getPerspectiveTransform(@Const
                                                           opencv_core.Point2f src,
                                                           @Const
                                                           opencv_core.Point2f dst)

returns 3x3 perspective transformation for the corresponding 4 point pairs.

getAffineTransform
```
@Namespace(value="cv")
@ByVal
public static opencv_core.Mat getAffineTransform(@Const
                                                      opencv_core.Point2f src,
                                                      @Const
                                                      opencv_core.Point2f dst)
```
\brief Calculates an affine transform from three pairs of the corresponding points.
The function calculates the \f$2 \times 3\f$ matrix of an affine transform so that:
\f[\begin{bmatrix} x'_i \\ y'_i \end{bmatrix} = \texttt{map\_matrix} \cdot \begin{bmatrix} x_i \\ y_i \\ 1 \end{bmatrix}\f]
where
\f[dst(i)=(x'_i,y'_i), src(i)=(x_i, y_i), i=0,1,2\f]

Parameters:
src - Coordinates of triangle vertices in the source image.
dst - Coordinates of the corresponding triangle vertices in the destination image.
\sa warpAffine, transform

invertAffineTransform
```
@Namespace(value="cv")
public static void invertAffineTransform(@ByVal
                                        opencv_core.Mat M,
                                        @ByVal
                                        opencv_core.Mat iM)
```
\brief Inverts an affine transformation.
The function computes an inverse affine transformation represented by \f$2 \times 3\f$ matrix M:
\f[\begin{bmatrix} a_{11} & a_{12} & b_1 \\ a_{21} & a_{22} & b_2 \end{bmatrix}\f]
The result is also a \f$2 \times 3\f$ matrix of the same type as M.

Parameters:
M - Original affine transformation.
iM - Output reverse affine transformation.

getPerspectiveTransform
```
@Namespace(value="cv")
@ByVal
public static opencv_core.Mat getPerspectiveTransform(@ByVal
                                                           opencv_core.Mat src,
                                                           @ByVal
                                                           opencv_core.Mat dst)
```
\brief Calculates a perspective transform from four pairs of the corresponding points.
The function calculates the \f$3 \times 3\f$ matrix of a perspective transform so that:
\f[\begin{bmatrix} t_i x'_i \\ t_i y'_i \\ t_i \end{bmatrix} = \texttt{map\_matrix} \cdot \begin{bmatrix} x_i \\ y_i \\ 1 \end{bmatrix}\f]
where
\f[dst(i)=(x'_i,y'_i), src(i)=(x_i, y_i), i=0,1,2,3\f]

Parameters:
src - Coordinates of quadrangle vertices in the source image.
dst - Coordinates of the corresponding quadrangle vertices in the destination image.
\sa findHomography, warpPerspective, perspectiveTransform

getAffineTransform

@Namespace(value="cv")
@ByVal
public static opencv_core.Mat getAffineTransform(@ByVal
                                                      opencv_core.Mat src,
                                                      @ByVal
                                                      opencv_core.Mat dst)

getRectSubPix
```
@Namespace(value="cv")
public static void getRectSubPix(@ByVal
                                opencv_core.Mat image,
                                @ByVal
                                opencv_core.Size patchSize,
                                @ByVal
                                opencv_core.Point2f center,
                                @ByVal
                                opencv_core.Mat patch,
                                int patchType)
```
\brief Retrieves a pixel rectangle from an image with sub-pixel accuracy.
The function getRectSubPix extracts pixels from src:
\f[dst(x, y) = src(x + \texttt{center.x} - ( \texttt{dst.cols} -1)*0.5, y + \texttt{center.y} - ( \texttt{dst.rows} -1)*0.5)\f]
where the values of the pixels at non-integer coordinates are retrieved using bilinear interpolation. Every channel of multi-channel images is processed independently. While the center of the rectangle must be inside the image, parts of the rectangle may be outside. In this case, the replication border mode (see cv::BorderTypes) is used to extrapolate the pixel values outside of the image.

Parameters:
image - Source image.
patchSize - Size of the extracted patch.
center - Floating point coordinates of the center of the extracted rectangle within the source image. The center must be inside the image.
patch - Extracted patch that has the size patchSize and the same number of channels as src .
patchType - Depth of the extracted pixels. By default, they have the same depth as src .
\sa warpAffine, warpPerspective

getRectSubPix

@Namespace(value="cv")
public static void getRectSubPix(@ByVal
                                opencv_core.Mat image,
                                @ByVal
                                opencv_core.Size patchSize,
                                @ByVal
                                opencv_core.Point2f center,
                                @ByVal
                                opencv_core.Mat patch)

logPolar
```
@Namespace(value="cv")
public static void logPolar(@ByVal
                           opencv_core.Mat src,
                           @ByVal
                           opencv_core.Mat dst,
                           @ByVal
                           opencv_core.Point2f center,
                           double M,
                           int flags)
```
\brief Remaps an image to log-polar space.
transforms the source image using the following transformation: \f[dst( \phi , \rho ) = src(x,y)\f] where \f[\rho = M \cdot \log{\sqrt{x^2 + y^2}} , \phi =atan(y/x)\f]
The function emulates the human "foveal" vision and can be used for fast scale and rotation-invariant template matching, for object tracking and so forth. The function can not operate in-place.

Parameters:
src - Source image
dst - Destination image
center - The transformation center; where the output precision is maximal
M - Magnitude scale parameter.
flags - A combination of interpolation methods, see cv::InterpolationFlags

linearPolar

@Namespace(value="cv")
public static void linearPolar(@ByVal
                              opencv_core.Mat src,
                              @ByVal
                              opencv_core.Mat dst,
                              @ByVal
                              opencv_core.Point2f center,
                              double maxRadius,
                              int flags)

\brief Remaps an image to polar space.

transforms the source image using the following transformation: \f[dst( \phi , \rho ) = src(x,y)\f] where \f[\rho = (src.width/maxRadius) \cdot \sqrt{x^2 + y^2} , \phi =atan(y/x)\f]

The function can not operate in-place.

Parameters:: src - Source image; dst - Destination image; center - The transformation center;; maxRadius - Inverse magnitude scale parameter; flags - A combination of interpolation methods, see cv::InterpolationFlags

integral

@Namespace(value="cv")
public static void integral(@ByVal
                           opencv_core.Mat src,
                           @ByVal
                           opencv_core.Mat sum,
                           int sdepth)

\} imgproc_transform

\addtogroup imgproc_misc \{

/** \overload

integral

@Namespace(value="cv")
public static void integral(@ByVal
                           opencv_core.Mat src,
                           @ByVal
                           opencv_core.Mat sum)

integral2

@Namespace(value="cv")
@Name(value="integral")
public static void integral2(@ByVal
                                      opencv_core.Mat src,
                                      @ByVal
                                      opencv_core.Mat sum,
                                      @ByVal
                                      opencv_core.Mat sqsum,
                                      int sdepth,
                                      int sqdepth)

\overload

integral2

@Namespace(value="cv")
@Name(value="integral")
public static void integral2(@ByVal
                                      opencv_core.Mat src,
                                      @ByVal
                                      opencv_core.Mat sum,
                                      @ByVal
                                      opencv_core.Mat sqsum)

integral3
```
@Namespace(value="cv")
@Name(value="integral")
public static void integral3(@ByVal
                                      opencv_core.Mat src,
                                      @ByVal
                                      opencv_core.Mat sum,
                                      @ByVal
                                      opencv_core.Mat sqsum,
                                      @ByVal
                                      opencv_core.Mat tilted,
                                      int sdepth,
                                      int sqdepth)
```
\brief Calculates the integral of an image.
The functions calculate one or more integral images for the source image as follows:
\f[\texttt{sum} (X,Y) = \sum _{x \f[\texttt{sqsum} (X,Y) = \sum _{x \f[\texttt{tilted} (X,Y) = \sum _{y Using these integral images, you can calculate sum, mean, and standard deviation over a specific up-right or rotated rectangular region of the image in a constant time, for example:
\f[\sum _{x_1 \leq x < x_2, \, y_1 \leq y < y_2} \texttt{image} (x,y) = \texttt{sum} (x_2,y_2)- \texttt{sum} (x_1,y_2)- \texttt{sum} (x_2,y_1)+ \texttt{sum} (x_1,y_1)\f]
It makes possible to do a fast blurring or fast block correlation with a variable window size, for example. In case of multi-channel images, sums for each channel are accumulated independently.
As a practical example, the next figure shows the calculation of the integral of a straight rectangle Rect(3,3,3,2) and of a tilted rectangle Rect(5,1,2,3) . The selected pixels in the original image are shown, as well as the relative pixels in the integral images sum and tilted .
![integral calculation example](pics/integral.png)

Parameters:
src - input image as \f$W \times H\f$, 8-bit or floating-point (32f or 64f).
sum - integral image as \f$(W+1)\times (H+1)\f$ , 32-bit integer or floating-point (32f or 64f).
sqsum - integral image for squared pixel values; it is \f$(W+1)\times (H+1)\f$, double-precision floating-point (64f) array.
tilted - integral for the image rotated by 45 degrees; it is \f$(W+1)\times (H+1)\f$ array with the same data type as sum.
sdepth - desired depth of the integral and the tilted integral images, CV_32S, CV_32F, or CV_64F.
sqdepth - desired depth of the integral image of squared pixel values, CV_32F or CV_64F.

integral3

@Namespace(value="cv")
@Name(value="integral")
public static void integral3(@ByVal
                                      opencv_core.Mat src,
                                      @ByVal
                                      opencv_core.Mat sum,
                                      @ByVal
                                      opencv_core.Mat sqsum,
                                      @ByVal
                                      opencv_core.Mat tilted)

accumulate
```
@Namespace(value="cv")
public static void accumulate(@ByVal
                             opencv_core.Mat src,
                             @ByVal
                             opencv_core.Mat dst,
                             @ByVal(nullValue="cv::noArray()")
                             opencv_core.Mat mask)
```
\} imgproc_misc
\addtogroup imgproc_motion \{
/** \brief Adds an image to the accumulator.
The function adds src or some of its elements to dst :
\f[\texttt{dst} (x,y) \leftarrow \texttt{dst} (x,y) + \texttt{src} (x,y) \quad \text{if} \quad \texttt{mask} (x,y) \ne 0\f]
The function supports multi-channel images. Each channel is processed independently.
The functions accumulate\* can be used, for example, to collect statistics of a scene background viewed by a still camera and for the further foreground-background segmentation.

Parameters:
src - Input image as 1- or 3-channel, 8-bit or 32-bit floating point.
dst - %Accumulator image with the same number of channels as input image, 32-bit or 64-bit floating-point.
mask - Optional operation mask.
\sa accumulateSquare, accumulateProduct, accumulateWeighted

accumulate

@Namespace(value="cv")
public static void accumulate(@ByVal
                             opencv_core.Mat src,
                             @ByVal
                             opencv_core.Mat dst)

accumulateSquare
```
@Namespace(value="cv")
public static void accumulateSquare(@ByVal
                                   opencv_core.Mat src,
                                   @ByVal
                                   opencv_core.Mat dst,
                                   @ByVal(nullValue="cv::noArray()")
                                   opencv_core.Mat mask)
```
\brief Adds the square of a source image to the accumulator.
The function adds the input image src or its selected region, raised to a power of 2, to the accumulator dst :
\f[\texttt{dst} (x,y) \leftarrow \texttt{dst} (x,y) + \texttt{src} (x,y)^2 \quad \text{if} \quad \texttt{mask} (x,y) \ne 0\f]
The function supports multi-channel images. Each channel is processed independently.

Parameters:
src - Input image as 1- or 3-channel, 8-bit or 32-bit floating point.
dst - %Accumulator image with the same number of channels as input image, 32-bit or 64-bit floating-point.
mask - Optional operation mask.
\sa accumulateSquare, accumulateProduct, accumulateWeighted

accumulateSquare

@Namespace(value="cv")
public static void accumulateSquare(@ByVal
                                   opencv_core.Mat src,
                                   @ByVal
                                   opencv_core.Mat dst)

accumulateProduct
```
@Namespace(value="cv")
public static void accumulateProduct(@ByVal
                                    opencv_core.Mat src1,
                                    @ByVal
                                    opencv_core.Mat src2,
                                    @ByVal
                                    opencv_core.Mat dst,
                                    @ByVal(nullValue="cv::noArray()")
                                    opencv_core.Mat mask)
```
\brief Adds the per-element product of two input images to the accumulator.
The function adds the product of two images or their selected regions to the accumulator dst :
\f[\texttt{dst} (x,y) \leftarrow \texttt{dst} (x,y) + \texttt{src1} (x,y) \cdot \texttt{src2} (x,y) \quad \text{if} \quad \texttt{mask} (x,y) \ne 0\f]
The function supports multi-channel images. Each channel is processed independently.

Parameters:
src1 - First input image, 1- or 3-channel, 8-bit or 32-bit floating point.
src2 - Second input image of the same type and the same size as src1 .
dst - %Accumulator with the same number of channels as input images, 32-bit or 64-bit floating-point.
mask - Optional operation mask.
\sa accumulate, accumulateSquare, accumulateWeighted

accumulateProduct

@Namespace(value="cv")
public static void accumulateProduct(@ByVal
                                    opencv_core.Mat src1,
                                    @ByVal
                                    opencv_core.Mat src2,
                                    @ByVal
                                    opencv_core.Mat dst)

accumulateWeighted
```
@Namespace(value="cv")
public static void accumulateWeighted(@ByVal
                                     opencv_core.Mat src,
                                     @ByVal
                                     opencv_core.Mat dst,
                                     double alpha,
                                     @ByVal(nullValue="cv::noArray()")
                                     opencv_core.Mat mask)
```
\brief Updates a running average.
The function calculates the weighted sum of the input image src and the accumulator dst so that dst becomes a running average of a frame sequence:
\f[\texttt{dst} (x,y) \leftarrow (1- \texttt{alpha} ) \cdot \texttt{dst} (x,y) + \texttt{alpha} \cdot \texttt{src} (x,y) \quad \text{if} \quad \texttt{mask} (x,y) \ne 0\f]
That is, alpha regulates the update speed (how fast the accumulator "forgets" about earlier images). The function supports multi-channel images. Each channel is processed independently.

Parameters:
src - Input image as 1- or 3-channel, 8-bit or 32-bit floating point.
dst - %Accumulator image with the same number of channels as input image, 32-bit or 64-bit floating-point.
alpha - Weight of the input image.
mask - Optional operation mask.
\sa accumulate, accumulateSquare, accumulateProduct

accumulateWeighted

@Namespace(value="cv")
public static void accumulateWeighted(@ByVal
                                     opencv_core.Mat src,
                                     @ByVal
                                     opencv_core.Mat dst,
                                     double alpha)

phaseCorrelate
```
@Namespace(value="cv")
@ByVal
public static opencv_core.Point2d phaseCorrelate(@ByVal
                                                      opencv_core.Mat src1,
                                                      @ByVal
                                                      opencv_core.Mat src2,
                                                      @ByVal(nullValue="cv::noArray()")
                                                      opencv_core.Mat window,
                                                      DoublePointer response)
```
\brief The function is used to detect translational shifts that occur between two images.
The operation takes advantage of the Fourier shift theorem for detecting the translational shift in the frequency domain. It can be used for fast image registration as well as motion estimation. For more information please see
Calculates the cross-power spectrum of two supplied source arrays. The arrays are padded if needed with getOptimalDFTSize.
The function performs the following equations: - First it applies a Hanning window (see ) to each image to remove possible edge effects. This window is cached until the array size changes to speed up processing time. - Next it computes the forward DFTs of each source array: \f[\mathbf{G}_a = \mathcal{F}\{src_1\}, \; \mathbf{G}_b = \mathcal{F}\{src_2\}\f] where \f$\mathcal{F}\f$ is the forward DFT. - It then computes the cross-power spectrum of each frequency domain array: \f[R = \frac{ \mathbf{G}_a \mathbf{G}_b^*}{|\mathbf{G}_a \mathbf{G}_b^*|}\f] - Next the cross-correlation is converted back into the time domain via the inverse DFT: \f[r = \mathcal{F}^{-1}\{R\}\f] - Finally, it computes the peak location and computes a 5x5 weighted centroid around the peak to achieve sub-pixel accuracy. \f[(\Delta x, \Delta y) = \texttt{weightedCentroid} \{\arg \max_{(x, y)}\{r\}\}\f] - If non-zero, the response parameter is computed as the sum of the elements of r within the 5x5 centroid around the peak location. It is normalized to a maximum of 1 (meaning there is a single peak) and will be smaller when there are multiple peaks.

Parameters:
src1 - Source floating point array (CV_32FC1 or CV_64FC1)
src2 - Source floating point array (CV_32FC1 or CV_64FC1)
window - Floating point array with windowing coefficients to reduce edge effects (optional).
response - Signal power within the 5x5 centroid around the peak, between 0 and 1 (optional).

Returns:
detected phase shift (sub-pixel) between the two arrays.
\sa dft, getOptimalDFTSize, idft, mulSpectrums createHanningWindow

phaseCorrelate

@Namespace(value="cv")
@ByVal
public static opencv_core.Point2d phaseCorrelate(@ByVal
                                                      opencv_core.Mat src1,
                                                      @ByVal
                                                      opencv_core.Mat src2)

phaseCorrelate

@Namespace(value="cv")
@ByVal
public static opencv_core.Point2d phaseCorrelate(@ByVal
                                                      opencv_core.Mat src1,
                                                      @ByVal
                                                      opencv_core.Mat src2,
                                                      @ByVal(nullValue="cv::noArray()")
                                                      opencv_core.Mat window,
                                                      DoubleBuffer response)

phaseCorrelate

@Namespace(value="cv")
@ByVal
public static opencv_core.Point2d phaseCorrelate(@ByVal
                                                      opencv_core.Mat src1,
                                                      @ByVal
                                                      opencv_core.Mat src2,
                                                      @ByVal(nullValue="cv::noArray()")
                                                      opencv_core.Mat window,
                                                      double[] response)

createHanningWindow

@Namespace(value="cv")
public static void createHanningWindow(@ByVal
                                      opencv_core.Mat dst,
                                      @ByVal
                                      opencv_core.Size winSize,
                                      int type)

\brief This function computes a Hanning window coefficients in two dimensions.

See (http://en.wikipedia.org/wiki/Hann_function) and (http://en.wikipedia.org/wiki/Window_function) for more information.

An example is shown below:

// create hanning window of size 100x100 and type CV_32F
    Mat hann;
    createHanningWindow(hann, Size(100, 100), CV_32F);

Parameters:: dst - Destination array to place Hann coefficients in; winSize - The window size specifications; type - Created array type

threshold
```
@Namespace(value="cv")
public static double threshold(@ByVal
                              opencv_core.Mat src,
                              @ByVal
                              opencv_core.Mat dst,
                              double thresh,
                              double maxval,
                              int type)
```
\} imgproc_motion
\addtogroup imgproc_misc \{
/** \brief Applies a fixed-level threshold to each array element.
The function applies fixed-level thresholding to a single-channel array. The function is typically used to get a bi-level (binary) image out of a grayscale image ( cv::compare could be also used for this purpose) or for removing a noise, that is, filtering out pixels with too small or too large values. There are several types of thresholding supported by the function. They are determined by type parameter.
Also, the special values cv::THRESH_OTSU or cv::THRESH_TRIANGLE may be combined with one of the above values. In these cases, the function determines the optimal threshold value using the Otsu's or Triangle algorithm and uses it instead of the specified thresh . The function returns the computed threshold value. Currently, the Otsu's and Triangle methods are implemented only for 8-bit images.

Parameters:
src - input array (single-channel, 8-bit or 32-bit floating point).
dst - output array of the same size and type as src.
thresh - threshold value.
maxval - maximum value to use with the THRESH_BINARY and THRESH_BINARY_INV thresholding types.
type - thresholding type (see the cv::ThresholdTypes).
\sa adaptiveThreshold, findContours, compare, min, max

adaptiveThreshold
```
@Namespace(value="cv")
public static void adaptiveThreshold(@ByVal
                                    opencv_core.Mat src,
                                    @ByVal
                                    opencv_core.Mat dst,
                                    double maxValue,
                                    int adaptiveMethod,
                                    int thresholdType,
                                    int blockSize,
                                    double C)
```
\brief Applies an adaptive threshold to an array.
The function transforms a grayscale image to a binary image according to the formulae: - **THRESH_BINARY** \f[dst(x,y) = \fork{\texttt{maxValue}}{if $src(x,y) > T(x,y)$}{0}{otherwise}\f] - **THRESH_BINARY_INV** \f[dst(x,y) = \fork{0}{if $src(x,y) > T(x,y)$}{\texttt{maxValue}}{otherwise}\f] where \f$T(x,y)\f$ is a threshold calculated individually for each pixel (see adaptiveMethod parameter).
The function can process the image in-place.

Parameters:
src - Source 8-bit single-channel image.
dst - Destination image of the same size and the same type as src.
maxValue - Non-zero value assigned to the pixels for which the condition is satisfied
adaptiveMethod - Adaptive thresholding algorithm to use, see cv::AdaptiveThresholdTypes
thresholdType - Thresholding type that must be either THRESH_BINARY or THRESH_BINARY_INV, see cv::ThresholdTypes.
blockSize - Size of a pixel neighborhood that is used to calculate a threshold value for the pixel: 3, 5, 7, and so on.
C - Constant subtracted from the mean or weighted mean (see the details below). Normally, it is positive but may be zero or negative as well.
\sa threshold, blur, GaussianBlur

pyrDown
```
@Namespace(value="cv")
public static void pyrDown(@ByVal
                          opencv_core.Mat src,
                          @ByVal
                          opencv_core.Mat dst,
                          @Const@ByRef(nullValue="cv::Size()")
                          opencv_core.Size dstsize,
                          int borderType)
```
\} imgproc_misc
\addtogroup imgproc_filter \{
/** \brief Blurs an image and downsamples it.
By default, size of the output image is computed as Size((src.cols+1)/2, (src.rows+1)/2), but in any case, the following conditions should be satisfied:
\f[\begin{array}{l} | \texttt{dstsize.width} *2-src.cols| \leq 2 \\ | \texttt{dstsize.height} *2-src.rows| \leq 2 \end{array}\f]
The function performs the downsampling step of the Gaussian pyramid construction. First, it convolves the source image with the kernel:
\f[\frac{1}{256} \begin{bmatrix} 1 & 4 & 6 & 4 & 1 \\ 4 & 16 & 24 & 16 & 4 \\ 6 & 24 & 36 & 24 & 6 \\ 4 & 16 & 24 & 16 & 4 \\ 1 & 4 & 6 & 4 & 1 \end{bmatrix}\f]
Then, it downsamples the image by rejecting even rows and columns.

Parameters:
src - input image.
dst - output image; it has the specified size and the same type as src.
dstsize - size of the output image.
borderType - Pixel extrapolation method, see cv::BorderTypes (BORDER_CONSTANT isn't supported)

pyrDown

@Namespace(value="cv")
public static void pyrDown(@ByVal
                          opencv_core.Mat src,
                          @ByVal
                          opencv_core.Mat dst)

pyrUp
```
@Namespace(value="cv")
public static void pyrUp(@ByVal
                        opencv_core.Mat src,
                        @ByVal
                        opencv_core.Mat dst,
                        @Const@ByRef(nullValue="cv::Size()")
                        opencv_core.Size dstsize,
                        int borderType)
```
\brief Upsamples an image and then blurs it.
By default, size of the output image is computed as Size(src.cols\*2, (src.rows\*2), but in any case, the following conditions should be satisfied:
\f[\begin{array}{l} | \texttt{dstsize.width} -src.cols*2| \leq ( \texttt{dstsize.width} \mod 2) \\ | \texttt{dstsize.height} -src.rows*2| \leq ( \texttt{dstsize.height} \mod 2) \end{array}\f]
The function performs the upsampling step of the Gaussian pyramid construction, though it can actually be used to construct the Laplacian pyramid. First, it upsamples the source image by injecting even zero rows and columns and then convolves the result with the same kernel as in pyrDown multiplied by 4.

Parameters:
src - input image.
dst - output image. It has the specified size and the same type as src .
dstsize - size of the output image.
borderType - Pixel extrapolation method, see cv::BorderTypes (only BORDER_DEFAULT is supported)

pyrUp

@Namespace(value="cv")
public static void pyrUp(@ByVal
                        opencv_core.Mat src,
                        @ByVal
                        opencv_core.Mat dst)

buildPyramid
```
@Namespace(value="cv")
public static void buildPyramid(@ByVal
                               opencv_core.Mat src,
                               @ByVal
                               opencv_core.MatVector dst,
                               int maxlevel,
                               int borderType)
```
\brief Constructs the Gaussian pyramid for an image.
The function constructs a vector of images and builds the Gaussian pyramid by recursively applying pyrDown to the previously built pyramid layers, starting from dst[0]==src.

Parameters:
src - Source image. Check pyrDown for the list of supported types.
dst - Destination vector of maxlevel+1 images of the same type as src. dst[0] will be the same as src. dst[1] is the next pyramid layer, a smoothed and down-sized src, and so on.
maxlevel - 0-based index of the last (the smallest) pyramid layer. It must be non-negative.
borderType - Pixel extrapolation method, see cv::BorderTypes (BORDER_CONSTANT isn't supported)

buildPyramid

@Namespace(value="cv")
public static void buildPyramid(@ByVal
                               opencv_core.Mat src,
                               @ByVal
                               opencv_core.MatVector dst,
                               int maxlevel)

undistort
```
@Namespace(value="cv")
public static void undistort(@ByVal
                            opencv_core.Mat src,
                            @ByVal
                            opencv_core.Mat dst,
                            @ByVal
                            opencv_core.Mat cameraMatrix,
                            @ByVal
                            opencv_core.Mat distCoeffs,
                            @ByVal(nullValue="cv::noArray()")
                            opencv_core.Mat newCameraMatrix)
```
\} imgproc_filter
\addtogroup imgproc_transform \{
/** \brief Transforms an image to compensate for lens distortion.
The function transforms an image to compensate radial and tangential lens distortion.
The function is simply a combination of cv::initUndistortRectifyMap (with unity R ) and cv::remap (with bilinear interpolation). See the former function for details of the transformation being performed.
Those pixels in the destination image, for which there is no correspondent pixels in the source image, are filled with zeros (black color).
A particular subset of the source image that will be visible in the corrected image can be regulated by newCameraMatrix. You can use cv::getOptimalNewCameraMatrix to compute the appropriate newCameraMatrix depending on your requirements.
The camera matrix and the distortion parameters can be determined using cv::calibrateCamera. If the resolution of images is different from the resolution used at the calibration stage, \f$f_x, f_y, c_x\f$ and \f$c_y\f$ need to be scaled accordingly, while the distortion coefficients remain the same.

Parameters:
src - Input (distorted) image.
dst - Output (corrected) image that has the same size and type as src .
cameraMatrix - Input camera matrix \f$A = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}\f$ .
distCoeffs - Input vector of distortion coefficients \f$(k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6[, s_1, s_2, s_3, s_4[, \tau_x, \tau_y]]]])\f$ of 4, 5, 8, 12 or 14 elements. If the vector is NULL/empty, the zero distortion coefficients are assumed.
newCameraMatrix - Camera matrix of the distorted image. By default, it is the same as cameraMatrix but you may additionally scale and shift the result by using a different matrix.

undistort

@Namespace(value="cv")
public static void undistort(@ByVal
                            opencv_core.Mat src,
                            @ByVal
                            opencv_core.Mat dst,
                            @ByVal
                            opencv_core.Mat cameraMatrix,
                            @ByVal
                            opencv_core.Mat distCoeffs)

initUndistortRectifyMap
```
@Namespace(value="cv")
public static void initUndistortRectifyMap(@ByVal
                                          opencv_core.Mat cameraMatrix,
                                          @ByVal
                                          opencv_core.Mat distCoeffs,
                                          @ByVal
                                          opencv_core.Mat R,
                                          @ByVal
                                          opencv_core.Mat newCameraMatrix,
                                          @ByVal
                                          opencv_core.Size size,
                                          int m1type,
                                          @ByVal
                                          opencv_core.Mat map1,
                                          @ByVal
                                          opencv_core.Mat map2)
```
\brief Computes the undistortion and rectification transformation map.
The function computes the joint undistortion and rectification transformation and represents the result in the form of maps for remap. The undistorted image looks like original, as if it is captured with a camera using the camera matrix =newCameraMatrix and zero distortion. In case of a monocular camera, newCameraMatrix is usually equal to cameraMatrix, or it can be computed by cv::getOptimalNewCameraMatrix for a better control over scaling. In case of a stereo camera, newCameraMatrix is normally set to P1 or P2 computed by cv::stereoRectify .
Also, this new camera is oriented differently in the coordinate space, according to R. That, for example, helps to align two heads of a stereo camera so that the epipolar lines on both images become horizontal and have the same y- coordinate (in case of a horizontally aligned stereo camera).
The function actually builds the maps for the inverse mapping algorithm that is used by remap. That is, for each pixel \f$(u, v)\f$ in the destination (corrected and rectified) image, the function computes the corresponding coordinates in the source image (that is, in the original image from camera). The following process is applied: \f[ \begin{array}{l} x \leftarrow (u - {c'}_x)/{f'}_x \\ y \leftarrow (v - {c'}_y)/{f'}_y \\ {[X\,Y\,W]} ^T \leftarrow R^{-1}*[x \, y \, 1]^T \\ x' \leftarrow X/W \\ y' \leftarrow Y/W \\ r^2 \leftarrow x'^2 + y'^2 \\ x'' \leftarrow x' \frac{1 + k_1 r^2 + k_2 r^4 + k_3 r^6}{1 + k_4 r^2 + k_5 r^4 + k_6 r^6} + 2p_1 x' y' + p_2(r^2 + 2 x'^2) + s_1 r^2 + s_2 r^4\\ y'' \leftarrow y' \frac{1 + k_1 r^2 + k_2 r^4 + k_3 r^6}{1 + k_4 r^2 + k_5 r^4 + k_6 r^6} + p_1 (r^2 + 2 y'^2) + 2 p_2 x' y' + s_3 r^2 + s_4 r^4 \\ s\vecthree{x'''}{y'''}{1} = \vecthreethree{R_{33}(\tau_x, \tau_y)}{0}{-R_{13}((\tau_x, \tau_y)} {0}{R_{33}(\tau_x, \tau_y)}{-R_{23}(\tau_x, \tau_y)} {0}{0}{1} R(\tau_x, \tau_y) \vecthree{x''}{y''}{1}\\ map_x(u,v) \leftarrow x''' f_x + c_x \\ map_y(u,v) \leftarrow y''' f_y + c_y \end{array} \f] where \f$(k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6[, s_1, s_2, s_3, s_4[, \tau_x, \tau_y]]]])\f$ are the distortion coefficients.
In case of a stereo camera, this function is called twice: once for each camera head, after stereoRectify, which in its turn is called after cv::stereoCalibrate. But if the stereo camera was not calibrated, it is still possible to compute the rectification transformations directly from the fundamental matrix using cv::stereoRectifyUncalibrated. For each camera, the function computes homography H as the rectification transformation in a pixel domain, not a rotation matrix R in 3D space. R can be computed from H as \f[\texttt{R} = \texttt{cameraMatrix} ^{-1} \cdot \texttt{H} \cdot \texttt{cameraMatrix}\f] where cameraMatrix can be chosen arbitrarily.

Parameters:
cameraMatrix - Input camera matrix \f$A=\vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}\f$ .
distCoeffs - Input vector of distortion coefficients \f$(k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6[, s_1, s_2, s_3, s_4[, \tau_x, \tau_y]]]])\f$ of 4, 5, 8, 12 or 14 elements. If the vector is NULL/empty, the zero distortion coefficients are assumed.
R - Optional rectification transformation in the object space (3x3 matrix). R1 or R2 , computed by stereoRectify can be passed here. If the matrix is empty, the identity transformation is assumed. In cvInitUndistortMap R assumed to be an identity matrix.
newCameraMatrix - New camera matrix \f$A'=\vecthreethree{f_x'}{0}{c_x'}{0}{f_y'}{c_y'}{0}{0}{1}\f$.
size - Undistorted image size.
m1type - Type of the first output map that can be CV_32FC1 or CV_16SC2, see cv::convertMaps
map1 - The first output map.
map2 - The second output map.

initWideAngleProjMap

@Namespace(value="cv")
public static float initWideAngleProjMap(@ByVal
                                        opencv_core.Mat cameraMatrix,
                                        @ByVal
                                        opencv_core.Mat distCoeffs,
                                        @ByVal
                                        opencv_core.Size imageSize,
                                        int destImageWidth,
                                        int m1type,
                                        @ByVal
                                        opencv_core.Mat map1,
                                        @ByVal
                                        opencv_core.Mat map2,
                                        int projType,
                                        double alpha)

initializes maps for cv::remap() for wide-angle

initWideAngleProjMap

@Namespace(value="cv")
public static float initWideAngleProjMap(@ByVal
                                        opencv_core.Mat cameraMatrix,
                                        @ByVal
                                        opencv_core.Mat distCoeffs,
                                        @ByVal
                                        opencv_core.Size imageSize,
                                        int destImageWidth,
                                        int m1type,
                                        @ByVal
                                        opencv_core.Mat map1,
                                        @ByVal
                                        opencv_core.Mat map2)

getDefaultNewCameraMatrix
```
@Namespace(value="cv")
@ByVal
public static opencv_core.Mat getDefaultNewCameraMatrix(@ByVal
                                                             opencv_core.Mat cameraMatrix,
                                                             @ByVal(nullValue="cv::Size()")
                                                             opencv_core.Size imgsize,
                                                             @Cast(value="bool")
                                                             boolean centerPrincipalPoint)
```
\brief Returns the default new camera matrix.
The function returns the camera matrix that is either an exact copy of the input cameraMatrix (when centerPrinicipalPoint=false ), or the modified one (when centerPrincipalPoint=true).
In the latter case, the new camera matrix will be:
\f[\begin{bmatrix} f_x && 0 && ( \texttt{imgSize.width} -1)*0.5 \\ 0 && f_y && ( \texttt{imgSize.height} -1)*0.5 \\ 0 && 0 && 1 \end{bmatrix} ,\f]
where \f$f_x\f$ and \f$f_y\f$ are \f$(0,0)\f$ and \f$(1,1)\f$ elements of cameraMatrix, respectively.
By default, the undistortion functions in OpenCV (see initUndistortRectifyMap, undistort) do not move the principal point. However, when you work with stereo, it is important to move the principal points in both views to the same y-coordinate (which is required by most of stereo correspondence algorithms), and may be to the same x-coordinate too. So, you can form the new camera matrix for each view where the principal points are located at the center.

Parameters:
cameraMatrix - Input camera matrix.
imgsize - Camera view image size in pixels.
centerPrincipalPoint - Location of the principal point in the new camera matrix. The parameter indicates whether this location should be at the image center or not.

getDefaultNewCameraMatrix

@Namespace(value="cv")
@ByVal
public static opencv_core.Mat getDefaultNewCameraMatrix(@ByVal
                                                             opencv_core.Mat cameraMatrix)

undistortPoints
```
@Namespace(value="cv")
public static void undistortPoints(@ByVal
                                  opencv_core.Mat src,
                                  @ByVal
                                  opencv_core.Mat dst,
                                  @ByVal
                                  opencv_core.Mat cameraMatrix,
                                  @ByVal
                                  opencv_core.Mat distCoeffs,
                                  @ByVal(nullValue="cv::noArray()")
                                  opencv_core.Mat R,
                                  @ByVal(nullValue="cv::noArray()")
                                  opencv_core.Mat P)
```
\brief Computes the ideal point coordinates from the observed point coordinates.
The function is similar to cv::undistort and cv::initUndistortRectifyMap but it operates on a sparse set of points instead of a raster image. Also the function performs a reverse transformation to projectPoints. In case of a 3D object, it does not reconstruct its 3D coordinates, but for a planar object, it does, up to a translation vector, if the proper R is specified.
```
// (u,v) is the input point, (u', v') is the output point
    // camera_matrix=[fx 0 cx; 0 fy cy; 0 0 1]
    // P=[fx' 0 cx' tx; 0 fy' cy' ty; 0 0 1 tz]
    x" = (u - cx)/fx
    y" = (v - cy)/fy
    (x',y') = undistort(x",y",dist_coeffs)
    [X,Y,W]T = R*[x' y' 1]T
    x = X/W, y = Y/W
    // only performed if P=[fx' 0 cx' [tx]; 0 fy' cy' [ty]; 0 0 1 [tz]] is specified
    u' = x*fx' + cx'
    v' = y*fy' + cy',
```
where cv::undistort is an approximate iterative algorithm that estimates the normalized original point coordinates out of the normalized distorted point coordinates ("normalized" means that the coordinates do not depend on the camera matrix).
The function can be used for both a stereo camera head or a monocular camera (when R is empty).
Parameters:
src - Observed point coordinates, 1xN or Nx1 2-channel (CV_32FC2 or CV_64FC2).
dst - Output ideal point coordinates after undistortion and reverse perspective transformation. If matrix P is identity or omitted, dst will contain normalized point coordinates.
cameraMatrix - Camera matrix \f$\vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}\f$ .
distCoeffs - Input vector of distortion coefficients \f$(k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6[, s_1, s_2, s_3, s_4[, \tau_x, \tau_y]]]])\f$ of 4, 5, 8, 12 or 14 elements. If the vector is NULL/empty, the zero distortion coefficients are assumed.
R - Rectification transformation in the object space (3x3 matrix). R1 or R2 computed by cv::stereoRectify can be passed here. If the matrix is empty, the identity transformation is used.
P - New camera matrix (3x3) or new projection matrix (3x4). P1 or P2 computed by cv::stereoRectify can be passed here. If the matrix is empty, the identity new camera matrix is used.

undistortPoints

@Namespace(value="cv")
public static void undistortPoints(@ByVal
                                  opencv_core.Mat src,
                                  @ByVal
                                  opencv_core.Mat dst,
                                  @ByVal
                                  opencv_core.Mat cameraMatrix,
                                  @ByVal
                                  opencv_core.Mat distCoeffs)

calcHist

@Namespace(value="cv")
public static void calcHist(@Const
                           opencv_core.Mat images,
                           int nimages,
                           @Const
                           IntPointer channels,
                           @ByVal
                           opencv_core.Mat mask,
                           @ByVal
                           opencv_core.Mat hist,
                           int dims,
                           @Const
                           IntPointer histSize,
                           @Cast(value="const float**")
                           PointerPointer ranges,
                           @Cast(value="bool")
                           boolean uniform,
                           @Cast(value="bool")
                           boolean accumulate)

\brief Calculates a histogram of a set of arrays.

The functions calcHist calculate the histogram of one or more arrays. The elements of a tuple used to increment a histogram bin are taken from the corresponding input arrays at the same location. The sample below shows how to compute a 2D Hue-Saturation histogram for a color image. :

#include <opencv2/imgproc.hpp>
    #include <opencv2/highgui.hpp>

    using namespace cv;

    int main( int argc, char** argv )
    {
        Mat src, hsv;
        if( argc != 2 || !(src=imread(argv[1], 1)).data )
            return -1;

        cvtColor(src, hsv, COLOR_BGR2HSV);

        // Quantize the hue to 30 levels
        // and the saturation to 32 levels
        int hbins = 30, sbins = 32;
        int histSize[] = {hbins, sbins};
        // hue varies from 0 to 179, see cvtColor
        float hranges[] = { 0, 180 };
        // saturation varies from 0 (black-gray-white) to
        // 255 (pure spectrum color)
        float sranges[] = { 0, 256 };
        const float* ranges[] = { hranges, sranges };
        MatND hist;
        // we compute the histogram from the 0-th and 1-st channels
        int channels[] = {0, 1};

        calcHist( &hsv, 1, channels, Mat(), // do not use mask
                 hist, 2, histSize, ranges,
                 true, // the histogram is uniform
                 false );
        double maxVal=0;
        minMaxLoc(hist, 0, &maxVal, 0, 0);

        int scale = 10;
        Mat histImg = Mat::zeros(sbins*scale, hbins*10, CV_8UC3);

        for( int h = 0; h < hbins; h++ )
            for( int s = 0; s < sbins; s++ )
            {
                float binVal = hist.at<float>(h, s);
                int intensity = cvRound(binVal*255/maxVal);
                rectangle( histImg, Point(h*scale, s*scale),
                            Point( (h+1)*scale - 1, (s+1)*scale - 1),
                            Scalar::all(intensity),
                            CV_FILLED );
            }

        namedWindow( "Source", 1 );
        imshow( "Source", src );

        namedWindow( "H-S Histogram", 1 );
        imshow( "H-S Histogram", histImg );
        waitKey();
    }

Parameters:: images - Source arrays. They all should have the same depth, CV_8U or CV_32F , and the same size. Each of them can have an arbitrary number of channels.; nimages - Number of source images.; channels - List of the dims channels used to compute the histogram. The first array channels are numerated from 0 to images[0].channels()-1 , the second array channels are counted from images[0].channels() to images[0].channels() + images[1].channels()-1, and so on.; mask - Optional mask. If the matrix is not empty, it must be an 8-bit array of the same size as images[i] . The non-zero mask elements mark the array elements counted in the histogram.; hist - Output histogram, which is a dense or sparse dims -dimensional array.; dims - Histogram dimensionality that must be positive and not greater than CV_MAX_DIMS (equal to 32 in the current OpenCV version).; histSize - Array of histogram sizes in each dimension.; ranges - Array of the dims arrays of the histogram bin boundaries in each dimension. When the histogram is uniform ( uniform =true), then for each dimension i it is enough to specify the lower (inclusive) boundary \f$L_0\f$ of the 0-th histogram bin and the upper (exclusive) boundary \f$U_{\texttt{histSize}[i]-1}\f$ for the last histogram bin histSize[i]-1 . That is, in case of a uniform histogram each of ranges[i] is an array of 2 elements. When the histogram is not uniform ( uniform=false ), then each of ranges[i] contains histSize[i]+1 elements: \f$L_0, U_0=L_1, U_1=L_2, ..., U_{\texttt{histSize[i]}-2}=L_{\texttt{histSize[i]}-1}, U_{\texttt{histSize[i]}-1}\f$ . The array elements, that are not between \f$L_0\f$ and \f$U_{\texttt{histSize[i]}-1}\f$ , are not counted in the histogram.; uniform - Flag indicating whether the histogram is uniform or not (see above).; accumulate - Accumulation flag. If it is set, the histogram is not cleared in the beginning when it is allocated. This feature enables you to compute a single histogram from several sets of arrays, or to update the histogram in time.

calcHist

@Namespace(value="cv")
public static void calcHist(@Const
                           opencv_core.Mat images,
                           int nimages,
                           @Const
                           IntPointer channels,
                           @ByVal
                           opencv_core.Mat mask,
                           @ByVal
                           opencv_core.Mat hist,
                           int dims,
                           @Const
                           IntPointer histSize,
                           @Const@ByPtrPtr
                           FloatPointer ranges)

calcHist

@Namespace(value="cv")
public static void calcHist(@Const
                           opencv_core.Mat images,
                           int nimages,
                           @Const
                           IntPointer channels,
                           @ByVal
                           opencv_core.Mat mask,
                           @ByVal
                           opencv_core.Mat hist,
                           int dims,
                           @Const
                           IntPointer histSize,
                           @Const@ByPtrPtr
                           FloatPointer ranges,
                           @Cast(value="bool")
                           boolean uniform,
                           @Cast(value="bool")
                           boolean accumulate)

calcHist

@Namespace(value="cv")
public static void calcHist(@Const
                           opencv_core.Mat images,
                           int nimages,
                           @Const
                           IntBuffer channels,
                           @ByVal
                           opencv_core.Mat mask,
                           @ByVal
                           opencv_core.Mat hist,
                           int dims,
                           @Const
                           IntBuffer histSize,
                           @Const@ByPtrPtr
                           FloatBuffer ranges,
                           @Cast(value="bool")
                           boolean uniform,
                           @Cast(value="bool")
                           boolean accumulate)

calcHist

@Namespace(value="cv")
public static void calcHist(@Const
                           opencv_core.Mat images,
                           int nimages,
                           @Const
                           IntBuffer channels,
                           @ByVal
                           opencv_core.Mat mask,
                           @ByVal
                           opencv_core.Mat hist,
                           int dims,
                           @Const
                           IntBuffer histSize,
                           @Const@ByPtrPtr
                           FloatBuffer ranges)

calcHist

@Namespace(value="cv")
public static void calcHist(@Const
                           opencv_core.Mat images,
                           int nimages,
                           @Const
                           int[] channels,
                           @ByVal
                           opencv_core.Mat mask,
                           @ByVal
                           opencv_core.Mat hist,
                           int dims,
                           @Const
                           int[] histSize,
                           @Const@ByPtrPtr
                           float[] ranges,
                           @Cast(value="bool")
                           boolean uniform,
                           @Cast(value="bool")
                           boolean accumulate)

calcHist

@Namespace(value="cv")
public static void calcHist(@Const
                           opencv_core.Mat images,
                           int nimages,
                           @Const
                           int[] channels,
                           @ByVal
                           opencv_core.Mat mask,
                           @ByVal
                           opencv_core.Mat hist,
                           int dims,
                           @Const
                           int[] histSize,
                           @Const@ByPtrPtr
                           float[] ranges)

calcHist

@Namespace(value="cv")
public static void calcHist(@Const
                           opencv_core.Mat images,
                           int nimages,
                           @Const
                           IntPointer channels,
                           @ByVal
                           opencv_core.Mat mask,
                           @ByRef
                           opencv_core.SparseMat hist,
                           int dims,
                           @Const
                           IntPointer histSize,
                           @Cast(value="const float**")
                           PointerPointer ranges,
                           @Cast(value="bool")
                           boolean uniform,
                           @Cast(value="bool")
                           boolean accumulate)

\overload

this variant uses cv::SparseMat for output

calcHist

@Namespace(value="cv")
public static void calcHist(@Const
                           opencv_core.Mat images,
                           int nimages,
                           @Const
                           IntPointer channels,
                           @ByVal
                           opencv_core.Mat mask,
                           @ByRef
                           opencv_core.SparseMat hist,
                           int dims,
                           @Const
                           IntPointer histSize,
                           @Const@ByPtrPtr
                           FloatPointer ranges)

calcHist

@Namespace(value="cv")
public static void calcHist(@Const
                           opencv_core.Mat images,
                           int nimages,
                           @Const
                           IntPointer channels,
                           @ByVal
                           opencv_core.Mat mask,
                           @ByRef
                           opencv_core.SparseMat hist,
                           int dims,
                           @Const
                           IntPointer histSize,
                           @Const@ByPtrPtr
                           FloatPointer ranges,
                           @Cast(value="bool")
                           boolean uniform,
                           @Cast(value="bool")
                           boolean accumulate)

calcHist

@Namespace(value="cv")
public static void calcHist(@Const
                           opencv_core.Mat images,
                           int nimages,
                           @Const
                           IntBuffer channels,
                           @ByVal
                           opencv_core.Mat mask,
                           @ByRef
                           opencv_core.SparseMat hist,
                           int dims,
                           @Const
                           IntBuffer histSize,
                           @Const@ByPtrPtr
                           FloatBuffer ranges,
                           @Cast(value="bool")
                           boolean uniform,
                           @Cast(value="bool")
                           boolean accumulate)

calcHist

@Namespace(value="cv")
public static void calcHist(@Const
                           opencv_core.Mat images,
                           int nimages,
                           @Const
                           IntBuffer channels,
                           @ByVal
                           opencv_core.Mat mask,
                           @ByRef
                           opencv_core.SparseMat hist,
                           int dims,
                           @Const
                           IntBuffer histSize,
                           @Const@ByPtrPtr
                           FloatBuffer ranges)

calcHist

@Namespace(value="cv")
public static void calcHist(@Const
                           opencv_core.Mat images,
                           int nimages,
                           @Const
                           int[] channels,
                           @ByVal
                           opencv_core.Mat mask,
                           @ByRef
                           opencv_core.SparseMat hist,
                           int dims,
                           @Const
                           int[] histSize,
                           @Const@ByPtrPtr
                           float[] ranges,
                           @Cast(value="bool")
                           boolean uniform,
                           @Cast(value="bool")
                           boolean accumulate)

calcHist

@Namespace(value="cv")
public static void calcHist(@Const
                           opencv_core.Mat images,
                           int nimages,
                           @Const
                           int[] channels,
                           @ByVal
                           opencv_core.Mat mask,
                           @ByRef
                           opencv_core.SparseMat hist,
                           int dims,
                           @Const
                           int[] histSize,
                           @Const@ByPtrPtr
                           float[] ranges)

calcHist

@Namespace(value="cv")
public static void calcHist(@ByVal
                           opencv_core.MatVector images,
                           @StdVector
                           IntPointer channels,
                           @ByVal
                           opencv_core.Mat mask,
                           @ByVal
                           opencv_core.Mat hist,
                           @StdVector
                           IntPointer histSize,
                           @StdVector
                           FloatPointer ranges,
                           @Cast(value="bool")
                           boolean accumulate)

\overload

calcHist

@Namespace(value="cv")
public static void calcHist(@ByVal
                           opencv_core.MatVector images,
                           @StdVector
                           IntPointer channels,
                           @ByVal
                           opencv_core.Mat mask,
                           @ByVal
                           opencv_core.Mat hist,
                           @StdVector
                           IntPointer histSize,
                           @StdVector
                           FloatPointer ranges)

calcHist

@Namespace(value="cv")
public static void calcHist(@ByVal
                           opencv_core.MatVector images,
                           @StdVector
                           IntBuffer channels,
                           @ByVal
                           opencv_core.Mat mask,
                           @ByVal
                           opencv_core.Mat hist,
                           @StdVector
                           IntBuffer histSize,
                           @StdVector
                           FloatBuffer ranges,
                           @Cast(value="bool")
                           boolean accumulate)

calcHist

@Namespace(value="cv")
public static void calcHist(@ByVal
                           opencv_core.MatVector images,
                           @StdVector
                           IntBuffer channels,
                           @ByVal
                           opencv_core.Mat mask,
                           @ByVal
                           opencv_core.Mat hist,
                           @StdVector
                           IntBuffer histSize,
                           @StdVector
                           FloatBuffer ranges)

calcHist

@Namespace(value="cv")
public static void calcHist(@ByVal
                           opencv_core.MatVector images,
                           @StdVector
                           int[] channels,
                           @ByVal
                           opencv_core.Mat mask,
                           @ByVal
                           opencv_core.Mat hist,
                           @StdVector
                           int[] histSize,
                           @StdVector
                           float[] ranges,
                           @Cast(value="bool")
                           boolean accumulate)

calcHist

@Namespace(value="cv")
public static void calcHist(@ByVal
                           opencv_core.MatVector images,
                           @StdVector
                           int[] channels,
                           @ByVal
                           opencv_core.Mat mask,
                           @ByVal
                           opencv_core.Mat hist,
                           @StdVector
                           int[] histSize,
                           @StdVector
                           float[] ranges)

calcBackProject
```
@Namespace(value="cv")
public static void calcBackProject(@Const
                                  opencv_core.Mat images,
                                  int nimages,
                                  @Const
                                  IntPointer channels,
                                  @ByVal
                                  opencv_core.Mat hist,
                                  @ByVal
                                  opencv_core.Mat backProject,
                                  @Cast(value="const float**")
                                  PointerPointer ranges,
                                  double scale,
                                  @Cast(value="bool")
                                  boolean uniform)
```
\brief Calculates the back projection of a histogram.
The functions calcBackProject calculate the back project of the histogram. That is, similarly to cv::calcHist , at each location (x, y) the function collects the values from the selected channels in the input images and finds the corresponding histogram bin. But instead of incrementing it, the function reads the bin value, scales it by scale , and stores in backProject(x,y) . In terms of statistics, the function computes probability of each element value in respect with the empirical probability distribution represented by the histogram. See how, for example, you can find and track a bright-colored object in a scene:
- Before tracking, show the object to the camera so that it covers almost the whole frame. Calculate a hue histogram. The histogram may have strong maximums, corresponding to the dominant colors in the object.
- When tracking, calculate a back projection of a hue plane of each input video frame using that pre-computed histogram. Threshold the back projection to suppress weak colors. It may also make sense to suppress pixels with non-sufficient color saturation and too dark or too bright pixels.
- Find connected components in the resulting picture and choose, for example, the largest component.
This is an approximate algorithm of the CamShift color object tracker.

Parameters:
images - Source arrays. They all should have the same depth, CV_8U or CV_32F , and the same size. Each of them can have an arbitrary number of channels.
nimages - Number of source images.
channels - The list of channels used to compute the back projection. The number of channels must match the histogram dimensionality. The first array channels are numerated from 0 to images[0].channels()-1 , the second array channels are counted from images[0].channels() to images[0].channels() + images[1].channels()-1, and so on.
hist - Input histogram that can be dense or sparse.
backProject - Destination back projection array that is a single-channel array of the same size and depth as images[0] .
ranges - Array of arrays of the histogram bin boundaries in each dimension. See calcHist .
scale - Optional scale factor for the output back projection.
uniform - Flag indicating whether the histogram is uniform or not (see above).
\sa cv::calcHist, cv::compareHist

calcBackProject

@Namespace(value="cv")
public static void calcBackProject(@Const
                                  opencv_core.Mat images,
                                  int nimages,
                                  @Const
                                  IntPointer channels,
                                  @ByVal
                                  opencv_core.Mat hist,
                                  @ByVal
                                  opencv_core.Mat backProject,
                                  @Const@ByPtrPtr
                                  FloatPointer ranges)

calcBackProject

@Namespace(value="cv")
public static void calcBackProject(@Const
                                  opencv_core.Mat images,
                                  int nimages,
                                  @Const
                                  IntPointer channels,
                                  @ByVal
                                  opencv_core.Mat hist,
                                  @ByVal
                                  opencv_core.Mat backProject,
                                  @Const@ByPtrPtr
                                  FloatPointer ranges,
                                  double scale,
                                  @Cast(value="bool")
                                  boolean uniform)

calcBackProject

@Namespace(value="cv")
public static void calcBackProject(@Const
                                  opencv_core.Mat images,
                                  int nimages,
                                  @Const
                                  IntBuffer channels,
                                  @ByVal
                                  opencv_core.Mat hist,
                                  @ByVal
                                  opencv_core.Mat backProject,
                                  @Const@ByPtrPtr
                                  FloatBuffer ranges,
                                  double scale,
                                  @Cast(value="bool")
                                  boolean uniform)

calcBackProject

@Namespace(value="cv")
public static void calcBackProject(@Const
                                  opencv_core.Mat images,
                                  int nimages,
                                  @Const
                                  IntBuffer channels,
                                  @ByVal
                                  opencv_core.Mat hist,
                                  @ByVal
                                  opencv_core.Mat backProject,
                                  @Const@ByPtrPtr
                                  FloatBuffer ranges)

calcBackProject

@Namespace(value="cv")
public static void calcBackProject(@Const
                                  opencv_core.Mat images,
                                  int nimages,
                                  @Const
                                  int[] channels,
                                  @ByVal
                                  opencv_core.Mat hist,
                                  @ByVal
                                  opencv_core.Mat backProject,
                                  @Const@ByPtrPtr
                                  float[] ranges,
                                  double scale,
                                  @Cast(value="bool")
                                  boolean uniform)

calcBackProject

@Namespace(value="cv")
public static void calcBackProject(@Const
                                  opencv_core.Mat images,
                                  int nimages,
                                  @Const
                                  int[] channels,
                                  @ByVal
                                  opencv_core.Mat hist,
                                  @ByVal
                                  opencv_core.Mat backProject,
                                  @Const@ByPtrPtr
                                  float[] ranges)

calcBackProject

@Namespace(value="cv")
public static void calcBackProject(@Const
                                  opencv_core.Mat images,
                                  int nimages,
                                  @Const
                                  IntPointer channels,
                                  @Const@ByRef
                                  opencv_core.SparseMat hist,
                                  @ByVal
                                  opencv_core.Mat backProject,
                                  @Cast(value="const float**")
                                  PointerPointer ranges,
                                  double scale,
                                  @Cast(value="bool")
                                  boolean uniform)

\overload

calcBackProject

@Namespace(value="cv")
public static void calcBackProject(@Const
                                  opencv_core.Mat images,
                                  int nimages,
                                  @Const
                                  IntPointer channels,
                                  @Const@ByRef
                                  opencv_core.SparseMat hist,
                                  @ByVal
                                  opencv_core.Mat backProject,
                                  @Const@ByPtrPtr
                                  FloatPointer ranges)

calcBackProject

@Namespace(value="cv")
public static void calcBackProject(@Const
                                  opencv_core.Mat images,
                                  int nimages,
                                  @Const
                                  IntPointer channels,
                                  @Const@ByRef
                                  opencv_core.SparseMat hist,
                                  @ByVal
                                  opencv_core.Mat backProject,
                                  @Const@ByPtrPtr
                                  FloatPointer ranges,
                                  double scale,
                                  @Cast(value="bool")
                                  boolean uniform)

calcBackProject

@Namespace(value="cv")
public static void calcBackProject(@Const
                                  opencv_core.Mat images,
                                  int nimages,
                                  @Const
                                  IntBuffer channels,
                                  @Const@ByRef
                                  opencv_core.SparseMat hist,
                                  @ByVal
                                  opencv_core.Mat backProject,
                                  @Const@ByPtrPtr
                                  FloatBuffer ranges,
                                  double scale,
                                  @Cast(value="bool")
                                  boolean uniform)

calcBackProject

@Namespace(value="cv")
public static void calcBackProject(@Const
                                  opencv_core.Mat images,
                                  int nimages,
                                  @Const
                                  IntBuffer channels,
                                  @Const@ByRef
                                  opencv_core.SparseMat hist,
                                  @ByVal
                                  opencv_core.Mat backProject,
                                  @Const@ByPtrPtr
                                  FloatBuffer ranges)

calcBackProject

@Namespace(value="cv")
public static void calcBackProject(@Const
                                  opencv_core.Mat images,
                                  int nimages,
                                  @Const
                                  int[] channels,
                                  @Const@ByRef
                                  opencv_core.SparseMat hist,
                                  @ByVal
                                  opencv_core.Mat backProject,
                                  @Const@ByPtrPtr
                                  float[] ranges,
                                  double scale,
                                  @Cast(value="bool")
                                  boolean uniform)

calcBackProject

@Namespace(value="cv")
public static void calcBackProject(@Const
                                  opencv_core.Mat images,
                                  int nimages,
                                  @Const
                                  int[] channels,
                                  @Const@ByRef
                                  opencv_core.SparseMat hist,
                                  @ByVal
                                  opencv_core.Mat backProject,
                                  @Const@ByPtrPtr
                                  float[] ranges)

calcBackProject

@Namespace(value="cv")
public static void calcBackProject(@ByVal
                                  opencv_core.MatVector images,
                                  @StdVector
                                  IntPointer channels,
                                  @ByVal
                                  opencv_core.Mat hist,
                                  @ByVal
                                  opencv_core.Mat dst,
                                  @StdVector
                                  FloatPointer ranges,
                                  double scale)

\overload

calcBackProject

@Namespace(value="cv")
public static void calcBackProject(@ByVal
                                  opencv_core.MatVector images,
                                  @StdVector
                                  IntBuffer channels,
                                  @ByVal
                                  opencv_core.Mat hist,
                                  @ByVal
                                  opencv_core.Mat dst,
                                  @StdVector
                                  FloatBuffer ranges,
                                  double scale)

calcBackProject

@Namespace(value="cv")
public static void calcBackProject(@ByVal
                                  opencv_core.MatVector images,
                                  @StdVector
                                  int[] channels,
                                  @ByVal
                                  opencv_core.Mat hist,
                                  @ByVal
                                  opencv_core.Mat dst,
                                  @StdVector
                                  float[] ranges,
                                  double scale)

compareHist
```
@Namespace(value="cv")
public static double compareHist(@ByVal
                                opencv_core.Mat H1,
                                @ByVal
                                opencv_core.Mat H2,
                                int method)
```
\brief Compares two histograms.
The function compare two dense or two sparse histograms using the specified method.
The function returns \f$d(H_1, H_2)\f$ .
While the function works well with 1-, 2-, 3-dimensional dense histograms, it may not be suitable for high-dimensional sparse histograms. In such histograms, because of aliasing and sampling problems, the coordinates of non-zero histogram bins can slightly shift. To compare such histograms or more general sparse configurations of weighted points, consider using the cv::EMD function.

Parameters:
H1 - First compared histogram.
H2 - Second compared histogram of the same size as H1 .
method - Comparison method, see cv::HistCompMethods

compareHist

@Namespace(value="cv")
public static double compareHist(@Const@ByRef
                                opencv_core.SparseMat H1,
                                @Const@ByRef
                                opencv_core.SparseMat H2,
                                int method)

\overload

equalizeHist
```
@Namespace(value="cv")
public static void equalizeHist(@ByVal
                               opencv_core.Mat src,
                               @ByVal
                               opencv_core.Mat dst)
```
\brief Equalizes the histogram of a grayscale image.
The function equalizes the histogram of the input image using the following algorithm:
- Calculate the histogram \f$H\f$ for src . - Normalize the histogram so that the sum of histogram bins is 255. - Compute the integral of the histogram: \f[H'_i = \sum _{0 \le j < i} H(j)\f] - Transform the image using \f$H'\f$ as a look-up table: \f$\texttt{dst}(x,y) = H'(\texttt{src}(x,y))\f$
The algorithm normalizes the brightness and increases the contrast of the image.

Parameters:
src - Source 8-bit single channel image.
dst - Destination image of the same size and type as src .

EMD
```
@Namespace(value="cv")
public static float EMD(@ByVal
                       opencv_core.Mat signature1,
                       @ByVal
                       opencv_core.Mat signature2,
                       int distType,
                       @ByVal(nullValue="cv::noArray()")
                       opencv_core.Mat cost,
                       FloatPointer lowerBound,
                       @ByVal(nullValue="cv::noArray()")
                       opencv_core.Mat flow)
```
\brief Computes the "minimal work" distance between two weighted point configurations.
The function computes the earth mover distance and/or a lower boundary of the distance between the two weighted point configurations. One of the applications described in \cite RubnerSept98, \cite Rubner2000 is multi-dimensional histogram comparison for image retrieval. EMD is a transportation problem that is solved using some modification of a simplex algorithm, thus the complexity is exponential in the worst case, though, on average it is much faster. In the case of a real metric the lower boundary can be calculated even faster (using linear-time algorithm) and it can be used to determine roughly whether the two signatures are far enough so that they cannot relate to the same object.

Parameters:
signature1 - First signature, a \f$\texttt{size1}\times \texttt{dims}+1\f$ floating-point matrix. Each row stores the point weight followed by the point coordinates. The matrix is allowed to have a single column (weights only) if the user-defined cost matrix is used.
signature2 - Second signature of the same format as signature1 , though the number of rows may be different. The total weights may be different. In this case an extra "dummy" point is added to either signature1 or signature2 .
distType - Used metric. See cv::DistanceTypes.
cost - User-defined \f$\texttt{size1}\times \texttt{size2}\f$ cost matrix. Also, if a cost matrix is used, lower boundary lowerBound cannot be calculated because it needs a metric function.
lowerBound - Optional input/output parameter: lower boundary of a distance between the two signatures that is a distance between mass centers. The lower boundary may not be calculated if the user-defined cost matrix is used, the total weights of point configurations are not equal, or if the signatures consist of weights only (the signature matrices have a single column). You must** initialize \*lowerBound . If the calculated distance between mass centers is greater or equal to \*lowerBound (it means that the signatures are far enough), the function does not calculate EMD. In any case \*lowerBound is set to the calculated distance between mass centers on return. Thus, if you want to calculate both distance between mass centers and EMD, \*lowerBound should be set to 0.
flow - Resultant \f$\texttt{size1} \times \texttt{size2}\f$ flow matrix: \f$\texttt{flow}_{i,j}\f$ is a flow from \f$i\f$ -th point of signature1 to \f$j\f$ -th point of signature2 .

EMD

@Namespace(value="cv")
public static float EMD(@ByVal
                       opencv_core.Mat signature1,
                       @ByVal
                       opencv_core.Mat signature2,
                       int distType)

EMD

@Namespace(value="cv")
public static float EMD(@ByVal
                       opencv_core.Mat signature1,
                       @ByVal
                       opencv_core.Mat signature2,
                       int distType,
                       @ByVal(nullValue="cv::noArray()")
                       opencv_core.Mat cost,
                       FloatBuffer lowerBound,
                       @ByVal(nullValue="cv::noArray()")
                       opencv_core.Mat flow)

EMD

@Namespace(value="cv")
public static float EMD(@ByVal
                       opencv_core.Mat signature1,
                       @ByVal
                       opencv_core.Mat signature2,
                       int distType,
                       @ByVal(nullValue="cv::noArray()")
                       opencv_core.Mat cost,
                       float[] lowerBound,
                       @ByVal(nullValue="cv::noArray()")
                       opencv_core.Mat flow)

watershed
```
@Namespace(value="cv")
public static void watershed(@ByVal
                            opencv_core.Mat image,
                            @ByVal
                            opencv_core.Mat markers)
```
\brief Performs a marker-based image segmentation using the watershed algorithm.
The function implements one of the variants of watershed, non-parametric marker-based segmentation algorithm, described in \cite Meyer92 .
Before passing the image to the function, you have to roughly outline the desired regions in the image markers with positive (\>0) indices. So, every region is represented as one or more connected components with the pixel values 1, 2, 3, and so on. Such markers can be retrieved from a binary mask using findContours and drawContours (see the watershed.cpp demo). The markers are "seeds" of the future image regions. All the other pixels in markers , whose relation to the outlined regions is not known and should be defined by the algorithm, should be set to 0's. In the function output, each pixel in markers is set to a value of the "seed" components or to -1 at boundaries between the regions.
\note Any two neighbor connected components are not necessarily separated by a watershed boundary (-1's pixels); for example, they can touch each other in the initial marker image passed to the function.

Parameters:
image - Input 8-bit 3-channel image.
markers - Input/output 32-bit single-channel image (map) of markers. It should have the same size as image .
\sa findContours
\ingroup imgproc_misc

pyrMeanShiftFiltering
```
@Namespace(value="cv")
public static void pyrMeanShiftFiltering(@ByVal
                                        opencv_core.Mat src,
                                        @ByVal
                                        opencv_core.Mat dst,
                                        double sp,
                                        double sr,
                                        int maxLevel,
                                        @ByVal(nullValue="cv::TermCriteria(cv::TermCriteria::MAX_ITER+cv::TermCriteria::EPS,5,1)")
                                        opencv_core.TermCriteria termcrit)
```
\addtogroup imgproc_filter \{
/** \brief Performs initial step of meanshift segmentation of an image.
The function implements the filtering stage of meanshift segmentation, that is, the output of the function is the filtered "posterized" image with color gradients and fine-grain texture flattened. At every pixel (X,Y) of the input image (or down-sized input image, see below) the function executes meanshift iterations, that is, the pixel (X,Y) neighborhood in the joint space-color hyperspace is considered:
\f[(x,y): X- \texttt{sp} \le x \le X+ \texttt{sp} , Y- \texttt{sp} \le y \le Y+ \texttt{sp} , ||(R,G,B)-(r,g,b)|| \le \texttt{sr}\f]
where (R,G,B) and (r,g,b) are the vectors of color components at (X,Y) and (x,y), respectively (though, the algorithm does not depend on the color space used, so any 3-component color space can be used instead). Over the neighborhood the average spatial value (X',Y') and average color vector (R',G',B') are found and they act as the neighborhood center on the next iteration:
\f[(X,Y)~(X',Y'), (R,G,B)~(R',G',B').\f]
After the iterations over, the color components of the initial pixel (that is, the pixel from where the iterations started) are set to the final value (average color at the last iteration):
\f[I(X,Y) <- (R*,G*,B*)\f]
When maxLevel \> 0, the gaussian pyramid of maxLevel+1 levels is built, and the above procedure is run on the smallest layer first. After that, the results are propagated to the larger layer and the iterations are run again only on those pixels where the layer colors differ by more than sr from the lower-resolution layer of the pyramid. That makes boundaries of color regions sharper. Note that the results will be actually different from the ones obtained by running the meanshift procedure on the whole original image (i.e. when maxLevel==0).

Parameters:
src - The source 8-bit, 3-channel image.
dst - The destination image of the same format and the same size as the source.
sp - The spatial window radius.
sr - The color window radius.
maxLevel - Maximum level of the pyramid for the segmentation.
termcrit - Termination criteria: when to stop meanshift iterations.

pyrMeanShiftFiltering

@Namespace(value="cv")
public static void pyrMeanShiftFiltering(@ByVal
                                        opencv_core.Mat src,
                                        @ByVal
                                        opencv_core.Mat dst,
                                        double sp,
                                        double sr)

grabCut
```
@Namespace(value="cv")
public static void grabCut(@ByVal
                          opencv_core.Mat img,
                          @ByVal
                          opencv_core.Mat mask,
                          @ByVal
                          opencv_core.Rect rect,
                          @ByVal
                          opencv_core.Mat bgdModel,
                          @ByVal
                          opencv_core.Mat fgdModel,
                          int iterCount,
                          int mode)
```
\brief Runs the GrabCut algorithm.
The function implements the [GrabCut image segmentation algorithm](http://en.wikipedia.org/wiki/GrabCut).

Parameters:
img - Input 8-bit 3-channel image.
mask - Input/output 8-bit single-channel mask. The mask is initialized by the function when mode is set to GC_INIT_WITH_RECT. Its elements may have one of the cv::GrabCutClasses.
rect - ROI containing a segmented object. The pixels outside of the ROI are marked as "obvious background". The parameter is only used when mode==GC_INIT_WITH_RECT .
bgdModel - Temporary array for the background model. Do not modify it while you are processing the same image.
fgdModel - Temporary arrays for the foreground model. Do not modify it while you are processing the same image.
iterCount - Number of iterations the algorithm should make before returning the result. Note that the result can be refined with further calls with mode==GC_INIT_WITH_MASK or mode==GC_EVAL .
mode - Operation mode that could be one of the cv::GrabCutModes

grabCut

@Namespace(value="cv")
public static void grabCut(@ByVal
                          opencv_core.Mat img,
                          @ByVal
                          opencv_core.Mat mask,
                          @ByVal
                          opencv_core.Rect rect,
                          @ByVal
                          opencv_core.Mat bgdModel,
                          @ByVal
                          opencv_core.Mat fgdModel,
                          int iterCount)

distanceTransformWithLabels
```
@Namespace(value="cv")
@Name(value="distanceTransform")
public static void distanceTransformWithLabels(@ByVal
                                                        opencv_core.Mat src,
                                                        @ByVal
                                                        opencv_core.Mat dst,
                                                        @ByVal
                                                        opencv_core.Mat labels,
                                                        int distanceType,
                                                        int maskSize,
                                                        int labelType)
```
\brief Calculates the distance to the closest zero pixel for each pixel of the source image.
The functions distanceTransform calculate the approximate or precise distance from every binary image pixel to the nearest zero pixel. For zero image pixels, the distance will obviously be zero.
When maskSize == DIST_MASK_PRECISE and distanceType == DIST_L2 , the function runs the algorithm described in \cite Felzenszwalb04 . This algorithm is parallelized with the TBB library.
In other cases, the algorithm \cite Borgefors86 is used. This means that for a pixel the function finds the shortest path to the nearest zero pixel consisting of basic shifts: horizontal, vertical, diagonal, or knight's move (the latest is available for a \f$5\times 5\f$ mask). The overall distance is calculated as a sum of these basic distances. Since the distance function should be symmetric, all of the horizontal and vertical shifts must have the same cost (denoted as a ), all the diagonal shifts must have the same cost (denoted as b), and all knight's moves must have the same cost (denoted as c). For the cv::DIST_C and cv::DIST_L1 types, the distance is calculated precisely, whereas for cv::DIST_L2 (Euclidean distance) the distance can be calculated only with a relative error (a \f$5\times 5\f$ mask gives more accurate results). For a,b, and c, OpenCV uses the values suggested in the original paper: - DIST_L1: a = 1, b = 2 - DIST_L2: - 3 x 3: a=0.955, b=1.3693 - 5 x 5: a=1, b=1.4, c=2.1969 - DIST_C: a = 1, b = 1
Typically, for a fast, coarse distance estimation DIST_L2, a \f$3\times 3\f$ mask is used. For a more accurate distance estimation DIST_L2, a \f$5\times 5\f$ mask or the precise algorithm is used. Note that both the precise and the approximate algorithms are linear on the number of pixels.
This variant of the function does not only compute the minimum distance for each pixel \f$(x, y)\f$ but also identifies the nearest connected component consisting of zero pixels (labelType==DIST_LABEL_CCOMP) or the nearest zero pixel (labelType==DIST_LABEL_PIXEL). Index of the component/pixel is stored in labels(x, y). When labelType==DIST_LABEL_CCOMP, the function automatically finds connected components of zero pixels in the input image and marks them with distinct labels. When labelType==DIST_LABEL_CCOMP, the function scans through the input image and marks all the zero pixels with distinct labels.
In this mode, the complexity is still linear. That is, the function provides a very fast way to compute the Voronoi diagram for a binary image. Currently, the second variant can use only the approximate distance transform algorithm, i.e. maskSize=DIST_MASK_PRECISE is not supported yet.

Parameters:
src - 8-bit, single-channel (binary) source image.
dst - Output image with calculated distances. It is a 8-bit or 32-bit floating-point, single-channel image of the same size as src.
labels - Output 2D array of labels (the discrete Voronoi diagram). It has the type CV_32SC1 and the same size as src.
distanceType - Type of distance, see cv::DistanceTypes
maskSize - Size of the distance transform mask, see cv::DistanceTransformMasks. DIST_MASK_PRECISE is not supported by this variant. In case of the DIST_L1 or DIST_C distance type, the parameter is forced to 3 because a \f$3\times 3\f$ mask gives the same result as \f$5\times 5\f$ or any larger aperture.
labelType - Type of the label array to build, see cv::DistanceTransformLabelTypes.

distanceTransformWithLabels

@Namespace(value="cv")
@Name(value="distanceTransform")
public static void distanceTransformWithLabels(@ByVal
                                                        opencv_core.Mat src,
                                                        @ByVal
                                                        opencv_core.Mat dst,
                                                        @ByVal
                                                        opencv_core.Mat labels,
                                                        int distanceType,
                                                        int maskSize)

distanceTransform
```
@Namespace(value="cv")
public static void distanceTransform(@ByVal
                                    opencv_core.Mat src,
                                    @ByVal
                                    opencv_core.Mat dst,
                                    int distanceType,
                                    int maskSize,
                                    int dstType)
```
\overload

Parameters:
src - 8-bit, single-channel (binary) source image.
dst - Output image with calculated distances. It is a 8-bit or 32-bit floating-point, single-channel image of the same size as src .
distanceType - Type of distance, see cv::DistanceTypes
maskSize - Size of the distance transform mask, see cv::DistanceTransformMasks. In case of the DIST_L1 or DIST_C distance type, the parameter is forced to 3 because a \f$3\times 3\f$ mask gives the same result as \f$5\times 5\f$ or any larger aperture.
dstType - Type of output image. It can be CV_8U or CV_32F. Type CV_8U can be used only for the first variant of the function and distanceType == DIST_L1.

distanceTransform

@Namespace(value="cv")
public static void distanceTransform(@ByVal
                                    opencv_core.Mat src,
                                    @ByVal
                                    opencv_core.Mat dst,
                                    int distanceType,
                                    int maskSize)

floodFill

@Namespace(value="cv")
public static int floodFill(@ByVal
                           opencv_core.Mat image,
                           @ByVal
                           opencv_core.Point seedPoint,
                           @ByVal
                           opencv_core.Scalar newVal,
                           opencv_core.Rect rect,
                           @ByVal(nullValue="cv::Scalar()")
                           opencv_core.Scalar loDiff,
                           @ByVal(nullValue="cv::Scalar()")
                           opencv_core.Scalar upDiff,
                           int flags)

\overload

variant without mask parameter

floodFill

@Namespace(value="cv")
public static int floodFill(@ByVal
                           opencv_core.Mat image,
                           @ByVal
                           opencv_core.Point seedPoint,
                           @ByVal
                           opencv_core.Scalar newVal)

floodFill
```
@Namespace(value="cv")
public static int floodFill(@ByVal
                           opencv_core.Mat image,
                           @ByVal
                           opencv_core.Mat mask,
                           @ByVal
                           opencv_core.Point seedPoint,
                           @ByVal
                           opencv_core.Scalar newVal,
                           opencv_core.Rect rect,
                           @ByVal(nullValue="cv::Scalar()")
                           opencv_core.Scalar loDiff,
                           @ByVal(nullValue="cv::Scalar()")
                           opencv_core.Scalar upDiff,
                           int flags)
```
\brief Fills a connected component with the given color.
The functions floodFill fill a connected component starting from the seed point with the specified color. The connectivity is determined by the color/brightness closeness of the neighbor pixels. The pixel at \f$(x,y)\f$ is considered to belong to the repainted domain if:
- in case of a grayscale image and floating range \f[\texttt{src} (x',y')- \texttt{loDiff} \leq \texttt{src} (x,y) \leq \texttt{src} (x',y')+ \texttt{upDiff}\f]

- in case of a grayscale image and fixed range \f[\texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)- \texttt{loDiff} \leq \texttt{src} (x,y) \leq \texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)+ \texttt{upDiff}\f]

- in case of a color image and floating range \f[\texttt{src} (x',y')_r- \texttt{loDiff} _r \leq \texttt{src} (x,y)_r \leq \texttt{src} (x',y')_r+ \texttt{upDiff} _r,\f] \f[\texttt{src} (x',y')_g- \texttt{loDiff} _g \leq \texttt{src} (x,y)_g \leq \texttt{src} (x',y')_g+ \texttt{upDiff} _g\f] and \f[\texttt{src} (x',y')_b- \texttt{loDiff} _b \leq \texttt{src} (x,y)_b \leq \texttt{src} (x',y')_b+ \texttt{upDiff} _b\f]

- in case of a color image and fixed range \f[\texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)_r- \texttt{loDiff} _r \leq \texttt{src} (x,y)_r \leq \texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)_r+ \texttt{upDiff} _r,\f] \f[\texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)_g- \texttt{loDiff} _g \leq \texttt{src} (x,y)_g \leq \texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)_g+ \texttt{upDiff} _g\f] and \f[\texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)_b- \texttt{loDiff} _b \leq \texttt{src} (x,y)_b \leq \texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)_b+ \texttt{upDiff} _b\f]

where \f$src(x',y')\f$ is the value of one of pixel neighbors that is already known to belong to the component. That is, to be added to the connected component, a color/brightness of the pixel should be close enough to: - Color/brightness of one of its neighbors that already belong to the connected component in case of a floating range. - Color/brightness of the seed point in case of a fixed range.
Use these functions to either mark a connected component with the specified color in-place, or build a mask and then extract the contour, or copy the region to another image, and so on.

Parameters:
image - Input/output 1- or 3-channel, 8-bit, or floating-point image. It is modified by the function unless the FLOODFILL_MASK_ONLY flag is set in the second variant of the function. See the details below.
mask - Operation mask that should be a single-channel 8-bit image, 2 pixels wider and 2 pixels taller than image. Since this is both an input and output parameter, you must take responsibility of initializing it. Flood-filling cannot go across non-zero pixels in the input mask. For example, an edge detector output can be used as a mask to stop filling at edges. On output, pixels in the mask corresponding to filled pixels in the image are set to 1 or to the a value specified in flags as described below. It is therefore possible to use the same mask in multiple calls to the function to make sure the filled areas do not overlap.
seedPoint - Starting point.
newVal - New value of the repainted domain pixels.
loDiff - Maximal lower brightness/color difference between the currently observed pixel and one of its neighbors belonging to the component, or a seed pixel being added to the component.
upDiff - Maximal upper brightness/color difference between the currently observed pixel and one of its neighbors belonging to the component, or a seed pixel being added to the component.
rect - Optional output parameter set by the function to the minimum bounding rectangle of the repainted domain.
flags - Operation flags. The first 8 bits contain a connectivity value. The default value of 4 means that only the four nearest neighbor pixels (those that share an edge) are considered. A connectivity value of 8 means that the eight nearest neighbor pixels (those that share a corner) will be considered. The next 8 bits (8-16) contain a value between 1 and 255 with which to fill the mask (the default value is 1). For example, 4 | ( 255 \<\< 8 ) will consider 4 nearest neighbours and fill the mask with a value of 255. The following additional options occupy higher bits and therefore may be further combined with the connectivity and mask fill values using bit-wise or (|), see cv::FloodFillFlags.
\note Since the mask is larger than the filled image, a pixel \f$(x, y)\f$ in image corresponds to the pixel \f$(x+1, y+1)\f$ in the mask .
\sa findContours

floodFill

@Namespace(value="cv")
public static int floodFill(@ByVal
                           opencv_core.Mat image,
                           @ByVal
                           opencv_core.Mat mask,
                           @ByVal
                           opencv_core.Point seedPoint,
                           @ByVal
                           opencv_core.Scalar newVal)

cvtColor
```
@Namespace(value="cv")
public static void cvtColor(@ByVal
                           opencv_core.Mat src,
                           @ByVal
                           opencv_core.Mat dst,
                           int code,
                           int dstCn)
```
\brief Converts an image from one color space to another.
The function converts an input image from one color space to another. In case of a transformation to-from RGB color space, the order of the channels should be specified explicitly (RGB or BGR). Note that the default color format in OpenCV is often referred to as RGB but it is actually BGR (the bytes are reversed). So the first byte in a standard (24-bit) color image will be an 8-bit Blue component, the second byte will be Green, and the third byte will be Red. The fourth, fifth, and sixth bytes would then be the second pixel (Blue, then Green, then Red), and so on.
The conventional ranges for R, G, and B channel values are: - 0 to 255 for CV_8U images - 0 to 65535 for CV_16U images - 0 to 1 for CV_32F images
In case of linear transformations, the range does not matter. But in case of a non-linear transformation, an input RGB image should be normalized to the proper value range to get the correct results, for example, for RGB \f$\rightarrow\f$ L\*u\*v\* transformation. For example, if you have a 32-bit floating-point image directly converted from an 8-bit image without any scaling, then it will have the 0..255 value range instead of 0..1 assumed by the function. So, before calling cvtColor , you need first to scale the image down:
```
img *= 1./255;
    cvtColor(img, img, COLOR_BGR2Luv);
```
If you use cvtColor with 8-bit images, the conversion will have some information lost. For many applications, this will not be noticeable but it is recommended to use 32-bit images in applications that need the full range of colors or that convert an image before an operation and then convert back.
If conversion adds the alpha channel, its value will set to the maximum of corresponding channel range: 255 for CV_8U, 65535 for CV_16U, 1 for CV_32F.
Parameters:
src - input image: 8-bit unsigned, 16-bit unsigned ( CV_16UC... ), or single-precision floating-point.
dst - output image of the same size and depth as src.
code - color space conversion code (see cv::ColorConversionCodes).
dstCn - number of channels in the destination image; if the parameter is 0, the number of the channels is derived automatically from src and code.
See Also:
imgproc_color_conversions

cvtColor

@Namespace(value="cv")
public static void cvtColor(@ByVal
                           opencv_core.Mat src,
                           @ByVal
                           opencv_core.Mat dst,
                           int code)

demosaicing

@Namespace(value="cv")
public static void demosaicing(@ByVal
                              opencv_core.Mat _src,
                              @ByVal
                              opencv_core.Mat _dst,
                              int code,
                              int dcn)

\} imgproc_misc

demosaicing

@Namespace(value="cv")
public static void demosaicing(@ByVal
                              opencv_core.Mat _src,
                              @ByVal
                              opencv_core.Mat _dst,
                              int code)

moments
```
@Namespace(value="cv")
@ByVal
public static opencv_core.Moments moments(@ByVal
                                               opencv_core.Mat array,
                                               @Cast(value="bool")
                                               boolean binaryImage)
```
\addtogroup imgproc_shape \{
/** \brief Calculates all of the moments up to the third order of a polygon or rasterized shape.
The function computes moments, up to the 3rd order, of a vector shape or a rasterized shape. The results are returned in the structure cv::Moments.

Parameters:
array - Raster image (single-channel, 8-bit or floating-point 2D array) or an array ( \f$1 \times N\f$ or \f$N \times 1\f$ ) of 2D points (Point or Point2f ).
binaryImage - If it is true, all non-zero image pixels are treated as 1's. The parameter is used for images only.

Returns:
moments.
\sa contourArea, arcLength

moments

@Namespace(value="cv")
@ByVal
public static opencv_core.Moments moments(@ByVal
                                               opencv_core.Mat array)

HuMoments
```
@Namespace(value="cv")
public static void HuMoments(@Const@ByRef
                            opencv_core.Moments moments,
                            DoublePointer hu)
```
\brief Calculates seven Hu invariants.
The function calculates seven Hu invariants (introduced in \cite Hu62; see also ) defined as:
\f[\begin{array}{l} hu[0]= \eta _{20}+ \eta _{02} \\ hu[1]=( \eta _{20}- \eta _{02})^{2}+4 \eta _{11}^{2} \\ hu[2]=( \eta _{30}-3 \eta _{12})^{2}+ (3 \eta _{21}- \eta _{03})^{2} \\ hu[3]=( \eta _{30}+ \eta _{12})^{2}+ ( \eta _{21}+ \eta _{03})^{2} \\ hu[4]=( \eta _{30}-3 \eta _{12})( \eta _{30}+ \eta _{12})[( \eta _{30}+ \eta _{12})^{2}-3( \eta _{21}+ \eta _{03})^{2}]+(3 \eta _{21}- \eta _{03})( \eta _{21}+ \eta _{03})[3( \eta _{30}+ \eta _{12})^{2}-( \eta _{21}+ \eta _{03})^{2}] \\ hu[5]=( \eta _{20}- \eta _{02})[( \eta _{30}+ \eta _{12})^{2}- ( \eta _{21}+ \eta _{03})^{2}]+4 \eta _{11}( \eta _{30}+ \eta _{12})( \eta _{21}+ \eta _{03}) \\ hu[6]=(3 \eta _{21}- \eta _{03})( \eta _{21}+ \eta _{03})[3( \eta _{30}+ \eta _{12})^{2}-( \eta _{21}+ \eta _{03})^{2}]-( \eta _{30}-3 \eta _{12})( \eta _{21}+ \eta _{03})[3( \eta _{30}+ \eta _{12})^{2}-( \eta _{21}+ \eta _{03})^{2}] \\ \end{array}\f]
where \f$\eta_{ji}\f$ stands for \f$\texttt{Moments::nu}_{ji}\f$ .
These values are proved to be invariants to the image scale, rotation, and reflection except the seventh one, whose sign is changed by reflection. This invariance is proved with the assumption of infinite image resolution. In case of raster images, the computed Hu invariants for the original and transformed images are a bit different.

Parameters:
moments - Input moments computed with moments .
hu - Output Hu invariants.
\sa matchShapes

HuMoments

@Namespace(value="cv")
public static void HuMoments(@Const@ByRef
                            opencv_core.Moments moments,
                            DoubleBuffer hu)

HuMoments

@Namespace(value="cv")
public static void HuMoments(@Const@ByRef
                            opencv_core.Moments moments,
                            double[] hu)

HuMoments

@Namespace(value="cv")
public static void HuMoments(@Const@ByRef
                            opencv_core.Moments m,
                            @ByVal
                            opencv_core.Mat hu)

\overload

matchTemplate
```
@Namespace(value="cv")
public static void matchTemplate(@ByVal
                                opencv_core.Mat image,
                                @ByVal
                                opencv_core.Mat templ,
                                @ByVal
                                opencv_core.Mat result,
                                int method,
                                @ByVal(nullValue="cv::noArray()")
                                opencv_core.Mat mask)
```
\brief Compares a template against overlapped image regions.
The function slides through image , compares the overlapped patches of size \f$w \times h\f$ against templ using the specified method and stores the comparison results in result . Here are the formulae for the available comparison methods ( \f$I\f$ denotes image, \f$T\f$ template, \f$R\f$ result ). The summation is done over template and/or the image patch: \f$x' = 0...w-1, y' = 0...h-1\f$
After the function finishes the comparison, the best matches can be found as global minimums (when TM_SQDIFF was used) or maximums (when TM_CCORR or TM_CCOEFF was used) using the minMaxLoc function. In case of a color image, template summation in the numerator and each sum in the denominator is done over all of the channels and separate mean values are used for each channel. That is, the function can take a color template and a color image. The result will still be a single-channel image, which is easier to analyze.

Parameters:
image - Image where the search is running. It must be 8-bit or 32-bit floating-point.
templ - Searched template. It must be not greater than the source image and have the same data type.
result - Map of comparison results. It must be single-channel 32-bit floating-point. If image is \f$W \times H\f$ and templ is \f$w \times h\f$ , then result is \f$(W-w+1) \times (H-h+1)\f$ .
method - Parameter specifying the comparison method, see cv::TemplateMatchModes
mask - Mask of searched template. It must have the same datatype and size with templ. It is not set by default.

matchTemplate

@Namespace(value="cv")
public static void matchTemplate(@ByVal
                                opencv_core.Mat image,
                                @ByVal
                                opencv_core.Mat templ,
                                @ByVal
                                opencv_core.Mat result,
                                int method)

connectedComponents
```
@Namespace(value="cv")
public static int connectedComponents(@ByVal
                                     opencv_core.Mat image,
                                     @ByVal
                                     opencv_core.Mat labels,
                                     int connectivity,
                                     int ltype)
```
\}
\addtogroup imgproc_shape \{
/** \brief 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.

Parameters:
image - the 8-bit single-channel image to be labeled
labels - destination labeled image
connectivity - 8 or 4 for 8-way or 4-way connectivity respectively
ltype - output image label type. Currently CV_32S and CV_16U are supported.

connectedComponents

@Namespace(value="cv")
public static int connectedComponents(@ByVal
                                     opencv_core.Mat image,
                                     @ByVal
                                     opencv_core.Mat labels)

connectedComponentsWithStats

@Namespace(value="cv")
public static int connectedComponentsWithStats(@ByVal
                                              opencv_core.Mat image,
                                              @ByVal
                                              opencv_core.Mat labels,
                                              @ByVal
                                              opencv_core.Mat stats,
                                              @ByVal
                                              opencv_core.Mat centroids,
                                              int connectivity,
                                              int ltype)

\overload

Parameters:: image - the 8-bit single-channel image to be labeled; labels - destination labeled image; stats - statistics output for each label, including the background label, see below for available statistics. Statistics are accessed via stats(label, COLUMN) where COLUMN is one of cv::ConnectedComponentsTypes. The data type is CV_32S.; centroids - centroid output for each label, including the background label. Centroids are accessed via centroids(label, 0) for x and centroids(label, 1) for y. The data type CV_64F.; connectivity - 8 or 4 for 8-way or 4-way connectivity respectively; ltype - output image label type. Currently CV_32S and CV_16U are supported.

connectedComponentsWithStats

@Namespace(value="cv")
public static int connectedComponentsWithStats(@ByVal
                                              opencv_core.Mat image,
                                              @ByVal
                                              opencv_core.Mat labels,
                                              @ByVal
                                              opencv_core.Mat stats,
                                              @ByVal
                                              opencv_core.Mat centroids)

findContours
```
@Namespace(value="cv")
public static void findContours(@ByVal
                               opencv_core.Mat image,
                               @ByVal
                               opencv_core.MatVector contours,
                               @ByVal
                               opencv_core.Mat hierarchy,
                               int mode,
                               int method,
                               @ByVal(nullValue="cv::Point()")
                               opencv_core.Point offset)
```
\brief Finds contours in a binary image.
The function retrieves contours from the binary image using the algorithm \cite Suzuki85 . The contours are a useful tool for shape analysis and object detection and recognition. See squares.c in the OpenCV sample directory.
\note Source image is modified by this function. Also, the function does not take into account 1-pixel border of the image (it's filled with 0's and used for neighbor analysis in the algorithm), therefore the contours touching the image border will be clipped.

Parameters:
image - Source, an 8-bit single-channel image. Non-zero pixels are treated as 1's. Zero pixels remain 0's, so the image is treated as binary . You can use compare , inRange , threshold , adaptiveThreshold , Canny , and others to create a binary image out of a grayscale or color one. The function modifies the image while extracting the contours. If mode equals to RETR_CCOMP or RETR_FLOODFILL, the input can also be a 32-bit integer image of labels (CV_32SC1).
contours - Detected contours. Each contour is stored as a vector of points.
hierarchy - Optional output vector, containing information about the image topology. It has as many elements as the number of contours. For each i-th contour contours[i] , the elements hierarchy[i][0] , hiearchy[i][1] , hiearchy[i][2] , and hiearchy[i][3] are set to 0-based indices in contours of the next and previous contours at the same hierarchical level, the first child contour and the parent contour, respectively. If for the contour i there are no next, previous, parent, or nested contours, the corresponding elements of hierarchy[i] will be negative.
mode - Contour retrieval mode, see cv::RetrievalModes
method - Contour approximation method, see cv::ContourApproximationModes
offset - Optional offset by which every contour point is shifted. This is useful if the contours are extracted from the image ROI and then they should be analyzed in the whole image context.

findContours

@Namespace(value="cv")
public static void findContours(@ByVal
                               opencv_core.Mat image,
                               @ByVal
                               opencv_core.MatVector contours,
                               @ByVal
                               opencv_core.Mat hierarchy,
                               int mode,
                               int method)

findContours

@Namespace(value="cv")
public static void findContours(@ByVal
                               opencv_core.Mat image,
                               @ByVal
                               opencv_core.MatVector contours,
                               int mode,
                               int method,
                               @ByVal(nullValue="cv::Point()")
                               opencv_core.Point offset)

\overload

findContours

@Namespace(value="cv")
public static void findContours(@ByVal
                               opencv_core.Mat image,
                               @ByVal
                               opencv_core.MatVector contours,
                               int mode,
                               int method)

approxPolyDP
```
@Namespace(value="cv")
public static void approxPolyDP(@ByVal
                               opencv_core.Mat curve,
                               @ByVal
                               opencv_core.Mat approxCurve,
                               double epsilon,
                               @Cast(value="bool")
                               boolean closed)
```
\brief Approximates a polygonal curve(s) with the specified precision.
The functions approxPolyDP approximate a curve or a polygon with another curve/polygon with less vertices so that the distance between them is less or equal to the specified precision. It uses the Douglas-Peucker algorithm

Parameters:
curve - Input vector of a 2D point stored in std::vector or Mat
approxCurve - Result of the approximation. The type should match the type of the input curve.
epsilon - Parameter specifying the approximation accuracy. This is the maximum distance between the original curve and its approximation.
closed - If true, the approximated curve is closed (its first and last vertices are connected). Otherwise, it is not closed.

arcLength

@Namespace(value="cv")
public static double arcLength(@ByVal
                              opencv_core.Mat curve,
                              @Cast(value="bool")
                              boolean closed)

\brief Calculates a contour perimeter or a curve length.

The function computes a curve length or a closed contour perimeter.

Parameters:: curve - Input vector of 2D points, stored in std::vector or Mat.; closed - Flag indicating whether the curve is closed or not.

boundingRect
```
@Namespace(value="cv")
@ByVal
public static opencv_core.Rect boundingRect(@ByVal
                                                 opencv_core.Mat points)
```
\brief Calculates the up-right bounding rectangle of a point set.
The function calculates and returns the minimal up-right bounding rectangle for the specified point set.

Parameters:
points - Input 2D point set, stored in std::vector or Mat.

contourArea
```
@Namespace(value="cv")
public static double contourArea(@ByVal
                                opencv_core.Mat contour,
                                @Cast(value="bool")
                                boolean oriented)
```
\brief Calculates a contour area.
The function computes a contour area. Similarly to moments , the area is computed using the Green formula. Thus, the returned area and the number of non-zero pixels, if you draw the contour using drawContours or fillPoly , can be different. Also, the function will most certainly give a wrong results for contours with self-intersections.
Example:
```
vector<Point> contour;
    contour.push_back(Point2f(0, 0));
    contour.push_back(Point2f(10, 0));
    contour.push_back(Point2f(10, 10));
    contour.push_back(Point2f(5, 4));

    double area0 = contourArea(contour);
    vector<Point> approx;
    approxPolyDP(contour, approx, 5, true);
    double area1 = contourArea(approx);

    cout << "area0 =" << area0 << endl <<
            "area1 =" << area1 << endl <<
            "approx poly vertices" << approx.size() << endl;
```
Parameters:
contour - Input vector of 2D points (contour vertices), stored in std::vector or Mat.
oriented - Oriented area flag. If it is true, the function returns a signed area value, depending on the contour orientation (clockwise or counter-clockwise). Using this feature you can determine orientation of a contour by taking the sign of an area. By default, the parameter is false, which means that the absolute value is returned.

contourArea

@Namespace(value="cv")
public static double contourArea(@ByVal
                                opencv_core.Mat contour)

minAreaRect
```
@Namespace(value="cv")
@ByVal
public static opencv_core.RotatedRect minAreaRect(@ByVal
                                                       opencv_core.Mat points)
```
\brief Finds a rotated rectangle of the minimum area enclosing the input 2D point set.
The function calculates and returns the minimum-area bounding rectangle (possibly rotated) for a specified point set. See the OpenCV sample minarea.cpp . Developer should keep in mind that the returned rotatedRect can contain negative indices when data is close to the containing Mat element boundary.

Parameters:
points - Input vector of 2D points, stored in std::vector\<\> or Mat

boxPoints
```
@Namespace(value="cv")
public static void boxPoints(@ByVal
                            opencv_core.RotatedRect box,
                            @ByVal
                            opencv_core.Mat points)
```
\brief Finds the four vertices of a rotated rect. Useful to draw the rotated rectangle.
The function finds the four vertices of a rotated rectangle. This function is useful to draw the rectangle. In C++, instead of using this function, you can directly use box.points() method. Please visit the [tutorial on bounding rectangle](http://docs.opencv.org/doc/tutorials/imgproc/shapedescriptors/bounding_rects_circles/bounding_rects_circles.html#bounding-rects-circles) for more information.

Parameters:
box - The input rotated rectangle. It may be the output of
points - The output array of four vertices of rectangles.

minEnclosingCircle

@Namespace(value="cv")
public static void minEnclosingCircle(@ByVal
                                     opencv_core.Mat points,
                                     @ByRef
                                     opencv_core.Point2f center,
                                     @ByRef
                                     FloatPointer radius)

\brief Finds a circle of the minimum area enclosing a 2D point set.

The function finds the minimal enclosing circle of a 2D point set using an iterative algorithm. See the OpenCV sample minarea.cpp .

Parameters:: points - Input vector of 2D points, stored in std::vector\<\> or Mat; center - Output center of the circle.; radius - Output radius of the circle.

minEnclosingCircle

@Namespace(value="cv")
public static void minEnclosingCircle(@ByVal
                                     opencv_core.Mat points,
                                     @ByRef
                                     opencv_core.Point2f center,
                                     @ByRef
                                     FloatBuffer radius)

minEnclosingCircle

@Namespace(value="cv")
public static void minEnclosingCircle(@ByVal
                                     opencv_core.Mat points,
                                     @ByRef
                                     opencv_core.Point2f center,
                                     @ByRef
                                     float[] radius)

minEnclosingTriangle
```
@Namespace(value="cv")
public static double minEnclosingTriangle(@ByVal
                                         opencv_core.Mat points,
                                         @ByVal
                                         opencv_core.Mat triangle)
```
\brief Finds a triangle of minimum area enclosing a 2D point set and returns its area.
The function finds a triangle of minimum area enclosing the given set of 2D points and returns its area. The output for a given 2D point set is shown in the image below. 2D points are depicted in red* and the enclosing triangle in *yellow*.
![Sample output of the minimum enclosing triangle function](pics/minenclosingtriangle.png)
The implementation of the algorithm is based on O'Rourke's \cite ORourke86 and Klee and Laskowski's \cite KleeLaskowski85 papers. O'Rourke provides a \f$\theta(n)\f$ algorithm for finding the minimal enclosing triangle of a 2D convex polygon with n vertices. Since the minEnclosingTriangle function takes a 2D point set as input an additional preprocessing step of computing the convex hull of the 2D point set is required. The complexity of the convexHull function is \f$O(n log(n))\f$ which is higher than \f$\theta(n)\f$. Thus the overall complexity of the function is \f$O(n log(n))\f$.

Parameters:
points - Input vector of 2D points with depth CV_32S or CV_32F, stored in std::vector\<\> or Mat
triangle - Output vector of three 2D points defining the vertices of the triangle. The depth of the OutputArray must be CV_32F.

matchShapes

@Namespace(value="cv")
public static double matchShapes(@ByVal
                                opencv_core.Mat contour1,
                                @ByVal
                                opencv_core.Mat contour2,
                                int method,
                                double parameter)

\brief Compares two shapes.

The function compares two shapes. All three implemented methods use the Hu invariants (see cv::HuMoments)

Parameters:: contour1 - First contour or grayscale image.; contour2 - Second contour or grayscale image.; method - Comparison method, see ::ShapeMatchModes; parameter - Method-specific parameter (not supported now).

convexHull
```
@Namespace(value="cv")
public static void convexHull(@ByVal
                             opencv_core.Mat points,
                             @ByVal
                             opencv_core.Mat hull,
                             @Cast(value="bool")
                             boolean clockwise,
                             @Cast(value="bool")
                             boolean returnPoints)
```
\brief Finds the convex hull of a point set.
The functions find the convex hull of a 2D point set using the Sklansky's algorithm \cite Sklansky82 that has *O(N logN)* complexity in the current implementation. See the OpenCV sample convexhull.cpp that demonstrates the usage of different function variants.

Parameters:
points - Input 2D point set, stored in std::vector or Mat.
hull - Output convex hull. It is either an integer vector of indices or vector of points. In the first case, the hull elements are 0-based indices of the convex hull points in the original array (since the set of convex hull points is a subset of the original point set). In the second case, hull elements are the convex hull points themselves.
clockwise - Orientation flag. If it is true, the output convex hull is oriented clockwise. Otherwise, it is oriented counter-clockwise. The assumed coordinate system has its X axis pointing to the right, and its Y axis pointing upwards.
returnPoints - Operation flag. In case of a matrix, when the flag is true, the function returns convex hull points. Otherwise, it returns indices of the convex hull points. When the output array is std::vector, the flag is ignored, and the output depends on the type of the vector: std::vector\ implies returnPoints=true, std::vector\ implies returnPoints=false.

convexHull

@Namespace(value="cv")
public static void convexHull(@ByVal
                             opencv_core.Mat points,
                             @ByVal
                             opencv_core.Mat hull)

convexityDefects
```
@Namespace(value="cv")
public static void convexityDefects(@ByVal
                                   opencv_core.Mat contour,
                                   @ByVal
                                   opencv_core.Mat convexhull,
                                   @ByVal
                                   opencv_core.Mat convexityDefects)
```
\brief Finds the convexity defects of a contour.
The figure below displays convexity defects of a hand contour:
![image](pics/defects.png)

Parameters:
contour - Input contour.
convexhull - Convex hull obtained using convexHull that should contain indices of the contour points that make the hull.
convexityDefects - The output vector of convexity defects. In C++ and the new Python/Java interface each convexity defect is represented as 4-element integer vector (a.k.a. cv::Vec4i): (start_index, end_index, farthest_pt_index, fixpt_depth), where indices are 0-based indices in the original contour of the convexity defect beginning, end and the farthest point, and fixpt_depth is fixed-point approximation (with 8 fractional bits) of the distance between the farthest contour point and the hull. That is, to get the floating-point value of the depth will be fixpt_depth/256.0.

isContourConvex
```
@Namespace(value="cv")
@Cast(value="bool")
public static boolean isContourConvex(@ByVal
                                               opencv_core.Mat contour)
```
\brief Tests a contour convexity.
The function tests whether the input contour is convex or not. The contour must be simple, that is, without self-intersections. Otherwise, the function output is undefined.

Parameters:
contour - Input vector of 2D points, stored in std::vector\<\> or Mat

intersectConvexConvex

@Namespace(value="cv")
public static float intersectConvexConvex(@ByVal
                                         opencv_core.Mat _p1,
                                         @ByVal
                                         opencv_core.Mat _p2,
                                         @ByVal
                                         opencv_core.Mat _p12,
                                         @Cast(value="bool")
                                         boolean handleNested)

finds intersection of two convex polygons

intersectConvexConvex

@Namespace(value="cv")
public static float intersectConvexConvex(@ByVal
                                         opencv_core.Mat _p1,
                                         @ByVal
                                         opencv_core.Mat _p2,
                                         @ByVal
                                         opencv_core.Mat _p12)

fitEllipse
```
@Namespace(value="cv")
@ByVal
public static opencv_core.RotatedRect fitEllipse(@ByVal
                                                      opencv_core.Mat points)
```
\brief Fits an ellipse around a set of 2D points.
The function calculates the ellipse that fits (in a least-squares sense) a set of 2D points best of all. It returns the rotated rectangle in which the ellipse is inscribed. The first algorithm described by \cite Fitzgibbon95 is used. Developer should keep in mind that it is possible that the returned ellipse/rotatedRect data contains negative indices, due to the data points being close to the border of the containing Mat element.

Parameters:
points - Input 2D point set, stored in std::vector\<\> or Mat

fitLine
```
@Namespace(value="cv")
public static void fitLine(@ByVal
                          opencv_core.Mat points,
                          @ByVal
                          opencv_core.Mat line,
                          int distType,
                          double param,
                          double reps,
                          double aeps)
```
\brief Fits a line to a 2D or 3D point set.
The function fitLine fits a line to a 2D or 3D point set by minimizing \f$\sum_i \rho(r_i)\f$ where \f$r_i\f$ is a distance between the \f$i^{th}\f$ point, the line and \f$\rho(r)\f$ is a distance function, one of the following: - DIST_L2 \f[\rho (r) = r^2/2 \quad \text{(the simplest and the fastest least-squares method)}\f] - DIST_L1 \f[\rho (r) = r\f] - DIST_L12 \f[\rho (r) = 2 \cdot ( \sqrt{1 + \frac{r^2}{2}} - 1)\f] - DIST_FAIR \f[\rho \left (r \right ) = C^2 \cdot \left ( \frac{r}{C} - \log{\left(1 + \frac{r}{C}\right)} \right ) \quad \text{where} \quad C=1.3998\f] - DIST_WELSCH \f[\rho \left (r \right ) = \frac{C^2}{2} \cdot \left ( 1 - \exp{\left(-\left(\frac{r}{C}\right)^2\right)} \right ) \quad \text{where} \quad C=2.9846\f] - DIST_HUBER \f[\rho (r) = \fork{r^2/2}{if $r < C$}{C \cdot (r-C/2)}{otherwise} \quad \text{where} \quad C=1.345\f]
The algorithm is based on the M-estimator ( ) technique that iteratively fits the line using the weighted least-squares algorithm. After each iteration the weights \f$w_i\f$ are adjusted to be inversely proportional to \f$\rho(r_i)\f$ .

Parameters:
points - Input vector of 2D or 3D points, stored in std::vector\<\> or Mat.
line - Output line parameters. In case of 2D fitting, it should be a vector of 4 elements (like Vec4f) - (vx, vy, x0, y0), where (vx, vy) is a normalized vector collinear to the line and (x0, y0) is a point on the line. In case of 3D fitting, it should be a vector of 6 elements (like Vec6f) - (vx, vy, vz, x0, y0, z0), where (vx, vy, vz) is a normalized vector collinear to the line and (x0, y0, z0) is a point on the line.
distType - Distance used by the M-estimator, see cv::DistanceTypes
param - Numerical parameter ( C ) for some types of distances. If it is 0, an optimal value is chosen.
reps - Sufficient accuracy for the radius (distance between the coordinate origin and the line).
aeps - Sufficient accuracy for the angle. 0.01 would be a good default value for reps and aeps.

pointPolygonTest
```
@Namespace(value="cv")
public static double pointPolygonTest(@ByVal
                                     opencv_core.Mat contour,
                                     @ByVal
                                     opencv_core.Point2f pt,
                                     @Cast(value="bool")
                                     boolean measureDist)
```
\brief Performs a point-in-contour test.
The function determines whether the point is inside a contour, outside, or lies on an edge (or coincides with a vertex). It returns positive (inside), negative (outside), or zero (on an edge) value, correspondingly. When measureDist=false , the return value is +1, -1, and 0, respectively. Otherwise, the return value is a signed distance between the point and the nearest contour edge.
See below a sample output of the function where each image pixel is tested against the contour:
![sample output](pics/pointpolygon.png)

Parameters:
contour - Input contour.
pt - Point tested against the contour.
measureDist - If true, the function estimates the signed distance from the point to the nearest contour edge. Otherwise, the function only checks if the point is inside a contour or not.

rotatedRectangleIntersection

@Namespace(value="cv")
public static int rotatedRectangleIntersection(@Const@ByRef
                                              opencv_core.RotatedRect rect1,
                                              @Const@ByRef
                                              opencv_core.RotatedRect rect2,
                                              @ByVal
                                              opencv_core.Mat intersectingRegion)

\brief Finds out if there is any intersection between two rotated rectangles.

If there is then the vertices of the interesecting region are returned as well.

Below are some examples of intersection configurations. The hatched pattern indicates the intersecting region and the red vertices are returned by the function.

![intersection examples](pics/intersection.png)

Parameters:: rect1 - First rectangle; rect2 - Second rectangle; intersectingRegion - The output array of the verticies of the intersecting region. It returns at most 8 vertices. Stored as std::vector\ or cv::Mat as Mx1 of type CV_32FC2.
Returns:: One of cv::RectanglesIntersectTypes

createCLAHE

@Namespace(value="cv")
@opencv_core.Ptr
public static opencv_imgproc.CLAHE createCLAHE(double clipLimit,
                                                              @ByVal(nullValue="cv::Size(8, 8)")
                                                              opencv_core.Size tileGridSize)

\} imgproc_shape

createCLAHE

@Namespace(value="cv")
@opencv_core.Ptr
public static opencv_imgproc.CLAHE createCLAHE()

createGeneralizedHoughBallard
```
@Namespace(value="cv")
@opencv_core.Ptr
public static opencv_imgproc.GeneralizedHoughBallard createGeneralizedHoughBallard()
```
Ballard, D.H. (1981). Generalizing the Hough transform to detect arbitrary shapes. Pattern Recognition 13 (2): 111-122. Detects position only without traslation and rotation

createGeneralizedHoughGuil
```
@Namespace(value="cv")
@opencv_core.Ptr
public static opencv_imgproc.GeneralizedHoughGuil createGeneralizedHoughGuil()
```
Guil, N., GonzÃ¡lez-Linares, J.M. and Zapata, E.L. (1999). Bidimensional shape detection using an invariant approach. Pattern Recognition 32 (6): 1025-1038. Detects position, traslation and rotation

blendLinear

@Namespace(value="cv")
public static void blendLinear(@ByVal
                              opencv_core.Mat src1,
                              @ByVal
                              opencv_core.Mat src2,
                              @ByVal
                              opencv_core.Mat weights1,
                              @ByVal
                              opencv_core.Mat weights2,
                              @ByVal
                              opencv_core.Mat dst)

Performs linear blending of two images

applyColorMap

@Namespace(value="cv")
public static void applyColorMap(@ByVal
                                opencv_core.Mat src,
                                @ByVal
                                opencv_core.Mat dst,
                                int colormap)

\brief Applies a GNU Octave/MATLAB equivalent colormap on a given image.

Parameters:: src - The source image, grayscale or colored does not matter.; dst - The result is the colormapped source image. Note: Mat::create is called on dst.; colormap - The colormap to apply, see cv::ColormapTypes

line
```
@Namespace(value="cv")
public static void line(@ByVal
                       opencv_core.Mat img,
                       @ByVal
                       opencv_core.Point pt1,
                       @ByVal
                       opencv_core.Point pt2,
                       @Const@ByRef
                       opencv_core.Scalar color,
                       int thickness,
                       int lineType,
                       int shift)
```
\} imgproc_colormap
\addtogroup imgproc_draw \{
/** \brief Draws a line segment connecting two points.
The function line draws the line segment between pt1 and pt2 points in the image. The line is clipped by the image boundaries. For non-antialiased lines with integer coordinates, the 8-connected or 4-connected Bresenham algorithm is used. Thick lines are drawn with rounding endings. Antialiased lines are drawn using Gaussian filtering.

Parameters:
img - Image.
pt1 - First point of the line segment.
pt2 - Second point of the line segment.
color - Line color.
thickness - Line thickness.
lineType - Type of the line, see cv::LineTypes.
shift - Number of fractional bits in the point coordinates.

line

@Namespace(value="cv")
public static void line(@ByVal
                       opencv_core.Mat img,
                       @ByVal
                       opencv_core.Point pt1,
                       @ByVal
                       opencv_core.Point pt2,
                       @Const@ByRef
                       opencv_core.Scalar color)

arrowedLine

@Namespace(value="cv")
public static void arrowedLine(@ByVal
                              opencv_core.Mat img,
                              @ByVal
                              opencv_core.Point pt1,
                              @ByVal
                              opencv_core.Point pt2,
                              @Const@ByRef
                              opencv_core.Scalar color,
                              int thickness,
                              int line_type,
                              int shift,
                              double tipLength)

\brief Draws a arrow segment pointing from the first point to the second one.

The function arrowedLine draws an arrow between pt1 and pt2 points in the image. See also cv::line.

Parameters:: img - Image.; pt1 - The point the arrow starts from.; pt2 - The point the arrow points to.; color - Line color.; thickness - Line thickness.; line_type - Type of the line, see cv::LineTypes; shift - Number of fractional bits in the point coordinates.; tipLength - The length of the arrow tip in relation to the arrow length

arrowedLine

@Namespace(value="cv")
public static void arrowedLine(@ByVal
                              opencv_core.Mat img,
                              @ByVal
                              opencv_core.Point pt1,
                              @ByVal
                              opencv_core.Point pt2,
                              @Const@ByRef
                              opencv_core.Scalar color)

rectangle

@Namespace(value="cv")
public static void rectangle(@ByVal
                            opencv_core.Mat img,
                            @ByVal
                            opencv_core.Point pt1,
                            @ByVal
                            opencv_core.Point pt2,
                            @Const@ByRef
                            opencv_core.Scalar color,
                            int thickness,
                            int lineType,
                            int shift)

\brief Draws a simple, thick, or filled up-right rectangle.

The function rectangle draws a rectangle outline or a filled rectangle whose two opposite corners are pt1 and pt2.

Parameters:: img - Image.; pt1 - Vertex of the rectangle.; pt2 - Vertex of the rectangle opposite to pt1 .; color - Rectangle color or brightness (grayscale image).; thickness - Thickness of lines that make up the rectangle. Negative values, like CV_FILLED , mean that the function has to draw a filled rectangle.; lineType - Type of the line. See the line description.; shift - Number of fractional bits in the point coordinates.

rectangle

@Namespace(value="cv")
public static void rectangle(@ByVal
                            opencv_core.Mat img,
                            @ByVal
                            opencv_core.Point pt1,
                            @ByVal
                            opencv_core.Point pt2,
                            @Const@ByRef
                            opencv_core.Scalar color)

rectangle

@Namespace(value="cv")
public static void rectangle(@ByRef
                            opencv_core.Mat img,
                            @ByVal
                            opencv_core.Rect rec,
                            @Const@ByRef
                            opencv_core.Scalar color,
                            int thickness,
                            int lineType,
                            int shift)

\overload

use rec parameter as alternative specification of the drawn rectangle: r.tl() and r.br()-Point(1,1) are opposite corners

rectangle

@Namespace(value="cv")
public static void rectangle(@ByRef
                            opencv_core.Mat img,
                            @ByVal
                            opencv_core.Rect rec,
                            @Const@ByRef
                            opencv_core.Scalar color)

circle

@Namespace(value="cv")
public static void circle(@ByVal
                         opencv_core.Mat img,
                         @ByVal
                         opencv_core.Point center,
                         int radius,
                         @Const@ByRef
                         opencv_core.Scalar color,
                         int thickness,
                         int lineType,
                         int shift)

\brief Draws a circle.

The function circle draws a simple or filled circle with a given center and radius.

Parameters:: img - Image where the circle is drawn.; center - Center of the circle.; radius - Radius of the circle.; color - Circle color.; thickness - Thickness of the circle outline, if positive. Negative thickness means that a filled circle is to be drawn.; lineType - Type of the circle boundary. See the line description.; shift - Number of fractional bits in the coordinates of the center and in the radius value.

circle

@Namespace(value="cv")
public static void circle(@ByVal
                         opencv_core.Mat img,
                         @ByVal
                         opencv_core.Point center,
                         int radius,
                         @Const@ByRef
                         opencv_core.Scalar color)

ellipse
```
@Namespace(value="cv")
public static void ellipse(@ByVal
                          opencv_core.Mat img,
                          @ByVal
                          opencv_core.Point center,
                          @ByVal
                          opencv_core.Size axes,
                          double angle,
                          double startAngle,
                          double endAngle,
                          @Const@ByRef
                          opencv_core.Scalar color,
                          int thickness,
                          int lineType,
                          int shift)
```
\brief Draws a simple or thick elliptic arc or fills an ellipse sector.
The functions ellipse with less parameters draw an ellipse outline, a filled ellipse, an elliptic arc, or a filled ellipse sector. A piecewise-linear curve is used to approximate the elliptic arc boundary. If you need more control of the ellipse rendering, you can retrieve the curve using ellipse2Poly and then render it with polylines or fill it with fillPoly . If you use the first variant of the function and want to draw the whole ellipse, not an arc, pass startAngle=0 and endAngle=360 . The figure below explains the meaning of the parameters.
![Parameters of Elliptic Arc](pics/ellipse.png)

Parameters:
img - Image.
center - Center of the ellipse.
axes - Half of the size of the ellipse main axes.
angle - Ellipse rotation angle in degrees.
startAngle - Starting angle of the elliptic arc in degrees.
endAngle - Ending angle of the elliptic arc in degrees.
color - Ellipse color.
thickness - Thickness of the ellipse arc outline, if positive. Otherwise, this indicates that a filled ellipse sector is to be drawn.
lineType - Type of the ellipse boundary. See the line description.
shift - Number of fractional bits in the coordinates of the center and values of axes.

ellipse

@Namespace(value="cv")
public static void ellipse(@ByVal
                          opencv_core.Mat img,
                          @ByVal
                          opencv_core.Point center,
                          @ByVal
                          opencv_core.Size axes,
                          double angle,
                          double startAngle,
                          double endAngle,
                          @Const@ByRef
                          opencv_core.Scalar color)

ellipse

@Namespace(value="cv")
public static void ellipse(@ByVal
                          opencv_core.Mat img,
                          @Const@ByRef
                          opencv_core.RotatedRect box,
                          @Const@ByRef
                          opencv_core.Scalar color,
                          int thickness,
                          int lineType)

\overload

Parameters:: img - Image.; box - Alternative ellipse representation via RotatedRect. This means that the function draws an ellipse inscribed in the rotated rectangle.; color - Ellipse color.; thickness - Thickness of the ellipse arc outline, if positive. Otherwise, this indicates that a filled ellipse sector is to be drawn.; lineType - Type of the ellipse boundary. See the line description.

ellipse

@Namespace(value="cv")
public static void ellipse(@ByVal
                          opencv_core.Mat img,
                          @Const@ByRef
                          opencv_core.RotatedRect box,
                          @Const@ByRef
                          opencv_core.Scalar color)

drawMarker

@Namespace(value="cv")
public static void drawMarker(@ByRef
                             opencv_core.Mat img,
                             @ByVal
                             opencv_core.Point position,
                             @Const@ByRef
                             opencv_core.Scalar color,
                             int markerType,
                             int markerSize,
                             int thickness,
                             int line_type)

\brief Draws a marker on a predefined position in an image.

The function drawMarker draws a marker on a given position in the image. For the moment several marker types are supported, see cv::MarkerTypes for more information.

Parameters:: img - Image.; position - The point where the crosshair is positioned.; markerType - The specific type of marker you want to use, see cv::MarkerTypes; color - Line color.; thickness - Line thickness.; line_type - Type of the line, see cv::LineTypes; markerSize - The length of the marker axis [default = 20 pixels]

drawMarker

@Namespace(value="cv")
public static void drawMarker(@ByRef
                             opencv_core.Mat img,
                             @ByVal
                             opencv_core.Point position,
                             @Const@ByRef
                             opencv_core.Scalar color)

fillConvexPoly

@Namespace(value="cv")
public static void fillConvexPoly(@ByRef
                                 opencv_core.Mat img,
                                 @Const
                                 opencv_core.Point pts,
                                 int npts,
                                 @Const@ByRef
                                 opencv_core.Scalar color,
                                 int lineType,
                                 int shift)

\overload

fillConvexPoly

@Namespace(value="cv")
public static void fillConvexPoly(@ByRef
                                 opencv_core.Mat img,
                                 @Const
                                 opencv_core.Point pts,
                                 int npts,
                                 @Const@ByRef
                                 opencv_core.Scalar color)

fillConvexPoly
```
@Namespace(value="cv")
public static void fillConvexPoly(@ByVal
                                 opencv_core.Mat img,
                                 @ByVal
                                 opencv_core.Mat points,
                                 @Const@ByRef
                                 opencv_core.Scalar color,
                                 int lineType,
                                 int shift)
```
\brief Fills a convex polygon.
The function fillConvexPoly draws a filled convex polygon. This function is much faster than the function cv::fillPoly . It can fill not only convex polygons but any monotonic polygon without self-intersections, that is, a polygon whose contour intersects every horizontal line (scan line) twice at the most (though, its top-most and/or the bottom edge could be horizontal).

Parameters:
img - Image.
points - Polygon vertices.
color - Polygon color.
lineType - Type of the polygon boundaries. See the line description.
shift - Number of fractional bits in the vertex coordinates.

fillConvexPoly

@Namespace(value="cv")
public static void fillConvexPoly(@ByVal
                                 opencv_core.Mat img,
                                 @ByVal
                                 opencv_core.Mat points,
                                 @Const@ByRef
                                 opencv_core.Scalar color)

fillPoly

@Namespace(value="cv")
public static void fillPoly(@ByRef
                           opencv_core.Mat img,
                           @Cast(value="const cv::Point**")
                           PointerPointer pts,
                           @Const
                           IntPointer npts,
                           int ncontours,
                           @Const@ByRef
                           opencv_core.Scalar color,
                           int lineType,
                           int shift,
                           @ByVal(nullValue="cv::Point()")
                           opencv_core.Point offset)

\overload

fillPoly

@Namespace(value="cv")
public static void fillPoly(@ByRef
                           opencv_core.Mat img,
                           @Const@ByPtrPtr
                           opencv_core.Point pts,
                           @Const
                           IntPointer npts,
                           int ncontours,
                           @Const@ByRef
                           opencv_core.Scalar color)

fillPoly

@Namespace(value="cv")
public static void fillPoly(@ByRef
                           opencv_core.Mat img,
                           @Const@ByPtrPtr
                           opencv_core.Point pts,
                           @Const
                           IntPointer npts,
                           int ncontours,
                           @Const@ByRef
                           opencv_core.Scalar color,
                           int lineType,
                           int shift,
                           @ByVal(nullValue="cv::Point()")
                           opencv_core.Point offset)

fillPoly

@Namespace(value="cv")
public static void fillPoly(@ByRef
                           opencv_core.Mat img,
                           @Const@ByPtrPtr
                           opencv_core.Point pts,
                           @Const
                           IntBuffer npts,
                           int ncontours,
                           @Const@ByRef
                           opencv_core.Scalar color,
                           int lineType,
                           int shift,
                           @ByVal(nullValue="cv::Point()")
                           opencv_core.Point offset)

fillPoly

@Namespace(value="cv")
public static void fillPoly(@ByRef
                           opencv_core.Mat img,
                           @Const@ByPtrPtr
                           opencv_core.Point pts,
                           @Const
                           IntBuffer npts,
                           int ncontours,
                           @Const@ByRef
                           opencv_core.Scalar color)

fillPoly

@Namespace(value="cv")
public static void fillPoly(@ByRef
                           opencv_core.Mat img,
                           @Const@ByPtrPtr
                           opencv_core.Point pts,
                           @Const
                           int[] npts,
                           int ncontours,
                           @Const@ByRef
                           opencv_core.Scalar color,
                           int lineType,
                           int shift,
                           @ByVal(nullValue="cv::Point()")
                           opencv_core.Point offset)

fillPoly

@Namespace(value="cv")
public static void fillPoly(@ByRef
                           opencv_core.Mat img,
                           @Const@ByPtrPtr
                           opencv_core.Point pts,
                           @Const
                           int[] npts,
                           int ncontours,
                           @Const@ByRef
                           opencv_core.Scalar color)

fillPoly

@Namespace(value="cv")
public static void fillPoly(@ByVal
                           opencv_core.Mat img,
                           @ByVal
                           opencv_core.MatVector pts,
                           @Const@ByRef
                           opencv_core.Scalar color,
                           int lineType,
                           int shift,
                           @ByVal(nullValue="cv::Point()")
                           opencv_core.Point offset)

\brief Fills the area bounded by one or more polygons.

The function fillPoly fills an area bounded by several polygonal contours. The function can fill complex areas, for example, areas with holes, contours with self-intersections (some of their parts), and so forth.

Parameters:: img - Image.; pts - Array of polygons where each polygon is represented as an array of points.; color - Polygon color.; lineType - Type of the polygon boundaries. See the line description.; shift - Number of fractional bits in the vertex coordinates.; offset - Optional offset of all points of the contours.

fillPoly

@Namespace(value="cv")
public static void fillPoly(@ByVal
                           opencv_core.Mat img,
                           @ByVal
                           opencv_core.MatVector pts,
                           @Const@ByRef
                           opencv_core.Scalar color)

polylines

@Namespace(value="cv")
public static void polylines(@ByRef
                            opencv_core.Mat img,
                            @Cast(value="const cv::Point*const*")
                            PointerPointer pts,
                            @Const
                            IntPointer npts,
                            int ncontours,
                            @Cast(value="bool")
                            boolean isClosed,
                            @Const@ByRef
                            opencv_core.Scalar color,
                            int thickness,
                            int lineType,
                            int shift)

\overload

polylines

@Namespace(value="cv")
public static void polylines(@ByRef
                            opencv_core.Mat img,
                            @Const@ByPtrPtr
                            opencv_core.Point pts,
                            @Const
                            IntPointer npts,
                            int ncontours,
                            @Cast(value="bool")
                            boolean isClosed,
                            @Const@ByRef
                            opencv_core.Scalar color)

polylines

@Namespace(value="cv")
public static void polylines(@ByRef
                            opencv_core.Mat img,
                            @Const@ByPtrPtr
                            opencv_core.Point pts,
                            @Const
                            IntPointer npts,
                            int ncontours,
                            @Cast(value="bool")
                            boolean isClosed,
                            @Const@ByRef
                            opencv_core.Scalar color,
                            int thickness,
                            int lineType,
                            int shift)

polylines

@Namespace(value="cv")
public static void polylines(@ByRef
                            opencv_core.Mat img,
                            @Const@ByPtrPtr
                            opencv_core.Point pts,
                            @Const
                            IntBuffer npts,
                            int ncontours,
                            @Cast(value="bool")
                            boolean isClosed,
                            @Const@ByRef
                            opencv_core.Scalar color,
                            int thickness,
                            int lineType,
                            int shift)

polylines

@Namespace(value="cv")
public static void polylines(@ByRef
                            opencv_core.Mat img,
                            @Const@ByPtrPtr
                            opencv_core.Point pts,
                            @Const
                            IntBuffer npts,
                            int ncontours,
                            @Cast(value="bool")
                            boolean isClosed,
                            @Const@ByRef
                            opencv_core.Scalar color)

polylines

@Namespace(value="cv")
public static void polylines(@ByRef
                            opencv_core.Mat img,
                            @Const@ByPtrPtr
                            opencv_core.Point pts,
                            @Const
                            int[] npts,
                            int ncontours,
                            @Cast(value="bool")
                            boolean isClosed,
                            @Const@ByRef
                            opencv_core.Scalar color,
                            int thickness,
                            int lineType,
                            int shift)

polylines

@Namespace(value="cv")
public static void polylines(@ByRef
                            opencv_core.Mat img,
                            @Const@ByPtrPtr
                            opencv_core.Point pts,
                            @Const
                            int[] npts,
                            int ncontours,
                            @Cast(value="bool")
                            boolean isClosed,
                            @Const@ByRef
                            opencv_core.Scalar color)

polylines

@Namespace(value="cv")
public static void polylines(@ByVal
                            opencv_core.Mat img,
                            @ByVal
                            opencv_core.MatVector pts,
                            @Cast(value="bool")
                            boolean isClosed,
                            @Const@ByRef
                            opencv_core.Scalar color,
                            int thickness,
                            int lineType,
                            int shift)

\brief Draws several polygonal curves.

Parameters:: img - Image.; pts - Array of polygonal curves.; isClosed - Flag indicating whether the drawn polylines are closed or not. If they are closed, the function draws a line from the last vertex of each curve to its first vertex.; color - Polyline color.; thickness - Thickness of the polyline edges.; lineType - Type of the line segments. See the line description.; shift - Number of fractional bits in the vertex coordinates.
The function polylines draws one or more polygonal curves.

polylines

@Namespace(value="cv")
public static void polylines(@ByVal
                            opencv_core.Mat img,
                            @ByVal
                            opencv_core.MatVector pts,
                            @Cast(value="bool")
                            boolean isClosed,
                            @Const@ByRef
                            opencv_core.Scalar color)

drawContours

@Namespace(value="cv")
public static void drawContours(@ByVal
                               opencv_core.Mat image,
                               @ByVal
                               opencv_core.MatVector contours,
                               int contourIdx,
                               @Const@ByRef
                               opencv_core.Scalar color,
                               int thickness,
                               int lineType,
                               @ByVal(nullValue="cv::noArray()")
                               opencv_core.Mat hierarchy,
                               int maxLevel,
                               @ByVal(nullValue="cv::Point()")
                               opencv_core.Point offset)

\brief Draws contours outlines or filled contours.

The function draws contour outlines in the image if \f$\texttt{thickness} \ge 0\f$ or fills the area bounded by the contours if \f$\texttt{thickness}<0\f$ . The example below shows how to retrieve connected components from the binary image and label them: :

#include "opencv2/imgproc.hpp"
    #include "opencv2/highgui.hpp"

    using namespace cv;
    using namespace std;

    int main( int argc, char** argv )
    {
        Mat src;
        // the first command-line parameter must be a filename of the binary
        // (black-n-white) image
        if( argc != 2 || !(src=imread(argv[1], 0)).data)
            return -1;

        Mat dst = Mat::zeros(src.rows, src.cols, CV_8UC3);

        src = src > 1;
        namedWindow( "Source", 1 );
        imshow( "Source", src );

        vector<vector<Point> > contours;
        vector<Vec4i> hierarchy;

        findContours( src, contours, hierarchy,
            RETR_CCOMP, CHAIN_APPROX_SIMPLE );

        // iterate through all the top-level contours,
        // draw each connected component with its own random color
        int idx = 0;
        for( ; idx >= 0; idx = hierarchy[idx][0] )
        {
            Scalar color( rand()&255, rand()&255, rand()&255 );
            drawContours( dst, contours, idx, color, FILLED, 8, hierarchy );
        }

        namedWindow( "Components", 1 );
        imshow( "Components", dst );
        waitKey(0);
    }

Parameters:: image - Destination image.; contours - All the input contours. Each contour is stored as a point vector.; contourIdx - Parameter indicating a contour to draw. If it is negative, all the contours are drawn.; color - Color of the contours.; thickness - Thickness of lines the contours are drawn with. If it is negative (for example, thickness=CV_FILLED ), the contour interiors are drawn.; lineType - Line connectivity. See cv::LineTypes.; hierarchy - Optional information about hierarchy. It is only needed if you want to draw only some of the contours (see maxLevel ).; maxLevel - Maximal level for drawn contours. If it is 0, only the specified contour is drawn. If it is 1, the function draws the contour(s) and all the nested contours. If it is 2, the function draws the contours, all the nested contours, all the nested-to-nested contours, and so on. This parameter is only taken into account when there is hierarchy available.; offset - Optional contour shift parameter. Shift all the drawn contours by the specified \f$\texttt{offset}=(dx,dy)\f$ .

drawContours

@Namespace(value="cv")
public static void drawContours(@ByVal
                               opencv_core.Mat image,
                               @ByVal
                               opencv_core.MatVector contours,
                               int contourIdx,
                               @Const@ByRef
                               opencv_core.Scalar color)

clipLine

@Namespace(value="cv")
@Cast(value="bool")
public static boolean clipLine(@ByVal
                                        opencv_core.Size imgSize,
                                        @ByRef
                                        opencv_core.Point pt1,
                                        @ByRef
                                        opencv_core.Point pt2)

\brief Clips the line against the image rectangle.

The functions clipLine calculate a part of the line segment that is entirely within the specified rectangle. They return false if the line segment is completely outside the rectangle. Otherwise, they return true .

Parameters:: imgSize - Image size. The image rectangle is Rect(0, 0, imgSize.width, imgSize.height) .; pt1 - First line point.; pt2 - Second line point.

clipLine

@Namespace(value="cv")
@Cast(value="bool")
public static boolean clipLine(@ByVal
                                        opencv_core.Rect imgRect,
                                        @ByRef
                                        opencv_core.Point pt1,
                                        @ByRef
                                        opencv_core.Point pt2)

\overload

Parameters:: imgRect - Image rectangle.; pt1 - First line point.; pt2 - Second line point.

ellipse2Poly

@Namespace(value="cv")
public static void ellipse2Poly(@ByVal
                               opencv_core.Point center,
                               @ByVal
                               opencv_core.Size axes,
                               int angle,
                               int arcStart,
                               int arcEnd,
                               int delta,
                               @ByRef
                               opencv_core.PointVector pts)

\brief Approximates an elliptic arc with a polyline.

The function ellipse2Poly computes the vertices of a polyline that approximates the specified elliptic arc. It is used by cv::ellipse.

Parameters:: center - Center of the arc.; axes - Half of the size of the ellipse main axes. See the ellipse for details.; angle - Rotation angle of the ellipse in degrees. See the ellipse for details.; arcStart - Starting angle of the elliptic arc in degrees.; arcEnd - Ending angle of the elliptic arc in degrees.; delta - Angle between the subsequent polyline vertices. It defines the approximation accuracy.; pts - Output vector of polyline vertices.

putText

@Namespace(value="cv")
public static void putText(@ByVal
                          opencv_core.Mat img,
                          @opencv_core.Str
                          BytePointer text,
                          @ByVal
                          opencv_core.Point org,
                          int fontFace,
                          double fontScale,
                          @ByVal
                          opencv_core.Scalar color,
                          int thickness,
                          int lineType,
                          @Cast(value="bool")
                          boolean bottomLeftOrigin)

\brief Draws a text string.

The function putText renders the specified text string in the image. Symbols that cannot be rendered using the specified font are replaced by question marks. See getTextSize for a text rendering code example.

Parameters:: img - Image.; text - Text string to be drawn.; org - Bottom-left corner of the text string in the image.; fontFace - Font type, see cv::HersheyFonts.; fontScale - Font scale factor that is multiplied by the font-specific base size.; color - Text color.; thickness - Thickness of the lines used to draw a text.; lineType - Line type. See the line for details.; bottomLeftOrigin - When true, the image data origin is at the bottom-left corner. Otherwise, it is at the top-left corner.

putText

@Namespace(value="cv")
public static void putText(@ByVal
                          opencv_core.Mat img,
                          @opencv_core.Str
                          BytePointer text,
                          @ByVal
                          opencv_core.Point org,
                          int fontFace,
                          double fontScale,
                          @ByVal
                          opencv_core.Scalar color)

putText

@Namespace(value="cv")
public static void putText(@ByVal
                          opencv_core.Mat img,
                          @opencv_core.Str
                          String text,
                          @ByVal
                          opencv_core.Point org,
                          int fontFace,
                          double fontScale,
                          @ByVal
                          opencv_core.Scalar color,
                          int thickness,
                          int lineType,
                          @Cast(value="bool")
                          boolean bottomLeftOrigin)

putText

@Namespace(value="cv")
public static void putText(@ByVal
                          opencv_core.Mat img,
                          @opencv_core.Str
                          String text,
                          @ByVal
                          opencv_core.Point org,
                          int fontFace,
                          double fontScale,
                          @ByVal
                          opencv_core.Scalar color)

getTextSize

@Namespace(value="cv")
@ByVal
public static opencv_core.Size getTextSize(@opencv_core.Str
                                                BytePointer text,
                                                int fontFace,
                                                double fontScale,
                                                int thickness,
                                                IntPointer baseLine)

\brief Calculates the width and height of a text string.

The function getTextSize calculates and returns the size of a box that contains the specified text. That is, the following code renders some text, the tight box surrounding it, and the baseline: :

String text = "Funny text inside the box";
    int fontFace = FONT_HERSHEY_SCRIPT_SIMPLEX;
    double fontScale = 2;
    int thickness = 3;

    Mat img(600, 800, CV_8UC3, Scalar::all(0));

    int baseline=0;
    Size textSize = getTextSize(text, fontFace,
                                fontScale, thickness, &baseline);
    baseline += thickness;

    // center the text
    Point textOrg((img.cols - textSize.width)/2,
                  (img.rows + textSize.height)/2);

    // draw the box
    rectangle(img, textOrg + Point(0, baseline),
              textOrg + Point(textSize.width, -textSize.height),
              Scalar(0,0,255));
    // ... and the baseline first
    line(img, textOrg + Point(0, thickness),
         textOrg + Point(textSize.width, thickness),
         Scalar(0, 0, 255));

    // then put the text itself
    putText(img, text, textOrg, fontFace, fontScale,
            Scalar::all(255), thickness, 8);

Parameters:: text - Input text string.; fontFace - Font to use, see cv::HersheyFonts.; fontScale - Font scale factor that is multiplied by the font-specific base size.; thickness - Thickness of lines used to render the text. See putText for details.; [out] - baseLine y-coordinate of the baseline relative to the bottom-most text point.
Returns:: The size of a box that contains the specified text.
See Also:: cv::putText

getTextSize

@Namespace(value="cv")
@ByVal
public static opencv_core.Size getTextSize(@opencv_core.Str
                                                String text,
                                                int fontFace,
                                                double fontScale,
                                                int thickness,
                                                IntBuffer baseLine)

getTextSize

@Namespace(value="cv")
@ByVal
public static opencv_core.Size getTextSize(@opencv_core.Str
                                                BytePointer text,
                                                int fontFace,
                                                double fontScale,
                                                int thickness,
                                                int[] baseLine)

getTextSize

@Namespace(value="cv")
@ByVal
public static opencv_core.Size getTextSize(@opencv_core.Str
                                                String text,
                                                int fontFace,
                                                double fontScale,
                                                int thickness,
                                                IntPointer baseLine)

getTextSize

@Namespace(value="cv")
@ByVal
public static opencv_core.Size getTextSize(@opencv_core.Str
                                                BytePointer text,
                                                int fontFace,
                                                double fontScale,
                                                int thickness,
                                                IntBuffer baseLine)

getTextSize

@Namespace(value="cv")
@ByVal
public static opencv_core.Size getTextSize(@opencv_core.Str
                                                String text,
                                                int fontFace,
                                                double fontScale,
                                                int thickness,
                                                int[] baseLine)

Class opencv_imgproc

Nested Class Summary

Nested classes/interfaces inherited from class org.bytedeco.javacpp.helper.opencv_imgproc

Field Summary

Constructor Summary

Method Summary

Methods inherited from class org.bytedeco.javacpp.helper.opencv_imgproc

Methods inherited from class org.bytedeco.javacpp.presets.opencv_imgproc

Methods inherited from class java.lang.Object

Field Detail

CV_BLUR_NO_SCALE

CV_BLUR

CV_GAUSSIAN

CV_MEDIAN

CV_BILATERAL

CV_GAUSSIAN_5x5

CV_SCHARR

CV_MAX_SOBEL_KSIZE

CV_BGR2BGRA

CV_RGB2RGBA

CV_BGRA2BGR

CV_RGBA2RGB

CV_BGR2RGBA

CV_RGB2BGRA

CV_RGBA2BGR

CV_BGRA2RGB

CV_BGR2RGB

CV_RGB2BGR

CV_BGRA2RGBA

CV_RGBA2BGRA

CV_BGR2GRAY

CV_RGB2GRAY

CV_GRAY2BGR

CV_GRAY2RGB

CV_GRAY2BGRA

CV_GRAY2RGBA

CV_BGRA2GRAY

CV_RGBA2GRAY

CV_BGR2BGR565

CV_RGB2BGR565

CV_BGR5652BGR

CV_BGR5652RGB

CV_BGRA2BGR565

CV_RGBA2BGR565

CV_BGR5652BGRA

CV_BGR5652RGBA

CV_GRAY2BGR565

CV_BGR5652GRAY

CV_BGR2BGR555

CV_RGB2BGR555

CV_BGR5552BGR

CV_BGR5552RGB

CV_BGRA2BGR555

CV_RGBA2BGR555

CV_BGR5552BGRA

CV_BGR5552RGBA

CV_GRAY2BGR555

CV_BGR5552GRAY

CV_BGR2XYZ

CV_RGB2XYZ

CV_XYZ2BGR

CV_XYZ2RGB

CV_BGR2YCrCb

CV_RGB2YCrCb

CV_YCrCb2BGR

CV_YCrCb2RGB

CV_BGR2HSV

CV_RGB2HSV

CV_BGR2Lab

CV_RGB2Lab

CV_BayerBG2BGR

CV_BayerGB2BGR

CV_BayerRG2BGR

CV_BayerGR2BGR

CV_BayerBG2RGB

CV_BayerGB2RGB

CV_BayerRG2RGB

CV_BayerGR2RGB

CV_BGR2Luv

CV_RGB2Luv