opencv_imgproc (JavaCPP Presets for OpenCV 2.4.9-0.8 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.BaseColumnFilter` The Base Class for Column-wise Filters This is the base class for linear or non-linear filters that process columns of 2D arrays.
`static class`	`opencv_imgproc.BaseFilter` The Base Class for Non-Separable 2D Filters.
`static class`	`opencv_imgproc.BaseRowFilter` The Base Class for 1D or Row-wise Filters This is the base class for linear or non-linear filters that process 1D data.
`static class`	`opencv_imgproc.CLAHE`
`static class`	`opencv_imgproc.CvChainPtReader`
`static class`	`opencv_imgproc.CvConnectedComp`
`static class`	`opencv_imgproc.CvContourScanner`
`static class`	`opencv_imgproc.CvConvexityDefect`
`static class`	`opencv_imgproc.CvDistanceFunction`
`static class`	`opencv_imgproc.CvFeatureTree`
`static class`	`opencv_imgproc.CvHuMoments`
`static class`	`opencv_imgproc.CvLSH`
`static class`	`opencv_imgproc.CvLSHOperations`
`static class`	`opencv_imgproc.CvMoments`
`static class`	`opencv_imgproc.CvQuadEdge2D`
`static class`	`opencv_imgproc.CvSubdiv2D`
`static class`	`opencv_imgproc.CvSubdiv2DPoint`
`static class`	`opencv_imgproc.FilterEngine` The Main Class for Image Filtering.
`static class`	`opencv_imgproc.GeneralizedHough` finds arbitrary template in the grayscale image using Generalized Hough Transform Ballard, D.H.
`static class`	`opencv_imgproc.Moments` raster image moments
`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::
`static int`	`ADAPTIVE_THRESH_MEAN_C` enum cv::
`static int`	`BORDER_CONSTANT` enum cv::
`static int`	`BORDER_DEFAULT` enum cv::
`static int`	`BORDER_ISOLATED` enum cv::
`static int`	`BORDER_REFLECT` enum cv::
`static int`	`BORDER_REFLECT_101` enum cv::
`static int`	`BORDER_REFLECT101` enum cv::
`static int`	`BORDER_REPLICATE` enum cv::
`static int`	`BORDER_TRANSPARENT` enum cv::
`static int`	`BORDER_WRAP` enum cv::
`static int`	`CHAIN_APPROX_NONE` enum cv::
`static int`	`CHAIN_APPROX_SIMPLE` enum cv::
`static int`	`CHAIN_APPROX_TC89_KCOS` enum cv::
`static int`	`CHAIN_APPROX_TC89_L1` enum cv::
`static int`	`COLOR_BayerBG2BGR` enum cv::
`static int`	`COLOR_BayerBG2BGR_VNG` enum cv::
`static int`	`COLOR_BayerBG2GRAY` enum cv::
`static int`	`COLOR_BayerBG2RGB` enum cv::
`static int`	`COLOR_BayerBG2RGB_VNG` enum cv::
`static int`	`COLOR_BayerGB2BGR` enum cv::
`static int`	`COLOR_BayerGB2BGR_VNG` enum cv::
`static int`	`COLOR_BayerGB2GRAY` enum cv::
`static int`	`COLOR_BayerGB2RGB` enum cv::
`static int`	`COLOR_BayerGB2RGB_VNG` enum cv::
`static int`	`COLOR_BayerGR2BGR` enum cv::
`static int`	`COLOR_BayerGR2BGR_VNG` enum cv::
`static int`	`COLOR_BayerGR2GRAY` enum cv::
`static int`	`COLOR_BayerGR2RGB` enum cv::
`static int`	`COLOR_BayerGR2RGB_VNG` enum cv::
`static int`	`COLOR_BayerRG2BGR` enum cv::
`static int`	`COLOR_BayerRG2BGR_VNG` enum cv::
`static int`	`COLOR_BayerRG2GRAY` enum cv::
`static int`	`COLOR_BayerRG2RGB` enum cv::
`static int`	`COLOR_BayerRG2RGB_VNG` enum cv::
`static int`	`COLOR_BGR2BGR555` enum cv::
`static int`	`COLOR_BGR2BGR565` enum cv::
`static int`	`COLOR_BGR2BGRA` enum cv::
`static int`	`COLOR_BGR2GRAY` enum cv::
`static int`	`COLOR_BGR2HLS` enum cv::
`static int`	`COLOR_BGR2HLS_FULL` enum cv::
`static int`	`COLOR_BGR2HSV` enum cv::
`static int`	`COLOR_BGR2HSV_FULL` enum cv::
`static int`	`COLOR_BGR2Lab` enum cv::
`static int`	`COLOR_BGR2Luv` enum cv::
`static int`	`COLOR_BGR2RGB` enum cv::
`static int`	`COLOR_BGR2RGBA` enum cv::
`static int`	`COLOR_BGR2XYZ` enum cv::
`static int`	`COLOR_BGR2YCrCb` enum cv::
`static int`	`COLOR_BGR2YUV` enum cv::
`static int`	`COLOR_BGR2YUV_I420` enum cv::
`static int`	`COLOR_BGR2YUV_IYUV` enum cv::
`static int`	`COLOR_BGR2YUV_YV12` enum cv::
`static int`	`COLOR_BGR5552BGR` enum cv::
`static int`	`COLOR_BGR5552BGRA` enum cv::
`static int`	`COLOR_BGR5552GRAY` enum cv::
`static int`	`COLOR_BGR5552RGB` enum cv::
`static int`	`COLOR_BGR5552RGBA` enum cv::
`static int`	`COLOR_BGR5652BGR` enum cv::
`static int`	`COLOR_BGR5652BGRA` enum cv::
`static int`	`COLOR_BGR5652GRAY` enum cv::
`static int`	`COLOR_BGR5652RGB` enum cv::
`static int`	`COLOR_BGR5652RGBA` enum cv::
`static int`	`COLOR_BGRA2BGR` enum cv::
`static int`	`COLOR_BGRA2BGR555` enum cv::
`static int`	`COLOR_BGRA2BGR565` enum cv::
`static int`	`COLOR_BGRA2GRAY` enum cv::
`static int`	`COLOR_BGRA2RGB` enum cv::
`static int`	`COLOR_BGRA2RGBA` enum cv::
`static int`	`COLOR_BGRA2YUV_I420` enum cv::
`static int`	`COLOR_BGRA2YUV_IYUV` enum cv::
`static int`	`COLOR_BGRA2YUV_YV12` enum cv::
`static int`	`COLOR_COLORCVT_MAX` enum cv::
`static int`	`COLOR_GRAY2BGR` enum cv::
`static int`	`COLOR_GRAY2BGR555` enum cv::
`static int`	`COLOR_GRAY2BGR565` enum cv::
`static int`	`COLOR_GRAY2BGRA` enum cv::
`static int`	`COLOR_GRAY2RGB` enum cv::
`static int`	`COLOR_GRAY2RGBA` enum cv::
`static int`	`COLOR_HLS2BGR` enum cv::
`static int`	`COLOR_HLS2BGR_FULL` enum cv::
`static int`	`COLOR_HLS2RGB` enum cv::
`static int`	`COLOR_HLS2RGB_FULL` enum cv::
`static int`	`COLOR_HSV2BGR` enum cv::
`static int`	`COLOR_HSV2BGR_FULL` enum cv::
`static int`	`COLOR_HSV2RGB` enum cv::
`static int`	`COLOR_HSV2RGB_FULL` enum cv::
`static int`	`COLOR_Lab2BGR` enum cv::
`static int`	`COLOR_Lab2LBGR` enum cv::
`static int`	`COLOR_Lab2LRGB` enum cv::
`static int`	`COLOR_Lab2RGB` enum cv::
`static int`	`COLOR_LBGR2Lab` enum cv::
`static int`	`COLOR_LBGR2Luv` enum cv::
`static int`	`COLOR_LRGB2Lab` enum cv::
`static int`	`COLOR_LRGB2Luv` enum cv::
`static int`	`COLOR_Luv2BGR` enum cv::
`static int`	`COLOR_Luv2LBGR` enum cv::
`static int`	`COLOR_Luv2LRGB` enum cv::
`static int`	`COLOR_Luv2RGB` enum cv::
`static int`	`COLOR_mRGBA2RGBA` enum cv::
`static int`	`COLOR_RGB2BGR` enum cv::
`static int`	`COLOR_RGB2BGR555` enum cv::
`static int`	`COLOR_RGB2BGR565` enum cv::
`static int`	`COLOR_RGB2BGRA` enum cv::
`static int`	`COLOR_RGB2GRAY` enum cv::
`static int`	`COLOR_RGB2HLS` enum cv::
`static int`	`COLOR_RGB2HLS_FULL` enum cv::
`static int`	`COLOR_RGB2HSV` enum cv::
`static int`	`COLOR_RGB2HSV_FULL` enum cv::
`static int`	`COLOR_RGB2Lab` enum cv::
`static int`	`COLOR_RGB2Luv` enum cv::
`static int`	`COLOR_RGB2RGBA` enum cv::
`static int`	`COLOR_RGB2XYZ` enum cv::
`static int`	`COLOR_RGB2YCrCb` enum cv::
`static int`	`COLOR_RGB2YUV` enum cv::
`static int`	`COLOR_RGB2YUV_I420` enum cv::
`static int`	`COLOR_RGB2YUV_IYUV` enum cv::
`static int`	`COLOR_RGB2YUV_YV12` enum cv::
`static int`	`COLOR_RGBA2BGR` enum cv::
`static int`	`COLOR_RGBA2BGR555` enum cv::
`static int`	`COLOR_RGBA2BGR565` enum cv::
`static int`	`COLOR_RGBA2BGRA` enum cv::
`static int`	`COLOR_RGBA2GRAY` enum cv::
`static int`	`COLOR_RGBA2mRGBA` enum cv::
`static int`	`COLOR_RGBA2RGB` enum cv::
`static int`	`COLOR_RGBA2YUV_I420` enum cv::
`static int`	`COLOR_RGBA2YUV_IYUV` enum cv::
`static int`	`COLOR_RGBA2YUV_YV12` enum cv::
`static int`	`COLOR_XYZ2BGR` enum cv::
`static int`	`COLOR_XYZ2RGB` enum cv::
`static int`	`COLOR_YCrCb2BGR` enum cv::
`static int`	`COLOR_YCrCb2RGB` enum cv::
`static int`	`COLOR_YUV2BGR` enum cv::
`static int`	`COLOR_YUV2BGR_I420` enum cv::
`static int`	`COLOR_YUV2BGR_IYUV` enum cv::
`static int`	`COLOR_YUV2BGR_NV12` enum cv::
`static int`	`COLOR_YUV2BGR_NV21` enum cv::
`static int`	`COLOR_YUV2BGR_UYNV` enum cv::
`static int`	`COLOR_YUV2BGR_UYVY` enum cv::
`static int`	`COLOR_YUV2BGR_Y422` enum cv::
`static int`	`COLOR_YUV2BGR_YUNV` enum cv::
`static int`	`COLOR_YUV2BGR_YUY2` enum cv::
`static int`	`COLOR_YUV2BGR_YUYV` enum cv::
`static int`	`COLOR_YUV2BGR_YV12` enum cv::
`static int`	`COLOR_YUV2BGR_YVYU` enum cv::
`static int`	`COLOR_YUV2BGRA_I420` enum cv::
`static int`	`COLOR_YUV2BGRA_IYUV` enum cv::
`static int`	`COLOR_YUV2BGRA_NV12` enum cv::
`static int`	`COLOR_YUV2BGRA_NV21` enum cv::
`static int`	`COLOR_YUV2BGRA_UYNV` enum cv::
`static int`	`COLOR_YUV2BGRA_UYVY` enum cv::
`static int`	`COLOR_YUV2BGRA_Y422` enum cv::
`static int`	`COLOR_YUV2BGRA_YUNV` enum cv::
`static int`	`COLOR_YUV2BGRA_YUY2` enum cv::
`static int`	`COLOR_YUV2BGRA_YUYV` enum cv::
`static int`	`COLOR_YUV2BGRA_YV12` enum cv::
`static int`	`COLOR_YUV2BGRA_YVYU` enum cv::
`static int`	`COLOR_YUV2GRAY_420` enum cv::
`static int`	`COLOR_YUV2GRAY_I420` enum cv::
`static int`	`COLOR_YUV2GRAY_IYUV` enum cv::
`static int`	`COLOR_YUV2GRAY_NV12` enum cv::
`static int`	`COLOR_YUV2GRAY_NV21` enum cv::
`static int`	`COLOR_YUV2GRAY_UYNV` enum cv::
`static int`	`COLOR_YUV2GRAY_UYVY` enum cv::
`static int`	`COLOR_YUV2GRAY_Y422` enum cv::
`static int`	`COLOR_YUV2GRAY_YUNV` enum cv::
`static int`	`COLOR_YUV2GRAY_YUY2` enum cv::
`static int`	`COLOR_YUV2GRAY_YUYV` enum cv::
`static int`	`COLOR_YUV2GRAY_YV12` enum cv::
`static int`	`COLOR_YUV2GRAY_YVYU` enum cv::
`static int`	`COLOR_YUV2RGB` enum cv::
`static int`	`COLOR_YUV2RGB_I420` enum cv::
`static int`	`COLOR_YUV2RGB_IYUV` enum cv::
`static int`	`COLOR_YUV2RGB_NV12` enum cv::
`static int`	`COLOR_YUV2RGB_NV21` enum cv::
`static int`	`COLOR_YUV2RGB_UYNV` enum cv::
`static int`	`COLOR_YUV2RGB_UYVY` enum cv::
`static int`	`COLOR_YUV2RGB_Y422` enum cv::
`static int`	`COLOR_YUV2RGB_YUNV` enum cv::
`static int`	`COLOR_YUV2RGB_YUY2` enum cv::
`static int`	`COLOR_YUV2RGB_YUYV` enum cv::
`static int`	`COLOR_YUV2RGB_YV12` enum cv::
`static int`	`COLOR_YUV2RGB_YVYU` enum cv::
`static int`	`COLOR_YUV2RGBA_I420` enum cv::
`static int`	`COLOR_YUV2RGBA_IYUV` enum cv::
`static int`	`COLOR_YUV2RGBA_NV12` enum cv::
`static int`	`COLOR_YUV2RGBA_NV21` enum cv::
`static int`	`COLOR_YUV2RGBA_UYNV` enum cv::
`static int`	`COLOR_YUV2RGBA_UYVY` enum cv::
`static int`	`COLOR_YUV2RGBA_Y422` enum cv::
`static int`	`COLOR_YUV2RGBA_YUNV` enum cv::
`static int`	`COLOR_YUV2RGBA_YUY2` enum cv::
`static int`	`COLOR_YUV2RGBA_YUYV` enum cv::
`static int`	`COLOR_YUV2RGBA_YV12` enum cv::
`static int`	`COLOR_YUV2RGBA_YVYU` enum cv::
`static int`	`COLOR_YUV420p2BGR` enum cv::
`static int`	`COLOR_YUV420p2BGRA` enum cv::
`static int`	`COLOR_YUV420p2GRAY` enum cv::
`static int`	`COLOR_YUV420p2RGB` enum cv::
`static int`	`COLOR_YUV420p2RGBA` enum cv::
`static int`	`COLOR_YUV420sp2BGR` enum cv::
`static int`	`COLOR_YUV420sp2BGRA` enum cv::
`static int`	`COLOR_YUV420sp2GRAY` enum cv::
`static int`	`COLOR_YUV420sp2RGB` enum cv::
`static int`	`COLOR_YUV420sp2RGBA` enum cv::
`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_VNG` enum
`static int`	`CV_BayerBG2GRAY` enum
`static int`	`CV_BayerBG2RGB` enum
`static int`	`CV_BayerBG2RGB_VNG` enum
`static int`	`CV_BayerGB2BGR` enum
`static int`	`CV_BayerGB2BGR_VNG` enum
`static int`	`CV_BayerGB2GRAY` enum
`static int`	`CV_BayerGB2RGB` enum
`static int`	`CV_BayerGB2RGB_VNG` enum
`static int`	`CV_BayerGR2BGR` enum
`static int`	`CV_BayerGR2BGR_VNG` enum
`static int`	`CV_BayerGR2GRAY` enum
`static int`	`CV_BayerGR2RGB` enum
`static int`	`CV_BayerGR2RGB_VNG` enum
`static int`	`CV_BayerRG2BGR` enum
`static int`	`CV_BayerRG2BGR_VNG` enum
`static int`	`CV_BayerRG2GRAY` enum
`static int`	`CV_BayerRG2RGB` 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
`static int`	`CV_BLUR` enum
`static int`	`CV_BLUR_NO_SCALE` enum
`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_CORREL` enum
`static int`	`CV_COMP_HELLINGER` enum
`static int`	`CV_COMP_INTERSECT` enum
`static int`	`CV_CONTOURS_MATCH_I1` enum
`static int`	`CV_CONTOURS_MATCH_I2` enum
`static int`	`CV_CONTOURS_MATCH_I3` enum
`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_FLOODFILL_FIXED_RANGE` enum
`static int`	`CV_FLOODFILL_MASK_ONLY` enum
`static int`	`CV_GAUSSIAN` enum
`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
`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_NEXT_AROUND_DST` enum CvNextEdgeType
`static int`	`CV_NEXT_AROUND_LEFT` enum CvNextEdgeType
`static int`	`CV_NEXT_AROUND_ORG` enum CvNextEdgeType
`static int`	`CV_NEXT_AROUND_RIGHT` enum CvNextEdgeType
`static int`	`CV_POLY_APPROX_DP` enum
`static int`	`CV_PREV_AROUND_DST` enum CvNextEdgeType
`static int`	`CV_PREV_AROUND_LEFT` enum CvNextEdgeType
`static int`	`CV_PREV_AROUND_ORG` enum CvNextEdgeType
`static int`	`CV_PREV_AROUND_RIGHT` enum CvNextEdgeType
`static int`	`CV_PTLOC_ERROR` enum CvSubdiv2DPointLocation
`static int`	`CV_PTLOC_INSIDE` enum CvSubdiv2DPointLocation
`static int`	`CV_PTLOC_ON_EDGE` enum CvSubdiv2DPointLocation
`static int`	`CV_PTLOC_OUTSIDE_RECT` enum CvSubdiv2DPointLocation
`static int`	`CV_PTLOC_VERTEX` enum CvSubdiv2DPointLocation
`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
`static int`	`CV_SHAPE_CUSTOM` enum
`static int`	`CV_SHAPE_ELLIPSE` enum
`static int`	`CV_SHAPE_RECT` enum
`static int`	`CV_SUBDIV2D_VIRTUAL_POINT_FLAG` \ Planar subdivisions * \
`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_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_LABEL_CCOMP` enum cv::
`static int`	`DIST_LABEL_PIXEL` enum cv::
`static int`	`FLOODFILL_FIXED_RANGE` enum cv::
`static int`	`FLOODFILL_MASK_ONLY` enum cv::
`static int`	`GC_BGD` enum cv::
`static int`	`GC_EVAL` enum cv::
`static int`	`GC_FGD` enum cv::
`static int`	`GC_INIT_WITH_MASK` enum cv::
`static int`	`GC_INIT_WITH_RECT` enum cv::
`static int`	`GC_PR_BGD` enum cv::
`static int`	`GC_PR_FGD` enum cv::
`static int`	`GHT_POSITION` enum cv::
`static int`	`GHT_ROTATION` enum cv::
`static int`	`GHT_SCALE` enum cv::
`static int`	`INTER_AREA` enum cv::
`static int`	`INTER_BITS` enum cv::
`static int`	`INTER_BITS2` enum cv::
`static int`	`INTER_CUBIC` enum cv::
`static int`	`INTER_LANCZOS4` enum cv::
`static int`	`INTER_LINEAR` enum cv::
`static int`	`INTER_MAX` enum cv::
`static int`	`INTER_NEAREST` enum cv::
`static int`	`INTER_TAB_SIZE` enum cv::
`static int`	`INTER_TAB_SIZE2` enum cv::
`static int`	`KERNEL_ASYMMETRICAL` enum cv::
`static int`	`KERNEL_GENERAL` enum cv::
`static int`	`KERNEL_INTEGER` enum cv::
`static int`	`KERNEL_SMOOTH` enum cv::
`static int`	`KERNEL_SYMMETRICAL` enum cv::
`static int`	`MORPH_BLACKHAT` enum cv::
`static int`	`MORPH_CLOSE` enum cv::
`static int`	`MORPH_CROSS` enum cv::
`static int`	`MORPH_DILATE` enum cv::
`static int`	`MORPH_ELLIPSE` enum cv::
`static int`	`MORPH_ERODE` enum cv::
`static int`	`MORPH_GRADIENT` enum cv::
`static int`	`MORPH_OPEN` enum cv::
`static int`	`MORPH_RECT` enum cv::
`static int`	`MORPH_TOPHAT` enum cv::
`static int`	`PROJ_SPHERICAL_EQRECT` enum cv::
`static int`	`PROJ_SPHERICAL_ORTHO` enum cv::
`static int`	`RETR_CCOMP` enum cv::
`static int`	`RETR_EXTERNAL` enum cv::
`static int`	`RETR_FLOODFILL` enum cv::
`static int`	`RETR_LIST` enum cv::
`static int`	`RETR_TREE` enum cv::
`static int`	`THRESH_BINARY` enum cv::
`static int`	`THRESH_BINARY_INV` enum cv::
`static int`	`THRESH_MASK` enum cv::
`static int`	`THRESH_OTSU` enum cv::
`static int`	`THRESH_TOZERO` enum cv::
`static int`	`THRESH_TOZERO_INV` enum cv::
`static int`	`THRESH_TRUNC` enum cv::
`static int`	`TM_CCOEFF` enum cv::
`static int`	`TM_CCOEFF_NORMED` enum cv::
`static int`	`TM_CCORR` enum cv::
`static int`	`TM_CCORR_NORMED` enum cv::
`static int`	`TM_SQDIFF` enum cv::
`static int`	`TM_SQDIFF_NORMED` enum cv::
`static int`	`WARP_INVERSE_MAP` enum cv::

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)` adds image to the accumulator (dst += src).
`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)` adds product of the 2 images to the accumulator (dst += src1*src2).
`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)` adds squared src image to the accumulator (dst += src*src).
`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)` updates the running average (dst = dst(1-alpha) + srcalpha)
`static void`	`adaptiveBilateralFilter(opencv_core.Mat src, opencv_core.Mat dst, opencv_core.Size ksize, double sigmaSpace)`
`static void`	`adaptiveBilateralFilter(opencv_core.Mat src, opencv_core.Mat dst, opencv_core.Size ksize, double sigmaSpace, double maxSigmaColor, opencv_core.Point anchor, int borderType)` smooths the image using adaptive bilateral filter
`static void`	`adaptiveThreshold(opencv_core.Mat src, opencv_core.Mat dst, double maxValue, int adaptiveMethod, int thresholdType, int blockSize, double C)` applies variable (adaptive) threshold to the image
`static void`	`approxPolyDP(opencv_core.Mat curve, opencv_core.Mat approxCurve, double epsilon, boolean closed)` approximates contour or a curve using Douglas-Peucker algorithm
`static double`	`arcLength(opencv_core.Mat curve, boolean closed)` computes the contour perimeter (closed=true) or a curve length
`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)` smooths the image using bilateral filter
`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)` a synonym for normalized box filter
`static int`	`borderInterpolate(int p, int len, int borderType)` 1D interpolation function: returns coordinate of the "donor" pixel for the specified location p.
`static opencv_core.Rect`	`boundingRect(opencv_core.Mat points)` computes the bounding rectangle for a contour
`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)` smooths the image using the box filter.
`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)` builds the gaussian pyramid using pyrDown() as a basic operation
`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)` computes back projection for the set of images
`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)` computes back projection for the set of images
`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)`
`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)` computes the joint dense histogram for a set of images.
`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)` computes the joint sparse histogram for a set of images.
`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)`
`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)` applies Canny edge detector and produces the edge map.
`static double`	`compareHist(opencv_core.Mat H1, opencv_core.Mat H2, int method)` compares two histograms stored in dense arrays
`static double`	`compareHist(opencv_core.SparseMat H1, opencv_core.SparseMat H2, int method)` compares two histograms stored in sparse arrays
`static double`	`contourArea(opencv_core.Mat contour)`
`static double`	`contourArea(opencv_core.Mat contour, boolean oriented)` computes the 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)` converts maps for remap from floating-point to fixed-point format or backwards
`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)` computes convex hull for a set of 2D points.
`static void`	`convexityDefects(opencv_core.Mat contour, opencv_core.Mat convexhull, opencv_core.Mat convexityDefects)` computes the contour convexity defects
`static void`	`copyMakeBorder(opencv_core.Mat src, opencv_core.Mat dst, int top, int bottom, int left, int right, int borderType)`
`static void`	`copyMakeBorder(opencv_core.Mat src, opencv_core.Mat dst, int top, int bottom, int left, int right, int borderType, opencv_core.Scalar value)` copies 2D array to a larger destination array with extrapolation of the outer part of src using the specified border mode
`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)` computes both eigenvalues and the eigenvectors of 2x2 derivative covariation matrix at each pixel.
`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)` computes Harris cornerness criteria at each image pixel
`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)` computes minimum eigen value of 2x2 derivative covariation matrix at each pixel - the cornerness criteria
`static void`	`cornerSubPix(opencv_core.Mat image, opencv_core.Mat corners, opencv_core.Size winSize, opencv_core.Size zeroZone, opencv_core.TermCriteria criteria)` adjusts the corner locations with sub-pixel accuracy to maximize the certain cornerness criteria
`static opencv_imgproc.FilterEngine`	`createBoxFilter(int srcType, int dstType, opencv_core.Size ksize)`
`static opencv_imgproc.FilterEngine`	`createBoxFilter(int srcType, int dstType, opencv_core.Size ksize, opencv_core.Point anchor, boolean normalize, int borderType)` returns box filter engine
`static opencv_imgproc.CLAHE`	`createCLAHE()`
`static opencv_imgproc.CLAHE`	`createCLAHE(double clipLimit, opencv_core.Size tileGridSize)`
`static opencv_imgproc.FilterEngine`	`createDerivFilter(int srcType, int dstType, int dx, int dy, int ksize)`
`static opencv_imgproc.FilterEngine`	`createDerivFilter(int srcType, int dstType, int dx, int dy, int ksize, int borderType)` returns filter engine for the generalized Sobel operator
`static opencv_imgproc.FilterEngine`	`createGaussianFilter(int type, opencv_core.Size ksize, double sigma1)`
`static opencv_imgproc.FilterEngine`	`createGaussianFilter(int type, opencv_core.Size ksize, double sigma1, double sigma2, int borderType)` returns the Gaussian filter engine
`static void`	`createHanningWindow(opencv_core.Mat dst, opencv_core.Size winSize, int type)`
`static opencv_imgproc.FilterEngine`	`createLinearFilter(int srcType, int dstType, opencv_core.Mat kernel)`
`static opencv_imgproc.FilterEngine`	`createLinearFilter(int srcType, int dstType, opencv_core.Mat kernel, opencv_core.Point _anchor, double delta, int rowBorderType, int columnBorderType, opencv_core.Scalar borderValue)` returns the non-separable linear filter engine
`static opencv_imgproc.FilterEngine`	`createMorphologyFilter(int op, int type, opencv_core.Mat kernel)`
`static opencv_imgproc.FilterEngine`	`createMorphologyFilter(int op, int type, opencv_core.Mat kernel, opencv_core.Point anchor, int rowBorderType, int columnBorderType, opencv_core.Scalar borderValue)` returns morphological filter engine.
`static opencv_imgproc.FilterEngine`	`createSeparableLinearFilter(int srcType, int dstType, opencv_core.Mat rowKernel, opencv_core.Mat columnKernel)`
`static opencv_imgproc.FilterEngine`	`createSeparableLinearFilter(int srcType, int dstType, opencv_core.Mat rowKernel, opencv_core.Mat columnKernel, opencv_core.Point anchor, double delta, int rowBorderType, int columnBorderType, opencv_core.Scalar borderValue)` returns the separable linear filter engine
`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)`
`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)` Background statistics accumulation
`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)`
`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)`
`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)` \ Contour Processing and Shape Analysis * \
`static double`	`cvArcLength(Pointer curve)`
`static double`	`cvArcLength(Pointer curve, opencv_core.CvSlice slice, int is_closed)`
`static opencv_core.CvRect`	`cvBoundingRect(opencv_core.CvArr points)`
`static opencv_core.CvRect`	`cvBoundingRect(opencv_core.CvArr points, int update)`
`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)`
`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)`
`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)`
`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)`
`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)`
`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)`
`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)`
`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)`
`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)` \ Feature detection * \
`static int`	`cvCheckContourConvexity(opencv_core.CvArr contour)`
`static void`	`cvClearHist(opencv_core.CvHistogram hist)`
`static double`	`cvCompareHist(opencv_core.CvHistogram hist1, opencv_core.CvHistogram hist2, int method)`
`static double`	`cvContourArea(opencv_core.CvArr contour)`
`static double`	`cvContourArea(opencv_core.CvArr contour, opencv_core.CvSlice slice, int oriented)`
`static double`	`cvContourPerimeter(Pointer contour)`
`static void`	`cvConvertMaps(opencv_core.CvArr mapx, opencv_core.CvArr mapy, opencv_core.CvArr mapxy, opencv_core.CvArr mapalpha)`
`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)`
`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)`
`static void`	`cvCopyHist(opencv_core.CvHistogram src, opencv_core.CvHistogram dst)`
`static void`	`cvCopyHist(opencv_core.CvHistogram src, PointerPointer dst)`
`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)` \ Image Processing * \
`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)`
`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)`
`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)`
`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)` \ Histogram functions * \
`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)`
`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)`
`static void`	`cvCvtColor(opencv_core.CvArr src, opencv_core.CvArr dst, int code)`
`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)`
`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)`
`static opencv_core.CvSeq`	`cvEndFindContours(opencv_imgproc.CvContourScanner scanner)`
`static void`	`cvEqualizeHist(opencv_core.CvArr src, opencv_core.CvArr dst)`
`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)`
`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)`
`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)` \ Contours retrieving * \
`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)`
`static opencv_core.CvSeq`	`cvFindNextContour(opencv_imgproc.CvContourScanner scanner)`
`static opencv_core.CvBox2D`	`cvFitEllipse2(opencv_core.CvArr 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)`
`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)`
`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)`
`static double`	`cvGetCentralMoment(opencv_imgproc.CvMoments moments, int x_order, int y_order)`
`static void`	`cvGetHuMoments(opencv_imgproc.CvMoments moments, opencv_imgproc.CvHuMoments hu_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)`
`static double`	`cvGetNormalizedCentralMoment(opencv_imgproc.CvMoments moments, int x_order, int y_order)`
`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)`
`static void`	`cvGetQuadrangleSubPix(opencv_core.CvArr src, opencv_core.CvArr dst, opencv_core.CvMat map_matrix)`
`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)`
`static double`	`cvGetSpatialMoment(opencv_imgproc.CvMoments moments, int x_order, int y_order)`
`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)`
`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)`
`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)`
`static void`	`cvInitUndistortMap(opencv_core.CvMat camera_matrix, opencv_core.CvMat distortion_coeffs, opencv_core.CvArr mapx, opencv_core.CvArr mapy)`
`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)`
`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)`
`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)`
`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)`
`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)`
`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)`
`static double`	`cvMatchShapes(Pointer object1, Pointer object2, int method)`
`static double`	`cvMatchShapes(Pointer object1, Pointer object2, int method, double parameter)`
`static void`	`cvMatchTemplate(opencv_core.CvArr image, opencv_core.CvArr templ, opencv_core.CvArr result, int method)`
`static opencv_core.CvRect`	`cvMaxRect(opencv_core.CvRect rect1, opencv_core.CvRect rect2)`
`static opencv_core.CvBox2D`	`cvMinAreaRect2(opencv_core.CvArr points)`
`static opencv_core.CvBox2D`	`cvMinAreaRect2(opencv_core.CvArr points, opencv_core.CvMemStorage storage)`
`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)`
`static void`	`cvMoments(opencv_core.CvArr arr, opencv_imgproc.CvMoments moments)`
`static void`	`cvMoments(opencv_core.CvArr arr, opencv_imgproc.CvMoments moments, int binary)`
`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)`
`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)`
`static void`	`cvNormalizeHist(opencv_core.CvHistogram hist, double factor)`
`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)`
`static opencv_core.CvSeq`	`cvPointSeqFromMat(int seq_kind, opencv_core.CvArr mat, opencv_core.CvContour contour_header, opencv_core.CvSeqBlock block)`
`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)`
`static void`	`cvPyrDown(opencv_core.CvArr src, opencv_core.CvArr dst)`
`static void`	`cvPyrDown(opencv_core.CvArr src, opencv_core.CvArr dst, int filter)`
`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)`
`static void`	`cvPyrUp(opencv_core.CvArr src, opencv_core.CvArr dst)`
`static void`	`cvPyrUp(opencv_core.CvArr src, opencv_core.CvArr dst, int filter)`
`static opencv_core.CvPoint`	`cvReadChainPoint(opencv_imgproc.CvChainPtReader reader)`
`static void`	`cvReleaseHist(opencv_core.CvHistogram hist)`
`static void`	`cvReleaseHist(PointerPointer hist)`
`static void`	`cvReleasePyramid(PointerPointer pyramid, int extra_layers)`
`static void`	`cvReleaseStructuringElement(opencv_core.IplConvKernel element)`
`static void`	`cvReleaseStructuringElement(PointerPointer 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)`
`static void`	`cvResize(opencv_core.CvArr src, opencv_core.CvArr dst)`
`static void`	`cvResize(opencv_core.CvArr src, opencv_core.CvArr dst, int interpolation)`
`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)`
`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)` data sampling
`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)`
`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)`
`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)`
`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)`
`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)`
`static void`	`cvStartReadChainPoints(opencv_core.CvChain chain, opencv_imgproc.CvChainPtReader reader)`
`static void`	`cvSubstituteContour(opencv_imgproc.CvContourScanner scanner, opencv_core.CvSeq new_contour)`
`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)` converts image from one color space to another
`static void`	`cvThreshHist(opencv_core.CvHistogram hist, double threshold)`
`static double`	`cvThreshold(opencv_core.CvArr src, opencv_core.CvArr dst, double threshold, double max_value, int threshold_type)`
`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)`
`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)`
`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)`
`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)`
`static void`	`cvWatershed(opencv_core.CvArr image, opencv_core.CvArr markers)`
`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)` dilates the image (applies the local maximum operator)
`static void`	`distanceTransform(opencv_core.Mat src, opencv_core.Mat dst, int distanceType, int maskSize)` computes the distance transform map
`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)` builds the discrete Voronoi diagram
`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)` draws contours in the image
`static void`	`eigen2x2(float[] a, float[] e, int n)`
`static void`	`eigen2x2(FloatBuffer a, FloatBuffer e, int n)`
`static void`	`eigen2x2(FloatPointer a, FloatPointer e, int n)`
`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)`
`static void`	`equalizeHist(opencv_core.Mat src, opencv_core.Mat dst)` normalizes the grayscale image brightness and contrast by normalizing its histogram
`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)` erodes the image (applies the local minimum operator)
`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)` applies non-separable 2D linear filter to the image
`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)` retrieves contours from black-n-white image.
`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)` retrieves contours and the hierarchical information from black-n-white image.
`static opencv_core.RotatedRect`	`fitEllipse(opencv_core.Mat points)` fits ellipse to the set of 2D points
`static void`	`fitLine(opencv_core.Mat points, opencv_core.Mat line, int distType, double param, double reps, double aeps)` fits line to the set of 2D points using M-estimator algorithm
`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)` fills the semi-uniform image region and/or the mask starting from the specified seed point
`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)` fills the semi-uniform image region starting from the specified seed point
`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)` smooths the image using 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)` returns 2x3 affine transformation for the corresponding 3 point pairs.
`static opencv_imgproc.BaseColumnFilter`	`getColumnSumFilter(int sumType, int dstType, int ksize)`
`static opencv_imgproc.BaseColumnFilter`	`getColumnSumFilter(int sumType, int dstType, int ksize, int anchor, double scale)` returns vertical 1D box filter
`static opencv_core.Mat`	`getDefaultNewCameraMatrix(opencv_core.Mat cameraMatrix)`
`static opencv_core.Mat`	`getDefaultNewCameraMatrix(opencv_core.Mat cameraMatrix, opencv_core.Size imgsize, boolean centerPrincipalPoint)` returns the default new camera matrix (by default it is the same as cameraMatrix unless centerPricipalPoint=true)
`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)` initializes kernels of the generalized Sobel operator
`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)` returns the Gabor kernel with the specified parameters
`static opencv_core.Mat`	`getGaussianKernel(int ksize, double sigma)`
`static opencv_core.Mat`	`getGaussianKernel(int ksize, double sigma, int ktype)` returns the Gaussian kernel with the specified parameters
`static int`	`getKernelType(opencv_core.Mat kernel, opencv_core.Point anchor)` returns type (one of KERNEL_*) of 1D or 2D kernel specified by its coefficients.
`static opencv_imgproc.BaseColumnFilter`	`getLinearColumnFilter(int bufType, int dstType, opencv_core.Mat kernel, int anchor, int symmetryType)`
`static opencv_imgproc.BaseColumnFilter`	`getLinearColumnFilter(int bufType, int dstType, opencv_core.Mat kernel, int anchor, int symmetryType, double delta, int bits)` returns the primitive column filter with the specified kernel
`static opencv_imgproc.BaseFilter`	`getLinearFilter(int srcType, int dstType, opencv_core.Mat kernel)`
`static opencv_imgproc.BaseFilter`	`getLinearFilter(int srcType, int dstType, opencv_core.Mat kernel, opencv_core.Point anchor, double delta, int bits)` returns 2D filter with the specified kernel
`static opencv_imgproc.BaseRowFilter`	`getLinearRowFilter(int srcType, int bufType, opencv_core.Mat kernel, int anchor, int symmetryType)` returns the primitive row filter with the specified kernel
`static opencv_imgproc.BaseColumnFilter`	`getMorphologyColumnFilter(int op, int type, int ksize)`
`static opencv_imgproc.BaseColumnFilter`	`getMorphologyColumnFilter(int op, int type, int ksize, int anchor)` returns vertical 1D morphological filter
`static opencv_imgproc.BaseFilter`	`getMorphologyFilter(int op, int type, opencv_core.Mat kernel)`
`static opencv_imgproc.BaseFilter`	`getMorphologyFilter(int op, int type, opencv_core.Mat kernel, opencv_core.Point anchor)` returns 2D morphological filter
`static opencv_imgproc.BaseRowFilter`	`getMorphologyRowFilter(int op, int type, int ksize)`
`static opencv_imgproc.BaseRowFilter`	`getMorphologyRowFilter(int op, int type, int ksize, int anchor)` returns horizontal 1D morphological filter
`static opencv_core.Mat`	`getPerspectiveTransform(opencv_core.Mat src, opencv_core.Mat dst)`
`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)` extracts rectangle from the image at sub-pixel location
`static opencv_core.Mat`	`getRotationMatrix2D(opencv_core.Point2f center, double angle, double scale)` returns 2x3 affine transformation matrix for the planar rotation.
`static opencv_imgproc.BaseRowFilter`	`getRowSumFilter(int srcType, int sumType, int ksize)`
`static opencv_imgproc.BaseRowFilter`	`getRowSumFilter(int srcType, int sumType, int ksize, int anchor)` returns horizontal 1D box filter
`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)` returns structuring element of the specified shape and size
`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)` finds the strong enough corners where the cornerMinEigenVal() or cornerHarris() report the local maxima
`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)` segments the image using 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)` finds circles in the grayscale image using 2+1 gradient 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)` finds lines in the black-n-white image using the standard or pyramid 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)` finds line segments in the black-n-white image using probabilistic Hough transform
`static void`	`HuMoments(opencv_imgproc.Moments moments, double[] hu)`
`static void`	`HuMoments(opencv_imgproc.Moments moments, DoubleBuffer hu)`
`static void`	`HuMoments(opencv_imgproc.Moments moments, DoublePointer hu)` computes 7 Hu invariants from the moments
`static void`	`HuMoments(opencv_imgproc.Moments m, opencv_core.Mat hu)`
`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)` initializes maps for cv::remap() to correct lens distortion and optionally rectify the image
`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)` computes the integral image
`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)` computes the integral image and integral for the squared image
`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)` computes the integral image, integral for the squared image and the tilted integral 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)` computes 2x3 affine transformation matrix that is inverse to the specified 2x3 affine transformation.
`static boolean`	`isContourConvex(opencv_core.Mat contour)` returns true if the contour is convex.
`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)` applies Laplacian operator to the image
`static double`	`matchShapes(opencv_core.Mat contour1, opencv_core.Mat contour2, int method, double parameter)` matches two contours using one of the available algorithms
`static void`	`matchTemplate(opencv_core.Mat image, opencv_core.Mat templ, opencv_core.Mat result, int method)` computes the proximity map for the raster template and the image where the template is searched for
`static void`	`medianBlur(opencv_core.Mat src, opencv_core.Mat dst, int ksize)` smooths the image using median filter.
`static opencv_core.RotatedRect`	`minAreaRect(opencv_core.Mat points)` computes the minimal rotated rectangle for a set of points
`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)` computes the minimal enclosing circle for a set of points
`static opencv_imgproc.Moments`	`moments(opencv_core.Mat array)`
`static opencv_imgproc.Moments`	`moments(opencv_core.Mat array, boolean binaryImage)` computes moments of the rasterized shape or a vector of points
`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)` applies an advanced morphological operation to the image
`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)`
`static opencv_core.Point2d`	`phaseCorrelateRes(opencv_core.Mat src1, opencv_core.Mat src2, opencv_core.Mat window)`
`static opencv_core.Point2d`	`phaseCorrelateRes(opencv_core.Mat src1, opencv_core.Mat src2, opencv_core.Mat window, double[] response)`
`static opencv_core.Point2d`	`phaseCorrelateRes(opencv_core.Mat src1, opencv_core.Mat src2, opencv_core.Mat window, DoubleBuffer response)`
`static opencv_core.Point2d`	`phaseCorrelateRes(opencv_core.Mat src1, opencv_core.Mat src2, opencv_core.Mat window, DoublePointer response)`
`static double`	`pointPolygonTest(opencv_core.Mat contour, opencv_core.Point2f pt, boolean measureDist)` checks if the point is inside the contour.
`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)` computes another complex cornerness criteria at each pixel
`static double`	`PSNR(opencv_core.Mat src1, opencv_core.Mat src2)` computes PSNR image/video quality metric
`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)` smooths and downsamples the image
`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)` filters image using meanshift algorithm
`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)` upsamples and smoothes the image
`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)` warps the image using the precomputed maps.
`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)` resizes the image
`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)` applies the vertical or horizontal Scharr operator to the image
`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)` applies separable 2D linear filter to the 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)` applies generalized Sobel operator to the image
`static double`	`threshold(opencv_core.Mat src, opencv_core.Mat dst, double thresh, double maxval, int type)` applies fixed threshold to the image
`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)` corrects lens distortion for the given camera matrix and distortion coefficients
`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)` returns points' coordinates after lens distortion correction
`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)` warps the image using affine transformation
`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)` warps the image using perspective transformation
`static void`	`watershed(opencv_core.Mat image, opencv_core.Mat markers)` segments the image using watershed algorithm

Methods inherited from class org.bytedeco.javacpp.helper.opencv_imgproc
cvCalcArrBackProject, cvCalcArrBackProjectPatch, cvCalcArrHist, cvCalcBackProject, cvCalcBackProject, cvCalcBackProjectPatch, cvCalcBackProjectPatch, cvCalcHist, cvCalcHist, cvCreateHist, cvFindContours, cvMakeHistHeaderForArray, cvMakeHistHeaderForArray, 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
  
  See Also:
  Constant Field Values
- CV_BLUR
```
public static final int CV_BLUR
```
  enum
  
  See Also:
  Constant Field Values
- CV_GAUSSIAN
```
public static final int CV_GAUSSIAN
```
  enum
  
  See Also:
  Constant Field Values
- CV_MEDIAN
```
public static final int CV_MEDIAN
```
  enum
  
  See Also:
  Constant Field Values
- CV_BILATERAL
```
public static final int CV_BILATERAL
```
  enum
  
  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_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
  
  See Also:
  Constant Field Values
- CV_SHAPE_CROSS
```
public static final int CV_SHAPE_CROSS
```
  enum
  
  See Also:
  Constant Field Values
- CV_SHAPE_ELLIPSE
```
public static final int CV_SHAPE_ELLIPSE
```
  enum
  
  See Also:
  Constant Field Values
- CV_SHAPE_CUSTOM
```
public static final int CV_SHAPE_CUSTOM
```
  enum
  
  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_SUBDIV2D_VIRTUAL_POINT_FLAG
```
public static final int CV_SUBDIV2D_VIRTUAL_POINT_FLAG
```
  \ Planar subdivisions * \
  
  See Also:
  Constant Field Values
- CV_PTLOC_ERROR
```
public static final int CV_PTLOC_ERROR
```
  enum CvSubdiv2DPointLocation
  
  See Also:
  Constant Field Values
- CV_PTLOC_OUTSIDE_RECT
```
public static final int CV_PTLOC_OUTSIDE_RECT
```
  enum CvSubdiv2DPointLocation
  
  See Also:
  Constant Field Values
- CV_PTLOC_INSIDE
```
public static final int CV_PTLOC_INSIDE
```
  enum CvSubdiv2DPointLocation
  
  See Also:
  Constant Field Values
- CV_PTLOC_VERTEX
```
public static final int CV_PTLOC_VERTEX
```
  enum CvSubdiv2DPointLocation
  
  See Also:
  Constant Field Values
- CV_PTLOC_ON_EDGE
```
public static final int CV_PTLOC_ON_EDGE
```
  enum CvSubdiv2DPointLocation
  
  See Also:
  Constant Field Values
- CV_NEXT_AROUND_ORG
```
public static final int CV_NEXT_AROUND_ORG
```
  enum CvNextEdgeType
  
  See Also:
  Constant Field Values
- CV_NEXT_AROUND_DST
```
public static final int CV_NEXT_AROUND_DST
```
  enum CvNextEdgeType
  
  See Also:
  Constant Field Values
- CV_PREV_AROUND_ORG
```
public static final int CV_PREV_AROUND_ORG
```
  enum CvNextEdgeType
  
  See Also:
  Constant Field Values
- CV_PREV_AROUND_DST
```
public static final int CV_PREV_AROUND_DST
```
  enum CvNextEdgeType
  
  See Also:
  Constant Field Values
- CV_NEXT_AROUND_LEFT
```
public static final int CV_NEXT_AROUND_LEFT
```
  enum CvNextEdgeType
  
  See Also:
  Constant Field Values
- CV_NEXT_AROUND_RIGHT
```
public static final int CV_NEXT_AROUND_RIGHT
```
  enum CvNextEdgeType
  
  See Also:
  Constant Field Values
- CV_PREV_AROUND_LEFT
```
public static final int CV_PREV_AROUND_LEFT
```
  enum CvNextEdgeType
  
  See Also:
  Constant Field Values
- CV_PREV_AROUND_RIGHT
```
public static final int CV_PREV_AROUND_RIGHT
```
  enum CvNextEdgeType
  
  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
  
  See Also:
  Constant Field Values
- CV_CONTOURS_MATCH_I2
```
public static final int CV_CONTOURS_MATCH_I2
```
  enum
  
  See Also:
  Constant Field Values
- CV_CONTOURS_MATCH_I3
```
public static final int CV_CONTOURS_MATCH_I3
```
  enum
  
  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_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_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
- BORDER_REPLICATE
```
public static final int BORDER_REPLICATE
```
  enum cv::
  
  See Also:
  Constant Field Values
- BORDER_CONSTANT
```
public static final int BORDER_CONSTANT
```
  enum cv::
  
  See Also:
  Constant Field Values
- BORDER_REFLECT
```
public static final int BORDER_REFLECT
```
  enum cv::
  
  See Also:
  Constant Field Values
- BORDER_WRAP
```
public static final int BORDER_WRAP
```
  enum cv::
  
  See Also:
  Constant Field Values
- BORDER_REFLECT_101
```
public static final int BORDER_REFLECT_101
```
  enum cv::
  
  See Also:
  Constant Field Values
- BORDER_REFLECT101
```
public static final int BORDER_REFLECT101
```
  enum cv::
  
  See Also:
  Constant Field Values
- BORDER_TRANSPARENT
```
public static final int BORDER_TRANSPARENT
```
  enum cv::
  
  See Also:
  Constant Field Values
- BORDER_DEFAULT
```
public static final int BORDER_DEFAULT
```
  enum cv::
  
  See Also:
  Constant Field Values
- BORDER_ISOLATED
```
public static final int BORDER_ISOLATED
```
  enum cv::
  
  See Also:
  Constant Field Values
- KERNEL_GENERAL
```
public static final int KERNEL_GENERAL
```
  enum cv::
  
  See Also:
  Constant Field Values
- KERNEL_SYMMETRICAL
```
public static final int KERNEL_SYMMETRICAL
```
  enum cv::
  
  See Also:
  Constant Field Values
- KERNEL_ASYMMETRICAL
```
public static final int KERNEL_ASYMMETRICAL
```
  enum cv::
  
  See Also:
  Constant Field Values
- KERNEL_SMOOTH
```
public static final int KERNEL_SMOOTH
```
  enum cv::
  
  See Also:
  Constant Field Values
- KERNEL_INTEGER
```
public static final int KERNEL_INTEGER
```
  enum cv::
  
  See Also:
  Constant Field Values
- MORPH_ERODE
```
public static final int MORPH_ERODE
```
  enum cv::
  
  See Also:
  Constant Field Values
- MORPH_DILATE
```
public static final int MORPH_DILATE
```
  enum cv::
  
  See Also:
  Constant Field Values
- MORPH_OPEN
```
public static final int MORPH_OPEN
```
  enum cv::
  
  See Also:
  Constant Field Values
- MORPH_CLOSE
```
public static final int MORPH_CLOSE
```
  enum cv::
  
  See Also:
  Constant Field Values
- MORPH_GRADIENT
```
public static final int MORPH_GRADIENT
```
  enum cv::
  
  See Also:
  Constant Field Values
- MORPH_TOPHAT
```
public static final int MORPH_TOPHAT
```
  enum cv::
  
  See Also:
  Constant Field Values
- MORPH_BLACKHAT
```
public static final int MORPH_BLACKHAT
```
  enum cv::
  
  See Also:
  Constant Field Values
- MORPH_RECT
```
public static final int MORPH_RECT
```
  enum cv::
  
  See Also:
  Constant Field Values
- MORPH_CROSS
```
public static final int MORPH_CROSS
```
  enum cv::
  
  See Also:
  Constant Field Values
- MORPH_ELLIPSE
```
public static final int MORPH_ELLIPSE
```
  enum cv::
  
  See Also:
  Constant Field Values
- GHT_POSITION
```
public static final int GHT_POSITION
```
  enum cv::
  
  See Also:
  Constant Field Values
- GHT_SCALE
```
public static final int GHT_SCALE
```
  enum cv::
  
  See Also:
  Constant Field Values
- GHT_ROTATION
```
public static final int GHT_ROTATION
```
  enum cv::
  
  See Also:
  Constant Field Values
- INTER_NEAREST
```
public static final int INTER_NEAREST
```
  enum cv::
  
  See Also:
  Constant Field Values
- INTER_LINEAR
```
public static final int INTER_LINEAR
```
  enum cv::
  
  See Also:
  Constant Field Values
- INTER_CUBIC
```
public static final int INTER_CUBIC
```
  enum cv::
  
  See Also:
  Constant Field Values
- INTER_AREA
```
public static final int INTER_AREA
```
  enum cv::
  
  See Also:
  Constant Field Values
- INTER_LANCZOS4
```
public static final int INTER_LANCZOS4
```
  enum cv::
  
  See Also:
  Constant Field Values
- INTER_MAX
```
public static final int INTER_MAX
```
  enum cv::
  
  See Also:
  Constant Field Values
- WARP_INVERSE_MAP
```
public static final int WARP_INVERSE_MAP
```
  enum cv::
  
  See Also:
  Constant Field Values
- INTER_BITS
```
public static final int INTER_BITS
```
  enum cv::
  
  See Also:
  Constant Field Values
- INTER_BITS2
```
public static final int INTER_BITS2
```
  enum cv::
  
  See Also:
  Constant Field Values
- INTER_TAB_SIZE
```
public static final int INTER_TAB_SIZE
```
  enum cv::
  
  See Also:
  Constant Field Values
- INTER_TAB_SIZE2
```
public static final int INTER_TAB_SIZE2
```
  enum cv::
  
  See Also:
  Constant Field Values
- THRESH_BINARY
```
public static final int THRESH_BINARY
```
  enum cv::
  
  See Also:
  Constant Field Values
- THRESH_BINARY_INV
```
public static final int THRESH_BINARY_INV
```
  enum cv::
  
  See Also:
  Constant Field Values
- THRESH_TRUNC
```
public static final int THRESH_TRUNC
```
  enum cv::
  
  See Also:
  Constant Field Values
- THRESH_TOZERO
```
public static final int THRESH_TOZERO
```
  enum cv::
  
  See Also:
  Constant Field Values
- THRESH_TOZERO_INV
```
public static final int THRESH_TOZERO_INV
```
  enum cv::
  
  See Also:
  Constant Field Values
- THRESH_MASK
```
public static final int THRESH_MASK
```
  enum cv::
  
  See Also:
  Constant Field Values
- THRESH_OTSU
```
public static final int THRESH_OTSU
```
  enum cv::
  
  See Also:
  Constant Field Values
- ADAPTIVE_THRESH_MEAN_C
```
public static final int ADAPTIVE_THRESH_MEAN_C
```
  enum cv::
  
  See Also:
  Constant Field Values
- ADAPTIVE_THRESH_GAUSSIAN_C
```
public static final int ADAPTIVE_THRESH_GAUSSIAN_C
```
  enum cv::
  
  See Also:
  Constant Field Values
- PROJ_SPHERICAL_ORTHO
```
public static final int PROJ_SPHERICAL_ORTHO
```
  enum cv::
  
  See Also:
  Constant Field Values
- PROJ_SPHERICAL_EQRECT
```
public static final int PROJ_SPHERICAL_EQRECT
```
  enum cv::
  
  See Also:
  Constant Field Values
- GC_BGD
```
public static final int GC_BGD
```
  enum cv::
  
  See Also:
  Constant Field Values
- GC_FGD
```
public static final int GC_FGD
```
  enum cv::
  
  See Also:
  Constant Field Values
- GC_PR_BGD
```
public static final int GC_PR_BGD
```
  enum cv::
  
  See Also:
  Constant Field Values
- GC_PR_FGD
```
public static final int GC_PR_FGD
```
  enum cv::
  
  See Also:
  Constant Field Values
- GC_INIT_WITH_RECT
```
public static final int GC_INIT_WITH_RECT
```
  enum cv::
  
  See Also:
  Constant Field Values
- GC_INIT_WITH_MASK
```
public static final int GC_INIT_WITH_MASK
```
  enum cv::
  
  See Also:
  Constant Field Values
- GC_EVAL
```
public static final int GC_EVAL
```
  enum cv::
  
  See Also:
  Constant Field Values
- DIST_LABEL_CCOMP
```
public static final int DIST_LABEL_CCOMP
```
  enum cv::
  
  See Also:
  Constant Field Values
- DIST_LABEL_PIXEL
```
public static final int DIST_LABEL_PIXEL
```
  enum cv::
  
  See Also:
  Constant Field Values
- FLOODFILL_FIXED_RANGE
```
public static final int FLOODFILL_FIXED_RANGE
```
  enum cv::
  
  See Also:
  Constant Field Values
- FLOODFILL_MASK_ONLY
```
public static final int FLOODFILL_MASK_ONLY
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_BGR2BGRA
```
public static final int COLOR_BGR2BGRA
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_RGB2RGBA
```
public static final int COLOR_RGB2RGBA
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_BGRA2BGR
```
public static final int COLOR_BGRA2BGR
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_RGBA2RGB
```
public static final int COLOR_RGBA2RGB
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_BGR2RGBA
```
public static final int COLOR_BGR2RGBA
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_RGB2BGRA
```
public static final int COLOR_RGB2BGRA
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_RGBA2BGR
```
public static final int COLOR_RGBA2BGR
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_BGRA2RGB
```
public static final int COLOR_BGRA2RGB
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_BGR2RGB
```
public static final int COLOR_BGR2RGB
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_RGB2BGR
```
public static final int COLOR_RGB2BGR
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_BGRA2RGBA
```
public static final int COLOR_BGRA2RGBA
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_RGBA2BGRA
```
public static final int COLOR_RGBA2BGRA
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_BGR2GRAY
```
public static final int COLOR_BGR2GRAY
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_RGB2GRAY
```
public static final int COLOR_RGB2GRAY
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_GRAY2BGR
```
public static final int COLOR_GRAY2BGR
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_GRAY2RGB
```
public static final int COLOR_GRAY2RGB
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_GRAY2BGRA
```
public static final int COLOR_GRAY2BGRA
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_GRAY2RGBA
```
public static final int COLOR_GRAY2RGBA
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_BGRA2GRAY
```
public static final int COLOR_BGRA2GRAY
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_RGBA2GRAY
```
public static final int COLOR_RGBA2GRAY
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_BGR2BGR565
```
public static final int COLOR_BGR2BGR565
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_RGB2BGR565
```
public static final int COLOR_RGB2BGR565
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_BGR5652BGR
```
public static final int COLOR_BGR5652BGR
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_BGR5652RGB
```
public static final int COLOR_BGR5652RGB
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_BGRA2BGR565
```
public static final int COLOR_BGRA2BGR565
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_RGBA2BGR565
```
public static final int COLOR_RGBA2BGR565
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_BGR5652BGRA
```
public static final int COLOR_BGR5652BGRA
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_BGR5652RGBA
```
public static final int COLOR_BGR5652RGBA
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_GRAY2BGR565
```
public static final int COLOR_GRAY2BGR565
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_BGR5652GRAY
```
public static final int COLOR_BGR5652GRAY
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_BGR2BGR555
```
public static final int COLOR_BGR2BGR555
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_RGB2BGR555
```
public static final int COLOR_RGB2BGR555
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_BGR5552BGR
```
public static final int COLOR_BGR5552BGR
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_BGR5552RGB
```
public static final int COLOR_BGR5552RGB
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_BGRA2BGR555
```
public static final int COLOR_BGRA2BGR555
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_RGBA2BGR555
```
public static final int COLOR_RGBA2BGR555
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_BGR5552BGRA
```
public static final int COLOR_BGR5552BGRA
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_BGR5552RGBA
```
public static final int COLOR_BGR5552RGBA
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_GRAY2BGR555
```
public static final int COLOR_GRAY2BGR555
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_BGR5552GRAY
```
public static final int COLOR_BGR5552GRAY
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_BGR2XYZ
```
public static final int COLOR_BGR2XYZ
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_RGB2XYZ
```
public static final int COLOR_RGB2XYZ
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_XYZ2BGR
```
public static final int COLOR_XYZ2BGR
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_XYZ2RGB
```
public static final int COLOR_XYZ2RGB
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_BGR2YCrCb
```
public static final int COLOR_BGR2YCrCb
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_RGB2YCrCb
```
public static final int COLOR_RGB2YCrCb
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_YCrCb2BGR
```
public static final int COLOR_YCrCb2BGR
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_YCrCb2RGB
```
public static final int COLOR_YCrCb2RGB
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_BGR2HSV
```
public static final int COLOR_BGR2HSV
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_RGB2HSV
```
public static final int COLOR_RGB2HSV
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_BGR2Lab
```
public static final int COLOR_BGR2Lab
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_RGB2Lab
```
public static final int COLOR_RGB2Lab
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_BayerBG2BGR
```
public static final int COLOR_BayerBG2BGR
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_BayerGB2BGR
```
public static final int COLOR_BayerGB2BGR
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_BayerRG2BGR
```
public static final int COLOR_BayerRG2BGR
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_BayerGR2BGR
```
public static final int COLOR_BayerGR2BGR
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_BayerBG2RGB
```
public static final int COLOR_BayerBG2RGB
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_BayerGB2RGB
```
public static final int COLOR_BayerGB2RGB
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_BayerRG2RGB
```
public static final int COLOR_BayerRG2RGB
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_BayerGR2RGB
```
public static final int COLOR_BayerGR2RGB
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_BGR2Luv
```
public static final int COLOR_BGR2Luv
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_RGB2Luv
```
public static final int COLOR_RGB2Luv
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_BGR2HLS
```
public static final int COLOR_BGR2HLS
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_RGB2HLS
```
public static final int COLOR_RGB2HLS
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_HSV2BGR
```
public static final int COLOR_HSV2BGR
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_HSV2RGB
```
public static final int COLOR_HSV2RGB
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_Lab2BGR
```
public static final int COLOR_Lab2BGR
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_Lab2RGB
```
public static final int COLOR_Lab2RGB
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_Luv2BGR
```
public static final int COLOR_Luv2BGR
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_Luv2RGB
```
public static final int COLOR_Luv2RGB
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_HLS2BGR
```
public static final int COLOR_HLS2BGR
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_HLS2RGB
```
public static final int COLOR_HLS2RGB
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_BayerBG2BGR_VNG
```
public static final int COLOR_BayerBG2BGR_VNG
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_BayerGB2BGR_VNG
```
public static final int COLOR_BayerGB2BGR_VNG
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_BayerRG2BGR_VNG
```
public static final int COLOR_BayerRG2BGR_VNG
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_BayerGR2BGR_VNG
```
public static final int COLOR_BayerGR2BGR_VNG
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_BayerBG2RGB_VNG
```
public static final int COLOR_BayerBG2RGB_VNG
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_BayerGB2RGB_VNG
```
public static final int COLOR_BayerGB2RGB_VNG
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_BayerRG2RGB_VNG
```
public static final int COLOR_BayerRG2RGB_VNG
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_BayerGR2RGB_VNG
```
public static final int COLOR_BayerGR2RGB_VNG
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_BGR2HSV_FULL
```
public static final int COLOR_BGR2HSV_FULL
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_RGB2HSV_FULL
```
public static final int COLOR_RGB2HSV_FULL
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_BGR2HLS_FULL
```
public static final int COLOR_BGR2HLS_FULL
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_RGB2HLS_FULL
```
public static final int COLOR_RGB2HLS_FULL
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_HSV2BGR_FULL
```
public static final int COLOR_HSV2BGR_FULL
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_HSV2RGB_FULL
```
public static final int COLOR_HSV2RGB_FULL
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_HLS2BGR_FULL
```
public static final int COLOR_HLS2BGR_FULL
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_HLS2RGB_FULL
```
public static final int COLOR_HLS2RGB_FULL
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_LBGR2Lab
```
public static final int COLOR_LBGR2Lab
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_LRGB2Lab
```
public static final int COLOR_LRGB2Lab
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_LBGR2Luv
```
public static final int COLOR_LBGR2Luv
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_LRGB2Luv
```
public static final int COLOR_LRGB2Luv
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_Lab2LBGR
```
public static final int COLOR_Lab2LBGR
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_Lab2LRGB
```
public static final int COLOR_Lab2LRGB
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_Luv2LBGR
```
public static final int COLOR_Luv2LBGR
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_Luv2LRGB
```
public static final int COLOR_Luv2LRGB
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_BGR2YUV
```
public static final int COLOR_BGR2YUV
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_RGB2YUV
```
public static final int COLOR_RGB2YUV
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_YUV2BGR
```
public static final int COLOR_YUV2BGR
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_YUV2RGB
```
public static final int COLOR_YUV2RGB
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_BayerBG2GRAY
```
public static final int COLOR_BayerBG2GRAY
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_BayerGB2GRAY
```
public static final int COLOR_BayerGB2GRAY
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_BayerRG2GRAY
```
public static final int COLOR_BayerRG2GRAY
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_BayerGR2GRAY
```
public static final int COLOR_BayerGR2GRAY
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_YUV2RGB_NV12
```
public static final int COLOR_YUV2RGB_NV12
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_YUV2BGR_NV12
```
public static final int COLOR_YUV2BGR_NV12
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_YUV2RGB_NV21
```
public static final int COLOR_YUV2RGB_NV21
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_YUV2BGR_NV21
```
public static final int COLOR_YUV2BGR_NV21
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_YUV420sp2RGB
```
public static final int COLOR_YUV420sp2RGB
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_YUV420sp2BGR
```
public static final int COLOR_YUV420sp2BGR
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_YUV2RGBA_NV12
```
public static final int COLOR_YUV2RGBA_NV12
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_YUV2BGRA_NV12
```
public static final int COLOR_YUV2BGRA_NV12
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_YUV2RGBA_NV21
```
public static final int COLOR_YUV2RGBA_NV21
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_YUV2BGRA_NV21
```
public static final int COLOR_YUV2BGRA_NV21
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_YUV420sp2RGBA
```
public static final int COLOR_YUV420sp2RGBA
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_YUV420sp2BGRA
```
public static final int COLOR_YUV420sp2BGRA
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_YUV2RGB_YV12
```
public static final int COLOR_YUV2RGB_YV12
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_YUV2BGR_YV12
```
public static final int COLOR_YUV2BGR_YV12
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_YUV2RGB_IYUV
```
public static final int COLOR_YUV2RGB_IYUV
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_YUV2BGR_IYUV
```
public static final int COLOR_YUV2BGR_IYUV
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_YUV2RGB_I420
```
public static final int COLOR_YUV2RGB_I420
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_YUV2BGR_I420
```
public static final int COLOR_YUV2BGR_I420
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_YUV420p2RGB
```
public static final int COLOR_YUV420p2RGB
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_YUV420p2BGR
```
public static final int COLOR_YUV420p2BGR
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_YUV2RGBA_YV12
```
public static final int COLOR_YUV2RGBA_YV12
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_YUV2BGRA_YV12
```
public static final int COLOR_YUV2BGRA_YV12
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_YUV2RGBA_IYUV
```
public static final int COLOR_YUV2RGBA_IYUV
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_YUV2BGRA_IYUV
```
public static final int COLOR_YUV2BGRA_IYUV
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_YUV2RGBA_I420
```
public static final int COLOR_YUV2RGBA_I420
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_YUV2BGRA_I420
```
public static final int COLOR_YUV2BGRA_I420
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_YUV420p2RGBA
```
public static final int COLOR_YUV420p2RGBA
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_YUV420p2BGRA
```
public static final int COLOR_YUV420p2BGRA
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_YUV2GRAY_420
```
public static final int COLOR_YUV2GRAY_420
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_YUV2GRAY_NV21
```
public static final int COLOR_YUV2GRAY_NV21
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_YUV2GRAY_NV12
```
public static final int COLOR_YUV2GRAY_NV12
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_YUV2GRAY_YV12
```
public static final int COLOR_YUV2GRAY_YV12
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_YUV2GRAY_IYUV
```
public static final int COLOR_YUV2GRAY_IYUV
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_YUV2GRAY_I420
```
public static final int COLOR_YUV2GRAY_I420
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_YUV420sp2GRAY
```
public static final int COLOR_YUV420sp2GRAY
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_YUV420p2GRAY
```
public static final int COLOR_YUV420p2GRAY
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_YUV2RGB_UYVY
```
public static final int COLOR_YUV2RGB_UYVY
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_YUV2BGR_UYVY
```
public static final int COLOR_YUV2BGR_UYVY
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_YUV2RGB_Y422
```
public static final int COLOR_YUV2RGB_Y422
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_YUV2BGR_Y422
```
public static final int COLOR_YUV2BGR_Y422
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_YUV2RGB_UYNV
```
public static final int COLOR_YUV2RGB_UYNV
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_YUV2BGR_UYNV
```
public static final int COLOR_YUV2BGR_UYNV
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_YUV2RGBA_UYVY
```
public static final int COLOR_YUV2RGBA_UYVY
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_YUV2BGRA_UYVY
```
public static final int COLOR_YUV2BGRA_UYVY
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_YUV2RGBA_Y422
```
public static final int COLOR_YUV2RGBA_Y422
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_YUV2BGRA_Y422
```
public static final int COLOR_YUV2BGRA_Y422
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_YUV2RGBA_UYNV
```
public static final int COLOR_YUV2RGBA_UYNV
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_YUV2BGRA_UYNV
```
public static final int COLOR_YUV2BGRA_UYNV
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_YUV2RGB_YUY2
```
public static final int COLOR_YUV2RGB_YUY2
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_YUV2BGR_YUY2
```
public static final int COLOR_YUV2BGR_YUY2
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_YUV2RGB_YVYU
```
public static final int COLOR_YUV2RGB_YVYU
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_YUV2BGR_YVYU
```
public static final int COLOR_YUV2BGR_YVYU
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_YUV2RGB_YUYV
```
public static final int COLOR_YUV2RGB_YUYV
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_YUV2BGR_YUYV
```
public static final int COLOR_YUV2BGR_YUYV
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_YUV2RGB_YUNV
```
public static final int COLOR_YUV2RGB_YUNV
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_YUV2BGR_YUNV
```
public static final int COLOR_YUV2BGR_YUNV
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_YUV2RGBA_YUY2
```
public static final int COLOR_YUV2RGBA_YUY2
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_YUV2BGRA_YUY2
```
public static final int COLOR_YUV2BGRA_YUY2
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_YUV2RGBA_YVYU
```
public static final int COLOR_YUV2RGBA_YVYU
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_YUV2BGRA_YVYU
```
public static final int COLOR_YUV2BGRA_YVYU
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_YUV2RGBA_YUYV
```
public static final int COLOR_YUV2RGBA_YUYV
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_YUV2BGRA_YUYV
```
public static final int COLOR_YUV2BGRA_YUYV
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_YUV2RGBA_YUNV
```
public static final int COLOR_YUV2RGBA_YUNV
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_YUV2BGRA_YUNV
```
public static final int COLOR_YUV2BGRA_YUNV
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_YUV2GRAY_UYVY
```
public static final int COLOR_YUV2GRAY_UYVY
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_YUV2GRAY_YUY2
```
public static final int COLOR_YUV2GRAY_YUY2
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_YUV2GRAY_Y422
```
public static final int COLOR_YUV2GRAY_Y422
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_YUV2GRAY_UYNV
```
public static final int COLOR_YUV2GRAY_UYNV
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_YUV2GRAY_YVYU
```
public static final int COLOR_YUV2GRAY_YVYU
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_YUV2GRAY_YUYV
```
public static final int COLOR_YUV2GRAY_YUYV
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_YUV2GRAY_YUNV
```
public static final int COLOR_YUV2GRAY_YUNV
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_RGBA2mRGBA
```
public static final int COLOR_RGBA2mRGBA
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_mRGBA2RGBA
```
public static final int COLOR_mRGBA2RGBA
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_RGB2YUV_I420
```
public static final int COLOR_RGB2YUV_I420
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_BGR2YUV_I420
```
public static final int COLOR_BGR2YUV_I420
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_RGB2YUV_IYUV
```
public static final int COLOR_RGB2YUV_IYUV
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_BGR2YUV_IYUV
```
public static final int COLOR_BGR2YUV_IYUV
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_RGBA2YUV_I420
```
public static final int COLOR_RGBA2YUV_I420
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_BGRA2YUV_I420
```
public static final int COLOR_BGRA2YUV_I420
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_RGBA2YUV_IYUV
```
public static final int COLOR_RGBA2YUV_IYUV
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_BGRA2YUV_IYUV
```
public static final int COLOR_BGRA2YUV_IYUV
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_RGB2YUV_YV12
```
public static final int COLOR_RGB2YUV_YV12
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_BGR2YUV_YV12
```
public static final int COLOR_BGR2YUV_YV12
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_RGBA2YUV_YV12
```
public static final int COLOR_RGBA2YUV_YV12
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_BGRA2YUV_YV12
```
public static final int COLOR_BGRA2YUV_YV12
```
  enum cv::
  
  See Also:
  Constant Field Values
- COLOR_COLORCVT_MAX
```
public static final int COLOR_COLORCVT_MAX
```
  enum cv::
  
  See Also:
  Constant Field Values
- TM_SQDIFF
```
public static final int TM_SQDIFF
```
  enum cv::
  
  See Also:
  Constant Field Values
- TM_SQDIFF_NORMED
```
public static final int TM_SQDIFF_NORMED
```
  enum cv::
  
  See Also:
  Constant Field Values
- TM_CCORR
```
public static final int TM_CCORR
```
  enum cv::
  
  See Also:
  Constant Field Values
- TM_CCORR_NORMED
```
public static final int TM_CCORR_NORMED
```
  enum cv::
  
  See Also:
  Constant Field Values
- TM_CCOEFF
```
public static final int TM_CCOEFF
```
  enum cv::
  
  See Also:
  Constant Field Values
- TM_CCOEFF_NORMED
```
public static final int TM_CCOEFF_NORMED
```
  enum cv::
  
  See Also:
  Constant Field Values
- RETR_EXTERNAL
```
public static final int RETR_EXTERNAL
```
  enum cv::
  
  See Also:
  Constant Field Values
- RETR_LIST
```
public static final int RETR_LIST
```
  enum cv::
  
  See Also:
  Constant Field Values
- RETR_CCOMP
```
public static final int RETR_CCOMP
```
  enum cv::
  
  See Also:
  Constant Field Values
- RETR_TREE
```
public static final int RETR_TREE
```
  enum cv::
  
  See Also:
  Constant Field Values
- RETR_FLOODFILL
```
public static final int RETR_FLOODFILL
```
  enum cv::
  
  See Also:
  Constant Field Values
- CHAIN_APPROX_NONE
```
public static final int CHAIN_APPROX_NONE
```
  enum cv::
  
  See Also:
  Constant Field Values
- CHAIN_APPROX_SIMPLE
```
public static final int CHAIN_APPROX_SIMPLE
```
  enum cv::
  
  See Also:
  Constant Field Values
- CHAIN_APPROX_TC89_L1
```
public static final int CHAIN_APPROX_TC89_L1
```
  enum cv::
  
  See Also:
  Constant Field Values
- CHAIN_APPROX_TC89_KCOS
```
public static final int CHAIN_APPROX_TC89_KCOS
```
  enum cv::
  
  See Also:
  Constant Field Values

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

Method Detail

cvAcc

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

Background statistics accumulation

cvAcc

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

cvSquareAcc

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

cvSquareAcc

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

cvMultiplyAcc

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

cvMultiplyAcc

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

cvRunningAvg

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

cvRunningAvg

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

cvCopyMakeBorder

public static void cvCopyMakeBorder(opencv_core.CvArr src,
                    opencv_core.CvArr dst,
                    opencv_core.CvPoint offset,
                    int bordertype,
                    opencv_core.CvScalar value)

\ Image Processing * \

cvCopyMakeBorder

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

cvCopyMakeBorder

public static void cvCopyMakeBorder(opencv_core.CvArr src,
                    opencv_core.CvArr dst,
                    IntBuffer offset,
                    int bordertype,
                    opencv_core.CvScalar value)

cvCopyMakeBorder

public static void cvCopyMakeBorder(opencv_core.CvArr src,
                    opencv_core.CvArr dst,
                    IntBuffer offset,
                    int bordertype)

cvCopyMakeBorder

public static void cvCopyMakeBorder(opencv_core.CvArr src,
                    opencv_core.CvArr dst,
                    int[] offset,
                    int bordertype,
                    opencv_core.CvScalar value)

cvCopyMakeBorder

public static void cvCopyMakeBorder(opencv_core.CvArr src,
                    opencv_core.CvArr dst,
                    int[] offset,
                    int bordertype)

cvSmooth

public static void cvSmooth(opencv_core.CvArr src,
            opencv_core.CvArr dst,
            int smoothtype,
            int size1,
            int size2,
            double sigma1,
            double sigma2)

cvSmooth

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

cvFilter2D

public static void cvFilter2D(opencv_core.CvArr src,
              opencv_core.CvArr dst,
              opencv_core.CvMat kernel,
              opencv_core.CvPoint anchor)

cvFilter2D

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

cvFilter2D

public static void cvFilter2D(opencv_core.CvArr src,
              opencv_core.CvArr dst,
              opencv_core.CvMat kernel,
              IntBuffer anchor)

cvFilter2D

public static void cvFilter2D(opencv_core.CvArr src,
              opencv_core.CvArr dst,
              opencv_core.CvMat kernel,
              int[] anchor)

cvIntegral

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

cvIntegral

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

cvPyrDown

public static void cvPyrDown(opencv_core.CvArr src,
             opencv_core.CvArr dst,
             int filter)

cvPyrDown

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

cvPyrUp

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

cvPyrUp

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

cvCreatePyramid

public 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)

cvCreatePyramid

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

cvReleasePyramid

public static void cvReleasePyramid(PointerPointer pyramid,
                    int extra_layers)

cvPyrMeanShiftFiltering

public static void cvPyrMeanShiftFiltering(opencv_core.CvArr src,
                           opencv_core.CvArr dst,
                           double sp,
                           double sr,
                           int max_level,
                           opencv_core.CvTermCriteria termcrit)

cvPyrMeanShiftFiltering

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

cvWatershed

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

cvSobel

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

cvSobel

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

cvLaplace

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

cvLaplace

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

cvCvtColor

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

cvResize

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

cvResize

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

cvWarpAffine

public static void cvWarpAffine(opencv_core.CvArr src,
                opencv_core.CvArr dst,
                opencv_core.CvMat map_matrix,
                int flags,
                opencv_core.CvScalar fillval)

cvWarpAffine

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

cvGetAffineTransform

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

cvGetAffineTransform

public static opencv_core.CvMat cvGetAffineTransform(FloatBuffer src,
                                     FloatBuffer dst,
                                     opencv_core.CvMat map_matrix)

cvGetAffineTransform

public static opencv_core.CvMat cvGetAffineTransform(float[] src,
                                     float[] dst,
                                     opencv_core.CvMat map_matrix)

cv2DRotationMatrix

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

cv2DRotationMatrix

public static opencv_core.CvMat cv2DRotationMatrix(FloatBuffer center,
                                   double angle,
                                   double scale,
                                   opencv_core.CvMat map_matrix)

cv2DRotationMatrix

public static opencv_core.CvMat cv2DRotationMatrix(float[] center,
                                   double angle,
                                   double scale,
                                   opencv_core.CvMat map_matrix)

cvWarpPerspective

public static void cvWarpPerspective(opencv_core.CvArr src,
                     opencv_core.CvArr dst,
                     opencv_core.CvMat map_matrix,
                     int flags,
                     opencv_core.CvScalar fillval)

cvWarpPerspective

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

cvGetPerspectiveTransform

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

cvGetPerspectiveTransform

public static opencv_core.CvMat cvGetPerspectiveTransform(FloatBuffer src,
                                          FloatBuffer dst,
                                          opencv_core.CvMat map_matrix)

cvGetPerspectiveTransform

public static opencv_core.CvMat cvGetPerspectiveTransform(float[] src,
                                          float[] dst,
                                          opencv_core.CvMat map_matrix)

cvRemap

public 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)

cvRemap

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

cvConvertMaps

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

cvLogPolar

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

cvLogPolar

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

cvLogPolar

public static void cvLogPolar(opencv_core.CvArr src,
              opencv_core.CvArr dst,
              FloatBuffer center,
              double M,
              int flags)

cvLogPolar

public static void cvLogPolar(opencv_core.CvArr src,
              opencv_core.CvArr dst,
              FloatBuffer center,
              double M)

cvLogPolar

public static void cvLogPolar(opencv_core.CvArr src,
              opencv_core.CvArr dst,
              float[] center,
              double M,
              int flags)

cvLogPolar

public static void cvLogPolar(opencv_core.CvArr src,
              opencv_core.CvArr dst,
              float[] center,
              double M)

cvLinearPolar

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

cvLinearPolar

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

cvLinearPolar

public static void cvLinearPolar(opencv_core.CvArr src,
                 opencv_core.CvArr dst,
                 FloatBuffer center,
                 double maxRadius,
                 int flags)

cvLinearPolar

public static void cvLinearPolar(opencv_core.CvArr src,
                 opencv_core.CvArr dst,
                 FloatBuffer center,
                 double maxRadius)

cvLinearPolar

public static void cvLinearPolar(opencv_core.CvArr src,
                 opencv_core.CvArr dst,
                 float[] center,
                 double maxRadius,
                 int flags)

cvLinearPolar

public static void cvLinearPolar(opencv_core.CvArr src,
                 opencv_core.CvArr dst,
                 float[] center,
                 double maxRadius)

cvUndistort2

public 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)

cvUndistort2

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

cvInitUndistortMap

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

cvInitUndistortRectifyMap

public 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)

cvUndistortPoints

public 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)

cvUndistortPoints

public static void cvUndistortPoints(opencv_core.CvMat src,
                     opencv_core.CvMat dst,
                     opencv_core.CvMat camera_matrix,
                     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)

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(PointerPointer element)

cvReleaseStructuringElement

public static void cvReleaseStructuringElement(opencv_core.IplConvKernel element)

cvErode

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

cvErode

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

cvDilate

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

cvDilate

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

cvMorphologyEx

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

cvMorphologyEx

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

cvMoments

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

cvMoments

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

cvGetSpatialMoment

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

cvGetCentralMoment

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

cvGetNormalizedCentralMoment

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

cvGetHuMoments

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

cvSampleLine

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

data sampling

cvSampleLine

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

cvSampleLine

public static int cvSampleLine(opencv_core.CvArr image,
               IntBuffer pt1,
               IntBuffer pt2,
               Pointer buffer,
               int connectivity)

cvSampleLine

public static int cvSampleLine(opencv_core.CvArr image,
               IntBuffer pt1,
               IntBuffer pt2,
               Pointer buffer)

cvSampleLine

public static int cvSampleLine(opencv_core.CvArr image,
               int[] pt1,
               int[] pt2,
               Pointer buffer,
               int connectivity)

cvSampleLine

public static int cvSampleLine(opencv_core.CvArr image,
               int[] pt1,
               int[] pt2,
               Pointer buffer)

cvGetRectSubPix

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

cvGetRectSubPix

public static void cvGetRectSubPix(opencv_core.CvArr src,
                   opencv_core.CvArr dst,
                   FloatBuffer center)

cvGetRectSubPix

public static void cvGetRectSubPix(opencv_core.CvArr src,
                   opencv_core.CvArr dst,
                   float[] center)

cvGetQuadrangleSubPix

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

cvMatchTemplate

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

cvCalcEMD2

public 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)

cvCalcEMD2

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

cvCalcEMD2

public 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)

cvCalcEMD2

public 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)

cvFindContours

public 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)

\ Contours retrieving * \

cvFindContours

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

cvFindContours

public 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)

cvFindContours

public 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)

cvFindContours

public 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)

cvStartFindContours

public static opencv_imgproc.CvContourScanner cvStartFindContours(opencv_core.CvArr image,
                                                  opencv_core.CvMemStorage storage,
                                                  int header_size,
                                                  int mode,
                                                  int method,
                                                  opencv_core.CvPoint offset)

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,
                                                  IntBuffer offset)

cvStartFindContours

public static opencv_imgproc.CvContourScanner cvStartFindContours(opencv_core.CvArr image,
                                                  opencv_core.CvMemStorage storage,
                                                  int header_size,
                                                  int mode,
                                                  int method,
                                                  int[] offset)

cvFindNextContour

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

cvSubstituteContour

public static void cvSubstituteContour(opencv_imgproc.CvContourScanner scanner,
                       opencv_core.CvSeq new_contour)

cvEndFindContours

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

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)

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)

cvReadChainPoint

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

cvApproxPoly

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

\ Contour Processing and Shape Analysis * \

cvApproxPoly

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

cvArcLength

public static double cvArcLength(Pointer curve,
                 opencv_core.CvSlice slice,
                 int is_closed)

cvArcLength

public static double cvArcLength(Pointer curve)

cvContourPerimeter

public static double cvContourPerimeter(Pointer contour)

cvBoundingRect

public static opencv_core.CvRect cvBoundingRect(opencv_core.CvArr points,
                                int update)

cvBoundingRect

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

cvContourArea

public static double cvContourArea(opencv_core.CvArr contour,
                   opencv_core.CvSlice slice,
                   int oriented)

cvContourArea

public static double cvContourArea(opencv_core.CvArr contour)

cvMinAreaRect2

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

cvMinAreaRect2

public static opencv_core.CvBox2D cvMinAreaRect2(opencv_core.CvArr points)

cvMinEnclosingCircle

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

cvMinEnclosingCircle

public static int cvMinEnclosingCircle(opencv_core.CvArr points,
                       FloatBuffer center,
                       FloatBuffer radius)

cvMinEnclosingCircle

public static int cvMinEnclosingCircle(opencv_core.CvArr points,
                       float[] center,
                       float[] radius)

cvMatchShapes

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

cvMatchShapes

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

cvConvexHull2

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

cvConvexHull2

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

cvCheckContourConvexity

public static int cvCheckContourConvexity(opencv_core.CvArr contour)

cvConvexityDefects

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

cvConvexityDefects

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

cvFitEllipse2

public static opencv_core.CvBox2D cvFitEllipse2(opencv_core.CvArr points)

cvMaxRect

public static opencv_core.CvRect cvMaxRect(opencv_core.CvRect rect1,
                           opencv_core.CvRect rect2)

cvBoxPoints

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

cvBoxPoints

public static void cvBoxPoints(opencv_core.CvBox2D box,
               FloatBuffer pt)

cvBoxPoints

public static void cvBoxPoints(opencv_core.CvBox2D box,
               float[] pt)

cvPointSeqFromMat

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

cvPointPolygonTest

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

cvPointPolygonTest

public static double cvPointPolygonTest(opencv_core.CvArr contour,
                        FloatBuffer pt,
                        int measure_dist)

cvPointPolygonTest

public static double cvPointPolygonTest(opencv_core.CvArr contour,
                        float[] pt,
                        int measure_dist)

cvCreateHist

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

\ Histogram functions * \

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,
                                   FloatPointer ranges,
                                   int uniform)

cvCreateHist

public static opencv_core.CvHistogram cvCreateHist(int dims,
                                   IntBuffer sizes,
                                   int type,
                                   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,
                                   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,
                      PointerPointer ranges,
                      int uniform)

cvSetHistBinRanges

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

cvSetHistBinRanges

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

cvSetHistBinRanges

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

cvSetHistBinRanges

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

cvSetHistBinRanges

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

cvSetHistBinRanges

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

cvMakeHistHeaderForArray

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

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,
                                               FloatPointer ranges,
                                               int uniform)

cvMakeHistHeaderForArray

public static opencv_core.CvHistogram cvMakeHistHeaderForArray(int dims,
                                               IntBuffer sizes,
                                               opencv_core.CvHistogram hist,
                                               FloatBuffer data,
                                               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,
                                               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(PointerPointer hist)

cvReleaseHist

public static void cvReleaseHist(opencv_core.CvHistogram hist)

cvClearHist

public static void cvClearHist(opencv_core.CvHistogram hist)

cvGetMinMaxHistValue

public static void cvGetMinMaxHistValue(opencv_core.CvHistogram hist,
                        FloatPointer min_value,
                        FloatPointer max_value,
                        IntPointer min_idx,
                        IntPointer max_idx)

cvGetMinMaxHistValue

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

cvGetMinMaxHistValue

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

cvGetMinMaxHistValue

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

cvGetMinMaxHistValue

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

cvGetMinMaxHistValue

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

cvNormalizeHist

public static void cvNormalizeHist(opencv_core.CvHistogram hist,
                   double factor)

cvThreshHist

public static void cvThreshHist(opencv_core.CvHistogram hist,
                double threshold)

cvCompareHist

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

cvCopyHist

public static void cvCopyHist(opencv_core.CvHistogram src,
              PointerPointer dst)

cvCopyHist

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

cvCalcBayesianProb

public static void cvCalcBayesianProb(PointerPointer src,
                      int number,
                      PointerPointer dst)

cvCalcBayesianProb

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

cvCalcArrHist

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

cvCalcArrHist

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

cvCalcArrHist

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

cvCalcHist

public static void cvCalcHist(PointerPointer image,
              opencv_core.CvHistogram hist,
              int accumulate,
              opencv_core.CvArr mask)

cvCalcHist

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

cvCalcHist

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

cvCalcArrBackProject

public static void cvCalcArrBackProject(PointerPointer image,
                        opencv_core.CvArr dst,
                        opencv_core.CvHistogram hist)

cvCalcArrBackProject

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

cvCalcBackProject

public static void cvCalcBackProject(PointerPointer image,
                     opencv_core.CvArr dst,
                     opencv_core.CvHistogram hist)

cvCalcBackProject

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

cvCalcArrBackProjectPatch

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

cvCalcArrBackProjectPatch

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

cvCalcBackProjectPatch

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

cvCalcBackProjectPatch

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

cvCalcProbDensity

public static void cvCalcProbDensity(opencv_core.CvHistogram hist1,
                     opencv_core.CvHistogram hist2,
                     opencv_core.CvHistogram dst_hist,
                     double scale)

cvCalcProbDensity

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

cvEqualizeHist

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

cvDistTransform

public 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)

cvDistTransform

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

cvDistTransform

public 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)

cvDistTransform

public 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)

cvThreshold

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

cvAdaptiveThreshold

public 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)

cvAdaptiveThreshold

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

cvFloodFill

public 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)

cvFloodFill

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

cvFloodFill

public 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)

cvFloodFill

public static void cvFloodFill(opencv_core.CvArr image,
               IntBuffer seed_point,
               opencv_core.CvScalar new_val)

cvFloodFill

public 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)

cvFloodFill

public static void cvFloodFill(opencv_core.CvArr image,
               int[] seed_point,
               opencv_core.CvScalar new_val)

cvCanny

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

\ Feature detection * \

cvCanny

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

cvPreCornerDetect

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

cvPreCornerDetect

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

cvCornerEigenValsAndVecs

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

cvCornerEigenValsAndVecs

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

cvCornerMinEigenVal

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

cvCornerMinEigenVal

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

cvCornerHarris

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

cvCornerHarris

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

cvFindCornerSubPix

public 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)

cvFindCornerSubPix

public static void cvFindCornerSubPix(opencv_core.CvArr image,
                      FloatBuffer corners,
                      int count,
                      opencv_core.CvSize win,
                      opencv_core.CvSize zero_zone,
                      opencv_core.CvTermCriteria criteria)

cvFindCornerSubPix

public static void cvFindCornerSubPix(opencv_core.CvArr image,
                      float[] corners,
                      int count,
                      opencv_core.CvSize win,
                      opencv_core.CvSize zero_zone,
                      opencv_core.CvTermCriteria criteria)

cvGoodFeaturesToTrack

public 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)

cvGoodFeaturesToTrack

public 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)

cvGoodFeaturesToTrack

public 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)

cvGoodFeaturesToTrack

public 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)

cvGoodFeaturesToTrack

public 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)

cvGoodFeaturesToTrack

public 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)

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)

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)

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(opencv_core.CvArr points,
             int dist_type,
             double param,
             double reps,
             double aeps,
             FloatPointer line)

cvFitLine

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

cvFitLine

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

borderInterpolate
```
public static int borderInterpolate(int p,
                    int len,
                    int borderType)
```
1D interpolation function: returns coordinate of the "donor" pixel for the specified location p.

getKernelType

public static int getKernelType(opencv_core.Mat kernel,
                opencv_core.Point anchor)

returns type (one of KERNEL_*) of 1D or 2D kernel specified by its coefficients.

getLinearRowFilter

public static opencv_imgproc.BaseRowFilter getLinearRowFilter(int srcType,
                                              int bufType,
                                              opencv_core.Mat kernel,
                                              int anchor,
                                              int symmetryType)

returns the primitive row filter with the specified kernel

getLinearColumnFilter

public static opencv_imgproc.BaseColumnFilter getLinearColumnFilter(int bufType,
                                                    int dstType,
                                                    opencv_core.Mat kernel,
                                                    int anchor,
                                                    int symmetryType,
                                                    double delta,
                                                    int bits)

returns the primitive column filter with the specified kernel

getLinearColumnFilter

public static opencv_imgproc.BaseColumnFilter getLinearColumnFilter(int bufType,
                                                    int dstType,
                                                    opencv_core.Mat kernel,
                                                    int anchor,
                                                    int symmetryType)

getLinearFilter

public static opencv_imgproc.BaseFilter getLinearFilter(int srcType,
                                        int dstType,
                                        opencv_core.Mat kernel,
                                        opencv_core.Point anchor,
                                        double delta,
                                        int bits)

returns 2D filter with the specified kernel

getLinearFilter

public static opencv_imgproc.BaseFilter getLinearFilter(int srcType,
                                        int dstType,
                                        opencv_core.Mat kernel)

createSeparableLinearFilter

public static opencv_imgproc.FilterEngine createSeparableLinearFilter(int srcType,
                                                      int dstType,
                                                      opencv_core.Mat rowKernel,
                                                      opencv_core.Mat columnKernel,
                                                      opencv_core.Point anchor,
                                                      double delta,
                                                      int rowBorderType,
                                                      int columnBorderType,
                                                      opencv_core.Scalar borderValue)

returns the separable linear filter engine

createSeparableLinearFilter

public static opencv_imgproc.FilterEngine createSeparableLinearFilter(int srcType,
                                                      int dstType,
                                                      opencv_core.Mat rowKernel,
                                                      opencv_core.Mat columnKernel)

createLinearFilter

public static opencv_imgproc.FilterEngine createLinearFilter(int srcType,
                                             int dstType,
                                             opencv_core.Mat kernel,
                                             opencv_core.Point _anchor,
                                             double delta,
                                             int rowBorderType,
                                             int columnBorderType,
                                             opencv_core.Scalar borderValue)

returns the non-separable linear filter engine

createLinearFilter

public static opencv_imgproc.FilterEngine createLinearFilter(int srcType,
                                             int dstType,
                                             opencv_core.Mat kernel)

getGaussianKernel

public static opencv_core.Mat getGaussianKernel(int ksize,
                                double sigma,
                                int ktype)

returns the Gaussian kernel with the specified parameters

getGaussianKernel

public static opencv_core.Mat getGaussianKernel(int ksize,
                                double sigma)

createGaussianFilter

public static opencv_imgproc.FilterEngine createGaussianFilter(int type,
                                               opencv_core.Size ksize,
                                               double sigma1,
                                               double sigma2,
                                               int borderType)

returns the Gaussian filter engine

createGaussianFilter

public static opencv_imgproc.FilterEngine createGaussianFilter(int type,
                                               opencv_core.Size ksize,
                                               double sigma1)

getDerivKernels

public static void getDerivKernels(opencv_core.Mat kx,
                   opencv_core.Mat ky,
                   int dx,
                   int dy,
                   int ksize,
                   boolean normalize,
                   int ktype)

initializes kernels of the generalized Sobel operator

getDerivKernels

public static void getDerivKernels(opencv_core.Mat kx,
                   opencv_core.Mat ky,
                   int dx,
                   int dy,
                   int ksize)

createDerivFilter

public static opencv_imgproc.FilterEngine createDerivFilter(int srcType,
                                            int dstType,
                                            int dx,
                                            int dy,
                                            int ksize,
                                            int borderType)

returns filter engine for the generalized Sobel operator

createDerivFilter

public static opencv_imgproc.FilterEngine createDerivFilter(int srcType,
                                            int dstType,
                                            int dx,
                                            int dy,
                                            int ksize)

getRowSumFilter

public static opencv_imgproc.BaseRowFilter getRowSumFilter(int srcType,
                                           int sumType,
                                           int ksize,
                                           int anchor)

returns horizontal 1D box filter

getRowSumFilter

public static opencv_imgproc.BaseRowFilter getRowSumFilter(int srcType,
                                           int sumType,
                                           int ksize)

getColumnSumFilter

public static opencv_imgproc.BaseColumnFilter getColumnSumFilter(int sumType,
                                                 int dstType,
                                                 int ksize,
                                                 int anchor,
                                                 double scale)

returns vertical 1D box filter

getColumnSumFilter

public static opencv_imgproc.BaseColumnFilter getColumnSumFilter(int sumType,
                                                 int dstType,
                                                 int ksize)

createBoxFilter

public static opencv_imgproc.FilterEngine createBoxFilter(int srcType,
                                          int dstType,
                                          opencv_core.Size ksize,
                                          opencv_core.Point anchor,
                                          boolean normalize,
                                          int borderType)

returns box filter engine

createBoxFilter

public static opencv_imgproc.FilterEngine createBoxFilter(int srcType,
                                          int dstType,
                                          opencv_core.Size ksize)

getGaborKernel

public static opencv_core.Mat getGaborKernel(opencv_core.Size ksize,
                             double sigma,
                             double theta,
                             double lambd,
                             double gamma,
                             double psi,
                             int ktype)

returns the Gabor kernel with the specified parameters

getGaborKernel

public static opencv_core.Mat getGaborKernel(opencv_core.Size ksize,
                             double sigma,
                             double theta,
                             double lambd,
                             double gamma)

getMorphologyRowFilter

public static opencv_imgproc.BaseRowFilter getMorphologyRowFilter(int op,
                                                  int type,
                                                  int ksize,
                                                  int anchor)

returns horizontal 1D morphological filter

getMorphologyRowFilter

public static opencv_imgproc.BaseRowFilter getMorphologyRowFilter(int op,
                                                  int type,
                                                  int ksize)

getMorphologyColumnFilter

public static opencv_imgproc.BaseColumnFilter getMorphologyColumnFilter(int op,
                                                        int type,
                                                        int ksize,
                                                        int anchor)

returns vertical 1D morphological filter

getMorphologyColumnFilter

public static opencv_imgproc.BaseColumnFilter getMorphologyColumnFilter(int op,
                                                        int type,
                                                        int ksize)

getMorphologyFilter

public static opencv_imgproc.BaseFilter getMorphologyFilter(int op,
                                            int type,
                                            opencv_core.Mat kernel,
                                            opencv_core.Point anchor)

returns 2D morphological filter

getMorphologyFilter

public static opencv_imgproc.BaseFilter getMorphologyFilter(int op,
                                            int type,
                                            opencv_core.Mat kernel)

morphologyDefaultBorderValue
```
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.

createMorphologyFilter

public static opencv_imgproc.FilterEngine createMorphologyFilter(int op,
                                                 int type,
                                                 opencv_core.Mat kernel,
                                                 opencv_core.Point anchor,
                                                 int rowBorderType,
                                                 int columnBorderType,
                                                 opencv_core.Scalar borderValue)

returns morphological filter engine. Only MORPH_ERODE and MORPH_DILATE are supported.

createMorphologyFilter

public static opencv_imgproc.FilterEngine createMorphologyFilter(int op,
                                                 int type,
                                                 opencv_core.Mat kernel)

getStructuringElement

public static opencv_core.Mat getStructuringElement(int shape,
                                    opencv_core.Size ksize,
                                    opencv_core.Point anchor)

returns structuring element of the specified shape and size

getStructuringElement

public static opencv_core.Mat getStructuringElement(int shape,
                                    opencv_core.Size ksize)

copyMakeBorder

public static void copyMakeBorder(opencv_core.Mat src,
                  opencv_core.Mat dst,
                  int top,
                  int bottom,
                  int left,
                  int right,
                  int borderType,
                  opencv_core.Scalar value)

copies 2D array to a larger destination array with extrapolation of the outer part of src using the specified border mode

copyMakeBorder

public static void copyMakeBorder(opencv_core.Mat src,
                  opencv_core.Mat dst,
                  int top,
                  int bottom,
                  int left,
                  int right,
                  int borderType)

medianBlur

public static void medianBlur(opencv_core.Mat src,
              opencv_core.Mat dst,
              int ksize)

smooths the image using median filter.

GaussianBlur

public static void GaussianBlur(opencv_core.Mat src,
                opencv_core.Mat dst,
                opencv_core.Size ksize,
                double sigmaX,
                double sigmaY,
                int borderType)

smooths the image using Gaussian filter.

GaussianBlur

public static void GaussianBlur(opencv_core.Mat src,
                opencv_core.Mat dst,
                opencv_core.Size ksize,
                double sigmaX)

bilateralFilter

public static void bilateralFilter(opencv_core.Mat src,
                   opencv_core.Mat dst,
                   int d,
                   double sigmaColor,
                   double sigmaSpace,
                   int borderType)

smooths the image using bilateral filter

bilateralFilter

public static void bilateralFilter(opencv_core.Mat src,
                   opencv_core.Mat dst,
                   int d,
                   double sigmaColor,
                   double sigmaSpace)

adaptiveBilateralFilter

public static void adaptiveBilateralFilter(opencv_core.Mat src,
                           opencv_core.Mat dst,
                           opencv_core.Size ksize,
                           double sigmaSpace,
                           double maxSigmaColor,
                           opencv_core.Point anchor,
                           int borderType)

smooths the image using adaptive bilateral filter

adaptiveBilateralFilter

public static void adaptiveBilateralFilter(opencv_core.Mat src,
                           opencv_core.Mat dst,
                           opencv_core.Size ksize,
                           double sigmaSpace)

boxFilter

public 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)

smooths the image using the box filter. Each pixel is processed in O(1) time

boxFilter

public static void boxFilter(opencv_core.Mat src,
             opencv_core.Mat dst,
             int ddepth,
             opencv_core.Size ksize)

blur

public static void blur(opencv_core.Mat src,
        opencv_core.Mat dst,
        opencv_core.Size ksize,
        opencv_core.Point anchor,
        int borderType)

a synonym for normalized box filter

blur

public static void blur(opencv_core.Mat src,
        opencv_core.Mat dst,
        opencv_core.Size ksize)

filter2D

public 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)

applies non-separable 2D linear filter to the image

filter2D

public static void filter2D(opencv_core.Mat src,
            opencv_core.Mat dst,
            int ddepth,
            opencv_core.Mat kernel)

sepFilter2D

public 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)

applies separable 2D linear filter to the image

sepFilter2D

public static void sepFilter2D(opencv_core.Mat src,
               opencv_core.Mat dst,
               int ddepth,
               opencv_core.Mat kernelX,
               opencv_core.Mat kernelY)

Sobel

public 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)

applies generalized Sobel operator to the image

Sobel

public static void Sobel(opencv_core.Mat src,
         opencv_core.Mat dst,
         int ddepth,
         int dx,
         int dy)

Scharr

public static void Scharr(opencv_core.Mat src,
          opencv_core.Mat dst,
          int ddepth,
          int dx,
          int dy,
          double scale,
          double delta,
          int borderType)

applies the vertical or horizontal Scharr operator to the image

Scharr

public static void Scharr(opencv_core.Mat src,
          opencv_core.Mat dst,
          int ddepth,
          int dx,
          int dy)

Laplacian

public static void Laplacian(opencv_core.Mat src,
             opencv_core.Mat dst,
             int ddepth,
             int ksize,
             double scale,
             double delta,
             int borderType)

applies Laplacian operator to the image

Laplacian

public static void Laplacian(opencv_core.Mat src,
             opencv_core.Mat dst,
             int ddepth)

Canny

public static void Canny(opencv_core.Mat image,
         opencv_core.Mat edges,
         double threshold1,
         double threshold2,
         int apertureSize,
         boolean L2gradient)

applies Canny edge detector and produces the edge map.

Canny

public static void Canny(opencv_core.Mat image,
         opencv_core.Mat edges,
         double threshold1,
         double threshold2)

cornerMinEigenVal

public static void cornerMinEigenVal(opencv_core.Mat src,
                     opencv_core.Mat dst,
                     int blockSize,
                     int ksize,
                     int borderType)

computes minimum eigen value of 2x2 derivative covariation matrix at each pixel - the cornerness criteria

cornerMinEigenVal

public static void cornerMinEigenVal(opencv_core.Mat src,
                     opencv_core.Mat dst,
                     int blockSize)

cornerHarris

public static void cornerHarris(opencv_core.Mat src,
                opencv_core.Mat dst,
                int blockSize,
                int ksize,
                double k,
                int borderType)

computes Harris cornerness criteria at each image pixel

cornerHarris

public static void cornerHarris(opencv_core.Mat src,
                opencv_core.Mat dst,
                int blockSize,
                int ksize,
                double k)

eigen2x2

public static void eigen2x2(FloatPointer a,
            FloatPointer e,
            int n)

eigen2x2

public static void eigen2x2(FloatBuffer a,
            FloatBuffer e,
            int n)

eigen2x2

public static void eigen2x2(float[] a,
            float[] e,
            int n)

cornerEigenValsAndVecs

public static void cornerEigenValsAndVecs(opencv_core.Mat src,
                          opencv_core.Mat dst,
                          int blockSize,
                          int ksize,
                          int borderType)

computes both eigenvalues and the eigenvectors of 2x2 derivative covariation matrix at each pixel. The output is stored as 6-channel matrix.

cornerEigenValsAndVecs

public static void cornerEigenValsAndVecs(opencv_core.Mat src,
                          opencv_core.Mat dst,
                          int blockSize,
                          int ksize)

preCornerDetect

public static void preCornerDetect(opencv_core.Mat src,
                   opencv_core.Mat dst,
                   int ksize,
                   int borderType)

computes another complex cornerness criteria at each pixel

preCornerDetect

public static void preCornerDetect(opencv_core.Mat src,
                   opencv_core.Mat dst,
                   int ksize)

cornerSubPix

public static void cornerSubPix(opencv_core.Mat image,
                opencv_core.Mat corners,
                opencv_core.Size winSize,
                opencv_core.Size zeroZone,
                opencv_core.TermCriteria criteria)

adjusts the corner locations with sub-pixel accuracy to maximize the certain cornerness criteria

goodFeaturesToTrack

public 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)

finds the strong enough corners where the cornerMinEigenVal() or cornerHarris() report the local maxima

goodFeaturesToTrack

public static void goodFeaturesToTrack(opencv_core.Mat image,
                       opencv_core.Mat corners,
                       int maxCorners,
                       double qualityLevel,
                       double minDistance)

HoughLines

public static void HoughLines(opencv_core.Mat image,
              opencv_core.Mat lines,
              double rho,
              double theta,
              int threshold,
              double srn,
              double stn)

finds lines in the black-n-white image using the standard or pyramid Hough transform

HoughLines

public static void HoughLines(opencv_core.Mat image,
              opencv_core.Mat lines,
              double rho,
              double theta,
              int threshold)

HoughLinesP

public static void HoughLinesP(opencv_core.Mat image,
               opencv_core.Mat lines,
               double rho,
               double theta,
               int threshold,
               double minLineLength,
               double maxLineGap)

finds line segments in the black-n-white image using probabilistic Hough transform

HoughLinesP

public static void HoughLinesP(opencv_core.Mat image,
               opencv_core.Mat lines,
               double rho,
               double theta,
               int threshold)

HoughCircles

public 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)

finds circles in the grayscale image using 2+1 gradient Hough transform

HoughCircles

public static void HoughCircles(opencv_core.Mat image,
                opencv_core.Mat circles,
                int method,
                double dp,
                double minDist)

erode

public 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)

erodes the image (applies the local minimum operator)

erode

public static void erode(opencv_core.Mat src,
         opencv_core.Mat dst,
         opencv_core.Mat kernel)

dilate

public 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)

dilates the image (applies the local maximum operator)

dilate

public static void dilate(opencv_core.Mat src,
          opencv_core.Mat dst,
          opencv_core.Mat kernel)

morphologyEx

public 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)

applies an advanced morphological operation to the image

morphologyEx

public static void morphologyEx(opencv_core.Mat src,
                opencv_core.Mat dst,
                int op,
                opencv_core.Mat kernel)

resize

public static void resize(opencv_core.Mat src,
          opencv_core.Mat dst,
          opencv_core.Size dsize,
          double fx,
          double fy,
          int interpolation)

resizes the image

resize

public static void resize(opencv_core.Mat src,
          opencv_core.Mat dst,
          opencv_core.Size dsize)

warpAffine

public 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)

warps the image using affine transformation

warpAffine

public static void warpAffine(opencv_core.Mat src,
              opencv_core.Mat dst,
              opencv_core.Mat M,
              opencv_core.Size dsize)

warpPerspective

public 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)

warps the image using perspective transformation

warpPerspective

public static void warpPerspective(opencv_core.Mat src,
                   opencv_core.Mat dst,
                   opencv_core.Mat M,
                   opencv_core.Size dsize)

remap

public 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)

warps the image using the precomputed maps. The maps are stored in either floating-point or integer fixed-point format

remap

public static void remap(opencv_core.Mat src,
         opencv_core.Mat dst,
         opencv_core.Mat map1,
         opencv_core.Mat map2,
         int interpolation)

convertMaps

public static void convertMaps(opencv_core.Mat map1,
               opencv_core.Mat map2,
               opencv_core.Mat dstmap1,
               opencv_core.Mat dstmap2,
               int dstmap1type,
               boolean nninterpolation)

converts maps for remap from floating-point to fixed-point format or backwards

convertMaps

public static void convertMaps(opencv_core.Mat map1,
               opencv_core.Mat map2,
               opencv_core.Mat dstmap1,
               opencv_core.Mat dstmap2,
               int dstmap1type)

getRotationMatrix2D

public static opencv_core.Mat getRotationMatrix2D(opencv_core.Point2f center,
                                  double angle,
                                  double scale)

returns 2x3 affine transformation matrix for the planar rotation.

getPerspectiveTransform

public static opencv_core.Mat getPerspectiveTransform(opencv_core.Point2f src,
                                      opencv_core.Point2f dst)

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

getAffineTransform

public static opencv_core.Mat getAffineTransform(opencv_core.Point2f src,
                                 opencv_core.Point2f dst)

returns 2x3 affine transformation for the corresponding 3 point pairs.

invertAffineTransform

public static void invertAffineTransform(opencv_core.Mat M,
                         opencv_core.Mat iM)

computes 2x3 affine transformation matrix that is inverse to the specified 2x3 affine transformation.

getPerspectiveTransform

public static opencv_core.Mat getPerspectiveTransform(opencv_core.Mat src,
                                      opencv_core.Mat dst)

getAffineTransform

public static opencv_core.Mat getAffineTransform(opencv_core.Mat src,
                                 opencv_core.Mat dst)

getRectSubPix

public static void getRectSubPix(opencv_core.Mat image,
                 opencv_core.Size patchSize,
                 opencv_core.Point2f center,
                 opencv_core.Mat patch,
                 int patchType)

extracts rectangle from the image at sub-pixel location

getRectSubPix

public static void getRectSubPix(opencv_core.Mat image,
                 opencv_core.Size patchSize,
                 opencv_core.Point2f center,
                 opencv_core.Mat patch)

integral

public static void integral(opencv_core.Mat src,
            opencv_core.Mat sum,
            int sdepth)

computes the integral image

integral

public static void integral(opencv_core.Mat src,
            opencv_core.Mat sum)

integral2

public static void integral2(opencv_core.Mat src,
             opencv_core.Mat sum,
             opencv_core.Mat sqsum,
             int sdepth)

computes the integral image and integral for the squared image

integral2

public static void integral2(opencv_core.Mat src,
             opencv_core.Mat sum,
             opencv_core.Mat sqsum)

integral3

public static void integral3(opencv_core.Mat src,
             opencv_core.Mat sum,
             opencv_core.Mat sqsum,
             opencv_core.Mat tilted,
             int sdepth)

computes the integral image, integral for the squared image and the tilted integral image

integral3

public static void integral3(opencv_core.Mat src,
             opencv_core.Mat sum,
             opencv_core.Mat sqsum,
             opencv_core.Mat tilted)

accumulate

public static void accumulate(opencv_core.Mat src,
              opencv_core.Mat dst,
              opencv_core.Mat mask)

adds image to the accumulator (dst += src). Unlike cv::add, dst and src can have different types.

accumulate

public static void accumulate(opencv_core.Mat src,
              opencv_core.Mat dst)

accumulateSquare

public static void accumulateSquare(opencv_core.Mat src,
                    opencv_core.Mat dst,
                    opencv_core.Mat mask)

adds squared src image to the accumulator (dst += src*src).

accumulateSquare

public static void accumulateSquare(opencv_core.Mat src,
                    opencv_core.Mat dst)

accumulateProduct

public static void accumulateProduct(opencv_core.Mat src1,
                     opencv_core.Mat src2,
                     opencv_core.Mat dst,
                     opencv_core.Mat mask)

adds product of the 2 images to the accumulator (dst += src1*src2).

accumulateProduct

public static void accumulateProduct(opencv_core.Mat src1,
                     opencv_core.Mat src2,
                     opencv_core.Mat dst)

accumulateWeighted

public static void accumulateWeighted(opencv_core.Mat src,
                      opencv_core.Mat dst,
                      double alpha,
                      opencv_core.Mat mask)

updates the running average (dst = dst*(1-alpha) + src*alpha)

accumulateWeighted

public static void accumulateWeighted(opencv_core.Mat src,
                      opencv_core.Mat dst,
                      double alpha)

PSNR

public static double PSNR(opencv_core.Mat src1,
          opencv_core.Mat src2)

computes PSNR image/video quality metric

phaseCorrelate

public static opencv_core.Point2d phaseCorrelate(opencv_core.Mat src1,
                                 opencv_core.Mat src2,
                                 opencv_core.Mat window)

phaseCorrelate

public static opencv_core.Point2d phaseCorrelate(opencv_core.Mat src1,
                                 opencv_core.Mat src2)

phaseCorrelateRes

public static opencv_core.Point2d phaseCorrelateRes(opencv_core.Mat src1,
                                    opencv_core.Mat src2,
                                    opencv_core.Mat window,
                                    DoublePointer response)

phaseCorrelateRes

public static opencv_core.Point2d phaseCorrelateRes(opencv_core.Mat src1,
                                    opencv_core.Mat src2,
                                    opencv_core.Mat window)

phaseCorrelateRes

public static opencv_core.Point2d phaseCorrelateRes(opencv_core.Mat src1,
                                    opencv_core.Mat src2,
                                    opencv_core.Mat window,
                                    DoubleBuffer response)

phaseCorrelateRes

public static opencv_core.Point2d phaseCorrelateRes(opencv_core.Mat src1,
                                    opencv_core.Mat src2,
                                    opencv_core.Mat window,
                                    double[] response)

createHanningWindow

public static void createHanningWindow(opencv_core.Mat dst,
                       opencv_core.Size winSize,
                       int type)

threshold

public static double threshold(opencv_core.Mat src,
               opencv_core.Mat dst,
               double thresh,
               double maxval,
               int type)

applies fixed threshold to the image

adaptiveThreshold

public static void adaptiveThreshold(opencv_core.Mat src,
                     opencv_core.Mat dst,
                     double maxValue,
                     int adaptiveMethod,
                     int thresholdType,
                     int blockSize,
                     double C)

applies variable (adaptive) threshold to the image

pyrDown

public static void pyrDown(opencv_core.Mat src,
           opencv_core.Mat dst,
           opencv_core.Size dstsize,
           int borderType)

smooths and downsamples the image

pyrDown

public static void pyrDown(opencv_core.Mat src,
           opencv_core.Mat dst)

pyrUp

public static void pyrUp(opencv_core.Mat src,
         opencv_core.Mat dst,
         opencv_core.Size dstsize,
         int borderType)

upsamples and smoothes the image

pyrUp

public static void pyrUp(opencv_core.Mat src,
         opencv_core.Mat dst)

buildPyramid

public static void buildPyramid(opencv_core.Mat src,
                opencv_core.MatVector dst,
                int maxlevel,
                int borderType)

builds the gaussian pyramid using pyrDown() as a basic operation

buildPyramid

public static void buildPyramid(opencv_core.Mat src,
                opencv_core.MatVector dst,
                int maxlevel)

undistort

public static void undistort(opencv_core.Mat src,
             opencv_core.Mat dst,
             opencv_core.Mat cameraMatrix,
             opencv_core.Mat distCoeffs,
             opencv_core.Mat newCameraMatrix)

corrects lens distortion for the given camera matrix and distortion coefficients

undistort

public static void undistort(opencv_core.Mat src,
             opencv_core.Mat dst,
             opencv_core.Mat cameraMatrix,
             opencv_core.Mat distCoeffs)

initUndistortRectifyMap

public 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)

initializes maps for cv::remap() to correct lens distortion and optionally rectify the image

initWideAngleProjMap

public 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

initWideAngleProjMap

public 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)

getDefaultNewCameraMatrix

public static opencv_core.Mat getDefaultNewCameraMatrix(opencv_core.Mat cameraMatrix,
                                        opencv_core.Size imgsize,
                                        boolean centerPrincipalPoint)

returns the default new camera matrix (by default it is the same as cameraMatrix unless centerPricipalPoint=true)

getDefaultNewCameraMatrix

public static opencv_core.Mat getDefaultNewCameraMatrix(opencv_core.Mat cameraMatrix)

undistortPoints

public 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)

returns points' coordinates after lens distortion correction

undistortPoints

public static void undistortPoints(opencv_core.Mat src,
                   opencv_core.Mat dst,
                   opencv_core.Mat cameraMatrix,
                   opencv_core.Mat distCoeffs)

calcHist

public 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)

computes the joint dense histogram for a set of images.

calcHist

public 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)

calcHist

public 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)

calcHist

public 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)

calcHist

public 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)

calcHist

public 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)

calcHist

public 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)

calcHist

public 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)

computes the joint sparse histogram for a set of images.

calcHist

public 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)

calcHist

public 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)

calcHist

public 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)

calcHist

public 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)

calcHist

public 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)

calcHist

public 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)

calcHist

public static void calcHist(opencv_core.MatVector images,
            IntPointer channels,
            opencv_core.Mat mask,
            opencv_core.Mat hist,
            IntPointer histSize,
            FloatPointer ranges,
            boolean accumulate)

calcHist

public static void calcHist(opencv_core.MatVector images,
            IntPointer channels,
            opencv_core.Mat mask,
            opencv_core.Mat hist,
            IntPointer histSize,
            FloatPointer ranges)

calcHist

public static void calcHist(opencv_core.MatVector images,
            IntBuffer channels,
            opencv_core.Mat mask,
            opencv_core.Mat hist,
            IntBuffer histSize,
            FloatBuffer ranges,
            boolean accumulate)

calcHist

public static void calcHist(opencv_core.MatVector images,
            IntBuffer channels,
            opencv_core.Mat mask,
            opencv_core.Mat hist,
            IntBuffer histSize,
            FloatBuffer ranges)

calcHist

public static void calcHist(opencv_core.MatVector images,
            int[] channels,
            opencv_core.Mat mask,
            opencv_core.Mat hist,
            int[] histSize,
            float[] ranges,
            boolean accumulate)

calcHist

public static void calcHist(opencv_core.MatVector images,
            int[] channels,
            opencv_core.Mat mask,
            opencv_core.Mat hist,
            int[] histSize,
            float[] ranges)

calcBackProject

public 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)

computes back projection for the set of images

calcBackProject

public static void calcBackProject(opencv_core.Mat images,
                   int nimages,
                   IntPointer channels,
                   opencv_core.Mat hist,
                   opencv_core.Mat backProject,
                   FloatPointer ranges)

calcBackProject

public 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)

calcBackProject

public 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)

calcBackProject

public static void calcBackProject(opencv_core.Mat images,
                   int nimages,
                   IntBuffer channels,
                   opencv_core.Mat hist,
                   opencv_core.Mat backProject,
                   FloatBuffer ranges)

calcBackProject

public 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)

calcBackProject

public static void calcBackProject(opencv_core.Mat images,
                   int nimages,
                   int[] channels,
                   opencv_core.Mat hist,
                   opencv_core.Mat backProject,
                   float[] ranges)

calcBackProject

public 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)

computes back projection for the set of images

calcBackProject

public static void calcBackProject(opencv_core.Mat images,
                   int nimages,
                   IntPointer channels,
                   opencv_core.SparseMat hist,
                   opencv_core.Mat backProject,
                   FloatPointer ranges)

calcBackProject

public 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)

calcBackProject

public 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)

calcBackProject

public static void calcBackProject(opencv_core.Mat images,
                   int nimages,
                   IntBuffer channels,
                   opencv_core.SparseMat hist,
                   opencv_core.Mat backProject,
                   FloatBuffer ranges)

calcBackProject

public 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)

calcBackProject

public static void calcBackProject(opencv_core.Mat images,
                   int nimages,
                   int[] channels,
                   opencv_core.SparseMat hist,
                   opencv_core.Mat backProject,
                   float[] ranges)

calcBackProject

public static void calcBackProject(opencv_core.MatVector images,
                   IntPointer channels,
                   opencv_core.Mat hist,
                   opencv_core.Mat dst,
                   FloatPointer ranges,
                   double scale)

calcBackProject

public static void calcBackProject(opencv_core.MatVector images,
                   IntBuffer channels,
                   opencv_core.Mat hist,
                   opencv_core.Mat dst,
                   FloatBuffer ranges,
                   double scale)

calcBackProject

public static void calcBackProject(opencv_core.MatVector images,
                   int[] channels,
                   opencv_core.Mat hist,
                   opencv_core.Mat dst,
                   float[] ranges,
                   double scale)

compareHist

public static double compareHist(opencv_core.Mat H1,
                 opencv_core.Mat H2,
                 int method)

compares two histograms stored in dense arrays

compareHist

public static double compareHist(opencv_core.SparseMat H1,
                 opencv_core.SparseMat H2,
                 int method)

compares two histograms stored in sparse arrays

equalizeHist

public static void equalizeHist(opencv_core.Mat src,
                opencv_core.Mat dst)

normalizes the grayscale image brightness and contrast by normalizing its histogram

createCLAHE

public static opencv_imgproc.CLAHE createCLAHE(double clipLimit,
                               opencv_core.Size tileGridSize)

createCLAHE

public static opencv_imgproc.CLAHE createCLAHE()

EMD

public static float EMD(opencv_core.Mat signature1,
        opencv_core.Mat signature2,
        int distType,
        opencv_core.Mat cost,
        FloatPointer lowerBound,
        opencv_core.Mat flow)

EMD

public static float EMD(opencv_core.Mat signature1,
        opencv_core.Mat signature2,
        int distType)

EMD

public static float EMD(opencv_core.Mat signature1,
        opencv_core.Mat signature2,
        int distType,
        opencv_core.Mat cost,
        FloatBuffer lowerBound,
        opencv_core.Mat flow)

EMD

public static float EMD(opencv_core.Mat signature1,
        opencv_core.Mat signature2,
        int distType,
        opencv_core.Mat cost,
        float[] lowerBound,
        opencv_core.Mat flow)

watershed

public static void watershed(opencv_core.Mat image,
             opencv_core.Mat markers)

segments the image using watershed algorithm

pyrMeanShiftFiltering

public static void pyrMeanShiftFiltering(opencv_core.Mat src,
                         opencv_core.Mat dst,
                         double sp,
                         double sr,
                         int maxLevel,
                         opencv_core.TermCriteria termcrit)

filters image using meanshift algorithm

pyrMeanShiftFiltering

public static void pyrMeanShiftFiltering(opencv_core.Mat src,
                         opencv_core.Mat dst,
                         double sp,
                         double sr)

grabCut

public 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)

segments the image using GrabCut algorithm

grabCut

public 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)

distanceTransformWithLabels

public static void distanceTransformWithLabels(opencv_core.Mat src,
                               opencv_core.Mat dst,
                               opencv_core.Mat labels,
                               int distanceType,
                               int maskSize,
                               int labelType)

builds the discrete Voronoi diagram

distanceTransformWithLabels

public static void distanceTransformWithLabels(opencv_core.Mat src,
                               opencv_core.Mat dst,
                               opencv_core.Mat labels,
                               int distanceType,
                               int maskSize)

distanceTransform

public static void distanceTransform(opencv_core.Mat src,
                     opencv_core.Mat dst,
                     int distanceType,
                     int maskSize)

computes the distance transform map

floodFill

public 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)

fills the semi-uniform image region starting from the specified seed point

floodFill

public static int floodFill(opencv_core.Mat image,
            opencv_core.Point seedPoint,
            opencv_core.Scalar newVal)

floodFill

public 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)

fills the semi-uniform image region and/or the mask starting from the specified seed point

floodFill

public static int floodFill(opencv_core.Mat image,
            opencv_core.Mat mask,
            opencv_core.Point seedPoint,
            opencv_core.Scalar newVal)

cvtColor

public static void cvtColor(opencv_core.Mat src,
            opencv_core.Mat dst,
            int code,
            int dstCn)

converts image from one color space to another

cvtColor

public static void cvtColor(opencv_core.Mat src,
            opencv_core.Mat dst,
            int code)

moments

public static opencv_imgproc.Moments moments(opencv_core.Mat array,
                             boolean binaryImage)

computes moments of the rasterized shape or a vector of points

moments

public static opencv_imgproc.Moments moments(opencv_core.Mat array)

HuMoments

public static void HuMoments(opencv_imgproc.Moments moments,
             DoublePointer hu)

computes 7 Hu invariants from the moments

HuMoments

public static void HuMoments(opencv_imgproc.Moments moments,
             DoubleBuffer hu)

HuMoments

public static void HuMoments(opencv_imgproc.Moments moments,
             double[] hu)

HuMoments

public static void HuMoments(opencv_imgproc.Moments m,
             opencv_core.Mat hu)

matchTemplate

public static void matchTemplate(opencv_core.Mat image,
                 opencv_core.Mat templ,
                 opencv_core.Mat result,
                 int method)

computes the proximity map for the raster template and the image where the template is searched for

findContours

public static void findContours(opencv_core.Mat image,
                opencv_core.MatVector contours,
                opencv_core.Mat hierarchy,
                int mode,
                int method,
                opencv_core.Point offset)

retrieves contours and the hierarchical information from black-n-white image.

findContours

public static void findContours(opencv_core.Mat image,
                opencv_core.MatVector contours,
                opencv_core.Mat hierarchy,
                int mode,
                int method)

findContours

public static void findContours(opencv_core.Mat image,
                opencv_core.MatVector contours,
                int mode,
                int method,
                opencv_core.Point offset)

retrieves contours from black-n-white image.

findContours

public static void findContours(opencv_core.Mat image,
                opencv_core.MatVector contours,
                int mode,
                int method)

drawContours

public 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)

draws contours in the image

drawContours

public static void drawContours(opencv_core.Mat image,
                opencv_core.MatVector contours,
                int contourIdx,
                opencv_core.Scalar color)

approxPolyDP

public static void approxPolyDP(opencv_core.Mat curve,
                opencv_core.Mat approxCurve,
                double epsilon,
                boolean closed)

approximates contour or a curve using Douglas-Peucker algorithm

arcLength

public static double arcLength(opencv_core.Mat curve,
               boolean closed)

computes the contour perimeter (closed=true) or a curve length

boundingRect

public static opencv_core.Rect boundingRect(opencv_core.Mat points)

computes the bounding rectangle for a contour

contourArea

public static double contourArea(opencv_core.Mat contour,
                 boolean oriented)

computes the contour area

contourArea

public static double contourArea(opencv_core.Mat contour)

minAreaRect

public static opencv_core.RotatedRect minAreaRect(opencv_core.Mat points)

computes the minimal rotated rectangle for a set of points

minEnclosingCircle

public static void minEnclosingCircle(opencv_core.Mat points,
                      opencv_core.Point2f center,
                      FloatPointer radius)

computes the minimal enclosing circle for a set of points

minEnclosingCircle

public static void minEnclosingCircle(opencv_core.Mat points,
                      opencv_core.Point2f center,
                      FloatBuffer radius)

minEnclosingCircle

public static void minEnclosingCircle(opencv_core.Mat points,
                      opencv_core.Point2f center,
                      float[] radius)

matchShapes

public static double matchShapes(opencv_core.Mat contour1,
                 opencv_core.Mat contour2,
                 int method,
                 double parameter)

matches two contours using one of the available algorithms

convexHull

public static void convexHull(opencv_core.Mat points,
              opencv_core.Mat hull,
              boolean clockwise,
              boolean returnPoints)

computes convex hull for a set of 2D points.

convexHull

public static void convexHull(opencv_core.Mat points,
              opencv_core.Mat hull)

convexityDefects

public static void convexityDefects(opencv_core.Mat contour,
                    opencv_core.Mat convexhull,
                    opencv_core.Mat convexityDefects)

computes the contour convexity defects

isContourConvex
```
public static boolean isContourConvex(opencv_core.Mat contour)
```
returns true if the contour is convex. Does not support contours with self-intersection

intersectConvexConvex

public static float intersectConvexConvex(opencv_core.Mat _p1,
                          opencv_core.Mat _p2,
                          opencv_core.Mat _p12,
                          boolean handleNested)

finds intersection of two convex polygons

intersectConvexConvex

public static float intersectConvexConvex(opencv_core.Mat _p1,
                          opencv_core.Mat _p2,
                          opencv_core.Mat _p12)

fitEllipse

public static opencv_core.RotatedRect fitEllipse(opencv_core.Mat points)

fits ellipse to the set of 2D points

fitLine

public static void fitLine(opencv_core.Mat points,
           opencv_core.Mat line,
           int distType,
           double param,
           double reps,
           double aeps)

fits line to the set of 2D points using M-estimator algorithm

pointPolygonTest

public static double pointPolygonTest(opencv_core.Mat contour,
                      opencv_core.Point2f pt,
                      boolean measureDist)

checks if the point is inside the contour. Optionally computes the signed distance from the point to the contour boundary

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