namespace cv

Overview

namespace cv {

// namespaces

namespace cv::Error;
namespace cv::cuda;
namespace cv::cudacodec;
namespace cv::cudev;
    namespace cv::cudev::functional_detail;
    namespace cv::cudev::vec_math_detail;
namespace cv::detail;
namespace cv::directx;
    namespace cv::directx::ocl;
namespace cv::fisheye;
namespace cv::flann;
namespace cv::hal;
namespace cv::hpp;
namespace cv::instr;
namespace cv::ml;
namespace cv::ocl;
namespace cv::ogl;
    namespace cv::ogl::ocl;
namespace cv::superres;
namespace cv::va_intel;
    namespace cv::va_intel::ocl;
namespace cv::videostab;
namespace cv::viz;

// typedefs

typedef Vec<uchar, 2> Vec2b;
typedef Vec<uchar, 3> Vec3b;
typedef Vec<uchar, 4> Vec4b;
typedef Vec<short, 2> Vec2s;
typedef Vec<short, 3> Vec3s;
typedef Vec<short, 4> Vec4s;
typedef Vec<ushort, 2> Vec2w;
typedef Vec<ushort, 3> Vec3w;
typedef Vec<ushort, 4> Vec4w;
typedef Vec<int, 2> Vec2i;
typedef Vec<int, 3> Vec3i;
typedef Vec<int, 4> Vec4i;
typedef Vec<int, 6> Vec6i;
typedef Vec<int, 8> Vec8i;
typedef Vec<float, 2> Vec2f;
typedef Vec<float, 3> Vec3f;
typedef Vec<float, 4> Vec4f;
typedef Vec<float, 6> Vec6f;
typedef Vec<double, 2> Vec2d;
typedef Vec<double, 3> Vec3d;
typedef Vec<double, 4> Vec4d;
typedef Vec<double, 6> Vec6d;
typedef Affine3<double> Affine3d;
typedef Affine3<float> Affine3f;

typedef void (*ButtonCallback)(
    int state,
    void *userdata
    );

typedef Complex<double> Complexd;
typedef Complex<float> Complexf;
typedef Feature2D DescriptorExtractor;

typedef int (*ErrorCallback)(
    int status,
    const char *func_name,
    const char *err_msg,
    const char *file_name,
    int line,
    void *userdata
    );

typedef Feature2D FeatureDetector;
typedef Hamming HammingLUT;
typedef const _InputArray& InputArray;
typedef InputArray InputArrayOfArrays;
typedef const _InputOutputArray& InputOutputArray;
typedef InputOutputArray InputOutputArrayOfArrays;
typedef Mat_<uchar> Mat1b;
typedef Mat_<double> Mat1d;
typedef Mat_<float> Mat1f;
typedef Mat_<int> Mat1i;
typedef Mat_<short> Mat1s;
typedef Mat_<ushort> Mat1w;
typedef Mat_<Vec2b> Mat2b;
typedef Mat_<Vec2d> Mat2d;
typedef Mat_<Vec2f> Mat2f;
typedef Mat_<Vec2i> Mat2i;
typedef Mat_<Vec2s> Mat2s;
typedef Mat_<Vec2w> Mat2w;
typedef Mat_<Vec3b> Mat3b;
typedef Mat_<Vec3d> Mat3d;
typedef Mat_<Vec3f> Mat3f;
typedef Mat_<Vec3i> Mat3i;
typedef Mat_<Vec3s> Mat3s;
typedef Mat_<Vec3w> Mat3w;
typedef Mat_<Vec4b> Mat4b;
typedef Mat_<Vec4d> Mat4d;
typedef Mat_<Vec4f> Mat4f;
typedef Mat_<Vec4i> Mat4i;
typedef Mat_<Vec4s> Mat4s;
typedef Mat_<Vec4w> Mat4w;
typedef Matx<double, 1, 2> Matx12d;
typedef Matx<float, 1, 2> Matx12f;
typedef Matx<double, 1, 3> Matx13d;
typedef Matx<float, 1, 3> Matx13f;
typedef Matx<double, 1, 4> Matx14d;
typedef Matx<float, 1, 4> Matx14f;
typedef Matx<double, 1, 6> Matx16d;
typedef Matx<float, 1, 6> Matx16f;
typedef Matx<double, 2, 1> Matx21d;
typedef Matx<float, 2, 1> Matx21f;
typedef Matx<double, 2, 2> Matx22d;
typedef Matx<float, 2, 2> Matx22f;
typedef Matx<double, 2, 3> Matx23d;
typedef Matx<float, 2, 3> Matx23f;
typedef Matx<double, 3, 1> Matx31d;
typedef Matx<float, 3, 1> Matx31f;
typedef Matx<double, 3, 2> Matx32d;
typedef Matx<float, 3, 2> Matx32f;
typedef Matx<double, 3, 3> Matx33d;
typedef Matx<float, 3, 3> Matx33f;
typedef Matx<double, 3, 4> Matx34d;
typedef Matx<float, 3, 4> Matx34f;
typedef Matx<double, 4, 1> Matx41d;
typedef Matx<float, 4, 1> Matx41f;
typedef Matx<double, 4, 3> Matx43d;
typedef Matx<float, 4, 3> Matx43f;
typedef Matx<double, 4, 4> Matx44d;
typedef Matx<float, 4, 4> Matx44f;
typedef Matx<double, 6, 1> Matx61d;
typedef Matx<float, 6, 1> Matx61f;
typedef Matx<double, 6, 6> Matx66d;
typedef Matx<float, 6, 6> Matx66f;
typedef Ptr<CvMemStorage> MemStorage;

typedef void (*MouseCallback)(
    int event,
    int x,
    int y,
    int flags,
    void *userdata
    );

typedef void (*OpenGlDrawCallback)(void *userdata);
typedef const _OutputArray& OutputArray;
typedef OutputArray OutputArrayOfArrays;
typedef Point2i Point;
typedef Point_<double> Point2d;
typedef Point_<float> Point2f;
typedef Point_<int> Point2i;
typedef Point_<int64> Point2l;
typedef Point3_<double> Point3d;
typedef Point3_<float> Point3f;
typedef Point3_<int> Point3i;
typedef Rect2i Rect;
typedef Rect_<double> Rect2d;
typedef Rect_<float> Rect2f;
typedef Rect_<int> Rect2i;
typedef Scalar_<double> Scalar;
typedef Size2i Size;
typedef Size_<double> Size2d;
typedef Size_<float> Size2f;
typedef Size_<int> Size2i;
typedef Size_<int64> Size2l;

typedef void (*TrackbarCallback)(
    int pos,
    void *userdata
    );

typedef v_reg<float, 4> v_float32x4;
typedef v_reg<double, 2> v_float64x2;
typedef v_reg<short, 8> v_int16x8;
typedef v_reg<int, 4> v_int32x4;
typedef v_reg<int64, 2> v_int64x2;
typedef v_reg<schar, 16> v_int8x16;
typedef v_reg<ushort, 8> v_uint16x8;
typedef v_reg<unsigned, 4> v_uint32x4;
typedef v_reg<uint64, 2> v_uint64x2;
typedef v_reg<uchar, 16> v_uint8x16;
typedef WImageC<short, 1> WImage1_16s;
typedef WImageC<ushort, 1> WImage1_16u;
typedef WImageC<uchar, 1> WImage1_b;
typedef WImageC<float, 1> WImage1_f;
typedef WImageC<short, 3> WImage3_16s;
typedef WImageC<ushort, 3> WImage3_16u;
typedef WImageC<uchar, 3> WImage3_b;
typedef WImageC<float, 3> WImage3_f;
typedef WImage<short> WImage_16s;
typedef WImage<ushort> WImage_16u;
typedef WImage<uchar> WImage_b;
typedef WImage<float> WImage_f;
typedef WImageBufferC<short, 1> WImageBuffer1_16s;
typedef WImageBufferC<ushort, 1> WImageBuffer1_16u;
typedef WImageBufferC<uchar, 1> WImageBuffer1_b;
typedef WImageBufferC<float, 1> WImageBuffer1_f;
typedef WImageBufferC<short, 3> WImageBuffer3_16s;
typedef WImageBufferC<ushort, 3> WImageBuffer3_16u;
typedef WImageBufferC<uchar, 3> WImageBuffer3_b;
typedef WImageBufferC<float, 3> WImageBuffer3_f;
typedef WImageBuffer<short> WImageBuffer_16s;
typedef WImageBuffer<ushort> WImageBuffer_16u;
typedef WImageBuffer<uchar> WImageBuffer_b;
typedef WImageBuffer<float> WImageBuffer_f;
typedef WImageViewC<short, 1> WImageView1_16s;
typedef WImageViewC<ushort, 1> WImageView1_16u;
typedef WImageViewC<uchar, 1> WImageView1_b;
typedef WImageViewC<float, 1> WImageView1_f;
typedef WImageViewC<short, 3> WImageView3_16s;
typedef WImageViewC<ushort, 3> WImageView3_16u;
typedef WImageViewC<uchar, 3> WImageView3_b;
typedef WImageViewC<float, 3> WImageView3_f;
typedef WImageView<short> WImageView_16s;
typedef WImageView<ushort> WImageView_16u;
typedef WImageView<uchar> WImageView_b;
typedef WImageView<float> WImageView_f;

// enums

enum
{
    OPEN_CAMERA          = 300,
    CLOSE_CAMERA,
    UPDATE_IMAGE_ELEMENT,
    SHOW_TRACKBAR,
};

enum
{
    CAP_PROP_DC1394_OFF                = -4,
    CAP_PROP_DC1394_MODE_MANUAL        = -3,
    CAP_PROP_DC1394_MODE_AUTO          = -2,
    CAP_PROP_DC1394_MODE_ONE_PUSH_AUTO = -1,
    CAP_PROP_DC1394_MAX                = 31,
};

enum
{
    CAP_OPENNI_DEPTH_GENERATOR = 1 <<31,
    CAP_OPENNI_IMAGE_GENERATOR = 1 <<30,
    CAP_OPENNI_IR_GENERATOR    = 1 <<29,
    CAP_OPENNI_GENERATORS_MASK = CAP_OPENNI_DEPTH_GENERATOR + CAP_OPENNI_IMAGE_GENERATOR + CAP_OPENNI_IR_GENERATOR,
};

enum
{
    CAP_PROP_OPENNI_OUTPUT_MODE       = 100,
    CAP_PROP_OPENNI_FRAME_MAX_DEPTH   = 101,
    CAP_PROP_OPENNI_BASELINE          = 102,
    CAP_PROP_OPENNI_FOCAL_LENGTH      = 103,
    CAP_PROP_OPENNI_REGISTRATION      = 104,
    CAP_PROP_OPENNI_REGISTRATION_ON   = CAP_PROP_OPENNI_REGISTRATION,
    CAP_PROP_OPENNI_APPROX_FRAME_SYNC = 105,
    CAP_PROP_OPENNI_MAX_BUFFER_SIZE   = 106,
    CAP_PROP_OPENNI_CIRCLE_BUFFER     = 107,
    CAP_PROP_OPENNI_MAX_TIME_DURATION = 108,
    CAP_PROP_OPENNI_GENERATOR_PRESENT = 109,
    CAP_PROP_OPENNI2_SYNC             = 110,
    CAP_PROP_OPENNI2_MIRROR           = 111,
};

enum
{
    CAP_OPENNI_IMAGE_GENERATOR_PRESENT         = CAP_OPENNI_IMAGE_GENERATOR + CAP_PROP_OPENNI_GENERATOR_PRESENT,
    CAP_OPENNI_IMAGE_GENERATOR_OUTPUT_MODE     = CAP_OPENNI_IMAGE_GENERATOR + CAP_PROP_OPENNI_OUTPUT_MODE,
    CAP_OPENNI_DEPTH_GENERATOR_PRESENT         = CAP_OPENNI_DEPTH_GENERATOR + CAP_PROP_OPENNI_GENERATOR_PRESENT,
    CAP_OPENNI_DEPTH_GENERATOR_BASELINE        = CAP_OPENNI_DEPTH_GENERATOR + CAP_PROP_OPENNI_BASELINE,
    CAP_OPENNI_DEPTH_GENERATOR_FOCAL_LENGTH    = CAP_OPENNI_DEPTH_GENERATOR + CAP_PROP_OPENNI_FOCAL_LENGTH,
    CAP_OPENNI_DEPTH_GENERATOR_REGISTRATION    = CAP_OPENNI_DEPTH_GENERATOR + CAP_PROP_OPENNI_REGISTRATION,
    CAP_OPENNI_DEPTH_GENERATOR_REGISTRATION_ON = CAP_OPENNI_DEPTH_GENERATOR_REGISTRATION,
    CAP_OPENNI_IR_GENERATOR_PRESENT            = CAP_OPENNI_IR_GENERATOR + CAP_PROP_OPENNI_GENERATOR_PRESENT,
};

enum
{
    CAP_OPENNI_DEPTH_MAP         = 0,
    CAP_OPENNI_POINT_CLOUD_MAP   = 1,
    CAP_OPENNI_DISPARITY_MAP     = 2,
    CAP_OPENNI_DISPARITY_MAP_32F = 3,
    CAP_OPENNI_VALID_DEPTH_MASK  = 4,
    CAP_OPENNI_BGR_IMAGE         = 5,
    CAP_OPENNI_GRAY_IMAGE        = 6,
    CAP_OPENNI_IR_IMAGE          = 7,
};

enum
{
    CAP_OPENNI_VGA_30HZ  = 0,
    CAP_OPENNI_SXGA_15HZ = 1,
    CAP_OPENNI_SXGA_30HZ = 2,
    CAP_OPENNI_QVGA_30HZ = 3,
    CAP_OPENNI_QVGA_60HZ = 4,
};

enum
{
    CAP_PROP_GSTREAMER_QUEUE_LENGTH = 200,
};

enum
{
    CAP_PROP_PVAPI_MULTICASTIP           = 300,
    CAP_PROP_PVAPI_FRAMESTARTTRIGGERMODE = 301,
    CAP_PROP_PVAPI_DECIMATIONHORIZONTAL  = 302,
    CAP_PROP_PVAPI_DECIMATIONVERTICAL    = 303,
    CAP_PROP_PVAPI_BINNINGX              = 304,
    CAP_PROP_PVAPI_BINNINGY              = 305,
    CAP_PROP_PVAPI_PIXELFORMAT           = 306,
};

enum
{
    CAP_PVAPI_FSTRIGMODE_FREERUN   = 0,
    CAP_PVAPI_FSTRIGMODE_SYNCIN1   = 1,
    CAP_PVAPI_FSTRIGMODE_SYNCIN2   = 2,
    CAP_PVAPI_FSTRIGMODE_FIXEDRATE = 3,
    CAP_PVAPI_FSTRIGMODE_SOFTWARE  = 4,
};

enum
{
    CAP_PVAPI_DECIMATION_OFF      = 1,
    CAP_PVAPI_DECIMATION_2OUTOF4  = 2,
    CAP_PVAPI_DECIMATION_2OUTOF8  = 4,
    CAP_PVAPI_DECIMATION_2OUTOF16 = 8,
};

enum
{
    CAP_PVAPI_PIXELFORMAT_MONO8   = 1,
    CAP_PVAPI_PIXELFORMAT_MONO16  = 2,
    CAP_PVAPI_PIXELFORMAT_BAYER8  = 3,
    CAP_PVAPI_PIXELFORMAT_BAYER16 = 4,
    CAP_PVAPI_PIXELFORMAT_RGB24   = 5,
    CAP_PVAPI_PIXELFORMAT_BGR24   = 6,
    CAP_PVAPI_PIXELFORMAT_RGBA32  = 7,
    CAP_PVAPI_PIXELFORMAT_BGRA32  = 8,
};

enum
{
    CAP_PROP_XI_DOWNSAMPLING                    = 400,
    CAP_PROP_XI_DATA_FORMAT                     = 401,
    CAP_PROP_XI_OFFSET_X                        = 402,
    CAP_PROP_XI_OFFSET_Y                        = 403,
    CAP_PROP_XI_TRG_SOURCE                      = 404,
    CAP_PROP_XI_TRG_SOFTWARE                    = 405,
    CAP_PROP_XI_GPI_SELECTOR                    = 406,
    CAP_PROP_XI_GPI_MODE                        = 407,
    CAP_PROP_XI_GPI_LEVEL                       = 408,
    CAP_PROP_XI_GPO_SELECTOR                    = 409,
    CAP_PROP_XI_GPO_MODE                        = 410,
    CAP_PROP_XI_LED_SELECTOR                    = 411,
    CAP_PROP_XI_LED_MODE                        = 412,
    CAP_PROP_XI_MANUAL_WB                       = 413,
    CAP_PROP_XI_AUTO_WB                         = 414,
    CAP_PROP_XI_AEAG                            = 415,
    CAP_PROP_XI_EXP_PRIORITY                    = 416,
    CAP_PROP_XI_AE_MAX_LIMIT                    = 417,
    CAP_PROP_XI_AG_MAX_LIMIT                    = 418,
    CAP_PROP_XI_AEAG_LEVEL                      = 419,
    CAP_PROP_XI_TIMEOUT                         = 420,
    CAP_PROP_XI_EXPOSURE                        = 421,
    CAP_PROP_XI_EXPOSURE_BURST_COUNT            = 422,
    CAP_PROP_XI_GAIN_SELECTOR                   = 423,
    CAP_PROP_XI_GAIN                            = 424,
    CAP_PROP_XI_DOWNSAMPLING_TYPE               = 426,
    CAP_PROP_XI_BINNING_SELECTOR                = 427,
    CAP_PROP_XI_BINNING_VERTICAL                = 428,
    CAP_PROP_XI_BINNING_HORIZONTAL              = 429,
    CAP_PROP_XI_BINNING_PATTERN                 = 430,
    CAP_PROP_XI_DECIMATION_SELECTOR             = 431,
    CAP_PROP_XI_DECIMATION_VERTICAL             = 432,
    CAP_PROP_XI_DECIMATION_HORIZONTAL           = 433,
    CAP_PROP_XI_DECIMATION_PATTERN              = 434,
    CAP_PROP_XI_TEST_PATTERN_GENERATOR_SELECTOR = 587,
    CAP_PROP_XI_TEST_PATTERN                    = 588,
    CAP_PROP_XI_IMAGE_DATA_FORMAT               = 435,
    CAP_PROP_XI_SHUTTER_TYPE                    = 436,
    CAP_PROP_XI_SENSOR_TAPS                     = 437,
    CAP_PROP_XI_AEAG_ROI_OFFSET_X               = 439,
    CAP_PROP_XI_AEAG_ROI_OFFSET_Y               = 440,
    CAP_PROP_XI_AEAG_ROI_WIDTH                  = 441,
    CAP_PROP_XI_AEAG_ROI_HEIGHT                 = 442,
    CAP_PROP_XI_BPC                             = 445,
    CAP_PROP_XI_WB_KR                           = 448,
    CAP_PROP_XI_WB_KG                           = 449,
    CAP_PROP_XI_WB_KB                           = 450,
    CAP_PROP_XI_WIDTH                           = 451,
    CAP_PROP_XI_HEIGHT                          = 452,
    CAP_PROP_XI_REGION_SELECTOR                 = 589,
    CAP_PROP_XI_REGION_MODE                     = 595,
    CAP_PROP_XI_LIMIT_BANDWIDTH                 = 459,
    CAP_PROP_XI_SENSOR_DATA_BIT_DEPTH           = 460,
    CAP_PROP_XI_OUTPUT_DATA_BIT_DEPTH           = 461,
    CAP_PROP_XI_IMAGE_DATA_BIT_DEPTH            = 462,
    CAP_PROP_XI_OUTPUT_DATA_PACKING             = 463,
    CAP_PROP_XI_OUTPUT_DATA_PACKING_TYPE        = 464,
    CAP_PROP_XI_IS_COOLED                       = 465,
    CAP_PROP_XI_COOLING                         = 466,
    CAP_PROP_XI_TARGET_TEMP                     = 467,
    CAP_PROP_XI_CHIP_TEMP                       = 468,
    CAP_PROP_XI_HOUS_TEMP                       = 469,
    CAP_PROP_XI_HOUS_BACK_SIDE_TEMP             = 590,
    CAP_PROP_XI_SENSOR_BOARD_TEMP               = 596,
    CAP_PROP_XI_CMS                             = 470,
    CAP_PROP_XI_APPLY_CMS                       = 471,
    CAP_PROP_XI_IMAGE_IS_COLOR                  = 474,
    CAP_PROP_XI_COLOR_FILTER_ARRAY              = 475,
    CAP_PROP_XI_GAMMAY                          = 476,
    CAP_PROP_XI_GAMMAC                          = 477,
    CAP_PROP_XI_SHARPNESS                       = 478,
    CAP_PROP_XI_CC_MATRIX_00                    = 479,
    CAP_PROP_XI_CC_MATRIX_01                    = 480,
    CAP_PROP_XI_CC_MATRIX_02                    = 481,
    CAP_PROP_XI_CC_MATRIX_03                    = 482,
    CAP_PROP_XI_CC_MATRIX_10                    = 483,
    CAP_PROP_XI_CC_MATRIX_11                    = 484,
    CAP_PROP_XI_CC_MATRIX_12                    = 485,
    CAP_PROP_XI_CC_MATRIX_13                    = 486,
    CAP_PROP_XI_CC_MATRIX_20                    = 487,
    CAP_PROP_XI_CC_MATRIX_21                    = 488,
    CAP_PROP_XI_CC_MATRIX_22                    = 489,
    CAP_PROP_XI_CC_MATRIX_23                    = 490,
    CAP_PROP_XI_CC_MATRIX_30                    = 491,
    CAP_PROP_XI_CC_MATRIX_31                    = 492,
    CAP_PROP_XI_CC_MATRIX_32                    = 493,
    CAP_PROP_XI_CC_MATRIX_33                    = 494,
    CAP_PROP_XI_DEFAULT_CC_MATRIX               = 495,
    CAP_PROP_XI_TRG_SELECTOR                    = 498,
    CAP_PROP_XI_ACQ_FRAME_BURST_COUNT           = 499,
    CAP_PROP_XI_DEBOUNCE_EN                     = 507,
    CAP_PROP_XI_DEBOUNCE_T0                     = 508,
    CAP_PROP_XI_DEBOUNCE_T1                     = 509,
    CAP_PROP_XI_DEBOUNCE_POL                    = 510,
    CAP_PROP_XI_LENS_MODE                       = 511,
    CAP_PROP_XI_LENS_APERTURE_VALUE             = 512,
    CAP_PROP_XI_LENS_FOCUS_MOVEMENT_VALUE       = 513,
    CAP_PROP_XI_LENS_FOCUS_MOVE                 = 514,
    CAP_PROP_XI_LENS_FOCUS_DISTANCE             = 515,
    CAP_PROP_XI_LENS_FOCAL_LENGTH               = 516,
    CAP_PROP_XI_LENS_FEATURE_SELECTOR           = 517,
    CAP_PROP_XI_LENS_FEATURE                    = 518,
    CAP_PROP_XI_DEVICE_MODEL_ID                 = 521,
    CAP_PROP_XI_DEVICE_SN                       = 522,
    CAP_PROP_XI_IMAGE_DATA_FORMAT_RGB32_ALPHA   = 529,
    CAP_PROP_XI_IMAGE_PAYLOAD_SIZE              = 530,
    CAP_PROP_XI_TRANSPORT_PIXEL_FORMAT          = 531,
    CAP_PROP_XI_SENSOR_CLOCK_FREQ_HZ            = 532,
    CAP_PROP_XI_SENSOR_CLOCK_FREQ_INDEX         = 533,
    CAP_PROP_XI_SENSOR_OUTPUT_CHANNEL_COUNT     = 534,
    CAP_PROP_XI_FRAMERATE                       = 535,
    CAP_PROP_XI_COUNTER_SELECTOR                = 536,
    CAP_PROP_XI_COUNTER_VALUE                   = 537,
    CAP_PROP_XI_ACQ_TIMING_MODE                 = 538,
    CAP_PROP_XI_AVAILABLE_BANDWIDTH             = 539,
    CAP_PROP_XI_BUFFER_POLICY                   = 540,
    CAP_PROP_XI_LUT_EN                          = 541,
    CAP_PROP_XI_LUT_INDEX                       = 542,
    CAP_PROP_XI_LUT_VALUE                       = 543,
    CAP_PROP_XI_TRG_DELAY                       = 544,
    CAP_PROP_XI_TS_RST_MODE                     = 545,
    CAP_PROP_XI_TS_RST_SOURCE                   = 546,
    CAP_PROP_XI_IS_DEVICE_EXIST                 = 547,
    CAP_PROP_XI_ACQ_BUFFER_SIZE                 = 548,
    CAP_PROP_XI_ACQ_BUFFER_SIZE_UNIT            = 549,
    CAP_PROP_XI_ACQ_TRANSPORT_BUFFER_SIZE       = 550,
    CAP_PROP_XI_BUFFERS_QUEUE_SIZE              = 551,
    CAP_PROP_XI_ACQ_TRANSPORT_BUFFER_COMMIT     = 552,
    CAP_PROP_XI_RECENT_FRAME                    = 553,
    CAP_PROP_XI_DEVICE_RESET                    = 554,
    CAP_PROP_XI_COLUMN_FPN_CORRECTION           = 555,
    CAP_PROP_XI_ROW_FPN_CORRECTION              = 591,
    CAP_PROP_XI_SENSOR_MODE                     = 558,
    CAP_PROP_XI_HDR                             = 559,
    CAP_PROP_XI_HDR_KNEEPOINT_COUNT             = 560,
    CAP_PROP_XI_HDR_T1                          = 561,
    CAP_PROP_XI_HDR_T2                          = 562,
    CAP_PROP_XI_KNEEPOINT1                      = 563,
    CAP_PROP_XI_KNEEPOINT2                      = 564,
    CAP_PROP_XI_IMAGE_BLACK_LEVEL               = 565,
    CAP_PROP_XI_HW_REVISION                     = 571,
    CAP_PROP_XI_DEBUG_LEVEL                     = 572,
    CAP_PROP_XI_AUTO_BANDWIDTH_CALCULATION      = 573,
    CAP_PROP_XI_FFS_FILE_ID                     = 594,
    CAP_PROP_XI_FFS_FILE_SIZE                   = 580,
    CAP_PROP_XI_FREE_FFS_SIZE                   = 581,
    CAP_PROP_XI_USED_FFS_SIZE                   = 582,
    CAP_PROP_XI_FFS_ACCESS_KEY                  = 583,
    CAP_PROP_XI_SENSOR_FEATURE_SELECTOR         = 585,
    CAP_PROP_XI_SENSOR_FEATURE_VALUE            = 586,
};

enum
{
    CAP_PROP_IOS_DEVICE_FOCUS        = 9001,
    CAP_PROP_IOS_DEVICE_EXPOSURE     = 9002,
    CAP_PROP_IOS_DEVICE_FLASH        = 9003,
    CAP_PROP_IOS_DEVICE_WHITEBALANCE = 9004,
    CAP_PROP_IOS_DEVICE_TORCH        = 9005,
};

enum
{
    CAP_PROP_GIGA_FRAME_OFFSET_X   = 10001,
    CAP_PROP_GIGA_FRAME_OFFSET_Y   = 10002,
    CAP_PROP_GIGA_FRAME_WIDTH_MAX  = 10003,
    CAP_PROP_GIGA_FRAME_HEIGH_MAX  = 10004,
    CAP_PROP_GIGA_FRAME_SENS_WIDTH = 10005,
    CAP_PROP_GIGA_FRAME_SENS_HEIGH = 10006,
};

enum
{
    CAP_PROP_INTELPERC_PROFILE_COUNT              = 11001,
    CAP_PROP_INTELPERC_PROFILE_IDX                = 11002,
    CAP_PROP_INTELPERC_DEPTH_LOW_CONFIDENCE_VALUE = 11003,
    CAP_PROP_INTELPERC_DEPTH_SATURATION_VALUE     = 11004,
    CAP_PROP_INTELPERC_DEPTH_CONFIDENCE_THRESHOLD = 11005,
    CAP_PROP_INTELPERC_DEPTH_FOCAL_LENGTH_HORZ    = 11006,
    CAP_PROP_INTELPERC_DEPTH_FOCAL_LENGTH_VERT    = 11007,
};

enum
{
    CAP_INTELPERC_DEPTH_GENERATOR = 1 <<29,
    CAP_INTELPERC_IMAGE_GENERATOR = 1 <<28,
    CAP_INTELPERC_GENERATORS_MASK = CAP_INTELPERC_DEPTH_GENERATOR + CAP_INTELPERC_IMAGE_GENERATOR,
};

enum
{
    CAP_INTELPERC_DEPTH_MAP   = 0,
    CAP_INTELPERC_UVDEPTH_MAP = 1,
    CAP_INTELPERC_IR_MAP      = 2,
    CAP_INTELPERC_IMAGE       = 3,
};

enum
{
    CAP_PROP_GPHOTO2_PREVIEW          = 17001,
    CAP_PROP_GPHOTO2_WIDGET_ENUMERATE = 17002,
    CAP_PROP_GPHOTO2_RELOAD_CONFIG    = 17003,
    CAP_PROP_GPHOTO2_RELOAD_ON_CHANGE = 17004,
    CAP_PROP_GPHOTO2_COLLECT_MSGS     = 17005,
    CAP_PROP_GPHOTO2_FLUSH_MSGS       = 17006,
    CAP_PROP_SPEED                    = 17007,
    CAP_PROP_APERTURE                 = 17008,
    CAP_PROP_EXPOSUREPROGRAM          = 17009,
    CAP_PROP_VIEWFINDER               = 17010,
};

enum
{
    CAP_PROP_IMAGES_BASE = 18000,
    CAP_PROP_IMAGES_LAST = 19000,
};

enum
{
    OPTFLOW_USE_INITIAL_FLOW     = 4,
    OPTFLOW_LK_GET_MIN_EIGENVALS = 8,
    OPTFLOW_FARNEBACK_GAUSSIAN   = 256,
};

enum
{
    MOTION_TRANSLATION = 0,
    MOTION_EUCLIDEAN   = 1,
    MOTION_AFFINE      = 2,
    MOTION_HOMOGRAPHY  = 3,
};

enum
{
    LMEDS  = 4,
    RANSAC = 8,
    RHO    = 16,
};

enum
{
    SOLVEPNP_ITERATIVE = 0,
    SOLVEPNP_EPNP      = 1,
    SOLVEPNP_P3P       = 2,
    SOLVEPNP_DLS       = 3,
    SOLVEPNP_UPNP      = 4,
    SOLVEPNP_AP3P      = 5,
};

enum
{
    CALIB_CB_ADAPTIVE_THRESH = 1,
    CALIB_CB_NORMALIZE_IMAGE = 2,
    CALIB_CB_FILTER_QUADS    = 4,
    CALIB_CB_FAST_CHECK      = 8,
};

enum
{
    CALIB_CB_SYMMETRIC_GRID  = 1,
    CALIB_CB_ASYMMETRIC_GRID = 2,
    CALIB_CB_CLUSTERING      = 4,
};

enum
{
    CALIB_USE_INTRINSIC_GUESS = 0x00001,
    CALIB_FIX_ASPECT_RATIO    = 0x00002,
    CALIB_FIX_PRINCIPAL_POINT = 0x00004,
    CALIB_ZERO_TANGENT_DIST   = 0x00008,
    CALIB_FIX_FOCAL_LENGTH    = 0x00010,
    CALIB_FIX_K1              = 0x00020,
    CALIB_FIX_K2              = 0x00040,
    CALIB_FIX_K3              = 0x00080,
    CALIB_FIX_K4              = 0x00800,
    CALIB_FIX_K5              = 0x01000,
    CALIB_FIX_K6              = 0x02000,
    CALIB_RATIONAL_MODEL      = 0x04000,
    CALIB_THIN_PRISM_MODEL    = 0x08000,
    CALIB_FIX_S1_S2_S3_S4     = 0x10000,
    CALIB_TILTED_MODEL        = 0x40000,
    CALIB_FIX_TAUX_TAUY       = 0x80000,
    CALIB_USE_QR              = 0x100000,
    CALIB_FIX_INTRINSIC       = 0x00100,
    CALIB_SAME_FOCAL_LENGTH   = 0x00200,
    CALIB_ZERO_DISPARITY      = 0x00400,
    CALIB_USE_LU              = (1 <<17),
};

enum
{
    FM_7POINT = 1,
    FM_8POINT = 2,
    FM_LMEDS  = 4,
    FM_RANSAC = 8,
};

enum
{
    CASCADE_DO_CANNY_PRUNING    = 1,
    CASCADE_SCALE_IMAGE         = 2,
    CASCADE_FIND_BIGGEST_OBJECT = 4,
    CASCADE_DO_ROUGH_SEARCH     = 8,
};

enum
{
    INPAINT_NS    = 0,
    INPAINT_TELEA = 1,
};

enum
{
    NORMAL_CLONE        = 1,
    MIXED_CLONE         = 2,
    MONOCHROME_TRANSFER = 3,
};

enum
{
    RECURS_FILTER   = 1,
    NORMCONV_FILTER = 2,
};

enum
{
    LDR_SIZE = 256,
};

enum
{
    ACCESS_READ  =1<<24,
    ACCESS_WRITE =1<<25,
    ACCESS_RW    =3<<24,
    ACCESS_MASK  =ACCESS_RW,
    ACCESS_FAST  =1<<26,
};

enum AdaptiveThresholdTypes;
enum BorderTypes;
enum CmpTypes;
enum ColorConversionCodes;
enum ColormapTypes;
enum ConnectedComponentsAlgorithmsTypes;
enum ConnectedComponentsTypes;
enum ContourApproximationModes;
enum CovarFlags;
enum DecompTypes;
enum DftFlags;
enum DistanceTransformLabelTypes;
enum DistanceTransformMasks;
enum DistanceTypes;
enum FloodFillFlags;
enum GemmFlags;
enum GrabCutClasses;
enum GrabCutModes;
enum HersheyFonts;
enum HistCompMethods;
enum HoughModes;
enum ImreadModes;
enum ImwriteFlags;
enum ImwritePAMFlags;
enum ImwritePNGFlags;
enum InterpolationFlags;
enum InterpolationMasks;
enum KmeansFlags;
enum LineSegmentDetectorModes;
enum LineTypes;
enum MarkerTypes;
enum MorphShapes;
enum MorphTypes;
enum MouseEventFlags;
enum MouseEventTypes;
enum NormTypes;
enum QtButtonTypes;
enum QtFontStyles;
enum QtFontWeights;
enum RectanglesIntersectTypes;
enum ReduceTypes;
enum RetrievalModes;
enum RotateFlags;
enum ShapeMatchModes;
enum SolveLPResult;
enum SortFlags;
enum TemplateMatchModes;
enum ThresholdTypes;
enum UMatUsageFlags;
enum UndistortTypes;
enum VideoCaptureAPIs;
enum VideoCaptureModes;
enum VideoCaptureProperties;
enum VideoWriterProperties;
enum WindowFlags;
enum WindowPropertyFlags;

// structs

template <typename T>
struct Accumulator;

template <>
struct Accumulator<unsigned char>;

template <>
struct Accumulator<short>;

template <>
struct Accumulator<unsigned short>;

template <>
struct Accumulator<char>;

struct CirclesGridFinderParameters;
struct DetectionROI;
struct DrawMatchesFlags;
struct HOGDescriptor;
struct Hamming;

template <class T>
struct L1;

template <class T>
struct L2;

struct MatSize;
struct MatStep;
struct Param;

template <>
struct ParamType<String>;

template <>
struct ParamType<uchar>;

template <>
struct ParamType<unsigned>;

template <>
struct ParamType<std::vector<Mat>>;

template <>
struct ParamType<uint64>;

template <>
struct ParamType<Mat>;

template <>
struct ParamType<Algorithm>;

template <>
struct ParamType<double>;

template <typename _Tp>
struct ParamType;

template <>
struct ParamType<float>;

template <>
struct ParamType<bool>;

template <typename T>
struct Ptr;

struct QtFont;

template <class T>
struct SL2;

struct UMatData;
struct UMatDataAutoLock;
struct softdouble;
struct softfloat;

template <
    typename _Tp,
    int n
    >
struct v_reg;

// classes

class AKAZE;

template <typename T>
class Affine3;

class AffineTransformer;
class AffineWarper;
class AgastFeatureDetector;
class Algorithm;
class AlignExposures;
class AlignMTB;

template <typename _Tp>
class Allocator;

template <
    typename _Tp,
    size_t fixed_size = 1024/sizeof(_Tp)+8
    >
class AutoBuffer;

class AutoLock;
class BFMatcher;
class BOWImgDescriptorExtractor;
class BOWKMeansTrainer;
class BOWTrainer;
class BRISK;
class BackgroundSubtractor;
class BackgroundSubtractorKNN;
class BackgroundSubtractorMOG2;
class BaseCascadeClassifier;
class BufferPoolController;
class CLAHE;
class CalibrateCRF;
class CalibrateDebevec;
class CalibrateRobertson;
class CascadeClassifier;
class ChiHistogramCostExtractor;
class CommandLineParser;

template <typename _Tp>
class Complex;

class CompressedRectilinearPortraitWarper;
class CompressedRectilinearWarper;
class ConjGradSolver;
class CylindricalWarper;
class DMatch;

template <typename _Tp>
class DataDepth;

template <typename _Tp>
class DataType;

class DenseOpticalFlow;
class DescriptorMatcher;
class DownhillSolver;
class DualTVL1OpticalFlow;
class EMDHistogramCostExtractor;
class EMDL1HistogramCostExtractor;
class Exception;
class FarnebackOpticalFlow;
class FastFeatureDetector;
class Feature2D;
class FileNode;
class FileNodeIterator;
class FileStorage;
class FisheyeWarper;
class FlannBasedMatcher;
class Formatted;
class Formatter;
class GFTTDetector;
class GeneralizedHough;
class GeneralizedHoughBallard;
class GeneralizedHoughGuil;
class HausdorffDistanceExtractor;
class HistogramCostExtractor;
class KAZE;
class KalmanFilter;
class KeyPoint;
class KeyPointsFilter;
class LDA;
class LineIterator;
class LineSegmentDetector;
class MSER;
class Mat;
class MatAllocator;

template <typename _Tp>
class MatCommaInitializer_;

class MatConstIterator;

template <typename _Tp>
class MatConstIterator_;

class MatExpr;

template <typename _Tp>
class MatIterator_;

class MatOp;

template <typename _Tp>
class Mat_;

template <
    typename _Tp,
    int m,
    int n
    >
class Matx;

template <
    typename _Tp,
    int m,
    int n
    >
class MatxCommaInitializer;

class MercatorWarper;
class MergeDebevec;
class MergeExposures;
class MergeMertens;
class MergeRobertson;
class MinProblemSolver;
class Moments;
class Mutex;
class NAryMatIterator;

template <class OBJECT>
class Node;

class NormHistogramCostExtractor;
class ORB;
class PCA;
class PaniniPortraitWarper;
class PaniniWarper;
class ParallelLoopBody;
class PlaneWarper;

template <typename _Tp>
class Point3_;

template <typename _Tp>
class Point_;

class RNG;
class RNG_MT19937;
class Range;

template <typename _Tp>
class Rect_;

class RotatedRect;
class SVD;

template <typename _Tp>
class Scalar_;

template <typename _Tp>
class Seq;

template <typename _Tp>
class SeqIterator;

class ShapeContextDistanceExtractor;
class ShapeDistanceExtractor;
class ShapeTransformer;
class SimilarRects;
class SimpleBlobDetector;

template <typename _Tp>
class Size_;

class SparseMat;
class SparseMatConstIterator;

template <typename _Tp>
class SparseMatConstIterator_;

class SparseMatIterator;

template <typename _Tp>
class SparseMatIterator_;

template <typename _Tp>
class SparseMat_;

class SparseOpticalFlow;
class SparsePyrLKOpticalFlow;
class SphericalWarper;
class StereoBM;
class StereoMatcher;
class StereoSGBM;
class StereographicWarper;
class Stitcher;
class String;
class Subdiv2D;

template <typename T>
class TLSData;

class TLSDataContainer;
class TermCriteria;
class ThinPlateSplineShapeTransformer;
class TickMeter;
class Tonemap;
class TonemapDrago;
class TonemapDurand;
class TonemapMantiuk;
class TonemapReinhard;
class TransverseMercatorWarper;

template <int _depth>
class TypeDepth;

template <>
class TypeDepth<CV_16U>;

template <>
class TypeDepth<CV_16S>;

template <>
class TypeDepth<CV_32F>;

template <>
class TypeDepth<CV_8U>;

template <>
class TypeDepth<CV_8S>;

template <>
class TypeDepth<CV_64F>;

template <>
class TypeDepth<CV_32S>;

class UMat;

template <
    typename _Tp,
    int cn
    >
class Vec;

template <
    typename _Tp,
    int m
    >
class VecCommaInitializer;

class VideoCapture;
class VideoWriter;

template <typename T>
class WImage;

template <typename T>
class WImageBuffer;

template <
    typename T,
    int C
    >
class WImageBufferC;

template <
    typename T,
    int C
    >
class WImageC;

template <typename T>
class WImageView;

template <
    typename T,
    int C
    >
class WImageViewC;

class WarperCreator;
class _InputArray;
class _InputOutputArray;
class _OutputArray;

// global variables

static const unsigned char popCountTable[];

// global functions

v_uint8x16
v_setzero_u8();

v_int8x16
v_setzero_s8();

v_uint16x8
v_setzero_u16();

v_int16x8
v_setzero_s16();

v_uint32x4
v_setzero_u32();

v_int32x4
v_setzero_s32();

v_float32x4
v_setzero_f32();

v_float64x2
v_setzero_f64();

v_uint64x2
v_setzero_u64();

v_int64x2
v_setzero_s64();

v_uint8x16
v_setall_u8(uchar val);

v_int8x16
v_setall_s8(schar val);

v_uint16x8
v_setall_u16(ushort val);

v_int16x8
v_setall_s16(short val);

v_uint32x4
v_setall_u32(unsigned val);

v_int32x4
v_setall_s32(int val);

v_float32x4
v_setall_f32(float val);

v_float64x2
v_setall_f64(double val);

v_uint64x2
v_setall_u64(uint64 val);

v_int64x2
v_setall_s64(int64 val);

template <
    typename _Tp0,
    int n0
    >
v_uint8x16
v_reinterpret_as_u8(const v_reg<_Tp0, n0>& a);

template <
    typename _Tp0,
    int n0
    >
v_int8x16
v_reinterpret_as_s8(const v_reg<_Tp0, n0>& a);

template <
    typename _Tp0,
    int n0
    >
v_uint16x8
v_reinterpret_as_u16(const v_reg<_Tp0, n0>& a);

template <
    typename _Tp0,
    int n0
    >
v_int16x8
v_reinterpret_as_s16(const v_reg<_Tp0, n0>& a);

template <
    typename _Tp0,
    int n0
    >
v_uint32x4
v_reinterpret_as_u32(const v_reg<_Tp0, n0>& a);

template <
    typename _Tp0,
    int n0
    >
v_int32x4
v_reinterpret_as_s32(const v_reg<_Tp0, n0>& a);

template <
    typename _Tp0,
    int n0
    >
v_float32x4
v_reinterpret_as_f32(const v_reg<_Tp0, n0>& a);

template <
    typename _Tp0,
    int n0
    >
v_float64x2
v_reinterpret_as_f64(const v_reg<_Tp0, n0>& a);

template <
    typename _Tp0,
    int n0
    >
v_uint64x2
v_reinterpret_as_u64(const v_reg<_Tp0, n0>& a);

template <
    typename _Tp0,
    int n0
    >
v_int64x2
v_reinterpret_as_s64(const v_reg<_Tp0, n0>& a);

template <int n>
v_uint16x8
v_shl(const v_uint16x8& a);

template <int n>
v_int16x8
v_shl(const v_int16x8& a);

template <int n>
v_uint32x4
v_shl(const v_uint32x4& a);

template <int n>
v_int32x4
v_shl(const v_int32x4& a);

template <int n>
v_uint64x2
v_shl(const v_uint64x2& a);

template <int n>
v_int64x2
v_shl(const v_int64x2& a);

template <int n>
v_uint16x8
v_shr(const v_uint16x8& a);

template <int n>
v_int16x8
v_shr(const v_int16x8& a);

template <int n>
v_uint32x4
v_shr(const v_uint32x4& a);

template <int n>
v_int32x4
v_shr(const v_int32x4& a);

template <int n>
v_uint64x2
v_shr(const v_uint64x2& a);

template <int n>
v_int64x2
v_shr(const v_int64x2& a);

template <int n>
v_uint16x8
v_rshr(const v_uint16x8& a);

template <int n>
v_int16x8
v_rshr(const v_int16x8& a);

template <int n>
v_uint32x4
v_rshr(const v_uint32x4& a);

template <int n>
v_int32x4
v_rshr(const v_int32x4& a);

template <int n>
v_uint64x2
v_rshr(const v_uint64x2& a);

template <int n>
v_int64x2
v_rshr(const v_int64x2& a);

v_uint8x16
v_pack(
    const v_uint16x8& a,
    const v_uint16x8& b
    );

v_int8x16
v_pack(
    const v_int16x8& a,
    const v_int16x8& b
    );

v_uint16x8
v_pack(
    const v_uint32x4& a,
    const v_uint32x4& b
    );

v_int16x8
v_pack(
    const v_int32x4& a,
    const v_int32x4& b
    );

v_uint32x4
v_pack(
    const v_uint64x2& a,
    const v_uint64x2& b
    );

v_int32x4
v_pack(
    const v_int64x2& a,
    const v_int64x2& b
    );

v_uint8x16
v_pack_u(
    const v_int16x8& a,
    const v_int16x8& b
    );

v_uint16x8
v_pack_u(
    const v_int32x4& a,
    const v_int32x4& b
    );

template <int n>
v_uint8x16
v_rshr_pack(
    const v_uint16x8& a,
    const v_uint16x8& b
    );

template <int n>
v_int8x16
v_rshr_pack(
    const v_int16x8& a,
    const v_int16x8& b
    );

template <int n>
v_uint16x8
v_rshr_pack(
    const v_uint32x4& a,
    const v_uint32x4& b
    );

template <int n>
v_int16x8
v_rshr_pack(
    const v_int32x4& a,
    const v_int32x4& b
    );

template <int n>
v_uint32x4
v_rshr_pack(
    const v_uint64x2& a,
    const v_uint64x2& b
    );

template <int n>
v_int32x4
v_rshr_pack(
    const v_int64x2& a,
    const v_int64x2& b
    );

template <int n>
v_uint8x16
v_rshr_pack_u(
    const v_int16x8& a,
    const v_int16x8& b
    );

template <int n>
v_uint16x8
v_rshr_pack_u(
    const v_int32x4& a,
    const v_int32x4& b
    );

void
v_pack_store(
    uchar* ptr,
    const v_uint16x8& a
    );

void
v_pack_store(
    schar* ptr,
    const v_int16x8& a
    );

void
v_pack_store(
    ushort* ptr,
    const v_uint32x4& a
    );

void
v_pack_store(
    short* ptr,
    const v_int32x4& a
    );

void
v_pack_store(
    unsigned* ptr,
    const v_uint64x2& a
    );

void
v_pack_store(
    int* ptr,
    const v_int64x2& a
    );

void
v_pack_u_store(
    uchar* ptr,
    const v_int16x8& a
    );

void
v_pack_u_store(
    ushort* ptr,
    const v_int32x4& a
    );

template <int n>
void
v_rshr_pack_store(
    uchar* ptr,
    const v_uint16x8& a
    );

template <int n>
void
v_rshr_pack_store(
    schar* ptr,
    const v_int16x8& a
    );

template <int n>
void
v_rshr_pack_store(
    ushort* ptr,
    const v_uint32x4& a
    );

template <int n>
void
v_rshr_pack_store(
    short* ptr,
    const v_int32x4& a
    );

template <int n>
void
v_rshr_pack_store(
    unsigned* ptr,
    const v_uint64x2& a
    );

template <int n>
void
v_rshr_pack_store(
    int* ptr,
    const v_int64x2& a
    );

template <int n>
void
v_rshr_pack_u_store(
    uchar* ptr,
    const v_int16x8& a
    );

template <int n>
void
v_rshr_pack_u_store(
    ushort* ptr,
    const v_int32x4& a
    );

static
bool
hasSIMD128();

static
uchar
abs(uchar a);

static
ushort
abs(ushort a);

static
unsigned
abs(unsigned a);

static
uint64
abs(uint64 a);

softfloat
abs(softfloat a);

softdouble
abs(softdouble a);

void
absdiff(
    InputArray src1,
    InputArray src2,
    OutputArray dst
    );

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

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

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

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

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

void
add(
    InputArray src1,
    InputArray src2,
    OutputArray dst,
    InputArray mask = noArray(),
    int dtype = -1
    );

void
addText(
    const Mat& img,
    const String& text,
    Point org,
    const QtFont& font
    );

void
addText(
    const Mat& img,
    const String& text,
    Point org,
    const String& nameFont,
    int pointSize = -1,
    Scalar color = Scalar::all(0),
    int weight = QT_FONT_NORMAL,
    int style = QT_STYLE_NORMAL,
    int spacing = 0
    );

void
addWeighted(
    InputArray src1,
    double alpha,
    InputArray src2,
    double beta,
    double gamma,
    OutputArray dst,
    int dtype = -1
    );

void
AGAST(
    InputArray image,
    std::vector<KeyPoint>& keypoints,
    int threshold,
    bool nonmaxSuppression = true
    );

void
AGAST(
    InputArray image,
    std::vector<KeyPoint>& keypoints,
    int threshold,
    bool nonmaxSuppression,
    int type
    );

template <typename _Tp>
static
_Tp*
alignPtr(
    _Tp* ptr,
    int n = (int) sizeof(_Tp)
    );

static
size_t
alignSize(
    size_t sz,
    int n
    );

void
applyColorMap(
    InputArray src,
    OutputArray dst,
    int colormap
    );

void
applyColorMap(
    InputArray src,
    OutputArray dst,
    InputArray userColor
    );

void
approxPolyDP(
    InputArray curve,
    OutputArray approxCurve,
    double epsilon,
    bool closed
    );

double
arcLength(
    InputArray curve,
    bool closed
    );

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

void
batchDistance(
    InputArray src1,
    InputArray src2,
    OutputArray dist,
    int dtype,
    OutputArray nidx,
    int normType = NORM_L2,
    int K = 0,
    InputArray mask = noArray(),
    int update = 0,
    bool crosscheck = false
    );

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

void
bitwise_and(
    InputArray src1,
    InputArray src2,
    OutputArray dst,
    InputArray mask = noArray()
    );

void
bitwise_not(
    InputArray src,
    OutputArray dst,
    InputArray mask = noArray()
    );

void
bitwise_or(
    InputArray src1,
    InputArray src2,
    OutputArray dst,
    InputArray mask = noArray()
    );

void
bitwise_xor(
    InputArray src1,
    InputArray src2,
    OutputArray dst,
    InputArray mask = noArray()
    );

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

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

int
borderInterpolate(
    int p,
    int len,
    int borderType
    );

Rect
boundingRect(InputArray points);

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

void
boxPoints(
    RotatedRect box,
    OutputArray points
    );

int
buildOpticalFlowPyramid(
    InputArray img,
    OutputArrayOfArrays pyramid,
    Size winSize,
    int maxLevel,
    bool withDerivatives = true,
    int pyrBorder = BORDER_REFLECT_101,
    int derivBorder = BORDER_CONSTANT,
    bool tryReuseInputImage = true
    );

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

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

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

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

void
calcCovarMatrix(
    const Mat* samples,
    int nsamples,
    Mat& covar,
    Mat& mean,
    int flags,
    int ctype = CV_64F
    );

void
calcCovarMatrix(
    InputArray samples,
    OutputArray covar,
    InputOutputArray mean,
    int flags,
    int ctype = CV_64F
    );

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

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

void
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
    );

void
calcOpticalFlowFarneback(
    InputArray prev,
    InputArray next,
    InputOutputArray flow,
    double pyr_scale,
    int levels,
    int winsize,
    int iterations,
    int poly_n,
    double poly_sigma,
    int flags
    );

void
calcOpticalFlowPyrLK(
    InputArray prevImg,
    InputArray nextImg,
    InputArray prevPts,
    InputOutputArray nextPts,
    OutputArray status,
    OutputArray err,
    Size winSize = Size(21, 21),
    int maxLevel = 3,
    TermCriteria criteria = TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, 0.01),
    int flags = 0,
    double minEigThreshold = 1e-4
    );

double
calibrateCamera(
    InputArrayOfArrays objectPoints,
    InputArrayOfArrays imagePoints,
    Size imageSize,
    InputOutputArray cameraMatrix,
    InputOutputArray distCoeffs,
    OutputArrayOfArrays rvecs,
    OutputArrayOfArrays tvecs,
    OutputArray stdDeviationsIntrinsics,
    OutputArray stdDeviationsExtrinsics,
    OutputArray perViewErrors,
    int flags = 0,
    TermCriteria criteria = TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, DBL_EPSILON)
    );

double
calibrateCamera(
    InputArrayOfArrays objectPoints,
    InputArrayOfArrays imagePoints,
    Size imageSize,
    InputOutputArray cameraMatrix,
    InputOutputArray distCoeffs,
    OutputArrayOfArrays rvecs,
    OutputArrayOfArrays tvecs,
    int flags = 0,
    TermCriteria criteria = TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, DBL_EPSILON)
    );

void
calibrationMatrixValues(
    InputArray cameraMatrix,
    Size imageSize,
    double apertureWidth,
    double apertureHeight,
    double& fovx,
    double& fovy,
    double& focalLength,
    Point2d& principalPoint,
    double& aspectRatio
    );

RotatedRect
CamShift(
    InputArray probImage,
    Rect& window,
    TermCriteria criteria
    );

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

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

void
cartToPolar(
    InputArray x,
    InputArray y,
    OutputArray magnitude,
    OutputArray angle,
    bool angleInDegrees = false
    );

softfloat
cbrt(const softfloat& a);

bool
checkHardwareSupport(int feature);

bool
checkRange(
    InputArray a,
    bool quiet = true,
    Point* pos = 0,
    double minVal = -DBL_MAX,
    double maxVal = DBL_MAX
    );

bool
Cholesky(
    float* A,
    size_t astep,
    int m,
    float* b,
    size_t bstep,
    int n
    );

bool
Cholesky(
    double* A,
    size_t astep,
    int m,
    double* b,
    size_t bstep,
    int n
    );

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

void
clearSeq(CvSeq* seq);

bool
clipLine(
    Size imgSize,
    Point& pt1,
    Point& pt2
    );

bool
clipLine(
    Size2l imgSize,
    Point2l& pt1,
    Point2l& pt2
    );

bool
clipLine(
    Rect imgRect,
    Point& pt1,
    Point& pt2
    );

void
colorChange(
    InputArray src,
    InputArray mask,
    OutputArray dst,
    float red_mul = 1.0f,
    float green_mul = 1.0f,
    float blue_mul = 1.0f
    );

void
compare(
    InputArray src1,
    InputArray src2,
    OutputArray dst,
    int cmpop
    );

double
compareHist(
    InputArray H1,
    InputArray H2,
    int method
    );

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

void
completeSymm(
    InputOutputArray mtx,
    bool lowerToUpper = false
    );

void
composeRT(
    InputArray rvec1,
    InputArray tvec1,
    InputArray rvec2,
    InputArray tvec2,
    OutputArray rvec3,
    OutputArray tvec3,
    OutputArray dr3dr1 = noArray(),
    OutputArray dr3dt1 = noArray(),
    OutputArray dr3dr2 = noArray(),
    OutputArray dr3dt2 = noArray(),
    OutputArray dt3dr1 = noArray(),
    OutputArray dt3dt1 = noArray(),
    OutputArray dt3dr2 = noArray(),
    OutputArray dt3dt2 = noArray()
    );

void
computeCorrespondEpilines(
    InputArray points,
    int whichImage,
    InputArray F,
    OutputArray lines
    );

void
computeRecallPrecisionCurve(
    const std::vector<std::vector<DMatch>>& matches1to2,
    const std::vector<std::vector<uchar>>& correctMatches1to2Mask,
    std::vector<Point2f>& recallPrecisionCurve
    );

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

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

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

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

double
contourArea(
    InputArray contour,
    bool oriented = false
    );

void
convertFp16(
    InputArray src,
    OutputArray dst
    );

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

void
convertPointsFromHomogeneous(
    InputArray src,
    OutputArray dst
    );

void
convertPointsHomogeneous(
    InputArray src,
    OutputArray dst
    );

void
convertPointsToHomogeneous(
    InputArray src,
    OutputArray dst
    );

void
convertScaleAbs(
    InputArray src,
    OutputArray dst,
    double alpha = 1,
    double beta = 0
    );

void
convexHull(
    InputArray points,
    OutputArray hull,
    bool clockwise = false,
    bool returnPoints = true
    );

void
convexityDefects(
    InputArray contour,
    InputArray convexhull,
    OutputArray convexityDefects
    );

void
copyMakeBorder(
    InputArray src,
    OutputArray dst,
    int top,
    int bottom,
    int left,
    int right,
    int borderType,
    const Scalar& value = Scalar()
    );

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

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

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

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

void
correctMatches(
    InputArray F,
    InputArray points1,
    InputArray points2,
    OutputArray newPoints1,
    OutputArray newPoints2
    );

int
countNonZero(InputArray src);

Ptr<AffineTransformer>
createAffineTransformer(bool fullAffine);

Ptr<AlignMTB>
createAlignMTB(
    int max_bits = 6,
    int exclude_range = 4,
    bool cut = true
    );

Ptr<BackgroundSubtractorKNN>
createBackgroundSubtractorKNN(
    int history = 500,
    double dist2Threshold = 400.0,
    bool detectShadows = true
    );

Ptr<BackgroundSubtractorMOG2>
createBackgroundSubtractorMOG2(
    int history = 500,
    double varThreshold = 16,
    bool detectShadows = true
    );

int
createButton(
    const String& bar_name,
    ButtonCallback on_change,
    void* userdata = 0,
    int type = QT_PUSH_BUTTON,
    bool initial_button_state = false
    );

Ptr<CalibrateDebevec>
createCalibrateDebevec(
    int samples = 70,
    float lambda = 10.0f,
    bool random = false
    );

Ptr<CalibrateRobertson>
createCalibrateRobertson(
    int max_iter = 30,
    float threshold = 0.01f
    );

Ptr<HistogramCostExtractor>
createChiHistogramCostExtractor(
    int nDummies = 25,
    float defaultCost = 0.2f
    );

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

Ptr<HistogramCostExtractor>
createEMDHistogramCostExtractor(
    int flag = DIST_L2,
    int nDummies = 25,
    float defaultCost = 0.2f
    );

Ptr<HistogramCostExtractor>
createEMDL1HistogramCostExtractor(
    int nDummies = 25,
    float defaultCost = 0.2f
    );

Ptr<BaseCascadeClassifier::MaskGenerator>
createFaceDetectionMaskGenerator();

Ptr<GeneralizedHoughBallard>
createGeneralizedHoughBallard();

Ptr<GeneralizedHoughGuil>
createGeneralizedHoughGuil();

void
createHanningWindow(
    OutputArray dst,
    Size winSize,
    int type
    );

Ptr<HausdorffDistanceExtractor>
createHausdorffDistanceExtractor(
    int distanceFlag = cv::NORM_L2,
    float rankProp = 0.6f
    );

Ptr<LineSegmentDetector>
createLineSegmentDetector(
    int _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
    );

Ptr<MergeDebevec>
createMergeDebevec();

Ptr<MergeMertens>
createMergeMertens(
    float contrast_weight = 1.0f,
    float saturation_weight = 1.0f,
    float exposure_weight = 0.0f
    );

Ptr<MergeRobertson>
createMergeRobertson();

Ptr<HistogramCostExtractor>
createNormHistogramCostExtractor(
    int flag = DIST_L2,
    int nDummies = 25,
    float defaultCost = 0.2f
    );

Ptr<DualTVL1OpticalFlow>
createOptFlow_DualTVL1();

Ptr<ShapeContextDistanceExtractor>
createShapeContextDistanceExtractor(
    int nAngularBins = 12,
    int nRadialBins = 4,
    float innerRadius = 0.2f,
    float outerRadius = 2,
    int iterations = 3,
    const Ptr<HistogramCostExtractor>& comparer = createChiHistogramCostExtractor(),
    const Ptr<ShapeTransformer>& transformer = createThinPlateSplineShapeTransformer()
    );

Ptr<Stitcher>
createStitcher(bool try_use_gpu = false);

Ptr<ThinPlateSplineShapeTransformer>
createThinPlateSplineShapeTransformer(double regularizationParameter = 0);

Ptr<Tonemap>
createTonemap(float gamma = 1.0f);

Ptr<TonemapDrago>
createTonemapDrago(
    float gamma = 1.0f,
    float saturation = 1.0f,
    float bias = 0.85f
    );

Ptr<TonemapDurand>
createTonemapDurand(
    float gamma = 1.0f,
    float contrast = 4.0f,
    float saturation = 1.0f,
    float sigma_space = 2.0f,
    float sigma_color = 2.0f
    );

Ptr<TonemapMantiuk>
createTonemapMantiuk(
    float gamma = 1.0f,
    float scale = 0.7f,
    float saturation = 1.0f
    );

Ptr<TonemapReinhard>
createTonemapReinhard(
    float gamma = 1.0f,
    float intensity = 0.0f,
    float light_adapt = 1.0f,
    float color_adapt = 0.0f
    );

int
createTrackbar(
    const String& trackbarname,
    const String& winname,
    int* value,
    int count,
    TrackbarCallback onChange = 0,
    void* userdata = 0
    );

float
cubeRoot(float val);

template <
    typename _Tp,
    int _rows,
    int _cols,
    int _options,
    int _maxRows,
    int _maxCols
    >
static
void
cv2eigen(
    const Mat& src,
    Eigen::Matrix<_Tp, _rows, _cols, _options, _maxRows, _maxCols>& dst
    );

template <
    typename _Tp,
    int _rows,
    int _cols,
    int _options,
    int _maxRows,
    int _maxCols
    >
static
void
cv2eigen(
    const Matx<_Tp, _rows, _cols>& src,
    Eigen::Matrix<_Tp, _rows, _cols, _options, _maxRows, _maxCols>& dst
    );

template <typename _Tp>
static
void
cv2eigen(
    const Mat& src,
    Eigen::Matrix<_Tp, Eigen::Dynamic, Eigen::Dynamic>& dst
    );

template <
    typename _Tp,
    int _rows,
    int _cols
    >
static
void
cv2eigen(
    const Matx<_Tp, _rows, _cols>& src,
    Eigen::Matrix<_Tp, Eigen::Dynamic, Eigen::Dynamic>& dst
    );

template <typename _Tp>
static
void
cv2eigen(
    const Mat& src,
    Eigen::Matrix<_Tp, Eigen::Dynamic, 1>& dst
    );

template <
    typename _Tp,
    int _rows
    >
static
void
cv2eigen(
    const Matx<_Tp, _rows, 1>& src,
    Eigen::Matrix<_Tp, Eigen::Dynamic, 1>& dst
    );

template <typename _Tp>
static
void
cv2eigen(
    const Mat& src,
    Eigen::Matrix<_Tp, 1, Eigen::Dynamic>& dst
    );

template <
    typename _Tp,
    int _cols
    >
static
void
cv2eigen(
    const Matx<_Tp, 1, _cols>& src,
    Eigen::Matrix<_Tp, 1, Eigen::Dynamic>& dst
    );

template <typename _Tp>
_Tp
cv_abs(_Tp x);

int
cv_abs(uchar x);

int
cv_abs(schar x);

int
cv_abs(ushort x);

int
cv_abs(short x);

Mat
cvarrToMat(
    const CvArr* arr,
    bool copyData = false,
    bool allowND = true,
    int coiMode = 0,
    AutoBuffer<double>* buf = 0
    );

static
Mat
cvarrToMatND(
    const CvArr* arr,
    bool copyData = false,
    int coiMode = 0
    );

void
cvEndWriteRawData_Base64(::CvFileStorage* fs);

void
cvtColor(
    InputArray src,
    OutputArray dst,
    int code,
    int dstCn = 0
    );

void
cvWriteMat_Base64(
    ::CvFileStorage* fs,
    const char* name,
    const ::CvMat* mat
    );

void
cvWriteMatND_Base64(
    ::CvFileStorage* fs,
    const char* name,
    const ::CvMatND* mat
    );

void
cvWriteRawData_Base64(
    ::CvFileStorage* fs,
    const void* _data,
    int len
    );

void
dct(
    InputArray src,
    OutputArray dst,
    int flags = 0
    );

void
decolor(
    InputArray src,
    OutputArray grayscale,
    OutputArray color_boost
    );

void
decomposeEssentialMat(
    InputArray E,
    OutputArray R1,
    OutputArray R2,
    OutputArray t
    );

int
decomposeHomographyMat(
    InputArray H,
    InputArray K,
    OutputArrayOfArrays rotations,
    OutputArrayOfArrays translations,
    OutputArrayOfArrays normals
    );

void
decomposeProjectionMatrix(
    InputArray projMatrix,
    OutputArray cameraMatrix,
    OutputArray rotMatrix,
    OutputArray transVect,
    OutputArray rotMatrixX = noArray(),
    OutputArray rotMatrixY = noArray(),
    OutputArray rotMatrixZ = noArray(),
    OutputArray eulerAngles = noArray()
    );

void
demosaicing(
    InputArray _src,
    OutputArray _dst,
    int code,
    int dcn = 0
    );

void
denoise_TVL1(
    const std::vector<Mat>& observations,
    Mat& result,
    double lambda = 1.0,
    int niters = 30
    );

void
destroyAllWindows();

void
destroyWindow(const String& winname);

void
detailEnhance(
    InputArray src,
    OutputArray dst,
    float sigma_s = 10,
    float sigma_r = 0.15f
    );

template <
    typename _Tp,
    int m
    >
static
double
determinant(const Matx<_Tp, m, m>& a);

double
determinant(InputArray mtx);

void
dft(
    InputArray src,
    OutputArray dst,
    int flags = 0,
    int nonzeroRows = 0
    );

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

void
displayOverlay(
    const String& winname,
    const String& text,
    int delayms = 0
    );

void
displayStatusBar(
    const String& winname,
    const String& text,
    int delayms = 0
    );

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

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

void
divide(
    InputArray src1,
    InputArray src2,
    OutputArray dst,
    double scale = 1,
    int dtype = -1
    );

void
divide(
    double scale,
    InputArray src2,
    OutputArray dst,
    int dtype = -1
    );

void
drawChessboardCorners(
    InputOutputArray image,
    Size patternSize,
    InputArray corners,
    bool patternWasFound
    );

void
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()
    );

void
drawKeypoints(
    InputArray image,
    const std::vector<KeyPoint>& keypoints,
    InputOutputArray outImage,
    const Scalar& color = Scalar::all(-1),
    int flags = DrawMatchesFlags::DEFAULT
    );

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

void
drawMatches(
    InputArray img1,
    const std::vector<KeyPoint>& keypoints1,
    InputArray img2,
    const std::vector<KeyPoint>& keypoints2,
    const std::vector<DMatch>& matches1to2,
    InputOutputArray outImg,
    const Scalar& matchColor = Scalar::all(-1),
    const Scalar& singlePointColor = Scalar::all(-1),
    const std::vector<char>& matchesMask = std::vector<char>(),
    int flags = DrawMatchesFlags::DEFAULT
    );

void
drawMatches(
    InputArray img1,
    const std::vector<KeyPoint>& keypoints1,
    InputArray img2,
    const std::vector<KeyPoint>& keypoints2,
    const std::vector<std::vector<DMatch>>& matches1to2,
    InputOutputArray outImg,
    const Scalar& matchColor = Scalar::all(-1),
    const Scalar& singlePointColor = Scalar::all(-1),
    const std::vector<std::vector<char>>& matchesMask = std::vector<std::vector<char>>(),
    int flags = DrawMatchesFlags::DEFAULT
    );

void
edgePreservingFilter(
    InputArray src,
    OutputArray dst,
    int flags = 1,
    float sigma_s = 60,
    float sigma_r = 0.4f
    );

bool
eigen(
    InputArray src,
    OutputArray eigenvalues,
    OutputArray eigenvectors = noArray()
    );

template <
    typename _Tp,
    int _rows,
    int _cols,
    int _options,
    int _maxRows,
    int _maxCols
    >
static
void
eigen2cv(
    const Eigen::Matrix<_Tp, _rows, _cols, _options, _maxRows, _maxCols>& src,
    Mat& dst
    );

template <
    typename _Tp,
    int _rows,
    int _cols,
    int _options,
    int _maxRows,
    int _maxCols
    >
static
void
eigen2cv(
    const Eigen::Matrix<_Tp, _rows, _cols, _options, _maxRows, _maxCols>& src,
    Matx<_Tp, _rows, _cols>& dst
    );

void
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
    );

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

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

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

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

float
EMDL1(
    InputArray signature1,
    InputArray signature2
    );

void
equalizeHist(
    InputArray src,
    OutputArray dst
    );

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

void
error(const Exception& exc);

void
error(
    int _code,
    const String& _err,
    const char* _func,
    const char* _file,
    int _line
    );

void
errorNoReturn(
    int _code,
    const String& _err,
    const char* _func,
    const char* _file,
    int _line
    );

cv::Mat
estimateAffine2D(
    InputArray from,
    InputArray to,
    OutputArray inliers = noArray(),
    int method = RANSAC,
    double ransacReprojThreshold = 3,
    size_t maxIters = 2000,
    double confidence = 0.99,
    size_t refineIters = 10
    );

int
estimateAffine3D(
    InputArray src,
    InputArray dst,
    OutputArray out,
    OutputArray inliers,
    double ransacThreshold = 3,
    double confidence = 0.99
    );

cv::Mat
estimateAffinePartial2D(
    InputArray from,
    InputArray to,
    OutputArray inliers = noArray(),
    int method = RANSAC,
    double ransacReprojThreshold = 3,
    size_t maxIters = 2000,
    double confidence = 0.99,
    size_t refineIters = 10
    );

Mat
estimateRigidTransform(
    InputArray src,
    InputArray dst,
    bool fullAffine
    );

void
evaluateFeatureDetector(
    const Mat& img1,
    const Mat& img2,
    const Mat& H1to2,
    std::vector<KeyPoint>* keypoints1,
    std::vector<KeyPoint>* keypoints2,
    float& repeatability,
    int& correspCount,
    const Ptr<FeatureDetector>& fdetector = Ptr<FeatureDetector>()
    );

softfloat
exp(const softfloat& a);

softdouble
exp(const softdouble& a);

void
exp(
    InputArray src,
    OutputArray dst
    );

void
extractChannel(
    InputArray src,
    OutputArray dst,
    int coi
    );

void
extractImageCOI(
    const CvArr* arr,
    OutputArray coiimg,
    int coi = -1
    );

void
FAST(
    InputArray image,
    std::vector<KeyPoint>& keypoints,
    int threshold,
    bool nonmaxSuppression = true
    );

void
FAST(
    InputArray image,
    std::vector<KeyPoint>& keypoints,
    int threshold,
    bool nonmaxSuppression,
    int type
    );

float
fastAtan2(
    float y,
    float x
    );

void
fastFree(void* ptr);

void*
fastMalloc(size_t bufSize);

void
fastNlMeansDenoising(
    InputArray src,
    OutputArray dst,
    float h = 3,
    int templateWindowSize = 7,
    int searchWindowSize = 21
    );

void
fastNlMeansDenoising(
    InputArray src,
    OutputArray dst,
    const std::vector<float>& h,
    int templateWindowSize = 7,
    int searchWindowSize = 21,
    int normType = NORM_L2
    );

void
fastNlMeansDenoisingColored(
    InputArray src,
    OutputArray dst,
    float h = 3,
    float hColor = 3,
    int templateWindowSize = 7,
    int searchWindowSize = 21
    );

void
fastNlMeansDenoisingColoredMulti(
    InputArrayOfArrays srcImgs,
    OutputArray dst,
    int imgToDenoiseIndex,
    int temporalWindowSize,
    float h = 3,
    float hColor = 3,
    int templateWindowSize = 7,
    int searchWindowSize = 21
    );

void
fastNlMeansDenoisingMulti(
    InputArrayOfArrays srcImgs,
    OutputArray dst,
    int imgToDenoiseIndex,
    int temporalWindowSize,
    float h = 3,
    int templateWindowSize = 7,
    int searchWindowSize = 21
    );

void
fastNlMeansDenoisingMulti(
    InputArrayOfArrays srcImgs,
    OutputArray dst,
    int imgToDenoiseIndex,
    int temporalWindowSize,
    const std::vector<float>& h,
    int templateWindowSize = 7,
    int searchWindowSize = 21,
    int normType = NORM_L2
    );

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

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

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

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

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

void
filterSpeckles(
    InputOutputArray img,
    double newVal,
    int maxSpeckleSize,
    double maxDiff,
    InputOutputArray buf = noArray()
    );

bool
find4QuadCornerSubpix(
    InputArray img,
    InputOutputArray corners,
    Size region_size
    );

bool
findChessboardCorners(
    InputArray image,
    Size patternSize,
    OutputArray corners,
    int flags = CALIB_CB_ADAPTIVE_THRESH+CALIB_CB_NORMALIZE_IMAGE
    );

bool
findCirclesGrid(
    InputArray image,
    Size patternSize,
    OutputArray centers,
    int flags,
    const Ptr<FeatureDetector>& blobDetector,
    CirclesGridFinderParameters parameters
    );

bool
findCirclesGrid(
    InputArray image,
    Size patternSize,
    OutputArray centers,
    int flags = CALIB_CB_SYMMETRIC_GRID,
    const Ptr<FeatureDetector>& blobDetector = SimpleBlobDetector::create()
    );

void
findContours(
    InputOutputArray image,
    OutputArrayOfArrays contours,
    OutputArray hierarchy,
    int mode,
    int method,
    Point offset = Point()
    );

void
findContours(
    InputOutputArray image,
    OutputArrayOfArrays contours,
    int mode,
    int method,
    Point offset = Point()
    );

Mat
findEssentialMat(
    InputArray points1,
    InputArray points2,
    InputArray cameraMatrix,
    int method = RANSAC,
    double prob = 0.999,
    double threshold = 1.0,
    OutputArray mask = noArray()
    );

Mat
findEssentialMat(
    InputArray points1,
    InputArray points2,
    double focal = 1.0,
    Point2d pp = Point2d(0, 0),
    int method = RANSAC,
    double prob = 0.999,
    double threshold = 1.0,
    OutputArray mask = noArray()
    );

Mat
findFundamentalMat(
    InputArray points1,
    InputArray points2,
    int method = FM_RANSAC,
    double param1 = 3.,
    double param2 = 0.99,
    OutputArray mask = noArray()
    );

Mat
findFundamentalMat(
    InputArray points1,
    InputArray points2,
    OutputArray mask,
    int method = FM_RANSAC,
    double param1 = 3.,
    double param2 = 0.99
    );

Mat
findHomography(
    InputArray srcPoints,
    InputArray dstPoints,
    int method = 0,
    double ransacReprojThreshold = 3,
    OutputArray mask = noArray(),
    const int maxIters = 2000,
    const double confidence = 0.995
    );

Mat
findHomography(
    InputArray srcPoints,
    InputArray dstPoints,
    OutputArray mask,
    int method = 0,
    double ransacReprojThreshold = 3
    );

void
findNonZero(
    InputArray src,
    OutputArray idx
    );

double
findTransformECC(
    InputArray templateImage,
    InputArray inputImage,
    InputOutputArray warpMatrix,
    int motionType = MOTION_AFFINE,
    TermCriteria criteria = TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 50, 0.001),
    InputArray inputMask = noArray()
    );

RotatedRect
fitEllipse(InputArray points);

void
fitLine(
    InputArray points,
    OutputArray line,
    int distType,
    double param,
    double reps,
    double aeps
    );

void
flip(
    InputArray src,
    OutputArray dst,
    int flipCode
    );

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

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

QtFont
fontQt(
    const String& nameFont,
    int pointSize = -1,
    Scalar color = Scalar::all(0),
    int weight = QT_FONT_NORMAL,
    int style = QT_STYLE_NORMAL,
    int spacing = 0
    );

String
format(
    const char* fmt,
    ...
    );

void
GaussianBlur(
    InputArray src,
    OutputArray dst,
    Size ksize,
    double sigmaX,
    double sigmaY = 0,
    int borderType = BORDER_DEFAULT
    );

void
gemm(
    InputArray src1,
    InputArray src2,
    double alpha,
    InputArray src3,
    double beta,
    OutputArray dst,
    int flags = 0
    );

Mat
getAffineTransform(
    const Point2f src [],
    const Point2f dst []
    );

Mat
getAffineTransform(
    InputArray src,
    InputArray dst
    );

const String&
getBuildInformation();

int64
getCPUTickCount();

Mat
getDefaultNewCameraMatrix(
    InputArray cameraMatrix,
    Size imgsize = Size(),
    bool centerPrincipalPoint = false
    );

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

static
size_t
getElemSize(int type);

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

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

int
getMouseWheelDelta(int flags);

int
getNearestPoint(
    const std::vector<Point2f>& recallPrecisionCurve,
    float l_precision
    );

int
getNumberOfCPUs();

int
getNumThreads();

int
getOptimalDFTSize(int vecsize);

Mat
getOptimalNewCameraMatrix(
    InputArray cameraMatrix,
    InputArray distCoeffs,
    Size imageSize,
    double alpha,
    Size newImgSize = Size(),
    Rect* validPixROI = 0,
    bool centerPrincipalPoint = false
    );

Mat
getPerspectiveTransform(
    const Point2f src [],
    const Point2f dst []
    );

Mat
getPerspectiveTransform(
    InputArray src,
    InputArray dst
    );

float
getRecall(
    const std::vector<Point2f>& recallPrecisionCurve,
    float l_precision
    );

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

Mat
getRotationMatrix2D(
    Point2f center,
    double angle,
    double scale
    );

schar*
getSeqElem(
    const CvSeq* seq,
    int index
    );

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

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

int
getThreadNum();

int64
getTickCount();

double
getTickFrequency();

int
getTrackbarPos(
    const String& trackbarname,
    const String& winname
    );

Rect
getValidDisparityROI(
    Rect roi1,
    Rect roi2,
    int minDisparity,
    int numberOfDisparities,
    int SADWindowSize
    );

double
getWindowProperty(
    const String& winname,
    int prop_id
    );

void
glob(
    String pattern,
    std::vector<String>& result,
    bool recursive = false
    );

void
goodFeaturesToTrack(
    InputArray image,
    OutputArray corners,
    int maxCorners,
    double qualityLevel,
    double minDistance,
    InputArray mask = noArray(),
    int blockSize = 3,
    bool useHarrisDetector = false,
    double k = 0.04
    );

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

void
groupRectangles(
    std::vector<Rect>& rectList,
    int groupThreshold,
    double eps = 0.2
    );

void
groupRectangles(
    std::vector<Rect>& rectList,
    std::vector<int>& weights,
    int groupThreshold,
    double eps = 0.2
    );

void
groupRectangles(
    std::vector<Rect>& rectList,
    int groupThreshold,
    double eps,
    std::vector<int>* weights,
    std::vector<double>* levelWeights
    );

void
groupRectangles(
    std::vector<Rect>& rectList,
    std::vector<int>& rejectLevels,
    std::vector<double>& levelWeights,
    int groupThreshold,
    double eps = 0.2
    );

void
groupRectangles_meanshift(
    std::vector<Rect>& rectList,
    std::vector<double>& foundWeights,
    std::vector<double>& foundScales,
    double detectThreshold = 0.0,
    Size winDetSize = Size(64, 128)
    );

bool
haveOpenVX();

void
hconcat(
    const Mat* src,
    size_t nsrc,
    OutputArray dst
    );

void
hconcat(
    InputArray src1,
    InputArray src2,
    OutputArray dst
    );

void
hconcat(
    InputArrayOfArrays src,
    OutputArray dst
    );

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

void
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
    );

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

void
HuMoments(
    const Moments& moments,
    double hu [7]
    );

void
HuMoments(
    const Moments& m,
    OutputArray hu
    );

void
idct(
    InputArray src,
    OutputArray dst,
    int flags = 0
    );

void
idft(
    InputArray src,
    OutputArray dst,
    int flags = 0,
    int nonzeroRows = 0
    );

void
illuminationChange(
    InputArray src,
    InputArray mask,
    OutputArray dst,
    float alpha = 0.2f,
    float beta = 0.4f
    );

Mat
imdecode(
    InputArray buf,
    int flags
    );

Mat
imdecode(
    InputArray buf,
    int flags,
    Mat* dst
    );

bool
imencode(
    const String& ext,
    InputArray img,
    std::vector<uchar>& buf,
    const std::vector<int>& params = std::vector<int>()
    );

Mat
imread(
    const String& filename,
    int flags = IMREAD_COLOR
    );

bool
imreadmulti(
    const String& filename,
    std::vector<Mat>& mats,
    int flags = IMREAD_ANYCOLOR
    );

void
imshow(
    const String& winname,
    InputArray mat
    );

void
imshow(
    const String& winname,
    const ogl::Texture2D& tex
    );

bool
imwrite(
    const String& filename,
    InputArray img,
    const std::vector<int>& params = std::vector<int>()
    );

Mat
initCameraMatrix2D(
    InputArrayOfArrays objectPoints,
    InputArrayOfArrays imagePoints,
    Size imageSize,
    double aspectRatio = 1.0
    );

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

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

void
inpaint(
    InputArray src,
    InputArray inpaintMask,
    OutputArray dst,
    double inpaintRadius,
    int flags
    );

void
inRange(
    InputArray src,
    InputArray lowerb,
    InputArray upperb,
    OutputArray dst
    );

void
insertChannel(
    InputArray src,
    InputOutputArray dst,
    int coi
    );

void
insertImageCOI(
    InputArray coiimg,
    CvArr* arr,
    int coi = -1
    );

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

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

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

float
intersectConvexConvex(
    InputArray _p1,
    InputArray _p2,
    OutputArray _p12,
    bool handleNested = true
    );

double
invert(
    InputArray src,
    OutputArray dst,
    int flags = DECOMP_LU
    );

void
invertAffineTransform(
    InputArray M,
    OutputArray iM
    );

bool
isContourConvex(InputArray contour);

double
kmeans(
    InputArray data,
    int K,
    InputOutputArray bestLabels,
    TermCriteria criteria,
    int attempts,
    int flags,
    OutputArray centers = noArray()
    );

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

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

void
linearPolar(
    InputArray src,
    OutputArray dst,
    Point2f center,
    double maxRadius,
    int flags
    );

void
loadWindowParameters(const String& windowName);

softfloat
log(const softfloat& a);

softdouble
log(const softdouble& a);

void
log(
    InputArray src,
    OutputArray dst
    );

void
logPolar(
    InputArray src,
    OutputArray dst,
    Point2f center,
    double M,
    int flags
    );

int
LU(
    float* A,
    size_t astep,
    int m,
    float* b,
    size_t bstep,
    int n
    );

int
LU(
    double* A,
    size_t astep,
    int m,
    double* b,
    size_t bstep,
    int n
    );

void
LUT(
    InputArray src,
    InputArray lut,
    OutputArray dst
    );

void
magnitude(
    InputArray x,
    InputArray y,
    OutputArray magnitude
    );

double
Mahalanobis(
    InputArray v1,
    InputArray v2,
    InputArray icovar
    );

template <typename T>
Ptr<T>
makePtr();

template <
    typename T,
    typename A1
    >
Ptr<T>
makePtr(const A1& a1);

template <
    typename T,
    typename A1,
    typename A2
    >
Ptr<T>
makePtr(
    const A1& a1,
    const A2& a2
    );

template <
    typename T,
    typename A1,
    typename A2,
    typename A3
    >
Ptr<T>
makePtr(
    const A1& a1,
    const A2& a2,
    const A3& a3
    );

template <
    typename T,
    typename A1,
    typename A2,
    typename A3,
    typename A4
    >
Ptr<T>
makePtr(
    const A1& a1,
    const A2& a2,
    const A3& a3,
    const A4& a4
    );

template <
    typename T,
    typename A1,
    typename A2,
    typename A3,
    typename A4,
    typename A5
    >
Ptr<T>
makePtr(
    const A1& a1,
    const A2& a2,
    const A3& a3,
    const A4& a4,
    const A5& a5
    );

template <
    typename T,
    typename A1,
    typename A2,
    typename A3,
    typename A4,
    typename A5,
    typename A6
    >
Ptr<T>
makePtr(
    const A1& a1,
    const A2& a2,
    const A3& a3,
    const A4& a4,
    const A5& a5,
    const A6& a6
    );

template <
    typename T,
    typename A1,
    typename A2,
    typename A3,
    typename A4,
    typename A5,
    typename A6,
    typename A7
    >
Ptr<T>
makePtr(
    const A1& a1,
    const A2& a2,
    const A3& a3,
    const A4& a4,
    const A5& a5,
    const A6& a6,
    const A7& a7
    );

template <
    typename T,
    typename A1,
    typename A2,
    typename A3,
    typename A4,
    typename A5,
    typename A6,
    typename A7,
    typename A8
    >
Ptr<T>
makePtr(
    const A1& a1,
    const A2& a2,
    const A3& a3,
    const A4& a4,
    const A5& a5,
    const A6& a6,
    const A7& a7,
    const A8& a8
    );

template <
    typename T,
    typename A1,
    typename A2,
    typename A3,
    typename A4,
    typename A5,
    typename A6,
    typename A7,
    typename A8,
    typename A9
    >
Ptr<T>
makePtr(
    const A1& a1,
    const A2& a2,
    const A3& a3,
    const A4& a4,
    const A5& a5,
    const A6& a6,
    const A7& a7,
    const A8& a8,
    const A9& a9
    );

template <
    typename T,
    typename A1,
    typename A2,
    typename A3,
    typename A4,
    typename A5,
    typename A6,
    typename A7,
    typename A8,
    typename A9,
    typename A10
    >
Ptr<T>
makePtr(
    const A1& a1,
    const A2& a2,
    const A3& a3,
    const A4& a4,
    const A5& a5,
    const A6& a6,
    const A7& a7,
    const A8& a8,
    const A9& a9,
    const A10& a10
    );

double
matchShapes(
    InputArray contour1,
    InputArray contour2,
    int method,
    double parameter
    );

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

void
matMulDeriv(
    InputArray A,
    InputArray B,
    OutputArray dABdA,
    OutputArray dABdB
    );

softfloat
max(
    const softfloat& a,
    const softfloat& b
    );

softdouble
max(
    const softdouble& a,
    const softdouble& b
    );

void
max(
    InputArray src1,
    InputArray src2,
    OutputArray dst
    );

void
max(
    const Mat& src1,
    const Mat& src2,
    Mat& dst
    );

void
max(
    const UMat& src1,
    const UMat& src2,
    UMat& dst
    );

Scalar
mean(
    InputArray src,
    InputArray mask = noArray()
    );

int
meanShift(
    InputArray probImage,
    Rect& window,
    TermCriteria criteria
    );

void
meanStdDev(
    InputArray src,
    OutputArray mean,
    OutputArray stddev,
    InputArray mask = noArray()
    );

void
medianBlur(
    InputArray src,
    OutputArray dst,
    int ksize
    );

void
merge(
    const Mat* mv,
    size_t count,
    OutputArray dst
    );

void
merge(
    InputArrayOfArrays mv,
    OutputArray dst
    );

softfloat
min(
    const softfloat& a,
    const softfloat& b
    );

softdouble
min(
    const softdouble& a,
    const softdouble& b
    );

void
min(
    InputArray src1,
    InputArray src2,
    OutputArray dst
    );

void
min(
    const Mat& src1,
    const Mat& src2,
    Mat& dst
    );

void
min(
    const UMat& src1,
    const UMat& src2,
    UMat& dst
    );

RotatedRect
minAreaRect(InputArray points);

void
minEnclosingCircle(
    InputArray points,
    Point2f& center,
    float& radius
    );

double
minEnclosingTriangle(
    InputArray points,
    OutputArray triangle
    );

void
minMaxIdx(
    InputArray src,
    double* minVal,
    double* maxVal = 0,
    int* minIdx = 0,
    int* maxIdx = 0,
    InputArray mask = noArray()
    );

void
minMaxLoc(
    InputArray src,
    double* minVal,
    double* maxVal = 0,
    Point* minLoc = 0,
    Point* maxLoc = 0,
    InputArray mask = noArray()
    );

void
minMaxLoc(
    const SparseMat& a,
    double* minVal,
    double* maxVal,
    int* minIdx = 0,
    int* maxIdx = 0
    );

void
mixChannels(
    const Mat* src,
    size_t nsrcs,
    Mat* dst,
    size_t ndsts,
    const int* fromTo,
    size_t npairs
    );

void
mixChannels(
    InputArrayOfArrays src,
    InputOutputArrayOfArrays dst,
    const int* fromTo,
    size_t npairs
    );

void
mixChannels(
    InputArrayOfArrays src,
    InputOutputArrayOfArrays dst,
    const std::vector<int>& fromTo
    );

Moments
moments(
    InputArray array,
    bool binaryImage = false
    );

static
Scalar
morphologyDefaultBorderValue();

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

void
moveWindow(
    const String& winname,
    int x,
    int y
    );

softfloat
mulAdd(
    const softfloat& a,
    const softfloat& b,
    const softfloat& c
    );

softdouble
mulAdd(
    const softdouble& a,
    const softdouble& b,
    const softdouble& c
    );

void
mulSpectrums(
    InputArray a,
    InputArray b,
    OutputArray c,
    int flags,
    bool conjB = false
    );

void
multiply(
    InputArray src1,
    InputArray src2,
    OutputArray dst,
    double scale = 1,
    int dtype = -1
    );

void
mulTransposed(
    InputArray src,
    OutputArray dst,
    bool aTa,
    InputArray delta = noArray(),
    double scale = 1,
    int dtype = -1
    );

void
namedWindow(
    const String& winname,
    int flags = WINDOW_AUTOSIZE
    );

InputOutputArray
noArray();

template <
    typename _Tp,
    int m,
    int n
    >
static
double
norm(const Matx<_Tp, m, n>& M);

template <
    typename _Tp,
    int m,
    int n
    >
static
double
norm(
    const Matx<_Tp, m, n>& M,
    int normType
    );

double
norm(
    InputArray src1,
    int normType = NORM_L2,
    InputArray mask = noArray()
    );

double
norm(
    InputArray src1,
    InputArray src2,
    int normType = NORM_L2,
    InputArray mask = noArray()
    );

double
norm(
    const SparseMat& src,
    int normType
    );

template <
    typename _Tp,
    int cn
    >
static
Vec<_Tp, cn>
normalize(const Vec<_Tp, cn>& v);

void
normalize(
    InputArray src,
    InputOutputArray dst,
    double alpha = 1,
    double beta = 0,
    int norm_type = NORM_L2,
    int dtype = -1,
    InputArray mask = noArray()
    );

void
normalize(
    const SparseMat& src,
    SparseMat& dst,
    double alpha,
    int normType
    );

template <
    typename _Tp,
    typename _AccTp
    >
static
_AccTp
normInf(
    const _Tp* a,
    int n
    );

template <
    typename _Tp,
    typename _AccTp
    >
static
_AccTp
normInf(
    const _Tp* a,
    const _Tp* b,
    int n
    );

template <
    typename _Tp,
    typename _AccTp
    >
static
_AccTp
normL1(
    const _Tp* a,
    int n
    );

template <
    typename _Tp,
    typename _AccTp
    >
static
_AccTp
normL1(
    const _Tp* a,
    const _Tp* b,
    int n
    );

float
normL1(
    const float* a,
    const float* b,
    int n
    );

int
normL1(
    const uchar* a,
    const uchar* b,
    int n
    );

template <
    typename _Tp,
    typename _AccTp
    >
static
_AccTp
normL2Sqr(
    const _Tp* a,
    int n
    );

template <
    typename _Tp,
    typename _AccTp
    >
static
_AccTp
normL2Sqr(
    const _Tp* a,
    const _Tp* b,
    int n
    );

static
float
normL2Sqr(
    const float* a,
    const float* b,
    int n
    );

template <typename T>
bool
operator!=(
    const Ptr<T>& ptr1,
    const Ptr<T>& ptr2
    );

template <
    typename _Tp,
    int n
    >
v_reg<_Tp, n>
operator!=(
    const v_reg<_Tp, n>& a,
    const v_reg<_Tp, n>& b
    );

template <typename _Tp>
bool
operator!=(
    const SeqIterator<_Tp>& a,
    const SeqIterator<_Tp>& b
    );

template <
    typename _Tp,
    int n
    >
v_reg<_Tp, n>
operator&(
    const v_reg<_Tp, n>& a,
    const v_reg<_Tp, n>& b
    );

template <
    typename _Tp,
    int n
    >
v_reg<_Tp, n>&
operator&=(
    v_reg<_Tp, n>& a,
    const v_reg<_Tp, n>& b
    );

template <typename T>
static
Affine3<T>
operator*(
    const Affine3<T>& affine1,
    const Affine3<T>& affine2
    );

template <
    typename T,
    typename V
    >
static
V
operator*(
    const Affine3<T>& affine,
    const V& vector
    );

static
Vec3f
operator*(
    const Affine3f& affine,
    const Vec3f& vector
    );

static
Vec3d
operator*(
    const Affine3d& affine,
    const Vec3d& vector
    );

template <
    typename _Tp,
    int n
    >
v_reg<_Tp, n>
operator*(
    const v_reg<_Tp, n>& a,
    const v_reg<_Tp, n>& b
    );

template <
    typename _Tp,
    int n
    >
v_reg<_Tp, n>&
operator*=(
    v_reg<_Tp, n>& a,
    const v_reg<_Tp, n>& b
    );

template <
    typename _Tp,
    int n
    >
v_reg<_Tp, n>
operator+(
    const v_reg<_Tp, n>& a,
    const v_reg<_Tp, n>& b
    );

template <
    typename _Tp,
    int n
    >
v_reg<_Tp, n>&
operator+=(
    v_reg<_Tp, n>& a,
    const v_reg<_Tp, n>& b
    );

template <
    typename _Tp,
    int n
    >
v_reg<_Tp, n>
operator-(
    const v_reg<_Tp, n>& a,
    const v_reg<_Tp, n>& b
    );

template <typename _Tp>
ptrdiff_t
operator-(
    const SeqIterator<_Tp>& a,
    const SeqIterator<_Tp>& b
    );

template <
    typename _Tp,
    int n
    >
v_reg<_Tp, n>&
operator-=(
    v_reg<_Tp, n>& a,
    const v_reg<_Tp, n>& b
    );

template <
    typename _Tp,
    int n
    >
v_reg<_Tp, n>
operator/(
    const v_reg<_Tp, n>& a,
    const v_reg<_Tp, n>& b
    );

template <
    typename _Tp,
    int n
    >
v_reg<_Tp, n>&
operator/=(
    v_reg<_Tp, n>& a,
    const v_reg<_Tp, n>& b
    );

template <
    typename _Tp,
    int n
    >
v_reg<_Tp, n>
operator<(
    const v_reg<_Tp, n>& a,
    const v_reg<_Tp, n>& b
    );

static
std::ostream&
operator<<(
    std::ostream& out,
    const TickMeter& tm
    );

template <
    typename _Tp,
    int n
    >
v_reg<_Tp, n>
operator<<(
    const v_reg<_Tp, n>& a,
    int imm
    );

static
String&
operator<<(
    String& out,
    Ptr<Formatted> fmtd
    );

static
String&
operator<<(
    String& out,
    const Mat& mtx
    );

template <
    typename _Tp,
    int n
    >
v_reg<_Tp, n>
operator<=(
    const v_reg<_Tp, n>& a,
    const v_reg<_Tp, n>& b
    );

template <typename T>
bool
operator==(
    const Ptr<T>& ptr1,
    const Ptr<T>& ptr2
    );

template <
    typename _Tp,
    int n
    >
v_reg<_Tp, n>
operator==(
    const v_reg<_Tp, n>& a,
    const v_reg<_Tp, n>& b
    );

template <typename _Tp>
bool
operator==(
    const SeqIterator<_Tp>& a,
    const SeqIterator<_Tp>& b
    );

template <
    typename _Tp,
    int n
    >
v_reg<_Tp, n>
operator>(
    const v_reg<_Tp, n>& a,
    const v_reg<_Tp, n>& b
    );

template <
    typename _Tp,
    int n
    >
v_reg<_Tp, n>
operator>=(
    const v_reg<_Tp, n>& a,
    const v_reg<_Tp, n>& b
    );

template <
    typename _Tp,
    int n
    >
v_reg<_Tp, n>
operator>>(
    const v_reg<_Tp, n>& a,
    int imm
    );

template <
    typename _Tp,
    int n
    >
v_reg<_Tp, n>
operator^(
    const v_reg<_Tp, n>& a,
    const v_reg<_Tp, n>& b
    );

template <
    typename _Tp,
    int n
    >
v_reg<_Tp, n>&
operator^=(
    v_reg<_Tp, n>& a,
    const v_reg<_Tp, n>& b
    );

template <
    typename _Tp,
    int n
    >
v_reg<_Tp, n>
operator|(
    const v_reg<_Tp, n>& a,
    const v_reg<_Tp, n>& b
    );

template <
    typename _Tp,
    int n
    >
v_reg<_Tp, n>&
operator|=(
    v_reg<_Tp, n>& a,
    const v_reg<_Tp, n>& b
    );

template <
    typename _Tp,
    int n
    >
v_reg<_Tp, n>
operator~(const v_reg<_Tp, n>& a);

void
parallel_for_(
    const Range& range,
    const ParallelLoopBody& body,
    double nstripes = -1.
    );

void
patchNaNs(
    InputOutputArray a,
    double val = 0
    );

void
PCABackProject(
    InputArray data,
    InputArray mean,
    InputArray eigenvectors,
    OutputArray result
    );

void
PCACompute(
    InputArray data,
    InputOutputArray mean,
    OutputArray eigenvectors,
    int maxComponents = 0
    );

void
PCACompute(
    InputArray data,
    InputOutputArray mean,
    OutputArray eigenvectors,
    double retainedVariance
    );

void
PCAProject(
    InputArray data,
    InputArray mean,
    InputArray eigenvectors,
    OutputArray result
    );

void
pencilSketch(
    InputArray src,
    OutputArray dst1,
    OutputArray dst2,
    float sigma_s = 60,
    float sigma_r = 0.07f,
    float shade_factor = 0.02f
    );

void
perspectiveTransform(
    InputArray src,
    OutputArray dst,
    InputArray m
    );

void
phase(
    InputArray x,
    InputArray y,
    OutputArray angle,
    bool angleInDegrees = false
    );

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

double
pointPolygonTest(
    InputArray contour,
    Point2f pt,
    bool measureDist
    );

void
polarToCart(
    InputArray magnitude,
    InputArray angle,
    OutputArray x,
    OutputArray y,
    bool angleInDegrees = false
    );

void
polylines(
    Mat& 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
polylines(
    InputOutputArray img,
    InputArrayOfArrays pts,
    bool isClosed,
    const Scalar& color,
    int thickness = 1,
    int lineType = LINE_8,
    int shift = 0
    );

softfloat
pow(
    const softfloat& a,
    const softfloat& b
    );

softdouble
pow(
    const softdouble& a,
    const softdouble& b
    );

void
pow(
    InputArray src,
    double power,
    OutputArray dst
    );

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

void
projectPoints(
    InputArray objectPoints,
    InputArray rvec,
    InputArray tvec,
    InputArray cameraMatrix,
    InputArray distCoeffs,
    OutputArray imagePoints,
    OutputArray jacobian = noArray(),
    double aspectRatio = 0
    );

double
PSNR(
    InputArray src1,
    InputArray src2
    );

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

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

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

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

void
randn(
    InputOutputArray dst,
    InputArray mean,
    InputArray stddev
    );

void
randShuffle(
    InputOutputArray dst,
    double iterFactor = 1.,
    RNG* rng = 0
    );

void
randu(
    InputOutputArray dst,
    InputArray low,
    InputArray high
    );

int
recoverPose(
    InputArray E,
    InputArray points1,
    InputArray points2,
    InputArray cameraMatrix,
    OutputArray R,
    OutputArray t,
    InputOutputArray mask = noArray()
    );

int
recoverPose(
    InputArray E,
    InputArray points1,
    InputArray points2,
    OutputArray R,
    OutputArray t,
    double focal = 1.0,
    Point2d pp = Point2d(0, 0),
    InputOutputArray mask = noArray()
    );

int
recoverPose(
    InputArray E,
    InputArray points1,
    InputArray points2,
    InputArray cameraMatrix,
    OutputArray R,
    OutputArray t,
    double distanceThresh,
    InputOutputArray mask = noArray(),
    OutputArray triangulatedPoints = noArray()
    );

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

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

float
rectify3Collinear(
    InputArray cameraMatrix1,
    InputArray distCoeffs1,
    InputArray cameraMatrix2,
    InputArray distCoeffs2,
    InputArray cameraMatrix3,
    InputArray distCoeffs3,
    InputArrayOfArrays imgpt1,
    InputArrayOfArrays imgpt3,
    Size imageSize,
    InputArray R12,
    InputArray T12,
    InputArray R13,
    InputArray T13,
    OutputArray R1,
    OutputArray R2,
    OutputArray R3,
    OutputArray P1,
    OutputArray P2,
    OutputArray P3,
    OutputArray Q,
    double alpha,
    Size newImgSize,
    Rect* roi1,
    Rect* roi2,
    int flags
    );

ErrorCallback
redirectError(
    ErrorCallback errCallback,
    void* userdata = 0,
    void** prevUserdata = 0
    );

void
reduce(
    InputArray src,
    OutputArray dst,
    int dim,
    int rtype,
    int dtype = -1
    );

void
remap(
    InputArray src,
    OutputArray dst,
    InputArray map1,
    InputArray map2,
    int interpolation,
    int borderMode = BORDER_CONSTANT,
    const Scalar& borderValue = Scalar()
    );

void
repeat(
    InputArray src,
    int ny,
    int nx,
    OutputArray dst
    );

Mat
repeat(
    const Mat& src,
    int ny,
    int nx
    );

void
reprojectImageTo3D(
    InputArray disparity,
    OutputArray _3dImage,
    InputArray Q,
    bool handleMissingValues = false,
    int ddepth = -1
    );

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

void
resizeWindow(
    const String& winname,
    int width,
    int height
    );

void
Rodrigues(
    InputArray src,
    OutputArray dst,
    OutputArray jacobian = noArray()
    );

void
rotate(
    InputArray src,
    OutputArray dst,
    int rotateCode
    );

int
rotatedRectangleIntersection(
    const RotatedRect& rect1,
    const RotatedRect& rect2,
    OutputArray intersectingRegion
    );

Vec3d
RQDecomp3x3(
    InputArray src,
    OutputArray mtxR,
    OutputArray mtxQ,
    OutputArray Qx = noArray(),
    OutputArray Qy = noArray(),
    OutputArray Qz = noArray()
    );

double
sampsonDistance(
    InputArray pt1,
    InputArray pt2,
    InputArray F
    );

template <typename _Tp>
static
_Tp
saturate_cast(uchar v);

template <typename _Tp>
static
_Tp
saturate_cast(schar v);

template <typename _Tp>
static
_Tp
saturate_cast(ushort v);

template <typename _Tp>
static
_Tp
saturate_cast(short v);

template <typename _Tp>
static
_Tp
saturate_cast(unsigned v);

template <typename _Tp>
static
_Tp
saturate_cast(int v);

template <typename _Tp>
static
_Tp
saturate_cast(float v);

template <typename _Tp>
static
_Tp
saturate_cast(double v);

template <typename _Tp>
static
_Tp
saturate_cast(int64 v);

template <typename _Tp>
static
_Tp
saturate_cast(uint64 v);

template <typename _Tp>
static
_Tp
saturate_cast(softfloat a);

template <typename _Tp>
static
_Tp
saturate_cast(softdouble a);

schar
saturate_cast< schar >(uchar v);

schar
saturate_cast< schar >(ushort v);

schar
saturate_cast< schar >(int v);

schar
saturate_cast< schar >(short v);

schar
saturate_cast< schar >(unsigned v);

schar
saturate_cast< schar >(float v);

schar
saturate_cast< schar >(double v);

schar
saturate_cast< schar >(int64 v);

schar
saturate_cast< schar >(uint64 v);

schar
saturate_cast< schar >(softfloat a);

schar
saturate_cast< schar >(softdouble a);

short
saturate_cast< short >(ushort v);

short
saturate_cast< short >(int v);

short
saturate_cast< short >(unsigned v);

short
saturate_cast< short >(float v);

short
saturate_cast< short >(double v);

short
saturate_cast< short >(int64 v);

short
saturate_cast< short >(uint64 v);

short
saturate_cast< short >(softfloat a);

short
saturate_cast< short >(softdouble a);

uchar
saturate_cast< uchar >(schar v);

uchar
saturate_cast< uchar >(ushort v);

uchar
saturate_cast< uchar >(int v);

uchar
saturate_cast< uchar >(short v);

uchar
saturate_cast< uchar >(unsigned v);

uchar
saturate_cast< uchar >(float v);

uchar
saturate_cast< uchar >(double v);

uchar
saturate_cast< uchar >(int64 v);

uchar
saturate_cast< uchar >(uint64 v);

uchar
saturate_cast< uchar >(softfloat a);

uchar
saturate_cast< uchar >(softdouble a);

unsigned
saturate_cast< unsigned >(float v);

unsigned
saturate_cast< unsigned >(double v);

unsigned
saturate_cast< unsigned >(softfloat a);

unsigned
saturate_cast< unsigned >(softdouble a);

ushort
saturate_cast< ushort >(schar v);

ushort
saturate_cast< ushort >(short v);

ushort
saturate_cast< ushort >(int v);

ushort
saturate_cast< ushort >(unsigned v);

ushort
saturate_cast< ushort >(float v);

ushort
saturate_cast< ushort >(double v);

ushort
saturate_cast< ushort >(int64 v);

ushort
saturate_cast< ushort >(uint64 v);

ushort
saturate_cast< ushort >(softfloat a);

ushort
saturate_cast< ushort >(softdouble a);

void
saveWindowParameters(const String& windowName);

void
scaleAdd(
    InputArray src1,
    double alpha,
    InputArray src2,
    OutputArray dst
    );

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

void
seamlessClone(
    InputArray src,
    InputArray dst,
    InputArray mask,
    Point p,
    OutputArray blend,
    int flags
    );

Rect
selectROI(
    const String& windowName,
    InputArray img,
    bool showCrosshair = true,
    bool fromCenter = false
    );

Rect
selectROI(
    InputArray img,
    bool showCrosshair = true,
    bool fromCenter = false
    );

void
selectROIs(
    const String& windowName,
    InputArray img,
    std::vector<Rect>& boundingBoxes,
    bool showCrosshair = true,
    bool fromCenter = false
    );

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

void
seqInsertSlice(
    CvSeq* seq,
    int before_index,
    const CvArr* from_arr
    );

void
seqPop(
    CvSeq* seq,
    void* element = 0
    );

void
seqPopFront(
    CvSeq* seq,
    void* element = 0
    );

void
seqPopMulti(
    CvSeq* seq,
    void* elements,
    int count,
    int in_front = 0
    );

schar*
seqPush(
    CvSeq* seq,
    const void* element = 0
    );

schar*
seqPushFront(
    CvSeq* seq,
    const void* element = 0
    );

void
seqRemove(
    CvSeq* seq,
    int index
    );

void
seqRemoveSlice(
    CvSeq* seq,
    CvSlice slice
    );

bool
setBreakOnError(bool flag);

void
setIdentity(
    InputOutputArray mtx,
    const Scalar& s = Scalar(1)
    );

void
setMouseCallback(
    const String& winname,
    MouseCallback onMouse,
    void* userdata = 0
    );

void
setNumThreads(int nthreads);

void
setOpenGlContext(const String& winname);

void
setOpenGlDrawCallback(
    const String& winname,
    OpenGlDrawCallback onOpenGlDraw,
    void* userdata = 0
    );

void
setRNGSeed(int seed);

void
setTrackbarMax(
    const String& trackbarname,
    const String& winname,
    int maxval
    );

void
setTrackbarMin(
    const String& trackbarname,
    const String& winname,
    int minval
    );

void
setTrackbarPos(
    const String& trackbarname,
    const String& winname,
    int pos
    );

void
setUseOpenVX(bool flag);

void
setUseOptimized(bool onoff);

void
setWindowProperty(
    const String& winname,
    int prop_id,
    double prop_value
    );

void
setWindowTitle(
    const String& winname,
    const String& title
    );

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

bool
solve(
    InputArray src1,
    InputArray src2,
    OutputArray dst,
    int flags = DECOMP_LU
    );

int
solveCubic(
    InputArray coeffs,
    OutputArray roots
    );

int
solveLP(
    const Mat& Func,
    const Mat& Constr,
    Mat& z
    );

bool
solvePnP(
    InputArray objectPoints,
    InputArray imagePoints,
    InputArray cameraMatrix,
    InputArray distCoeffs,
    OutputArray rvec,
    OutputArray tvec,
    bool useExtrinsicGuess = false,
    int flags = SOLVEPNP_ITERATIVE
    );

bool
solvePnPRansac(
    InputArray objectPoints,
    InputArray imagePoints,
    InputArray cameraMatrix,
    InputArray distCoeffs,
    OutputArray rvec,
    OutputArray tvec,
    bool useExtrinsicGuess = false,
    int iterationsCount = 100,
    float reprojectionError = 8.0,
    double confidence = 0.99,
    OutputArray inliers = noArray(),
    int flags = SOLVEPNP_ITERATIVE
    );

double
solvePoly(
    InputArray coeffs,
    OutputArray roots,
    int maxIters = 300
    );

void
sort(
    InputArray src,
    OutputArray dst,
    int flags
    );

void
sortIdx(
    InputArray src,
    OutputArray dst,
    int flags
    );

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

void
split(
    const Mat& src,
    Mat* mvbegin
    );

void
split(
    InputArray m,
    OutputArrayOfArrays mv
    );

void
sqrBoxFilter(
    InputArray _src,
    OutputArray _dst,
    int ddepth,
    Size ksize,
    Point anchor = Point(-1, -1),
    bool normalize = true,
    int borderType = BORDER_DEFAULT
    );

softfloat
sqrt(const softfloat& a);

softdouble
sqrt(const softdouble& a);

void
sqrt(
    InputArray src,
    OutputArray dst
    );

int
startLoop(
    int(*)(int argc, char*argv[]) pt2Func,
    int argc,
    char* argv []
    );

int
startWindowThread();

double
stereoCalibrate(
    InputArrayOfArrays objectPoints,
    InputArrayOfArrays imagePoints1,
    InputArrayOfArrays imagePoints2,
    InputOutputArray cameraMatrix1,
    InputOutputArray distCoeffs1,
    InputOutputArray cameraMatrix2,
    InputOutputArray distCoeffs2,
    Size imageSize,
    OutputArray R,
    OutputArray T,
    OutputArray E,
    OutputArray F,
    int flags = CALIB_FIX_INTRINSIC,
    TermCriteria criteria = TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, 1e-6)
    );

void
stereoRectify(
    InputArray cameraMatrix1,
    InputArray distCoeffs1,
    InputArray cameraMatrix2,
    InputArray distCoeffs2,
    Size imageSize,
    InputArray R,
    InputArray T,
    OutputArray R1,
    OutputArray R2,
    OutputArray P1,
    OutputArray P2,
    OutputArray Q,
    int flags = CALIB_ZERO_DISPARITY,
    double alpha = -1,
    Size newImageSize = Size(),
    Rect* validPixROI1 = 0,
    Rect* validPixROI2 = 0
    );

bool
stereoRectifyUncalibrated(
    InputArray points1,
    InputArray points2,
    InputArray F,
    Size imgSize,
    OutputArray H1,
    OutputArray H2,
    double threshold = 5
    );

void
stopLoop();

void
stylization(
    InputArray src,
    OutputArray dst,
    float sigma_s = 60,
    float sigma_r = 0.45f
    );

void
subtract(
    InputArray src1,
    InputArray src2,
    OutputArray dst,
    InputArray mask = noArray(),
    int dtype = -1
    );

Scalar
sum(InputArray src);

void
SVBackSubst(
    InputArray w,
    InputArray u,
    InputArray vt,
    InputArray rhs,
    OutputArray dst
    );

void
SVDecomp(
    InputArray src,
    OutputArray w,
    OutputArray u,
    OutputArray vt,
    int flags = 0
    );

void
swap(
    Mat& a,
    Mat& b
    );

void
swap(
    UMat& a,
    UMat& b
    );

template <typename T>
void
swap(
    Ptr<T>& ptr1,
    Ptr<T>& ptr2
    );

String
tempfile(const char* suffix = 0);

void
textureFlattening(
    InputArray src,
    InputArray mask,
    OutputArray dst,
    float low_threshold = 30,
    float high_threshold = 45,
    int kernel_size = 3
    );

RNG&
theRNG();

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

template <
    typename _Tp,
    int m,
    int n
    >
static
double
trace(const Matx<_Tp, m, n>& a);

Scalar
trace(InputArray mtx);

void
transform(
    InputArray src,
    OutputArray dst,
    InputArray m
    );

void
transpose(
    InputArray src,
    OutputArray dst
    );

void
triangulatePoints(
    InputArray projMatr1,
    InputArray projMatr2,
    InputArray projPoints1,
    InputArray projPoints2,
    OutputArray points4D
    );

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

void
undistortPoints(
    InputArray src,
    OutputArray dst,
    InputArray cameraMatrix,
    InputArray distCoeffs,
    InputArray R = noArray(),
    InputArray P = noArray()
    );

void
updateWindow(const String& winname);

bool
useOpenVX();

bool
useOptimized();

template <
    typename _Tp,
    int n
    >
v_reg<typename V_TypeTraits<_Tp>::abs_type, n>
v_abs(const v_reg<_Tp, n>& a);

template <
    typename _Tp,
    int n
    >
v_reg<typename V_TypeTraits<_Tp>::abs_type, n>
v_absdiff(
    const v_reg<_Tp, n>& a,
    const v_reg<_Tp, n>& b
    );

v_float32x4
v_absdiff(
    const v_float32x4& a,
    const v_float32x4& b
    );

v_float64x2
v_absdiff(
    const v_float64x2& a,
    const v_float64x2& b
    );

template <
    typename _Tp,
    int n
    >
v_reg<_Tp, n>
v_add_wrap(
    const v_reg<_Tp, n>& a,
    const v_reg<_Tp, n>& b
    );

template <
    typename _Tp,
    int n
    >
v_reg<int, n>
v_ceil(const v_reg<_Tp, n>& a);

template <int n>
v_reg<int, n>
v_ceil(const v_reg<float, n>& a);

template <int n>
v_reg<int, n*2>
v_ceil(const v_reg<double, n>& a);

template <
    typename _Tp,
    int n
    >
bool
v_check_all(const v_reg<_Tp, n>& a);

template <
    typename _Tp,
    int n
    >
bool
v_check_any(const v_reg<_Tp, n>& a);

template <
    typename _Tp,
    int n
    >
v_reg<_Tp, n>
v_combine_high(
    const v_reg<_Tp, n>& a,
    const v_reg<_Tp, n>& b
    );

template <
    typename _Tp,
    int n
    >
v_reg<_Tp, n>
v_combine_low(
    const v_reg<_Tp, n>& a,
    const v_reg<_Tp, n>& b
    );

template <int n>
v_reg<float, n>
v_cvt_f32(const v_reg<int, n>& a);

template <int n>
v_reg<double, n>
v_cvt_f64(const v_reg<int, n*2>& a);

template <int n>
v_reg<double, n>
v_cvt_f64(const v_reg<float, n*2>& a);

template <
    typename _Tp,
    int n
    >
v_reg<typename V_TypeTraits<_Tp>::w_type, n/2>
v_dotprod(
    const v_reg<_Tp, n>& a,
    const v_reg<_Tp, n>& b
    );

template <
    typename _Tp,
    int n
    >
void
v_expand(
    const v_reg<_Tp, n>& a,
    v_reg<typename V_TypeTraits<_Tp>::w_type, n/2>& b0,
    v_reg<typename V_TypeTraits<_Tp>::w_type, n/2>& b1
    );

template <
    int s,
    typename _Tp,
    int n
    >
v_reg<_Tp, n>
v_extract(
    const v_reg<_Tp, n>& a,
    const v_reg<_Tp, n>& b
    );

template <
    typename _Tp,
    int n
    >
v_reg<int, n>
v_floor(const v_reg<_Tp, n>& a);

template <int n>
v_reg<int, n>
v_floor(const v_reg<float, n>& a);

template <int n>
v_reg<int, n*2>
v_floor(const v_reg<double, n>& a);

template <
    typename _Tp,
    int n
    >
v_reg<_Tp, n>
v_invsqrt(const v_reg<_Tp, n>& a);

template <typename _Tp>
v_reg<_Tp, V_SIMD128Traits<_Tp>::nlanes>
v_load(const _Tp* ptr);

template <typename _Tp>
v_reg<_Tp, V_SIMD128Traits<_Tp>::nlanes>
v_load_aligned(const _Tp* ptr);

template <
    typename _Tp,
    int n
    >
void
v_load_deinterleave(
    const _Tp* ptr,
    v_reg<_Tp, n>& a,
    v_reg<_Tp, n>& b
    );

template <
    typename _Tp,
    int n
    >
void
v_load_deinterleave(
    const _Tp* ptr,
    v_reg<_Tp, n>& a,
    v_reg<_Tp, n>& b,
    v_reg<_Tp, n>& c
    );

template <
    typename _Tp,
    int n
    >
void
v_load_deinterleave(
    const _Tp* ptr,
    v_reg<_Tp, n>& a,
    v_reg<_Tp, n>& b,
    v_reg<_Tp, n>& c,
    v_reg<_Tp, n>& d
    );

template <typename _Tp>
v_reg<typename V_TypeTraits<_Tp>::w_type, V_SIMD128Traits<_Tp>::nlanes/2>
v_load_expand(const _Tp* ptr);

template <typename _Tp>
v_reg<typename V_TypeTraits<_Tp>::q_type, V_SIMD128Traits<_Tp>::nlanes/4>
v_load_expand_q(const _Tp* ptr);

template <typename _Tp>
v_reg<_Tp, V_SIMD128Traits<_Tp>::nlanes>
v_load_halves(
    const _Tp* loptr,
    const _Tp* hiptr
    );

template <
    typename _Tp,
    int n
    >
v_reg<_Tp, n>
v_magnitude(
    const v_reg<_Tp, n>& a,
    const v_reg<_Tp, n>& b
    );

v_float32x4
v_matmul(
    const v_float32x4& v,
    const v_float32x4& m0,
    const v_float32x4& m1,
    const v_float32x4& m2,
    const v_float32x4& m3
    );

template <
    typename _Tp,
    int n
    >
v_reg<_Tp, n>
v_max(
    const v_reg<_Tp, n>& a,
    const v_reg<_Tp, n>& b
    );

template <
    typename _Tp,
    int n
    >
v_reg<_Tp, n>
v_min(
    const v_reg<_Tp, n>& a,
    const v_reg<_Tp, n>& b
    );

template <
    typename _Tp,
    int n
    >
void
v_mul_expand(
    const v_reg<_Tp, n>& a,
    const v_reg<_Tp, n>& b,
    v_reg<typename V_TypeTraits<_Tp>::w_type, n/2>& c,
    v_reg<typename V_TypeTraits<_Tp>::w_type, n/2>& d
    );

template <
    typename _Tp,
    int n
    >
v_reg<_Tp, n>
v_muladd(
    const v_reg<_Tp, n>& a,
    const v_reg<_Tp, n>& b,
    const v_reg<_Tp, n>& c
    );

template <
    typename _Tp,
    int n
    >
v_uint32x4
v_popcount(const v_reg<_Tp, n>& a);

template <
    typename _Tp,
    int n
    >
void
v_recombine(
    const v_reg<_Tp, n>& a,
    const v_reg<_Tp, n>& b,
    v_reg<_Tp, n>& low,
    v_reg<_Tp, n>& high
    );

template <
    typename _Tp,
    int n
    >
_Tp
v_reduce_max(const v_reg<_Tp, n>& a);

template <
    typename _Tp,
    int n
    >
_Tp
v_reduce_min(const v_reg<_Tp, n>& a);

template <
    typename _Tp,
    int n
    >
V_TypeTraits<_Tp>::sum_type
v_reduce_sum(const v_reg<_Tp, n>& a);

v_float32x4
v_reduce_sum4(
    const v_float32x4& a,
    const v_float32x4& b,
    const v_float32x4& c,
    const v_float32x4& d
    );

template <
    typename _Tp,
    int n
    >
v_reg<int, n>
v_round(const v_reg<_Tp, n>& a);

template <int n>
v_reg<int, n>
v_round(const v_reg<float, n>& a);

template <int n>
v_reg<int, n*2>
v_round(const v_reg<double, n>& a);

template <
    typename _Tp,
    int n
    >
v_reg<_Tp, n>
v_select(
    const v_reg<_Tp, n>& mask,
    const v_reg<_Tp, n>& a,
    const v_reg<_Tp, n>& b
    );

template <
    typename _Tp,
    int n
    >
int
v_signmask(const v_reg<_Tp, n>& a);

template <
    typename _Tp,
    int n
    >
v_reg<_Tp, n>
v_sqr_magnitude(
    const v_reg<_Tp, n>& a,
    const v_reg<_Tp, n>& b
    );

template <
    typename _Tp,
    int n
    >
v_reg<_Tp, n>
v_sqrt(const v_reg<_Tp, n>& a);

template <
    typename _Tp,
    int n
    >
void
v_store(
    _Tp* ptr,
    const v_reg<_Tp, n>& a
    );

template <
    typename _Tp,
    int n
    >
void
v_store_aligned(
    _Tp* ptr,
    const v_reg<_Tp, n>& a
    );

template <
    typename _Tp,
    int n
    >
void
v_store_high(
    _Tp* ptr,
    const v_reg<_Tp, n>& a
    );

template <
    typename _Tp,
    int n
    >
void
v_store_interleave(
    _Tp* ptr,
    const v_reg<_Tp, n>& a,
    const v_reg<_Tp, n>& b
    );

template <
    typename _Tp,
    int n
    >
void
v_store_interleave(
    _Tp* ptr,
    const v_reg<_Tp, n>& a,
    const v_reg<_Tp, n>& b,
    const v_reg<_Tp, n>& c
    );

template <
    typename _Tp,
    int n
    >
void
v_store_interleave(
    _Tp* ptr,
    const v_reg<_Tp, n>& a,
    const v_reg<_Tp, n>& b,
    const v_reg<_Tp, n>& c,
    const v_reg<_Tp, n>& d
    );

template <
    typename _Tp,
    int n
    >
void
v_store_low(
    _Tp* ptr,
    const v_reg<_Tp, n>& a
    );

template <
    typename _Tp,
    int n
    >
v_reg<_Tp, n>
v_sub_wrap(
    const v_reg<_Tp, n>& a,
    const v_reg<_Tp, n>& b
    );

template <typename _Tp>
void
v_transpose4x4(
    v_reg<_Tp, 4>& a0,
    const v_reg<_Tp, 4>& a1,
    const v_reg<_Tp, 4>& a2,
    const v_reg<_Tp, 4>& a3,
    v_reg<_Tp, 4>& b0,
    v_reg<_Tp, 4>& b1,
    v_reg<_Tp, 4>& b2,
    v_reg<_Tp, 4>& b3
    );

template <
    typename _Tp,
    int n
    >
v_reg<int, n>
v_trunc(const v_reg<_Tp, n>& a);

template <int n>
v_reg<int, n>
v_trunc(const v_reg<float, n>& a);

template <int n>
v_reg<int, n*2>
v_trunc(const v_reg<double, n>& a);

template <
    typename _Tp,
    int n
    >
void
v_zip(
    const v_reg<_Tp, n>& a0,
    const v_reg<_Tp, n>& a1,
    v_reg<_Tp, n>& b0,
    v_reg<_Tp, n>& b1
    );

void
validateDisparity(
    InputOutputArray disparity,
    InputArray cost,
    int minDisparity,
    int numberOfDisparities,
    int disp12MaxDisp = 1
    );

void
vconcat(
    const Mat* src,
    size_t nsrc,
    OutputArray dst
    );

void
vconcat(
    InputArray src1,
    InputArray src2,
    OutputArray dst
    );

void
vconcat(
    InputArrayOfArrays src,
    OutputArray dst
    );

int
waitKey(int delay = 0);

int
waitKeyEx(int delay = 0);

void
warpAffine(
    InputArray src,
    OutputArray dst,
    InputArray M,
    Size dsize,
    int flags = INTER_LINEAR,
    int borderMode = BORDER_CONSTANT,
    const Scalar& borderValue = Scalar()
    );

void
warpPerspective(
    InputArray src,
    OutputArray dst,
    InputArray M,
    Size dsize,
    int flags = INTER_LINEAR,
    int borderMode = BORDER_CONSTANT,
    const Scalar& borderValue = Scalar()
    );

void
watershed(
    InputArray image,
    InputOutputArray markers
    );

void
winrt_imshow();

void
winrt_initContainer(::Windows::UI::Xaml::Controls::Panel^ container);

void
winrt_onVisibilityChanged(bool visible);

void
winrt_setFrameContainer(::Windows::UI::Xaml::Controls::Image^ image);

template <typename ... Args>
void
winrt_startMessageLoop(
    std::function<void(Args...)>&& callback,
    Args... args
    );

template <typename ... Args>
void
winrt_startMessageLoop(
    void  callback Args...,
    Args... args
    );

template void
winrt_startMessageLoop(void  callback void);

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

} // namespace cv

Detailed Documentation

Enum Values

CAP_PROP_DC1394_OFF

turn the feature off (not controlled manually nor automatically).

CAP_PROP_DC1394_MODE_MANUAL

set automatically when a value of the feature is set by the user.

CAP_PROP_OPENNI_FRAME_MAX_DEPTH

In mm.

CAP_PROP_OPENNI_BASELINE

In mm.

CAP_PROP_OPENNI_FOCAL_LENGTH

In pixels.

CAP_PROP_OPENNI_REGISTRATION

Flag that synchronizes the remapping depth map to image map by changing depth generator’s view point (if the flag is “on”) or sets this view point to its normal one (if the flag is “off”).

CAP_OPENNI_DEPTH_MAP

Depth values in mm (CV_16UC1)

CAP_OPENNI_POINT_CLOUD_MAP

XYZ in meters (CV_32FC3)

CAP_OPENNI_DISPARITY_MAP

Disparity in pixels (CV_8UC1)

CAP_OPENNI_DISPARITY_MAP_32F

Disparity in pixels (CV_32FC1)

CAP_OPENNI_VALID_DEPTH_MASK

CV_8UC1.

CAP_OPENNI_BGR_IMAGE

Data given from RGB image generator.

CAP_OPENNI_GRAY_IMAGE

Data given from RGB image generator.

CAP_OPENNI_IR_IMAGE

Data given from IR image generator.

CAP_PROP_GSTREAMER_QUEUE_LENGTH

Default is 1.

CAP_PROP_PVAPI_MULTICASTIP

IP for enable multicast master mode. 0 for disable multicast.

CAP_PROP_PVAPI_FRAMESTARTTRIGGERMODE

FrameStartTriggerMode: Determines how a frame is initiated.

CAP_PROP_PVAPI_DECIMATIONHORIZONTAL

Horizontal sub-sampling of the image.

CAP_PROP_PVAPI_DECIMATIONVERTICAL

Vertical sub-sampling of the image.

CAP_PROP_PVAPI_BINNINGX

Horizontal binning factor.

CAP_PROP_PVAPI_BINNINGY

Vertical binning factor.

CAP_PROP_PVAPI_PIXELFORMAT

Pixel format.

CAP_PVAPI_FSTRIGMODE_FREERUN

Freerun.

CAP_PVAPI_FSTRIGMODE_SYNCIN1

SyncIn1.

CAP_PVAPI_FSTRIGMODE_SYNCIN2

SyncIn2.

CAP_PVAPI_FSTRIGMODE_FIXEDRATE

FixedRate.

CAP_PVAPI_FSTRIGMODE_SOFTWARE

Software.

CAP_PVAPI_DECIMATION_OFF

Off.

CAP_PVAPI_DECIMATION_2OUTOF4

2 out of 4 decimation

CAP_PVAPI_DECIMATION_2OUTOF8

2 out of 8 decimation

CAP_PVAPI_DECIMATION_2OUTOF16

2 out of 16 decimation

CAP_PVAPI_PIXELFORMAT_MONO8

Mono8.

CAP_PVAPI_PIXELFORMAT_MONO16

Mono16.

CAP_PVAPI_PIXELFORMAT_BAYER8

Bayer8.

CAP_PVAPI_PIXELFORMAT_BAYER16

Bayer16.

CAP_PVAPI_PIXELFORMAT_RGB24

Rgb24.

CAP_PVAPI_PIXELFORMAT_BGR24

Bgr24.

CAP_PVAPI_PIXELFORMAT_RGBA32

Rgba32.

CAP_PVAPI_PIXELFORMAT_BGRA32

Bgra32.

CAP_PROP_XI_DOWNSAMPLING

Change image resolution by binning or skipping.

CAP_PROP_XI_DATA_FORMAT

Output data format.

CAP_PROP_XI_OFFSET_X

Horizontal offset from the origin to the area of interest (in pixels).

CAP_PROP_XI_OFFSET_Y

Vertical offset from the origin to the area of interest (in pixels).

CAP_PROP_XI_TRG_SOURCE

Defines source of trigger.

CAP_PROP_XI_TRG_SOFTWARE

Generates an internal trigger. PRM_TRG_SOURCE must be set to TRG_SOFTWARE.

CAP_PROP_XI_GPI_SELECTOR

Selects general purpose input.

CAP_PROP_XI_GPI_MODE

Set general purpose input mode.

CAP_PROP_XI_GPI_LEVEL

Get general purpose level.

CAP_PROP_XI_GPO_SELECTOR

Selects general purpose output.

CAP_PROP_XI_GPO_MODE

Set general purpose output mode.

CAP_PROP_XI_LED_SELECTOR

Selects camera signalling LED.

CAP_PROP_XI_LED_MODE

Define camera signalling LED functionality.

CAP_PROP_XI_MANUAL_WB

Calculates White Balance(must be called during acquisition).

CAP_PROP_XI_AUTO_WB

Automatic white balance.

CAP_PROP_XI_AEAG

Automatic exposure/gain.

CAP_PROP_XI_EXP_PRIORITY

Exposure priority (0.5 - exposure 50%, gain 50%).

CAP_PROP_XI_AE_MAX_LIMIT

Maximum limit of exposure in AEAG procedure.

CAP_PROP_XI_AG_MAX_LIMIT

Maximum limit of gain in AEAG procedure.

CAP_PROP_XI_AEAG_LEVEL

Average intensity of output signal AEAG should achieve(in %).

CAP_PROP_XI_TIMEOUT

Image capture timeout in milliseconds.

CAP_PROP_XI_EXPOSURE

Exposure time in microseconds.

CAP_PROP_XI_EXPOSURE_BURST_COUNT

Sets the number of times of exposure in one frame.

CAP_PROP_XI_GAIN_SELECTOR

Gain selector for parameter Gain allows to select different type of gains.

CAP_PROP_XI_GAIN

Gain in dB.

CAP_PROP_XI_DOWNSAMPLING_TYPE

Change image downsampling type.

CAP_PROP_XI_BINNING_SELECTOR

Binning engine selector.

CAP_PROP_XI_BINNING_VERTICAL

Vertical Binning - number of vertical photo-sensitive cells to combine together.

CAP_PROP_XI_BINNING_HORIZONTAL

Horizontal Binning - number of horizontal photo-sensitive cells to combine together.

CAP_PROP_XI_BINNING_PATTERN

Binning pattern type.

CAP_PROP_XI_DECIMATION_SELECTOR

Decimation engine selector.

CAP_PROP_XI_DECIMATION_VERTICAL

Vertical Decimation - vertical sub-sampling of the image - reduces the vertical resolution of the image by the specified vertical decimation factor.

CAP_PROP_XI_DECIMATION_HORIZONTAL

Horizontal Decimation - horizontal sub-sampling of the image - reduces the horizontal resolution of the image by the specified vertical decimation factor.

CAP_PROP_XI_DECIMATION_PATTERN

Decimation pattern type.

CAP_PROP_XI_TEST_PATTERN_GENERATOR_SELECTOR

Selects which test pattern generator is controlled by the TestPattern feature.

CAP_PROP_XI_TEST_PATTERN

Selects which test pattern type is generated by the selected generator.

CAP_PROP_XI_IMAGE_DATA_FORMAT

Output data format.

CAP_PROP_XI_SHUTTER_TYPE

Change sensor shutter type(CMOS sensor).

CAP_PROP_XI_SENSOR_TAPS

Number of taps.

CAP_PROP_XI_AEAG_ROI_OFFSET_X

Automatic exposure/gain ROI offset X.

CAP_PROP_XI_AEAG_ROI_OFFSET_Y

Automatic exposure/gain ROI offset Y.

CAP_PROP_XI_AEAG_ROI_WIDTH

Automatic exposure/gain ROI Width.

CAP_PROP_XI_AEAG_ROI_HEIGHT

Automatic exposure/gain ROI Height.

CAP_PROP_XI_BPC

Correction of bad pixels.

CAP_PROP_XI_WB_KR

White balance red coefficient.

CAP_PROP_XI_WB_KG

White balance green coefficient.

CAP_PROP_XI_WB_KB

White balance blue coefficient.

CAP_PROP_XI_WIDTH

Width of the Image provided by the device (in pixels).

CAP_PROP_XI_HEIGHT

Height of the Image provided by the device (in pixels).

CAP_PROP_XI_REGION_SELECTOR

Selects Region in Multiple ROI which parameters are set by width, height, … ,region mode.

CAP_PROP_XI_REGION_MODE

Activates/deactivates Region selected by Region Selector.

CAP_PROP_XI_LIMIT_BANDWIDTH

Set/get bandwidth(datarate)(in Megabits).

CAP_PROP_XI_SENSOR_DATA_BIT_DEPTH

Sensor output data bit depth.

CAP_PROP_XI_OUTPUT_DATA_BIT_DEPTH

Device output data bit depth.

CAP_PROP_XI_IMAGE_DATA_BIT_DEPTH

bitdepth of data returned by function xiGetImage.

CAP_PROP_XI_OUTPUT_DATA_PACKING

Device output data packing (or grouping) enabled. Packing could be enabled if output_data_bit_depth > 8 and packing capability is available.

CAP_PROP_XI_OUTPUT_DATA_PACKING_TYPE

Data packing type. Some cameras supports only specific packing type.

CAP_PROP_XI_IS_COOLED

Returns 1 for cameras that support cooling.

CAP_PROP_XI_COOLING

Start camera cooling.

CAP_PROP_XI_TARGET_TEMP

Set sensor target temperature for cooling.

CAP_PROP_XI_CHIP_TEMP

Camera sensor temperature.

CAP_PROP_XI_HOUS_TEMP

Camera housing temperature.

CAP_PROP_XI_HOUS_BACK_SIDE_TEMP

Camera housing back side temperature.

CAP_PROP_XI_SENSOR_BOARD_TEMP

Camera sensor board temperature.

CAP_PROP_XI_CMS

Mode of color management system.

CAP_PROP_XI_APPLY_CMS

Enable applying of CMS profiles to xiGetImage (see XI_PRM_INPUT_CMS_PROFILE, XI_PRM_OUTPUT_CMS_PROFILE).

CAP_PROP_XI_IMAGE_IS_COLOR

Returns 1 for color cameras.

CAP_PROP_XI_COLOR_FILTER_ARRAY

Returns color filter array type of RAW data.

CAP_PROP_XI_GAMMAY

Luminosity gamma.

CAP_PROP_XI_GAMMAC

Chromaticity gamma.

CAP_PROP_XI_SHARPNESS

Sharpness Strength.

CAP_PROP_XI_CC_MATRIX_00

Color Correction Matrix element [0][0].

CAP_PROP_XI_CC_MATRIX_01

Color Correction Matrix element [0][1].

CAP_PROP_XI_CC_MATRIX_02

Color Correction Matrix element [0][2].

CAP_PROP_XI_CC_MATRIX_03

Color Correction Matrix element [0][3].

CAP_PROP_XI_CC_MATRIX_10

Color Correction Matrix element [1][0].

CAP_PROP_XI_CC_MATRIX_11

Color Correction Matrix element [1][1].

CAP_PROP_XI_CC_MATRIX_12

Color Correction Matrix element [1][2].

CAP_PROP_XI_CC_MATRIX_13

Color Correction Matrix element [1][3].

CAP_PROP_XI_CC_MATRIX_20

Color Correction Matrix element [2][0].

CAP_PROP_XI_CC_MATRIX_21

Color Correction Matrix element [2][1].

CAP_PROP_XI_CC_MATRIX_22

Color Correction Matrix element [2][2].

CAP_PROP_XI_CC_MATRIX_23

Color Correction Matrix element [2][3].

CAP_PROP_XI_CC_MATRIX_30

Color Correction Matrix element [3][0].

CAP_PROP_XI_CC_MATRIX_31

Color Correction Matrix element [3][1].

CAP_PROP_XI_CC_MATRIX_32

Color Correction Matrix element [3][2].

CAP_PROP_XI_CC_MATRIX_33

Color Correction Matrix element [3][3].

CAP_PROP_XI_DEFAULT_CC_MATRIX

Set default Color Correction Matrix.

CAP_PROP_XI_TRG_SELECTOR

Selects the type of trigger.

CAP_PROP_XI_ACQ_FRAME_BURST_COUNT

Sets number of frames acquired by burst. This burst is used only if trigger is set to FrameBurstStart.

CAP_PROP_XI_DEBOUNCE_EN

Enable/Disable debounce to selected GPI.

CAP_PROP_XI_DEBOUNCE_T0

Debounce time (x * 10us).

CAP_PROP_XI_DEBOUNCE_T1

Debounce time (x * 10us).

CAP_PROP_XI_DEBOUNCE_POL

Debounce polarity (pol = 1 t0 - falling edge, t1 - rising edge).

CAP_PROP_XI_LENS_MODE

Status of lens control interface. This shall be set to XI_ON before any Lens operations.

CAP_PROP_XI_LENS_APERTURE_VALUE

Current lens aperture value in stops. Examples: 2.8, 4, 5.6, 8, 11.

CAP_PROP_XI_LENS_FOCUS_MOVEMENT_VALUE

Lens current focus movement value to be used by XI_PRM_LENS_FOCUS_MOVE in motor steps.

CAP_PROP_XI_LENS_FOCUS_MOVE

Moves lens focus motor by steps set in XI_PRM_LENS_FOCUS_MOVEMENT_VALUE.

CAP_PROP_XI_LENS_FOCUS_DISTANCE

Lens focus distance in cm.

CAP_PROP_XI_LENS_FOCAL_LENGTH

Lens focal distance in mm.

CAP_PROP_XI_LENS_FEATURE_SELECTOR

Selects the current feature which is accessible by XI_PRM_LENS_FEATURE.

CAP_PROP_XI_LENS_FEATURE

Allows access to lens feature value currently selected by XI_PRM_LENS_FEATURE_SELECTOR.

CAP_PROP_XI_DEVICE_MODEL_ID

Returns device model id.

CAP_PROP_XI_DEVICE_SN

Returns device serial number.

CAP_PROP_XI_IMAGE_DATA_FORMAT_RGB32_ALPHA

The alpha channel of RGB32 output image format.

CAP_PROP_XI_IMAGE_PAYLOAD_SIZE

Buffer size in bytes sufficient for output image returned by xiGetImage.

CAP_PROP_XI_TRANSPORT_PIXEL_FORMAT

Current format of pixels on transport layer.

CAP_PROP_XI_SENSOR_CLOCK_FREQ_HZ

Sensor clock frequency in Hz.

CAP_PROP_XI_SENSOR_CLOCK_FREQ_INDEX

Sensor clock frequency index. Sensor with selected frequencies have possibility to set the frequency only by this index.

CAP_PROP_XI_SENSOR_OUTPUT_CHANNEL_COUNT

Number of output channels from sensor used for data transfer.

CAP_PROP_XI_FRAMERATE

Define framerate in Hz.

CAP_PROP_XI_COUNTER_SELECTOR

Select counter.

CAP_PROP_XI_COUNTER_VALUE

Counter status.

CAP_PROP_XI_ACQ_TIMING_MODE

Type of sensor frames timing.

CAP_PROP_XI_AVAILABLE_BANDWIDTH

Calculate and returns available interface bandwidth(int Megabits).

CAP_PROP_XI_BUFFER_POLICY

Data move policy.

CAP_PROP_XI_LUT_EN

Activates LUT.

CAP_PROP_XI_LUT_INDEX

Control the index (offset) of the coefficient to access in the LUT.

CAP_PROP_XI_LUT_VALUE

Value at entry LUTIndex of the LUT.

CAP_PROP_XI_TRG_DELAY

Specifies the delay in microseconds (us) to apply after the trigger reception before activating it.

CAP_PROP_XI_TS_RST_MODE

Defines how time stamp reset engine will be armed.

CAP_PROP_XI_TS_RST_SOURCE

Defines which source will be used for timestamp reset. Writing this parameter will trigger settings of engine (arming).

CAP_PROP_XI_IS_DEVICE_EXIST

Returns 1 if camera connected and works properly.

CAP_PROP_XI_ACQ_BUFFER_SIZE

Acquisition buffer size in buffer_size_unit. Default bytes.

CAP_PROP_XI_ACQ_BUFFER_SIZE_UNIT

Acquisition buffer size unit in bytes. Default 1. E.g. Value 1024 means that buffer_size is in KiBytes.

CAP_PROP_XI_ACQ_TRANSPORT_BUFFER_SIZE

Acquisition transport buffer size in bytes.

CAP_PROP_XI_BUFFERS_QUEUE_SIZE

Queue of field/frame buffers.

CAP_PROP_XI_ACQ_TRANSPORT_BUFFER_COMMIT

Number of buffers to commit to low level.

CAP_PROP_XI_RECENT_FRAME

GetImage returns most recent frame.

CAP_PROP_XI_DEVICE_RESET

Resets the camera to default state.

CAP_PROP_XI_COLUMN_FPN_CORRECTION

Correction of column FPN.

CAP_PROP_XI_ROW_FPN_CORRECTION

Correction of row FPN.

CAP_PROP_XI_SENSOR_MODE

Current sensor mode. Allows to select sensor mode by one integer. Setting of this parameter affects: image dimensions and downsampling.

CAP_PROP_XI_HDR

Enable High Dynamic Range feature.

CAP_PROP_XI_HDR_KNEEPOINT_COUNT

The number of kneepoints in the PWLR.

CAP_PROP_XI_HDR_T1

Position of first kneepoint(in % of XI_PRM_EXPOSURE).

CAP_PROP_XI_HDR_T2

Position of second kneepoint (in % of XI_PRM_EXPOSURE).

CAP_PROP_XI_KNEEPOINT1

Value of first kneepoint (% of sensor saturation).

CAP_PROP_XI_KNEEPOINT2

Value of second kneepoint (% of sensor saturation).

CAP_PROP_XI_IMAGE_BLACK_LEVEL

Last image black level counts. Can be used for Offline processing to recall it.

CAP_PROP_XI_HW_REVISION

Returns hardware revision number.

CAP_PROP_XI_DEBUG_LEVEL

Set debug level.

CAP_PROP_XI_AUTO_BANDWIDTH_CALCULATION

Automatic bandwidth calculation.

CAP_PROP_XI_FFS_FILE_ID

File number.

CAP_PROP_XI_FFS_FILE_SIZE

Size of file.

CAP_PROP_XI_FREE_FFS_SIZE

Size of free camera FFS.

CAP_PROP_XI_USED_FFS_SIZE

Size of used camera FFS.

CAP_PROP_XI_FFS_ACCESS_KEY

Setting of key enables file operations on some cameras.

CAP_PROP_XI_SENSOR_FEATURE_SELECTOR

Selects the current feature which is accessible by XI_PRM_SENSOR_FEATURE_VALUE.

CAP_PROP_XI_SENSOR_FEATURE_VALUE

Allows access to sensor feature value currently selected by XI_PRM_SENSOR_FEATURE_SELECTOR.

CAP_INTELPERC_DEPTH_MAP

Each pixel is a 16-bit integer. The value indicates the distance from an object to the camera’s XY plane or the Cartesian depth.

CAP_INTELPERC_UVDEPTH_MAP

Each pixel contains two 32-bit floating point values in the range of 0-1, representing the mapping of depth coordinates to the color coordinates.

CAP_INTELPERC_IR_MAP

Each pixel is a 16-bit integer. The value indicates the intensity of the reflected laser beam.

CAP_PROP_GPHOTO2_PREVIEW

Capture only preview from liveview mode.

CAP_PROP_GPHOTO2_WIDGET_ENUMERATE

Readonly, returns (const char *).

CAP_PROP_GPHOTO2_RELOAD_CONFIG

Trigger, only by set. Reload camera settings.

CAP_PROP_GPHOTO2_RELOAD_ON_CHANGE

Reload all settings on set.

CAP_PROP_GPHOTO2_COLLECT_MSGS

Collect messages with details.

CAP_PROP_GPHOTO2_FLUSH_MSGS

Readonly, returns (const char *).

CAP_PROP_SPEED

Exposure speed. Can be readonly, depends on camera program.

CAP_PROP_APERTURE

Aperture. Can be readonly, depends on camera program.

CAP_PROP_EXPOSUREPROGRAM

Camera exposure program.

CAP_PROP_VIEWFINDER

Enter liveview mode.

LMEDS

least-median algorithm

RANSAC

RANSAC algorithm.

RHO

RHO algorithm.

SOLVEPNP_EPNP

EPnP: Efficient Perspective-n-Point Camera Pose Estimation [45].

SOLVEPNP_P3P

Complete Solution Classification for the Perspective-Three-Point Problem [30].

SOLVEPNP_DLS

A Direct Least-Squares (DLS) Method for PnP [38].

SOLVEPNP_UPNP

Exhaustive Linearization for Robust Camera Pose and Focal Length Estimation [65].

SOLVEPNP_AP3P

An Efficient Algebraic Solution to the Perspective-Three-Point Problem [42].

CALIB_USE_QR

use QR instead of SVD decomposition for solving. Faster but potentially less precise

CALIB_USE_LU

use LU instead of SVD decomposition for solving. much faster but potentially less precise

FM_7POINT

7-point algorithm

FM_8POINT

8-point algorithm

FM_LMEDS

least-median algorithm

FM_RANSAC

RANSAC algorithm.

Global Functions

bool
haveOpenVX()

Check if use of OpenVX is possible.

void
setUseOpenVX(bool flag)

Enable/disable use of OpenVX.

bool
useOpenVX()

Check if use of OpenVX is enabled.