packages feed

opencv-raw (empty) → 0.1.0.0

raw patch · 11 files changed

+2929/−0 lines, 11 filesdep +Cabaldep +basedep +bindings-DSLbuild-type:Customsetup-changed

Dependencies added: Cabal, base, bindings-DSL, vector

Files

+ LICENSE view
@@ -0,0 +1,30 @@+Copyright (c) 2013, Arjun Comar++All rights reserved.++Redistribution and use in source and binary forms, with or without+modification, are permitted provided that the following conditions are met:++    * Redistributions of source code must retain the above copyright+      notice, this list of conditions and the following disclaimer.++    * Redistributions in binary form must reproduce the above+      copyright notice, this list of conditions and the following+      disclaimer in the documentation and/or other materials provided+      with the distribution.++    * Neither the name of Arjun Comar nor the names of other+      contributors may be used to endorse or promote products derived+      from this software without specific prior written permission.++THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ OpenCVRaw/Consts.hsc view
@@ -0,0 +1,622 @@+{-# LANGUAGE ForeignFunctionInterface #-}+#include <bindings.dsl.h>+#include <opencv_generated.hpp>+module OpenCVRaw.Consts where+#strict_import+import Foreign.C+import Foreign.C.Types+#num CV_ADAPTIVESKINDETECTOR_MORPHING_METHOD_ERODE0+#num CV_ADAPTIVESKINDETECTOR_MORPHING_METHOD_ERODE_DILATE0+#num CV_ADAPTIVESKINDETECTOR_MORPHING_METHOD_ERODE_ERODE0+#num CV_ADAPTIVESKINDETECTOR_MORPHING_METHOD_NONE0+#num CV_ADAPTIVE_THRESH_GAUSSIAN_C0+#num CV_ADAPTIVE_THRESH_MEAN_C0+#num CV_ANN_MLP_GAUSSIAN0+#num CV_ANN_MLP_IDENTITY0+#num CV_ANN_MLP_NO_INPUT_SCALE0+#num CV_ANN_MLP_NO_OUTPUT_SCALE0+#num CV_ANN_MLP_SIGMOID_SYM0+#num CV_ANN_MLP_TRAINPARAMS_BACKPROP0+#num CV_ANN_MLP_TRAINPARAMS_RPROP0+#num CV_ANN_MLP_UPDATE_WEIGHTS0+#num CV_BOOST_DEFAULT0+#num CV_BOOST_DISCRETE0+#num CV_BOOST_GENTLE0+#num CV_BOOST_GINI0+#num CV_BOOST_LOGIT0+#num CV_BOOST_MISCLASS0+#num CV_BOOST_REAL0+#num CV_BOOST_SQERR0+#num CV_BORDER_CONSTANT0+#num CV_BORDER_DEFAULT0+#num CV_BORDER_ISOLATED0+#num CV_BORDER_REFLECT0+#num CV_BORDER_REFLECT1010+#num CV_BORDER_REFLECT_1010+#num CV_BORDER_REPLICATE0+#num CV_BORDER_TRANSPARENT0+#num CV_BORDER_WRAP0+#num CV_CALIB_CB_ADAPTIVE_THRESH0+#num CV_CALIB_CB_ASYMMETRIC_GRID0+#num CV_CALIB_CB_CLUSTERING0+#num CV_CALIB_CB_FAST_CHECK0+#num CV_CALIB_CB_FILTER_QUADS0+#num CV_CALIB_CB_NORMALIZE_IMAGE0+#num CV_CALIB_CB_SYMMETRIC_GRID0+#num CV_CALIB_FIX_ASPECT_RATIO0+#num CV_CALIB_FIX_FOCAL_LENGTH0+#num CV_CALIB_FIX_INTRINSIC0+#num CV_CALIB_FIX_K10+#num CV_CALIB_FIX_K20+#num CV_CALIB_FIX_K30+#num CV_CALIB_FIX_K40+#num CV_CALIB_FIX_K50+#num CV_CALIB_FIX_K60+#num CV_CALIB_FIX_PRINCIPAL_POINT0+#num CV_CALIB_RATIONAL_MODEL0+#num CV_CALIB_SAME_FOCAL_LENGTH0+#num CV_CALIB_USE_INTRINSIC_GUESS0+#num CV_CALIB_ZERO_DISPARITY0+#num CV_CALIB_ZERO_TANGENT_DIST0+#num CV_CASCADE_DO_CANNY_PRUNING0+#num CV_CASCADE_DO_ROUGH_SEARCH0+#num CV_CASCADE_FIND_BIGGEST_OBJECT0+#num CV_CASCADE_SCALE_IMAGE0+#num CV_CHAIN_APPROX_NONE0+#num CV_CHAIN_APPROX_SIMPLE0+#num CV_CHAIN_APPROX_TC89_KCOS0+#num CV_CHAIN_APPROX_TC89_L10+#num CV_CMP_EQ0+#num CV_CMP_GE0+#num CV_CMP_GT0+#num CV_CMP_LE0+#num CV_CMP_LT0+#num CV_CMP_NE0+#num CV_COLORMAP_AUTUMN0+#num CV_COLORMAP_BONE0+#num CV_COLORMAP_COOL0+#num CV_COLORMAP_HOT0+#num CV_COLORMAP_HSV0+#num CV_COLORMAP_JET0+#num CV_COLORMAP_OCEAN0+#num CV_COLORMAP_PINK0+#num CV_COLORMAP_RAINBOW0+#num CV_COLORMAP_SPRING0+#num CV_COLORMAP_SUMMER0+#num CV_COLORMAP_WINTER0+#num CV_COLOR_BAYERBG2BGR0+#num CV_COLOR_BAYERBG2BGR_VNG0+#num CV_COLOR_BAYERBG2GRAY0+#num CV_COLOR_BAYERBG2RGB0+#num CV_COLOR_BAYERBG2RGB_VNG0+#num CV_COLOR_BAYERGB2BGR0+#num CV_COLOR_BAYERGB2BGR_VNG0+#num CV_COLOR_BAYERGB2GRAY0+#num CV_COLOR_BAYERGB2RGB0+#num CV_COLOR_BAYERGB2RGB_VNG0+#num CV_COLOR_BAYERGR2BGR0+#num CV_COLOR_BAYERGR2BGR_VNG0+#num CV_COLOR_BAYERGR2GRAY0+#num CV_COLOR_BAYERGR2RGB0+#num CV_COLOR_BAYERGR2RGB_VNG0+#num CV_COLOR_BAYERRG2BGR0+#num CV_COLOR_BAYERRG2BGR_VNG0+#num CV_COLOR_BAYERRG2GRAY0+#num CV_COLOR_BAYERRG2RGB0+#num CV_COLOR_BAYERRG2RGB_VNG0+#num CV_COLOR_BGR2BGR5550+#num CV_COLOR_BGR2BGR5650+#num CV_COLOR_BGR2BGRA0+#num CV_COLOR_BGR2GRAY0+#num CV_COLOR_BGR2HLS0+#num CV_COLOR_BGR2HLS_FULL0+#num CV_COLOR_BGR2HSV0+#num CV_COLOR_BGR2HSV_FULL0+#num CV_COLOR_BGR2LAB0+#num CV_COLOR_BGR2LUV0+#num CV_COLOR_BGR2RGB0+#num CV_COLOR_BGR2RGBA0+#num CV_COLOR_BGR2XYZ0+#num CV_COLOR_BGR2YCRCB0+#num CV_COLOR_BGR2YUV0+#num CV_COLOR_BGR2YUV_I4200+#num CV_COLOR_BGR2YUV_IYUV0+#num CV_COLOR_BGR2YUV_YV120+#num CV_COLOR_BGR5552BGR0+#num CV_COLOR_BGR5552BGRA0+#num CV_COLOR_BGR5552GRAY0+#num CV_COLOR_BGR5552RGB0+#num CV_COLOR_BGR5552RGBA0+#num CV_COLOR_BGR5652BGR0+#num CV_COLOR_BGR5652BGRA0+#num CV_COLOR_BGR5652GRAY0+#num CV_COLOR_BGR5652RGB0+#num CV_COLOR_BGR5652RGBA0+#num CV_COLOR_BGRA2BGR0+#num CV_COLOR_BGRA2BGR5550+#num CV_COLOR_BGRA2BGR5650+#num CV_COLOR_BGRA2GRAY0+#num CV_COLOR_BGRA2RGB0+#num CV_COLOR_BGRA2RGBA0+#num CV_COLOR_BGRA2YUV_I4200+#num CV_COLOR_BGRA2YUV_IYUV0+#num CV_COLOR_BGRA2YUV_YV120+#num CV_COLOR_COLORCVT_MAX0+#num CV_COLOR_GRAY2BGR0+#num CV_COLOR_GRAY2BGR5550+#num CV_COLOR_GRAY2BGR5650+#num CV_COLOR_GRAY2BGRA0+#num CV_COLOR_GRAY2RGB0+#num CV_COLOR_GRAY2RGBA0+#num CV_COLOR_HLS2BGR0+#num CV_COLOR_HLS2BGR_FULL0+#num CV_COLOR_HLS2RGB0+#num CV_COLOR_HLS2RGB_FULL0+#num CV_COLOR_HSV2BGR0+#num CV_COLOR_HSV2BGR_FULL0+#num CV_COLOR_HSV2RGB0+#num CV_COLOR_HSV2RGB_FULL0+#num CV_COLOR_LAB2BGR0+#num CV_COLOR_LAB2LBGR0+#num CV_COLOR_LAB2LRGB0+#num CV_COLOR_LAB2RGB0+#num CV_COLOR_LBGR2LAB0+#num CV_COLOR_LBGR2LUV0+#num CV_COLOR_LRGB2LAB0+#num CV_COLOR_LRGB2LUV0+#num CV_COLOR_LUV2BGR0+#num CV_COLOR_LUV2LBGR0+#num CV_COLOR_LUV2LRGB0+#num CV_COLOR_LUV2RGB0+#num CV_COLOR_MRGBA2RGBA0+#num CV_COLOR_RGB2BGR0+#num CV_COLOR_RGB2BGR5550+#num CV_COLOR_RGB2BGR5650+#num CV_COLOR_RGB2BGRA0+#num CV_COLOR_RGB2GRAY0+#num CV_COLOR_RGB2HLS0+#num CV_COLOR_RGB2HLS_FULL0+#num CV_COLOR_RGB2HSV0+#num CV_COLOR_RGB2HSV_FULL0+#num CV_COLOR_RGB2LAB0+#num CV_COLOR_RGB2LUV0+#num CV_COLOR_RGB2RGBA0+#num CV_COLOR_RGB2XYZ0+#num CV_COLOR_RGB2YCRCB0+#num CV_COLOR_RGB2YUV0+#num CV_COLOR_RGB2YUV_I4200+#num CV_COLOR_RGB2YUV_IYUV0+#num CV_COLOR_RGB2YUV_YV120+#num CV_COLOR_RGBA2BGR0+#num CV_COLOR_RGBA2BGR5550+#num CV_COLOR_RGBA2BGR5650+#num CV_COLOR_RGBA2BGRA0+#num CV_COLOR_RGBA2GRAY0+#num CV_COLOR_RGBA2MRGBA0+#num CV_COLOR_RGBA2RGB0+#num CV_COLOR_RGBA2YUV_I4200+#num CV_COLOR_RGBA2YUV_IYUV0+#num CV_COLOR_RGBA2YUV_YV120+#num CV_COLOR_XYZ2BGR0+#num CV_COLOR_XYZ2RGB0+#num CV_COLOR_YCRCB2BGR0+#num CV_COLOR_YCRCB2RGB0+#num CV_COLOR_YUV2BGR0+#num CV_COLOR_YUV2BGRA_I4200+#num CV_COLOR_YUV2BGRA_IYUV0+#num CV_COLOR_YUV2BGRA_NV120+#num CV_COLOR_YUV2BGRA_NV210+#num CV_COLOR_YUV2BGRA_UYNV0+#num CV_COLOR_YUV2BGRA_UYVY0+#num CV_COLOR_YUV2BGRA_Y4220+#num CV_COLOR_YUV2BGRA_YUNV0+#num CV_COLOR_YUV2BGRA_YUY20+#num CV_COLOR_YUV2BGRA_YUYV0+#num CV_COLOR_YUV2BGRA_YV120+#num CV_COLOR_YUV2BGRA_YVYU0+#num CV_COLOR_YUV2BGR_I4200+#num CV_COLOR_YUV2BGR_IYUV0+#num CV_COLOR_YUV2BGR_NV120+#num CV_COLOR_YUV2BGR_NV210+#num CV_COLOR_YUV2BGR_UYNV0+#num CV_COLOR_YUV2BGR_UYVY0+#num CV_COLOR_YUV2BGR_Y4220+#num CV_COLOR_YUV2BGR_YUNV0+#num CV_COLOR_YUV2BGR_YUY20+#num CV_COLOR_YUV2BGR_YUYV0+#num CV_COLOR_YUV2BGR_YV120+#num CV_COLOR_YUV2BGR_YVYU0+#num CV_COLOR_YUV2GRAY_4200+#num CV_COLOR_YUV2GRAY_I4200+#num CV_COLOR_YUV2GRAY_IYUV0+#num CV_COLOR_YUV2GRAY_NV120+#num CV_COLOR_YUV2GRAY_NV210+#num CV_COLOR_YUV2GRAY_UYNV0+#num CV_COLOR_YUV2GRAY_UYVY0+#num CV_COLOR_YUV2GRAY_Y4220+#num CV_COLOR_YUV2GRAY_YUNV0+#num CV_COLOR_YUV2GRAY_YUY20+#num CV_COLOR_YUV2GRAY_YUYV0+#num CV_COLOR_YUV2GRAY_YV120+#num CV_COLOR_YUV2GRAY_YVYU0+#num CV_COLOR_YUV2RGB0+#num CV_COLOR_YUV2RGBA_I4200+#num CV_COLOR_YUV2RGBA_IYUV0+#num CV_COLOR_YUV2RGBA_NV120+#num CV_COLOR_YUV2RGBA_NV210+#num CV_COLOR_YUV2RGBA_UYNV0+#num CV_COLOR_YUV2RGBA_UYVY0+#num CV_COLOR_YUV2RGBA_Y4220+#num CV_COLOR_YUV2RGBA_YUNV0+#num CV_COLOR_YUV2RGBA_YUY20+#num CV_COLOR_YUV2RGBA_YUYV0+#num CV_COLOR_YUV2RGBA_YV120+#num CV_COLOR_YUV2RGBA_YVYU0+#num CV_COLOR_YUV2RGB_I4200+#num CV_COLOR_YUV2RGB_IYUV0+#num CV_COLOR_YUV2RGB_NV120+#num CV_COLOR_YUV2RGB_NV210+#num CV_COLOR_YUV2RGB_UYNV0+#num CV_COLOR_YUV2RGB_UYVY0+#num CV_COLOR_YUV2RGB_Y4220+#num CV_COLOR_YUV2RGB_YUNV0+#num CV_COLOR_YUV2RGB_YUY20+#num CV_COLOR_YUV2RGB_YUYV0+#num CV_COLOR_YUV2RGB_YV120+#num CV_COLOR_YUV2RGB_YVYU0+#num CV_COLOR_YUV420P2BGR0+#num CV_COLOR_YUV420P2BGRA0+#num CV_COLOR_YUV420P2GRAY0+#num CV_COLOR_YUV420P2RGB0+#num CV_COLOR_YUV420P2RGBA0+#num CV_COLOR_YUV420SP2BGR0+#num CV_COLOR_YUV420SP2BGRA0+#num CV_COLOR_YUV420SP2GRAY0+#num CV_COLOR_YUV420SP2RGB0+#num CV_COLOR_YUV420SP2RGBA0+#num CV_COVAR_COLS0+#num CV_COVAR_NORMAL0+#num CV_COVAR_ROWS0+#num CV_COVAR_SCALE0+#num CV_COVAR_SCRAMBLED0+#num CV_COVAR_USE_AVG0+#num CV_DCT_INVERSE0+#num CV_DCT_ROWS0+#num CV_DECOMP_CHOLESKY0+#num CV_DECOMP_EIG0+#num CV_DECOMP_LU0+#num CV_DECOMP_NORMAL0+#num CV_DECOMP_QR0+#num CV_DECOMP_SVD0+#num CV_DEPTH_MASK0+#num CV_DEPTH_MASK_16S0+#num CV_DEPTH_MASK_16U0+#num CV_DEPTH_MASK_32F0+#num CV_DEPTH_MASK_32S0+#num CV_DEPTH_MASK_64F0+#num CV_DEPTH_MASK_8S0+#num CV_DEPTH_MASK_8U0+#num CV_DEPTH_MASK_ALL0+#num CV_DEPTH_MASK_ALL_BUT_8S0+#num CV_DEPTH_MASK_FLT0+#num CV_DFT_COMPLEX_OUTPUT0+#num CV_DFT_INVERSE0+#num CV_DFT_REAL_OUTPUT0+#num CV_DFT_ROWS0+#num CV_DFT_SCALE0+#num CV_DIST_LABEL_CCOMP0+#num CV_DIST_LABEL_PIXEL0+#num CV_DRAWMATCHESFLAGS_DEFAULT0+#num CV_DRAWMATCHESFLAGS_DRAW_OVER_OUTIMG0+#num CV_DRAWMATCHESFLAGS_DRAW_RICH_KEYPOINTS0+#num CV_DRAWMATCHESFLAGS_NOT_DRAW_SINGLE_POINTS0+#num CV_EM_COV_MAT_DEFAULT0+#num CV_EM_COV_MAT_DIAGONAL0+#num CV_EM_COV_MAT_GENERIC0+#num CV_EM_COV_MAT_SPHERICAL0+#num CV_EM_DEFAULT_MAX_ITERS0+#num CV_EM_DEFAULT_NCLUSTERS0+#num CV_EM_START_AUTO_STEP0+#num CV_EM_START_E_STEP0+#num CV_EM_START_M_STEP0+#num CV_EPNP0+#num CV_EPNP1+#num CV_EVENT_FLAG_ALTKEY0+#num CV_EVENT_FLAG_CTRLKEY0+#num CV_EVENT_FLAG_LBUTTON0+#num CV_EVENT_FLAG_MBUTTON0+#num CV_EVENT_FLAG_RBUTTON0+#num CV_EVENT_FLAG_SHIFTKEY0+#num CV_EVENT_LBUTTONDBLCLK0+#num CV_EVENT_LBUTTONDOWN0+#num CV_EVENT_LBUTTONUP0+#num CV_EVENT_MBUTTONDBLCLK0+#num CV_EVENT_MBUTTONDOWN0+#num CV_EVENT_MBUTTONUP0+#num CV_EVENT_MOUSEMOVE0+#num CV_EVENT_RBUTTONDBLCLK0+#num CV_EVENT_RBUTTONDOWN0+#num CV_EVENT_RBUTTONUP0+#num CV_FASTFEATUREDETECTOR_TYPE_5_80+#num CV_FASTFEATUREDETECTOR_TYPE_7_120+#num CV_FASTFEATUREDETECTOR_TYPE_9_160+#num CV_FEATUREEVALUATOR_HAAR0+#num CV_FEATUREEVALUATOR_HOG0+#num CV_FEATUREEVALUATOR_LBP0+#num CV_FILENODE_EMPTY0+#num CV_FILENODE_FLOAT0+#num CV_FILENODE_FLOW0+#num CV_FILENODE_INT0+#num CV_FILENODE_MAP0+#num CV_FILENODE_NAMED0+#num CV_FILENODE_NONE0+#num CV_FILENODE_REAL0+#num CV_FILENODE_REF0+#num CV_FILENODE_SEQ0+#num CV_FILENODE_STR0+#num CV_FILENODE_STRING0+#num CV_FILENODE_TYPE_MASK0+#num CV_FILENODE_USER0+#num CV_FILESTORAGE_APPEND0+#num CV_FILESTORAGE_FORMAT_AUTO0+#num CV_FILESTORAGE_FORMAT_MASK0+#num CV_FILESTORAGE_FORMAT_XML0+#num CV_FILESTORAGE_FORMAT_YAML0+#num CV_FILESTORAGE_INSIDE_MAP0+#num CV_FILESTORAGE_MEMORY0+#num CV_FILESTORAGE_NAME_EXPECTED0+#num CV_FILESTORAGE_READ0+#num CV_FILESTORAGE_UNDEFINED0+#num CV_FILESTORAGE_VALUE_EXPECTED0+#num CV_FILESTORAGE_WRITE0+#num CV_FLOODFILL_FIXED_RANGE0+#num CV_FLOODFILL_MASK_ONLY0+#num CV_FM_7POINT0+#num CV_FM_8POINT0+#num CV_FM_LMEDS0+#num CV_FM_RANSAC0+#num CV_FONT_HERSHEY_COMPLEX0+#num CV_FONT_HERSHEY_COMPLEX_SMALL0+#num CV_FONT_HERSHEY_DUPLEX0+#num CV_FONT_HERSHEY_PLAIN0+#num CV_FONT_HERSHEY_SCRIPT_COMPLEX0+#num CV_FONT_HERSHEY_SCRIPT_SIMPLEX0+#num CV_FONT_HERSHEY_SIMPLEX0+#num CV_FONT_HERSHEY_TRIPLEX0+#num CV_FONT_ITALIC0+#num CV_FREAK_NB_ORIENPAIRS0+#num CV_FREAK_NB_PAIRS0+#num CV_FREAK_NB_SCALES0+#num CV_FUZZYMEANSHIFTTRACKER_MINKERNELMASS0+#num CV_FUZZYMEANSHIFTTRACKER_RMEDGEDENSITYFUZZY0+#num CV_FUZZYMEANSHIFTTRACKER_RMEDGEDENSITYLINEAR0+#num CV_FUZZYMEANSHIFTTRACKER_RMINNERDENSITY0+#num CV_FUZZYMEANSHIFTTRACKER_TSDISABLED0+#num CV_FUZZYMEANSHIFTTRACKER_TSNONE0+#num CV_FUZZYMEANSHIFTTRACKER_TSSEARCHING0+#num CV_FUZZYMEANSHIFTTRACKER_TSSETWINDOW0+#num CV_FUZZYMEANSHIFTTRACKER_TSTRACKING0+#num CV_GBTREES_ABSOLUTE_LOSS0+#num CV_GBTREES_DEVIANCE_LOSS0+#num CV_GBTREES_HUBER_LOSS0+#num CV_GBTREES_SQUARED_LOSS0+#num CV_GC_BGD0+#num CV_GC_EVAL0+#num CV_GC_FGD0+#num CV_GC_INIT_WITH_MASK0+#num CV_GC_INIT_WITH_RECT0+#num CV_GC_PR_BGD0+#num CV_GC_PR_FGD0+#num CV_GEMM_1_T0+#num CV_GEMM_2_T0+#num CV_GEMM_3_T0+#num CV_GHT_POSITION0+#num CV_GHT_ROTATION0+#num CV_GHT_SCALE0+#num CV_HAMMING_NORMTYPE0+#num CV_HOGDESCRIPTOR_DEFAULT_NLEVELS0+#num CV_HOGDESCRIPTOR_L2HYS0+#num CV_IMREAD_ANYCOLOR0+#num CV_IMREAD_ANYDEPTH0+#num CV_IMREAD_COLOR0+#num CV_IMREAD_GRAYSCALE0+#num CV_IMREAD_UNCHANGED0+#num CV_IMWRITE_JPEG_QUALITY0+#num CV_IMWRITE_PNG_BILEVEL0+#num CV_IMWRITE_PNG_COMPRESSION0+#num CV_IMWRITE_PNG_STRATEGY0+#num CV_IMWRITE_PNG_STRATEGY_DEFAULT0+#num CV_IMWRITE_PNG_STRATEGY_FILTERED0+#num CV_IMWRITE_PNG_STRATEGY_FIXED0+#num CV_IMWRITE_PNG_STRATEGY_HUFFMAN_ONLY0+#num CV_IMWRITE_PNG_STRATEGY_RLE0+#num CV_IMWRITE_PXM_BINARY0+#num CV_INTER_AREA0+#num CV_INTER_BITS0+#num CV_INTER_BITS20+#num CV_INTER_CUBIC0+#num CV_INTER_LANCZOS40+#num CV_INTER_LINEAR0+#num CV_INTER_MAX0+#num CV_INTER_NEAREST0+#num CV_INTER_TAB_SIZE0+#num CV_INTER_TAB_SIZE20+#num CV_ITERATIVE0+#num CV_ITERATIVE1+#num CV_KERNEL_ASYMMETRICAL0+#num CV_KERNEL_GENERAL0+#num CV_KERNEL_INTEGER0+#num CV_KERNEL_SMOOTH0+#num CV_KERNEL_SYMMETRICAL0+#num CV_KMEANS_PP_CENTERS0+#num CV_KMEANS_RANDOM_CENTERS0+#num CV_KMEANS_USE_INITIAL_LABELS0+#num CV_LEVMARQ_CALC_J0+#num CV_LEVMARQ_CHECK_ERR0+#num CV_LEVMARQ_DONE0+#num CV_LEVMARQ_STARTED0+#num CV_LMEDS0+#num CV_MAGIC_MASK0+#num CV_MAT_AUTO_STEP0+#num CV_MAT_CONTINUOUS_FLAG0+#num CV_MAT_MAGIC_VAL0+#num CV_MAT_SUBMATRIX_FLAG0+#num CV_MORPH_BLACKHAT0+#num CV_MORPH_CLOSE0+#num CV_MORPH_CROSS0+#num CV_MORPH_DILATE0+#num CV_MORPH_ELLIPSE0+#num CV_MORPH_ERODE0+#num CV_MORPH_GRADIENT0+#num CV_MORPH_OPEN0+#num CV_MORPH_RECT0+#num CV_MORPH_TOPHAT0+#num CV_NORM_HAMMING0+#num CV_NORM_HAMMING20+#num CV_NORM_INF0+#num CV_NORM_L10+#num CV_NORM_L20+#num CV_NORM_L2SQR0+#num CV_NORM_MINMAX0+#num CV_NORM_RELATIVE0+#num CV_NORM_TYPE_MASK0+#num CV_OPTFLOW_FARNEBACK_GAUSSIAN0+#num CV_OPTFLOW_LK_GET_MIN_EIGENVALS0+#num CV_OPTFLOW_USE_INITIAL_FLOW0+#num CV_ORB_FAST_SCORE0+#num CV_ORB_HARRIS_SCORE0+#num CV_ORB_KBYTES0+#num CV_P3P0+#num CV_P3P1+#num CV_PARAMGRID_SVM_C0+#num CV_PARAMGRID_SVM_COEF0+#num CV_PARAMGRID_SVM_DEGREE0+#num CV_PARAMGRID_SVM_GAMMA0+#num CV_PARAMGRID_SVM_NU0+#num CV_PARAMGRID_SVM_P0+#num CV_PARAM_ALGORITHM0+#num CV_PARAM_BOOLEAN0+#num CV_PARAM_FLOAT0+#num CV_PARAM_INT0+#num CV_PARAM_MAT0+#num CV_PARAM_MAT_VECTOR0+#num CV_PARAM_REAL0+#num CV_PARAM_SHORT0+#num CV_PARAM_STRING0+#num CV_PARAM_UCHAR0+#num CV_PARAM_UINT640+#num CV_PARAM_UNSIGNED_INT0+#num CV_PROJ_SPHERICAL_EQRECT0+#num CV_PROJ_SPHERICAL_ORTHO0+#num CV_RANSAC0+#num CV_RETR_CCOMP0+#num CV_RETR_EXTERNAL0+#num CV_RETR_FLOODFILL0+#num CV_RETR_LIST0+#num CV_RETR_TREE0+#num CV_RIGID_BODY_MOTION0+#num CV_RNG_NORMAL0+#num CV_RNG_UNIFORM0+#num CV_ROTATION0+#num CV_SELFSIMDESCRIPTOR_DEFAULT_LARGE_SIZE0+#num CV_SELFSIMDESCRIPTOR_DEFAULT_NUM_ANGLES0+#num CV_SELFSIMDESCRIPTOR_DEFAULT_NUM_DISTANCE_BUCKETS0+#num CV_SELFSIMDESCRIPTOR_DEFAULT_SMALL_SIZE0+#num CV_SELFSIMDESCRIPTOR_DEFAULT_START_DISTANCE_BUCKET0+#num CV_SORT_ASCENDING0+#num CV_SORT_DESCENDING0+#num CV_SORT_EVERY_COLUMN0+#num CV_SORT_EVERY_ROW0+#num CV_SPARSEMAT_HASH_BIT0+#num CV_SPARSEMAT_HASH_SCALE0+#num CV_SPARSEMAT_MAGIC_VAL0+#num CV_SPARSEMAT_MAX_DIM0+#num CV_STEREOBM_BASIC_PRESET0+#num CV_STEREOBM_FISH_EYE_PRESET0+#num CV_STEREOBM_NARROW_PRESET0+#num CV_STEREOBM_PREFILTER_NORMALIZED_RESPONSE0+#num CV_STEREOBM_PREFILTER_XSOBEL0+#num CV_STEREOSGBM_DISP_SCALE0+#num CV_STEREOSGBM_DISP_SHIFT0+#num CV_STEREOVAR_CYCLE_O0+#num CV_STEREOVAR_CYCLE_V0+#num CV_STEREOVAR_PENALIZATION_CHARBONNIER0+#num CV_STEREOVAR_PENALIZATION_PERONA_MALIK0+#num CV_STEREOVAR_PENALIZATION_TICHONOV0+#num CV_STEREOVAR_USE_AUTO_PARAMS0+#num CV_STEREOVAR_USE_EQUALIZE_HIST0+#num CV_STEREOVAR_USE_INITIAL_DISPARITY0+#num CV_STEREOVAR_USE_MEDIAN_FILTERING0+#num CV_STEREOVAR_USE_SMART_ID0+#num CV_SUBDIV2D_NEXT_AROUND_DST0+#num CV_SUBDIV2D_NEXT_AROUND_LEFT0+#num CV_SUBDIV2D_NEXT_AROUND_ORG0+#num CV_SUBDIV2D_NEXT_AROUND_RIGHT0+#num CV_SUBDIV2D_PREV_AROUND_DST0+#num CV_SUBDIV2D_PREV_AROUND_LEFT0+#num CV_SUBDIV2D_PREV_AROUND_ORG0+#num CV_SUBDIV2D_PREV_AROUND_RIGHT0+#num CV_SUBDIV2D_PTLOC_ERROR0+#num CV_SUBDIV2D_PTLOC_INSIDE0+#num CV_SUBDIV2D_PTLOC_ON_EDGE0+#num CV_SUBDIV2D_PTLOC_OUTSIDE_RECT0+#num CV_SUBDIV2D_PTLOC_VERTEX0+#num CV_SVD_FULL_UV0+#num CV_SVD_MODIFY_A0+#num CV_SVD_NO_UV0+#num CV_SVM_C0+#num CV_SVM_COEF0+#num CV_SVM_C_SVC0+#num CV_SVM_DEGREE0+#num CV_SVM_EPS_SVR0+#num CV_SVM_GAMMA0+#num CV_SVM_LINEAR0+#num CV_SVM_NU0+#num CV_SVM_NU_SVC0+#num CV_SVM_NU_SVR0+#num CV_SVM_ONE_CLASS0+#num CV_SVM_P0+#num CV_SVM_POLY0+#num CV_SVM_RBF0+#num CV_SVM_SIGMOID0+#num CV_TERMCRITERIA_COUNT0+#num CV_TERMCRITERIA_EPS0+#num CV_TERMCRITERIA_MAX_ITER0+#num CV_THRESH_BINARY0+#num CV_THRESH_BINARY_INV0+#num CV_THRESH_MASK0+#num CV_THRESH_OTSU0+#num CV_THRESH_TOZERO0+#num CV_THRESH_TOZERO_INV0+#num CV_THRESH_TRUNC0+#num CV_TM_CCOEFF0+#num CV_TM_CCOEFF_NORMED0+#num CV_TM_CCORR0+#num CV_TM_CCORR_NORMED0+#num CV_TM_SQDIFF0+#num CV_TM_SQDIFF_NORMED0+#num CV_TRANSLATION0+#num CV_TYPE_MASK0+#num CV_WARP_INVERSE_MAP0+#num CV_WINDOW_AUTOSIZE0+#num CV_WINDOW_NORMAL0+#num CV_WINDOW_OPENGL0+#num CV_WND_PROP_ASPECT_RATIO0+#num CV_WND_PROP_AUTOSIZE0+#num CV_WND_PROP_FULLSCREEN0+#num CV_WND_PROP_OPENGL0+#num CV__INPUTARRAY_EXPR0+#num CV__INPUTARRAY_FIXED_SIZE0+#num CV__INPUTARRAY_FIXED_TYPE0+#num CV__INPUTARRAY_GPU_MAT0+#num CV__INPUTARRAY_KIND_MASK0+#num CV__INPUTARRAY_KIND_SHIFT0+#num CV__INPUTARRAY_MAT0+#num CV__INPUTARRAY_MATX0+#num CV__INPUTARRAY_NONE0+#num CV__INPUTARRAY_OCL_MAT0+#num CV__INPUTARRAY_OPENGL_BUFFER0+#num CV__INPUTARRAY_OPENGL_TEXTURE0+#num CV__INPUTARRAY_STD_VECTOR0+#num CV__INPUTARRAY_STD_VECTOR_MAT0+#num CV__INPUTARRAY_STD_VECTOR_VECTOR0
+ OpenCVRaw/CppTypes.hsc view
@@ -0,0 +1,19 @@+{-# LANGUAGE ForeignFunctionInterface #-}+#include <bindings.dsl.h>+#include <cpptypes.hpp>+module OpenCVRaw.CppTypes where+#strict_import++{- Provides wrappers for core c++ types that Haskell doesn't have access to + - but opencv requires. -}+import OpenCVRaw.Types+import Foreign.C+import Foreign.C.Types+import Foreign.Ptr++#ccall std_create_string , CString -> CInt -> IO (Ptr <string>)+#ccall std_create_vector_int , Ptr CInt -> CSize -> IO (Ptr <vector_int>)++toStdString :: String -> IO (Ptr C'string)+toStdString s = do  (cs, l) <- newCStringLen s+                    c'std_create_string cs (fromIntegral l)
+ OpenCVRaw/Funcs.hsc view
@@ -0,0 +1,475 @@+{-# LANGUAGE ForeignFunctionInterface #-}+#include <bindings.dsl.h>+#include <opencv_generated.hpp>+module OpenCVRaw.Funcs where+#strict_import+import Foreign.C+import Foreign.C.Types+import OpenCVRaw.Types+#ccall cv_create_BFMatcher , CInt -> CInt -> IO (Ptr <BFMatcher>)+#ccall cv_create_BRISK , CInt -> CInt -> CFloat -> IO (Ptr <BRISK>)+#ccall cv_create_BRISK5 , Ptr <vector_float> -> Ptr <vector_int> -> CFloat -> CFloat -> Ptr <vector_int> -> IO (Ptr <BRISK>)+#ccall cv_create_BackgroundSubtractorMOG , IO (Ptr <BackgroundSubtractorMOG>)+#ccall cv_create_BackgroundSubtractorMOG4 , CInt -> CInt -> CDouble -> CDouble -> IO (Ptr <BackgroundSubtractorMOG>)+#ccall cv_CamShift , Ptr <Mat> -> Ptr <Rect> -> Ptr <TermCriteria> -> IO (Ptr <RotatedRect>)+#ccall cv_Canny , Ptr <Mat> -> Ptr <Mat> -> CDouble -> CDouble -> CInt -> CInt -> IO ()+#ccall cv_create_CascadeClassifier , IO (Ptr <CascadeClassifier>)+#ccall cv_create_CascadeClassifier1 , Ptr <string> -> IO (Ptr <CascadeClassifier>)+#ccall cv_create_CvANN_MLP , IO (Ptr <CvANN_MLP>)+#ccall cv_create_CvANN_MLP4 , Ptr <Mat> -> CInt -> CDouble -> CDouble -> IO (Ptr <CvANN_MLP>)+#ccall cv_create_CvBoost , IO (Ptr <CvBoost>)+#ccall cv_create_CvBoost8 , Ptr <Mat> -> CInt -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <CvBoostParams> -> IO (Ptr <CvBoost>)+#ccall cv_create_CvDTree , IO (Ptr <CvDTree>)+#ccall cv_create_CvERTrees , IO (Ptr <CvERTrees>)+#ccall cv_create_CvGBTrees , IO (Ptr <CvGBTrees>)+#ccall cv_create_CvGBTrees8 , Ptr <Mat> -> CInt -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <CvGBTreesParams> -> IO (Ptr <CvGBTrees>)+#ccall cv_create_CvKNearest , IO (Ptr <CvKNearest>)+#ccall cv_create_CvKNearest5 , Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> CInt -> CInt -> IO (Ptr <CvKNearest>)+#ccall cv_create_CvNormalBayesClassifier , IO (Ptr <CvNormalBayesClassifier>)+#ccall cv_create_CvNormalBayesClassifier4 , Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> IO (Ptr <CvNormalBayesClassifier>)+#ccall cv_create_CvRTrees , IO (Ptr <CvRTrees>)+#ccall cv_create_CvSVM , IO (Ptr <CvSVM>)+#ccall cv_create_CvSVM5 , Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <CvSVMParams> -> IO (Ptr <CvSVM>)+#ccall cv_create_DMatch , IO (Ptr <DMatch>)+#ccall cv_create_DMatch3 , CInt -> CInt -> CFloat -> IO (Ptr <DMatch>)+#ccall cv_create_DMatch4 , CInt -> CInt -> CInt -> CFloat -> IO (Ptr <DMatch>)+#ccall cv_create_EM , CInt -> CInt -> Ptr <TermCriteria> -> IO (Ptr <EM>)+#ccall cv_create_FastFeatureDetector , CInt -> CInt -> IO (Ptr <FastFeatureDetector>)+#ccall cv_create_FileNode , IO (Ptr <FileNode>)+#ccall cv_create_FileStorage , IO (Ptr <FileStorage>)+#ccall cv_create_FileStorage3 , Ptr <string> -> CInt -> Ptr <string> -> IO (Ptr <FileStorage>)+#ccall cv_create_FlannBasedMatcher , Ptr <IndexParams> -> Ptr <SearchParams> -> IO (Ptr <FlannBasedMatcher>)+#ccall cv_create_GFTTDetector , CInt -> CDouble -> CDouble -> CInt -> CInt -> CDouble -> IO (Ptr <GFTTDetector>)+#ccall cv_GaussianBlur , Ptr <Mat> -> Ptr <Mat> -> Ptr <Size> -> CDouble -> CDouble -> CInt -> IO ()+#ccall cv_create_GridAdaptedFeatureDetector , Ptr <FeatureDetector> -> CInt -> CInt -> CInt -> IO (Ptr <GridAdaptedFeatureDetector>)+#ccall cv_create_HOGDescriptor , IO (Ptr <HOGDescriptor>)+#ccall cv_create_HOGDescriptor1 , Ptr <String> -> IO (Ptr <HOGDescriptor>)+#ccall cv_create_HOGDescriptor11 , Ptr <Size> -> Ptr <Size> -> Ptr <Size> -> Ptr <Size> -> CInt -> CInt -> CDouble -> CInt -> CDouble -> CInt -> CInt -> IO (Ptr <HOGDescriptor>)+#ccall cv_HoughCircles , Ptr <Mat> -> Ptr <Mat> -> CInt -> CDouble -> CDouble -> CDouble -> CDouble -> CInt -> CInt -> IO ()+#ccall cv_HoughLines , Ptr <Mat> -> Ptr <Mat> -> CDouble -> CDouble -> CInt -> CDouble -> CDouble -> IO ()+#ccall cv_HoughLinesP , Ptr <Mat> -> Ptr <Mat> -> CDouble -> CDouble -> CInt -> CDouble -> CDouble -> IO ()+#ccall cv_HuMoments , Ptr <Moments> -> Ptr <Mat> -> IO ()+#ccall cv_create_Index , IO (Ptr <Index>)+#ccall cv_create_Index3 , Ptr <Mat> -> Ptr <IndexParams> -> Ptr <flann_distance_t> -> IO (Ptr <Index>)+#ccall cv_create_KDTree , IO (Ptr <KDTree>)+#ccall cv_create_KDTree2 , Ptr <Mat> -> CInt -> IO (Ptr <KDTree>)+#ccall cv_create_KDTree3 , Ptr <Mat> -> Ptr <Mat> -> CInt -> IO (Ptr <KDTree>)+#ccall cv_create_KalmanFilter , IO (Ptr <KalmanFilter>)+#ccall cv_create_KalmanFilter4 , CInt -> CInt -> CInt -> CInt -> IO (Ptr <KalmanFilter>)+#ccall cv_create_KeyPoint , IO (Ptr <KeyPoint>)+#ccall cv_create_KeyPoint7 , CFloat -> CFloat -> CFloat -> CFloat -> CFloat -> CInt -> CInt -> IO (Ptr <KeyPoint>)+#ccall cv_LUT , Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> CInt -> IO ()+#ccall cv_Laplacian , Ptr <Mat> -> Ptr <Mat> -> CInt -> CInt -> CDouble -> CDouble -> CInt -> IO ()+#ccall cv_create_MSER , CInt -> CInt -> CInt -> CDouble -> CDouble -> CInt -> CDouble -> CDouble -> CInt -> IO (Ptr <MSER>)+#ccall cv_Mahalanobis , Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> IO CDouble+#ccall cv_create_ORB , CInt -> CFloat -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO (Ptr <ORB>)+#ccall cv_PCABackProject , Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> IO ()+#ccall cv_PCACompute , Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> CInt -> IO ()+#ccall cv_PCAComputeVar , Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> CDouble -> IO ()+#ccall cv_PCAProject , Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> IO ()+#ccall cv_PSNR , Ptr <Mat> -> Ptr <Mat> -> IO CDouble+#ccall cv_create_Params , IO (Ptr <Params>)+#ccall cv_create_PyramidAdaptedFeatureDetector , Ptr <FeatureDetector> -> CInt -> IO (Ptr <PyramidAdaptedFeatureDetector>)+#ccall cv_RQDecomp3x3 , Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> IO (Ptr <Vec3d>)+#ccall cv_Rodrigues , Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> IO ()+#ccall cv_SVBackSubst , Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> IO ()+#ccall cv_SVDecomp , Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> CInt -> IO ()+#ccall cv_Scharr , Ptr <Mat> -> Ptr <Mat> -> CInt -> CInt -> CInt -> CDouble -> CDouble -> CInt -> IO ()+#ccall cv_create_SimpleBlobDetector , Ptr <Params> -> IO (Ptr <SimpleBlobDetector>)+#ccall cv_Sobel , Ptr <Mat> -> Ptr <Mat> -> CInt -> CInt -> CInt -> CInt -> CDouble -> CDouble -> CInt -> IO ()+#ccall cv_create_StarDetector , CInt -> CInt -> CInt -> CInt -> CInt -> IO (Ptr <StarDetector>)+#ccall cv_create_StereoBM , IO (Ptr <StereoBM>)+#ccall cv_create_StereoBM3 , CInt -> CInt -> CInt -> IO (Ptr <StereoBM>)+#ccall cv_create_StereoSGBM , IO (Ptr <StereoSGBM>)+#ccall cv_create_StereoSGBM11 , CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO (Ptr <StereoSGBM>)+#ccall cv_create_StereoVar , IO (Ptr <StereoVar>)+#ccall cv_create_StereoVar12 , CInt -> CDouble -> CInt -> CInt -> CInt -> CInt -> CDouble -> CFloat -> CFloat -> CInt -> CInt -> CInt -> IO (Ptr <StereoVar>)+#ccall cv_create_Subdiv2D , IO (Ptr <Subdiv2D>)+#ccall cv_create_Subdiv2D1 , Ptr <Rect> -> IO (Ptr <Subdiv2D>)+#ccall cv_create_VideoCapture , IO (Ptr <VideoCapture>)+#ccall cv_create_VideoCapture1 , CInt -> IO (Ptr <VideoCapture>)+#ccall cv_create_VideoWriter , IO (Ptr <VideoWriter>)+#ccall cv_create_VideoWriter5 , Ptr <string> -> CInt -> CDouble -> Ptr <Size> -> CInt -> IO (Ptr <VideoWriter>)+#ccall cv_Algorithm__create , Ptr <Algorithm> -> Ptr <string> -> IO (Ptr <Algorithm>)+#ccall cv_absdiff , Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> IO ()+#ccall cv_accumulate , Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> IO ()+#ccall cv_accumulateProduct , Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> IO ()+#ccall cv_accumulateSquare , Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> IO ()+#ccall cv_accumulateWeighted , Ptr <Mat> -> Ptr <Mat> -> CDouble -> Ptr <Mat> -> IO ()+#ccall cv_adaptiveBilateralFilter , Ptr <Mat> -> Ptr <Mat> -> Ptr <Size> -> CDouble -> Ptr <Point> -> CInt -> IO ()+#ccall cv_adaptiveThreshold , Ptr <Mat> -> Ptr <Mat> -> CDouble -> CInt -> CInt -> CInt -> CDouble -> IO ()+#ccall cv_add , Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> CInt -> IO ()+#ccall cv_DescriptorMatcher_add1 , Ptr <DescriptorMatcher> -> Ptr <vector_Mat> -> IO ()+#ccall cv_addWeighted , Ptr <Mat> -> CDouble -> Ptr <Mat> -> CDouble -> CDouble -> Ptr <Mat> -> CInt -> IO ()+#ccall cv_CLAHE_apply , Ptr <CLAHE> -> Ptr <Mat> -> Ptr <Mat> -> IO ()+#ccall cv_applyColorMap , Ptr <Mat> -> Ptr <Mat> -> CInt -> IO ()+#ccall cv_approxPolyDP , Ptr <Mat> -> Ptr <Mat> -> CDouble -> CInt -> IO ()+#ccall cv_arcLength , Ptr <Mat> -> CInt -> IO CDouble+#ccall cv_batchDistance , Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> CInt -> Ptr <Mat> -> CInt -> CInt -> Ptr <Mat> -> CInt -> CInt -> IO ()+#ccall cv_bilateralFilter , Ptr <Mat> -> Ptr <Mat> -> CInt -> CDouble -> CDouble -> CInt -> IO ()+#ccall cv_bitwise_and , Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> IO ()+#ccall cv_bitwise_not , Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> IO ()+#ccall cv_bitwise_or , Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> IO ()+#ccall cv_bitwise_xor , Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> IO ()+#ccall cv_blur , Ptr <Mat> -> Ptr <Mat> -> Ptr <Size> -> Ptr <Point> -> CInt -> IO ()+#ccall cv_borderInterpolate , CInt -> CInt -> CInt -> IO CInt+#ccall cv_boundingRect , Ptr <Mat> -> IO (Ptr <Rect>)+#ccall cv_boxFilter , Ptr <Mat> -> Ptr <Mat> -> CInt -> Ptr <Size> -> Ptr <Point> -> CInt -> CInt -> IO ()+#ccall cv_KDTree_build , Ptr <KDTree> -> Ptr <Mat> -> CInt -> IO ()+#ccall cv_Index_build3 , Ptr <Index> -> Ptr <Mat> -> Ptr <IndexParams> -> Ptr <flann_distance_t> -> IO ()+#ccall cv_buildOpticalFlowPyramid , Ptr <Mat> -> Ptr <vector_Mat> -> Ptr <Size> -> CInt -> CInt -> CInt -> CInt -> CInt -> IO CInt+#ccall cv_calcBackProject , Ptr <vector_Mat> -> Ptr <vector_int> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <vector_float> -> CDouble -> IO ()+#ccall cv_calcCovarMatrix , Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> CInt -> CInt -> IO ()+#ccall cv_calcGlobalOrientation , Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> CDouble -> CDouble -> IO CDouble+#ccall cv_calcHist , Ptr <vector_Mat> -> Ptr <vector_int> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <vector_int> -> Ptr <vector_float> -> CInt -> IO ()+#ccall cv_calcMotionGradient , Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> CDouble -> CDouble -> CInt -> IO ()+#ccall cv_calcOpticalFlowFarneback , Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> CDouble -> CInt -> CInt -> CInt -> CInt -> CDouble -> CInt -> IO ()+#ccall cv_calcOpticalFlowPyrLK , Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Size> -> CInt -> Ptr <TermCriteria> -> CInt -> CDouble -> IO ()+#ccall cv_calcOpticalFlowSF , Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> CInt -> CInt -> CInt -> IO ()+#ccall cv_calcOpticalFlowSF16 , Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> CInt -> CInt -> CInt -> CDouble -> CDouble -> CInt -> CDouble -> CDouble -> CDouble -> CInt -> CDouble -> CDouble -> CDouble -> IO ()+#ccall cv_calibrateCamera , Ptr <vector_Mat> -> Ptr <vector_Mat> -> Ptr <Size> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <vector_Mat> -> Ptr <vector_Mat> -> CInt -> Ptr <TermCriteria> -> IO CDouble+#ccall cv_calibrationMatrixValues , Ptr <Mat> -> Ptr <Size> -> CDouble -> CDouble -> CDouble -> CDouble -> CDouble -> Ptr <Point2d> -> CDouble -> IO ()+#ccall cv_cartToPolar , Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> CInt -> IO ()+#ccall cv_chamerMatching , Ptr <Mat> -> Ptr <Mat> -> Ptr <vector_vector_Point> -> Ptr <vector_float> -> CDouble -> CInt -> CDouble -> CInt -> CInt -> CInt -> CDouble -> CDouble -> CDouble -> CDouble -> IO CInt+#ccall cv_HOGDescriptor_checkDetectorSize , Ptr <HOGDescriptor> -> IO CInt+#ccall cv_checkHardwareSupport , CInt -> IO CInt+#ccall cv_checkRange , Ptr <Mat> -> CInt -> Ptr <Point> -> CDouble -> CDouble -> IO CInt+#ccall cv_circle , Ptr <Mat> -> Ptr <Point> -> CInt -> Ptr <Scalar> -> CInt -> CInt -> CInt -> IO ()+#ccall cv_CvNormalBayesClassifier_clear , Ptr <CvNormalBayesClassifier> -> IO ()+#ccall cv_DescriptorMatcher_clear0 , Ptr <DescriptorMatcher> -> IO ()+#ccall cv_clipLine , Ptr <Rect> -> Ptr <Point> -> Ptr <Point> -> IO CInt+#ccall cv_compare , Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> CInt -> IO ()+#ccall cv_compareHist , Ptr <Mat> -> Ptr <Mat> -> CInt -> IO CDouble+#ccall cv_completeSymm , Ptr <Mat> -> CInt -> IO ()+#ccall cv_composeRT , Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> IO ()+#ccall cv_DescriptorExtractor_compute , Ptr <DescriptorExtractor> -> Ptr <Mat> -> Ptr <vector_KeyPoint> -> Ptr <Mat> -> IO ()+#ccall cv_Feature2D_compute3 , Ptr <Feature2D> -> Ptr <Mat> -> Ptr <vector_KeyPoint> -> Ptr <Mat> -> IO ()+#ccall cv_HOGDescriptor_compute5 , Ptr <HOGDescriptor> -> Ptr <Mat> -> Ptr <vector_float> -> Ptr <Size> -> Ptr <Size> -> Ptr <vector_Point> -> IO ()+#ccall cv_computeCorrespondEpilines , Ptr <Mat> -> CInt -> Ptr <Mat> -> Ptr <Mat> -> IO ()+#ccall cv_HOGDescriptor_computeGradient , Ptr <HOGDescriptor> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Size> -> Ptr <Size> -> IO ()+#ccall cv_contourArea , Ptr <Mat> -> CInt -> IO CDouble+#ccall cv_convertMaps , Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> CInt -> CInt -> IO ()+#ccall cv_convertPointsFromHomogeneous , Ptr <Mat> -> Ptr <Mat> -> IO ()+#ccall cv_convertPointsToHomogeneous , Ptr <Mat> -> Ptr <Mat> -> IO ()+#ccall cv_convertScaleAbs , Ptr <Mat> -> Ptr <Mat> -> CDouble -> CDouble -> IO ()+#ccall cv_convexHull , Ptr <Mat> -> Ptr <Mat> -> CInt -> CInt -> IO ()+#ccall cv_convexityDefects , Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> IO ()+#ccall cv_copyMakeBorder , Ptr <Mat> -> Ptr <Mat> -> CInt -> CInt -> CInt -> CInt -> CInt -> Ptr <Scalar> -> IO ()+#ccall cv_cornerEigenValsAndVecs , Ptr <Mat> -> Ptr <Mat> -> CInt -> CInt -> CInt -> IO ()+#ccall cv_cornerHarris , Ptr <Mat> -> Ptr <Mat> -> CInt -> CInt -> CDouble -> CInt -> IO ()+#ccall cv_cornerMinEigenVal , Ptr <Mat> -> Ptr <Mat> -> CInt -> CInt -> CInt -> IO ()+#ccall cv_cornerSubPix , Ptr <Mat> -> Ptr <Mat> -> Ptr <Size> -> Ptr <Size> -> Ptr <TermCriteria> -> IO ()+#ccall cv_KalmanFilter_correct , Ptr <KalmanFilter> -> Ptr <Mat> -> IO (Ptr <Mat>)+#ccall cv_correctMatches , Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> IO ()+#ccall cv_countNonZero , Ptr <Mat> -> IO CInt+#ccall cv_CvANN_MLP_create , Ptr <CvANN_MLP> -> Ptr <Mat> -> CInt -> CDouble -> CDouble -> IO ()+#ccall cv_DescriptorMatcher_create1 , Ptr <DescriptorMatcher> -> Ptr <string> -> IO (Ptr <DescriptorMatcher>)+#ccall cv_createCLAHE , CDouble -> Ptr <Size> -> IO (Ptr <CLAHE>)+#ccall cv_createEigenFaceRecognizer , CInt -> CDouble -> IO (Ptr <FaceRecognizer>)+#ccall cv_createFisherFaceRecognizer , CInt -> CDouble -> IO (Ptr <FaceRecognizer>)+#ccall cv_createHanningWindow , Ptr <Mat> -> Ptr <Size> -> CInt -> IO ()+#ccall cv_createLBPHFaceRecognizer , CInt -> CInt -> CInt -> CInt -> CDouble -> IO (Ptr <FaceRecognizer>)+#ccall cv_cubeRoot , CFloat -> IO CFloat+#ccall cv_cvtColor , Ptr <Mat> -> Ptr <Mat> -> CInt -> CInt -> IO ()+#ccall cv_dct , Ptr <Mat> -> Ptr <Mat> -> CInt -> IO ()+#ccall cv_decomposeProjectionMatrix , Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> IO ()+#ccall cv_destroyAllWindows , IO ()+#ccall cv_destroyWindow , Ptr <string> -> IO ()+#ccall cv_FeatureDetector_detect , Ptr <FeatureDetector> -> Ptr <Mat> -> Ptr <vector_KeyPoint> -> Ptr <Mat> -> IO ()+#ccall cv_HOGDescriptor_detect7 , Ptr <HOGDescriptor> -> Ptr <Mat> -> Ptr <vector_Point> -> Ptr <vector_double> -> CDouble -> Ptr <Size> -> Ptr <Size> -> Ptr <vector_Point> -> IO ()+#ccall cv_CascadeClassifier_detectMultiScale , Ptr <CascadeClassifier> -> Ptr <Mat> -> Ptr <vector_Rect> -> CDouble -> CInt -> CInt -> Ptr <Size> -> Ptr <Size> -> IO ()+#ccall cv_CascadeClassifier_detectMultiScale10 , Ptr <CascadeClassifier> -> Ptr <Mat> -> Ptr <vector_Rect> -> Ptr <vector_int> -> Ptr <vector_double> -> CDouble -> CInt -> CInt -> Ptr <Size> -> Ptr <Size> -> CInt -> IO ()+#ccall cv_HOGDescriptor_detectMultiScale9 , Ptr <HOGDescriptor> -> Ptr <Mat> -> Ptr <vector_Rect> -> Ptr <vector_double> -> CDouble -> Ptr <Size> -> Ptr <Size> -> CDouble -> CDouble -> CInt -> IO ()+#ccall cv_determinant , Ptr <Mat> -> IO CDouble+#ccall cv_dft , Ptr <Mat> -> Ptr <Mat> -> CInt -> CInt -> IO ()+#ccall cv_dilate , Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Point> -> CInt -> CInt -> Ptr <Scalar> -> IO ()+#ccall cv_KDTree_dims , Ptr <KDTree> -> IO CInt+#ccall cv_distanceTransform , Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> CInt -> CInt -> CInt -> IO ()+#ccall cv_distanceTransform4 , Ptr <Mat> -> Ptr <Mat> -> CInt -> CInt -> IO ()+#ccall cv_divide , Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> CDouble -> CInt -> IO ()+#ccall cv_divide4 , CDouble -> Ptr <Mat> -> Ptr <Mat> -> CInt -> IO ()+#ccall cv_drawChessboardCorners , Ptr <Mat> -> Ptr <Size> -> Ptr <Mat> -> CInt -> IO ()+#ccall cv_drawContours , Ptr <Mat> -> Ptr <vector_Mat> -> CInt -> Ptr <Scalar> -> CInt -> CInt -> Ptr <Mat> -> CInt -> Ptr <Point> -> IO ()+#ccall cv_drawDataMatrixCodes , Ptr <Mat> -> Ptr <vector_string> -> Ptr <Mat> -> IO ()+#ccall cv_drawKeypoints , Ptr <Mat> -> Ptr <vector_KeyPoint> -> Ptr <Mat> -> Ptr <Scalar> -> CInt -> IO ()+#ccall cv_Subdiv2D_edgeDst , Ptr <Subdiv2D> -> CInt -> Ptr <Point2f> -> IO CInt+#ccall cv_Subdiv2D_edgeOrg , Ptr <Subdiv2D> -> CInt -> Ptr <Point2f> -> IO CInt+#ccall cv_eigen , Ptr <Mat> -> CInt -> Ptr <Mat> -> Ptr <Mat> -> IO CInt+#ccall cv_ellipse , Ptr <Mat> -> Ptr <Point> -> Ptr <Size> -> CDouble -> CDouble -> CDouble -> Ptr <Scalar> -> CInt -> CInt -> CInt -> IO ()+#ccall cv_ellipse2Poly , Ptr <Point> -> Ptr <Size> -> CInt -> CInt -> CInt -> CInt -> Ptr <vector_Point> -> IO ()+#ccall cv_ellipse5 , Ptr <Mat> -> Ptr <RotatedRect> -> Ptr <Scalar> -> CInt -> CInt -> IO ()+#ccall cv_FileNode_empty , Ptr <FileNode> -> IO CInt+#ccall cv_CascadeClassifier_empty0 , Ptr <CascadeClassifier> -> IO CInt+#ccall cv_equalizeHist , Ptr <Mat> -> Ptr <Mat> -> IO ()+#ccall cv_erode , Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Point> -> CInt -> CInt -> Ptr <Scalar> -> IO ()+#ccall cv_estimateAffine3D , Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> CDouble -> CDouble -> IO CInt+#ccall cv_estimateRigidTransform , Ptr <Mat> -> Ptr <Mat> -> CInt -> IO (Ptr <Mat>)+#ccall cv_exp , Ptr <Mat> -> Ptr <Mat> -> IO ()+#ccall cv_extractChannel , Ptr <Mat> -> Ptr <Mat> -> CInt -> IO ()+#ccall cv_fastAtan2 , CFloat -> CFloat -> IO CFloat+#ccall cv_fillConvexPoly , Ptr <Mat> -> Ptr <Mat> -> Ptr <Scalar> -> CInt -> CInt -> IO ()+#ccall cv_fillPoly , Ptr <Mat> -> Ptr <vector_Mat> -> Ptr <Scalar> -> CInt -> CInt -> Ptr <Point> -> IO ()+#ccall cv_filter2D , Ptr <Mat> -> Ptr <Mat> -> CInt -> Ptr <Mat> -> Ptr <Point> -> CDouble -> CInt -> IO ()+#ccall cv_filterSpeckles , Ptr <Mat> -> CDouble -> CInt -> CDouble -> Ptr <Mat> -> IO ()+#ccall cv_findChessboardCorners , Ptr <Mat> -> Ptr <Size> -> Ptr <Mat> -> CInt -> IO CInt+#ccall cv_findCirclesGrid , Ptr <Mat> -> Ptr <Size> -> Ptr <Mat> -> CInt -> Ptr <FeatureDetector> -> IO CInt+#ccall cv_findCirclesGridDefault , Ptr <Mat> -> Ptr <Size> -> Ptr <Mat> -> CInt -> IO CInt+#ccall cv_findContours , Ptr <Mat> -> Ptr <vector_Mat> -> Ptr <Mat> -> CInt -> CInt -> Ptr <Point> -> IO ()+#ccall cv_findDataMatrix , Ptr <Mat> -> Ptr <vector_string> -> Ptr <Mat> -> Ptr <vector_Mat> -> IO ()+#ccall cv_findFundamentalMat , Ptr <Mat> -> Ptr <Mat> -> CInt -> CDouble -> CDouble -> Ptr <Mat> -> IO (Ptr <Mat>)+#ccall cv_findHomography , Ptr <Mat> -> Ptr <Mat> -> CInt -> CDouble -> Ptr <Mat> -> IO (Ptr <Mat>)+#ccall cv_KDTree_findNearest , Ptr <KDTree> -> Ptr <Mat> -> CInt -> CInt -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> IO CInt+#ccall cv_Subdiv2D_findNearest2 , Ptr <Subdiv2D> -> Ptr <Point2f> -> Ptr <Point2f> -> IO CInt+#ccall cv_findNonZero , Ptr <Mat> -> Ptr <Mat> -> IO ()+#ccall cv_KDTree_findOrthoRange , Ptr <KDTree> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> IO ()+#ccall cv_CvKNearest_find_nearest , Ptr <CvKNearest> -> Ptr <Mat> -> CInt -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> IO CFloat+#ccall cv_fitEllipse , Ptr <Mat> -> IO (Ptr <RotatedRect>)+#ccall cv_fitLine , Ptr <Mat> -> Ptr <Mat> -> CInt -> CDouble -> CDouble -> CDouble -> IO ()+#ccall cv_flip , Ptr <Mat> -> Ptr <Mat> -> CInt -> IO ()+#ccall cv_floodFill , Ptr <Mat> -> Ptr <Mat> -> Ptr <Point> -> Ptr <Scalar> -> Ptr <Rect> -> Ptr <Scalar> -> Ptr <Scalar> -> CInt -> IO CInt+#ccall cv_gemm , Ptr <Mat> -> Ptr <Mat> -> CDouble -> Ptr <Mat> -> CDouble -> Ptr <Mat> -> CInt -> IO ()+#ccall cv_BRISK_generateKernel , Ptr <BRISK> -> Ptr <vector_float> -> Ptr <vector_int> -> CFloat -> CFloat -> Ptr <vector_int> -> IO ()+#ccall cv_VideoCapture_get , Ptr <VideoCapture> -> CInt -> IO CDouble+#ccall cv_getAffineTransform , Ptr <Mat> -> Ptr <Mat> -> IO (Ptr <Mat>)+#ccall cv_Algorithm_getAlgorithm , Ptr <Algorithm> -> Ptr <string> -> IO (Ptr <Algorithm>)+#ccall cv_Index_getAlgorithm0 , Ptr <Index> -> IO (Ptr <flann_algorithm_t>)+#ccall cv_Algorithm_getBool , Ptr <Algorithm> -> Ptr <string> -> IO CInt+#ccall cv_getBuildInformation , IO (Ptr <string>)+#ccall cv_getCPUTickCount , IO CLong+#ccall cv_HOGDescriptor_getDaimlerPeopleDetector , Ptr <HOGDescriptor> -> IO (Ptr <vector_float>)+#ccall cv_getDefaultNewCameraMatrix , Ptr <Mat> -> Ptr <Size> -> CInt -> IO (Ptr <Mat>)+#ccall cv_HOGDescriptor_getDefaultPeopleDetector , Ptr <HOGDescriptor> -> IO (Ptr <vector_float>)+#ccall cv_getDerivKernels , Ptr <Mat> -> Ptr <Mat> -> CInt -> CInt -> CInt -> CInt -> CInt -> IO ()+#ccall cv_HOGDescriptor_getDescriptorSize , Ptr <HOGDescriptor> -> IO CSize+#ccall cv_Index_getDistance , Ptr <Index> -> IO (Ptr <flann_distance_t>)+#ccall cv_Algorithm_getDouble , Ptr <Algorithm> -> Ptr <string> -> IO CDouble+#ccall cv_Subdiv2D_getEdge , Ptr <Subdiv2D> -> CInt -> CInt -> IO CInt+#ccall cv_Subdiv2D_getEdgeList , Ptr <Subdiv2D> -> Ptr <vector_Vec4f> -> IO ()+#ccall cv_FileStorage_getFirstTopLevelNode , Ptr <FileStorage> -> IO (Ptr <FileNode>)+#ccall cv_getGaborKernel , Ptr <Size> -> CDouble -> CDouble -> CDouble -> CDouble -> CDouble -> CInt -> IO (Ptr <Mat>)+#ccall cv_getGaussianKernel , CInt -> CDouble -> CInt -> IO (Ptr <Mat>)+#ccall cv_Algorithm_getInt , Ptr <Algorithm> -> Ptr <string> -> IO CInt+#ccall cv_Algorithm_getList , Ptr <Algorithm> -> Ptr <vector_string> -> IO ()+#ccall cv_Algorithm_getMat , Ptr <Algorithm> -> Ptr <string> -> IO (Ptr <Mat>)+#ccall cv_Algorithm_getMatVector , Ptr <Algorithm> -> Ptr <string> -> IO (Ptr <vector_Mat>)+#ccall cv_getNumberOfCPUs , IO CInt+#ccall cv_getOptimalDFTSize , CInt -> IO CInt+#ccall cv_getOptimalNewCameraMatrix , Ptr <Mat> -> Ptr <Mat> -> Ptr <Size> -> CDouble -> Ptr <Size> -> Ptr <Rect> -> CInt -> IO (Ptr <Mat>)+#ccall cv_Algorithm_getParams , Ptr <Algorithm> -> Ptr <vector_string> -> IO ()+#ccall cv_getPerspectiveTransform , Ptr <Mat> -> Ptr <Mat> -> IO (Ptr <Mat>)+#ccall cv_KDTree_getPoints , Ptr <KDTree> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> IO ()+#ccall cv_getRectSubPix , Ptr <Mat> -> Ptr <Size> -> Ptr <Point2f> -> Ptr <Mat> -> CInt -> IO ()+#ccall cv_getRotationMatrix2D , Ptr <Point2f> -> CDouble -> CDouble -> IO (Ptr <Mat>)+#ccall cv_Algorithm_getString , Ptr <Algorithm> -> Ptr <string> -> IO (Ptr <string>)+#ccall cv_getStructuringElement , CInt -> Ptr <Size> -> Ptr <Point> -> IO (Ptr <Mat>)+#ccall cv_getTextSize , Ptr <string> -> CInt -> CDouble -> CInt -> Ptr CInt -> IO (Ptr <Size>)+#ccall cv_getTickCount , IO CLong+#ccall cv_getTickFrequency , IO CDouble+#ccall cv_getTrackbarPos , Ptr <string> -> Ptr <string> -> IO CInt+#ccall cv_DescriptorMatcher_getTrainDescriptors , Ptr <DescriptorMatcher> -> IO (Ptr <vector_Mat>)+#ccall cv_Subdiv2D_getTriangleList , Ptr <Subdiv2D> -> Ptr <vector_Vec6f> -> IO ()+#ccall cv_getValidDisparityROI , Ptr <Rect> -> Ptr <Rect> -> CInt -> CInt -> CInt -> IO (Ptr <Rect>)+#ccall cv_CvDTree_getVarImportance , Ptr <CvDTree> -> IO (Ptr <Mat>)+#ccall cv_CvRTrees_getVarImportance0 , Ptr <CvRTrees> -> IO (Ptr <Mat>)+#ccall cv_Subdiv2D_getVertex , Ptr <Subdiv2D> -> CInt -> Ptr CInt -> IO (Ptr <Point2f>)+#ccall cv_Subdiv2D_getVoronoiFacetList , Ptr <Subdiv2D> -> Ptr <vector_int> -> Ptr <vector_vector_Point2f> -> Ptr <vector_Point2f> -> IO ()+#ccall cv_HOGDescriptor_getWinSigma , Ptr <HOGDescriptor> -> IO CDouble+#ccall cv_getWindowProperty , Ptr <string> -> CInt -> IO CDouble+#ccall cv_CvSVM_get_support_vector_count , Ptr <CvSVM> -> IO CInt+#ccall cv_CvSVM_get_var_count , Ptr <CvSVM> -> IO CInt+#ccall cv_goodFeaturesToTrack , Ptr <Mat> -> Ptr <Mat> -> CInt -> CDouble -> CDouble -> Ptr <Mat> -> CInt -> CInt -> CDouble -> IO ()+#ccall cv_VideoCapture_grab , Ptr <VideoCapture> -> IO CInt+#ccall cv_grabCut , Ptr <Mat> -> Ptr <Mat> -> Ptr <Rect> -> Ptr <Mat> -> Ptr <Mat> -> CInt -> CInt -> IO ()+#ccall cv_groupRectangles , Ptr <vector_Rect> -> Ptr <vector_int> -> CInt -> CDouble -> IO ()+#ccall cv_hconcat , Ptr <vector_Mat> -> Ptr <Mat> -> IO ()+#ccall cv_idct , Ptr <Mat> -> Ptr <Mat> -> CInt -> IO ()+#ccall cv_idft , Ptr <Mat> -> Ptr <Mat> -> CInt -> CInt -> IO ()+#ccall cv_imdecode , Ptr <Mat> -> CInt -> IO (Ptr <Mat>)+#ccall cv_imencode , Ptr <string> -> Ptr <Mat> -> Ptr <vector_uchar> -> Ptr <vector_int> -> IO CInt+#ccall cv_imread , Ptr <string> -> CInt -> IO (Ptr <Mat>)+#ccall cv_imshow , Ptr <string> -> Ptr <Mat> -> IO ()+#ccall cv_imwrite , Ptr <string> -> Ptr <Mat> -> Ptr <vector_int> -> IO CInt+#ccall cv_inRange , Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> IO ()+#ccall cv_initCameraMatrix2D , Ptr <vector_Mat> -> Ptr <vector_Mat> -> Ptr <Size> -> CDouble -> IO (Ptr <Mat>)+#ccall cv_Subdiv2D_initDelaunay , Ptr <Subdiv2D> -> Ptr <Rect> -> IO ()+#ccall cv_initUndistortRectifyMap , Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Size> -> CInt -> Ptr <Mat> -> Ptr <Mat> -> IO ()+#ccall cv_initWideAngleProjMap , Ptr <Mat> -> Ptr <Mat> -> Ptr <Size> -> CInt -> CInt -> Ptr <Mat> -> Ptr <Mat> -> CInt -> CDouble -> IO CFloat+#ccall cv_Subdiv2D_insert , Ptr <Subdiv2D> -> Ptr <Point2f> -> IO CInt+#ccall cv_Subdiv2D_insert1 , Ptr <Subdiv2D> -> Ptr <vector_Point2f> -> IO ()+#ccall cv_insertChannel , Ptr <Mat> -> Ptr <Mat> -> CInt -> IO ()+#ccall cv_integral , Ptr <Mat> -> Ptr <Mat> -> CInt -> IO ()+#ccall cv_integral4 , Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> CInt -> IO ()+#ccall cv_integral5 , Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> CInt -> IO ()+#ccall cv_intersectConvexConvex , Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> CInt -> IO CFloat+#ccall cv_invert , Ptr <Mat> -> Ptr <Mat> -> CInt -> IO CDouble+#ccall cv_invertAffineTransform , Ptr <Mat> -> Ptr <Mat> -> IO ()+#ccall cv_isContourConvex , Ptr <Mat> -> IO CInt+#ccall cv_FileNode_isInt , Ptr <FileNode> -> IO CInt+#ccall cv_FileNode_isMap , Ptr <FileNode> -> IO CInt+#ccall cv_FileNode_isNamed , Ptr <FileNode> -> IO CInt+#ccall cv_FileNode_isNone , Ptr <FileNode> -> IO CInt+#ccall cv_FileStorage_isOpened , Ptr <FileStorage> -> IO CInt+#ccall cv_VideoWriter_isOpened0 , Ptr <VideoWriter> -> IO CInt+#ccall cv_FileNode_isReal , Ptr <FileNode> -> IO CInt+#ccall cv_FileNode_isSeq , Ptr <FileNode> -> IO CInt+#ccall cv_FileNode_isString , Ptr <FileNode> -> IO CInt+#ccall cv_EM_isTrained , Ptr <EM> -> IO CInt+#ccall cv_kmeans , Ptr <Mat> -> CInt -> Ptr <Mat> -> Ptr <TermCriteria> -> CInt -> CInt -> Ptr <Mat> -> IO CDouble+#ccall cv_DescriptorMatcher_knnMatch , Ptr <DescriptorMatcher> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <vector_vector_DMatch> -> CInt -> Ptr <Mat> -> CInt -> IO ()+#ccall cv_DescriptorMatcher_knnMatch5 , Ptr <DescriptorMatcher> -> Ptr <Mat> -> Ptr <vector_vector_DMatch> -> CInt -> Ptr <vector_Mat> -> CInt -> IO ()+#ccall cv_Index_knnSearch , Ptr <Index> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> CInt -> Ptr <SearchParams> -> IO ()+#ccall cv_line , Ptr <Mat> -> Ptr <Point> -> Ptr <Point> -> Ptr <Scalar> -> CInt -> CInt -> CInt -> IO ()+#ccall cv_Index_load , Ptr <Index> -> Ptr <Mat> -> Ptr <string> -> IO CInt+#ccall cv_FaceRecognizer_load1 , Ptr <FaceRecognizer> -> Ptr <string> -> IO ()+#ccall cv_HOGDescriptor_load2 , Ptr <HOGDescriptor> -> Ptr <String> -> Ptr <String> -> IO CInt+#ccall cv_Subdiv2D_locate , Ptr <Subdiv2D> -> Ptr <Point2f> -> CInt -> CInt -> IO CInt+#ccall cv_log , Ptr <Mat> -> Ptr <Mat> -> IO ()+#ccall cv_magnitude , Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> IO ()+#ccall cv_matMulDeriv , Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> IO ()+#ccall cv_DescriptorMatcher_match , Ptr <DescriptorMatcher> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <vector_DMatch> -> Ptr <Mat> -> IO ()+#ccall cv_DescriptorMatcher_match3 , Ptr <DescriptorMatcher> -> Ptr <Mat> -> Ptr <vector_DMatch> -> Ptr <vector_Mat> -> IO ()+#ccall cv_matchShapes , Ptr <Mat> -> Ptr <Mat> -> CInt -> CDouble -> IO CDouble+#ccall cv_matchTemplate , Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> CInt -> IO ()+#ccall cv_max , Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> IO ()+#ccall cv_mean , Ptr <Mat> -> Ptr <Mat> -> IO (Ptr <Scalar>)+#ccall cv_meanShift , Ptr <Mat> -> Ptr <Rect> -> Ptr <TermCriteria> -> IO CInt+#ccall cv_meanStdDev , Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> IO ()+#ccall cv_medianBlur , Ptr <Mat> -> Ptr <Mat> -> CInt -> IO ()+#ccall cv_merge , Ptr <vector_Mat> -> Ptr <Mat> -> IO ()+#ccall cv_min , Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> IO ()+#ccall cv_minAreaRect , Ptr <Mat> -> IO (Ptr <RotatedRect>)+#ccall cv_minEnclosingCircle , Ptr <Mat> -> Ptr <Point2f> -> CFloat -> IO ()+#ccall cv_minMaxLoc , Ptr <Mat> -> Ptr CDouble -> Ptr CDouble -> Ptr <Point> -> Ptr <Point> -> Ptr <Mat> -> IO ()+#ccall cv_mixChannels , Ptr <vector_Mat> -> Ptr <vector_Mat> -> Ptr <vector_int> -> IO ()+#ccall cv_moments , Ptr <Mat> -> CInt -> IO (Ptr <Moments>)+#ccall cv_morphologyEx , Ptr <Mat> -> Ptr <Mat> -> CInt -> Ptr <Mat> -> Ptr <Point> -> CInt -> CInt -> Ptr <Scalar> -> IO ()+#ccall cv_moveWindow , Ptr <string> -> CInt -> CInt -> IO ()+#ccall cv_mulSpectrums , Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> CInt -> CInt -> IO ()+#ccall cv_mulTransposed , Ptr <Mat> -> Ptr <Mat> -> CInt -> Ptr <Mat> -> CDouble -> CInt -> IO ()+#ccall cv_multiply , Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> CDouble -> CInt -> IO ()+#ccall cv_FileNode_name , Ptr <FileNode> -> IO (Ptr <string>)+#ccall cv_namedWindow , Ptr <string> -> CInt -> IO ()+#ccall cv_Subdiv2D_nextEdge , Ptr <Subdiv2D> -> CInt -> IO CInt+#ccall cv_norm , Ptr <Mat> -> CInt -> Ptr <Mat> -> IO CDouble+#ccall cv_norm4 , Ptr <Mat> -> Ptr <Mat> -> CInt -> Ptr <Mat> -> IO CDouble+#ccall cv_normalize , Ptr <Mat> -> Ptr <Mat> -> CDouble -> CDouble -> CInt -> CInt -> Ptr <Mat> -> IO ()+#ccall cv_FileStorage_open , Ptr <FileStorage> -> Ptr <string> -> CInt -> Ptr <string> -> IO CInt+#ccall cv_VideoCapture_open1 , Ptr <VideoCapture> -> CInt -> IO CInt+#ccall cv_VideoWriter_open5 , Ptr <VideoWriter> -> Ptr <string> -> CInt -> CDouble -> Ptr <Size> -> CInt -> IO CInt+#ccall cv_StereoBM_call , Ptr <StereoBM> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> CInt -> IO ()+#ccall cv_StarDetector_call , Ptr <StarDetector> -> Ptr <Mat> -> Ptr <vector_KeyPoint> -> IO ()+#ccall cv_StereoVar_call , Ptr <StereoVar> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> IO ()+#ccall cv_Feature2D_call , Ptr <Feature2D> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <vector_KeyPoint> -> Ptr <Mat> -> CInt -> IO ()+#ccall cv_FileStorage_getelem , Ptr <FileStorage> -> CString -> IO (Ptr <FileNode>)+#ccall cv_FileNode_getelem , Ptr <FileNode> -> CInt -> IO (Ptr <FileNode>)+#ccall cv_Algorithm_paramHelp , Ptr <Algorithm> -> Ptr <string> -> IO (Ptr <string>)+#ccall cv_Algorithm_paramType , Ptr <Algorithm> -> Ptr <string> -> IO CInt+#ccall cv_patchNaNs , Ptr <Mat> -> CDouble -> IO ()+#ccall cv_perspectiveTransform , Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> IO ()+#ccall cv_phase , Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> CInt -> IO ()+#ccall cv_phaseCorrelate , Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> IO (Ptr <Point2d>)+#ccall cv_phaseCorrelateRes , Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr CDouble -> IO (Ptr <Point2d>)+#ccall cv_pointPolygonTest , Ptr <Mat> -> Ptr <Point2f> -> CInt -> IO CDouble+#ccall cv_polarToCart , Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> CInt -> IO ()+#ccall cv_polylines , Ptr <Mat> -> Ptr <vector_Mat> -> CInt -> Ptr <Scalar> -> CInt -> CInt -> CInt -> IO ()+#ccall cv_pow , Ptr <Mat> -> CDouble -> Ptr <Mat> -> IO ()+#ccall cv_preCornerDetect , Ptr <Mat> -> Ptr <Mat> -> CInt -> CInt -> IO ()+#ccall cv_CvNormalBayesClassifier_predict , Ptr <CvNormalBayesClassifier> -> Ptr <Mat> -> Ptr <Mat> -> IO CFloat+#ccall cv_KalmanFilter_predict1 , Ptr <KalmanFilter> -> Ptr <Mat> -> IO (Ptr <Mat>)+#ccall cv_CvANN_MLP_predict2 , Ptr <CvANN_MLP> -> Ptr <Mat> -> Ptr <Mat> -> IO CFloat+#ccall cv_FaceRecognizer_predict3 , Ptr <FaceRecognizer> -> Ptr <Mat> -> CInt -> CDouble -> IO ()+#ccall cv_CvGBTrees_predict4 , Ptr <CvGBTrees> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Range> -> CInt -> IO CFloat+#ccall cv_CvBoost_predict5 , Ptr <CvBoost> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Range> -> CInt -> CInt -> IO CFloat+#ccall cv_CvRTrees_predict_prob , Ptr <CvRTrees> -> Ptr <Mat> -> Ptr <Mat> -> IO CFloat+#ccall cv_projectPoints , Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> CDouble -> IO ()+#ccall cv_CvBoost_prune , Ptr <CvBoost> -> Ptr <CvSlice> -> IO ()+#ccall cv_putText , Ptr <Mat> -> Ptr <string> -> Ptr <Point> -> CInt -> CDouble -> Ptr <Scalar> -> CInt -> CInt -> CInt -> IO ()+#ccall cv_pyrDown , Ptr <Mat> -> Ptr <Mat> -> Ptr <Size> -> CInt -> IO ()+#ccall cv_pyrMeanShiftFiltering , Ptr <Mat> -> Ptr <Mat> -> CDouble -> CDouble -> CInt -> Ptr <TermCriteria> -> IO ()+#ccall cv_pyrUp , Ptr <Mat> -> Ptr <Mat> -> Ptr <Size> -> CInt -> IO ()+#ccall cv_Index_radiusSearch , Ptr <Index> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> CDouble -> CInt -> Ptr <SearchParams> -> IO CInt+#ccall cv_randShuffle_ , Ptr <Mat> -> CDouble -> IO ()+#ccall cv_randn , Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> IO ()+#ccall cv_randu , Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> IO ()+#ccall cv_VideoCapture_read , Ptr <VideoCapture> -> Ptr <Mat> -> IO CInt+#ccall cv_rectangle , Ptr <Mat> -> Ptr <Point> -> Ptr <Point> -> Ptr <Scalar> -> CInt -> CInt -> CInt -> IO ()+#ccall cv_rectify3Collinear , Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <vector_Mat> -> Ptr <vector_Mat> -> Ptr <Size> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> CDouble -> Ptr <Size> -> Ptr <Rect> -> Ptr <Rect> -> CInt -> IO CFloat+#ccall cv_reduce , Ptr <Mat> -> Ptr <Mat> -> CInt -> CInt -> CInt -> IO ()+#ccall cv_FileStorage_release , Ptr <FileStorage> -> IO ()+#ccall cv_VideoWriter_release0 , Ptr <VideoWriter> -> IO ()+#ccall cv_FileStorage_releaseAndGetString , Ptr <FileStorage> -> IO (Ptr <string>)+#ccall cv_remap , Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> CInt -> CInt -> Ptr <Scalar> -> IO ()+#ccall cv_repeat , Ptr <Mat> -> CInt -> CInt -> Ptr <Mat> -> IO ()+#ccall cv_reprojectImageTo3D , Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> CInt -> CInt -> IO ()+#ccall cv_resize , Ptr <Mat> -> Ptr <Mat> -> Ptr <Size> -> CDouble -> CDouble -> CInt -> IO ()+#ccall cv_resizeWindow , Ptr <string> -> CInt -> CInt -> IO ()+#ccall cv_VideoCapture_retrieve , Ptr <VideoCapture> -> Ptr <Mat> -> CInt -> IO CInt+#ccall cv_FileStorage_root , Ptr <FileStorage> -> CInt -> IO (Ptr <FileNode>)+#ccall cv_Subdiv2D_rotateEdge , Ptr <Subdiv2D> -> CInt -> CInt -> IO CInt+#ccall cv_Index_save , Ptr <Index> -> Ptr <string> -> IO ()+#ccall cv_FaceRecognizer_save1 , Ptr <FaceRecognizer> -> Ptr <string> -> IO ()+#ccall cv_HOGDescriptor_save2 , Ptr <HOGDescriptor> -> Ptr <String> -> Ptr <String> -> IO ()+#ccall cv_scaleAdd , Ptr <Mat> -> CDouble -> Ptr <Mat> -> Ptr <Mat> -> IO ()+#ccall cv_segmentMotion , Ptr <Mat> -> Ptr <Mat> -> Ptr <vector_Rect> -> CDouble -> CDouble -> IO ()+#ccall cv_sepFilter2D , Ptr <Mat> -> Ptr <Mat> -> CInt -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Point> -> CDouble -> CInt -> IO ()+#ccall cv_VideoCapture_set , Ptr <VideoCapture> -> CInt -> CDouble -> IO CInt+#ccall cv_Algorithm_setAlgorithm , Ptr <Algorithm> -> Ptr <string> -> Ptr <Algorithm> -> IO ()+#ccall cv_Algorithm_setBool , Ptr <Algorithm> -> Ptr <string> -> CInt -> IO ()+#ccall cv_CLAHE_setClipLimit , Ptr <CLAHE> -> CDouble -> IO ()+#ccall cv_Algorithm_setDouble , Ptr <Algorithm> -> Ptr <string> -> CDouble -> IO ()+#ccall cv_setIdentity , Ptr <Mat> -> Ptr <Scalar> -> IO ()+#ccall cv_Algorithm_setInt , Ptr <Algorithm> -> Ptr <string> -> CInt -> IO ()+#ccall cv_Algorithm_setMat , Ptr <Algorithm> -> Ptr <string> -> Ptr <Mat> -> IO ()+#ccall cv_Algorithm_setMatVector , Ptr <Algorithm> -> Ptr <string> -> Ptr <vector_Mat> -> IO ()+#ccall cv_HOGDescriptor_setSVMDetector , Ptr <HOGDescriptor> -> Ptr <Mat> -> IO ()+#ccall cv_Algorithm_setString , Ptr <Algorithm> -> Ptr <string> -> Ptr <string> -> IO ()+#ccall cv_CLAHE_setTilesGridSize , Ptr <CLAHE> -> Ptr <Size> -> IO ()+#ccall cv_setTrackbarPos , Ptr <string> -> Ptr <string> -> CInt -> IO ()+#ccall cv_setUseOptimized , CInt -> IO ()+#ccall cv_setWindowProperty , Ptr <string> -> CInt -> CDouble -> IO ()+#ccall cv_FileNode_size , Ptr <FileNode> -> IO CSize+#ccall cv_solve , Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> CInt -> IO CInt+#ccall cv_solveCubic , Ptr <Mat> -> Ptr <Mat> -> IO CInt+#ccall cv_solvePnP , Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> CInt -> CInt -> IO CInt+#ccall cv_solvePnPRansac , Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> CInt -> CInt -> CFloat -> CInt -> Ptr <Mat> -> CInt -> IO ()+#ccall cv_solvePoly , Ptr <Mat> -> Ptr <Mat> -> CInt -> IO CDouble+#ccall cv_sort , Ptr <Mat> -> Ptr <Mat> -> CInt -> IO ()+#ccall cv_sortIdx , Ptr <Mat> -> Ptr <Mat> -> CInt -> IO ()+#ccall cv_split , Ptr <Mat> -> Ptr <vector_Mat> -> IO ()+#ccall cv_sqrt , Ptr <Mat> -> Ptr <Mat> -> IO ()+#ccall cv_startWindowThread , IO CInt+#ccall cv_stereoCalibrate , Ptr <vector_Mat> -> Ptr <vector_Mat> -> Ptr <vector_Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Size> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <TermCriteria> -> CInt -> IO CDouble+#ccall cv_stereoRectify , Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Size> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> CInt -> CDouble -> Ptr <Size> -> Ptr <Rect> -> Ptr <Rect> -> IO ()+#ccall cv_stereoRectifyUncalibrated , Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Size> -> Ptr <Mat> -> Ptr <Mat> -> CDouble -> IO CInt+#ccall cv_subtract , Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> CInt -> IO ()+#ccall cv_sum , Ptr <Mat> -> IO (Ptr <Scalar>)+#ccall cv_Subdiv2D_symEdge , Ptr <Subdiv2D> -> CInt -> IO CInt+#ccall cv_threshold , Ptr <Mat> -> Ptr <Mat> -> CDouble -> CDouble -> CInt -> IO CDouble+#ccall cv_trace , Ptr <Mat> -> IO (Ptr <Scalar>)+#ccall cv_CvNormalBayesClassifier_train , Ptr <CvNormalBayesClassifier> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> CInt -> IO CInt+#ccall cv_DescriptorMatcher_train0 , Ptr <DescriptorMatcher> -> IO ()+#ccall cv_FaceRecognizer_train2 , Ptr <FaceRecognizer> -> Ptr <vector_Mat> -> Ptr <Mat> -> IO ()+#ccall cv_EM_train4 , Ptr <EM> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> IO CInt+#ccall cv_CvSVM_train5 , Ptr <CvSVM> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <CvSVMParams> -> IO CInt+#ccall cv_CvANN_MLP_train6 , Ptr <CvANN_MLP> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <CvANN_MLP_TrainParams> -> CInt -> IO CInt+#ccall cv_CvERTrees_train8 , Ptr <CvERTrees> -> Ptr <Mat> -> CInt -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <CvRTParams> -> IO CInt+#ccall cv_CvGBTrees_train9 , Ptr <CvGBTrees> -> Ptr <Mat> -> CInt -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <CvGBTreesParams> -> CInt -> IO CInt+#ccall cv_EM_trainE , Ptr <EM> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> IO CInt+#ccall cv_EM_trainM , Ptr <EM> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> IO CInt+#ccall cv_CvSVM_train_auto , Ptr <CvSVM> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <CvSVMParams> -> CInt -> Ptr <CvParamGrid> -> Ptr <CvParamGrid> -> Ptr <CvParamGrid> -> Ptr <CvParamGrid> -> Ptr <CvParamGrid> -> Ptr <CvParamGrid> -> CInt -> IO CInt+#ccall cv_transform , Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> IO ()+#ccall cv_transpose , Ptr <Mat> -> Ptr <Mat> -> IO ()+#ccall cv_triangulatePoints , Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> IO ()+#ccall cv_FileNode_type , Ptr <FileNode> -> IO CInt+#ccall cv_undistort , Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> IO ()+#ccall cv_undistortPoints , Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> IO ()+#ccall cv_FaceRecognizer_update , Ptr <FaceRecognizer> -> Ptr <vector_Mat> -> Ptr <Mat> -> IO ()+#ccall cv_updateMotionHistory , Ptr <Mat> -> Ptr <Mat> -> CDouble -> CDouble -> IO ()+#ccall cv_useOptimized , IO CInt+#ccall cv_validateDisparity , Ptr <Mat> -> Ptr <Mat> -> CInt -> CInt -> CInt -> IO ()+#ccall cv_vconcat , Ptr <vector_Mat> -> Ptr <Mat> -> IO ()+#ccall cv_waitKey , CInt -> IO CInt+#ccall cv_warpAffine , Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Size> -> CInt -> CInt -> Ptr <Scalar> -> IO ()+#ccall cv_warpPerspective , Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> Ptr <Size> -> CInt -> CInt -> Ptr <Scalar> -> IO ()+#ccall cv_watershed , Ptr <Mat> -> Ptr <Mat> -> IO ()+#ccall cv_VideoWriter_write , Ptr <VideoWriter> -> Ptr <Mat> -> IO ()
+ OpenCVRaw/Mat.hsc view
@@ -0,0 +1,50 @@+{-# LANGUAGE ForeignFunctionInterface #-}+#include <bindings.dsl.h>+#include <mat.hpp>+module OpenCVRaw.Mat where+#strict_import++import OpenCVRaw.Types+import Foreign.C+import Foreign.C.Types+import Foreign.Ptr+import Foreign.ForeignPtr+import Data.Vector.Storable+++#ccall cv_create_Mat        , IO (Ptr <Mat>)+#ccall cv_Mat_getRow        , Ptr <Mat> -> CInt -> IO (Ptr <Mat>)+#ccall cv_Mat_getCol        , Ptr <Mat> -> CInt -> IO (Ptr <Mat>)+#ccall cv_Mat_getRowRange   , Ptr <Mat> -> CInt -> CInt -> IO (Ptr <Mat>)+#ccall cv_Mat_getColRange   , Ptr <Mat> -> CInt -> CInt -> IO (Ptr <Mat>)+#ccall cv_Mat_elemSize      , Ptr <Mat> -> IO CSize+#ccall cv_Mat_elemSize1     , Ptr <Mat> -> IO CSize+#ccall cv_Mat_type          , Ptr <Mat> -> IO CInt+#ccall cv_Mat_depth         , Ptr <Mat> -> IO CInt+#ccall cv_Mat_total         , Ptr <Mat> -> IO CSize+#ccall cv_Mat_isContinuous  , Ptr <Mat> -> IO CInt+#ccall cv_Mat_channels      , Ptr <Mat> -> IO CInt+#ccall cv_Mat_rows          , Ptr <Mat> -> IO CInt+#ccall cv_Mat_cols          , Ptr <Mat> -> IO CInt+#ccall cv_Mat_empty         , Ptr <Mat> -> IO CInt+#ccall cv_Mat_size          , Ptr <Mat> -> IO (Ptr <Size>)+#ccall cv_Mat_step1         , Ptr <Mat> -> IO CSize+#ccall cv_Mat_diag          , Ptr <Mat> -> IO (Ptr <Mat>)+#ccall cv_Mat_diag_d        , Ptr <Mat> -> CInt -> IO (Ptr <Mat>)+#ccall cv_create_diagMat    , Ptr <Mat> -> IO (Ptr <Mat>)++#ccall cv_Mat_assign        , Ptr <Mat> -> Ptr <Mat> -> IO (Ptr <Mat>) +#ccall cv_Mat_assignVal     , Ptr <Mat> -> Ptr <Scalar> -> IO (Ptr <Mat>) +#ccall cv_Mat_clone         , Ptr <Mat> -> IO (Ptr <Mat>)+#ccall cv_Mat_copyTo        , Ptr <Mat> -> Ptr <Mat> -> IO ()+#ccall cv_Mat_copyTo_masked , Ptr <Mat> -> Ptr <Mat> -> Ptr <Mat> -> IO ()+#ccall cv_Mat_assignTo      , Ptr <Mat> -> Ptr <Mat> -> IO ()+#ccall cv_Mat_assignTo_t    , Ptr <Mat> -> Ptr <Mat> -> CInt -> IO ()+#ccall cv_Mat_setTo         , Ptr <Mat> -> Ptr <Scalar> -> IO (Ptr <Mat>)+#ccall cv_Mat_setTo_masked  , Ptr <Mat> -> Ptr <Scalar> -> Ptr <Mat> -> IO (Ptr <Mat>)++#ccall cv_Mat_reshape       , Ptr <Mat> -> CInt -> IO (Ptr <Mat>)+#ccall cv_Mat_reshape_rows  , Ptr <Mat> -> CInt -> CInt -> IO (Ptr <Mat>)++#ccall cv_Mat_ptr           , Ptr <Mat> -> IO (Ptr CUChar)+
+ OpenCVRaw/Types.hsc view
@@ -0,0 +1,99 @@+{-# LANGUAGE ForeignFunctionInterface #-}+#include <bindings.dsl.h>+#include <opencv_generated.hpp>+module OpenCVRaw.Types where+#strict_import+import Foreign.C+import Foreign.C.Types+#opaque_t Algorithm+#opaque_t CLAHE+#opaque_t CvANN_MLP+#opaque_t CvANN_MLP_TrainParams+#opaque_t CvBoost+#opaque_t CvBoostParams+#opaque_t CvDTree+#opaque_t CvDTreeNode+#opaque_t CvDTreeParams+#opaque_t CvERTrees+#opaque_t CvGBTrees+#opaque_t CvGBTreesParams+#opaque_t CvKNearest+#opaque_t CvNormalBayesClassifier+#opaque_t CvParamGrid+#opaque_t CvRTParams+#opaque_t CvRTrees+#opaque_t CvSVM+#opaque_t CvSVMParams+#opaque_t CvSlice+#opaque_t CvStatModel+#opaque_t DescriptorExtractor+#opaque_t DescriptorMatcher+#opaque_t FaceRecognizer+#opaque_t Feature2D+#opaque_t FeatureDetector+#opaque_t FileNode+#opaque_t IndexParams+#opaque_t Mat+#opaque_t Moments+#opaque_t Point+#opaque_t Point2d+#opaque_t Point2f+#opaque_t Range+#opaque_t Rect+#opaque_t RotatedRect+#opaque_t Scalar+#opaque_t SearchParams+#opaque_t Params+#opaque_t Size+#opaque_t String+#opaque_t TermCriteria+#opaque_t Vec2d+#opaque_t Vec3d+#opaque_t BFMatcher+#opaque_t BRISK+#opaque_t BackgroundSubtractor+#opaque_t BackgroundSubtractorMOG+#opaque_t CascadeClassifier+#opaque_t EM+#opaque_t FastFeatureDetector+#opaque_t FileStorage+#opaque_t FlannBasedMatcher+#opaque_t GFTTDetector+#opaque_t GridAdaptedFeatureDetector+#opaque_t KDTree+#opaque_t KalmanFilter+#opaque_t KeyPoint+#opaque_t MSER+#opaque_t ORB+#opaque_t PyramidAdaptedFeatureDetector+#opaque_t SimpleBlobDetector+#opaque_t StarDetector+#opaque_t StereoBM+#opaque_t StereoSGBM+#opaque_t StereoVar+#opaque_t Subdiv2D+#opaque_t VideoCapture+#opaque_t VideoWriter+#opaque_t Index+#opaque_t flann_algorithm_t+#opaque_t flann_distance_t+#opaque_t explicit+#opaque_t string+#opaque_t DMatch+#opaque_t HOGDescriptor+#opaque_t vector_DMatch+#opaque_t vector_KeyPoint+#opaque_t vector_Mat+#opaque_t vector_Point+#opaque_t vector_Point2f+#opaque_t vector_Rect+#opaque_t vector_Vec4f+#opaque_t vector_Vec6f+#opaque_t vector_double+#opaque_t vector_float+#opaque_t vector_int+#opaque_t vector_string+#opaque_t vector_uchar+#opaque_t vector_vector_DMatch+#opaque_t vector_vector_Point+#opaque_t vector_vector_Point2f
+ Setup.hs view
@@ -0,0 +1,8 @@+import Distribution.Simple++main :: IO ()+main = defaultMainWithHooks simpleUserHooks {+                                            -- The following hook prevents cabal from checking to see if generated cpp header and+                                            -- source files actually compile before completing configuration.+                                            postConf = postConf emptyUserHooks } +
+ cbits/cpptypes.cpp view
@@ -0,0 +1,33 @@+/*+ * =====================================================================================+ *+ *       Filename:  cpptypes.cpp+ *+ *    Description:  + *+ *        Version:  1.0+ *        Created:  09/24/13 20:14:24+ *       Revision:  none+ *       Compiler:  gcc+ *+ *         Author:  YOUR NAME (), + *   Organization:  + *+ * =====================================================================================+ */+#include <opencv_generated.hpp>+#include <cpptypes.hpp>++extern "C" {+string* std_create_string(char* s, int len) {++    return new string(*s, len);++}++vector_int* std_create_vector_int(int* is, size_t len) {++    return new vector_int(is, is + len);++}+}
+ cbits/mat.cpp view
@@ -0,0 +1,148 @@+/*+ * =====================================================================================+ *+ *       Filename:  mat.cpp+ *+ *    Description:  + *+ *        Version:  1.0+ *        Created:  09/24/13 20:12:17+ *       Revision:  none+ *       Compiler:  gcc+ *+ *         Author:  YOUR NAME (), + *   Organization:  + *+ * =====================================================================================+ */+#include <opencv_generated.hpp>+#include <mat.hpp>++extern "C" {+Mat* cv_create_Mat() {+    return new Mat();+}++Mat* cv_Mat_assign(Mat* self, Mat* m) {+    *self = *m;+    return self;+}++Mat* cv_Mat_assignVal(Mat* self, Scalar* s) {+    *self = *s;+    return self;+}++Mat* cv_Mat_getRow(Mat* self, int y) {+    return new Mat(self->row(y));+}++Mat* cv_Mat_getCol(Mat* self, int x) {+    return new Mat(self->col(x));+}++Mat* cv_Mat_getRowRange(Mat* self, int startrow, int endrow) {+    return new Mat(self->rowRange(startrow, endrow));+}+Mat* cv_Mat_getColRange(Mat* self, int startcol, int endrow) {+    return new Mat(self->colRange(startcol, endrow));+}+Mat* cv_Mat_diag(Mat* self) {+    return new Mat(self->diag());+}++Mat* cv_Mat_diag_d(Mat* self, int d) {+    return new Mat(self->diag(d));+}++Mat* cv_create_diagMat(Mat* d) {+    return new Mat(Mat::diag(*d));+}++Mat* cv_Mat_clone(Mat* self) {+    return new Mat(self->clone());+}++void cv_Mat_copyTo(Mat* self, Mat* m) {+    self->copyTo(*m);+}++void cv_Mat_copyTo_masked(Mat* self, Mat* m, Mat* mask) {+    self->copyTo(*m, *mask);+}++void cv_Mat_assignTo(Mat* self, Mat* m) {+    self->assignTo(*m);+}++void cv_Mat_assignTo_t(Mat*self, Mat* m, int t) {+    self->assignTo(*m, t);+}++Mat* cv_Mat_setTo(Mat* self, Scalar* value) {+    Mat* m = new Mat;+    *m = *value;+    self->setTo(*m);+}++Mat* cv_Mat_setTo_masked(Mat* self, Scalar* value, Mat* mask) {+    Mat* m = new Mat;+    *m = *value;+    self->setTo(*m, *mask);+}++Mat* cv_Mat_reshape(Mat* self, int cn) {+   return new Mat(self->reshape(cn)); +}++Mat* cv_Mat_reshape_rows(Mat* self, int cn, int rows) {+   return new Mat(self->reshape(cn, rows)); +}+++size_t cv_Mat_elemSize(Mat* self) {+    return self->elemSize();+}++size_t cv_Mat_elemSize1(Mat* self) {+    return self->elemSize1();+}++int cv_Mat_type(Mat* self) {+    return self->type();+}++int cv_Mat_depth(Mat* self) {+    return self->depth();+}++size_t cv_Mat_total(Mat* self) {+    return self->total();+}++bool cv_Mat_isContinuous(Mat* self) {+    return self->isContinuous();+}++int cv_Mat_channels(Mat* self) {+    return self->channels();+}+int cv_Mat_rows(Mat* self) {+    return self->rows;+}+int cv_Mat_cols(Mat* self) {+    return self->cols;+}+int cv_Mat_empty(Mat* self) {+    return self->empty();+}+Size* cv_Mat_size(Mat* self) {+    return new Size(self->size());+}+size_t cv_Mat_step1(Mat* self) {+    return self->step1();+}+uchar* cv_Mat_ptr(Mat* self) {+    return self->ptr();+}+}
+ cbits/opencv_generated.cpp view
@@ -0,0 +1,1408 @@+#include "opencv_generated.hpp"+using namespace cv;+using namespace std;+using namespace flann;+using namespace cvflann;+extern "C" {+BFMatcher* cv_create_BFMatcher(int normType, bool crossCheck) {+	return new BFMatcher(normType, crossCheck);+}+BRISK* cv_create_BRISK(int thresh, int octaves, float patternScale) {+	return new BRISK(thresh, octaves, patternScale);+}+BRISK* cv_create_BRISK5(vector_float* radiusList, vector_int* numberList, float dMax, float dMin, vector_int* indexChange) {+	return new BRISK(*radiusList, *numberList, dMax, dMin, *indexChange);+}+BackgroundSubtractorMOG* cv_create_BackgroundSubtractorMOG() {+	return new BackgroundSubtractorMOG();+}+BackgroundSubtractorMOG* cv_create_BackgroundSubtractorMOG4(int history, int nmixtures, double backgroundRatio, double noiseSigma) {+	return new BackgroundSubtractorMOG(history, nmixtures, backgroundRatio, noiseSigma);+}+RotatedRect* cv_CamShift(Mat* probImage, Rect* window, TermCriteria* criteria) {+	return new RotatedRect(cv::CamShift(*probImage, *window, *criteria));+}+void cv_Canny(Mat* image, Mat* edges, double threshold1, double threshold2, int apertureSize, bool L2gradient) {+	cv::Canny(*image, *edges, threshold1, threshold2, apertureSize, L2gradient);+}+CascadeClassifier* cv_create_CascadeClassifier() {+	return new CascadeClassifier();+}+CascadeClassifier* cv_create_CascadeClassifier1(string* filename) {+	return new CascadeClassifier(*filename);+}+CvANN_MLP* cv_create_CvANN_MLP() {+	return new CvANN_MLP();+}+CvANN_MLP* cv_create_CvANN_MLP4(Mat* layerSizes, int activateFunc, double fparam1, double fparam2) {+	return new CvANN_MLP(*layerSizes, activateFunc, fparam1, fparam2);+}+CvBoost* cv_create_CvBoost() {+	return new CvBoost();+}+CvBoost* cv_create_CvBoost8(Mat* trainData, int tflag, Mat* responses, Mat* varIdx, Mat* sampleIdx, Mat* varType, Mat* missingDataMask, CvBoostParams* params) {+	return new CvBoost(*trainData, tflag, *responses, *varIdx, *sampleIdx, *varType, *missingDataMask, *params);+}+CvDTree* cv_create_CvDTree() {+	return new CvDTree();+}+CvERTrees* cv_create_CvERTrees() {+	return new CvERTrees();+}+CvGBTrees* cv_create_CvGBTrees() {+	return new CvGBTrees();+}+CvGBTrees* cv_create_CvGBTrees8(Mat* trainData, int tflag, Mat* responses, Mat* varIdx, Mat* sampleIdx, Mat* varType, Mat* missingDataMask, CvGBTreesParams* params) {+	return new CvGBTrees(*trainData, tflag, *responses, *varIdx, *sampleIdx, *varType, *missingDataMask, *params);+}+CvKNearest* cv_create_CvKNearest() {+	return new CvKNearest();+}+CvKNearest* cv_create_CvKNearest5(Mat* trainData, Mat* responses, Mat* sampleIdx, bool isRegression, int max_k) {+	return new CvKNearest(*trainData, *responses, *sampleIdx, isRegression, max_k);+}+CvNormalBayesClassifier* cv_create_CvNormalBayesClassifier() {+	return new CvNormalBayesClassifier();+}+CvNormalBayesClassifier* cv_create_CvNormalBayesClassifier4(Mat* trainData, Mat* responses, Mat* varIdx, Mat* sampleIdx) {+	return new CvNormalBayesClassifier(*trainData, *responses, *varIdx, *sampleIdx);+}+CvRTrees* cv_create_CvRTrees() {+	return new CvRTrees();+}+CvSVM* cv_create_CvSVM() {+	return new CvSVM();+}+CvSVM* cv_create_CvSVM5(Mat* trainData, Mat* responses, Mat* varIdx, Mat* sampleIdx, CvSVMParams* params) {+	return new CvSVM(*trainData, *responses, *varIdx, *sampleIdx, *params);+}+DMatch* cv_create_DMatch() {+	return new DMatch();+}+DMatch* cv_create_DMatch3(int _queryIdx, int _trainIdx, float _distance) {+	return new DMatch(_queryIdx, _trainIdx, _distance);+}+DMatch* cv_create_DMatch4(int _queryIdx, int _trainIdx, int _imgIdx, float _distance) {+	return new DMatch(_queryIdx, _trainIdx, _imgIdx, _distance);+}+EM* cv_create_EM(int nclusters, int covMatType, TermCriteria* termCrit) {+	return new EM(nclusters, covMatType, *termCrit);+}+FastFeatureDetector* cv_create_FastFeatureDetector(int threshold, bool nonmaxSuppression) {+	return new FastFeatureDetector(threshold, nonmaxSuppression);+}+FileNode* cv_create_FileNode() {+	return new FileNode();+}+FileStorage* cv_create_FileStorage() {+	return new FileStorage();+}+FileStorage* cv_create_FileStorage3(string* source, int flags, string* encoding) {+	return new FileStorage(*source, flags, *encoding);+}+FlannBasedMatcher* cv_create_FlannBasedMatcher(flann_IndexParams* indexParams, flann_SearchParams* searchParams) {+	return new FlannBasedMatcher(indexParams, searchParams);+}+GFTTDetector* cv_create_GFTTDetector(int maxCorners, double qualityLevel, double minDistance, int blockSize, bool useHarrisDetector, double k) {+	return new GFTTDetector(maxCorners, qualityLevel, minDistance, blockSize, useHarrisDetector, k);+}+void cv_GaussianBlur(Mat* src, Mat* dst, Size* ksize, double sigmaX, double sigmaY, int borderType) {+	cv::GaussianBlur(*src, *dst, *ksize, sigmaX, sigmaY, borderType);+}+GridAdaptedFeatureDetector* cv_create_GridAdaptedFeatureDetector(FeatureDetector* detector, int maxTotalKeypoints, int gridRows, int gridCols) {+	return new GridAdaptedFeatureDetector(detector, maxTotalKeypoints, gridRows, gridCols);+}+HOGDescriptor* cv_create_HOGDescriptor() {+	return new HOGDescriptor();+}+HOGDescriptor* cv_create_HOGDescriptor1(String* filename) {+	return new HOGDescriptor(*filename);+}+HOGDescriptor* cv_create_HOGDescriptor11(Size* _winSize, Size* _blockSize, Size* _blockStride, Size* _cellSize, int _nbins, int _derivAperture, double _winSigma, int _histogramNormType, double _L2HysThreshold, bool _gammaCorrection, int _nlevels) {+	return new HOGDescriptor(*_winSize, *_blockSize, *_blockStride, *_cellSize, _nbins, _derivAperture, _winSigma, _histogramNormType, _L2HysThreshold, _gammaCorrection, _nlevels);+}+void cv_HoughCircles(Mat* image, Mat* circles, int method, double dp, double minDist, double param1, double param2, int minRadius, int maxRadius) {+	cv::HoughCircles(*image, *circles, method, dp, minDist, param1, param2, minRadius, maxRadius);+}+void cv_HoughLines(Mat* image, Mat* lines, double rho, double theta, int threshold, double srn, double stn) {+	cv::HoughLines(*image, *lines, rho, theta, threshold, srn, stn);+}+void cv_HoughLinesP(Mat* image, Mat* lines, double rho, double theta, int threshold, double minLineLength, double maxLineGap) {+	cv::HoughLinesP(*image, *lines, rho, theta, threshold, minLineLength, maxLineGap);+}+void cv_HuMoments(Moments* m, Mat* hu) {+	cv::HuMoments(*m, *hu);+}+Index* cv_create_Index() {+	return new Index();+}+Index* cv_create_Index3(Mat* features, IndexParams* params, cvflann_flann_distance_t* distType) {+	return new Index(*features, *params, *distType);+}+KDTree* cv_create_KDTree() {+	return new KDTree();+}+KDTree* cv_create_KDTree2(Mat* points, bool copyAndReorderPoints) {+	return new KDTree(*points, copyAndReorderPoints);+}+KDTree* cv_create_KDTree3(Mat* points, Mat* _labels, bool copyAndReorderPoints) {+	return new KDTree(*points, *_labels, copyAndReorderPoints);+}+KalmanFilter* cv_create_KalmanFilter() {+	return new KalmanFilter();+}+KalmanFilter* cv_create_KalmanFilter4(int dynamParams, int measureParams, int controlParams, int type) {+	return new KalmanFilter(dynamParams, measureParams, controlParams, type);+}+KeyPoint* cv_create_KeyPoint() {+	return new KeyPoint();+}+KeyPoint* cv_create_KeyPoint7(float x, float y, float _size, float _angle, float _response, int _octave, int _class_id) {+	return new KeyPoint(x, y, _size, _angle, _response, _octave, _class_id);+}+void cv_LUT(Mat* src, Mat* lut, Mat* dst, int interpolation) {+	cv::LUT(*src, *lut, *dst, interpolation);+}+void cv_Laplacian(Mat* src, Mat* dst, int ddepth, int ksize, double scale, double delta, int borderType) {+	cv::Laplacian(*src, *dst, ddepth, ksize, scale, delta, borderType);+}+MSER* cv_create_MSER(int _delta, int _min_area, int _max_area, double _max_variation, double _min_diversity, int _max_evolution, double _area_threshold, double _min_margin, int _edge_blur_size) {+	return new MSER(_delta, _min_area, _max_area, _max_variation, _min_diversity, _max_evolution, _area_threshold, _min_margin, _edge_blur_size);+}+double cv_Mahalanobis(Mat* v1, Mat* v2, Mat* icovar) {+	return cv::Mahalanobis(*v1, *v2, *icovar);+}+ORB* cv_create_ORB(int nfeatures, float scaleFactor, int nlevels, int edgeThreshold, int firstLevel, int WTA_K, int scoreType, int patchSize) {+	return new ORB(nfeatures, scaleFactor, nlevels, edgeThreshold, firstLevel, WTA_K, scoreType, patchSize);+}+void cv_PCABackProject(Mat* data, Mat* mean, Mat* eigenvectors, Mat* result) {+	cv::PCABackProject(*data, *mean, *eigenvectors, *result);+}+void cv_PCACompute(Mat* data, Mat* mean, Mat* eigenvectors, int maxComponents) {+	cv::PCACompute(*data, *mean, *eigenvectors, maxComponents);+}+void cv_PCAComputeVar(Mat* data, Mat* mean, Mat* eigenvectors, double retainedVariance) {+	cv::PCAComputeVar(*data, *mean, *eigenvectors, retainedVariance);+}+void cv_PCAProject(Mat* data, Mat* mean, Mat* eigenvectors, Mat* result) {+	cv::PCAProject(*data, *mean, *eigenvectors, *result);+}+double cv_PSNR(Mat* src1, Mat* src2) {+	return cv::PSNR(*src1, *src2);+}+Params* cv_create_Params() {+	return new Params();+}+PyramidAdaptedFeatureDetector* cv_create_PyramidAdaptedFeatureDetector(FeatureDetector* detector, int maxLevel) {+	return new PyramidAdaptedFeatureDetector(detector, maxLevel);+}+Vec3d* cv_RQDecomp3x3(Mat* src, Mat* mtxR, Mat* mtxQ, Mat* Qx, Mat* Qy, Mat* Qz) {+	return new Vec3d(cv::RQDecomp3x3(*src, *mtxR, *mtxQ, *Qx, *Qy, *Qz));+}+void cv_Rodrigues(Mat* src, Mat* dst, Mat* jacobian) {+	cv::Rodrigues(*src, *dst, *jacobian);+}+void cv_SVBackSubst(Mat* w, Mat* u, Mat* vt, Mat* rhs, Mat* dst) {+	cv::SVBackSubst(*w, *u, *vt, *rhs, *dst);+}+void cv_SVDecomp(Mat* src, Mat* w, Mat* u, Mat* vt, int flags) {+	cv::SVDecomp(*src, *w, *u, *vt, flags);+}+void cv_Scharr(Mat* src, Mat* dst, int ddepth, int dx, int dy, double scale, double delta, int borderType) {+	cv::Scharr(*src, *dst, ddepth, dx, dy, scale, delta, borderType);+}+SimpleBlobDetector* cv_create_SimpleBlobDetector(SimpleBlobDetector_Params* parameters) {+	return new SimpleBlobDetector(*parameters);+}+void cv_Sobel(Mat* src, Mat* dst, int ddepth, int dx, int dy, int ksize, double scale, double delta, int borderType) {+	cv::Sobel(*src, *dst, ddepth, dx, dy, ksize, scale, delta, borderType);+}+StarDetector* cv_create_StarDetector(int _maxSize, int _responseThreshold, int _lineThresholdProjected, int _lineThresholdBinarized, int _suppressNonmaxSize) {+	return new StarDetector(_maxSize, _responseThreshold, _lineThresholdProjected, _lineThresholdBinarized, _suppressNonmaxSize);+}+StereoBM* cv_create_StereoBM() {+	return new StereoBM();+}+StereoBM* cv_create_StereoBM3(int preset, int ndisparities, int SADWindowSize) {+	return new StereoBM(preset, ndisparities, SADWindowSize);+}+StereoSGBM* cv_create_StereoSGBM() {+	return new StereoSGBM();+}+StereoSGBM* cv_create_StereoSGBM11(int minDisparity, int numDisparities, int SADWindowSize, int P1, int P2, int disp12MaxDiff, int preFilterCap, int uniquenessRatio, int speckleWindowSize, int speckleRange, bool fullDP) {+	return new StereoSGBM(minDisparity, numDisparities, SADWindowSize, P1, P2, disp12MaxDiff, preFilterCap, uniquenessRatio, speckleWindowSize, speckleRange, fullDP);+}+StereoVar* cv_create_StereoVar() {+	return new StereoVar();+}+StereoVar* cv_create_StereoVar12(int levels, double pyrScale, int nIt, int minDisp, int maxDisp, int poly_n, double poly_sigma, float fi, float lambda, int penalization, int cycle, int flags) {+	return new StereoVar(levels, pyrScale, nIt, minDisp, maxDisp, poly_n, poly_sigma, fi, lambda, penalization, cycle, flags);+}+Subdiv2D* cv_create_Subdiv2D() {+	return new Subdiv2D();+}+Subdiv2D* cv_create_Subdiv2D1(Rect* rect) {+	return new Subdiv2D(*rect);+}+VideoCapture* cv_create_VideoCapture() {+	return new VideoCapture();+}+VideoCapture* cv_create_VideoCapture1(int device) {+	return new VideoCapture(device);+}+VideoWriter* cv_create_VideoWriter() {+	return new VideoWriter();+}+VideoWriter* cv_create_VideoWriter5(string* filename, int fourcc, double fps, Size* frameSize, bool isColor) {+	return new VideoWriter(*filename, fourcc, fps, *frameSize, isColor);+}+Algorithm* cv_Algorithm__create(Algorithm* self, string* name) {+	return &*self->_create(*name);+}+void cv_absdiff(Mat* src1, Mat* src2, Mat* dst) {+	cv::absdiff(*src1, *src2, *dst);+}+void cv_accumulate(Mat* src, Mat* dst, Mat* mask) {+	cv::accumulate(*src, *dst, *mask);+}+void cv_accumulateProduct(Mat* src1, Mat* src2, Mat* dst, Mat* mask) {+	cv::accumulateProduct(*src1, *src2, *dst, *mask);+}+void cv_accumulateSquare(Mat* src, Mat* dst, Mat* mask) {+	cv::accumulateSquare(*src, *dst, *mask);+}+void cv_accumulateWeighted(Mat* src, Mat* dst, double alpha, Mat* mask) {+	cv::accumulateWeighted(*src, *dst, alpha, *mask);+}+void cv_adaptiveBilateralFilter(Mat* src, Mat* dst, Size* ksize, double sigmaSpace, Point* anchor, int borderType) {+	cv::adaptiveBilateralFilter(*src, *dst, *ksize, sigmaSpace, *anchor, borderType);+}+void cv_adaptiveThreshold(Mat* src, Mat* dst, double maxValue, int adaptiveMethod, int thresholdType, int blockSize, double C) {+	cv::adaptiveThreshold(*src, *dst, maxValue, adaptiveMethod, thresholdType, blockSize, C);+}+void cv_add(Mat* src1, Mat* src2, Mat* dst, Mat* mask, int dtype) {+	cv::add(*src1, *src2, *dst, *mask, dtype);+}+void cv_DescriptorMatcher_add1(DescriptorMatcher* self, vector_Mat* descriptors) {+	self->add(*descriptors);+}+void cv_addWeighted(Mat* src1, double alpha, Mat* src2, double beta, double gamma, Mat* dst, int dtype) {+	cv::addWeighted(*src1, alpha, *src2, beta, gamma, *dst, dtype);+}+void cv_CLAHE_apply(CLAHE* self, Mat* src, Mat* dst) {+	self->apply(*src, *dst);+}+void cv_applyColorMap(Mat* src, Mat* dst, int colormap) {+	cv::applyColorMap(*src, *dst, colormap);+}+void cv_approxPolyDP(Mat* curve, Mat* approxCurve, double epsilon, bool closed) {+	cv::approxPolyDP(*curve, *approxCurve, epsilon, closed);+}+double cv_arcLength(Mat* curve, bool closed) {+	return cv::arcLength(*curve, closed);+}+void cv_batchDistance(Mat* src1, Mat* src2, Mat* dist, int dtype, Mat* nidx, int normType, int K, Mat* mask, int update, bool crosscheck) {+	cv::batchDistance(*src1, *src2, *dist, dtype, *nidx, normType, K, *mask, update, crosscheck);+}+void cv_bilateralFilter(Mat* src, Mat* dst, int d, double sigmaColor, double sigmaSpace, int borderType) {+	cv::bilateralFilter(*src, *dst, d, sigmaColor, sigmaSpace, borderType);+}+void cv_bitwise_and(Mat* src1, Mat* src2, Mat* dst, Mat* mask) {+	cv::bitwise_and(*src1, *src2, *dst, *mask);+}+void cv_bitwise_not(Mat* src, Mat* dst, Mat* mask) {+	cv::bitwise_not(*src, *dst, *mask);+}+void cv_bitwise_or(Mat* src1, Mat* src2, Mat* dst, Mat* mask) {+	cv::bitwise_or(*src1, *src2, *dst, *mask);+}+void cv_bitwise_xor(Mat* src1, Mat* src2, Mat* dst, Mat* mask) {+	cv::bitwise_xor(*src1, *src2, *dst, *mask);+}+void cv_blur(Mat* src, Mat* dst, Size* ksize, Point* anchor, int borderType) {+	cv::blur(*src, *dst, *ksize, *anchor, borderType);+}+int cv_borderInterpolate(int p, int len, int borderType) {+	return cv::borderInterpolate(p, len, borderType);+}+Rect* cv_boundingRect(Mat* points) {+	return new Rect(cv::boundingRect(*points));+}+void cv_boxFilter(Mat* src, Mat* dst, int ddepth, Size* ksize, Point* anchor, bool normalize, int borderType) {+	cv::boxFilter(*src, *dst, ddepth, *ksize, *anchor, normalize, borderType);+}+void cv_KDTree_build(KDTree* self, Mat* points, bool copyAndReorderPoints) {+	self->build(*points, copyAndReorderPoints);+}+void cv_Index_build3(Index* self, Mat* features, IndexParams* params, cvflann_flann_distance_t* distType) {+	self->build(*features, *params, *distType);+}+int cv_buildOpticalFlowPyramid(Mat* img, vector_Mat* pyramid, Size* winSize, int maxLevel, bool withDerivatives, int pyrBorder, int derivBorder, bool tryReuseInputImage) {+	return cv::buildOpticalFlowPyramid(*img, *pyramid, *winSize, maxLevel, withDerivatives, pyrBorder, derivBorder, tryReuseInputImage);+}+void cv_calcBackProject(vector_Mat* images, vector_int* channels, Mat* hist, Mat* dst, vector_float* ranges, double scale) {+	cv::calcBackProject(*images, *channels, *hist, *dst, *ranges, scale);+}+void cv_calcCovarMatrix(Mat* samples, Mat* covar, Mat* mean, int flags, int ctype) {+	cv::calcCovarMatrix(*samples, *covar, *mean, flags, ctype);+}+double cv_calcGlobalOrientation(Mat* orientation, Mat* mask, Mat* mhi, double timestamp, double duration) {+	return cv::calcGlobalOrientation(*orientation, *mask, *mhi, timestamp, duration);+}+void cv_calcHist(vector_Mat* images, vector_int* channels, Mat* mask, Mat* hist, vector_int* histSize, vector_float* ranges, bool accumulate) {+	cv::calcHist(*images, *channels, *mask, *hist, *histSize, *ranges, accumulate);+}+void cv_calcMotionGradient(Mat* mhi, Mat* mask, Mat* orientation, double delta1, double delta2, int apertureSize) {+	cv::calcMotionGradient(*mhi, *mask, *orientation, delta1, delta2, apertureSize);+}+void cv_calcOpticalFlowFarneback(Mat* prev, Mat* next, Mat* flow, double pyr_scale, int levels, int winsize, int iterations, int poly_n, double poly_sigma, int flags) {+	cv::calcOpticalFlowFarneback(*prev, *next, *flow, pyr_scale, levels, winsize, iterations, poly_n, poly_sigma, flags);+}+void cv_calcOpticalFlowPyrLK(Mat* prevImg, Mat* nextImg, Mat* prevPts, Mat* nextPts, Mat* status, Mat* err, Size* winSize, int maxLevel, TermCriteria* criteria, int flags, double minEigThreshold) {+	cv::calcOpticalFlowPyrLK(*prevImg, *nextImg, *prevPts, *nextPts, *status, *err, *winSize, maxLevel, *criteria, flags, minEigThreshold);+}+void cv_calcOpticalFlowSF(Mat* from, Mat* to, Mat* flow, int layers, int averaging_block_size, int max_flow) {+	cv::calcOpticalFlowSF(*from, *to, *flow, layers, averaging_block_size, max_flow);+}+void cv_calcOpticalFlowSF16(Mat* from, Mat* to, Mat* flow, int layers, int averaging_block_size, int max_flow, double sigma_dist, double sigma_color, int postprocess_window, double sigma_dist_fix, double sigma_color_fix, double occ_thr, int upscale_averaging_radius, double upscale_sigma_dist, double upscale_sigma_color, double speed_up_thr) {+	cv::calcOpticalFlowSF(*from, *to, *flow, layers, averaging_block_size, max_flow, sigma_dist, sigma_color, postprocess_window, sigma_dist_fix, sigma_color_fix, occ_thr, upscale_averaging_radius, upscale_sigma_dist, upscale_sigma_color, speed_up_thr);+}+double cv_calibrateCamera(vector_Mat* objectPoints, vector_Mat* imagePoints, Size* imageSize, Mat* cameraMatrix, Mat* distCoeffs, vector_Mat* rvecs, vector_Mat* tvecs, int flags, TermCriteria* criteria) {+	return cv::calibrateCamera(*objectPoints, *imagePoints, *imageSize, *cameraMatrix, *distCoeffs, *rvecs, *tvecs, flags, *criteria);+}+void cv_calibrationMatrixValues(Mat* cameraMatrix, Size* imageSize, double apertureWidth, double apertureHeight, double fovx, double fovy, double focalLength, Point2d* principalPoint, double aspectRatio) {+	cv::calibrationMatrixValues(*cameraMatrix, *imageSize, apertureWidth, apertureHeight, fovx, fovy, focalLength, *principalPoint, aspectRatio);+}+void cv_cartToPolar(Mat* x, Mat* y, Mat* magnitude, Mat* angle, bool angleInDegrees) {+	cv::cartToPolar(*x, *y, *magnitude, *angle, angleInDegrees);+}+int cv_chamerMatching(Mat* img, Mat* templ, vector_vector_Point* results, vector_float* cost, double templScale, int maxMatches, double minMatchDistance, int padX, int padY, int scales, double minScale, double maxScale, double orientationWeight, double truncate) {+	return cv::chamerMatching(*img, *templ, *results, *cost, templScale, maxMatches, minMatchDistance, padX, padY, scales, minScale, maxScale, orientationWeight, truncate);+}+bool cv_HOGDescriptor_checkDetectorSize(HOGDescriptor* self) {+	return self->checkDetectorSize();+}+bool cv_checkHardwareSupport(int feature) {+	return cv::checkHardwareSupport(feature);+}+bool cv_checkRange(Mat* a, bool quiet, Point* pos, double minVal, double maxVal) {+	return cv::checkRange(*a, quiet, pos, minVal, maxVal);+}+void cv_circle(Mat* img, Point* center, int radius, Scalar* color, int thickness, int lineType, int shift) {+	cv::circle(*img, *center, radius, *color, thickness, lineType, shift);+}+void cv_CvNormalBayesClassifier_clear(CvNormalBayesClassifier* self) {+	self->clear();+}+void cv_DescriptorMatcher_clear0(DescriptorMatcher* self) {+	self->clear();+}+bool cv_clipLine(Rect* imgRect, Point* pt1, Point* pt2) {+	return cv::clipLine(*imgRect, *pt1, *pt2);+}+void cv_compare(Mat* src1, Mat* src2, Mat* dst, int cmpop) {+	cv::compare(*src1, *src2, *dst, cmpop);+}+double cv_compareHist(Mat* H1, Mat* H2, int method) {+	return cv::compareHist(*H1, *H2, method);+}+void cv_completeSymm(Mat* mtx, bool lowerToUpper) {+	cv::completeSymm(*mtx, lowerToUpper);+}+void cv_composeRT(Mat* rvec1, Mat* tvec1, Mat* rvec2, Mat* tvec2, Mat* rvec3, Mat* tvec3, Mat* dr3dr1, Mat* dr3dt1, Mat* dr3dr2, Mat* dr3dt2, Mat* dt3dr1, Mat* dt3dt1, Mat* dt3dr2, Mat* dt3dt2) {+	cv::composeRT(*rvec1, *tvec1, *rvec2, *tvec2, *rvec3, *tvec3, *dr3dr1, *dr3dt1, *dr3dr2, *dr3dt2, *dt3dr1, *dt3dt1, *dt3dr2, *dt3dt2);+}+void cv_DescriptorExtractor_compute(DescriptorExtractor* self, Mat* image, vector_KeyPoint* keypoints, Mat* descriptors) {+	self->compute(*image, *keypoints, *descriptors);+}+void cv_Feature2D_compute3(Feature2D* self, Mat* image, vector_KeyPoint* keypoints, Mat* descriptors) {+	self->compute(*image, *keypoints, *descriptors);+}+void cv_HOGDescriptor_compute5(HOGDescriptor* self, Mat* img, vector_float* descriptors, Size* winStride, Size* padding, vector_Point* locations) {+	self->compute(*img, *descriptors, *winStride, *padding, *locations);+}+void cv_computeCorrespondEpilines(Mat* points, int whichImage, Mat* F, Mat* lines) {+	cv::computeCorrespondEpilines(*points, whichImage, *F, *lines);+}+void cv_HOGDescriptor_computeGradient(HOGDescriptor* self, Mat* img, Mat* grad, Mat* angleOfs, Size* paddingTL, Size* paddingBR) {+	self->computeGradient(*img, *grad, *angleOfs, *paddingTL, *paddingBR);+}+double cv_contourArea(Mat* contour, bool oriented) {+	return cv::contourArea(*contour, oriented);+}+void cv_convertMaps(Mat* map1, Mat* map2, Mat* dstmap1, Mat* dstmap2, int dstmap1type, bool nninterpolation) {+	cv::convertMaps(*map1, *map2, *dstmap1, *dstmap2, dstmap1type, nninterpolation);+}+void cv_convertPointsFromHomogeneous(Mat* src, Mat* dst) {+	cv::convertPointsFromHomogeneous(*src, *dst);+}+void cv_convertPointsToHomogeneous(Mat* src, Mat* dst) {+	cv::convertPointsToHomogeneous(*src, *dst);+}+void cv_convertScaleAbs(Mat* src, Mat* dst, double alpha, double beta) {+	cv::convertScaleAbs(*src, *dst, alpha, beta);+}+void cv_convexHull(Mat* points, Mat* hull, bool clockwise, bool returnPoints) {+	cv::convexHull(*points, *hull, clockwise, returnPoints);+}+void cv_convexityDefects(Mat* contour, Mat* convexhull, Mat* convexityDefects) {+	cv::convexityDefects(*contour, *convexhull, *convexityDefects);+}+void cv_copyMakeBorder(Mat* src, Mat* dst, int top, int bottom, int left, int right, int borderType, Scalar* value) {+	cv::copyMakeBorder(*src, *dst, top, bottom, left, right, borderType, *value);+}+void cv_cornerEigenValsAndVecs(Mat* src, Mat* dst, int blockSize, int ksize, int borderType) {+	cv::cornerEigenValsAndVecs(*src, *dst, blockSize, ksize, borderType);+}+void cv_cornerHarris(Mat* src, Mat* dst, int blockSize, int ksize, double k, int borderType) {+	cv::cornerHarris(*src, *dst, blockSize, ksize, k, borderType);+}+void cv_cornerMinEigenVal(Mat* src, Mat* dst, int blockSize, int ksize, int borderType) {+	cv::cornerMinEigenVal(*src, *dst, blockSize, ksize, borderType);+}+void cv_cornerSubPix(Mat* image, Mat* corners, Size* winSize, Size* zeroZone, TermCriteria* criteria) {+	cv::cornerSubPix(*image, *corners, *winSize, *zeroZone, *criteria);+}+Mat* cv_KalmanFilter_correct(KalmanFilter* self, Mat* measurement) {+	return new Mat(self->correct(*measurement));+}+void cv_correctMatches(Mat* F, Mat* points1, Mat* points2, Mat* newPoints1, Mat* newPoints2) {+	cv::correctMatches(*F, *points1, *points2, *newPoints1, *newPoints2);+}+int cv_countNonZero(Mat* src) {+	return cv::countNonZero(*src);+}+void cv_CvANN_MLP_create(CvANN_MLP* self, Mat* layerSizes, int activateFunc, double fparam1, double fparam2) {+	self->create(*layerSizes, activateFunc, fparam1, fparam2);+}+DescriptorMatcher* cv_DescriptorMatcher_create1(DescriptorMatcher* self, string* descriptorMatcherType) {+	return &*self->create(*descriptorMatcherType);+}+CLAHE* cv_createCLAHE(double clipLimit, Size* tileGridSize) {+	return &*cv::createCLAHE(clipLimit, *tileGridSize);+}+FaceRecognizer* cv_createEigenFaceRecognizer(int num_components, double threshold) {+	return &*cv::createEigenFaceRecognizer(num_components, threshold);+}+FaceRecognizer* cv_createFisherFaceRecognizer(int num_components, double threshold) {+	return &*cv::createFisherFaceRecognizer(num_components, threshold);+}+void cv_createHanningWindow(Mat* dst, Size* winSize, int type) {+	cv::createHanningWindow(*dst, *winSize, type);+}+FaceRecognizer* cv_createLBPHFaceRecognizer(int radius, int neighbors, int grid_x, int grid_y, double threshold) {+	return &*cv::createLBPHFaceRecognizer(radius, neighbors, grid_x, grid_y, threshold);+}+float cv_cubeRoot(float val) {+	return cv::cubeRoot(val);+}+void cv_cvtColor(Mat* src, Mat* dst, int code, int dstCn) {+	cv::cvtColor(*src, *dst, code, dstCn);+}+void cv_dct(Mat* src, Mat* dst, int flags) {+	cv::dct(*src, *dst, flags);+}+void cv_decomposeProjectionMatrix(Mat* projMatrix, Mat* cameraMatrix, Mat* rotMatrix, Mat* transVect, Mat* rotMatrixX, Mat* rotMatrixY, Mat* rotMatrixZ, Mat* eulerAngles) {+	cv::decomposeProjectionMatrix(*projMatrix, *cameraMatrix, *rotMatrix, *transVect, *rotMatrixX, *rotMatrixY, *rotMatrixZ, *eulerAngles);+}+void cv_destroyAllWindows() {+	cv::destroyAllWindows();+}+void cv_destroyWindow(string* winname) {+	cv::destroyWindow(*winname);+}+void cv_FeatureDetector_detect(FeatureDetector* self, Mat* image, vector_KeyPoint* keypoints, Mat* mask) {+	self->detect(*image, *keypoints, *mask);+}+void cv_HOGDescriptor_detect7(HOGDescriptor* self, Mat* img, vector_Point* foundLocations, vector_double* weights, double hitThreshold, Size* winStride, Size* padding, vector_Point* searchLocations) {+	self->detect(*img, *foundLocations, *weights, hitThreshold, *winStride, *padding, *searchLocations);+}+void cv_CascadeClassifier_detectMultiScale(CascadeClassifier* self, Mat* image, vector_Rect* objects, double scaleFactor, int minNeighbors, int flags, Size* minSize, Size* maxSize) {+	self->detectMultiScale(*image, *objects, scaleFactor, minNeighbors, flags, *minSize, *maxSize);+}+void cv_CascadeClassifier_detectMultiScale10(CascadeClassifier* self, Mat* image, vector_Rect* objects, vector_int* rejectLevels, vector_double* levelWeights, double scaleFactor, int minNeighbors, int flags, Size* minSize, Size* maxSize, bool outputRejectLevels) {+	self->detectMultiScale(*image, *objects, *rejectLevels, *levelWeights, scaleFactor, minNeighbors, flags, *minSize, *maxSize, outputRejectLevels);+}+void cv_HOGDescriptor_detectMultiScale9(HOGDescriptor* self, Mat* img, vector_Rect* foundLocations, vector_double* foundWeights, double hitThreshold, Size* winStride, Size* padding, double scale, double finalThreshold, bool useMeanshiftGrouping) {+	self->detectMultiScale(*img, *foundLocations, *foundWeights, hitThreshold, *winStride, *padding, scale, finalThreshold, useMeanshiftGrouping);+}+double cv_determinant(Mat* mtx) {+	return cv::determinant(*mtx);+}+void cv_dft(Mat* src, Mat* dst, int flags, int nonzeroRows) {+	cv::dft(*src, *dst, flags, nonzeroRows);+}+void cv_dilate(Mat* src, Mat* dst, Mat* kernel, Point* anchor, int iterations, int borderType, Scalar* borderValue) {+	cv::dilate(*src, *dst, *kernel, *anchor, iterations, borderType, *borderValue);+}+int cv_KDTree_dims(KDTree* self) {+	return self->dims();+}+void cv_distanceTransform(Mat* src, Mat* dst, Mat* labels, int distanceType, int maskSize, int labelType) {+	cv::distanceTransform(*src, *dst, *labels, distanceType, maskSize, labelType);+}+void cv_distanceTransform4(Mat* src, Mat* dst, int distanceType, int maskSize) {+	cv::distanceTransform(*src, *dst, distanceType, maskSize);+}+void cv_divide(Mat* src1, Mat* src2, Mat* dst, double scale, int dtype) {+	cv::divide(*src1, *src2, *dst, scale, dtype);+}+void cv_divide4(double scale, Mat* src2, Mat* dst, int dtype) {+	cv::divide(scale, *src2, *dst, dtype);+}+void cv_drawChessboardCorners(Mat* image, Size* patternSize, Mat* corners, bool patternWasFound) {+	cv::drawChessboardCorners(*image, *patternSize, *corners, patternWasFound);+}+void cv_drawContours(Mat* image, vector_Mat* contours, int contourIdx, Scalar* color, int thickness, int lineType, Mat* hierarchy, int maxLevel, Point* offset) {+	cv::drawContours(*image, *contours, contourIdx, *color, thickness, lineType, *hierarchy, maxLevel, *offset);+}+void cv_drawDataMatrixCodes(Mat* image, vector_string* codes, Mat* corners) {+	cv::drawDataMatrixCodes(*image, *codes, *corners);+}+void cv_drawKeypoints(Mat* image, vector_KeyPoint* keypoints, Mat* outImage, Scalar* color, int flags) {+	cv::drawKeypoints(*image, *keypoints, *outImage, *color, flags);+}+int cv_Subdiv2D_edgeDst(Subdiv2D* self, int edge, Point2f* dstpt) {+	return self->edgeDst(edge, dstpt);+}+int cv_Subdiv2D_edgeOrg(Subdiv2D* self, int edge, Point2f* orgpt) {+	return self->edgeOrg(edge, orgpt);+}+bool cv_eigen(Mat* src, bool computeEigenvectors, Mat* eigenvalues, Mat* eigenvectors) {+	return cv::eigen(*src, computeEigenvectors, *eigenvalues, *eigenvectors);+}+void cv_ellipse(Mat* img, Point* center, Size* axes, double angle, double startAngle, double endAngle, Scalar* color, int thickness, int lineType, int shift) {+	cv::ellipse(*img, *center, *axes, angle, startAngle, endAngle, *color, thickness, lineType, shift);+}+void cv_ellipse2Poly(Point* center, Size* axes, int angle, int arcStart, int arcEnd, int delta, vector_Point* pts) {+	cv::ellipse2Poly(*center, *axes, angle, arcStart, arcEnd, delta, *pts);+}+void cv_ellipse5(Mat* img, RotatedRect* box, Scalar* color, int thickness, int lineType) {+	cv::ellipse(*img, *box, *color, thickness, lineType);+}+bool cv_FileNode_empty(FileNode* self) {+	return self->empty();+}+bool cv_CascadeClassifier_empty0(CascadeClassifier* self) {+	return self->empty();+}+void cv_equalizeHist(Mat* src, Mat* dst) {+	cv::equalizeHist(*src, *dst);+}+void cv_erode(Mat* src, Mat* dst, Mat* kernel, Point* anchor, int iterations, int borderType, Scalar* borderValue) {+	cv::erode(*src, *dst, *kernel, *anchor, iterations, borderType, *borderValue);+}+int cv_estimateAffine3D(Mat* src, Mat* dst, Mat* out, Mat* inliers, double ransacThreshold, double confidence) {+	return cv::estimateAffine3D(*src, *dst, *out, *inliers, ransacThreshold, confidence);+}+Mat* cv_estimateRigidTransform(Mat* src, Mat* dst, bool fullAffine) {+	return new Mat(cv::estimateRigidTransform(*src, *dst, fullAffine));+}+void cv_exp(Mat* src, Mat* dst) {+	cv::exp(*src, *dst);+}+void cv_extractChannel(Mat* src, Mat* dst, int coi) {+	cv::extractChannel(*src, *dst, coi);+}+float cv_fastAtan2(float y, float x) {+	return cv::fastAtan2(y, x);+}+void cv_fillConvexPoly(Mat* img, Mat* points, Scalar* color, int lineType, int shift) {+	cv::fillConvexPoly(*img, *points, *color, lineType, shift);+}+void cv_fillPoly(Mat* img, vector_Mat* pts, Scalar* color, int lineType, int shift, Point* offset) {+	cv::fillPoly(*img, *pts, *color, lineType, shift, *offset);+}+void cv_filter2D(Mat* src, Mat* dst, int ddepth, Mat* kernel, Point* anchor, double delta, int borderType) {+	cv::filter2D(*src, *dst, ddepth, *kernel, *anchor, delta, borderType);+}+void cv_filterSpeckles(Mat* img, double newVal, int maxSpeckleSize, double maxDiff, Mat* buf) {+	cv::filterSpeckles(*img, newVal, maxSpeckleSize, maxDiff, *buf);+}+bool cv_findChessboardCorners(Mat* image, Size* patternSize, Mat* corners, int flags) {+	return cv::findChessboardCorners(*image, *patternSize, *corners, flags);+}+bool cv_findCirclesGrid(Mat* image, Size* patternSize, Mat* centers, int flags, FeatureDetector* blobDetector) {+	return cv::findCirclesGrid(*image, *patternSize, *centers, flags, blobDetector);+}+bool cv_findCirclesGridDefault(Mat* image, Size* patternSize, Mat* centers, int flags) {+	return cv::findCirclesGridDefault(*image, *patternSize, *centers, flags);+}+void cv_findContours(Mat* image, vector_Mat* contours, Mat* hierarchy, int mode, int method, Point* offset) {+	cv::findContours(*image, *contours, *hierarchy, mode, method, *offset);+}+void cv_findDataMatrix(Mat* image, vector_string* codes, Mat* corners, vector_Mat* dmtx) {+	cv::findDataMatrix(*image, *codes, *corners, *dmtx);+}+Mat* cv_findFundamentalMat(Mat* points1, Mat* points2, int method, double param1, double param2, Mat* mask) {+	return new Mat(cv::findFundamentalMat(*points1, *points2, method, param1, param2, *mask));+}+Mat* cv_findHomography(Mat* srcPoints, Mat* dstPoints, int method, double ransacReprojThreshold, Mat* mask) {+	return new Mat(cv::findHomography(*srcPoints, *dstPoints, method, ransacReprojThreshold, *mask));+}+int cv_KDTree_findNearest(KDTree* self, Mat* vec, int K, int Emax, Mat* neighborsIdx, Mat* neighbors, Mat* dist, Mat* labels) {+	return self->findNearest(*vec, K, Emax, *neighborsIdx, *neighbors, *dist, *labels);+}+int cv_Subdiv2D_findNearest2(Subdiv2D* self, Point2f* pt, Point2f* nearestPt) {+	return self->findNearest(*pt, nearestPt);+}+void cv_findNonZero(Mat* src, Mat* idx) {+	cv::findNonZero(*src, *idx);+}+void cv_KDTree_findOrthoRange(KDTree* self, Mat* minBounds, Mat* maxBounds, Mat* neighborsIdx, Mat* neighbors, Mat* labels) {+	self->findOrthoRange(*minBounds, *maxBounds, *neighborsIdx, *neighbors, *labels);+}+float cv_CvKNearest_find_nearest(CvKNearest* self, Mat* samples, int k, Mat* results, Mat* neighborResponses, Mat* dists) {+	return self->find_nearest(*samples, k, *results, *neighborResponses, *dists);+}+RotatedRect* cv_fitEllipse(Mat* points) {+	return new RotatedRect(cv::fitEllipse(*points));+}+void cv_fitLine(Mat* points, Mat* line, int distType, double param, double reps, double aeps) {+	cv::fitLine(*points, *line, distType, param, reps, aeps);+}+void cv_flip(Mat* src, Mat* dst, int flipCode) {+	cv::flip(*src, *dst, flipCode);+}+int cv_floodFill(Mat* image, Mat* mask, Point* seedPoint, Scalar* newVal, Rect* rect, Scalar* loDiff, Scalar* upDiff, int flags) {+	return cv::floodFill(*image, *mask, *seedPoint, *newVal, rect, *loDiff, *upDiff, flags);+}+void cv_gemm(Mat* src1, Mat* src2, double alpha, Mat* src3, double gamma, Mat* dst, int flags) {+	cv::gemm(*src1, *src2, alpha, *src3, gamma, *dst, flags);+}+void cv_BRISK_generateKernel(BRISK* self, vector_float* radiusList, vector_int* numberList, float dMax, float dMin, vector_int* indexChange) {+	self->generateKernel(*radiusList, *numberList, dMax, dMin, *indexChange);+}+double cv_VideoCapture_get(VideoCapture* self, int propId) {+	return self->get(propId);+}+Mat* cv_getAffineTransform(Mat* src, Mat* dst) {+	return new Mat(cv::getAffineTransform(*src, *dst));+}+Algorithm* cv_Algorithm_getAlgorithm(Algorithm* self, string* name) {+	return &*self->getAlgorithm(*name);+}+cvflann_flann_algorithm_t* cv_Index_getAlgorithm0(Index* self) {+	return new cvflann_flann_algorithm_t(self->getAlgorithm());+}+bool cv_Algorithm_getBool(Algorithm* self, string* name) {+	return self->getBool(*name);+}+string* cv_getBuildInformation() {+	return new string(cv::getBuildInformation());+}+int64 cv_getCPUTickCount() {+	return cv::getCPUTickCount();+}+vector_float* cv_HOGDescriptor_getDaimlerPeopleDetector(HOGDescriptor* self) {+	return new vector_float(self->getDaimlerPeopleDetector());+}+Mat* cv_getDefaultNewCameraMatrix(Mat* cameraMatrix, Size* imgsize, bool centerPrincipalPoint) {+	return new Mat(cv::getDefaultNewCameraMatrix(*cameraMatrix, *imgsize, centerPrincipalPoint));+}+vector_float* cv_HOGDescriptor_getDefaultPeopleDetector(HOGDescriptor* self) {+	return new vector_float(self->getDefaultPeopleDetector());+}+void cv_getDerivKernels(Mat* kx, Mat* ky, int dx, int dy, int ksize, bool normalize, int ktype) {+	cv::getDerivKernels(*kx, *ky, dx, dy, ksize, normalize, ktype);+}+size_t cv_HOGDescriptor_getDescriptorSize(HOGDescriptor* self) {+	return self->getDescriptorSize();+}+cvflann_flann_distance_t* cv_Index_getDistance(Index* self) {+	return new cvflann_flann_distance_t(self->getDistance());+}+double cv_Algorithm_getDouble(Algorithm* self, string* name) {+	return self->getDouble(*name);+}+int cv_Subdiv2D_getEdge(Subdiv2D* self, int edge, int nextEdgeType) {+	return self->getEdge(edge, nextEdgeType);+}+void cv_Subdiv2D_getEdgeList(Subdiv2D* self, vector_Vec4f* edgeList) {+	self->getEdgeList(*edgeList);+}+FileNode* cv_FileStorage_getFirstTopLevelNode(FileStorage* self) {+	return new FileNode(self->getFirstTopLevelNode());+}+Mat* cv_getGaborKernel(Size* ksize, double sigma, double theta, double lambd, double gamma, double psi, int ktype) {+	return new Mat(cv::getGaborKernel(*ksize, sigma, theta, lambd, gamma, psi, ktype));+}+Mat* cv_getGaussianKernel(int ksize, double sigma, int ktype) {+	return new Mat(cv::getGaussianKernel(ksize, sigma, ktype));+}+int cv_Algorithm_getInt(Algorithm* self, string* name) {+	return self->getInt(*name);+}+void cv_Algorithm_getList(Algorithm* self, vector_string* algorithms) {+	self->getList(*algorithms);+}+Mat* cv_Algorithm_getMat(Algorithm* self, string* name) {+	return new Mat(self->getMat(*name));+}+vector_Mat* cv_Algorithm_getMatVector(Algorithm* self, string* name) {+	return new vector_Mat(self->getMatVector(*name));+}+int cv_getNumberOfCPUs() {+	return cv::getNumberOfCPUs();+}+int cv_getOptimalDFTSize(int vecsize) {+	return cv::getOptimalDFTSize(vecsize);+}+Mat* cv_getOptimalNewCameraMatrix(Mat* cameraMatrix, Mat* distCoeffs, Size* imageSize, double alpha, Size* newImgSize, Rect* validPixROI, bool centerPrincipalPoint) {+	return new Mat(cv::getOptimalNewCameraMatrix(*cameraMatrix, *distCoeffs, *imageSize, alpha, *newImgSize, validPixROI, centerPrincipalPoint));+}+void cv_Algorithm_getParams(Algorithm* self, vector_string* names) {+	self->getParams(*names);+}+Mat* cv_getPerspectiveTransform(Mat* src, Mat* dst) {+	return new Mat(cv::getPerspectiveTransform(*src, *dst));+}+void cv_KDTree_getPoints(KDTree* self, Mat* idx, Mat* pts, Mat* labels) {+	self->getPoints(*idx, *pts, *labels);+}+void cv_getRectSubPix(Mat* image, Size* patchSize, Point2f* center, Mat* patch, int patchType) {+	cv::getRectSubPix(*image, *patchSize, *center, *patch, patchType);+}+Mat* cv_getRotationMatrix2D(Point2f* center, double angle, double scale) {+	return new Mat(cv::getRotationMatrix2D(*center, angle, scale));+}+string* cv_Algorithm_getString(Algorithm* self, string* name) {+	return new string(self->getString(*name));+}+Mat* cv_getStructuringElement(int shape, Size* ksize, Point* anchor) {+	return new Mat(cv::getStructuringElement(shape, *ksize, *anchor));+}+Size* cv_getTextSize(string* text, int fontFace, double fontScale, int thickness, int* baseLine) {+	return new Size(cv::getTextSize(*text, fontFace, fontScale, thickness, baseLine));+}+int64 cv_getTickCount() {+	return cv::getTickCount();+}+double cv_getTickFrequency() {+	return cv::getTickFrequency();+}+int cv_getTrackbarPos(string* trackbarname, string* winname) {+	return cv::getTrackbarPos(*trackbarname, *winname);+}+vector_Mat* cv_DescriptorMatcher_getTrainDescriptors(DescriptorMatcher* self) {+	return new vector_Mat(self->getTrainDescriptors());+}+void cv_Subdiv2D_getTriangleList(Subdiv2D* self, vector_Vec6f* triangleList) {+	self->getTriangleList(*triangleList);+}+Rect* cv_getValidDisparityROI(Rect* roi1, Rect* roi2, int minDisparity, int numberOfDisparities, int SADWindowSize) {+	return new Rect(cv::getValidDisparityROI(*roi1, *roi2, minDisparity, numberOfDisparities, SADWindowSize));+}+Mat* cv_CvDTree_getVarImportance(CvDTree* self) {+	return new Mat(self->getVarImportance());+}+Mat* cv_CvRTrees_getVarImportance0(CvRTrees* self) {+	return new Mat(self->getVarImportance());+}+Point2f* cv_Subdiv2D_getVertex(Subdiv2D* self, int vertex, int* firstEdge) {+	return new Point2f(self->getVertex(vertex, firstEdge));+}+void cv_Subdiv2D_getVoronoiFacetList(Subdiv2D* self, vector_int* idx, vector_vector_Point2f* facetList, vector_Point2f* facetCenters) {+	self->getVoronoiFacetList(*idx, *facetList, *facetCenters);+}+double cv_HOGDescriptor_getWinSigma(HOGDescriptor* self) {+	return self->getWinSigma();+}+double cv_getWindowProperty(string* winname, int prop_id) {+	return cv::getWindowProperty(*winname, prop_id);+}+int cv_CvSVM_get_support_vector_count(CvSVM* self) {+	return self->get_support_vector_count();+}+int cv_CvSVM_get_var_count(CvSVM* self) {+	return self->get_var_count();+}+void cv_goodFeaturesToTrack(Mat* image, Mat* corners, int maxCorners, double qualityLevel, double minDistance, Mat* mask, int blockSize, bool useHarrisDetector, double k) {+	cv::goodFeaturesToTrack(*image, *corners, maxCorners, qualityLevel, minDistance, *mask, blockSize, useHarrisDetector, k);+}+bool cv_VideoCapture_grab(VideoCapture* self) {+	return self->grab();+}+void cv_grabCut(Mat* img, Mat* mask, Rect* rect, Mat* bgdModel, Mat* fgdModel, int iterCount, int mode) {+	cv::grabCut(*img, *mask, *rect, *bgdModel, *fgdModel, iterCount, mode);+}+void cv_groupRectangles(vector_Rect* rectList, vector_int* weights, int groupThreshold, double eps) {+	cv::groupRectangles(*rectList, *weights, groupThreshold, eps);+}+void cv_hconcat(vector_Mat* src, Mat* dst) {+	cv::hconcat(*src, *dst);+}+void cv_idct(Mat* src, Mat* dst, int flags) {+	cv::idct(*src, *dst, flags);+}+void cv_idft(Mat* src, Mat* dst, int flags, int nonzeroRows) {+	cv::idft(*src, *dst, flags, nonzeroRows);+}+Mat* cv_imdecode(Mat* buf, int flags) {+	return new Mat(cv::imdecode(*buf, flags));+}+bool cv_imencode(string* ext, Mat* img, vector_uchar* buf, vector_int* params) {+	return cv::imencode(*ext, *img, *buf, *params);+}+Mat* cv_imread(string* filename, int flags) {+	return new Mat(cv::imread(*filename, flags));+}+void cv_imshow(string* winname, Mat* mat) {+	cv::imshow(*winname, *mat);+}+bool cv_imwrite(string* filename, Mat* img, vector_int* params) {+	return cv::imwrite(*filename, *img, *params);+}+void cv_inRange(Mat* src, Mat* lowerb, Mat* upperb, Mat* dst) {+	cv::inRange(*src, *lowerb, *upperb, *dst);+}+Mat* cv_initCameraMatrix2D(vector_Mat* objectPoints, vector_Mat* imagePoints, Size* imageSize, double aspectRatio) {+	return new Mat(cv::initCameraMatrix2D(*objectPoints, *imagePoints, *imageSize, aspectRatio));+}+void cv_Subdiv2D_initDelaunay(Subdiv2D* self, Rect* rect) {+	self->initDelaunay(*rect);+}+void cv_initUndistortRectifyMap(Mat* cameraMatrix, Mat* distCoeffs, Mat* R, Mat* newCameraMatrix, Size* size, int m1type, Mat* map1, Mat* map2) {+	cv::initUndistortRectifyMap(*cameraMatrix, *distCoeffs, *R, *newCameraMatrix, *size, m1type, *map1, *map2);+}+float cv_initWideAngleProjMap(Mat* cameraMatrix, Mat* distCoeffs, Size* imageSize, int destImageWidth, int m1type, Mat* map1, Mat* map2, int projType, double alpha) {+	return cv::initWideAngleProjMap(*cameraMatrix, *distCoeffs, *imageSize, destImageWidth, m1type, *map1, *map2, projType, alpha);+}+int cv_Subdiv2D_insert(Subdiv2D* self, Point2f* pt) {+	return self->insert(*pt);+}+void cv_Subdiv2D_insert1(Subdiv2D* self, vector_Point2f* ptvec) {+	self->insert(*ptvec);+}+void cv_insertChannel(Mat* src, Mat* dst, int coi) {+	cv::insertChannel(*src, *dst, coi);+}+void cv_integral(Mat* src, Mat* sum, int sdepth) {+	cv::integral(*src, *sum, sdepth);+}+void cv_integral4(Mat* src, Mat* sum, Mat* sqsum, int sdepth) {+	cv::integral(*src, *sum, *sqsum, sdepth);+}+void cv_integral5(Mat* src, Mat* sum, Mat* sqsum, Mat* tilted, int sdepth) {+	cv::integral(*src, *sum, *sqsum, *tilted, sdepth);+}+float cv_intersectConvexConvex(Mat* _p1, Mat* _p2, Mat* _p12, bool handleNested) {+	return cv::intersectConvexConvex(*_p1, *_p2, *_p12, handleNested);+}+double cv_invert(Mat* src, Mat* dst, int flags) {+	return cv::invert(*src, *dst, flags);+}+void cv_invertAffineTransform(Mat* M, Mat* iM) {+	cv::invertAffineTransform(*M, *iM);+}+bool cv_isContourConvex(Mat* contour) {+	return cv::isContourConvex(*contour);+}+bool cv_FileNode_isInt(FileNode* self) {+	return self->isInt();+}+bool cv_FileNode_isMap(FileNode* self) {+	return self->isMap();+}+bool cv_FileNode_isNamed(FileNode* self) {+	return self->isNamed();+}+bool cv_FileNode_isNone(FileNode* self) {+	return self->isNone();+}+bool cv_FileStorage_isOpened(FileStorage* self) {+	return self->isOpened();+}+bool cv_VideoWriter_isOpened0(VideoWriter* self) {+	return self->isOpened();+}+bool cv_FileNode_isReal(FileNode* self) {+	return self->isReal();+}+bool cv_FileNode_isSeq(FileNode* self) {+	return self->isSeq();+}+bool cv_FileNode_isString(FileNode* self) {+	return self->isString();+}+bool cv_EM_isTrained(EM* self) {+	return self->isTrained();+}+double cv_kmeans(Mat* data, int K, Mat* bestLabels, TermCriteria* criteria, int attempts, int flags, Mat* centers) {+	return cv::kmeans(*data, K, *bestLabels, *criteria, attempts, flags, *centers);+}+void cv_DescriptorMatcher_knnMatch(DescriptorMatcher* self, Mat* queryDescriptors, Mat* trainDescriptors, vector_vector_DMatch* matches, int k, Mat* mask, bool compactResult) {+	self->knnMatch(*queryDescriptors, *trainDescriptors, *matches, k, *mask, compactResult);+}+void cv_DescriptorMatcher_knnMatch5(DescriptorMatcher* self, Mat* queryDescriptors, vector_vector_DMatch* matches, int k, vector_Mat* masks, bool compactResult) {+	self->knnMatch(*queryDescriptors, *matches, k, *masks, compactResult);+}+void cv_Index_knnSearch(Index* self, Mat* query, Mat* indices, Mat* dists, int knn, SearchParams* params) {+	self->knnSearch(*query, *indices, *dists, knn, *params);+}+void cv_line(Mat* img, Point* pt1, Point* pt2, Scalar* color, int thickness, int lineType, int shift) {+	cv::line(*img, *pt1, *pt2, *color, thickness, lineType, shift);+}+bool cv_Index_load(Index* self, Mat* features, string* filename) {+	return self->load(*features, *filename);+}+void cv_FaceRecognizer_load1(FaceRecognizer* self, string* filename) {+	self->load(*filename);+}+bool cv_HOGDescriptor_load2(HOGDescriptor* self, String* filename, String* objname) {+	return self->load(*filename, *objname);+}+int cv_Subdiv2D_locate(Subdiv2D* self, Point2f* pt, int edge, int vertex) {+	return self->locate(*pt, edge, vertex);+}+void cv_log(Mat* src, Mat* dst) {+	cv::log(*src, *dst);+}+void cv_magnitude(Mat* x, Mat* y, Mat* magnitude) {+	cv::magnitude(*x, *y, *magnitude);+}+void cv_matMulDeriv(Mat* A, Mat* B, Mat* dABdA, Mat* dABdB) {+	cv::matMulDeriv(*A, *B, *dABdA, *dABdB);+}+void cv_DescriptorMatcher_match(DescriptorMatcher* self, Mat* queryDescriptors, Mat* trainDescriptors, vector_DMatch* matches, Mat* mask) {+	self->match(*queryDescriptors, *trainDescriptors, *matches, *mask);+}+void cv_DescriptorMatcher_match3(DescriptorMatcher* self, Mat* queryDescriptors, vector_DMatch* matches, vector_Mat* masks) {+	self->match(*queryDescriptors, *matches, *masks);+}+double cv_matchShapes(Mat* contour1, Mat* contour2, int method, double parameter) {+	return cv::matchShapes(*contour1, *contour2, method, parameter);+}+void cv_matchTemplate(Mat* image, Mat* templ, Mat* result, int method) {+	cv::matchTemplate(*image, *templ, *result, method);+}+void cv_max(Mat* src1, Mat* src2, Mat* dst) {+	cv::max(*src1, *src2, *dst);+}+Scalar* cv_mean(Mat* src, Mat* mask) {+	return new Scalar(cv::mean(*src, *mask));+}+int cv_meanShift(Mat* probImage, Rect* window, TermCriteria* criteria) {+	return cv::meanShift(*probImage, *window, *criteria);+}+void cv_meanStdDev(Mat* src, Mat* mean, Mat* stddev, Mat* mask) {+	cv::meanStdDev(*src, *mean, *stddev, *mask);+}+void cv_medianBlur(Mat* src, Mat* dst, int ksize) {+	cv::medianBlur(*src, *dst, ksize);+}+void cv_merge(vector_Mat* mv, Mat* dst) {+	cv::merge(*mv, *dst);+}+void cv_min(Mat* src1, Mat* src2, Mat* dst) {+	cv::min(*src1, *src2, *dst);+}+RotatedRect* cv_minAreaRect(Mat* points) {+	return new RotatedRect(cv::minAreaRect(*points));+}+void cv_minEnclosingCircle(Mat* points, Point2f* center, float radius) {+	cv::minEnclosingCircle(*points, *center, radius);+}+void cv_minMaxLoc(Mat* src, double* minVal, double* maxVal, Point* minLoc, Point* maxLoc, Mat* mask) {+	cv::minMaxLoc(*src, minVal, maxVal, minLoc, maxLoc, *mask);+}+void cv_mixChannels(vector_Mat* src, vector_Mat* dst, vector_int* fromTo) {+	cv::mixChannels(*src, *dst, *fromTo);+}+Moments* cv_moments(Mat* array, bool binaryImage) {+	return new Moments(cv::moments(*array, binaryImage));+}+void cv_morphologyEx(Mat* src, Mat* dst, int op, Mat* kernel, Point* anchor, int iterations, int borderType, Scalar* borderValue) {+	cv::morphologyEx(*src, *dst, op, *kernel, *anchor, iterations, borderType, *borderValue);+}+void cv_moveWindow(string* winname, int x, int y) {+	cv::moveWindow(*winname, x, y);+}+void cv_mulSpectrums(Mat* a, Mat* b, Mat* c, int flags, bool conjB) {+	cv::mulSpectrums(*a, *b, *c, flags, conjB);+}+void cv_mulTransposed(Mat* src, Mat* dst, bool aTa, Mat* delta, double scale, int dtype) {+	cv::mulTransposed(*src, *dst, aTa, *delta, scale, dtype);+}+void cv_multiply(Mat* src1, Mat* src2, Mat* dst, double scale, int dtype) {+	cv::multiply(*src1, *src2, *dst, scale, dtype);+}+string* cv_FileNode_name(FileNode* self) {+	return new string(self->name());+}+void cv_namedWindow(string* winname, int flags) {+	cv::namedWindow(*winname, flags);+}+int cv_Subdiv2D_nextEdge(Subdiv2D* self, int edge) {+	return self->nextEdge(edge);+}+double cv_norm(Mat* src1, int normType, Mat* mask) {+	return cv::norm(*src1, normType, *mask);+}+double cv_norm4(Mat* src1, Mat* src2, int normType, Mat* mask) {+	return cv::norm(*src1, *src2, normType, *mask);+}+void cv_normalize(Mat* src, Mat* dst, double alpha, double beta, int norm_type, int dtype, Mat* mask) {+	cv::normalize(*src, *dst, alpha, beta, norm_type, dtype, *mask);+}+bool cv_FileStorage_open(FileStorage* self, string* filename, int flags, string* encoding) {+	return self->open(*filename, flags, *encoding);+}+bool cv_VideoCapture_open1(VideoCapture* self, int device) {+	return self->open(device);+}+bool cv_VideoWriter_open5(VideoWriter* self, string* filename, int fourcc, double fps, Size* frameSize, bool isColor) {+	return self->open(*filename, fourcc, fps, *frameSize, isColor);+}+void cv_StereoBM_call(StereoBM* self, Mat* left, Mat* right, Mat* disparity, int disptype) {+	self->operator ()(*left, *right, *disparity, disptype);+}+void cv_StarDetector_call(StarDetector* self, Mat* image, vector_KeyPoint* keypoints) {+	self->operator ()(*image, *keypoints);+}+void cv_StereoVar_call(StereoVar* self, Mat* left, Mat* right, Mat* disp) {+	self->operator ()(*left, *right, *disp);+}+void cv_Feature2D_call(Feature2D* self, Mat* image, Mat* mask, vector_KeyPoint* keypoints, Mat* descriptors, bool useProvidedKeypoints) {+	self->operator ()(*image, *mask, *keypoints, *descriptors, useProvidedKeypoints);+}+FileNode* cv_FileStorage_getelem(FileStorage* self, c_string nodename) {+	return new FileNode(self->operator[](nodename));+}+FileNode* cv_FileNode_getelem(FileNode* self, int i) {+	return new FileNode(self->operator[](i));+}+string* cv_Algorithm_paramHelp(Algorithm* self, string* name) {+	return new string(self->paramHelp(*name));+}+int cv_Algorithm_paramType(Algorithm* self, string* name) {+	return self->paramType(*name);+}+void cv_patchNaNs(Mat* a, double val) {+	cv::patchNaNs(*a, val);+}+void cv_perspectiveTransform(Mat* src, Mat* dst, Mat* m) {+	cv::perspectiveTransform(*src, *dst, *m);+}+void cv_phase(Mat* x, Mat* y, Mat* angle, bool angleInDegrees) {+	cv::phase(*x, *y, *angle, angleInDegrees);+}+Point2d* cv_phaseCorrelate(Mat* src1, Mat* src2, Mat* window) {+	return new Point2d(cv::phaseCorrelate(*src1, *src2, *window));+}+Point2d* cv_phaseCorrelateRes(Mat* src1, Mat* src2, Mat* window, double* response) {+	return new Point2d(cv::phaseCorrelateRes(*src1, *src2, *window, response));+}+double cv_pointPolygonTest(Mat* contour, Point2f* pt, bool measureDist) {+	return cv::pointPolygonTest(*contour, *pt, measureDist);+}+void cv_polarToCart(Mat* magnitude, Mat* angle, Mat* x, Mat* y, bool angleInDegrees) {+	cv::polarToCart(*magnitude, *angle, *x, *y, angleInDegrees);+}+void cv_polylines(Mat* img, vector_Mat* pts, bool isClosed, Scalar* color, int thickness, int lineType, int shift) {+	cv::polylines(*img, *pts, isClosed, *color, thickness, lineType, shift);+}+void cv_pow(Mat* src, double power, Mat* dst) {+	cv::pow(*src, power, *dst);+}+void cv_preCornerDetect(Mat* src, Mat* dst, int ksize, int borderType) {+	cv::preCornerDetect(*src, *dst, ksize, borderType);+}+float cv_CvNormalBayesClassifier_predict(CvNormalBayesClassifier* self, Mat* samples, Mat* results) {+	return self->predict(*samples, results);+}+Mat* cv_KalmanFilter_predict1(KalmanFilter* self, Mat* control) {+	return new Mat(self->predict(*control));+}+float cv_CvANN_MLP_predict2(CvANN_MLP* self, Mat* inputs, Mat* outputs) {+	return self->predict(*inputs, *outputs);+}+void cv_FaceRecognizer_predict3(FaceRecognizer* self, Mat* src, int label, double confidence) {+	self->predict(*src, label, confidence);+}+float cv_CvGBTrees_predict4(CvGBTrees* self, Mat* sample, Mat* missing, Range* slice, int k) {+	return self->predict(*sample, *missing, *slice, k);+}+float cv_CvBoost_predict5(CvBoost* self, Mat* sample, Mat* missing, Range* slice, bool rawMode, bool returnSum) {+	return self->predict(*sample, *missing, *slice, rawMode, returnSum);+}+float cv_CvRTrees_predict_prob(CvRTrees* self, Mat* sample, Mat* missing) {+	return self->predict_prob(*sample, *missing);+}+void cv_projectPoints(Mat* objectPoints, Mat* rvec, Mat* tvec, Mat* cameraMatrix, Mat* distCoeffs, Mat* imagePoints, Mat* jacobian, double aspectRatio) {+	cv::projectPoints(*objectPoints, *rvec, *tvec, *cameraMatrix, *distCoeffs, *imagePoints, *jacobian, aspectRatio);+}+void cv_CvBoost_prune(CvBoost* self, CvSlice* slice) {+	self->prune(*slice);+}+void cv_putText(Mat* img, string* text, Point* org, int fontFace, double fontScale, Scalar* color, int thickness, int lineType, bool bottomLeftOrigin) {+	cv::putText(*img, *text, *org, fontFace, fontScale, *color, thickness, lineType, bottomLeftOrigin);+}+void cv_pyrDown(Mat* src, Mat* dst, Size* dstsize, int borderType) {+	cv::pyrDown(*src, *dst, *dstsize, borderType);+}+void cv_pyrMeanShiftFiltering(Mat* src, Mat* dst, double sp, double sr, int maxLevel, TermCriteria* termcrit) {+	cv::pyrMeanShiftFiltering(*src, *dst, sp, sr, maxLevel, *termcrit);+}+void cv_pyrUp(Mat* src, Mat* dst, Size* dstsize, int borderType) {+	cv::pyrUp(*src, *dst, *dstsize, borderType);+}+int cv_Index_radiusSearch(Index* self, Mat* query, Mat* indices, Mat* dists, double radius, int maxResults, SearchParams* params) {+	return self->radiusSearch(*query, *indices, *dists, radius, maxResults, *params);+}+void cv_randShuffle_(Mat* dst, double iterFactor) {+	cv::randShuffle_(*dst, iterFactor);+}+void cv_randn(Mat* dst, Mat* mean, Mat* stddev) {+	cv::randn(*dst, *mean, *stddev);+}+void cv_randu(Mat* dst, Mat* low, Mat* high) {+	cv::randu(*dst, *low, *high);+}+bool cv_VideoCapture_read(VideoCapture* self, Mat* image) {+	return self->read(*image);+}+void cv_rectangle(Mat* img, Point* pt1, Point* pt2, Scalar* color, int thickness, int lineType, int shift) {+	cv::rectangle(*img, *pt1, *pt2, *color, thickness, lineType, shift);+}+float cv_rectify3Collinear(Mat* cameraMatrix1, Mat* distCoeffs1, Mat* cameraMatrix2, Mat* distCoeffs2, Mat* cameraMatrix3, Mat* distCoeffs3, vector_Mat* imgpt1, vector_Mat* imgpt3, Size* imageSize, Mat* R12, Mat* T12, Mat* R13, Mat* T13, Mat* R1, Mat* R2, Mat* R3, Mat* P1, Mat* P2, Mat* P3, Mat* Q, double alpha, Size* newImgSize, Rect* roi1, Rect* roi2, int flags) {+	return cv::rectify3Collinear(*cameraMatrix1, *distCoeffs1, *cameraMatrix2, *distCoeffs2, *cameraMatrix3, *distCoeffs3, *imgpt1, *imgpt3, *imageSize, *R12, *T12, *R13, *T13, *R1, *R2, *R3, *P1, *P2, *P3, *Q, alpha, *newImgSize, roi1, roi2, flags);+}+void cv_reduce(Mat* src, Mat* dst, int dim, int rtype, int dtype) {+	cv::reduce(*src, *dst, dim, rtype, dtype);+}+void cv_FileStorage_release(FileStorage* self) {+	self->release();+}+void cv_VideoWriter_release0(VideoWriter* self) {+	self->release();+}+string* cv_FileStorage_releaseAndGetString(FileStorage* self) {+	return new string(self->releaseAndGetString());+}+void cv_remap(Mat* src, Mat* dst, Mat* map1, Mat* map2, int interpolation, int borderMode, Scalar* borderValue) {+	cv::remap(*src, *dst, *map1, *map2, interpolation, borderMode, *borderValue);+}+void cv_repeat(Mat* src, int ny, int nx, Mat* dst) {+	cv::repeat(*src, ny, nx, *dst);+}+void cv_reprojectImageTo3D(Mat* disparity, Mat* _3dImage, Mat* Q, bool handleMissingValues, int ddepth) {+	cv::reprojectImageTo3D(*disparity, *_3dImage, *Q, handleMissingValues, ddepth);+}+void cv_resize(Mat* src, Mat* dst, Size* dsize, double fx, double fy, int interpolation) {+	cv::resize(*src, *dst, *dsize, fx, fy, interpolation);+}+void cv_resizeWindow(string* winname, int width, int height) {+	cv::resizeWindow(*winname, width, height);+}+bool cv_VideoCapture_retrieve(VideoCapture* self, Mat* image, int channel) {+	return self->retrieve(*image, channel);+}+FileNode* cv_FileStorage_root(FileStorage* self, int streamidx) {+	return new FileNode(self->root(streamidx));+}+int cv_Subdiv2D_rotateEdge(Subdiv2D* self, int edge, int rotate) {+	return self->rotateEdge(edge, rotate);+}+void cv_Index_save(Index* self, string* filename) {+	self->save(*filename);+}+void cv_FaceRecognizer_save1(FaceRecognizer* self, string* filename) {+	self->save(*filename);+}+void cv_HOGDescriptor_save2(HOGDescriptor* self, String* filename, String* objname) {+	self->save(*filename, *objname);+}+void cv_scaleAdd(Mat* src1, double alpha, Mat* src2, Mat* dst) {+	cv::scaleAdd(*src1, alpha, *src2, *dst);+}+void cv_segmentMotion(Mat* mhi, Mat* segmask, vector_Rect* boundingRects, double timestamp, double segThresh) {+	cv::segmentMotion(*mhi, *segmask, *boundingRects, timestamp, segThresh);+}+void cv_sepFilter2D(Mat* src, Mat* dst, int ddepth, Mat* kernelX, Mat* kernelY, Point* anchor, double delta, int borderType) {+	cv::sepFilter2D(*src, *dst, ddepth, *kernelX, *kernelY, *anchor, delta, borderType);+}+bool cv_VideoCapture_set(VideoCapture* self, int propId, double value) {+	return self->set(propId, value);+}+void cv_Algorithm_setAlgorithm(Algorithm* self, string* name, Algorithm* value) {+	self->setAlgorithm(*name, value);+}+void cv_Algorithm_setBool(Algorithm* self, string* name, bool value) {+	self->setBool(*name, value);+}+void cv_CLAHE_setClipLimit(CLAHE* self, double clipLimit) {+	self->setClipLimit(clipLimit);+}+void cv_Algorithm_setDouble(Algorithm* self, string* name, double value) {+	self->setDouble(*name, value);+}+void cv_setIdentity(Mat* mtx, Scalar* s) {+	cv::setIdentity(*mtx, *s);+}+void cv_Algorithm_setInt(Algorithm* self, string* name, int value) {+	self->setInt(*name, value);+}+void cv_Algorithm_setMat(Algorithm* self, string* name, Mat* value) {+	self->setMat(*name, *value);+}+void cv_Algorithm_setMatVector(Algorithm* self, string* name, vector_Mat* value) {+	self->setMatVector(*name, *value);+}+void cv_HOGDescriptor_setSVMDetector(HOGDescriptor* self, Mat* _svmdetector) {+	self->setSVMDetector(*_svmdetector);+}+void cv_Algorithm_setString(Algorithm* self, string* name, string* value) {+	self->setString(*name, *value);+}+void cv_CLAHE_setTilesGridSize(CLAHE* self, Size* tileGridSize) {+	self->setTilesGridSize(*tileGridSize);+}+void cv_setTrackbarPos(string* trackbarname, string* winname, int pos) {+	cv::setTrackbarPos(*trackbarname, *winname, pos);+}+void cv_setUseOptimized(bool onoff) {+	cv::setUseOptimized(onoff);+}+void cv_setWindowProperty(string* winname, int prop_id, double prop_value) {+	cv::setWindowProperty(*winname, prop_id, prop_value);+}+size_t cv_FileNode_size(FileNode* self) {+	return self->size();+}+bool cv_solve(Mat* src1, Mat* src2, Mat* dst, int flags) {+	return cv::solve(*src1, *src2, *dst, flags);+}+int cv_solveCubic(Mat* coeffs, Mat* roots) {+	return cv::solveCubic(*coeffs, *roots);+}+bool cv_solvePnP(Mat* objectPoints, Mat* imagePoints, Mat* cameraMatrix, Mat* distCoeffs, Mat* rvec, Mat* tvec, bool useExtrinsicGuess, int flags) {+	return cv::solvePnP(*objectPoints, *imagePoints, *cameraMatrix, *distCoeffs, *rvec, *tvec, useExtrinsicGuess, flags);+}+void cv_solvePnPRansac(Mat* objectPoints, Mat* imagePoints, Mat* cameraMatrix, Mat* distCoeffs, Mat* rvec, Mat* tvec, bool useExtrinsicGuess, int iterationsCount, float reprojectionError, int minInliersCount, Mat* inliers, int flags) {+	cv::solvePnPRansac(*objectPoints, *imagePoints, *cameraMatrix, *distCoeffs, *rvec, *tvec, useExtrinsicGuess, iterationsCount, reprojectionError, minInliersCount, *inliers, flags);+}+double cv_solvePoly(Mat* coeffs, Mat* roots, int maxIters) {+	return cv::solvePoly(*coeffs, *roots, maxIters);+}+void cv_sort(Mat* src, Mat* dst, int flags) {+	cv::sort(*src, *dst, flags);+}+void cv_sortIdx(Mat* src, Mat* dst, int flags) {+	cv::sortIdx(*src, *dst, flags);+}+void cv_split(Mat* m, vector_Mat* mv) {+	cv::split(*m, *mv);+}+void cv_sqrt(Mat* src, Mat* dst) {+	cv::sqrt(*src, *dst);+}+int cv_startWindowThread() {+	return cv::startWindowThread();+}+double cv_stereoCalibrate(vector_Mat* objectPoints, vector_Mat* imagePoints1, vector_Mat* imagePoints2, Mat* cameraMatrix1, Mat* distCoeffs1, Mat* cameraMatrix2, Mat* distCoeffs2, Size* imageSize, Mat* R, Mat* T, Mat* E, Mat* F, TermCriteria* criteria, int flags) {+	return cv::stereoCalibrate(*objectPoints, *imagePoints1, *imagePoints2, *cameraMatrix1, *distCoeffs1, *cameraMatrix2, *distCoeffs2, *imageSize, *R, *T, *E, *F, *criteria, flags);+}+void cv_stereoRectify(Mat* cameraMatrix1, Mat* distCoeffs1, Mat* cameraMatrix2, Mat* distCoeffs2, Size* imageSize, Mat* R, Mat* T, Mat* R1, Mat* R2, Mat* P1, Mat* P2, Mat* Q, int flags, double alpha, Size* newImageSize, Rect* validPixROI1, Rect* validPixROI2) {+	cv::stereoRectify(*cameraMatrix1, *distCoeffs1, *cameraMatrix2, *distCoeffs2, *imageSize, *R, *T, *R1, *R2, *P1, *P2, *Q, flags, alpha, *newImageSize, validPixROI1, validPixROI2);+}+bool cv_stereoRectifyUncalibrated(Mat* points1, Mat* points2, Mat* F, Size* imgSize, Mat* H1, Mat* H2, double threshold) {+	return cv::stereoRectifyUncalibrated(*points1, *points2, *F, *imgSize, *H1, *H2, threshold);+}+void cv_subtract(Mat* src1, Mat* src2, Mat* dst, Mat* mask, int dtype) {+	cv::subtract(*src1, *src2, *dst, *mask, dtype);+}+Scalar* cv_sum(Mat* src) {+	return new Scalar(cv::sum(*src));+}+int cv_Subdiv2D_symEdge(Subdiv2D* self, int edge) {+	return self->symEdge(edge);+}+double cv_threshold(Mat* src, Mat* dst, double thresh, double maxval, int type) {+	return cv::threshold(*src, *dst, thresh, maxval, type);+}+Scalar* cv_trace(Mat* mtx) {+	return new Scalar(cv::trace(*mtx));+}+bool cv_CvNormalBayesClassifier_train(CvNormalBayesClassifier* self, Mat* trainData, Mat* responses, Mat* varIdx, Mat* sampleIdx, bool update) {+	return self->train(*trainData, *responses, *varIdx, *sampleIdx, update);+}+void cv_DescriptorMatcher_train0(DescriptorMatcher* self) {+	self->train();+}+void cv_FaceRecognizer_train2(FaceRecognizer* self, vector_Mat* src, Mat* labels) {+	self->train(*src, *labels);+}+bool cv_EM_train4(EM* self, Mat* samples, Mat* logLikelihoods, Mat* labels, Mat* probs) {+	return self->train(*samples, *logLikelihoods, *labels, *probs);+}+bool cv_CvSVM_train5(CvSVM* self, Mat* trainData, Mat* responses, Mat* varIdx, Mat* sampleIdx, CvSVMParams* params) {+	return self->train(*trainData, *responses, *varIdx, *sampleIdx, *params);+}+int cv_CvANN_MLP_train6(CvANN_MLP* self, Mat* inputs, Mat* outputs, Mat* sampleWeights, Mat* sampleIdx, CvANN_MLP_TrainParams* params, int flags) {+	return self->train(*inputs, *outputs, *sampleWeights, *sampleIdx, *params, flags);+}+bool cv_CvERTrees_train8(CvERTrees* self, Mat* trainData, int tflag, Mat* responses, Mat* varIdx, Mat* sampleIdx, Mat* varType, Mat* missingDataMask, CvRTParams* params) {+	return self->train(*trainData, tflag, *responses, *varIdx, *sampleIdx, *varType, *missingDataMask, *params);+}+bool cv_CvGBTrees_train9(CvGBTrees* self, Mat* trainData, int tflag, Mat* responses, Mat* varIdx, Mat* sampleIdx, Mat* varType, Mat* missingDataMask, CvGBTreesParams* params, bool update) {+	return self->train(*trainData, tflag, *responses, *varIdx, *sampleIdx, *varType, *missingDataMask, *params, update);+}+bool cv_EM_trainE(EM* self, Mat* samples, Mat* means0, Mat* covs0, Mat* weights0, Mat* logLikelihoods, Mat* labels, Mat* probs) {+	return self->trainE(*samples, *means0, *covs0, *weights0, *logLikelihoods, *labels, *probs);+}+bool cv_EM_trainM(EM* self, Mat* samples, Mat* probs0, Mat* logLikelihoods, Mat* labels, Mat* probs) {+	return self->trainM(*samples, *probs0, *logLikelihoods, *labels, *probs);+}+bool cv_CvSVM_train_auto(CvSVM* self, Mat* trainData, Mat* responses, Mat* varIdx, Mat* sampleIdx, CvSVMParams* params, int k_fold, CvParamGrid* Cgrid, CvParamGrid* gammaGrid, CvParamGrid* pGrid, CvParamGrid* nuGrid, CvParamGrid* coeffGrid, CvParamGrid* degreeGrid, bool balanced) {+	return self->train_auto(*trainData, *responses, *varIdx, *sampleIdx, *params, k_fold, *Cgrid, *gammaGrid, *pGrid, *nuGrid, *coeffGrid, *degreeGrid, balanced);+}+void cv_transform(Mat* src, Mat* dst, Mat* m) {+	cv::transform(*src, *dst, *m);+}+void cv_transpose(Mat* src, Mat* dst) {+	cv::transpose(*src, *dst);+}+void cv_triangulatePoints(Mat* projMatr1, Mat* projMatr2, Mat* projPoints1, Mat* projPoints2, Mat* points4D) {+	cv::triangulatePoints(*projMatr1, *projMatr2, *projPoints1, *projPoints2, *points4D);+}+int cv_FileNode_type(FileNode* self) {+	return self->type();+}+void cv_undistort(Mat* src, Mat* dst, Mat* cameraMatrix, Mat* distCoeffs, Mat* newCameraMatrix) {+	cv::undistort(*src, *dst, *cameraMatrix, *distCoeffs, *newCameraMatrix);+}+void cv_undistortPoints(Mat* src, Mat* dst, Mat* cameraMatrix, Mat* distCoeffs, Mat* R, Mat* P) {+	cv::undistortPoints(*src, *dst, *cameraMatrix, *distCoeffs, *R, *P);+}+void cv_FaceRecognizer_update(FaceRecognizer* self, vector_Mat* src, Mat* labels) {+	self->update(*src, *labels);+}+void cv_updateMotionHistory(Mat* silhouette, Mat* mhi, double timestamp, double duration) {+	cv::updateMotionHistory(*silhouette, *mhi, timestamp, duration);+}+bool cv_useOptimized() {+	return cv::useOptimized();+}+void cv_validateDisparity(Mat* disparity, Mat* cost, int minDisparity, int numberOfDisparities, int disp12MaxDisp) {+	cv::validateDisparity(*disparity, *cost, minDisparity, numberOfDisparities, disp12MaxDisp);+}+void cv_vconcat(vector_Mat* src, Mat* dst) {+	cv::vconcat(*src, *dst);+}+int cv_waitKey(int delay) {+	return cv::waitKey(delay);+}+void cv_warpAffine(Mat* src, Mat* dst, Mat* M, Size* dsize, int flags, int borderMode, Scalar* borderValue) {+	cv::warpAffine(*src, *dst, *M, *dsize, flags, borderMode, *borderValue);+}+void cv_warpPerspective(Mat* src, Mat* dst, Mat* M, Size* dsize, int flags, int borderMode, Scalar* borderValue) {+	cv::warpPerspective(*src, *dst, *M, *dsize, flags, borderMode, *borderValue);+}+void cv_watershed(Mat* image, Mat* markers) {+	cv::watershed(*image, *markers);+}+void cv_VideoWriter_write(VideoWriter* self, Mat* image) {+	self->write(*image);+}+}
+ opencv-raw.cabal view
@@ -0,0 +1,37 @@+name:                opencv-raw+version:             0.1.0.0+synopsis:            Raw Haskell bindings to OpenCV >= 2.0+homepage:            www.github.com/arjuncomar/opencv-raw.git+license:             BSD3+license-file:        LICENSE+author:              Arjun Comar+maintainer:          nrujac@gmail.com+category:            AI, Machine Vision+build-type:          Custom+cabal-version:       >=1.10++source-repository head+    type: git+    location: git://github.com++library+    include-dirs:           cbits/+    includes:               cbits/opencv_generated.hpp+                          , cbits/cpptypes.hpp+                          , cbits/mat.hpp+    c-sources:              cbits/opencv_generated.cpp+                          , cbits/cpptypes.cpp+                          , cbits/mat.cpp+    cc-options:             -fpermissive -O3+    ghc-options:            -pgml g++ -O2+    exposed-modules:        OpenCVRaw.Types+                          , OpenCVRaw.Consts+                          , OpenCVRaw.Funcs+                          , OpenCVRaw.CppTypes+                          , OpenCVRaw.Mat+    pkgconfig-depends:      opencv+    build-depends:          base >=4.6 && <4.7+                          , bindings-DSL >= 1.0.14 && <= 1.1+                          , Cabal >=1.16+                          , vector >= 0.10+    default-language:       Haskell2010