Global Namespace

Overview

// namespaces

namespace Controls;
namespace NcvCTprep;
namespace cv;
    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;
namespace cvflann;
    namespace cvflann::anyimpl;
    namespace cvflann::lsh;
namespace std;

// typedefs

typedef struct CvPOSITObject CvPOSITObject;

typedef void(CV_STDCALL* Cv_iplAllocateImageData)(
    IplImage *,
    int,
    int
    );

typedef IplImage*(CV_STDCALL* Cv_iplCloneImage)(const IplImage *);

typedef IplImage*(CV_STDCALL* Cv_iplCreateImageHeader)(
    int,
    int,
    int,
    char *,
    char *,
    int,
    int,
    int,
    int,
    int,
    IplROI *,
    IplImage *,
    void *,
    IplTileInfo *
    );

typedef IplROI*(CV_STDCALL* Cv_iplCreateROI)(
    int,
    int,
    int,
    int,
    int
    );

typedef void(CV_STDCALL* Cv_iplDeallocate)(
    IplImage *,
    int
    );

typedef int (*CvCmpFunc)(
    const void *a,
    const void *b,
    void *userdata
    );

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

typedef uint32_t uint;
typedef signed char schar;
typedef unsigned char uchar;
typedef unsigned short ushort;
typedef int64_t int64;
typedef uint64_t uint64;
typedef struct CvFileStorage CvFileStorage;
typedef void CvArr;
typedef void* (*CvCloneFunc)(const void *struct_ptr);
typedef struct CvGenericHash CvFileNodeHash;
typedef int CvHistType;
typedef int (*CvIsInstanceFunc)(const void *struct_ptr);
typedef CvContour CvPoint2DSeq;

typedef void* (*CvReadFunc)(
    CvFileStorage *storage,
    CvFileNode *node
    );

typedef void (*CvReleaseFunc)(void **struct_dblptr);
typedef uint64 CvRNG;
typedef int CVStatus;

typedef void (*CvWriteFunc)(
    CvFileStorage *storage,
    const char *name,
    const void *struct_ptr,
    CvAttrList attributes
    );

typedef struct _IplTileInfo IplTileInfo;
typedef struct _CvContourScanner* CvContourScanner;

typedef float (*CvDistanceFunction)(
    const float *a,
    const float *b,
    void *user_param
    );

typedef void* VADisplay;
typedef unsigned int VASurfaceID;
typedef short Ncv16s;
typedef unsigned short Ncv16u;
typedef float Ncv32f;
typedef int Ncv32s;
typedef unsigned int Ncv32u;
typedef double Ncv64f;
typedef long long Ncv64s;
typedef unsigned long long Ncv64u;
typedef signed char Ncv8s;
typedef unsigned char Ncv8u;
typedef bool NcvBool;
typedef void NCVDebugOutputHandler(const cv::String &msg);
typedef Ncv32u NCVStatus;
typedef struct _NcvTimer* NcvTimer;
typedef Ncv32f Ncv32f_a;
typedef Ncv32u Ncv32u_a;

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

typedef void (*CvMouseCallback)(
    int event,
    int x,
    int y,
    int flags,
    void *param
    );

typedef void (*CvOpenGlDrawCallback)(void *userdata);
typedef void (*CvTrackbarCallback)(int pos);

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

typedef struct CvHidHaarClassifierCascade CvHidHaarClassifierCascade;
typedef struct CvCapture CvCapture;
typedef struct CvVideoWriter CvVideoWriter;
typedef struct CvCapture CvCapture;
typedef struct CvVideoWriter CvVideoWriter;

// enums

enum
{
    CV_LOAD_IMAGE_UNCHANGED          =-1,
    CV_LOAD_IMAGE_GRAYSCALE          =0,
    CV_LOAD_IMAGE_COLOR              =1,
    CV_LOAD_IMAGE_ANYDEPTH           =2,
    CV_LOAD_IMAGE_ANYCOLOR           =4,
    CV_LOAD_IMAGE_IGNORE_ORIENTATION =128,
};

enum
{
    CV_IMWRITE_JPEG_QUALITY               =1,
    CV_IMWRITE_JPEG_PROGRESSIVE           =2,
    CV_IMWRITE_JPEG_OPTIMIZE              =3,
    CV_IMWRITE_JPEG_RST_INTERVAL          =4,
    CV_IMWRITE_JPEG_LUMA_QUALITY          =5,
    CV_IMWRITE_JPEG_CHROMA_QUALITY        =6,
    CV_IMWRITE_PNG_COMPRESSION            =16,
    CV_IMWRITE_PNG_STRATEGY               =17,
    CV_IMWRITE_PNG_BILEVEL                =18,
    CV_IMWRITE_PNG_STRATEGY_DEFAULT       =0,
    CV_IMWRITE_PNG_STRATEGY_FILTERED      =1,
    CV_IMWRITE_PNG_STRATEGY_HUFFMAN_ONLY  =2,
    CV_IMWRITE_PNG_STRATEGY_RLE           =3,
    CV_IMWRITE_PNG_STRATEGY_FIXED         =4,
    CV_IMWRITE_PXM_BINARY                 =32,
    CV_IMWRITE_WEBP_QUALITY               =64,
    CV_IMWRITE_PAM_TUPLETYPE              = 128,
    CV_IMWRITE_PAM_FORMAT_NULL            = 0,
    CV_IMWRITE_PAM_FORMAT_BLACKANDWHITE   = 1,
    CV_IMWRITE_PAM_FORMAT_GRAYSCALE       = 2,
    CV_IMWRITE_PAM_FORMAT_GRAYSCALE_ALPHA = 3,
    CV_IMWRITE_PAM_FORMAT_RGB             = 4,
    CV_IMWRITE_PAM_FORMAT_RGB_ALPHA       = 5,
};

enum
{
    CV_CVTIMG_FLIP    =1,
    CV_CVTIMG_SWAP_RB =2,
};

enum
{
    CV_CAP_ANY           =0,
    CV_CAP_MIL           =100,
    CV_CAP_VFW           =200,
    CV_CAP_V4L           =200,
    CV_CAP_V4L2          =200,
    CV_CAP_FIREWARE      =300,
    CV_CAP_FIREWIRE      =300,
    CV_CAP_IEEE1394      =300,
    CV_CAP_DC1394        =300,
    CV_CAP_CMU1394       =300,
    CV_CAP_STEREO        =400,
    CV_CAP_TYZX          =400,
    CV_TYZX_LEFT         =400,
    CV_TYZX_RIGHT        =401,
    CV_TYZX_COLOR        =402,
    CV_TYZX_Z            =403,
    CV_CAP_QT            =500,
    CV_CAP_UNICAP        =600,
    CV_CAP_DSHOW         =700,
    CV_CAP_MSMF          =1400,
    CV_CAP_PVAPI         =800,
    CV_CAP_OPENNI        =900,
    CV_CAP_OPENNI_ASUS   =910,
    CV_CAP_ANDROID       =1000,
    CV_CAP_ANDROID_BACK  =CV_CAP_ANDROID+99,
    CV_CAP_ANDROID_FRONT =CV_CAP_ANDROID+98,
    CV_CAP_XIAPI         =1100,
    CV_CAP_AVFOUNDATION  = 1200,
    CV_CAP_GIGANETIX     = 1300,
    CV_CAP_INTELPERC     = 1500,
    CV_CAP_OPENNI2       = 1600,
    CV_CAP_GPHOTO2       = 1700,
    CV_CAP_GSTREAMER     = 1800,
    CV_CAP_FFMPEG        = 1900,
    CV_CAP_IMAGES        = 2000,
    CV_CAP_ARAVIS        = 2100,
    CV_CAP_OCV_MJPEG     = 2200,
};

enum
{
    CV_CAP_PROP_DC1394_OFF                           = -4,
    CV_CAP_PROP_DC1394_MODE_MANUAL                   = -3,
    CV_CAP_PROP_DC1394_MODE_AUTO                     = -2,
    CV_CAP_PROP_DC1394_MODE_ONE_PUSH_AUTO            = -1,
    CV_CAP_PROP_POS_MSEC                             =0,
    CV_CAP_PROP_POS_FRAMES                           =1,
    CV_CAP_PROP_POS_AVI_RATIO                        =2,
    CV_CAP_PROP_FRAME_WIDTH                          =3,
    CV_CAP_PROP_FRAME_HEIGHT                         =4,
    CV_CAP_PROP_FPS                                  =5,
    CV_CAP_PROP_FOURCC                               =6,
    CV_CAP_PROP_FRAME_COUNT                          =7,
    CV_CAP_PROP_FORMAT                               =8,
    CV_CAP_PROP_MODE                                 =9,
    CV_CAP_PROP_BRIGHTNESS                           =10,
    CV_CAP_PROP_CONTRAST                             =11,
    CV_CAP_PROP_SATURATION                           =12,
    CV_CAP_PROP_HUE                                  =13,
    CV_CAP_PROP_GAIN                                 =14,
    CV_CAP_PROP_EXPOSURE                             =15,
    CV_CAP_PROP_CONVERT_RGB                          =16,
    CV_CAP_PROP_WHITE_BALANCE_BLUE_U                 =17,
    CV_CAP_PROP_RECTIFICATION                        =18,
    CV_CAP_PROP_MONOCHROME                           =19,
    CV_CAP_PROP_SHARPNESS                            =20,
    CV_CAP_PROP_AUTO_EXPOSURE                        =21,
    CV_CAP_PROP_GAMMA                                =22,
    CV_CAP_PROP_TEMPERATURE                          =23,
    CV_CAP_PROP_TRIGGER                              =24,
    CV_CAP_PROP_TRIGGER_DELAY                        =25,
    CV_CAP_PROP_WHITE_BALANCE_RED_V                  =26,
    CV_CAP_PROP_ZOOM                                 =27,
    CV_CAP_PROP_FOCUS                                =28,
    CV_CAP_PROP_GUID                                 =29,
    CV_CAP_PROP_ISO_SPEED                            =30,
    CV_CAP_PROP_MAX_DC1394                           =31,
    CV_CAP_PROP_BACKLIGHT                            =32,
    CV_CAP_PROP_PAN                                  =33,
    CV_CAP_PROP_TILT                                 =34,
    CV_CAP_PROP_ROLL                                 =35,
    CV_CAP_PROP_IRIS                                 =36,
    CV_CAP_PROP_SETTINGS                             =37,
    CV_CAP_PROP_BUFFERSIZE                           =38,
    CV_CAP_PROP_AUTOFOCUS                            =39,
    CV_CAP_PROP_SAR_NUM                              =40,
    CV_CAP_PROP_SAR_DEN                              =41,
    CV_CAP_PROP_AUTOGRAB                             =1024,
    CV_CAP_PROP_SUPPORTED_PREVIEW_SIZES_STRING       =1025,
    CV_CAP_PROP_PREVIEW_FORMAT                       =1026,
    CV_CAP_OPENNI_DEPTH_GENERATOR                    = 1 <<31,
    CV_CAP_OPENNI_IMAGE_GENERATOR                    = 1 <<30,
    CV_CAP_OPENNI_IR_GENERATOR                       = 1 <<29,
    CV_CAP_OPENNI_GENERATORS_MASK                    = CV_CAP_OPENNI_DEPTH_GENERATOR + CV_CAP_OPENNI_IMAGE_GENERATOR + CV_CAP_OPENNI_IR_GENERATOR,
    CV_CAP_PROP_OPENNI_OUTPUT_MODE                   = 100,
    CV_CAP_PROP_OPENNI_FRAME_MAX_DEPTH               = 101,
    CV_CAP_PROP_OPENNI_BASELINE                      = 102,
    CV_CAP_PROP_OPENNI_FOCAL_LENGTH                  = 103,
    CV_CAP_PROP_OPENNI_REGISTRATION                  = 104,
    CV_CAP_PROP_OPENNI_REGISTRATION_ON               = CV_CAP_PROP_OPENNI_REGISTRATION,
    CV_CAP_PROP_OPENNI_APPROX_FRAME_SYNC             = 105,
    CV_CAP_PROP_OPENNI_MAX_BUFFER_SIZE               = 106,
    CV_CAP_PROP_OPENNI_CIRCLE_BUFFER                 = 107,
    CV_CAP_PROP_OPENNI_MAX_TIME_DURATION             = 108,
    CV_CAP_PROP_OPENNI_GENERATOR_PRESENT             = 109,
    CV_CAP_PROP_OPENNI2_SYNC                         = 110,
    CV_CAP_PROP_OPENNI2_MIRROR                       = 111,
    CV_CAP_OPENNI_IMAGE_GENERATOR_PRESENT            = CV_CAP_OPENNI_IMAGE_GENERATOR + CV_CAP_PROP_OPENNI_GENERATOR_PRESENT,
    CV_CAP_OPENNI_IMAGE_GENERATOR_OUTPUT_MODE        = CV_CAP_OPENNI_IMAGE_GENERATOR + CV_CAP_PROP_OPENNI_OUTPUT_MODE,
    CV_CAP_OPENNI_DEPTH_GENERATOR_PRESENT            = CV_CAP_OPENNI_DEPTH_GENERATOR + CV_CAP_PROP_OPENNI_GENERATOR_PRESENT,
    CV_CAP_OPENNI_DEPTH_GENERATOR_BASELINE           = CV_CAP_OPENNI_DEPTH_GENERATOR + CV_CAP_PROP_OPENNI_BASELINE,
    CV_CAP_OPENNI_DEPTH_GENERATOR_FOCAL_LENGTH       = CV_CAP_OPENNI_DEPTH_GENERATOR + CV_CAP_PROP_OPENNI_FOCAL_LENGTH,
    CV_CAP_OPENNI_DEPTH_GENERATOR_REGISTRATION       = CV_CAP_OPENNI_DEPTH_GENERATOR + CV_CAP_PROP_OPENNI_REGISTRATION,
    CV_CAP_OPENNI_DEPTH_GENERATOR_REGISTRATION_ON    = CV_CAP_OPENNI_DEPTH_GENERATOR_REGISTRATION,
    CV_CAP_OPENNI_IR_GENERATOR_PRESENT               = CV_CAP_OPENNI_IR_GENERATOR + CV_CAP_PROP_OPENNI_GENERATOR_PRESENT,
    CV_CAP_GSTREAMER_QUEUE_LENGTH                    = 200,
    CV_CAP_PROP_PVAPI_MULTICASTIP                    = 300,
    CV_CAP_PROP_PVAPI_FRAMESTARTTRIGGERMODE          = 301,
    CV_CAP_PROP_PVAPI_DECIMATIONHORIZONTAL           = 302,
    CV_CAP_PROP_PVAPI_DECIMATIONVERTICAL             = 303,
    CV_CAP_PROP_PVAPI_BINNINGX                       = 304,
    CV_CAP_PROP_PVAPI_BINNINGY                       = 305,
    CV_CAP_PROP_PVAPI_PIXELFORMAT                    = 306,
    CV_CAP_PROP_XI_DOWNSAMPLING                      = 400,
    CV_CAP_PROP_XI_DATA_FORMAT                       = 401,
    CV_CAP_PROP_XI_OFFSET_X                          = 402,
    CV_CAP_PROP_XI_OFFSET_Y                          = 403,
    CV_CAP_PROP_XI_TRG_SOURCE                        = 404,
    CV_CAP_PROP_XI_TRG_SOFTWARE                      = 405,
    CV_CAP_PROP_XI_GPI_SELECTOR                      = 406,
    CV_CAP_PROP_XI_GPI_MODE                          = 407,
    CV_CAP_PROP_XI_GPI_LEVEL                         = 408,
    CV_CAP_PROP_XI_GPO_SELECTOR                      = 409,
    CV_CAP_PROP_XI_GPO_MODE                          = 410,
    CV_CAP_PROP_XI_LED_SELECTOR                      = 411,
    CV_CAP_PROP_XI_LED_MODE                          = 412,
    CV_CAP_PROP_XI_MANUAL_WB                         = 413,
    CV_CAP_PROP_XI_AUTO_WB                           = 414,
    CV_CAP_PROP_XI_AEAG                              = 415,
    CV_CAP_PROP_XI_EXP_PRIORITY                      = 416,
    CV_CAP_PROP_XI_AE_MAX_LIMIT                      = 417,
    CV_CAP_PROP_XI_AG_MAX_LIMIT                      = 418,
    CV_CAP_PROP_XI_AEAG_LEVEL                        = 419,
    CV_CAP_PROP_XI_TIMEOUT                           = 420,
    CV_CAP_PROP_XI_EXPOSURE                          = 421,
    CV_CAP_PROP_XI_EXPOSURE_BURST_COUNT              = 422,
    CV_CAP_PROP_XI_GAIN_SELECTOR                     = 423,
    CV_CAP_PROP_XI_GAIN                              = 424,
    CV_CAP_PROP_XI_DOWNSAMPLING_TYPE                 = 426,
    CV_CAP_PROP_XI_BINNING_SELECTOR                  = 427,
    CV_CAP_PROP_XI_BINNING_VERTICAL                  = 428,
    CV_CAP_PROP_XI_BINNING_HORIZONTAL                = 429,
    CV_CAP_PROP_XI_BINNING_PATTERN                   = 430,
    CV_CAP_PROP_XI_DECIMATION_SELECTOR               = 431,
    CV_CAP_PROP_XI_DECIMATION_VERTICAL               = 432,
    CV_CAP_PROP_XI_DECIMATION_HORIZONTAL             = 433,
    CV_CAP_PROP_XI_DECIMATION_PATTERN                = 434,
    CV_CAP_PROP_XI_TEST_PATTERN_GENERATOR_SELECTOR   = 587,
    CV_CAP_PROP_XI_TEST_PATTERN                      = 588,
    CV_CAP_PROP_XI_IMAGE_DATA_FORMAT                 = 435,
    CV_CAP_PROP_XI_SHUTTER_TYPE                      = 436,
    CV_CAP_PROP_XI_SENSOR_TAPS                       = 437,
    CV_CAP_PROP_XI_AEAG_ROI_OFFSET_X                 = 439,
    CV_CAP_PROP_XI_AEAG_ROI_OFFSET_Y                 = 440,
    CV_CAP_PROP_XI_AEAG_ROI_WIDTH                    = 441,
    CV_CAP_PROP_XI_AEAG_ROI_HEIGHT                   = 442,
    CV_CAP_PROP_XI_BPC                               = 445,
    CV_CAP_PROP_XI_WB_KR                             = 448,
    CV_CAP_PROP_XI_WB_KG                             = 449,
    CV_CAP_PROP_XI_WB_KB                             = 450,
    CV_CAP_PROP_XI_WIDTH                             = 451,
    CV_CAP_PROP_XI_HEIGHT                            = 452,
    CV_CAP_PROP_XI_REGION_SELECTOR                   = 589,
    CV_CAP_PROP_XI_REGION_MODE                       = 595,
    CV_CAP_PROP_XI_LIMIT_BANDWIDTH                   = 459,
    CV_CAP_PROP_XI_SENSOR_DATA_BIT_DEPTH             = 460,
    CV_CAP_PROP_XI_OUTPUT_DATA_BIT_DEPTH             = 461,
    CV_CAP_PROP_XI_IMAGE_DATA_BIT_DEPTH              = 462,
    CV_CAP_PROP_XI_OUTPUT_DATA_PACKING               = 463,
    CV_CAP_PROP_XI_OUTPUT_DATA_PACKING_TYPE          = 464,
    CV_CAP_PROP_XI_IS_COOLED                         = 465,
    CV_CAP_PROP_XI_COOLING                           = 466,
    CV_CAP_PROP_XI_TARGET_TEMP                       = 467,
    CV_CAP_PROP_XI_CHIP_TEMP                         = 468,
    CV_CAP_PROP_XI_HOUS_TEMP                         = 469,
    CV_CAP_PROP_XI_HOUS_BACK_SIDE_TEMP               = 590,
    CV_CAP_PROP_XI_SENSOR_BOARD_TEMP                 = 596,
    CV_CAP_PROP_XI_CMS                               = 470,
    CV_CAP_PROP_XI_APPLY_CMS                         = 471,
    CV_CAP_PROP_XI_IMAGE_IS_COLOR                    = 474,
    CV_CAP_PROP_XI_COLOR_FILTER_ARRAY                = 475,
    CV_CAP_PROP_XI_GAMMAY                            = 476,
    CV_CAP_PROP_XI_GAMMAC                            = 477,
    CV_CAP_PROP_XI_SHARPNESS                         = 478,
    CV_CAP_PROP_XI_CC_MATRIX_00                      = 479,
    CV_CAP_PROP_XI_CC_MATRIX_01                      = 480,
    CV_CAP_PROP_XI_CC_MATRIX_02                      = 481,
    CV_CAP_PROP_XI_CC_MATRIX_03                      = 482,
    CV_CAP_PROP_XI_CC_MATRIX_10                      = 483,
    CV_CAP_PROP_XI_CC_MATRIX_11                      = 484,
    CV_CAP_PROP_XI_CC_MATRIX_12                      = 485,
    CV_CAP_PROP_XI_CC_MATRIX_13                      = 486,
    CV_CAP_PROP_XI_CC_MATRIX_20                      = 487,
    CV_CAP_PROP_XI_CC_MATRIX_21                      = 488,
    CV_CAP_PROP_XI_CC_MATRIX_22                      = 489,
    CV_CAP_PROP_XI_CC_MATRIX_23                      = 490,
    CV_CAP_PROP_XI_CC_MATRIX_30                      = 491,
    CV_CAP_PROP_XI_CC_MATRIX_31                      = 492,
    CV_CAP_PROP_XI_CC_MATRIX_32                      = 493,
    CV_CAP_PROP_XI_CC_MATRIX_33                      = 494,
    CV_CAP_PROP_XI_DEFAULT_CC_MATRIX                 = 495,
    CV_CAP_PROP_XI_TRG_SELECTOR                      = 498,
    CV_CAP_PROP_XI_ACQ_FRAME_BURST_COUNT             = 499,
    CV_CAP_PROP_XI_DEBOUNCE_EN                       = 507,
    CV_CAP_PROP_XI_DEBOUNCE_T0                       = 508,
    CV_CAP_PROP_XI_DEBOUNCE_T1                       = 509,
    CV_CAP_PROP_XI_DEBOUNCE_POL                      = 510,
    CV_CAP_PROP_XI_LENS_MODE                         = 511,
    CV_CAP_PROP_XI_LENS_APERTURE_VALUE               = 512,
    CV_CAP_PROP_XI_LENS_FOCUS_MOVEMENT_VALUE         = 513,
    CV_CAP_PROP_XI_LENS_FOCUS_MOVE                   = 514,
    CV_CAP_PROP_XI_LENS_FOCUS_DISTANCE               = 515,
    CV_CAP_PROP_XI_LENS_FOCAL_LENGTH                 = 516,
    CV_CAP_PROP_XI_LENS_FEATURE_SELECTOR             = 517,
    CV_CAP_PROP_XI_LENS_FEATURE                      = 518,
    CV_CAP_PROP_XI_DEVICE_MODEL_ID                   = 521,
    CV_CAP_PROP_XI_DEVICE_SN                         = 522,
    CV_CAP_PROP_XI_IMAGE_DATA_FORMAT_RGB32_ALPHA     = 529,
    CV_CAP_PROP_XI_IMAGE_PAYLOAD_SIZE                = 530,
    CV_CAP_PROP_XI_TRANSPORT_PIXEL_FORMAT            = 531,
    CV_CAP_PROP_XI_SENSOR_CLOCK_FREQ_HZ              = 532,
    CV_CAP_PROP_XI_SENSOR_CLOCK_FREQ_INDEX           = 533,
    CV_CAP_PROP_XI_SENSOR_OUTPUT_CHANNEL_COUNT       = 534,
    CV_CAP_PROP_XI_FRAMERATE                         = 535,
    CV_CAP_PROP_XI_COUNTER_SELECTOR                  = 536,
    CV_CAP_PROP_XI_COUNTER_VALUE                     = 537,
    CV_CAP_PROP_XI_ACQ_TIMING_MODE                   = 538,
    CV_CAP_PROP_XI_AVAILABLE_BANDWIDTH               = 539,
    CV_CAP_PROP_XI_BUFFER_POLICY                     = 540,
    CV_CAP_PROP_XI_LUT_EN                            = 541,
    CV_CAP_PROP_XI_LUT_INDEX                         = 542,
    CV_CAP_PROP_XI_LUT_VALUE                         = 543,
    CV_CAP_PROP_XI_TRG_DELAY                         = 544,
    CV_CAP_PROP_XI_TS_RST_MODE                       = 545,
    CV_CAP_PROP_XI_TS_RST_SOURCE                     = 546,
    CV_CAP_PROP_XI_IS_DEVICE_EXIST                   = 547,
    CV_CAP_PROP_XI_ACQ_BUFFER_SIZE                   = 548,
    CV_CAP_PROP_XI_ACQ_BUFFER_SIZE_UNIT              = 549,
    CV_CAP_PROP_XI_ACQ_TRANSPORT_BUFFER_SIZE         = 550,
    CV_CAP_PROP_XI_BUFFERS_QUEUE_SIZE                = 551,
    CV_CAP_PROP_XI_ACQ_TRANSPORT_BUFFER_COMMIT       = 552,
    CV_CAP_PROP_XI_RECENT_FRAME                      = 553,
    CV_CAP_PROP_XI_DEVICE_RESET                      = 554,
    CV_CAP_PROP_XI_COLUMN_FPN_CORRECTION             = 555,
    CV_CAP_PROP_XI_ROW_FPN_CORRECTION                = 591,
    CV_CAP_PROP_XI_SENSOR_MODE                       = 558,
    CV_CAP_PROP_XI_HDR                               = 559,
    CV_CAP_PROP_XI_HDR_KNEEPOINT_COUNT               = 560,
    CV_CAP_PROP_XI_HDR_T1                            = 561,
    CV_CAP_PROP_XI_HDR_T2                            = 562,
    CV_CAP_PROP_XI_KNEEPOINT1                        = 563,
    CV_CAP_PROP_XI_KNEEPOINT2                        = 564,
    CV_CAP_PROP_XI_IMAGE_BLACK_LEVEL                 = 565,
    CV_CAP_PROP_XI_HW_REVISION                       = 571,
    CV_CAP_PROP_XI_DEBUG_LEVEL                       = 572,
    CV_CAP_PROP_XI_AUTO_BANDWIDTH_CALCULATION        = 573,
    CV_CAP_PROP_XI_FFS_FILE_ID                       = 594,
    CV_CAP_PROP_XI_FFS_FILE_SIZE                     = 580,
    CV_CAP_PROP_XI_FREE_FFS_SIZE                     = 581,
    CV_CAP_PROP_XI_USED_FFS_SIZE                     = 582,
    CV_CAP_PROP_XI_FFS_ACCESS_KEY                    = 583,
    CV_CAP_PROP_XI_SENSOR_FEATURE_SELECTOR           = 585,
    CV_CAP_PROP_XI_SENSOR_FEATURE_VALUE              = 586,
    CV_CAP_PROP_ANDROID_FLASH_MODE                   = 8001,
    CV_CAP_PROP_ANDROID_FOCUS_MODE                   = 8002,
    CV_CAP_PROP_ANDROID_WHITE_BALANCE                = 8003,
    CV_CAP_PROP_ANDROID_ANTIBANDING                  = 8004,
    CV_CAP_PROP_ANDROID_FOCAL_LENGTH                 = 8005,
    CV_CAP_PROP_ANDROID_FOCUS_DISTANCE_NEAR          = 8006,
    CV_CAP_PROP_ANDROID_FOCUS_DISTANCE_OPTIMAL       = 8007,
    CV_CAP_PROP_ANDROID_FOCUS_DISTANCE_FAR           = 8008,
    CV_CAP_PROP_ANDROID_EXPOSE_LOCK                  = 8009,
    CV_CAP_PROP_ANDROID_WHITEBALANCE_LOCK            = 8010,
    CV_CAP_PROP_IOS_DEVICE_FOCUS                     = 9001,
    CV_CAP_PROP_IOS_DEVICE_EXPOSURE                  = 9002,
    CV_CAP_PROP_IOS_DEVICE_FLASH                     = 9003,
    CV_CAP_PROP_IOS_DEVICE_WHITEBALANCE              = 9004,
    CV_CAP_PROP_IOS_DEVICE_TORCH                     = 9005,
    CV_CAP_PROP_GIGA_FRAME_OFFSET_X                  = 10001,
    CV_CAP_PROP_GIGA_FRAME_OFFSET_Y                  = 10002,
    CV_CAP_PROP_GIGA_FRAME_WIDTH_MAX                 = 10003,
    CV_CAP_PROP_GIGA_FRAME_HEIGH_MAX                 = 10004,
    CV_CAP_PROP_GIGA_FRAME_SENS_WIDTH                = 10005,
    CV_CAP_PROP_GIGA_FRAME_SENS_HEIGH                = 10006,
    CV_CAP_PROP_INTELPERC_PROFILE_COUNT              = 11001,
    CV_CAP_PROP_INTELPERC_PROFILE_IDX                = 11002,
    CV_CAP_PROP_INTELPERC_DEPTH_LOW_CONFIDENCE_VALUE = 11003,
    CV_CAP_PROP_INTELPERC_DEPTH_SATURATION_VALUE     = 11004,
    CV_CAP_PROP_INTELPERC_DEPTH_CONFIDENCE_THRESHOLD = 11005,
    CV_CAP_PROP_INTELPERC_DEPTH_FOCAL_LENGTH_HORZ    = 11006,
    CV_CAP_PROP_INTELPERC_DEPTH_FOCAL_LENGTH_VERT    = 11007,
    CV_CAP_INTELPERC_DEPTH_GENERATOR                 = 1 <<29,
    CV_CAP_INTELPERC_IMAGE_GENERATOR                 = 1 <<28,
    CV_CAP_INTELPERC_GENERATORS_MASK                 = CV_CAP_INTELPERC_DEPTH_GENERATOR + CV_CAP_INTELPERC_IMAGE_GENERATOR,
};

enum
{
    CV_CAP_MODE_BGR  = 0,
    CV_CAP_MODE_RGB  = 1,
    CV_CAP_MODE_GRAY = 2,
    CV_CAP_MODE_YUYV = 3,
};

enum
{
    CV_CAP_OPENNI_DEPTH_MAP         = 0,
    CV_CAP_OPENNI_POINT_CLOUD_MAP   = 1,
    CV_CAP_OPENNI_DISPARITY_MAP     = 2,
    CV_CAP_OPENNI_DISPARITY_MAP_32F = 3,
    CV_CAP_OPENNI_VALID_DEPTH_MASK  = 4,
    CV_CAP_OPENNI_BGR_IMAGE         = 5,
    CV_CAP_OPENNI_GRAY_IMAGE        = 6,
    CV_CAP_OPENNI_IR_IMAGE          = 7,
};

enum
{
    CV_CAP_OPENNI_VGA_30HZ  = 0,
    CV_CAP_OPENNI_SXGA_15HZ = 1,
    CV_CAP_OPENNI_SXGA_30HZ = 2,
    CV_CAP_OPENNI_QVGA_30HZ = 3,
    CV_CAP_OPENNI_QVGA_60HZ = 4,
};

enum
{
    CV_CAP_INTELPERC_DEPTH_MAP   = 0,
    CV_CAP_INTELPERC_UVDEPTH_MAP = 1,
    CV_CAP_INTELPERC_IR_MAP      = 2,
    CV_CAP_INTELPERC_IMAGE       = 3,
};

enum
{
    CV_CAP_PROP_GPHOTO2_PREVIEW          = 17001,
    CV_CAP_PROP_GPHOTO2_WIDGET_ENUMERATE = 17002,
    CV_CAP_PROP_GPHOTO2_RELOAD_CONFIG    = 17003,
    CV_CAP_PROP_GPHOTO2_RELOAD_ON_CHANGE = 17004,
    CV_CAP_PROP_GPHOTO2_COLLECT_MSGS     = 17005,
    CV_CAP_PROP_GPHOTO2_FLUSH_MSGS       = 17006,
    CV_CAP_PROP_SPEED                    = 17007,
    CV_CAP_PROP_APERTURE                 = 17008,
    CV_CAP_PROP_EXPOSUREPROGRAM          = 17009,
    CV_CAP_PROP_VIEWFINDER               = 17010,
};

enum
{
    CV_FONT_LIGHT    = 25,
    CV_FONT_NORMAL   = 50,
    CV_FONT_DEMIBOLD = 63,
    CV_FONT_BOLD     = 75,
    CV_FONT_BLACK    = 87,
};

enum
{
    CV_STYLE_NORMAL  = 0,
    CV_STYLE_ITALIC  = 1,
    CV_STYLE_OBLIQUE = 2,
};

enum
{
    CV_PUSH_BUTTON = 0,
    CV_CHECKBOX    = 1,
    CV_RADIOBOX    = 2,
};

enum
{
    CV_WND_PROP_FULLSCREEN  = 0,
    CV_WND_PROP_AUTOSIZE    = 1,
    CV_WND_PROP_ASPECTRATIO = 2,
    CV_WND_PROP_OPENGL      = 3,
    CV_WND_PROP_VISIBLE     = 4,
    CV_WINDOW_NORMAL        = 0x00000000,
    CV_WINDOW_AUTOSIZE      = 0x00000001,
    CV_WINDOW_OPENGL        = 0x00001000,
    CV_GUI_EXPANDED         = 0x00000000,
    CV_GUI_NORMAL           = 0x00000010,
    CV_WINDOW_FULLSCREEN    = 1,
    CV_WINDOW_FREERATIO     = 0x00000100,
    CV_WINDOW_KEEPRATIO     = 0x00000000,
};

enum
{
    CV_EVENT_MOUSEMOVE     =0,
    CV_EVENT_LBUTTONDOWN   =1,
    CV_EVENT_RBUTTONDOWN   =2,
    CV_EVENT_MBUTTONDOWN   =3,
    CV_EVENT_LBUTTONUP     =4,
    CV_EVENT_RBUTTONUP     =5,
    CV_EVENT_MBUTTONUP     =6,
    CV_EVENT_LBUTTONDBLCLK =7,
    CV_EVENT_RBUTTONDBLCLK =8,
    CV_EVENT_MBUTTONDBLCLK =9,
    CV_EVENT_MOUSEWHEEL    =10,
    CV_EVENT_MOUSEHWHEEL   =11,
};

enum
{
    CV_EVENT_FLAG_LBUTTON  =1,
    CV_EVENT_FLAG_RBUTTON  =2,
    CV_EVENT_FLAG_MBUTTON  =4,
    CV_EVENT_FLAG_CTRLKEY  =8,
    CV_EVENT_FLAG_SHIFTKEY =16,
    CV_EVENT_FLAG_ALTKEY   =32,
};

enum
{
    CV_ITERATIVE = 0,
    CV_EPNP      = 1,
    CV_P3P       = 2,
    CV_DLS       = 3,
};

enum
{
    NCV_SUCCESS,
    NCV_UNKNOWN_ERROR,
    NCV_CUDA_ERROR,
    NCV_NPP_ERROR,
    NCV_FILE_ERROR,
    NCV_NULL_PTR,
    NCV_INCONSISTENT_INPUT,
    NCV_TEXTURE_BIND_ERROR,
    NCV_DIMENSIONS_INVALID,
    NCV_INVALID_ROI,
    NCV_INVALID_STEP,
    NCV_INVALID_SCALE,
    NCV_ALLOCATOR_NOT_INITIALIZED,
    NCV_ALLOCATOR_BAD_ALLOC,
    NCV_ALLOCATOR_BAD_DEALLOC,
    NCV_ALLOCATOR_INSUFFICIENT_CAPACITY,
    NCV_ALLOCATOR_DEALLOC_ORDER,
    NCV_ALLOCATOR_BAD_REUSE,
    NCV_MEM_COPY_ERROR,
    NCV_MEM_RESIDENCE_ERROR,
    NCV_MEM_INSUFFICIENT_CAPACITY,
    NCV_HAAR_INVALID_PIXEL_STEP,
    NCV_HAAR_TOO_MANY_FEATURES_IN_CLASSIFIER,
    NCV_HAAR_TOO_MANY_FEATURES_IN_CASCADE,
    NCV_HAAR_TOO_LARGE_FEATURES,
    NCV_HAAR_XML_LOADING_EXCEPTION,
    NCV_NOIMPL_HAAR_TILTED_FEATURES,
    NCV_NOT_IMPLEMENTED,
    NCV_WARNING_HAAR_DETECTIONS_VECTOR_OVERFLOW,
    NPPST_SUCCESS                               = NCV_SUCCESS,
    NPPST_ERROR,
    NPPST_CUDA_KERNEL_EXECUTION_ERROR,
    NPPST_NULL_POINTER_ERROR,
    NPPST_TEXTURE_BIND_ERROR,
    NPPST_MEMCPY_ERROR,
    NPPST_MEM_ALLOC_ERR,
    NPPST_MEMFREE_ERR,
    NPPST_INVALID_ROI,
    NPPST_INVALID_STEP,
    NPPST_INVALID_SCALE,
    NPPST_MEM_INSUFFICIENT_BUFFER,
    NPPST_MEM_RESIDENCE_ERROR,
    NPPST_MEM_INTERNAL_ERROR,
    NCV_LAST_STATUS,
};

enum
{
    NCVPipeObjDet_Default             = 0x000,
    NCVPipeObjDet_UseFairImageScaling = 0x001,
    NCVPipeObjDet_FindLargestObject   = 0x002,
    NCVPipeObjDet_VisualizeInPlace    = 0x004,
};

enum
{
    CV_StsOk                     =                       0,
    CV_StsBackTrace              =               -1,
    CV_StsError                  =                   -2,
    CV_StsInternal               =                -3,
    CV_StsNoMem                  =                   -4,
    CV_StsBadArg                 =                  -5,
    CV_StsBadFunc                =                 -6,
    CV_StsNoConv                 =                  -7,
    CV_StsAutoTrace              =               -8,
    CV_HeaderIsNull              =               -9,
    CV_BadImageSize              =              -10,
    CV_BadOffset                 =                 -11,
    CV_BadDataPtr                =                -12,
    CV_BadStep                   =                   -13,
    CV_BadModelOrChSeq           =           -14,
    CV_BadNumChannels            =            -15,
    CV_BadNumChannel1U           =           -16,
    CV_BadDepth                  =                  -17,
    CV_BadAlphaChannel           =           -18,
    CV_BadOrder                  =                  -19,
    CV_BadOrigin                 =                 -20,
    CV_BadAlign                  =                  -21,
    CV_BadCallBack               =               -22,
    CV_BadTileSize               =               -23,
    CV_BadCOI                    =                    -24,
    CV_BadROISize                =                -25,
    CV_MaskIsTiled               =               -26,
    CV_StsNullPtr                =                -27,
    CV_StsVecLengthErr           =           -28,
    CV_StsFilterStructContentErr = -29,
    CV_StsKernelStructContentErr = -30,
    CV_StsFilterOffsetErr        =        -31,
    CV_StsBadSize                =                -201,
    CV_StsDivByZero              =              -202,
    CV_StsInplaceNotSupported    =    -203,
    CV_StsObjectNotFound         =         -204,
    CV_StsUnmatchedFormats       =       -205,
    CV_StsBadFlag                =                -206,
    CV_StsBadPoint               =               -207,
    CV_StsBadMask                =                -208,
    CV_StsUnmatchedSizes         =         -209,
    CV_StsUnsupportedFormat      =      -210,
    CV_StsOutOfRange             =             -211,
    CV_StsParseError             =             -212,
    CV_StsNotImplemented         =         -213,
    CV_StsBadMemBlock            =            -214,
    CV_StsAssert                 =                 -215,
    CV_GpuNotSupported           =           -216,
    CV_GpuApiCallError           =           -217,
    CV_OpenGlNotSupported        =        -218,
    CV_OpenGlApiCallError        =        -219,
    CV_OpenCLApiCallError        =        -220,
    CV_OpenCLDoubleNotSupported  =  -221,
    CV_OpenCLInitError           =           -222,
    CV_OpenCLNoAMDBlasFft        =        -223,
};

enum
{
    CV_GAUSSIAN_5x5 = 7,
};

enum
{
    CV_SCHARR          =-1,
    CV_MAX_SOBEL_KSIZE =7,
};

enum
{
    CV_BGR2BGRA        =0,
    CV_RGB2RGBA        =CV_BGR2BGRA,
    CV_BGRA2BGR        =1,
    CV_RGBA2RGB        =CV_BGRA2BGR,
    CV_BGR2RGBA        =2,
    CV_RGB2BGRA        =CV_BGR2RGBA,
    CV_RGBA2BGR        =3,
    CV_BGRA2RGB        =CV_RGBA2BGR,
    CV_BGR2RGB         =4,
    CV_RGB2BGR         =CV_BGR2RGB,
    CV_BGRA2RGBA       =5,
    CV_RGBA2BGRA       =CV_BGRA2RGBA,
    CV_BGR2GRAY        =6,
    CV_RGB2GRAY        =7,
    CV_GRAY2BGR        =8,
    CV_GRAY2RGB        =CV_GRAY2BGR,
    CV_GRAY2BGRA       =9,
    CV_GRAY2RGBA       =CV_GRAY2BGRA,
    CV_BGRA2GRAY       =10,
    CV_RGBA2GRAY       =11,
    CV_BGR2BGR565      =12,
    CV_RGB2BGR565      =13,
    CV_BGR5652BGR      =14,
    CV_BGR5652RGB      =15,
    CV_BGRA2BGR565     =16,
    CV_RGBA2BGR565     =17,
    CV_BGR5652BGRA     =18,
    CV_BGR5652RGBA     =19,
    CV_GRAY2BGR565     =20,
    CV_BGR5652GRAY     =21,
    CV_BGR2BGR555      =22,
    CV_RGB2BGR555      =23,
    CV_BGR5552BGR      =24,
    CV_BGR5552RGB      =25,
    CV_BGRA2BGR555     =26,
    CV_RGBA2BGR555     =27,
    CV_BGR5552BGRA     =28,
    CV_BGR5552RGBA     =29,
    CV_GRAY2BGR555     =30,
    CV_BGR5552GRAY     =31,
    CV_BGR2XYZ         =32,
    CV_RGB2XYZ         =33,
    CV_XYZ2BGR         =34,
    CV_XYZ2RGB         =35,
    CV_BGR2YCrCb       =36,
    CV_RGB2YCrCb       =37,
    CV_YCrCb2BGR       =38,
    CV_YCrCb2RGB       =39,
    CV_BGR2HSV         =40,
    CV_RGB2HSV         =41,
    CV_BGR2Lab         =44,
    CV_RGB2Lab         =45,
    CV_BayerBG2BGR     =46,
    CV_BayerGB2BGR     =47,
    CV_BayerRG2BGR     =48,
    CV_BayerGR2BGR     =49,
    CV_BayerBG2RGB     =CV_BayerRG2BGR,
    CV_BayerGB2RGB     =CV_BayerGR2BGR,
    CV_BayerRG2RGB     =CV_BayerBG2BGR,
    CV_BayerGR2RGB     =CV_BayerGB2BGR,
    CV_BGR2Luv         =50,
    CV_RGB2Luv         =51,
    CV_BGR2HLS         =52,
    CV_RGB2HLS         =53,
    CV_HSV2BGR         =54,
    CV_HSV2RGB         =55,
    CV_Lab2BGR         =56,
    CV_Lab2RGB         =57,
    CV_Luv2BGR         =58,
    CV_Luv2RGB         =59,
    CV_HLS2BGR         =60,
    CV_HLS2RGB         =61,
    CV_BayerBG2BGR_VNG =62,
    CV_BayerGB2BGR_VNG =63,
    CV_BayerRG2BGR_VNG =64,
    CV_BayerGR2BGR_VNG =65,
    CV_BayerBG2RGB_VNG =CV_BayerRG2BGR_VNG,
    CV_BayerGB2RGB_VNG =CV_BayerGR2BGR_VNG,
    CV_BayerRG2RGB_VNG =CV_BayerBG2BGR_VNG,
    CV_BayerGR2RGB_VNG =CV_BayerGB2BGR_VNG,
    CV_BGR2HSV_FULL    = 66,
    CV_RGB2HSV_FULL    = 67,
    CV_BGR2HLS_FULL    = 68,
    CV_RGB2HLS_FULL    = 69,
    CV_HSV2BGR_FULL    = 70,
    CV_HSV2RGB_FULL    = 71,
    CV_HLS2BGR_FULL    = 72,
    CV_HLS2RGB_FULL    = 73,
    CV_LBGR2Lab        = 74,
    CV_LRGB2Lab        = 75,
    CV_LBGR2Luv        = 76,
    CV_LRGB2Luv        = 77,
    CV_Lab2LBGR        = 78,
    CV_Lab2LRGB        = 79,
    CV_Luv2LBGR        = 80,
    CV_Luv2LRGB        = 81,
    CV_BGR2YUV         = 82,
    CV_RGB2YUV         = 83,
    CV_YUV2BGR         = 84,
    CV_YUV2RGB         = 85,
    CV_BayerBG2GRAY    = 86,
    CV_BayerGB2GRAY    = 87,
    CV_BayerRG2GRAY    = 88,
    CV_BayerGR2GRAY    = 89,
    CV_YUV2RGB_NV12    = 90,
    CV_YUV2BGR_NV12    = 91,
    CV_YUV2RGB_NV21    = 92,
    CV_YUV2BGR_NV21    = 93,
    CV_YUV420sp2RGB    = CV_YUV2RGB_NV21,
    CV_YUV420sp2BGR    = CV_YUV2BGR_NV21,
    CV_YUV2RGBA_NV12   = 94,
    CV_YUV2BGRA_NV12   = 95,
    CV_YUV2RGBA_NV21   = 96,
    CV_YUV2BGRA_NV21   = 97,
    CV_YUV420sp2RGBA   = CV_YUV2RGBA_NV21,
    CV_YUV420sp2BGRA   = CV_YUV2BGRA_NV21,
    CV_YUV2RGB_YV12    = 98,
    CV_YUV2BGR_YV12    = 99,
    CV_YUV2RGB_IYUV    = 100,
    CV_YUV2BGR_IYUV    = 101,
    CV_YUV2RGB_I420    = CV_YUV2RGB_IYUV,
    CV_YUV2BGR_I420    = CV_YUV2BGR_IYUV,
    CV_YUV420p2RGB     = CV_YUV2RGB_YV12,
    CV_YUV420p2BGR     = CV_YUV2BGR_YV12,
    CV_YUV2RGBA_YV12   = 102,
    CV_YUV2BGRA_YV12   = 103,
    CV_YUV2RGBA_IYUV   = 104,
    CV_YUV2BGRA_IYUV   = 105,
    CV_YUV2RGBA_I420   = CV_YUV2RGBA_IYUV,
    CV_YUV2BGRA_I420   = CV_YUV2BGRA_IYUV,
    CV_YUV420p2RGBA    = CV_YUV2RGBA_YV12,
    CV_YUV420p2BGRA    = CV_YUV2BGRA_YV12,
    CV_YUV2GRAY_420    = 106,
    CV_YUV2GRAY_NV21   = CV_YUV2GRAY_420,
    CV_YUV2GRAY_NV12   = CV_YUV2GRAY_420,
    CV_YUV2GRAY_YV12   = CV_YUV2GRAY_420,
    CV_YUV2GRAY_IYUV   = CV_YUV2GRAY_420,
    CV_YUV2GRAY_I420   = CV_YUV2GRAY_420,
    CV_YUV420sp2GRAY   = CV_YUV2GRAY_420,
    CV_YUV420p2GRAY    = CV_YUV2GRAY_420,
    CV_YUV2RGB_UYVY    = 107,
    CV_YUV2BGR_UYVY    = 108,
    CV_YUV2RGB_Y422    = CV_YUV2RGB_UYVY,
    CV_YUV2BGR_Y422    = CV_YUV2BGR_UYVY,
    CV_YUV2RGB_UYNV    = CV_YUV2RGB_UYVY,
    CV_YUV2BGR_UYNV    = CV_YUV2BGR_UYVY,
    CV_YUV2RGBA_UYVY   = 111,
    CV_YUV2BGRA_UYVY   = 112,
    CV_YUV2RGBA_Y422   = CV_YUV2RGBA_UYVY,
    CV_YUV2BGRA_Y422   = CV_YUV2BGRA_UYVY,
    CV_YUV2RGBA_UYNV   = CV_YUV2RGBA_UYVY,
    CV_YUV2BGRA_UYNV   = CV_YUV2BGRA_UYVY,
    CV_YUV2RGB_YUY2    = 115,
    CV_YUV2BGR_YUY2    = 116,
    CV_YUV2RGB_YVYU    = 117,
    CV_YUV2BGR_YVYU    = 118,
    CV_YUV2RGB_YUYV    = CV_YUV2RGB_YUY2,
    CV_YUV2BGR_YUYV    = CV_YUV2BGR_YUY2,
    CV_YUV2RGB_YUNV    = CV_YUV2RGB_YUY2,
    CV_YUV2BGR_YUNV    = CV_YUV2BGR_YUY2,
    CV_YUV2RGBA_YUY2   = 119,
    CV_YUV2BGRA_YUY2   = 120,
    CV_YUV2RGBA_YVYU   = 121,
    CV_YUV2BGRA_YVYU   = 122,
    CV_YUV2RGBA_YUYV   = CV_YUV2RGBA_YUY2,
    CV_YUV2BGRA_YUYV   = CV_YUV2BGRA_YUY2,
    CV_YUV2RGBA_YUNV   = CV_YUV2RGBA_YUY2,
    CV_YUV2BGRA_YUNV   = CV_YUV2BGRA_YUY2,
    CV_YUV2GRAY_UYVY   = 123,
    CV_YUV2GRAY_YUY2   = 124,
    CV_YUV2GRAY_Y422   = CV_YUV2GRAY_UYVY,
    CV_YUV2GRAY_UYNV   = CV_YUV2GRAY_UYVY,
    CV_YUV2GRAY_YVYU   = CV_YUV2GRAY_YUY2,
    CV_YUV2GRAY_YUYV   = CV_YUV2GRAY_YUY2,
    CV_YUV2GRAY_YUNV   = CV_YUV2GRAY_YUY2,
    CV_RGBA2mRGBA      = 125,
    CV_mRGBA2RGBA      = 126,
    CV_RGB2YUV_I420    = 127,
    CV_BGR2YUV_I420    = 128,
    CV_RGB2YUV_IYUV    = CV_RGB2YUV_I420,
    CV_BGR2YUV_IYUV    = CV_BGR2YUV_I420,
    CV_RGBA2YUV_I420   = 129,
    CV_BGRA2YUV_I420   = 130,
    CV_RGBA2YUV_IYUV   = CV_RGBA2YUV_I420,
    CV_BGRA2YUV_IYUV   = CV_BGRA2YUV_I420,
    CV_RGB2YUV_YV12    = 131,
    CV_BGR2YUV_YV12    = 132,
    CV_RGBA2YUV_YV12   = 133,
    CV_BGRA2YUV_YV12   = 134,
    CV_BayerBG2BGR_EA  = 135,
    CV_BayerGB2BGR_EA  = 136,
    CV_BayerRG2BGR_EA  = 137,
    CV_BayerGR2BGR_EA  = 138,
    CV_BayerBG2RGB_EA  = CV_BayerRG2BGR_EA,
    CV_BayerGB2RGB_EA  = CV_BayerGR2BGR_EA,
    CV_BayerRG2RGB_EA  = CV_BayerBG2BGR_EA,
    CV_BayerGR2RGB_EA  = CV_BayerGB2BGR_EA,
    CV_BayerBG2BGRA    =139,
    CV_BayerGB2BGRA    =140,
    CV_BayerRG2BGRA    =141,
    CV_BayerGR2BGRA    =142,
    CV_BayerBG2RGBA    =CV_BayerRG2BGRA,
    CV_BayerGB2RGBA    =CV_BayerGR2BGRA,
    CV_BayerRG2RGBA    =CV_BayerBG2BGRA,
    CV_BayerGR2RGBA    =CV_BayerGB2BGRA,
    CV_COLORCVT_MAX    = 143,
};

enum
{
    CV_INTER_NN       =0,
    CV_INTER_LINEAR   =1,
    CV_INTER_CUBIC    =2,
    CV_INTER_AREA     =3,
    CV_INTER_LANCZOS4 =4,
};

enum
{
    CV_WARP_FILL_OUTLIERS =8,
    CV_WARP_INVERSE_MAP   =16,
};

enum
{
    CV_MOP_ERODE    =0,
    CV_MOP_DILATE   =1,
    CV_MOP_OPEN     =2,
    CV_MOP_CLOSE    =3,
    CV_MOP_GRADIENT =4,
    CV_MOP_TOPHAT   =5,
    CV_MOP_BLACKHAT =6,
};

enum
{
    CV_TM_SQDIFF        =0,
    CV_TM_SQDIFF_NORMED =1,
    CV_TM_CCORR         =2,
    CV_TM_CCORR_NORMED  =3,
    CV_TM_CCOEFF        =4,
    CV_TM_CCOEFF_NORMED =5,
};

enum
{
    CV_RETR_EXTERNAL  =0,
    CV_RETR_LIST      =1,
    CV_RETR_CCOMP     =2,
    CV_RETR_TREE      =3,
    CV_RETR_FLOODFILL =4,
};

enum
{
    CV_CHAIN_CODE             =0,
    CV_CHAIN_APPROX_NONE      =1,
    CV_CHAIN_APPROX_SIMPLE    =2,
    CV_CHAIN_APPROX_TC89_L1   =3,
    CV_CHAIN_APPROX_TC89_KCOS =4,
    CV_LINK_RUNS              =5,
};

enum
{
    CV_POLY_APPROX_DP = 0,
};

enum
{
    CV_CONTOURS_MATCH_I1 =1,
    CV_CONTOURS_MATCH_I2 =2,
    CV_CONTOURS_MATCH_I3 =3,
};

enum
{
    CV_CLOCKWISE         =1,
    CV_COUNTER_CLOCKWISE =2,
};

enum
{
    CV_COMP_CORREL        =0,
    CV_COMP_CHISQR        =1,
    CV_COMP_INTERSECT     =2,
    CV_COMP_BHATTACHARYYA =3,
    CV_COMP_HELLINGER     =CV_COMP_BHATTACHARYYA,
    CV_COMP_CHISQR_ALT    =4,
    CV_COMP_KL_DIV        =5,
};

enum
{
    CV_DIST_MASK_3       =3,
    CV_DIST_MASK_5       =5,
    CV_DIST_MASK_PRECISE =0,
};

enum
{
    CV_DIST_LABEL_CCOMP = 0,
    CV_DIST_LABEL_PIXEL = 1,
};

enum
{
    CV_DIST_USER   =-1,
    CV_DIST_L1     =1,
    CV_DIST_L2     =2,
    CV_DIST_C      =3,
    CV_DIST_L12    =4,
    CV_DIST_FAIR   =5,
    CV_DIST_WELSCH =6,
    CV_DIST_HUBER  =7,
};

enum
{
    CV_THRESH_BINARY     =0,
    CV_THRESH_BINARY_INV =1,
    CV_THRESH_TRUNC      =2,
    CV_THRESH_TOZERO     =3,
    CV_THRESH_TOZERO_INV =4,
    CV_THRESH_MASK       =7,
    CV_THRESH_OTSU       =8,
    CV_THRESH_TRIANGLE   =16,
};

enum
{
    CV_ADAPTIVE_THRESH_MEAN_C     =0,
    CV_ADAPTIVE_THRESH_GAUSSIAN_C =1,
};

enum
{
    CV_FLOODFILL_FIXED_RANGE =(1 <<16),
    CV_FLOODFILL_MASK_ONLY   =(1 <<17),
};

enum
{
    CV_CANNY_L2_GRADIENT =(1 <<31),
};

enum
{
    CV_HOUGH_STANDARD      =0,
    CV_HOUGH_PROBABILISTIC =1,
    CV_HOUGH_MULTI_SCALE   =2,
    CV_HOUGH_GRADIENT      =3,
};

enum CpuFeatures;
enum InpaintingModes;
enum MorphShapes_c;
enum NCVMemoryType;
enum NppStBorderType;
enum NppStInterpMode;
enum SmoothMethod_c;

// structs

struct CvAttrList;
struct CvAvgComp;
struct CvBox2D;
struct CvChain;
struct CvChainPtReader;
struct CvConnectedComp;
struct CvContour;
struct CvConvexityDefect;
struct CvFileNode;
struct CvFont;
struct CvGraph;
struct CvGraphEdge;
struct CvGraphScanner;
struct CvGraphVtx;
struct CvGraphVtx2D;
struct CvHaarClassifier;
struct CvHaarClassifierCascade;
struct CvHaarFeature;
struct CvHaarStageClassifier;
struct CvHistogram;
struct CvHuMoments;
struct CvKalman;
struct CvLineIterator;
struct CvMat;
struct CvMatND;
struct CvMemBlock;
struct CvMemStorage;
struct CvMemStoragePos;
struct CvModuleInfo;
struct CvMoments;
struct CvNArrayIterator;
struct CvPluginFuncInfo;
struct CvPoint;
struct CvPoint2D32f;
struct CvPoint2D64f;
struct CvPoint3D32f;
struct CvPoint3D64f;
struct CvRect;
struct CvScalar;
struct CvSeq;
struct CvSeqBlock;
struct CvSeqReader;
struct CvSeqWriter;
struct CvSet;
struct CvSetElem;
struct CvSize;
struct CvSize2D32f;
struct CvSlice;
struct CvSparseMat;
struct CvSparseMatIterator;
struct CvSparseNode;
struct CvStereoBMState;
struct CvString;
struct CvStringHashNode;
struct CvTermCriteria;
struct CvTreeNodeIterator;
struct CvType;
struct CvTypeInfo;
struct HaarClassifierCascadeDescriptor;
struct HaarClassifierNode128;
struct HaarClassifierNodeDescriptor32;
struct HaarFeature64;
struct HaarFeatureDescriptor32;
struct HaarStage64;
struct IplConvKernel;
struct IplConvKernelFP;
struct IplImage;
struct IplROI;
struct NCVBroxOpticalFlowDescriptor;
struct NCVMemPtr;
struct NCVMemSegment;
struct NcvPoint2D32s;
struct NcvPoint2D32u;
struct NcvRect32s;
struct NcvRect32u;
struct NcvRect8u;
struct NcvSize32s;
struct NcvSize32u;
struct NppStInterpolationState;
struct cvhalDFT;
struct cvhalFilter2D;

// unions

union Cv16suf;
union Cv32suf;
union Cv64suf;

// protocols

protocol CvPhotoCameraDelegate -p;
protocol CvVideoCameraDelegate -p;

// classes

class CvAbstractCamera;
class CvLevMarq;
class CvPhotoCamera;
class CvVideoCamera;
class INCVMemAllocator;

template <class T>
class NCVMatrix;

template <class T>
class NCVMatrixAlloc;

template <class T>
class NCVMatrixReuse;

class NCVMemNativeAllocator;
class NCVMemStackAllocator;

template <class T>
class NCVVector;

template <class T>
class NCVVectorAlloc;

template <class T>
class NCVVectorReuse;

// global variables

CL_RUNTIME_EXPORT clAmdBlasStatus(* clAmdBlasCgemmEx_pfn)(clAmdBlasOrder order, clAmdBlasTranspose transA, clAmdBlasTranspose transB, size_t M, size_t N, size_t K, FloatComplex alpha, const cl_mem A, size_t offA, size_t lda, const cl_mem B, size_t offB, size_t ldb, FloatComplex beta, cl_mem C, size_t offC, size_t ldc, cl_uint numCommandQueues, cl_command_queue *commandQueues, cl_uint numEventsInWaitList, const cl_event *eventWaitList, cl_event *events);
CL_RUNTIME_EXPORT clAmdBlasStatus(* clAmdBlasDgemmEx_pfn)(clAmdBlasOrder order, clAmdBlasTranspose transA, clAmdBlasTranspose transB, size_t M, size_t N, size_t K, cl_double alpha, const cl_mem A, size_t offA, size_t lda, const cl_mem B, size_t offB, size_t ldb, cl_double beta, cl_mem C, size_t offC, size_t ldc, cl_uint numCommandQueues, cl_command_queue *commandQueues, cl_uint numEventsInWaitList, const cl_event *eventWaitList, cl_event *events);
CL_RUNTIME_EXPORT clAmdBlasStatus(* clAmdBlasSetup_pfn)();
CL_RUNTIME_EXPORT clAmdBlasStatus(* clAmdBlasSgemmEx_pfn)(clAmdBlasOrder order, clAmdBlasTranspose transA, clAmdBlasTranspose transB, size_t M, size_t N, size_t K, cl_float alpha, const cl_mem A, size_t offA, size_t lda, const cl_mem B, size_t offB, size_t ldb, cl_float beta, cl_mem C, size_t offC, size_t ldc, cl_uint numCommandQueues, cl_command_queue *commandQueues, cl_uint numEventsInWaitList, const cl_event *eventWaitList, cl_event *events);
CL_RUNTIME_EXPORT void(* clAmdBlasTeardown_pfn)();
CL_RUNTIME_EXPORT clAmdBlasStatus(* clAmdBlasZgemmEx_pfn)(clAmdBlasOrder order, clAmdBlasTranspose transA, clAmdBlasTranspose transB, size_t M, size_t N, size_t K, DoubleComplex alpha, const cl_mem A, size_t offA, size_t lda, const cl_mem B, size_t offB, size_t ldb, DoubleComplex beta, cl_mem C, size_t offC, size_t ldc, cl_uint numCommandQueues, cl_command_queue *commandQueues, cl_uint numEventsInWaitList, const cl_event *eventWaitList, cl_event *events);
CL_RUNTIME_EXPORT clAmdFftStatus(* clAmdFftBakePlan_pfn)(clAmdFftPlanHandle plHandle, cl_uint numQueues, cl_command_queue *commQueueFFT, void(CL_CALLBACK *pfn_notify)(clAmdFftPlanHandle plHandle, void *user_data), void *user_data);
CL_RUNTIME_EXPORT clAmdFftStatus(* clAmdFftCreateDefaultPlan_pfn)(clAmdFftPlanHandle *plHandle, cl_context context, const clAmdFftDim dim, const size_t *clLengths);
CL_RUNTIME_EXPORT clAmdFftStatus(* clAmdFftDestroyPlan_pfn)(clAmdFftPlanHandle *plHandle);
CL_RUNTIME_EXPORT clAmdFftStatus(* clAmdFftEnqueueTransform_pfn)(clAmdFftPlanHandle plHandle, clAmdFftDirection dir, cl_uint numQueuesAndEvents, cl_command_queue *commQueues, cl_uint numWaitEvents, const cl_event *waitEvents, cl_event *outEvents, cl_mem *inputBuffers, cl_mem *outputBuffers, cl_mem tmpBuffer);
CL_RUNTIME_EXPORT clAmdFftStatus(* clAmdFftGetTmpBufSize_pfn)(const clAmdFftPlanHandle plHandle, size_t *buffersize);
CL_RUNTIME_EXPORT clAmdFftStatus(* clAmdFftGetVersion_pfn)(cl_uint *major, cl_uint *minor, cl_uint *patch);
CL_RUNTIME_EXPORT clAmdFftStatus(* clAmdFftSetLayout_pfn)(clAmdFftPlanHandle plHandle, clAmdFftLayout iLayout, clAmdFftLayout oLayout);
CL_RUNTIME_EXPORT clAmdFftStatus(* clAmdFftSetPlanBatchSize_pfn)(clAmdFftPlanHandle plHandle, size_t batchSize);
CL_RUNTIME_EXPORT clAmdFftStatus(* clAmdFftSetPlanDistance_pfn)(clAmdFftPlanHandle plHandle, size_t iDist, size_t oDist);
CL_RUNTIME_EXPORT clAmdFftStatus(* clAmdFftSetPlanInStride_pfn)(clAmdFftPlanHandle plHandle, const clAmdFftDim dim, size_t *clStrides);
CL_RUNTIME_EXPORT clAmdFftStatus(* clAmdFftSetPlanOutStride_pfn)(clAmdFftPlanHandle plHandle, const clAmdFftDim dim, size_t *clStrides);
CL_RUNTIME_EXPORT clAmdFftStatus(* clAmdFftSetPlanPrecision_pfn)(clAmdFftPlanHandle plHandle, clAmdFftPrecision precision);
CL_RUNTIME_EXPORT clAmdFftStatus(* clAmdFftSetPlanScale_pfn)(clAmdFftPlanHandle plHandle, clAmdFftDirection dir, cl_float scale);
CL_RUNTIME_EXPORT clAmdFftStatus(* clAmdFftSetResultLocation_pfn)(clAmdFftPlanHandle plHandle, clAmdFftResultLocation placeness);
CL_RUNTIME_EXPORT clAmdFftStatus(* clAmdFftSetup_pfn)(const clAmdFftSetupData *setupData);
CL_RUNTIME_EXPORT clAmdFftStatus(* clAmdFftTeardown_pfn)();
CL_RUNTIME_EXPORT const cl_device_id const char void void*CL_RUNTIME_EXPORT const cl_device_id const char const cl_program const char void void*CL_RUNTIME_EXPORT void cl_int*CL_RUNTIME_EXPORT cl_int*CL_RUNTIME_EXPORT const cl_device_id const void void void cl_int*CL_RUNTIME_EXPORT const void void void cl_int*CL_RUNTIME_EXPORT const cl_image_format const cl_image_desc void cl_int*CL_RUNTIME_EXPORT const cl_image_format void cl_int*CL_RUNTIME_EXPORT const cl_image_format void cl_int*CL_RUNTIME_EXPORT const char cl_int*CL_RUNTIME_EXPORT cl_kernel cl_uint*CL_RUNTIME_EXPORT const cl_device_id const size_t const unsigned char cl_int cl_int*CL_RUNTIME_EXPORT const cl_device_id const char cl_int*CL_RUNTIME_EXPORT const char const size_t cl_int*CL_RUNTIME_EXPORT cl_addressing_mode;
CL_RUNTIME_EXPORT const cl_device_id const char void void*CL_RUNTIME_EXPORT const cl_device_id const char const cl_program const char void void*CL_RUNTIME_EXPORT void cl_int*CL_RUNTIME_EXPORT cl_int*CL_RUNTIME_EXPORT const cl_device_id const void void void cl_int*CL_RUNTIME_EXPORT const void void void cl_int*CL_RUNTIME_EXPORT const cl_image_format const cl_image_desc void cl_int*CL_RUNTIME_EXPORT const cl_image_format void cl_int*CL_RUNTIME_EXPORT const cl_image_format void cl_int*CL_RUNTIME_EXPORT const char cl_int*CL_RUNTIME_EXPORT cl_kernel cl_uint*CL_RUNTIME_EXPORT const cl_device_id const size_t const unsigned char cl_int cl_int*CL_RUNTIME_EXPORT const cl_device_id const char cl_int*CL_RUNTIME_EXPORT const char const size_t cl_int*CL_RUNTIME_EXPORT cl_bool;
CL_RUNTIME_EXPORT const cl_device_id const char void void*CL_RUNTIME_EXPORT const cl_device_id const char const cl_program const char void void*CL_RUNTIME_EXPORT void cl_int*CL_RUNTIME_EXPORT cl_int*CL_RUNTIME_EXPORT const cl_device_id const void void void cl_int*CL_RUNTIME_EXPORT const void void void cl_int*CL_RUNTIME_EXPORT const cl_image_format const cl_image_desc void cl_int*CL_RUNTIME_EXPORT const cl_image_format void cl_int*CL_RUNTIME_EXPORT const cl_image_format void cl_int*CL_RUNTIME_EXPORT const char cl_int*CL_RUNTIME_EXPORT cl_kernel cl_uint*CL_RUNTIME_EXPORT const cl_device_id const size_t const unsigned char cl_int cl_int*CL_RUNTIME_EXPORT const cl_device_id const char cl_int*CL_RUNTIME_EXPORT const char const size_t cl_int*CL_RUNTIME_EXPORT cl_int*CL_RUNTIME_EXPORT cl_buffer_create_type;
CL_RUNTIME_EXPORT cl_command_queue_info;
CL_RUNTIME_EXPORT const cl_device_id const char void void*CL_RUNTIME_EXPORT const cl_device_id const char const cl_program const char void void*CL_RUNTIME_EXPORT void cl_int*CL_RUNTIME_EXPORT cl_command_queue_properties;
CL_RUNTIME_EXPORT void size_t*CL_RUNTIME_EXPORT cl_context_info;
CL_RUNTIME_EXPORT const cl_device_id const char void void*CL_RUNTIME_EXPORT const cl_device_id const char const cl_program const char void void*CL_RUNTIME_EXPORT void cl_int*CL_RUNTIME_EXPORT cl_device_id;
CL_RUNTIME_EXPORT void size_t*CL_RUNTIME_EXPORT void size_t*CL_RUNTIME_EXPORT cl_device_id cl_uint*CL_RUNTIME_EXPORT cl_device_info;
CL_RUNTIME_EXPORT const cl_device_id const char void void*CL_RUNTIME_EXPORT const cl_device_id const char const cl_program const char void void*CL_RUNTIME_EXPORT void cl_int*CL_RUNTIME_EXPORT cl_int*CL_RUNTIME_EXPORT const cl_device_id const void void void cl_int*CL_RUNTIME_EXPORT cl_device_type;
CL_RUNTIME_EXPORT void size_t*CL_RUNTIME_EXPORT void size_t*CL_RUNTIME_EXPORT cl_device_id cl_uint*CL_RUNTIME_EXPORT void size_t*CL_RUNTIME_EXPORT cl_event_info;
CL_RUNTIME_EXPORT const cl_device_id const char void void*CL_RUNTIME_EXPORT const cl_device_id const char const cl_program const char void void*CL_RUNTIME_EXPORT void cl_int*CL_RUNTIME_EXPORT cl_int*CL_RUNTIME_EXPORT const cl_device_id const void void void cl_int*CL_RUNTIME_EXPORT const void void void cl_int*CL_RUNTIME_EXPORT const cl_image_format const cl_image_desc void cl_int*CL_RUNTIME_EXPORT const cl_image_format void cl_int*CL_RUNTIME_EXPORT const cl_image_format void cl_int*CL_RUNTIME_EXPORT const char cl_int*CL_RUNTIME_EXPORT cl_kernel cl_uint*CL_RUNTIME_EXPORT const cl_device_id const size_t const unsigned char cl_int cl_int*CL_RUNTIME_EXPORT const cl_device_id const char cl_int*CL_RUNTIME_EXPORT const char const size_t cl_int*CL_RUNTIME_EXPORT cl_filter_mode;
CL_RUNTIME_EXPORT cl_image_info;
CL_RUNTIME_EXPORT cl_int;
CL_RUNTIME_EXPORT cl_event*CL_RUNTIME_EXPORT const cl_event cl_event*CL_RUNTIME_EXPORT const cl_mem const cl_event cl_event*CL_RUNTIME_EXPORT cl_kernel;
CL_RUNTIME_EXPORT void size_t*CL_RUNTIME_EXPORT cl_kernel_arg_info;
CL_RUNTIME_EXPORT void size_t*CL_RUNTIME_EXPORT void size_t*CL_RUNTIME_EXPORT cl_kernel_info;
CL_RUNTIME_EXPORT void size_t*CL_RUNTIME_EXPORT void size_t*CL_RUNTIME_EXPORT void size_t*CL_RUNTIME_EXPORT cl_kernel_work_group_info;
CL_RUNTIME_EXPORT const cl_event cl_event*CL_RUNTIME_EXPORT cl_mem;
CL_RUNTIME_EXPORT const cl_device_id const char void void*CL_RUNTIME_EXPORT const cl_device_id const char const cl_program const char void void*CL_RUNTIME_EXPORT cl_mem_flags;
CL_RUNTIME_EXPORT void size_t*CL_RUNTIME_EXPORT void size_t*CL_RUNTIME_EXPORT void size_t*CL_RUNTIME_EXPORT void size_t*CL_RUNTIME_EXPORT cl_mem_info;
CL_RUNTIME_EXPORT cl_event*CL_RUNTIME_EXPORT const cl_event cl_event*CL_RUNTIME_EXPORT const cl_mem cl_mem_migration_flags;
CL_RUNTIME_EXPORT void size_t*CL_RUNTIME_EXPORT void size_t*CL_RUNTIME_EXPORT void size_t*CL_RUNTIME_EXPORT void size_t*CL_RUNTIME_EXPORT void size_t*CL_RUNTIME_EXPORT cl_platform_id cl_uint*CL_RUNTIME_EXPORT void size_t*CL_RUNTIME_EXPORT void size_t*CL_RUNTIME_EXPORT void size_t*CL_RUNTIME_EXPORT void size_t*CL_RUNTIME_EXPORT cl_mem_object_type;
CL_RUNTIME_EXPORT void size_t*CL_RUNTIME_EXPORT void size_t*CL_RUNTIME_EXPORT void size_t*CL_RUNTIME_EXPORT void size_t*CL_RUNTIME_EXPORT void size_t*CL_RUNTIME_EXPORT cl_platform_id cl_uint*CL_RUNTIME_EXPORT cl_platform_info;
CL_RUNTIME_EXPORT void size_t*CL_RUNTIME_EXPORT void size_t*CL_RUNTIME_EXPORT cl_device_id cl_uint*CL_RUNTIME_EXPORT void size_t*CL_RUNTIME_EXPORT void size_t*CL_RUNTIME_EXPORT cl_profiling_info;
CL_RUNTIME_EXPORT void size_t*CL_RUNTIME_EXPORT void size_t*CL_RUNTIME_EXPORT void size_t*CL_RUNTIME_EXPORT void size_t*CL_RUNTIME_EXPORT void size_t*CL_RUNTIME_EXPORT cl_platform_id cl_uint*CL_RUNTIME_EXPORT void size_t*CL_RUNTIME_EXPORT cl_program_build_info;
CL_RUNTIME_EXPORT void size_t*CL_RUNTIME_EXPORT void size_t*CL_RUNTIME_EXPORT void size_t*CL_RUNTIME_EXPORT void size_t*CL_RUNTIME_EXPORT void size_t*CL_RUNTIME_EXPORT cl_platform_id cl_uint*CL_RUNTIME_EXPORT void size_t*CL_RUNTIME_EXPORT void size_t*CL_RUNTIME_EXPORT cl_program_info;
CL_RUNTIME_EXPORT void size_t*CL_RUNTIME_EXPORT void size_t*CL_RUNTIME_EXPORT void size_t*CL_RUNTIME_EXPORT void size_t*CL_RUNTIME_EXPORT void size_t*CL_RUNTIME_EXPORT cl_platform_id cl_uint*CL_RUNTIME_EXPORT void size_t*CL_RUNTIME_EXPORT void size_t*CL_RUNTIME_EXPORT void size_t*CL_RUNTIME_EXPORT cl_sampler_info;
CL_RUNTIME_EXPORT cl_uint;
CL_RUNTIME_EXPORT const cl_device_id const char void void*CL_RUNTIME_EXPORT const cl_device_id const char const cl_program const char void void*CL_RUNTIME_EXPORT size_t;
const Ncv32u K_LOG2_WARP_SIZE;
const Ncv32u K_WARP_SIZE;

// global functions

void
cvCalcMatMulDeriv(
    const CvMat* A,
    const CvMat* B,
    CvMat* dABdA,
    CvMat* dABdB
    );

double
cvCalibrateCamera2(
    const CvMat* object_points,
    const CvMat* image_points,
    const CvMat* point_counts,
    CvSize image_size,
    CvMat* camera_matrix,
    CvMat* distortion_coeffs,
    CvMat* rotation_vectors = NULL,
    CvMat* translation_vectors = NULL,
    int flags = 0,
    CvTermCriteria term_crit = cvTermCriteria(CV_TERMCRIT_ITER+CV_TERMCRIT_EPS, 30, DBL_EPSILON)
    );

void
cvCalibrationMatrixValues(
    const CvMat* camera_matrix,
    CvSize image_size,
    double aperture_width = 0,
    double aperture_height = 0,
    double* fovx = NULL,
    double* fovy = NULL,
    double* focal_length = NULL,
    CvPoint2D64f* principal_point = NULL,
    double* pixel_aspect_ratio = NULL
    );

int
cvCheckChessboard(
    IplImage* src,
    CvSize size
    );

void
cvComposeRT(
    const CvMat* _rvec1,
    const CvMat* _tvec1,
    const CvMat* _rvec2,
    const CvMat* _tvec2,
    CvMat* _rvec3,
    CvMat* _tvec3,
    CvMat* dr3dr1 = 0,
    CvMat* dr3dt1 = 0,
    CvMat* dr3dr2 = 0,
    CvMat* dr3dt2 = 0,
    CvMat* dt3dr1 = 0,
    CvMat* dt3dt1 = 0,
    CvMat* dt3dr2 = 0,
    CvMat* dt3dt2 = 0
    );

void
cvComputeCorrespondEpilines(
    const CvMat* points,
    int which_image,
    const CvMat* fundamental_matrix,
    CvMat* correspondent_lines
    );

void
cvConvertPointsHomogeneous(
    const CvMat* src,
    CvMat* dst
    );

void
cvCorrectMatches(
    CvMat* F,
    CvMat* points1,
    CvMat* points2,
    CvMat* new_points1,
    CvMat* new_points2
    );

CvPOSITObject*
cvCreatePOSITObject(
    CvPoint3D32f* points,
    int point_count
    );

CvStereoBMState*
cvCreateStereoBMState(
    int preset = 0,
    int numberOfDisparities = 0
    );

void
cvDecomposeProjectionMatrix(
    const CvMat* projMatr,
    CvMat* calibMatr,
    CvMat* rotMatr,
    CvMat* posVect,
    CvMat* rotMatrX = NULL,
    CvMat* rotMatrY = NULL,
    CvMat* rotMatrZ = NULL,
    CvPoint3D64f* eulerAngles = NULL
    );

void
cvDrawChessboardCorners(
    CvArr* image,
    CvSize pattern_size,
    CvPoint2D32f* corners,
    int count,
    int pattern_was_found
    );

int
cvFindChessboardCorners(
    const void* image,
    CvSize pattern_size,
    CvPoint2D32f* corners,
    int* corner_count = NULL,
    int flags = 1+2
    );

void
cvFindExtrinsicCameraParams2(
    const CvMat* object_points,
    const CvMat* image_points,
    const CvMat* camera_matrix,
    const CvMat* distortion_coeffs,
    CvMat* rotation_vector,
    CvMat* translation_vector,
    int use_extrinsic_guess = 0
    );

int
cvFindFundamentalMat(
    const CvMat* points1,
    const CvMat* points2,
    CvMat* fundamental_matrix,
    int method = 8,
    double param1 = 3.,
    double param2 = 0.99,
    CvMat* status = NULL
    );

int
cvFindHomography(
    const CvMat* src_points,
    const CvMat* dst_points,
    CvMat* homography,
    int method = 0,
    double ransacReprojThreshold = 3,
    CvMat* mask = 0,
    int maxIters = 2000,
    double confidence = 0.995
    );

void
cvFindStereoCorrespondenceBM(
    const CvArr* left,
    const CvArr* right,
    CvArr* disparity,
    CvStereoBMState* state
    );

void
cvGetOptimalNewCameraMatrix(
    const CvMat* camera_matrix,
    const CvMat* dist_coeffs,
    CvSize image_size,
    double alpha,
    CvMat* new_camera_matrix,
    CvSize new_imag_size = cvSize(0, 0),
    CvRect* valid_pixel_ROI = 0,
    int center_principal_point = 0
    );

CvRect
cvGetValidDisparityROI(
    CvRect roi1,
    CvRect roi2,
    int minDisparity,
    int numberOfDisparities,
    int SADWindowSize
    );

void
cvInitIntrinsicParams2D(
    const CvMat* object_points,
    const CvMat* image_points,
    const CvMat* npoints,
    CvSize image_size,
    CvMat* camera_matrix,
    double aspect_ratio = 1.
    );

void
cvPOSIT(
    CvPOSITObject* posit_object,
    CvPoint2D32f* image_points,
    double focal_length,
    CvTermCriteria criteria,
    float* rotation_matrix,
    float* translation_vector
    );

void
cvProjectPoints2(
    const CvMat* object_points,
    const CvMat* rotation_vector,
    const CvMat* translation_vector,
    const CvMat* camera_matrix,
    const CvMat* distortion_coeffs,
    CvMat* image_points,
    CvMat* dpdrot = NULL,
    CvMat* dpdt = NULL,
    CvMat* dpdf = NULL,
    CvMat* dpdc = NULL,
    CvMat* dpddist = NULL,
    double aspect_ratio = 0
    );

int
cvRANSACUpdateNumIters(
    double p,
    double err_prob,
    int model_points,
    int max_iters
    );

void
cvReleasePOSITObject(CvPOSITObject** posit_object);

void
cvReleaseStereoBMState(CvStereoBMState** state);

void
cvReprojectImageTo3D(
    const CvArr* disparityImage,
    CvArr* _3dImage,
    const CvMat* Q,
    int handleMissingValues = 0
    );

int
cvRodrigues2(
    const CvMat* src,
    CvMat* dst,
    CvMat* jacobian = 0
    );

void
cvRQDecomp3x3(
    const CvMat* matrixM,
    CvMat* matrixR,
    CvMat* matrixQ,
    CvMat* matrixQx = NULL,
    CvMat* matrixQy = NULL,
    CvMat* matrixQz = NULL,
    CvPoint3D64f* eulerAngles = NULL
    );

double
cvStereoCalibrate(
    const CvMat* object_points,
    const CvMat* image_points1,
    const CvMat* image_points2,
    const CvMat* npoints,
    CvMat* camera_matrix1,
    CvMat* dist_coeffs1,
    CvMat* camera_matrix2,
    CvMat* dist_coeffs2,
    CvSize image_size,
    CvMat* R,
    CvMat* T,
    CvMat* E = 0,
    CvMat* F = 0,
    int flags = 256,
    CvTermCriteria term_crit = cvTermCriteria(CV_TERMCRIT_ITER+CV_TERMCRIT_EPS, 30, 1e-6)
    );

void
cvStereoRectify(
    const CvMat* camera_matrix1,
    const CvMat* camera_matrix2,
    const CvMat* dist_coeffs1,
    const CvMat* dist_coeffs2,
    CvSize image_size,
    const CvMat* R,
    const CvMat* T,
    CvMat* R1,
    CvMat* R2,
    CvMat* P1,
    CvMat* P2,
    CvMat* Q = 0,
    int flags = 1024,
    double alpha = -1,
    CvSize new_image_size = cvSize(0, 0),
    CvRect* valid_pix_ROI1 = 0,
    CvRect* valid_pix_ROI2 = 0
    );

int
cvStereoRectifyUncalibrated(
    const CvMat* points1,
    const CvMat* points2,
    const CvMat* F,
    CvSize img_size,
    CvMat* H1,
    CvMat* H2,
    double threshold = 5
    );

void
cvTriangulatePoints(
    CvMat* projMatr1,
    CvMat* projMatr2,
    CvMat* projPoints1,
    CvMat* projPoints2,
    CvMat* points4D
    );

void
cvValidateDisparity(
    CvArr* disparity,
    const CvArr* cost,
    int minDisparity,
    int numberOfDisparities,
    int disp12MaxDiff = 1
    );

void
cvAbsDiff(
    const CvArr* src1,
    const CvArr* src2,
    CvArr* dst
    );

void
cvAbsDiffS(
    const CvArr* src,
    CvArr* dst,
    CvScalar value
    );

void
cvAdd(
    const CvArr* src1,
    const CvArr* src2,
    CvArr* dst,
    const CvArr* mask = NULL
    );

void
cvAddS(
    const CvArr* src,
    CvScalar value,
    CvArr* dst,
    const CvArr* mask = NULL
    );

void
cvAddWeighted(
    const CvArr* src1,
    double alpha,
    const CvArr* src2,
    double beta,
    double gamma,
    CvArr* dst
    );

void*
cvAlloc(size_t size);

void
cvAnd(
    const CvArr* src1,
    const CvArr* src2,
    CvArr* dst,
    const CvArr* mask = NULL
    );

void
cvAndS(
    const CvArr* src,
    CvScalar value,
    CvArr* dst,
    const CvArr* mask = NULL
    );

const char*
cvAttrValue(
    const CvAttrList* attr,
    const char* attr_name
    );

CvScalar
cvAvg(
    const CvArr* arr,
    const CvArr* mask = NULL
    );

void
cvAvgSdv(
    const CvArr* arr,
    CvScalar* mean,
    CvScalar* std_dev,
    const CvArr* mask = NULL
    );

void
cvBackProjectPCA(
    const CvArr* proj,
    const CvArr* mean,
    const CvArr* eigenvects,
    CvArr* result
    );

void
cvCalcCovarMatrix(
    const CvArr** vects,
    int count,
    CvArr* cov_mat,
    CvArr* avg,
    int flags
    );

void
cvCalcPCA(
    const CvArr* data,
    CvArr* mean,
    CvArr* eigenvals,
    CvArr* eigenvects,
    int flags
    );

void
cvCartToPolar(
    const CvArr* x,
    const CvArr* y,
    CvArr* magnitude,
    CvArr* angle = NULL,
    int angle_in_degrees = 0
    );

float
cvCbrt(float value);

void
cvChangeSeqBlock(
    void* reader,
    int direction
    );

int
cvCheckArr(
    const CvArr* arr,
    int flags = 0,
    double min_val = 0,
    double max_val = 0
    );

int
cvCheckHardwareSupport(int feature);

CvTermCriteria
cvCheckTermCriteria(
    CvTermCriteria criteria,
    double default_eps,
    int default_max_iters
    );

void
cvClearGraph(CvGraph* graph);

void
cvClearMemStorage(CvMemStorage* storage);

void
cvClearND(
    CvArr* arr,
    const int* idx
    );

void
cvClearSeq(CvSeq* seq);

void
cvClearSet(CvSet* set_header);

void*
cvClone(const void* struct_ptr);

CvGraph*
cvCloneGraph(
    const CvGraph* graph,
    CvMemStorage* storage
    );

IplImage*
cvCloneImage(const IplImage* image);

CvMat*
cvCloneMat(const CvMat* mat);

CvMatND*
cvCloneMatND(const CvMatND* mat);

CvSeq*
cvCloneSeq(
    const CvSeq* seq,
    CvMemStorage* storage = NULL
    );

CvSparseMat*
cvCloneSparseMat(const CvSparseMat* mat);

void
cvCmp(
    const CvArr* src1,
    const CvArr* src2,
    CvArr* dst,
    int cmp_op
    );

void
cvCmpS(
    const CvArr* src,
    double value,
    CvArr* dst,
    int cmp_op
    );

void
cvCompleteSymm(
    CvMat* matrix,
    int LtoR = 0
    );

void
cvConvertScale(
    const CvArr* src,
    CvArr* dst,
    double scale = 1,
    double shift = 0
    );

void
cvConvertScaleAbs(
    const CvArr* src,
    CvArr* dst,
    double scale = 1,
    double shift = 0
    );

void
cvCopy(
    const CvArr* src,
    CvArr* dst,
    const CvArr* mask = NULL
    );

int
cvCountNonZero(const CvArr* arr);

CvMemStorage*
cvCreateChildMemStorage(CvMemStorage* parent);

void
cvCreateData(CvArr* arr);

CvGraph*
cvCreateGraph(
    int graph_flags,
    int header_size,
    int vtx_size,
    int edge_size,
    CvMemStorage* storage
    );

CvGraphScanner*
cvCreateGraphScanner(
    CvGraph* graph,
    CvGraphVtx* vtx = NULL,
    int mask = -1
    );

IplImage*
cvCreateImage(
    CvSize size,
    int depth,
    int channels
    );

IplImage*
cvCreateImageHeader(
    CvSize size,
    int depth,
    int channels
    );

CvMat*
cvCreateMat(
    int rows,
    int cols,
    int type
    );

CvMat*
cvCreateMatHeader(
    int rows,
    int cols,
    int type
    );

CvMatND*
cvCreateMatND(
    int dims,
    const int* sizes,
    int type
    );

CvMatND*
cvCreateMatNDHeader(
    int dims,
    const int* sizes,
    int type
    );

CvMemStorage*
cvCreateMemStorage(int block_size = 0);

CvSeq*
cvCreateSeq(
    int seq_flags,
    size_t header_size,
    size_t elem_size,
    CvMemStorage* storage
    );

void
cvCreateSeqBlock(CvSeqWriter* writer);

CvSet*
cvCreateSet(
    int set_flags,
    int header_size,
    int elem_size,
    CvMemStorage* storage
    );

CvSparseMat*
cvCreateSparseMat(
    int dims,
    const int* sizes,
    int type
    );

void
cvCrossProduct(
    const CvArr* src1,
    const CvArr* src2,
    CvArr* dst
    );

void*
cvCvtSeqToArray(
    const CvSeq* seq,
    void* elements,
    CvSlice slice = CV_WHOLE_SEQ
    );

void
cvDCT(
    const CvArr* src,
    CvArr* dst,
    int flags
    );

void
cvDecRefData(CvArr* arr);

double
cvDet(const CvArr* mat);

void
cvDFT(
    const CvArr* src,
    CvArr* dst,
    int flags,
    int nonzero_rows = 0
    );

void
cvDiv(
    const CvArr* src1,
    const CvArr* src2,
    CvArr* dst,
    double scale = 1
    );

double
cvDotProduct(
    const CvArr* src1,
    const CvArr* src2
    );

void
cvEigenVV(
    CvArr* mat,
    CvArr* evects,
    CvArr* evals,
    double eps = 0,
    int lowindex = -1,
    int highindex = -1
    );

CvSeq*
cvEndWriteSeq(CvSeqWriter* writer);

void
cvEndWriteStruct(CvFileStorage* fs);

void
cvError(
    int status,
    const char* func_name,
    const char* err_msg,
    const char* file_name,
    int line
    );

int
cvErrorFromIppStatus(int ipp_status);

const char*
cvErrorStr(int status);

void
cvExp(
    const CvArr* src,
    CvArr* dst
    );

float
cvFastArctan(
    float y,
    float x
    );

CvGraphEdge*
cvFindGraphEdge(
    const CvGraph* graph,
    int start_idx,
    int end_idx
    );

CvGraphEdge*
cvFindGraphEdgeByPtr(
    const CvGraph* graph,
    const CvGraphVtx* start_vtx,
    const CvGraphVtx* end_vtx
    );

CvTypeInfo*
cvFindType(const char* type_name);

CvTypeInfo*
cvFirstType(void);

void
cvFlip(
    const CvArr* src,
    CvArr* dst = NULL,
    int flip_mode = 0
    );

void
cvFlushSeqWriter(CvSeqWriter* writer);

void
cvFree_(void* ptr);

void
cvGEMM(
    const CvArr* src1,
    const CvArr* src2,
    double alpha,
    const CvArr* src3,
    double beta,
    CvArr* dst,
    int tABC = 0
    );

CvScalar
cvGet1D(
    const CvArr* arr,
    int idx0
    );

CvScalar
cvGet2D(
    const CvArr* arr,
    int idx0,
    int idx1
    );

CvScalar
cvGet3D(
    const CvArr* arr,
    int idx0,
    int idx1,
    int idx2
    );

CvMat*
cvGetCol(
    const CvArr* arr,
    CvMat* submat,
    int col
    );

CvMat*
cvGetCols(
    const CvArr* arr,
    CvMat* submat,
    int start_col,
    int end_col
    );

CvMat*
cvGetDiag(
    const CvArr* arr,
    CvMat* submat,
    int diag = 0
    );

int
cvGetDims(
    const CvArr* arr,
    int* sizes = NULL
    );

int
cvGetDimSize(
    const CvArr* arr,
    int index
    );

int
cvGetElemType(const CvArr* arr);

int
cvGetErrInfo(
    const char** errcode_desc,
    const char** description,
    const char** filename,
    int* line
    );

int
cvGetErrMode(void);

int
cvGetErrStatus(void);

CvFileNode*
cvGetFileNode(
    CvFileStorage* fs,
    CvFileNode* map,
    const CvStringHashNode* key,
    int create_missing = 0
    );

CvFileNode*
cvGetFileNodeByName(
    const CvFileStorage* fs,
    const CvFileNode* map,
    const char* name
    );

const char*
cvGetFileNodeName(const CvFileNode* node);

CvStringHashNode*
cvGetHashedKey(
    CvFileStorage* fs,
    const char* name,
    int len = -1,
    int create_missing = 0
    );

IplImage*
cvGetImage(
    const CvArr* arr,
    IplImage* image_header
    );

int
cvGetImageCOI(const IplImage* image);

CvRect
cvGetImageROI(const IplImage* image);

CvMat*
cvGetMat(
    const CvArr* arr,
    CvMat* header,
    int* coi = NULL,
    int allowND = 0
    );

CvScalar
cvGetND(
    const CvArr* arr,
    const int* idx
    );

CvSparseNode*
cvGetNextSparseNode(CvSparseMatIterator* mat_iterator);

int
cvGetNumThreads(void);

int
cvGetOptimalDFTSize(int size0);

void
cvGetRawData(
    const CvArr* arr,
    uchar** data,
    int* step = NULL,
    CvSize* roi_size = NULL
    );

double
cvGetReal1D(
    const CvArr* arr,
    int idx0
    );

double
cvGetReal2D(
    const CvArr* arr,
    int idx0,
    int idx1
    );

double
cvGetReal3D(
    const CvArr* arr,
    int idx0,
    int idx1,
    int idx2
    );

double
cvGetRealND(
    const CvArr* arr,
    const int* idx
    );

CvFileNode*
cvGetRootFileNode(
    const CvFileStorage* fs,
    int stream_index = 0
    );

CvMat*
cvGetRow(
    const CvArr* arr,
    CvMat* submat,
    int row
    );

CvMat*
cvGetRows(
    const CvArr* arr,
    CvMat* submat,
    int start_row,
    int end_row,
    int delta_row = 1
    );

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

int
cvGetSeqReaderPos(CvSeqReader* reader);

CvSetElem*
cvGetSetElem(
    const CvSet* set_header,
    int idx
    );

CvSize
cvGetSize(const CvArr* arr);

CvMat*
cvGetSubRect(
    const CvArr* arr,
    CvMat* submat,
    CvRect rect
    );

int
cvGetThreadNum(void);

int64
cvGetTickCount(void);

double
cvGetTickFrequency(void);

int
cvGraphAddEdge(
    CvGraph* graph,
    int start_idx,
    int end_idx,
    const CvGraphEdge* edge = NULL,
    CvGraphEdge** inserted_edge = NULL
    );

int
cvGraphAddEdgeByPtr(
    CvGraph* graph,
    CvGraphVtx* start_vtx,
    CvGraphVtx* end_vtx,
    const CvGraphEdge* edge = NULL,
    CvGraphEdge** inserted_edge = NULL
    );

int
cvGraphAddVtx(
    CvGraph* graph,
    const CvGraphVtx* vtx = NULL,
    CvGraphVtx** inserted_vtx = NULL
    );

void
cvGraphRemoveEdge(
    CvGraph* graph,
    int start_idx,
    int end_idx
    );

void
cvGraphRemoveEdgeByPtr(
    CvGraph* graph,
    CvGraphVtx* start_vtx,
    CvGraphVtx* end_vtx
    );

int
cvGraphRemoveVtx(
    CvGraph* graph,
    int index
    );

int
cvGraphRemoveVtxByPtr(
    CvGraph* graph,
    CvGraphVtx* vtx
    );

int
cvGraphVtxDegree(
    const CvGraph* graph,
    int vtx_idx
    );

int
cvGraphVtxDegreeByPtr(
    const CvGraph* graph,
    const CvGraphVtx* vtx
    );

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

int
cvIncRefData(CvArr* arr);

IplImage*
cvInitImageHeader(
    IplImage* image,
    CvSize size,
    int depth,
    int channels,
    int origin = 0,
    int align = 4
    );

CvMat*
cvInitMatHeader(
    CvMat* mat,
    int rows,
    int cols,
    int type,
    void* data = NULL,
    int step = 0x7fffffff
    );

CvMatND*
cvInitMatNDHeader(
    CvMatND* mat,
    int dims,
    const int* sizes,
    int type,
    void* data = NULL
    );

int
cvInitNArrayIterator(
    int count,
    CvArr** arrs,
    const CvArr* mask,
    CvMatND* stubs,
    CvNArrayIterator* array_iterator,
    int flags = 0
    );

CvSparseNode*
cvInitSparseMatIterator(
    const CvSparseMat* mat,
    CvSparseMatIterator* mat_iterator
    );

void
cvInitTreeNodeIterator(
    CvTreeNodeIterator* tree_iterator,
    const void* first,
    int max_level
    );

void
cvInRange(
    const CvArr* src,
    const CvArr* lower,
    const CvArr* upper,
    CvArr* dst
    );

void
cvInRangeS(
    const CvArr* src,
    CvScalar lower,
    CvScalar upper,
    CvArr* dst
    );

void
cvInsertNodeIntoTree(
    void* node,
    void* parent,
    void* frame
    );

double
cvInvert(
    const CvArr* src,
    CvArr* dst,
    int method = 0
    );

int
cvKMeans2(
    const CvArr* samples,
    int cluster_count,
    CvArr* labels,
    CvTermCriteria termcrit,
    int attempts = 1,
    CvRNG* rng = 0,
    int flags = 0,
    CvArr* _centers = 0,
    double* compactness = 0
    );

void*
cvLoad(
    const char* filename,
    CvMemStorage* memstorage = NULL,
    const char* name = NULL,
    const char** real_name = NULL
    );

void
cvLog(
    const CvArr* src,
    CvArr* dst
    );

void
cvLUT(
    const CvArr* src,
    CvArr* dst,
    const CvArr* lut
    );

double
cvMahalanobis(
    const CvArr* vec1,
    const CvArr* vec2,
    const CvArr* mat
    );

CvSeq*
cvMakeSeqHeaderForArray(
    int seq_type,
    int header_size,
    int elem_size,
    void* elements,
    int total,
    CvSeq* seq,
    CvSeqBlock* block
    );

void
cvMax(
    const CvArr* src1,
    const CvArr* src2,
    CvArr* dst
    );

void
cvMaxS(
    const CvArr* src,
    double value,
    CvArr* dst
    );

void*
cvMemStorageAlloc(
    CvMemStorage* storage,
    size_t size
    );

CvString
cvMemStorageAllocString(
    CvMemStorage* storage,
    const char* ptr,
    int len = -1
    );

void
cvMerge(
    const CvArr* src0,
    const CvArr* src1,
    const CvArr* src2,
    const CvArr* src3,
    CvArr* dst
    );

void
cvMin(
    const CvArr* src1,
    const CvArr* src2,
    CvArr* dst
    );

void
cvMinMaxLoc(
    const CvArr* arr,
    double* min_val,
    double* max_val,
    CvPoint* min_loc = NULL,
    CvPoint* max_loc = NULL,
    const CvArr* mask = NULL
    );

void
cvMinS(
    const CvArr* src,
    double value,
    CvArr* dst
    );

void
cvMixChannels(
    const CvArr** src,
    int src_count,
    CvArr** dst,
    int dst_count,
    const int* from_to,
    int pair_count
    );

void
cvMul(
    const CvArr* src1,
    const CvArr* src2,
    CvArr* dst,
    double scale = 1
    );

void
cvMulSpectrums(
    const CvArr* src1,
    const CvArr* src2,
    CvArr* dst,
    int flags
    );

void
cvMulTransposed(
    const CvArr* src,
    CvArr* dst,
    int order,
    const CvArr* delta = NULL,
    double scale = 1.
    );

int
cvNextGraphItem(CvGraphScanner* scanner);

int
cvNextNArraySlice(CvNArrayIterator* array_iterator);

void*
cvNextTreeNode(CvTreeNodeIterator* tree_iterator);

double
cvNorm(
    const CvArr* arr1,
    const CvArr* arr2 = NULL,
    int norm_type = 4,
    const CvArr* mask = NULL
    );

void
cvNormalize(
    const CvArr* src,
    CvArr* dst,
    double a = 1.,
    double b = 0.,
    int norm_type = 4,
    const CvArr* mask = NULL
    );

void
cvNot(
    const CvArr* src,
    CvArr* dst
    );

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

CvFileStorage*
cvOpenFileStorage(
    const char* filename,
    CvMemStorage* memstorage,
    int flags,
    const char* encoding = NULL
    );

void
cvOr(
    const CvArr* src1,
    const CvArr* src2,
    CvArr* dst,
    const CvArr* mask = NULL
    );

void
cvOrS(
    const CvArr* src,
    CvScalar value,
    CvArr* dst,
    const CvArr* mask = NULL
    );

void
cvPerspectiveTransform(
    const CvArr* src,
    CvArr* dst,
    const CvMat* mat
    );

void
cvPolarToCart(
    const CvArr* magnitude,
    const CvArr* angle,
    CvArr* x,
    CvArr* y,
    int angle_in_degrees = 0
    );

void
cvPow(
    const CvArr* src,
    CvArr* dst,
    double power
    );

void*
cvPrevTreeNode(CvTreeNodeIterator* tree_iterator);

void
cvProjectPCA(
    const CvArr* data,
    const CvArr* mean,
    const CvArr* eigenvects,
    CvArr* result
    );

uchar*
cvPtr1D(
    const CvArr* arr,
    int idx0,
    int* type = NULL
    );

uchar*
cvPtr2D(
    const CvArr* arr,
    int idx0,
    int idx1,
    int* type = NULL
    );

uchar*
cvPtr3D(
    const CvArr* arr,
    int idx0,
    int idx1,
    int idx2,
    int* type = NULL
    );

uchar*
cvPtrND(
    const CvArr* arr,
    const int* idx,
    int* type = NULL,
    int create_node = 1,
    unsigned* precalc_hashval = NULL
    );

void
cvRandArr(
    CvRNG* rng,
    CvArr* arr,
    int dist_type,
    CvScalar param1,
    CvScalar param2
    );

void
cvRandShuffle(
    CvArr* mat,
    CvRNG* rng,
    double iter_factor = 1.
    );

CvArr*
cvRange(
    CvArr* mat,
    double start,
    double end
    );

void
cvRawDataToScalar(
    const void* data,
    int type,
    CvScalar* scalar
    );

void*
cvRead(
    CvFileStorage* fs,
    CvFileNode* node,
    CvAttrList* attributes = NULL
    );

void*
cvReadByName(
    CvFileStorage* fs,
    const CvFileNode* map,
    const char* name,
    CvAttrList* attributes = NULL
    );

int
cvReadInt(
    const CvFileNode* node,
    int default_value = 0
    );

int
cvReadIntByName(
    const CvFileStorage* fs,
    const CvFileNode* map,
    const char* name,
    int default_value = 0
    );

void
cvReadRawData(
    const CvFileStorage* fs,
    const CvFileNode* src,
    void* dst,
    const char* dt
    );

void
cvReadRawDataSlice(
    const CvFileStorage* fs,
    CvSeqReader* reader,
    int count,
    void* dst,
    const char* dt
    );

double
cvReadReal(
    const CvFileNode* node,
    double default_value = 0.
    );

double
cvReadRealByName(
    const CvFileStorage* fs,
    const CvFileNode* map,
    const char* name,
    double default_value = 0.
    );

const char*
cvReadString(
    const CvFileNode* node,
    const char* default_value = NULL
    );

const char*
cvReadStringByName(
    const CvFileStorage* fs,
    const CvFileNode* map,
    const char* name,
    const char* default_value = NULL
    );

CvErrorCallback
cvRedirectError(
    CvErrorCallback error_handler,
    void* userdata = NULL,
    void** prev_userdata = NULL
    );

void
cvReduce(
    const CvArr* src,
    CvArr* dst,
    int dim = -1,
    int op = 0
    );

void
cvRegisterType(const CvTypeInfo* info);

void
cvRelease(void** struct_ptr);

void
cvReleaseData(CvArr* arr);

void
cvReleaseFileStorage(CvFileStorage** fs);

void
cvReleaseGraphScanner(CvGraphScanner** scanner);

void
cvReleaseImage(IplImage** image);

void
cvReleaseImageHeader(IplImage** image);

void
cvReleaseMat(CvMat** mat);

void
cvReleaseMatND(CvMatND** mat);

void
cvReleaseMemStorage(CvMemStorage** storage);

void
cvReleaseSparseMat(CvSparseMat** mat);

void
cvRemoveNodeFromTree(
    void* node,
    void* frame
    );

void
cvRepeat(
    const CvArr* src,
    CvArr* dst
    );

void
cvResetImageROI(IplImage* image);

CvMat*
cvReshape(
    const CvArr* arr,
    CvMat* header,
    int new_cn,
    int new_rows = 0
    );

CvArr*
cvReshapeMatND(
    const CvArr* arr,
    int sizeof_header,
    CvArr* header,
    int new_cn,
    int new_dims,
    int* new_sizes
    );

void
cvRestoreMemStoragePos(
    CvMemStorage* storage,
    CvMemStoragePos* pos
    );

void
cvSave(
    const char* filename,
    const void* struct_ptr,
    const char* name = NULL,
    const char* comment = NULL,
    CvAttrList attributes = cvAttrList()
    );

void
cvSaveMemStoragePos(
    const CvMemStorage* storage,
    CvMemStoragePos* pos
    );

void
cvScalarToRawData(
    const CvScalar* scalar,
    void* data,
    int type,
    int extend_to_12 = 0
    );

void
cvScaleAdd(
    const CvArr* src1,
    CvScalar scale,
    const CvArr* src2,
    CvArr* dst
    );

int
cvSeqElemIdx(
    const CvSeq* seq,
    const void* element,
    CvSeqBlock** block = NULL
    );

schar*
cvSeqInsert(
    CvSeq* seq,
    int before_index,
    const void* element = NULL
    );

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

void
cvSeqInvert(CvSeq* seq);

int
cvSeqPartition(
    const CvSeq* seq,
    CvMemStorage* storage,
    CvSeq** labels,
    CvCmpFunc is_equal,
    void* userdata
    );

void
cvSeqPop(
    CvSeq* seq,
    void* element = NULL
    );

void
cvSeqPopFront(
    CvSeq* seq,
    void* element = NULL
    );

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

schar*
cvSeqPush(
    CvSeq* seq,
    const void* element = NULL
    );

schar*
cvSeqPushFront(
    CvSeq* seq,
    const void* element = NULL
    );

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

void
cvSeqRemove(
    CvSeq* seq,
    int index
    );

void
cvSeqRemoveSlice(
    CvSeq* seq,
    CvSlice slice
    );

schar*
cvSeqSearch(
    CvSeq* seq,
    const void* elem,
    CvCmpFunc func,
    int is_sorted,
    int* elem_idx,
    void* userdata = NULL
    );

CvSeq*
cvSeqSlice(
    const CvSeq* seq,
    CvSlice slice,
    CvMemStorage* storage = NULL,
    int copy_data = 0
    );

void
cvSeqSort(
    CvSeq* seq,
    CvCmpFunc func,
    void* userdata = NULL
    );

void
cvSet(
    CvArr* arr,
    CvScalar value,
    const CvArr* mask = NULL
    );

void
cvSet1D(
    CvArr* arr,
    int idx0,
    CvScalar value
    );

void
cvSet2D(
    CvArr* arr,
    int idx0,
    int idx1,
    CvScalar value
    );

void
cvSet3D(
    CvArr* arr,
    int idx0,
    int idx1,
    int idx2,
    CvScalar value
    );

int
cvSetAdd(
    CvSet* set_header,
    CvSetElem* elem = NULL,
    CvSetElem** inserted_elem = NULL
    );

void
cvSetData(
    CvArr* arr,
    void* data,
    int step
    );

int
cvSetErrMode(int mode);

void
cvSetErrStatus(int status);

void
cvSetIdentity(
    CvArr* mat,
    CvScalar value = cvRealScalar(1)
    );

void
cvSetImageCOI(
    IplImage* image,
    int coi
    );

void
cvSetImageROI(
    IplImage* image,
    CvRect rect
    );

void
cvSetIPLAllocators(
    Cv_iplCreateImageHeader create_header,
    Cv_iplAllocateImageData allocate_data,
    Cv_iplDeallocate deallocate,
    Cv_iplCreateROI create_roi,
    Cv_iplCloneImage clone_image
    );

void
cvSetND(
    CvArr* arr,
    const int* idx,
    CvScalar value
    );

CvSetElem*
cvSetNew(CvSet* set_header);

void
cvSetNumThreads(int threads = 0);

void
cvSetReal1D(
    CvArr* arr,
    int idx0,
    double value
    );

void
cvSetReal2D(
    CvArr* arr,
    int idx0,
    int idx1,
    double value
    );

void
cvSetReal3D(
    CvArr* arr,
    int idx0,
    int idx1,
    int idx2,
    double value
    );

void
cvSetRealND(
    CvArr* arr,
    const int* idx,
    double value
    );

void
cvSetRemove(
    CvSet* set_header,
    int index
    );

void
cvSetRemoveByPtr(
    CvSet* set_header,
    void* elem
    );

void
cvSetSeqBlockSize(
    CvSeq* seq,
    int delta_elems
    );

void
cvSetSeqReaderPos(
    CvSeqReader* reader,
    int index,
    int is_relative = 0
    );

void
cvSetZero(CvArr* arr);

int
cvSliceLength(
    CvSlice slice,
    const CvSeq* seq
    );

int
cvSolve(
    const CvArr* src1,
    const CvArr* src2,
    CvArr* dst,
    int method = 0
    );

int
cvSolveCubic(
    const CvMat* coeffs,
    CvMat* roots
    );

void
cvSolvePoly(
    const CvMat* coeffs,
    CvMat* roots2,
    int maxiter = 20,
    int fig = 100
    );

void
cvSort(
    const CvArr* src,
    CvArr* dst = NULL,
    CvArr* idxmat = NULL,
    int flags = 0
    );

void
cvSplit(
    const CvArr* src,
    CvArr* dst0,
    CvArr* dst1,
    CvArr* dst2,
    CvArr* dst3
    );

void
cvStartAppendToSeq(
    CvSeq* seq,
    CvSeqWriter* writer
    );

void
cvStartNextStream(CvFileStorage* fs);

void
cvStartReadRawData(
    const CvFileStorage* fs,
    const CvFileNode* src,
    CvSeqReader* reader
    );

void
cvStartReadSeq(
    const CvSeq* seq,
    CvSeqReader* reader,
    int reverse = 0
    );

void
cvStartWriteSeq(
    int seq_flags,
    int header_size,
    int elem_size,
    CvMemStorage* storage,
    CvSeqWriter* writer
    );

void
cvStartWriteStruct(
    CvFileStorage* fs,
    const char* name,
    int struct_flags,
    const char* type_name = NULL,
    CvAttrList attributes = cvAttrList()
    );

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

void
cvSub(
    const CvArr* src1,
    const CvArr* src2,
    CvArr* dst,
    const CvArr* mask = NULL
    );

void
cvSubRS(
    const CvArr* src,
    CvScalar value,
    CvArr* dst,
    const CvArr* mask = NULL
    );

void
cvSubS(
    const CvArr* src,
    CvScalar value,
    CvArr* dst,
    const CvArr* mask = NULL
    );

CvScalar
cvSum(const CvArr* arr);

void
cvSVBkSb(
    const CvArr* W,
    const CvArr* U,
    const CvArr* V,
    const CvArr* B,
    CvArr* X,
    int flags
    );

void
cvSVD(
    CvArr* A,
    CvArr* W,
    CvArr* U = NULL,
    CvArr* V = NULL,
    int flags = 0
    );

CvScalar
cvTrace(const CvArr* mat);

void
cvTransform(
    const CvArr* src,
    CvArr* dst,
    const CvMat* transmat,
    const CvMat* shiftvec = NULL
    );

void
cvTranspose(
    const CvArr* src,
    CvArr* dst
    );

CvSeq*
cvTreeToNodeSeq(
    const void* first,
    int header_size,
    CvMemStorage* storage
    );

CvTypeInfo*
cvTypeOf(const void* struct_ptr);

void
cvUnregisterType(const char* type_name);

int
cvUseOptimized(int on_off);

void
cvWrite(
    CvFileStorage* fs,
    const char* name,
    const void* ptr,
    CvAttrList attributes = cvAttrList()
    );

void
cvWriteComment(
    CvFileStorage* fs,
    const char* comment,
    int eol_comment
    );

void
cvWriteFileNode(
    CvFileStorage* fs,
    const char* new_node_name,
    const CvFileNode* node,
    int embed
    );

void
cvWriteInt(
    CvFileStorage* fs,
    const char* name,
    int value
    );

void
cvWriteRawData(
    CvFileStorage* fs,
    const void* src,
    int len,
    const char* dt
    );

void
cvWriteRawDataBase64(
    CvFileStorage* fs,
    const void* src,
    int len,
    const char* dt
    );

void
cvWriteReal(
    CvFileStorage* fs,
    const char* name,
    double value
    );

void
cvWriteString(
    CvFileStorage* fs,
    const char* name,
    const char* str,
    int quote = 0
    );

void
cvXor(
    const CvArr* src1,
    const CvArr* src2,
    CvArr* dst,
    const CvArr* mask = NULL
    );

void
cvXorS(
    const CvArr* src,
    CvScalar value,
    CvArr* dst,
    const CvArr* mask = NULL
    );

CV_XADD(
    int* addr,
    int delta
    );

int
cvCeil(double value);

int
cvCeil(float value);

int
cvCeil(int value);

int
cvFloor(double value);

int
cvFloor(float value);

int
cvFloor(int value);

int
cvIsInf(double value);

int
cvIsInf(float value);

int
cvIsNaN(double value);

int
cvIsNaN(float value);

int
cvRound(double value);

int
cvRound(float value);

int
cvRound(int value);

float32x2_t
cv_vrecp_f32(float32x2_t val);

float32x4_t
cv_vrecpq_f32(float32x4_t val);

int32x2_t
cv_vrnd_s32_f32(float32x2_t v);

uint32x2_t
cv_vrnd_u32_f32(float32x2_t v);

int32x4_t
cv_vrndq_s32_f32(float32x4_t v);

uint32x4_t
cv_vrndq_u32_f32(float32x4_t v);

float32x2_t
cv_vrsqrt_f32(float32x2_t val);

float32x4_t
cv_vrsqrtq_f32(float32x4_t val);

float32x2_t
cv_vsqrt_f32(float32x2_t val);

float32x4_t
cv_vsqrtq_f32(float32x4_t val);

CL_RUNTIME_EXPORT const cl_device_id const char void void*CL_RUNTIME_EXPORT const cl_device_id const char const cl_program const char void void*CL_RUNTIME_EXPORT void cl_int*CL_RUNTIME_EXPORT
cl_command_queue(CL_API_CALL* clCreateCommandQueue_pfn);

CL_RUNTIME_EXPORT const cl_device_id const char void void*CL_RUNTIME_EXPORT const cl_device_id const char const cl_program const char void void*CL_RUNTIME_EXPORT void cl_int*CL_RUNTIME_EXPORT cl_int*CL_RUNTIME_EXPORT
cl_context(CL_API_CALL* clCreateContext_pfn) const;

CL_RUNTIME_EXPORT const cl_device_id const char void void*CL_RUNTIME_EXPORT const cl_device_id const char const cl_program const char void void*CL_RUNTIME_EXPORT void cl_int*CL_RUNTIME_EXPORT cl_int*CL_RUNTIME_EXPORT const cl_device_id const void void void cl_int*CL_RUNTIME_EXPORT const void void void cl_int*CL_RUNTIME_EXPORT const cl_image_format const cl_image_desc void cl_int*CL_RUNTIME_EXPORT const cl_image_format void cl_int*CL_RUNTIME_EXPORT const cl_image_format void cl_int*CL_RUNTIME_EXPORT const char cl_int*CL_RUNTIME_EXPORT cl_kernel cl_uint*CL_RUNTIME_EXPORT const cl_device_id const size_t const unsigned char cl_int cl_int*CL_RUNTIME_EXPORT const cl_device_id const char cl_int*CL_RUNTIME_EXPORT const char const size_t cl_int*CL_RUNTIME_EXPORT cl_int*CL_RUNTIME_EXPORT const void cl_int*CL_RUNTIME_EXPORT const cl_device_partition_property cl_device_id cl_uint*CL_RUNTIME_EXPORT
cl_event(CL_API_CALL* clCreateUserEvent_pfn);

CL_RUNTIME_EXPORT
cl_int(CL_API_CALL* clBuildProgram_pfn);

CL_RUNTIME_EXPORT const cl_device_id const char void void*CL_RUNTIME_EXPORT const cl_device_id const char const cl_program const char void void*CL_RUNTIME_EXPORT void cl_int*CL_RUNTIME_EXPORT cl_int*CL_RUNTIME_EXPORT const cl_device_id const void void void cl_int*CL_RUNTIME_EXPORT const void void void cl_int*CL_RUNTIME_EXPORT const cl_image_format const cl_image_desc void cl_int*CL_RUNTIME_EXPORT const cl_image_format void cl_int*CL_RUNTIME_EXPORT const cl_image_format void cl_int*CL_RUNTIME_EXPORT
cl_kernel(CL_API_CALL* clCreateKernel_pfn);

CL_RUNTIME_EXPORT const cl_device_id const char void void*CL_RUNTIME_EXPORT const cl_device_id const char const cl_program const char void void*CL_RUNTIME_EXPORT
cl_mem(CL_API_CALL* clCreateBuffer_pfn);

CL_RUNTIME_EXPORT const cl_device_id const char void void*CL_RUNTIME_EXPORT const cl_device_id const char const cl_program const char void void*CL_RUNTIME_EXPORT void cl_int*CL_RUNTIME_EXPORT cl_int*CL_RUNTIME_EXPORT const cl_device_id const void void void cl_int*CL_RUNTIME_EXPORT const void void void cl_int*CL_RUNTIME_EXPORT const cl_image_format const cl_image_desc void cl_int*CL_RUNTIME_EXPORT const cl_image_format void cl_int*CL_RUNTIME_EXPORT const cl_image_format void cl_int*CL_RUNTIME_EXPORT const char cl_int*CL_RUNTIME_EXPORT cl_kernel cl_uint*CL_RUNTIME_EXPORT
cl_program(CL_API_CALL* clCreateProgramWithBinary_pfn);

CL_RUNTIME_EXPORT const cl_device_id const char void void*CL_RUNTIME_EXPORT const cl_device_id const char const cl_program const char void void*CL_RUNTIME_EXPORT void cl_int*CL_RUNTIME_EXPORT cl_int*CL_RUNTIME_EXPORT const cl_device_id const void void void cl_int*CL_RUNTIME_EXPORT const void void void cl_int*CL_RUNTIME_EXPORT const cl_image_format const cl_image_desc void cl_int*CL_RUNTIME_EXPORT const cl_image_format void cl_int*CL_RUNTIME_EXPORT const cl_image_format void cl_int*CL_RUNTIME_EXPORT const char cl_int*CL_RUNTIME_EXPORT cl_kernel cl_uint*CL_RUNTIME_EXPORT const cl_device_id const size_t const unsigned char cl_int cl_int*CL_RUNTIME_EXPORT const cl_device_id const char cl_int*CL_RUNTIME_EXPORT const char const size_t cl_int*CL_RUNTIME_EXPORT
cl_sampler(CL_API_CALL* clCreateSampler_pfn);

CL_RUNTIME_EXPORT const cl_event cl_event*CL_RUNTIME_EXPORT const cl_event cl_event*CL_RUNTIME_EXPORT const size_t const size_t const size_t const cl_event cl_event*CL_RUNTIME_EXPORT const size_t const size_t const cl_event cl_event*CL_RUNTIME_EXPORT const size_t const size_t const size_t const cl_event cl_event*CL_RUNTIME_EXPORT const size_t const size_t const cl_event cl_event*CL_RUNTIME_EXPORT const void const cl_event cl_event*CL_RUNTIME_EXPORT const void const size_t const size_t const cl_event cl_event*CL_RUNTIME_EXPORT void*CL_API_CALL*
clEnqueueMapBuffer_pfn(
    cl_command_queue,
    cl_mem,
    cl_bool,
    cl_map_flags,
    size_t,
    size_t,
    cl_uint,
    const cl_event*,
    cl_event*,
    cl_int*
    );

CL_RUNTIME_EXPORT void*CL_API_CALL*
clEnqueueMapImage_pfn(
    cl_command_queue,
    cl_mem,
    cl_bool,
    cl_map_flags,
    const size_t*,
    const size_t*,
    size_t*,
    size_t*,
    cl_uint,
    const cl_event*,
    cl_event*,
    cl_int*
    );

CL_RUNTIME_EXPORT void size_t*CL_RUNTIME_EXPORT void size_t*CL_RUNTIME_EXPORT cl_device_id cl_uint*CL_RUNTIME_EXPORT void size_t*CL_RUNTIME_EXPORT void size_t*CL_RUNTIME_EXPORT void size_t*CL_RUNTIME_EXPORT void*CL_API_CALL*
clGetExtensionFunctionAddress_pfn(const char*);

CL_RUNTIME_EXPORT void*CL_API_CALL*
clGetExtensionFunctionAddressForPlatform_pfn(
    cl_platform_id,
    const char*
    );

cl_int
clBuildProgram_fn(
    cl_program p0,
    cl_uint p1,
    const cl_device_id* p2,
    const char* p3,
    void(CL_CALLBACK*p4)(cl_program, void*),
    void* p5
    );

cl_int
clCompileProgram_fn(
    cl_program p0,
    cl_uint p1,
    const cl_device_id* p2,
    const char* p3,
    cl_uint p4,
    const cl_program* p5,
    const char** p6,
    void(CL_CALLBACK*p7)(cl_program, void*),
    void* p8
    );

cl_mem
clCreateBuffer_fn(
    cl_context p0,
    cl_mem_flags p1,
    size_t p2,
    void* p3,
    cl_int* p4
    );

cl_command_queue
clCreateCommandQueue_fn(
    cl_context p0,
    cl_device_id p1,
    cl_command_queue_properties p2,
    cl_int* p3
    );

cl_context
clCreateContext_fn(
    const cl_context_properties* p0,
    cl_uint p1,
    const cl_device_id* p2,
    void(CL_CALLBACK*p3)(const char*, const void*, size_t, void*),
    void* p4,
    cl_int* p5
    );

cl_context
clCreateContextFromType_fn(
    const cl_context_properties* p0,
    cl_device_type p1,
    void(CL_CALLBACK*p2)(const char*, const void*, size_t, void*),
    void* p3,
    cl_int* p4
    );

cl_mem
clCreateImage2D_fn(
    cl_context p0,
    cl_mem_flags p1,
    const cl_image_format* p2,
    size_t p3,
    size_t p4,
    size_t p5,
    void* p6,
    cl_int* p7
    );

cl_mem
clCreateImage3D_fn(
    cl_context p0,
    cl_mem_flags p1,
    const cl_image_format* p2,
    size_t p3,
    size_t p4,
    size_t p5,
    size_t p6,
    size_t p7,
    void* p8,
    cl_int* p9
    );

cl_mem
clCreateImage_fn(
    cl_context p0,
    cl_mem_flags p1,
    const cl_image_format* p2,
    const cl_image_desc* p3,
    void* p4,
    cl_int* p5
    );

cl_kernel
clCreateKernel_fn(
    cl_program p0,
    const char* p1,
    cl_int* p2
    );

cl_int
clCreateKernelsInProgram_fn(
    cl_program p0,
    cl_uint p1,
    cl_kernel* p2,
    cl_uint* p3
    );

cl_program
clCreateProgramWithBinary_fn(
    cl_context p0,
    cl_uint p1,
    const cl_device_id* p2,
    const size_t* p3,
    const unsigned char** p4,
    cl_int* p5,
    cl_int* p6
    );

cl_program
clCreateProgramWithBuiltInKernels_fn(
    cl_context p0,
    cl_uint p1,
    const cl_device_id* p2,
    const char* p3,
    cl_int* p4
    );

cl_program
clCreateProgramWithSource_fn(
    cl_context p0,
    cl_uint p1,
    const char** p2,
    const size_t* p3,
    cl_int* p4
    );

cl_sampler
clCreateSampler_fn(
    cl_context p0,
    cl_bool p1,
    cl_addressing_mode p2,
    cl_filter_mode p3,
    cl_int* p4
    );

cl_mem
clCreateSubBuffer_fn(
    cl_mem p0,
    cl_mem_flags p1,
    cl_buffer_create_type p2,
    const void* p3,
    cl_int* p4
    );

cl_int
clCreateSubDevices_fn(
    cl_device_id p0,
    const cl_device_partition_property* p1,
    cl_uint p2,
    cl_device_id* p3,
    cl_uint* p4
    );

cl_event
clCreateUserEvent_fn(
    cl_context p0,
    cl_int* p1
    );

cl_int
clEnqueueBarrier_fn(cl_command_queue p0);

cl_int
clEnqueueBarrierWithWaitList_fn(
    cl_command_queue p0,
    cl_uint p1,
    const cl_event* p2,
    cl_event* p3
    );

cl_int
clEnqueueCopyBuffer_fn(
    cl_command_queue p0,
    cl_mem p1,
    cl_mem p2,
    size_t p3,
    size_t p4,
    size_t p5,
    cl_uint p6,
    const cl_event* p7,
    cl_event* p8
    );

cl_int
clEnqueueCopyBufferRect_fn(
    cl_command_queue p0,
    cl_mem p1,
    cl_mem p2,
    const size_t* p3,
    const size_t* p4,
    const size_t* p5,
    size_t p6,
    size_t p7,
    size_t p8,
    size_t p9,
    cl_uint p10,
    const cl_event* p11,
    cl_event* p12
    );

cl_int
clEnqueueCopyBufferToImage_fn(
    cl_command_queue p0,
    cl_mem p1,
    cl_mem p2,
    size_t p3,
    const size_t* p4,
    const size_t* p5,
    cl_uint p6,
    const cl_event* p7,
    cl_event* p8
    );

cl_int
clEnqueueCopyImage_fn(
    cl_command_queue p0,
    cl_mem p1,
    cl_mem p2,
    const size_t* p3,
    const size_t* p4,
    const size_t* p5,
    cl_uint p6,
    const cl_event* p7,
    cl_event* p8
    );

cl_int
clEnqueueCopyImageToBuffer_fn(
    cl_command_queue p0,
    cl_mem p1,
    cl_mem p2,
    const size_t* p3,
    const size_t* p4,
    size_t p5,
    cl_uint p6,
    const cl_event* p7,
    cl_event* p8
    );

cl_int
clEnqueueFillBuffer_fn(
    cl_command_queue p0,
    cl_mem p1,
    const void* p2,
    size_t p3,
    size_t p4,
    size_t p5,
    cl_uint p6,
    const cl_event* p7,
    cl_event* p8
    );

cl_int
clEnqueueFillImage_fn(
    cl_command_queue p0,
    cl_mem p1,
    const void* p2,
    const size_t* p3,
    const size_t* p4,
    cl_uint p5,
    const cl_event* p6,
    cl_event* p7
    );

void*
clEnqueueMapBuffer_fn(
    cl_command_queue p0,
    cl_mem p1,
    cl_bool p2,
    cl_map_flags p3,
    size_t p4,
    size_t p5,
    cl_uint p6,
    const cl_event* p7,
    cl_event* p8,
    cl_int* p9
    );

void*
clEnqueueMapImage_fn(
    cl_command_queue p0,
    cl_mem p1,
    cl_bool p2,
    cl_map_flags p3,
    const size_t* p4,
    const size_t* p5,
    size_t* p6,
    size_t* p7,
    cl_uint p8,
    const cl_event* p9,
    cl_event* p10,
    cl_int* p11
    );

cl_int
clEnqueueMarker_fn(
    cl_command_queue p0,
    cl_event* p1
    );

cl_int
clEnqueueMarkerWithWaitList_fn(
    cl_command_queue p0,
    cl_uint p1,
    const cl_event* p2,
    cl_event* p3
    );

cl_int
clEnqueueMigrateMemObjects_fn(
    cl_command_queue p0,
    cl_uint p1,
    const cl_mem* p2,
    cl_mem_migration_flags p3,
    cl_uint p4,
    const cl_event* p5,
    cl_event* p6
    );

cl_int
clEnqueueNativeKernel_fn(
    cl_command_queue p0,
    void(CL_CALLBACK*p1)(void*),
    void* p2,
    size_t p3,
    cl_uint p4,
    const cl_mem* p5,
    const void** p6,
    cl_uint p7,
    const cl_event* p8,
    cl_event* p9
    );

cl_int
clEnqueueNDRangeKernel_fn(
    cl_command_queue p0,
    cl_kernel p1,
    cl_uint p2,
    const size_t* p3,
    const size_t* p4,
    const size_t* p5,
    cl_uint p6,
    const cl_event* p7,
    cl_event* p8
    );

cl_int
clEnqueueReadBuffer_fn(
    cl_command_queue p0,
    cl_mem p1,
    cl_bool p2,
    size_t p3,
    size_t p4,
    void* p5,
    cl_uint p6,
    const cl_event* p7,
    cl_event* p8
    );

cl_int
clEnqueueReadBufferRect_fn(
    cl_command_queue p0,
    cl_mem p1,
    cl_bool p2,
    const size_t* p3,
    const size_t* p4,
    const size_t* p5,
    size_t p6,
    size_t p7,
    size_t p8,
    size_t p9,
    void* p10,
    cl_uint p11,
    const cl_event* p12,
    cl_event* p13
    );

cl_int
clEnqueueReadImage_fn(
    cl_command_queue p0,
    cl_mem p1,
    cl_bool p2,
    const size_t* p3,
    const size_t* p4,
    size_t p5,
    size_t p6,
    void* p7,
    cl_uint p8,
    const cl_event* p9,
    cl_event* p10
    );

cl_int
clEnqueueTask_fn(
    cl_command_queue p0,
    cl_kernel p1,
    cl_uint p2,
    const cl_event* p3,
    cl_event* p4
    );

cl_int
clEnqueueUnmapMemObject_fn(
    cl_command_queue p0,
    cl_mem p1,
    void* p2,
    cl_uint p3,
    const cl_event* p4,
    cl_event* p5
    );

cl_int
clEnqueueWaitForEvents_fn(
    cl_command_queue p0,
    cl_uint p1,
    const cl_event* p2
    );

cl_int
clEnqueueWriteBuffer_fn(
    cl_command_queue p0,
    cl_mem p1,
    cl_bool p2,
    size_t p3,
    size_t p4,
    const void* p5,
    cl_uint p6,
    const cl_event* p7,
    cl_event* p8
    );

cl_int
clEnqueueWriteBufferRect_fn(
    cl_command_queue p0,
    cl_mem p1,
    cl_bool p2,
    const size_t* p3,
    const size_t* p4,
    const size_t* p5,
    size_t p6,
    size_t p7,
    size_t p8,
    size_t p9,
    const void* p10,
    cl_uint p11,
    const cl_event* p12,
    cl_event* p13
    );

cl_int
clEnqueueWriteImage_fn(
    cl_command_queue p0,
    cl_mem p1,
    cl_bool p2,
    const size_t* p3,
    const size_t* p4,
    size_t p5,
    size_t p6,
    const void* p7,
    cl_uint p8,
    const cl_event* p9,
    cl_event* p10
    );

cl_int
clFinish_fn(cl_command_queue p0);

cl_int
clFlush_fn(cl_command_queue p0);

cl_int
clGetCommandQueueInfo_fn(
    cl_command_queue p0,
    cl_command_queue_info p1,
    size_t p2,
    void* p3,
    size_t* p4
    );

cl_int
clGetContextInfo_fn(
    cl_context p0,
    cl_context_info p1,
    size_t p2,
    void* p3,
    size_t* p4
    );

cl_int
clGetDeviceIDs_fn(
    cl_platform_id p0,
    cl_device_type p1,
    cl_uint p2,
    cl_device_id* p3,
    cl_uint* p4
    );

cl_int
clGetDeviceInfo_fn(
    cl_device_id p0,
    cl_device_info p1,
    size_t p2,
    void* p3,
    size_t* p4
    );

cl_int
clGetEventInfo_fn(
    cl_event p0,
    cl_event_info p1,
    size_t p2,
    void* p3,
    size_t* p4
    );

cl_int
clGetEventProfilingInfo_fn(
    cl_event p0,
    cl_profiling_info p1,
    size_t p2,
    void* p3,
    size_t* p4
    );

void*
clGetExtensionFunctionAddress_fn(const char* p0);

void*
clGetExtensionFunctionAddressForPlatform_fn(
    cl_platform_id p0,
    const char* p1
    );

cl_int
clGetImageInfo_fn(
    cl_mem p0,
    cl_image_info p1,
    size_t p2,
    void* p3,
    size_t* p4
    );

cl_int
clGetKernelArgInfo_fn(
    cl_kernel p0,
    cl_uint p1,
    cl_kernel_arg_info p2,
    size_t p3,
    void* p4,
    size_t* p5
    );

cl_int
clGetKernelInfo_fn(
    cl_kernel p0,
    cl_kernel_info p1,
    size_t p2,
    void* p3,
    size_t* p4
    );

cl_int
clGetKernelWorkGroupInfo_fn(
    cl_kernel p0,
    cl_device_id p1,
    cl_kernel_work_group_info p2,
    size_t p3,
    void* p4,
    size_t* p5
    );

cl_int
clGetMemObjectInfo_fn(
    cl_mem p0,
    cl_mem_info p1,
    size_t p2,
    void* p3,
    size_t* p4
    );

cl_int
clGetPlatformIDs_fn(
    cl_uint p0,
    cl_platform_id* p1,
    cl_uint* p2
    );

cl_int
clGetPlatformInfo_fn(
    cl_platform_id p0,
    cl_platform_info p1,
    size_t p2,
    void* p3,
    size_t* p4
    );

cl_int
clGetProgramBuildInfo_fn(
    cl_program p0,
    cl_device_id p1,
    cl_program_build_info p2,
    size_t p3,
    void* p4,
    size_t* p5
    );

cl_int
clGetProgramInfo_fn(
    cl_program p0,
    cl_program_info p1,
    size_t p2,
    void* p3,
    size_t* p4
    );

cl_int
clGetSamplerInfo_fn(
    cl_sampler p0,
    cl_sampler_info p1,
    size_t p2,
    void* p3,
    size_t* p4
    );

cl_int
clGetSupportedImageFormats_fn(
    cl_context p0,
    cl_mem_flags p1,
    cl_mem_object_type p2,
    cl_uint p3,
    cl_image_format* p4,
    cl_uint* p5
    );

cl_program
clLinkProgram_fn(
    cl_context p0,
    cl_uint p1,
    const cl_device_id* p2,
    const char* p3,
    cl_uint p4,
    const cl_program* p5,
    void(CL_CALLBACK*p6)(cl_program, void*),
    void* p7,
    cl_int* p8
    );

cl_int
clReleaseCommandQueue_fn(cl_command_queue p0);

cl_int
clReleaseContext_fn(cl_context p0);

cl_int
clReleaseDevice_fn(cl_device_id p0);

cl_int
clReleaseEvent_fn(cl_event p0);

cl_int
clReleaseKernel_fn(cl_kernel p0);

cl_int
clReleaseMemObject_fn(cl_mem p0);

cl_int
clReleaseProgram_fn(cl_program p0);

cl_int
clReleaseSampler_fn(cl_sampler p0);

cl_int
clRetainCommandQueue_fn(cl_command_queue p0);

cl_int
clRetainContext_fn(cl_context p0);

cl_int
clRetainDevice_fn(cl_device_id p0);

cl_int
clRetainEvent_fn(cl_event p0);

cl_int
clRetainKernel_fn(cl_kernel p0);

cl_int
clRetainMemObject_fn(cl_mem p0);

cl_int
clRetainProgram_fn(cl_program p0);

cl_int
clRetainSampler_fn(cl_sampler p0);

cl_int
clSetEventCallback_fn(
    cl_event p0,
    cl_int p1,
    void(CL_CALLBACK*p2)(cl_event, cl_int, void*),
    void* p3
    );

cl_int
clSetKernelArg_fn(
    cl_kernel p0,
    cl_uint p1,
    size_t p2,
    const void* p3
    );

cl_int
clSetMemObjectDestructorCallback_fn(
    cl_mem p0,
    void(CL_CALLBACK*p1)(cl_mem, void*),
    void* p2
    );

cl_int
clSetUserEventStatus_fn(
    cl_event p0,
    cl_int p1
    );

cl_int
clUnloadCompiler_fn();

cl_int
clUnloadPlatformCompiler_fn(cl_platform_id p0);

cl_int
clWaitForEvents_fn(
    cl_uint p0,
    const cl_event* p1
    );

template <
    typename _Tp,
    class _EqPredicate
    >
int
partition(
    const std::vector<_Tp>& _vec,
    std::vector<int>& labels,
    _EqPredicate predicate = _EqPredicate()
    );

int
cvCeil(const cv::softfloat& a);

int
cvCeil(const cv::softdouble& a);

int
cvFloor(const cv::softfloat& a);

int
cvFloor(const cv::softdouble& a);

int
cvRound(const cv::softfloat& a);

int
cvRound(const cv::softdouble& a);

int
cvTrunc(const cv::softfloat& a);

int
cvTrunc(const cv::softdouble& a);

void
_mm_deinterleave_epi16(
    __m128i& v_r0,
    __m128i& v_r1,
    __m128i& v_g0,
    __m128i& v_g1
    );

void
_mm_deinterleave_epi16(
    __m128i& v_r0,
    __m128i& v_r1,
    __m128i& v_g0,
    __m128i& v_g1,
    __m128i& v_b0,
    __m128i& v_b1
    );

void
_mm_deinterleave_epi16(
    __m128i& v_r0,
    __m128i& v_r1,
    __m128i& v_g0,
    __m128i& v_g1,
    __m128i& v_b0,
    __m128i& v_b1,
    __m128i& v_a0,
    __m128i& v_a1
    );

void
_mm_deinterleave_epi8(
    __m128i& v_r0,
    __m128i& v_r1,
    __m128i& v_g0,
    __m128i& v_g1
    );

void
_mm_deinterleave_epi8(
    __m128i& v_r0,
    __m128i& v_r1,
    __m128i& v_g0,
    __m128i& v_g1,
    __m128i& v_b0,
    __m128i& v_b1
    );

void
_mm_deinterleave_epi8(
    __m128i& v_r0,
    __m128i& v_r1,
    __m128i& v_g0,
    __m128i& v_g1,
    __m128i& v_b0,
    __m128i& v_b1,
    __m128i& v_a0,
    __m128i& v_a1
    );

void
_mm_deinterleave_ps(
    __m128& v_r0,
    __m128& v_r1,
    __m128& v_g0,
    __m128& v_g1
    );

void
_mm_deinterleave_ps(
    __m128& v_r0,
    __m128& v_r1,
    __m128& v_g0,
    __m128& v_g1,
    __m128& v_b0,
    __m128& v_b1
    );

void
_mm_deinterleave_ps(
    __m128& v_r0,
    __m128& v_r1,
    __m128& v_g0,
    __m128& v_g1,
    __m128& v_b0,
    __m128& v_b1,
    __m128& v_a0,
    __m128& v_a1
    );

void
_mm_interleave_epi8(
    __m128i& v_r0,
    __m128i& v_r1,
    __m128i& v_g0,
    __m128i& v_g1
    );

void
_mm_interleave_epi8(
    __m128i& v_r0,
    __m128i& v_r1,
    __m128i& v_g0,
    __m128i& v_g1,
    __m128i& v_b0,
    __m128i& v_b1
    );

void
_mm_interleave_epi8(
    __m128i& v_r0,
    __m128i& v_r1,
    __m128i& v_g0,
    __m128i& v_g1,
    __m128i& v_b0,
    __m128i& v_b1,
    __m128i& v_a0,
    __m128i& v_a1
    );

void
_mm_interleave_ps(
    __m128& v_r0,
    __m128& v_r1,
    __m128& v_g0,
    __m128& v_g1
    );

void
_mm_interleave_ps(
    __m128& v_r0,
    __m128& v_r1,
    __m128& v_g0,
    __m128& v_g1,
    __m128& v_b0,
    __m128& v_b1
    );

void
_mm_interleave_ps(
    __m128& v_r0,
    __m128& v_r1,
    __m128& v_g0,
    __m128& v_g1,
    __m128& v_b0,
    __m128& v_b1,
    __m128& v_a0,
    __m128& v_a1
    );

CvAttrList
cvAttrList(
    const char** attr = NULL,
    CvAttrList* next = NULL
    );

CvSparseMat*
cvCreateSparseMat(const cv::SparseMat& m);

int
cvIplDepth(int type);

CvMat
cvMat(
    int rows,
    int cols,
    int type,
    void* data = NULL
    );

double
cvmGet(
    const CvMat* mat,
    int row,
    int col
    );

void
cvmSet(
    CvMat* mat,
    int row,
    int col,
    double value
    );

CvPoint
cvPoint(
    int x,
    int y
    );

CvPoint2D32f
cvPoint2D32f(
    double x,
    double y
    );

CvPoint2D64f
cvPoint2D64f(
    double x,
    double y
    );

CvPoint3D32f
cvPoint3D32f(
    double x,
    double y,
    double z
    );

CvPoint3D64f
cvPoint3D64f(
    double x,
    double y,
    double z
    );

CvPoint
cvPointFrom32f(CvPoint2D32f point);

CvPoint2D32f
cvPointTo32f(CvPoint point);

unsigned
cvRandInt(CvRNG* rng);

double
cvRandReal(CvRNG* rng);

CvScalar
cvRealScalar(double val0);

CvRect
cvRect(
    int x,
    int y,
    int width,
    int height
    );

IplROI
cvRectToROI(
    CvRect rect,
    int coi
    );

CvRNG
cvRNG(int64 seed = -1);

CvRect
cvROIToRect(IplROI roi);

CvScalar
cvScalar(
    double val0,
    double val1 = 0,
    double val2 = 0,
    double val3 = 0
    );

CvScalar
cvScalarAll(double val0123);

CvSize
cvSize(
    int width,
    int height
    );

CvSize2D32f
cvSize2D32f(
    double width,
    double height
    );

CvSlice
cvSlice(
    int start,
    int end
    );

CvTermCriteria
cvTermCriteria(
    int type,
    int max_iter,
    double epsilon
    );

int
hal_ni_absdiff16s(
    const short* src1_data,
    size_t src1_step,
    const short* src2_data,
    size_t src2_step,
    short* dst_data,
    size_t dst_step,
    int width,
    int height
    );

int
hal_ni_absdiff16u(
    const ushort* src1_data,
    size_t src1_step,
    const ushort* src2_data,
    size_t src2_step,
    ushort* dst_data,
    size_t dst_step,
    int width,
    int height
    );

int
hal_ni_absdiff32f(
    const float* src1_data,
    size_t src1_step,
    const float* src2_data,
    size_t src2_step,
    float* dst_data,
    size_t dst_step,
    int width,
    int height
    );

int
hal_ni_absdiff32s(
    const int* src1_data,
    size_t src1_step,
    const int* src2_data,
    size_t src2_step,
    int* dst_data,
    size_t dst_step,
    int width,
    int height
    );

int
hal_ni_absdiff64f(
    const double* src1_data,
    size_t src1_step,
    const double* src2_data,
    size_t src2_step,
    double* dst_data,
    size_t dst_step,
    int width,
    int height
    );

int
hal_ni_absdiff8s(
    const schar* src1_data,
    size_t src1_step,
    const schar* src2_data,
    size_t src2_step,
    schar* dst_data,
    size_t dst_step,
    int width,
    int height
    );

int
hal_ni_absdiff8u(
    const uchar* src1_data,
    size_t src1_step,
    const uchar* src2_data,
    size_t src2_step,
    uchar* dst_data,
    size_t dst_step,
    int width,
    int height
    );

int
hal_ni_add16s(
    const short* src1_data,
    size_t src1_step,
    const short* src2_data,
    size_t src2_step,
    short* dst_data,
    size_t dst_step,
    int width,
    int height
    );

int
hal_ni_add16u(
    const ushort* src1_data,
    size_t src1_step,
    const ushort* src2_data,
    size_t src2_step,
    ushort* dst_data,
    size_t dst_step,
    int width,
    int height
    );

int
hal_ni_add32f(
    const float* src1_data,
    size_t src1_step,
    const float* src2_data,
    size_t src2_step,
    float* dst_data,
    size_t dst_step,
    int width,
    int height
    );

int
hal_ni_add32s(
    const int* src1_data,
    size_t src1_step,
    const int* src2_data,
    size_t src2_step,
    int* dst_data,
    size_t dst_step,
    int width,
    int height
    );

int
hal_ni_add64f(
    const double* src1_data,
    size_t src1_step,
    const double* src2_data,
    size_t src2_step,
    double* dst_data,
    size_t dst_step,
    int width,
    int height
    );

int
hal_ni_add8s(
    const schar* src1_data,
    size_t src1_step,
    const schar* src2_data,
    size_t src2_step,
    schar* dst_data,
    size_t dst_step,
    int width,
    int height
    );

int
hal_ni_add8u(
    const uchar* src1_data,
    size_t src1_step,
    const uchar* src2_data,
    size_t src2_step,
    uchar* dst_data,
    size_t dst_step,
    int width,
    int height
    );

int
hal_ni_addWeighted16s(
    const short* src1_data,
    size_t src1_step,
    const short* src2_data,
    size_t src2_step,
    short* dst_data,
    size_t dst_step,
    int width,
    int height,
    const double scalars [3]
    );

int
hal_ni_addWeighted16u(
    const ushort* src1_data,
    size_t src1_step,
    const ushort* src2_data,
    size_t src2_step,
    ushort* dst_data,
    size_t dst_step,
    int width,
    int height,
    const double scalars [3]
    );

int
hal_ni_addWeighted32f(
    const float* src1_data,
    size_t src1_step,
    const float* src2_data,
    size_t src2_step,
    float* dst_data,
    size_t dst_step,
    int width,
    int height,
    const double scalars [3]
    );

int
hal_ni_addWeighted32s(
    const int* src1_data,
    size_t src1_step,
    const int* src2_data,
    size_t src2_step,
    int* dst_data,
    size_t dst_step,
    int width,
    int height,
    const double scalars [3]
    );

int
hal_ni_addWeighted64f(
    const double* src1_data,
    size_t src1_step,
    const double* src2_data,
    size_t src2_step,
    double* dst_data,
    size_t dst_step,
    int width,
    int height,
    const double scalars [3]
    );

int
hal_ni_addWeighted8s(
    const schar* src1_data,
    size_t src1_step,
    const schar* src2_data,
    size_t src2_step,
    schar* dst_data,
    size_t dst_step,
    int width,
    int height,
    const double scalars [3]
    );

int
hal_ni_addWeighted8u(
    const uchar* src1_data,
    size_t src1_step,
    const uchar* src2_data,
    size_t src2_step,
    uchar* dst_data,
    size_t dst_step,
    int width,
    int height,
    const double scalars [3]
    );

int
hal_ni_and8u(
    const uchar* src1_data,
    size_t src1_step,
    const uchar* src2_data,
    size_t src2_step,
    uchar* dst_data,
    size_t dst_step,
    int width,
    int height
    );

int
hal_ni_Cholesky32f(
    float* src1,
    size_t src1_step,
    int m,
    float* src2,
    size_t src2_step,
    int n,
    bool* info
    );

int
hal_ni_Cholesky64f(
    double* src1,
    size_t src1_step,
    int m,
    double* src2,
    size_t src2_step,
    int n,
    bool* info
    );

int
hal_ni_cmp16s(
    const short* src1_data,
    size_t src1_step,
    const short* src2_data,
    size_t src2_step,
    uchar* dst_data,
    size_t dst_step,
    int width,
    int height,
    int operation
    );

int
hal_ni_cmp16u(
    const ushort* src1_data,
    size_t src1_step,
    const ushort* src2_data,
    size_t src2_step,
    uchar* dst_data,
    size_t dst_step,
    int width,
    int height,
    int operation
    );

int
hal_ni_cmp32f(
    const float* src1_data,
    size_t src1_step,
    const float* src2_data,
    size_t src2_step,
    uchar* dst_data,
    size_t dst_step,
    int width,
    int height,
    int operation
    );

int
hal_ni_cmp32s(
    const int* src1_data,
    size_t src1_step,
    const int* src2_data,
    size_t src2_step,
    uchar* dst_data,
    size_t dst_step,
    int width,
    int height,
    int operation
    );

int
hal_ni_cmp64f(
    const double* src1_data,
    size_t src1_step,
    const double* src2_data,
    size_t src2_step,
    uchar* dst_data,
    size_t dst_step,
    int width,
    int height,
    int operation
    );

int
hal_ni_cmp8s(
    const schar* src1_data,
    size_t src1_step,
    const schar* src2_data,
    size_t src2_step,
    uchar* dst_data,
    size_t dst_step,
    int width,
    int height,
    int operation
    );

int
hal_ni_cmp8u(
    const uchar* src1_data,
    size_t src1_step,
    const uchar* src2_data,
    size_t src2_step,
    uchar* dst_data,
    size_t dst_step,
    int width,
    int height,
    int operation
    );

int
hal_ni_dct2D(
    cvhalDFT* context,
    const uchar* src_data,
    size_t src_step,
    uchar* dst_data,
    size_t dst_step
    );

int
hal_ni_dctFree2D(cvhalDFT* context);

int
hal_ni_dctInit2D(
    cvhalDFT** context,
    int width,
    int height,
    int depth,
    int flags
    );

int
hal_ni_dft1D(
    cvhalDFT* context,
    const uchar* src,
    uchar* dst
    );

int
hal_ni_dft2D(
    cvhalDFT* context,
    const uchar* src_data,
    size_t src_step,
    uchar* dst_data,
    size_t dst_step
    );

int
hal_ni_dftFree1D(cvhalDFT* context);

int
hal_ni_dftFree2D(cvhalDFT* context);

int
hal_ni_dftInit1D(
    cvhalDFT** context,
    int len,
    int count,
    int depth,
    int flags,
    bool* needBuffer
    );

int
hal_ni_dftInit2D(
    cvhalDFT** context,
    int width,
    int height,
    int depth,
    int src_channels,
    int dst_channels,
    int flags,
    int nonzero_rows
    );

int
hal_ni_div16s(
    const short* src1_data,
    size_t src1_step,
    const short* src2_data,
    size_t src2_step,
    short* dst_data,
    size_t dst_step,
    int width,
    int height,
    double scale
    );

int
hal_ni_div16u(
    const ushort* src1_data,
    size_t src1_step,
    const ushort* src2_data,
    size_t src2_step,
    ushort* dst_data,
    size_t dst_step,
    int width,
    int height,
    double scale
    );

int
hal_ni_div32f(
    const float* src1_data,
    size_t src1_step,
    const float* src2_data,
    size_t src2_step,
    float* dst_data,
    size_t dst_step,
    int width,
    int height,
    double scale
    );

int
hal_ni_div32s(
    const int* src1_data,
    size_t src1_step,
    const int* src2_data,
    size_t src2_step,
    int* dst_data,
    size_t dst_step,
    int width,
    int height,
    double scale
    );

int
hal_ni_div64f(
    const double* src1_data,
    size_t src1_step,
    const double* src2_data,
    size_t src2_step,
    double* dst_data,
    size_t dst_step,
    int width,
    int height,
    double scale
    );

int
hal_ni_div8s(
    const schar* src1_data,
    size_t src1_step,
    const schar* src2_data,
    size_t src2_step,
    schar* dst_data,
    size_t dst_step,
    int width,
    int height,
    double scale
    );

int
hal_ni_div8u(
    const uchar* src1_data,
    size_t src1_step,
    const uchar* src2_data,
    size_t src2_step,
    uchar* dst_data,
    size_t dst_step,
    int width,
    int height,
    double scale
    );

int
hal_ni_exp32f(
    const float* src,
    float* dst,
    int len
    );

int
hal_ni_exp64f(
    const double* src,
    double* dst,
    int len
    );

int
hal_ni_fastAtan32f(
    const float* y,
    const float* x,
    float* dst,
    int len,
    bool angleInDegrees
    );

int
hal_ni_fastAtan64f(
    const double* y,
    const double* x,
    double* dst,
    int len,
    bool angleInDegrees
    );

int
hal_ni_gemm32f(
    const float* src1,
    size_t src1_step,
    const float* src2,
    size_t src2_step,
    float alpha,
    const float* src3,
    size_t src3_step,
    float beta,
    float* dst,
    size_t dst_step,
    int m,
    int n,
    int k,
    int flags
    );

int
hal_ni_gemm32fc(
    const float* src1,
    size_t src1_step,
    const float* src2,
    size_t src2_step,
    float alpha,
    const float* src3,
    size_t src3_step,
    float beta,
    float* dst,
    size_t dst_step,
    int m,
    int n,
    int k,
    int flags
    );

int
hal_ni_gemm64f(
    const double* src1,
    size_t src1_step,
    const double* src2,
    size_t src2_step,
    double alpha,
    const double* src3,
    size_t src3_step,
    double beta,
    double* dst,
    size_t dst_step,
    int m,
    int n,
    int k,
    int flags
    );

int
hal_ni_gemm64fc(
    const double* src1,
    size_t src1_step,
    const double* src2,
    size_t src2_step,
    double alpha,
    const double* src3,
    size_t src3_step,
    double beta,
    double* dst,
    size_t dst_step,
    int m,
    int n,
    int k,
    int flags
    );

int
hal_ni_invSqrt32f(
    const float* src,
    float* dst,
    int len
    );

int
hal_ni_invSqrt64f(
    const double* src,
    double* dst,
    int len
    );

int
hal_ni_log32f(
    const float* src,
    float* dst,
    int len
    );

int
hal_ni_log64f(
    const double* src,
    double* dst,
    int len
    );

int
hal_ni_LU32f(
    float* src1,
    size_t src1_step,
    int m,
    float* src2,
    size_t src2_step,
    int n,
    int* info
    );

int
hal_ni_LU64f(
    double* src1,
    size_t src1_step,
    int m,
    double* src2,
    size_t src2_step,
    int n,
    int* info
    );

int
hal_ni_magnitude32f(
    const float* x,
    const float* y,
    float* dst,
    int len
    );

int
hal_ni_magnitude64f(
    const double* x,
    const double* y,
    double* dst,
    int len
    );

int
hal_ni_max16s(
    const short* src1_data,
    size_t src1_step,
    const short* src2_data,
    size_t src2_step,
    short* dst_data,
    size_t dst_step,
    int width,
    int height
    );

int
hal_ni_max16u(
    const ushort* src1_data,
    size_t src1_step,
    const ushort* src2_data,
    size_t src2_step,
    ushort* dst_data,
    size_t dst_step,
    int width,
    int height
    );

int
hal_ni_max32f(
    const float* src1_data,
    size_t src1_step,
    const float* src2_data,
    size_t src2_step,
    float* dst_data,
    size_t dst_step,
    int width,
    int height
    );

int
hal_ni_max32s(
    const int* src1_data,
    size_t src1_step,
    const int* src2_data,
    size_t src2_step,
    int* dst_data,
    size_t dst_step,
    int width,
    int height
    );

int
hal_ni_max64f(
    const double* src1_data,
    size_t src1_step,
    const double* src2_data,
    size_t src2_step,
    double* dst_data,
    size_t dst_step,
    int width,
    int height
    );

int
hal_ni_max8s(
    const schar* src1_data,
    size_t src1_step,
    const schar* src2_data,
    size_t src2_step,
    schar* dst_data,
    size_t dst_step,
    int width,
    int height
    );

int
hal_ni_max8u(
    const uchar* src1_data,
    size_t src1_step,
    const uchar* src2_data,
    size_t src2_step,
    uchar* dst_data,
    size_t dst_step,
    int width,
    int height
    );

int
hal_ni_merge16u(
    const ushort** src_data,
    ushort* dst_data,
    int len,
    int cn
    );

int
hal_ni_merge32s(
    const int** src_data,
    int* dst_data,
    int len,
    int cn
    );

int
hal_ni_merge64s(
    const int64** src_data,
    int64* dst_data,
    int len,
    int cn
    );

int
hal_ni_merge8u(
    const uchar** src_data,
    uchar* dst_data,
    int len,
    int cn
    );

int
hal_ni_min16s(
    const short* src1_data,
    size_t src1_step,
    const short* src2_data,
    size_t src2_step,
    short* dst_data,
    size_t dst_step,
    int width,
    int height
    );

int
hal_ni_min16u(
    const ushort* src1_data,
    size_t src1_step,
    const ushort* src2_data,
    size_t src2_step,
    ushort* dst_data,
    size_t dst_step,
    int width,
    int height
    );

int
hal_ni_min32f(
    const float* src1_data,
    size_t src1_step,
    const float* src2_data,
    size_t src2_step,
    float* dst_data,
    size_t dst_step,
    int width,
    int height
    );

int
hal_ni_min32s(
    const int* src1_data,
    size_t src1_step,
    const int* src2_data,
    size_t src2_step,
    int* dst_data,
    size_t dst_step,
    int width,
    int height
    );

int
hal_ni_min64f(
    const double* src1_data,
    size_t src1_step,
    const double* src2_data,
    size_t src2_step,
    double* dst_data,
    size_t dst_step,
    int width,
    int height
    );

int
hal_ni_min8s(
    const schar* src1_data,
    size_t src1_step,
    const schar* src2_data,
    size_t src2_step,
    schar* dst_data,
    size_t dst_step,
    int width,
    int height
    );

int
hal_ni_min8u(
    const uchar* src1_data,
    size_t src1_step,
    const uchar* src2_data,
    size_t src2_step,
    uchar* dst_data,
    size_t dst_step,
    int width,
    int height
    );

int
hal_ni_mul16s(
    const short* src1_data,
    size_t src1_step,
    const short* src2_data,
    size_t src2_step,
    short* dst_data,
    size_t dst_step,
    int width,
    int height,
    double scale
    );

int
hal_ni_mul16u(
    const ushort* src1_data,
    size_t src1_step,
    const ushort* src2_data,
    size_t src2_step,
    ushort* dst_data,
    size_t dst_step,
    int width,
    int height,
    double scale
    );

int
hal_ni_mul32f(
    const float* src1_data,
    size_t src1_step,
    const float* src2_data,
    size_t src2_step,
    float* dst_data,
    size_t dst_step,
    int width,
    int height,
    double scale
    );

int
hal_ni_mul32s(
    const int* src1_data,
    size_t src1_step,
    const int* src2_data,
    size_t src2_step,
    int* dst_data,
    size_t dst_step,
    int width,
    int height,
    double scale
    );

int
hal_ni_mul64f(
    const double* src1_data,
    size_t src1_step,
    const double* src2_data,
    size_t src2_step,
    double* dst_data,
    size_t dst_step,
    int width,
    int height,
    double scale
    );

int
hal_ni_mul8s(
    const schar* src1_data,
    size_t src1_step,
    const schar* src2_data,
    size_t src2_step,
    schar* dst_data,
    size_t dst_step,
    int width,
    int height,
    double scale
    );

int
hal_ni_mul8u(
    const uchar* src1_data,
    size_t src1_step,
    const uchar* src2_data,
    size_t src2_step,
    uchar* dst_data,
    size_t dst_step,
    int width,
    int height,
    double scale
    );

int
hal_ni_not8u(
    const uchar* src_data,
    size_t src_step,
    uchar* dst_data,
    size_t dst_step,
    int width,
    int height
    );

int
hal_ni_or8u(
    const uchar* src1_data,
    size_t src1_step,
    const uchar* src2_data,
    size_t src2_step,
    uchar* dst_data,
    size_t dst_step,
    int width,
    int height
    );

int
hal_ni_QR32f(
    float* src1,
    size_t src1_step,
    int m,
    int n,
    int k,
    float* src2,
    size_t src2_step,
    float* dst,
    int* info
    );

int
hal_ni_QR64f(
    double* src1,
    size_t src1_step,
    int m,
    int n,
    int k,
    double* src2,
    size_t src2_step,
    double* dst,
    int* info
    );

int
hal_ni_recip16s(
    const short* src_data,
    size_t src_step,
    short* dst_data,
    size_t dst_step,
    int width,
    int height,
    double scale
    );

int
hal_ni_recip16u(
    const ushort* src_data,
    size_t src_step,
    ushort* dst_data,
    size_t dst_step,
    int width,
    int height,
    double scale
    );

int
hal_ni_recip32f(
    const float* src_data,
    size_t src_step,
    float* dst_data,
    size_t dst_step,
    int width,
    int height,
    double scale
    );

int
hal_ni_recip32s(
    const int* src_data,
    size_t src_step,
    int* dst_data,
    size_t dst_step,
    int width,
    int height,
    double scale
    );

int
hal_ni_recip64f(
    const double* src_data,
    size_t src_step,
    double* dst_data,
    size_t dst_step,
    int width,
    int height,
    double scale
    );

int
hal_ni_recip8s(
    const schar* src_data,
    size_t src_step,
    schar* dst_data,
    size_t dst_step,
    int width,
    int height,
    double scale
    );

int
hal_ni_recip8u(
    const uchar* src_data,
    size_t src_step,
    uchar* dst_data,
    size_t dst_step,
    int width,
    int height,
    double scale
    );

int
hal_ni_split16u(
    const ushort* src_data,
    ushort** dst_data,
    int len,
    int cn
    );

int
hal_ni_split32s(
    const int* src_data,
    int** dst_data,
    int len,
    int cn
    );

int
hal_ni_split64s(
    const int64* src_data,
    int64** dst_data,
    int len,
    int cn
    );

int
hal_ni_split8u(
    const uchar* src_data,
    uchar** dst_data,
    int len,
    int cn
    );

int
hal_