opencv2/imgproc.hpp

#include <opencv2/core.hpp>

Include dependency graph for imgproc.hpp:

This graph shows which files directly or indirectly include imgproc.hpp:

Classes

class cv::CLAHE

Base class for Contrast Limited Adaptive Histogram Equalization. More…

class cv::Filter2DParams

class cv::FontFace

Wrapper on top of a truetype/opentype/etc font, i.e. Freetype’s FT_Face. More…

class cv::GeneralizedHough

finds arbitrary template in the grayscale image using Generalized Hough Transform More…

class cv::GeneralizedHoughBallard

finds arbitrary template in the grayscale image using Generalized Hough Transform More…

class cv::GeneralizedHoughGuil

finds arbitrary template in the grayscale image using Generalized Hough Transform More…

class cv::LineIterator

Class for iterating over all pixels on a raster line segment. More…

class cv::LineSegmentDetector

Line segment detector class. More…

Namespaces

namespace cv

namespace cv::fisheye

Enumerations

enum cv::ColorConversionCodes {
COLOR_BGR2BGRA = 0,
COLOR_RGB2RGBA = COLOR_BGR2BGRA,
COLOR_BGRA2BGR = 1,
COLOR_RGBA2RGB = COLOR_BGRA2BGR,
COLOR_BGR2RGBA = 2,
COLOR_RGB2BGRA = COLOR_BGR2RGBA,
COLOR_RGBA2BGR = 3,
COLOR_BGRA2RGB = COLOR_RGBA2BGR,
COLOR_BGR2RGB = 4,
COLOR_RGB2BGR = COLOR_BGR2RGB,
COLOR_BGRA2RGBA = 5,
COLOR_RGBA2BGRA = COLOR_BGRA2RGBA,
COLOR_BGR2GRAY = 6,
COLOR_RGB2GRAY = 7,
COLOR_GRAY2BGR = 8,
COLOR_GRAY2RGB = COLOR_GRAY2BGR,
COLOR_GRAY2BGRA = 9,
COLOR_GRAY2RGBA = COLOR_GRAY2BGRA,
COLOR_BGRA2GRAY = 10,
COLOR_RGBA2GRAY = 11,
COLOR_BGR2BGR565 = 12,
COLOR_RGB2BGR565 = 13,
COLOR_BGR5652BGR = 14,
COLOR_BGR5652RGB = 15,
COLOR_BGRA2BGR565 = 16,
COLOR_RGBA2BGR565 = 17,
COLOR_BGR5652BGRA = 18,
COLOR_BGR5652RGBA = 19,
COLOR_GRAY2BGR565 = 20,
COLOR_BGR5652GRAY = 21,
COLOR_BGR2BGR555 = 22,
COLOR_RGB2BGR555 = 23,
COLOR_BGR5552BGR = 24,
COLOR_BGR5552RGB = 25,
COLOR_BGRA2BGR555 = 26,
COLOR_RGBA2BGR555 = 27,
COLOR_BGR5552BGRA = 28,
COLOR_BGR5552RGBA = 29,
COLOR_GRAY2BGR555 = 30,
COLOR_BGR5552GRAY = 31,
COLOR_BGR2XYZ = 32,
COLOR_RGB2XYZ = 33,
COLOR_XYZ2BGR = 34,
COLOR_XYZ2RGB = 35,
COLOR_BGR2YCrCb = 36,
COLOR_RGB2YCrCb = 37,
COLOR_YCrCb2BGR = 38,
COLOR_YCrCb2RGB = 39,
COLOR_BGR2HSV = 40,
COLOR_RGB2HSV = 41,
COLOR_BGR2Lab = 44,
COLOR_RGB2Lab = 45,
COLOR_BGR2Luv = 50,
COLOR_RGB2Luv = 51,
COLOR_BGR2HLS = 52,
COLOR_RGB2HLS = 53,
COLOR_HSV2BGR = 54,
COLOR_HSV2RGB = 55,
COLOR_Lab2BGR = 56,
COLOR_Lab2RGB = 57,
COLOR_Luv2BGR = 58,
COLOR_Luv2RGB = 59,
COLOR_HLS2BGR = 60,
COLOR_HLS2RGB = 61,
COLOR_BGR2HSV_FULL = 66,
COLOR_RGB2HSV_FULL = 67,
COLOR_BGR2HLS_FULL = 68,
COLOR_RGB2HLS_FULL = 69,
COLOR_HSV2BGR_FULL = 70,
COLOR_HSV2RGB_FULL = 71,
COLOR_HLS2BGR_FULL = 72,
COLOR_HLS2RGB_FULL = 73,
COLOR_LBGR2Lab = 74,
COLOR_LRGB2Lab = 75,
COLOR_LBGR2Luv = 76,
COLOR_LRGB2Luv = 77,
COLOR_Lab2LBGR = 78,
COLOR_Lab2LRGB = 79,
COLOR_Luv2LBGR = 80,
COLOR_Luv2LRGB = 81,
COLOR_BGR2YUV = 82,
COLOR_RGB2YUV = 83,
COLOR_YUV2BGR = 84,
COLOR_YUV2RGB = 85,
COLOR_YUV2RGB_NV12 = 90,
COLOR_YUV2BGR_NV12 = 91,
COLOR_YUV2RGB_NV21 = 92,
COLOR_YUV2BGR_NV21 = 93,
COLOR_YUV420sp2RGB = COLOR_YUV2RGB_NV21,
COLOR_YUV420sp2BGR = COLOR_YUV2BGR_NV21,
COLOR_YUV2RGBA_NV12 = 94,
COLOR_YUV2BGRA_NV12 = 95,
COLOR_YUV2RGBA_NV21 = 96,
COLOR_YUV2BGRA_NV21 = 97,
COLOR_YUV420sp2RGBA = COLOR_YUV2RGBA_NV21,
COLOR_YUV420sp2BGRA = COLOR_YUV2BGRA_NV21,
COLOR_YUV2RGB_YV12 = 98,
COLOR_YUV2BGR_YV12 = 99,
COLOR_YUV2RGB_IYUV = 100,
COLOR_YUV2BGR_IYUV = 101,
COLOR_YUV2RGB_I420 = COLOR_YUV2RGB_IYUV,
COLOR_YUV2BGR_I420 = COLOR_YUV2BGR_IYUV,
COLOR_YUV420p2RGB = COLOR_YUV2RGB_YV12,
COLOR_YUV420p2BGR = COLOR_YUV2BGR_YV12,
COLOR_YUV2RGBA_YV12 = 102,
COLOR_YUV2BGRA_YV12 = 103,
COLOR_YUV2RGBA_IYUV = 104,
COLOR_YUV2BGRA_IYUV = 105,
COLOR_YUV2RGBA_I420 = COLOR_YUV2RGBA_IYUV,
COLOR_YUV2BGRA_I420 = COLOR_YUV2BGRA_IYUV,
COLOR_YUV420p2RGBA = COLOR_YUV2RGBA_YV12,
COLOR_YUV420p2BGRA = COLOR_YUV2BGRA_YV12,
COLOR_YUV2GRAY_420 = 106,
COLOR_YUV2GRAY_NV21 = COLOR_YUV2GRAY_420,
COLOR_YUV2GRAY_NV12 = COLOR_YUV2GRAY_420,
COLOR_YUV2GRAY_YV12 = COLOR_YUV2GRAY_420,
COLOR_YUV2GRAY_IYUV = COLOR_YUV2GRAY_420,
COLOR_YUV2GRAY_I420 = COLOR_YUV2GRAY_420,
COLOR_YUV420sp2GRAY = COLOR_YUV2GRAY_420,
COLOR_YUV420p2GRAY = COLOR_YUV2GRAY_420,
COLOR_YUV2RGB_UYVY = 107,
COLOR_YUV2BGR_UYVY = 108,
COLOR_YUV2RGB_Y422 = COLOR_YUV2RGB_UYVY,
COLOR_YUV2BGR_Y422 = COLOR_YUV2BGR_UYVY,
COLOR_YUV2RGB_UYNV = COLOR_YUV2RGB_UYVY,
COLOR_YUV2BGR_UYNV = COLOR_YUV2BGR_UYVY,
COLOR_YUV2RGBA_UYVY = 111,
COLOR_YUV2BGRA_UYVY = 112,
COLOR_YUV2RGBA_Y422 = COLOR_YUV2RGBA_UYVY,
COLOR_YUV2BGRA_Y422 = COLOR_YUV2BGRA_UYVY,
COLOR_YUV2RGBA_UYNV = COLOR_YUV2RGBA_UYVY,
COLOR_YUV2BGRA_UYNV = COLOR_YUV2BGRA_UYVY,
COLOR_YUV2RGB_YUY2 = 115,
COLOR_YUV2BGR_YUY2 = 116,
COLOR_YUV2RGB_YVYU = 117,
COLOR_YUV2BGR_YVYU = 118,
COLOR_YUV2RGB_YUYV = COLOR_YUV2RGB_YUY2,
COLOR_YUV2BGR_YUYV = COLOR_YUV2BGR_YUY2,
COLOR_YUV2RGB_YUNV = COLOR_YUV2RGB_YUY2,
COLOR_YUV2BGR_YUNV = COLOR_YUV2BGR_YUY2,
COLOR_YUV2RGBA_YUY2 = 119,
COLOR_YUV2BGRA_YUY2 = 120,
COLOR_YUV2RGBA_YVYU = 121,
COLOR_YUV2BGRA_YVYU = 122,
COLOR_YUV2RGBA_YUYV = COLOR_YUV2RGBA_YUY2,
COLOR_YUV2BGRA_YUYV = COLOR_YUV2BGRA_YUY2,
COLOR_YUV2RGBA_YUNV = COLOR_YUV2RGBA_YUY2,
COLOR_YUV2BGRA_YUNV = COLOR_YUV2BGRA_YUY2,
COLOR_YUV2GRAY_UYVY = 123,
COLOR_YUV2GRAY_YUY2 = 124,
COLOR_YUV2GRAY_Y422 = COLOR_YUV2GRAY_UYVY,
COLOR_YUV2GRAY_UYNV = COLOR_YUV2GRAY_UYVY,
COLOR_YUV2GRAY_YVYU = COLOR_YUV2GRAY_YUY2,
COLOR_YUV2GRAY_YUYV = COLOR_YUV2GRAY_YUY2,
COLOR_YUV2GRAY_YUNV = COLOR_YUV2GRAY_YUY2,
COLOR_RGBA2mRGBA = 125,
COLOR_mRGBA2RGBA = 126,
COLOR_RGB2YUV_I420 = 127,
COLOR_BGR2YUV_I420 = 128,
COLOR_RGB2YUV_IYUV = COLOR_RGB2YUV_I420,
COLOR_BGR2YUV_IYUV = COLOR_BGR2YUV_I420,
COLOR_RGBA2YUV_I420 = 129,
COLOR_BGRA2YUV_I420 = 130,
COLOR_RGBA2YUV_IYUV = COLOR_RGBA2YUV_I420,
COLOR_BGRA2YUV_IYUV = COLOR_BGRA2YUV_I420,
COLOR_RGB2YUV_YV12 = 131,
COLOR_BGR2YUV_YV12 = 132,
COLOR_RGBA2YUV_YV12 = 133,
COLOR_BGRA2YUV_YV12 = 134,
COLOR_BayerBG2BGR = 46,
COLOR_BayerGB2BGR = 47,
COLOR_BayerRG2BGR = 48,
COLOR_BayerGR2BGR = 49,
COLOR_BayerRGGB2BGR = COLOR_BayerBG2BGR,
COLOR_BayerGRBG2BGR = COLOR_BayerGB2BGR,
COLOR_BayerBGGR2BGR = COLOR_BayerRG2BGR,
COLOR_BayerGBRG2BGR = COLOR_BayerGR2BGR,
COLOR_BayerRGGB2RGB = COLOR_BayerBGGR2BGR,
COLOR_BayerGRBG2RGB = COLOR_BayerGBRG2BGR,
COLOR_BayerBGGR2RGB = COLOR_BayerRGGB2BGR,
COLOR_BayerGBRG2RGB = COLOR_BayerGRBG2BGR,
COLOR_BayerBG2RGB = COLOR_BayerRG2BGR,
COLOR_BayerGB2RGB = COLOR_BayerGR2BGR,
COLOR_BayerRG2RGB = COLOR_BayerBG2BGR,
COLOR_BayerGR2RGB = COLOR_BayerGB2BGR,
COLOR_BayerBG2GRAY = 86,
COLOR_BayerGB2GRAY = 87,
COLOR_BayerRG2GRAY = 88,
COLOR_BayerGR2GRAY = 89,
COLOR_BayerRGGB2GRAY = COLOR_BayerBG2GRAY,
COLOR_BayerGRBG2GRAY = COLOR_BayerGB2GRAY,
COLOR_BayerBGGR2GRAY = COLOR_BayerRG2GRAY,
COLOR_BayerGBRG2GRAY = COLOR_BayerGR2GRAY,
COLOR_BayerBG2BGR_VNG = 62,
COLOR_BayerGB2BGR_VNG = 63,
COLOR_BayerRG2BGR_VNG = 64,
COLOR_BayerGR2BGR_VNG = 65,
COLOR_BayerRGGB2BGR_VNG = COLOR_BayerBG2BGR_VNG,
COLOR_BayerGRBG2BGR_VNG = COLOR_BayerGB2BGR_VNG,
COLOR_BayerBGGR2BGR_VNG = COLOR_BayerRG2BGR_VNG,
COLOR_BayerGBRG2BGR_VNG = COLOR_BayerGR2BGR_VNG,
COLOR_BayerRGGB2RGB_VNG = COLOR_BayerBGGR2BGR_VNG,
COLOR_BayerGRBG2RGB_VNG = COLOR_BayerGBRG2BGR_VNG,
COLOR_BayerBGGR2RGB_VNG = COLOR_BayerRGGB2BGR_VNG,
COLOR_BayerGBRG2RGB_VNG = COLOR_BayerGRBG2BGR_VNG,
COLOR_BayerBG2RGB_VNG = COLOR_BayerRG2BGR_VNG,
COLOR_BayerGB2RGB_VNG = COLOR_BayerGR2BGR_VNG,
COLOR_BayerRG2RGB_VNG = COLOR_BayerBG2BGR_VNG,
COLOR_BayerGR2RGB_VNG = COLOR_BayerGB2BGR_VNG,
COLOR_BayerBG2BGR_EA = 135,
COLOR_BayerGB2BGR_EA = 136,
COLOR_BayerRG2BGR_EA = 137,
COLOR_BayerGR2BGR_EA = 138,
COLOR_BayerRGGB2BGR_EA = COLOR_BayerBG2BGR_EA,
COLOR_BayerGRBG2BGR_EA = COLOR_BayerGB2BGR_EA,
COLOR_BayerBGGR2BGR_EA = COLOR_BayerRG2BGR_EA,
COLOR_BayerGBRG2BGR_EA = COLOR_BayerGR2BGR_EA,
COLOR_BayerRGGB2RGB_EA = COLOR_BayerBGGR2BGR_EA,
COLOR_BayerGRBG2RGB_EA = COLOR_BayerGBRG2BGR_EA,
COLOR_BayerBGGR2RGB_EA = COLOR_BayerRGGB2BGR_EA,
COLOR_BayerGBRG2RGB_EA = COLOR_BayerGRBG2BGR_EA,
COLOR_BayerBG2RGB_EA = COLOR_BayerRG2BGR_EA,
COLOR_BayerGB2RGB_EA = COLOR_BayerGR2BGR_EA,
COLOR_BayerRG2RGB_EA = COLOR_BayerBG2BGR_EA,
COLOR_BayerGR2RGB_EA = COLOR_BayerGB2BGR_EA,
COLOR_BayerBG2BGRA = 139,
COLOR_BayerGB2BGRA = 140,
COLOR_BayerRG2BGRA = 141,
COLOR_BayerGR2BGRA = 142,
COLOR_BayerRGGB2BGRA = COLOR_BayerBG2BGRA,
COLOR_BayerGRBG2BGRA = COLOR_BayerGB2BGRA,
COLOR_BayerBGGR2BGRA = COLOR_BayerRG2BGRA,
COLOR_BayerGBRG2BGRA = COLOR_BayerGR2BGRA,
COLOR_BayerRGGB2RGBA = COLOR_BayerBGGR2BGRA,
COLOR_BayerGRBG2RGBA = COLOR_BayerGBRG2BGRA,
COLOR_BayerBGGR2RGBA = COLOR_BayerRGGB2BGRA,
COLOR_BayerGBRG2RGBA = COLOR_BayerGRBG2BGRA,
COLOR_BayerBG2RGBA = COLOR_BayerRG2BGRA,
COLOR_BayerGB2RGBA = COLOR_BayerGR2BGRA,
COLOR_BayerRG2RGBA = COLOR_BayerBG2BGRA,
COLOR_BayerGR2RGBA = COLOR_BayerGB2BGRA,
COLOR_RGB2YUV_UYVY = 143,
COLOR_BGR2YUV_UYVY = 144,
COLOR_RGB2YUV_Y422 = COLOR_RGB2YUV_UYVY,
COLOR_BGR2YUV_Y422 = COLOR_BGR2YUV_UYVY,
COLOR_RGB2YUV_UYNV = COLOR_RGB2YUV_UYVY,
COLOR_BGR2YUV_UYNV = COLOR_BGR2YUV_UYVY,
COLOR_RGBA2YUV_UYVY = 145,
COLOR_BGRA2YUV_UYVY = 146,
COLOR_RGBA2YUV_Y422 = COLOR_RGBA2YUV_UYVY,
COLOR_BGRA2YUV_Y422 = COLOR_BGRA2YUV_UYVY,
COLOR_RGBA2YUV_UYNV = COLOR_RGBA2YUV_UYVY,
COLOR_BGRA2YUV_UYNV = COLOR_BGRA2YUV_UYVY,
COLOR_RGB2YUV_YUY2 = 147,
COLOR_BGR2YUV_YUY2 = 148,
COLOR_RGB2YUV_YVYU = 149,
COLOR_BGR2YUV_YVYU = 150,
COLOR_RGB2YUV_YUYV = COLOR_RGB2YUV_YUY2,
COLOR_BGR2YUV_YUYV = COLOR_BGR2YUV_YUY2,
COLOR_RGB2YUV_YUNV = COLOR_RGB2YUV_YUY2,
COLOR_BGR2YUV_YUNV = COLOR_BGR2YUV_YUY2,
COLOR_RGBA2YUV_YUY2 = 151,
COLOR_BGRA2YUV_YUY2 = 152,
COLOR_RGBA2YUV_YVYU = 153,
COLOR_BGRA2YUV_YVYU = 154,
COLOR_RGBA2YUV_YUYV = COLOR_RGBA2YUV_YUY2,
COLOR_BGRA2YUV_YUYV = COLOR_BGRA2YUV_YUY2,
COLOR_RGBA2YUV_YUNV = COLOR_RGBA2YUV_YUY2,
COLOR_BGRA2YUV_YUNV = COLOR_BGRA2YUV_YUY2,
COLOR_COLORCVT_MAX = 155
}

enum cv::HistCompMethods {
HISTCMP_CORREL = 0,
HISTCMP_CHISQR = 1,
HISTCMP_INTERSECT = 2,
HISTCMP_BHATTACHARYYA = 3,
HISTCMP_HELLINGER = HISTCMP_BHATTACHARYYA,
HISTCMP_CHISQR_ALT = 4,
HISTCMP_KL_DIV = 5
}

enum cv::TemplateMatchModes {
TM_SQDIFF = 0,
TM_SQDIFF_NORMED = 1,
TM_CCORR = 2,
TM_CCORR_NORMED = 3,
TM_CCOEFF = 4,
TM_CCOEFF_NORMED = 5
}

type of the template matching operation More…

enum cv::HoughModes {
HOUGH_STANDARD = 0,
HOUGH_PROBABILISTIC = 1,
HOUGH_MULTI_SCALE = 2,
HOUGH_GRADIENT = 3,
HOUGH_GRADIENT_ALT = 4
}

Variants of a Hough transform. More…

enum cv::HersheyFonts {
FONT_HERSHEY_SIMPLEX = 0,
FONT_HERSHEY_PLAIN = 1,
FONT_HERSHEY_DUPLEX = 2,
FONT_HERSHEY_COMPLEX = 3,
FONT_HERSHEY_TRIPLEX = 4,
FONT_HERSHEY_COMPLEX_SMALL = 5,
FONT_HERSHEY_SCRIPT_SIMPLEX = 6,
FONT_HERSHEY_SCRIPT_COMPLEX = 7,
FONT_ITALIC = 16
}

enum cv::LineTypes {
FILLED = -1,
LINE_4 = 4,
LINE_8 = 8,
LINE_AA = 16
}

enum cv::MarkerTypes {
MARKER_CROSS = 0,
MARKER_TILTED_CROSS = 1,
MARKER_STAR = 2,
MARKER_DIAMOND = 3,
MARKER_SQUARE = 4,
MARKER_TRIANGLE_UP = 5,
MARKER_TRIANGLE_DOWN = 6
}

enum cv::PutTextFlags {
PUT_TEXT_ALIGN_LEFT =0,
PUT_TEXT_ALIGN_CENTER =1,
PUT_TEXT_ALIGN_RIGHT =2,
PUT_TEXT_ALIGN_MASK =3,
PUT_TEXT_ORIGIN_TL =0,
PUT_TEXT_ORIGIN_BL =32,
PUT_TEXT_WRAP =128
}

Defines various put text flags. More…

enum cv::InterpolationFlags {
INTER_NEAREST = 0,
INTER_LINEAR = 1,
INTER_CUBIC = 2,
INTER_AREA = 3,
INTER_LANCZOS4 = 4,
INTER_LINEAR_EXACT = 5,
INTER_NEAREST_EXACT = 6,
INTER_MAX = 7,
WARP_FILL_OUTLIERS = 8,
WARP_INVERSE_MAP = 16,
WARP_RELATIVE_MAP = 32
}

interpolation algorithm More…

enum cv::InterpolationMasks {
INTER_BITS = 5,
INTER_BITS2 = INTER_BITS * 2,
INTER_TAB_SIZE = 1 << INTER_BITS,
INTER_TAB_SIZE2 = INTER_TAB_SIZE * INTER_TAB_SIZE
}

enum cv::UndistortTypes {
PROJ_SPHERICAL_ORTHO = 0,
PROJ_SPHERICAL_EQRECT = 1
}

cv::undistort mode More…

enum cv::WarpPolarMode {
WARP_POLAR_LINEAR = 0,
WARP_POLAR_LOG = 256
}

Specify the polar mapping mode. More…

enum cv::LineSegmentDetectorModes {
LSD_REFINE_NONE = 0,
LSD_REFINE_STD = 1,
LSD_REFINE_ADV = 2
}

Variants of Line Segment Detector. More…

enum cv::AdaptiveThresholdTypes {
ADAPTIVE_THRESH_MEAN_C = 0,
ADAPTIVE_THRESH_GAUSSIAN_C = 1
}

enum cv::DistanceTransformLabelTypes {
DIST_LABEL_CCOMP = 0,
DIST_LABEL_PIXEL = 1
}

distanceTransform algorithm flags More…

enum cv::DistanceTransformMasks {
DIST_MASK_3 = 3,
DIST_MASK_5 = 5,
DIST_MASK_PRECISE = 0
}

Mask size for distance transform. More…

enum cv::FloodFillFlags {
FLOODFILL_FIXED_RANGE = 1 << 16,
FLOODFILL_MASK_ONLY = 1 << 17
}

floodfill algorithm flags More…

enum cv::GrabCutClasses {
GC_BGD = 0,
GC_FGD = 1,
GC_PR_BGD = 2,
GC_PR_FGD = 3
}

class of the pixel in GrabCut algorithm More…

enum cv::GrabCutModes {
GC_INIT_WITH_RECT = 0,
GC_INIT_WITH_MASK = 1,
GC_EVAL = 2,
GC_EVAL_FREEZE_MODEL = 3
}

GrabCut algorithm flags. More…

enum cv::ThresholdTypes {
THRESH_BINARY = 0,
THRESH_BINARY_INV = 1,
THRESH_TRUNC = 2,
THRESH_TOZERO = 3,
THRESH_TOZERO_INV = 4,
THRESH_MASK = 7,
THRESH_OTSU = 8,
THRESH_TRIANGLE = 16,
THRESH_DRYRUN = 128
}

enum cv::ColormapTypes {
COLORMAP_AUTUMN = 0,
COLORMAP_BONE = 1,
COLORMAP_JET = 2,
COLORMAP_WINTER = 3,
COLORMAP_RAINBOW = 4,
COLORMAP_OCEAN = 5,
COLORMAP_SUMMER = 6,
COLORMAP_SPRING = 7,
COLORMAP_COOL = 8,
COLORMAP_HSV = 9,
COLORMAP_PINK = 10,
COLORMAP_HOT = 11,
COLORMAP_PARULA = 12,
COLORMAP_MAGMA = 13,
COLORMAP_INFERNO = 14,
COLORMAP_PLASMA = 15,
COLORMAP_VIRIDIS = 16,
COLORMAP_CIVIDIS = 17,
COLORMAP_TWILIGHT = 18,
COLORMAP_TWILIGHT_SHIFTED = 19,
COLORMAP_TURBO = 20,
COLORMAP_DEEPGREEN = 21
}

GNU Octave/MATLAB equivalent colormaps. More…

enum cv::MorphShapes {
MORPH_RECT = 0,
MORPH_CROSS = 1,
MORPH_ELLIPSE = 2,
MORPH_DIAMOND = 3
}

shape of the structuring element More…

enum cv::MorphTypes {
MORPH_ERODE = 0,
MORPH_DILATE = 1,
MORPH_OPEN = 2,
MORPH_CLOSE = 3,
MORPH_GRADIENT = 4,
MORPH_TOPHAT = 5,
MORPH_BLACKHAT = 6,
MORPH_HITMISS = 7
}

type of morphological operation More…

enum cv::SpecialFilter {
FILTER_SCHARR = -1
}

enum cv::ConnectedComponentsAlgorithmsTypes {
CCL_DEFAULT = -1,
CCL_WU = 0,
CCL_GRANA = 1,
CCL_BOLELLI = 2,
CCL_SAUF = 3,
CCL_BBDT = 4,
CCL_SPAGHETTI = 5
}

connected components algorithm More…

enum cv::ConnectedComponentsTypes {
CC_STAT_LEFT = 0,
CC_STAT_TOP = 1,
CC_STAT_WIDTH = 2,
CC_STAT_HEIGHT = 3,
CC_STAT_AREA = 4
}

connected components statistics More…

enum cv::ContourApproximationModes {
CHAIN_CODE = 0,
CHAIN_APPROX_NONE = 1,
CHAIN_APPROX_SIMPLE = 2,
CHAIN_APPROX_TC89_L1 = 3,
CHAIN_APPROX_TC89_KCOS = 4,
LINK_RUNS = 5
}

the contour approximation algorithm More…

enum cv::RetrievalModes {
RETR_EXTERNAL = 0,
RETR_LIST = 1,
RETR_CCOMP = 2,
RETR_TREE = 3,
RETR_FLOODFILL = 4
}

mode of the contour retrieval algorithm More…

enum cv::ShapeMatchModes {
CONTOURS_MATCH_I1 =1,
CONTOURS_MATCH_I2 =2,
CONTOURS_MATCH_I3 =3
}

Shape matching methods. More…

Functions

void cv::cvtColor (InputArray src, OutputArray dst, int code, int dstCn=0, AlgorithmHint hint=cv::ALGO_HINT_DEFAULT)

Converts an image from one color space to another.

void cv::cvtColorTwoPlane (InputArray src1, InputArray src2, OutputArray dst, int code, AlgorithmHint hint=cv::ALGO_HINT_DEFAULT)

Converts an image from one color space to another where the source image is stored in two planes.

void cv::demosaicing (InputArray src, OutputArray dst, int code, int dstCn=0)

main function for all demosaicing processes

void cv::calcBackProject (const Mat *images, int nimages, const int *channels, const SparseMat &hist, OutputArray backProject, const float **ranges, double scale=1, bool uniform=true)

void cv::calcBackProject (const Mat *images, int nimages, const int *channels, InputArray hist, OutputArray backProject, const float **ranges, double scale=1, bool uniform=true)

Calculates the back projection of a histogram.

void cv::calcBackProject (InputArrayOfArrays images, const std::vector< int > &channels, InputArray hist, OutputArray dst, const std::vector< float > &ranges, double scale)

void cv::calcHist (const Mat *images, int nimages, const int *channels, InputArray mask, OutputArray hist, int dims, const int *histSize, const float **ranges, bool uniform=true, bool accumulate=false)

Calculates a histogram of a set of arrays.

void cv::calcHist (const Mat *images, int nimages, const int *channels, InputArray mask, SparseMat &hist, int dims, const int *histSize, const float **ranges, bool uniform=true, bool accumulate=false)

void cv::calcHist (InputArrayOfArrays images, const std::vector< int > &channels, InputArray mask, OutputArray hist, const std::vector< int > &histSize, const std::vector< float > &ranges, bool accumulate=false)

double cv::compareHist (const SparseMat &H1, const SparseMat &H2, int method)

double cv::compareHist (InputArray H1, InputArray H2, int method)

Compares two histograms.

Ptr< CLAHE > cv::createCLAHE (double clipLimit=40.0, Size tileGridSize=Size(8, 8))

Creates a smart pointer to a cv::CLAHE class and initializes it.

float cv::EMD (InputArray signature1, InputArray signature2, int distType, InputArray cost=noArray(), float *lowerBound=0, OutputArray flow=noArray())

Computes the “minimal work” distance between two weighted point configurations.

void cv::equalizeHist (InputArray src, OutputArray dst)

Equalizes the histogram of a grayscale image.

float cv::wrapperEMD (InputArray signature1, InputArray signature2, int distType, InputArray cost=noArray(), Ptr< float > lowerBound=Ptr< float >(), OutputArray flow=noArray())

void cv::matchTemplate (InputArray image, InputArray templ, OutputArray result, int method, InputArray mask=noArray())

Compares a template against overlapped image regions.

void cv::Canny (InputArray dx, InputArray dy, OutputArray edges, double threshold1, double threshold2, bool L2gradient=false)

void cv::Canny (InputArray image, OutputArray edges, double threshold1, double threshold2, int apertureSize=3, bool L2gradient=false)

Finds edges in an image using the Canny algorithm [54] .

void cv::cornerEigenValsAndVecs (InputArray src, OutputArray dst, int blockSize, int ksize, int borderType=BORDER_DEFAULT)

Calculates eigenvalues and eigenvectors of image blocks for corner detection.

void cv::cornerHarris (InputArray src, OutputArray dst, int blockSize, int ksize, double k, int borderType=BORDER_DEFAULT)

Harris corner detector.

void cv::cornerMinEigenVal (InputArray src, OutputArray dst, int blockSize, int ksize=3, int borderType=BORDER_DEFAULT)

Calculates the minimal eigenvalue of gradient matrices for corner detection.

void cv::cornerSubPix (InputArray image, InputOutputArray corners, Size winSize, Size zeroZone, TermCriteria criteria)

Refines the corner locations.

Ptr< LineSegmentDetector > cv::createLineSegmentDetector (LineSegmentDetectorModes refine=LSD_REFINE_STD, double scale=0.8, double sigma_scale=0.6, double quant=2.0, double ang_th=22.5, double log_eps=0, double density_th=0.7, int n_bins=1024)

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

void cv::HoughCircles (InputArray image, OutputArray circles, int method, double dp, double minDist, double param1=100, double param2=100, int minRadius=0, int maxRadius=0)

Finds circles in a grayscale image using the Hough transform.

void cv::HoughLines (InputArray image, OutputArray lines, double rho, double theta, int threshold, double srn=0, double stn=0, double min_theta=0, double max_theta=CV_PI, bool use_edgeval=false)

Finds lines in a binary image using the standard Hough transform.

void cv::HoughLinesP (InputArray image, OutputArray lines, double rho, double theta, int threshold, double minLineLength=0, double maxLineGap=0)

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

void cv::HoughLinesPointSet (InputArray point, OutputArray lines, int lines_max, int threshold, double min_rho, double max_rho, double rho_step, double min_theta, double max_theta, double theta_step)

Finds lines in a set of points using the standard Hough transform.

void cv::preCornerDetect (InputArray src, OutputArray dst, int ksize, int borderType=BORDER_DEFAULT)

Calculates a feature map for corner detection.

void cv::arrowedLine (InputOutputArray img, Point pt1, Point pt2, const Scalar &color, int thickness=1, int line_type=8, int shift=0, double tipLength=0.1)

Draws an arrow segment pointing from the first point to the second one.

void cv::circle (InputOutputArray img, Point center, int radius, const Scalar &color, int thickness=1, int lineType=LINE_8, int shift=0)

Draws a circle.

bool cv::clipLine (Rect imgRect, Point &pt1, Point &pt2)

bool cv::clipLine (Size imgSize, Point &pt1, Point &pt2)

Clips the line against the image rectangle.

bool cv::clipLine (Size2l imgSize, Point2l &pt1, Point2l &pt2)

void cv::drawContours (InputOutputArray image, InputArrayOfArrays contours, int contourIdx, const Scalar &color, int thickness=1, int lineType=LINE_8, InputArray hierarchy=noArray(), int maxLevel=INT_MAX, Point offset=Point())

Draws contours outlines or filled contours.

void cv::drawFrameAxes (InputOutputArray image, InputArray cameraMatrix, InputArray distCoeffs, InputArray rvec, InputArray tvec, float length, int thickness=3)

Draw axes of the world/object coordinate system from pose estimation.

void cv::drawMarker (InputOutputArray img, Point position, const Scalar &color, int markerType=MARKER_CROSS, int markerSize=20, int thickness=1, int line_type=8)

Draws a marker on a predefined position in an image.

void cv::ellipse (InputOutputArray img, const RotatedRect &box, const Scalar &color, int thickness=1, int lineType=LINE_8)

void cv::ellipse (InputOutputArray img, Point center, Size axes, double angle, double startAngle, double endAngle, const Scalar &color, int thickness=1, int lineType=LINE_8, int shift=0)

Draws a simple or thick elliptic arc or fills an ellipse sector.

void cv::ellipse2Poly (Point center, Size axes, int angle, int arcStart, int arcEnd, int delta, std::vector< Point > &pts)

Approximates an elliptic arc with a polyline.

void cv::ellipse2Poly (Point2d center, Size2d axes, int angle, int arcStart, int arcEnd, int delta, std::vector< Point2d > &pts)

void cv::fillConvexPoly (InputOutputArray img, const Point *pts, int npts, const Scalar &color, int lineType=LINE_8, int shift=0)

void cv::fillConvexPoly (InputOutputArray img, InputArray points, const Scalar &color, int lineType=LINE_8, int shift=0)

Fills a convex polygon.

void cv::fillPoly (InputOutputArray img, const Point **pts, const int *npts, int ncontours, const Scalar &color, int lineType=LINE_8, int shift=0, Point offset=Point())

void cv::fillPoly (InputOutputArray img, InputArrayOfArrays pts, const Scalar &color, int lineType=LINE_8, int shift=0, Point offset=Point())

Fills the area bounded by one or more polygons.

double cv::getFontScaleFromHeight (const int fontFace, const int pixelHeight, const int thickness=1)

Calculates the font-specific size to use to achieve a given height in pixels.

Size cv::getTextSize (const String &text, int fontFace, double fontScale, int thickness, int *baseLine)

Calculates the width and height of a text string.

Rect cv::getTextSize (Size imgsize, const String &text, Point org, FontFace &fface, int size, int weight=0, PutTextFlags flags=PUT_TEXT_ALIGN_LEFT, Range wrap=Range())

Calculates the bounding rect for the text.

void cv::line (InputOutputArray img, Point pt1, Point pt2, const Scalar &color, int thickness=1, int lineType=LINE_8, int shift=0)

Draws a line segment connecting two points.

void cv::polylines (InputOutputArray img, const Point *const *pts, const int *npts, int ncontours, bool isClosed, const Scalar &color, int thickness=1, int lineType=LINE_8, int shift=0)

void cv::polylines (InputOutputArray img, InputArrayOfArrays pts, bool isClosed, const Scalar &color, int thickness=1, int lineType=LINE_8, int shift=0)

Draws several polygonal curves.

void cv::putText (InputOutputArray img, const String &text, Point org, int fontFace, double fontScale, Scalar color, int thickness=1, int lineType=LINE_8, bool bottomLeftOrigin=false)

Draws a text string.

Point cv::putText (InputOutputArray img, const String &text, Point org, Scalar color, FontFace &fface, int size, int weight=0, PutTextFlags flags=PUT_TEXT_ALIGN_LEFT, Range wrap=Range())

Draws a text string using specified font.

void cv::rectangle (InputOutputArray img, Point pt1, Point pt2, const Scalar &color, int thickness=1, int lineType=LINE_8, int shift=0)

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

void cv::rectangle (InputOutputArray img, Rect rec, const Scalar &color, int thickness=1, int lineType=LINE_8, int shift=0)

void cv::convertMaps (InputArray map1, InputArray map2, OutputArray dstmap1, OutputArray dstmap2, int dstmap1type, bool nninterpolation=false)

Converts image transformation maps from one representation to another.

void cv::getRectSubPix (InputArray image, Size patchSize, Point2f center, OutputArray patch, int patchType=-1)

Retrieves a pixel rectangle from an image with sub-pixel accuracy.

void cv::initInverseRectificationMap (InputArray cameraMatrix, InputArray distCoeffs, InputArray R, InputArray newCameraMatrix, const Size &size, int m1type, OutputArray map1, OutputArray map2)

Computes the projection and inverse-rectification transformation map. In essense, this is the inverse of initUndistortRectifyMap to accomodate stereo-rectification of projectors (‘inverse-cameras’) in projector-camera pairs.

void cv::initUndistortRectifyMap (InputArray cameraMatrix, InputArray distCoeffs, InputArray R, InputArray newCameraMatrix, Size size, int m1type, OutputArray map1, OutputArray map2)

Computes the undistortion and rectification transformation map.

float cv::initWideAngleProjMap (InputArray cameraMatrix, InputArray distCoeffs, Size imageSize, int destImageWidth, int m1type, OutputArray map1, OutputArray map2, enum UndistortTypes projType=PROJ_SPHERICAL_EQRECT, double alpha=0)

initializes maps for remap for wide-angle

static float cv::initWideAngleProjMap (InputArray cameraMatrix, InputArray distCoeffs, Size imageSize, int destImageWidth, int m1type, OutputArray map1, OutputArray map2, int projType, double alpha=0)

void cv::remap (InputArray src, OutputArray dst, InputArray map1, InputArray map2, int interpolation, int borderMode=BORDER_CONSTANT, const Scalar &borderValue=Scalar(), AlgorithmHint hint=cv::ALGO_HINT_DEFAULT)

Applies a generic geometrical transformation to an image.

void cv::resize (InputArray src, OutputArray dst, Size dsize, double fx=0, double fy=0, int interpolation=INTER_LINEAR)

Resizes an image.

void cv::undistort (InputArray src, OutputArray dst, InputArray cameraMatrix, InputArray distCoeffs, InputArray newCameraMatrix=noArray())

Transforms an image to compensate for lens distortion.

void cv::warpAffine (InputArray src, OutputArray dst, InputArray M, Size dsize, int flags=INTER_LINEAR, int borderMode=BORDER_CONSTANT, const Scalar &borderValue=Scalar(), AlgorithmHint hint=cv::ALGO_HINT_DEFAULT)

Applies an affine transformation to an image.

void cv::warpPerspective (InputArray src, OutputArray dst, InputArray M, Size dsize, int flags=INTER_LINEAR, int borderMode=BORDER_CONSTANT, const Scalar &borderValue=Scalar(), AlgorithmHint hint=cv::ALGO_HINT_DEFAULT)

Applies a perspective transformation to an image.

void cv::warpPolar (InputArray src, OutputArray dst, Size dsize, Point2f center, double maxRadius, int flags)

Remaps an image to polar or semilog-polar coordinates space.

void cv::adaptiveThreshold (InputArray src, OutputArray dst, double maxValue, int adaptiveMethod, int thresholdType, int blockSize, double C)

Applies an adaptive threshold to an array.

void cv::blendLinear (InputArray src1, InputArray src2, InputArray weights1, InputArray weights2, OutputArray dst)

void cv::distanceTransform (InputArray src, OutputArray dst, int distanceType, int maskSize, int dstType=CV_32F)

void cv::distanceTransform (InputArray src, OutputArray dst, OutputArray labels, int distanceType, int maskSize, int labelType=DIST_LABEL_CCOMP)

Calculates the distance to the closest zero pixel for each pixel of the source image.

int cv::floodFill (InputOutputArray image, InputOutputArray mask, Point seedPoint, Scalar newVal, Rect *rect=0, Scalar loDiff=Scalar(), Scalar upDiff=Scalar(), int flags=4)

Fills a connected component with the given color.

int cv::floodFill (InputOutputArray image, Point seedPoint, Scalar newVal, Rect *rect=0, Scalar loDiff=Scalar(), Scalar upDiff=Scalar(), int flags=4)

void cv::integral (InputArray src, OutputArray sum, int sdepth=-1)

void cv::integral (InputArray src, OutputArray sum, OutputArray sqsum, int sdepth=-1, int sqdepth=-1)

void cv::integral (InputArray src, OutputArray sum, OutputArray sqsum, OutputArray tilted, int sdepth=-1, int sqdepth=-1)

Calculates the integral of an image.

double cv::threshold (InputArray src, OutputArray dst, double thresh, double maxval, int type)

Applies a fixed-level threshold to each array element.

double cv::thresholdWithMask (InputArray src, InputOutputArray dst, InputArray mask, double thresh, double maxval, int type)

Same as threshold, but with an optional mask.

void cv::accumulate (InputArray src, InputOutputArray dst, InputArray mask=noArray())

Adds an image to the accumulator image.

void cv::accumulateProduct (InputArray src1, InputArray src2, InputOutputArray dst, InputArray mask=noArray())

Adds the per-element product of two input images to the accumulator image.

void cv::accumulateSquare (InputArray src, InputOutputArray dst, InputArray mask=noArray())

Adds the square of a source image to the accumulator image.

void cv::accumulateWeighted (InputArray src, InputOutputArray dst, double alpha, InputArray mask=noArray())

Updates a running average.

void cv::createHanningWindow (OutputArray dst, Size winSize, int type)

This function computes a Hanning window coefficients in two dimensions.

Point2d cv::phaseCorrelate (InputArray src1, InputArray src2, InputArray window=noArray(), double *response=0)

The function is used to detect translational shifts that occur between two images.

Point2d cv::phaseCorrelateIterative (InputArray src1, InputArray src2, int L2size=7, int maxIters=10)

Detects translational shifts between two images.

void cv::applyColorMap (InputArray src, OutputArray dst, InputArray userColor)

Applies a user colormap on a given image.

void cv::applyColorMap (InputArray src, OutputArray dst, int colormap)

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

void cv::bilateralFilter (InputArray src, OutputArray dst, int d, double sigmaColor, double sigmaSpace, int borderType=BORDER_DEFAULT)

Applies the bilateral filter to an image.

void cv::blur (InputArray src, OutputArray dst, Size ksize, Point anchor=Point(-1,-1), int borderType=BORDER_DEFAULT)

Blurs an image using the normalized box filter.

void cv::boxFilter (InputArray src, OutputArray dst, int ddepth, Size ksize, Point anchor=Point(-1,-1), bool normalize=true, int borderType=BORDER_DEFAULT)

Blurs an image using the box filter.

void cv::buildPyramid (InputArray src, OutputArrayOfArrays dst, int maxlevel, int borderType=BORDER_DEFAULT)

Constructs the Gaussian pyramid for an image.

void cv::dilate (InputArray src, OutputArray dst, InputArray kernel, Point anchor=Point(-1,-1), int iterations=1, int borderType=BORDER_CONSTANT, const Scalar &borderValue=morphologyDefaultBorderValue())

Dilates an image by using a specific structuring element.

void cv::erode (InputArray src, OutputArray dst, InputArray kernel, Point anchor=Point(-1,-1), int iterations=1, int borderType=BORDER_CONSTANT, const Scalar &borderValue=morphologyDefaultBorderValue())

Erodes an image by using a specific structuring element.

void cv::filter2D (InputArray src, OutputArray dst, InputArray kernel, const Filter2DParams &params=Filter2DParams())

void cv::filter2D (InputArray src, OutputArray dst, int ddepth, InputArray kernel, Point anchor=Point(-1,-1), double delta=0, int borderType=BORDER_DEFAULT)

Convolves an image with the kernel.

void cv::GaussianBlur (InputArray src, OutputArray dst, Size ksize, double sigmaX, double sigmaY=0, int borderType=BORDER_DEFAULT, AlgorithmHint hint=cv::ALGO_HINT_DEFAULT)

Blurs an image using a Gaussian filter.

void cv::getDerivKernels (OutputArray kx, OutputArray ky, int dx, int dy, int ksize, bool normalize=false, int ktype=CV_32F)

Returns filter coefficients for computing spatial image derivatives.

Mat cv::getGaborKernel (Size ksize, double sigma, double theta, double lambd, double gamma, double psi=CV_PI *0.5, int ktype=CV_64F)

Returns Gabor filter coefficients.

Mat cv::getGaussianKernel (int ksize, double sigma, int ktype=CV_64F)

Returns Gaussian filter coefficients.

Mat cv::getStructuringElement (int shape, Size ksize, Point anchor=Point(-1,-1))

Returns a structuring element of the specified size and shape for morphological operations.

void cv::Laplacian (InputArray src, OutputArray dst, int ddepth, int ksize=1, double scale=1, double delta=0, int borderType=BORDER_DEFAULT)

Calculates the Laplacian of an image.

void cv::medianBlur (InputArray src, OutputArray dst, int ksize)

Blurs an image using the median filter.

static Scalar cv::morphologyDefaultBorderValue ()

returns “magic” border value for erosion and dilation. It is automatically transformed to Scalar::all(-DBL_MAX) for dilation.

void cv::morphologyEx (InputArray src, OutputArray dst, int op, InputArray kernel, Point anchor=Point(-1,-1), int iterations=1, int borderType=BORDER_CONSTANT, const Scalar &borderValue=morphologyDefaultBorderValue())

Performs advanced morphological transformations.

void cv::pyrDown (InputArray src, OutputArray dst, const Size &dstsize=Size(), int borderType=BORDER_DEFAULT)

Blurs an image and downsamples it.

void cv::pyrMeanShiftFiltering (InputArray src, OutputArray dst, double sp, double sr, int maxLevel=1, TermCriteria termcrit=TermCriteria(TermCriteria::MAX_ITER+TermCriteria::EPS, 5, 1))

Performs initial step of meanshift segmentation of an image.

void cv::pyrUp (InputArray src, OutputArray dst, const Size &dstsize=Size(), int borderType=BORDER_DEFAULT)

Upsamples an image and then blurs it.

void cv::Scharr (InputArray src, OutputArray dst, int ddepth, int dx, int dy, double scale=1, double delta=0, int borderType=BORDER_DEFAULT)

Calculates the first x- or y- image derivative using Scharr operator.

void cv::sepFilter2D (InputArray src, OutputArray dst, int ddepth, InputArray kernelX, InputArray kernelY, Point anchor=Point(-1,-1), double delta=0, int borderType=BORDER_DEFAULT)

Applies a separable linear filter to an image.

void cv::Sobel (InputArray src, OutputArray dst, int ddepth, int dx, int dy, int ksize=3, double scale=1, double delta=0, int borderType=BORDER_DEFAULT)

Calculates the first, second, third, or mixed image derivatives using an extended Sobel operator.

void cv::spatialGradient (InputArray src, OutputArray dx, OutputArray dy, int ksize=3, int borderType=BORDER_DEFAULT)

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

void cv::sqrBoxFilter (InputArray src, OutputArray dst, int ddepth, Size ksize, Point anchor=Point(-1, -1), bool normalize=true, int borderType=BORDER_DEFAULT)

Calculates the normalized sum of squares of the pixel values overlapping the filter.

void cv::stackBlur (InputArray src, OutputArray dst, Size ksize)

Blurs an image using the stackBlur.

void cv::grabCut (InputArray img, InputOutputArray mask, Rect rect, InputOutputArray bgdModel, InputOutputArray fgdModel, int iterCount, int mode=GC_EVAL)

Runs the GrabCut algorithm.

void cv::watershed (InputArray image, InputOutputArray markers)

Performs a marker-based image segmentation using the watershed algorithm.

int cv::connectedComponents (InputArray image, OutputArray labels, int connectivity, int ltype, int ccltype)

computes the connected components labeled image of boolean image

int cv::connectedComponents (InputArray image, OutputArray labels, int connectivity=8, int ltype=CV_32S)

int cv::connectedComponentsWithStats (InputArray image, OutputArray labels, OutputArray stats, OutputArray centroids, int connectivity, int ltype, int ccltype)

computes the connected components labeled image of boolean image and also produces a statistics output for each label

int cv::connectedComponentsWithStats (InputArray image, OutputArray labels, OutputArray stats, OutputArray centroids, int connectivity=8, int ltype=CV_32S)

Ptr< GeneralizedHoughBallard > cv::createGeneralizedHoughBallard ()

Creates a smart pointer to a cv::GeneralizedHoughBallard class and initializes it.

Ptr< GeneralizedHoughGuil > cv::createGeneralizedHoughGuil ()

Creates a smart pointer to a cv::GeneralizedHoughGuil class and initializes it.

void cv::findContours (InputArray image, OutputArrayOfArrays contours, int mode, int method, Point offset=Point())

void cv::findContours (InputArray image, OutputArrayOfArrays contours, OutputArray hierarchy, int mode, int method, Point offset=Point())

Finds contours in a binary image.

void cv::findContoursLinkRuns (InputArray image, OutputArrayOfArrays contours)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

void cv::findContoursLinkRuns (InputArray image, OutputArrayOfArrays contours, OutputArray hierarchy)

Find contours using link runs algorithm.