diff --git a/LICENSE b/LICENSE new file mode 100644 --- /dev/null +++ b/LICENSE @@ -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. diff --git a/OpenCVRaw/Consts.hsc b/OpenCVRaw/Consts.hsc new file mode 100644 --- /dev/null +++ b/OpenCVRaw/Consts.hsc @@ -0,0 +1,622 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +#include +#include +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 diff --git a/OpenCVRaw/CppTypes.hsc b/OpenCVRaw/CppTypes.hsc new file mode 100644 --- /dev/null +++ b/OpenCVRaw/CppTypes.hsc @@ -0,0 +1,19 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +#include +#include +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 ) +#ccall std_create_vector_int , Ptr CInt -> CSize -> IO (Ptr ) + +toStdString :: String -> IO (Ptr C'string) +toStdString s = do (cs, l) <- newCStringLen s + c'std_create_string cs (fromIntegral l) diff --git a/OpenCVRaw/Funcs.hsc b/OpenCVRaw/Funcs.hsc new file mode 100644 --- /dev/null +++ b/OpenCVRaw/Funcs.hsc @@ -0,0 +1,475 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +#include +#include +module OpenCVRaw.Funcs where +#strict_import +import Foreign.C +import Foreign.C.Types +import OpenCVRaw.Types +#ccall cv_create_BFMatcher , CInt -> CInt -> IO (Ptr ) +#ccall cv_create_BRISK , CInt -> CInt -> CFloat -> IO (Ptr ) +#ccall cv_create_BRISK5 , Ptr -> Ptr -> CFloat -> CFloat -> Ptr -> IO (Ptr ) +#ccall cv_create_BackgroundSubtractorMOG , IO (Ptr ) +#ccall cv_create_BackgroundSubtractorMOG4 , CInt -> CInt -> CDouble -> CDouble -> IO (Ptr ) +#ccall cv_CamShift , Ptr -> Ptr -> Ptr -> IO (Ptr ) +#ccall cv_Canny , Ptr -> Ptr -> CDouble -> CDouble -> CInt -> CInt -> IO () +#ccall cv_create_CascadeClassifier , IO (Ptr ) +#ccall cv_create_CascadeClassifier1 , Ptr -> IO (Ptr ) +#ccall cv_create_CvANN_MLP , IO (Ptr ) +#ccall cv_create_CvANN_MLP4 , Ptr -> CInt -> CDouble -> CDouble -> IO (Ptr ) +#ccall cv_create_CvBoost , IO (Ptr ) +#ccall cv_create_CvBoost8 , Ptr -> CInt -> Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> IO (Ptr ) +#ccall cv_create_CvDTree , IO (Ptr ) +#ccall cv_create_CvERTrees , IO (Ptr ) +#ccall cv_create_CvGBTrees , IO (Ptr ) +#ccall cv_create_CvGBTrees8 , Ptr -> CInt -> Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> IO (Ptr ) +#ccall cv_create_CvKNearest , IO (Ptr ) +#ccall cv_create_CvKNearest5 , Ptr -> Ptr -> Ptr -> CInt -> CInt -> IO (Ptr ) +#ccall cv_create_CvNormalBayesClassifier , IO (Ptr ) +#ccall cv_create_CvNormalBayesClassifier4 , Ptr -> Ptr -> Ptr -> Ptr -> IO (Ptr ) +#ccall cv_create_CvRTrees , IO (Ptr ) +#ccall cv_create_CvSVM , IO (Ptr ) +#ccall cv_create_CvSVM5 , Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> IO (Ptr ) +#ccall cv_create_DMatch , IO (Ptr ) +#ccall cv_create_DMatch3 , CInt -> CInt -> CFloat -> IO (Ptr ) +#ccall cv_create_DMatch4 , CInt -> CInt -> CInt -> CFloat -> IO (Ptr ) +#ccall cv_create_EM , CInt -> CInt -> Ptr -> IO (Ptr ) +#ccall cv_create_FastFeatureDetector , CInt -> CInt -> IO (Ptr ) +#ccall cv_create_FileNode , IO (Ptr ) +#ccall cv_create_FileStorage , IO (Ptr ) +#ccall cv_create_FileStorage3 , Ptr -> CInt -> Ptr -> IO (Ptr ) +#ccall cv_create_FlannBasedMatcher , Ptr -> Ptr -> IO (Ptr ) +#ccall cv_create_GFTTDetector , CInt -> CDouble -> CDouble -> CInt -> CInt -> CDouble -> IO (Ptr ) +#ccall cv_GaussianBlur , Ptr -> Ptr -> Ptr -> CDouble -> CDouble -> CInt -> IO () +#ccall cv_create_GridAdaptedFeatureDetector , Ptr -> CInt -> CInt -> CInt -> IO (Ptr ) +#ccall cv_create_HOGDescriptor , IO (Ptr ) +#ccall cv_create_HOGDescriptor1 , Ptr -> IO (Ptr ) +#ccall cv_create_HOGDescriptor11 , Ptr -> Ptr -> Ptr -> Ptr -> CInt -> CInt -> CDouble -> CInt -> CDouble -> CInt -> CInt -> IO (Ptr ) +#ccall cv_HoughCircles , Ptr -> Ptr -> CInt -> CDouble -> CDouble -> CDouble -> CDouble -> CInt -> CInt -> IO () +#ccall cv_HoughLines , Ptr -> Ptr -> CDouble -> CDouble -> CInt -> CDouble -> CDouble -> IO () +#ccall cv_HoughLinesP , Ptr -> Ptr -> CDouble -> CDouble -> CInt -> CDouble -> CDouble -> IO () +#ccall cv_HuMoments , Ptr -> Ptr -> IO () +#ccall cv_create_Index , IO (Ptr ) +#ccall cv_create_Index3 , Ptr -> Ptr -> Ptr -> IO (Ptr ) +#ccall cv_create_KDTree , IO (Ptr ) +#ccall cv_create_KDTree2 , Ptr -> CInt -> IO (Ptr ) +#ccall cv_create_KDTree3 , Ptr -> Ptr -> CInt -> IO (Ptr ) +#ccall cv_create_KalmanFilter , IO (Ptr ) +#ccall cv_create_KalmanFilter4 , CInt -> CInt -> CInt -> CInt -> IO (Ptr ) +#ccall cv_create_KeyPoint , IO (Ptr ) +#ccall cv_create_KeyPoint7 , CFloat -> CFloat -> CFloat -> CFloat -> CFloat -> CInt -> CInt -> IO (Ptr ) +#ccall cv_LUT , Ptr -> Ptr -> Ptr -> CInt -> IO () +#ccall cv_Laplacian , Ptr -> Ptr -> CInt -> CInt -> CDouble -> CDouble -> CInt -> IO () +#ccall cv_create_MSER , CInt -> CInt -> CInt -> CDouble -> CDouble -> CInt -> CDouble -> CDouble -> CInt -> IO (Ptr ) +#ccall cv_Mahalanobis , Ptr -> Ptr -> Ptr -> IO CDouble +#ccall cv_create_ORB , CInt -> CFloat -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO (Ptr ) +#ccall cv_PCABackProject , Ptr -> Ptr -> Ptr -> Ptr -> IO () +#ccall cv_PCACompute , Ptr -> Ptr -> Ptr -> CInt -> IO () +#ccall cv_PCAComputeVar , Ptr -> Ptr -> Ptr -> CDouble -> IO () +#ccall cv_PCAProject , Ptr -> Ptr -> Ptr -> Ptr -> IO () +#ccall cv_PSNR , Ptr -> Ptr -> IO CDouble +#ccall cv_create_Params , IO (Ptr ) +#ccall cv_create_PyramidAdaptedFeatureDetector , Ptr -> CInt -> IO (Ptr ) +#ccall cv_RQDecomp3x3 , Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> IO (Ptr ) +#ccall cv_Rodrigues , Ptr -> Ptr -> Ptr -> IO () +#ccall cv_SVBackSubst , Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> IO () +#ccall cv_SVDecomp , Ptr -> Ptr -> Ptr -> Ptr -> CInt -> IO () +#ccall cv_Scharr , Ptr -> Ptr -> CInt -> CInt -> CInt -> CDouble -> CDouble -> CInt -> IO () +#ccall cv_create_SimpleBlobDetector , Ptr -> IO (Ptr ) +#ccall cv_Sobel , Ptr -> Ptr -> CInt -> CInt -> CInt -> CInt -> CDouble -> CDouble -> CInt -> IO () +#ccall cv_create_StarDetector , CInt -> CInt -> CInt -> CInt -> CInt -> IO (Ptr ) +#ccall cv_create_StereoBM , IO (Ptr ) +#ccall cv_create_StereoBM3 , CInt -> CInt -> CInt -> IO (Ptr ) +#ccall cv_create_StereoSGBM , IO (Ptr ) +#ccall cv_create_StereoSGBM11 , CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO (Ptr ) +#ccall cv_create_StereoVar , IO (Ptr ) +#ccall cv_create_StereoVar12 , CInt -> CDouble -> CInt -> CInt -> CInt -> CInt -> CDouble -> CFloat -> CFloat -> CInt -> CInt -> CInt -> IO (Ptr ) +#ccall cv_create_Subdiv2D , IO (Ptr ) +#ccall cv_create_Subdiv2D1 , Ptr -> IO (Ptr ) +#ccall cv_create_VideoCapture , IO (Ptr ) +#ccall cv_create_VideoCapture1 , CInt -> IO (Ptr ) +#ccall cv_create_VideoWriter , IO (Ptr ) +#ccall cv_create_VideoWriter5 , Ptr -> CInt -> CDouble -> Ptr -> CInt -> IO (Ptr ) +#ccall cv_Algorithm__create , Ptr -> Ptr -> IO (Ptr ) +#ccall cv_absdiff , Ptr -> Ptr -> Ptr -> IO () +#ccall cv_accumulate , Ptr -> Ptr -> Ptr -> IO () +#ccall cv_accumulateProduct , Ptr -> Ptr -> Ptr -> Ptr -> IO () +#ccall cv_accumulateSquare , Ptr -> Ptr -> Ptr -> IO () +#ccall cv_accumulateWeighted , Ptr -> Ptr -> CDouble -> Ptr -> IO () +#ccall cv_adaptiveBilateralFilter , Ptr -> Ptr -> Ptr -> CDouble -> Ptr -> CInt -> IO () +#ccall cv_adaptiveThreshold , Ptr -> Ptr -> CDouble -> CInt -> CInt -> CInt -> CDouble -> IO () +#ccall cv_add , Ptr -> Ptr -> Ptr -> Ptr -> CInt -> IO () +#ccall cv_DescriptorMatcher_add1 , Ptr -> Ptr -> IO () +#ccall cv_addWeighted , Ptr -> CDouble -> Ptr -> CDouble -> CDouble -> Ptr -> CInt -> IO () +#ccall cv_CLAHE_apply , Ptr -> Ptr -> Ptr -> IO () +#ccall cv_applyColorMap , Ptr -> Ptr -> CInt -> IO () +#ccall cv_approxPolyDP , Ptr -> Ptr -> CDouble -> CInt -> IO () +#ccall cv_arcLength , Ptr -> CInt -> IO CDouble +#ccall cv_batchDistance , Ptr -> Ptr -> Ptr -> CInt -> Ptr -> CInt -> CInt -> Ptr -> CInt -> CInt -> IO () +#ccall cv_bilateralFilter , Ptr -> Ptr -> CInt -> CDouble -> CDouble -> CInt -> IO () +#ccall cv_bitwise_and , Ptr -> Ptr -> Ptr -> Ptr -> IO () +#ccall cv_bitwise_not , Ptr -> Ptr -> Ptr -> IO () +#ccall cv_bitwise_or , Ptr -> Ptr -> Ptr -> Ptr -> IO () +#ccall cv_bitwise_xor , Ptr -> Ptr -> Ptr -> Ptr -> IO () +#ccall cv_blur , Ptr -> Ptr -> Ptr -> Ptr -> CInt -> IO () +#ccall cv_borderInterpolate , CInt -> CInt -> CInt -> IO CInt +#ccall cv_boundingRect , Ptr -> IO (Ptr ) +#ccall cv_boxFilter , Ptr -> Ptr -> CInt -> Ptr -> Ptr -> CInt -> CInt -> IO () +#ccall cv_KDTree_build , Ptr -> Ptr -> CInt -> IO () +#ccall cv_Index_build3 , Ptr -> Ptr -> Ptr -> Ptr -> IO () +#ccall cv_buildOpticalFlowPyramid , Ptr -> Ptr -> Ptr -> CInt -> CInt -> CInt -> CInt -> CInt -> IO CInt +#ccall cv_calcBackProject , Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> CDouble -> IO () +#ccall cv_calcCovarMatrix , Ptr -> Ptr -> Ptr -> CInt -> CInt -> IO () +#ccall cv_calcGlobalOrientation , Ptr -> Ptr -> Ptr -> CDouble -> CDouble -> IO CDouble +#ccall cv_calcHist , Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> CInt -> IO () +#ccall cv_calcMotionGradient , Ptr -> Ptr -> Ptr -> CDouble -> CDouble -> CInt -> IO () +#ccall cv_calcOpticalFlowFarneback , Ptr -> Ptr -> Ptr -> CDouble -> CInt -> CInt -> CInt -> CInt -> CDouble -> CInt -> IO () +#ccall cv_calcOpticalFlowPyrLK , Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> CInt -> Ptr -> CInt -> CDouble -> IO () +#ccall cv_calcOpticalFlowSF , Ptr -> Ptr -> Ptr -> CInt -> CInt -> CInt -> IO () +#ccall cv_calcOpticalFlowSF16 , Ptr -> Ptr -> Ptr -> CInt -> CInt -> CInt -> CDouble -> CDouble -> CInt -> CDouble -> CDouble -> CDouble -> CInt -> CDouble -> CDouble -> CDouble -> IO () +#ccall cv_calibrateCamera , Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> CInt -> Ptr -> IO CDouble +#ccall cv_calibrationMatrixValues , Ptr -> Ptr -> CDouble -> CDouble -> CDouble -> CDouble -> CDouble -> Ptr -> CDouble -> IO () +#ccall cv_cartToPolar , Ptr -> Ptr -> Ptr -> Ptr -> CInt -> IO () +#ccall cv_chamerMatching , Ptr -> Ptr -> Ptr -> Ptr -> CDouble -> CInt -> CDouble -> CInt -> CInt -> CInt -> CDouble -> CDouble -> CDouble -> CDouble -> IO CInt +#ccall cv_HOGDescriptor_checkDetectorSize , Ptr -> IO CInt +#ccall cv_checkHardwareSupport , CInt -> IO CInt +#ccall cv_checkRange , Ptr -> CInt -> Ptr -> CDouble -> CDouble -> IO CInt +#ccall cv_circle , Ptr -> Ptr -> CInt -> Ptr -> CInt -> CInt -> CInt -> IO () +#ccall cv_CvNormalBayesClassifier_clear , Ptr -> IO () +#ccall cv_DescriptorMatcher_clear0 , Ptr -> IO () +#ccall cv_clipLine , Ptr -> Ptr -> Ptr -> IO CInt +#ccall cv_compare , Ptr -> Ptr -> Ptr -> CInt -> IO () +#ccall cv_compareHist , Ptr -> Ptr -> CInt -> IO CDouble +#ccall cv_completeSymm , Ptr -> CInt -> IO () +#ccall cv_composeRT , Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> IO () +#ccall cv_DescriptorExtractor_compute , Ptr -> Ptr -> Ptr -> Ptr -> IO () +#ccall cv_Feature2D_compute3 , Ptr -> Ptr -> Ptr -> Ptr -> IO () +#ccall cv_HOGDescriptor_compute5 , Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> IO () +#ccall cv_computeCorrespondEpilines , Ptr -> CInt -> Ptr -> Ptr -> IO () +#ccall cv_HOGDescriptor_computeGradient , Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> IO () +#ccall cv_contourArea , Ptr -> CInt -> IO CDouble +#ccall cv_convertMaps , Ptr -> Ptr -> Ptr -> Ptr -> CInt -> CInt -> IO () +#ccall cv_convertPointsFromHomogeneous , Ptr -> Ptr -> IO () +#ccall cv_convertPointsToHomogeneous , Ptr -> Ptr -> IO () +#ccall cv_convertScaleAbs , Ptr -> Ptr -> CDouble -> CDouble -> IO () +#ccall cv_convexHull , Ptr -> Ptr -> CInt -> CInt -> IO () +#ccall cv_convexityDefects , Ptr -> Ptr -> Ptr -> IO () +#ccall cv_copyMakeBorder , Ptr -> Ptr -> CInt -> CInt -> CInt -> CInt -> CInt -> Ptr -> IO () +#ccall cv_cornerEigenValsAndVecs , Ptr -> Ptr -> CInt -> CInt -> CInt -> IO () +#ccall cv_cornerHarris , Ptr -> Ptr -> CInt -> CInt -> CDouble -> CInt -> IO () +#ccall cv_cornerMinEigenVal , Ptr -> Ptr -> CInt -> CInt -> CInt -> IO () +#ccall cv_cornerSubPix , Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> IO () +#ccall cv_KalmanFilter_correct , Ptr -> Ptr -> IO (Ptr ) +#ccall cv_correctMatches , Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> IO () +#ccall cv_countNonZero , Ptr -> IO CInt +#ccall cv_CvANN_MLP_create , Ptr -> Ptr -> CInt -> CDouble -> CDouble -> IO () +#ccall cv_DescriptorMatcher_create1 , Ptr -> Ptr -> IO (Ptr ) +#ccall cv_createCLAHE , CDouble -> Ptr -> IO (Ptr ) +#ccall cv_createEigenFaceRecognizer , CInt -> CDouble -> IO (Ptr ) +#ccall cv_createFisherFaceRecognizer , CInt -> CDouble -> IO (Ptr ) +#ccall cv_createHanningWindow , Ptr -> Ptr -> CInt -> IO () +#ccall cv_createLBPHFaceRecognizer , CInt -> CInt -> CInt -> CInt -> CDouble -> IO (Ptr ) +#ccall cv_cubeRoot , CFloat -> IO CFloat +#ccall cv_cvtColor , Ptr -> Ptr -> CInt -> CInt -> IO () +#ccall cv_dct , Ptr -> Ptr -> CInt -> IO () +#ccall cv_decomposeProjectionMatrix , Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> IO () +#ccall cv_destroyAllWindows , IO () +#ccall cv_destroyWindow , Ptr -> IO () +#ccall cv_FeatureDetector_detect , Ptr -> Ptr -> Ptr -> Ptr -> IO () +#ccall cv_HOGDescriptor_detect7 , Ptr -> Ptr -> Ptr -> Ptr -> CDouble -> Ptr -> Ptr -> Ptr -> IO () +#ccall cv_CascadeClassifier_detectMultiScale , Ptr -> Ptr -> Ptr -> CDouble -> CInt -> CInt -> Ptr -> Ptr -> IO () +#ccall cv_CascadeClassifier_detectMultiScale10 , Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> CDouble -> CInt -> CInt -> Ptr -> Ptr -> CInt -> IO () +#ccall cv_HOGDescriptor_detectMultiScale9 , Ptr -> Ptr -> Ptr -> Ptr -> CDouble -> Ptr -> Ptr -> CDouble -> CDouble -> CInt -> IO () +#ccall cv_determinant , Ptr -> IO CDouble +#ccall cv_dft , Ptr -> Ptr -> CInt -> CInt -> IO () +#ccall cv_dilate , Ptr -> Ptr -> Ptr -> Ptr -> CInt -> CInt -> Ptr -> IO () +#ccall cv_KDTree_dims , Ptr -> IO CInt +#ccall cv_distanceTransform , Ptr -> Ptr -> Ptr -> CInt -> CInt -> CInt -> IO () +#ccall cv_distanceTransform4 , Ptr -> Ptr -> CInt -> CInt -> IO () +#ccall cv_divide , Ptr -> Ptr -> Ptr -> CDouble -> CInt -> IO () +#ccall cv_divide4 , CDouble -> Ptr -> Ptr -> CInt -> IO () +#ccall cv_drawChessboardCorners , Ptr -> Ptr -> Ptr -> CInt -> IO () +#ccall cv_drawContours , Ptr -> Ptr -> CInt -> Ptr -> CInt -> CInt -> Ptr -> CInt -> Ptr -> IO () +#ccall cv_drawDataMatrixCodes , Ptr -> Ptr -> Ptr -> IO () +#ccall cv_drawKeypoints , Ptr -> Ptr -> Ptr -> Ptr -> CInt -> IO () +#ccall cv_Subdiv2D_edgeDst , Ptr -> CInt -> Ptr -> IO CInt +#ccall cv_Subdiv2D_edgeOrg , Ptr -> CInt -> Ptr -> IO CInt +#ccall cv_eigen , Ptr -> CInt -> Ptr -> Ptr -> IO CInt +#ccall cv_ellipse , Ptr -> Ptr -> Ptr -> CDouble -> CDouble -> CDouble -> Ptr -> CInt -> CInt -> CInt -> IO () +#ccall cv_ellipse2Poly , Ptr -> Ptr -> CInt -> CInt -> CInt -> CInt -> Ptr -> IO () +#ccall cv_ellipse5 , Ptr -> Ptr -> Ptr -> CInt -> CInt -> IO () +#ccall cv_FileNode_empty , Ptr -> IO CInt +#ccall cv_CascadeClassifier_empty0 , Ptr -> IO CInt +#ccall cv_equalizeHist , Ptr -> Ptr -> IO () +#ccall cv_erode , Ptr -> Ptr -> Ptr -> Ptr -> CInt -> CInt -> Ptr -> IO () +#ccall cv_estimateAffine3D , Ptr -> Ptr -> Ptr -> Ptr -> CDouble -> CDouble -> IO CInt +#ccall cv_estimateRigidTransform , Ptr -> Ptr -> CInt -> IO (Ptr ) +#ccall cv_exp , Ptr -> Ptr -> IO () +#ccall cv_extractChannel , Ptr -> Ptr -> CInt -> IO () +#ccall cv_fastAtan2 , CFloat -> CFloat -> IO CFloat +#ccall cv_fillConvexPoly , Ptr -> Ptr -> Ptr -> CInt -> CInt -> IO () +#ccall cv_fillPoly , Ptr -> Ptr -> Ptr -> CInt -> CInt -> Ptr -> IO () +#ccall cv_filter2D , Ptr -> Ptr -> CInt -> Ptr -> Ptr -> CDouble -> CInt -> IO () +#ccall cv_filterSpeckles , Ptr -> CDouble -> CInt -> CDouble -> Ptr -> IO () +#ccall cv_findChessboardCorners , Ptr -> Ptr -> Ptr -> CInt -> IO CInt +#ccall cv_findCirclesGrid , Ptr -> Ptr -> Ptr -> CInt -> Ptr -> IO CInt +#ccall cv_findCirclesGridDefault , Ptr -> Ptr -> Ptr -> CInt -> IO CInt +#ccall cv_findContours , Ptr -> Ptr -> Ptr -> CInt -> CInt -> Ptr -> IO () +#ccall cv_findDataMatrix , Ptr -> Ptr -> Ptr -> Ptr -> IO () +#ccall cv_findFundamentalMat , Ptr -> Ptr -> CInt -> CDouble -> CDouble -> Ptr -> IO (Ptr ) +#ccall cv_findHomography , Ptr -> Ptr -> CInt -> CDouble -> Ptr -> IO (Ptr ) +#ccall cv_KDTree_findNearest , Ptr -> Ptr -> CInt -> CInt -> Ptr -> Ptr -> Ptr -> Ptr -> IO CInt +#ccall cv_Subdiv2D_findNearest2 , Ptr -> Ptr -> Ptr -> IO CInt +#ccall cv_findNonZero , Ptr -> Ptr -> IO () +#ccall cv_KDTree_findOrthoRange , Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> IO () +#ccall cv_CvKNearest_find_nearest , Ptr -> Ptr -> CInt -> Ptr -> Ptr -> Ptr -> IO CFloat +#ccall cv_fitEllipse , Ptr -> IO (Ptr ) +#ccall cv_fitLine , Ptr -> Ptr -> CInt -> CDouble -> CDouble -> CDouble -> IO () +#ccall cv_flip , Ptr -> Ptr -> CInt -> IO () +#ccall cv_floodFill , Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> CInt -> IO CInt +#ccall cv_gemm , Ptr -> Ptr -> CDouble -> Ptr -> CDouble -> Ptr -> CInt -> IO () +#ccall cv_BRISK_generateKernel , Ptr -> Ptr -> Ptr -> CFloat -> CFloat -> Ptr -> IO () +#ccall cv_VideoCapture_get , Ptr -> CInt -> IO CDouble +#ccall cv_getAffineTransform , Ptr -> Ptr -> IO (Ptr ) +#ccall cv_Algorithm_getAlgorithm , Ptr -> Ptr -> IO (Ptr ) +#ccall cv_Index_getAlgorithm0 , Ptr -> IO (Ptr ) +#ccall cv_Algorithm_getBool , Ptr -> Ptr -> IO CInt +#ccall cv_getBuildInformation , IO (Ptr ) +#ccall cv_getCPUTickCount , IO CLong +#ccall cv_HOGDescriptor_getDaimlerPeopleDetector , Ptr -> IO (Ptr ) +#ccall cv_getDefaultNewCameraMatrix , Ptr -> Ptr -> CInt -> IO (Ptr ) +#ccall cv_HOGDescriptor_getDefaultPeopleDetector , Ptr -> IO (Ptr ) +#ccall cv_getDerivKernels , Ptr -> Ptr -> CInt -> CInt -> CInt -> CInt -> CInt -> IO () +#ccall cv_HOGDescriptor_getDescriptorSize , Ptr -> IO CSize +#ccall cv_Index_getDistance , Ptr -> IO (Ptr ) +#ccall cv_Algorithm_getDouble , Ptr -> Ptr -> IO CDouble +#ccall cv_Subdiv2D_getEdge , Ptr -> CInt -> CInt -> IO CInt +#ccall cv_Subdiv2D_getEdgeList , Ptr -> Ptr -> IO () +#ccall cv_FileStorage_getFirstTopLevelNode , Ptr -> IO (Ptr ) +#ccall cv_getGaborKernel , Ptr -> CDouble -> CDouble -> CDouble -> CDouble -> CDouble -> CInt -> IO (Ptr ) +#ccall cv_getGaussianKernel , CInt -> CDouble -> CInt -> IO (Ptr ) +#ccall cv_Algorithm_getInt , Ptr -> Ptr -> IO CInt +#ccall cv_Algorithm_getList , Ptr -> Ptr -> IO () +#ccall cv_Algorithm_getMat , Ptr -> Ptr -> IO (Ptr ) +#ccall cv_Algorithm_getMatVector , Ptr -> Ptr -> IO (Ptr ) +#ccall cv_getNumberOfCPUs , IO CInt +#ccall cv_getOptimalDFTSize , CInt -> IO CInt +#ccall cv_getOptimalNewCameraMatrix , Ptr -> Ptr -> Ptr -> CDouble -> Ptr -> Ptr -> CInt -> IO (Ptr ) +#ccall cv_Algorithm_getParams , Ptr -> Ptr -> IO () +#ccall cv_getPerspectiveTransform , Ptr -> Ptr -> IO (Ptr ) +#ccall cv_KDTree_getPoints , Ptr -> Ptr -> Ptr -> Ptr -> IO () +#ccall cv_getRectSubPix , Ptr -> Ptr -> Ptr -> Ptr -> CInt -> IO () +#ccall cv_getRotationMatrix2D , Ptr -> CDouble -> CDouble -> IO (Ptr ) +#ccall cv_Algorithm_getString , Ptr -> Ptr -> IO (Ptr ) +#ccall cv_getStructuringElement , CInt -> Ptr -> Ptr -> IO (Ptr ) +#ccall cv_getTextSize , Ptr -> CInt -> CDouble -> CInt -> Ptr CInt -> IO (Ptr ) +#ccall cv_getTickCount , IO CLong +#ccall cv_getTickFrequency , IO CDouble +#ccall cv_getTrackbarPos , Ptr -> Ptr -> IO CInt +#ccall cv_DescriptorMatcher_getTrainDescriptors , Ptr -> IO (Ptr ) +#ccall cv_Subdiv2D_getTriangleList , Ptr -> Ptr -> IO () +#ccall cv_getValidDisparityROI , Ptr -> Ptr -> CInt -> CInt -> CInt -> IO (Ptr ) +#ccall cv_CvDTree_getVarImportance , Ptr -> IO (Ptr ) +#ccall cv_CvRTrees_getVarImportance0 , Ptr -> IO (Ptr ) +#ccall cv_Subdiv2D_getVertex , Ptr -> CInt -> Ptr CInt -> IO (Ptr ) +#ccall cv_Subdiv2D_getVoronoiFacetList , Ptr -> Ptr -> Ptr -> Ptr -> IO () +#ccall cv_HOGDescriptor_getWinSigma , Ptr -> IO CDouble +#ccall cv_getWindowProperty , Ptr -> CInt -> IO CDouble +#ccall cv_CvSVM_get_support_vector_count , Ptr -> IO CInt +#ccall cv_CvSVM_get_var_count , Ptr -> IO CInt +#ccall cv_goodFeaturesToTrack , Ptr -> Ptr -> CInt -> CDouble -> CDouble -> Ptr -> CInt -> CInt -> CDouble -> IO () +#ccall cv_VideoCapture_grab , Ptr -> IO CInt +#ccall cv_grabCut , Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> CInt -> CInt -> IO () +#ccall cv_groupRectangles , Ptr -> Ptr -> CInt -> CDouble -> IO () +#ccall cv_hconcat , Ptr -> Ptr -> IO () +#ccall cv_idct , Ptr -> Ptr -> CInt -> IO () +#ccall cv_idft , Ptr -> Ptr -> CInt -> CInt -> IO () +#ccall cv_imdecode , Ptr -> CInt -> IO (Ptr ) +#ccall cv_imencode , Ptr -> Ptr -> Ptr -> Ptr -> IO CInt +#ccall cv_imread , Ptr -> CInt -> IO (Ptr ) +#ccall cv_imshow , Ptr -> Ptr -> IO () +#ccall cv_imwrite , Ptr -> Ptr -> Ptr -> IO CInt +#ccall cv_inRange , Ptr -> Ptr -> Ptr -> Ptr -> IO () +#ccall cv_initCameraMatrix2D , Ptr -> Ptr -> Ptr -> CDouble -> IO (Ptr ) +#ccall cv_Subdiv2D_initDelaunay , Ptr -> Ptr -> IO () +#ccall cv_initUndistortRectifyMap , Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> CInt -> Ptr -> Ptr -> IO () +#ccall cv_initWideAngleProjMap , Ptr -> Ptr -> Ptr -> CInt -> CInt -> Ptr -> Ptr -> CInt -> CDouble -> IO CFloat +#ccall cv_Subdiv2D_insert , Ptr -> Ptr -> IO CInt +#ccall cv_Subdiv2D_insert1 , Ptr -> Ptr -> IO () +#ccall cv_insertChannel , Ptr -> Ptr -> CInt -> IO () +#ccall cv_integral , Ptr -> Ptr -> CInt -> IO () +#ccall cv_integral4 , Ptr -> Ptr -> Ptr -> CInt -> IO () +#ccall cv_integral5 , Ptr -> Ptr -> Ptr -> Ptr -> CInt -> IO () +#ccall cv_intersectConvexConvex , Ptr -> Ptr -> Ptr -> CInt -> IO CFloat +#ccall cv_invert , Ptr -> Ptr -> CInt -> IO CDouble +#ccall cv_invertAffineTransform , Ptr -> Ptr -> IO () +#ccall cv_isContourConvex , Ptr -> IO CInt +#ccall cv_FileNode_isInt , Ptr -> IO CInt +#ccall cv_FileNode_isMap , Ptr -> IO CInt +#ccall cv_FileNode_isNamed , Ptr -> IO CInt +#ccall cv_FileNode_isNone , Ptr -> IO CInt +#ccall cv_FileStorage_isOpened , Ptr -> IO CInt +#ccall cv_VideoWriter_isOpened0 , Ptr -> IO CInt +#ccall cv_FileNode_isReal , Ptr -> IO CInt +#ccall cv_FileNode_isSeq , Ptr -> IO CInt +#ccall cv_FileNode_isString , Ptr -> IO CInt +#ccall cv_EM_isTrained , Ptr -> IO CInt +#ccall cv_kmeans , Ptr -> CInt -> Ptr -> Ptr -> CInt -> CInt -> Ptr -> IO CDouble +#ccall cv_DescriptorMatcher_knnMatch , Ptr -> Ptr -> Ptr -> Ptr -> CInt -> Ptr -> CInt -> IO () +#ccall cv_DescriptorMatcher_knnMatch5 , Ptr -> Ptr -> Ptr -> CInt -> Ptr -> CInt -> IO () +#ccall cv_Index_knnSearch , Ptr -> Ptr -> Ptr -> Ptr -> CInt -> Ptr -> IO () +#ccall cv_line , Ptr -> Ptr -> Ptr -> Ptr -> CInt -> CInt -> CInt -> IO () +#ccall cv_Index_load , Ptr -> Ptr -> Ptr -> IO CInt +#ccall cv_FaceRecognizer_load1 , Ptr -> Ptr -> IO () +#ccall cv_HOGDescriptor_load2 , Ptr -> Ptr -> Ptr -> IO CInt +#ccall cv_Subdiv2D_locate , Ptr -> Ptr -> CInt -> CInt -> IO CInt +#ccall cv_log , Ptr -> Ptr -> IO () +#ccall cv_magnitude , Ptr -> Ptr -> Ptr -> IO () +#ccall cv_matMulDeriv , Ptr -> Ptr -> Ptr -> Ptr -> IO () +#ccall cv_DescriptorMatcher_match , Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> IO () +#ccall cv_DescriptorMatcher_match3 , Ptr -> Ptr -> Ptr -> Ptr -> IO () +#ccall cv_matchShapes , Ptr -> Ptr -> CInt -> CDouble -> IO CDouble +#ccall cv_matchTemplate , Ptr -> Ptr -> Ptr -> CInt -> IO () +#ccall cv_max , Ptr -> Ptr -> Ptr -> IO () +#ccall cv_mean , Ptr -> Ptr -> IO (Ptr ) +#ccall cv_meanShift , Ptr -> Ptr -> Ptr -> IO CInt +#ccall cv_meanStdDev , Ptr -> Ptr -> Ptr -> Ptr -> IO () +#ccall cv_medianBlur , Ptr -> Ptr -> CInt -> IO () +#ccall cv_merge , Ptr -> Ptr -> IO () +#ccall cv_min , Ptr -> Ptr -> Ptr -> IO () +#ccall cv_minAreaRect , Ptr -> IO (Ptr ) +#ccall cv_minEnclosingCircle , Ptr -> Ptr -> CFloat -> IO () +#ccall cv_minMaxLoc , Ptr -> Ptr CDouble -> Ptr CDouble -> Ptr -> Ptr -> Ptr -> IO () +#ccall cv_mixChannels , Ptr -> Ptr -> Ptr -> IO () +#ccall cv_moments , Ptr -> CInt -> IO (Ptr ) +#ccall cv_morphologyEx , Ptr -> Ptr -> CInt -> Ptr -> Ptr -> CInt -> CInt -> Ptr -> IO () +#ccall cv_moveWindow , Ptr -> CInt -> CInt -> IO () +#ccall cv_mulSpectrums , Ptr -> Ptr -> Ptr -> CInt -> CInt -> IO () +#ccall cv_mulTransposed , Ptr -> Ptr -> CInt -> Ptr -> CDouble -> CInt -> IO () +#ccall cv_multiply , Ptr -> Ptr -> Ptr -> CDouble -> CInt -> IO () +#ccall cv_FileNode_name , Ptr -> IO (Ptr ) +#ccall cv_namedWindow , Ptr -> CInt -> IO () +#ccall cv_Subdiv2D_nextEdge , Ptr -> CInt -> IO CInt +#ccall cv_norm , Ptr -> CInt -> Ptr -> IO CDouble +#ccall cv_norm4 , Ptr -> Ptr -> CInt -> Ptr -> IO CDouble +#ccall cv_normalize , Ptr -> Ptr -> CDouble -> CDouble -> CInt -> CInt -> Ptr -> IO () +#ccall cv_FileStorage_open , Ptr -> Ptr -> CInt -> Ptr -> IO CInt +#ccall cv_VideoCapture_open1 , Ptr -> CInt -> IO CInt +#ccall cv_VideoWriter_open5 , Ptr -> Ptr -> CInt -> CDouble -> Ptr -> CInt -> IO CInt +#ccall cv_StereoBM_call , Ptr -> Ptr -> Ptr -> Ptr -> CInt -> IO () +#ccall cv_StarDetector_call , Ptr -> Ptr -> Ptr -> IO () +#ccall cv_StereoVar_call , Ptr -> Ptr -> Ptr -> Ptr -> IO () +#ccall cv_Feature2D_call , Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> CInt -> IO () +#ccall cv_FileStorage_getelem , Ptr -> CString -> IO (Ptr ) +#ccall cv_FileNode_getelem , Ptr -> CInt -> IO (Ptr ) +#ccall cv_Algorithm_paramHelp , Ptr -> Ptr -> IO (Ptr ) +#ccall cv_Algorithm_paramType , Ptr -> Ptr -> IO CInt +#ccall cv_patchNaNs , Ptr -> CDouble -> IO () +#ccall cv_perspectiveTransform , Ptr -> Ptr -> Ptr -> IO () +#ccall cv_phase , Ptr -> Ptr -> Ptr -> CInt -> IO () +#ccall cv_phaseCorrelate , Ptr -> Ptr -> Ptr -> IO (Ptr ) +#ccall cv_phaseCorrelateRes , Ptr -> Ptr -> Ptr -> Ptr CDouble -> IO (Ptr ) +#ccall cv_pointPolygonTest , Ptr -> Ptr -> CInt -> IO CDouble +#ccall cv_polarToCart , Ptr -> Ptr -> Ptr -> Ptr -> CInt -> IO () +#ccall cv_polylines , Ptr -> Ptr -> CInt -> Ptr -> CInt -> CInt -> CInt -> IO () +#ccall cv_pow , Ptr -> CDouble -> Ptr -> IO () +#ccall cv_preCornerDetect , Ptr -> Ptr -> CInt -> CInt -> IO () +#ccall cv_CvNormalBayesClassifier_predict , Ptr -> Ptr -> Ptr -> IO CFloat +#ccall cv_KalmanFilter_predict1 , Ptr -> Ptr -> IO (Ptr ) +#ccall cv_CvANN_MLP_predict2 , Ptr -> Ptr -> Ptr -> IO CFloat +#ccall cv_FaceRecognizer_predict3 , Ptr -> Ptr -> CInt -> CDouble -> IO () +#ccall cv_CvGBTrees_predict4 , Ptr -> Ptr -> Ptr -> Ptr -> CInt -> IO CFloat +#ccall cv_CvBoost_predict5 , Ptr -> Ptr -> Ptr -> Ptr -> CInt -> CInt -> IO CFloat +#ccall cv_CvRTrees_predict_prob , Ptr -> Ptr -> Ptr -> IO CFloat +#ccall cv_projectPoints , Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> CDouble -> IO () +#ccall cv_CvBoost_prune , Ptr -> Ptr -> IO () +#ccall cv_putText , Ptr -> Ptr -> Ptr -> CInt -> CDouble -> Ptr -> CInt -> CInt -> CInt -> IO () +#ccall cv_pyrDown , Ptr -> Ptr -> Ptr -> CInt -> IO () +#ccall cv_pyrMeanShiftFiltering , Ptr -> Ptr -> CDouble -> CDouble -> CInt -> Ptr -> IO () +#ccall cv_pyrUp , Ptr -> Ptr -> Ptr -> CInt -> IO () +#ccall cv_Index_radiusSearch , Ptr -> Ptr -> Ptr -> Ptr -> CDouble -> CInt -> Ptr -> IO CInt +#ccall cv_randShuffle_ , Ptr -> CDouble -> IO () +#ccall cv_randn , Ptr -> Ptr -> Ptr -> IO () +#ccall cv_randu , Ptr -> Ptr -> Ptr -> IO () +#ccall cv_VideoCapture_read , Ptr -> Ptr -> IO CInt +#ccall cv_rectangle , Ptr -> Ptr -> Ptr -> Ptr -> CInt -> CInt -> CInt -> IO () +#ccall cv_rectify3Collinear , Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> CDouble -> Ptr -> Ptr -> Ptr -> CInt -> IO CFloat +#ccall cv_reduce , Ptr -> Ptr -> CInt -> CInt -> CInt -> IO () +#ccall cv_FileStorage_release , Ptr -> IO () +#ccall cv_VideoWriter_release0 , Ptr -> IO () +#ccall cv_FileStorage_releaseAndGetString , Ptr -> IO (Ptr ) +#ccall cv_remap , Ptr -> Ptr -> Ptr -> Ptr -> CInt -> CInt -> Ptr -> IO () +#ccall cv_repeat , Ptr -> CInt -> CInt -> Ptr -> IO () +#ccall cv_reprojectImageTo3D , Ptr -> Ptr -> Ptr -> CInt -> CInt -> IO () +#ccall cv_resize , Ptr -> Ptr -> Ptr -> CDouble -> CDouble -> CInt -> IO () +#ccall cv_resizeWindow , Ptr -> CInt -> CInt -> IO () +#ccall cv_VideoCapture_retrieve , Ptr -> Ptr -> CInt -> IO CInt +#ccall cv_FileStorage_root , Ptr -> CInt -> IO (Ptr ) +#ccall cv_Subdiv2D_rotateEdge , Ptr -> CInt -> CInt -> IO CInt +#ccall cv_Index_save , Ptr -> Ptr -> IO () +#ccall cv_FaceRecognizer_save1 , Ptr -> Ptr -> IO () +#ccall cv_HOGDescriptor_save2 , Ptr -> Ptr -> Ptr -> IO () +#ccall cv_scaleAdd , Ptr -> CDouble -> Ptr -> Ptr -> IO () +#ccall cv_segmentMotion , Ptr -> Ptr -> Ptr -> CDouble -> CDouble -> IO () +#ccall cv_sepFilter2D , Ptr -> Ptr -> CInt -> Ptr -> Ptr -> Ptr -> CDouble -> CInt -> IO () +#ccall cv_VideoCapture_set , Ptr -> CInt -> CDouble -> IO CInt +#ccall cv_Algorithm_setAlgorithm , Ptr -> Ptr -> Ptr -> IO () +#ccall cv_Algorithm_setBool , Ptr -> Ptr -> CInt -> IO () +#ccall cv_CLAHE_setClipLimit , Ptr -> CDouble -> IO () +#ccall cv_Algorithm_setDouble , Ptr -> Ptr -> CDouble -> IO () +#ccall cv_setIdentity , Ptr -> Ptr -> IO () +#ccall cv_Algorithm_setInt , Ptr -> Ptr -> CInt -> IO () +#ccall cv_Algorithm_setMat , Ptr -> Ptr -> Ptr -> IO () +#ccall cv_Algorithm_setMatVector , Ptr -> Ptr -> Ptr -> IO () +#ccall cv_HOGDescriptor_setSVMDetector , Ptr -> Ptr -> IO () +#ccall cv_Algorithm_setString , Ptr -> Ptr -> Ptr -> IO () +#ccall cv_CLAHE_setTilesGridSize , Ptr -> Ptr -> IO () +#ccall cv_setTrackbarPos , Ptr -> Ptr -> CInt -> IO () +#ccall cv_setUseOptimized , CInt -> IO () +#ccall cv_setWindowProperty , Ptr -> CInt -> CDouble -> IO () +#ccall cv_FileNode_size , Ptr -> IO CSize +#ccall cv_solve , Ptr -> Ptr -> Ptr -> CInt -> IO CInt +#ccall cv_solveCubic , Ptr -> Ptr -> IO CInt +#ccall cv_solvePnP , Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> CInt -> CInt -> IO CInt +#ccall cv_solvePnPRansac , Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> CInt -> CInt -> CFloat -> CInt -> Ptr -> CInt -> IO () +#ccall cv_solvePoly , Ptr -> Ptr -> CInt -> IO CDouble +#ccall cv_sort , Ptr -> Ptr -> CInt -> IO () +#ccall cv_sortIdx , Ptr -> Ptr -> CInt -> IO () +#ccall cv_split , Ptr -> Ptr -> IO () +#ccall cv_sqrt , Ptr -> Ptr -> IO () +#ccall cv_startWindowThread , IO CInt +#ccall cv_stereoCalibrate , Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> CInt -> IO CDouble +#ccall cv_stereoRectify , Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> CInt -> CDouble -> Ptr -> Ptr -> Ptr -> IO () +#ccall cv_stereoRectifyUncalibrated , Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> CDouble -> IO CInt +#ccall cv_subtract , Ptr -> Ptr -> Ptr -> Ptr -> CInt -> IO () +#ccall cv_sum , Ptr -> IO (Ptr ) +#ccall cv_Subdiv2D_symEdge , Ptr -> CInt -> IO CInt +#ccall cv_threshold , Ptr -> Ptr -> CDouble -> CDouble -> CInt -> IO CDouble +#ccall cv_trace , Ptr -> IO (Ptr ) +#ccall cv_CvNormalBayesClassifier_train , Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> CInt -> IO CInt +#ccall cv_DescriptorMatcher_train0 , Ptr -> IO () +#ccall cv_FaceRecognizer_train2 , Ptr -> Ptr -> Ptr -> IO () +#ccall cv_EM_train4 , Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> IO CInt +#ccall cv_CvSVM_train5 , Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> IO CInt +#ccall cv_CvANN_MLP_train6 , Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> CInt -> IO CInt +#ccall cv_CvERTrees_train8 , Ptr -> Ptr -> CInt -> Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> IO CInt +#ccall cv_CvGBTrees_train9 , Ptr -> Ptr -> CInt -> Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> CInt -> IO CInt +#ccall cv_EM_trainE , Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> IO CInt +#ccall cv_EM_trainM , Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> IO CInt +#ccall cv_CvSVM_train_auto , Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> CInt -> Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> CInt -> IO CInt +#ccall cv_transform , Ptr -> Ptr -> Ptr -> IO () +#ccall cv_transpose , Ptr -> Ptr -> IO () +#ccall cv_triangulatePoints , Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> IO () +#ccall cv_FileNode_type , Ptr -> IO CInt +#ccall cv_undistort , Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> IO () +#ccall cv_undistortPoints , Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> Ptr -> IO () +#ccall cv_FaceRecognizer_update , Ptr -> Ptr -> Ptr -> IO () +#ccall cv_updateMotionHistory , Ptr -> Ptr -> CDouble -> CDouble -> IO () +#ccall cv_useOptimized , IO CInt +#ccall cv_validateDisparity , Ptr -> Ptr -> CInt -> CInt -> CInt -> IO () +#ccall cv_vconcat , Ptr -> Ptr -> IO () +#ccall cv_waitKey , CInt -> IO CInt +#ccall cv_warpAffine , Ptr -> Ptr -> Ptr -> Ptr -> CInt -> CInt -> Ptr -> IO () +#ccall cv_warpPerspective , Ptr -> Ptr -> Ptr -> Ptr -> CInt -> CInt -> Ptr -> IO () +#ccall cv_watershed , Ptr -> Ptr -> IO () +#ccall cv_VideoWriter_write , Ptr -> Ptr -> IO () diff --git a/OpenCVRaw/Mat.hsc b/OpenCVRaw/Mat.hsc new file mode 100644 --- /dev/null +++ b/OpenCVRaw/Mat.hsc @@ -0,0 +1,50 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +#include +#include +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 ) +#ccall cv_Mat_getRow , Ptr -> CInt -> IO (Ptr ) +#ccall cv_Mat_getCol , Ptr -> CInt -> IO (Ptr ) +#ccall cv_Mat_getRowRange , Ptr -> CInt -> CInt -> IO (Ptr ) +#ccall cv_Mat_getColRange , Ptr -> CInt -> CInt -> IO (Ptr ) +#ccall cv_Mat_elemSize , Ptr -> IO CSize +#ccall cv_Mat_elemSize1 , Ptr -> IO CSize +#ccall cv_Mat_type , Ptr -> IO CInt +#ccall cv_Mat_depth , Ptr -> IO CInt +#ccall cv_Mat_total , Ptr -> IO CSize +#ccall cv_Mat_isContinuous , Ptr -> IO CInt +#ccall cv_Mat_channels , Ptr -> IO CInt +#ccall cv_Mat_rows , Ptr -> IO CInt +#ccall cv_Mat_cols , Ptr -> IO CInt +#ccall cv_Mat_empty , Ptr -> IO CInt +#ccall cv_Mat_size , Ptr -> IO (Ptr ) +#ccall cv_Mat_step1 , Ptr -> IO CSize +#ccall cv_Mat_diag , Ptr -> IO (Ptr ) +#ccall cv_Mat_diag_d , Ptr -> CInt -> IO (Ptr ) +#ccall cv_create_diagMat , Ptr -> IO (Ptr ) + +#ccall cv_Mat_assign , Ptr -> Ptr -> IO (Ptr ) +#ccall cv_Mat_assignVal , Ptr -> Ptr -> IO (Ptr ) +#ccall cv_Mat_clone , Ptr -> IO (Ptr ) +#ccall cv_Mat_copyTo , Ptr -> Ptr -> IO () +#ccall cv_Mat_copyTo_masked , Ptr -> Ptr -> Ptr -> IO () +#ccall cv_Mat_assignTo , Ptr -> Ptr -> IO () +#ccall cv_Mat_assignTo_t , Ptr -> Ptr -> CInt -> IO () +#ccall cv_Mat_setTo , Ptr -> Ptr -> IO (Ptr ) +#ccall cv_Mat_setTo_masked , Ptr -> Ptr -> Ptr -> IO (Ptr ) + +#ccall cv_Mat_reshape , Ptr -> CInt -> IO (Ptr ) +#ccall cv_Mat_reshape_rows , Ptr -> CInt -> CInt -> IO (Ptr ) + +#ccall cv_Mat_ptr , Ptr -> IO (Ptr CUChar) + diff --git a/OpenCVRaw/Types.hsc b/OpenCVRaw/Types.hsc new file mode 100644 --- /dev/null +++ b/OpenCVRaw/Types.hsc @@ -0,0 +1,99 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +#include +#include +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 diff --git a/Setup.hs b/Setup.hs new file mode 100644 --- /dev/null +++ b/Setup.hs @@ -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 } + diff --git a/cbits/cpptypes.cpp b/cbits/cpptypes.cpp new file mode 100644 --- /dev/null +++ b/cbits/cpptypes.cpp @@ -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 +#include + +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); + +} +} diff --git a/cbits/mat.cpp b/cbits/mat.cpp new file mode 100644 --- /dev/null +++ b/cbits/mat.cpp @@ -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 +#include + +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(); +} +} diff --git a/cbits/opencv_generated.cpp b/cbits/opencv_generated.cpp new file mode 100644 --- /dev/null +++ b/cbits/opencv_generated.cpp @@ -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); +} +} diff --git a/opencv-raw.cabal b/opencv-raw.cabal new file mode 100644 --- /dev/null +++ b/opencv-raw.cabal @@ -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