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,