opencv 0.5.3

//
// This file is auto-generated, please don't edit!
//

#include "stdint.h"
#include "common.h"

typedef int64_t int64;

#include <iostream>
#include "opencv2/opencv_modules.hpp"
#include <string>
#include "common_opencv.h"

using namespace cv;
#include "types.h"
#include "/usr/include/opencv2/core.hpp"
#include "/usr/include/opencv2/core/affine.hpp"
#include "/usr/include/opencv2/core/base.hpp"
#include "/usr/include/opencv2/core/bufferpool.hpp"
#include "/usr/include/opencv2/core/core.hpp"
#include "/usr/include/opencv2/core/core_c.h"
#include "/usr/include/opencv2/core/cv_cpu_helper.h"
#include "/usr/include/opencv2/core/cvdef.h"
#include "/usr/include/opencv2/core/directx.hpp"
#include "/usr/include/opencv2/core/fast_math.hpp"
#include "/usr/include/opencv2/core/hal/hal.hpp"
#include "/usr/include/opencv2/core/hal/interface.h"
#include "/usr/include/opencv2/core/mat.hpp"
#include "/usr/include/opencv2/core/matx.hpp"
#include "/usr/include/opencv2/core/neon_utils.hpp"
#include "/usr/include/opencv2/core/optim.hpp"
#include "/usr/include/opencv2/core/ovx.hpp"
#include "/usr/include/opencv2/core/saturate.hpp"
#include "/usr/include/opencv2/core/softfloat.hpp"
#include "/usr/include/opencv2/core/sse_utils.hpp"
#include "/usr/include/opencv2/core/traits.hpp"
#include "/usr/include/opencv2/core/types.hpp"
#include "/usr/include/opencv2/core/types_c.h"
#include "/usr/include/opencv2/core/utility.hpp"
#include "/usr/include/opencv2/core/utils/filesystem.hpp"
#include "/usr/include/opencv2/core/utils/logger.defines.hpp"
#include "/usr/include/opencv2/core/utils/logger.hpp"
#include "/usr/include/opencv2/core/va_intel.hpp"
#include "/usr/include/opencv2/core/version.hpp"
#include "/usr/include/opencv2/core/vsx_utils.hpp"
#include "/usr/include/opencv2/core/wimage.hpp"
#include "/usr/include/opencv2/calib3d.hpp"
#include "/usr/include/opencv2/calib3d/calib3d.hpp"
#include "/usr/include/opencv2/calib3d/calib3d_c.h"
#include "/usr/include/opencv2/features2d.hpp"
#include "/usr/include/opencv2/features2d/features2d.hpp"
#include "/usr/include/opencv2/features2d/hal/interface.h"
#include "/usr/include/opencv2/highgui.hpp"
#include "/usr/include/opencv2/highgui/highgui.hpp"
#include "/usr/include/opencv2/highgui/highgui_c.h"
#include "/usr/include/opencv2/imgcodecs.hpp"
#include "/usr/include/opencv2/imgcodecs/imgcodecs.hpp"
#include "/usr/include/opencv2/imgcodecs/imgcodecs_c.h"
#include "/usr/include/opencv2/imgproc.hpp"
#include "/usr/include/opencv2/imgproc/hal/hal.hpp"
#include "/usr/include/opencv2/imgproc/hal/interface.h"
#include "/usr/include/opencv2/imgproc/imgproc.hpp"
#include "/usr/include/opencv2/imgproc/imgproc_c.h"
#include "/usr/include/opencv2/imgproc/types_c.h"
#include "/usr/include/opencv2/ml.hpp"
#include "/usr/include/opencv2/ml/ml.hpp"
#include "/usr/include/opencv2/objdetect.hpp"
#include "/usr/include/opencv2/objdetect/detection_based_tracker.hpp"
#include "/usr/include/opencv2/objdetect/objdetect.hpp"
#include "/usr/include/opencv2/objdetect/objdetect_c.h"
#include "/usr/include/opencv2/photo.hpp"
#include "/usr/include/opencv2/photo/photo.hpp"
#include "/usr/include/opencv2/photo/photo_c.h"
#include "/usr/include/opencv2/shape.hpp"
#include "/usr/include/opencv2/shape/emdL1.hpp"
#include "/usr/include/opencv2/shape/hist_cost.hpp"
#include "/usr/include/opencv2/shape/shape.hpp"
#include "/usr/include/opencv2/shape/shape_distance.hpp"
#include "/usr/include/opencv2/shape/shape_transformer.hpp"
#include "/usr/include/opencv2/stitching.hpp"
#include "/usr/include/opencv2/stitching/warpers.hpp"
#include "/usr/include/opencv2/superres.hpp"
#include "/usr/include/opencv2/video.hpp"
#include "/usr/include/opencv2/video/background_segm.hpp"
#include "/usr/include/opencv2/video/tracking.hpp"
#include "/usr/include/opencv2/video/tracking_c.h"
#include "/usr/include/opencv2/video/video.hpp"
#include "/usr/include/opencv2/videoio.hpp"
#include "/usr/include/opencv2/videoio/videoio.hpp"
#include "/usr/include/opencv2/videoio/videoio_c.h"
#include "/usr/include/opencv2/videostab.hpp"
#include "/usr/include/opencv2/videostab/deblurring.hpp"
#include "/usr/include/opencv2/videostab/fast_marching.hpp"
#include "/usr/include/opencv2/videostab/frame_source.hpp"
#include "/usr/include/opencv2/videostab/global_motion.hpp"
#include "/usr/include/opencv2/videostab/inpainting.hpp"
#include "/usr/include/opencv2/videostab/log.hpp"
#include "/usr/include/opencv2/videostab/motion_core.hpp"
#include "/usr/include/opencv2/videostab/motion_stabilizing.hpp"
#include "/usr/include/opencv2/videostab/optical_flow.hpp"
#include "/usr/include/opencv2/videostab/outlier_rejection.hpp"
#include "/usr/include/opencv2/videostab/ring_buffer.hpp"
#include "/usr/include/opencv2/videostab/stabilizer.hpp"
#include "/usr/include/opencv2/videostab/wobble_suppression.hpp"
#include "/usr/include/opencv2/dnn.hpp"
#include "/usr/include/opencv2/dnn/all_layers.hpp"
#include "/usr/include/opencv2/dnn/dict.hpp"
#include "/usr/include/opencv2/dnn/dnn.hpp"
#include "/usr/include/opencv2/dnn/layer.hpp"
#include "/usr/include/opencv2/dnn/shape_utils.hpp"


extern "C" {

#include "return_types.h"

// CV_FOURCC_char_c1_char_c2_char_c3_char_c4
// parsed: CV_FOURCC
// as:     CV_FOURCC (function)
// Arg ARG Primitive(char) c1= Primitive(char) = 
// Arg ARG Primitive(char) c2= Primitive(char) = 
// Arg ARG Primitive(char) c3= Primitive(char) = 
// Arg ARG Primitive(char) c4= Primitive(char) = 
// Return value: Primitive(int)
cv_return_value_int cv_core_CV_FOURCC_char_c1_char_c2_char_c3_char_c4(char c1, char c2, char c3, char c4) {
    try {
        int ret = CV_FOURCC(c1, c2, c3, c4);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cvCbrt_float_value
// parsed: cvCbrt
// as:     cvCbrt (function)
// Arg ARG Primitive(float) value= Primitive(float) = 
// Return value: Primitive(float)
cv_return_value_float cv_core_cvCbrt_float_value(float value) {
    try {
        float ret = cvCbrt(value);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<float*>(&ret) };
    } CVRS_CATCH(cv_return_value_float)
}

// cvChangeSeqBlock_void_X_reader_int_direction
// parsed: cvChangeSeqBlock
// as:     cvChangeSeqBlock (function)
// Arg ARG RawPtr[Primitive(void)] * reader= (ptr) RawPtr[Primitive(void)] = 
// Arg ARG Primitive(int) direction= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cvChangeSeqBlock_void_X_reader_int_direction(void* reader, int direction) {
    try {
        cvChangeSeqBlock(reader, direction);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cvCheckHardwareSupport_int_feature
// parsed: cvCheckHardwareSupport
// as:     cvCheckHardwareSupport (function)
// Arg ARG Primitive(int) feature= Primitive(int) = 
// Return value: Primitive(int)
cv_return_value_int cv_core_cvCheckHardwareSupport_int_feature(int feature) {
    try {
        int ret = cvCheckHardwareSupport(feature);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cvContourPerimeter_const_void_X_contour
// parsed: cvContourPerimeter
// as:     cvContourPerimeter (function)
// Arg ARG RawPtr[Primitive(void)] * contour= (ptr) RawPtr[Primitive(void)] = 
// Return value: Primitive(double)
cv_return_value_double cv_core_cvContourPerimeter_const_void_X_contour(const void* contour) {
    try {
        double ret = cvContourPerimeter(contour);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cvDestroyAllWindows
// parsed: cvDestroyAllWindows
// as:     cvDestroyAllWindows (function)
// Return value: Primitive(void)
cv_return_value_void cv_core_cvDestroyAllWindows() {
    try {
        cvDestroyAllWindows();
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cvDestroyWindow_const_char_X_name
// parsed: cvDestroyWindow
// as:     cvDestroyWindow (function)
// Arg ARG RawPtr[Primitive(char)] * name= (ptr) RawPtr[Primitive(char)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cvDestroyWindow_const_char_X_name(const char* name) {
    try {
        cvDestroyWindow(name);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cvDisplayOverlay_const_char_X_name_const_char_X_text_int_delayms
// parsed: cvDisplayOverlay
// as:     cvDisplayOverlay (function)
// Arg ARG RawPtr[Primitive(char)] * name= (ptr) RawPtr[Primitive(char)] = 
// Arg ARG RawPtr[Primitive(char)] * text= (ptr) RawPtr[Primitive(char)] = 
// Arg ARG Primitive(int) delayms= Primitive(int) = 0
// Return value: Primitive(void)
cv_return_value_void cv_core_cvDisplayOverlay_const_char_X_name_const_char_X_text_int_delayms(const char* name, const char* text, int delayms) {
    try {
        cvDisplayOverlay(name, text, delayms);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cvDisplayStatusBar_const_char_X_name_const_char_X_text_int_delayms
// parsed: cvDisplayStatusBar
// as:     cvDisplayStatusBar (function)
// Arg ARG RawPtr[Primitive(char)] * name= (ptr) RawPtr[Primitive(char)] = 
// Arg ARG RawPtr[Primitive(char)] * text= (ptr) RawPtr[Primitive(char)] = 
// Arg ARG Primitive(int) delayms= Primitive(int) = 0
// Return value: Primitive(void)
cv_return_value_void cv_core_cvDisplayStatusBar_const_char_X_name_const_char_X_text_int_delayms(const char* name, const char* text, int delayms) {
    try {
        cvDisplayStatusBar(name, text, delayms);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cvErrorFromIppStatus_int_ipp_status
// parsed: cvErrorFromIppStatus
// as:     cvErrorFromIppStatus (function)
// Arg ARG Primitive(int) ipp_status= Primitive(int) = 
// Return value: Primitive(int)
cv_return_value_int cv_core_cvErrorFromIppStatus_int_ipp_status(int ipp_status) {
    try {
        int ret = cvErrorFromIppStatus(ipp_status);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cvErrorStr_int_status
// parsed: cvErrorStr
// as:     cvErrorStr (function)
// Arg ARG Primitive(int) status= Primitive(int) = 
// Return value: RawPtr[Primitive(char)]
cv_return_value_const_char_X cv_core_cvErrorStr_int_status(int status) {
    try {
        const char* ret = cvErrorStr(status);
        return { Error::Code::StsOk, NULL, strdup(ret) };
    } CVRS_CATCH(cv_return_value_const_char_X)
}

// cvError_int_status_const_char_X_func_name_const_char_X_err_msg_const_char_X_file_name_int_line
// parsed: cvError
// as:     cvError (function)
// Arg ARG Primitive(int) status= Primitive(int) = 
// Arg ARG RawPtr[Primitive(char)] * func_name= (ptr) RawPtr[Primitive(char)] = 
// Arg ARG RawPtr[Primitive(char)] * err_msg= (ptr) RawPtr[Primitive(char)] = 
// Arg ARG RawPtr[Primitive(char)] * file_name= (ptr) RawPtr[Primitive(char)] = 
// Arg ARG Primitive(int) line= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cvError_int_status_const_char_X_func_name_const_char_X_err_msg_const_char_X_file_name_int_line(int status, const char* func_name, const char* err_msg, const char* file_name, int line) {
    try {
        cvError(status, func_name, err_msg, file_name, line);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cvFastArctan_float_y_float_x
// parsed: cvFastArctan
// as:     cvFastArctan (function)
// Arg ARG Primitive(float) y= Primitive(float) = 
// Arg ARG Primitive(float) x= Primitive(float) = 
// Return value: Primitive(float)
cv_return_value_float cv_core_cvFastArctan_float_y_float_x(float y, float x) {
    try {
        float ret = cvFastArctan(y, x);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<float*>(&ret) };
    } CVRS_CATCH(cv_return_value_float)
}

// cvGetErrMode
// parsed: cvGetErrMode
// as:     cvGetErrMode (function)
// Return value: Primitive(int)
cv_return_value_int cv_core_cvGetErrMode() {
    try {
        int ret = cvGetErrMode();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cvGetErrStatus
// parsed: cvGetErrStatus
// as:     cvGetErrStatus (function)
// Return value: Primitive(int)
cv_return_value_int cv_core_cvGetErrStatus() {
    try {
        int ret = cvGetErrStatus();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cvGetNumThreads
// parsed: cvGetNumThreads
// as:     cvGetNumThreads (function)
// Return value: Primitive(int)
cv_return_value_int cv_core_cvGetNumThreads() {
    try {
        int ret = cvGetNumThreads();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cvGetOptimalDFTSize_int_size0
// parsed: cvGetOptimalDFTSize
// as:     cvGetOptimalDFTSize (function)
// Arg ARG Primitive(int) size0= Primitive(int) = 
// Return value: Primitive(int)
cv_return_value_int cv_core_cvGetOptimalDFTSize_int_size0(int size0) {
    try {
        int ret = cvGetOptimalDFTSize(size0);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cvGetThreadNum
// parsed: cvGetThreadNum
// as:     cvGetThreadNum (function)
// Return value: Primitive(int)
cv_return_value_int cv_core_cvGetThreadNum() {
    try {
        int ret = cvGetThreadNum();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cvGetTickCount
// parsed: cvGetTickCount
// as:     cvGetTickCount (function)
// Return value: Primitive(int64)
cv_return_value_int64 cv_core_cvGetTickCount() {
    try {
        int64 ret = cvGetTickCount();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int64*>(&ret) };
    } CVRS_CATCH(cv_return_value_int64)
}

// cvGetTickFrequency
// parsed: cvGetTickFrequency
// as:     cvGetTickFrequency (function)
// Return value: Primitive(double)
cv_return_value_double cv_core_cvGetTickFrequency() {
    try {
        double ret = cvGetTickFrequency();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cvGetTrackbarPos_const_char_X_trackbar_name_const_char_X_window_name
// parsed: cvGetTrackbarPos
// as:     cvGetTrackbarPos (function)
// Arg ARG RawPtr[Primitive(char)] * trackbar_name= (ptr) RawPtr[Primitive(char)] = 
// Arg ARG RawPtr[Primitive(char)] * window_name= (ptr) RawPtr[Primitive(char)] = 
// Return value: Primitive(int)
cv_return_value_int cv_core_cvGetTrackbarPos_const_char_X_trackbar_name_const_char_X_window_name(const char* trackbar_name, const char* window_name) {
    try {
        int ret = cvGetTrackbarPos(trackbar_name, window_name);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cvGetWindowHandle_const_char_X_name
// parsed: cvGetWindowHandle
// as:     cvGetWindowHandle (function)
// Arg ARG RawPtr[Primitive(char)] * name= (ptr) RawPtr[Primitive(char)] = 
// Return value: RawPtr[Primitive(void)]
cv_return_value_void_X cv_core_cvGetWindowHandle_const_char_X_name(const char* name) {
    try {
        void* ret = cvGetWindowHandle(name);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<void**>(&ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cvGetWindowImageRect_const_char_X_name
// parsed: cvGetWindowImageRect
// as:     cvGetWindowImageRect (function)
// Arg ARG RawPtr[Primitive(char)] * name= (ptr) RawPtr[Primitive(char)] = 
// Return value: cv::Rect (simple)
cv_return_value_RectWrapper cv_core_cvGetWindowImageRect_const_char_X_name(const char* name) {
    try {
        cv::Rect ret = cvGetWindowImageRect(name);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<RectWrapper*>(&ret) };
    } CVRS_CATCH(cv_return_value_RectWrapper)
}

// cvGetWindowName_void_X_window_handle
// parsed: cvGetWindowName
// as:     cvGetWindowName (function)
// Arg ARG RawPtr[Primitive(void)] * window_handle= (ptr) RawPtr[Primitive(void)] = 
// Return value: RawPtr[Primitive(char)]
cv_return_value_const_char_X cv_core_cvGetWindowName_void_X_window_handle(void* window_handle) {
    try {
        const char* ret = cvGetWindowName(window_handle);
        return { Error::Code::StsOk, NULL, strdup(ret) };
    } CVRS_CATCH(cv_return_value_const_char_X)
}

// cvGetWindowProperty_const_char_X_name_int_prop_id
// parsed: cvGetWindowProperty
// as:     cvGetWindowProperty (function)
// Arg ARG RawPtr[Primitive(char)] * name= (ptr) RawPtr[Primitive(char)] = 
// Arg ARG Primitive(int) prop_id= Primitive(int) = 
// Return value: Primitive(double)
cv_return_value_double cv_core_cvGetWindowProperty_const_char_X_name_int_prop_id(const char* name, int prop_id) {
    try {
        double ret = cvGetWindowProperty(name, prop_id);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cvGuiBoxReport_int_status_const_char_X_func_name_const_char_X_err_msg_const_char_X_file_name_int_line_void_X_userdata
// parsed: cvGuiBoxReport
// as:     cvGuiBoxReport (function)
// Arg ARG Primitive(int) status= Primitive(int) = 
// Arg ARG RawPtr[Primitive(char)] * func_name= (ptr) RawPtr[Primitive(char)] = 
// Arg ARG RawPtr[Primitive(char)] * err_msg= (ptr) RawPtr[Primitive(char)] = 
// Arg ARG RawPtr[Primitive(char)] * file_name= (ptr) RawPtr[Primitive(char)] = 
// Arg ARG Primitive(int) line= Primitive(int) = 
// Arg ARG RawPtr[Primitive(void)] * userdata= (ptr) RawPtr[Primitive(void)] = 
// Return value: Primitive(int)
cv_return_value_int cv_core_cvGuiBoxReport_int_status_const_char_X_func_name_const_char_X_err_msg_const_char_X_file_name_int_line_void_X_userdata(int status, const char* func_name, const char* err_msg, const char* file_name, int line, void* userdata) {
    try {
        int ret = cvGuiBoxReport(status, func_name, err_msg, file_name, line, userdata);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cvHaveImageReader_const_char_X_filename
// parsed: cvHaveImageReader
// as:     cvHaveImageReader (function)
// Arg ARG RawPtr[Primitive(char)] * filename= (ptr) RawPtr[Primitive(char)] = 
// Return value: Primitive(int)
cv_return_value_int cv_core_cvHaveImageReader_const_char_X_filename(const char* filename) {
    try {
        int ret = cvHaveImageReader(filename);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cvHaveImageWriter_const_char_X_filename
// parsed: cvHaveImageWriter
// as:     cvHaveImageWriter (function)
// Arg ARG RawPtr[Primitive(char)] * filename= (ptr) RawPtr[Primitive(char)] = 
// Return value: Primitive(int)
cv_return_value_int cv_core_cvHaveImageWriter_const_char_X_filename(const char* filename) {
    try {
        int ret = cvHaveImageWriter(filename);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cvInsertNodeIntoTree_void_X_node_void_X_parent_void_X_frame
// parsed: cvInsertNodeIntoTree
// as:     cvInsertNodeIntoTree (function)
// Arg ARG RawPtr[Primitive(void)] * node= (ptr) RawPtr[Primitive(void)] = 
// Arg ARG RawPtr[Primitive(void)] * parent= (ptr) RawPtr[Primitive(void)] = 
// Arg ARG RawPtr[Primitive(void)] * frame= (ptr) RawPtr[Primitive(void)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cvInsertNodeIntoTree_void_X_node_void_X_parent_void_X_frame(void* node, void* parent, void* frame) {
    try {
        cvInsertNodeIntoTree(node, parent, frame);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cvIplDepth_int_type
// parsed: cvIplDepth
// as:     cvIplDepth (function)
// Arg ARG Primitive(int) type= Primitive(int) = 
// Return value: Primitive(int)
cv_return_value_int cv_core_cvIplDepth_int_type(int type) {
    try {
        int ret = cvIplDepth(type);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cvLoadWindowParameters_const_char_X_name
// parsed: cvLoadWindowParameters
// as:     cvLoadWindowParameters (function)
// Arg ARG RawPtr[Primitive(char)] * name= (ptr) RawPtr[Primitive(char)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cvLoadWindowParameters_const_char_X_name(const char* name) {
    try {
        cvLoadWindowParameters(name);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cvMatchShapes_const_void_X_object1_const_void_X_object2_int_method_double_parameter
// parsed: cvMatchShapes
// as:     cvMatchShapes (function)
// Arg ARG RawPtr[Primitive(void)] * object1= (ptr) RawPtr[Primitive(void)] = 
// Arg ARG RawPtr[Primitive(void)] * object2= (ptr) RawPtr[Primitive(void)] = 
// Arg ARG Primitive(int) method= Primitive(int) = 
// Arg ARG Primitive(double) parameter= Primitive(double) = 0
// Return value: Primitive(double)
cv_return_value_double cv_core_cvMatchShapes_const_void_X_object1_const_void_X_object2_int_method_double_parameter(const void* object1, const void* object2, int method, double parameter) {
    try {
        double ret = cvMatchShapes(object1, object2, method, parameter);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cvMoveWindow_const_char_X_name_int_x_int_y
// parsed: cvMoveWindow
// as:     cvMoveWindow (function)
// Arg ARG RawPtr[Primitive(char)] * name= (ptr) RawPtr[Primitive(char)] = 
// Arg ARG Primitive(int) x= Primitive(int) = 
// Arg ARG Primitive(int) y= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cvMoveWindow_const_char_X_name_int_x_int_y(const char* name, int x, int y) {
    try {
        cvMoveWindow(name, x, y);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cvNamedWindow_const_char_X_name_int_flags
// parsed: cvNamedWindow
// as:     cvNamedWindow (function)
// Arg ARG RawPtr[Primitive(char)] * name= (ptr) RawPtr[Primitive(char)] = 
// Arg ARG Primitive(int) flags= Primitive(int) = CV_WINDOW_AUTOSIZE
// Return value: Primitive(int)
cv_return_value_int cv_core_cvNamedWindow_const_char_X_name_int_flags(const char* name, int flags) {
    try {
        int ret = cvNamedWindow(name, flags);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cvNulDevReport_int_status_const_char_X_func_name_const_char_X_err_msg_const_char_X_file_name_int_line_void_X_userdata
// parsed: cvNulDevReport
// as:     cvNulDevReport (function)
// Arg ARG Primitive(int) status= Primitive(int) = 
// Arg ARG RawPtr[Primitive(char)] * func_name= (ptr) RawPtr[Primitive(char)] = 
// Arg ARG RawPtr[Primitive(char)] * err_msg= (ptr) RawPtr[Primitive(char)] = 
// Arg ARG RawPtr[Primitive(char)] * file_name= (ptr) RawPtr[Primitive(char)] = 
// Arg ARG Primitive(int) line= Primitive(int) = 
// Arg ARG RawPtr[Primitive(void)] * userdata= (ptr) RawPtr[Primitive(void)] = 
// Return value: Primitive(int)
cv_return_value_int cv_core_cvNulDevReport_int_status_const_char_X_func_name_const_char_X_err_msg_const_char_X_file_name_int_line_void_X_userdata(int status, const char* func_name, const char* err_msg, const char* file_name, int line, void* userdata) {
    try {
        int ret = cvNulDevReport(status, func_name, err_msg, file_name, line, userdata);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cvRANSACUpdateNumIters_double_p_double_err_prob_int_model_points_int_max_iters
// parsed: cvRANSACUpdateNumIters
// as:     cvRANSACUpdateNumIters (function)
// Arg ARG Primitive(double) p= Primitive(double) = 
// Arg ARG Primitive(double) err_prob= Primitive(double) = 
// Arg ARG Primitive(int) model_points= Primitive(int) = 
// Arg ARG Primitive(int) max_iters= Primitive(int) = 
// Return value: Primitive(int)
cv_return_value_int cv_core_cvRANSACUpdateNumIters_double_p_double_err_prob_int_model_points_int_max_iters(double p, double err_prob, int model_points, int max_iters) {
    try {
        int ret = cvRANSACUpdateNumIters(p, err_prob, model_points, max_iters);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cvRNG_int64_seed
// parsed: cvRNG
// as:     cvRNG (function)
// Arg ARG Primitive(int64) seed= Primitive(int64) = -1
// Return value: Primitive(uint64)
cv_return_value_uint64 cv_core_cvRNG_int64_seed(int64 seed) {
    try {
        uint64 ret = cvRNG(seed);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<uint64*>(&ret) };
    } CVRS_CATCH(cv_return_value_uint64)
}

// cvRemoveNodeFromTree_void_X_node_void_X_frame
// parsed: cvRemoveNodeFromTree
// as:     cvRemoveNodeFromTree (function)
// Arg ARG RawPtr[Primitive(void)] * node= (ptr) RawPtr[Primitive(void)] = 
// Arg ARG RawPtr[Primitive(void)] * frame= (ptr) RawPtr[Primitive(void)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cvRemoveNodeFromTree_void_X_node_void_X_frame(void* node, void* frame) {
    try {
        cvRemoveNodeFromTree(node, frame);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cvResizeWindow_const_char_X_name_int_width_int_height
// parsed: cvResizeWindow
// as:     cvResizeWindow (function)
// Arg ARG RawPtr[Primitive(char)] * name= (ptr) RawPtr[Primitive(char)] = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cvResizeWindow_const_char_X_name_int_width_int_height(const char* name, int width, int height) {
    try {
        cvResizeWindow(name, width, height);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cvRound64_softdouble_a
// parsed: cvRound64
// as:     cvRound64 (function)
// Arg ARG cv::softdouble (boxed) a= cv::softdouble (boxed) = 
// Return value: Primitive(int64_t)
cv_return_value_int64_t cv_core_cvRound64_softdouble_a(void* a) {
    try {
        int64_t ret = cvRound64(*reinterpret_cast<cv::softdouble*>(a));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int64_t*>(&ret) };
    } CVRS_CATCH(cv_return_value_int64_t)
}

// cvSaveWindowParameters_const_char_X_name
// parsed: cvSaveWindowParameters
// as:     cvSaveWindowParameters (function)
// Arg ARG RawPtr[Primitive(char)] * name= (ptr) RawPtr[Primitive(char)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cvSaveWindowParameters_const_char_X_name(const char* name) {
    try {
        cvSaveWindowParameters(name);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cvSetErrMode_int_mode
// parsed: cvSetErrMode
// as:     cvSetErrMode (function)
// Arg ARG Primitive(int) mode= Primitive(int) = 
// Return value: Primitive(int)
cv_return_value_int cv_core_cvSetErrMode_int_mode(int mode) {
    try {
        int ret = cvSetErrMode(mode);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cvSetErrStatus_int_status
// parsed: cvSetErrStatus
// as:     cvSetErrStatus (function)
// Arg ARG Primitive(int) status= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cvSetErrStatus_int_status(int status) {
    try {
        cvSetErrStatus(status);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cvSetNumThreads_int_threads
// parsed: cvSetNumThreads
// as:     cvSetNumThreads (function)
// Arg ARG Primitive(int) threads= Primitive(int) = 0
// Return value: Primitive(void)
cv_return_value_void cv_core_cvSetNumThreads_int_threads(int threads) {
    try {
        cvSetNumThreads(threads);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cvSetOpenGlContext_const_char_X_window_name
// parsed: cvSetOpenGlContext
// as:     cvSetOpenGlContext (function)
// Arg ARG RawPtr[Primitive(char)] * window_name= (ptr) RawPtr[Primitive(char)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cvSetOpenGlContext_const_char_X_window_name(const char* window_name) {
    try {
        cvSetOpenGlContext(window_name);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cvSetTrackbarMax_const_char_X_trackbar_name_const_char_X_window_name_int_maxval
// parsed: cvSetTrackbarMax
// as:     cvSetTrackbarMax (function)
// Arg ARG RawPtr[Primitive(char)] * trackbar_name= (ptr) RawPtr[Primitive(char)] = 
// Arg ARG RawPtr[Primitive(char)] * window_name= (ptr) RawPtr[Primitive(char)] = 
// Arg ARG Primitive(int) maxval= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cvSetTrackbarMax_const_char_X_trackbar_name_const_char_X_window_name_int_maxval(const char* trackbar_name, const char* window_name, int maxval) {
    try {
        cvSetTrackbarMax(trackbar_name, window_name, maxval);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cvSetTrackbarMin_const_char_X_trackbar_name_const_char_X_window_name_int_minval
// parsed: cvSetTrackbarMin
// as:     cvSetTrackbarMin (function)
// Arg ARG RawPtr[Primitive(char)] * trackbar_name= (ptr) RawPtr[Primitive(char)] = 
// Arg ARG RawPtr[Primitive(char)] * window_name= (ptr) RawPtr[Primitive(char)] = 
// Arg ARG Primitive(int) minval= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cvSetTrackbarMin_const_char_X_trackbar_name_const_char_X_window_name_int_minval(const char* trackbar_name, const char* window_name, int minval) {
    try {
        cvSetTrackbarMin(trackbar_name, window_name, minval);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cvSetTrackbarPos_const_char_X_trackbar_name_const_char_X_window_name_int_pos
// parsed: cvSetTrackbarPos
// as:     cvSetTrackbarPos (function)
// Arg ARG RawPtr[Primitive(char)] * trackbar_name= (ptr) RawPtr[Primitive(char)] = 
// Arg ARG RawPtr[Primitive(char)] * window_name= (ptr) RawPtr[Primitive(char)] = 
// Arg ARG Primitive(int) pos= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cvSetTrackbarPos_const_char_X_trackbar_name_const_char_X_window_name_int_pos(const char* trackbar_name, const char* window_name, int pos) {
    try {
        cvSetTrackbarPos(trackbar_name, window_name, pos);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cvSetWindowProperty_const_char_X_name_int_prop_id_double_prop_value
// parsed: cvSetWindowProperty
// as:     cvSetWindowProperty (function)
// Arg ARG RawPtr[Primitive(char)] * name= (ptr) RawPtr[Primitive(char)] = 
// Arg ARG Primitive(int) prop_id= Primitive(int) = 
// Arg ARG Primitive(double) prop_value= Primitive(double) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cvSetWindowProperty_const_char_X_name_int_prop_id_double_prop_value(const char* name, int prop_id, double prop_value) {
    try {
        cvSetWindowProperty(name, prop_id, prop_value);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cvStartWindowThread
// parsed: cvStartWindowThread
// as:     cvStartWindowThread (function)
// Return value: Primitive(int)
cv_return_value_int cv_core_cvStartWindowThread() {
    try {
        int ret = cvStartWindowThread();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cvStdErrReport_int_status_const_char_X_func_name_const_char_X_err_msg_const_char_X_file_name_int_line_void_X_userdata
// parsed: cvStdErrReport
// as:     cvStdErrReport (function)
// Arg ARG Primitive(int) status= Primitive(int) = 
// Arg ARG RawPtr[Primitive(char)] * func_name= (ptr) RawPtr[Primitive(char)] = 
// Arg ARG RawPtr[Primitive(char)] * err_msg= (ptr) RawPtr[Primitive(char)] = 
// Arg ARG RawPtr[Primitive(char)] * file_name= (ptr) RawPtr[Primitive(char)] = 
// Arg ARG Primitive(int) line= Primitive(int) = 
// Arg ARG RawPtr[Primitive(void)] * userdata= (ptr) RawPtr[Primitive(void)] = 
// Return value: Primitive(int)
cv_return_value_int cv_core_cvStdErrReport_int_status_const_char_X_func_name_const_char_X_err_msg_const_char_X_file_name_int_line_void_X_userdata(int status, const char* func_name, const char* err_msg, const char* file_name, int line, void* userdata) {
    try {
        int ret = cvStdErrReport(status, func_name, err_msg, file_name, line, userdata);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cvStopLoop
// parsed: cvStopLoop
// as:     cvStopLoop (function)
// Return value: Primitive(void)
cv_return_value_void cv_core_cvStopLoop() {
    try {
        cvStopLoop();
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cvTrunc_softdouble_a
// parsed: cvTrunc
// as:     cvTrunc (function)
// Arg ARG cv::softdouble (boxed) a= cv::softdouble (boxed) = 
// Return value: Primitive(int)
cv_return_value_int cv_core_cvTrunc_softdouble_a(void* a) {
    try {
        int ret = cvTrunc(*reinterpret_cast<cv::softdouble*>(a));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cvTrunc_softfloat_a
// parsed: cvTrunc
// as:     cvTrunc (function)
// Arg ARG cv::softfloat (boxed) a= cv::softfloat (boxed) = 
// Return value: Primitive(int)
cv_return_value_int cv_core_cvTrunc_softfloat_a(void* a) {
    try {
        int ret = cvTrunc(*reinterpret_cast<cv::softfloat*>(a));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cvUnregisterType_const_char_X_type_name
// parsed: cvUnregisterType
// as:     cvUnregisterType (function)
// Arg ARG RawPtr[Primitive(char)] * type_name= (ptr) RawPtr[Primitive(char)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cvUnregisterType_const_char_X_type_name(const char* type_name) {
    try {
        cvUnregisterType(type_name);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cvUpdateWindow_const_char_X_window_name
// parsed: cvUpdateWindow
// as:     cvUpdateWindow (function)
// Arg ARG RawPtr[Primitive(char)] * window_name= (ptr) RawPtr[Primitive(char)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cvUpdateWindow_const_char_X_window_name(const char* window_name) {
    try {
        cvUpdateWindow(window_name);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cvUseOptimized_int_on_off
// parsed: cvUseOptimized
// as:     cvUseOptimized (function)
// Arg ARG Primitive(int) on_off= Primitive(int) = 
// Return value: Primitive(int)
cv_return_value_int cv_core_cvUseOptimized_int_on_off(int on_off) {
    try {
        int ret = cvUseOptimized(on_off);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cvWaitKey_int_delay
// parsed: cvWaitKey
// as:     cvWaitKey (function)
// Arg ARG Primitive(int) delay= Primitive(int) = 0
// Return value: Primitive(int)
cv_return_value_int cv_core_cvWaitKey_int_delay(int delay) {
    try {
        int ret = cvWaitKey(delay);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_AGAST_Mat_image_VectorOfKeyPoint_keypoints_int_threshold_bool_nonmaxSuppression
// parsed: cv::AGAST
// as:     cv::AGAST (function)
// Arg ARG cv::Mat (boxed) image= cv::Mat (boxed) = 
// Arg ARG Vector[cv::KeyPoint (simple)] keypoints= Vector[cv::KeyPoint (simple)] = 
// Arg ARG Primitive(int) threshold= Primitive(int) = 
// Arg ARG Primitive(bool) nonmaxSuppression= Primitive(bool) = true
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_AGAST_Mat_image_VectorOfKeyPoint_keypoints_int_threshold_bool_nonmaxSuppression(void* image, void* keypoints, int threshold, bool nonmaxSuppression) {
    try {
        cv::AGAST(*reinterpret_cast<cv::Mat*>(image), *reinterpret_cast<std::vector<cv::KeyPoint>*>(keypoints), threshold, nonmaxSuppression);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_AGAST_Mat_image_VectorOfKeyPoint_keypoints_int_threshold_bool_nonmaxSuppression_int_type
// parsed: cv::AGAST
// as:     cv::AGAST (function)
// Arg ARG cv::Mat (boxed) image= cv::Mat (boxed) = 
// Arg ARG Vector[cv::KeyPoint (simple)] keypoints= Vector[cv::KeyPoint (simple)] = 
// Arg ARG Primitive(int) threshold= Primitive(int) = 
// Arg ARG Primitive(bool) nonmaxSuppression= Primitive(bool) = 
// Arg ARG Primitive(int) type= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_AGAST_Mat_image_VectorOfKeyPoint_keypoints_int_threshold_bool_nonmaxSuppression_int_type(void* image, void* keypoints, int threshold, bool nonmaxSuppression, int type) {
    try {
        cv::AGAST(*reinterpret_cast<cv::Mat*>(image), *reinterpret_cast<std::vector<cv::KeyPoint>*>(keypoints), threshold, nonmaxSuppression, type);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_CamShift_Mat_probImage_Rect_window_TermCriteria_criteria
// parsed: cv::CamShift
// as:     cv::CamShift (function)
// Arg ARG cv::Mat (boxed) probImage= cv::Mat (boxed) = 
// Arg ARG cv::Rect (simple) window= cv::Rect (simple) = 
// Arg ARG cv::TermCriteria (boxed) criteria= cv::TermCriteria (boxed) = 
// Return value: cv::RotatedRect (boxed)
cv_return_value_void_X cv_core_cv_CamShift_Mat_probImage_Rect_window_TermCriteria_criteria(void* probImage, RectWrapper window, void* criteria) {
    try {
        cv::RotatedRect ret = cv::CamShift(*reinterpret_cast<cv::Mat*>(probImage), *reinterpret_cast<cv::Rect*>(&window), *reinterpret_cast<cv::TermCriteria*>(criteria));
        return { Error::Code::StsOk, NULL, new cv::RotatedRect(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_Canny_Mat_dx_Mat_dy_Mat_edges_double_threshold1_double_threshold2_bool_L2gradient
// parsed: cv::Canny
// as:     cv::Canny (function)
// Arg ARG cv::Mat (boxed) dx= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dy= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) edges= cv::Mat (boxed) = 
// Arg ARG Primitive(double) threshold1= Primitive(double) = 
// Arg ARG Primitive(double) threshold2= Primitive(double) = 
// Arg ARG Primitive(bool) L2gradient= Primitive(bool) = false
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_Canny_Mat_dx_Mat_dy_Mat_edges_double_threshold1_double_threshold2_bool_L2gradient(void* dx, void* dy, void* edges, double threshold1, double threshold2, bool L2gradient) {
    try {
        cv::Canny(*reinterpret_cast<cv::Mat*>(dx), *reinterpret_cast<cv::Mat*>(dy), *reinterpret_cast<cv::Mat*>(edges), threshold1, threshold2, L2gradient);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_Canny_Mat_image_Mat_edges_double_threshold1_double_threshold2_int_apertureSize_bool_L2gradient
// parsed: cv::Canny
// as:     cv::Canny (function)
// Arg ARG cv::Mat (boxed) image= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) edges= cv::Mat (boxed) = 
// Arg ARG Primitive(double) threshold1= Primitive(double) = 
// Arg ARG Primitive(double) threshold2= Primitive(double) = 
// Arg ARG Primitive(int) apertureSize= Primitive(int) = 3
// Arg ARG Primitive(bool) L2gradient= Primitive(bool) = false
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_Canny_Mat_image_Mat_edges_double_threshold1_double_threshold2_int_apertureSize_bool_L2gradient(void* image, void* edges, double threshold1, double threshold2, int apertureSize, bool L2gradient) {
    try {
        cv::Canny(*reinterpret_cast<cv::Mat*>(image), *reinterpret_cast<cv::Mat*>(edges), threshold1, threshold2, apertureSize, L2gradient);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_Cholesky_double_X_A_size_t_astep_int_m_double_X_b_size_t_bstep_int_n
// parsed: cv::Cholesky
// as:     cv::Cholesky (function)
// Arg ARG RawPtr[Primitive(double)] * A= (ptr) RawPtr[Primitive(double)] = 
// Arg ARG Primitive(size_t) astep= Primitive(size_t) = 
// Arg ARG Primitive(int) m= Primitive(int) = 
// Arg ARG RawPtr[Primitive(double)] * b= (ptr) RawPtr[Primitive(double)] = 
// Arg ARG Primitive(size_t) bstep= Primitive(size_t) = 
// Arg ARG Primitive(int) n= Primitive(int) = 
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_Cholesky_double_X_A_size_t_astep_int_m_double_X_b_size_t_bstep_int_n(double* A, std::size_t astep, int m, double* b, std::size_t bstep, int n) {
    try {
        bool ret = cv::Cholesky(A, astep, m, b, bstep, n);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_Cholesky_float_X_A_size_t_astep_int_m_float_X_b_size_t_bstep_int_n
// parsed: cv::Cholesky
// as:     cv::Cholesky (function)
// Arg ARG RawPtr[Primitive(float)] * A= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG Primitive(size_t) astep= Primitive(size_t) = 
// Arg ARG Primitive(int) m= Primitive(int) = 
// Arg ARG RawPtr[Primitive(float)] * b= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG Primitive(size_t) bstep= Primitive(size_t) = 
// Arg ARG Primitive(int) n= Primitive(int) = 
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_Cholesky_float_X_A_size_t_astep_int_m_float_X_b_size_t_bstep_int_n(float* A, std::size_t astep, int m, float* b, std::size_t bstep, int n) {
    try {
        bool ret = cv::Cholesky(A, astep, m, b, bstep, n);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_EMDL1_Mat_signature1_Mat_signature2
// parsed: cv::EMDL1
// as:     cv::EMDL1 (function)
// Arg ARG cv::Mat (boxed) signature1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) signature2= cv::Mat (boxed) = 
// Return value: Primitive(float)
cv_return_value_float cv_core_cv_EMDL1_Mat_signature1_Mat_signature2(void* signature1, void* signature2) {
    try {
        float ret = cv::EMDL1(*reinterpret_cast<cv::Mat*>(signature1), *reinterpret_cast<cv::Mat*>(signature2));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<float*>(&ret) };
    } CVRS_CATCH(cv_return_value_float)
}

// cv_EMD_Mat_signature1_Mat_signature2_int_distType_Mat_cost_float_X_lowerBound_Mat_flow
// parsed: cv::EMD
// as:     cv::EMD (function)
// Arg ARG cv::Mat (boxed) signature1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) signature2= cv::Mat (boxed) = 
// Arg ARG Primitive(int) distType= Primitive(int) = 
// Arg ARG cv::Mat (boxed) cost= cv::Mat (boxed) = noArray()
// Arg ARG RawPtr[Primitive(float)] * lowerBound= (ptr) RawPtr[Primitive(float)] = 0
// Arg ARG cv::Mat (boxed) flow= cv::Mat (boxed) = noArray()
// Return value: Primitive(float)
cv_return_value_float cv_core_cv_EMD_Mat_signature1_Mat_signature2_int_distType_Mat_cost_float_X_lowerBound_Mat_flow(void* signature1, void* signature2, int distType, void* cost, float* lowerBound, void* flow) {
    try {
        float ret = cv::EMD(*reinterpret_cast<cv::Mat*>(signature1), *reinterpret_cast<cv::Mat*>(signature2), distType, *reinterpret_cast<cv::Mat*>(cost), lowerBound, *reinterpret_cast<cv::Mat*>(flow));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<float*>(&ret) };
    } CVRS_CATCH(cv_return_value_float)
}

// cv_FAST_Mat_image_VectorOfKeyPoint_keypoints_int_threshold_bool_nonmaxSuppression
// parsed: cv::FAST
// as:     cv::FAST (function)
// Arg ARG cv::Mat (boxed) image= cv::Mat (boxed) = 
// Arg ARG Vector[cv::KeyPoint (simple)] keypoints= Vector[cv::KeyPoint (simple)] = 
// Arg ARG Primitive(int) threshold= Primitive(int) = 
// Arg ARG Primitive(bool) nonmaxSuppression= Primitive(bool) = true
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_FAST_Mat_image_VectorOfKeyPoint_keypoints_int_threshold_bool_nonmaxSuppression(void* image, void* keypoints, int threshold, bool nonmaxSuppression) {
    try {
        cv::FAST(*reinterpret_cast<cv::Mat*>(image), *reinterpret_cast<std::vector<cv::KeyPoint>*>(keypoints), threshold, nonmaxSuppression);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_FAST_Mat_image_VectorOfKeyPoint_keypoints_int_threshold_bool_nonmaxSuppression_int_type
// parsed: cv::FAST
// as:     cv::FAST (function)
// Arg ARG cv::Mat (boxed) image= cv::Mat (boxed) = 
// Arg ARG Vector[cv::KeyPoint (simple)] keypoints= Vector[cv::KeyPoint (simple)] = 
// Arg ARG Primitive(int) threshold= Primitive(int) = 
// Arg ARG Primitive(bool) nonmaxSuppression= Primitive(bool) = 
// Arg ARG Primitive(int) type= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_FAST_Mat_image_VectorOfKeyPoint_keypoints_int_threshold_bool_nonmaxSuppression_int_type(void* image, void* keypoints, int threshold, bool nonmaxSuppression, int type) {
    try {
        cv::FAST(*reinterpret_cast<cv::Mat*>(image), *reinterpret_cast<std::vector<cv::KeyPoint>*>(keypoints), threshold, nonmaxSuppression, type);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_GaussianBlur_Mat_src_Mat_dst_Size_ksize_double_sigmaX_double_sigmaY_int_borderType
// parsed: cv::GaussianBlur
// as:     cv::GaussianBlur (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG cv::Size (simple) ksize= cv::Size (simple) = 
// Arg ARG Primitive(double) sigmaX= Primitive(double) = 
// Arg ARG Primitive(double) sigmaY= Primitive(double) = 0
// Arg ARG Primitive(int) borderType= Primitive(int) = BORDER_DEFAULT
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_GaussianBlur_Mat_src_Mat_dst_Size_ksize_double_sigmaX_double_sigmaY_int_borderType(void* src, void* dst, SizeWrapper ksize, double sigmaX, double sigmaY, int borderType) {
    try {
        cv::GaussianBlur(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst), *reinterpret_cast<cv::Size*>(&ksize), sigmaX, sigmaY, borderType);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_HoughCircles_Mat_image_Mat_circles_int_method_double_dp_double_minDist_double_param1_double_param2_int_minRadius_int_maxRadius
// parsed: cv::HoughCircles
// as:     cv::HoughCircles (function)
// Arg ARG cv::Mat (boxed) image= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) circles= cv::Mat (boxed) = 
// Arg ARG Primitive(int) method= Primitive(int) = 
// Arg ARG Primitive(double) dp= Primitive(double) = 
// Arg ARG Primitive(double) minDist= Primitive(double) = 
// Arg ARG Primitive(double) param1= Primitive(double) = 100
// Arg ARG Primitive(double) param2= Primitive(double) = 100
// Arg ARG Primitive(int) minRadius= Primitive(int) = 0
// Arg ARG Primitive(int) maxRadius= Primitive(int) = 0
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_HoughCircles_Mat_image_Mat_circles_int_method_double_dp_double_minDist_double_param1_double_param2_int_minRadius_int_maxRadius(void* image, void* circles, int method, double dp, double minDist, double param1, double param2, int minRadius, int maxRadius) {
    try {
        cv::HoughCircles(*reinterpret_cast<cv::Mat*>(image), *reinterpret_cast<cv::Mat*>(circles), method, dp, minDist, param1, param2, minRadius, maxRadius);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_HoughLinesP_Mat_image_Mat_lines_double_rho_double_theta_int_threshold_double_minLineLength_double_maxLineGap
// parsed: cv::HoughLinesP
// as:     cv::HoughLinesP (function)
// Arg ARG cv::Mat (boxed) image= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) lines= cv::Mat (boxed) = 
// Arg ARG Primitive(double) rho= Primitive(double) = 
// Arg ARG Primitive(double) theta= Primitive(double) = 
// Arg ARG Primitive(int) threshold= Primitive(int) = 
// Arg ARG Primitive(double) minLineLength= Primitive(double) = 0
// Arg ARG Primitive(double) maxLineGap= Primitive(double) = 0
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_HoughLinesP_Mat_image_Mat_lines_double_rho_double_theta_int_threshold_double_minLineLength_double_maxLineGap(void* image, void* lines, double rho, double theta, int threshold, double minLineLength, double maxLineGap) {
    try {
        cv::HoughLinesP(*reinterpret_cast<cv::Mat*>(image), *reinterpret_cast<cv::Mat*>(lines), rho, theta, threshold, minLineLength, maxLineGap);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_HoughLinesPointSet_Mat__point_Mat__lines_int_lines_max_int_threshold_double_min_rho_double_max_rho_double_rho_step_double_min_theta_double_max_theta_double_theta_step
// parsed: cv::HoughLinesPointSet
// as:     cv::HoughLinesPointSet (function)
// Arg ARG cv::Mat (boxed) _point= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) _lines= cv::Mat (boxed) = 
// Arg ARG Primitive(int) lines_max= Primitive(int) = 
// Arg ARG Primitive(int) threshold= Primitive(int) = 
// Arg ARG Primitive(double) min_rho= Primitive(double) = 
// Arg ARG Primitive(double) max_rho= Primitive(double) = 
// Arg ARG Primitive(double) rho_step= Primitive(double) = 
// Arg ARG Primitive(double) min_theta= Primitive(double) = 
// Arg ARG Primitive(double) max_theta= Primitive(double) = 
// Arg ARG Primitive(double) theta_step= Primitive(double) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_HoughLinesPointSet_Mat__point_Mat__lines_int_lines_max_int_threshold_double_min_rho_double_max_rho_double_rho_step_double_min_theta_double_max_theta_double_theta_step(void* _point, void* _lines, int lines_max, int threshold, double min_rho, double max_rho, double rho_step, double min_theta, double max_theta, double theta_step) {
    try {
        cv::HoughLinesPointSet(*reinterpret_cast<cv::Mat*>(_point), *reinterpret_cast<cv::Mat*>(_lines), lines_max, threshold, min_rho, max_rho, rho_step, min_theta, max_theta, theta_step);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_HoughLines_Mat_image_Mat_lines_double_rho_double_theta_int_threshold_double_srn_double_stn_double_min_theta_double_max_theta
// parsed: cv::HoughLines
// as:     cv::HoughLines (function)
// Arg ARG cv::Mat (boxed) image= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) lines= cv::Mat (boxed) = 
// Arg ARG Primitive(double) rho= Primitive(double) = 
// Arg ARG Primitive(double) theta= Primitive(double) = 
// Arg ARG Primitive(int) threshold= Primitive(int) = 
// Arg ARG Primitive(double) srn= Primitive(double) = 0
// Arg ARG Primitive(double) stn= Primitive(double) = 0
// Arg ARG Primitive(double) min_theta= Primitive(double) = 0
// Arg ARG Primitive(double) max_theta= Primitive(double) = CV_PI
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_HoughLines_Mat_image_Mat_lines_double_rho_double_theta_int_threshold_double_srn_double_stn_double_min_theta_double_max_theta(void* image, void* lines, double rho, double theta, int threshold, double srn, double stn, double min_theta, double max_theta) {
    try {
        cv::HoughLines(*reinterpret_cast<cv::Mat*>(image), *reinterpret_cast<cv::Mat*>(lines), rho, theta, threshold, srn, stn, min_theta, max_theta);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_HuMoments_Moments_m_Mat_hu
// parsed: cv::HuMoments
// as:     cv::HuMoments (function)
// Arg ARG cv::Moments (simple) m= cv::Moments (simple) = 
// Arg ARG cv::Mat (boxed) hu= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_HuMoments_Moments_m_Mat_hu(cv::Moments m, void* hu) {
    try {
        cv::HuMoments(*reinterpret_cast<cv::Moments*>(&m), *reinterpret_cast<cv::Mat*>(hu));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_LUT_Mat_src_Mat_lut_Mat_dst
// parsed: cv::LUT
// as:     cv::LUT (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) lut= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_LUT_Mat_src_Mat_lut_Mat_dst(void* src, void* lut, void* dst) {
    try {
        cv::LUT(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(lut), *reinterpret_cast<cv::Mat*>(dst));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_LU_double_X_A_size_t_astep_int_m_double_X_b_size_t_bstep_int_n
// parsed: cv::LU
// as:     cv::LU (function)
// Arg ARG RawPtr[Primitive(double)] * A= (ptr) RawPtr[Primitive(double)] = 
// Arg ARG Primitive(size_t) astep= Primitive(size_t) = 
// Arg ARG Primitive(int) m= Primitive(int) = 
// Arg ARG RawPtr[Primitive(double)] * b= (ptr) RawPtr[Primitive(double)] = 
// Arg ARG Primitive(size_t) bstep= Primitive(size_t) = 
// Arg ARG Primitive(int) n= Primitive(int) = 
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_LU_double_X_A_size_t_astep_int_m_double_X_b_size_t_bstep_int_n(double* A, std::size_t astep, int m, double* b, std::size_t bstep, int n) {
    try {
        int ret = cv::LU(A, astep, m, b, bstep, n);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_LU_float_X_A_size_t_astep_int_m_float_X_b_size_t_bstep_int_n
// parsed: cv::LU
// as:     cv::LU (function)
// Arg ARG RawPtr[Primitive(float)] * A= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG Primitive(size_t) astep= Primitive(size_t) = 
// Arg ARG Primitive(int) m= Primitive(int) = 
// Arg ARG RawPtr[Primitive(float)] * b= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG Primitive(size_t) bstep= Primitive(size_t) = 
// Arg ARG Primitive(int) n= Primitive(int) = 
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_LU_float_X_A_size_t_astep_int_m_float_X_b_size_t_bstep_int_n(float* A, std::size_t astep, int m, float* b, std::size_t bstep, int n) {
    try {
        int ret = cv::LU(A, astep, m, b, bstep, n);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_Laplacian_Mat_src_Mat_dst_int_ddepth_int_ksize_double_scale_double_delta_int_borderType
// parsed: cv::Laplacian
// as:     cv::Laplacian (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG Primitive(int) ddepth= Primitive(int) = 
// Arg ARG Primitive(int) ksize= Primitive(int) = 1
// Arg ARG Primitive(double) scale= Primitive(double) = 1
// Arg ARG Primitive(double) delta= Primitive(double) = 0
// Arg ARG Primitive(int) borderType= Primitive(int) = BORDER_DEFAULT
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_Laplacian_Mat_src_Mat_dst_int_ddepth_int_ksize_double_scale_double_delta_int_borderType(void* src, void* dst, int ddepth, int ksize, double scale, double delta, int borderType) {
    try {
        cv::Laplacian(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst), ddepth, ksize, scale, delta, borderType);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_Mahalanobis_Mat_v1_Mat_v2_Mat_icovar
// parsed: cv::Mahalanobis
// as:     cv::Mahalanobis (function)
// Arg ARG cv::Mat (boxed) v1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) v2= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) icovar= cv::Mat (boxed) = 
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_Mahalanobis_Mat_v1_Mat_v2_Mat_icovar(void* v1, void* v2, void* icovar) {
    try {
        double ret = cv::Mahalanobis(*reinterpret_cast<cv::Mat*>(v1), *reinterpret_cast<cv::Mat*>(v2), *reinterpret_cast<cv::Mat*>(icovar));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_PCABackProject_Mat_data_Mat_mean_Mat_eigenvectors_Mat_result
// parsed: cv::PCABackProject
// as:     cv::PCABackProject (function)
// Arg ARG cv::Mat (boxed) data= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) mean= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) eigenvectors= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) result= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_PCABackProject_Mat_data_Mat_mean_Mat_eigenvectors_Mat_result(void* data, void* mean, void* eigenvectors, void* result) {
    try {
        cv::PCABackProject(*reinterpret_cast<cv::Mat*>(data), *reinterpret_cast<cv::Mat*>(mean), *reinterpret_cast<cv::Mat*>(eigenvectors), *reinterpret_cast<cv::Mat*>(result));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_PCACompute_Mat_data_Mat_mean_Mat_eigenvectors_Mat_eigenvalues_double_retainedVariance
// parsed: cv::PCACompute
// as:     cv::PCACompute (function)
// Arg ARG cv::Mat (boxed) data= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) mean= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) eigenvectors= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) eigenvalues= cv::Mat (boxed) = 
// Arg ARG Primitive(double) retainedVariance= Primitive(double) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_PCACompute_Mat_data_Mat_mean_Mat_eigenvectors_Mat_eigenvalues_double_retainedVariance(void* data, void* mean, void* eigenvectors, void* eigenvalues, double retainedVariance) {
    try {
        cv::PCACompute(*reinterpret_cast<cv::Mat*>(data), *reinterpret_cast<cv::Mat*>(mean), *reinterpret_cast<cv::Mat*>(eigenvectors), *reinterpret_cast<cv::Mat*>(eigenvalues), retainedVariance);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_PCACompute_Mat_data_Mat_mean_Mat_eigenvectors_Mat_eigenvalues_int_maxComponents
// parsed: cv::PCACompute
// as:     cv::PCACompute (function)
// Arg ARG cv::Mat (boxed) data= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) mean= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) eigenvectors= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) eigenvalues= cv::Mat (boxed) = 
// Arg ARG Primitive(int) maxComponents= Primitive(int) = 0
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_PCACompute_Mat_data_Mat_mean_Mat_eigenvectors_Mat_eigenvalues_int_maxComponents(void* data, void* mean, void* eigenvectors, void* eigenvalues, int maxComponents) {
    try {
        cv::PCACompute(*reinterpret_cast<cv::Mat*>(data), *reinterpret_cast<cv::Mat*>(mean), *reinterpret_cast<cv::Mat*>(eigenvectors), *reinterpret_cast<cv::Mat*>(eigenvalues), maxComponents);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_PCACompute_Mat_data_Mat_mean_Mat_eigenvectors_double_retainedVariance
// parsed: cv::PCACompute
// as:     cv::PCACompute (function)
// Arg ARG cv::Mat (boxed) data= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) mean= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) eigenvectors= cv::Mat (boxed) = 
// Arg ARG Primitive(double) retainedVariance= Primitive(double) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_PCACompute_Mat_data_Mat_mean_Mat_eigenvectors_double_retainedVariance(void* data, void* mean, void* eigenvectors, double retainedVariance) {
    try {
        cv::PCACompute(*reinterpret_cast<cv::Mat*>(data), *reinterpret_cast<cv::Mat*>(mean), *reinterpret_cast<cv::Mat*>(eigenvectors), retainedVariance);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_PCACompute_Mat_data_Mat_mean_Mat_eigenvectors_int_maxComponents
// parsed: cv::PCACompute
// as:     cv::PCACompute (function)
// Arg ARG cv::Mat (boxed) data= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) mean= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) eigenvectors= cv::Mat (boxed) = 
// Arg ARG Primitive(int) maxComponents= Primitive(int) = 0
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_PCACompute_Mat_data_Mat_mean_Mat_eigenvectors_int_maxComponents(void* data, void* mean, void* eigenvectors, int maxComponents) {
    try {
        cv::PCACompute(*reinterpret_cast<cv::Mat*>(data), *reinterpret_cast<cv::Mat*>(mean), *reinterpret_cast<cv::Mat*>(eigenvectors), maxComponents);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_PCAProject_Mat_data_Mat_mean_Mat_eigenvectors_Mat_result
// parsed: cv::PCAProject
// as:     cv::PCAProject (function)
// Arg ARG cv::Mat (boxed) data= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) mean= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) eigenvectors= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) result= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_PCAProject_Mat_data_Mat_mean_Mat_eigenvectors_Mat_result(void* data, void* mean, void* eigenvectors, void* result) {
    try {
        cv::PCAProject(*reinterpret_cast<cv::Mat*>(data), *reinterpret_cast<cv::Mat*>(mean), *reinterpret_cast<cv::Mat*>(eigenvectors), *reinterpret_cast<cv::Mat*>(result));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_PSNR_Mat_src1_Mat_src2
// parsed: cv::PSNR
// as:     cv::PSNR (function)
// Arg ARG cv::Mat (boxed) src1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) src2= cv::Mat (boxed) = 
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_PSNR_Mat_src1_Mat_src2(void* src1, void* src2) {
    try {
        double ret = cv::PSNR(*reinterpret_cast<cv::Mat*>(src1), *reinterpret_cast<cv::Mat*>(src2));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_RQDecomp3x3_Mat_src_Mat_mtxR_Mat_mtxQ_Mat_Qx_Mat_Qy_Mat_Qz
// parsed: cv::RQDecomp3x3
// as:     cv::RQDecomp3x3 (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) mtxR= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) mtxQ= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) Qx= cv::Mat (boxed) = noArray()
// Arg ARG cv::Mat (boxed) Qy= cv::Mat (boxed) = noArray()
// Arg ARG cv::Mat (boxed) Qz= cv::Mat (boxed) = noArray()
// Return value: cv::Vec3d (simple)
cv_return_value_Vec3dWrapper cv_core_cv_RQDecomp3x3_Mat_src_Mat_mtxR_Mat_mtxQ_Mat_Qx_Mat_Qy_Mat_Qz(void* src, void* mtxR, void* mtxQ, void* Qx, void* Qy, void* Qz) {
    try {
        cv::Vec3d ret = cv::RQDecomp3x3(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(mtxR), *reinterpret_cast<cv::Mat*>(mtxQ), *reinterpret_cast<cv::Mat*>(Qx), *reinterpret_cast<cv::Mat*>(Qy), *reinterpret_cast<cv::Mat*>(Qz));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<Vec3dWrapper*>(&ret) };
    } CVRS_CATCH(cv_return_value_Vec3dWrapper)
}

// cv_Rodrigues_Mat_src_Mat_dst_Mat_jacobian
// parsed: cv::Rodrigues
// as:     cv::Rodrigues (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) jacobian= cv::Mat (boxed) = noArray()
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_Rodrigues_Mat_src_Mat_dst_Mat_jacobian(void* src, void* dst, void* jacobian) {
    try {
        cv::Rodrigues(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst), *reinterpret_cast<cv::Mat*>(jacobian));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_SVBackSubst_Mat_w_Mat_u_Mat_vt_Mat_rhs_Mat_dst
// parsed: cv::SVBackSubst
// as:     cv::SVBackSubst (function)
// Arg ARG cv::Mat (boxed) w= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) u= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) vt= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) rhs= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_SVBackSubst_Mat_w_Mat_u_Mat_vt_Mat_rhs_Mat_dst(void* w, void* u, void* vt, void* rhs, void* dst) {
    try {
        cv::SVBackSubst(*reinterpret_cast<cv::Mat*>(w), *reinterpret_cast<cv::Mat*>(u), *reinterpret_cast<cv::Mat*>(vt), *reinterpret_cast<cv::Mat*>(rhs), *reinterpret_cast<cv::Mat*>(dst));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_SVDecomp_Mat_src_Mat_w_Mat_u_Mat_vt_int_flags
// parsed: cv::SVDecomp
// as:     cv::SVDecomp (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) w= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) u= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) vt= cv::Mat (boxed) = 
// Arg ARG Primitive(int) flags= Primitive(int) = 0
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_SVDecomp_Mat_src_Mat_w_Mat_u_Mat_vt_int_flags(void* src, void* w, void* u, void* vt, int flags) {
    try {
        cv::SVDecomp(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(w), *reinterpret_cast<cv::Mat*>(u), *reinterpret_cast<cv::Mat*>(vt), flags);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_Scharr_Mat_src_Mat_dst_int_ddepth_int_dx_int_dy_double_scale_double_delta_int_borderType
// parsed: cv::Scharr
// as:     cv::Scharr (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG Primitive(int) ddepth= Primitive(int) = 
// Arg ARG Primitive(int) dx= Primitive(int) = 
// Arg ARG Primitive(int) dy= Primitive(int) = 
// Arg ARG Primitive(double) scale= Primitive(double) = 1
// Arg ARG Primitive(double) delta= Primitive(double) = 0
// Arg ARG Primitive(int) borderType= Primitive(int) = BORDER_DEFAULT
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_Scharr_Mat_src_Mat_dst_int_ddepth_int_dx_int_dy_double_scale_double_delta_int_borderType(void* src, void* dst, int ddepth, int dx, int dy, double scale, double delta, int borderType) {
    try {
        cv::Scharr(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst), ddepth, dx, dy, scale, delta, borderType);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_Sobel_Mat_src_Mat_dst_int_ddepth_int_dx_int_dy_int_ksize_double_scale_double_delta_int_borderType
// parsed: cv::Sobel
// as:     cv::Sobel (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG Primitive(int) ddepth= Primitive(int) = 
// Arg ARG Primitive(int) dx= Primitive(int) = 
// Arg ARG Primitive(int) dy= Primitive(int) = 
// Arg ARG Primitive(int) ksize= Primitive(int) = 3
// Arg ARG Primitive(double) scale= Primitive(double) = 1
// Arg ARG Primitive(double) delta= Primitive(double) = 0
// Arg ARG Primitive(int) borderType= Primitive(int) = BORDER_DEFAULT
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_Sobel_Mat_src_Mat_dst_int_ddepth_int_dx_int_dy_int_ksize_double_scale_double_delta_int_borderType(void* src, void* dst, int ddepth, int dx, int dy, int ksize, double scale, double delta, int borderType) {
    try {
        cv::Sobel(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst), ddepth, dx, dy, ksize, scale, delta, borderType);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_abs_softdouble_a
// parsed: cv::abs
// as:     cv::abs (function)
// Arg ARG cv::softdouble (boxed) a= cv::softdouble (boxed) = 
// Return value: cv::softdouble (boxed)
cv_return_value_void_X cv_core_cv_abs_softdouble_a(void* a) {
    try {
        cv::softdouble ret = cv::abs(*reinterpret_cast<cv::softdouble*>(a));
        return { Error::Code::StsOk, NULL, new cv::softdouble(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_abs_softfloat_a
// parsed: cv::abs
// as:     cv::abs (function)
// Arg ARG cv::softfloat (boxed) a= cv::softfloat (boxed) = 
// Return value: cv::softfloat (boxed)
cv_return_value_void_X cv_core_cv_abs_softfloat_a(void* a) {
    try {
        cv::softfloat ret = cv::abs(*reinterpret_cast<cv::softfloat*>(a));
        return { Error::Code::StsOk, NULL, new cv::softfloat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_absdiff_Mat_src1_Mat_src2_Mat_dst
// parsed: cv::absdiff
// as:     cv::absdiff (function)
// Arg ARG cv::Mat (boxed) src1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) src2= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_absdiff_Mat_src1_Mat_src2_Mat_dst(void* src1, void* src2, void* dst) {
    try {
        cv::absdiff(*reinterpret_cast<cv::Mat*>(src1), *reinterpret_cast<cv::Mat*>(src2), *reinterpret_cast<cv::Mat*>(dst));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_accumulateProduct_Mat_src1_Mat_src2_Mat_dst_Mat_mask
// parsed: cv::accumulateProduct
// as:     cv::accumulateProduct (function)
// Arg ARG cv::Mat (boxed) src1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) src2= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) mask= cv::Mat (boxed) = noArray()
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_accumulateProduct_Mat_src1_Mat_src2_Mat_dst_Mat_mask(void* src1, void* src2, void* dst, void* mask) {
    try {
        cv::accumulateProduct(*reinterpret_cast<cv::Mat*>(src1), *reinterpret_cast<cv::Mat*>(src2), *reinterpret_cast<cv::Mat*>(dst), *reinterpret_cast<cv::Mat*>(mask));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_accumulateSquare_Mat_src_Mat_dst_Mat_mask
// parsed: cv::accumulateSquare
// as:     cv::accumulateSquare (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) mask= cv::Mat (boxed) = noArray()
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_accumulateSquare_Mat_src_Mat_dst_Mat_mask(void* src, void* dst, void* mask) {
    try {
        cv::accumulateSquare(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst), *reinterpret_cast<cv::Mat*>(mask));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_accumulateWeighted_Mat_src_Mat_dst_double_alpha_Mat_mask
// parsed: cv::accumulateWeighted
// as:     cv::accumulateWeighted (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG Primitive(double) alpha= Primitive(double) = 
// Arg ARG cv::Mat (boxed) mask= cv::Mat (boxed) = noArray()
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_accumulateWeighted_Mat_src_Mat_dst_double_alpha_Mat_mask(void* src, void* dst, double alpha, void* mask) {
    try {
        cv::accumulateWeighted(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst), alpha, *reinterpret_cast<cv::Mat*>(mask));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_accumulate_Mat_src_Mat_dst_Mat_mask
// parsed: cv::accumulate
// as:     cv::accumulate (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) mask= cv::Mat (boxed) = noArray()
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_accumulate_Mat_src_Mat_dst_Mat_mask(void* src, void* dst, void* mask) {
    try {
        cv::accumulate(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst), *reinterpret_cast<cv::Mat*>(mask));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_adaptiveThreshold_Mat_src_Mat_dst_double_maxValue_int_adaptiveMethod_int_thresholdType_int_blockSize_double_C
// parsed: cv::adaptiveThreshold
// as:     cv::adaptiveThreshold (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG Primitive(double) maxValue= Primitive(double) = 
// Arg ARG Primitive(int) adaptiveMethod= Primitive(int) = 
// Arg ARG Primitive(int) thresholdType= Primitive(int) = 
// Arg ARG Primitive(int) blockSize= Primitive(int) = 
// Arg ARG Primitive(double) C= Primitive(double) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_adaptiveThreshold_Mat_src_Mat_dst_double_maxValue_int_adaptiveMethod_int_thresholdType_int_blockSize_double_C(void* src, void* dst, double maxValue, int adaptiveMethod, int thresholdType, int blockSize, double C) {
    try {
        cv::adaptiveThreshold(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst), maxValue, adaptiveMethod, thresholdType, blockSize, C);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_addText_Mat_img_String_text_Point_org_QtFont_font
// parsed: cv::addText
// as:     cv::addText (function)
// Arg ARG cv::Mat (boxed) img= cv::Mat (boxed) = 
// Arg ARG string text= string = 
// Arg ARG cv::Point (simple) org= cv::Point (simple) = 
// Arg ARG cv::QtFont (boxed) font= cv::QtFont (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_addText_Mat_img_String_text_Point_org_QtFont_font(void* img, const char* text, PointWrapper org, void* font) {
    try {
        cv::addText(*reinterpret_cast<cv::Mat*>(img), String(text), *reinterpret_cast<cv::Point*>(&org), *reinterpret_cast<cv::QtFont*>(font));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_addText_Mat_img_String_text_Point_org_String_nameFont_int_pointSize_Scalar_color_int_weight_int_style_int_spacing
// parsed: cv::addText
// as:     cv::addText (function)
// Arg ARG cv::Mat (boxed) img= cv::Mat (boxed) = 
// Arg ARG string text= string = 
// Arg ARG cv::Point (simple) org= cv::Point (simple) = 
// Arg ARG string nameFont= string = 
// Arg ARG Primitive(int) pointSize= Primitive(int) = -1
// Arg ARG cv::Scalar (simple) color= cv::Scalar (simple) = Scalar::all(0)
// Arg ARG Primitive(int) weight= Primitive(int) = QT_FONT_NORMAL
// Arg ARG Primitive(int) style= Primitive(int) = QT_STYLE_NORMAL
// Arg ARG Primitive(int) spacing= Primitive(int) = 0
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_addText_Mat_img_String_text_Point_org_String_nameFont_int_pointSize_Scalar_color_int_weight_int_style_int_spacing(void* img, const char* text, PointWrapper org, const char* nameFont, int pointSize, ScalarWrapper color, int weight, int style, int spacing) {
    try {
        cv::addText(*reinterpret_cast<cv::Mat*>(img), String(text), *reinterpret_cast<cv::Point*>(&org), String(nameFont), pointSize, *reinterpret_cast<cv::Scalar*>(&color), weight, style, spacing);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_addWeighted_Mat_src1_double_alpha_Mat_src2_double_beta_double_gamma_Mat_dst_int_dtype
// parsed: cv::addWeighted
// as:     cv::addWeighted (function)
// Arg ARG cv::Mat (boxed) src1= cv::Mat (boxed) = 
// Arg ARG Primitive(double) alpha= Primitive(double) = 
// Arg ARG cv::Mat (boxed) src2= cv::Mat (boxed) = 
// Arg ARG Primitive(double) beta= Primitive(double) = 
// Arg ARG Primitive(double) gamma= Primitive(double) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG Primitive(int) dtype= Primitive(int) = -1
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_addWeighted_Mat_src1_double_alpha_Mat_src2_double_beta_double_gamma_Mat_dst_int_dtype(void* src1, double alpha, void* src2, double beta, double gamma, void* dst, int dtype) {
    try {
        cv::addWeighted(*reinterpret_cast<cv::Mat*>(src1), alpha, *reinterpret_cast<cv::Mat*>(src2), beta, gamma, *reinterpret_cast<cv::Mat*>(dst), dtype);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_add_Mat_src1_Mat_src2_Mat_dst_Mat_mask_int_dtype
// parsed: cv::add
// as:     cv::add (function)
// Arg ARG cv::Mat (boxed) src1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) src2= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) mask= cv::Mat (boxed) = noArray()
// Arg ARG Primitive(int) dtype= Primitive(int) = -1
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_add_Mat_src1_Mat_src2_Mat_dst_Mat_mask_int_dtype(void* src1, void* src2, void* dst, void* mask, int dtype) {
    try {
        cv::add(*reinterpret_cast<cv::Mat*>(src1), *reinterpret_cast<cv::Mat*>(src2), *reinterpret_cast<cv::Mat*>(dst), *reinterpret_cast<cv::Mat*>(mask), dtype);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_alignSize_size_t_sz_int_n
// parsed: cv::alignSize
// as:     cv::alignSize (function)
// Arg ARG Primitive(size_t) sz= Primitive(size_t) = 
// Arg ARG Primitive(int) n= Primitive(int) = 
// Return value: Primitive(size_t)
cv_return_value_std_size_t cv_core_cv_alignSize_size_t_sz_int_n(std::size_t sz, int n) {
    try {
        size_t ret = cv::alignSize(sz, n);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<std::size_t*>(&ret) };
    } CVRS_CATCH(cv_return_value_std_size_t)
}

// cv_applyColorMap_Mat_src_Mat_dst_Mat_userColor
// parsed: cv::applyColorMap
// as:     cv::applyColorMap (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) userColor= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_applyColorMap_Mat_src_Mat_dst_Mat_userColor(void* src, void* dst, void* userColor) {
    try {
        cv::applyColorMap(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst), *reinterpret_cast<cv::Mat*>(userColor));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_applyColorMap_Mat_src_Mat_dst_int_colormap
// parsed: cv::applyColorMap
// as:     cv::applyColorMap (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG Primitive(int) colormap= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_applyColorMap_Mat_src_Mat_dst_int_colormap(void* src, void* dst, int colormap) {
    try {
        cv::applyColorMap(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst), colormap);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_approxPolyDP_Mat_curve_Mat_approxCurve_double_epsilon_bool_closed
// parsed: cv::approxPolyDP
// as:     cv::approxPolyDP (function)
// Arg ARG cv::Mat (boxed) curve= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) approxCurve= cv::Mat (boxed) = 
// Arg ARG Primitive(double) epsilon= Primitive(double) = 
// Arg ARG Primitive(bool) closed= Primitive(bool) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_approxPolyDP_Mat_curve_Mat_approxCurve_double_epsilon_bool_closed(void* curve, void* approxCurve, double epsilon, bool closed) {
    try {
        cv::approxPolyDP(*reinterpret_cast<cv::Mat*>(curve), *reinterpret_cast<cv::Mat*>(approxCurve), epsilon, closed);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_arcLength_Mat_curve_bool_closed
// parsed: cv::arcLength
// as:     cv::arcLength (function)
// Arg ARG cv::Mat (boxed) curve= cv::Mat (boxed) = 
// Arg ARG Primitive(bool) closed= Primitive(bool) = 
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_arcLength_Mat_curve_bool_closed(void* curve, bool closed) {
    try {
        double ret = cv::arcLength(*reinterpret_cast<cv::Mat*>(curve), closed);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_arrowedLine_Mat_img_Point_pt1_Point_pt2_Scalar_color_int_thickness_int_line_type_int_shift_double_tipLength
// parsed: cv::arrowedLine
// as:     cv::arrowedLine (function)
// Arg ARG cv::Mat (boxed) img= cv::Mat (boxed) = 
// Arg ARG cv::Point (simple) pt1= cv::Point (simple) = 
// Arg ARG cv::Point (simple) pt2= cv::Point (simple) = 
// Arg ARG cv::Scalar (simple) color= cv::Scalar (simple) = 
// Arg ARG Primitive(int) thickness= Primitive(int) = 1
// Arg ARG Primitive(int) line_type= Primitive(int) = 8
// Arg ARG Primitive(int) shift= Primitive(int) = 0
// Arg ARG Primitive(double) tipLength= Primitive(double) = 0.1
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_arrowedLine_Mat_img_Point_pt1_Point_pt2_Scalar_color_int_thickness_int_line_type_int_shift_double_tipLength(void* img, PointWrapper pt1, PointWrapper pt2, ScalarWrapper color, int thickness, int line_type, int shift, double tipLength) {
    try {
        cv::arrowedLine(*reinterpret_cast<cv::Mat*>(img), *reinterpret_cast<cv::Point*>(&pt1), *reinterpret_cast<cv::Point*>(&pt2), *reinterpret_cast<cv::Scalar*>(&color), thickness, line_type, shift, tipLength);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_batchDistance_Mat_src1_Mat_src2_Mat_dist_int_dtype_Mat_nidx_int_normType_int_K_Mat_mask_int_update_bool_crosscheck
// parsed: cv::batchDistance
// as:     cv::batchDistance (function)
// Arg ARG cv::Mat (boxed) src1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) src2= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dist= cv::Mat (boxed) = 
// Arg ARG Primitive(int) dtype= Primitive(int) = 
// Arg ARG cv::Mat (boxed) nidx= cv::Mat (boxed) = 
// Arg ARG Primitive(int) normType= Primitive(int) = NORM_L2
// Arg ARG Primitive(int) K= Primitive(int) = 0
// Arg ARG cv::Mat (boxed) mask= cv::Mat (boxed) = noArray()
// Arg ARG Primitive(int) update= Primitive(int) = 0
// Arg ARG Primitive(bool) crosscheck= Primitive(bool) = false
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_batchDistance_Mat_src1_Mat_src2_Mat_dist_int_dtype_Mat_nidx_int_normType_int_K_Mat_mask_int_update_bool_crosscheck(void* src1, void* src2, void* dist, int dtype, void* nidx, int normType, int K, void* mask, int update, bool crosscheck) {
    try {
        cv::batchDistance(*reinterpret_cast<cv::Mat*>(src1), *reinterpret_cast<cv::Mat*>(src2), *reinterpret_cast<cv::Mat*>(dist), dtype, *reinterpret_cast<cv::Mat*>(nidx), normType, K, *reinterpret_cast<cv::Mat*>(mask), update, crosscheck);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_bilateralFilter_Mat_src_Mat_dst_int_d_double_sigmaColor_double_sigmaSpace_int_borderType
// parsed: cv::bilateralFilter
// as:     cv::bilateralFilter (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG Primitive(int) d= Primitive(int) = 
// Arg ARG Primitive(double) sigmaColor= Primitive(double) = 
// Arg ARG Primitive(double) sigmaSpace= Primitive(double) = 
// Arg ARG Primitive(int) borderType= Primitive(int) = BORDER_DEFAULT
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_bilateralFilter_Mat_src_Mat_dst_int_d_double_sigmaColor_double_sigmaSpace_int_borderType(void* src, void* dst, int d, double sigmaColor, double sigmaSpace, int borderType) {
    try {
        cv::bilateralFilter(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst), d, sigmaColor, sigmaSpace, borderType);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_bitwise_and_Mat_src1_Mat_src2_Mat_dst_Mat_mask
// parsed: cv::bitwise_and
// as:     cv::bitwise_and (function)
// Arg ARG cv::Mat (boxed) src1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) src2= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) mask= cv::Mat (boxed) = noArray()
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_bitwise_and_Mat_src1_Mat_src2_Mat_dst_Mat_mask(void* src1, void* src2, void* dst, void* mask) {
    try {
        cv::bitwise_and(*reinterpret_cast<cv::Mat*>(src1), *reinterpret_cast<cv::Mat*>(src2), *reinterpret_cast<cv::Mat*>(dst), *reinterpret_cast<cv::Mat*>(mask));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_bitwise_not_Mat_src_Mat_dst_Mat_mask
// parsed: cv::bitwise_not
// as:     cv::bitwise_not (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) mask= cv::Mat (boxed) = noArray()
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_bitwise_not_Mat_src_Mat_dst_Mat_mask(void* src, void* dst, void* mask) {
    try {
        cv::bitwise_not(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst), *reinterpret_cast<cv::Mat*>(mask));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_bitwise_or_Mat_src1_Mat_src2_Mat_dst_Mat_mask
// parsed: cv::bitwise_or
// as:     cv::bitwise_or (function)
// Arg ARG cv::Mat (boxed) src1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) src2= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) mask= cv::Mat (boxed) = noArray()
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_bitwise_or_Mat_src1_Mat_src2_Mat_dst_Mat_mask(void* src1, void* src2, void* dst, void* mask) {
    try {
        cv::bitwise_or(*reinterpret_cast<cv::Mat*>(src1), *reinterpret_cast<cv::Mat*>(src2), *reinterpret_cast<cv::Mat*>(dst), *reinterpret_cast<cv::Mat*>(mask));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_bitwise_xor_Mat_src1_Mat_src2_Mat_dst_Mat_mask
// parsed: cv::bitwise_xor
// as:     cv::bitwise_xor (function)
// Arg ARG cv::Mat (boxed) src1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) src2= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) mask= cv::Mat (boxed) = noArray()
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_bitwise_xor_Mat_src1_Mat_src2_Mat_dst_Mat_mask(void* src1, void* src2, void* dst, void* mask) {
    try {
        cv::bitwise_xor(*reinterpret_cast<cv::Mat*>(src1), *reinterpret_cast<cv::Mat*>(src2), *reinterpret_cast<cv::Mat*>(dst), *reinterpret_cast<cv::Mat*>(mask));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_blendLinear_Mat_src1_Mat_src2_Mat_weights1_Mat_weights2_Mat_dst
// parsed: cv::blendLinear
// as:     cv::blendLinear (function)
// Arg ARG cv::Mat (boxed) src1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) src2= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) weights1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) weights2= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_blendLinear_Mat_src1_Mat_src2_Mat_weights1_Mat_weights2_Mat_dst(void* src1, void* src2, void* weights1, void* weights2, void* dst) {
    try {
        cv::blendLinear(*reinterpret_cast<cv::Mat*>(src1), *reinterpret_cast<cv::Mat*>(src2), *reinterpret_cast<cv::Mat*>(weights1), *reinterpret_cast<cv::Mat*>(weights2), *reinterpret_cast<cv::Mat*>(dst));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_blur_Mat_src_Mat_dst_Size_ksize_Point_anchor_int_borderType
// parsed: cv::blur
// as:     cv::blur (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG cv::Size (simple) ksize= cv::Size (simple) = 
// Arg ARG cv::Point (simple) anchor= cv::Point (simple) = Point(-1,-1)
// Arg ARG Primitive(int) borderType= Primitive(int) = BORDER_DEFAULT
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_blur_Mat_src_Mat_dst_Size_ksize_Point_anchor_int_borderType(void* src, void* dst, SizeWrapper ksize, PointWrapper anchor, int borderType) {
    try {
        cv::blur(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst), *reinterpret_cast<cv::Size*>(&ksize), *reinterpret_cast<cv::Point*>(&anchor), borderType);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_borderInterpolate_int_p_int_len_int_borderType
// parsed: cv::borderInterpolate
// as:     cv::borderInterpolate (function)
// Arg ARG Primitive(int) p= Primitive(int) = 
// Arg ARG Primitive(int) len= Primitive(int) = 
// Arg ARG Primitive(int) borderType= Primitive(int) = 
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_borderInterpolate_int_p_int_len_int_borderType(int p, int len, int borderType) {
    try {
        int ret = cv::borderInterpolate(p, len, borderType);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_boundingRect_Mat_array
// parsed: cv::boundingRect
// as:     cv::boundingRect (function)
// Arg ARG cv::Mat (boxed) array= cv::Mat (boxed) = 
// Return value: cv::Rect (simple)
cv_return_value_RectWrapper cv_core_cv_boundingRect_Mat_array(void* array) {
    try {
        cv::Rect ret = cv::boundingRect(*reinterpret_cast<cv::Mat*>(array));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<RectWrapper*>(&ret) };
    } CVRS_CATCH(cv_return_value_RectWrapper)
}

// cv_boxFilter_Mat_src_Mat_dst_int_ddepth_Size_ksize_Point_anchor_bool_normalize_int_borderType
// parsed: cv::boxFilter
// as:     cv::boxFilter (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG Primitive(int) ddepth= Primitive(int) = 
// Arg ARG cv::Size (simple) ksize= cv::Size (simple) = 
// Arg ARG cv::Point (simple) anchor= cv::Point (simple) = Point(-1,-1)
// Arg ARG Primitive(bool) normalize= Primitive(bool) = true
// Arg ARG Primitive(int) borderType= Primitive(int) = BORDER_DEFAULT
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_boxFilter_Mat_src_Mat_dst_int_ddepth_Size_ksize_Point_anchor_bool_normalize_int_borderType(void* src, void* dst, int ddepth, SizeWrapper ksize, PointWrapper anchor, bool normalize, int borderType) {
    try {
        cv::boxFilter(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst), ddepth, *reinterpret_cast<cv::Size*>(&ksize), *reinterpret_cast<cv::Point*>(&anchor), normalize, borderType);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_boxPoints_RotatedRect_box_Mat_points
// parsed: cv::boxPoints
// as:     cv::boxPoints (function)
// Arg ARG cv::RotatedRect (boxed) box= cv::RotatedRect (boxed) = 
// Arg ARG cv::Mat (boxed) points= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_boxPoints_RotatedRect_box_Mat_points(void* box, void* points) {
    try {
        cv::boxPoints(*reinterpret_cast<cv::RotatedRect*>(box), *reinterpret_cast<cv::Mat*>(points));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_buildOpticalFlowPyramid_Mat_img_VectorOfMat_pyramid_Size_winSize_int_maxLevel_bool_withDerivatives_int_pyrBorder_int_derivBorder_bool_tryReuseInputImage
// parsed: cv::buildOpticalFlowPyramid
// as:     cv::buildOpticalFlowPyramid (function)
// Arg ARG cv::Mat (boxed) img= cv::Mat (boxed) = 
// Arg ARG Vector[cv::Mat (boxed)] pyramid= Vector[cv::Mat (boxed)] = 
// Arg ARG cv::Size (simple) winSize= cv::Size (simple) = 
// Arg ARG Primitive(int) maxLevel= Primitive(int) = 
// Arg ARG Primitive(bool) withDerivatives= Primitive(bool) = true
// Arg ARG Primitive(int) pyrBorder= Primitive(int) = BORDER_REFLECT_101
// Arg ARG Primitive(int) derivBorder= Primitive(int) = BORDER_CONSTANT
// Arg ARG Primitive(bool) tryReuseInputImage= Primitive(bool) = true
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_buildOpticalFlowPyramid_Mat_img_VectorOfMat_pyramid_Size_winSize_int_maxLevel_bool_withDerivatives_int_pyrBorder_int_derivBorder_bool_tryReuseInputImage(void* img, void** pyramid, SizeWrapper winSize, int maxLevel, bool withDerivatives, int pyrBorder, int derivBorder, bool tryReuseInputImage) {
    try {
        int ret = cv::buildOpticalFlowPyramid(*reinterpret_cast<cv::Mat*>(img), *reinterpret_cast<std::vector<cv::Mat>*>(pyramid), *reinterpret_cast<cv::Size*>(&winSize), maxLevel, withDerivatives, pyrBorder, derivBorder, tryReuseInputImage);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_buildPyramid_Mat_src_VectorOfMat_dst_int_maxlevel_int_borderType
// parsed: cv::buildPyramid
// as:     cv::buildPyramid (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG Vector[cv::Mat (boxed)] dst= Vector[cv::Mat (boxed)] = 
// Arg ARG Primitive(int) maxlevel= Primitive(int) = 
// Arg ARG Primitive(int) borderType= Primitive(int) = BORDER_DEFAULT
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_buildPyramid_Mat_src_VectorOfMat_dst_int_maxlevel_int_borderType(void* src, void** dst, int maxlevel, int borderType) {
    try {
        cv::buildPyramid(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<std::vector<cv::Mat>*>(dst), maxlevel, borderType);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_calcBackProject_VectorOfMat_images_VectorOfint_channels_Mat_hist_Mat_dst_VectorOffloat_ranges_double_scale
// parsed: cv::calcBackProject
// as:     cv::calcBackProject (function)
// Arg ARG Vector[cv::Mat (boxed)] images= Vector[cv::Mat (boxed)] = 
// Arg ARG Vector[Primitive(int)] channels= Vector[Primitive(int)] = 
// Arg ARG cv::Mat (boxed) hist= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG Vector[Primitive(float)] ranges= Vector[Primitive(float)] = 
// Arg ARG Primitive(double) scale= Primitive(double) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_calcBackProject_VectorOfMat_images_VectorOfint_channels_Mat_hist_Mat_dst_VectorOffloat_ranges_double_scale(void* images, void* channels, void* hist, void* dst, void* ranges, double scale) {
    try {
        cv::calcBackProject(*reinterpret_cast<std::vector<cv::Mat>*>(images), *reinterpret_cast<std::vector<int>*>(channels), *reinterpret_cast<cv::Mat*>(hist), *reinterpret_cast<cv::Mat*>(dst), *reinterpret_cast<std::vector<float>*>(ranges), scale);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_calcCovarMatrix_Mat_samples_Mat_covar_Mat_mean_int_flags_int_ctype
// parsed: cv::calcCovarMatrix
// as:     cv::calcCovarMatrix (function)
// Arg ARG cv::Mat (boxed) samples= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) covar= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) mean= cv::Mat (boxed) = 
// Arg ARG Primitive(int) flags= Primitive(int) = 
// Arg ARG Primitive(int) ctype= Primitive(int) = CV_64F
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_calcCovarMatrix_Mat_samples_Mat_covar_Mat_mean_int_flags_int_ctype(void* samples, void* covar, void* mean, int flags, int ctype) {
    try {
        cv::calcCovarMatrix(*reinterpret_cast<cv::Mat*>(samples), *reinterpret_cast<cv::Mat*>(covar), *reinterpret_cast<cv::Mat*>(mean), flags, ctype);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_calcCovarMatrix_const_Mat_samples_int_nsamples_Mat_covar_Mat_mean_int_flags_int_ctype
// parsed: cv::calcCovarMatrix
// as:     cv::calcCovarMatrix (function)
// Arg ARG RawPtr[cv::Mat (boxed)] * samples= (ptr) RawPtr[cv::Mat (boxed)] = 
// Arg ARG Primitive(int) nsamples= Primitive(int) = 
// Arg ARG cv::Mat (boxed) covar= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) mean= cv::Mat (boxed) = 
// Arg ARG Primitive(int) flags= Primitive(int) = 
// Arg ARG Primitive(int) ctype= Primitive(int) = CV_64F
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_calcCovarMatrix_const_Mat_samples_int_nsamples_Mat_covar_Mat_mean_int_flags_int_ctype(const void* samples, int nsamples, void* covar, void* mean, int flags, int ctype) {
    try {
        cv::calcCovarMatrix(reinterpret_cast<const cv::Mat*>(samples), nsamples, *reinterpret_cast<cv::Mat*>(covar), *reinterpret_cast<cv::Mat*>(mean), flags, ctype);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_calcHist_VectorOfMat_images_VectorOfint_channels_Mat_mask_Mat_hist_VectorOfint_histSize_VectorOffloat_ranges_bool_accumulate
// parsed: cv::calcHist
// as:     cv::calcHist (function)
// Arg ARG Vector[cv::Mat (boxed)] images= Vector[cv::Mat (boxed)] = 
// Arg ARG Vector[Primitive(int)] channels= Vector[Primitive(int)] = 
// Arg ARG cv::Mat (boxed) mask= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) hist= cv::Mat (boxed) = 
// Arg ARG Vector[Primitive(int)] histSize= Vector[Primitive(int)] = 
// Arg ARG Vector[Primitive(float)] ranges= Vector[Primitive(float)] = 
// Arg ARG Primitive(bool) accumulate= Primitive(bool) = false
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_calcHist_VectorOfMat_images_VectorOfint_channels_Mat_mask_Mat_hist_VectorOfint_histSize_VectorOffloat_ranges_bool_accumulate(void* images, void* channels, void* mask, void* hist, void* histSize, void* ranges, bool accumulate) {
    try {
        cv::calcHist(*reinterpret_cast<std::vector<cv::Mat>*>(images), *reinterpret_cast<std::vector<int>*>(channels), *reinterpret_cast<cv::Mat*>(mask), *reinterpret_cast<cv::Mat*>(hist), *reinterpret_cast<std::vector<int>*>(histSize), *reinterpret_cast<std::vector<float>*>(ranges), accumulate);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_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
// parsed: cv::calcOpticalFlowFarneback
// as:     cv::calcOpticalFlowFarneback (function)
// Arg ARG cv::Mat (boxed) prev= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) next= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) flow= cv::Mat (boxed) = 
// Arg ARG Primitive(double) pyr_scale= Primitive(double) = 
// Arg ARG Primitive(int) levels= Primitive(int) = 
// Arg ARG Primitive(int) winsize= Primitive(int) = 
// Arg ARG Primitive(int) iterations= Primitive(int) = 
// Arg ARG Primitive(int) poly_n= Primitive(int) = 
// Arg ARG Primitive(double) poly_sigma= Primitive(double) = 
// Arg ARG Primitive(int) flags= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_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(void* prev, void* next, void* flow, double pyr_scale, int levels, int winsize, int iterations, int poly_n, double poly_sigma, int flags) {
    try {
        cv::calcOpticalFlowFarneback(*reinterpret_cast<cv::Mat*>(prev), *reinterpret_cast<cv::Mat*>(next), *reinterpret_cast<cv::Mat*>(flow), pyr_scale, levels, winsize, iterations, poly_n, poly_sigma, flags);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_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
// parsed: cv::calcOpticalFlowPyrLK
// as:     cv::calcOpticalFlowPyrLK (function)
// Arg ARG cv::Mat (boxed) prevImg= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) nextImg= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) prevPts= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) nextPts= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) status= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) err= cv::Mat (boxed) = 
// Arg ARG cv::Size (simple) winSize= cv::Size (simple) = Size(21,21)
// Arg ARG Primitive(int) maxLevel= Primitive(int) = 3
// Arg ARG cv::TermCriteria (boxed) criteria= cv::TermCriteria (boxed) = TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, 0.01)
// Arg ARG Primitive(int) flags= Primitive(int) = 0
// Arg ARG Primitive(double) minEigThreshold= Primitive(double) = 1e-4
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_calcOpticalFlowPyrLK_Mat_prevImg_Mat_nextImg_Mat_prevPts_Mat_nextPts_Mat_status_Mat_err_Size_winSize_int_maxLevel_TermCriteria_criteria_int_flags_double_minEigThreshold(void* prevImg, void* nextImg, void* prevPts, void* nextPts, void* status, void* err, SizeWrapper winSize, int maxLevel, void* criteria, int flags, double minEigThreshold) {
    try {
        cv::calcOpticalFlowPyrLK(*reinterpret_cast<cv::Mat*>(prevImg), *reinterpret_cast<cv::Mat*>(nextImg), *reinterpret_cast<cv::Mat*>(prevPts), *reinterpret_cast<cv::Mat*>(nextPts), *reinterpret_cast<cv::Mat*>(status), *reinterpret_cast<cv::Mat*>(err), *reinterpret_cast<cv::Size*>(&winSize), maxLevel, *reinterpret_cast<cv::TermCriteria*>(criteria), flags, minEigThreshold);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_calibrateCamera_VectorOfMat_objectPoints_VectorOfMat_imagePoints_Size_imageSize_Mat_cameraMatrix_Mat_distCoeffs_VectorOfMat_rvecs_VectorOfMat_tvecs_Mat_stdDeviationsIntrinsics_Mat_stdDeviationsExtrinsics_Mat_perViewErrors_int_flags_TermCriteria_criteria
// parsed: cv::calibrateCamera
// as:     cv::calibrateCamera (function)
// Arg ARG Vector[cv::Mat (boxed)] objectPoints= Vector[cv::Mat (boxed)] = 
// Arg ARG Vector[cv::Mat (boxed)] imagePoints= Vector[cv::Mat (boxed)] = 
// Arg ARG cv::Size (simple) imageSize= cv::Size (simple) = 
// Arg ARG cv::Mat (boxed) cameraMatrix= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) distCoeffs= cv::Mat (boxed) = 
// Arg ARG Vector[cv::Mat (boxed)] rvecs= Vector[cv::Mat (boxed)] = 
// Arg ARG Vector[cv::Mat (boxed)] tvecs= Vector[cv::Mat (boxed)] = 
// Arg ARG cv::Mat (boxed) stdDeviationsIntrinsics= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) stdDeviationsExtrinsics= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) perViewErrors= cv::Mat (boxed) = 
// Arg ARG Primitive(int) flags= Primitive(int) = 0
// Arg ARG cv::TermCriteria (boxed) criteria= cv::TermCriteria (boxed) = TermCriteria( TermCriteria::COUNT + TermCriteria::EPS, 30, DBL_EPSILON)
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_calibrateCamera_VectorOfMat_objectPoints_VectorOfMat_imagePoints_Size_imageSize_Mat_cameraMatrix_Mat_distCoeffs_VectorOfMat_rvecs_VectorOfMat_tvecs_Mat_stdDeviationsIntrinsics_Mat_stdDeviationsExtrinsics_Mat_perViewErrors_int_flags_TermCriteria_criteria(void* objectPoints, void* imagePoints, SizeWrapper imageSize, void* cameraMatrix, void* distCoeffs, void** rvecs, void** tvecs, void* stdDeviationsIntrinsics, void* stdDeviationsExtrinsics, void* perViewErrors, int flags, void* criteria) {
    try {
        double ret = cv::calibrateCamera(*reinterpret_cast<std::vector<cv::Mat>*>(objectPoints), *reinterpret_cast<std::vector<cv::Mat>*>(imagePoints), *reinterpret_cast<cv::Size*>(&imageSize), *reinterpret_cast<cv::Mat*>(cameraMatrix), *reinterpret_cast<cv::Mat*>(distCoeffs), *reinterpret_cast<std::vector<cv::Mat>*>(rvecs), *reinterpret_cast<std::vector<cv::Mat>*>(tvecs), *reinterpret_cast<cv::Mat*>(stdDeviationsIntrinsics), *reinterpret_cast<cv::Mat*>(stdDeviationsExtrinsics), *reinterpret_cast<cv::Mat*>(perViewErrors), flags, *reinterpret_cast<cv::TermCriteria*>(criteria));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_calibrateCamera_VectorOfMat_objectPoints_VectorOfMat_imagePoints_Size_imageSize_Mat_cameraMatrix_Mat_distCoeffs_VectorOfMat_rvecs_VectorOfMat_tvecs_int_flags_TermCriteria_criteria
// parsed: cv::calibrateCamera
// as:     cv::calibrateCamera (function)
// Arg ARG Vector[cv::Mat (boxed)] objectPoints= Vector[cv::Mat (boxed)] = 
// Arg ARG Vector[cv::Mat (boxed)] imagePoints= Vector[cv::Mat (boxed)] = 
// Arg ARG cv::Size (simple) imageSize= cv::Size (simple) = 
// Arg ARG cv::Mat (boxed) cameraMatrix= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) distCoeffs= cv::Mat (boxed) = 
// Arg ARG Vector[cv::Mat (boxed)] rvecs= Vector[cv::Mat (boxed)] = 
// Arg ARG Vector[cv::Mat (boxed)] tvecs= Vector[cv::Mat (boxed)] = 
// Arg ARG Primitive(int) flags= Primitive(int) = 0
// Arg ARG cv::TermCriteria (boxed) criteria= cv::TermCriteria (boxed) = TermCriteria( TermCriteria::COUNT + TermCriteria::EPS, 30, DBL_EPSILON)
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_calibrateCamera_VectorOfMat_objectPoints_VectorOfMat_imagePoints_Size_imageSize_Mat_cameraMatrix_Mat_distCoeffs_VectorOfMat_rvecs_VectorOfMat_tvecs_int_flags_TermCriteria_criteria(void* objectPoints, void* imagePoints, SizeWrapper imageSize, void* cameraMatrix, void* distCoeffs, void** rvecs, void** tvecs, int flags, void* criteria) {
    try {
        double ret = cv::calibrateCamera(*reinterpret_cast<std::vector<cv::Mat>*>(objectPoints), *reinterpret_cast<std::vector<cv::Mat>*>(imagePoints), *reinterpret_cast<cv::Size*>(&imageSize), *reinterpret_cast<cv::Mat*>(cameraMatrix), *reinterpret_cast<cv::Mat*>(distCoeffs), *reinterpret_cast<std::vector<cv::Mat>*>(rvecs), *reinterpret_cast<std::vector<cv::Mat>*>(tvecs), flags, *reinterpret_cast<cv::TermCriteria*>(criteria));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_calibrationMatrixValues_Mat_cameraMatrix_Size_imageSize_double_apertureWidth_double_apertureHeight_double_fovx_double_fovy_double_focalLength_Point2d_principalPoint_double_aspectRatio
// parsed: cv::calibrationMatrixValues
// as:     cv::calibrationMatrixValues (function)
// Arg ARG cv::Mat (boxed) cameraMatrix= cv::Mat (boxed) = 
// Arg ARG cv::Size (simple) imageSize= cv::Size (simple) = 
// Arg ARG Primitive(double) apertureWidth= Primitive(double) = 
// Arg ARG Primitive(double) apertureHeight= Primitive(double) = 
// Arg ARG Primitive(double) fovx= Primitive(double) = 
// Arg ARG Primitive(double) fovy= Primitive(double) = 
// Arg ARG Primitive(double) focalLength= Primitive(double) = 
// Arg ARG cv::Point2d (simple) principalPoint= cv::Point2d (simple) = 
// Arg ARG Primitive(double) aspectRatio= Primitive(double) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_calibrationMatrixValues_Mat_cameraMatrix_Size_imageSize_double_apertureWidth_double_apertureHeight_double_fovx_double_fovy_double_focalLength_Point2d_principalPoint_double_aspectRatio(void* cameraMatrix, SizeWrapper imageSize, double apertureWidth, double apertureHeight, double fovx, double fovy, double focalLength, Point2dWrapper principalPoint, double aspectRatio) {
    try {
        cv::calibrationMatrixValues(*reinterpret_cast<cv::Mat*>(cameraMatrix), *reinterpret_cast<cv::Size*>(&imageSize), apertureWidth, apertureHeight, fovx, fovy, focalLength, *reinterpret_cast<cv::Point2d*>(&principalPoint), aspectRatio);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_cartToPolar_Mat_x_Mat_y_Mat_magnitude_Mat_angle_bool_angleInDegrees
// parsed: cv::cartToPolar
// as:     cv::cartToPolar (function)
// Arg ARG cv::Mat (boxed) x= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) y= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) magnitude= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) angle= cv::Mat (boxed) = 
// Arg ARG Primitive(bool) angleInDegrees= Primitive(bool) = false
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_cartToPolar_Mat_x_Mat_y_Mat_magnitude_Mat_angle_bool_angleInDegrees(void* x, void* y, void* magnitude, void* angle, bool angleInDegrees) {
    try {
        cv::cartToPolar(*reinterpret_cast<cv::Mat*>(x), *reinterpret_cast<cv::Mat*>(y), *reinterpret_cast<cv::Mat*>(magnitude), *reinterpret_cast<cv::Mat*>(angle), angleInDegrees);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_cbrt_softfloat_a
// parsed: cv::cbrt
// as:     cv::cbrt (function)
// Arg ARG cv::softfloat (boxed) a= cv::softfloat (boxed) = 
// Return value: cv::softfloat (boxed)
cv_return_value_void_X cv_core_cv_cbrt_softfloat_a(void* a) {
    try {
        cv::softfloat ret = cv::cbrt(*reinterpret_cast<cv::softfloat*>(a));
        return { Error::Code::StsOk, NULL, new cv::softfloat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_checkHardwareSupport_int_feature
// parsed: cv::checkHardwareSupport
// as:     cv::checkHardwareSupport (function)
// Arg ARG Primitive(int) feature= Primitive(int) = 
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_checkHardwareSupport_int_feature(int feature) {
    try {
        bool ret = cv::checkHardwareSupport(feature);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_checkRange_Mat_a_bool_quiet_Point_X_pos_double_minVal_double_maxVal
// parsed: cv::checkRange
// as:     cv::checkRange (function)
// Arg ARG cv::Mat (boxed) a= cv::Mat (boxed) = 
// Arg ARG Primitive(bool) quiet= Primitive(bool) = true
// Arg ARG RawPtr[cv::Point (simple)] * pos= (ptr) RawPtr[cv::Point (simple)] = 0
// Arg ARG Primitive(double) minVal= Primitive(double) = -DBL_MAX
// Arg ARG Primitive(double) maxVal= Primitive(double) = DBL_MAX
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_checkRange_Mat_a_bool_quiet_Point_X_pos_double_minVal_double_maxVal(void* a, bool quiet, cv::Point* pos, double minVal, double maxVal) {
    try {
        bool ret = cv::checkRange(*reinterpret_cast<cv::Mat*>(a), quiet, reinterpret_cast<cv::Point*>(&pos), minVal, maxVal);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_circle_Mat_img_Point_center_int_radius_Scalar_color_int_thickness_int_lineType_int_shift
// parsed: cv::circle
// as:     cv::circle (function)
// Arg ARG cv::Mat (boxed) img= cv::Mat (boxed) = 
// Arg ARG cv::Point (simple) center= cv::Point (simple) = 
// Arg ARG Primitive(int) radius= Primitive(int) = 
// Arg ARG cv::Scalar (simple) color= cv::Scalar (simple) = 
// Arg ARG Primitive(int) thickness= Primitive(int) = 1
// Arg ARG Primitive(int) lineType= Primitive(int) = LINE_8
// Arg ARG Primitive(int) shift= Primitive(int) = 0
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_circle_Mat_img_Point_center_int_radius_Scalar_color_int_thickness_int_lineType_int_shift(void* img, PointWrapper center, int radius, ScalarWrapper color, int thickness, int lineType, int shift) {
    try {
        cv::circle(*reinterpret_cast<cv::Mat*>(img), *reinterpret_cast<cv::Point*>(&center), radius, *reinterpret_cast<cv::Scalar*>(&color), thickness, lineType, shift);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_clipLine_Rect_imgRect_Point_pt1_Point_pt2
// parsed: cv::clipLine
// as:     cv::clipLine (function)
// Arg ARG cv::Rect (simple) imgRect= cv::Rect (simple) = 
// Arg ARG cv::Point (simple) pt1= cv::Point (simple) = 
// Arg ARG cv::Point (simple) pt2= cv::Point (simple) = 
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_clipLine_Rect_imgRect_Point_pt1_Point_pt2(RectWrapper imgRect, PointWrapper pt1, PointWrapper pt2) {
    try {
        bool ret = cv::clipLine(*reinterpret_cast<cv::Rect*>(&imgRect), *reinterpret_cast<cv::Point*>(&pt1), *reinterpret_cast<cv::Point*>(&pt2));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_clipLine_Size2l_imgSize_Point2l_pt1_Point2l_pt2
// parsed: cv::clipLine
// as:     cv::clipLine (function)
// Arg ARG cv::Size2l (simple) imgSize= cv::Size2l (simple) = 
// Arg ARG cv::Point2l (simple) pt1= cv::Point2l (simple) = 
// Arg ARG cv::Point2l (simple) pt2= cv::Point2l (simple) = 
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_clipLine_Size2l_imgSize_Point2l_pt1_Point2l_pt2(Size2lWrapper imgSize, Point2lWrapper pt1, Point2lWrapper pt2) {
    try {
        bool ret = cv::clipLine(*reinterpret_cast<cv::Size2l*>(&imgSize), *reinterpret_cast<cv::Point2l*>(&pt1), *reinterpret_cast<cv::Point2l*>(&pt2));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_clipLine_Size_imgSize_Point_pt1_Point_pt2
// parsed: cv::clipLine
// as:     cv::clipLine (function)
// Arg ARG cv::Size (simple) imgSize= cv::Size (simple) = 
// Arg ARG cv::Point (simple) pt1= cv::Point (simple) = 
// Arg ARG cv::Point (simple) pt2= cv::Point (simple) = 
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_clipLine_Size_imgSize_Point_pt1_Point_pt2(SizeWrapper imgSize, PointWrapper pt1, PointWrapper pt2) {
    try {
        bool ret = cv::clipLine(*reinterpret_cast<cv::Size*>(&imgSize), *reinterpret_cast<cv::Point*>(&pt1), *reinterpret_cast<cv::Point*>(&pt2));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_colorChange_Mat_src_Mat_mask_Mat_dst_float_red_mul_float_green_mul_float_blue_mul
// parsed: cv::colorChange
// as:     cv::colorChange (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) mask= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG Primitive(float) red_mul= Primitive(float) = 1.0f
// Arg ARG Primitive(float) green_mul= Primitive(float) = 1.0f
// Arg ARG Primitive(float) blue_mul= Primitive(float) = 1.0f
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_colorChange_Mat_src_Mat_mask_Mat_dst_float_red_mul_float_green_mul_float_blue_mul(void* src, void* mask, void* dst, float red_mul, float green_mul, float blue_mul) {
    try {
        cv::colorChange(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(mask), *reinterpret_cast<cv::Mat*>(dst), red_mul, green_mul, blue_mul);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_compareHist_Mat_H1_Mat_H2_int_method
// parsed: cv::compareHist
// as:     cv::compareHist (function)
// Arg ARG cv::Mat (boxed) H1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) H2= cv::Mat (boxed) = 
// Arg ARG Primitive(int) method= Primitive(int) = 
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_compareHist_Mat_H1_Mat_H2_int_method(void* H1, void* H2, int method) {
    try {
        double ret = cv::compareHist(*reinterpret_cast<cv::Mat*>(H1), *reinterpret_cast<cv::Mat*>(H2), method);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_compare_Mat_src1_Mat_src2_Mat_dst_int_cmpop
// parsed: cv::compare
// as:     cv::compare (function)
// Arg ARG cv::Mat (boxed) src1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) src2= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG Primitive(int) cmpop= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_compare_Mat_src1_Mat_src2_Mat_dst_int_cmpop(void* src1, void* src2, void* dst, int cmpop) {
    try {
        cv::compare(*reinterpret_cast<cv::Mat*>(src1), *reinterpret_cast<cv::Mat*>(src2), *reinterpret_cast<cv::Mat*>(dst), cmpop);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_completeSymm_Mat_m_bool_lowerToUpper
// parsed: cv::completeSymm
// as:     cv::completeSymm (function)
// Arg ARG cv::Mat (boxed) m= cv::Mat (boxed) = 
// Arg ARG Primitive(bool) lowerToUpper= Primitive(bool) = false
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_completeSymm_Mat_m_bool_lowerToUpper(void* m, bool lowerToUpper) {
    try {
        cv::completeSymm(*reinterpret_cast<cv::Mat*>(m), lowerToUpper);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_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
// parsed: cv::composeRT
// as:     cv::composeRT (function)
// Arg ARG cv::Mat (boxed) rvec1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) tvec1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) rvec2= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) tvec2= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) rvec3= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) tvec3= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dr3dr1= cv::Mat (boxed) = noArray()
// Arg ARG cv::Mat (boxed) dr3dt1= cv::Mat (boxed) = noArray()
// Arg ARG cv::Mat (boxed) dr3dr2= cv::Mat (boxed) = noArray()
// Arg ARG cv::Mat (boxed) dr3dt2= cv::Mat (boxed) = noArray()
// Arg ARG cv::Mat (boxed) dt3dr1= cv::Mat (boxed) = noArray()
// Arg ARG cv::Mat (boxed) dt3dt1= cv::Mat (boxed) = noArray()
// Arg ARG cv::Mat (boxed) dt3dr2= cv::Mat (boxed) = noArray()
// Arg ARG cv::Mat (boxed) dt3dt2= cv::Mat (boxed) = noArray()
// Return value: Primitive(void)
cv_return_value_void cv_core_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(void* rvec1, void* tvec1, void* rvec2, void* tvec2, void* rvec3, void* tvec3, void* dr3dr1, void* dr3dt1, void* dr3dr2, void* dr3dt2, void* dt3dr1, void* dt3dt1, void* dt3dr2, void* dt3dt2) {
    try {
        cv::composeRT(*reinterpret_cast<cv::Mat*>(rvec1), *reinterpret_cast<cv::Mat*>(tvec1), *reinterpret_cast<cv::Mat*>(rvec2), *reinterpret_cast<cv::Mat*>(tvec2), *reinterpret_cast<cv::Mat*>(rvec3), *reinterpret_cast<cv::Mat*>(tvec3), *reinterpret_cast<cv::Mat*>(dr3dr1), *reinterpret_cast<cv::Mat*>(dr3dt1), *reinterpret_cast<cv::Mat*>(dr3dr2), *reinterpret_cast<cv::Mat*>(dr3dt2), *reinterpret_cast<cv::Mat*>(dt3dr1), *reinterpret_cast<cv::Mat*>(dt3dt1), *reinterpret_cast<cv::Mat*>(dt3dr2), *reinterpret_cast<cv::Mat*>(dt3dt2));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_computeCorrespondEpilines_Mat_points_int_whichImage_Mat_F_Mat_lines
// parsed: cv::computeCorrespondEpilines
// as:     cv::computeCorrespondEpilines (function)
// Arg ARG cv::Mat (boxed) points= cv::Mat (boxed) = 
// Arg ARG Primitive(int) whichImage= Primitive(int) = 
// Arg ARG cv::Mat (boxed) F= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) lines= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_computeCorrespondEpilines_Mat_points_int_whichImage_Mat_F_Mat_lines(void* points, int whichImage, void* F, void* lines) {
    try {
        cv::computeCorrespondEpilines(*reinterpret_cast<cv::Mat*>(points), whichImage, *reinterpret_cast<cv::Mat*>(F), *reinterpret_cast<cv::Mat*>(lines));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_computeRecallPrecisionCurve_VectorOfVectorOfDMatch_matches1to2_VectorOfVectorOfuchar_correctMatches1to2Mask_VectorOfPoint2f_recallPrecisionCurve
// parsed: cv::computeRecallPrecisionCurve
// as:     cv::computeRecallPrecisionCurve (function)
// Arg ARG Vector[Vector[cv::DMatch (simple)]] matches1to2= Vector[Vector[cv::DMatch (simple)]] = 
// Arg ARG Vector[Vector[Primitive(uchar)]] correctMatches1to2Mask= Vector[Vector[Primitive(uchar)]] = 
// Arg ARG Vector[cv::Point2f (simple)] recallPrecisionCurve= Vector[cv::Point2f (simple)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_computeRecallPrecisionCurve_VectorOfVectorOfDMatch_matches1to2_VectorOfVectorOfuchar_correctMatches1to2Mask_VectorOfPoint2f_recallPrecisionCurve(void* matches1to2, void* correctMatches1to2Mask, void* recallPrecisionCurve) {
    try {
        cv::computeRecallPrecisionCurve(*reinterpret_cast<std::vector<std::vector<cv::DMatch>>*>(matches1to2), *reinterpret_cast<std::vector<std::vector<uchar>>*>(correctMatches1to2Mask), *reinterpret_cast<std::vector<cv::Point2f>*>(recallPrecisionCurve));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_connectedComponentsWithStats_Mat_image_Mat_labels_Mat_stats_Mat_centroids_int_connectivity_int_ltype
// parsed: cv::connectedComponentsWithStats
// as:     cv::connectedComponentsWithStats (function)
// Arg ARG cv::Mat (boxed) image= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) labels= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) stats= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) centroids= cv::Mat (boxed) = 
// Arg ARG Primitive(int) connectivity= Primitive(int) = 8
// Arg ARG Primitive(int) ltype= Primitive(int) = CV_32S
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_connectedComponentsWithStats_Mat_image_Mat_labels_Mat_stats_Mat_centroids_int_connectivity_int_ltype(void* image, void* labels, void* stats, void* centroids, int connectivity, int ltype) {
    try {
        int ret = cv::connectedComponentsWithStats(*reinterpret_cast<cv::Mat*>(image), *reinterpret_cast<cv::Mat*>(labels), *reinterpret_cast<cv::Mat*>(stats), *reinterpret_cast<cv::Mat*>(centroids), connectivity, ltype);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_connectedComponentsWithStats_Mat_image_Mat_labels_Mat_stats_Mat_centroids_int_connectivity_int_ltype_int_ccltype
// parsed: cv::connectedComponentsWithStats
// as:     cv::connectedComponentsWithStats (function)
// Arg ARG cv::Mat (boxed) image= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) labels= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) stats= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) centroids= cv::Mat (boxed) = 
// Arg ARG Primitive(int) connectivity= Primitive(int) = 
// Arg ARG Primitive(int) ltype= Primitive(int) = 
// Arg ARG Primitive(int) ccltype= Primitive(int) = 
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_connectedComponentsWithStats_Mat_image_Mat_labels_Mat_stats_Mat_centroids_int_connectivity_int_ltype_int_ccltype(void* image, void* labels, void* stats, void* centroids, int connectivity, int ltype, int ccltype) {
    try {
        int ret = cv::connectedComponentsWithStats(*reinterpret_cast<cv::Mat*>(image), *reinterpret_cast<cv::Mat*>(labels), *reinterpret_cast<cv::Mat*>(stats), *reinterpret_cast<cv::Mat*>(centroids), connectivity, ltype, ccltype);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_connectedComponents_Mat_image_Mat_labels_int_connectivity_int_ltype
// parsed: cv::connectedComponents
// as:     cv::connectedComponents (function)
// Arg ARG cv::Mat (boxed) image= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) labels= cv::Mat (boxed) = 
// Arg ARG Primitive(int) connectivity= Primitive(int) = 8
// Arg ARG Primitive(int) ltype= Primitive(int) = CV_32S
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_connectedComponents_Mat_image_Mat_labels_int_connectivity_int_ltype(void* image, void* labels, int connectivity, int ltype) {
    try {
        int ret = cv::connectedComponents(*reinterpret_cast<cv::Mat*>(image), *reinterpret_cast<cv::Mat*>(labels), connectivity, ltype);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_connectedComponents_Mat_image_Mat_labels_int_connectivity_int_ltype_int_ccltype
// parsed: cv::connectedComponents
// as:     cv::connectedComponents (function)
// Arg ARG cv::Mat (boxed) image= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) labels= cv::Mat (boxed) = 
// Arg ARG Primitive(int) connectivity= Primitive(int) = 
// Arg ARG Primitive(int) ltype= Primitive(int) = 
// Arg ARG Primitive(int) ccltype= Primitive(int) = 
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_connectedComponents_Mat_image_Mat_labels_int_connectivity_int_ltype_int_ccltype(void* image, void* labels, int connectivity, int ltype, int ccltype) {
    try {
        int ret = cv::connectedComponents(*reinterpret_cast<cv::Mat*>(image), *reinterpret_cast<cv::Mat*>(labels), connectivity, ltype, ccltype);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_contourArea_Mat_contour_bool_oriented
// parsed: cv::contourArea
// as:     cv::contourArea (function)
// Arg ARG cv::Mat (boxed) contour= cv::Mat (boxed) = 
// Arg ARG Primitive(bool) oriented= Primitive(bool) = false
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_contourArea_Mat_contour_bool_oriented(void* contour, bool oriented) {
    try {
        double ret = cv::contourArea(*reinterpret_cast<cv::Mat*>(contour), oriented);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_convertFp16_Mat_src_Mat_dst
// parsed: cv::convertFp16
// as:     cv::convertFp16 (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_convertFp16_Mat_src_Mat_dst(void* src, void* dst) {
    try {
        cv::convertFp16(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_convertMaps_Mat_map1_Mat_map2_Mat_dstmap1_Mat_dstmap2_int_dstmap1type_bool_nninterpolation
// parsed: cv::convertMaps
// as:     cv::convertMaps (function)
// Arg ARG cv::Mat (boxed) map1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) map2= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dstmap1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dstmap2= cv::Mat (boxed) = 
// Arg ARG Primitive(int) dstmap1type= Primitive(int) = 
// Arg ARG Primitive(bool) nninterpolation= Primitive(bool) = false
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_convertMaps_Mat_map1_Mat_map2_Mat_dstmap1_Mat_dstmap2_int_dstmap1type_bool_nninterpolation(void* map1, void* map2, void* dstmap1, void* dstmap2, int dstmap1type, bool nninterpolation) {
    try {
        cv::convertMaps(*reinterpret_cast<cv::Mat*>(map1), *reinterpret_cast<cv::Mat*>(map2), *reinterpret_cast<cv::Mat*>(dstmap1), *reinterpret_cast<cv::Mat*>(dstmap2), dstmap1type, nninterpolation);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_convertPointsFromHomogeneous_Mat_src_Mat_dst
// parsed: cv::convertPointsFromHomogeneous
// as:     cv::convertPointsFromHomogeneous (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_convertPointsFromHomogeneous_Mat_src_Mat_dst(void* src, void* dst) {
    try {
        cv::convertPointsFromHomogeneous(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_convertPointsHomogeneous_Mat_src_Mat_dst
// parsed: cv::convertPointsHomogeneous
// as:     cv::convertPointsHomogeneous (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_convertPointsHomogeneous_Mat_src_Mat_dst(void* src, void* dst) {
    try {
        cv::convertPointsHomogeneous(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_convertPointsToHomogeneous_Mat_src_Mat_dst
// parsed: cv::convertPointsToHomogeneous
// as:     cv::convertPointsToHomogeneous (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_convertPointsToHomogeneous_Mat_src_Mat_dst(void* src, void* dst) {
    try {
        cv::convertPointsToHomogeneous(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_convertScaleAbs_Mat_src_Mat_dst_double_alpha_double_beta
// parsed: cv::convertScaleAbs
// as:     cv::convertScaleAbs (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG Primitive(double) alpha= Primitive(double) = 1
// Arg ARG Primitive(double) beta= Primitive(double) = 0
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_convertScaleAbs_Mat_src_Mat_dst_double_alpha_double_beta(void* src, void* dst, double alpha, double beta) {
    try {
        cv::convertScaleAbs(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst), alpha, beta);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_convexHull_Mat_points_Mat_hull_bool_clockwise_bool_returnPoints
// parsed: cv::convexHull
// as:     cv::convexHull (function)
// Arg ARG cv::Mat (boxed) points= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) hull= cv::Mat (boxed) = 
// Arg ARG Primitive(bool) clockwise= Primitive(bool) = false
// Arg ARG Primitive(bool) returnPoints= Primitive(bool) = true
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_convexHull_Mat_points_Mat_hull_bool_clockwise_bool_returnPoints(void* points, void* hull, bool clockwise, bool returnPoints) {
    try {
        cv::convexHull(*reinterpret_cast<cv::Mat*>(points), *reinterpret_cast<cv::Mat*>(hull), clockwise, returnPoints);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_convexityDefects_Mat_contour_Mat_convexhull_Mat_convexityDefects
// parsed: cv::convexityDefects
// as:     cv::convexityDefects (function)
// Arg ARG cv::Mat (boxed) contour= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) convexhull= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) convexityDefects= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_convexityDefects_Mat_contour_Mat_convexhull_Mat_convexityDefects(void* contour, void* convexhull, void* convexityDefects) {
    try {
        cv::convexityDefects(*reinterpret_cast<cv::Mat*>(contour), *reinterpret_cast<cv::Mat*>(convexhull), *reinterpret_cast<cv::Mat*>(convexityDefects));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_copyMakeBorder_Mat_src_Mat_dst_int_top_int_bottom_int_left_int_right_int_borderType_Scalar_value
// parsed: cv::copyMakeBorder
// as:     cv::copyMakeBorder (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG Primitive(int) top= Primitive(int) = 
// Arg ARG Primitive(int) bottom= Primitive(int) = 
// Arg ARG Primitive(int) left= Primitive(int) = 
// Arg ARG Primitive(int) right= Primitive(int) = 
// Arg ARG Primitive(int) borderType= Primitive(int) = 
// Arg ARG cv::Scalar (simple) value= cv::Scalar (simple) = Scalar()
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_copyMakeBorder_Mat_src_Mat_dst_int_top_int_bottom_int_left_int_right_int_borderType_Scalar_value(void* src, void* dst, int top, int bottom, int left, int right, int borderType, ScalarWrapper value) {
    try {
        cv::copyMakeBorder(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst), top, bottom, left, right, borderType, *reinterpret_cast<cv::Scalar*>(&value));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_cornerEigenValsAndVecs_Mat_src_Mat_dst_int_blockSize_int_ksize_int_borderType
// parsed: cv::cornerEigenValsAndVecs
// as:     cv::cornerEigenValsAndVecs (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG Primitive(int) blockSize= Primitive(int) = 
// Arg ARG Primitive(int) ksize= Primitive(int) = 
// Arg ARG Primitive(int) borderType= Primitive(int) = BORDER_DEFAULT
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_cornerEigenValsAndVecs_Mat_src_Mat_dst_int_blockSize_int_ksize_int_borderType(void* src, void* dst, int blockSize, int ksize, int borderType) {
    try {
        cv::cornerEigenValsAndVecs(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst), blockSize, ksize, borderType);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_cornerHarris_Mat_src_Mat_dst_int_blockSize_int_ksize_double_k_int_borderType
// parsed: cv::cornerHarris
// as:     cv::cornerHarris (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG Primitive(int) blockSize= Primitive(int) = 
// Arg ARG Primitive(int) ksize= Primitive(int) = 
// Arg ARG Primitive(double) k= Primitive(double) = 
// Arg ARG Primitive(int) borderType= Primitive(int) = BORDER_DEFAULT
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_cornerHarris_Mat_src_Mat_dst_int_blockSize_int_ksize_double_k_int_borderType(void* src, void* dst, int blockSize, int ksize, double k, int borderType) {
    try {
        cv::cornerHarris(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst), blockSize, ksize, k, borderType);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_cornerMinEigenVal_Mat_src_Mat_dst_int_blockSize_int_ksize_int_borderType
// parsed: cv::cornerMinEigenVal
// as:     cv::cornerMinEigenVal (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG Primitive(int) blockSize= Primitive(int) = 
// Arg ARG Primitive(int) ksize= Primitive(int) = 3
// Arg ARG Primitive(int) borderType= Primitive(int) = BORDER_DEFAULT
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_cornerMinEigenVal_Mat_src_Mat_dst_int_blockSize_int_ksize_int_borderType(void* src, void* dst, int blockSize, int ksize, int borderType) {
    try {
        cv::cornerMinEigenVal(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst), blockSize, ksize, borderType);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_cornerSubPix_Mat_image_Mat_corners_Size_winSize_Size_zeroZone_TermCriteria_criteria
// parsed: cv::cornerSubPix
// as:     cv::cornerSubPix (function)
// Arg ARG cv::Mat (boxed) image= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) corners= cv::Mat (boxed) = 
// Arg ARG cv::Size (simple) winSize= cv::Size (simple) = 
// Arg ARG cv::Size (simple) zeroZone= cv::Size (simple) = 
// Arg ARG cv::TermCriteria (boxed) criteria= cv::TermCriteria (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_cornerSubPix_Mat_image_Mat_corners_Size_winSize_Size_zeroZone_TermCriteria_criteria(void* image, void* corners, SizeWrapper winSize, SizeWrapper zeroZone, void* criteria) {
    try {
        cv::cornerSubPix(*reinterpret_cast<cv::Mat*>(image), *reinterpret_cast<cv::Mat*>(corners), *reinterpret_cast<cv::Size*>(&winSize), *reinterpret_cast<cv::Size*>(&zeroZone), *reinterpret_cast<cv::TermCriteria*>(criteria));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_correctMatches_Mat_F_Mat_points1_Mat_points2_Mat_newPoints1_Mat_newPoints2
// parsed: cv::correctMatches
// as:     cv::correctMatches (function)
// Arg ARG cv::Mat (boxed) F= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) points1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) points2= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) newPoints1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) newPoints2= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_correctMatches_Mat_F_Mat_points1_Mat_points2_Mat_newPoints1_Mat_newPoints2(void* F, void* points1, void* points2, void* newPoints1, void* newPoints2) {
    try {
        cv::correctMatches(*reinterpret_cast<cv::Mat*>(F), *reinterpret_cast<cv::Mat*>(points1), *reinterpret_cast<cv::Mat*>(points2), *reinterpret_cast<cv::Mat*>(newPoints1), *reinterpret_cast<cv::Mat*>(newPoints2));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_cos_softdouble_a
// parsed: cv::cos
// as:     cv::cos (function)
// Arg ARG cv::softdouble (boxed) a= cv::softdouble (boxed) = 
// Return value: cv::softdouble (boxed)
cv_return_value_void_X cv_core_cv_cos_softdouble_a(void* a) {
    try {
        cv::softdouble ret = cv::cos(*reinterpret_cast<cv::softdouble*>(a));
        return { Error::Code::StsOk, NULL, new cv::softdouble(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_countNonZero_Mat_src
// parsed: cv::countNonZero
// as:     cv::countNonZero (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_countNonZero_Mat_src(void* src) {
    try {
        int ret = cv::countNonZero(*reinterpret_cast<cv::Mat*>(src));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_createAffineTransformer_bool_fullAffine
// parsed: cv::createAffineTransformer
// as:     cv::createAffineTransformer (function)
// Arg ARG Primitive(bool) fullAffine= Primitive(bool) = 
// Return value: SmartPtr[cv::AffineTransformer (boxed)]
cv_return_value_void_X cv_core_cv_createAffineTransformer_bool_fullAffine(bool fullAffine) {
    try {
        Ptr<cv::AffineTransformer> *ret = new Ptr<cv::AffineTransformer>(cv::createAffineTransformer(fullAffine));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_createAlignMTB_int_max_bits_int_exclude_range_bool_cut
// parsed: cv::createAlignMTB
// as:     cv::createAlignMTB (function)
// Arg ARG Primitive(int) max_bits= Primitive(int) = 6
// Arg ARG Primitive(int) exclude_range= Primitive(int) = 4
// Arg ARG Primitive(bool) cut= Primitive(bool) = true
// Return value: SmartPtr[cv::AlignMTB (boxed)]
cv_return_value_void_X cv_core_cv_createAlignMTB_int_max_bits_int_exclude_range_bool_cut(int max_bits, int exclude_range, bool cut) {
    try {
        Ptr<cv::AlignMTB> *ret = new Ptr<cv::AlignMTB>(cv::createAlignMTB(max_bits, exclude_range, cut));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_createBackgroundSubtractorKNN_int_history_double_dist2Threshold_bool_detectShadows
// parsed: cv::createBackgroundSubtractorKNN
// as:     cv::createBackgroundSubtractorKNN (function)
// Arg ARG Primitive(int) history= Primitive(int) = 500
// Arg ARG Primitive(double) dist2Threshold= Primitive(double) = 400.0
// Arg ARG Primitive(bool) detectShadows= Primitive(bool) = true
// Return value: SmartPtr[cv::BackgroundSubtractorKNN (boxed)]
cv_return_value_void_X cv_core_cv_createBackgroundSubtractorKNN_int_history_double_dist2Threshold_bool_detectShadows(int history, double dist2Threshold, bool detectShadows) {
    try {
        Ptr<cv::BackgroundSubtractorKNN> *ret = new Ptr<cv::BackgroundSubtractorKNN>(cv::createBackgroundSubtractorKNN(history, dist2Threshold, detectShadows));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_createBackgroundSubtractorMOG2_int_history_double_varThreshold_bool_detectShadows
// parsed: cv::createBackgroundSubtractorMOG2
// as:     cv::createBackgroundSubtractorMOG2 (function)
// Arg ARG Primitive(int) history= Primitive(int) = 500
// Arg ARG Primitive(double) varThreshold= Primitive(double) = 16
// Arg ARG Primitive(bool) detectShadows= Primitive(bool) = true
// Return value: SmartPtr[cv::BackgroundSubtractorMOG2 (boxed)]
cv_return_value_void_X cv_core_cv_createBackgroundSubtractorMOG2_int_history_double_varThreshold_bool_detectShadows(int history, double varThreshold, bool detectShadows) {
    try {
        Ptr<cv::BackgroundSubtractorMOG2> *ret = new Ptr<cv::BackgroundSubtractorMOG2>(cv::createBackgroundSubtractorMOG2(history, varThreshold, detectShadows));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_createButton_String_bar_name_ButtonCallback_on_change_void_X_userdata_int_type_bool_initial_button_state
// parsed: cv::createButton
// as:     cv::createButton (function)
// Arg ARG string bar_name= string = 
// Arg ARG cv::ButtonCallback (callback) on_change= cv::ButtonCallback (callback) = 
// Arg ARG RawPtr[Primitive(void)] * userdata= (ptr) RawPtr[Primitive(void)] = 0
// Arg ARG Primitive(int) type= Primitive(int) = QT_PUSH_BUTTON
// Arg ARG Primitive(bool) initial_button_state= Primitive(bool) = false
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_createButton_String_bar_name_ButtonCallback_on_change_void_X_userdata_int_type_bool_initial_button_state(const char* bar_name, cv::ButtonCallback on_change, void* userdata, int type, bool initial_button_state) {
    try {
        int ret = cv::createButton(String(bar_name), *reinterpret_cast<cv::ButtonCallback*>(&on_change), userdata, type, initial_button_state);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_createCLAHE_double_clipLimit_Size_tileGridSize
// parsed: cv::createCLAHE
// as:     cv::createCLAHE (function)
// Arg ARG Primitive(double) clipLimit= Primitive(double) = 40.0
// Arg ARG cv::Size (simple) tileGridSize= cv::Size (simple) = Size(8, 8)
// Return value: SmartPtr[cv::CLAHE (boxed)]
cv_return_value_void_X cv_core_cv_createCLAHE_double_clipLimit_Size_tileGridSize(double clipLimit, SizeWrapper tileGridSize) {
    try {
        Ptr<cv::CLAHE> *ret = new Ptr<cv::CLAHE>(cv::createCLAHE(clipLimit, *reinterpret_cast<cv::Size*>(&tileGridSize)));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_createCalibrateDebevec_int_samples_float_lambda_bool_random
// parsed: cv::createCalibrateDebevec
// as:     cv::createCalibrateDebevec (function)
// Arg ARG Primitive(int) samples= Primitive(int) = 70
// Arg ARG Primitive(float) lambda= Primitive(float) = 10.0f
// Arg ARG Primitive(bool) random= Primitive(bool) = false
// Return value: SmartPtr[cv::CalibrateDebevec (boxed)]
cv_return_value_void_X cv_core_cv_createCalibrateDebevec_int_samples_float_lambda_bool_random(int samples, float lambda, bool random) {
    try {
        Ptr<cv::CalibrateDebevec> *ret = new Ptr<cv::CalibrateDebevec>(cv::createCalibrateDebevec(samples, lambda, random));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_createCalibrateRobertson_int_max_iter_float_threshold
// parsed: cv::createCalibrateRobertson
// as:     cv::createCalibrateRobertson (function)
// Arg ARG Primitive(int) max_iter= Primitive(int) = 30
// Arg ARG Primitive(float) threshold= Primitive(float) = 0.01f
// Return value: SmartPtr[cv::CalibrateRobertson (boxed)]
cv_return_value_void_X cv_core_cv_createCalibrateRobertson_int_max_iter_float_threshold(int max_iter, float threshold) {
    try {
        Ptr<cv::CalibrateRobertson> *ret = new Ptr<cv::CalibrateRobertson>(cv::createCalibrateRobertson(max_iter, threshold));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_createChiHistogramCostExtractor_int_nDummies_float_defaultCost
// parsed: cv::createChiHistogramCostExtractor
// as:     cv::createChiHistogramCostExtractor (function)
// Arg ARG Primitive(int) nDummies= Primitive(int) = 25
// Arg ARG Primitive(float) defaultCost= Primitive(float) = 0.2f
// Return value: SmartPtr[cv::HistogramCostExtractor (boxed)]
cv_return_value_void_X cv_core_cv_createChiHistogramCostExtractor_int_nDummies_float_defaultCost(int nDummies, float defaultCost) {
    try {
        Ptr<cv::HistogramCostExtractor> *ret = new Ptr<cv::HistogramCostExtractor>(cv::createChiHistogramCostExtractor(nDummies, defaultCost));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_createEMDHistogramCostExtractor_int_flag_int_nDummies_float_defaultCost
// parsed: cv::createEMDHistogramCostExtractor
// as:     cv::createEMDHistogramCostExtractor (function)
// Arg ARG Primitive(int) flag= Primitive(int) = DIST_L2
// Arg ARG Primitive(int) nDummies= Primitive(int) = 25
// Arg ARG Primitive(float) defaultCost= Primitive(float) = 0.2f
// Return value: SmartPtr[cv::HistogramCostExtractor (boxed)]
cv_return_value_void_X cv_core_cv_createEMDHistogramCostExtractor_int_flag_int_nDummies_float_defaultCost(int flag, int nDummies, float defaultCost) {
    try {
        Ptr<cv::HistogramCostExtractor> *ret = new Ptr<cv::HistogramCostExtractor>(cv::createEMDHistogramCostExtractor(flag, nDummies, defaultCost));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_createEMDL1HistogramCostExtractor_int_nDummies_float_defaultCost
// parsed: cv::createEMDL1HistogramCostExtractor
// as:     cv::createEMDL1HistogramCostExtractor (function)
// Arg ARG Primitive(int) nDummies= Primitive(int) = 25
// Arg ARG Primitive(float) defaultCost= Primitive(float) = 0.2f
// Return value: SmartPtr[cv::HistogramCostExtractor (boxed)]
cv_return_value_void_X cv_core_cv_createEMDL1HistogramCostExtractor_int_nDummies_float_defaultCost(int nDummies, float defaultCost) {
    try {
        Ptr<cv::HistogramCostExtractor> *ret = new Ptr<cv::HistogramCostExtractor>(cv::createEMDL1HistogramCostExtractor(nDummies, defaultCost));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_createFaceDetectionMaskGenerator
// parsed: cv::createFaceDetectionMaskGenerator
// as:     cv::createFaceDetectionMaskGenerator (function)
// Return value: SmartPtr[cv::BaseCascadeClassifier::MaskGenerator (boxed)]
cv_return_value_void_X cv_core_cv_createFaceDetectionMaskGenerator() {
    try {
        Ptr<cv::BaseCascadeClassifier::MaskGenerator> *ret = new Ptr<cv::BaseCascadeClassifier::MaskGenerator>(cv::createFaceDetectionMaskGenerator());
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_createGeneralizedHoughBallard
// parsed: cv::createGeneralizedHoughBallard
// as:     cv::createGeneralizedHoughBallard (function)
// Return value: SmartPtr[cv::GeneralizedHoughBallard (boxed)]
cv_return_value_void_X cv_core_cv_createGeneralizedHoughBallard() {
    try {
        Ptr<cv::GeneralizedHoughBallard> *ret = new Ptr<cv::GeneralizedHoughBallard>(cv::createGeneralizedHoughBallard());
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_createGeneralizedHoughGuil
// parsed: cv::createGeneralizedHoughGuil
// as:     cv::createGeneralizedHoughGuil (function)
// Return value: SmartPtr[cv::GeneralizedHoughGuil (boxed)]
cv_return_value_void_X cv_core_cv_createGeneralizedHoughGuil() {
    try {
        Ptr<cv::GeneralizedHoughGuil> *ret = new Ptr<cv::GeneralizedHoughGuil>(cv::createGeneralizedHoughGuil());
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_createHanningWindow_Mat_dst_Size_winSize_int_type
// parsed: cv::createHanningWindow
// as:     cv::createHanningWindow (function)
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG cv::Size (simple) winSize= cv::Size (simple) = 
// Arg ARG Primitive(int) type= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_createHanningWindow_Mat_dst_Size_winSize_int_type(void* dst, SizeWrapper winSize, int type) {
    try {
        cv::createHanningWindow(*reinterpret_cast<cv::Mat*>(dst), *reinterpret_cast<cv::Size*>(&winSize), type);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_createHausdorffDistanceExtractor_int_distanceFlag_float_rankProp
// parsed: cv::createHausdorffDistanceExtractor
// as:     cv::createHausdorffDistanceExtractor (function)
// Arg ARG Primitive(int) distanceFlag= Primitive(int) = cv::NORM_L2
// Arg ARG Primitive(float) rankProp= Primitive(float) = 0.6f
// Return value: SmartPtr[cv::HausdorffDistanceExtractor (boxed)]
cv_return_value_void_X cv_core_cv_createHausdorffDistanceExtractor_int_distanceFlag_float_rankProp(int distanceFlag, float rankProp) {
    try {
        Ptr<cv::HausdorffDistanceExtractor> *ret = new Ptr<cv::HausdorffDistanceExtractor>(cv::createHausdorffDistanceExtractor(distanceFlag, rankProp));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_createLineSegmentDetector_int__refine_double__scale_double__sigma_scale_double__quant_double__ang_th_double__log_eps_double__density_th_int__n_bins
// parsed: cv::createLineSegmentDetector
// as:     cv::createLineSegmentDetector (function)
// Arg ARG Primitive(int) _refine= Primitive(int) = LSD_REFINE_STD
// Arg ARG Primitive(double) _scale= Primitive(double) = 0.8
// Arg ARG Primitive(double) _sigma_scale= Primitive(double) = 0.6
// Arg ARG Primitive(double) _quant= Primitive(double) = 2.0
// Arg ARG Primitive(double) _ang_th= Primitive(double) = 22.5
// Arg ARG Primitive(double) _log_eps= Primitive(double) = 0
// Arg ARG Primitive(double) _density_th= Primitive(double) = 0.7
// Arg ARG Primitive(int) _n_bins= Primitive(int) = 1024
// Return value: SmartPtr[cv::LineSegmentDetector (boxed)]
cv_return_value_void_X cv_core_cv_createLineSegmentDetector_int__refine_double__scale_double__sigma_scale_double__quant_double__ang_th_double__log_eps_double__density_th_int__n_bins(int _refine, double _scale, double _sigma_scale, double _quant, double _ang_th, double _log_eps, double _density_th, int _n_bins) {
    try {
        Ptr<cv::LineSegmentDetector> *ret = new Ptr<cv::LineSegmentDetector>(cv::createLineSegmentDetector(_refine, _scale, _sigma_scale, _quant, _ang_th, _log_eps, _density_th, _n_bins));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_createMergeDebevec
// parsed: cv::createMergeDebevec
// as:     cv::createMergeDebevec (function)
// Return value: SmartPtr[cv::MergeDebevec (boxed)]
cv_return_value_void_X cv_core_cv_createMergeDebevec() {
    try {
        Ptr<cv::MergeDebevec> *ret = new Ptr<cv::MergeDebevec>(cv::createMergeDebevec());
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_createMergeMertens_float_contrast_weight_float_saturation_weight_float_exposure_weight
// parsed: cv::createMergeMertens
// as:     cv::createMergeMertens (function)
// Arg ARG Primitive(float) contrast_weight= Primitive(float) = 1.0f
// Arg ARG Primitive(float) saturation_weight= Primitive(float) = 1.0f
// Arg ARG Primitive(float) exposure_weight= Primitive(float) = 0.0f
// Return value: SmartPtr[cv::MergeMertens (boxed)]
cv_return_value_void_X cv_core_cv_createMergeMertens_float_contrast_weight_float_saturation_weight_float_exposure_weight(float contrast_weight, float saturation_weight, float exposure_weight) {
    try {
        Ptr<cv::MergeMertens> *ret = new Ptr<cv::MergeMertens>(cv::createMergeMertens(contrast_weight, saturation_weight, exposure_weight));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_createMergeRobertson
// parsed: cv::createMergeRobertson
// as:     cv::createMergeRobertson (function)
// Return value: SmartPtr[cv::MergeRobertson (boxed)]
cv_return_value_void_X cv_core_cv_createMergeRobertson() {
    try {
        Ptr<cv::MergeRobertson> *ret = new Ptr<cv::MergeRobertson>(cv::createMergeRobertson());
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_createNormHistogramCostExtractor_int_flag_int_nDummies_float_defaultCost
// parsed: cv::createNormHistogramCostExtractor
// as:     cv::createNormHistogramCostExtractor (function)
// Arg ARG Primitive(int) flag= Primitive(int) = DIST_L2
// Arg ARG Primitive(int) nDummies= Primitive(int) = 25
// Arg ARG Primitive(float) defaultCost= Primitive(float) = 0.2f
// Return value: SmartPtr[cv::HistogramCostExtractor (boxed)]
cv_return_value_void_X cv_core_cv_createNormHistogramCostExtractor_int_flag_int_nDummies_float_defaultCost(int flag, int nDummies, float defaultCost) {
    try {
        Ptr<cv::HistogramCostExtractor> *ret = new Ptr<cv::HistogramCostExtractor>(cv::createNormHistogramCostExtractor(flag, nDummies, defaultCost));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_createOptFlow_DualTVL1
// parsed: cv::createOptFlow_DualTVL1
// as:     cv::createOptFlow_DualTVL1 (function)
// Return value: SmartPtr[cv::DualTVL1OpticalFlow (boxed)]
cv_return_value_void_X cv_core_cv_createOptFlow_DualTVL1() {
    try {
        Ptr<cv::DualTVL1OpticalFlow> *ret = new Ptr<cv::DualTVL1OpticalFlow>(cv::createOptFlow_DualTVL1());
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_createStitcherScans_bool_try_use_gpu
// parsed: cv::createStitcherScans
// as:     cv::createStitcherScans (function)
// Arg ARG Primitive(bool) try_use_gpu= Primitive(bool) = false
// Return value: SmartPtr[cv::Stitcher (boxed)]
cv_return_value_void_X cv_core_cv_createStitcherScans_bool_try_use_gpu(bool try_use_gpu) {
    try {
        Ptr<cv::Stitcher> *ret = new Ptr<cv::Stitcher>(cv::createStitcherScans(try_use_gpu));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_createStitcher_bool_try_use_gpu
// parsed: cv::createStitcher
// as:     cv::createStitcher (function)
// Arg ARG Primitive(bool) try_use_gpu= Primitive(bool) = false
// Return value: SmartPtr[cv::Stitcher (boxed)]
cv_return_value_void_X cv_core_cv_createStitcher_bool_try_use_gpu(bool try_use_gpu) {
    try {
        Ptr<cv::Stitcher> *ret = new Ptr<cv::Stitcher>(cv::createStitcher(try_use_gpu));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_createThinPlateSplineShapeTransformer_double_regularizationParameter
// parsed: cv::createThinPlateSplineShapeTransformer
// as:     cv::createThinPlateSplineShapeTransformer (function)
// Arg ARG Primitive(double) regularizationParameter= Primitive(double) = 0
// Return value: SmartPtr[cv::ThinPlateSplineShapeTransformer (boxed)]
cv_return_value_void_X cv_core_cv_createThinPlateSplineShapeTransformer_double_regularizationParameter(double regularizationParameter) {
    try {
        Ptr<cv::ThinPlateSplineShapeTransformer> *ret = new Ptr<cv::ThinPlateSplineShapeTransformer>(cv::createThinPlateSplineShapeTransformer(regularizationParameter));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_createTonemapDrago_float_gamma_float_saturation_float_bias
// parsed: cv::createTonemapDrago
// as:     cv::createTonemapDrago (function)
// Arg ARG Primitive(float) gamma= Primitive(float) = 1.0f
// Arg ARG Primitive(float) saturation= Primitive(float) = 1.0f
// Arg ARG Primitive(float) bias= Primitive(float) = 0.85f
// Return value: SmartPtr[cv::TonemapDrago (boxed)]
cv_return_value_void_X cv_core_cv_createTonemapDrago_float_gamma_float_saturation_float_bias(float gamma, float saturation, float bias) {
    try {
        Ptr<cv::TonemapDrago> *ret = new Ptr<cv::TonemapDrago>(cv::createTonemapDrago(gamma, saturation, bias));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_createTonemapMantiuk_float_gamma_float_scale_float_saturation
// parsed: cv::createTonemapMantiuk
// as:     cv::createTonemapMantiuk (function)
// Arg ARG Primitive(float) gamma= Primitive(float) = 1.0f
// Arg ARG Primitive(float) scale= Primitive(float) = 0.7f
// Arg ARG Primitive(float) saturation= Primitive(float) = 1.0f
// Return value: SmartPtr[cv::TonemapMantiuk (boxed)]
cv_return_value_void_X cv_core_cv_createTonemapMantiuk_float_gamma_float_scale_float_saturation(float gamma, float scale, float saturation) {
    try {
        Ptr<cv::TonemapMantiuk> *ret = new Ptr<cv::TonemapMantiuk>(cv::createTonemapMantiuk(gamma, scale, saturation));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_createTonemapReinhard_float_gamma_float_intensity_float_light_adapt_float_color_adapt
// parsed: cv::createTonemapReinhard
// as:     cv::createTonemapReinhard (function)
// Arg ARG Primitive(float) gamma= Primitive(float) = 1.0f
// Arg ARG Primitive(float) intensity= Primitive(float) = 0.0f
// Arg ARG Primitive(float) light_adapt= Primitive(float) = 1.0f
// Arg ARG Primitive(float) color_adapt= Primitive(float) = 0.0f
// Return value: SmartPtr[cv::TonemapReinhard (boxed)]
cv_return_value_void_X cv_core_cv_createTonemapReinhard_float_gamma_float_intensity_float_light_adapt_float_color_adapt(float gamma, float intensity, float light_adapt, float color_adapt) {
    try {
        Ptr<cv::TonemapReinhard> *ret = new Ptr<cv::TonemapReinhard>(cv::createTonemapReinhard(gamma, intensity, light_adapt, color_adapt));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_createTonemap_float_gamma
// parsed: cv::createTonemap
// as:     cv::createTonemap (function)
// Arg ARG Primitive(float) gamma= Primitive(float) = 1.0f
// Return value: SmartPtr[cv::Tonemap (boxed)]
cv_return_value_void_X cv_core_cv_createTonemap_float_gamma(float gamma) {
    try {
        Ptr<cv::Tonemap> *ret = new Ptr<cv::Tonemap>(cv::createTonemap(gamma));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_createTrackbar_String_trackbarname_String_winname_int_X_value_int_count_TrackbarCallback_onChange_void_X_userdata
// parsed: cv::createTrackbar
// as:     cv::createTrackbar (function)
// Arg ARG string trackbarname= string = 
// Arg ARG string winname= string = 
// Arg ARG RawPtr[Primitive(int)] * value= (ptr) RawPtr[Primitive(int)] = 
// Arg ARG Primitive(int) count= Primitive(int) = 
// Arg ARG cv::TrackbarCallback (callback) onChange= cv::TrackbarCallback (callback) = 0
// Arg ARG RawPtr[Primitive(void)] * userdata= (ptr) RawPtr[Primitive(void)] = 0
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_createTrackbar_String_trackbarname_String_winname_int_X_value_int_count_TrackbarCallback_onChange_void_X_userdata(const char* trackbarname, const char* winname, int* value, int count, cv::TrackbarCallback onChange, void* userdata) {
    try {
        int ret = cv::createTrackbar(String(trackbarname), String(winname), value, count, *reinterpret_cast<cv::TrackbarCallback*>(&onChange), userdata);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_cubeRoot_float_val
// parsed: cv::cubeRoot
// as:     cv::cubeRoot (function)
// Arg ARG Primitive(float) val= Primitive(float) = 
// Return value: Primitive(float)
cv_return_value_float cv_core_cv_cubeRoot_float_val(float val) {
    try {
        float ret = cv::cubeRoot(val);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<float*>(&ret) };
    } CVRS_CATCH(cv_return_value_float)
}

// cv_cv_abs_schar_x
// parsed: cv::cv_abs
// as:     cv::cv_abs (function)
// Arg ARG Primitive(schar) x= Primitive(schar) = 
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_cv_abs_schar_x(char x) {
    try {
        int ret = cv::cv_abs(x);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_cv_abs_ushort_x
// parsed: cv::cv_abs
// as:     cv::cv_abs (function)
// Arg ARG Primitive(ushort) x= Primitive(ushort) = 
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_cv_abs_ushort_x(unsigned short x) {
    try {
        int ret = cv::cv_abs(x);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_cvtColorTwoPlane_Mat_src1_Mat_src2_Mat_dst_int_code
// parsed: cv::cvtColorTwoPlane
// as:     cv::cvtColorTwoPlane (function)
// Arg ARG cv::Mat (boxed) src1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) src2= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG Primitive(int) code= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_cvtColorTwoPlane_Mat_src1_Mat_src2_Mat_dst_int_code(void* src1, void* src2, void* dst, int code) {
    try {
        cv::cvtColorTwoPlane(*reinterpret_cast<cv::Mat*>(src1), *reinterpret_cast<cv::Mat*>(src2), *reinterpret_cast<cv::Mat*>(dst), code);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_cvtColor_Mat_src_Mat_dst_int_code_int_dstCn
// parsed: cv::cvtColor
// as:     cv::cvtColor (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG Primitive(int) code= Primitive(int) = 
// Arg ARG Primitive(int) dstCn= Primitive(int) = 0
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_cvtColor_Mat_src_Mat_dst_int_code_int_dstCn(void* src, void* dst, int code, int dstCn) {
    try {
        cv::cvtColor(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst), code, dstCn);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_dct_Mat_src_Mat_dst_int_flags
// parsed: cv::dct
// as:     cv::dct (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG Primitive(int) flags= Primitive(int) = 0
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_dct_Mat_src_Mat_dst_int_flags(void* src, void* dst, int flags) {
    try {
        cv::dct(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst), flags);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_decolor_Mat_src_Mat_grayscale_Mat_color_boost
// parsed: cv::decolor
// as:     cv::decolor (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) grayscale= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) color_boost= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_decolor_Mat_src_Mat_grayscale_Mat_color_boost(void* src, void* grayscale, void* color_boost) {
    try {
        cv::decolor(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(grayscale), *reinterpret_cast<cv::Mat*>(color_boost));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_decomposeEssentialMat_Mat_E_Mat_R1_Mat_R2_Mat_t
// parsed: cv::decomposeEssentialMat
// as:     cv::decomposeEssentialMat (function)
// Arg ARG cv::Mat (boxed) E= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) R1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) R2= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) t= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_decomposeEssentialMat_Mat_E_Mat_R1_Mat_R2_Mat_t(void* E, void* R1, void* R2, void* t) {
    try {
        cv::decomposeEssentialMat(*reinterpret_cast<cv::Mat*>(E), *reinterpret_cast<cv::Mat*>(R1), *reinterpret_cast<cv::Mat*>(R2), *reinterpret_cast<cv::Mat*>(t));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_decomposeHomographyMat_Mat_H_Mat_K_VectorOfMat_rotations_VectorOfMat_translations_VectorOfMat_normals
// parsed: cv::decomposeHomographyMat
// as:     cv::decomposeHomographyMat (function)
// Arg ARG cv::Mat (boxed) H= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) K= cv::Mat (boxed) = 
// Arg ARG Vector[cv::Mat (boxed)] rotations= Vector[cv::Mat (boxed)] = 
// Arg ARG Vector[cv::Mat (boxed)] translations= Vector[cv::Mat (boxed)] = 
// Arg ARG Vector[cv::Mat (boxed)] normals= Vector[cv::Mat (boxed)] = 
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_decomposeHomographyMat_Mat_H_Mat_K_VectorOfMat_rotations_VectorOfMat_translations_VectorOfMat_normals(void* H, void* K, void** rotations, void** translations, void** normals) {
    try {
        int ret = cv::decomposeHomographyMat(*reinterpret_cast<cv::Mat*>(H), *reinterpret_cast<cv::Mat*>(K), *reinterpret_cast<std::vector<cv::Mat>*>(rotations), *reinterpret_cast<std::vector<cv::Mat>*>(translations), *reinterpret_cast<std::vector<cv::Mat>*>(normals));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_decomposeProjectionMatrix_Mat_projMatrix_Mat_cameraMatrix_Mat_rotMatrix_Mat_transVect_Mat_rotMatrixX_Mat_rotMatrixY_Mat_rotMatrixZ_Mat_eulerAngles
// parsed: cv::decomposeProjectionMatrix
// as:     cv::decomposeProjectionMatrix (function)
// Arg ARG cv::Mat (boxed) projMatrix= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) cameraMatrix= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) rotMatrix= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) transVect= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) rotMatrixX= cv::Mat (boxed) = noArray()
// Arg ARG cv::Mat (boxed) rotMatrixY= cv::Mat (boxed) = noArray()
// Arg ARG cv::Mat (boxed) rotMatrixZ= cv::Mat (boxed) = noArray()
// Arg ARG cv::Mat (boxed) eulerAngles= cv::Mat (boxed) = noArray()
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_decomposeProjectionMatrix_Mat_projMatrix_Mat_cameraMatrix_Mat_rotMatrix_Mat_transVect_Mat_rotMatrixX_Mat_rotMatrixY_Mat_rotMatrixZ_Mat_eulerAngles(void* projMatrix, void* cameraMatrix, void* rotMatrix, void* transVect, void* rotMatrixX, void* rotMatrixY, void* rotMatrixZ, void* eulerAngles) {
    try {
        cv::decomposeProjectionMatrix(*reinterpret_cast<cv::Mat*>(projMatrix), *reinterpret_cast<cv::Mat*>(cameraMatrix), *reinterpret_cast<cv::Mat*>(rotMatrix), *reinterpret_cast<cv::Mat*>(transVect), *reinterpret_cast<cv::Mat*>(rotMatrixX), *reinterpret_cast<cv::Mat*>(rotMatrixY), *reinterpret_cast<cv::Mat*>(rotMatrixZ), *reinterpret_cast<cv::Mat*>(eulerAngles));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_demosaicing_Mat_src_Mat_dst_int_code_int_dstCn
// parsed: cv::demosaicing
// as:     cv::demosaicing (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG Primitive(int) code= Primitive(int) = 
// Arg ARG Primitive(int) dstCn= Primitive(int) = 0
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_demosaicing_Mat_src_Mat_dst_int_code_int_dstCn(void* src, void* dst, int code, int dstCn) {
    try {
        cv::demosaicing(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst), code, dstCn);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_denoise_TVL1_VectorOfMat_observations_Mat_result_double_lambda_int_niters
// parsed: cv::denoise_TVL1
// as:     cv::denoise_TVL1 (function)
// Arg ARG Vector[cv::Mat (boxed)] observations= Vector[cv::Mat (boxed)] = 
// Arg ARG cv::Mat (boxed) result= cv::Mat (boxed) = 
// Arg ARG Primitive(double) lambda= Primitive(double) = 1.0
// Arg ARG Primitive(int) niters= Primitive(int) = 30
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_denoise_TVL1_VectorOfMat_observations_Mat_result_double_lambda_int_niters(void* observations, void* result, double lambda, int niters) {
    try {
        cv::denoise_TVL1(*reinterpret_cast<std::vector<cv::Mat>*>(observations), *reinterpret_cast<cv::Mat*>(result), lambda, niters);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_destroyAllWindows
// parsed: cv::destroyAllWindows
// as:     cv::destroyAllWindows (function)
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_destroyAllWindows() {
    try {
        cv::destroyAllWindows();
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_destroyWindow_String_winname
// parsed: cv::destroyWindow
// as:     cv::destroyWindow (function)
// Arg ARG string winname= string = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_destroyWindow_String_winname(const char* winname) {
    try {
        cv::destroyWindow(String(winname));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_detailEnhance_Mat_src_Mat_dst_float_sigma_s_float_sigma_r
// parsed: cv::detailEnhance
// as:     cv::detailEnhance (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG Primitive(float) sigma_s= Primitive(float) = 10
// Arg ARG Primitive(float) sigma_r= Primitive(float) = 0.15f
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_detailEnhance_Mat_src_Mat_dst_float_sigma_s_float_sigma_r(void* src, void* dst, float sigma_s, float sigma_r) {
    try {
        cv::detailEnhance(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst), sigma_s, sigma_r);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_detectQRCode_Mat_in_VectorOfPoint_points_double_eps_x_double_eps_y
// parsed: cv::detectQRCode
// as:     cv::detectQRCode (function)
// Arg ARG cv::Mat (boxed) in= cv::Mat (boxed) = 
// Arg ARG Vector[cv::Point (simple)] points= Vector[cv::Point (simple)] = 
// Arg ARG Primitive(double) eps_x= Primitive(double) = 0.2
// Arg ARG Primitive(double) eps_y= Primitive(double) = 0.1
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_detectQRCode_Mat_in_VectorOfPoint_points_double_eps_x_double_eps_y(void* in, void* points, double eps_x, double eps_y) {
    try {
        bool ret = cv::detectQRCode(*reinterpret_cast<cv::Mat*>(in), *reinterpret_cast<std::vector<cv::Point>*>(points), eps_x, eps_y);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_determinant_Mat_mtx
// parsed: cv::determinant
// as:     cv::determinant (function)
// Arg ARG cv::Mat (boxed) mtx= cv::Mat (boxed) = 
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_determinant_Mat_mtx(void* mtx) {
    try {
        double ret = cv::determinant(*reinterpret_cast<cv::Mat*>(mtx));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_dft_Mat_src_Mat_dst_int_flags_int_nonzeroRows
// parsed: cv::dft
// as:     cv::dft (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG Primitive(int) flags= Primitive(int) = 0
// Arg ARG Primitive(int) nonzeroRows= Primitive(int) = 0
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_dft_Mat_src_Mat_dst_int_flags_int_nonzeroRows(void* src, void* dst, int flags, int nonzeroRows) {
    try {
        cv::dft(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst), flags, nonzeroRows);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_dilate_Mat_src_Mat_dst_Mat_kernel_Point_anchor_int_iterations_int_borderType_Scalar_borderValue
// parsed: cv::dilate
// as:     cv::dilate (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) kernel= cv::Mat (boxed) = 
// Arg ARG cv::Point (simple) anchor= cv::Point (simple) = Point(-1,-1)
// Arg ARG Primitive(int) iterations= Primitive(int) = 1
// Arg ARG Primitive(int) borderType= Primitive(int) = BORDER_CONSTANT
// Arg ARG cv::Scalar (simple) borderValue= cv::Scalar (simple) = morphologyDefaultBorderValue()
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_dilate_Mat_src_Mat_dst_Mat_kernel_Point_anchor_int_iterations_int_borderType_Scalar_borderValue(void* src, void* dst, void* kernel, PointWrapper anchor, int iterations, int borderType, ScalarWrapper borderValue) {
    try {
        cv::dilate(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst), *reinterpret_cast<cv::Mat*>(kernel), *reinterpret_cast<cv::Point*>(&anchor), iterations, borderType, *reinterpret_cast<cv::Scalar*>(&borderValue));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_directx_getTypeFromD3DFORMAT_int_iD3DFORMAT
// parsed: cv::directx::getTypeFromD3DFORMAT
// as:     cv::directx::getTypeFromD3DFORMAT (function)
// Arg ARG Primitive(int) iD3DFORMAT= Primitive(int) = 
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_directx_getTypeFromD3DFORMAT_int_iD3DFORMAT(int iD3DFORMAT) {
    try {
        int ret = cv::directx::getTypeFromD3DFORMAT(iD3DFORMAT);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_directx_getTypeFromDXGI_FORMAT_int_iDXGI_FORMAT
// parsed: cv::directx::getTypeFromDXGI_FORMAT
// as:     cv::directx::getTypeFromDXGI_FORMAT (function)
// Arg ARG Primitive(int) iDXGI_FORMAT= Primitive(int) = 
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_directx_getTypeFromDXGI_FORMAT_int_iDXGI_FORMAT(int iDXGI_FORMAT) {
    try {
        int ret = cv::directx::getTypeFromDXGI_FORMAT(iDXGI_FORMAT);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_displayOverlay_String_winname_String_text_int_delayms
// parsed: cv::displayOverlay
// as:     cv::displayOverlay (function)
// Arg ARG string winname= string = 
// Arg ARG string text= string = 
// Arg ARG Primitive(int) delayms= Primitive(int) = 0
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_displayOverlay_String_winname_String_text_int_delayms(const char* winname, const char* text, int delayms) {
    try {
        cv::displayOverlay(String(winname), String(text), delayms);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_displayStatusBar_String_winname_String_text_int_delayms
// parsed: cv::displayStatusBar
// as:     cv::displayStatusBar (function)
// Arg ARG string winname= string = 
// Arg ARG string text= string = 
// Arg ARG Primitive(int) delayms= Primitive(int) = 0
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_displayStatusBar_String_winname_String_text_int_delayms(const char* winname, const char* text, int delayms) {
    try {
        cv::displayStatusBar(String(winname), String(text), delayms);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_distanceTransform_Mat_src_Mat_dst_Mat_labels_int_distanceType_int_maskSize_int_labelType
// parsed: cv::distanceTransform
// as:     cv::distanceTransform (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) labels= cv::Mat (boxed) = 
// Arg ARG Primitive(int) distanceType= Primitive(int) = 
// Arg ARG Primitive(int) maskSize= Primitive(int) = 
// Arg ARG Primitive(int) labelType= Primitive(int) = DIST_LABEL_CCOMP
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_distanceTransform_Mat_src_Mat_dst_Mat_labels_int_distanceType_int_maskSize_int_labelType(void* src, void* dst, void* labels, int distanceType, int maskSize, int labelType) {
    try {
        cv::distanceTransform(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst), *reinterpret_cast<cv::Mat*>(labels), distanceType, maskSize, labelType);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_distanceTransform_Mat_src_Mat_dst_int_distanceType_int_maskSize_int_dstType
// parsed: cv::distanceTransform
// as:     cv::distanceTransform (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG Primitive(int) distanceType= Primitive(int) = 
// Arg ARG Primitive(int) maskSize= Primitive(int) = 
// Arg ARG Primitive(int) dstType= Primitive(int) = CV_32F
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_distanceTransform_Mat_src_Mat_dst_int_distanceType_int_maskSize_int_dstType(void* src, void* dst, int distanceType, int maskSize, int dstType) {
    try {
        cv::distanceTransform(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst), distanceType, maskSize, dstType);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_divUp_int_a_unsigned_int_b
// parsed: cv::divUp
// as:     cv::divUp (function)
// Arg ARG Primitive(int) a= Primitive(int) = 
// Arg ARG Primitive(unsigned int) b= Primitive(unsigned int) = 
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_divUp_int_a_unsigned_int_b(int a, unsigned int b) {
    try {
        int ret = cv::divUp(a, b);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_divUp_size_t_a_unsigned_int_b
// parsed: cv::divUp
// as:     cv::divUp (function)
// Arg ARG Primitive(size_t) a= Primitive(size_t) = 
// Arg ARG Primitive(unsigned int) b= Primitive(unsigned int) = 
// Return value: Primitive(size_t)
cv_return_value_std_size_t cv_core_cv_divUp_size_t_a_unsigned_int_b(std::size_t a, unsigned int b) {
    try {
        size_t ret = cv::divUp(a, b);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<std::size_t*>(&ret) };
    } CVRS_CATCH(cv_return_value_std_size_t)
}

// cv_divide_Mat_src1_Mat_src2_Mat_dst_double_scale_int_dtype
// parsed: cv::divide
// as:     cv::divide (function)
// Arg ARG cv::Mat (boxed) src1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) src2= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG Primitive(double) scale= Primitive(double) = 1
// Arg ARG Primitive(int) dtype= Primitive(int) = -1
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_divide_Mat_src1_Mat_src2_Mat_dst_double_scale_int_dtype(void* src1, void* src2, void* dst, double scale, int dtype) {
    try {
        cv::divide(*reinterpret_cast<cv::Mat*>(src1), *reinterpret_cast<cv::Mat*>(src2), *reinterpret_cast<cv::Mat*>(dst), scale, dtype);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_divide_double_scale_Mat_src2_Mat_dst_int_dtype
// parsed: cv::divide
// as:     cv::divide (function)
// Arg ARG Primitive(double) scale= Primitive(double) = 
// Arg ARG cv::Mat (boxed) src2= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG Primitive(int) dtype= Primitive(int) = -1
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_divide_double_scale_Mat_src2_Mat_dst_int_dtype(double scale, void* src2, void* dst, int dtype) {
    try {
        cv::divide(scale, *reinterpret_cast<cv::Mat*>(src2), *reinterpret_cast<cv::Mat*>(dst), dtype);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_dnn_NMSBoxes_VectorOfRect2d_bboxes_VectorOffloat_scores_float_score_threshold_float_nms_threshold_VectorOfint_indices_float_eta_int_top_k
// parsed: cv::dnn::NMSBoxes
// as:     cv::dnn::NMSBoxes (function)
// Arg ARG Vector[cv::Rect2d (simple)] bboxes= Vector[cv::Rect2d (simple)] = 
// Arg ARG Vector[Primitive(float)] scores= Vector[Primitive(float)] = 
// Arg ARG Primitive(float) score_threshold= Primitive(float) = 
// Arg ARG Primitive(float) nms_threshold= Primitive(float) = 
// Arg ARG Vector[Primitive(int)] indices= Vector[Primitive(int)] = 
// Arg ARG Primitive(float) eta= Primitive(float) = 1.f
// Arg ARG Primitive(int) top_k= Primitive(int) = 0
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_dnn_NMSBoxes_VectorOfRect2d_bboxes_VectorOffloat_scores_float_score_threshold_float_nms_threshold_VectorOfint_indices_float_eta_int_top_k(void* bboxes, void* scores, float score_threshold, float nms_threshold, void* indices, float eta, int top_k) {
    try {
        cv::dnn::NMSBoxes(*reinterpret_cast<std::vector<cv::Rect2d>*>(bboxes), *reinterpret_cast<std::vector<float>*>(scores), score_threshold, nms_threshold, *reinterpret_cast<std::vector<int>*>(indices), eta, top_k);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_dnn_NMSBoxes_VectorOfRect_bboxes_VectorOffloat_scores_float_score_threshold_float_nms_threshold_VectorOfint_indices_float_eta_int_top_k
// parsed: cv::dnn::NMSBoxes
// as:     cv::dnn::NMSBoxes (function)
// Arg ARG Vector[cv::Rect (simple)] bboxes= Vector[cv::Rect (simple)] = 
// Arg ARG Vector[Primitive(float)] scores= Vector[Primitive(float)] = 
// Arg ARG Primitive(float) score_threshold= Primitive(float) = 
// Arg ARG Primitive(float) nms_threshold= Primitive(float) = 
// Arg ARG Vector[Primitive(int)] indices= Vector[Primitive(int)] = 
// Arg ARG Primitive(float) eta= Primitive(float) = 1.f
// Arg ARG Primitive(int) top_k= Primitive(int) = 0
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_dnn_NMSBoxes_VectorOfRect_bboxes_VectorOffloat_scores_float_score_threshold_float_nms_threshold_VectorOfint_indices_float_eta_int_top_k(void* bboxes, void* scores, float score_threshold, float nms_threshold, void* indices, float eta, int top_k) {
    try {
        cv::dnn::NMSBoxes(*reinterpret_cast<std::vector<cv::Rect>*>(bboxes), *reinterpret_cast<std::vector<float>*>(scores), score_threshold, nms_threshold, *reinterpret_cast<std::vector<int>*>(indices), eta, top_k);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_dnn_NMSBoxes_VectorOfRotatedRect_bboxes_VectorOffloat_scores_float_score_threshold_float_nms_threshold_VectorOfint_indices_float_eta_int_top_k
// parsed: cv::dnn::NMSBoxes
// as:     cv::dnn::NMSBoxes (function)
// Arg ARG Vector[cv::RotatedRect (boxed)] bboxes= Vector[cv::RotatedRect (boxed)] = 
// Arg ARG Vector[Primitive(float)] scores= Vector[Primitive(float)] = 
// Arg ARG Primitive(float) score_threshold= Primitive(float) = 
// Arg ARG Primitive(float) nms_threshold= Primitive(float) = 
// Arg ARG Vector[Primitive(int)] indices= Vector[Primitive(int)] = 
// Arg ARG Primitive(float) eta= Primitive(float) = 1.f
// Arg ARG Primitive(int) top_k= Primitive(int) = 0
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_dnn_NMSBoxes_VectorOfRotatedRect_bboxes_VectorOffloat_scores_float_score_threshold_float_nms_threshold_VectorOfint_indices_float_eta_int_top_k(void* bboxes, void* scores, float score_threshold, float nms_threshold, void* indices, float eta, int top_k) {
    try {
        cv::dnn::NMSBoxes(*reinterpret_cast<std::vector<cv::RotatedRect>*>(bboxes), *reinterpret_cast<std::vector<float>*>(scores), score_threshold, nms_threshold, *reinterpret_cast<std::vector<int>*>(indices), eta, top_k);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_dnn_blobFromImage_Mat_image_Mat_blob_double_scalefactor_Size_size_Scalar_mean_bool_swapRB_bool_crop_int_ddepth
// parsed: cv::dnn::blobFromImage
// as:     cv::dnn::blobFromImage (function)
// Arg ARG cv::Mat (boxed) image= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) blob= cv::Mat (boxed) = 
// Arg ARG Primitive(double) scalefactor= Primitive(double) = 1.0
// Arg ARG cv::Size (simple) size= cv::Size (simple) = Size()
// Arg ARG cv::Scalar (simple) mean= cv::Scalar (simple) = Scalar()
// Arg ARG Primitive(bool) swapRB= Primitive(bool) = false
// Arg ARG Primitive(bool) crop= Primitive(bool) = false
// Arg ARG Primitive(int) ddepth= Primitive(int) = CV_32F
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_dnn_blobFromImage_Mat_image_Mat_blob_double_scalefactor_Size_size_Scalar_mean_bool_swapRB_bool_crop_int_ddepth(void* image, void* blob, double scalefactor, SizeWrapper size, ScalarWrapper mean, bool swapRB, bool crop, int ddepth) {
    try {
        cv::dnn::blobFromImage(*reinterpret_cast<cv::Mat*>(image), *reinterpret_cast<cv::Mat*>(blob), scalefactor, *reinterpret_cast<cv::Size*>(&size), *reinterpret_cast<cv::Scalar*>(&mean), swapRB, crop, ddepth);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_dnn_blobFromImage_Mat_image_double_scalefactor_Size_size_Scalar_mean_bool_swapRB_bool_crop_int_ddepth
// parsed: cv::dnn::blobFromImage
// as:     cv::dnn::blobFromImage (function)
// Arg ARG cv::Mat (boxed) image= cv::Mat (boxed) = 
// Arg ARG Primitive(double) scalefactor= Primitive(double) = 1.0
// Arg ARG cv::Size (simple) size= cv::Size (simple) = Size()
// Arg ARG cv::Scalar (simple) mean= cv::Scalar (simple) = Scalar()
// Arg ARG Primitive(bool) swapRB= Primitive(bool) = false
// Arg ARG Primitive(bool) crop= Primitive(bool) = false
// Arg ARG Primitive(int) ddepth= Primitive(int) = CV_32F
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_dnn_blobFromImage_Mat_image_double_scalefactor_Size_size_Scalar_mean_bool_swapRB_bool_crop_int_ddepth(void* image, double scalefactor, SizeWrapper size, ScalarWrapper mean, bool swapRB, bool crop, int ddepth) {
    try {
        cv::Mat ret = cv::dnn::blobFromImage(*reinterpret_cast<cv::Mat*>(image), scalefactor, *reinterpret_cast<cv::Size*>(&size), *reinterpret_cast<cv::Scalar*>(&mean), swapRB, crop, ddepth);
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_dnn_blobFromImages_VectorOfMat_images_Mat_blob_double_scalefactor_Size_size_Scalar_mean_bool_swapRB_bool_crop_int_ddepth
// parsed: cv::dnn::blobFromImages
// as:     cv::dnn::blobFromImages (function)
// Arg ARG Vector[cv::Mat (boxed)] images= Vector[cv::Mat (boxed)] = 
// Arg ARG cv::Mat (boxed) blob= cv::Mat (boxed) = 
// Arg ARG Primitive(double) scalefactor= Primitive(double) = 1.0
// Arg ARG cv::Size (simple) size= cv::Size (simple) = Size()
// Arg ARG cv::Scalar (simple) mean= cv::Scalar (simple) = Scalar()
// Arg ARG Primitive(bool) swapRB= Primitive(bool) = false
// Arg ARG Primitive(bool) crop= Primitive(bool) = false
// Arg ARG Primitive(int) ddepth= Primitive(int) = CV_32F
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_dnn_blobFromImages_VectorOfMat_images_Mat_blob_double_scalefactor_Size_size_Scalar_mean_bool_swapRB_bool_crop_int_ddepth(void* images, void* blob, double scalefactor, SizeWrapper size, ScalarWrapper mean, bool swapRB, bool crop, int ddepth) {
    try {
        cv::dnn::blobFromImages(*reinterpret_cast<std::vector<cv::Mat>*>(images), *reinterpret_cast<cv::Mat*>(blob), scalefactor, *reinterpret_cast<cv::Size*>(&size), *reinterpret_cast<cv::Scalar*>(&mean), swapRB, crop, ddepth);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_dnn_blobFromImages_VectorOfMat_images_double_scalefactor_Size_size_Scalar_mean_bool_swapRB_bool_crop_int_ddepth
// parsed: cv::dnn::blobFromImages
// as:     cv::dnn::blobFromImages (function)
// Arg ARG Vector[cv::Mat (boxed)] images= Vector[cv::Mat (boxed)] = 
// Arg ARG Primitive(double) scalefactor= Primitive(double) = 1.0
// Arg ARG cv::Size (simple) size= cv::Size (simple) = Size()
// Arg ARG cv::Scalar (simple) mean= cv::Scalar (simple) = Scalar()
// Arg ARG Primitive(bool) swapRB= Primitive(bool) = false
// Arg ARG Primitive(bool) crop= Primitive(bool) = false
// Arg ARG Primitive(int) ddepth= Primitive(int) = CV_32F
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_dnn_blobFromImages_VectorOfMat_images_double_scalefactor_Size_size_Scalar_mean_bool_swapRB_bool_crop_int_ddepth(void* images, double scalefactor, SizeWrapper size, ScalarWrapper mean, bool swapRB, bool crop, int ddepth) {
    try {
        cv::Mat ret = cv::dnn::blobFromImages(*reinterpret_cast<std::vector<cv::Mat>*>(images), scalefactor, *reinterpret_cast<cv::Size*>(&size), *reinterpret_cast<cv::Scalar*>(&mean), swapRB, crop, ddepth);
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_dnn_clamp_Range_r_int_axisSize
// parsed: cv::dnn::clamp
// as:     cv::dnn::clamp (function)
// Arg ARG cv::Range (boxed) r= cv::Range (boxed) = 
// Arg ARG Primitive(int) axisSize= Primitive(int) = 
// Return value: cv::Range (boxed)
cv_return_value_void_X cv_core_cv_dnn_clamp_Range_r_int_axisSize(void* r, int axisSize) {
    try {
        cv::Range ret = cv::dnn::clamp(*reinterpret_cast<cv::Range*>(r), axisSize);
        return { Error::Code::StsOk, NULL, new cv::Range(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_dnn_clamp_int_ax_int_dims
// parsed: cv::dnn::clamp
// as:     cv::dnn::clamp (function)
// Arg ARG Primitive(int) ax= Primitive(int) = 
// Arg ARG Primitive(int) dims= Primitive(int) = 
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_dnn_clamp_int_ax_int_dims(int ax, int dims) {
    try {
        int ret = cv::dnn::clamp(ax, dims);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_dnn_getPlane_Mat_m_int_n_int_cn
// parsed: cv::dnn::getPlane
// as:     cv::dnn::getPlane (function)
// Arg ARG cv::Mat (boxed) m= cv::Mat (boxed) = 
// Arg ARG Primitive(int) n= Primitive(int) = 
// Arg ARG Primitive(int) cn= Primitive(int) = 
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_dnn_getPlane_Mat_m_int_n_int_cn(void* m, int n, int cn) {
    try {
        cv::Mat ret = cv::dnn::getPlane(*reinterpret_cast<cv::Mat*>(m), n, cn);
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_dnn_imagesFromBlob_Mat_blob__VectorOfMat_images_
// parsed: cv::dnn::imagesFromBlob
// as:     cv::dnn::imagesFromBlob (function)
// Arg ARG cv::Mat (boxed) blob_= cv::Mat (boxed) = 
// Arg ARG Vector[cv::Mat (boxed)] images_= Vector[cv::Mat (boxed)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_dnn_imagesFromBlob_Mat_blob__VectorOfMat_images_(void* blob_, void** images_) {
    try {
        cv::dnn::imagesFromBlob(*reinterpret_cast<cv::Mat*>(blob_), *reinterpret_cast<std::vector<cv::Mat>*>(images_));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_dnn_readNetFromCaffe_String_prototxt_String_caffeModel
// parsed: cv::dnn::readNetFromCaffe
// as:     cv::dnn::readNetFromCaffe (function)
// Arg ARG string prototxt= string = 
// Arg ARG string caffeModel= string = String()
// Return value: cv::dnn::Net (simple)
cv_return_value_Net cv_core_cv_dnn_readNetFromCaffe_String_prototxt_String_caffeModel(const char* prototxt, const char* caffeModel) {
    try {
        cv::dnn::Net ret = cv::dnn::readNetFromCaffe(String(prototxt), String(caffeModel));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<cv::dnn::Net*>(&ret) };
    } CVRS_CATCH(cv_return_value_Net)
}

// cv_dnn_readNetFromCaffe_VectorOfuchar_bufferProto_VectorOfuchar_bufferModel
// parsed: cv::dnn::readNetFromCaffe
// as:     cv::dnn::readNetFromCaffe (function)
// Arg ARG Vector[Primitive(uchar)] bufferProto= Vector[Primitive(uchar)] = 
// Arg ARG Vector[Primitive(uchar)] bufferModel= Vector[Primitive(uchar)] = std::vector<uchar>()
// Return value: cv::dnn::Net (simple)
cv_return_value_Net cv_core_cv_dnn_readNetFromCaffe_VectorOfuchar_bufferProto_VectorOfuchar_bufferModel(void* bufferProto, void* bufferModel) {
    try {
        cv::dnn::Net ret = cv::dnn::readNetFromCaffe(*reinterpret_cast<std::vector<uchar>*>(bufferProto), *reinterpret_cast<std::vector<uchar>*>(bufferModel));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<cv::dnn::Net*>(&ret) };
    } CVRS_CATCH(cv_return_value_Net)
}

// cv_dnn_readNetFromCaffe_const_char_X_bufferProto_size_t_lenProto_const_char_X_bufferModel_size_t_lenModel
// parsed: cv::dnn::readNetFromCaffe
// as:     cv::dnn::readNetFromCaffe (function)
// Arg ARG RawPtr[Primitive(char)] * bufferProto= (ptr) RawPtr[Primitive(char)] = 
// Arg ARG Primitive(size_t) lenProto= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(char)] * bufferModel= (ptr) RawPtr[Primitive(char)] = NULL
// Arg ARG Primitive(size_t) lenModel= Primitive(size_t) = 0
// Return value: cv::dnn::Net (simple)
cv_return_value_Net cv_core_cv_dnn_readNetFromCaffe_const_char_X_bufferProto_size_t_lenProto_const_char_X_bufferModel_size_t_lenModel(const char* bufferProto, std::size_t lenProto, const char* bufferModel, std::size_t lenModel) {
    try {
        cv::dnn::Net ret = cv::dnn::readNetFromCaffe(bufferProto, lenProto, bufferModel, lenModel);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<cv::dnn::Net*>(&ret) };
    } CVRS_CATCH(cv_return_value_Net)
}

// cv_dnn_readNetFromDarknet_String_cfgFile_String_darknetModel
// parsed: cv::dnn::readNetFromDarknet
// as:     cv::dnn::readNetFromDarknet (function)
// Arg ARG string cfgFile= string = 
// Arg ARG string darknetModel= string = String()
// Return value: cv::dnn::Net (simple)
cv_return_value_Net cv_core_cv_dnn_readNetFromDarknet_String_cfgFile_String_darknetModel(const char* cfgFile, const char* darknetModel) {
    try {
        cv::dnn::Net ret = cv::dnn::readNetFromDarknet(String(cfgFile), String(darknetModel));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<cv::dnn::Net*>(&ret) };
    } CVRS_CATCH(cv_return_value_Net)
}

// cv_dnn_readNetFromDarknet_VectorOfuchar_bufferCfg_VectorOfuchar_bufferModel
// parsed: cv::dnn::readNetFromDarknet
// as:     cv::dnn::readNetFromDarknet (function)
// Arg ARG Vector[Primitive(uchar)] bufferCfg= Vector[Primitive(uchar)] = 
// Arg ARG Vector[Primitive(uchar)] bufferModel= Vector[Primitive(uchar)] = std::vector<uchar>()
// Return value: cv::dnn::Net (simple)
cv_return_value_Net cv_core_cv_dnn_readNetFromDarknet_VectorOfuchar_bufferCfg_VectorOfuchar_bufferModel(void* bufferCfg, void* bufferModel) {
    try {
        cv::dnn::Net ret = cv::dnn::readNetFromDarknet(*reinterpret_cast<std::vector<uchar>*>(bufferCfg), *reinterpret_cast<std::vector<uchar>*>(bufferModel));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<cv::dnn::Net*>(&ret) };
    } CVRS_CATCH(cv_return_value_Net)
}

// cv_dnn_readNetFromDarknet_const_char_X_bufferCfg_size_t_lenCfg_const_char_X_bufferModel_size_t_lenModel
// parsed: cv::dnn::readNetFromDarknet
// as:     cv::dnn::readNetFromDarknet (function)
// Arg ARG RawPtr[Primitive(char)] * bufferCfg= (ptr) RawPtr[Primitive(char)] = 
// Arg ARG Primitive(size_t) lenCfg= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(char)] * bufferModel= (ptr) RawPtr[Primitive(char)] = NULL
// Arg ARG Primitive(size_t) lenModel= Primitive(size_t) = 0
// Return value: cv::dnn::Net (simple)
cv_return_value_Net cv_core_cv_dnn_readNetFromDarknet_const_char_X_bufferCfg_size_t_lenCfg_const_char_X_bufferModel_size_t_lenModel(const char* bufferCfg, std::size_t lenCfg, const char* bufferModel, std::size_t lenModel) {
    try {
        cv::dnn::Net ret = cv::dnn::readNetFromDarknet(bufferCfg, lenCfg, bufferModel, lenModel);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<cv::dnn::Net*>(&ret) };
    } CVRS_CATCH(cv_return_value_Net)
}

// cv_dnn_readNetFromModelOptimizer_String_xml_String_bin
// parsed: cv::dnn::readNetFromModelOptimizer
// as:     cv::dnn::readNetFromModelOptimizer (function)
// Arg ARG string xml= string = 
// Arg ARG string bin= string = 
// Return value: cv::dnn::Net (simple)
cv_return_value_Net cv_core_cv_dnn_readNetFromModelOptimizer_String_xml_String_bin(const char* xml, const char* bin) {
    try {
        cv::dnn::Net ret = cv::dnn::readNetFromModelOptimizer(String(xml), String(bin));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<cv::dnn::Net*>(&ret) };
    } CVRS_CATCH(cv_return_value_Net)
}

// cv_dnn_readNetFromONNX_String_onnxFile
// parsed: cv::dnn::readNetFromONNX
// as:     cv::dnn::readNetFromONNX (function)
// Arg ARG string onnxFile= string = 
// Return value: cv::dnn::Net (simple)
cv_return_value_Net cv_core_cv_dnn_readNetFromONNX_String_onnxFile(const char* onnxFile) {
    try {
        cv::dnn::Net ret = cv::dnn::readNetFromONNX(String(onnxFile));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<cv::dnn::Net*>(&ret) };
    } CVRS_CATCH(cv_return_value_Net)
}

// cv_dnn_readNetFromTensorflow_String_model_String_config
// parsed: cv::dnn::readNetFromTensorflow
// as:     cv::dnn::readNetFromTensorflow (function)
// Arg ARG string model= string = 
// Arg ARG string config= string = String()
// Return value: cv::dnn::Net (simple)
cv_return_value_Net cv_core_cv_dnn_readNetFromTensorflow_String_model_String_config(const char* model, const char* config) {
    try {
        cv::dnn::Net ret = cv::dnn::readNetFromTensorflow(String(model), String(config));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<cv::dnn::Net*>(&ret) };
    } CVRS_CATCH(cv_return_value_Net)
}

// cv_dnn_readNetFromTensorflow_VectorOfuchar_bufferModel_VectorOfuchar_bufferConfig
// parsed: cv::dnn::readNetFromTensorflow
// as:     cv::dnn::readNetFromTensorflow (function)
// Arg ARG Vector[Primitive(uchar)] bufferModel= Vector[Primitive(uchar)] = 
// Arg ARG Vector[Primitive(uchar)] bufferConfig= Vector[Primitive(uchar)] = std::vector<uchar>()
// Return value: cv::dnn::Net (simple)
cv_return_value_Net cv_core_cv_dnn_readNetFromTensorflow_VectorOfuchar_bufferModel_VectorOfuchar_bufferConfig(void* bufferModel, void* bufferConfig) {
    try {
        cv::dnn::Net ret = cv::dnn::readNetFromTensorflow(*reinterpret_cast<std::vector<uchar>*>(bufferModel), *reinterpret_cast<std::vector<uchar>*>(bufferConfig));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<cv::dnn::Net*>(&ret) };
    } CVRS_CATCH(cv_return_value_Net)
}

// cv_dnn_readNetFromTensorflow_const_char_X_bufferModel_size_t_lenModel_const_char_X_bufferConfig_size_t_lenConfig
// parsed: cv::dnn::readNetFromTensorflow
// as:     cv::dnn::readNetFromTensorflow (function)
// Arg ARG RawPtr[Primitive(char)] * bufferModel= (ptr) RawPtr[Primitive(char)] = 
// Arg ARG Primitive(size_t) lenModel= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(char)] * bufferConfig= (ptr) RawPtr[Primitive(char)] = NULL
// Arg ARG Primitive(size_t) lenConfig= Primitive(size_t) = 0
// Return value: cv::dnn::Net (simple)
cv_return_value_Net cv_core_cv_dnn_readNetFromTensorflow_const_char_X_bufferModel_size_t_lenModel_const_char_X_bufferConfig_size_t_lenConfig(const char* bufferModel, std::size_t lenModel, const char* bufferConfig, std::size_t lenConfig) {
    try {
        cv::dnn::Net ret = cv::dnn::readNetFromTensorflow(bufferModel, lenModel, bufferConfig, lenConfig);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<cv::dnn::Net*>(&ret) };
    } CVRS_CATCH(cv_return_value_Net)
}

// cv_dnn_readNetFromTorch_String_model_bool_isBinary_bool_evaluate
// parsed: cv::dnn::readNetFromTorch
// as:     cv::dnn::readNetFromTorch (function)
// Arg ARG string model= string = 
// Arg ARG Primitive(bool) isBinary= Primitive(bool) = true
// Arg ARG Primitive(bool) evaluate= Primitive(bool) = true
// Return value: cv::dnn::Net (simple)
cv_return_value_Net cv_core_cv_dnn_readNetFromTorch_String_model_bool_isBinary_bool_evaluate(const char* model, bool isBinary, bool evaluate) {
    try {
        cv::dnn::Net ret = cv::dnn::readNetFromTorch(String(model), isBinary, evaluate);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<cv::dnn::Net*>(&ret) };
    } CVRS_CATCH(cv_return_value_Net)
}

// cv_dnn_readNet_String_framework_VectorOfuchar_bufferModel_VectorOfuchar_bufferConfig
// parsed: cv::dnn::readNet
// as:     cv::dnn::readNet (function)
// Arg ARG string framework= string = 
// Arg ARG Vector[Primitive(uchar)] bufferModel= Vector[Primitive(uchar)] = 
// Arg ARG Vector[Primitive(uchar)] bufferConfig= Vector[Primitive(uchar)] = std::vector<uchar>()
// Return value: cv::dnn::Net (simple)
cv_return_value_Net cv_core_cv_dnn_readNet_String_framework_VectorOfuchar_bufferModel_VectorOfuchar_bufferConfig(const char* framework, void* bufferModel, void* bufferConfig) {
    try {
        cv::dnn::Net ret = cv::dnn::readNet(String(framework), *reinterpret_cast<std::vector<uchar>*>(bufferModel), *reinterpret_cast<std::vector<uchar>*>(bufferConfig));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<cv::dnn::Net*>(&ret) };
    } CVRS_CATCH(cv_return_value_Net)
}

// cv_dnn_readNet_String_model_String_config_String_framework
// parsed: cv::dnn::readNet
// as:     cv::dnn::readNet (function)
// Arg ARG string model= string = 
// Arg ARG string config= string = ""
// Arg ARG string framework= string = ""
// Return value: cv::dnn::Net (simple)
cv_return_value_Net cv_core_cv_dnn_readNet_String_model_String_config_String_framework(const char* model, const char* config, const char* framework) {
    try {
        cv::dnn::Net ret = cv::dnn::readNet(String(model), String(config), String(framework));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<cv::dnn::Net*>(&ret) };
    } CVRS_CATCH(cv_return_value_Net)
}

// cv_dnn_readTensorFromONNX_String_path
// parsed: cv::dnn::readTensorFromONNX
// as:     cv::dnn::readTensorFromONNX (function)
// Arg ARG string path= string = 
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_dnn_readTensorFromONNX_String_path(const char* path) {
    try {
        cv::Mat ret = cv::dnn::readTensorFromONNX(String(path));
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_dnn_readTorchBlob_String_filename_bool_isBinary
// parsed: cv::dnn::readTorchBlob
// as:     cv::dnn::readTorchBlob (function)
// Arg ARG string filename= string = 
// Arg ARG Primitive(bool) isBinary= Primitive(bool) = true
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_dnn_readTorchBlob_String_filename_bool_isBinary(const char* filename, bool isBinary) {
    try {
        cv::Mat ret = cv::dnn::readTorchBlob(String(filename), isBinary);
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_dnn_resetMyriadDevice
// parsed: cv::dnn::resetMyriadDevice
// as:     cv::dnn::resetMyriadDevice (function)
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_dnn_resetMyriadDevice() {
    try {
        cv::dnn::resetMyriadDevice();
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_dnn_shape_MatSize_sz
// parsed: cv::dnn::shape
// as:     cv::dnn::shape (function)
// Arg ARG cv::MatSize (boxed) sz= cv::MatSize (boxed) = 
// Return value: Vector[Primitive(int)]
cv_return_value_void_X cv_core_cv_dnn_shape_MatSize_sz(void* sz) {
    try {
        std::vector<int> ret = cv::dnn::shape(*reinterpret_cast<cv::MatSize*>(sz));
        return { Error::Code::StsOk, NULL, (void *)new std::vector<int>(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_dnn_shape_Mat_mat
// parsed: cv::dnn::shape
// as:     cv::dnn::shape (function)
// Arg ARG cv::Mat (boxed) mat= cv::Mat (boxed) = 
// Return value: Vector[Primitive(int)]
cv_return_value_void_X cv_core_cv_dnn_shape_Mat_mat(void* mat) {
    try {
        std::vector<int> ret = cv::dnn::shape(*reinterpret_cast<cv::Mat*>(mat));
        return { Error::Code::StsOk, NULL, (void *)new std::vector<int>(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_dnn_shape_const_int_X_dims_int_n
// parsed: cv::dnn::shape
// as:     cv::dnn::shape (function)
// Arg ARG RawPtr[Primitive(int)] * dims= (ptr) RawPtr[Primitive(int)] = 
// Arg ARG Primitive(int) n= Primitive(int) = 
// Return value: Vector[Primitive(int)]
cv_return_value_void_X cv_core_cv_dnn_shape_const_int_X_dims_int_n(const int* dims, int n) {
    try {
        std::vector<int> ret = cv::dnn::shape(dims, n);
        return { Error::Code::StsOk, NULL, (void *)new std::vector<int>(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_dnn_shape_int_a0_int_a1_int_a2_int_a3
// parsed: cv::dnn::shape
// as:     cv::dnn::shape (function)
// Arg ARG Primitive(int) a0= Primitive(int) = 
// Arg ARG Primitive(int) a1= Primitive(int) = -1
// Arg ARG Primitive(int) a2= Primitive(int) = -1
// Arg ARG Primitive(int) a3= Primitive(int) = -1
// Return value: Vector[Primitive(int)]
cv_return_value_void_X cv_core_cv_dnn_shape_int_a0_int_a1_int_a2_int_a3(int a0, int a1, int a2, int a3) {
    try {
        std::vector<int> ret = cv::dnn::shape(a0, a1, a2, a3);
        return { Error::Code::StsOk, NULL, (void *)new std::vector<int>(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_dnn_shrinkCaffeModel_String_src_String_dst_VectorOfString_layersTypes
// parsed: cv::dnn::shrinkCaffeModel
// as:     cv::dnn::shrinkCaffeModel (function)
// Arg ARG string src= string = 
// Arg ARG string dst= string = 
// Arg ARG Vector[string] layersTypes= Vector[string] = std::vector<String>()
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_dnn_shrinkCaffeModel_String_src_String_dst_VectorOfString_layersTypes(const char* src, const char* dst, void* layersTypes) {
    try {
        cv::dnn::shrinkCaffeModel(String(src), String(dst), *reinterpret_cast<std::vector<String>*>(layersTypes));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_dnn_slice_Mat_m_Range_r0
// parsed: cv::dnn::slice
// as:     cv::dnn::slice (function)
// Arg ARG cv::Mat (boxed) m= cv::Mat (boxed) = 
// Arg ARG cv::Range (boxed) r0= cv::Range (boxed) = 
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_dnn_slice_Mat_m_Range_r0(void* m, void* r0) {
    try {
        cv::Mat ret = cv::dnn::slice(*reinterpret_cast<cv::Mat*>(m), *reinterpret_cast<cv::Range*>(r0));
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_dnn_slice_Mat_m_Range_r0_Range_r1
// parsed: cv::dnn::slice
// as:     cv::dnn::slice (function)
// Arg ARG cv::Mat (boxed) m= cv::Mat (boxed) = 
// Arg ARG cv::Range (boxed) r0= cv::Range (boxed) = 
// Arg ARG cv::Range (boxed) r1= cv::Range (boxed) = 
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_dnn_slice_Mat_m_Range_r0_Range_r1(void* m, void* r0, void* r1) {
    try {
        cv::Mat ret = cv::dnn::slice(*reinterpret_cast<cv::Mat*>(m), *reinterpret_cast<cv::Range*>(r0), *reinterpret_cast<cv::Range*>(r1));
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_dnn_slice_Mat_m_Range_r0_Range_r1_Range_r2
// parsed: cv::dnn::slice
// as:     cv::dnn::slice (function)
// Arg ARG cv::Mat (boxed) m= cv::Mat (boxed) = 
// Arg ARG cv::Range (boxed) r0= cv::Range (boxed) = 
// Arg ARG cv::Range (boxed) r1= cv::Range (boxed) = 
// Arg ARG cv::Range (boxed) r2= cv::Range (boxed) = 
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_dnn_slice_Mat_m_Range_r0_Range_r1_Range_r2(void* m, void* r0, void* r1, void* r2) {
    try {
        cv::Mat ret = cv::dnn::slice(*reinterpret_cast<cv::Mat*>(m), *reinterpret_cast<cv::Range*>(r0), *reinterpret_cast<cv::Range*>(r1), *reinterpret_cast<cv::Range*>(r2));
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_dnn_slice_Mat_m_Range_r0_Range_r1_Range_r2_Range_r3
// parsed: cv::dnn::slice
// as:     cv::dnn::slice (function)
// Arg ARG cv::Mat (boxed) m= cv::Mat (boxed) = 
// Arg ARG cv::Range (boxed) r0= cv::Range (boxed) = 
// Arg ARG cv::Range (boxed) r1= cv::Range (boxed) = 
// Arg ARG cv::Range (boxed) r2= cv::Range (boxed) = 
// Arg ARG cv::Range (boxed) r3= cv::Range (boxed) = 
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_dnn_slice_Mat_m_Range_r0_Range_r1_Range_r2_Range_r3(void* m, void* r0, void* r1, void* r2, void* r3) {
    try {
        cv::Mat ret = cv::dnn::slice(*reinterpret_cast<cv::Mat*>(m), *reinterpret_cast<cv::Range*>(r0), *reinterpret_cast<cv::Range*>(r1), *reinterpret_cast<cv::Range*>(r2), *reinterpret_cast<cv::Range*>(r3));
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_dnn_writeTextGraph_String_model_String_output
// parsed: cv::dnn::writeTextGraph
// as:     cv::dnn::writeTextGraph (function)
// Arg ARG string model= string = 
// Arg ARG string output= string = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_dnn_writeTextGraph_String_model_String_output(const char* model, const char* output) {
    try {
        cv::dnn::writeTextGraph(String(model), String(output));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_drawChessboardCorners_Mat_image_Size_patternSize_Mat_corners_bool_patternWasFound
// parsed: cv::drawChessboardCorners
// as:     cv::drawChessboardCorners (function)
// Arg ARG cv::Mat (boxed) image= cv::Mat (boxed) = 
// Arg ARG cv::Size (simple) patternSize= cv::Size (simple) = 
// Arg ARG cv::Mat (boxed) corners= cv::Mat (boxed) = 
// Arg ARG Primitive(bool) patternWasFound= Primitive(bool) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_drawChessboardCorners_Mat_image_Size_patternSize_Mat_corners_bool_patternWasFound(void* image, SizeWrapper patternSize, void* corners, bool patternWasFound) {
    try {
        cv::drawChessboardCorners(*reinterpret_cast<cv::Mat*>(image), *reinterpret_cast<cv::Size*>(&patternSize), *reinterpret_cast<cv::Mat*>(corners), patternWasFound);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_drawContours_Mat_image_VectorOfMat_contours_int_contourIdx_Scalar_color_int_thickness_int_lineType_Mat_hierarchy_int_maxLevel_Point_offset
// parsed: cv::drawContours
// as:     cv::drawContours (function)
// Arg ARG cv::Mat (boxed) image= cv::Mat (boxed) = 
// Arg ARG Vector[cv::Mat (boxed)] contours= Vector[cv::Mat (boxed)] = 
// Arg ARG Primitive(int) contourIdx= Primitive(int) = 
// Arg ARG cv::Scalar (simple) color= cv::Scalar (simple) = 
// Arg ARG Primitive(int) thickness= Primitive(int) = 1
// Arg ARG Primitive(int) lineType= Primitive(int) = LINE_8
// Arg ARG cv::Mat (boxed) hierarchy= cv::Mat (boxed) = noArray()
// Arg ARG Primitive(int) maxLevel= Primitive(int) = INT_MAX
// Arg ARG cv::Point (simple) offset= cv::Point (simple) = Point()
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_drawContours_Mat_image_VectorOfMat_contours_int_contourIdx_Scalar_color_int_thickness_int_lineType_Mat_hierarchy_int_maxLevel_Point_offset(void* image, void* contours, int contourIdx, ScalarWrapper color, int thickness, int lineType, void* hierarchy, int maxLevel, PointWrapper offset) {
    try {
        cv::drawContours(*reinterpret_cast<cv::Mat*>(image), *reinterpret_cast<std::vector<cv::Mat>*>(contours), contourIdx, *reinterpret_cast<cv::Scalar*>(&color), thickness, lineType, *reinterpret_cast<cv::Mat*>(hierarchy), maxLevel, *reinterpret_cast<cv::Point*>(&offset));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_drawFrameAxes_Mat_image_Mat_cameraMatrix_Mat_distCoeffs_Mat_rvec_Mat_tvec_float_length_int_thickness
// parsed: cv::drawFrameAxes
// as:     cv::drawFrameAxes (function)
// Arg ARG cv::Mat (boxed) image= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) cameraMatrix= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) distCoeffs= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) rvec= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) tvec= cv::Mat (boxed) = 
// Arg ARG Primitive(float) length= Primitive(float) = 
// Arg ARG Primitive(int) thickness= Primitive(int) = 3
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_drawFrameAxes_Mat_image_Mat_cameraMatrix_Mat_distCoeffs_Mat_rvec_Mat_tvec_float_length_int_thickness(void* image, void* cameraMatrix, void* distCoeffs, void* rvec, void* tvec, float length, int thickness) {
    try {
        cv::drawFrameAxes(*reinterpret_cast<cv::Mat*>(image), *reinterpret_cast<cv::Mat*>(cameraMatrix), *reinterpret_cast<cv::Mat*>(distCoeffs), *reinterpret_cast<cv::Mat*>(rvec), *reinterpret_cast<cv::Mat*>(tvec), length, thickness);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_drawKeypoints_Mat_image_VectorOfKeyPoint_keypoints_Mat_outImage_Scalar_color_int_flags
// parsed: cv::drawKeypoints
// as:     cv::drawKeypoints (function)
// Arg ARG cv::Mat (boxed) image= cv::Mat (boxed) = 
// Arg ARG Vector[cv::KeyPoint (simple)] keypoints= Vector[cv::KeyPoint (simple)] = 
// Arg ARG cv::Mat (boxed) outImage= cv::Mat (boxed) = 
// Arg ARG cv::Scalar (simple) color= cv::Scalar (simple) = Scalar::all(-1)
// Arg ARG Primitive(int) flags= Primitive(int) = DrawMatchesFlags::DEFAULT
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_drawKeypoints_Mat_image_VectorOfKeyPoint_keypoints_Mat_outImage_Scalar_color_int_flags(void* image, void* keypoints, void* outImage, ScalarWrapper color, int flags) {
    try {
        cv::drawKeypoints(*reinterpret_cast<cv::Mat*>(image), *reinterpret_cast<std::vector<cv::KeyPoint>*>(keypoints), *reinterpret_cast<cv::Mat*>(outImage), *reinterpret_cast<cv::Scalar*>(&color), flags);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_drawMarker_Mat_img_Point_position_Scalar_color_int_markerType_int_markerSize_int_thickness_int_line_type
// parsed: cv::drawMarker
// as:     cv::drawMarker (function)
// Arg ARG cv::Mat (boxed) img= cv::Mat (boxed) = 
// Arg ARG cv::Point (simple) position= cv::Point (simple) = 
// Arg ARG cv::Scalar (simple) color= cv::Scalar (simple) = 
// Arg ARG Primitive(int) markerType= Primitive(int) = MARKER_CROSS
// Arg ARG Primitive(int) markerSize= Primitive(int) = 20
// Arg ARG Primitive(int) thickness= Primitive(int) = 1
// Arg ARG Primitive(int) line_type= Primitive(int) = 8
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_drawMarker_Mat_img_Point_position_Scalar_color_int_markerType_int_markerSize_int_thickness_int_line_type(void* img, PointWrapper position, ScalarWrapper color, int markerType, int markerSize, int thickness, int line_type) {
    try {
        cv::drawMarker(*reinterpret_cast<cv::Mat*>(img), *reinterpret_cast<cv::Point*>(&position), *reinterpret_cast<cv::Scalar*>(&color), markerType, markerSize, thickness, line_type);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_drawMatches_Mat_img1_VectorOfKeyPoint_keypoints1_Mat_img2_VectorOfKeyPoint_keypoints2_VectorOfDMatch_matches1to2_Mat_outImg_Scalar_matchColor_Scalar_singlePointColor_VectorOfchar_matchesMask_int_flags
// parsed: cv::drawMatches
// as:     cv::drawMatches (function)
// Arg ARG cv::Mat (boxed) img1= cv::Mat (boxed) = 
// Arg ARG Vector[cv::KeyPoint (simple)] keypoints1= Vector[cv::KeyPoint (simple)] = 
// Arg ARG cv::Mat (boxed) img2= cv::Mat (boxed) = 
// Arg ARG Vector[cv::KeyPoint (simple)] keypoints2= Vector[cv::KeyPoint (simple)] = 
// Arg ARG Vector[cv::DMatch (simple)] matches1to2= Vector[cv::DMatch (simple)] = 
// Arg ARG cv::Mat (boxed) outImg= cv::Mat (boxed) = 
// Arg ARG cv::Scalar (simple) matchColor= cv::Scalar (simple) = Scalar::all(-1)
// Arg ARG cv::Scalar (simple) singlePointColor= cv::Scalar (simple) = Scalar::all(-1)
// Arg ARG Vector[Primitive(char)] matchesMask= Vector[Primitive(char)] = std::vector<char>()
// Arg ARG Primitive(int) flags= Primitive(int) = DrawMatchesFlags::DEFAULT
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_drawMatches_Mat_img1_VectorOfKeyPoint_keypoints1_Mat_img2_VectorOfKeyPoint_keypoints2_VectorOfDMatch_matches1to2_Mat_outImg_Scalar_matchColor_Scalar_singlePointColor_VectorOfchar_matchesMask_int_flags(void* img1, void* keypoints1, void* img2, void* keypoints2, void* matches1to2, void* outImg, ScalarWrapper matchColor, ScalarWrapper singlePointColor, void* matchesMask, int flags) {
    try {
        cv::drawMatches(*reinterpret_cast<cv::Mat*>(img1), *reinterpret_cast<std::vector<cv::KeyPoint>*>(keypoints1), *reinterpret_cast<cv::Mat*>(img2), *reinterpret_cast<std::vector<cv::KeyPoint>*>(keypoints2), *reinterpret_cast<std::vector<cv::DMatch>*>(matches1to2), *reinterpret_cast<cv::Mat*>(outImg), *reinterpret_cast<cv::Scalar*>(&matchColor), *reinterpret_cast<cv::Scalar*>(&singlePointColor), *reinterpret_cast<std::vector<char>*>(matchesMask), flags);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_drawMatches_Mat_img1_VectorOfKeyPoint_keypoints1_Mat_img2_VectorOfKeyPoint_keypoints2_VectorOfVectorOfDMatch_matches1to2_Mat_outImg_Scalar_matchColor_Scalar_singlePointColor_VectorOfVectorOfchar_matchesMask_int_flags
// parsed: cv::drawMatches
// as:     cv::drawMatches (function)
// Arg ARG cv::Mat (boxed) img1= cv::Mat (boxed) = 
// Arg ARG Vector[cv::KeyPoint (simple)] keypoints1= Vector[cv::KeyPoint (simple)] = 
// Arg ARG cv::Mat (boxed) img2= cv::Mat (boxed) = 
// Arg ARG Vector[cv::KeyPoint (simple)] keypoints2= Vector[cv::KeyPoint (simple)] = 
// Arg ARG Vector[Vector[cv::DMatch (simple)]] matches1to2= Vector[Vector[cv::DMatch (simple)]] = 
// Arg ARG cv::Mat (boxed) outImg= cv::Mat (boxed) = 
// Arg ARG cv::Scalar (simple) matchColor= cv::Scalar (simple) = Scalar::all(-1)
// Arg ARG cv::Scalar (simple) singlePointColor= cv::Scalar (simple) = Scalar::all(-1)
// Arg ARG Vector[Vector[Primitive(char)]] matchesMask= Vector[Vector[Primitive(char)]] = std::vector<std::vector<char> >()
// Arg ARG Primitive(int) flags= Primitive(int) = DrawMatchesFlags::DEFAULT
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_drawMatches_Mat_img1_VectorOfKeyPoint_keypoints1_Mat_img2_VectorOfKeyPoint_keypoints2_VectorOfVectorOfDMatch_matches1to2_Mat_outImg_Scalar_matchColor_Scalar_singlePointColor_VectorOfVectorOfchar_matchesMask_int_flags(void* img1, void* keypoints1, void* img2, void* keypoints2, void* matches1to2, void* outImg, ScalarWrapper matchColor, ScalarWrapper singlePointColor, void* matchesMask, int flags) {
    try {
        cv::drawMatches(*reinterpret_cast<cv::Mat*>(img1), *reinterpret_cast<std::vector<cv::KeyPoint>*>(keypoints1), *reinterpret_cast<cv::Mat*>(img2), *reinterpret_cast<std::vector<cv::KeyPoint>*>(keypoints2), *reinterpret_cast<std::vector<std::vector<cv::DMatch>>*>(matches1to2), *reinterpret_cast<cv::Mat*>(outImg), *reinterpret_cast<cv::Scalar*>(&matchColor), *reinterpret_cast<cv::Scalar*>(&singlePointColor), *reinterpret_cast<std::vector<std::vector<char>>*>(matchesMask), flags);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_edgePreservingFilter_Mat_src_Mat_dst_int_flags_float_sigma_s_float_sigma_r
// parsed: cv::edgePreservingFilter
// as:     cv::edgePreservingFilter (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG Primitive(int) flags= Primitive(int) = 1
// Arg ARG Primitive(float) sigma_s= Primitive(float) = 60
// Arg ARG Primitive(float) sigma_r= Primitive(float) = 0.4f
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_edgePreservingFilter_Mat_src_Mat_dst_int_flags_float_sigma_s_float_sigma_r(void* src, void* dst, int flags, float sigma_s, float sigma_r) {
    try {
        cv::edgePreservingFilter(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst), flags, sigma_s, sigma_r);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_eigenNonSymmetric_Mat_src_Mat_eigenvalues_Mat_eigenvectors
// parsed: cv::eigenNonSymmetric
// as:     cv::eigenNonSymmetric (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) eigenvalues= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) eigenvectors= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_eigenNonSymmetric_Mat_src_Mat_eigenvalues_Mat_eigenvectors(void* src, void* eigenvalues, void* eigenvectors) {
    try {
        cv::eigenNonSymmetric(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(eigenvalues), *reinterpret_cast<cv::Mat*>(eigenvectors));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_eigen_Mat_src_Mat_eigenvalues_Mat_eigenvectors
// parsed: cv::eigen
// as:     cv::eigen (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) eigenvalues= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) eigenvectors= cv::Mat (boxed) = noArray()
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_eigen_Mat_src_Mat_eigenvalues_Mat_eigenvectors(void* src, void* eigenvalues, void* eigenvectors) {
    try {
        bool ret = cv::eigen(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(eigenvalues), *reinterpret_cast<cv::Mat*>(eigenvectors));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_ellipse2Poly_Point2d_center_Size2d_axes_int_angle_int_arcStart_int_arcEnd_int_delta_VectorOfPoint2d_pts
// parsed: cv::ellipse2Poly
// as:     cv::ellipse2Poly (function)
// Arg ARG cv::Point2d (simple) center= cv::Point2d (simple) = 
// Arg ARG cv::Size2d (simple) axes= cv::Size2d (simple) = 
// Arg ARG Primitive(int) angle= Primitive(int) = 
// Arg ARG Primitive(int) arcStart= Primitive(int) = 
// Arg ARG Primitive(int) arcEnd= Primitive(int) = 
// Arg ARG Primitive(int) delta= Primitive(int) = 
// Arg ARG Vector[cv::Point2d (simple)] pts= Vector[cv::Point2d (simple)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ellipse2Poly_Point2d_center_Size2d_axes_int_angle_int_arcStart_int_arcEnd_int_delta_VectorOfPoint2d_pts(Point2dWrapper center, Size2dWrapper axes, int angle, int arcStart, int arcEnd, int delta, void* pts) {
    try {
        cv::ellipse2Poly(*reinterpret_cast<cv::Point2d*>(&center), *reinterpret_cast<cv::Size2d*>(&axes), angle, arcStart, arcEnd, delta, *reinterpret_cast<std::vector<cv::Point2d>*>(pts));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ellipse2Poly_Point_center_Size_axes_int_angle_int_arcStart_int_arcEnd_int_delta_VectorOfPoint_pts
// parsed: cv::ellipse2Poly
// as:     cv::ellipse2Poly (function)
// Arg ARG cv::Point (simple) center= cv::Point (simple) = 
// Arg ARG cv::Size (simple) axes= cv::Size (simple) = 
// Arg ARG Primitive(int) angle= Primitive(int) = 
// Arg ARG Primitive(int) arcStart= Primitive(int) = 
// Arg ARG Primitive(int) arcEnd= Primitive(int) = 
// Arg ARG Primitive(int) delta= Primitive(int) = 
// Arg ARG Vector[cv::Point (simple)] pts= Vector[cv::Point (simple)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ellipse2Poly_Point_center_Size_axes_int_angle_int_arcStart_int_arcEnd_int_delta_VectorOfPoint_pts(PointWrapper center, SizeWrapper axes, int angle, int arcStart, int arcEnd, int delta, void* pts) {
    try {
        cv::ellipse2Poly(*reinterpret_cast<cv::Point*>(&center), *reinterpret_cast<cv::Size*>(&axes), angle, arcStart, arcEnd, delta, *reinterpret_cast<std::vector<cv::Point>*>(pts));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ellipse_Mat_img_Point_center_Size_axes_double_angle_double_startAngle_double_endAngle_Scalar_color_int_thickness_int_lineType_int_shift
// parsed: cv::ellipse
// as:     cv::ellipse (function)
// Arg ARG cv::Mat (boxed) img= cv::Mat (boxed) = 
// Arg ARG cv::Point (simple) center= cv::Point (simple) = 
// Arg ARG cv::Size (simple) axes= cv::Size (simple) = 
// Arg ARG Primitive(double) angle= Primitive(double) = 
// Arg ARG Primitive(double) startAngle= Primitive(double) = 
// Arg ARG Primitive(double) endAngle= Primitive(double) = 
// Arg ARG cv::Scalar (simple) color= cv::Scalar (simple) = 
// Arg ARG Primitive(int) thickness= Primitive(int) = 1
// Arg ARG Primitive(int) lineType= Primitive(int) = LINE_8
// Arg ARG Primitive(int) shift= Primitive(int) = 0
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ellipse_Mat_img_Point_center_Size_axes_double_angle_double_startAngle_double_endAngle_Scalar_color_int_thickness_int_lineType_int_shift(void* img, PointWrapper center, SizeWrapper axes, double angle, double startAngle, double endAngle, ScalarWrapper color, int thickness, int lineType, int shift) {
    try {
        cv::ellipse(*reinterpret_cast<cv::Mat*>(img), *reinterpret_cast<cv::Point*>(&center), *reinterpret_cast<cv::Size*>(&axes), angle, startAngle, endAngle, *reinterpret_cast<cv::Scalar*>(&color), thickness, lineType, shift);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ellipse_Mat_img_RotatedRect_box_Scalar_color_int_thickness_int_lineType
// parsed: cv::ellipse
// as:     cv::ellipse (function)
// Arg ARG cv::Mat (boxed) img= cv::Mat (boxed) = 
// Arg ARG cv::RotatedRect (boxed) box= cv::RotatedRect (boxed) = 
// Arg ARG cv::Scalar (simple) color= cv::Scalar (simple) = 
// Arg ARG Primitive(int) thickness= Primitive(int) = 1
// Arg ARG Primitive(int) lineType= Primitive(int) = LINE_8
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ellipse_Mat_img_RotatedRect_box_Scalar_color_int_thickness_int_lineType(void* img, void* box, ScalarWrapper color, int thickness, int lineType) {
    try {
        cv::ellipse(*reinterpret_cast<cv::Mat*>(img), *reinterpret_cast<cv::RotatedRect*>(box), *reinterpret_cast<cv::Scalar*>(&color), thickness, lineType);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_equalizeHist_Mat_src_Mat_dst
// parsed: cv::equalizeHist
// as:     cv::equalizeHist (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_equalizeHist_Mat_src_Mat_dst(void* src, void* dst) {
    try {
        cv::equalizeHist(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_erode_Mat_src_Mat_dst_Mat_kernel_Point_anchor_int_iterations_int_borderType_Scalar_borderValue
// parsed: cv::erode
// as:     cv::erode (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) kernel= cv::Mat (boxed) = 
// Arg ARG cv::Point (simple) anchor= cv::Point (simple) = Point(-1,-1)
// Arg ARG Primitive(int) iterations= Primitive(int) = 1
// Arg ARG Primitive(int) borderType= Primitive(int) = BORDER_CONSTANT
// Arg ARG cv::Scalar (simple) borderValue= cv::Scalar (simple) = morphologyDefaultBorderValue()
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_erode_Mat_src_Mat_dst_Mat_kernel_Point_anchor_int_iterations_int_borderType_Scalar_borderValue(void* src, void* dst, void* kernel, PointWrapper anchor, int iterations, int borderType, ScalarWrapper borderValue) {
    try {
        cv::erode(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst), *reinterpret_cast<cv::Mat*>(kernel), *reinterpret_cast<cv::Point*>(&anchor), iterations, borderType, *reinterpret_cast<cv::Scalar*>(&borderValue));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_error_int__code_String__err_const_char_X__func_const_char_X__file_int__line
// parsed: cv::error
// as:     cv::error (function)
// Arg ARG Primitive(int) _code= Primitive(int) = 
// Arg ARG string _err= string = 
// Arg ARG RawPtr[Primitive(char)] * _func= (ptr) RawPtr[Primitive(char)] = 
// Arg ARG RawPtr[Primitive(char)] * _file= (ptr) RawPtr[Primitive(char)] = 
// Arg ARG Primitive(int) _line= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_error_int__code_String__err_const_char_X__func_const_char_X__file_int__line(int _code, const char* _err, const char* _func, const char* _file, int _line) {
    try {
        cv::error(_code, String(_err), _func, _file, _line);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_estimateAffine2D_Mat_from_Mat_to_Mat_inliers_int_method_double_ransacReprojThreshold_size_t_maxIters_double_confidence_size_t_refineIters
// parsed: cv::estimateAffine2D
// as:     cv::estimateAffine2D (function)
// Arg ARG cv::Mat (boxed) from= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) to= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) inliers= cv::Mat (boxed) = noArray()
// Arg ARG Primitive(int) method= Primitive(int) = RANSAC
// Arg ARG Primitive(double) ransacReprojThreshold= Primitive(double) = 3
// Arg ARG Primitive(size_t) maxIters= Primitive(size_t) = 2000
// Arg ARG Primitive(double) confidence= Primitive(double) = 0.99
// Arg ARG Primitive(size_t) refineIters= Primitive(size_t) = 10
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_estimateAffine2D_Mat_from_Mat_to_Mat_inliers_int_method_double_ransacReprojThreshold_size_t_maxIters_double_confidence_size_t_refineIters(void* from, void* to, void* inliers, int method, double ransacReprojThreshold, std::size_t maxIters, double confidence, std::size_t refineIters) {
    try {
        cv::Mat ret = cv::estimateAffine2D(*reinterpret_cast<cv::Mat*>(from), *reinterpret_cast<cv::Mat*>(to), *reinterpret_cast<cv::Mat*>(inliers), method, ransacReprojThreshold, maxIters, confidence, refineIters);
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_estimateAffine3D_Mat_src_Mat_dst_Mat_out_Mat_inliers_double_ransacThreshold_double_confidence
// parsed: cv::estimateAffine3D
// as:     cv::estimateAffine3D (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) out= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) inliers= cv::Mat (boxed) = 
// Arg ARG Primitive(double) ransacThreshold= Primitive(double) = 3
// Arg ARG Primitive(double) confidence= Primitive(double) = 0.99
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_estimateAffine3D_Mat_src_Mat_dst_Mat_out_Mat_inliers_double_ransacThreshold_double_confidence(void* src, void* dst, void* out, void* inliers, double ransacThreshold, double confidence) {
    try {
        int ret = cv::estimateAffine3D(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst), *reinterpret_cast<cv::Mat*>(out), *reinterpret_cast<cv::Mat*>(inliers), ransacThreshold, confidence);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_estimateAffinePartial2D_Mat_from_Mat_to_Mat_inliers_int_method_double_ransacReprojThreshold_size_t_maxIters_double_confidence_size_t_refineIters
// parsed: cv::estimateAffinePartial2D
// as:     cv::estimateAffinePartial2D (function)
// Arg ARG cv::Mat (boxed) from= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) to= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) inliers= cv::Mat (boxed) = noArray()
// Arg ARG Primitive(int) method= Primitive(int) = RANSAC
// Arg ARG Primitive(double) ransacReprojThreshold= Primitive(double) = 3
// Arg ARG Primitive(size_t) maxIters= Primitive(size_t) = 2000
// Arg ARG Primitive(double) confidence= Primitive(double) = 0.99
// Arg ARG Primitive(size_t) refineIters= Primitive(size_t) = 10
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_estimateAffinePartial2D_Mat_from_Mat_to_Mat_inliers_int_method_double_ransacReprojThreshold_size_t_maxIters_double_confidence_size_t_refineIters(void* from, void* to, void* inliers, int method, double ransacReprojThreshold, std::size_t maxIters, double confidence, std::size_t refineIters) {
    try {
        cv::Mat ret = cv::estimateAffinePartial2D(*reinterpret_cast<cv::Mat*>(from), *reinterpret_cast<cv::Mat*>(to), *reinterpret_cast<cv::Mat*>(inliers), method, ransacReprojThreshold, maxIters, confidence, refineIters);
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_estimateRigidTransform_Mat_src_Mat_dst_bool_fullAffine
// parsed: cv::estimateRigidTransform
// as:     cv::estimateRigidTransform (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG Primitive(bool) fullAffine= Primitive(bool) = 
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_estimateRigidTransform_Mat_src_Mat_dst_bool_fullAffine(void* src, void* dst, bool fullAffine) {
    try {
        cv::Mat ret = cv::estimateRigidTransform(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst), fullAffine);
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_estimateRigidTransform_Mat_src_Mat_dst_bool_fullAffine_int_ransacMaxIters_double_ransacGoodRatio_int_ransacSize0
// parsed: cv::estimateRigidTransform
// as:     cv::estimateRigidTransform (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG Primitive(bool) fullAffine= Primitive(bool) = 
// Arg ARG Primitive(int) ransacMaxIters= Primitive(int) = 
// Arg ARG Primitive(double) ransacGoodRatio= Primitive(double) = 
// Arg ARG Primitive(int) ransacSize0= Primitive(int) = 
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_estimateRigidTransform_Mat_src_Mat_dst_bool_fullAffine_int_ransacMaxIters_double_ransacGoodRatio_int_ransacSize0(void* src, void* dst, bool fullAffine, int ransacMaxIters, double ransacGoodRatio, int ransacSize0) {
    try {
        cv::Mat ret = cv::estimateRigidTransform(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst), fullAffine, ransacMaxIters, ransacGoodRatio, ransacSize0);
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_evaluateFeatureDetector_Mat_img1_Mat_img2_Mat_H1to2_VectorOfKeyPoint_keypoints1_VectorOfKeyPoint_keypoints2_float_repeatability_int_correspCount_PtrOfFeature2D_fdetector
// parsed: cv::evaluateFeatureDetector
// as:     cv::evaluateFeatureDetector (function)
// Arg ARG cv::Mat (boxed) img1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) img2= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) H1to2= cv::Mat (boxed) = 
// Arg ARG RawPtr[Vector[cv::KeyPoint (simple)]] * keypoints1= (ptr) RawPtr[Vector[cv::KeyPoint (simple)]] = 
// Arg ARG RawPtr[Vector[cv::KeyPoint (simple)]] * keypoints2= (ptr) RawPtr[Vector[cv::KeyPoint (simple)]] = 
// Arg ARG Primitive(float) repeatability= Primitive(float) = 
// Arg ARG Primitive(int) correspCount= Primitive(int) = 
// Arg ARG SmartPtr[cv::Feature2D (boxed)] fdetector= SmartPtr[cv::Feature2D (boxed)] = Ptr<FeatureDetector>()
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_evaluateFeatureDetector_Mat_img1_Mat_img2_Mat_H1to2_VectorOfKeyPoint_keypoints1_VectorOfKeyPoint_keypoints2_float_repeatability_int_correspCount_PtrOfFeature2D_fdetector(void* img1, void* img2, void* H1to2, void* keypoints1, void* keypoints2, float repeatability, int correspCount, void* fdetector) {
    try {
        cv::evaluateFeatureDetector(*reinterpret_cast<cv::Mat*>(img1), *reinterpret_cast<cv::Mat*>(img2), *reinterpret_cast<cv::Mat*>(H1to2), reinterpret_cast<std::vector<cv::KeyPoint>*>(keypoints1), reinterpret_cast<std::vector<cv::KeyPoint>*>(keypoints2), repeatability, correspCount, reinterpret_cast<cv::Feature2D*>(fdetector));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_exp_Mat_src_Mat_dst
// parsed: cv::exp
// as:     cv::exp (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_exp_Mat_src_Mat_dst(void* src, void* dst) {
    try {
        cv::exp(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_exp_softdouble_a
// parsed: cv::exp
// as:     cv::exp (function)
// Arg ARG cv::softdouble (boxed) a= cv::softdouble (boxed) = 
// Return value: cv::softdouble (boxed)
cv_return_value_void_X cv_core_cv_exp_softdouble_a(void* a) {
    try {
        cv::softdouble ret = cv::exp(*reinterpret_cast<cv::softdouble*>(a));
        return { Error::Code::StsOk, NULL, new cv::softdouble(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_exp_softfloat_a
// parsed: cv::exp
// as:     cv::exp (function)
// Arg ARG cv::softfloat (boxed) a= cv::softfloat (boxed) = 
// Return value: cv::softfloat (boxed)
cv_return_value_void_X cv_core_cv_exp_softfloat_a(void* a) {
    try {
        cv::softfloat ret = cv::exp(*reinterpret_cast<cv::softfloat*>(a));
        return { Error::Code::StsOk, NULL, new cv::softfloat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_extractChannel_Mat_src_Mat_dst_int_coi
// parsed: cv::extractChannel
// as:     cv::extractChannel (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG Primitive(int) coi= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_extractChannel_Mat_src_Mat_dst_int_coi(void* src, void* dst, int coi) {
    try {
        cv::extractChannel(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst), coi);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_fastAtan2_float_y_float_x
// parsed: cv::fastAtan2
// as:     cv::fastAtan2 (function)
// Arg ARG Primitive(float) y= Primitive(float) = 
// Arg ARG Primitive(float) x= Primitive(float) = 
// Return value: Primitive(float)
cv_return_value_float cv_core_cv_fastAtan2_float_y_float_x(float y, float x) {
    try {
        float ret = cv::fastAtan2(y, x);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<float*>(&ret) };
    } CVRS_CATCH(cv_return_value_float)
}

// cv_fastNlMeansDenoisingColoredMulti_VectorOfMat_srcImgs_Mat_dst_int_imgToDenoiseIndex_int_temporalWindowSize_float_h_float_hColor_int_templateWindowSize_int_searchWindowSize
// parsed: cv::fastNlMeansDenoisingColoredMulti
// as:     cv::fastNlMeansDenoisingColoredMulti (function)
// Arg ARG Vector[cv::Mat (boxed)] srcImgs= Vector[cv::Mat (boxed)] = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG Primitive(int) imgToDenoiseIndex= Primitive(int) = 
// Arg ARG Primitive(int) temporalWindowSize= Primitive(int) = 
// Arg ARG Primitive(float) h= Primitive(float) = 3
// Arg ARG Primitive(float) hColor= Primitive(float) = 3
// Arg ARG Primitive(int) templateWindowSize= Primitive(int) = 7
// Arg ARG Primitive(int) searchWindowSize= Primitive(int) = 21
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_fastNlMeansDenoisingColoredMulti_VectorOfMat_srcImgs_Mat_dst_int_imgToDenoiseIndex_int_temporalWindowSize_float_h_float_hColor_int_templateWindowSize_int_searchWindowSize(void* srcImgs, void* dst, int imgToDenoiseIndex, int temporalWindowSize, float h, float hColor, int templateWindowSize, int searchWindowSize) {
    try {
        cv::fastNlMeansDenoisingColoredMulti(*reinterpret_cast<std::vector<cv::Mat>*>(srcImgs), *reinterpret_cast<cv::Mat*>(dst), imgToDenoiseIndex, temporalWindowSize, h, hColor, templateWindowSize, searchWindowSize);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_fastNlMeansDenoisingColored_Mat_src_Mat_dst_float_h_float_hColor_int_templateWindowSize_int_searchWindowSize
// parsed: cv::fastNlMeansDenoisingColored
// as:     cv::fastNlMeansDenoisingColored (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG Primitive(float) h= Primitive(float) = 3
// Arg ARG Primitive(float) hColor= Primitive(float) = 3
// Arg ARG Primitive(int) templateWindowSize= Primitive(int) = 7
// Arg ARG Primitive(int) searchWindowSize= Primitive(int) = 21
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_fastNlMeansDenoisingColored_Mat_src_Mat_dst_float_h_float_hColor_int_templateWindowSize_int_searchWindowSize(void* src, void* dst, float h, float hColor, int templateWindowSize, int searchWindowSize) {
    try {
        cv::fastNlMeansDenoisingColored(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst), h, hColor, templateWindowSize, searchWindowSize);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_fastNlMeansDenoisingMulti_VectorOfMat_srcImgs_Mat_dst_int_imgToDenoiseIndex_int_temporalWindowSize_VectorOffloat_h_int_templateWindowSize_int_searchWindowSize_int_normType
// parsed: cv::fastNlMeansDenoisingMulti
// as:     cv::fastNlMeansDenoisingMulti (function)
// Arg ARG Vector[cv::Mat (boxed)] srcImgs= Vector[cv::Mat (boxed)] = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG Primitive(int) imgToDenoiseIndex= Primitive(int) = 
// Arg ARG Primitive(int) temporalWindowSize= Primitive(int) = 
// Arg ARG Vector[Primitive(float)] h= Vector[Primitive(float)] = 
// Arg ARG Primitive(int) templateWindowSize= Primitive(int) = 7
// Arg ARG Primitive(int) searchWindowSize= Primitive(int) = 21
// Arg ARG Primitive(int) normType= Primitive(int) = NORM_L2
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_fastNlMeansDenoisingMulti_VectorOfMat_srcImgs_Mat_dst_int_imgToDenoiseIndex_int_temporalWindowSize_VectorOffloat_h_int_templateWindowSize_int_searchWindowSize_int_normType(void* srcImgs, void* dst, int imgToDenoiseIndex, int temporalWindowSize, void* h, int templateWindowSize, int searchWindowSize, int normType) {
    try {
        cv::fastNlMeansDenoisingMulti(*reinterpret_cast<std::vector<cv::Mat>*>(srcImgs), *reinterpret_cast<cv::Mat*>(dst), imgToDenoiseIndex, temporalWindowSize, *reinterpret_cast<std::vector<float>*>(h), templateWindowSize, searchWindowSize, normType);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_fastNlMeansDenoisingMulti_VectorOfMat_srcImgs_Mat_dst_int_imgToDenoiseIndex_int_temporalWindowSize_float_h_int_templateWindowSize_int_searchWindowSize
// parsed: cv::fastNlMeansDenoisingMulti
// as:     cv::fastNlMeansDenoisingMulti (function)
// Arg ARG Vector[cv::Mat (boxed)] srcImgs= Vector[cv::Mat (boxed)] = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG Primitive(int) imgToDenoiseIndex= Primitive(int) = 
// Arg ARG Primitive(int) temporalWindowSize= Primitive(int) = 
// Arg ARG Primitive(float) h= Primitive(float) = 3
// Arg ARG Primitive(int) templateWindowSize= Primitive(int) = 7
// Arg ARG Primitive(int) searchWindowSize= Primitive(int) = 21
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_fastNlMeansDenoisingMulti_VectorOfMat_srcImgs_Mat_dst_int_imgToDenoiseIndex_int_temporalWindowSize_float_h_int_templateWindowSize_int_searchWindowSize(void* srcImgs, void* dst, int imgToDenoiseIndex, int temporalWindowSize, float h, int templateWindowSize, int searchWindowSize) {
    try {
        cv::fastNlMeansDenoisingMulti(*reinterpret_cast<std::vector<cv::Mat>*>(srcImgs), *reinterpret_cast<cv::Mat*>(dst), imgToDenoiseIndex, temporalWindowSize, h, templateWindowSize, searchWindowSize);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_fastNlMeansDenoising_Mat_src_Mat_dst_VectorOffloat_h_int_templateWindowSize_int_searchWindowSize_int_normType
// parsed: cv::fastNlMeansDenoising
// as:     cv::fastNlMeansDenoising (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG Vector[Primitive(float)] h= Vector[Primitive(float)] = 
// Arg ARG Primitive(int) templateWindowSize= Primitive(int) = 7
// Arg ARG Primitive(int) searchWindowSize= Primitive(int) = 21
// Arg ARG Primitive(int) normType= Primitive(int) = NORM_L2
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_fastNlMeansDenoising_Mat_src_Mat_dst_VectorOffloat_h_int_templateWindowSize_int_searchWindowSize_int_normType(void* src, void* dst, void* h, int templateWindowSize, int searchWindowSize, int normType) {
    try {
        cv::fastNlMeansDenoising(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst), *reinterpret_cast<std::vector<float>*>(h), templateWindowSize, searchWindowSize, normType);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_fastNlMeansDenoising_Mat_src_Mat_dst_float_h_int_templateWindowSize_int_searchWindowSize
// parsed: cv::fastNlMeansDenoising
// as:     cv::fastNlMeansDenoising (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG Primitive(float) h= Primitive(float) = 3
// Arg ARG Primitive(int) templateWindowSize= Primitive(int) = 7
// Arg ARG Primitive(int) searchWindowSize= Primitive(int) = 21
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_fastNlMeansDenoising_Mat_src_Mat_dst_float_h_int_templateWindowSize_int_searchWindowSize(void* src, void* dst, float h, int templateWindowSize, int searchWindowSize) {
    try {
        cv::fastNlMeansDenoising(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst), h, templateWindowSize, searchWindowSize);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_fillConvexPoly_Mat_img_Mat_points_Scalar_color_int_lineType_int_shift
// parsed: cv::fillConvexPoly
// as:     cv::fillConvexPoly (function)
// Arg ARG cv::Mat (boxed) img= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) points= cv::Mat (boxed) = 
// Arg ARG cv::Scalar (simple) color= cv::Scalar (simple) = 
// Arg ARG Primitive(int) lineType= Primitive(int) = LINE_8
// Arg ARG Primitive(int) shift= Primitive(int) = 0
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_fillConvexPoly_Mat_img_Mat_points_Scalar_color_int_lineType_int_shift(void* img, void* points, ScalarWrapper color, int lineType, int shift) {
    try {
        cv::fillConvexPoly(*reinterpret_cast<cv::Mat*>(img), *reinterpret_cast<cv::Mat*>(points), *reinterpret_cast<cv::Scalar*>(&color), lineType, shift);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_fillConvexPoly_Mat_img_const_Point_X_pts_int_npts_Scalar_color_int_lineType_int_shift
// parsed: cv::fillConvexPoly
// as:     cv::fillConvexPoly (function)
// Arg ARG cv::Mat (boxed) img= cv::Mat (boxed) = 
// Arg ARG RawPtr[cv::Point (simple)] * pts= (ptr) RawPtr[cv::Point (simple)] = 
// Arg ARG Primitive(int) npts= Primitive(int) = 
// Arg ARG cv::Scalar (simple) color= cv::Scalar (simple) = 
// Arg ARG Primitive(int) lineType= Primitive(int) = LINE_8
// Arg ARG Primitive(int) shift= Primitive(int) = 0
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_fillConvexPoly_Mat_img_const_Point_X_pts_int_npts_Scalar_color_int_lineType_int_shift(void* img, const cv::Point* pts, int npts, ScalarWrapper color, int lineType, int shift) {
    try {
        cv::fillConvexPoly(*reinterpret_cast<cv::Mat*>(img), reinterpret_cast<cv::Point*>(&pts), npts, *reinterpret_cast<cv::Scalar*>(&color), lineType, shift);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_fillPoly_Mat_img_VectorOfMat_pts_Scalar_color_int_lineType_int_shift_Point_offset
// parsed: cv::fillPoly
// as:     cv::fillPoly (function)
// Arg ARG cv::Mat (boxed) img= cv::Mat (boxed) = 
// Arg ARG Vector[cv::Mat (boxed)] pts= Vector[cv::Mat (boxed)] = 
// Arg ARG cv::Scalar (simple) color= cv::Scalar (simple) = 
// Arg ARG Primitive(int) lineType= Primitive(int) = LINE_8
// Arg ARG Primitive(int) shift= Primitive(int) = 0
// Arg ARG cv::Point (simple) offset= cv::Point (simple) = Point()
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_fillPoly_Mat_img_VectorOfMat_pts_Scalar_color_int_lineType_int_shift_Point_offset(void* img, void* pts, ScalarWrapper color, int lineType, int shift, PointWrapper offset) {
    try {
        cv::fillPoly(*reinterpret_cast<cv::Mat*>(img), *reinterpret_cast<std::vector<cv::Mat>*>(pts), *reinterpret_cast<cv::Scalar*>(&color), lineType, shift, *reinterpret_cast<cv::Point*>(&offset));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_filter2D_Mat_src_Mat_dst_int_ddepth_Mat_kernel_Point_anchor_double_delta_int_borderType
// parsed: cv::filter2D
// as:     cv::filter2D (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG Primitive(int) ddepth= Primitive(int) = 
// Arg ARG cv::Mat (boxed) kernel= cv::Mat (boxed) = 
// Arg ARG cv::Point (simple) anchor= cv::Point (simple) = Point(-1,-1)
// Arg ARG Primitive(double) delta= Primitive(double) = 0
// Arg ARG Primitive(int) borderType= Primitive(int) = BORDER_DEFAULT
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_filter2D_Mat_src_Mat_dst_int_ddepth_Mat_kernel_Point_anchor_double_delta_int_borderType(void* src, void* dst, int ddepth, void* kernel, PointWrapper anchor, double delta, int borderType) {
    try {
        cv::filter2D(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst), ddepth, *reinterpret_cast<cv::Mat*>(kernel), *reinterpret_cast<cv::Point*>(&anchor), delta, borderType);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_filterHomographyDecompByVisibleRefpoints_VectorOfMat_rotations_VectorOfMat_normals_Mat_beforePoints_Mat_afterPoints_Mat_possibleSolutions_Mat_pointsMask
// parsed: cv::filterHomographyDecompByVisibleRefpoints
// as:     cv::filterHomographyDecompByVisibleRefpoints (function)
// Arg ARG Vector[cv::Mat (boxed)] rotations= Vector[cv::Mat (boxed)] = 
// Arg ARG Vector[cv::Mat (boxed)] normals= Vector[cv::Mat (boxed)] = 
// Arg ARG cv::Mat (boxed) beforePoints= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) afterPoints= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) possibleSolutions= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) pointsMask= cv::Mat (boxed) = noArray()
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_filterHomographyDecompByVisibleRefpoints_VectorOfMat_rotations_VectorOfMat_normals_Mat_beforePoints_Mat_afterPoints_Mat_possibleSolutions_Mat_pointsMask(void* rotations, void* normals, void* beforePoints, void* afterPoints, void* possibleSolutions, void* pointsMask) {
    try {
        cv::filterHomographyDecompByVisibleRefpoints(*reinterpret_cast<std::vector<cv::Mat>*>(rotations), *reinterpret_cast<std::vector<cv::Mat>*>(normals), *reinterpret_cast<cv::Mat*>(beforePoints), *reinterpret_cast<cv::Mat*>(afterPoints), *reinterpret_cast<cv::Mat*>(possibleSolutions), *reinterpret_cast<cv::Mat*>(pointsMask));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_filterSpeckles_Mat_img_double_newVal_int_maxSpeckleSize_double_maxDiff_Mat_buf
// parsed: cv::filterSpeckles
// as:     cv::filterSpeckles (function)
// Arg ARG cv::Mat (boxed) img= cv::Mat (boxed) = 
// Arg ARG Primitive(double) newVal= Primitive(double) = 
// Arg ARG Primitive(int) maxSpeckleSize= Primitive(int) = 
// Arg ARG Primitive(double) maxDiff= Primitive(double) = 
// Arg ARG cv::Mat (boxed) buf= cv::Mat (boxed) = noArray()
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_filterSpeckles_Mat_img_double_newVal_int_maxSpeckleSize_double_maxDiff_Mat_buf(void* img, double newVal, int maxSpeckleSize, double maxDiff, void* buf) {
    try {
        cv::filterSpeckles(*reinterpret_cast<cv::Mat*>(img), newVal, maxSpeckleSize, maxDiff, *reinterpret_cast<cv::Mat*>(buf));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_find4QuadCornerSubpix_Mat_img_Mat_corners_Size_region_size
// parsed: cv::find4QuadCornerSubpix
// as:     cv::find4QuadCornerSubpix (function)
// Arg ARG cv::Mat (boxed) img= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) corners= cv::Mat (boxed) = 
// Arg ARG cv::Size (simple) region_size= cv::Size (simple) = 
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_find4QuadCornerSubpix_Mat_img_Mat_corners_Size_region_size(void* img, void* corners, SizeWrapper region_size) {
    try {
        bool ret = cv::find4QuadCornerSubpix(*reinterpret_cast<cv::Mat*>(img), *reinterpret_cast<cv::Mat*>(corners), *reinterpret_cast<cv::Size*>(&region_size));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_findChessboardCorners_Mat_image_Size_patternSize_Mat_corners_int_flags
// parsed: cv::findChessboardCorners
// as:     cv::findChessboardCorners (function)
// Arg ARG cv::Mat (boxed) image= cv::Mat (boxed) = 
// Arg ARG cv::Size (simple) patternSize= cv::Size (simple) = 
// Arg ARG cv::Mat (boxed) corners= cv::Mat (boxed) = 
// Arg ARG Primitive(int) flags= Primitive(int) = CALIB_CB_ADAPTIVE_THRESH + CALIB_CB_NORMALIZE_IMAGE
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_findChessboardCorners_Mat_image_Size_patternSize_Mat_corners_int_flags(void* image, SizeWrapper patternSize, void* corners, int flags) {
    try {
        bool ret = cv::findChessboardCorners(*reinterpret_cast<cv::Mat*>(image), *reinterpret_cast<cv::Size*>(&patternSize), *reinterpret_cast<cv::Mat*>(corners), flags);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_findContours_Mat_image_VectorOfMat_contours_Mat_hierarchy_int_mode_int_method_Point_offset
// parsed: cv::findContours
// as:     cv::findContours (function)
// Arg ARG cv::Mat (boxed) image= cv::Mat (boxed) = 
// Arg ARG Vector[cv::Mat (boxed)] contours= Vector[cv::Mat (boxed)] = 
// Arg ARG cv::Mat (boxed) hierarchy= cv::Mat (boxed) = 
// Arg ARG Primitive(int) mode= Primitive(int) = 
// Arg ARG Primitive(int) method= Primitive(int) = 
// Arg ARG cv::Point (simple) offset= cv::Point (simple) = Point()
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_findContours_Mat_image_VectorOfMat_contours_Mat_hierarchy_int_mode_int_method_Point_offset(void* image, void** contours, void* hierarchy, int mode, int method, PointWrapper offset) {
    try {
        cv::findContours(*reinterpret_cast<cv::Mat*>(image), *reinterpret_cast<std::vector<cv::Mat>*>(contours), *reinterpret_cast<cv::Mat*>(hierarchy), mode, method, *reinterpret_cast<cv::Point*>(&offset));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_findContours_Mat_image_VectorOfMat_contours_int_mode_int_method_Point_offset
// parsed: cv::findContours
// as:     cv::findContours (function)
// Arg ARG cv::Mat (boxed) image= cv::Mat (boxed) = 
// Arg ARG Vector[cv::Mat (boxed)] contours= Vector[cv::Mat (boxed)] = 
// Arg ARG Primitive(int) mode= Primitive(int) = 
// Arg ARG Primitive(int) method= Primitive(int) = 
// Arg ARG cv::Point (simple) offset= cv::Point (simple) = Point()
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_findContours_Mat_image_VectorOfMat_contours_int_mode_int_method_Point_offset(void* image, void** contours, int mode, int method, PointWrapper offset) {
    try {
        cv::findContours(*reinterpret_cast<cv::Mat*>(image), *reinterpret_cast<std::vector<cv::Mat>*>(contours), mode, method, *reinterpret_cast<cv::Point*>(&offset));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_findEssentialMat_Mat_points1_Mat_points2_Mat_cameraMatrix_int_method_double_prob_double_threshold_Mat_mask
// parsed: cv::findEssentialMat
// as:     cv::findEssentialMat (function)
// Arg ARG cv::Mat (boxed) points1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) points2= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) cameraMatrix= cv::Mat (boxed) = 
// Arg ARG Primitive(int) method= Primitive(int) = RANSAC
// Arg ARG Primitive(double) prob= Primitive(double) = 0.999
// Arg ARG Primitive(double) threshold= Primitive(double) = 1.0
// Arg ARG cv::Mat (boxed) mask= cv::Mat (boxed) = noArray()
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_findEssentialMat_Mat_points1_Mat_points2_Mat_cameraMatrix_int_method_double_prob_double_threshold_Mat_mask(void* points1, void* points2, void* cameraMatrix, int method, double prob, double threshold, void* mask) {
    try {
        cv::Mat ret = cv::findEssentialMat(*reinterpret_cast<cv::Mat*>(points1), *reinterpret_cast<cv::Mat*>(points2), *reinterpret_cast<cv::Mat*>(cameraMatrix), method, prob, threshold, *reinterpret_cast<cv::Mat*>(mask));
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_findEssentialMat_Mat_points1_Mat_points2_double_focal_Point2d_pp_int_method_double_prob_double_threshold_Mat_mask
// parsed: cv::findEssentialMat
// as:     cv::findEssentialMat (function)
// Arg ARG cv::Mat (boxed) points1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) points2= cv::Mat (boxed) = 
// Arg ARG Primitive(double) focal= Primitive(double) = 1.0
// Arg ARG cv::Point2d (simple) pp= cv::Point2d (simple) = Point2d(0, 0)
// Arg ARG Primitive(int) method= Primitive(int) = RANSAC
// Arg ARG Primitive(double) prob= Primitive(double) = 0.999
// Arg ARG Primitive(double) threshold= Primitive(double) = 1.0
// Arg ARG cv::Mat (boxed) mask= cv::Mat (boxed) = noArray()
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_findEssentialMat_Mat_points1_Mat_points2_double_focal_Point2d_pp_int_method_double_prob_double_threshold_Mat_mask(void* points1, void* points2, double focal, Point2dWrapper pp, int method, double prob, double threshold, void* mask) {
    try {
        cv::Mat ret = cv::findEssentialMat(*reinterpret_cast<cv::Mat*>(points1), *reinterpret_cast<cv::Mat*>(points2), focal, *reinterpret_cast<cv::Point2d*>(&pp), method, prob, threshold, *reinterpret_cast<cv::Mat*>(mask));
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_findFundamentalMat_Mat_points1_Mat_points2_Mat_mask_int_method_double_ransacReprojThreshold_double_confidence
// parsed: cv::findFundamentalMat
// as:     cv::findFundamentalMat (function)
// Arg ARG cv::Mat (boxed) points1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) points2= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) mask= cv::Mat (boxed) = 
// Arg ARG Primitive(int) method= Primitive(int) = FM_RANSAC
// Arg ARG Primitive(double) ransacReprojThreshold= Primitive(double) = 3.
// Arg ARG Primitive(double) confidence= Primitive(double) = 0.99
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_findFundamentalMat_Mat_points1_Mat_points2_Mat_mask_int_method_double_ransacReprojThreshold_double_confidence(void* points1, void* points2, void* mask, int method, double ransacReprojThreshold, double confidence) {
    try {
        cv::Mat ret = cv::findFundamentalMat(*reinterpret_cast<cv::Mat*>(points1), *reinterpret_cast<cv::Mat*>(points2), *reinterpret_cast<cv::Mat*>(mask), method, ransacReprojThreshold, confidence);
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_findFundamentalMat_Mat_points1_Mat_points2_int_method_double_ransacReprojThreshold_double_confidence_Mat_mask
// parsed: cv::findFundamentalMat
// as:     cv::findFundamentalMat (function)
// Arg ARG cv::Mat (boxed) points1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) points2= cv::Mat (boxed) = 
// Arg ARG Primitive(int) method= Primitive(int) = FM_RANSAC
// Arg ARG Primitive(double) ransacReprojThreshold= Primitive(double) = 3.
// Arg ARG Primitive(double) confidence= Primitive(double) = 0.99
// Arg ARG cv::Mat (boxed) mask= cv::Mat (boxed) = noArray()
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_findFundamentalMat_Mat_points1_Mat_points2_int_method_double_ransacReprojThreshold_double_confidence_Mat_mask(void* points1, void* points2, int method, double ransacReprojThreshold, double confidence, void* mask) {
    try {
        cv::Mat ret = cv::findFundamentalMat(*reinterpret_cast<cv::Mat*>(points1), *reinterpret_cast<cv::Mat*>(points2), method, ransacReprojThreshold, confidence, *reinterpret_cast<cv::Mat*>(mask));
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_findHomography_Mat_srcPoints_Mat_dstPoints_Mat_mask_int_method_double_ransacReprojThreshold
// parsed: cv::findHomography
// as:     cv::findHomography (function)
// Arg ARG cv::Mat (boxed) srcPoints= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dstPoints= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) mask= cv::Mat (boxed) = 
// Arg ARG Primitive(int) method= Primitive(int) = 0
// Arg ARG Primitive(double) ransacReprojThreshold= Primitive(double) = 3
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_findHomography_Mat_srcPoints_Mat_dstPoints_Mat_mask_int_method_double_ransacReprojThreshold(void* srcPoints, void* dstPoints, void* mask, int method, double ransacReprojThreshold) {
    try {
        cv::Mat ret = cv::findHomography(*reinterpret_cast<cv::Mat*>(srcPoints), *reinterpret_cast<cv::Mat*>(dstPoints), *reinterpret_cast<cv::Mat*>(mask), method, ransacReprojThreshold);
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_findHomography_Mat_srcPoints_Mat_dstPoints_int_method_double_ransacReprojThreshold_Mat_mask_int_maxIters_double_confidence
// parsed: cv::findHomography
// as:     cv::findHomography (function)
// Arg ARG cv::Mat (boxed) srcPoints= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dstPoints= cv::Mat (boxed) = 
// Arg ARG Primitive(int) method= Primitive(int) = 0
// Arg ARG Primitive(double) ransacReprojThreshold= Primitive(double) = 3
// Arg ARG cv::Mat (boxed) mask= cv::Mat (boxed) = noArray()
// Arg ARG Primitive(int) maxIters= Primitive(int) = 2000
// Arg ARG Primitive(double) confidence= Primitive(double) = 0.995
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_findHomography_Mat_srcPoints_Mat_dstPoints_int_method_double_ransacReprojThreshold_Mat_mask_int_maxIters_double_confidence(void* srcPoints, void* dstPoints, int method, double ransacReprojThreshold, void* mask, int maxIters, double confidence) {
    try {
        cv::Mat ret = cv::findHomography(*reinterpret_cast<cv::Mat*>(srcPoints), *reinterpret_cast<cv::Mat*>(dstPoints), method, ransacReprojThreshold, *reinterpret_cast<cv::Mat*>(mask), maxIters, confidence);
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_findNonZero_Mat_src_Mat_idx
// parsed: cv::findNonZero
// as:     cv::findNonZero (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) idx= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_findNonZero_Mat_src_Mat_idx(void* src, void* idx) {
    try {
        cv::findNonZero(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(idx));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_findTransformECC_Mat_templateImage_Mat_inputImage_Mat_warpMatrix_int_motionType_TermCriteria_criteria_Mat_inputMask
// parsed: cv::findTransformECC
// as:     cv::findTransformECC (function)
// Arg ARG cv::Mat (boxed) templateImage= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) inputImage= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) warpMatrix= cv::Mat (boxed) = 
// Arg ARG Primitive(int) motionType= Primitive(int) = MOTION_AFFINE
// Arg ARG cv::TermCriteria (boxed) criteria= cv::TermCriteria (boxed) = TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 50, 0.001)
// Arg ARG cv::Mat (boxed) inputMask= cv::Mat (boxed) = noArray()
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_findTransformECC_Mat_templateImage_Mat_inputImage_Mat_warpMatrix_int_motionType_TermCriteria_criteria_Mat_inputMask(void* templateImage, void* inputImage, void* warpMatrix, int motionType, void* criteria, void* inputMask) {
    try {
        double ret = cv::findTransformECC(*reinterpret_cast<cv::Mat*>(templateImage), *reinterpret_cast<cv::Mat*>(inputImage), *reinterpret_cast<cv::Mat*>(warpMatrix), motionType, *reinterpret_cast<cv::TermCriteria*>(criteria), *reinterpret_cast<cv::Mat*>(inputMask));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_fisheye_calibrate_VectorOfMat_objectPoints_VectorOfMat_imagePoints_Size_image_size_Mat_K_Mat_D_VectorOfMat_rvecs_VectorOfMat_tvecs_int_flags_TermCriteria_criteria
// parsed: cv::fisheye::calibrate
// as:     cv::fisheye::calibrate (function)
// Arg ARG Vector[cv::Mat (boxed)] objectPoints= Vector[cv::Mat (boxed)] = 
// Arg ARG Vector[cv::Mat (boxed)] imagePoints= Vector[cv::Mat (boxed)] = 
// Arg ARG cv::Size (simple) image_size= cv::Size (simple) = 
// Arg ARG cv::Mat (boxed) K= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) D= cv::Mat (boxed) = 
// Arg ARG Vector[cv::Mat (boxed)] rvecs= Vector[cv::Mat (boxed)] = 
// Arg ARG Vector[cv::Mat (boxed)] tvecs= Vector[cv::Mat (boxed)] = 
// Arg ARG Primitive(int) flags= Primitive(int) = 0
// Arg ARG cv::TermCriteria (boxed) criteria= cv::TermCriteria (boxed) = TermCriteria(TermCriteria::COUNT + TermCriteria::EPS, 100, DBL_EPSILON)
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_fisheye_calibrate_VectorOfMat_objectPoints_VectorOfMat_imagePoints_Size_image_size_Mat_K_Mat_D_VectorOfMat_rvecs_VectorOfMat_tvecs_int_flags_TermCriteria_criteria(void* objectPoints, void* imagePoints, SizeWrapper image_size, void* K, void* D, void** rvecs, void** tvecs, int flags, void* criteria) {
    try {
        double ret = cv::fisheye::calibrate(*reinterpret_cast<std::vector<cv::Mat>*>(objectPoints), *reinterpret_cast<std::vector<cv::Mat>*>(imagePoints), *reinterpret_cast<cv::Size*>(&image_size), *reinterpret_cast<cv::Mat*>(K), *reinterpret_cast<cv::Mat*>(D), *reinterpret_cast<std::vector<cv::Mat>*>(rvecs), *reinterpret_cast<std::vector<cv::Mat>*>(tvecs), flags, *reinterpret_cast<cv::TermCriteria*>(criteria));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_fisheye_distortPoints_Mat_undistorted_Mat_distorted_Mat_K_Mat_D_double_alpha
// parsed: cv::fisheye::distortPoints
// as:     cv::fisheye::distortPoints (function)
// Arg ARG cv::Mat (boxed) undistorted= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) distorted= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) K= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) D= cv::Mat (boxed) = 
// Arg ARG Primitive(double) alpha= Primitive(double) = 0
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_fisheye_distortPoints_Mat_undistorted_Mat_distorted_Mat_K_Mat_D_double_alpha(void* undistorted, void* distorted, void* K, void* D, double alpha) {
    try {
        cv::fisheye::distortPoints(*reinterpret_cast<cv::Mat*>(undistorted), *reinterpret_cast<cv::Mat*>(distorted), *reinterpret_cast<cv::Mat*>(K), *reinterpret_cast<cv::Mat*>(D), alpha);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_fisheye_estimateNewCameraMatrixForUndistortRectify_Mat_K_Mat_D_Size_image_size_Mat_R_Mat_P_double_balance_Size_new_size_double_fov_scale
// parsed: cv::fisheye::estimateNewCameraMatrixForUndistortRectify
// as:     cv::fisheye::estimateNewCameraMatrixForUndistortRectify (function)
// Arg ARG cv::Mat (boxed) K= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) D= cv::Mat (boxed) = 
// Arg ARG cv::Size (simple) image_size= cv::Size (simple) = 
// Arg ARG cv::Mat (boxed) R= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) P= cv::Mat (boxed) = 
// Arg ARG Primitive(double) balance= Primitive(double) = 0.0
// Arg ARG cv::Size (simple) new_size= cv::Size (simple) = Size()
// Arg ARG Primitive(double) fov_scale= Primitive(double) = 1.0
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_fisheye_estimateNewCameraMatrixForUndistortRectify_Mat_K_Mat_D_Size_image_size_Mat_R_Mat_P_double_balance_Size_new_size_double_fov_scale(void* K, void* D, SizeWrapper image_size, void* R, void* P, double balance, SizeWrapper new_size, double fov_scale) {
    try {
        cv::fisheye::estimateNewCameraMatrixForUndistortRectify(*reinterpret_cast<cv::Mat*>(K), *reinterpret_cast<cv::Mat*>(D), *reinterpret_cast<cv::Size*>(&image_size), *reinterpret_cast<cv::Mat*>(R), *reinterpret_cast<cv::Mat*>(P), balance, *reinterpret_cast<cv::Size*>(&new_size), fov_scale);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_fisheye_initUndistortRectifyMap_Mat_K_Mat_D_Mat_R_Mat_P_Size_size_int_m1type_Mat_map1_Mat_map2
// parsed: cv::fisheye::initUndistortRectifyMap
// as:     cv::fisheye::initUndistortRectifyMap (function)
// Arg ARG cv::Mat (boxed) K= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) D= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) R= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) P= cv::Mat (boxed) = 
// Arg ARG cv::Size (simple) size= cv::Size (simple) = 
// Arg ARG Primitive(int) m1type= Primitive(int) = 
// Arg ARG cv::Mat (boxed) map1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) map2= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_fisheye_initUndistortRectifyMap_Mat_K_Mat_D_Mat_R_Mat_P_Size_size_int_m1type_Mat_map1_Mat_map2(void* K, void* D, void* R, void* P, SizeWrapper size, int m1type, void* map1, void* map2) {
    try {
        cv::fisheye::initUndistortRectifyMap(*reinterpret_cast<cv::Mat*>(K), *reinterpret_cast<cv::Mat*>(D), *reinterpret_cast<cv::Mat*>(R), *reinterpret_cast<cv::Mat*>(P), *reinterpret_cast<cv::Size*>(&size), m1type, *reinterpret_cast<cv::Mat*>(map1), *reinterpret_cast<cv::Mat*>(map2));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_fisheye_projectPoints_Mat_objectPoints_Mat_imagePoints_Mat_rvec_Mat_tvec_Mat_K_Mat_D_double_alpha_Mat_jacobian
// parsed: cv::fisheye::projectPoints
// as:     cv::fisheye::projectPoints (function)
// Arg ARG cv::Mat (boxed) objectPoints= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) imagePoints= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) rvec= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) tvec= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) K= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) D= cv::Mat (boxed) = 
// Arg ARG Primitive(double) alpha= Primitive(double) = 0
// Arg ARG cv::Mat (boxed) jacobian= cv::Mat (boxed) = noArray()
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_fisheye_projectPoints_Mat_objectPoints_Mat_imagePoints_Mat_rvec_Mat_tvec_Mat_K_Mat_D_double_alpha_Mat_jacobian(void* objectPoints, void* imagePoints, void* rvec, void* tvec, void* K, void* D, double alpha, void* jacobian) {
    try {
        cv::fisheye::projectPoints(*reinterpret_cast<cv::Mat*>(objectPoints), *reinterpret_cast<cv::Mat*>(imagePoints), *reinterpret_cast<cv::Mat*>(rvec), *reinterpret_cast<cv::Mat*>(tvec), *reinterpret_cast<cv::Mat*>(K), *reinterpret_cast<cv::Mat*>(D), alpha, *reinterpret_cast<cv::Mat*>(jacobian));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_fisheye_stereoCalibrate_VectorOfMat_objectPoints_VectorOfMat_imagePoints1_VectorOfMat_imagePoints2_Mat_K1_Mat_D1_Mat_K2_Mat_D2_Size_imageSize_Mat_R_Mat_T_int_flags_TermCriteria_criteria
// parsed: cv::fisheye::stereoCalibrate
// as:     cv::fisheye::stereoCalibrate (function)
// Arg ARG Vector[cv::Mat (boxed)] objectPoints= Vector[cv::Mat (boxed)] = 
// Arg ARG Vector[cv::Mat (boxed)] imagePoints1= Vector[cv::Mat (boxed)] = 
// Arg ARG Vector[cv::Mat (boxed)] imagePoints2= Vector[cv::Mat (boxed)] = 
// Arg ARG cv::Mat (boxed) K1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) D1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) K2= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) D2= cv::Mat (boxed) = 
// Arg ARG cv::Size (simple) imageSize= cv::Size (simple) = 
// Arg ARG cv::Mat (boxed) R= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) T= cv::Mat (boxed) = 
// Arg ARG Primitive(int) flags= Primitive(int) = fisheye::CALIB_FIX_INTRINSIC
// Arg ARG cv::TermCriteria (boxed) criteria= cv::TermCriteria (boxed) = TermCriteria(TermCriteria::COUNT + TermCriteria::EPS, 100, DBL_EPSILON)
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_fisheye_stereoCalibrate_VectorOfMat_objectPoints_VectorOfMat_imagePoints1_VectorOfMat_imagePoints2_Mat_K1_Mat_D1_Mat_K2_Mat_D2_Size_imageSize_Mat_R_Mat_T_int_flags_TermCriteria_criteria(void* objectPoints, void* imagePoints1, void* imagePoints2, void* K1, void* D1, void* K2, void* D2, SizeWrapper imageSize, void* R, void* T, int flags, void* criteria) {
    try {
        double ret = cv::fisheye::stereoCalibrate(*reinterpret_cast<std::vector<cv::Mat>*>(objectPoints), *reinterpret_cast<std::vector<cv::Mat>*>(imagePoints1), *reinterpret_cast<std::vector<cv::Mat>*>(imagePoints2), *reinterpret_cast<cv::Mat*>(K1), *reinterpret_cast<cv::Mat*>(D1), *reinterpret_cast<cv::Mat*>(K2), *reinterpret_cast<cv::Mat*>(D2), *reinterpret_cast<cv::Size*>(&imageSize), *reinterpret_cast<cv::Mat*>(R), *reinterpret_cast<cv::Mat*>(T), flags, *reinterpret_cast<cv::TermCriteria*>(criteria));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_fisheye_stereoRectify_Mat_K1_Mat_D1_Mat_K2_Mat_D2_Size_imageSize_Mat_R_Mat_tvec_Mat_R1_Mat_R2_Mat_P1_Mat_P2_Mat_Q_int_flags_Size_newImageSize_double_balance_double_fov_scale
// parsed: cv::fisheye::stereoRectify
// as:     cv::fisheye::stereoRectify (function)
// Arg ARG cv::Mat (boxed) K1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) D1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) K2= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) D2= cv::Mat (boxed) = 
// Arg ARG cv::Size (simple) imageSize= cv::Size (simple) = 
// Arg ARG cv::Mat (boxed) R= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) tvec= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) R1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) R2= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) P1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) P2= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) Q= cv::Mat (boxed) = 
// Arg ARG Primitive(int) flags= Primitive(int) = 
// Arg ARG cv::Size (simple) newImageSize= cv::Size (simple) = Size()
// Arg ARG Primitive(double) balance= Primitive(double) = 0.0
// Arg ARG Primitive(double) fov_scale= Primitive(double) = 1.0
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_fisheye_stereoRectify_Mat_K1_Mat_D1_Mat_K2_Mat_D2_Size_imageSize_Mat_R_Mat_tvec_Mat_R1_Mat_R2_Mat_P1_Mat_P2_Mat_Q_int_flags_Size_newImageSize_double_balance_double_fov_scale(void* K1, void* D1, void* K2, void* D2, SizeWrapper imageSize, void* R, void* tvec, void* R1, void* R2, void* P1, void* P2, void* Q, int flags, SizeWrapper newImageSize, double balance, double fov_scale) {
    try {
        cv::fisheye::stereoRectify(*reinterpret_cast<cv::Mat*>(K1), *reinterpret_cast<cv::Mat*>(D1), *reinterpret_cast<cv::Mat*>(K2), *reinterpret_cast<cv::Mat*>(D2), *reinterpret_cast<cv::Size*>(&imageSize), *reinterpret_cast<cv::Mat*>(R), *reinterpret_cast<cv::Mat*>(tvec), *reinterpret_cast<cv::Mat*>(R1), *reinterpret_cast<cv::Mat*>(R2), *reinterpret_cast<cv::Mat*>(P1), *reinterpret_cast<cv::Mat*>(P2), *reinterpret_cast<cv::Mat*>(Q), flags, *reinterpret_cast<cv::Size*>(&newImageSize), balance, fov_scale);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_fisheye_undistortImage_Mat_distorted_Mat_undistorted_Mat_K_Mat_D_Mat_Knew_Size_new_size
// parsed: cv::fisheye::undistortImage
// as:     cv::fisheye::undistortImage (function)
// Arg ARG cv::Mat (boxed) distorted= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) undistorted= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) K= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) D= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) Knew= cv::Mat (boxed) = cv::noArray()
// Arg ARG cv::Size (simple) new_size= cv::Size (simple) = Size()
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_fisheye_undistortImage_Mat_distorted_Mat_undistorted_Mat_K_Mat_D_Mat_Knew_Size_new_size(void* distorted, void* undistorted, void* K, void* D, void* Knew, SizeWrapper new_size) {
    try {
        cv::fisheye::undistortImage(*reinterpret_cast<cv::Mat*>(distorted), *reinterpret_cast<cv::Mat*>(undistorted), *reinterpret_cast<cv::Mat*>(K), *reinterpret_cast<cv::Mat*>(D), *reinterpret_cast<cv::Mat*>(Knew), *reinterpret_cast<cv::Size*>(&new_size));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_fisheye_undistortPoints_Mat_distorted_Mat_undistorted_Mat_K_Mat_D_Mat_R_Mat_P
// parsed: cv::fisheye::undistortPoints
// as:     cv::fisheye::undistortPoints (function)
// Arg ARG cv::Mat (boxed) distorted= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) undistorted= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) K= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) D= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) R= cv::Mat (boxed) = noArray()
// Arg ARG cv::Mat (boxed) P= cv::Mat (boxed) = noArray()
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_fisheye_undistortPoints_Mat_distorted_Mat_undistorted_Mat_K_Mat_D_Mat_R_Mat_P(void* distorted, void* undistorted, void* K, void* D, void* R, void* P) {
    try {
        cv::fisheye::undistortPoints(*reinterpret_cast<cv::Mat*>(distorted), *reinterpret_cast<cv::Mat*>(undistorted), *reinterpret_cast<cv::Mat*>(K), *reinterpret_cast<cv::Mat*>(D), *reinterpret_cast<cv::Mat*>(R), *reinterpret_cast<cv::Mat*>(P));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_fitEllipseAMS_Mat_points
// parsed: cv::fitEllipseAMS
// as:     cv::fitEllipseAMS (function)
// Arg ARG cv::Mat (boxed) points= cv::Mat (boxed) = 
// Return value: cv::RotatedRect (boxed)
cv_return_value_void_X cv_core_cv_fitEllipseAMS_Mat_points(void* points) {
    try {
        cv::RotatedRect ret = cv::fitEllipseAMS(*reinterpret_cast<cv::Mat*>(points));
        return { Error::Code::StsOk, NULL, new cv::RotatedRect(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_fitEllipseDirect_Mat_points
// parsed: cv::fitEllipseDirect
// as:     cv::fitEllipseDirect (function)
// Arg ARG cv::Mat (boxed) points= cv::Mat (boxed) = 
// Return value: cv::RotatedRect (boxed)
cv_return_value_void_X cv_core_cv_fitEllipseDirect_Mat_points(void* points) {
    try {
        cv::RotatedRect ret = cv::fitEllipseDirect(*reinterpret_cast<cv::Mat*>(points));
        return { Error::Code::StsOk, NULL, new cv::RotatedRect(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_fitEllipse_Mat_points
// parsed: cv::fitEllipse
// as:     cv::fitEllipse (function)
// Arg ARG cv::Mat (boxed) points= cv::Mat (boxed) = 
// Return value: cv::RotatedRect (boxed)
cv_return_value_void_X cv_core_cv_fitEllipse_Mat_points(void* points) {
    try {
        cv::RotatedRect ret = cv::fitEllipse(*reinterpret_cast<cv::Mat*>(points));
        return { Error::Code::StsOk, NULL, new cv::RotatedRect(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_fitLine_Mat_points_Mat_line_int_distType_double_param_double_reps_double_aeps
// parsed: cv::fitLine
// as:     cv::fitLine (function)
// Arg ARG cv::Mat (boxed) points= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) line= cv::Mat (boxed) = 
// Arg ARG Primitive(int) distType= Primitive(int) = 
// Arg ARG Primitive(double) param= Primitive(double) = 
// Arg ARG Primitive(double) reps= Primitive(double) = 
// Arg ARG Primitive(double) aeps= Primitive(double) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_fitLine_Mat_points_Mat_line_int_distType_double_param_double_reps_double_aeps(void* points, void* line, int distType, double param, double reps, double aeps) {
    try {
        cv::fitLine(*reinterpret_cast<cv::Mat*>(points), *reinterpret_cast<cv::Mat*>(line), distType, param, reps, aeps);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_flip_Mat_src_Mat_dst_int_flipCode
// parsed: cv::flip
// as:     cv::flip (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG Primitive(int) flipCode= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_flip_Mat_src_Mat_dst_int_flipCode(void* src, void* dst, int flipCode) {
    try {
        cv::flip(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst), flipCode);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_floodFill_Mat_image_Mat_mask_Point_seedPoint_Scalar_newVal_Rect_X_rect_Scalar_loDiff_Scalar_upDiff_int_flags
// parsed: cv::floodFill
// as:     cv::floodFill (function)
// Arg ARG cv::Mat (boxed) image= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) mask= cv::Mat (boxed) = 
// Arg ARG cv::Point (simple) seedPoint= cv::Point (simple) = 
// Arg ARG cv::Scalar (simple) newVal= cv::Scalar (simple) = 
// Arg ARG RawPtr[cv::Rect (simple)] * rect= (ptr) RawPtr[cv::Rect (simple)] = 0
// Arg ARG cv::Scalar (simple) loDiff= cv::Scalar (simple) = Scalar()
// Arg ARG cv::Scalar (simple) upDiff= cv::Scalar (simple) = Scalar()
// Arg ARG Primitive(int) flags= Primitive(int) = 4
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_floodFill_Mat_image_Mat_mask_Point_seedPoint_Scalar_newVal_Rect_X_rect_Scalar_loDiff_Scalar_upDiff_int_flags(void* image, void* mask, PointWrapper seedPoint, ScalarWrapper newVal, cv::Rect* rect, ScalarWrapper loDiff, ScalarWrapper upDiff, int flags) {
    try {
        int ret = cv::floodFill(*reinterpret_cast<cv::Mat*>(image), *reinterpret_cast<cv::Mat*>(mask), *reinterpret_cast<cv::Point*>(&seedPoint), *reinterpret_cast<cv::Scalar*>(&newVal), reinterpret_cast<cv::Rect*>(&rect), *reinterpret_cast<cv::Scalar*>(&loDiff), *reinterpret_cast<cv::Scalar*>(&upDiff), flags);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_floodFill_Mat_image_Point_seedPoint_Scalar_newVal_Rect_X_rect_Scalar_loDiff_Scalar_upDiff_int_flags
// parsed: cv::floodFill
// as:     cv::floodFill (function)
// Arg ARG cv::Mat (boxed) image= cv::Mat (boxed) = 
// Arg ARG cv::Point (simple) seedPoint= cv::Point (simple) = 
// Arg ARG cv::Scalar (simple) newVal= cv::Scalar (simple) = 
// Arg ARG RawPtr[cv::Rect (simple)] * rect= (ptr) RawPtr[cv::Rect (simple)] = 0
// Arg ARG cv::Scalar (simple) loDiff= cv::Scalar (simple) = Scalar()
// Arg ARG cv::Scalar (simple) upDiff= cv::Scalar (simple) = Scalar()
// Arg ARG Primitive(int) flags= Primitive(int) = 4
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_floodFill_Mat_image_Point_seedPoint_Scalar_newVal_Rect_X_rect_Scalar_loDiff_Scalar_upDiff_int_flags(void* image, PointWrapper seedPoint, ScalarWrapper newVal, cv::Rect* rect, ScalarWrapper loDiff, ScalarWrapper upDiff, int flags) {
    try {
        int ret = cv::floodFill(*reinterpret_cast<cv::Mat*>(image), *reinterpret_cast<cv::Point*>(&seedPoint), *reinterpret_cast<cv::Scalar*>(&newVal), reinterpret_cast<cv::Rect*>(&rect), *reinterpret_cast<cv::Scalar*>(&loDiff), *reinterpret_cast<cv::Scalar*>(&upDiff), flags);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_fontQt_String_nameFont_int_pointSize_Scalar_color_int_weight_int_style_int_spacing
// parsed: cv::fontQt
// as:     cv::fontQt (function)
// Arg ARG string nameFont= string = 
// Arg ARG Primitive(int) pointSize= Primitive(int) = -1
// Arg ARG cv::Scalar (simple) color= cv::Scalar (simple) = Scalar::all(0)
// Arg ARG Primitive(int) weight= Primitive(int) = QT_FONT_NORMAL
// Arg ARG Primitive(int) style= Primitive(int) = QT_STYLE_NORMAL
// Arg ARG Primitive(int) spacing= Primitive(int) = 0
// Return value: cv::QtFont (boxed)
cv_return_value_void_X cv_core_cv_fontQt_String_nameFont_int_pointSize_Scalar_color_int_weight_int_style_int_spacing(const char* nameFont, int pointSize, ScalarWrapper color, int weight, int style, int spacing) {
    try {
        cv::QtFont ret = cv::fontQt(String(nameFont), pointSize, *reinterpret_cast<cv::Scalar*>(&color), weight, style, spacing);
        return { Error::Code::StsOk, NULL, new cv::QtFont(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_gemm_Mat_src1_Mat_src2_double_alpha_Mat_src3_double_beta_Mat_dst_int_flags
// parsed: cv::gemm
// as:     cv::gemm (function)
// Arg ARG cv::Mat (boxed) src1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) src2= cv::Mat (boxed) = 
// Arg ARG Primitive(double) alpha= Primitive(double) = 
// Arg ARG cv::Mat (boxed) src3= cv::Mat (boxed) = 
// Arg ARG Primitive(double) beta= Primitive(double) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG Primitive(int) flags= Primitive(int) = 0
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_gemm_Mat_src1_Mat_src2_double_alpha_Mat_src3_double_beta_Mat_dst_int_flags(void* src1, void* src2, double alpha, void* src3, double beta, void* dst, int flags) {
    try {
        cv::gemm(*reinterpret_cast<cv::Mat*>(src1), *reinterpret_cast<cv::Mat*>(src2), alpha, *reinterpret_cast<cv::Mat*>(src3), beta, *reinterpret_cast<cv::Mat*>(dst), flags);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_getAffineTransform_Mat_src_Mat_dst
// parsed: cv::getAffineTransform
// as:     cv::getAffineTransform (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_getAffineTransform_Mat_src_Mat_dst(void* src, void* dst) {
    try {
        cv::Mat ret = cv::getAffineTransform(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst));
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_getAffineTransform_const_Point2f_X_src_const_Point2f_X_dst
// parsed: cv::getAffineTransform
// as:     cv::getAffineTransform (function)
// Arg ARG RawPtr[cv::Point2f (simple)] * src= (ptr) RawPtr[cv::Point2f (simple)] = 
// Arg ARG RawPtr[cv::Point2f (simple)] * dst= (ptr) RawPtr[cv::Point2f (simple)] = 
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_getAffineTransform_const_Point2f_X_src_const_Point2f_X_dst(const cv::Point2f* src, const cv::Point2f* dst) {
    try {
        cv::Mat ret = cv::getAffineTransform(reinterpret_cast<cv::Point2f*>(&src), reinterpret_cast<cv::Point2f*>(&dst));
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_getBuildInformation
// parsed: cv::getBuildInformation
// as:     cv::getBuildInformation (function)
// Return value: string
cv_return_value_const_char_X cv_core_cv_getBuildInformation() {
    try {
        String ret = cv::getBuildInformation();
        return { Error::Code::StsOk, NULL, strdup(ret.c_str()) };
    } CVRS_CATCH(cv_return_value_const_char_X)
}

// cv_getCPUTickCount
// parsed: cv::getCPUTickCount
// as:     cv::getCPUTickCount (function)
// Return value: Primitive(int64)
cv_return_value_int64 cv_core_cv_getCPUTickCount() {
    try {
        int64 ret = cv::getCPUTickCount();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int64*>(&ret) };
    } CVRS_CATCH(cv_return_value_int64)
}

// cv_getDefaultNewCameraMatrix_Mat_cameraMatrix_Size_imgsize_bool_centerPrincipalPoint
// parsed: cv::getDefaultNewCameraMatrix
// as:     cv::getDefaultNewCameraMatrix (function)
// Arg ARG cv::Mat (boxed) cameraMatrix= cv::Mat (boxed) = 
// Arg ARG cv::Size (simple) imgsize= cv::Size (simple) = Size()
// Arg ARG Primitive(bool) centerPrincipalPoint= Primitive(bool) = false
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_getDefaultNewCameraMatrix_Mat_cameraMatrix_Size_imgsize_bool_centerPrincipalPoint(void* cameraMatrix, SizeWrapper imgsize, bool centerPrincipalPoint) {
    try {
        cv::Mat ret = cv::getDefaultNewCameraMatrix(*reinterpret_cast<cv::Mat*>(cameraMatrix), *reinterpret_cast<cv::Size*>(&imgsize), centerPrincipalPoint);
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_getDerivKernels_Mat_kx_Mat_ky_int_dx_int_dy_int_ksize_bool_normalize_int_ktype
// parsed: cv::getDerivKernels
// as:     cv::getDerivKernels (function)
// Arg ARG cv::Mat (boxed) kx= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) ky= cv::Mat (boxed) = 
// Arg ARG Primitive(int) dx= Primitive(int) = 
// Arg ARG Primitive(int) dy= Primitive(int) = 
// Arg ARG Primitive(int) ksize= Primitive(int) = 
// Arg ARG Primitive(bool) normalize= Primitive(bool) = false
// Arg ARG Primitive(int) ktype= Primitive(int) = CV_32F
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_getDerivKernels_Mat_kx_Mat_ky_int_dx_int_dy_int_ksize_bool_normalize_int_ktype(void* kx, void* ky, int dx, int dy, int ksize, bool normalize, int ktype) {
    try {
        cv::getDerivKernels(*reinterpret_cast<cv::Mat*>(kx), *reinterpret_cast<cv::Mat*>(ky), dx, dy, ksize, normalize, ktype);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_getElemSize_int_type
// parsed: cv::getElemSize
// as:     cv::getElemSize (function)
// Arg ARG Primitive(int) type= Primitive(int) = 
// Return value: Primitive(size_t)
cv_return_value_std_size_t cv_core_cv_getElemSize_int_type(int type) {
    try {
        size_t ret = cv::getElemSize(type);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<std::size_t*>(&ret) };
    } CVRS_CATCH(cv_return_value_std_size_t)
}

// cv_getFontScaleFromHeight_int_fontFace_int_pixelHeight_int_thickness
// parsed: cv::getFontScaleFromHeight
// as:     cv::getFontScaleFromHeight (function)
// Arg ARG Primitive(int) fontFace= Primitive(int) = 
// Arg ARG Primitive(int) pixelHeight= Primitive(int) = 
// Arg ARG Primitive(int) thickness= Primitive(int) = 1
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_getFontScaleFromHeight_int_fontFace_int_pixelHeight_int_thickness(int fontFace, int pixelHeight, int thickness) {
    try {
        double ret = cv::getFontScaleFromHeight(fontFace, pixelHeight, thickness);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_getGaborKernel_Size_ksize_double_sigma_double_theta_double_lambd_double_gamma_double_psi_int_ktype
// parsed: cv::getGaborKernel
// as:     cv::getGaborKernel (function)
// Arg ARG cv::Size (simple) ksize= cv::Size (simple) = 
// Arg ARG Primitive(double) sigma= Primitive(double) = 
// Arg ARG Primitive(double) theta= Primitive(double) = 
// Arg ARG Primitive(double) lambd= Primitive(double) = 
// Arg ARG Primitive(double) gamma= Primitive(double) = 
// Arg ARG Primitive(double) psi= Primitive(double) = CV_PI*0.5
// Arg ARG Primitive(int) ktype= Primitive(int) = CV_64F
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_getGaborKernel_Size_ksize_double_sigma_double_theta_double_lambd_double_gamma_double_psi_int_ktype(SizeWrapper ksize, double sigma, double theta, double lambd, double gamma, double psi, int ktype) {
    try {
        cv::Mat ret = cv::getGaborKernel(*reinterpret_cast<cv::Size*>(&ksize), sigma, theta, lambd, gamma, psi, ktype);
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_getGaussianKernel_int_ksize_double_sigma_int_ktype
// parsed: cv::getGaussianKernel
// as:     cv::getGaussianKernel (function)
// Arg ARG Primitive(int) ksize= Primitive(int) = 
// Arg ARG Primitive(double) sigma= Primitive(double) = 
// Arg ARG Primitive(int) ktype= Primitive(int) = CV_64F
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_getGaussianKernel_int_ksize_double_sigma_int_ktype(int ksize, double sigma, int ktype) {
    try {
        cv::Mat ret = cv::getGaussianKernel(ksize, sigma, ktype);
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_getHardwareFeatureName_int_feature
// parsed: cv::getHardwareFeatureName
// as:     cv::getHardwareFeatureName (function)
// Arg ARG Primitive(int) feature= Primitive(int) = 
// Return value: string
cv_return_value_char_X cv_core_cv_getHardwareFeatureName_int_feature(int feature) {
    try {
        String ret = cv::getHardwareFeatureName(feature);
        return { Error::Code::StsOk, NULL, strdup(ret.c_str()) };
    } CVRS_CATCH(cv_return_value_char_X)
}

// cv_getMouseWheelDelta_int_flags
// parsed: cv::getMouseWheelDelta
// as:     cv::getMouseWheelDelta (function)
// Arg ARG Primitive(int) flags= Primitive(int) = 
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_getMouseWheelDelta_int_flags(int flags) {
    try {
        int ret = cv::getMouseWheelDelta(flags);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_getNearestPoint_VectorOfPoint2f_recallPrecisionCurve_float_l_precision
// parsed: cv::getNearestPoint
// as:     cv::getNearestPoint (function)
// Arg ARG Vector[cv::Point2f (simple)] recallPrecisionCurve= Vector[cv::Point2f (simple)] = 
// Arg ARG Primitive(float) l_precision= Primitive(float) = 
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_getNearestPoint_VectorOfPoint2f_recallPrecisionCurve_float_l_precision(void* recallPrecisionCurve, float l_precision) {
    try {
        int ret = cv::getNearestPoint(*reinterpret_cast<std::vector<cv::Point2f>*>(recallPrecisionCurve), l_precision);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_getNumThreads
// parsed: cv::getNumThreads
// as:     cv::getNumThreads (function)
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_getNumThreads() {
    try {
        int ret = cv::getNumThreads();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_getNumberOfCPUs
// parsed: cv::getNumberOfCPUs
// as:     cv::getNumberOfCPUs (function)
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_getNumberOfCPUs() {
    try {
        int ret = cv::getNumberOfCPUs();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_getOptimalDFTSize_int_vecsize
// parsed: cv::getOptimalDFTSize
// as:     cv::getOptimalDFTSize (function)
// Arg ARG Primitive(int) vecsize= Primitive(int) = 
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_getOptimalDFTSize_int_vecsize(int vecsize) {
    try {
        int ret = cv::getOptimalDFTSize(vecsize);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_getOptimalNewCameraMatrix_Mat_cameraMatrix_Mat_distCoeffs_Size_imageSize_double_alpha_Size_newImgSize_Rect_X_validPixROI_bool_centerPrincipalPoint
// parsed: cv::getOptimalNewCameraMatrix
// as:     cv::getOptimalNewCameraMatrix (function)
// Arg ARG cv::Mat (boxed) cameraMatrix= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) distCoeffs= cv::Mat (boxed) = 
// Arg ARG cv::Size (simple) imageSize= cv::Size (simple) = 
// Arg ARG Primitive(double) alpha= Primitive(double) = 
// Arg ARG cv::Size (simple) newImgSize= cv::Size (simple) = Size()
// Arg ARG RawPtr[cv::Rect (simple)] * validPixROI= (ptr) RawPtr[cv::Rect (simple)] = 0
// Arg ARG Primitive(bool) centerPrincipalPoint= Primitive(bool) = false
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_getOptimalNewCameraMatrix_Mat_cameraMatrix_Mat_distCoeffs_Size_imageSize_double_alpha_Size_newImgSize_Rect_X_validPixROI_bool_centerPrincipalPoint(void* cameraMatrix, void* distCoeffs, SizeWrapper imageSize, double alpha, SizeWrapper newImgSize, cv::Rect* validPixROI, bool centerPrincipalPoint) {
    try {
        cv::Mat ret = cv::getOptimalNewCameraMatrix(*reinterpret_cast<cv::Mat*>(cameraMatrix), *reinterpret_cast<cv::Mat*>(distCoeffs), *reinterpret_cast<cv::Size*>(&imageSize), alpha, *reinterpret_cast<cv::Size*>(&newImgSize), reinterpret_cast<cv::Rect*>(&validPixROI), centerPrincipalPoint);
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_getPerspectiveTransform_Mat_src_Mat_dst
// parsed: cv::getPerspectiveTransform
// as:     cv::getPerspectiveTransform (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_getPerspectiveTransform_Mat_src_Mat_dst(void* src, void* dst) {
    try {
        cv::Mat ret = cv::getPerspectiveTransform(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst));
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_getPerspectiveTransform_const_Point2f_X_src_const_Point2f_X_dst
// parsed: cv::getPerspectiveTransform
// as:     cv::getPerspectiveTransform (function)
// Arg ARG RawPtr[cv::Point2f (simple)] * src= (ptr) RawPtr[cv::Point2f (simple)] = 
// Arg ARG RawPtr[cv::Point2f (simple)] * dst= (ptr) RawPtr[cv::Point2f (simple)] = 
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_getPerspectiveTransform_const_Point2f_X_src_const_Point2f_X_dst(const cv::Point2f* src, const cv::Point2f* dst) {
    try {
        cv::Mat ret = cv::getPerspectiveTransform(reinterpret_cast<cv::Point2f*>(&src), reinterpret_cast<cv::Point2f*>(&dst));
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_getRecall_VectorOfPoint2f_recallPrecisionCurve_float_l_precision
// parsed: cv::getRecall
// as:     cv::getRecall (function)
// Arg ARG Vector[cv::Point2f (simple)] recallPrecisionCurve= Vector[cv::Point2f (simple)] = 
// Arg ARG Primitive(float) l_precision= Primitive(float) = 
// Return value: Primitive(float)
cv_return_value_float cv_core_cv_getRecall_VectorOfPoint2f_recallPrecisionCurve_float_l_precision(void* recallPrecisionCurve, float l_precision) {
    try {
        float ret = cv::getRecall(*reinterpret_cast<std::vector<cv::Point2f>*>(recallPrecisionCurve), l_precision);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<float*>(&ret) };
    } CVRS_CATCH(cv_return_value_float)
}

// cv_getRectSubPix_Mat_image_Size_patchSize_Point2f_center_Mat_patch_int_patchType
// parsed: cv::getRectSubPix
// as:     cv::getRectSubPix (function)
// Arg ARG cv::Mat (boxed) image= cv::Mat (boxed) = 
// Arg ARG cv::Size (simple) patchSize= cv::Size (simple) = 
// Arg ARG cv::Point2f (simple) center= cv::Point2f (simple) = 
// Arg ARG cv::Mat (boxed) patch= cv::Mat (boxed) = 
// Arg ARG Primitive(int) patchType= Primitive(int) = -1
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_getRectSubPix_Mat_image_Size_patchSize_Point2f_center_Mat_patch_int_patchType(void* image, SizeWrapper patchSize, Point2fWrapper center, void* patch, int patchType) {
    try {
        cv::getRectSubPix(*reinterpret_cast<cv::Mat*>(image), *reinterpret_cast<cv::Size*>(&patchSize), *reinterpret_cast<cv::Point2f*>(&center), *reinterpret_cast<cv::Mat*>(patch), patchType);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_getRotationMatrix2D_Point2f_center_double_angle_double_scale
// parsed: cv::getRotationMatrix2D
// as:     cv::getRotationMatrix2D (function)
// Arg ARG cv::Point2f (simple) center= cv::Point2f (simple) = 
// Arg ARG Primitive(double) angle= Primitive(double) = 
// Arg ARG Primitive(double) scale= Primitive(double) = 
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_getRotationMatrix2D_Point2f_center_double_angle_double_scale(Point2fWrapper center, double angle, double scale) {
    try {
        cv::Mat ret = cv::getRotationMatrix2D(*reinterpret_cast<cv::Point2f*>(&center), angle, scale);
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_getStructuringElement_int_shape_Size_ksize_Point_anchor
// parsed: cv::getStructuringElement
// as:     cv::getStructuringElement (function)
// Arg ARG Primitive(int) shape= Primitive(int) = 
// Arg ARG cv::Size (simple) ksize= cv::Size (simple) = 
// Arg ARG cv::Point (simple) anchor= cv::Point (simple) = Point(-1,-1)
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_getStructuringElement_int_shape_Size_ksize_Point_anchor(int shape, SizeWrapper ksize, PointWrapper anchor) {
    try {
        cv::Mat ret = cv::getStructuringElement(shape, *reinterpret_cast<cv::Size*>(&ksize), *reinterpret_cast<cv::Point*>(&anchor));
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_getTextSize_String_text_int_fontFace_double_fontScale_int_thickness_int_X_baseLine
// parsed: cv::getTextSize
// as:     cv::getTextSize (function)
// Arg ARG string text= string = 
// Arg ARG Primitive(int) fontFace= Primitive(int) = 
// Arg ARG Primitive(double) fontScale= Primitive(double) = 
// Arg ARG Primitive(int) thickness= Primitive(int) = 
// Arg ARG RawPtr[Primitive(int)] * baseLine= (ptr) RawPtr[Primitive(int)] = 
// Return value: cv::Size (simple)
cv_return_value_SizeWrapper cv_core_cv_getTextSize_String_text_int_fontFace_double_fontScale_int_thickness_int_X_baseLine(const char* text, int fontFace, double fontScale, int thickness, int* baseLine) {
    try {
        cv::Size ret = cv::getTextSize(String(text), fontFace, fontScale, thickness, baseLine);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<SizeWrapper*>(&ret) };
    } CVRS_CATCH(cv_return_value_SizeWrapper)
}

// cv_getThreadNum
// parsed: cv::getThreadNum
// as:     cv::getThreadNum (function)
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_getThreadNum() {
    try {
        int ret = cv::getThreadNum();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_getTickCount
// parsed: cv::getTickCount
// as:     cv::getTickCount (function)
// Return value: Primitive(int64)
cv_return_value_int64 cv_core_cv_getTickCount() {
    try {
        int64 ret = cv::getTickCount();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int64*>(&ret) };
    } CVRS_CATCH(cv_return_value_int64)
}

// cv_getTickFrequency
// parsed: cv::getTickFrequency
// as:     cv::getTickFrequency (function)
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_getTickFrequency() {
    try {
        double ret = cv::getTickFrequency();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_getTrackbarPos_String_trackbarname_String_winname
// parsed: cv::getTrackbarPos
// as:     cv::getTrackbarPos (function)
// Arg ARG string trackbarname= string = 
// Arg ARG string winname= string = 
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_getTrackbarPos_String_trackbarname_String_winname(const char* trackbarname, const char* winname) {
    try {
        int ret = cv::getTrackbarPos(String(trackbarname), String(winname));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_getValidDisparityROI_Rect_roi1_Rect_roi2_int_minDisparity_int_numberOfDisparities_int_SADWindowSize
// parsed: cv::getValidDisparityROI
// as:     cv::getValidDisparityROI (function)
// Arg ARG cv::Rect (simple) roi1= cv::Rect (simple) = 
// Arg ARG cv::Rect (simple) roi2= cv::Rect (simple) = 
// Arg ARG Primitive(int) minDisparity= Primitive(int) = 
// Arg ARG Primitive(int) numberOfDisparities= Primitive(int) = 
// Arg ARG Primitive(int) SADWindowSize= Primitive(int) = 
// Return value: cv::Rect (simple)
cv_return_value_RectWrapper cv_core_cv_getValidDisparityROI_Rect_roi1_Rect_roi2_int_minDisparity_int_numberOfDisparities_int_SADWindowSize(RectWrapper roi1, RectWrapper roi2, int minDisparity, int numberOfDisparities, int SADWindowSize) {
    try {
        cv::Rect ret = cv::getValidDisparityROI(*reinterpret_cast<cv::Rect*>(&roi1), *reinterpret_cast<cv::Rect*>(&roi2), minDisparity, numberOfDisparities, SADWindowSize);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<RectWrapper*>(&ret) };
    } CVRS_CATCH(cv_return_value_RectWrapper)
}

// cv_getVersionMajor
// parsed: cv::getVersionMajor
// as:     cv::getVersionMajor (function)
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_getVersionMajor() {
    try {
        int ret = cv::getVersionMajor();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_getVersionMinor
// parsed: cv::getVersionMinor
// as:     cv::getVersionMinor (function)
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_getVersionMinor() {
    try {
        int ret = cv::getVersionMinor();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_getVersionRevision
// parsed: cv::getVersionRevision
// as:     cv::getVersionRevision (function)
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_getVersionRevision() {
    try {
        int ret = cv::getVersionRevision();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_getVersionString
// parsed: cv::getVersionString
// as:     cv::getVersionString (function)
// Return value: string
cv_return_value_char_X cv_core_cv_getVersionString() {
    try {
        String ret = cv::getVersionString();
        return { Error::Code::StsOk, NULL, strdup(ret.c_str()) };
    } CVRS_CATCH(cv_return_value_char_X)
}

// cv_getWindowImageRect_String_winname
// parsed: cv::getWindowImageRect
// as:     cv::getWindowImageRect (function)
// Arg ARG string winname= string = 
// Return value: cv::Rect (simple)
cv_return_value_RectWrapper cv_core_cv_getWindowImageRect_String_winname(const char* winname) {
    try {
        cv::Rect ret = cv::getWindowImageRect(String(winname));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<RectWrapper*>(&ret) };
    } CVRS_CATCH(cv_return_value_RectWrapper)
}

// cv_getWindowProperty_String_winname_int_prop_id
// parsed: cv::getWindowProperty
// as:     cv::getWindowProperty (function)
// Arg ARG string winname= string = 
// Arg ARG Primitive(int) prop_id= Primitive(int) = 
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_getWindowProperty_String_winname_int_prop_id(const char* winname, int prop_id) {
    try {
        double ret = cv::getWindowProperty(String(winname), prop_id);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_glob_String_pattern_VectorOfString_result_bool_recursive
// parsed: cv::glob
// as:     cv::glob (function)
// Arg ARG string pattern= string = 
// Arg ARG Vector[string] result= Vector[string] = 
// Arg ARG Primitive(bool) recursive= Primitive(bool) = false
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_glob_String_pattern_VectorOfString_result_bool_recursive(const char* pattern, void* result, bool recursive) {
    try {
        cv::glob(String(pattern), *reinterpret_cast<std::vector<String>*>(result), recursive);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_goodFeaturesToTrack_Mat_image_Mat_corners_int_maxCorners_double_qualityLevel_double_minDistance_Mat_mask_int_blockSize_bool_useHarrisDetector_double_k
// parsed: cv::goodFeaturesToTrack
// as:     cv::goodFeaturesToTrack (function)
// Arg ARG cv::Mat (boxed) image= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) corners= cv::Mat (boxed) = 
// Arg ARG Primitive(int) maxCorners= Primitive(int) = 
// Arg ARG Primitive(double) qualityLevel= Primitive(double) = 
// Arg ARG Primitive(double) minDistance= Primitive(double) = 
// Arg ARG cv::Mat (boxed) mask= cv::Mat (boxed) = noArray()
// Arg ARG Primitive(int) blockSize= Primitive(int) = 3
// Arg ARG Primitive(bool) useHarrisDetector= Primitive(bool) = false
// Arg ARG Primitive(double) k= Primitive(double) = 0.04
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_goodFeaturesToTrack_Mat_image_Mat_corners_int_maxCorners_double_qualityLevel_double_minDistance_Mat_mask_int_blockSize_bool_useHarrisDetector_double_k(void* image, void* corners, int maxCorners, double qualityLevel, double minDistance, void* mask, int blockSize, bool useHarrisDetector, double k) {
    try {
        cv::goodFeaturesToTrack(*reinterpret_cast<cv::Mat*>(image), *reinterpret_cast<cv::Mat*>(corners), maxCorners, qualityLevel, minDistance, *reinterpret_cast<cv::Mat*>(mask), blockSize, useHarrisDetector, k);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_goodFeaturesToTrack_Mat_image_Mat_corners_int_maxCorners_double_qualityLevel_double_minDistance_Mat_mask_int_blockSize_int_gradientSize_bool_useHarrisDetector_double_k
// parsed: cv::goodFeaturesToTrack
// as:     cv::goodFeaturesToTrack (function)
// Arg ARG cv::Mat (boxed) image= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) corners= cv::Mat (boxed) = 
// Arg ARG Primitive(int) maxCorners= Primitive(int) = 
// Arg ARG Primitive(double) qualityLevel= Primitive(double) = 
// Arg ARG Primitive(double) minDistance= Primitive(double) = 
// Arg ARG cv::Mat (boxed) mask= cv::Mat (boxed) = 
// Arg ARG Primitive(int) blockSize= Primitive(int) = 
// Arg ARG Primitive(int) gradientSize= Primitive(int) = 
// Arg ARG Primitive(bool) useHarrisDetector= Primitive(bool) = false
// Arg ARG Primitive(double) k= Primitive(double) = 0.04
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_goodFeaturesToTrack_Mat_image_Mat_corners_int_maxCorners_double_qualityLevel_double_minDistance_Mat_mask_int_blockSize_int_gradientSize_bool_useHarrisDetector_double_k(void* image, void* corners, int maxCorners, double qualityLevel, double minDistance, void* mask, int blockSize, int gradientSize, bool useHarrisDetector, double k) {
    try {
        cv::goodFeaturesToTrack(*reinterpret_cast<cv::Mat*>(image), *reinterpret_cast<cv::Mat*>(corners), maxCorners, qualityLevel, minDistance, *reinterpret_cast<cv::Mat*>(mask), blockSize, gradientSize, useHarrisDetector, k);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_grabCut_Mat_img_Mat_mask_Rect_rect_Mat_bgdModel_Mat_fgdModel_int_iterCount_int_mode
// parsed: cv::grabCut
// as:     cv::grabCut (function)
// Arg ARG cv::Mat (boxed) img= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) mask= cv::Mat (boxed) = 
// Arg ARG cv::Rect (simple) rect= cv::Rect (simple) = 
// Arg ARG cv::Mat (boxed) bgdModel= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) fgdModel= cv::Mat (boxed) = 
// Arg ARG Primitive(int) iterCount= Primitive(int) = 
// Arg ARG Primitive(int) mode= Primitive(int) = GC_EVAL
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_grabCut_Mat_img_Mat_mask_Rect_rect_Mat_bgdModel_Mat_fgdModel_int_iterCount_int_mode(void* img, void* mask, RectWrapper rect, void* bgdModel, void* fgdModel, int iterCount, int mode) {
    try {
        cv::grabCut(*reinterpret_cast<cv::Mat*>(img), *reinterpret_cast<cv::Mat*>(mask), *reinterpret_cast<cv::Rect*>(&rect), *reinterpret_cast<cv::Mat*>(bgdModel), *reinterpret_cast<cv::Mat*>(fgdModel), iterCount, mode);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_groupRectangles_VectorOfRect_rectList_VectorOfint_rejectLevels_VectorOfdouble_levelWeights_int_groupThreshold_double_eps
// parsed: cv::groupRectangles
// as:     cv::groupRectangles (function)
// Arg ARG Vector[cv::Rect (simple)] rectList= Vector[cv::Rect (simple)] = 
// Arg ARG Vector[Primitive(int)] rejectLevels= Vector[Primitive(int)] = 
// Arg ARG Vector[Primitive(double)] levelWeights= Vector[Primitive(double)] = 
// Arg ARG Primitive(int) groupThreshold= Primitive(int) = 
// Arg ARG Primitive(double) eps= Primitive(double) = 0.2
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_groupRectangles_VectorOfRect_rectList_VectorOfint_rejectLevels_VectorOfdouble_levelWeights_int_groupThreshold_double_eps(void* rectList, void* rejectLevels, void* levelWeights, int groupThreshold, double eps) {
    try {
        cv::groupRectangles(*reinterpret_cast<std::vector<cv::Rect>*>(rectList), *reinterpret_cast<std::vector<int>*>(rejectLevels), *reinterpret_cast<std::vector<double>*>(levelWeights), groupThreshold, eps);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_groupRectangles_VectorOfRect_rectList_VectorOfint_weights_int_groupThreshold_double_eps
// parsed: cv::groupRectangles
// as:     cv::groupRectangles (function)
// Arg ARG Vector[cv::Rect (simple)] rectList= Vector[cv::Rect (simple)] = 
// Arg ARG Vector[Primitive(int)] weights= Vector[Primitive(int)] = 
// Arg ARG Primitive(int) groupThreshold= Primitive(int) = 
// Arg ARG Primitive(double) eps= Primitive(double) = 0.2
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_groupRectangles_VectorOfRect_rectList_VectorOfint_weights_int_groupThreshold_double_eps(void* rectList, void* weights, int groupThreshold, double eps) {
    try {
        cv::groupRectangles(*reinterpret_cast<std::vector<cv::Rect>*>(rectList), *reinterpret_cast<std::vector<int>*>(weights), groupThreshold, eps);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_groupRectangles_VectorOfRect_rectList_int_groupThreshold_double_eps
// parsed: cv::groupRectangles
// as:     cv::groupRectangles (function)
// Arg ARG Vector[cv::Rect (simple)] rectList= Vector[cv::Rect (simple)] = 
// Arg ARG Primitive(int) groupThreshold= Primitive(int) = 
// Arg ARG Primitive(double) eps= Primitive(double) = 0.2
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_groupRectangles_VectorOfRect_rectList_int_groupThreshold_double_eps(void* rectList, int groupThreshold, double eps) {
    try {
        cv::groupRectangles(*reinterpret_cast<std::vector<cv::Rect>*>(rectList), groupThreshold, eps);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_groupRectangles_VectorOfRect_rectList_int_groupThreshold_double_eps_VectorOfint_weights_VectorOfdouble_levelWeights
// parsed: cv::groupRectangles
// as:     cv::groupRectangles (function)
// Arg ARG Vector[cv::Rect (simple)] rectList= Vector[cv::Rect (simple)] = 
// Arg ARG Primitive(int) groupThreshold= Primitive(int) = 
// Arg ARG Primitive(double) eps= Primitive(double) = 
// Arg ARG RawPtr[Vector[Primitive(int)]] * weights= (ptr) RawPtr[Vector[Primitive(int)]] = 
// Arg ARG RawPtr[Vector[Primitive(double)]] * levelWeights= (ptr) RawPtr[Vector[Primitive(double)]] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_groupRectangles_VectorOfRect_rectList_int_groupThreshold_double_eps_VectorOfint_weights_VectorOfdouble_levelWeights(void* rectList, int groupThreshold, double eps, void* weights, void* levelWeights) {
    try {
        cv::groupRectangles(*reinterpret_cast<std::vector<cv::Rect>*>(rectList), groupThreshold, eps, reinterpret_cast<std::vector<int>*>(weights), reinterpret_cast<std::vector<double>*>(levelWeights));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_groupRectangles_meanshift_VectorOfRect_rectList_VectorOfdouble_foundWeights_VectorOfdouble_foundScales_double_detectThreshold_Size_winDetSize
// parsed: cv::groupRectangles_meanshift
// as:     cv::groupRectangles_meanshift (function)
// Arg ARG Vector[cv::Rect (simple)] rectList= Vector[cv::Rect (simple)] = 
// Arg ARG Vector[Primitive(double)] foundWeights= Vector[Primitive(double)] = 
// Arg ARG Vector[Primitive(double)] foundScales= Vector[Primitive(double)] = 
// Arg ARG Primitive(double) detectThreshold= Primitive(double) = 0.0
// Arg ARG cv::Size (simple) winDetSize= cv::Size (simple) = Size(64, 128)
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_groupRectangles_meanshift_VectorOfRect_rectList_VectorOfdouble_foundWeights_VectorOfdouble_foundScales_double_detectThreshold_Size_winDetSize(void* rectList, void* foundWeights, void* foundScales, double detectThreshold, SizeWrapper winDetSize) {
    try {
        cv::groupRectangles_meanshift(*reinterpret_cast<std::vector<cv::Rect>*>(rectList), *reinterpret_cast<std::vector<double>*>(foundWeights), *reinterpret_cast<std::vector<double>*>(foundScales), detectThreshold, *reinterpret_cast<cv::Size*>(&winDetSize));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_Cholesky32f_float_X_A_size_t_astep_int_m_float_X_b_size_t_bstep_int_n
// parsed: cv::hal::Cholesky32f
// as:     cv::hal::Cholesky32f (function)
// Arg ARG RawPtr[Primitive(float)] * A= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG Primitive(size_t) astep= Primitive(size_t) = 
// Arg ARG Primitive(int) m= Primitive(int) = 
// Arg ARG RawPtr[Primitive(float)] * b= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG Primitive(size_t) bstep= Primitive(size_t) = 
// Arg ARG Primitive(int) n= Primitive(int) = 
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_hal_Cholesky32f_float_X_A_size_t_astep_int_m_float_X_b_size_t_bstep_int_n(float* A, std::size_t astep, int m, float* b, std::size_t bstep, int n) {
    try {
        bool ret = cv::hal::Cholesky32f(A, astep, m, b, bstep, n);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_hal_Cholesky64f_double_X_A_size_t_astep_int_m_double_X_b_size_t_bstep_int_n
// parsed: cv::hal::Cholesky64f
// as:     cv::hal::Cholesky64f (function)
// Arg ARG RawPtr[Primitive(double)] * A= (ptr) RawPtr[Primitive(double)] = 
// Arg ARG Primitive(size_t) astep= Primitive(size_t) = 
// Arg ARG Primitive(int) m= Primitive(int) = 
// Arg ARG RawPtr[Primitive(double)] * b= (ptr) RawPtr[Primitive(double)] = 
// Arg ARG Primitive(size_t) bstep= Primitive(size_t) = 
// Arg ARG Primitive(int) n= Primitive(int) = 
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_hal_Cholesky64f_double_X_A_size_t_astep_int_m_double_X_b_size_t_bstep_int_n(double* A, std::size_t astep, int m, double* b, std::size_t bstep, int n) {
    try {
        bool ret = cv::hal::Cholesky64f(A, astep, m, b, bstep, n);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_hal_LU32f_float_X_A_size_t_astep_int_m_float_X_b_size_t_bstep_int_n
// parsed: cv::hal::LU32f
// as:     cv::hal::LU32f (function)
// Arg ARG RawPtr[Primitive(float)] * A= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG Primitive(size_t) astep= Primitive(size_t) = 
// Arg ARG Primitive(int) m= Primitive(int) = 
// Arg ARG RawPtr[Primitive(float)] * b= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG Primitive(size_t) bstep= Primitive(size_t) = 
// Arg ARG Primitive(int) n= Primitive(int) = 
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_hal_LU32f_float_X_A_size_t_astep_int_m_float_X_b_size_t_bstep_int_n(float* A, std::size_t astep, int m, float* b, std::size_t bstep, int n) {
    try {
        int ret = cv::hal::LU32f(A, astep, m, b, bstep, n);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_hal_LU64f_double_X_A_size_t_astep_int_m_double_X_b_size_t_bstep_int_n
// parsed: cv::hal::LU64f
// as:     cv::hal::LU64f (function)
// Arg ARG RawPtr[Primitive(double)] * A= (ptr) RawPtr[Primitive(double)] = 
// Arg ARG Primitive(size_t) astep= Primitive(size_t) = 
// Arg ARG Primitive(int) m= Primitive(int) = 
// Arg ARG RawPtr[Primitive(double)] * b= (ptr) RawPtr[Primitive(double)] = 
// Arg ARG Primitive(size_t) bstep= Primitive(size_t) = 
// Arg ARG Primitive(int) n= Primitive(int) = 
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_hal_LU64f_double_X_A_size_t_astep_int_m_double_X_b_size_t_bstep_int_n(double* A, std::size_t astep, int m, double* b, std::size_t bstep, int n) {
    try {
        int ret = cv::hal::LU64f(A, astep, m, b, bstep, n);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_hal_QR32f_float_X_A_size_t_astep_int_m_int_n_int_k_float_X_b_size_t_bstep_float_X_hFactors
// parsed: cv::hal::QR32f
// as:     cv::hal::QR32f (function)
// Arg ARG RawPtr[Primitive(float)] * A= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG Primitive(size_t) astep= Primitive(size_t) = 
// Arg ARG Primitive(int) m= Primitive(int) = 
// Arg ARG Primitive(int) n= Primitive(int) = 
// Arg ARG Primitive(int) k= Primitive(int) = 
// Arg ARG RawPtr[Primitive(float)] * b= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG Primitive(size_t) bstep= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(float)] * hFactors= (ptr) RawPtr[Primitive(float)] = 
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_hal_QR32f_float_X_A_size_t_astep_int_m_int_n_int_k_float_X_b_size_t_bstep_float_X_hFactors(float* A, std::size_t astep, int m, int n, int k, float* b, std::size_t bstep, float* hFactors) {
    try {
        int ret = cv::hal::QR32f(A, astep, m, n, k, b, bstep, hFactors);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_hal_QR64f_double_X_A_size_t_astep_int_m_int_n_int_k_double_X_b_size_t_bstep_double_X_hFactors
// parsed: cv::hal::QR64f
// as:     cv::hal::QR64f (function)
// Arg ARG RawPtr[Primitive(double)] * A= (ptr) RawPtr[Primitive(double)] = 
// Arg ARG Primitive(size_t) astep= Primitive(size_t) = 
// Arg ARG Primitive(int) m= Primitive(int) = 
// Arg ARG Primitive(int) n= Primitive(int) = 
// Arg ARG Primitive(int) k= Primitive(int) = 
// Arg ARG RawPtr[Primitive(double)] * b= (ptr) RawPtr[Primitive(double)] = 
// Arg ARG Primitive(size_t) bstep= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(double)] * hFactors= (ptr) RawPtr[Primitive(double)] = 
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_hal_QR64f_double_X_A_size_t_astep_int_m_int_n_int_k_double_X_b_size_t_bstep_double_X_hFactors(double* A, std::size_t astep, int m, int n, int k, double* b, std::size_t bstep, double* hFactors) {
    try {
        int ret = cv::hal::QR64f(A, astep, m, n, k, b, bstep, hFactors);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_hal_SVD32f_float_X_At_size_t_astep_float_X_W_float_X_U_size_t_ustep_float_X_Vt_size_t_vstep_int_m_int_n_int_flags
// parsed: cv::hal::SVD32f
// as:     cv::hal::SVD32f (function)
// Arg ARG RawPtr[Primitive(float)] * At= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG Primitive(size_t) astep= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(float)] * W= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG RawPtr[Primitive(float)] * U= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG Primitive(size_t) ustep= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(float)] * Vt= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG Primitive(size_t) vstep= Primitive(size_t) = 
// Arg ARG Primitive(int) m= Primitive(int) = 
// Arg ARG Primitive(int) n= Primitive(int) = 
// Arg ARG Primitive(int) flags= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_SVD32f_float_X_At_size_t_astep_float_X_W_float_X_U_size_t_ustep_float_X_Vt_size_t_vstep_int_m_int_n_int_flags(float* At, std::size_t astep, float* W, float* U, std::size_t ustep, float* Vt, std::size_t vstep, int m, int n, int flags) {
    try {
        cv::hal::SVD32f(At, astep, W, U, ustep, Vt, vstep, m, n, flags);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_SVD64f_double_X_At_size_t_astep_double_X_W_double_X_U_size_t_ustep_double_X_Vt_size_t_vstep_int_m_int_n_int_flags
// parsed: cv::hal::SVD64f
// as:     cv::hal::SVD64f (function)
// Arg ARG RawPtr[Primitive(double)] * At= (ptr) RawPtr[Primitive(double)] = 
// Arg ARG Primitive(size_t) astep= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(double)] * W= (ptr) RawPtr[Primitive(double)] = 
// Arg ARG RawPtr[Primitive(double)] * U= (ptr) RawPtr[Primitive(double)] = 
// Arg ARG Primitive(size_t) ustep= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(double)] * Vt= (ptr) RawPtr[Primitive(double)] = 
// Arg ARG Primitive(size_t) vstep= Primitive(size_t) = 
// Arg ARG Primitive(int) m= Primitive(int) = 
// Arg ARG Primitive(int) n= Primitive(int) = 
// Arg ARG Primitive(int) flags= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_SVD64f_double_X_At_size_t_astep_double_X_W_double_X_U_size_t_ustep_double_X_Vt_size_t_vstep_int_m_int_n_int_flags(double* At, std::size_t astep, double* W, double* U, std::size_t ustep, double* Vt, std::size_t vstep, int m, int n, int flags) {
    try {
        cv::hal::SVD64f(At, astep, W, U, ustep, Vt, vstep, m, n, flags);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_absdiff16s_const_short_X_src1_size_t_step1_const_short_X_src2_size_t_step2_short_X_dst_size_t_step_int_width_int_height_void_X_unnamed_arg
// parsed: cv::hal::absdiff16s
// as:     cv::hal::absdiff16s (function)
// Arg ARG RawPtr[Primitive(short)] * src1= (ptr) RawPtr[Primitive(short)] = 
// Arg ARG Primitive(size_t) step1= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(short)] * src2= (ptr) RawPtr[Primitive(short)] = 
// Arg ARG Primitive(size_t) step2= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(short)] * dst= (ptr) RawPtr[Primitive(short)] = 
// Arg ARG Primitive(size_t) step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG RawPtr[Primitive(void)] * unnamed_arg= (ptr) RawPtr[Primitive(void)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_absdiff16s_const_short_X_src1_size_t_step1_const_short_X_src2_size_t_step2_short_X_dst_size_t_step_int_width_int_height_void_X_unnamed_arg(const short* src1, std::size_t step1, const short* src2, std::size_t step2, short* dst, std::size_t step, int width, int height, void* unnamed_arg) {
    try {
        cv::hal::absdiff16s(src1, step1, src2, step2, dst, step, width, height, unnamed_arg);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_absdiff16u_const_ushort_X_src1_size_t_step1_const_ushort_X_src2_size_t_step2_ushort_X_dst_size_t_step_int_width_int_height_void_X_unnamed_arg
// parsed: cv::hal::absdiff16u
// as:     cv::hal::absdiff16u (function)
// Arg ARG RawPtr[Primitive(ushort)] * src1= (ptr) RawPtr[Primitive(ushort)] = 
// Arg ARG Primitive(size_t) step1= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(ushort)] * src2= (ptr) RawPtr[Primitive(ushort)] = 
// Arg ARG Primitive(size_t) step2= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(ushort)] * dst= (ptr) RawPtr[Primitive(ushort)] = 
// Arg ARG Primitive(size_t) step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG RawPtr[Primitive(void)] * unnamed_arg= (ptr) RawPtr[Primitive(void)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_absdiff16u_const_ushort_X_src1_size_t_step1_const_ushort_X_src2_size_t_step2_ushort_X_dst_size_t_step_int_width_int_height_void_X_unnamed_arg(const ushort* src1, std::size_t step1, const ushort* src2, std::size_t step2, ushort* dst, std::size_t step, int width, int height, void* unnamed_arg) {
    try {
        cv::hal::absdiff16u(src1, step1, src2, step2, dst, step, width, height, unnamed_arg);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_absdiff32f_const_float_X_src1_size_t_step1_const_float_X_src2_size_t_step2_float_X_dst_size_t_step_int_width_int_height_void_X_unnamed_arg
// parsed: cv::hal::absdiff32f
// as:     cv::hal::absdiff32f (function)
// Arg ARG RawPtr[Primitive(float)] * src1= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG Primitive(size_t) step1= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(float)] * src2= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG Primitive(size_t) step2= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(float)] * dst= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG Primitive(size_t) step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG RawPtr[Primitive(void)] * unnamed_arg= (ptr) RawPtr[Primitive(void)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_absdiff32f_const_float_X_src1_size_t_step1_const_float_X_src2_size_t_step2_float_X_dst_size_t_step_int_width_int_height_void_X_unnamed_arg(const float* src1, std::size_t step1, const float* src2, std::size_t step2, float* dst, std::size_t step, int width, int height, void* unnamed_arg) {
    try {
        cv::hal::absdiff32f(src1, step1, src2, step2, dst, step, width, height, unnamed_arg);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_absdiff32s_const_int_X_src1_size_t_step1_const_int_X_src2_size_t_step2_int_X_dst_size_t_step_int_width_int_height_void_X_unnamed_arg
// parsed: cv::hal::absdiff32s
// as:     cv::hal::absdiff32s (function)
// Arg ARG RawPtr[Primitive(int)] * src1= (ptr) RawPtr[Primitive(int)] = 
// Arg ARG Primitive(size_t) step1= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(int)] * src2= (ptr) RawPtr[Primitive(int)] = 
// Arg ARG Primitive(size_t) step2= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(int)] * dst= (ptr) RawPtr[Primitive(int)] = 
// Arg ARG Primitive(size_t) step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG RawPtr[Primitive(void)] * unnamed_arg= (ptr) RawPtr[Primitive(void)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_absdiff32s_const_int_X_src1_size_t_step1_const_int_X_src2_size_t_step2_int_X_dst_size_t_step_int_width_int_height_void_X_unnamed_arg(const int* src1, std::size_t step1, const int* src2, std::size_t step2, int* dst, std::size_t step, int width, int height, void* unnamed_arg) {
    try {
        cv::hal::absdiff32s(src1, step1, src2, step2, dst, step, width, height, unnamed_arg);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_absdiff64f_const_double_X_src1_size_t_step1_const_double_X_src2_size_t_step2_double_X_dst_size_t_step_int_width_int_height_void_X_unnamed_arg
// parsed: cv::hal::absdiff64f
// as:     cv::hal::absdiff64f (function)
// Arg ARG RawPtr[Primitive(double)] * src1= (ptr) RawPtr[Primitive(double)] = 
// Arg ARG Primitive(size_t) step1= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(double)] * src2= (ptr) RawPtr[Primitive(double)] = 
// Arg ARG Primitive(size_t) step2= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(double)] * dst= (ptr) RawPtr[Primitive(double)] = 
// Arg ARG Primitive(size_t) step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG RawPtr[Primitive(void)] * unnamed_arg= (ptr) RawPtr[Primitive(void)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_absdiff64f_const_double_X_src1_size_t_step1_const_double_X_src2_size_t_step2_double_X_dst_size_t_step_int_width_int_height_void_X_unnamed_arg(const double* src1, std::size_t step1, const double* src2, std::size_t step2, double* dst, std::size_t step, int width, int height, void* unnamed_arg) {
    try {
        cv::hal::absdiff64f(src1, step1, src2, step2, dst, step, width, height, unnamed_arg);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_absdiff8s_const_schar_X_src1_size_t_step1_const_schar_X_src2_size_t_step2_schar_X_dst_size_t_step_int_width_int_height_void_X_unnamed_arg
// parsed: cv::hal::absdiff8s
// as:     cv::hal::absdiff8s (function)
// Arg ARG RawPtr[Primitive(schar)] * src1= (ptr) RawPtr[Primitive(schar)] = 
// Arg ARG Primitive(size_t) step1= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(schar)] * src2= (ptr) RawPtr[Primitive(schar)] = 
// Arg ARG Primitive(size_t) step2= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(schar)] * dst= (ptr) RawPtr[Primitive(schar)] = 
// Arg ARG Primitive(size_t) step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG RawPtr[Primitive(void)] * unnamed_arg= (ptr) RawPtr[Primitive(void)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_absdiff8s_const_schar_X_src1_size_t_step1_const_schar_X_src2_size_t_step2_schar_X_dst_size_t_step_int_width_int_height_void_X_unnamed_arg(const schar* src1, std::size_t step1, const schar* src2, std::size_t step2, schar* dst, std::size_t step, int width, int height, void* unnamed_arg) {
    try {
        cv::hal::absdiff8s(src1, step1, src2, step2, dst, step, width, height, unnamed_arg);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_absdiff8u_const_uchar_X_src1_size_t_step1_const_uchar_X_src2_size_t_step2_uchar_X_dst_size_t_step_int_width_int_height_void_X_unnamed_arg
// parsed: cv::hal::absdiff8u
// as:     cv::hal::absdiff8u (function)
// Arg ARG RawPtr[Primitive(uchar)] * src1= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) step1= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(uchar)] * src2= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) step2= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(uchar)] * dst= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG RawPtr[Primitive(void)] * unnamed_arg= (ptr) RawPtr[Primitive(void)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_absdiff8u_const_uchar_X_src1_size_t_step1_const_uchar_X_src2_size_t_step2_uchar_X_dst_size_t_step_int_width_int_height_void_X_unnamed_arg(const uchar* src1, std::size_t step1, const uchar* src2, std::size_t step2, uchar* dst, std::size_t step, int width, int height, void* unnamed_arg) {
    try {
        cv::hal::absdiff8u(src1, step1, src2, step2, dst, step, width, height, unnamed_arg);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_add16s_const_short_X_src1_size_t_step1_const_short_X_src2_size_t_step2_short_X_dst_size_t_step_int_width_int_height_void_X_unnamed_arg
// parsed: cv::hal::add16s
// as:     cv::hal::add16s (function)
// Arg ARG RawPtr[Primitive(short)] * src1= (ptr) RawPtr[Primitive(short)] = 
// Arg ARG Primitive(size_t) step1= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(short)] * src2= (ptr) RawPtr[Primitive(short)] = 
// Arg ARG Primitive(size_t) step2= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(short)] * dst= (ptr) RawPtr[Primitive(short)] = 
// Arg ARG Primitive(size_t) step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG RawPtr[Primitive(void)] * unnamed_arg= (ptr) RawPtr[Primitive(void)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_add16s_const_short_X_src1_size_t_step1_const_short_X_src2_size_t_step2_short_X_dst_size_t_step_int_width_int_height_void_X_unnamed_arg(const short* src1, std::size_t step1, const short* src2, std::size_t step2, short* dst, std::size_t step, int width, int height, void* unnamed_arg) {
    try {
        cv::hal::add16s(src1, step1, src2, step2, dst, step, width, height, unnamed_arg);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_add16u_const_ushort_X_src1_size_t_step1_const_ushort_X_src2_size_t_step2_ushort_X_dst_size_t_step_int_width_int_height_void_X_unnamed_arg
// parsed: cv::hal::add16u
// as:     cv::hal::add16u (function)
// Arg ARG RawPtr[Primitive(ushort)] * src1= (ptr) RawPtr[Primitive(ushort)] = 
// Arg ARG Primitive(size_t) step1= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(ushort)] * src2= (ptr) RawPtr[Primitive(ushort)] = 
// Arg ARG Primitive(size_t) step2= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(ushort)] * dst= (ptr) RawPtr[Primitive(ushort)] = 
// Arg ARG Primitive(size_t) step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG RawPtr[Primitive(void)] * unnamed_arg= (ptr) RawPtr[Primitive(void)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_add16u_const_ushort_X_src1_size_t_step1_const_ushort_X_src2_size_t_step2_ushort_X_dst_size_t_step_int_width_int_height_void_X_unnamed_arg(const ushort* src1, std::size_t step1, const ushort* src2, std::size_t step2, ushort* dst, std::size_t step, int width, int height, void* unnamed_arg) {
    try {
        cv::hal::add16u(src1, step1, src2, step2, dst, step, width, height, unnamed_arg);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_add32f_const_float_X_src1_size_t_step1_const_float_X_src2_size_t_step2_float_X_dst_size_t_step_int_width_int_height_void_X_unnamed_arg
// parsed: cv::hal::add32f
// as:     cv::hal::add32f (function)
// Arg ARG RawPtr[Primitive(float)] * src1= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG Primitive(size_t) step1= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(float)] * src2= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG Primitive(size_t) step2= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(float)] * dst= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG Primitive(size_t) step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG RawPtr[Primitive(void)] * unnamed_arg= (ptr) RawPtr[Primitive(void)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_add32f_const_float_X_src1_size_t_step1_const_float_X_src2_size_t_step2_float_X_dst_size_t_step_int_width_int_height_void_X_unnamed_arg(const float* src1, std::size_t step1, const float* src2, std::size_t step2, float* dst, std::size_t step, int width, int height, void* unnamed_arg) {
    try {
        cv::hal::add32f(src1, step1, src2, step2, dst, step, width, height, unnamed_arg);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_add32s_const_int_X_src1_size_t_step1_const_int_X_src2_size_t_step2_int_X_dst_size_t_step_int_width_int_height_void_X_unnamed_arg
// parsed: cv::hal::add32s
// as:     cv::hal::add32s (function)
// Arg ARG RawPtr[Primitive(int)] * src1= (ptr) RawPtr[Primitive(int)] = 
// Arg ARG Primitive(size_t) step1= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(int)] * src2= (ptr) RawPtr[Primitive(int)] = 
// Arg ARG Primitive(size_t) step2= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(int)] * dst= (ptr) RawPtr[Primitive(int)] = 
// Arg ARG Primitive(size_t) step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG RawPtr[Primitive(void)] * unnamed_arg= (ptr) RawPtr[Primitive(void)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_add32s_const_int_X_src1_size_t_step1_const_int_X_src2_size_t_step2_int_X_dst_size_t_step_int_width_int_height_void_X_unnamed_arg(const int* src1, std::size_t step1, const int* src2, std::size_t step2, int* dst, std::size_t step, int width, int height, void* unnamed_arg) {
    try {
        cv::hal::add32s(src1, step1, src2, step2, dst, step, width, height, unnamed_arg);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_add64f_const_double_X_src1_size_t_step1_const_double_X_src2_size_t_step2_double_X_dst_size_t_step_int_width_int_height_void_X_unnamed_arg
// parsed: cv::hal::add64f
// as:     cv::hal::add64f (function)
// Arg ARG RawPtr[Primitive(double)] * src1= (ptr) RawPtr[Primitive(double)] = 
// Arg ARG Primitive(size_t) step1= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(double)] * src2= (ptr) RawPtr[Primitive(double)] = 
// Arg ARG Primitive(size_t) step2= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(double)] * dst= (ptr) RawPtr[Primitive(double)] = 
// Arg ARG Primitive(size_t) step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG RawPtr[Primitive(void)] * unnamed_arg= (ptr) RawPtr[Primitive(void)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_add64f_const_double_X_src1_size_t_step1_const_double_X_src2_size_t_step2_double_X_dst_size_t_step_int_width_int_height_void_X_unnamed_arg(const double* src1, std::size_t step1, const double* src2, std::size_t step2, double* dst, std::size_t step, int width, int height, void* unnamed_arg) {
    try {
        cv::hal::add64f(src1, step1, src2, step2, dst, step, width, height, unnamed_arg);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_add8s_const_schar_X_src1_size_t_step1_const_schar_X_src2_size_t_step2_schar_X_dst_size_t_step_int_width_int_height_void_X_unnamed_arg
// parsed: cv::hal::add8s
// as:     cv::hal::add8s (function)
// Arg ARG RawPtr[Primitive(schar)] * src1= (ptr) RawPtr[Primitive(schar)] = 
// Arg ARG Primitive(size_t) step1= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(schar)] * src2= (ptr) RawPtr[Primitive(schar)] = 
// Arg ARG Primitive(size_t) step2= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(schar)] * dst= (ptr) RawPtr[Primitive(schar)] = 
// Arg ARG Primitive(size_t) step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG RawPtr[Primitive(void)] * unnamed_arg= (ptr) RawPtr[Primitive(void)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_add8s_const_schar_X_src1_size_t_step1_const_schar_X_src2_size_t_step2_schar_X_dst_size_t_step_int_width_int_height_void_X_unnamed_arg(const schar* src1, std::size_t step1, const schar* src2, std::size_t step2, schar* dst, std::size_t step, int width, int height, void* unnamed_arg) {
    try {
        cv::hal::add8s(src1, step1, src2, step2, dst, step, width, height, unnamed_arg);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_add8u_const_uchar_X_src1_size_t_step1_const_uchar_X_src2_size_t_step2_uchar_X_dst_size_t_step_int_width_int_height_void_X_unnamed_arg
// parsed: cv::hal::add8u
// as:     cv::hal::add8u (function)
// Arg ARG RawPtr[Primitive(uchar)] * src1= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) step1= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(uchar)] * src2= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) step2= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(uchar)] * dst= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG RawPtr[Primitive(void)] * unnamed_arg= (ptr) RawPtr[Primitive(void)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_add8u_const_uchar_X_src1_size_t_step1_const_uchar_X_src2_size_t_step2_uchar_X_dst_size_t_step_int_width_int_height_void_X_unnamed_arg(const uchar* src1, std::size_t step1, const uchar* src2, std::size_t step2, uchar* dst, std::size_t step, int width, int height, void* unnamed_arg) {
    try {
        cv::hal::add8u(src1, step1, src2, step2, dst, step, width, height, unnamed_arg);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_addWeighted16s_const_short_X_src1_size_t_step1_const_short_X_src2_size_t_step2_short_X_dst_size_t_step_int_width_int_height_void_X_scalars
// parsed: cv::hal::addWeighted16s
// as:     cv::hal::addWeighted16s (function)
// Arg ARG RawPtr[Primitive(short)] * src1= (ptr) RawPtr[Primitive(short)] = 
// Arg ARG Primitive(size_t) step1= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(short)] * src2= (ptr) RawPtr[Primitive(short)] = 
// Arg ARG Primitive(size_t) step2= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(short)] * dst= (ptr) RawPtr[Primitive(short)] = 
// Arg ARG Primitive(size_t) step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG RawPtr[Primitive(void)] * scalars= (ptr) RawPtr[Primitive(void)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_addWeighted16s_const_short_X_src1_size_t_step1_const_short_X_src2_size_t_step2_short_X_dst_size_t_step_int_width_int_height_void_X_scalars(const short* src1, std::size_t step1, const short* src2, std::size_t step2, short* dst, std::size_t step, int width, int height, void* scalars) {
    try {
        cv::hal::addWeighted16s(src1, step1, src2, step2, dst, step, width, height, scalars);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_addWeighted16u_const_ushort_X_src1_size_t_step1_const_ushort_X_src2_size_t_step2_ushort_X_dst_size_t_step_int_width_int_height_void_X_scalars
// parsed: cv::hal::addWeighted16u
// as:     cv::hal::addWeighted16u (function)
// Arg ARG RawPtr[Primitive(ushort)] * src1= (ptr) RawPtr[Primitive(ushort)] = 
// Arg ARG Primitive(size_t) step1= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(ushort)] * src2= (ptr) RawPtr[Primitive(ushort)] = 
// Arg ARG Primitive(size_t) step2= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(ushort)] * dst= (ptr) RawPtr[Primitive(ushort)] = 
// Arg ARG Primitive(size_t) step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG RawPtr[Primitive(void)] * scalars= (ptr) RawPtr[Primitive(void)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_addWeighted16u_const_ushort_X_src1_size_t_step1_const_ushort_X_src2_size_t_step2_ushort_X_dst_size_t_step_int_width_int_height_void_X_scalars(const ushort* src1, std::size_t step1, const ushort* src2, std::size_t step2, ushort* dst, std::size_t step, int width, int height, void* scalars) {
    try {
        cv::hal::addWeighted16u(src1, step1, src2, step2, dst, step, width, height, scalars);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_addWeighted32f_const_float_X_src1_size_t_step1_const_float_X_src2_size_t_step2_float_X_dst_size_t_step_int_width_int_height_void_X_scalars
// parsed: cv::hal::addWeighted32f
// as:     cv::hal::addWeighted32f (function)
// Arg ARG RawPtr[Primitive(float)] * src1= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG Primitive(size_t) step1= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(float)] * src2= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG Primitive(size_t) step2= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(float)] * dst= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG Primitive(size_t) step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG RawPtr[Primitive(void)] * scalars= (ptr) RawPtr[Primitive(void)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_addWeighted32f_const_float_X_src1_size_t_step1_const_float_X_src2_size_t_step2_float_X_dst_size_t_step_int_width_int_height_void_X_scalars(const float* src1, std::size_t step1, const float* src2, std::size_t step2, float* dst, std::size_t step, int width, int height, void* scalars) {
    try {
        cv::hal::addWeighted32f(src1, step1, src2, step2, dst, step, width, height, scalars);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_addWeighted32s_const_int_X_src1_size_t_step1_const_int_X_src2_size_t_step2_int_X_dst_size_t_step_int_width_int_height_void_X_scalars
// parsed: cv::hal::addWeighted32s
// as:     cv::hal::addWeighted32s (function)
// Arg ARG RawPtr[Primitive(int)] * src1= (ptr) RawPtr[Primitive(int)] = 
// Arg ARG Primitive(size_t) step1= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(int)] * src2= (ptr) RawPtr[Primitive(int)] = 
// Arg ARG Primitive(size_t) step2= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(int)] * dst= (ptr) RawPtr[Primitive(int)] = 
// Arg ARG Primitive(size_t) step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG RawPtr[Primitive(void)] * scalars= (ptr) RawPtr[Primitive(void)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_addWeighted32s_const_int_X_src1_size_t_step1_const_int_X_src2_size_t_step2_int_X_dst_size_t_step_int_width_int_height_void_X_scalars(const int* src1, std::size_t step1, const int* src2, std::size_t step2, int* dst, std::size_t step, int width, int height, void* scalars) {
    try {
        cv::hal::addWeighted32s(src1, step1, src2, step2, dst, step, width, height, scalars);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_addWeighted64f_const_double_X_src1_size_t_step1_const_double_X_src2_size_t_step2_double_X_dst_size_t_step_int_width_int_height_void_X_scalars
// parsed: cv::hal::addWeighted64f
// as:     cv::hal::addWeighted64f (function)
// Arg ARG RawPtr[Primitive(double)] * src1= (ptr) RawPtr[Primitive(double)] = 
// Arg ARG Primitive(size_t) step1= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(double)] * src2= (ptr) RawPtr[Primitive(double)] = 
// Arg ARG Primitive(size_t) step2= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(double)] * dst= (ptr) RawPtr[Primitive(double)] = 
// Arg ARG Primitive(size_t) step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG RawPtr[Primitive(void)] * scalars= (ptr) RawPtr[Primitive(void)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_addWeighted64f_const_double_X_src1_size_t_step1_const_double_X_src2_size_t_step2_double_X_dst_size_t_step_int_width_int_height_void_X_scalars(const double* src1, std::size_t step1, const double* src2, std::size_t step2, double* dst, std::size_t step, int width, int height, void* scalars) {
    try {
        cv::hal::addWeighted64f(src1, step1, src2, step2, dst, step, width, height, scalars);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_addWeighted8s_const_schar_X_src1_size_t_step1_const_schar_X_src2_size_t_step2_schar_X_dst_size_t_step_int_width_int_height_void_X_scalars
// parsed: cv::hal::addWeighted8s
// as:     cv::hal::addWeighted8s (function)
// Arg ARG RawPtr[Primitive(schar)] * src1= (ptr) RawPtr[Primitive(schar)] = 
// Arg ARG Primitive(size_t) step1= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(schar)] * src2= (ptr) RawPtr[Primitive(schar)] = 
// Arg ARG Primitive(size_t) step2= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(schar)] * dst= (ptr) RawPtr[Primitive(schar)] = 
// Arg ARG Primitive(size_t) step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG RawPtr[Primitive(void)] * scalars= (ptr) RawPtr[Primitive(void)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_addWeighted8s_const_schar_X_src1_size_t_step1_const_schar_X_src2_size_t_step2_schar_X_dst_size_t_step_int_width_int_height_void_X_scalars(const schar* src1, std::size_t step1, const schar* src2, std::size_t step2, schar* dst, std::size_t step, int width, int height, void* scalars) {
    try {
        cv::hal::addWeighted8s(src1, step1, src2, step2, dst, step, width, height, scalars);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_addWeighted8u_const_uchar_X_src1_size_t_step1_const_uchar_X_src2_size_t_step2_uchar_X_dst_size_t_step_int_width_int_height_void_X__scalars
// parsed: cv::hal::addWeighted8u
// as:     cv::hal::addWeighted8u (function)
// Arg ARG RawPtr[Primitive(uchar)] * src1= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) step1= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(uchar)] * src2= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) step2= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(uchar)] * dst= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG RawPtr[Primitive(void)] * _scalars= (ptr) RawPtr[Primitive(void)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_addWeighted8u_const_uchar_X_src1_size_t_step1_const_uchar_X_src2_size_t_step2_uchar_X_dst_size_t_step_int_width_int_height_void_X__scalars(const uchar* src1, std::size_t step1, const uchar* src2, std::size_t step2, uchar* dst, std::size_t step, int width, int height, void* _scalars) {
    try {
        cv::hal::addWeighted8u(src1, step1, src2, step2, dst, step, width, height, _scalars);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_and8u_const_uchar_X_src1_size_t_step1_const_uchar_X_src2_size_t_step2_uchar_X_dst_size_t_step_int_width_int_height_void_X_unnamed_arg
// parsed: cv::hal::and8u
// as:     cv::hal::and8u (function)
// Arg ARG RawPtr[Primitive(uchar)] * src1= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) step1= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(uchar)] * src2= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) step2= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(uchar)] * dst= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG RawPtr[Primitive(void)] * unnamed_arg= (ptr) RawPtr[Primitive(void)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_and8u_const_uchar_X_src1_size_t_step1_const_uchar_X_src2_size_t_step2_uchar_X_dst_size_t_step_int_width_int_height_void_X_unnamed_arg(const uchar* src1, std::size_t step1, const uchar* src2, std::size_t step2, uchar* dst, std::size_t step, int width, int height, void* unnamed_arg) {
    try {
        cv::hal::and8u(src1, step1, src2, step2, dst, step, width, height, unnamed_arg);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_cmp16s_const_short_X_src1_size_t_step1_const_short_X_src2_size_t_step2_uchar_X_dst_size_t_step_int_width_int_height_void_X__cmpop
// parsed: cv::hal::cmp16s
// as:     cv::hal::cmp16s (function)
// Arg ARG RawPtr[Primitive(short)] * src1= (ptr) RawPtr[Primitive(short)] = 
// Arg ARG Primitive(size_t) step1= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(short)] * src2= (ptr) RawPtr[Primitive(short)] = 
// Arg ARG Primitive(size_t) step2= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(uchar)] * dst= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG RawPtr[Primitive(void)] * _cmpop= (ptr) RawPtr[Primitive(void)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_cmp16s_const_short_X_src1_size_t_step1_const_short_X_src2_size_t_step2_uchar_X_dst_size_t_step_int_width_int_height_void_X__cmpop(const short* src1, std::size_t step1, const short* src2, std::size_t step2, uchar* dst, std::size_t step, int width, int height, void* _cmpop) {
    try {
        cv::hal::cmp16s(src1, step1, src2, step2, dst, step, width, height, _cmpop);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_cmp16u_const_ushort_X_src1_size_t_step1_const_ushort_X_src2_size_t_step2_uchar_X_dst_size_t_step_int_width_int_height_void_X__cmpop
// parsed: cv::hal::cmp16u
// as:     cv::hal::cmp16u (function)
// Arg ARG RawPtr[Primitive(ushort)] * src1= (ptr) RawPtr[Primitive(ushort)] = 
// Arg ARG Primitive(size_t) step1= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(ushort)] * src2= (ptr) RawPtr[Primitive(ushort)] = 
// Arg ARG Primitive(size_t) step2= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(uchar)] * dst= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG RawPtr[Primitive(void)] * _cmpop= (ptr) RawPtr[Primitive(void)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_cmp16u_const_ushort_X_src1_size_t_step1_const_ushort_X_src2_size_t_step2_uchar_X_dst_size_t_step_int_width_int_height_void_X__cmpop(const ushort* src1, std::size_t step1, const ushort* src2, std::size_t step2, uchar* dst, std::size_t step, int width, int height, void* _cmpop) {
    try {
        cv::hal::cmp16u(src1, step1, src2, step2, dst, step, width, height, _cmpop);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_cmp32f_const_float_X_src1_size_t_step1_const_float_X_src2_size_t_step2_uchar_X_dst_size_t_step_int_width_int_height_void_X__cmpop
// parsed: cv::hal::cmp32f
// as:     cv::hal::cmp32f (function)
// Arg ARG RawPtr[Primitive(float)] * src1= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG Primitive(size_t) step1= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(float)] * src2= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG Primitive(size_t) step2= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(uchar)] * dst= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG RawPtr[Primitive(void)] * _cmpop= (ptr) RawPtr[Primitive(void)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_cmp32f_const_float_X_src1_size_t_step1_const_float_X_src2_size_t_step2_uchar_X_dst_size_t_step_int_width_int_height_void_X__cmpop(const float* src1, std::size_t step1, const float* src2, std::size_t step2, uchar* dst, std::size_t step, int width, int height, void* _cmpop) {
    try {
        cv::hal::cmp32f(src1, step1, src2, step2, dst, step, width, height, _cmpop);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_cmp32s_const_int_X_src1_size_t_step1_const_int_X_src2_size_t_step2_uchar_X_dst_size_t_step_int_width_int_height_void_X__cmpop
// parsed: cv::hal::cmp32s
// as:     cv::hal::cmp32s (function)
// Arg ARG RawPtr[Primitive(int)] * src1= (ptr) RawPtr[Primitive(int)] = 
// Arg ARG Primitive(size_t) step1= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(int)] * src2= (ptr) RawPtr[Primitive(int)] = 
// Arg ARG Primitive(size_t) step2= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(uchar)] * dst= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG RawPtr[Primitive(void)] * _cmpop= (ptr) RawPtr[Primitive(void)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_cmp32s_const_int_X_src1_size_t_step1_const_int_X_src2_size_t_step2_uchar_X_dst_size_t_step_int_width_int_height_void_X__cmpop(const int* src1, std::size_t step1, const int* src2, std::size_t step2, uchar* dst, std::size_t step, int width, int height, void* _cmpop) {
    try {
        cv::hal::cmp32s(src1, step1, src2, step2, dst, step, width, height, _cmpop);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_cmp64f_const_double_X_src1_size_t_step1_const_double_X_src2_size_t_step2_uchar_X_dst_size_t_step_int_width_int_height_void_X__cmpop
// parsed: cv::hal::cmp64f
// as:     cv::hal::cmp64f (function)
// Arg ARG RawPtr[Primitive(double)] * src1= (ptr) RawPtr[Primitive(double)] = 
// Arg ARG Primitive(size_t) step1= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(double)] * src2= (ptr) RawPtr[Primitive(double)] = 
// Arg ARG Primitive(size_t) step2= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(uchar)] * dst= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG RawPtr[Primitive(void)] * _cmpop= (ptr) RawPtr[Primitive(void)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_cmp64f_const_double_X_src1_size_t_step1_const_double_X_src2_size_t_step2_uchar_X_dst_size_t_step_int_width_int_height_void_X__cmpop(const double* src1, std::size_t step1, const double* src2, std::size_t step2, uchar* dst, std::size_t step, int width, int height, void* _cmpop) {
    try {
        cv::hal::cmp64f(src1, step1, src2, step2, dst, step, width, height, _cmpop);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_cmp8s_const_schar_X_src1_size_t_step1_const_schar_X_src2_size_t_step2_uchar_X_dst_size_t_step_int_width_int_height_void_X__cmpop
// parsed: cv::hal::cmp8s
// as:     cv::hal::cmp8s (function)
// Arg ARG RawPtr[Primitive(schar)] * src1= (ptr) RawPtr[Primitive(schar)] = 
// Arg ARG Primitive(size_t) step1= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(schar)] * src2= (ptr) RawPtr[Primitive(schar)] = 
// Arg ARG Primitive(size_t) step2= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(uchar)] * dst= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG RawPtr[Primitive(void)] * _cmpop= (ptr) RawPtr[Primitive(void)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_cmp8s_const_schar_X_src1_size_t_step1_const_schar_X_src2_size_t_step2_uchar_X_dst_size_t_step_int_width_int_height_void_X__cmpop(const schar* src1, std::size_t step1, const schar* src2, std::size_t step2, uchar* dst, std::size_t step, int width, int height, void* _cmpop) {
    try {
        cv::hal::cmp8s(src1, step1, src2, step2, dst, step, width, height, _cmpop);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_cmp8u_const_uchar_X_src1_size_t_step1_const_uchar_X_src2_size_t_step2_uchar_X_dst_size_t_step_int_width_int_height_void_X__cmpop
// parsed: cv::hal::cmp8u
// as:     cv::hal::cmp8u (function)
// Arg ARG RawPtr[Primitive(uchar)] * src1= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) step1= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(uchar)] * src2= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) step2= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(uchar)] * dst= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG RawPtr[Primitive(void)] * _cmpop= (ptr) RawPtr[Primitive(void)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_cmp8u_const_uchar_X_src1_size_t_step1_const_uchar_X_src2_size_t_step2_uchar_X_dst_size_t_step_int_width_int_height_void_X__cmpop(const uchar* src1, std::size_t step1, const uchar* src2, std::size_t step2, uchar* dst, std::size_t step, int width, int height, void* _cmpop) {
    try {
        cv::hal::cmp8u(src1, step1, src2, step2, dst, step, width, height, _cmpop);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_cvtBGR5x5toBGR_const_uchar_X_src_data_size_t_src_step_uchar_X_dst_data_size_t_dst_step_int_width_int_height_int_dcn_bool_swapBlue_int_greenBits
// parsed: cv::hal::cvtBGR5x5toBGR
// as:     cv::hal::cvtBGR5x5toBGR (function)
// Arg ARG RawPtr[Primitive(uchar)] * src_data= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) src_step= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(uchar)] * dst_data= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) dst_step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG Primitive(int) dcn= Primitive(int) = 
// Arg ARG Primitive(bool) swapBlue= Primitive(bool) = 
// Arg ARG Primitive(int) greenBits= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_cvtBGR5x5toBGR_const_uchar_X_src_data_size_t_src_step_uchar_X_dst_data_size_t_dst_step_int_width_int_height_int_dcn_bool_swapBlue_int_greenBits(const uchar* src_data, std::size_t src_step, uchar* dst_data, std::size_t dst_step, int width, int height, int dcn, bool swapBlue, int greenBits) {
    try {
        cv::hal::cvtBGR5x5toBGR(src_data, src_step, dst_data, dst_step, width, height, dcn, swapBlue, greenBits);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_cvtBGR5x5toGray_const_uchar_X_src_data_size_t_src_step_uchar_X_dst_data_size_t_dst_step_int_width_int_height_int_greenBits
// parsed: cv::hal::cvtBGR5x5toGray
// as:     cv::hal::cvtBGR5x5toGray (function)
// Arg ARG RawPtr[Primitive(uchar)] * src_data= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) src_step= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(uchar)] * dst_data= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) dst_step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG Primitive(int) greenBits= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_cvtBGR5x5toGray_const_uchar_X_src_data_size_t_src_step_uchar_X_dst_data_size_t_dst_step_int_width_int_height_int_greenBits(const uchar* src_data, std::size_t src_step, uchar* dst_data, std::size_t dst_step, int width, int height, int greenBits) {
    try {
        cv::hal::cvtBGR5x5toGray(src_data, src_step, dst_data, dst_step, width, height, greenBits);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_cvtBGRtoBGR5x5_const_uchar_X_src_data_size_t_src_step_uchar_X_dst_data_size_t_dst_step_int_width_int_height_int_scn_bool_swapBlue_int_greenBits
// parsed: cv::hal::cvtBGRtoBGR5x5
// as:     cv::hal::cvtBGRtoBGR5x5 (function)
// Arg ARG RawPtr[Primitive(uchar)] * src_data= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) src_step= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(uchar)] * dst_data= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) dst_step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG Primitive(int) scn= Primitive(int) = 
// Arg ARG Primitive(bool) swapBlue= Primitive(bool) = 
// Arg ARG Primitive(int) greenBits= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_cvtBGRtoBGR5x5_const_uchar_X_src_data_size_t_src_step_uchar_X_dst_data_size_t_dst_step_int_width_int_height_int_scn_bool_swapBlue_int_greenBits(const uchar* src_data, std::size_t src_step, uchar* dst_data, std::size_t dst_step, int width, int height, int scn, bool swapBlue, int greenBits) {
    try {
        cv::hal::cvtBGRtoBGR5x5(src_data, src_step, dst_data, dst_step, width, height, scn, swapBlue, greenBits);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_cvtBGRtoBGR_const_uchar_X_src_data_size_t_src_step_uchar_X_dst_data_size_t_dst_step_int_width_int_height_int_depth_int_scn_int_dcn_bool_swapBlue
// parsed: cv::hal::cvtBGRtoBGR
// as:     cv::hal::cvtBGRtoBGR (function)
// Arg ARG RawPtr[Primitive(uchar)] * src_data= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) src_step= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(uchar)] * dst_data= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) dst_step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG Primitive(int) depth= Primitive(int) = 
// Arg ARG Primitive(int) scn= Primitive(int) = 
// Arg ARG Primitive(int) dcn= Primitive(int) = 
// Arg ARG Primitive(bool) swapBlue= Primitive(bool) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_cvtBGRtoBGR_const_uchar_X_src_data_size_t_src_step_uchar_X_dst_data_size_t_dst_step_int_width_int_height_int_depth_int_scn_int_dcn_bool_swapBlue(const uchar* src_data, std::size_t src_step, uchar* dst_data, std::size_t dst_step, int width, int height, int depth, int scn, int dcn, bool swapBlue) {
    try {
        cv::hal::cvtBGRtoBGR(src_data, src_step, dst_data, dst_step, width, height, depth, scn, dcn, swapBlue);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_cvtBGRtoGray_const_uchar_X_src_data_size_t_src_step_uchar_X_dst_data_size_t_dst_step_int_width_int_height_int_depth_int_scn_bool_swapBlue
// parsed: cv::hal::cvtBGRtoGray
// as:     cv::hal::cvtBGRtoGray (function)
// Arg ARG RawPtr[Primitive(uchar)] * src_data= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) src_step= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(uchar)] * dst_data= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) dst_step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG Primitive(int) depth= Primitive(int) = 
// Arg ARG Primitive(int) scn= Primitive(int) = 
// Arg ARG Primitive(bool) swapBlue= Primitive(bool) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_cvtBGRtoGray_const_uchar_X_src_data_size_t_src_step_uchar_X_dst_data_size_t_dst_step_int_width_int_height_int_depth_int_scn_bool_swapBlue(const uchar* src_data, std::size_t src_step, uchar* dst_data, std::size_t dst_step, int width, int height, int depth, int scn, bool swapBlue) {
    try {
        cv::hal::cvtBGRtoGray(src_data, src_step, dst_data, dst_step, width, height, depth, scn, swapBlue);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_cvtBGRtoHSV_const_uchar_X_src_data_size_t_src_step_uchar_X_dst_data_size_t_dst_step_int_width_int_height_int_depth_int_scn_bool_swapBlue_bool_isFullRange_bool_isHSV
// parsed: cv::hal::cvtBGRtoHSV
// as:     cv::hal::cvtBGRtoHSV (function)
// Arg ARG RawPtr[Primitive(uchar)] * src_data= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) src_step= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(uchar)] * dst_data= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) dst_step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG Primitive(int) depth= Primitive(int) = 
// Arg ARG Primitive(int) scn= Primitive(int) = 
// Arg ARG Primitive(bool) swapBlue= Primitive(bool) = 
// Arg ARG Primitive(bool) isFullRange= Primitive(bool) = 
// Arg ARG Primitive(bool) isHSV= Primitive(bool) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_cvtBGRtoHSV_const_uchar_X_src_data_size_t_src_step_uchar_X_dst_data_size_t_dst_step_int_width_int_height_int_depth_int_scn_bool_swapBlue_bool_isFullRange_bool_isHSV(const uchar* src_data, std::size_t src_step, uchar* dst_data, std::size_t dst_step, int width, int height, int depth, int scn, bool swapBlue, bool isFullRange, bool isHSV) {
    try {
        cv::hal::cvtBGRtoHSV(src_data, src_step, dst_data, dst_step, width, height, depth, scn, swapBlue, isFullRange, isHSV);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_cvtBGRtoLab_const_uchar_X_src_data_size_t_src_step_uchar_X_dst_data_size_t_dst_step_int_width_int_height_int_depth_int_scn_bool_swapBlue_bool_isLab_bool_srgb
// parsed: cv::hal::cvtBGRtoLab
// as:     cv::hal::cvtBGRtoLab (function)
// Arg ARG RawPtr[Primitive(uchar)] * src_data= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) src_step= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(uchar)] * dst_data= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) dst_step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG Primitive(int) depth= Primitive(int) = 
// Arg ARG Primitive(int) scn= Primitive(int) = 
// Arg ARG Primitive(bool) swapBlue= Primitive(bool) = 
// Arg ARG Primitive(bool) isLab= Primitive(bool) = 
// Arg ARG Primitive(bool) srgb= Primitive(bool) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_cvtBGRtoLab_const_uchar_X_src_data_size_t_src_step_uchar_X_dst_data_size_t_dst_step_int_width_int_height_int_depth_int_scn_bool_swapBlue_bool_isLab_bool_srgb(const uchar* src_data, std::size_t src_step, uchar* dst_data, std::size_t dst_step, int width, int height, int depth, int scn, bool swapBlue, bool isLab, bool srgb) {
    try {
        cv::hal::cvtBGRtoLab(src_data, src_step, dst_data, dst_step, width, height, depth, scn, swapBlue, isLab, srgb);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_cvtBGRtoThreePlaneYUV_const_uchar_X_src_data_size_t_src_step_uchar_X_dst_data_size_t_dst_step_int_width_int_height_int_scn_bool_swapBlue_int_uIdx
// parsed: cv::hal::cvtBGRtoThreePlaneYUV
// as:     cv::hal::cvtBGRtoThreePlaneYUV (function)
// Arg ARG RawPtr[Primitive(uchar)] * src_data= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) src_step= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(uchar)] * dst_data= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) dst_step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG Primitive(int) scn= Primitive(int) = 
// Arg ARG Primitive(bool) swapBlue= Primitive(bool) = 
// Arg ARG Primitive(int) uIdx= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_cvtBGRtoThreePlaneYUV_const_uchar_X_src_data_size_t_src_step_uchar_X_dst_data_size_t_dst_step_int_width_int_height_int_scn_bool_swapBlue_int_uIdx(const uchar* src_data, std::size_t src_step, uchar* dst_data, std::size_t dst_step, int width, int height, int scn, bool swapBlue, int uIdx) {
    try {
        cv::hal::cvtBGRtoThreePlaneYUV(src_data, src_step, dst_data, dst_step, width, height, scn, swapBlue, uIdx);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_cvtBGRtoTwoPlaneYUV_const_uchar_X_src_data_size_t_src_step_uchar_X_y_data_uchar_X_uv_data_size_t_dst_step_int_width_int_height_int_scn_bool_swapBlue_int_uIdx
// parsed: cv::hal::cvtBGRtoTwoPlaneYUV
// as:     cv::hal::cvtBGRtoTwoPlaneYUV (function)
// Arg ARG RawPtr[Primitive(uchar)] * src_data= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) src_step= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(uchar)] * y_data= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG RawPtr[Primitive(uchar)] * uv_data= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) dst_step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG Primitive(int) scn= Primitive(int) = 
// Arg ARG Primitive(bool) swapBlue= Primitive(bool) = 
// Arg ARG Primitive(int) uIdx= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_cvtBGRtoTwoPlaneYUV_const_uchar_X_src_data_size_t_src_step_uchar_X_y_data_uchar_X_uv_data_size_t_dst_step_int_width_int_height_int_scn_bool_swapBlue_int_uIdx(const uchar* src_data, std::size_t src_step, uchar* y_data, uchar* uv_data, std::size_t dst_step, int width, int height, int scn, bool swapBlue, int uIdx) {
    try {
        cv::hal::cvtBGRtoTwoPlaneYUV(src_data, src_step, y_data, uv_data, dst_step, width, height, scn, swapBlue, uIdx);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_cvtBGRtoXYZ_const_uchar_X_src_data_size_t_src_step_uchar_X_dst_data_size_t_dst_step_int_width_int_height_int_depth_int_scn_bool_swapBlue
// parsed: cv::hal::cvtBGRtoXYZ
// as:     cv::hal::cvtBGRtoXYZ (function)
// Arg ARG RawPtr[Primitive(uchar)] * src_data= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) src_step= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(uchar)] * dst_data= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) dst_step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG Primitive(int) depth= Primitive(int) = 
// Arg ARG Primitive(int) scn= Primitive(int) = 
// Arg ARG Primitive(bool) swapBlue= Primitive(bool) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_cvtBGRtoXYZ_const_uchar_X_src_data_size_t_src_step_uchar_X_dst_data_size_t_dst_step_int_width_int_height_int_depth_int_scn_bool_swapBlue(const uchar* src_data, std::size_t src_step, uchar* dst_data, std::size_t dst_step, int width, int height, int depth, int scn, bool swapBlue) {
    try {
        cv::hal::cvtBGRtoXYZ(src_data, src_step, dst_data, dst_step, width, height, depth, scn, swapBlue);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_cvtBGRtoYUV_const_uchar_X_src_data_size_t_src_step_uchar_X_dst_data_size_t_dst_step_int_width_int_height_int_depth_int_scn_bool_swapBlue_bool_isCbCr
// parsed: cv::hal::cvtBGRtoYUV
// as:     cv::hal::cvtBGRtoYUV (function)
// Arg ARG RawPtr[Primitive(uchar)] * src_data= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) src_step= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(uchar)] * dst_data= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) dst_step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG Primitive(int) depth= Primitive(int) = 
// Arg ARG Primitive(int) scn= Primitive(int) = 
// Arg ARG Primitive(bool) swapBlue= Primitive(bool) = 
// Arg ARG Primitive(bool) isCbCr= Primitive(bool) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_cvtBGRtoYUV_const_uchar_X_src_data_size_t_src_step_uchar_X_dst_data_size_t_dst_step_int_width_int_height_int_depth_int_scn_bool_swapBlue_bool_isCbCr(const uchar* src_data, std::size_t src_step, uchar* dst_data, std::size_t dst_step, int width, int height, int depth, int scn, bool swapBlue, bool isCbCr) {
    try {
        cv::hal::cvtBGRtoYUV(src_data, src_step, dst_data, dst_step, width, height, depth, scn, swapBlue, isCbCr);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_cvtGraytoBGR5x5_const_uchar_X_src_data_size_t_src_step_uchar_X_dst_data_size_t_dst_step_int_width_int_height_int_greenBits
// parsed: cv::hal::cvtGraytoBGR5x5
// as:     cv::hal::cvtGraytoBGR5x5 (function)
// Arg ARG RawPtr[Primitive(uchar)] * src_data= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) src_step= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(uchar)] * dst_data= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) dst_step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG Primitive(int) greenBits= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_cvtGraytoBGR5x5_const_uchar_X_src_data_size_t_src_step_uchar_X_dst_data_size_t_dst_step_int_width_int_height_int_greenBits(const uchar* src_data, std::size_t src_step, uchar* dst_data, std::size_t dst_step, int width, int height, int greenBits) {
    try {
        cv::hal::cvtGraytoBGR5x5(src_data, src_step, dst_data, dst_step, width, height, greenBits);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_cvtGraytoBGR_const_uchar_X_src_data_size_t_src_step_uchar_X_dst_data_size_t_dst_step_int_width_int_height_int_depth_int_dcn
// parsed: cv::hal::cvtGraytoBGR
// as:     cv::hal::cvtGraytoBGR (function)
// Arg ARG RawPtr[Primitive(uchar)] * src_data= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) src_step= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(uchar)] * dst_data= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) dst_step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG Primitive(int) depth= Primitive(int) = 
// Arg ARG Primitive(int) dcn= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_cvtGraytoBGR_const_uchar_X_src_data_size_t_src_step_uchar_X_dst_data_size_t_dst_step_int_width_int_height_int_depth_int_dcn(const uchar* src_data, std::size_t src_step, uchar* dst_data, std::size_t dst_step, int width, int height, int depth, int dcn) {
    try {
        cv::hal::cvtGraytoBGR(src_data, src_step, dst_data, dst_step, width, height, depth, dcn);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_cvtHSVtoBGR_const_uchar_X_src_data_size_t_src_step_uchar_X_dst_data_size_t_dst_step_int_width_int_height_int_depth_int_dcn_bool_swapBlue_bool_isFullRange_bool_isHSV
// parsed: cv::hal::cvtHSVtoBGR
// as:     cv::hal::cvtHSVtoBGR (function)
// Arg ARG RawPtr[Primitive(uchar)] * src_data= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) src_step= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(uchar)] * dst_data= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) dst_step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG Primitive(int) depth= Primitive(int) = 
// Arg ARG Primitive(int) dcn= Primitive(int) = 
// Arg ARG Primitive(bool) swapBlue= Primitive(bool) = 
// Arg ARG Primitive(bool) isFullRange= Primitive(bool) = 
// Arg ARG Primitive(bool) isHSV= Primitive(bool) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_cvtHSVtoBGR_const_uchar_X_src_data_size_t_src_step_uchar_X_dst_data_size_t_dst_step_int_width_int_height_int_depth_int_dcn_bool_swapBlue_bool_isFullRange_bool_isHSV(const uchar* src_data, std::size_t src_step, uchar* dst_data, std::size_t dst_step, int width, int height, int depth, int dcn, bool swapBlue, bool isFullRange, bool isHSV) {
    try {
        cv::hal::cvtHSVtoBGR(src_data, src_step, dst_data, dst_step, width, height, depth, dcn, swapBlue, isFullRange, isHSV);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_cvtLabtoBGR_const_uchar_X_src_data_size_t_src_step_uchar_X_dst_data_size_t_dst_step_int_width_int_height_int_depth_int_dcn_bool_swapBlue_bool_isLab_bool_srgb
// parsed: cv::hal::cvtLabtoBGR
// as:     cv::hal::cvtLabtoBGR (function)
// Arg ARG RawPtr[Primitive(uchar)] * src_data= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) src_step= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(uchar)] * dst_data= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) dst_step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG Primitive(int) depth= Primitive(int) = 
// Arg ARG Primitive(int) dcn= Primitive(int) = 
// Arg ARG Primitive(bool) swapBlue= Primitive(bool) = 
// Arg ARG Primitive(bool) isLab= Primitive(bool) = 
// Arg ARG Primitive(bool) srgb= Primitive(bool) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_cvtLabtoBGR_const_uchar_X_src_data_size_t_src_step_uchar_X_dst_data_size_t_dst_step_int_width_int_height_int_depth_int_dcn_bool_swapBlue_bool_isLab_bool_srgb(const uchar* src_data, std::size_t src_step, uchar* dst_data, std::size_t dst_step, int width, int height, int depth, int dcn, bool swapBlue, bool isLab, bool srgb) {
    try {
        cv::hal::cvtLabtoBGR(src_data, src_step, dst_data, dst_step, width, height, depth, dcn, swapBlue, isLab, srgb);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_cvtMultipliedRGBAtoRGBA_const_uchar_X_src_data_size_t_src_step_uchar_X_dst_data_size_t_dst_step_int_width_int_height
// parsed: cv::hal::cvtMultipliedRGBAtoRGBA
// as:     cv::hal::cvtMultipliedRGBAtoRGBA (function)
// Arg ARG RawPtr[Primitive(uchar)] * src_data= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) src_step= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(uchar)] * dst_data= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) dst_step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_cvtMultipliedRGBAtoRGBA_const_uchar_X_src_data_size_t_src_step_uchar_X_dst_data_size_t_dst_step_int_width_int_height(const uchar* src_data, std::size_t src_step, uchar* dst_data, std::size_t dst_step, int width, int height) {
    try {
        cv::hal::cvtMultipliedRGBAtoRGBA(src_data, src_step, dst_data, dst_step, width, height);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_cvtOnePlaneYUVtoBGR_const_uchar_X_src_data_size_t_src_step_uchar_X_dst_data_size_t_dst_step_int_width_int_height_int_dcn_bool_swapBlue_int_uIdx_int_ycn
// parsed: cv::hal::cvtOnePlaneYUVtoBGR
// as:     cv::hal::cvtOnePlaneYUVtoBGR (function)
// Arg ARG RawPtr[Primitive(uchar)] * src_data= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) src_step= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(uchar)] * dst_data= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) dst_step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG Primitive(int) dcn= Primitive(int) = 
// Arg ARG Primitive(bool) swapBlue= Primitive(bool) = 
// Arg ARG Primitive(int) uIdx= Primitive(int) = 
// Arg ARG Primitive(int) ycn= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_cvtOnePlaneYUVtoBGR_const_uchar_X_src_data_size_t_src_step_uchar_X_dst_data_size_t_dst_step_int_width_int_height_int_dcn_bool_swapBlue_int_uIdx_int_ycn(const uchar* src_data, std::size_t src_step, uchar* dst_data, std::size_t dst_step, int width, int height, int dcn, bool swapBlue, int uIdx, int ycn) {
    try {
        cv::hal::cvtOnePlaneYUVtoBGR(src_data, src_step, dst_data, dst_step, width, height, dcn, swapBlue, uIdx, ycn);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_cvtRGBAtoMultipliedRGBA_const_uchar_X_src_data_size_t_src_step_uchar_X_dst_data_size_t_dst_step_int_width_int_height
// parsed: cv::hal::cvtRGBAtoMultipliedRGBA
// as:     cv::hal::cvtRGBAtoMultipliedRGBA (function)
// Arg ARG RawPtr[Primitive(uchar)] * src_data= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) src_step= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(uchar)] * dst_data= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) dst_step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_cvtRGBAtoMultipliedRGBA_const_uchar_X_src_data_size_t_src_step_uchar_X_dst_data_size_t_dst_step_int_width_int_height(const uchar* src_data, std::size_t src_step, uchar* dst_data, std::size_t dst_step, int width, int height) {
    try {
        cv::hal::cvtRGBAtoMultipliedRGBA(src_data, src_step, dst_data, dst_step, width, height);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_cvtThreePlaneYUVtoBGR_const_uchar_X_src_data_size_t_src_step_uchar_X_dst_data_size_t_dst_step_int_dst_width_int_dst_height_int_dcn_bool_swapBlue_int_uIdx
// parsed: cv::hal::cvtThreePlaneYUVtoBGR
// as:     cv::hal::cvtThreePlaneYUVtoBGR (function)
// Arg ARG RawPtr[Primitive(uchar)] * src_data= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) src_step= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(uchar)] * dst_data= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) dst_step= Primitive(size_t) = 
// Arg ARG Primitive(int) dst_width= Primitive(int) = 
// Arg ARG Primitive(int) dst_height= Primitive(int) = 
// Arg ARG Primitive(int) dcn= Primitive(int) = 
// Arg ARG Primitive(bool) swapBlue= Primitive(bool) = 
// Arg ARG Primitive(int) uIdx= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_cvtThreePlaneYUVtoBGR_const_uchar_X_src_data_size_t_src_step_uchar_X_dst_data_size_t_dst_step_int_dst_width_int_dst_height_int_dcn_bool_swapBlue_int_uIdx(const uchar* src_data, std::size_t src_step, uchar* dst_data, std::size_t dst_step, int dst_width, int dst_height, int dcn, bool swapBlue, int uIdx) {
    try {
        cv::hal::cvtThreePlaneYUVtoBGR(src_data, src_step, dst_data, dst_step, dst_width, dst_height, dcn, swapBlue, uIdx);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_cvtTwoPlaneYUVtoBGR_const_uchar_X_src_data_size_t_src_step_uchar_X_dst_data_size_t_dst_step_int_dst_width_int_dst_height_int_dcn_bool_swapBlue_int_uIdx
// parsed: cv::hal::cvtTwoPlaneYUVtoBGR
// as:     cv::hal::cvtTwoPlaneYUVtoBGR (function)
// Arg ARG RawPtr[Primitive(uchar)] * src_data= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) src_step= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(uchar)] * dst_data= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) dst_step= Primitive(size_t) = 
// Arg ARG Primitive(int) dst_width= Primitive(int) = 
// Arg ARG Primitive(int) dst_height= Primitive(int) = 
// Arg ARG Primitive(int) dcn= Primitive(int) = 
// Arg ARG Primitive(bool) swapBlue= Primitive(bool) = 
// Arg ARG Primitive(int) uIdx= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_cvtTwoPlaneYUVtoBGR_const_uchar_X_src_data_size_t_src_step_uchar_X_dst_data_size_t_dst_step_int_dst_width_int_dst_height_int_dcn_bool_swapBlue_int_uIdx(const uchar* src_data, std::size_t src_step, uchar* dst_data, std::size_t dst_step, int dst_width, int dst_height, int dcn, bool swapBlue, int uIdx) {
    try {
        cv::hal::cvtTwoPlaneYUVtoBGR(src_data, src_step, dst_data, dst_step, dst_width, dst_height, dcn, swapBlue, uIdx);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_cvtTwoPlaneYUVtoBGR_const_uchar_X_y_data_const_uchar_X_uv_data_size_t_src_step_uchar_X_dst_data_size_t_dst_step_int_dst_width_int_dst_height_int_dcn_bool_swapBlue_int_uIdx
// parsed: cv::hal::cvtTwoPlaneYUVtoBGR
// as:     cv::hal::cvtTwoPlaneYUVtoBGR (function)
// Arg ARG RawPtr[Primitive(uchar)] * y_data= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG RawPtr[Primitive(uchar)] * uv_data= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) src_step= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(uchar)] * dst_data= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) dst_step= Primitive(size_t) = 
// Arg ARG Primitive(int) dst_width= Primitive(int) = 
// Arg ARG Primitive(int) dst_height= Primitive(int) = 
// Arg ARG Primitive(int) dcn= Primitive(int) = 
// Arg ARG Primitive(bool) swapBlue= Primitive(bool) = 
// Arg ARG Primitive(int) uIdx= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_cvtTwoPlaneYUVtoBGR_const_uchar_X_y_data_const_uchar_X_uv_data_size_t_src_step_uchar_X_dst_data_size_t_dst_step_int_dst_width_int_dst_height_int_dcn_bool_swapBlue_int_uIdx(const uchar* y_data, const uchar* uv_data, std::size_t src_step, uchar* dst_data, std::size_t dst_step, int dst_width, int dst_height, int dcn, bool swapBlue, int uIdx) {
    try {
        cv::hal::cvtTwoPlaneYUVtoBGR(y_data, uv_data, src_step, dst_data, dst_step, dst_width, dst_height, dcn, swapBlue, uIdx);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_cvtXYZtoBGR_const_uchar_X_src_data_size_t_src_step_uchar_X_dst_data_size_t_dst_step_int_width_int_height_int_depth_int_dcn_bool_swapBlue
// parsed: cv::hal::cvtXYZtoBGR
// as:     cv::hal::cvtXYZtoBGR (function)
// Arg ARG RawPtr[Primitive(uchar)] * src_data= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) src_step= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(uchar)] * dst_data= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) dst_step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG Primitive(int) depth= Primitive(int) = 
// Arg ARG Primitive(int) dcn= Primitive(int) = 
// Arg ARG Primitive(bool) swapBlue= Primitive(bool) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_cvtXYZtoBGR_const_uchar_X_src_data_size_t_src_step_uchar_X_dst_data_size_t_dst_step_int_width_int_height_int_depth_int_dcn_bool_swapBlue(const uchar* src_data, std::size_t src_step, uchar* dst_data, std::size_t dst_step, int width, int height, int depth, int dcn, bool swapBlue) {
    try {
        cv::hal::cvtXYZtoBGR(src_data, src_step, dst_data, dst_step, width, height, depth, dcn, swapBlue);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_cvtYUVtoBGR_const_uchar_X_src_data_size_t_src_step_uchar_X_dst_data_size_t_dst_step_int_width_int_height_int_depth_int_dcn_bool_swapBlue_bool_isCbCr
// parsed: cv::hal::cvtYUVtoBGR
// as:     cv::hal::cvtYUVtoBGR (function)
// Arg ARG RawPtr[Primitive(uchar)] * src_data= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) src_step= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(uchar)] * dst_data= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) dst_step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG Primitive(int) depth= Primitive(int) = 
// Arg ARG Primitive(int) dcn= Primitive(int) = 
// Arg ARG Primitive(bool) swapBlue= Primitive(bool) = 
// Arg ARG Primitive(bool) isCbCr= Primitive(bool) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_cvtYUVtoBGR_const_uchar_X_src_data_size_t_src_step_uchar_X_dst_data_size_t_dst_step_int_width_int_height_int_depth_int_dcn_bool_swapBlue_bool_isCbCr(const uchar* src_data, std::size_t src_step, uchar* dst_data, std::size_t dst_step, int width, int height, int depth, int dcn, bool swapBlue, bool isCbCr) {
    try {
        cv::hal::cvtYUVtoBGR(src_data, src_step, dst_data, dst_step, width, height, depth, dcn, swapBlue, isCbCr);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_div16s_const_short_X_src1_size_t_step1_const_short_X_src2_size_t_step2_short_X_dst_size_t_step_int_width_int_height_void_X_scale
// parsed: cv::hal::div16s
// as:     cv::hal::div16s (function)
// Arg ARG RawPtr[Primitive(short)] * src1= (ptr) RawPtr[Primitive(short)] = 
// Arg ARG Primitive(size_t) step1= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(short)] * src2= (ptr) RawPtr[Primitive(short)] = 
// Arg ARG Primitive(size_t) step2= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(short)] * dst= (ptr) RawPtr[Primitive(short)] = 
// Arg ARG Primitive(size_t) step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG RawPtr[Primitive(void)] * scale= (ptr) RawPtr[Primitive(void)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_div16s_const_short_X_src1_size_t_step1_const_short_X_src2_size_t_step2_short_X_dst_size_t_step_int_width_int_height_void_X_scale(const short* src1, std::size_t step1, const short* src2, std::size_t step2, short* dst, std::size_t step, int width, int height, void* scale) {
    try {
        cv::hal::div16s(src1, step1, src2, step2, dst, step, width, height, scale);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_div16u_const_ushort_X_src1_size_t_step1_const_ushort_X_src2_size_t_step2_ushort_X_dst_size_t_step_int_width_int_height_void_X_scale
// parsed: cv::hal::div16u
// as:     cv::hal::div16u (function)
// Arg ARG RawPtr[Primitive(ushort)] * src1= (ptr) RawPtr[Primitive(ushort)] = 
// Arg ARG Primitive(size_t) step1= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(ushort)] * src2= (ptr) RawPtr[Primitive(ushort)] = 
// Arg ARG Primitive(size_t) step2= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(ushort)] * dst= (ptr) RawPtr[Primitive(ushort)] = 
// Arg ARG Primitive(size_t) step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG RawPtr[Primitive(void)] * scale= (ptr) RawPtr[Primitive(void)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_div16u_const_ushort_X_src1_size_t_step1_const_ushort_X_src2_size_t_step2_ushort_X_dst_size_t_step_int_width_int_height_void_X_scale(const ushort* src1, std::size_t step1, const ushort* src2, std::size_t step2, ushort* dst, std::size_t step, int width, int height, void* scale) {
    try {
        cv::hal::div16u(src1, step1, src2, step2, dst, step, width, height, scale);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_div32f_const_float_X_src1_size_t_step1_const_float_X_src2_size_t_step2_float_X_dst_size_t_step_int_width_int_height_void_X_scale
// parsed: cv::hal::div32f
// as:     cv::hal::div32f (function)
// Arg ARG RawPtr[Primitive(float)] * src1= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG Primitive(size_t) step1= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(float)] * src2= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG Primitive(size_t) step2= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(float)] * dst= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG Primitive(size_t) step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG RawPtr[Primitive(void)] * scale= (ptr) RawPtr[Primitive(void)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_div32f_const_float_X_src1_size_t_step1_const_float_X_src2_size_t_step2_float_X_dst_size_t_step_int_width_int_height_void_X_scale(const float* src1, std::size_t step1, const float* src2, std::size_t step2, float* dst, std::size_t step, int width, int height, void* scale) {
    try {
        cv::hal::div32f(src1, step1, src2, step2, dst, step, width, height, scale);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_div32s_const_int_X_src1_size_t_step1_const_int_X_src2_size_t_step2_int_X_dst_size_t_step_int_width_int_height_void_X_scale
// parsed: cv::hal::div32s
// as:     cv::hal::div32s (function)
// Arg ARG RawPtr[Primitive(int)] * src1= (ptr) RawPtr[Primitive(int)] = 
// Arg ARG Primitive(size_t) step1= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(int)] * src2= (ptr) RawPtr[Primitive(int)] = 
// Arg ARG Primitive(size_t) step2= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(int)] * dst= (ptr) RawPtr[Primitive(int)] = 
// Arg ARG Primitive(size_t) step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG RawPtr[Primitive(void)] * scale= (ptr) RawPtr[Primitive(void)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_div32s_const_int_X_src1_size_t_step1_const_int_X_src2_size_t_step2_int_X_dst_size_t_step_int_width_int_height_void_X_scale(const int* src1, std::size_t step1, const int* src2, std::size_t step2, int* dst, std::size_t step, int width, int height, void* scale) {
    try {
        cv::hal::div32s(src1, step1, src2, step2, dst, step, width, height, scale);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_div64f_const_double_X_src1_size_t_step1_const_double_X_src2_size_t_step2_double_X_dst_size_t_step_int_width_int_height_void_X_scale
// parsed: cv::hal::div64f
// as:     cv::hal::div64f (function)
// Arg ARG RawPtr[Primitive(double)] * src1= (ptr) RawPtr[Primitive(double)] = 
// Arg ARG Primitive(size_t) step1= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(double)] * src2= (ptr) RawPtr[Primitive(double)] = 
// Arg ARG Primitive(size_t) step2= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(double)] * dst= (ptr) RawPtr[Primitive(double)] = 
// Arg ARG Primitive(size_t) step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG RawPtr[Primitive(void)] * scale= (ptr) RawPtr[Primitive(void)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_div64f_const_double_X_src1_size_t_step1_const_double_X_src2_size_t_step2_double_X_dst_size_t_step_int_width_int_height_void_X_scale(const double* src1, std::size_t step1, const double* src2, std::size_t step2, double* dst, std::size_t step, int width, int height, void* scale) {
    try {
        cv::hal::div64f(src1, step1, src2, step2, dst, step, width, height, scale);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_div8s_const_schar_X_src1_size_t_step1_const_schar_X_src2_size_t_step2_schar_X_dst_size_t_step_int_width_int_height_void_X_scale
// parsed: cv::hal::div8s
// as:     cv::hal::div8s (function)
// Arg ARG RawPtr[Primitive(schar)] * src1= (ptr) RawPtr[Primitive(schar)] = 
// Arg ARG Primitive(size_t) step1= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(schar)] * src2= (ptr) RawPtr[Primitive(schar)] = 
// Arg ARG Primitive(size_t) step2= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(schar)] * dst= (ptr) RawPtr[Primitive(schar)] = 
// Arg ARG Primitive(size_t) step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG RawPtr[Primitive(void)] * scale= (ptr) RawPtr[Primitive(void)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_div8s_const_schar_X_src1_size_t_step1_const_schar_X_src2_size_t_step2_schar_X_dst_size_t_step_int_width_int_height_void_X_scale(const schar* src1, std::size_t step1, const schar* src2, std::size_t step2, schar* dst, std::size_t step, int width, int height, void* scale) {
    try {
        cv::hal::div8s(src1, step1, src2, step2, dst, step, width, height, scale);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_div8u_const_uchar_X_src1_size_t_step1_const_uchar_X_src2_size_t_step2_uchar_X_dst_size_t_step_int_width_int_height_void_X_scale
// parsed: cv::hal::div8u
// as:     cv::hal::div8u (function)
// Arg ARG RawPtr[Primitive(uchar)] * src1= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) step1= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(uchar)] * src2= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) step2= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(uchar)] * dst= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG RawPtr[Primitive(void)] * scale= (ptr) RawPtr[Primitive(void)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_div8u_const_uchar_X_src1_size_t_step1_const_uchar_X_src2_size_t_step2_uchar_X_dst_size_t_step_int_width_int_height_void_X_scale(const uchar* src1, std::size_t step1, const uchar* src2, std::size_t step2, uchar* dst, std::size_t step, int width, int height, void* scale) {
    try {
        cv::hal::div8u(src1, step1, src2, step2, dst, step, width, height, scale);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_exp32f_const_float_X_src_float_X_dst_int_n
// parsed: cv::hal::exp32f
// as:     cv::hal::exp32f (function)
// Arg ARG RawPtr[Primitive(float)] * src= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG RawPtr[Primitive(float)] * dst= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG Primitive(int) n= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_exp32f_const_float_X_src_float_X_dst_int_n(const float* src, float* dst, int n) {
    try {
        cv::hal::exp32f(src, dst, n);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_exp64f_const_double_X_src_double_X_dst_int_n
// parsed: cv::hal::exp64f
// as:     cv::hal::exp64f (function)
// Arg ARG RawPtr[Primitive(double)] * src= (ptr) RawPtr[Primitive(double)] = 
// Arg ARG RawPtr[Primitive(double)] * dst= (ptr) RawPtr[Primitive(double)] = 
// Arg ARG Primitive(int) n= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_exp64f_const_double_X_src_double_X_dst_int_n(const double* src, double* dst, int n) {
    try {
        cv::hal::exp64f(src, dst, n);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_exp_const_double_X_src_double_X_dst_int_n
// parsed: cv::hal::exp
// as:     cv::hal::exp (function)
// Arg ARG RawPtr[Primitive(double)] * src= (ptr) RawPtr[Primitive(double)] = 
// Arg ARG RawPtr[Primitive(double)] * dst= (ptr) RawPtr[Primitive(double)] = 
// Arg ARG Primitive(int) n= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_exp_const_double_X_src_double_X_dst_int_n(const double* src, double* dst, int n) {
    try {
        cv::hal::exp(src, dst, n);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_exp_const_float_X_src_float_X_dst_int_n
// parsed: cv::hal::exp
// as:     cv::hal::exp (function)
// Arg ARG RawPtr[Primitive(float)] * src= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG RawPtr[Primitive(float)] * dst= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG Primitive(int) n= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_exp_const_float_X_src_float_X_dst_int_n(const float* src, float* dst, int n) {
    try {
        cv::hal::exp(src, dst, n);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_fastAtan2_const_float_X_y_const_float_X_x_float_X_dst_int_n_bool_angleInDegrees
// parsed: cv::hal::fastAtan2
// as:     cv::hal::fastAtan2 (function)
// Arg ARG RawPtr[Primitive(float)] * y= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG RawPtr[Primitive(float)] * x= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG RawPtr[Primitive(float)] * dst= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG Primitive(int) n= Primitive(int) = 
// Arg ARG Primitive(bool) angleInDegrees= Primitive(bool) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_fastAtan2_const_float_X_y_const_float_X_x_float_X_dst_int_n_bool_angleInDegrees(const float* y, const float* x, float* dst, int n, bool angleInDegrees) {
    try {
        cv::hal::fastAtan2(y, x, dst, n, angleInDegrees);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_fastAtan32f_const_float_X_y_const_float_X_x_float_X_dst_int_n_bool_angleInDegrees
// parsed: cv::hal::fastAtan32f
// as:     cv::hal::fastAtan32f (function)
// Arg ARG RawPtr[Primitive(float)] * y= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG RawPtr[Primitive(float)] * x= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG RawPtr[Primitive(float)] * dst= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG Primitive(int) n= Primitive(int) = 
// Arg ARG Primitive(bool) angleInDegrees= Primitive(bool) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_fastAtan32f_const_float_X_y_const_float_X_x_float_X_dst_int_n_bool_angleInDegrees(const float* y, const float* x, float* dst, int n, bool angleInDegrees) {
    try {
        cv::hal::fastAtan32f(y, x, dst, n, angleInDegrees);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_fastAtan64f_const_double_X_y_const_double_X_x_double_X_dst_int_n_bool_angleInDegrees
// parsed: cv::hal::fastAtan64f
// as:     cv::hal::fastAtan64f (function)
// Arg ARG RawPtr[Primitive(double)] * y= (ptr) RawPtr[Primitive(double)] = 
// Arg ARG RawPtr[Primitive(double)] * x= (ptr) RawPtr[Primitive(double)] = 
// Arg ARG RawPtr[Primitive(double)] * dst= (ptr) RawPtr[Primitive(double)] = 
// Arg ARG Primitive(int) n= Primitive(int) = 
// Arg ARG Primitive(bool) angleInDegrees= Primitive(bool) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_fastAtan64f_const_double_X_y_const_double_X_x_double_X_dst_int_n_bool_angleInDegrees(const double* y, const double* x, double* dst, int n, bool angleInDegrees) {
    try {
        cv::hal::fastAtan64f(y, x, dst, n, angleInDegrees);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_filter2D_int_stype_int_dtype_int_kernel_type_uchar_X_src_data_size_t_src_step_uchar_X_dst_data_size_t_dst_step_int_width_int_height_int_full_width_int_full_height_int_offset_x_int_offset_y_uchar_X_kernel_data_size_t_kernel_step_int_kernel_width_int_kernel_height_int_anchor_x_int_anchor_y_double_delta_int_borderType_bool_isSubmatrix
// parsed: cv::hal::filter2D
// as:     cv::hal::filter2D (function)
// Arg ARG Primitive(int) stype= Primitive(int) = 
// Arg ARG Primitive(int) dtype= Primitive(int) = 
// Arg ARG Primitive(int) kernel_type= Primitive(int) = 
// Arg ARG RawPtr[Primitive(uchar)] * src_data= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) src_step= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(uchar)] * dst_data= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) dst_step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG Primitive(int) full_width= Primitive(int) = 
// Arg ARG Primitive(int) full_height= Primitive(int) = 
// Arg ARG Primitive(int) offset_x= Primitive(int) = 
// Arg ARG Primitive(int) offset_y= Primitive(int) = 
// Arg ARG RawPtr[Primitive(uchar)] * kernel_data= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) kernel_step= Primitive(size_t) = 
// Arg ARG Primitive(int) kernel_width= Primitive(int) = 
// Arg ARG Primitive(int) kernel_height= Primitive(int) = 
// Arg ARG Primitive(int) anchor_x= Primitive(int) = 
// Arg ARG Primitive(int) anchor_y= Primitive(int) = 
// Arg ARG Primitive(double) delta= Primitive(double) = 
// Arg ARG Primitive(int) borderType= Primitive(int) = 
// Arg ARG Primitive(bool) isSubmatrix= Primitive(bool) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_filter2D_int_stype_int_dtype_int_kernel_type_uchar_X_src_data_size_t_src_step_uchar_X_dst_data_size_t_dst_step_int_width_int_height_int_full_width_int_full_height_int_offset_x_int_offset_y_uchar_X_kernel_data_size_t_kernel_step_int_kernel_width_int_kernel_height_int_anchor_x_int_anchor_y_double_delta_int_borderType_bool_isSubmatrix(int stype, int dtype, int kernel_type, uchar* src_data, std::size_t src_step, uchar* dst_data, std::size_t dst_step, int width, int height, int full_width, int full_height, int offset_x, int offset_y, uchar* kernel_data, std::size_t kernel_step, int kernel_width, int kernel_height, int anchor_x, int anchor_y, double delta, int borderType, bool isSubmatrix) {
    try {
        cv::hal::filter2D(stype, dtype, kernel_type, src_data, src_step, dst_data, dst_step, width, height, full_width, full_height, offset_x, offset_y, kernel_data, kernel_step, kernel_width, kernel_height, anchor_x, anchor_y, delta, borderType, isSubmatrix);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_gemm32f_const_float_X_src1_size_t_src1_step_const_float_X_src2_size_t_src2_step_float_alpha_const_float_X_src3_size_t_src3_step_float_beta_float_X_dst_size_t_dst_step_int_m_a_int_n_a_int_n_d_int_flags
// parsed: cv::hal::gemm32f
// as:     cv::hal::gemm32f (function)
// Arg ARG RawPtr[Primitive(float)] * src1= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG Primitive(size_t) src1_step= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(float)] * src2= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG Primitive(size_t) src2_step= Primitive(size_t) = 
// Arg ARG Primitive(float) alpha= Primitive(float) = 
// Arg ARG RawPtr[Primitive(float)] * src3= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG Primitive(size_t) src3_step= Primitive(size_t) = 
// Arg ARG Primitive(float) beta= Primitive(float) = 
// Arg ARG RawPtr[Primitive(float)] * dst= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG Primitive(size_t) dst_step= Primitive(size_t) = 
// Arg ARG Primitive(int) m_a= Primitive(int) = 
// Arg ARG Primitive(int) n_a= Primitive(int) = 
// Arg ARG Primitive(int) n_d= Primitive(int) = 
// Arg ARG Primitive(int) flags= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_gemm32f_const_float_X_src1_size_t_src1_step_const_float_X_src2_size_t_src2_step_float_alpha_const_float_X_src3_size_t_src3_step_float_beta_float_X_dst_size_t_dst_step_int_m_a_int_n_a_int_n_d_int_flags(const float* src1, std::size_t src1_step, const float* src2, std::size_t src2_step, float alpha, const float* src3, std::size_t src3_step, float beta, float* dst, std::size_t dst_step, int m_a, int n_a, int n_d, int flags) {
    try {
        cv::hal::gemm32f(src1, src1_step, src2, src2_step, alpha, src3, src3_step, beta, dst, dst_step, m_a, n_a, n_d, flags);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_gemm32fc_const_float_X_src1_size_t_src1_step_const_float_X_src2_size_t_src2_step_float_alpha_const_float_X_src3_size_t_src3_step_float_beta_float_X_dst_size_t_dst_step_int_m_a_int_n_a_int_n_d_int_flags
// parsed: cv::hal::gemm32fc
// as:     cv::hal::gemm32fc (function)
// Arg ARG RawPtr[Primitive(float)] * src1= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG Primitive(size_t) src1_step= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(float)] * src2= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG Primitive(size_t) src2_step= Primitive(size_t) = 
// Arg ARG Primitive(float) alpha= Primitive(float) = 
// Arg ARG RawPtr[Primitive(float)] * src3= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG Primitive(size_t) src3_step= Primitive(size_t) = 
// Arg ARG Primitive(float) beta= Primitive(float) = 
// Arg ARG RawPtr[Primitive(float)] * dst= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG Primitive(size_t) dst_step= Primitive(size_t) = 
// Arg ARG Primitive(int) m_a= Primitive(int) = 
// Arg ARG Primitive(int) n_a= Primitive(int) = 
// Arg ARG Primitive(int) n_d= Primitive(int) = 
// Arg ARG Primitive(int) flags= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_gemm32fc_const_float_X_src1_size_t_src1_step_const_float_X_src2_size_t_src2_step_float_alpha_const_float_X_src3_size_t_src3_step_float_beta_float_X_dst_size_t_dst_step_int_m_a_int_n_a_int_n_d_int_flags(const float* src1, std::size_t src1_step, const float* src2, std::size_t src2_step, float alpha, const float* src3, std::size_t src3_step, float beta, float* dst, std::size_t dst_step, int m_a, int n_a, int n_d, int flags) {
    try {
        cv::hal::gemm32fc(src1, src1_step, src2, src2_step, alpha, src3, src3_step, beta, dst, dst_step, m_a, n_a, n_d, flags);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_gemm64f_const_double_X_src1_size_t_src1_step_const_double_X_src2_size_t_src2_step_double_alpha_const_double_X_src3_size_t_src3_step_double_beta_double_X_dst_size_t_dst_step_int_m_a_int_n_a_int_n_d_int_flags
// parsed: cv::hal::gemm64f
// as:     cv::hal::gemm64f (function)
// Arg ARG RawPtr[Primitive(double)] * src1= (ptr) RawPtr[Primitive(double)] = 
// Arg ARG Primitive(size_t) src1_step= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(double)] * src2= (ptr) RawPtr[Primitive(double)] = 
// Arg ARG Primitive(size_t) src2_step= Primitive(size_t) = 
// Arg ARG Primitive(double) alpha= Primitive(double) = 
// Arg ARG RawPtr[Primitive(double)] * src3= (ptr) RawPtr[Primitive(double)] = 
// Arg ARG Primitive(size_t) src3_step= Primitive(size_t) = 
// Arg ARG Primitive(double) beta= Primitive(double) = 
// Arg ARG RawPtr[Primitive(double)] * dst= (ptr) RawPtr[Primitive(double)] = 
// Arg ARG Primitive(size_t) dst_step= Primitive(size_t) = 
// Arg ARG Primitive(int) m_a= Primitive(int) = 
// Arg ARG Primitive(int) n_a= Primitive(int) = 
// Arg ARG Primitive(int) n_d= Primitive(int) = 
// Arg ARG Primitive(int) flags= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_gemm64f_const_double_X_src1_size_t_src1_step_const_double_X_src2_size_t_src2_step_double_alpha_const_double_X_src3_size_t_src3_step_double_beta_double_X_dst_size_t_dst_step_int_m_a_int_n_a_int_n_d_int_flags(const double* src1, std::size_t src1_step, const double* src2, std::size_t src2_step, double alpha, const double* src3, std::size_t src3_step, double beta, double* dst, std::size_t dst_step, int m_a, int n_a, int n_d, int flags) {
    try {
        cv::hal::gemm64f(src1, src1_step, src2, src2_step, alpha, src3, src3_step, beta, dst, dst_step, m_a, n_a, n_d, flags);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_gemm64fc_const_double_X_src1_size_t_src1_step_const_double_X_src2_size_t_src2_step_double_alpha_const_double_X_src3_size_t_src3_step_double_beta_double_X_dst_size_t_dst_step_int_m_a_int_n_a_int_n_d_int_flags
// parsed: cv::hal::gemm64fc
// as:     cv::hal::gemm64fc (function)
// Arg ARG RawPtr[Primitive(double)] * src1= (ptr) RawPtr[Primitive(double)] = 
// Arg ARG Primitive(size_t) src1_step= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(double)] * src2= (ptr) RawPtr[Primitive(double)] = 
// Arg ARG Primitive(size_t) src2_step= Primitive(size_t) = 
// Arg ARG Primitive(double) alpha= Primitive(double) = 
// Arg ARG RawPtr[Primitive(double)] * src3= (ptr) RawPtr[Primitive(double)] = 
// Arg ARG Primitive(size_t) src3_step= Primitive(size_t) = 
// Arg ARG Primitive(double) beta= Primitive(double) = 
// Arg ARG RawPtr[Primitive(double)] * dst= (ptr) RawPtr[Primitive(double)] = 
// Arg ARG Primitive(size_t) dst_step= Primitive(size_t) = 
// Arg ARG Primitive(int) m_a= Primitive(int) = 
// Arg ARG Primitive(int) n_a= Primitive(int) = 
// Arg ARG Primitive(int) n_d= Primitive(int) = 
// Arg ARG Primitive(int) flags= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_gemm64fc_const_double_X_src1_size_t_src1_step_const_double_X_src2_size_t_src2_step_double_alpha_const_double_X_src3_size_t_src3_step_double_beta_double_X_dst_size_t_dst_step_int_m_a_int_n_a_int_n_d_int_flags(const double* src1, std::size_t src1_step, const double* src2, std::size_t src2_step, double alpha, const double* src3, std::size_t src3_step, double beta, double* dst, std::size_t dst_step, int m_a, int n_a, int n_d, int flags) {
    try {
        cv::hal::gemm64fc(src1, src1_step, src2, src2_step, alpha, src3, src3_step, beta, dst, dst_step, m_a, n_a, n_d, flags);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_integral_int_depth_int_sdepth_int_sqdepth_const_uchar_X_src_size_t_srcstep_uchar_X_sum_size_t_sumstep_uchar_X_sqsum_size_t_sqsumstep_uchar_X_tilted_size_t_tstep_int_width_int_height_int_cn
// parsed: cv::hal::integral
// as:     cv::hal::integral (function)
// Arg ARG Primitive(int) depth= Primitive(int) = 
// Arg ARG Primitive(int) sdepth= Primitive(int) = 
// Arg ARG Primitive(int) sqdepth= Primitive(int) = 
// Arg ARG RawPtr[Primitive(uchar)] * src= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) srcstep= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(uchar)] * sum= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) sumstep= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(uchar)] * sqsum= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) sqsumstep= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(uchar)] * tilted= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) tstep= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG Primitive(int) cn= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_integral_int_depth_int_sdepth_int_sqdepth_const_uchar_X_src_size_t_srcstep_uchar_X_sum_size_t_sumstep_uchar_X_sqsum_size_t_sqsumstep_uchar_X_tilted_size_t_tstep_int_width_int_height_int_cn(int depth, int sdepth, int sqdepth, const uchar* src, std::size_t srcstep, uchar* sum, std::size_t sumstep, uchar* sqsum, std::size_t sqsumstep, uchar* tilted, std::size_t tstep, int width, int height, int cn) {
    try {
        cv::hal::integral(depth, sdepth, sqdepth, src, srcstep, sum, sumstep, sqsum, sqsumstep, tilted, tstep, width, height, cn);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_invSqrt32f_const_float_X_src_float_X_dst_int_len
// parsed: cv::hal::invSqrt32f
// as:     cv::hal::invSqrt32f (function)
// Arg ARG RawPtr[Primitive(float)] * src= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG RawPtr[Primitive(float)] * dst= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG Primitive(int) len= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_invSqrt32f_const_float_X_src_float_X_dst_int_len(const float* src, float* dst, int len) {
    try {
        cv::hal::invSqrt32f(src, dst, len);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_invSqrt64f_const_double_X_src_double_X_dst_int_len
// parsed: cv::hal::invSqrt64f
// as:     cv::hal::invSqrt64f (function)
// Arg ARG RawPtr[Primitive(double)] * src= (ptr) RawPtr[Primitive(double)] = 
// Arg ARG RawPtr[Primitive(double)] * dst= (ptr) RawPtr[Primitive(double)] = 
// Arg ARG Primitive(int) len= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_invSqrt64f_const_double_X_src_double_X_dst_int_len(const double* src, double* dst, int len) {
    try {
        cv::hal::invSqrt64f(src, dst, len);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_invSqrt_const_double_X_src_double_X_dst_int_len
// parsed: cv::hal::invSqrt
// as:     cv::hal::invSqrt (function)
// Arg ARG RawPtr[Primitive(double)] * src= (ptr) RawPtr[Primitive(double)] = 
// Arg ARG RawPtr[Primitive(double)] * dst= (ptr) RawPtr[Primitive(double)] = 
// Arg ARG Primitive(int) len= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_invSqrt_const_double_X_src_double_X_dst_int_len(const double* src, double* dst, int len) {
    try {
        cv::hal::invSqrt(src, dst, len);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_invSqrt_const_float_X_src_float_X_dst_int_len
// parsed: cv::hal::invSqrt
// as:     cv::hal::invSqrt (function)
// Arg ARG RawPtr[Primitive(float)] * src= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG RawPtr[Primitive(float)] * dst= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG Primitive(int) len= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_invSqrt_const_float_X_src_float_X_dst_int_len(const float* src, float* dst, int len) {
    try {
        cv::hal::invSqrt(src, dst, len);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_log32f_const_float_X_src_float_X_dst_int_n
// parsed: cv::hal::log32f
// as:     cv::hal::log32f (function)
// Arg ARG RawPtr[Primitive(float)] * src= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG RawPtr[Primitive(float)] * dst= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG Primitive(int) n= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_log32f_const_float_X_src_float_X_dst_int_n(const float* src, float* dst, int n) {
    try {
        cv::hal::log32f(src, dst, n);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_log64f_const_double_X_src_double_X_dst_int_n
// parsed: cv::hal::log64f
// as:     cv::hal::log64f (function)
// Arg ARG RawPtr[Primitive(double)] * src= (ptr) RawPtr[Primitive(double)] = 
// Arg ARG RawPtr[Primitive(double)] * dst= (ptr) RawPtr[Primitive(double)] = 
// Arg ARG Primitive(int) n= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_log64f_const_double_X_src_double_X_dst_int_n(const double* src, double* dst, int n) {
    try {
        cv::hal::log64f(src, dst, n);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_log_const_double_X_src_double_X_dst_int_n
// parsed: cv::hal::log
// as:     cv::hal::log (function)
// Arg ARG RawPtr[Primitive(double)] * src= (ptr) RawPtr[Primitive(double)] = 
// Arg ARG RawPtr[Primitive(double)] * dst= (ptr) RawPtr[Primitive(double)] = 
// Arg ARG Primitive(int) n= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_log_const_double_X_src_double_X_dst_int_n(const double* src, double* dst, int n) {
    try {
        cv::hal::log(src, dst, n);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_log_const_float_X_src_float_X_dst_int_n
// parsed: cv::hal::log
// as:     cv::hal::log (function)
// Arg ARG RawPtr[Primitive(float)] * src= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG RawPtr[Primitive(float)] * dst= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG Primitive(int) n= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_log_const_float_X_src_float_X_dst_int_n(const float* src, float* dst, int n) {
    try {
        cv::hal::log(src, dst, n);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_magnitude32f_const_float_X_x_const_float_X_y_float_X_dst_int_n
// parsed: cv::hal::magnitude32f
// as:     cv::hal::magnitude32f (function)
// Arg ARG RawPtr[Primitive(float)] * x= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG RawPtr[Primitive(float)] * y= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG RawPtr[Primitive(float)] * dst= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG Primitive(int) n= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_magnitude32f_const_float_X_x_const_float_X_y_float_X_dst_int_n(const float* x, const float* y, float* dst, int n) {
    try {
        cv::hal::magnitude32f(x, y, dst, n);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_magnitude64f_const_double_X_x_const_double_X_y_double_X_dst_int_n
// parsed: cv::hal::magnitude64f
// as:     cv::hal::magnitude64f (function)
// Arg ARG RawPtr[Primitive(double)] * x= (ptr) RawPtr[Primitive(double)] = 
// Arg ARG RawPtr[Primitive(double)] * y= (ptr) RawPtr[Primitive(double)] = 
// Arg ARG RawPtr[Primitive(double)] * dst= (ptr) RawPtr[Primitive(double)] = 
// Arg ARG Primitive(int) n= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_magnitude64f_const_double_X_x_const_double_X_y_double_X_dst_int_n(const double* x, const double* y, double* dst, int n) {
    try {
        cv::hal::magnitude64f(x, y, dst, n);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_magnitude_const_double_X_x_const_double_X_y_double_X_dst_int_n
// parsed: cv::hal::magnitude
// as:     cv::hal::magnitude (function)
// Arg ARG RawPtr[Primitive(double)] * x= (ptr) RawPtr[Primitive(double)] = 
// Arg ARG RawPtr[Primitive(double)] * y= (ptr) RawPtr[Primitive(double)] = 
// Arg ARG RawPtr[Primitive(double)] * dst= (ptr) RawPtr[Primitive(double)] = 
// Arg ARG Primitive(int) n= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_magnitude_const_double_X_x_const_double_X_y_double_X_dst_int_n(const double* x, const double* y, double* dst, int n) {
    try {
        cv::hal::magnitude(x, y, dst, n);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_magnitude_const_float_X_x_const_float_X_y_float_X_dst_int_n
// parsed: cv::hal::magnitude
// as:     cv::hal::magnitude (function)
// Arg ARG RawPtr[Primitive(float)] * x= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG RawPtr[Primitive(float)] * y= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG RawPtr[Primitive(float)] * dst= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG Primitive(int) n= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_magnitude_const_float_X_x_const_float_X_y_float_X_dst_int_n(const float* x, const float* y, float* dst, int n) {
    try {
        cv::hal::magnitude(x, y, dst, n);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_max16s_const_short_X_src1_size_t_step1_const_short_X_src2_size_t_step2_short_X_dst_size_t_step_int_width_int_height_void_X_unnamed_arg
// parsed: cv::hal::max16s
// as:     cv::hal::max16s (function)
// Arg ARG RawPtr[Primitive(short)] * src1= (ptr) RawPtr[Primitive(short)] = 
// Arg ARG Primitive(size_t) step1= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(short)] * src2= (ptr) RawPtr[Primitive(short)] = 
// Arg ARG Primitive(size_t) step2= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(short)] * dst= (ptr) RawPtr[Primitive(short)] = 
// Arg ARG Primitive(size_t) step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG RawPtr[Primitive(void)] * unnamed_arg= (ptr) RawPtr[Primitive(void)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_max16s_const_short_X_src1_size_t_step1_const_short_X_src2_size_t_step2_short_X_dst_size_t_step_int_width_int_height_void_X_unnamed_arg(const short* src1, std::size_t step1, const short* src2, std::size_t step2, short* dst, std::size_t step, int width, int height, void* unnamed_arg) {
    try {
        cv::hal::max16s(src1, step1, src2, step2, dst, step, width, height, unnamed_arg);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_max16u_const_ushort_X_src1_size_t_step1_const_ushort_X_src2_size_t_step2_ushort_X_dst_size_t_step_int_width_int_height_void_X_unnamed_arg
// parsed: cv::hal::max16u
// as:     cv::hal::max16u (function)
// Arg ARG RawPtr[Primitive(ushort)] * src1= (ptr) RawPtr[Primitive(ushort)] = 
// Arg ARG Primitive(size_t) step1= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(ushort)] * src2= (ptr) RawPtr[Primitive(ushort)] = 
// Arg ARG Primitive(size_t) step2= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(ushort)] * dst= (ptr) RawPtr[Primitive(ushort)] = 
// Arg ARG Primitive(size_t) step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG RawPtr[Primitive(void)] * unnamed_arg= (ptr) RawPtr[Primitive(void)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_max16u_const_ushort_X_src1_size_t_step1_const_ushort_X_src2_size_t_step2_ushort_X_dst_size_t_step_int_width_int_height_void_X_unnamed_arg(const ushort* src1, std::size_t step1, const ushort* src2, std::size_t step2, ushort* dst, std::size_t step, int width, int height, void* unnamed_arg) {
    try {
        cv::hal::max16u(src1, step1, src2, step2, dst, step, width, height, unnamed_arg);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_max32f_const_float_X_src1_size_t_step1_const_float_X_src2_size_t_step2_float_X_dst_size_t_step_int_width_int_height_void_X_unnamed_arg
// parsed: cv::hal::max32f
// as:     cv::hal::max32f (function)
// Arg ARG RawPtr[Primitive(float)] * src1= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG Primitive(size_t) step1= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(float)] * src2= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG Primitive(size_t) step2= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(float)] * dst= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG Primitive(size_t) step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG RawPtr[Primitive(void)] * unnamed_arg= (ptr) RawPtr[Primitive(void)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_max32f_const_float_X_src1_size_t_step1_const_float_X_src2_size_t_step2_float_X_dst_size_t_step_int_width_int_height_void_X_unnamed_arg(const float* src1, std::size_t step1, const float* src2, std::size_t step2, float* dst, std::size_t step, int width, int height, void* unnamed_arg) {
    try {
        cv::hal::max32f(src1, step1, src2, step2, dst, step, width, height, unnamed_arg);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_max32s_const_int_X_src1_size_t_step1_const_int_X_src2_size_t_step2_int_X_dst_size_t_step_int_width_int_height_void_X_unnamed_arg
// parsed: cv::hal::max32s
// as:     cv::hal::max32s (function)
// Arg ARG RawPtr[Primitive(int)] * src1= (ptr) RawPtr[Primitive(int)] = 
// Arg ARG Primitive(size_t) step1= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(int)] * src2= (ptr) RawPtr[Primitive(int)] = 
// Arg ARG Primitive(size_t) step2= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(int)] * dst= (ptr) RawPtr[Primitive(int)] = 
// Arg ARG Primitive(size_t) step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG RawPtr[Primitive(void)] * unnamed_arg= (ptr) RawPtr[Primitive(void)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_max32s_const_int_X_src1_size_t_step1_const_int_X_src2_size_t_step2_int_X_dst_size_t_step_int_width_int_height_void_X_unnamed_arg(const int* src1, std::size_t step1, const int* src2, std::size_t step2, int* dst, std::size_t step, int width, int height, void* unnamed_arg) {
    try {
        cv::hal::max32s(src1, step1, src2, step2, dst, step, width, height, unnamed_arg);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_max64f_const_double_X_src1_size_t_step1_const_double_X_src2_size_t_step2_double_X_dst_size_t_step_int_width_int_height_void_X_unnamed_arg
// parsed: cv::hal::max64f
// as:     cv::hal::max64f (function)
// Arg ARG RawPtr[Primitive(double)] * src1= (ptr) RawPtr[Primitive(double)] = 
// Arg ARG Primitive(size_t) step1= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(double)] * src2= (ptr) RawPtr[Primitive(double)] = 
// Arg ARG Primitive(size_t) step2= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(double)] * dst= (ptr) RawPtr[Primitive(double)] = 
// Arg ARG Primitive(size_t) step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG RawPtr[Primitive(void)] * unnamed_arg= (ptr) RawPtr[Primitive(void)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_max64f_const_double_X_src1_size_t_step1_const_double_X_src2_size_t_step2_double_X_dst_size_t_step_int_width_int_height_void_X_unnamed_arg(const double* src1, std::size_t step1, const double* src2, std::size_t step2, double* dst, std::size_t step, int width, int height, void* unnamed_arg) {
    try {
        cv::hal::max64f(src1, step1, src2, step2, dst, step, width, height, unnamed_arg);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_max8s_const_schar_X_src1_size_t_step1_const_schar_X_src2_size_t_step2_schar_X_dst_size_t_step_int_width_int_height_void_X_unnamed_arg
// parsed: cv::hal::max8s
// as:     cv::hal::max8s (function)
// Arg ARG RawPtr[Primitive(schar)] * src1= (ptr) RawPtr[Primitive(schar)] = 
// Arg ARG Primitive(size_t) step1= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(schar)] * src2= (ptr) RawPtr[Primitive(schar)] = 
// Arg ARG Primitive(size_t) step2= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(schar)] * dst= (ptr) RawPtr[Primitive(schar)] = 
// Arg ARG Primitive(size_t) step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG RawPtr[Primitive(void)] * unnamed_arg= (ptr) RawPtr[Primitive(void)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_max8s_const_schar_X_src1_size_t_step1_const_schar_X_src2_size_t_step2_schar_X_dst_size_t_step_int_width_int_height_void_X_unnamed_arg(const schar* src1, std::size_t step1, const schar* src2, std::size_t step2, schar* dst, std::size_t step, int width, int height, void* unnamed_arg) {
    try {
        cv::hal::max8s(src1, step1, src2, step2, dst, step, width, height, unnamed_arg);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_max8u_const_uchar_X_src1_size_t_step1_const_uchar_X_src2_size_t_step2_uchar_X_dst_size_t_step_int_width_int_height_void_X_unnamed_arg
// parsed: cv::hal::max8u
// as:     cv::hal::max8u (function)
// Arg ARG RawPtr[Primitive(uchar)] * src1= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) step1= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(uchar)] * src2= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) step2= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(uchar)] * dst= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG RawPtr[Primitive(void)] * unnamed_arg= (ptr) RawPtr[Primitive(void)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_max8u_const_uchar_X_src1_size_t_step1_const_uchar_X_src2_size_t_step2_uchar_X_dst_size_t_step_int_width_int_height_void_X_unnamed_arg(const uchar* src1, std::size_t step1, const uchar* src2, std::size_t step2, uchar* dst, std::size_t step, int width, int height, void* unnamed_arg) {
    try {
        cv::hal::max8u(src1, step1, src2, step2, dst, step, width, height, unnamed_arg);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_min16s_const_short_X_src1_size_t_step1_const_short_X_src2_size_t_step2_short_X_dst_size_t_step_int_width_int_height_void_X_unnamed_arg
// parsed: cv::hal::min16s
// as:     cv::hal::min16s (function)
// Arg ARG RawPtr[Primitive(short)] * src1= (ptr) RawPtr[Primitive(short)] = 
// Arg ARG Primitive(size_t) step1= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(short)] * src2= (ptr) RawPtr[Primitive(short)] = 
// Arg ARG Primitive(size_t) step2= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(short)] * dst= (ptr) RawPtr[Primitive(short)] = 
// Arg ARG Primitive(size_t) step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG RawPtr[Primitive(void)] * unnamed_arg= (ptr) RawPtr[Primitive(void)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_min16s_const_short_X_src1_size_t_step1_const_short_X_src2_size_t_step2_short_X_dst_size_t_step_int_width_int_height_void_X_unnamed_arg(const short* src1, std::size_t step1, const short* src2, std::size_t step2, short* dst, std::size_t step, int width, int height, void* unnamed_arg) {
    try {
        cv::hal::min16s(src1, step1, src2, step2, dst, step, width, height, unnamed_arg);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_min16u_const_ushort_X_src1_size_t_step1_const_ushort_X_src2_size_t_step2_ushort_X_dst_size_t_step_int_width_int_height_void_X_unnamed_arg
// parsed: cv::hal::min16u
// as:     cv::hal::min16u (function)
// Arg ARG RawPtr[Primitive(ushort)] * src1= (ptr) RawPtr[Primitive(ushort)] = 
// Arg ARG Primitive(size_t) step1= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(ushort)] * src2= (ptr) RawPtr[Primitive(ushort)] = 
// Arg ARG Primitive(size_t) step2= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(ushort)] * dst= (ptr) RawPtr[Primitive(ushort)] = 
// Arg ARG Primitive(size_t) step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG RawPtr[Primitive(void)] * unnamed_arg= (ptr) RawPtr[Primitive(void)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_min16u_const_ushort_X_src1_size_t_step1_const_ushort_X_src2_size_t_step2_ushort_X_dst_size_t_step_int_width_int_height_void_X_unnamed_arg(const ushort* src1, std::size_t step1, const ushort* src2, std::size_t step2, ushort* dst, std::size_t step, int width, int height, void* unnamed_arg) {
    try {
        cv::hal::min16u(src1, step1, src2, step2, dst, step, width, height, unnamed_arg);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_min32f_const_float_X_src1_size_t_step1_const_float_X_src2_size_t_step2_float_X_dst_size_t_step_int_width_int_height_void_X_unnamed_arg
// parsed: cv::hal::min32f
// as:     cv::hal::min32f (function)
// Arg ARG RawPtr[Primitive(float)] * src1= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG Primitive(size_t) step1= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(float)] * src2= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG Primitive(size_t) step2= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(float)] * dst= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG Primitive(size_t) step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG RawPtr[Primitive(void)] * unnamed_arg= (ptr) RawPtr[Primitive(void)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_min32f_const_float_X_src1_size_t_step1_const_float_X_src2_size_t_step2_float_X_dst_size_t_step_int_width_int_height_void_X_unnamed_arg(const float* src1, std::size_t step1, const float* src2, std::size_t step2, float* dst, std::size_t step, int width, int height, void* unnamed_arg) {
    try {
        cv::hal::min32f(src1, step1, src2, step2, dst, step, width, height, unnamed_arg);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_min32s_const_int_X_src1_size_t_step1_const_int_X_src2_size_t_step2_int_X_dst_size_t_step_int_width_int_height_void_X_unnamed_arg
// parsed: cv::hal::min32s
// as:     cv::hal::min32s (function)
// Arg ARG RawPtr[Primitive(int)] * src1= (ptr) RawPtr[Primitive(int)] = 
// Arg ARG Primitive(size_t) step1= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(int)] * src2= (ptr) RawPtr[Primitive(int)] = 
// Arg ARG Primitive(size_t) step2= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(int)] * dst= (ptr) RawPtr[Primitive(int)] = 
// Arg ARG Primitive(size_t) step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG RawPtr[Primitive(void)] * unnamed_arg= (ptr) RawPtr[Primitive(void)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_min32s_const_int_X_src1_size_t_step1_const_int_X_src2_size_t_step2_int_X_dst_size_t_step_int_width_int_height_void_X_unnamed_arg(const int* src1, std::size_t step1, const int* src2, std::size_t step2, int* dst, std::size_t step, int width, int height, void* unnamed_arg) {
    try {
        cv::hal::min32s(src1, step1, src2, step2, dst, step, width, height, unnamed_arg);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_min64f_const_double_X_src1_size_t_step1_const_double_X_src2_size_t_step2_double_X_dst_size_t_step_int_width_int_height_void_X_unnamed_arg
// parsed: cv::hal::min64f
// as:     cv::hal::min64f (function)
// Arg ARG RawPtr[Primitive(double)] * src1= (ptr) RawPtr[Primitive(double)] = 
// Arg ARG Primitive(size_t) step1= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(double)] * src2= (ptr) RawPtr[Primitive(double)] = 
// Arg ARG Primitive(size_t) step2= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(double)] * dst= (ptr) RawPtr[Primitive(double)] = 
// Arg ARG Primitive(size_t) step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG RawPtr[Primitive(void)] * unnamed_arg= (ptr) RawPtr[Primitive(void)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_min64f_const_double_X_src1_size_t_step1_const_double_X_src2_size_t_step2_double_X_dst_size_t_step_int_width_int_height_void_X_unnamed_arg(const double* src1, std::size_t step1, const double* src2, std::size_t step2, double* dst, std::size_t step, int width, int height, void* unnamed_arg) {
    try {
        cv::hal::min64f(src1, step1, src2, step2, dst, step, width, height, unnamed_arg);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_min8s_const_schar_X_src1_size_t_step1_const_schar_X_src2_size_t_step2_schar_X_dst_size_t_step_int_width_int_height_void_X_unnamed_arg
// parsed: cv::hal::min8s
// as:     cv::hal::min8s (function)
// Arg ARG RawPtr[Primitive(schar)] * src1= (ptr) RawPtr[Primitive(schar)] = 
// Arg ARG Primitive(size_t) step1= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(schar)] * src2= (ptr) RawPtr[Primitive(schar)] = 
// Arg ARG Primitive(size_t) step2= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(schar)] * dst= (ptr) RawPtr[Primitive(schar)] = 
// Arg ARG Primitive(size_t) step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG RawPtr[Primitive(void)] * unnamed_arg= (ptr) RawPtr[Primitive(void)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_min8s_const_schar_X_src1_size_t_step1_const_schar_X_src2_size_t_step2_schar_X_dst_size_t_step_int_width_int_height_void_X_unnamed_arg(const schar* src1, std::size_t step1, const schar* src2, std::size_t step2, schar* dst, std::size_t step, int width, int height, void* unnamed_arg) {
    try {
        cv::hal::min8s(src1, step1, src2, step2, dst, step, width, height, unnamed_arg);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_min8u_const_uchar_X_src1_size_t_step1_const_uchar_X_src2_size_t_step2_uchar_X_dst_size_t_step_int_width_int_height_void_X_unnamed_arg
// parsed: cv::hal::min8u
// as:     cv::hal::min8u (function)
// Arg ARG RawPtr[Primitive(uchar)] * src1= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) step1= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(uchar)] * src2= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) step2= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(uchar)] * dst= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG RawPtr[Primitive(void)] * unnamed_arg= (ptr) RawPtr[Primitive(void)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_min8u_const_uchar_X_src1_size_t_step1_const_uchar_X_src2_size_t_step2_uchar_X_dst_size_t_step_int_width_int_height_void_X_unnamed_arg(const uchar* src1, std::size_t step1, const uchar* src2, std::size_t step2, uchar* dst, std::size_t step, int width, int height, void* unnamed_arg) {
    try {
        cv::hal::min8u(src1, step1, src2, step2, dst, step, width, height, unnamed_arg);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_mul16s_const_short_X_src1_size_t_step1_const_short_X_src2_size_t_step2_short_X_dst_size_t_step_int_width_int_height_void_X_scale
// parsed: cv::hal::mul16s
// as:     cv::hal::mul16s (function)
// Arg ARG RawPtr[Primitive(short)] * src1= (ptr) RawPtr[Primitive(short)] = 
// Arg ARG Primitive(size_t) step1= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(short)] * src2= (ptr) RawPtr[Primitive(short)] = 
// Arg ARG Primitive(size_t) step2= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(short)] * dst= (ptr) RawPtr[Primitive(short)] = 
// Arg ARG Primitive(size_t) step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG RawPtr[Primitive(void)] * scale= (ptr) RawPtr[Primitive(void)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_mul16s_const_short_X_src1_size_t_step1_const_short_X_src2_size_t_step2_short_X_dst_size_t_step_int_width_int_height_void_X_scale(const short* src1, std::size_t step1, const short* src2, std::size_t step2, short* dst, std::size_t step, int width, int height, void* scale) {
    try {
        cv::hal::mul16s(src1, step1, src2, step2, dst, step, width, height, scale);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_mul16u_const_ushort_X_src1_size_t_step1_const_ushort_X_src2_size_t_step2_ushort_X_dst_size_t_step_int_width_int_height_void_X_scale
// parsed: cv::hal::mul16u
// as:     cv::hal::mul16u (function)
// Arg ARG RawPtr[Primitive(ushort)] * src1= (ptr) RawPtr[Primitive(ushort)] = 
// Arg ARG Primitive(size_t) step1= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(ushort)] * src2= (ptr) RawPtr[Primitive(ushort)] = 
// Arg ARG Primitive(size_t) step2= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(ushort)] * dst= (ptr) RawPtr[Primitive(ushort)] = 
// Arg ARG Primitive(size_t) step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG RawPtr[Primitive(void)] * scale= (ptr) RawPtr[Primitive(void)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_mul16u_const_ushort_X_src1_size_t_step1_const_ushort_X_src2_size_t_step2_ushort_X_dst_size_t_step_int_width_int_height_void_X_scale(const ushort* src1, std::size_t step1, const ushort* src2, std::size_t step2, ushort* dst, std::size_t step, int width, int height, void* scale) {
    try {
        cv::hal::mul16u(src1, step1, src2, step2, dst, step, width, height, scale);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_mul32f_const_float_X_src1_size_t_step1_const_float_X_src2_size_t_step2_float_X_dst_size_t_step_int_width_int_height_void_X_scale
// parsed: cv::hal::mul32f
// as:     cv::hal::mul32f (function)
// Arg ARG RawPtr[Primitive(float)] * src1= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG Primitive(size_t) step1= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(float)] * src2= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG Primitive(size_t) step2= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(float)] * dst= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG Primitive(size_t) step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG RawPtr[Primitive(void)] * scale= (ptr) RawPtr[Primitive(void)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_mul32f_const_float_X_src1_size_t_step1_const_float_X_src2_size_t_step2_float_X_dst_size_t_step_int_width_int_height_void_X_scale(const float* src1, std::size_t step1, const float* src2, std::size_t step2, float* dst, std::size_t step, int width, int height, void* scale) {
    try {
        cv::hal::mul32f(src1, step1, src2, step2, dst, step, width, height, scale);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_mul32s_const_int_X_src1_size_t_step1_const_int_X_src2_size_t_step2_int_X_dst_size_t_step_int_width_int_height_void_X_scale
// parsed: cv::hal::mul32s
// as:     cv::hal::mul32s (function)
// Arg ARG RawPtr[Primitive(int)] * src1= (ptr) RawPtr[Primitive(int)] = 
// Arg ARG Primitive(size_t) step1= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(int)] * src2= (ptr) RawPtr[Primitive(int)] = 
// Arg ARG Primitive(size_t) step2= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(int)] * dst= (ptr) RawPtr[Primitive(int)] = 
// Arg ARG Primitive(size_t) step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG RawPtr[Primitive(void)] * scale= (ptr) RawPtr[Primitive(void)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_mul32s_const_int_X_src1_size_t_step1_const_int_X_src2_size_t_step2_int_X_dst_size_t_step_int_width_int_height_void_X_scale(const int* src1, std::size_t step1, const int* src2, std::size_t step2, int* dst, std::size_t step, int width, int height, void* scale) {
    try {
        cv::hal::mul32s(src1, step1, src2, step2, dst, step, width, height, scale);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_mul64f_const_double_X_src1_size_t_step1_const_double_X_src2_size_t_step2_double_X_dst_size_t_step_int_width_int_height_void_X_scale
// parsed: cv::hal::mul64f
// as:     cv::hal::mul64f (function)
// Arg ARG RawPtr[Primitive(double)] * src1= (ptr) RawPtr[Primitive(double)] = 
// Arg ARG Primitive(size_t) step1= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(double)] * src2= (ptr) RawPtr[Primitive(double)] = 
// Arg ARG Primitive(size_t) step2= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(double)] * dst= (ptr) RawPtr[Primitive(double)] = 
// Arg ARG Primitive(size_t) step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG RawPtr[Primitive(void)] * scale= (ptr) RawPtr[Primitive(void)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_mul64f_const_double_X_src1_size_t_step1_const_double_X_src2_size_t_step2_double_X_dst_size_t_step_int_width_int_height_void_X_scale(const double* src1, std::size_t step1, const double* src2, std::size_t step2, double* dst, std::size_t step, int width, int height, void* scale) {
    try {
        cv::hal::mul64f(src1, step1, src2, step2, dst, step, width, height, scale);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_mul8s_const_schar_X_src1_size_t_step1_const_schar_X_src2_size_t_step2_schar_X_dst_size_t_step_int_width_int_height_void_X_scale
// parsed: cv::hal::mul8s
// as:     cv::hal::mul8s (function)
// Arg ARG RawPtr[Primitive(schar)] * src1= (ptr) RawPtr[Primitive(schar)] = 
// Arg ARG Primitive(size_t) step1= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(schar)] * src2= (ptr) RawPtr[Primitive(schar)] = 
// Arg ARG Primitive(size_t) step2= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(schar)] * dst= (ptr) RawPtr[Primitive(schar)] = 
// Arg ARG Primitive(size_t) step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG RawPtr[Primitive(void)] * scale= (ptr) RawPtr[Primitive(void)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_mul8s_const_schar_X_src1_size_t_step1_const_schar_X_src2_size_t_step2_schar_X_dst_size_t_step_int_width_int_height_void_X_scale(const schar* src1, std::size_t step1, const schar* src2, std::size_t step2, schar* dst, std::size_t step, int width, int height, void* scale) {
    try {
        cv::hal::mul8s(src1, step1, src2, step2, dst, step, width, height, scale);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_mul8u_const_uchar_X_src1_size_t_step1_const_uchar_X_src2_size_t_step2_uchar_X_dst_size_t_step_int_width_int_height_void_X_scale
// parsed: cv::hal::mul8u
// as:     cv::hal::mul8u (function)
// Arg ARG RawPtr[Primitive(uchar)] * src1= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) step1= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(uchar)] * src2= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) step2= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(uchar)] * dst= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG RawPtr[Primitive(void)] * scale= (ptr) RawPtr[Primitive(void)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_mul8u_const_uchar_X_src1_size_t_step1_const_uchar_X_src2_size_t_step2_uchar_X_dst_size_t_step_int_width_int_height_void_X_scale(const uchar* src1, std::size_t step1, const uchar* src2, std::size_t step2, uchar* dst, std::size_t step, int width, int height, void* scale) {
    try {
        cv::hal::mul8u(src1, step1, src2, step2, dst, step, width, height, scale);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_normHamming_const_uchar_X_a_const_uchar_X_b_int_n
// parsed: cv::hal::normHamming
// as:     cv::hal::normHamming (function)
// Arg ARG RawPtr[Primitive(uchar)] * a= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG RawPtr[Primitive(uchar)] * b= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(int) n= Primitive(int) = 
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_hal_normHamming_const_uchar_X_a_const_uchar_X_b_int_n(const uchar* a, const uchar* b, int n) {
    try {
        int ret = cv::hal::normHamming(a, b, n);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_hal_normHamming_const_uchar_X_a_const_uchar_X_b_int_n_int_cellSize
// parsed: cv::hal::normHamming
// as:     cv::hal::normHamming (function)
// Arg ARG RawPtr[Primitive(uchar)] * a= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG RawPtr[Primitive(uchar)] * b= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(int) n= Primitive(int) = 
// Arg ARG Primitive(int) cellSize= Primitive(int) = 
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_hal_normHamming_const_uchar_X_a_const_uchar_X_b_int_n_int_cellSize(const uchar* a, const uchar* b, int n, int cellSize) {
    try {
        int ret = cv::hal::normHamming(a, b, n, cellSize);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_hal_normHamming_const_uchar_X_a_int_n
// parsed: cv::hal::normHamming
// as:     cv::hal::normHamming (function)
// Arg ARG RawPtr[Primitive(uchar)] * a= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(int) n= Primitive(int) = 
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_hal_normHamming_const_uchar_X_a_int_n(const uchar* a, int n) {
    try {
        int ret = cv::hal::normHamming(a, n);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_hal_normHamming_const_uchar_X_a_int_n_int_cellSize
// parsed: cv::hal::normHamming
// as:     cv::hal::normHamming (function)
// Arg ARG RawPtr[Primitive(uchar)] * a= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(int) n= Primitive(int) = 
// Arg ARG Primitive(int) cellSize= Primitive(int) = 
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_hal_normHamming_const_uchar_X_a_int_n_int_cellSize(const uchar* a, int n, int cellSize) {
    try {
        int ret = cv::hal::normHamming(a, n, cellSize);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_hal_normL1__const_float_X_a_const_float_X_b_int_n
// parsed: cv::hal::normL1_
// as:     cv::hal::normL1_ (function)
// Arg ARG RawPtr[Primitive(float)] * a= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG RawPtr[Primitive(float)] * b= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG Primitive(int) n= Primitive(int) = 
// Return value: Primitive(float)
cv_return_value_float cv_core_cv_hal_normL1__const_float_X_a_const_float_X_b_int_n(const float* a, const float* b, int n) {
    try {
        float ret = cv::hal::normL1_(a, b, n);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<float*>(&ret) };
    } CVRS_CATCH(cv_return_value_float)
}

// cv_hal_normL1__const_uchar_X_a_const_uchar_X_b_int_n
// parsed: cv::hal::normL1_
// as:     cv::hal::normL1_ (function)
// Arg ARG RawPtr[Primitive(uchar)] * a= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG RawPtr[Primitive(uchar)] * b= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(int) n= Primitive(int) = 
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_hal_normL1__const_uchar_X_a_const_uchar_X_b_int_n(const uchar* a, const uchar* b, int n) {
    try {
        int ret = cv::hal::normL1_(a, b, n);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_hal_normL2Sqr__const_float_X_a_const_float_X_b_int_n
// parsed: cv::hal::normL2Sqr_
// as:     cv::hal::normL2Sqr_ (function)
// Arg ARG RawPtr[Primitive(float)] * a= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG RawPtr[Primitive(float)] * b= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG Primitive(int) n= Primitive(int) = 
// Return value: Primitive(float)
cv_return_value_float cv_core_cv_hal_normL2Sqr__const_float_X_a_const_float_X_b_int_n(const float* a, const float* b, int n) {
    try {
        float ret = cv::hal::normL2Sqr_(a, b, n);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<float*>(&ret) };
    } CVRS_CATCH(cv_return_value_float)
}

// cv_hal_not8u_const_uchar_X_src1_size_t_step1_const_uchar_X_src2_size_t_step2_uchar_X_dst_size_t_step_int_width_int_height_void_X_unnamed_arg
// parsed: cv::hal::not8u
// as:     cv::hal::not8u (function)
// Arg ARG RawPtr[Primitive(uchar)] * src1= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) step1= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(uchar)] * src2= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) step2= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(uchar)] * dst= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG RawPtr[Primitive(void)] * unnamed_arg= (ptr) RawPtr[Primitive(void)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_not8u_const_uchar_X_src1_size_t_step1_const_uchar_X_src2_size_t_step2_uchar_X_dst_size_t_step_int_width_int_height_void_X_unnamed_arg(const uchar* src1, std::size_t step1, const uchar* src2, std::size_t step2, uchar* dst, std::size_t step, int width, int height, void* unnamed_arg) {
    try {
        cv::hal::not8u(src1, step1, src2, step2, dst, step, width, height, unnamed_arg);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_or8u_const_uchar_X_src1_size_t_step1_const_uchar_X_src2_size_t_step2_uchar_X_dst_size_t_step_int_width_int_height_void_X_unnamed_arg
// parsed: cv::hal::or8u
// as:     cv::hal::or8u (function)
// Arg ARG RawPtr[Primitive(uchar)] * src1= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) step1= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(uchar)] * src2= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) step2= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(uchar)] * dst= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG RawPtr[Primitive(void)] * unnamed_arg= (ptr) RawPtr[Primitive(void)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_or8u_const_uchar_X_src1_size_t_step1_const_uchar_X_src2_size_t_step2_uchar_X_dst_size_t_step_int_width_int_height_void_X_unnamed_arg(const uchar* src1, std::size_t step1, const uchar* src2, std::size_t step2, uchar* dst, std::size_t step, int width, int height, void* unnamed_arg) {
    try {
        cv::hal::or8u(src1, step1, src2, step2, dst, step, width, height, unnamed_arg);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_recip16s_const_short_X_unnamed_arg_size_t_unnamed_arg_1_const_short_X_src2_size_t_step2_short_X_dst_size_t_step_int_width_int_height_void_X_scale
// parsed: cv::hal::recip16s
// as:     cv::hal::recip16s (function)
// Arg ARG RawPtr[Primitive(short)] * unnamed_arg= (ptr) RawPtr[Primitive(short)] = 
// Arg ARG Primitive(size_t) unnamed_arg_1= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(short)] * src2= (ptr) RawPtr[Primitive(short)] = 
// Arg ARG Primitive(size_t) step2= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(short)] * dst= (ptr) RawPtr[Primitive(short)] = 
// Arg ARG Primitive(size_t) step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG RawPtr[Primitive(void)] * scale= (ptr) RawPtr[Primitive(void)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_recip16s_const_short_X_unnamed_arg_size_t_unnamed_arg_1_const_short_X_src2_size_t_step2_short_X_dst_size_t_step_int_width_int_height_void_X_scale(const short* unnamed_arg, std::size_t unnamed_arg_1, const short* src2, std::size_t step2, short* dst, std::size_t step, int width, int height, void* scale) {
    try {
        cv::hal::recip16s(unnamed_arg, unnamed_arg_1, src2, step2, dst, step, width, height, scale);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_recip16u_const_ushort_X_unnamed_arg_size_t_unnamed_arg_1_const_ushort_X_src2_size_t_step2_ushort_X_dst_size_t_step_int_width_int_height_void_X_scale
// parsed: cv::hal::recip16u
// as:     cv::hal::recip16u (function)
// Arg ARG RawPtr[Primitive(ushort)] * unnamed_arg= (ptr) RawPtr[Primitive(ushort)] = 
// Arg ARG Primitive(size_t) unnamed_arg_1= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(ushort)] * src2= (ptr) RawPtr[Primitive(ushort)] = 
// Arg ARG Primitive(size_t) step2= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(ushort)] * dst= (ptr) RawPtr[Primitive(ushort)] = 
// Arg ARG Primitive(size_t) step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG RawPtr[Primitive(void)] * scale= (ptr) RawPtr[Primitive(void)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_recip16u_const_ushort_X_unnamed_arg_size_t_unnamed_arg_1_const_ushort_X_src2_size_t_step2_ushort_X_dst_size_t_step_int_width_int_height_void_X_scale(const ushort* unnamed_arg, std::size_t unnamed_arg_1, const ushort* src2, std::size_t step2, ushort* dst, std::size_t step, int width, int height, void* scale) {
    try {
        cv::hal::recip16u(unnamed_arg, unnamed_arg_1, src2, step2, dst, step, width, height, scale);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_recip32f_const_float_X_unnamed_arg_size_t_unnamed_arg_1_const_float_X_src2_size_t_step2_float_X_dst_size_t_step_int_width_int_height_void_X_scale
// parsed: cv::hal::recip32f
// as:     cv::hal::recip32f (function)
// Arg ARG RawPtr[Primitive(float)] * unnamed_arg= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG Primitive(size_t) unnamed_arg_1= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(float)] * src2= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG Primitive(size_t) step2= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(float)] * dst= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG Primitive(size_t) step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG RawPtr[Primitive(void)] * scale= (ptr) RawPtr[Primitive(void)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_recip32f_const_float_X_unnamed_arg_size_t_unnamed_arg_1_const_float_X_src2_size_t_step2_float_X_dst_size_t_step_int_width_int_height_void_X_scale(const float* unnamed_arg, std::size_t unnamed_arg_1, const float* src2, std::size_t step2, float* dst, std::size_t step, int width, int height, void* scale) {
    try {
        cv::hal::recip32f(unnamed_arg, unnamed_arg_1, src2, step2, dst, step, width, height, scale);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_recip32s_const_int_X_unnamed_arg_size_t_unnamed_arg_1_const_int_X_src2_size_t_step2_int_X_dst_size_t_step_int_width_int_height_void_X_scale
// parsed: cv::hal::recip32s
// as:     cv::hal::recip32s (function)
// Arg ARG RawPtr[Primitive(int)] * unnamed_arg= (ptr) RawPtr[Primitive(int)] = 
// Arg ARG Primitive(size_t) unnamed_arg_1= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(int)] * src2= (ptr) RawPtr[Primitive(int)] = 
// Arg ARG Primitive(size_t) step2= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(int)] * dst= (ptr) RawPtr[Primitive(int)] = 
// Arg ARG Primitive(size_t) step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG RawPtr[Primitive(void)] * scale= (ptr) RawPtr[Primitive(void)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_recip32s_const_int_X_unnamed_arg_size_t_unnamed_arg_1_const_int_X_src2_size_t_step2_int_X_dst_size_t_step_int_width_int_height_void_X_scale(const int* unnamed_arg, std::size_t unnamed_arg_1, const int* src2, std::size_t step2, int* dst, std::size_t step, int width, int height, void* scale) {
    try {
        cv::hal::recip32s(unnamed_arg, unnamed_arg_1, src2, step2, dst, step, width, height, scale);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_recip64f_const_double_X_unnamed_arg_size_t_unnamed_arg_1_const_double_X_src2_size_t_step2_double_X_dst_size_t_step_int_width_int_height_void_X_scale
// parsed: cv::hal::recip64f
// as:     cv::hal::recip64f (function)
// Arg ARG RawPtr[Primitive(double)] * unnamed_arg= (ptr) RawPtr[Primitive(double)] = 
// Arg ARG Primitive(size_t) unnamed_arg_1= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(double)] * src2= (ptr) RawPtr[Primitive(double)] = 
// Arg ARG Primitive(size_t) step2= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(double)] * dst= (ptr) RawPtr[Primitive(double)] = 
// Arg ARG Primitive(size_t) step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG RawPtr[Primitive(void)] * scale= (ptr) RawPtr[Primitive(void)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_recip64f_const_double_X_unnamed_arg_size_t_unnamed_arg_1_const_double_X_src2_size_t_step2_double_X_dst_size_t_step_int_width_int_height_void_X_scale(const double* unnamed_arg, std::size_t unnamed_arg_1, const double* src2, std::size_t step2, double* dst, std::size_t step, int width, int height, void* scale) {
    try {
        cv::hal::recip64f(unnamed_arg, unnamed_arg_1, src2, step2, dst, step, width, height, scale);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_recip8s_const_schar_X_unnamed_arg_size_t_unnamed_arg_1_const_schar_X_src2_size_t_step2_schar_X_dst_size_t_step_int_width_int_height_void_X_scale
// parsed: cv::hal::recip8s
// as:     cv::hal::recip8s (function)
// Arg ARG RawPtr[Primitive(schar)] * unnamed_arg= (ptr) RawPtr[Primitive(schar)] = 
// Arg ARG Primitive(size_t) unnamed_arg_1= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(schar)] * src2= (ptr) RawPtr[Primitive(schar)] = 
// Arg ARG Primitive(size_t) step2= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(schar)] * dst= (ptr) RawPtr[Primitive(schar)] = 
// Arg ARG Primitive(size_t) step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG RawPtr[Primitive(void)] * scale= (ptr) RawPtr[Primitive(void)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_recip8s_const_schar_X_unnamed_arg_size_t_unnamed_arg_1_const_schar_X_src2_size_t_step2_schar_X_dst_size_t_step_int_width_int_height_void_X_scale(const schar* unnamed_arg, std::size_t unnamed_arg_1, const schar* src2, std::size_t step2, schar* dst, std::size_t step, int width, int height, void* scale) {
    try {
        cv::hal::recip8s(unnamed_arg, unnamed_arg_1, src2, step2, dst, step, width, height, scale);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_recip8u_const_uchar_X_unnamed_arg_size_t_unnamed_arg_1_const_uchar_X_src2_size_t_step2_uchar_X_dst_size_t_step_int_width_int_height_void_X_scale
// parsed: cv::hal::recip8u
// as:     cv::hal::recip8u (function)
// Arg ARG RawPtr[Primitive(uchar)] * unnamed_arg= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) unnamed_arg_1= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(uchar)] * src2= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) step2= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(uchar)] * dst= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG RawPtr[Primitive(void)] * scale= (ptr) RawPtr[Primitive(void)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_recip8u_const_uchar_X_unnamed_arg_size_t_unnamed_arg_1_const_uchar_X_src2_size_t_step2_uchar_X_dst_size_t_step_int_width_int_height_void_X_scale(const uchar* unnamed_arg, std::size_t unnamed_arg_1, const uchar* src2, std::size_t step2, uchar* dst, std::size_t step, int width, int height, void* scale) {
    try {
        cv::hal::recip8u(unnamed_arg, unnamed_arg_1, src2, step2, dst, step, width, height, scale);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_resize_int_src_type_const_uchar_X_src_data_size_t_src_step_int_src_width_int_src_height_uchar_X_dst_data_size_t_dst_step_int_dst_width_int_dst_height_double_inv_scale_x_double_inv_scale_y_int_interpolation
// parsed: cv::hal::resize
// as:     cv::hal::resize (function)
// Arg ARG Primitive(int) src_type= Primitive(int) = 
// Arg ARG RawPtr[Primitive(uchar)] * src_data= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) src_step= Primitive(size_t) = 
// Arg ARG Primitive(int) src_width= Primitive(int) = 
// Arg ARG Primitive(int) src_height= Primitive(int) = 
// Arg ARG RawPtr[Primitive(uchar)] * dst_data= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) dst_step= Primitive(size_t) = 
// Arg ARG Primitive(int) dst_width= Primitive(int) = 
// Arg ARG Primitive(int) dst_height= Primitive(int) = 
// Arg ARG Primitive(double) inv_scale_x= Primitive(double) = 
// Arg ARG Primitive(double) inv_scale_y= Primitive(double) = 
// Arg ARG Primitive(int) interpolation= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_resize_int_src_type_const_uchar_X_src_data_size_t_src_step_int_src_width_int_src_height_uchar_X_dst_data_size_t_dst_step_int_dst_width_int_dst_height_double_inv_scale_x_double_inv_scale_y_int_interpolation(int src_type, const uchar* src_data, std::size_t src_step, int src_width, int src_height, uchar* dst_data, std::size_t dst_step, int dst_width, int dst_height, double inv_scale_x, double inv_scale_y, int interpolation) {
    try {
        cv::hal::resize(src_type, src_data, src_step, src_width, src_height, dst_data, dst_step, dst_width, dst_height, inv_scale_x, inv_scale_y, interpolation);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_sepFilter2D_int_stype_int_dtype_int_ktype_uchar_X_src_data_size_t_src_step_uchar_X_dst_data_size_t_dst_step_int_width_int_height_int_full_width_int_full_height_int_offset_x_int_offset_y_uchar_X_kernelx_data_int_kernelx_len_uchar_X_kernely_data_int_kernely_len_int_anchor_x_int_anchor_y_double_delta_int_borderType
// parsed: cv::hal::sepFilter2D
// as:     cv::hal::sepFilter2D (function)
// Arg ARG Primitive(int) stype= Primitive(int) = 
// Arg ARG Primitive(int) dtype= Primitive(int) = 
// Arg ARG Primitive(int) ktype= Primitive(int) = 
// Arg ARG RawPtr[Primitive(uchar)] * src_data= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) src_step= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(uchar)] * dst_data= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) dst_step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG Primitive(int) full_width= Primitive(int) = 
// Arg ARG Primitive(int) full_height= Primitive(int) = 
// Arg ARG Primitive(int) offset_x= Primitive(int) = 
// Arg ARG Primitive(int) offset_y= Primitive(int) = 
// Arg ARG RawPtr[Primitive(uchar)] * kernelx_data= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(int) kernelx_len= Primitive(int) = 
// Arg ARG RawPtr[Primitive(uchar)] * kernely_data= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(int) kernely_len= Primitive(int) = 
// Arg ARG Primitive(int) anchor_x= Primitive(int) = 
// Arg ARG Primitive(int) anchor_y= Primitive(int) = 
// Arg ARG Primitive(double) delta= Primitive(double) = 
// Arg ARG Primitive(int) borderType= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_sepFilter2D_int_stype_int_dtype_int_ktype_uchar_X_src_data_size_t_src_step_uchar_X_dst_data_size_t_dst_step_int_width_int_height_int_full_width_int_full_height_int_offset_x_int_offset_y_uchar_X_kernelx_data_int_kernelx_len_uchar_X_kernely_data_int_kernely_len_int_anchor_x_int_anchor_y_double_delta_int_borderType(int stype, int dtype, int ktype, uchar* src_data, std::size_t src_step, uchar* dst_data, std::size_t dst_step, int width, int height, int full_width, int full_height, int offset_x, int offset_y, uchar* kernelx_data, int kernelx_len, uchar* kernely_data, int kernely_len, int anchor_x, int anchor_y, double delta, int borderType) {
    try {
        cv::hal::sepFilter2D(stype, dtype, ktype, src_data, src_step, dst_data, dst_step, width, height, full_width, full_height, offset_x, offset_y, kernelx_data, kernelx_len, kernely_data, kernely_len, anchor_x, anchor_y, delta, borderType);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_sqrt32f_const_float_X_src_float_X_dst_int_len
// parsed: cv::hal::sqrt32f
// as:     cv::hal::sqrt32f (function)
// Arg ARG RawPtr[Primitive(float)] * src= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG RawPtr[Primitive(float)] * dst= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG Primitive(int) len= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_sqrt32f_const_float_X_src_float_X_dst_int_len(const float* src, float* dst, int len) {
    try {
        cv::hal::sqrt32f(src, dst, len);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_sqrt64f_const_double_X_src_double_X_dst_int_len
// parsed: cv::hal::sqrt64f
// as:     cv::hal::sqrt64f (function)
// Arg ARG RawPtr[Primitive(double)] * src= (ptr) RawPtr[Primitive(double)] = 
// Arg ARG RawPtr[Primitive(double)] * dst= (ptr) RawPtr[Primitive(double)] = 
// Arg ARG Primitive(int) len= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_sqrt64f_const_double_X_src_double_X_dst_int_len(const double* src, double* dst, int len) {
    try {
        cv::hal::sqrt64f(src, dst, len);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_sqrt_const_double_X_src_double_X_dst_int_len
// parsed: cv::hal::sqrt
// as:     cv::hal::sqrt (function)
// Arg ARG RawPtr[Primitive(double)] * src= (ptr) RawPtr[Primitive(double)] = 
// Arg ARG RawPtr[Primitive(double)] * dst= (ptr) RawPtr[Primitive(double)] = 
// Arg ARG Primitive(int) len= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_sqrt_const_double_X_src_double_X_dst_int_len(const double* src, double* dst, int len) {
    try {
        cv::hal::sqrt(src, dst, len);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_sqrt_const_float_X_src_float_X_dst_int_len
// parsed: cv::hal::sqrt
// as:     cv::hal::sqrt (function)
// Arg ARG RawPtr[Primitive(float)] * src= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG RawPtr[Primitive(float)] * dst= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG Primitive(int) len= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_sqrt_const_float_X_src_float_X_dst_int_len(const float* src, float* dst, int len) {
    try {
        cv::hal::sqrt(src, dst, len);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_sub16s_const_short_X_src1_size_t_step1_const_short_X_src2_size_t_step2_short_X_dst_size_t_step_int_width_int_height_void_X_unnamed_arg
// parsed: cv::hal::sub16s
// as:     cv::hal::sub16s (function)
// Arg ARG RawPtr[Primitive(short)] * src1= (ptr) RawPtr[Primitive(short)] = 
// Arg ARG Primitive(size_t) step1= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(short)] * src2= (ptr) RawPtr[Primitive(short)] = 
// Arg ARG Primitive(size_t) step2= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(short)] * dst= (ptr) RawPtr[Primitive(short)] = 
// Arg ARG Primitive(size_t) step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG RawPtr[Primitive(void)] * unnamed_arg= (ptr) RawPtr[Primitive(void)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_sub16s_const_short_X_src1_size_t_step1_const_short_X_src2_size_t_step2_short_X_dst_size_t_step_int_width_int_height_void_X_unnamed_arg(const short* src1, std::size_t step1, const short* src2, std::size_t step2, short* dst, std::size_t step, int width, int height, void* unnamed_arg) {
    try {
        cv::hal::sub16s(src1, step1, src2, step2, dst, step, width, height, unnamed_arg);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_sub16u_const_ushort_X_src1_size_t_step1_const_ushort_X_src2_size_t_step2_ushort_X_dst_size_t_step_int_width_int_height_void_X_unnamed_arg
// parsed: cv::hal::sub16u
// as:     cv::hal::sub16u (function)
// Arg ARG RawPtr[Primitive(ushort)] * src1= (ptr) RawPtr[Primitive(ushort)] = 
// Arg ARG Primitive(size_t) step1= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(ushort)] * src2= (ptr) RawPtr[Primitive(ushort)] = 
// Arg ARG Primitive(size_t) step2= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(ushort)] * dst= (ptr) RawPtr[Primitive(ushort)] = 
// Arg ARG Primitive(size_t) step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG RawPtr[Primitive(void)] * unnamed_arg= (ptr) RawPtr[Primitive(void)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_sub16u_const_ushort_X_src1_size_t_step1_const_ushort_X_src2_size_t_step2_ushort_X_dst_size_t_step_int_width_int_height_void_X_unnamed_arg(const ushort* src1, std::size_t step1, const ushort* src2, std::size_t step2, ushort* dst, std::size_t step, int width, int height, void* unnamed_arg) {
    try {
        cv::hal::sub16u(src1, step1, src2, step2, dst, step, width, height, unnamed_arg);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_sub32f_const_float_X_src1_size_t_step1_const_float_X_src2_size_t_step2_float_X_dst_size_t_step_int_width_int_height_void_X_unnamed_arg
// parsed: cv::hal::sub32f
// as:     cv::hal::sub32f (function)
// Arg ARG RawPtr[Primitive(float)] * src1= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG Primitive(size_t) step1= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(float)] * src2= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG Primitive(size_t) step2= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(float)] * dst= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG Primitive(size_t) step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG RawPtr[Primitive(void)] * unnamed_arg= (ptr) RawPtr[Primitive(void)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_sub32f_const_float_X_src1_size_t_step1_const_float_X_src2_size_t_step2_float_X_dst_size_t_step_int_width_int_height_void_X_unnamed_arg(const float* src1, std::size_t step1, const float* src2, std::size_t step2, float* dst, std::size_t step, int width, int height, void* unnamed_arg) {
    try {
        cv::hal::sub32f(src1, step1, src2, step2, dst, step, width, height, unnamed_arg);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_sub32s_const_int_X_src1_size_t_step1_const_int_X_src2_size_t_step2_int_X_dst_size_t_step_int_width_int_height_void_X_unnamed_arg
// parsed: cv::hal::sub32s
// as:     cv::hal::sub32s (function)
// Arg ARG RawPtr[Primitive(int)] * src1= (ptr) RawPtr[Primitive(int)] = 
// Arg ARG Primitive(size_t) step1= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(int)] * src2= (ptr) RawPtr[Primitive(int)] = 
// Arg ARG Primitive(size_t) step2= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(int)] * dst= (ptr) RawPtr[Primitive(int)] = 
// Arg ARG Primitive(size_t) step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG RawPtr[Primitive(void)] * unnamed_arg= (ptr) RawPtr[Primitive(void)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_sub32s_const_int_X_src1_size_t_step1_const_int_X_src2_size_t_step2_int_X_dst_size_t_step_int_width_int_height_void_X_unnamed_arg(const int* src1, std::size_t step1, const int* src2, std::size_t step2, int* dst, std::size_t step, int width, int height, void* unnamed_arg) {
    try {
        cv::hal::sub32s(src1, step1, src2, step2, dst, step, width, height, unnamed_arg);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_sub64f_const_double_X_src1_size_t_step1_const_double_X_src2_size_t_step2_double_X_dst_size_t_step_int_width_int_height_void_X_unnamed_arg
// parsed: cv::hal::sub64f
// as:     cv::hal::sub64f (function)
// Arg ARG RawPtr[Primitive(double)] * src1= (ptr) RawPtr[Primitive(double)] = 
// Arg ARG Primitive(size_t) step1= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(double)] * src2= (ptr) RawPtr[Primitive(double)] = 
// Arg ARG Primitive(size_t) step2= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(double)] * dst= (ptr) RawPtr[Primitive(double)] = 
// Arg ARG Primitive(size_t) step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG RawPtr[Primitive(void)] * unnamed_arg= (ptr) RawPtr[Primitive(void)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_sub64f_const_double_X_src1_size_t_step1_const_double_X_src2_size_t_step2_double_X_dst_size_t_step_int_width_int_height_void_X_unnamed_arg(const double* src1, std::size_t step1, const double* src2, std::size_t step2, double* dst, std::size_t step, int width, int height, void* unnamed_arg) {
    try {
        cv::hal::sub64f(src1, step1, src2, step2, dst, step, width, height, unnamed_arg);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_sub8s_const_schar_X_src1_size_t_step1_const_schar_X_src2_size_t_step2_schar_X_dst_size_t_step_int_width_int_height_void_X_unnamed_arg
// parsed: cv::hal::sub8s
// as:     cv::hal::sub8s (function)
// Arg ARG RawPtr[Primitive(schar)] * src1= (ptr) RawPtr[Primitive(schar)] = 
// Arg ARG Primitive(size_t) step1= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(schar)] * src2= (ptr) RawPtr[Primitive(schar)] = 
// Arg ARG Primitive(size_t) step2= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(schar)] * dst= (ptr) RawPtr[Primitive(schar)] = 
// Arg ARG Primitive(size_t) step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG RawPtr[Primitive(void)] * unnamed_arg= (ptr) RawPtr[Primitive(void)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_sub8s_const_schar_X_src1_size_t_step1_const_schar_X_src2_size_t_step2_schar_X_dst_size_t_step_int_width_int_height_void_X_unnamed_arg(const schar* src1, std::size_t step1, const schar* src2, std::size_t step2, schar* dst, std::size_t step, int width, int height, void* unnamed_arg) {
    try {
        cv::hal::sub8s(src1, step1, src2, step2, dst, step, width, height, unnamed_arg);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_sub8u_const_uchar_X_src1_size_t_step1_const_uchar_X_src2_size_t_step2_uchar_X_dst_size_t_step_int_width_int_height_void_X_unnamed_arg
// parsed: cv::hal::sub8u
// as:     cv::hal::sub8u (function)
// Arg ARG RawPtr[Primitive(uchar)] * src1= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) step1= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(uchar)] * src2= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) step2= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(uchar)] * dst= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG RawPtr[Primitive(void)] * unnamed_arg= (ptr) RawPtr[Primitive(void)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_sub8u_const_uchar_X_src1_size_t_step1_const_uchar_X_src2_size_t_step2_uchar_X_dst_size_t_step_int_width_int_height_void_X_unnamed_arg(const uchar* src1, std::size_t step1, const uchar* src2, std::size_t step2, uchar* dst, std::size_t step, int width, int height, void* unnamed_arg) {
    try {
        cv::hal::sub8u(src1, step1, src2, step2, dst, step, width, height, unnamed_arg);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hal_xor8u_const_uchar_X_src1_size_t_step1_const_uchar_X_src2_size_t_step2_uchar_X_dst_size_t_step_int_width_int_height_void_X_unnamed_arg
// parsed: cv::hal::xor8u
// as:     cv::hal::xor8u (function)
// Arg ARG RawPtr[Primitive(uchar)] * src1= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) step1= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(uchar)] * src2= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) step2= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(uchar)] * dst= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(size_t) step= Primitive(size_t) = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Arg ARG RawPtr[Primitive(void)] * unnamed_arg= (ptr) RawPtr[Primitive(void)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hal_xor8u_const_uchar_X_src1_size_t_step1_const_uchar_X_src2_size_t_step2_uchar_X_dst_size_t_step_int_width_int_height_void_X_unnamed_arg(const uchar* src1, std::size_t step1, const uchar* src2, std::size_t step2, uchar* dst, std::size_t step, int width, int height, void* unnamed_arg) {
    try {
        cv::hal::xor8u(src1, step1, src2, step2, dst, step, width, height, unnamed_arg);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_haveOpenVX
// parsed: cv::haveOpenVX
// as:     cv::haveOpenVX (function)
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_haveOpenVX() {
    try {
        bool ret = cv::haveOpenVX();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_hconcat_Mat_src1_Mat_src2_Mat_dst
// parsed: cv::hconcat
// as:     cv::hconcat (function)
// Arg ARG cv::Mat (boxed) src1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) src2= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hconcat_Mat_src1_Mat_src2_Mat_dst(void* src1, void* src2, void* dst) {
    try {
        cv::hconcat(*reinterpret_cast<cv::Mat*>(src1), *reinterpret_cast<cv::Mat*>(src2), *reinterpret_cast<cv::Mat*>(dst));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hconcat_VectorOfMat_src_Mat_dst
// parsed: cv::hconcat
// as:     cv::hconcat (function)
// Arg ARG Vector[cv::Mat (boxed)] src= Vector[cv::Mat (boxed)] = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hconcat_VectorOfMat_src_Mat_dst(void* src, void* dst) {
    try {
        cv::hconcat(*reinterpret_cast<std::vector<cv::Mat>*>(src), *reinterpret_cast<cv::Mat*>(dst));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_hconcat_const_Mat_src_size_t_nsrc_Mat_dst
// parsed: cv::hconcat
// as:     cv::hconcat (function)
// Arg ARG RawPtr[cv::Mat (boxed)] * src= (ptr) RawPtr[cv::Mat (boxed)] = 
// Arg ARG Primitive(size_t) nsrc= Primitive(size_t) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_hconcat_const_Mat_src_size_t_nsrc_Mat_dst(const void* src, std::size_t nsrc, void* dst) {
    try {
        cv::hconcat(reinterpret_cast<const cv::Mat*>(src), nsrc, *reinterpret_cast<cv::Mat*>(dst));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_idct_Mat_src_Mat_dst_int_flags
// parsed: cv::idct
// as:     cv::idct (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG Primitive(int) flags= Primitive(int) = 0
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_idct_Mat_src_Mat_dst_int_flags(void* src, void* dst, int flags) {
    try {
        cv::idct(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst), flags);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_idft_Mat_src_Mat_dst_int_flags_int_nonzeroRows
// parsed: cv::idft
// as:     cv::idft (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG Primitive(int) flags= Primitive(int) = 0
// Arg ARG Primitive(int) nonzeroRows= Primitive(int) = 0
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_idft_Mat_src_Mat_dst_int_flags_int_nonzeroRows(void* src, void* dst, int flags, int nonzeroRows) {
    try {
        cv::idft(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst), flags, nonzeroRows);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_illuminationChange_Mat_src_Mat_mask_Mat_dst_float_alpha_float_beta
// parsed: cv::illuminationChange
// as:     cv::illuminationChange (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) mask= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG Primitive(float) alpha= Primitive(float) = 0.2f
// Arg ARG Primitive(float) beta= Primitive(float) = 0.4f
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_illuminationChange_Mat_src_Mat_mask_Mat_dst_float_alpha_float_beta(void* src, void* mask, void* dst, float alpha, float beta) {
    try {
        cv::illuminationChange(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(mask), *reinterpret_cast<cv::Mat*>(dst), alpha, beta);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_imdecode_Mat_buf_int_flags
// parsed: cv::imdecode
// as:     cv::imdecode (function)
// Arg ARG cv::Mat (boxed) buf= cv::Mat (boxed) = 
// Arg ARG Primitive(int) flags= Primitive(int) = 
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_imdecode_Mat_buf_int_flags(void* buf, int flags) {
    try {
        cv::Mat ret = cv::imdecode(*reinterpret_cast<cv::Mat*>(buf), flags);
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_imdecode_Mat_buf_int_flags_Mat_dst
// parsed: cv::imdecode
// as:     cv::imdecode (function)
// Arg ARG cv::Mat (boxed) buf= cv::Mat (boxed) = 
// Arg ARG Primitive(int) flags= Primitive(int) = 
// Arg ARG RawPtr[cv::Mat (boxed)] * dst= (ptr) RawPtr[cv::Mat (boxed)] = 
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_imdecode_Mat_buf_int_flags_Mat_dst(void* buf, int flags, void* dst) {
    try {
        cv::Mat ret = cv::imdecode(*reinterpret_cast<cv::Mat*>(buf), flags, reinterpret_cast<cv::Mat*>(dst));
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_imencode_String_ext_Mat_img_VectorOfuchar_buf_VectorOfint_params
// parsed: cv::imencode
// as:     cv::imencode (function)
// Arg ARG string ext= string = 
// Arg ARG cv::Mat (boxed) img= cv::Mat (boxed) = 
// Arg ARG Vector[Primitive(uchar)] buf= Vector[Primitive(uchar)] = 
// Arg ARG Vector[Primitive(int)] params= Vector[Primitive(int)] = std::vector<int>()
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_imencode_String_ext_Mat_img_VectorOfuchar_buf_VectorOfint_params(const char* ext, void* img, void* buf, void* params) {
    try {
        bool ret = cv::imencode(String(ext), *reinterpret_cast<cv::Mat*>(img), *reinterpret_cast<std::vector<uchar>*>(buf), *reinterpret_cast<std::vector<int>*>(params));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_imread_String_filename_int_flags
// parsed: cv::imread
// as:     cv::imread (function)
// Arg ARG string filename= string = 
// Arg ARG Primitive(int) flags= Primitive(int) = IMREAD_COLOR
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_imread_String_filename_int_flags(const char* filename, int flags) {
    try {
        cv::Mat ret = cv::imread(String(filename), flags);
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_imreadmulti_String_filename_VectorOfMat_mats_int_flags
// parsed: cv::imreadmulti
// as:     cv::imreadmulti (function)
// Arg ARG string filename= string = 
// Arg ARG Vector[cv::Mat (boxed)] mats= Vector[cv::Mat (boxed)] = 
// Arg ARG Primitive(int) flags= Primitive(int) = IMREAD_ANYCOLOR
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_imreadmulti_String_filename_VectorOfMat_mats_int_flags(const char* filename, void* mats, int flags) {
    try {
        bool ret = cv::imreadmulti(String(filename), *reinterpret_cast<std::vector<cv::Mat>*>(mats), flags);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_imshow_String_winname_Mat_mat
// parsed: cv::imshow
// as:     cv::imshow (function)
// Arg ARG string winname= string = 
// Arg ARG cv::Mat (boxed) mat= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_imshow_String_winname_Mat_mat(const char* winname, void* mat) {
    try {
        cv::imshow(String(winname), *reinterpret_cast<cv::Mat*>(mat));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_imwrite_String_filename_Mat_img_VectorOfint_params
// parsed: cv::imwrite
// as:     cv::imwrite (function)
// Arg ARG string filename= string = 
// Arg ARG cv::Mat (boxed) img= cv::Mat (boxed) = 
// Arg ARG Vector[Primitive(int)] params= Vector[Primitive(int)] = std::vector<int>()
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_imwrite_String_filename_Mat_img_VectorOfint_params(const char* filename, void* img, void* params) {
    try {
        bool ret = cv::imwrite(String(filename), *reinterpret_cast<cv::Mat*>(img), *reinterpret_cast<std::vector<int>*>(params));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_inRange_Mat_src_Mat_lowerb_Mat_upperb_Mat_dst
// parsed: cv::inRange
// as:     cv::inRange (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) lowerb= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) upperb= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_inRange_Mat_src_Mat_lowerb_Mat_upperb_Mat_dst(void* src, void* lowerb, void* upperb, void* dst) {
    try {
        cv::inRange(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(lowerb), *reinterpret_cast<cv::Mat*>(upperb), *reinterpret_cast<cv::Mat*>(dst));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_initCameraMatrix2D_VectorOfMat_objectPoints_VectorOfMat_imagePoints_Size_imageSize_double_aspectRatio
// parsed: cv::initCameraMatrix2D
// as:     cv::initCameraMatrix2D (function)
// Arg ARG Vector[cv::Mat (boxed)] objectPoints= Vector[cv::Mat (boxed)] = 
// Arg ARG Vector[cv::Mat (boxed)] imagePoints= Vector[cv::Mat (boxed)] = 
// Arg ARG cv::Size (simple) imageSize= cv::Size (simple) = 
// Arg ARG Primitive(double) aspectRatio= Primitive(double) = 1.0
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_initCameraMatrix2D_VectorOfMat_objectPoints_VectorOfMat_imagePoints_Size_imageSize_double_aspectRatio(void* objectPoints, void* imagePoints, SizeWrapper imageSize, double aspectRatio) {
    try {
        cv::Mat ret = cv::initCameraMatrix2D(*reinterpret_cast<std::vector<cv::Mat>*>(objectPoints), *reinterpret_cast<std::vector<cv::Mat>*>(imagePoints), *reinterpret_cast<cv::Size*>(&imageSize), aspectRatio);
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_initUndistortRectifyMap_Mat_cameraMatrix_Mat_distCoeffs_Mat_R_Mat_newCameraMatrix_Size_size_int_m1type_Mat_map1_Mat_map2
// parsed: cv::initUndistortRectifyMap
// as:     cv::initUndistortRectifyMap (function)
// Arg ARG cv::Mat (boxed) cameraMatrix= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) distCoeffs= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) R= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) newCameraMatrix= cv::Mat (boxed) = 
// Arg ARG cv::Size (simple) size= cv::Size (simple) = 
// Arg ARG Primitive(int) m1type= Primitive(int) = 
// Arg ARG cv::Mat (boxed) map1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) map2= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_initUndistortRectifyMap_Mat_cameraMatrix_Mat_distCoeffs_Mat_R_Mat_newCameraMatrix_Size_size_int_m1type_Mat_map1_Mat_map2(void* cameraMatrix, void* distCoeffs, void* R, void* newCameraMatrix, SizeWrapper size, int m1type, void* map1, void* map2) {
    try {
        cv::initUndistortRectifyMap(*reinterpret_cast<cv::Mat*>(cameraMatrix), *reinterpret_cast<cv::Mat*>(distCoeffs), *reinterpret_cast<cv::Mat*>(R), *reinterpret_cast<cv::Mat*>(newCameraMatrix), *reinterpret_cast<cv::Size*>(&size), m1type, *reinterpret_cast<cv::Mat*>(map1), *reinterpret_cast<cv::Mat*>(map2));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_initWideAngleProjMap_Mat_cameraMatrix_Mat_distCoeffs_Size_imageSize_int_destImageWidth_int_m1type_Mat_map1_Mat_map2_int_projType_double_alpha
// parsed: cv::initWideAngleProjMap
// as:     cv::initWideAngleProjMap (function)
// Arg ARG cv::Mat (boxed) cameraMatrix= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) distCoeffs= cv::Mat (boxed) = 
// Arg ARG cv::Size (simple) imageSize= cv::Size (simple) = 
// Arg ARG Primitive(int) destImageWidth= Primitive(int) = 
// Arg ARG Primitive(int) m1type= Primitive(int) = 
// Arg ARG cv::Mat (boxed) map1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) map2= cv::Mat (boxed) = 
// Arg ARG Primitive(int) projType= Primitive(int) = PROJ_SPHERICAL_EQRECT
// Arg ARG Primitive(double) alpha= Primitive(double) = 0
// Return value: Primitive(float)
cv_return_value_float cv_core_cv_initWideAngleProjMap_Mat_cameraMatrix_Mat_distCoeffs_Size_imageSize_int_destImageWidth_int_m1type_Mat_map1_Mat_map2_int_projType_double_alpha(void* cameraMatrix, void* distCoeffs, SizeWrapper imageSize, int destImageWidth, int m1type, void* map1, void* map2, int projType, double alpha) {
    try {
        float ret = cv::initWideAngleProjMap(*reinterpret_cast<cv::Mat*>(cameraMatrix), *reinterpret_cast<cv::Mat*>(distCoeffs), *reinterpret_cast<cv::Size*>(&imageSize), destImageWidth, m1type, *reinterpret_cast<cv::Mat*>(map1), *reinterpret_cast<cv::Mat*>(map2), projType, alpha);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<float*>(&ret) };
    } CVRS_CATCH(cv_return_value_float)
}

// cv_inpaint_Mat_src_Mat_inpaintMask_Mat_dst_double_inpaintRadius_int_flags
// parsed: cv::inpaint
// as:     cv::inpaint (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) inpaintMask= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG Primitive(double) inpaintRadius= Primitive(double) = 
// Arg ARG Primitive(int) flags= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_inpaint_Mat_src_Mat_inpaintMask_Mat_dst_double_inpaintRadius_int_flags(void* src, void* inpaintMask, void* dst, double inpaintRadius, int flags) {
    try {
        cv::inpaint(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(inpaintMask), *reinterpret_cast<cv::Mat*>(dst), inpaintRadius, flags);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_insertChannel_Mat_src_Mat_dst_int_coi
// parsed: cv::insertChannel
// as:     cv::insertChannel (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG Primitive(int) coi= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_insertChannel_Mat_src_Mat_dst_int_coi(void* src, void* dst, int coi) {
    try {
        cv::insertChannel(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst), coi);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_instr_resetTrace
// parsed: cv::instr::resetTrace
// as:     cv::instr::resetTrace (function)
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_instr_resetTrace() {
    try {
        cv::instr::resetTrace();
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_instr_setFlags_int_modeFlags
// parsed: cv::instr::setFlags
// as:     cv::instr::setFlags (function)
// Arg ARG Primitive(int) modeFlags= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_instr_setFlags_int_modeFlags(int modeFlags) {
    try {
        cv::instr::setFlags(modeFlags);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_instr_setUseInstrumentation_bool_flag
// parsed: cv::instr::setUseInstrumentation
// as:     cv::instr::setUseInstrumentation (function)
// Arg ARG Primitive(bool) flag= Primitive(bool) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_instr_setUseInstrumentation_bool_flag(bool flag) {
    try {
        cv::instr::setUseInstrumentation(flag);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_instr_useInstrumentation
// parsed: cv::instr::useInstrumentation
// as:     cv::instr::useInstrumentation (function)
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_instr_useInstrumentation() {
    try {
        bool ret = cv::instr::useInstrumentation();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_integral_Mat_src_Mat_sum_Mat_sqsum_Mat_tilted_int_sdepth_int_sqdepth
// parsed: cv::integral
// as:     cv::integral (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) sum= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) sqsum= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) tilted= cv::Mat (boxed) = 
// Arg ARG Primitive(int) sdepth= Primitive(int) = -1
// Arg ARG Primitive(int) sqdepth= Primitive(int) = -1
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_integral_Mat_src_Mat_sum_Mat_sqsum_Mat_tilted_int_sdepth_int_sqdepth(void* src, void* sum, void* sqsum, void* tilted, int sdepth, int sqdepth) {
    try {
        cv::integral(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(sum), *reinterpret_cast<cv::Mat*>(sqsum), *reinterpret_cast<cv::Mat*>(tilted), sdepth, sqdepth);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_integral_Mat_src_Mat_sum_Mat_sqsum_int_sdepth_int_sqdepth
// parsed: cv::integral
// as:     cv::integral (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) sum= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) sqsum= cv::Mat (boxed) = 
// Arg ARG Primitive(int) sdepth= Primitive(int) = -1
// Arg ARG Primitive(int) sqdepth= Primitive(int) = -1
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_integral_Mat_src_Mat_sum_Mat_sqsum_int_sdepth_int_sqdepth(void* src, void* sum, void* sqsum, int sdepth, int sqdepth) {
    try {
        cv::integral(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(sum), *reinterpret_cast<cv::Mat*>(sqsum), sdepth, sqdepth);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_integral_Mat_src_Mat_sum_int_sdepth
// parsed: cv::integral
// as:     cv::integral (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) sum= cv::Mat (boxed) = 
// Arg ARG Primitive(int) sdepth= Primitive(int) = -1
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_integral_Mat_src_Mat_sum_int_sdepth(void* src, void* sum, int sdepth) {
    try {
        cv::integral(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(sum), sdepth);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_intersectConvexConvex_Mat__p1_Mat__p2_Mat__p12_bool_handleNested
// parsed: cv::intersectConvexConvex
// as:     cv::intersectConvexConvex (function)
// Arg ARG cv::Mat (boxed) _p1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) _p2= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) _p12= cv::Mat (boxed) = 
// Arg ARG Primitive(bool) handleNested= Primitive(bool) = true
// Return value: Primitive(float)
cv_return_value_float cv_core_cv_intersectConvexConvex_Mat__p1_Mat__p2_Mat__p12_bool_handleNested(void* _p1, void* _p2, void* _p12, bool handleNested) {
    try {
        float ret = cv::intersectConvexConvex(*reinterpret_cast<cv::Mat*>(_p1), *reinterpret_cast<cv::Mat*>(_p2), *reinterpret_cast<cv::Mat*>(_p12), handleNested);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<float*>(&ret) };
    } CVRS_CATCH(cv_return_value_float)
}

// cv_invertAffineTransform_Mat_M_Mat_iM
// parsed: cv::invertAffineTransform
// as:     cv::invertAffineTransform (function)
// Arg ARG cv::Mat (boxed) M= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) iM= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_invertAffineTransform_Mat_M_Mat_iM(void* M, void* iM) {
    try {
        cv::invertAffineTransform(*reinterpret_cast<cv::Mat*>(M), *reinterpret_cast<cv::Mat*>(iM));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_invert_Mat_src_Mat_dst_int_flags
// parsed: cv::invert
// as:     cv::invert (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG Primitive(int) flags= Primitive(int) = DECOMP_LU
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_invert_Mat_src_Mat_dst_int_flags(void* src, void* dst, int flags) {
    try {
        double ret = cv::invert(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst), flags);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_ipp_getIppErrorLocation
// parsed: cv::ipp::getIppErrorLocation
// as:     cv::ipp::getIppErrorLocation (function)
// Return value: string
cv_return_value_char_X cv_core_cv_ipp_getIppErrorLocation() {
    try {
        String ret = cv::ipp::getIppErrorLocation();
        return { Error::Code::StsOk, NULL, strdup(ret.c_str()) };
    } CVRS_CATCH(cv_return_value_char_X)
}

// cv_ipp_getIppFeatures
// parsed: cv::ipp::getIppFeatures
// as:     cv::ipp::getIppFeatures (function)
// Return value: Primitive(unsigned long long)
cv_return_value_unsigned_long_long cv_core_cv_ipp_getIppFeatures() {
    try {
        unsigned long long ret = cv::ipp::getIppFeatures();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<unsigned long long*>(&ret) };
    } CVRS_CATCH(cv_return_value_unsigned_long_long)
}

// cv_ipp_getIppStatus
// parsed: cv::ipp::getIppStatus
// as:     cv::ipp::getIppStatus (function)
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_ipp_getIppStatus() {
    try {
        int ret = cv::ipp::getIppStatus();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_ipp_getIppVersion
// parsed: cv::ipp::getIppVersion
// as:     cv::ipp::getIppVersion (function)
// Return value: string
cv_return_value_char_X cv_core_cv_ipp_getIppVersion() {
    try {
        String ret = cv::ipp::getIppVersion();
        return { Error::Code::StsOk, NULL, strdup(ret.c_str()) };
    } CVRS_CATCH(cv_return_value_char_X)
}

// cv_ipp_setUseIPP_NE_bool_flag
// parsed: cv::ipp::setUseIPP_NE
// as:     cv::ipp::setUseIPP_NE (function)
// Arg ARG Primitive(bool) flag= Primitive(bool) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ipp_setUseIPP_NE_bool_flag(bool flag) {
    try {
        cv::ipp::setUseIPP_NE(flag);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ipp_setUseIPP_NotExact_bool_flag
// parsed: cv::ipp::setUseIPP_NotExact
// as:     cv::ipp::setUseIPP_NotExact (function)
// Arg ARG Primitive(bool) flag= Primitive(bool) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ipp_setUseIPP_NotExact_bool_flag(bool flag) {
    try {
        cv::ipp::setUseIPP_NotExact(flag);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ipp_setUseIPP_bool_flag
// parsed: cv::ipp::setUseIPP
// as:     cv::ipp::setUseIPP (function)
// Arg ARG Primitive(bool) flag= Primitive(bool) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ipp_setUseIPP_bool_flag(bool flag) {
    try {
        cv::ipp::setUseIPP(flag);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ipp_useIPP
// parsed: cv::ipp::useIPP
// as:     cv::ipp::useIPP (function)
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_ipp_useIPP() {
    try {
        bool ret = cv::ipp::useIPP();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_ipp_useIPP_NE
// parsed: cv::ipp::useIPP_NE
// as:     cv::ipp::useIPP_NE (function)
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_ipp_useIPP_NE() {
    try {
        bool ret = cv::ipp::useIPP_NE();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_ipp_useIPP_NotExact
// parsed: cv::ipp::useIPP_NotExact
// as:     cv::ipp::useIPP_NotExact (function)
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_ipp_useIPP_NotExact() {
    try {
        bool ret = cv::ipp::useIPP_NotExact();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_isContourConvex_Mat_contour
// parsed: cv::isContourConvex
// as:     cv::isContourConvex (function)
// Arg ARG cv::Mat (boxed) contour= cv::Mat (boxed) = 
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_isContourConvex_Mat_contour(void* contour) {
    try {
        bool ret = cv::isContourConvex(*reinterpret_cast<cv::Mat*>(contour));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_kmeans_Mat_data_int_K_Mat_bestLabels_TermCriteria_criteria_int_attempts_int_flags_Mat_centers
// parsed: cv::kmeans
// as:     cv::kmeans (function)
// Arg ARG cv::Mat (boxed) data= cv::Mat (boxed) = 
// Arg ARG Primitive(int) K= Primitive(int) = 
// Arg ARG cv::Mat (boxed) bestLabels= cv::Mat (boxed) = 
// Arg ARG cv::TermCriteria (boxed) criteria= cv::TermCriteria (boxed) = 
// Arg ARG Primitive(int) attempts= Primitive(int) = 
// Arg ARG Primitive(int) flags= Primitive(int) = 
// Arg ARG cv::Mat (boxed) centers= cv::Mat (boxed) = noArray()
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_kmeans_Mat_data_int_K_Mat_bestLabels_TermCriteria_criteria_int_attempts_int_flags_Mat_centers(void* data, int K, void* bestLabels, void* criteria, int attempts, int flags, void* centers) {
    try {
        double ret = cv::kmeans(*reinterpret_cast<cv::Mat*>(data), K, *reinterpret_cast<cv::Mat*>(bestLabels), *reinterpret_cast<cv::TermCriteria*>(criteria), attempts, flags, *reinterpret_cast<cv::Mat*>(centers));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_line_Mat_img_Point_pt1_Point_pt2_Scalar_color_int_thickness_int_lineType_int_shift
// parsed: cv::line
// as:     cv::line (function)
// Arg ARG cv::Mat (boxed) img= cv::Mat (boxed) = 
// Arg ARG cv::Point (simple) pt1= cv::Point (simple) = 
// Arg ARG cv::Point (simple) pt2= cv::Point (simple) = 
// Arg ARG cv::Scalar (simple) color= cv::Scalar (simple) = 
// Arg ARG Primitive(int) thickness= Primitive(int) = 1
// Arg ARG Primitive(int) lineType= Primitive(int) = LINE_8
// Arg ARG Primitive(int) shift= Primitive(int) = 0
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_line_Mat_img_Point_pt1_Point_pt2_Scalar_color_int_thickness_int_lineType_int_shift(void* img, PointWrapper pt1, PointWrapper pt2, ScalarWrapper color, int thickness, int lineType, int shift) {
    try {
        cv::line(*reinterpret_cast<cv::Mat*>(img), *reinterpret_cast<cv::Point*>(&pt1), *reinterpret_cast<cv::Point*>(&pt2), *reinterpret_cast<cv::Scalar*>(&color), thickness, lineType, shift);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_linearPolar_Mat_src_Mat_dst_Point2f_center_double_maxRadius_int_flags
// parsed: cv::linearPolar
// as:     cv::linearPolar (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG cv::Point2f (simple) center= cv::Point2f (simple) = 
// Arg ARG Primitive(double) maxRadius= Primitive(double) = 
// Arg ARG Primitive(int) flags= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_linearPolar_Mat_src_Mat_dst_Point2f_center_double_maxRadius_int_flags(void* src, void* dst, Point2fWrapper center, double maxRadius, int flags) {
    try {
        cv::linearPolar(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst), *reinterpret_cast<cv::Point2f*>(&center), maxRadius, flags);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_loadWindowParameters_String_windowName
// parsed: cv::loadWindowParameters
// as:     cv::loadWindowParameters (function)
// Arg ARG string windowName= string = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_loadWindowParameters_String_windowName(const char* windowName) {
    try {
        cv::loadWindowParameters(String(windowName));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_logPolar_Mat_src_Mat_dst_Point2f_center_double_M_int_flags
// parsed: cv::logPolar
// as:     cv::logPolar (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG cv::Point2f (simple) center= cv::Point2f (simple) = 
// Arg ARG Primitive(double) M= Primitive(double) = 
// Arg ARG Primitive(int) flags= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_logPolar_Mat_src_Mat_dst_Point2f_center_double_M_int_flags(void* src, void* dst, Point2fWrapper center, double M, int flags) {
    try {
        cv::logPolar(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst), *reinterpret_cast<cv::Point2f*>(&center), M, flags);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_log_Mat_src_Mat_dst
// parsed: cv::log
// as:     cv::log (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_log_Mat_src_Mat_dst(void* src, void* dst) {
    try {
        cv::log(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_log_softdouble_a
// parsed: cv::log
// as:     cv::log (function)
// Arg ARG cv::softdouble (boxed) a= cv::softdouble (boxed) = 
// Return value: cv::softdouble (boxed)
cv_return_value_void_X cv_core_cv_log_softdouble_a(void* a) {
    try {
        cv::softdouble ret = cv::log(*reinterpret_cast<cv::softdouble*>(a));
        return { Error::Code::StsOk, NULL, new cv::softdouble(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_log_softfloat_a
// parsed: cv::log
// as:     cv::log (function)
// Arg ARG cv::softfloat (boxed) a= cv::softfloat (boxed) = 
// Return value: cv::softfloat (boxed)
cv_return_value_void_X cv_core_cv_log_softfloat_a(void* a) {
    try {
        cv::softfloat ret = cv::log(*reinterpret_cast<cv::softfloat*>(a));
        return { Error::Code::StsOk, NULL, new cv::softfloat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_magnitude_Mat_x_Mat_y_Mat_magnitude
// parsed: cv::magnitude
// as:     cv::magnitude (function)
// Arg ARG cv::Mat (boxed) x= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) y= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) magnitude= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_magnitude_Mat_x_Mat_y_Mat_magnitude(void* x, void* y, void* magnitude) {
    try {
        cv::magnitude(*reinterpret_cast<cv::Mat*>(x), *reinterpret_cast<cv::Mat*>(y), *reinterpret_cast<cv::Mat*>(magnitude));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_matMulDeriv_Mat_A_Mat_B_Mat_dABdA_Mat_dABdB
// parsed: cv::matMulDeriv
// as:     cv::matMulDeriv (function)
// Arg ARG cv::Mat (boxed) A= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) B= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dABdA= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dABdB= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_matMulDeriv_Mat_A_Mat_B_Mat_dABdA_Mat_dABdB(void* A, void* B, void* dABdA, void* dABdB) {
    try {
        cv::matMulDeriv(*reinterpret_cast<cv::Mat*>(A), *reinterpret_cast<cv::Mat*>(B), *reinterpret_cast<cv::Mat*>(dABdA), *reinterpret_cast<cv::Mat*>(dABdB));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_matchShapes_Mat_contour1_Mat_contour2_int_method_double_parameter
// parsed: cv::matchShapes
// as:     cv::matchShapes (function)
// Arg ARG cv::Mat (boxed) contour1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) contour2= cv::Mat (boxed) = 
// Arg ARG Primitive(int) method= Primitive(int) = 
// Arg ARG Primitive(double) parameter= Primitive(double) = 
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_matchShapes_Mat_contour1_Mat_contour2_int_method_double_parameter(void* contour1, void* contour2, int method, double parameter) {
    try {
        double ret = cv::matchShapes(*reinterpret_cast<cv::Mat*>(contour1), *reinterpret_cast<cv::Mat*>(contour2), method, parameter);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_matchTemplate_Mat_image_Mat_templ_Mat_result_int_method_Mat_mask
// parsed: cv::matchTemplate
// as:     cv::matchTemplate (function)
// Arg ARG cv::Mat (boxed) image= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) templ= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) result= cv::Mat (boxed) = 
// Arg ARG Primitive(int) method= Primitive(int) = 
// Arg ARG cv::Mat (boxed) mask= cv::Mat (boxed) = noArray()
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_matchTemplate_Mat_image_Mat_templ_Mat_result_int_method_Mat_mask(void* image, void* templ, void* result, int method, void* mask) {
    try {
        cv::matchTemplate(*reinterpret_cast<cv::Mat*>(image), *reinterpret_cast<cv::Mat*>(templ), *reinterpret_cast<cv::Mat*>(result), method, *reinterpret_cast<cv::Mat*>(mask));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_max_Mat_src1_Mat_src2_Mat_dst
// parsed: cv::max
// as:     cv::max (function)
// Arg ARG cv::Mat (boxed) src1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) src2= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_max_Mat_src1_Mat_src2_Mat_dst(void* src1, void* src2, void* dst) {
    try {
        cv::max(*reinterpret_cast<cv::Mat*>(src1), *reinterpret_cast<cv::Mat*>(src2), *reinterpret_cast<cv::Mat*>(dst));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_max_softdouble_a_softdouble_b
// parsed: cv::max
// as:     cv::max (function)
// Arg ARG cv::softdouble (boxed) a= cv::softdouble (boxed) = 
// Arg ARG cv::softdouble (boxed) b= cv::softdouble (boxed) = 
// Return value: cv::softdouble (boxed)
cv_return_value_void_X cv_core_cv_max_softdouble_a_softdouble_b(void* a, void* b) {
    try {
        cv::softdouble ret = cv::max(*reinterpret_cast<cv::softdouble*>(a), *reinterpret_cast<cv::softdouble*>(b));
        return { Error::Code::StsOk, NULL, new cv::softdouble(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_max_softfloat_a_softfloat_b
// parsed: cv::max
// as:     cv::max (function)
// Arg ARG cv::softfloat (boxed) a= cv::softfloat (boxed) = 
// Arg ARG cv::softfloat (boxed) b= cv::softfloat (boxed) = 
// Return value: cv::softfloat (boxed)
cv_return_value_void_X cv_core_cv_max_softfloat_a_softfloat_b(void* a, void* b) {
    try {
        cv::softfloat ret = cv::max(*reinterpret_cast<cv::softfloat*>(a), *reinterpret_cast<cv::softfloat*>(b));
        return { Error::Code::StsOk, NULL, new cv::softfloat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_meanShift_Mat_probImage_Rect_window_TermCriteria_criteria
// parsed: cv::meanShift
// as:     cv::meanShift (function)
// Arg ARG cv::Mat (boxed) probImage= cv::Mat (boxed) = 
// Arg ARG cv::Rect (simple) window= cv::Rect (simple) = 
// Arg ARG cv::TermCriteria (boxed) criteria= cv::TermCriteria (boxed) = 
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_meanShift_Mat_probImage_Rect_window_TermCriteria_criteria(void* probImage, RectWrapper window, void* criteria) {
    try {
        int ret = cv::meanShift(*reinterpret_cast<cv::Mat*>(probImage), *reinterpret_cast<cv::Rect*>(&window), *reinterpret_cast<cv::TermCriteria*>(criteria));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_meanStdDev_Mat_src_Mat_mean_Mat_stddev_Mat_mask
// parsed: cv::meanStdDev
// as:     cv::meanStdDev (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) mean= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) stddev= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) mask= cv::Mat (boxed) = noArray()
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_meanStdDev_Mat_src_Mat_mean_Mat_stddev_Mat_mask(void* src, void* mean, void* stddev, void* mask) {
    try {
        cv::meanStdDev(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(mean), *reinterpret_cast<cv::Mat*>(stddev), *reinterpret_cast<cv::Mat*>(mask));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_mean_Mat_src_Mat_mask
// parsed: cv::mean
// as:     cv::mean (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) mask= cv::Mat (boxed) = noArray()
// Return value: cv::Scalar (simple)
cv_return_value_ScalarWrapper cv_core_cv_mean_Mat_src_Mat_mask(void* src, void* mask) {
    try {
        cv::Scalar ret = cv::mean(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(mask));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<ScalarWrapper*>(&ret) };
    } CVRS_CATCH(cv_return_value_ScalarWrapper)
}

// cv_medianBlur_Mat_src_Mat_dst_int_ksize
// parsed: cv::medianBlur
// as:     cv::medianBlur (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG Primitive(int) ksize= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_medianBlur_Mat_src_Mat_dst_int_ksize(void* src, void* dst, int ksize) {
    try {
        cv::medianBlur(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst), ksize);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_merge_VectorOfMat_mv_Mat_dst
// parsed: cv::merge
// as:     cv::merge (function)
// Arg ARG Vector[cv::Mat (boxed)] mv= Vector[cv::Mat (boxed)] = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_merge_VectorOfMat_mv_Mat_dst(void* mv, void* dst) {
    try {
        cv::merge(*reinterpret_cast<std::vector<cv::Mat>*>(mv), *reinterpret_cast<cv::Mat*>(dst));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_merge_const_Mat_mv_size_t_count_Mat_dst
// parsed: cv::merge
// as:     cv::merge (function)
// Arg ARG RawPtr[cv::Mat (boxed)] * mv= (ptr) RawPtr[cv::Mat (boxed)] = 
// Arg ARG Primitive(size_t) count= Primitive(size_t) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_merge_const_Mat_mv_size_t_count_Mat_dst(const void* mv, std::size_t count, void* dst) {
    try {
        cv::merge(reinterpret_cast<const cv::Mat*>(mv), count, *reinterpret_cast<cv::Mat*>(dst));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_minAreaRect_Mat_points
// parsed: cv::minAreaRect
// as:     cv::minAreaRect (function)
// Arg ARG cv::Mat (boxed) points= cv::Mat (boxed) = 
// Return value: cv::RotatedRect (boxed)
cv_return_value_void_X cv_core_cv_minAreaRect_Mat_points(void* points) {
    try {
        cv::RotatedRect ret = cv::minAreaRect(*reinterpret_cast<cv::Mat*>(points));
        return { Error::Code::StsOk, NULL, new cv::RotatedRect(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_minEnclosingCircle_Mat_points_Point2f_center_float_radius
// parsed: cv::minEnclosingCircle
// as:     cv::minEnclosingCircle (function)
// Arg ARG cv::Mat (boxed) points= cv::Mat (boxed) = 
// Arg ARG cv::Point2f (simple) center= cv::Point2f (simple) = 
// Arg ARG Primitive(float) radius= Primitive(float) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_minEnclosingCircle_Mat_points_Point2f_center_float_radius(void* points, Point2fWrapper center, float radius) {
    try {
        cv::minEnclosingCircle(*reinterpret_cast<cv::Mat*>(points), *reinterpret_cast<cv::Point2f*>(&center), radius);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_minEnclosingTriangle_Mat_points_Mat_triangle
// parsed: cv::minEnclosingTriangle
// as:     cv::minEnclosingTriangle (function)
// Arg ARG cv::Mat (boxed) points= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) triangle= cv::Mat (boxed) = 
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_minEnclosingTriangle_Mat_points_Mat_triangle(void* points, void* triangle) {
    try {
        double ret = cv::minEnclosingTriangle(*reinterpret_cast<cv::Mat*>(points), *reinterpret_cast<cv::Mat*>(triangle));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_minMaxIdx_Mat_src_double_X_minVal_double_X_maxVal_int_X_minIdx_int_X_maxIdx_Mat_mask
// parsed: cv::minMaxIdx
// as:     cv::minMaxIdx (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG RawPtr[Primitive(double)] * minVal= (ptr) RawPtr[Primitive(double)] = 
// Arg ARG RawPtr[Primitive(double)] * maxVal= (ptr) RawPtr[Primitive(double)] = 0
// Arg ARG RawPtr[Primitive(int)] * minIdx= (ptr) RawPtr[Primitive(int)] = 0
// Arg ARG RawPtr[Primitive(int)] * maxIdx= (ptr) RawPtr[Primitive(int)] = 0
// Arg ARG cv::Mat (boxed) mask= cv::Mat (boxed) = noArray()
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_minMaxIdx_Mat_src_double_X_minVal_double_X_maxVal_int_X_minIdx_int_X_maxIdx_Mat_mask(void* src, double* minVal, double* maxVal, int* minIdx, int* maxIdx, void* mask) {
    try {
        cv::minMaxIdx(*reinterpret_cast<cv::Mat*>(src), minVal, maxVal, minIdx, maxIdx, *reinterpret_cast<cv::Mat*>(mask));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_minMaxLoc_Mat_src_double_X_minVal_double_X_maxVal_Point_X_minLoc_Point_X_maxLoc_Mat_mask
// parsed: cv::minMaxLoc
// as:     cv::minMaxLoc (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG RawPtr[Primitive(double)] * minVal= (ptr) RawPtr[Primitive(double)] = 
// Arg ARG RawPtr[Primitive(double)] * maxVal= (ptr) RawPtr[Primitive(double)] = 0
// Arg ARG RawPtr[cv::Point (simple)] * minLoc= (ptr) RawPtr[cv::Point (simple)] = 0
// Arg ARG RawPtr[cv::Point (simple)] * maxLoc= (ptr) RawPtr[cv::Point (simple)] = 0
// Arg ARG cv::Mat (boxed) mask= cv::Mat (boxed) = noArray()
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_minMaxLoc_Mat_src_double_X_minVal_double_X_maxVal_Point_X_minLoc_Point_X_maxLoc_Mat_mask(void* src, double* minVal, double* maxVal, cv::Point* minLoc, cv::Point* maxLoc, void* mask) {
    try {
        cv::minMaxLoc(*reinterpret_cast<cv::Mat*>(src), minVal, maxVal, reinterpret_cast<cv::Point*>(&minLoc), reinterpret_cast<cv::Point*>(&maxLoc), *reinterpret_cast<cv::Mat*>(mask));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_min_Mat_src1_Mat_src2_Mat_dst
// parsed: cv::min
// as:     cv::min (function)
// Arg ARG cv::Mat (boxed) src1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) src2= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_min_Mat_src1_Mat_src2_Mat_dst(void* src1, void* src2, void* dst) {
    try {
        cv::min(*reinterpret_cast<cv::Mat*>(src1), *reinterpret_cast<cv::Mat*>(src2), *reinterpret_cast<cv::Mat*>(dst));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_min_softdouble_a_softdouble_b
// parsed: cv::min
// as:     cv::min (function)
// Arg ARG cv::softdouble (boxed) a= cv::softdouble (boxed) = 
// Arg ARG cv::softdouble (boxed) b= cv::softdouble (boxed) = 
// Return value: cv::softdouble (boxed)
cv_return_value_void_X cv_core_cv_min_softdouble_a_softdouble_b(void* a, void* b) {
    try {
        cv::softdouble ret = cv::min(*reinterpret_cast<cv::softdouble*>(a), *reinterpret_cast<cv::softdouble*>(b));
        return { Error::Code::StsOk, NULL, new cv::softdouble(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_min_softfloat_a_softfloat_b
// parsed: cv::min
// as:     cv::min (function)
// Arg ARG cv::softfloat (boxed) a= cv::softfloat (boxed) = 
// Arg ARG cv::softfloat (boxed) b= cv::softfloat (boxed) = 
// Return value: cv::softfloat (boxed)
cv_return_value_void_X cv_core_cv_min_softfloat_a_softfloat_b(void* a, void* b) {
    try {
        cv::softfloat ret = cv::min(*reinterpret_cast<cv::softfloat*>(a), *reinterpret_cast<cv::softfloat*>(b));
        return { Error::Code::StsOk, NULL, new cv::softfloat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_mixChannels_VectorOfMat_src_VectorOfMat_dst_VectorOfint_fromTo
// parsed: cv::mixChannels
// as:     cv::mixChannels (function)
// Arg ARG Vector[cv::Mat (boxed)] src= Vector[cv::Mat (boxed)] = 
// Arg ARG Vector[cv::Mat (boxed)] dst= Vector[cv::Mat (boxed)] = 
// Arg ARG Vector[Primitive(int)] fromTo= Vector[Primitive(int)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_mixChannels_VectorOfMat_src_VectorOfMat_dst_VectorOfint_fromTo(void* src, void** dst, void* fromTo) {
    try {
        cv::mixChannels(*reinterpret_cast<std::vector<cv::Mat>*>(src), *reinterpret_cast<std::vector<cv::Mat>*>(dst), *reinterpret_cast<std::vector<int>*>(fromTo));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_mixChannels_VectorOfMat_src_VectorOfMat_dst_const_int_X_fromTo_size_t_npairs
// parsed: cv::mixChannels
// as:     cv::mixChannels (function)
// Arg ARG Vector[cv::Mat (boxed)] src= Vector[cv::Mat (boxed)] = 
// Arg ARG Vector[cv::Mat (boxed)] dst= Vector[cv::Mat (boxed)] = 
// Arg ARG RawPtr[Primitive(int)] * fromTo= (ptr) RawPtr[Primitive(int)] = 
// Arg ARG Primitive(size_t) npairs= Primitive(size_t) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_mixChannels_VectorOfMat_src_VectorOfMat_dst_const_int_X_fromTo_size_t_npairs(void* src, void** dst, const int* fromTo, std::size_t npairs) {
    try {
        cv::mixChannels(*reinterpret_cast<std::vector<cv::Mat>*>(src), *reinterpret_cast<std::vector<cv::Mat>*>(dst), fromTo, npairs);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_mixChannels_const_Mat_src_size_t_nsrcs_Mat_dst_size_t_ndsts_const_int_X_fromTo_size_t_npairs
// parsed: cv::mixChannels
// as:     cv::mixChannels (function)
// Arg ARG RawPtr[cv::Mat (boxed)] * src= (ptr) RawPtr[cv::Mat (boxed)] = 
// Arg ARG Primitive(size_t) nsrcs= Primitive(size_t) = 
// Arg ARG RawPtr[cv::Mat (boxed)] * dst= (ptr) RawPtr[cv::Mat (boxed)] = 
// Arg ARG Primitive(size_t) ndsts= Primitive(size_t) = 
// Arg ARG RawPtr[Primitive(int)] * fromTo= (ptr) RawPtr[Primitive(int)] = 
// Arg ARG Primitive(size_t) npairs= Primitive(size_t) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_mixChannels_const_Mat_src_size_t_nsrcs_Mat_dst_size_t_ndsts_const_int_X_fromTo_size_t_npairs(const void* src, std::size_t nsrcs, void* dst, std::size_t ndsts, const int* fromTo, std::size_t npairs) {
    try {
        cv::mixChannels(reinterpret_cast<const cv::Mat*>(src), nsrcs, reinterpret_cast<cv::Mat*>(dst), ndsts, fromTo, npairs);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ml_createConcentricSpheresTestSet_int_nsamples_int_nfeatures_int_nclasses_Mat_samples_Mat_responses
// parsed: cv::ml::createConcentricSpheresTestSet
// as:     cv::ml::createConcentricSpheresTestSet (function)
// Arg ARG Primitive(int) nsamples= Primitive(int) = 
// Arg ARG Primitive(int) nfeatures= Primitive(int) = 
// Arg ARG Primitive(int) nclasses= Primitive(int) = 
// Arg ARG cv::Mat (boxed) samples= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) responses= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ml_createConcentricSpheresTestSet_int_nsamples_int_nfeatures_int_nclasses_Mat_samples_Mat_responses(int nsamples, int nfeatures, int nclasses, void* samples, void* responses) {
    try {
        cv::ml::createConcentricSpheresTestSet(nsamples, nfeatures, nclasses, *reinterpret_cast<cv::Mat*>(samples), *reinterpret_cast<cv::Mat*>(responses));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ml_randMVNormal_Mat_mean_Mat_cov_int_nsamples_Mat_samples
// parsed: cv::ml::randMVNormal
// as:     cv::ml::randMVNormal (function)
// Arg ARG cv::Mat (boxed) mean= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) cov= cv::Mat (boxed) = 
// Arg ARG Primitive(int) nsamples= Primitive(int) = 
// Arg ARG cv::Mat (boxed) samples= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ml_randMVNormal_Mat_mean_Mat_cov_int_nsamples_Mat_samples(void* mean, void* cov, int nsamples, void* samples) {
    try {
        cv::ml::randMVNormal(*reinterpret_cast<cv::Mat*>(mean), *reinterpret_cast<cv::Mat*>(cov), nsamples, *reinterpret_cast<cv::Mat*>(samples));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_moments_Mat_array_bool_binaryImage
// parsed: cv::moments
// as:     cv::moments (function)
// Arg ARG cv::Mat (boxed) array= cv::Mat (boxed) = 
// Arg ARG Primitive(bool) binaryImage= Primitive(bool) = false
// Return value: cv::Moments (simple)
cv_return_value_Moments cv_core_cv_moments_Mat_array_bool_binaryImage(void* array, bool binaryImage) {
    try {
        cv::Moments ret = cv::moments(*reinterpret_cast<cv::Mat*>(array), binaryImage);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<cv::Moments*>(&ret) };
    } CVRS_CATCH(cv_return_value_Moments)
}

// cv_morphologyDefaultBorderValue
// parsed: cv::morphologyDefaultBorderValue
// as:     cv::morphologyDefaultBorderValue (function)
// Return value: cv::Scalar (simple)
cv_return_value_ScalarWrapper cv_core_cv_morphologyDefaultBorderValue() {
    try {
        cv::Scalar ret = cv::morphologyDefaultBorderValue();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<ScalarWrapper*>(&ret) };
    } CVRS_CATCH(cv_return_value_ScalarWrapper)
}

// cv_morphologyEx_Mat_src_Mat_dst_int_op_Mat_kernel_Point_anchor_int_iterations_int_borderType_Scalar_borderValue
// parsed: cv::morphologyEx
// as:     cv::morphologyEx (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG Primitive(int) op= Primitive(int) = 
// Arg ARG cv::Mat (boxed) kernel= cv::Mat (boxed) = 
// Arg ARG cv::Point (simple) anchor= cv::Point (simple) = Point(-1,-1)
// Arg ARG Primitive(int) iterations= Primitive(int) = 1
// Arg ARG Primitive(int) borderType= Primitive(int) = BORDER_CONSTANT
// Arg ARG cv::Scalar (simple) borderValue= cv::Scalar (simple) = morphologyDefaultBorderValue()
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_morphologyEx_Mat_src_Mat_dst_int_op_Mat_kernel_Point_anchor_int_iterations_int_borderType_Scalar_borderValue(void* src, void* dst, int op, void* kernel, PointWrapper anchor, int iterations, int borderType, ScalarWrapper borderValue) {
    try {
        cv::morphologyEx(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst), op, *reinterpret_cast<cv::Mat*>(kernel), *reinterpret_cast<cv::Point*>(&anchor), iterations, borderType, *reinterpret_cast<cv::Scalar*>(&borderValue));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_moveWindow_String_winname_int_x_int_y
// parsed: cv::moveWindow
// as:     cv::moveWindow (function)
// Arg ARG string winname= string = 
// Arg ARG Primitive(int) x= Primitive(int) = 
// Arg ARG Primitive(int) y= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_moveWindow_String_winname_int_x_int_y(const char* winname, int x, int y) {
    try {
        cv::moveWindow(String(winname), x, y);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_mulAdd_softdouble_a_softdouble_b_softdouble_c
// parsed: cv::mulAdd
// as:     cv::mulAdd (function)
// Arg ARG cv::softdouble (boxed) a= cv::softdouble (boxed) = 
// Arg ARG cv::softdouble (boxed) b= cv::softdouble (boxed) = 
// Arg ARG cv::softdouble (boxed) c= cv::softdouble (boxed) = 
// Return value: cv::softdouble (boxed)
cv_return_value_void_X cv_core_cv_mulAdd_softdouble_a_softdouble_b_softdouble_c(void* a, void* b, void* c) {
    try {
        cv::softdouble ret = cv::mulAdd(*reinterpret_cast<cv::softdouble*>(a), *reinterpret_cast<cv::softdouble*>(b), *reinterpret_cast<cv::softdouble*>(c));
        return { Error::Code::StsOk, NULL, new cv::softdouble(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_mulAdd_softfloat_a_softfloat_b_softfloat_c
// parsed: cv::mulAdd
// as:     cv::mulAdd (function)
// Arg ARG cv::softfloat (boxed) a= cv::softfloat (boxed) = 
// Arg ARG cv::softfloat (boxed) b= cv::softfloat (boxed) = 
// Arg ARG cv::softfloat (boxed) c= cv::softfloat (boxed) = 
// Return value: cv::softfloat (boxed)
cv_return_value_void_X cv_core_cv_mulAdd_softfloat_a_softfloat_b_softfloat_c(void* a, void* b, void* c) {
    try {
        cv::softfloat ret = cv::mulAdd(*reinterpret_cast<cv::softfloat*>(a), *reinterpret_cast<cv::softfloat*>(b), *reinterpret_cast<cv::softfloat*>(c));
        return { Error::Code::StsOk, NULL, new cv::softfloat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_mulSpectrums_Mat_a_Mat_b_Mat_c_int_flags_bool_conjB
// parsed: cv::mulSpectrums
// as:     cv::mulSpectrums (function)
// Arg ARG cv::Mat (boxed) a= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) b= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) c= cv::Mat (boxed) = 
// Arg ARG Primitive(int) flags= Primitive(int) = 
// Arg ARG Primitive(bool) conjB= Primitive(bool) = false
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_mulSpectrums_Mat_a_Mat_b_Mat_c_int_flags_bool_conjB(void* a, void* b, void* c, int flags, bool conjB) {
    try {
        cv::mulSpectrums(*reinterpret_cast<cv::Mat*>(a), *reinterpret_cast<cv::Mat*>(b), *reinterpret_cast<cv::Mat*>(c), flags, conjB);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_mulTransposed_Mat_src_Mat_dst_bool_aTa_Mat_delta_double_scale_int_dtype
// parsed: cv::mulTransposed
// as:     cv::mulTransposed (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG Primitive(bool) aTa= Primitive(bool) = 
// Arg ARG cv::Mat (boxed) delta= cv::Mat (boxed) = noArray()
// Arg ARG Primitive(double) scale= Primitive(double) = 1
// Arg ARG Primitive(int) dtype= Primitive(int) = -1
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_mulTransposed_Mat_src_Mat_dst_bool_aTa_Mat_delta_double_scale_int_dtype(void* src, void* dst, bool aTa, void* delta, double scale, int dtype) {
    try {
        cv::mulTransposed(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst), aTa, *reinterpret_cast<cv::Mat*>(delta), scale, dtype);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_multiply_Mat_src1_Mat_src2_Mat_dst_double_scale_int_dtype
// parsed: cv::multiply
// as:     cv::multiply (function)
// Arg ARG cv::Mat (boxed) src1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) src2= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG Primitive(double) scale= Primitive(double) = 1
// Arg ARG Primitive(int) dtype= Primitive(int) = -1
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_multiply_Mat_src1_Mat_src2_Mat_dst_double_scale_int_dtype(void* src1, void* src2, void* dst, double scale, int dtype) {
    try {
        cv::multiply(*reinterpret_cast<cv::Mat*>(src1), *reinterpret_cast<cv::Mat*>(src2), *reinterpret_cast<cv::Mat*>(dst), scale, dtype);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_namedWindow_String_winname_int_flags
// parsed: cv::namedWindow
// as:     cv::namedWindow (function)
// Arg ARG string winname= string = 
// Arg ARG Primitive(int) flags= Primitive(int) = WINDOW_AUTOSIZE
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_namedWindow_String_winname_int_flags(const char* winname, int flags) {
    try {
        cv::namedWindow(String(winname), flags);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_normL1_const_float_X_a_const_float_X_b_int_n
// parsed: cv::normL1
// as:     cv::normL1 (function)
// Arg ARG RawPtr[Primitive(float)] * a= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG RawPtr[Primitive(float)] * b= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG Primitive(int) n= Primitive(int) = 
// Return value: Primitive(float)
cv_return_value_float cv_core_cv_normL1_const_float_X_a_const_float_X_b_int_n(const float* a, const float* b, int n) {
    try {
        float ret = cv::normL1(a, b, n);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<float*>(&ret) };
    } CVRS_CATCH(cv_return_value_float)
}

// cv_normL1_const_uchar_X_a_const_uchar_X_b_int_n
// parsed: cv::normL1
// as:     cv::normL1 (function)
// Arg ARG RawPtr[Primitive(uchar)] * a= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG RawPtr[Primitive(uchar)] * b= (ptr) RawPtr[Primitive(uchar)] = 
// Arg ARG Primitive(int) n= Primitive(int) = 
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_normL1_const_uchar_X_a_const_uchar_X_b_int_n(const uchar* a, const uchar* b, int n) {
    try {
        int ret = cv::normL1(a, b, n);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_normL2Sqr_const_float_X_a_const_float_X_b_int_n
// parsed: cv::normL2Sqr
// as:     cv::normL2Sqr (function)
// Arg ARG RawPtr[Primitive(float)] * a= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG RawPtr[Primitive(float)] * b= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG Primitive(int) n= Primitive(int) = 
// Return value: Primitive(float)
cv_return_value_float cv_core_cv_normL2Sqr_const_float_X_a_const_float_X_b_int_n(const float* a, const float* b, int n) {
    try {
        float ret = cv::normL2Sqr(a, b, n);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<float*>(&ret) };
    } CVRS_CATCH(cv_return_value_float)
}

// cv_norm_Mat_src1_Mat_src2_int_normType_Mat_mask
// parsed: cv::norm
// as:     cv::norm (function)
// Arg ARG cv::Mat (boxed) src1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) src2= cv::Mat (boxed) = 
// Arg ARG Primitive(int) normType= Primitive(int) = NORM_L2
// Arg ARG cv::Mat (boxed) mask= cv::Mat (boxed) = noArray()
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_norm_Mat_src1_Mat_src2_int_normType_Mat_mask(void* src1, void* src2, int normType, void* mask) {
    try {
        double ret = cv::norm(*reinterpret_cast<cv::Mat*>(src1), *reinterpret_cast<cv::Mat*>(src2), normType, *reinterpret_cast<cv::Mat*>(mask));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_norm_Mat_src1_int_normType_Mat_mask
// parsed: cv::norm
// as:     cv::norm (function)
// Arg ARG cv::Mat (boxed) src1= cv::Mat (boxed) = 
// Arg ARG Primitive(int) normType= Primitive(int) = NORM_L2
// Arg ARG cv::Mat (boxed) mask= cv::Mat (boxed) = noArray()
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_norm_Mat_src1_int_normType_Mat_mask(void* src1, int normType, void* mask) {
    try {
        double ret = cv::norm(*reinterpret_cast<cv::Mat*>(src1), normType, *reinterpret_cast<cv::Mat*>(mask));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_normalize_Mat_src_Mat_dst_double_alpha_double_beta_int_norm_type_int_dtype_Mat_mask
// parsed: cv::normalize
// as:     cv::normalize (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG Primitive(double) alpha= Primitive(double) = 1
// Arg ARG Primitive(double) beta= Primitive(double) = 0
// Arg ARG Primitive(int) norm_type= Primitive(int) = NORM_L2
// Arg ARG Primitive(int) dtype= Primitive(int) = -1
// Arg ARG cv::Mat (boxed) mask= cv::Mat (boxed) = noArray()
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_normalize_Mat_src_Mat_dst_double_alpha_double_beta_int_norm_type_int_dtype_Mat_mask(void* src, void* dst, double alpha, double beta, int norm_type, int dtype, void* mask) {
    try {
        cv::normalize(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst), alpha, beta, norm_type, dtype, *reinterpret_cast<cv::Mat*>(mask));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_parallel_for__Range_range_ParallelLoopBody_body_double_nstripes
// parsed: cv::parallel_for_
// as:     cv::parallel_for_ (function)
// Arg ARG cv::Range (boxed) range= cv::Range (boxed) = 
// Arg ARG cv::ParallelLoopBody (boxed) body= cv::ParallelLoopBody (boxed) = 
// Arg ARG Primitive(double) nstripes= Primitive(double) = -1.
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_parallel_for__Range_range_ParallelLoopBody_body_double_nstripes(void* range, void* body, double nstripes) {
    try {
        cv::parallel_for_(*reinterpret_cast<cv::Range*>(range), *reinterpret_cast<cv::ParallelLoopBody*>(body), nstripes);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_patchNaNs_Mat_a_double_val
// parsed: cv::patchNaNs
// as:     cv::patchNaNs (function)
// Arg ARG cv::Mat (boxed) a= cv::Mat (boxed) = 
// Arg ARG Primitive(double) val= Primitive(double) = 0
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_patchNaNs_Mat_a_double_val(void* a, double val) {
    try {
        cv::patchNaNs(*reinterpret_cast<cv::Mat*>(a), val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_pencilSketch_Mat_src_Mat_dst1_Mat_dst2_float_sigma_s_float_sigma_r_float_shade_factor
// parsed: cv::pencilSketch
// as:     cv::pencilSketch (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst2= cv::Mat (boxed) = 
// Arg ARG Primitive(float) sigma_s= Primitive(float) = 60
// Arg ARG Primitive(float) sigma_r= Primitive(float) = 0.07f
// Arg ARG Primitive(float) shade_factor= Primitive(float) = 0.02f
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_pencilSketch_Mat_src_Mat_dst1_Mat_dst2_float_sigma_s_float_sigma_r_float_shade_factor(void* src, void* dst1, void* dst2, float sigma_s, float sigma_r, float shade_factor) {
    try {
        cv::pencilSketch(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst1), *reinterpret_cast<cv::Mat*>(dst2), sigma_s, sigma_r, shade_factor);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_perspectiveTransform_Mat_src_Mat_dst_Mat_m
// parsed: cv::perspectiveTransform
// as:     cv::perspectiveTransform (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) m= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_perspectiveTransform_Mat_src_Mat_dst_Mat_m(void* src, void* dst, void* m) {
    try {
        cv::perspectiveTransform(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst), *reinterpret_cast<cv::Mat*>(m));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_phaseCorrelate_Mat_src1_Mat_src2_Mat_window_double_X_response
// parsed: cv::phaseCorrelate
// as:     cv::phaseCorrelate (function)
// Arg ARG cv::Mat (boxed) src1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) src2= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) window= cv::Mat (boxed) = noArray()
// Arg ARG RawPtr[Primitive(double)] * response= (ptr) RawPtr[Primitive(double)] = 0
// Return value: cv::Point2d (simple)
cv_return_value_Point2dWrapper cv_core_cv_phaseCorrelate_Mat_src1_Mat_src2_Mat_window_double_X_response(void* src1, void* src2, void* window, double* response) {
    try {
        cv::Point2d ret = cv::phaseCorrelate(*reinterpret_cast<cv::Mat*>(src1), *reinterpret_cast<cv::Mat*>(src2), *reinterpret_cast<cv::Mat*>(window), response);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<Point2dWrapper*>(&ret) };
    } CVRS_CATCH(cv_return_value_Point2dWrapper)
}

// cv_phase_Mat_x_Mat_y_Mat_angle_bool_angleInDegrees
// parsed: cv::phase
// as:     cv::phase (function)
// Arg ARG cv::Mat (boxed) x= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) y= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) angle= cv::Mat (boxed) = 
// Arg ARG Primitive(bool) angleInDegrees= Primitive(bool) = false
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_phase_Mat_x_Mat_y_Mat_angle_bool_angleInDegrees(void* x, void* y, void* angle, bool angleInDegrees) {
    try {
        cv::phase(*reinterpret_cast<cv::Mat*>(x), *reinterpret_cast<cv::Mat*>(y), *reinterpret_cast<cv::Mat*>(angle), angleInDegrees);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_pointPolygonTest_Mat_contour_Point2f_pt_bool_measureDist
// parsed: cv::pointPolygonTest
// as:     cv::pointPolygonTest (function)
// Arg ARG cv::Mat (boxed) contour= cv::Mat (boxed) = 
// Arg ARG cv::Point2f (simple) pt= cv::Point2f (simple) = 
// Arg ARG Primitive(bool) measureDist= Primitive(bool) = 
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_pointPolygonTest_Mat_contour_Point2f_pt_bool_measureDist(void* contour, Point2fWrapper pt, bool measureDist) {
    try {
        double ret = cv::pointPolygonTest(*reinterpret_cast<cv::Mat*>(contour), *reinterpret_cast<cv::Point2f*>(&pt), measureDist);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_polarToCart_Mat_magnitude_Mat_angle_Mat_x_Mat_y_bool_angleInDegrees
// parsed: cv::polarToCart
// as:     cv::polarToCart (function)
// Arg ARG cv::Mat (boxed) magnitude= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) angle= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) x= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) y= cv::Mat (boxed) = 
// Arg ARG Primitive(bool) angleInDegrees= Primitive(bool) = false
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_polarToCart_Mat_magnitude_Mat_angle_Mat_x_Mat_y_bool_angleInDegrees(void* magnitude, void* angle, void* x, void* y, bool angleInDegrees) {
    try {
        cv::polarToCart(*reinterpret_cast<cv::Mat*>(magnitude), *reinterpret_cast<cv::Mat*>(angle), *reinterpret_cast<cv::Mat*>(x), *reinterpret_cast<cv::Mat*>(y), angleInDegrees);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_polylines_Mat_img_VectorOfMat_pts_bool_isClosed_Scalar_color_int_thickness_int_lineType_int_shift
// parsed: cv::polylines
// as:     cv::polylines (function)
// Arg ARG cv::Mat (boxed) img= cv::Mat (boxed) = 
// Arg ARG Vector[cv::Mat (boxed)] pts= Vector[cv::Mat (boxed)] = 
// Arg ARG Primitive(bool) isClosed= Primitive(bool) = 
// Arg ARG cv::Scalar (simple) color= cv::Scalar (simple) = 
// Arg ARG Primitive(int) thickness= Primitive(int) = 1
// Arg ARG Primitive(int) lineType= Primitive(int) = LINE_8
// Arg ARG Primitive(int) shift= Primitive(int) = 0
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_polylines_Mat_img_VectorOfMat_pts_bool_isClosed_Scalar_color_int_thickness_int_lineType_int_shift(void* img, void* pts, bool isClosed, ScalarWrapper color, int thickness, int lineType, int shift) {
    try {
        cv::polylines(*reinterpret_cast<cv::Mat*>(img), *reinterpret_cast<std::vector<cv::Mat>*>(pts), isClosed, *reinterpret_cast<cv::Scalar*>(&color), thickness, lineType, shift);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_pow_Mat_src_double_power_Mat_dst
// parsed: cv::pow
// as:     cv::pow (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG Primitive(double) power= Primitive(double) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_pow_Mat_src_double_power_Mat_dst(void* src, double power, void* dst) {
    try {
        cv::pow(*reinterpret_cast<cv::Mat*>(src), power, *reinterpret_cast<cv::Mat*>(dst));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_pow_softdouble_a_softdouble_b
// parsed: cv::pow
// as:     cv::pow (function)
// Arg ARG cv::softdouble (boxed) a= cv::softdouble (boxed) = 
// Arg ARG cv::softdouble (boxed) b= cv::softdouble (boxed) = 
// Return value: cv::softdouble (boxed)
cv_return_value_void_X cv_core_cv_pow_softdouble_a_softdouble_b(void* a, void* b) {
    try {
        cv::softdouble ret = cv::pow(*reinterpret_cast<cv::softdouble*>(a), *reinterpret_cast<cv::softdouble*>(b));
        return { Error::Code::StsOk, NULL, new cv::softdouble(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_pow_softfloat_a_softfloat_b
// parsed: cv::pow
// as:     cv::pow (function)
// Arg ARG cv::softfloat (boxed) a= cv::softfloat (boxed) = 
// Arg ARG cv::softfloat (boxed) b= cv::softfloat (boxed) = 
// Return value: cv::softfloat (boxed)
cv_return_value_void_X cv_core_cv_pow_softfloat_a_softfloat_b(void* a, void* b) {
    try {
        cv::softfloat ret = cv::pow(*reinterpret_cast<cv::softfloat*>(a), *reinterpret_cast<cv::softfloat*>(b));
        return { Error::Code::StsOk, NULL, new cv::softfloat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_preCornerDetect_Mat_src_Mat_dst_int_ksize_int_borderType
// parsed: cv::preCornerDetect
// as:     cv::preCornerDetect (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG Primitive(int) ksize= Primitive(int) = 
// Arg ARG Primitive(int) borderType= Primitive(int) = BORDER_DEFAULT
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_preCornerDetect_Mat_src_Mat_dst_int_ksize_int_borderType(void* src, void* dst, int ksize, int borderType) {
    try {
        cv::preCornerDetect(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst), ksize, borderType);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_projectPoints_Mat_objectPoints_Mat_rvec_Mat_tvec_Mat_cameraMatrix_Mat_distCoeffs_Mat_imagePoints_Mat_jacobian_double_aspectRatio
// parsed: cv::projectPoints
// as:     cv::projectPoints (function)
// Arg ARG cv::Mat (boxed) objectPoints= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) rvec= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) tvec= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) cameraMatrix= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) distCoeffs= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) imagePoints= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) jacobian= cv::Mat (boxed) = noArray()
// Arg ARG Primitive(double) aspectRatio= Primitive(double) = 0
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_projectPoints_Mat_objectPoints_Mat_rvec_Mat_tvec_Mat_cameraMatrix_Mat_distCoeffs_Mat_imagePoints_Mat_jacobian_double_aspectRatio(void* objectPoints, void* rvec, void* tvec, void* cameraMatrix, void* distCoeffs, void* imagePoints, void* jacobian, double aspectRatio) {
    try {
        cv::projectPoints(*reinterpret_cast<cv::Mat*>(objectPoints), *reinterpret_cast<cv::Mat*>(rvec), *reinterpret_cast<cv::Mat*>(tvec), *reinterpret_cast<cv::Mat*>(cameraMatrix), *reinterpret_cast<cv::Mat*>(distCoeffs), *reinterpret_cast<cv::Mat*>(imagePoints), *reinterpret_cast<cv::Mat*>(jacobian), aspectRatio);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_putText_Mat_img_String_text_Point_org_int_fontFace_double_fontScale_Scalar_color_int_thickness_int_lineType_bool_bottomLeftOrigin
// parsed: cv::putText
// as:     cv::putText (function)
// Arg ARG cv::Mat (boxed) img= cv::Mat (boxed) = 
// Arg ARG string text= string = 
// Arg ARG cv::Point (simple) org= cv::Point (simple) = 
// Arg ARG Primitive(int) fontFace= Primitive(int) = 
// Arg ARG Primitive(double) fontScale= Primitive(double) = 
// Arg ARG cv::Scalar (simple) color= cv::Scalar (simple) = 
// Arg ARG Primitive(int) thickness= Primitive(int) = 1
// Arg ARG Primitive(int) lineType= Primitive(int) = LINE_8
// Arg ARG Primitive(bool) bottomLeftOrigin= Primitive(bool) = false
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_putText_Mat_img_String_text_Point_org_int_fontFace_double_fontScale_Scalar_color_int_thickness_int_lineType_bool_bottomLeftOrigin(void* img, const char* text, PointWrapper org, int fontFace, double fontScale, ScalarWrapper color, int thickness, int lineType, bool bottomLeftOrigin) {
    try {
        cv::putText(*reinterpret_cast<cv::Mat*>(img), String(text), *reinterpret_cast<cv::Point*>(&org), fontFace, fontScale, *reinterpret_cast<cv::Scalar*>(&color), thickness, lineType, bottomLeftOrigin);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_pyrDown_Mat_src_Mat_dst_Size_dstsize_int_borderType
// parsed: cv::pyrDown
// as:     cv::pyrDown (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG cv::Size (simple) dstsize= cv::Size (simple) = Size()
// Arg ARG Primitive(int) borderType= Primitive(int) = BORDER_DEFAULT
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_pyrDown_Mat_src_Mat_dst_Size_dstsize_int_borderType(void* src, void* dst, SizeWrapper dstsize, int borderType) {
    try {
        cv::pyrDown(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst), *reinterpret_cast<cv::Size*>(&dstsize), borderType);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_pyrMeanShiftFiltering_Mat_src_Mat_dst_double_sp_double_sr_int_maxLevel_TermCriteria_termcrit
// parsed: cv::pyrMeanShiftFiltering
// as:     cv::pyrMeanShiftFiltering (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG Primitive(double) sp= Primitive(double) = 
// Arg ARG Primitive(double) sr= Primitive(double) = 
// Arg ARG Primitive(int) maxLevel= Primitive(int) = 1
// Arg ARG cv::TermCriteria (boxed) termcrit= cv::TermCriteria (boxed) = TermCriteria(TermCriteria::MAX_ITER+TermCriteria::EPS,5,1)
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_pyrMeanShiftFiltering_Mat_src_Mat_dst_double_sp_double_sr_int_maxLevel_TermCriteria_termcrit(void* src, void* dst, double sp, double sr, int maxLevel, void* termcrit) {
    try {
        cv::pyrMeanShiftFiltering(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst), sp, sr, maxLevel, *reinterpret_cast<cv::TermCriteria*>(termcrit));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_pyrUp_Mat_src_Mat_dst_Size_dstsize_int_borderType
// parsed: cv::pyrUp
// as:     cv::pyrUp (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG cv::Size (simple) dstsize= cv::Size (simple) = Size()
// Arg ARG Primitive(int) borderType= Primitive(int) = BORDER_DEFAULT
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_pyrUp_Mat_src_Mat_dst_Size_dstsize_int_borderType(void* src, void* dst, SizeWrapper dstsize, int borderType) {
    try {
        cv::pyrUp(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst), *reinterpret_cast<cv::Size*>(&dstsize), borderType);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_randn_Mat_dst_Mat_mean_Mat_stddev
// parsed: cv::randn
// as:     cv::randn (function)
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) mean= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) stddev= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_randn_Mat_dst_Mat_mean_Mat_stddev(void* dst, void* mean, void* stddev) {
    try {
        cv::randn(*reinterpret_cast<cv::Mat*>(dst), *reinterpret_cast<cv::Mat*>(mean), *reinterpret_cast<cv::Mat*>(stddev));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_randu_Mat_dst_Mat_low_Mat_high
// parsed: cv::randu
// as:     cv::randu (function)
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) low= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) high= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_randu_Mat_dst_Mat_low_Mat_high(void* dst, void* low, void* high) {
    try {
        cv::randu(*reinterpret_cast<cv::Mat*>(dst), *reinterpret_cast<cv::Mat*>(low), *reinterpret_cast<cv::Mat*>(high));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_recoverPose_Mat_E_Mat_points1_Mat_points2_Mat_R_Mat_t_double_focal_Point2d_pp_Mat_mask
// parsed: cv::recoverPose
// as:     cv::recoverPose (function)
// Arg ARG cv::Mat (boxed) E= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) points1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) points2= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) R= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) t= cv::Mat (boxed) = 
// Arg ARG Primitive(double) focal= Primitive(double) = 1.0
// Arg ARG cv::Point2d (simple) pp= cv::Point2d (simple) = Point2d(0, 0)
// Arg ARG cv::Mat (boxed) mask= cv::Mat (boxed) = noArray()
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_recoverPose_Mat_E_Mat_points1_Mat_points2_Mat_R_Mat_t_double_focal_Point2d_pp_Mat_mask(void* E, void* points1, void* points2, void* R, void* t, double focal, Point2dWrapper pp, void* mask) {
    try {
        int ret = cv::recoverPose(*reinterpret_cast<cv::Mat*>(E), *reinterpret_cast<cv::Mat*>(points1), *reinterpret_cast<cv::Mat*>(points2), *reinterpret_cast<cv::Mat*>(R), *reinterpret_cast<cv::Mat*>(t), focal, *reinterpret_cast<cv::Point2d*>(&pp), *reinterpret_cast<cv::Mat*>(mask));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_recoverPose_Mat_E_Mat_points1_Mat_points2_Mat_cameraMatrix_Mat_R_Mat_t_Mat_mask
// parsed: cv::recoverPose
// as:     cv::recoverPose (function)
// Arg ARG cv::Mat (boxed) E= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) points1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) points2= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) cameraMatrix= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) R= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) t= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) mask= cv::Mat (boxed) = noArray()
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_recoverPose_Mat_E_Mat_points1_Mat_points2_Mat_cameraMatrix_Mat_R_Mat_t_Mat_mask(void* E, void* points1, void* points2, void* cameraMatrix, void* R, void* t, void* mask) {
    try {
        int ret = cv::recoverPose(*reinterpret_cast<cv::Mat*>(E), *reinterpret_cast<cv::Mat*>(points1), *reinterpret_cast<cv::Mat*>(points2), *reinterpret_cast<cv::Mat*>(cameraMatrix), *reinterpret_cast<cv::Mat*>(R), *reinterpret_cast<cv::Mat*>(t), *reinterpret_cast<cv::Mat*>(mask));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_recoverPose_Mat_E_Mat_points1_Mat_points2_Mat_cameraMatrix_Mat_R_Mat_t_double_distanceThresh_Mat_mask_Mat_triangulatedPoints
// parsed: cv::recoverPose
// as:     cv::recoverPose (function)
// Arg ARG cv::Mat (boxed) E= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) points1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) points2= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) cameraMatrix= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) R= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) t= cv::Mat (boxed) = 
// Arg ARG Primitive(double) distanceThresh= Primitive(double) = 
// Arg ARG cv::Mat (boxed) mask= cv::Mat (boxed) = noArray()
// Arg ARG cv::Mat (boxed) triangulatedPoints= cv::Mat (boxed) = noArray()
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_recoverPose_Mat_E_Mat_points1_Mat_points2_Mat_cameraMatrix_Mat_R_Mat_t_double_distanceThresh_Mat_mask_Mat_triangulatedPoints(void* E, void* points1, void* points2, void* cameraMatrix, void* R, void* t, double distanceThresh, void* mask, void* triangulatedPoints) {
    try {
        int ret = cv::recoverPose(*reinterpret_cast<cv::Mat*>(E), *reinterpret_cast<cv::Mat*>(points1), *reinterpret_cast<cv::Mat*>(points2), *reinterpret_cast<cv::Mat*>(cameraMatrix), *reinterpret_cast<cv::Mat*>(R), *reinterpret_cast<cv::Mat*>(t), distanceThresh, *reinterpret_cast<cv::Mat*>(mask), *reinterpret_cast<cv::Mat*>(triangulatedPoints));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_rectangle_Mat_img_Point_pt1_Point_pt2_Scalar_color_int_thickness_int_lineType_int_shift
// parsed: cv::rectangle
// as:     cv::rectangle (function)
// Arg ARG cv::Mat (boxed) img= cv::Mat (boxed) = 
// Arg ARG cv::Point (simple) pt1= cv::Point (simple) = 
// Arg ARG cv::Point (simple) pt2= cv::Point (simple) = 
// Arg ARG cv::Scalar (simple) color= cv::Scalar (simple) = 
// Arg ARG Primitive(int) thickness= Primitive(int) = 1
// Arg ARG Primitive(int) lineType= Primitive(int) = LINE_8
// Arg ARG Primitive(int) shift= Primitive(int) = 0
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_rectangle_Mat_img_Point_pt1_Point_pt2_Scalar_color_int_thickness_int_lineType_int_shift(void* img, PointWrapper pt1, PointWrapper pt2, ScalarWrapper color, int thickness, int lineType, int shift) {
    try {
        cv::rectangle(*reinterpret_cast<cv::Mat*>(img), *reinterpret_cast<cv::Point*>(&pt1), *reinterpret_cast<cv::Point*>(&pt2), *reinterpret_cast<cv::Scalar*>(&color), thickness, lineType, shift);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_rectangle_Mat_img_Rect_rec_Scalar_color_int_thickness_int_lineType_int_shift
// parsed: cv::rectangle
// as:     cv::rectangle (function)
// Arg ARG cv::Mat (boxed) img= cv::Mat (boxed) = 
// Arg ARG cv::Rect (simple) rec= cv::Rect (simple) = 
// Arg ARG cv::Scalar (simple) color= cv::Scalar (simple) = 
// Arg ARG Primitive(int) thickness= Primitive(int) = 1
// Arg ARG Primitive(int) lineType= Primitive(int) = LINE_8
// Arg ARG Primitive(int) shift= Primitive(int) = 0
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_rectangle_Mat_img_Rect_rec_Scalar_color_int_thickness_int_lineType_int_shift(void* img, RectWrapper rec, ScalarWrapper color, int thickness, int lineType, int shift) {
    try {
        cv::rectangle(*reinterpret_cast<cv::Mat*>(img), *reinterpret_cast<cv::Rect*>(&rec), *reinterpret_cast<cv::Scalar*>(&color), thickness, lineType, shift);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_rectify3Collinear_Mat_cameraMatrix1_Mat_distCoeffs1_Mat_cameraMatrix2_Mat_distCoeffs2_Mat_cameraMatrix3_Mat_distCoeffs3_VectorOfMat_imgpt1_VectorOfMat_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_X_roi1_Rect_X_roi2_int_flags
// parsed: cv::rectify3Collinear
// as:     cv::rectify3Collinear (function)
// Arg ARG cv::Mat (boxed) cameraMatrix1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) distCoeffs1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) cameraMatrix2= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) distCoeffs2= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) cameraMatrix3= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) distCoeffs3= cv::Mat (boxed) = 
// Arg ARG Vector[cv::Mat (boxed)] imgpt1= Vector[cv::Mat (boxed)] = 
// Arg ARG Vector[cv::Mat (boxed)] imgpt3= Vector[cv::Mat (boxed)] = 
// Arg ARG cv::Size (simple) imageSize= cv::Size (simple) = 
// Arg ARG cv::Mat (boxed) R12= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) T12= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) R13= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) T13= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) R1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) R2= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) R3= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) P1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) P2= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) P3= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) Q= cv::Mat (boxed) = 
// Arg ARG Primitive(double) alpha= Primitive(double) = 
// Arg ARG cv::Size (simple) newImgSize= cv::Size (simple) = 
// Arg ARG RawPtr[cv::Rect (simple)] * roi1= (ptr) RawPtr[cv::Rect (simple)] = 
// Arg ARG RawPtr[cv::Rect (simple)] * roi2= (ptr) RawPtr[cv::Rect (simple)] = 
// Arg ARG Primitive(int) flags= Primitive(int) = 
// Return value: Primitive(float)
cv_return_value_float cv_core_cv_rectify3Collinear_Mat_cameraMatrix1_Mat_distCoeffs1_Mat_cameraMatrix2_Mat_distCoeffs2_Mat_cameraMatrix3_Mat_distCoeffs3_VectorOfMat_imgpt1_VectorOfMat_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_X_roi1_Rect_X_roi2_int_flags(void* cameraMatrix1, void* distCoeffs1, void* cameraMatrix2, void* distCoeffs2, void* cameraMatrix3, void* distCoeffs3, void* imgpt1, void* imgpt3, SizeWrapper imageSize, void* R12, void* T12, void* R13, void* T13, void* R1, void* R2, void* R3, void* P1, void* P2, void* P3, void* Q, double alpha, SizeWrapper newImgSize, cv::Rect* roi1, cv::Rect* roi2, int flags) {
    try {
        float ret = cv::rectify3Collinear(*reinterpret_cast<cv::Mat*>(cameraMatrix1), *reinterpret_cast<cv::Mat*>(distCoeffs1), *reinterpret_cast<cv::Mat*>(cameraMatrix2), *reinterpret_cast<cv::Mat*>(distCoeffs2), *reinterpret_cast<cv::Mat*>(cameraMatrix3), *reinterpret_cast<cv::Mat*>(distCoeffs3), *reinterpret_cast<std::vector<cv::Mat>*>(imgpt1), *reinterpret_cast<std::vector<cv::Mat>*>(imgpt3), *reinterpret_cast<cv::Size*>(&imageSize), *reinterpret_cast<cv::Mat*>(R12), *reinterpret_cast<cv::Mat*>(T12), *reinterpret_cast<cv::Mat*>(R13), *reinterpret_cast<cv::Mat*>(T13), *reinterpret_cast<cv::Mat*>(R1), *reinterpret_cast<cv::Mat*>(R2), *reinterpret_cast<cv::Mat*>(R3), *reinterpret_cast<cv::Mat*>(P1), *reinterpret_cast<cv::Mat*>(P2), *reinterpret_cast<cv::Mat*>(P3), *reinterpret_cast<cv::Mat*>(Q), alpha, *reinterpret_cast<cv::Size*>(&newImgSize), reinterpret_cast<cv::Rect*>(&roi1), reinterpret_cast<cv::Rect*>(&roi2), flags);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<float*>(&ret) };
    } CVRS_CATCH(cv_return_value_float)
}

// cv_reduce_Mat_src_Mat_dst_int_dim_int_rtype_int_dtype
// parsed: cv::reduce
// as:     cv::reduce (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG Primitive(int) dim= Primitive(int) = 
// Arg ARG Primitive(int) rtype= Primitive(int) = 
// Arg ARG Primitive(int) dtype= Primitive(int) = -1
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_reduce_Mat_src_Mat_dst_int_dim_int_rtype_int_dtype(void* src, void* dst, int dim, int rtype, int dtype) {
    try {
        cv::reduce(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst), dim, rtype, dtype);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_remap_Mat_src_Mat_dst_Mat_map1_Mat_map2_int_interpolation_int_borderMode_Scalar_borderValue
// parsed: cv::remap
// as:     cv::remap (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) map1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) map2= cv::Mat (boxed) = 
// Arg ARG Primitive(int) interpolation= Primitive(int) = 
// Arg ARG Primitive(int) borderMode= Primitive(int) = BORDER_CONSTANT
// Arg ARG cv::Scalar (simple) borderValue= cv::Scalar (simple) = Scalar()
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_remap_Mat_src_Mat_dst_Mat_map1_Mat_map2_int_interpolation_int_borderMode_Scalar_borderValue(void* src, void* dst, void* map1, void* map2, int interpolation, int borderMode, ScalarWrapper borderValue) {
    try {
        cv::remap(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst), *reinterpret_cast<cv::Mat*>(map1), *reinterpret_cast<cv::Mat*>(map2), interpolation, borderMode, *reinterpret_cast<cv::Scalar*>(&borderValue));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_repeat_Mat_src_int_ny_int_nx
// parsed: cv::repeat
// as:     cv::repeat (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG Primitive(int) ny= Primitive(int) = 
// Arg ARG Primitive(int) nx= Primitive(int) = 
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_repeat_Mat_src_int_ny_int_nx(void* src, int ny, int nx) {
    try {
        cv::Mat ret = cv::repeat(*reinterpret_cast<cv::Mat*>(src), ny, nx);
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_repeat_Mat_src_int_ny_int_nx_Mat_dst
// parsed: cv::repeat
// as:     cv::repeat (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG Primitive(int) ny= Primitive(int) = 
// Arg ARG Primitive(int) nx= Primitive(int) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_repeat_Mat_src_int_ny_int_nx_Mat_dst(void* src, int ny, int nx, void* dst) {
    try {
        cv::repeat(*reinterpret_cast<cv::Mat*>(src), ny, nx, *reinterpret_cast<cv::Mat*>(dst));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_reprojectImageTo3D_Mat_disparity_Mat__3dImage_Mat_Q_bool_handleMissingValues_int_ddepth
// parsed: cv::reprojectImageTo3D
// as:     cv::reprojectImageTo3D (function)
// Arg ARG cv::Mat (boxed) disparity= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) _3dImage= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) Q= cv::Mat (boxed) = 
// Arg ARG Primitive(bool) handleMissingValues= Primitive(bool) = false
// Arg ARG Primitive(int) ddepth= Primitive(int) = -1
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_reprojectImageTo3D_Mat_disparity_Mat__3dImage_Mat_Q_bool_handleMissingValues_int_ddepth(void* disparity, void* _3dImage, void* Q, bool handleMissingValues, int ddepth) {
    try {
        cv::reprojectImageTo3D(*reinterpret_cast<cv::Mat*>(disparity), *reinterpret_cast<cv::Mat*>(_3dImage), *reinterpret_cast<cv::Mat*>(Q), handleMissingValues, ddepth);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_resizeWindow_String_winname_Size_size
// parsed: cv::resizeWindow
// as:     cv::resizeWindow (function)
// Arg ARG string winname= string = 
// Arg ARG cv::Size (simple) size= cv::Size (simple) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_resizeWindow_String_winname_Size_size(const char* winname, SizeWrapper size) {
    try {
        cv::resizeWindow(String(winname), *reinterpret_cast<cv::Size*>(&size));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_resizeWindow_String_winname_int_width_int_height
// parsed: cv::resizeWindow
// as:     cv::resizeWindow (function)
// Arg ARG string winname= string = 
// Arg ARG Primitive(int) width= Primitive(int) = 
// Arg ARG Primitive(int) height= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_resizeWindow_String_winname_int_width_int_height(const char* winname, int width, int height) {
    try {
        cv::resizeWindow(String(winname), width, height);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_resize_Mat_src_Mat_dst_Size_dsize_double_fx_double_fy_int_interpolation
// parsed: cv::resize
// as:     cv::resize (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG cv::Size (simple) dsize= cv::Size (simple) = 
// Arg ARG Primitive(double) fx= Primitive(double) = 0
// Arg ARG Primitive(double) fy= Primitive(double) = 0
// Arg ARG Primitive(int) interpolation= Primitive(int) = INTER_LINEAR
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_resize_Mat_src_Mat_dst_Size_dsize_double_fx_double_fy_int_interpolation(void* src, void* dst, SizeWrapper dsize, double fx, double fy, int interpolation) {
    try {
        cv::resize(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst), *reinterpret_cast<cv::Size*>(&dsize), fx, fy, interpolation);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_rotate_Mat_src_Mat_dst_int_rotateCode
// parsed: cv::rotate
// as:     cv::rotate (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG Primitive(int) rotateCode= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_rotate_Mat_src_Mat_dst_int_rotateCode(void* src, void* dst, int rotateCode) {
    try {
        cv::rotate(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst), rotateCode);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_rotatedRectangleIntersection_RotatedRect_rect1_RotatedRect_rect2_Mat_intersectingRegion
// parsed: cv::rotatedRectangleIntersection
// as:     cv::rotatedRectangleIntersection (function)
// Arg ARG cv::RotatedRect (boxed) rect1= cv::RotatedRect (boxed) = 
// Arg ARG cv::RotatedRect (boxed) rect2= cv::RotatedRect (boxed) = 
// Arg ARG cv::Mat (boxed) intersectingRegion= cv::Mat (boxed) = 
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_rotatedRectangleIntersection_RotatedRect_rect1_RotatedRect_rect2_Mat_intersectingRegion(void* rect1, void* rect2, void* intersectingRegion) {
    try {
        int ret = cv::rotatedRectangleIntersection(*reinterpret_cast<cv::RotatedRect*>(rect1), *reinterpret_cast<cv::RotatedRect*>(rect2), *reinterpret_cast<cv::Mat*>(intersectingRegion));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_roundUp_int_a_unsigned_int_b
// parsed: cv::roundUp
// as:     cv::roundUp (function)
// Arg ARG Primitive(int) a= Primitive(int) = 
// Arg ARG Primitive(unsigned int) b= Primitive(unsigned int) = 
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_roundUp_int_a_unsigned_int_b(int a, unsigned int b) {
    try {
        int ret = cv::roundUp(a, b);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_roundUp_size_t_a_unsigned_int_b
// parsed: cv::roundUp
// as:     cv::roundUp (function)
// Arg ARG Primitive(size_t) a= Primitive(size_t) = 
// Arg ARG Primitive(unsigned int) b= Primitive(unsigned int) = 
// Return value: Primitive(size_t)
cv_return_value_std_size_t cv_core_cv_roundUp_size_t_a_unsigned_int_b(std::size_t a, unsigned int b) {
    try {
        size_t ret = cv::roundUp(a, b);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<std::size_t*>(&ret) };
    } CVRS_CATCH(cv_return_value_std_size_t)
}

// cv_sampsonDistance_Mat_pt1_Mat_pt2_Mat_F
// parsed: cv::sampsonDistance
// as:     cv::sampsonDistance (function)
// Arg ARG cv::Mat (boxed) pt1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) pt2= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) F= cv::Mat (boxed) = 
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_sampsonDistance_Mat_pt1_Mat_pt2_Mat_F(void* pt1, void* pt2, void* F) {
    try {
        double ret = cv::sampsonDistance(*reinterpret_cast<cv::Mat*>(pt1), *reinterpret_cast<cv::Mat*>(pt2), *reinterpret_cast<cv::Mat*>(F));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_saveWindowParameters_String_windowName
// parsed: cv::saveWindowParameters
// as:     cv::saveWindowParameters (function)
// Arg ARG string windowName= string = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_saveWindowParameters_String_windowName(const char* windowName) {
    try {
        cv::saveWindowParameters(String(windowName));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_scaleAdd_Mat_src1_double_alpha_Mat_src2_Mat_dst
// parsed: cv::scaleAdd
// as:     cv::scaleAdd (function)
// Arg ARG cv::Mat (boxed) src1= cv::Mat (boxed) = 
// Arg ARG Primitive(double) alpha= Primitive(double) = 
// Arg ARG cv::Mat (boxed) src2= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_scaleAdd_Mat_src1_double_alpha_Mat_src2_Mat_dst(void* src1, double alpha, void* src2, void* dst) {
    try {
        cv::scaleAdd(*reinterpret_cast<cv::Mat*>(src1), alpha, *reinterpret_cast<cv::Mat*>(src2), *reinterpret_cast<cv::Mat*>(dst));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_seamlessClone_Mat_src_Mat_dst_Mat_mask_Point_p_Mat_blend_int_flags
// parsed: cv::seamlessClone
// as:     cv::seamlessClone (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) mask= cv::Mat (boxed) = 
// Arg ARG cv::Point (simple) p= cv::Point (simple) = 
// Arg ARG cv::Mat (boxed) blend= cv::Mat (boxed) = 
// Arg ARG Primitive(int) flags= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_seamlessClone_Mat_src_Mat_dst_Mat_mask_Point_p_Mat_blend_int_flags(void* src, void* dst, void* mask, PointWrapper p, void* blend, int flags) {
    try {
        cv::seamlessClone(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst), *reinterpret_cast<cv::Mat*>(mask), *reinterpret_cast<cv::Point*>(&p), *reinterpret_cast<cv::Mat*>(blend), flags);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_selectROI_Mat_img_bool_showCrosshair_bool_fromCenter
// parsed: cv::selectROI
// as:     cv::selectROI (function)
// Arg ARG cv::Mat (boxed) img= cv::Mat (boxed) = 
// Arg ARG Primitive(bool) showCrosshair= Primitive(bool) = true
// Arg ARG Primitive(bool) fromCenter= Primitive(bool) = false
// Return value: cv::Rect (simple)
cv_return_value_RectWrapper cv_core_cv_selectROI_Mat_img_bool_showCrosshair_bool_fromCenter(void* img, bool showCrosshair, bool fromCenter) {
    try {
        cv::Rect ret = cv::selectROI(*reinterpret_cast<cv::Mat*>(img), showCrosshair, fromCenter);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<RectWrapper*>(&ret) };
    } CVRS_CATCH(cv_return_value_RectWrapper)
}

// cv_selectROI_String_windowName_Mat_img_bool_showCrosshair_bool_fromCenter
// parsed: cv::selectROI
// as:     cv::selectROI (function)
// Arg ARG string windowName= string = 
// Arg ARG cv::Mat (boxed) img= cv::Mat (boxed) = 
// Arg ARG Primitive(bool) showCrosshair= Primitive(bool) = true
// Arg ARG Primitive(bool) fromCenter= Primitive(bool) = false
// Return value: cv::Rect (simple)
cv_return_value_RectWrapper cv_core_cv_selectROI_String_windowName_Mat_img_bool_showCrosshair_bool_fromCenter(const char* windowName, void* img, bool showCrosshair, bool fromCenter) {
    try {
        cv::Rect ret = cv::selectROI(String(windowName), *reinterpret_cast<cv::Mat*>(img), showCrosshair, fromCenter);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<RectWrapper*>(&ret) };
    } CVRS_CATCH(cv_return_value_RectWrapper)
}

// cv_selectROIs_String_windowName_Mat_img_VectorOfRect_boundingBoxes_bool_showCrosshair_bool_fromCenter
// parsed: cv::selectROIs
// as:     cv::selectROIs (function)
// Arg ARG string windowName= string = 
// Arg ARG cv::Mat (boxed) img= cv::Mat (boxed) = 
// Arg ARG Vector[cv::Rect (simple)] boundingBoxes= Vector[cv::Rect (simple)] = 
// Arg ARG Primitive(bool) showCrosshair= Primitive(bool) = true
// Arg ARG Primitive(bool) fromCenter= Primitive(bool) = false
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_selectROIs_String_windowName_Mat_img_VectorOfRect_boundingBoxes_bool_showCrosshair_bool_fromCenter(const char* windowName, void* img, void* boundingBoxes, bool showCrosshair, bool fromCenter) {
    try {
        cv::selectROIs(String(windowName), *reinterpret_cast<cv::Mat*>(img), *reinterpret_cast<std::vector<cv::Rect>*>(boundingBoxes), showCrosshair, fromCenter);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_sepFilter2D_Mat_src_Mat_dst_int_ddepth_Mat_kernelX_Mat_kernelY_Point_anchor_double_delta_int_borderType
// parsed: cv::sepFilter2D
// as:     cv::sepFilter2D (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG Primitive(int) ddepth= Primitive(int) = 
// Arg ARG cv::Mat (boxed) kernelX= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) kernelY= cv::Mat (boxed) = 
// Arg ARG cv::Point (simple) anchor= cv::Point (simple) = Point(-1,-1)
// Arg ARG Primitive(double) delta= Primitive(double) = 0
// Arg ARG Primitive(int) borderType= Primitive(int) = BORDER_DEFAULT
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_sepFilter2D_Mat_src_Mat_dst_int_ddepth_Mat_kernelX_Mat_kernelY_Point_anchor_double_delta_int_borderType(void* src, void* dst, int ddepth, void* kernelX, void* kernelY, PointWrapper anchor, double delta, int borderType) {
    try {
        cv::sepFilter2D(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst), ddepth, *reinterpret_cast<cv::Mat*>(kernelX), *reinterpret_cast<cv::Mat*>(kernelY), *reinterpret_cast<cv::Point*>(&anchor), delta, borderType);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_setBreakOnError_bool_flag
// parsed: cv::setBreakOnError
// as:     cv::setBreakOnError (function)
// Arg ARG Primitive(bool) flag= Primitive(bool) = 
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_setBreakOnError_bool_flag(bool flag) {
    try {
        bool ret = cv::setBreakOnError(flag);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_setIdentity_Mat_mtx_Scalar_s
// parsed: cv::setIdentity
// as:     cv::setIdentity (function)
// Arg ARG cv::Mat (boxed) mtx= cv::Mat (boxed) = 
// Arg ARG cv::Scalar (simple) s= cv::Scalar (simple) = Scalar(1)
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_setIdentity_Mat_mtx_Scalar_s(void* mtx, ScalarWrapper s) {
    try {
        cv::setIdentity(*reinterpret_cast<cv::Mat*>(mtx), *reinterpret_cast<cv::Scalar*>(&s));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_setMouseCallback_String_winname_MouseCallback_onMouse_void_X_userdata
// parsed: cv::setMouseCallback
// as:     cv::setMouseCallback (function)
// Arg ARG string winname= string = 
// Arg ARG cv::MouseCallback (callback) onMouse= cv::MouseCallback (callback) = 
// Arg ARG RawPtr[Primitive(void)] * userdata= (ptr) RawPtr[Primitive(void)] = 0
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_setMouseCallback_String_winname_MouseCallback_onMouse_void_X_userdata(const char* winname, cv::MouseCallback onMouse, void* userdata) {
    try {
        cv::setMouseCallback(String(winname), *reinterpret_cast<cv::MouseCallback*>(&onMouse), userdata);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_setNumThreads_int_nthreads
// parsed: cv::setNumThreads
// as:     cv::setNumThreads (function)
// Arg ARG Primitive(int) nthreads= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_setNumThreads_int_nthreads(int nthreads) {
    try {
        cv::setNumThreads(nthreads);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_setOpenGlContext_String_winname
// parsed: cv::setOpenGlContext
// as:     cv::setOpenGlContext (function)
// Arg ARG string winname= string = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_setOpenGlContext_String_winname(const char* winname) {
    try {
        cv::setOpenGlContext(String(winname));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_setOpenGlDrawCallback_String_winname_OpenGlDrawCallback_onOpenGlDraw_void_X_userdata
// parsed: cv::setOpenGlDrawCallback
// as:     cv::setOpenGlDrawCallback (function)
// Arg ARG string winname= string = 
// Arg ARG cv::OpenGlDrawCallback (callback) onOpenGlDraw= cv::OpenGlDrawCallback (callback) = 
// Arg ARG RawPtr[Primitive(void)] * userdata= (ptr) RawPtr[Primitive(void)] = 0
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_setOpenGlDrawCallback_String_winname_OpenGlDrawCallback_onOpenGlDraw_void_X_userdata(const char* winname, cv::OpenGlDrawCallback onOpenGlDraw, void* userdata) {
    try {
        cv::setOpenGlDrawCallback(String(winname), *reinterpret_cast<cv::OpenGlDrawCallback*>(&onOpenGlDraw), userdata);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_setRNGSeed_int_seed
// parsed: cv::setRNGSeed
// as:     cv::setRNGSeed (function)
// Arg ARG Primitive(int) seed= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_setRNGSeed_int_seed(int seed) {
    try {
        cv::setRNGSeed(seed);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_setTrackbarMax_String_trackbarname_String_winname_int_maxval
// parsed: cv::setTrackbarMax
// as:     cv::setTrackbarMax (function)
// Arg ARG string trackbarname= string = 
// Arg ARG string winname= string = 
// Arg ARG Primitive(int) maxval= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_setTrackbarMax_String_trackbarname_String_winname_int_maxval(const char* trackbarname, const char* winname, int maxval) {
    try {
        cv::setTrackbarMax(String(trackbarname), String(winname), maxval);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_setTrackbarMin_String_trackbarname_String_winname_int_minval
// parsed: cv::setTrackbarMin
// as:     cv::setTrackbarMin (function)
// Arg ARG string trackbarname= string = 
// Arg ARG string winname= string = 
// Arg ARG Primitive(int) minval= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_setTrackbarMin_String_trackbarname_String_winname_int_minval(const char* trackbarname, const char* winname, int minval) {
    try {
        cv::setTrackbarMin(String(trackbarname), String(winname), minval);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_setTrackbarPos_String_trackbarname_String_winname_int_pos
// parsed: cv::setTrackbarPos
// as:     cv::setTrackbarPos (function)
// Arg ARG string trackbarname= string = 
// Arg ARG string winname= string = 
// Arg ARG Primitive(int) pos= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_setTrackbarPos_String_trackbarname_String_winname_int_pos(const char* trackbarname, const char* winname, int pos) {
    try {
        cv::setTrackbarPos(String(trackbarname), String(winname), pos);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_setUseOpenVX_bool_flag
// parsed: cv::setUseOpenVX
// as:     cv::setUseOpenVX (function)
// Arg ARG Primitive(bool) flag= Primitive(bool) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_setUseOpenVX_bool_flag(bool flag) {
    try {
        cv::setUseOpenVX(flag);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_setUseOptimized_bool_onoff
// parsed: cv::setUseOptimized
// as:     cv::setUseOptimized (function)
// Arg ARG Primitive(bool) onoff= Primitive(bool) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_setUseOptimized_bool_onoff(bool onoff) {
    try {
        cv::setUseOptimized(onoff);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_setWindowProperty_String_winname_int_prop_id_double_prop_value
// parsed: cv::setWindowProperty
// as:     cv::setWindowProperty (function)
// Arg ARG string winname= string = 
// Arg ARG Primitive(int) prop_id= Primitive(int) = 
// Arg ARG Primitive(double) prop_value= Primitive(double) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_setWindowProperty_String_winname_int_prop_id_double_prop_value(const char* winname, int prop_id, double prop_value) {
    try {
        cv::setWindowProperty(String(winname), prop_id, prop_value);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_setWindowTitle_String_winname_String_title
// parsed: cv::setWindowTitle
// as:     cv::setWindowTitle (function)
// Arg ARG string winname= string = 
// Arg ARG string title= string = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_setWindowTitle_String_winname_String_title(const char* winname, const char* title) {
    try {
        cv::setWindowTitle(String(winname), String(title));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_sin_softdouble_a
// parsed: cv::sin
// as:     cv::sin (function)
// Arg ARG cv::softdouble (boxed) a= cv::softdouble (boxed) = 
// Return value: cv::softdouble (boxed)
cv_return_value_void_X cv_core_cv_sin_softdouble_a(void* a) {
    try {
        cv::softdouble ret = cv::sin(*reinterpret_cast<cv::softdouble*>(a));
        return { Error::Code::StsOk, NULL, new cv::softdouble(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_solveCubic_Mat_coeffs_Mat_roots
// parsed: cv::solveCubic
// as:     cv::solveCubic (function)
// Arg ARG cv::Mat (boxed) coeffs= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) roots= cv::Mat (boxed) = 
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_solveCubic_Mat_coeffs_Mat_roots(void* coeffs, void* roots) {
    try {
        int ret = cv::solveCubic(*reinterpret_cast<cv::Mat*>(coeffs), *reinterpret_cast<cv::Mat*>(roots));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_solveLP_Mat_Func_Mat_Constr_Mat_z
// parsed: cv::solveLP
// as:     cv::solveLP (function)
// Arg ARG cv::Mat (boxed) Func= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) Constr= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) z= cv::Mat (boxed) = 
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_solveLP_Mat_Func_Mat_Constr_Mat_z(void* Func, void* Constr, void* z) {
    try {
        int ret = cv::solveLP(*reinterpret_cast<cv::Mat*>(Func), *reinterpret_cast<cv::Mat*>(Constr), *reinterpret_cast<cv::Mat*>(z));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_solveP3P_Mat_objectPoints_Mat_imagePoints_Mat_cameraMatrix_Mat_distCoeffs_VectorOfMat_rvecs_VectorOfMat_tvecs_int_flags
// parsed: cv::solveP3P
// as:     cv::solveP3P (function)
// Arg ARG cv::Mat (boxed) objectPoints= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) imagePoints= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) cameraMatrix= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) distCoeffs= cv::Mat (boxed) = 
// Arg ARG Vector[cv::Mat (boxed)] rvecs= Vector[cv::Mat (boxed)] = 
// Arg ARG Vector[cv::Mat (boxed)] tvecs= Vector[cv::Mat (boxed)] = 
// Arg ARG Primitive(int) flags= Primitive(int) = 
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_solveP3P_Mat_objectPoints_Mat_imagePoints_Mat_cameraMatrix_Mat_distCoeffs_VectorOfMat_rvecs_VectorOfMat_tvecs_int_flags(void* objectPoints, void* imagePoints, void* cameraMatrix, void* distCoeffs, void** rvecs, void** tvecs, int flags) {
    try {
        int ret = cv::solveP3P(*reinterpret_cast<cv::Mat*>(objectPoints), *reinterpret_cast<cv::Mat*>(imagePoints), *reinterpret_cast<cv::Mat*>(cameraMatrix), *reinterpret_cast<cv::Mat*>(distCoeffs), *reinterpret_cast<std::vector<cv::Mat>*>(rvecs), *reinterpret_cast<std::vector<cv::Mat>*>(tvecs), flags);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_solvePnPRansac_Mat_objectPoints_Mat_imagePoints_Mat_cameraMatrix_Mat_distCoeffs_Mat_rvec_Mat_tvec_bool_useExtrinsicGuess_int_iterationsCount_float_reprojectionError_double_confidence_Mat_inliers_int_flags
// parsed: cv::solvePnPRansac
// as:     cv::solvePnPRansac (function)
// Arg ARG cv::Mat (boxed) objectPoints= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) imagePoints= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) cameraMatrix= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) distCoeffs= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) rvec= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) tvec= cv::Mat (boxed) = 
// Arg ARG Primitive(bool) useExtrinsicGuess= Primitive(bool) = false
// Arg ARG Primitive(int) iterationsCount= Primitive(int) = 100
// Arg ARG Primitive(float) reprojectionError= Primitive(float) = 8.0
// Arg ARG Primitive(double) confidence= Primitive(double) = 0.99
// Arg ARG cv::Mat (boxed) inliers= cv::Mat (boxed) = noArray()
// Arg ARG Primitive(int) flags= Primitive(int) = SOLVEPNP_ITERATIVE
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_solvePnPRansac_Mat_objectPoints_Mat_imagePoints_Mat_cameraMatrix_Mat_distCoeffs_Mat_rvec_Mat_tvec_bool_useExtrinsicGuess_int_iterationsCount_float_reprojectionError_double_confidence_Mat_inliers_int_flags(void* objectPoints, void* imagePoints, void* cameraMatrix, void* distCoeffs, void* rvec, void* tvec, bool useExtrinsicGuess, int iterationsCount, float reprojectionError, double confidence, void* inliers, int flags) {
    try {
        bool ret = cv::solvePnPRansac(*reinterpret_cast<cv::Mat*>(objectPoints), *reinterpret_cast<cv::Mat*>(imagePoints), *reinterpret_cast<cv::Mat*>(cameraMatrix), *reinterpret_cast<cv::Mat*>(distCoeffs), *reinterpret_cast<cv::Mat*>(rvec), *reinterpret_cast<cv::Mat*>(tvec), useExtrinsicGuess, iterationsCount, reprojectionError, confidence, *reinterpret_cast<cv::Mat*>(inliers), flags);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_solvePnP_Mat_objectPoints_Mat_imagePoints_Mat_cameraMatrix_Mat_distCoeffs_Mat_rvec_Mat_tvec_bool_useExtrinsicGuess_int_flags
// parsed: cv::solvePnP
// as:     cv::solvePnP (function)
// Arg ARG cv::Mat (boxed) objectPoints= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) imagePoints= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) cameraMatrix= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) distCoeffs= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) rvec= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) tvec= cv::Mat (boxed) = 
// Arg ARG Primitive(bool) useExtrinsicGuess= Primitive(bool) = false
// Arg ARG Primitive(int) flags= Primitive(int) = SOLVEPNP_ITERATIVE
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_solvePnP_Mat_objectPoints_Mat_imagePoints_Mat_cameraMatrix_Mat_distCoeffs_Mat_rvec_Mat_tvec_bool_useExtrinsicGuess_int_flags(void* objectPoints, void* imagePoints, void* cameraMatrix, void* distCoeffs, void* rvec, void* tvec, bool useExtrinsicGuess, int flags) {
    try {
        bool ret = cv::solvePnP(*reinterpret_cast<cv::Mat*>(objectPoints), *reinterpret_cast<cv::Mat*>(imagePoints), *reinterpret_cast<cv::Mat*>(cameraMatrix), *reinterpret_cast<cv::Mat*>(distCoeffs), *reinterpret_cast<cv::Mat*>(rvec), *reinterpret_cast<cv::Mat*>(tvec), useExtrinsicGuess, flags);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_solvePoly_Mat_coeffs_Mat_roots_int_maxIters
// parsed: cv::solvePoly
// as:     cv::solvePoly (function)
// Arg ARG cv::Mat (boxed) coeffs= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) roots= cv::Mat (boxed) = 
// Arg ARG Primitive(int) maxIters= Primitive(int) = 300
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_solvePoly_Mat_coeffs_Mat_roots_int_maxIters(void* coeffs, void* roots, int maxIters) {
    try {
        double ret = cv::solvePoly(*reinterpret_cast<cv::Mat*>(coeffs), *reinterpret_cast<cv::Mat*>(roots), maxIters);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_solve_Mat_src1_Mat_src2_Mat_dst_int_flags
// parsed: cv::solve
// as:     cv::solve (function)
// Arg ARG cv::Mat (boxed) src1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) src2= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG Primitive(int) flags= Primitive(int) = DECOMP_LU
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_solve_Mat_src1_Mat_src2_Mat_dst_int_flags(void* src1, void* src2, void* dst, int flags) {
    try {
        bool ret = cv::solve(*reinterpret_cast<cv::Mat*>(src1), *reinterpret_cast<cv::Mat*>(src2), *reinterpret_cast<cv::Mat*>(dst), flags);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_sortIdx_Mat_src_Mat_dst_int_flags
// parsed: cv::sortIdx
// as:     cv::sortIdx (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG Primitive(int) flags= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_sortIdx_Mat_src_Mat_dst_int_flags(void* src, void* dst, int flags) {
    try {
        cv::sortIdx(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst), flags);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_sort_Mat_src_Mat_dst_int_flags
// parsed: cv::sort
// as:     cv::sort (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG Primitive(int) flags= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_sort_Mat_src_Mat_dst_int_flags(void* src, void* dst, int flags) {
    try {
        cv::sort(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst), flags);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_spatialGradient_Mat_src_Mat_dx_Mat_dy_int_ksize_int_borderType
// parsed: cv::spatialGradient
// as:     cv::spatialGradient (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dx= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dy= cv::Mat (boxed) = 
// Arg ARG Primitive(int) ksize= Primitive(int) = 3
// Arg ARG Primitive(int) borderType= Primitive(int) = BORDER_DEFAULT
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_spatialGradient_Mat_src_Mat_dx_Mat_dy_int_ksize_int_borderType(void* src, void* dx, void* dy, int ksize, int borderType) {
    try {
        cv::spatialGradient(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dx), *reinterpret_cast<cv::Mat*>(dy), ksize, borderType);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_split_Mat_m_VectorOfMat_mv
// parsed: cv::split
// as:     cv::split (function)
// Arg ARG cv::Mat (boxed) m= cv::Mat (boxed) = 
// Arg ARG Vector[cv::Mat (boxed)] mv= Vector[cv::Mat (boxed)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_split_Mat_m_VectorOfMat_mv(void* m, void** mv) {
    try {
        cv::split(*reinterpret_cast<cv::Mat*>(m), *reinterpret_cast<std::vector<cv::Mat>*>(mv));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_split_Mat_src_Mat_mvbegin
// parsed: cv::split
// as:     cv::split (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG RawPtr[cv::Mat (boxed)] * mvbegin= (ptr) RawPtr[cv::Mat (boxed)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_split_Mat_src_Mat_mvbegin(void* src, void* mvbegin) {
    try {
        cv::split(*reinterpret_cast<cv::Mat*>(src), reinterpret_cast<cv::Mat*>(mvbegin));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_sqrBoxFilter_Mat_src_Mat_dst_int_ddepth_Size_ksize_Point_anchor_bool_normalize_int_borderType
// parsed: cv::sqrBoxFilter
// as:     cv::sqrBoxFilter (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG Primitive(int) ddepth= Primitive(int) = 
// Arg ARG cv::Size (simple) ksize= cv::Size (simple) = 
// Arg ARG cv::Point (simple) anchor= cv::Point (simple) = Point(-1, -1)
// Arg ARG Primitive(bool) normalize= Primitive(bool) = true
// Arg ARG Primitive(int) borderType= Primitive(int) = BORDER_DEFAULT
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_sqrBoxFilter_Mat_src_Mat_dst_int_ddepth_Size_ksize_Point_anchor_bool_normalize_int_borderType(void* src, void* dst, int ddepth, SizeWrapper ksize, PointWrapper anchor, bool normalize, int borderType) {
    try {
        cv::sqrBoxFilter(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst), ddepth, *reinterpret_cast<cv::Size*>(&ksize), *reinterpret_cast<cv::Point*>(&anchor), normalize, borderType);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_sqrt_Mat_src_Mat_dst
// parsed: cv::sqrt
// as:     cv::sqrt (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_sqrt_Mat_src_Mat_dst(void* src, void* dst) {
    try {
        cv::sqrt(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_sqrt_softdouble_a
// parsed: cv::sqrt
// as:     cv::sqrt (function)
// Arg ARG cv::softdouble (boxed) a= cv::softdouble (boxed) = 
// Return value: cv::softdouble (boxed)
cv_return_value_void_X cv_core_cv_sqrt_softdouble_a(void* a) {
    try {
        cv::softdouble ret = cv::sqrt(*reinterpret_cast<cv::softdouble*>(a));
        return { Error::Code::StsOk, NULL, new cv::softdouble(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_sqrt_softfloat_a
// parsed: cv::sqrt
// as:     cv::sqrt (function)
// Arg ARG cv::softfloat (boxed) a= cv::softfloat (boxed) = 
// Return value: cv::softfloat (boxed)
cv_return_value_void_X cv_core_cv_sqrt_softfloat_a(void* a) {
    try {
        cv::softfloat ret = cv::sqrt(*reinterpret_cast<cv::softfloat*>(a));
        return { Error::Code::StsOk, NULL, new cv::softfloat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_startWindowThread
// parsed: cv::startWindowThread
// as:     cv::startWindowThread (function)
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_startWindowThread() {
    try {
        int ret = cv::startWindowThread();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_stereoCalibrate_VectorOfMat_objectPoints_VectorOfMat_imagePoints1_VectorOfMat_imagePoints2_Mat_cameraMatrix1_Mat_distCoeffs1_Mat_cameraMatrix2_Mat_distCoeffs2_Size_imageSize_Mat_R_Mat_T_Mat_E_Mat_F_Mat_perViewErrors_int_flags_TermCriteria_criteria
// parsed: cv::stereoCalibrate
// as:     cv::stereoCalibrate (function)
// Arg ARG Vector[cv::Mat (boxed)] objectPoints= Vector[cv::Mat (boxed)] = 
// Arg ARG Vector[cv::Mat (boxed)] imagePoints1= Vector[cv::Mat (boxed)] = 
// Arg ARG Vector[cv::Mat (boxed)] imagePoints2= Vector[cv::Mat (boxed)] = 
// Arg ARG cv::Mat (boxed) cameraMatrix1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) distCoeffs1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) cameraMatrix2= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) distCoeffs2= cv::Mat (boxed) = 
// Arg ARG cv::Size (simple) imageSize= cv::Size (simple) = 
// Arg ARG cv::Mat (boxed) R= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) T= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) E= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) F= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) perViewErrors= cv::Mat (boxed) = 
// Arg ARG Primitive(int) flags= Primitive(int) = CALIB_FIX_INTRINSIC
// Arg ARG cv::TermCriteria (boxed) criteria= cv::TermCriteria (boxed) = TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, 1e-6)
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_stereoCalibrate_VectorOfMat_objectPoints_VectorOfMat_imagePoints1_VectorOfMat_imagePoints2_Mat_cameraMatrix1_Mat_distCoeffs1_Mat_cameraMatrix2_Mat_distCoeffs2_Size_imageSize_Mat_R_Mat_T_Mat_E_Mat_F_Mat_perViewErrors_int_flags_TermCriteria_criteria(void* objectPoints, void* imagePoints1, void* imagePoints2, void* cameraMatrix1, void* distCoeffs1, void* cameraMatrix2, void* distCoeffs2, SizeWrapper imageSize, void* R, void* T, void* E, void* F, void* perViewErrors, int flags, void* criteria) {
    try {
        double ret = cv::stereoCalibrate(*reinterpret_cast<std::vector<cv::Mat>*>(objectPoints), *reinterpret_cast<std::vector<cv::Mat>*>(imagePoints1), *reinterpret_cast<std::vector<cv::Mat>*>(imagePoints2), *reinterpret_cast<cv::Mat*>(cameraMatrix1), *reinterpret_cast<cv::Mat*>(distCoeffs1), *reinterpret_cast<cv::Mat*>(cameraMatrix2), *reinterpret_cast<cv::Mat*>(distCoeffs2), *reinterpret_cast<cv::Size*>(&imageSize), *reinterpret_cast<cv::Mat*>(R), *reinterpret_cast<cv::Mat*>(T), *reinterpret_cast<cv::Mat*>(E), *reinterpret_cast<cv::Mat*>(F), *reinterpret_cast<cv::Mat*>(perViewErrors), flags, *reinterpret_cast<cv::TermCriteria*>(criteria));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_stereoCalibrate_VectorOfMat_objectPoints_VectorOfMat_imagePoints1_VectorOfMat_imagePoints2_Mat_cameraMatrix1_Mat_distCoeffs1_Mat_cameraMatrix2_Mat_distCoeffs2_Size_imageSize_Mat_R_Mat_T_Mat_E_Mat_F_int_flags_TermCriteria_criteria
// parsed: cv::stereoCalibrate
// as:     cv::stereoCalibrate (function)
// Arg ARG Vector[cv::Mat (boxed)] objectPoints= Vector[cv::Mat (boxed)] = 
// Arg ARG Vector[cv::Mat (boxed)] imagePoints1= Vector[cv::Mat (boxed)] = 
// Arg ARG Vector[cv::Mat (boxed)] imagePoints2= Vector[cv::Mat (boxed)] = 
// Arg ARG cv::Mat (boxed) cameraMatrix1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) distCoeffs1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) cameraMatrix2= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) distCoeffs2= cv::Mat (boxed) = 
// Arg ARG cv::Size (simple) imageSize= cv::Size (simple) = 
// Arg ARG cv::Mat (boxed) R= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) T= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) E= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) F= cv::Mat (boxed) = 
// Arg ARG Primitive(int) flags= Primitive(int) = CALIB_FIX_INTRINSIC
// Arg ARG cv::TermCriteria (boxed) criteria= cv::TermCriteria (boxed) = TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, 1e-6)
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_stereoCalibrate_VectorOfMat_objectPoints_VectorOfMat_imagePoints1_VectorOfMat_imagePoints2_Mat_cameraMatrix1_Mat_distCoeffs1_Mat_cameraMatrix2_Mat_distCoeffs2_Size_imageSize_Mat_R_Mat_T_Mat_E_Mat_F_int_flags_TermCriteria_criteria(void* objectPoints, void* imagePoints1, void* imagePoints2, void* cameraMatrix1, void* distCoeffs1, void* cameraMatrix2, void* distCoeffs2, SizeWrapper imageSize, void* R, void* T, void* E, void* F, int flags, void* criteria) {
    try {
        double ret = cv::stereoCalibrate(*reinterpret_cast<std::vector<cv::Mat>*>(objectPoints), *reinterpret_cast<std::vector<cv::Mat>*>(imagePoints1), *reinterpret_cast<std::vector<cv::Mat>*>(imagePoints2), *reinterpret_cast<cv::Mat*>(cameraMatrix1), *reinterpret_cast<cv::Mat*>(distCoeffs1), *reinterpret_cast<cv::Mat*>(cameraMatrix2), *reinterpret_cast<cv::Mat*>(distCoeffs2), *reinterpret_cast<cv::Size*>(&imageSize), *reinterpret_cast<cv::Mat*>(R), *reinterpret_cast<cv::Mat*>(T), *reinterpret_cast<cv::Mat*>(E), *reinterpret_cast<cv::Mat*>(F), flags, *reinterpret_cast<cv::TermCriteria*>(criteria));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_stereoRectifyUncalibrated_Mat_points1_Mat_points2_Mat_F_Size_imgSize_Mat_H1_Mat_H2_double_threshold
// parsed: cv::stereoRectifyUncalibrated
// as:     cv::stereoRectifyUncalibrated (function)
// Arg ARG cv::Mat (boxed) points1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) points2= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) F= cv::Mat (boxed) = 
// Arg ARG cv::Size (simple) imgSize= cv::Size (simple) = 
// Arg ARG cv::Mat (boxed) H1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) H2= cv::Mat (boxed) = 
// Arg ARG Primitive(double) threshold= Primitive(double) = 5
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_stereoRectifyUncalibrated_Mat_points1_Mat_points2_Mat_F_Size_imgSize_Mat_H1_Mat_H2_double_threshold(void* points1, void* points2, void* F, SizeWrapper imgSize, void* H1, void* H2, double threshold) {
    try {
        bool ret = cv::stereoRectifyUncalibrated(*reinterpret_cast<cv::Mat*>(points1), *reinterpret_cast<cv::Mat*>(points2), *reinterpret_cast<cv::Mat*>(F), *reinterpret_cast<cv::Size*>(&imgSize), *reinterpret_cast<cv::Mat*>(H1), *reinterpret_cast<cv::Mat*>(H2), threshold);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// 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_X_validPixROI1_Rect_X_validPixROI2
// parsed: cv::stereoRectify
// as:     cv::stereoRectify (function)
// Arg ARG cv::Mat (boxed) cameraMatrix1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) distCoeffs1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) cameraMatrix2= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) distCoeffs2= cv::Mat (boxed) = 
// Arg ARG cv::Size (simple) imageSize= cv::Size (simple) = 
// Arg ARG cv::Mat (boxed) R= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) T= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) R1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) R2= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) P1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) P2= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) Q= cv::Mat (boxed) = 
// Arg ARG Primitive(int) flags= Primitive(int) = CALIB_ZERO_DISPARITY
// Arg ARG Primitive(double) alpha= Primitive(double) = -1
// Arg ARG cv::Size (simple) newImageSize= cv::Size (simple) = Size()
// Arg ARG RawPtr[cv::Rect (simple)] * validPixROI1= (ptr) RawPtr[cv::Rect (simple)] = 0
// Arg ARG RawPtr[cv::Rect (simple)] * validPixROI2= (ptr) RawPtr[cv::Rect (simple)] = 0
// Return value: Primitive(void)
cv_return_value_void cv_core_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_X_validPixROI1_Rect_X_validPixROI2(void* cameraMatrix1, void* distCoeffs1, void* cameraMatrix2, void* distCoeffs2, SizeWrapper imageSize, void* R, void* T, void* R1, void* R2, void* P1, void* P2, void* Q, int flags, double alpha, SizeWrapper newImageSize, cv::Rect* validPixROI1, cv::Rect* validPixROI2) {
    try {
        cv::stereoRectify(*reinterpret_cast<cv::Mat*>(cameraMatrix1), *reinterpret_cast<cv::Mat*>(distCoeffs1), *reinterpret_cast<cv::Mat*>(cameraMatrix2), *reinterpret_cast<cv::Mat*>(distCoeffs2), *reinterpret_cast<cv::Size*>(&imageSize), *reinterpret_cast<cv::Mat*>(R), *reinterpret_cast<cv::Mat*>(T), *reinterpret_cast<cv::Mat*>(R1), *reinterpret_cast<cv::Mat*>(R2), *reinterpret_cast<cv::Mat*>(P1), *reinterpret_cast<cv::Mat*>(P2), *reinterpret_cast<cv::Mat*>(Q), flags, alpha, *reinterpret_cast<cv::Size*>(&newImageSize), reinterpret_cast<cv::Rect*>(&validPixROI1), reinterpret_cast<cv::Rect*>(&validPixROI2));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_stopLoop
// parsed: cv::stopLoop
// as:     cv::stopLoop (function)
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_stopLoop() {
    try {
        cv::stopLoop();
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_stylization_Mat_src_Mat_dst_float_sigma_s_float_sigma_r
// parsed: cv::stylization
// as:     cv::stylization (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG Primitive(float) sigma_s= Primitive(float) = 60
// Arg ARG Primitive(float) sigma_r= Primitive(float) = 0.45f
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_stylization_Mat_src_Mat_dst_float_sigma_s_float_sigma_r(void* src, void* dst, float sigma_s, float sigma_r) {
    try {
        cv::stylization(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst), sigma_s, sigma_r);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_subtract_Mat_src1_Mat_src2_Mat_dst_Mat_mask_int_dtype
// parsed: cv::subtract
// as:     cv::subtract (function)
// Arg ARG cv::Mat (boxed) src1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) src2= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) mask= cv::Mat (boxed) = noArray()
// Arg ARG Primitive(int) dtype= Primitive(int) = -1
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_subtract_Mat_src1_Mat_src2_Mat_dst_Mat_mask_int_dtype(void* src1, void* src2, void* dst, void* mask, int dtype) {
    try {
        cv::subtract(*reinterpret_cast<cv::Mat*>(src1), *reinterpret_cast<cv::Mat*>(src2), *reinterpret_cast<cv::Mat*>(dst), *reinterpret_cast<cv::Mat*>(mask), dtype);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_sum_Mat_src
// parsed: cv::sum
// as:     cv::sum (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Return value: cv::Scalar (simple)
cv_return_value_ScalarWrapper cv_core_cv_sum_Mat_src(void* src) {
    try {
        cv::Scalar ret = cv::sum(*reinterpret_cast<cv::Mat*>(src));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<ScalarWrapper*>(&ret) };
    } CVRS_CATCH(cv_return_value_ScalarWrapper)
}

// cv_superres_createFrameSource_Camera_int_deviceId
// parsed: cv::superres::createFrameSource_Camera
// as:     cv::superres::createFrameSource_Camera (function)
// Arg ARG Primitive(int) deviceId= Primitive(int) = 0
// Return value: SmartPtr[cv::superres::FrameSource (boxed)]
cv_return_value_void_X cv_core_cv_superres_createFrameSource_Camera_int_deviceId(int deviceId) {
    try {
        Ptr<cv::superres::FrameSource> *ret = new Ptr<cv::superres::FrameSource>(cv::superres::createFrameSource_Camera(deviceId));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_superres_createFrameSource_Empty
// parsed: cv::superres::createFrameSource_Empty
// as:     cv::superres::createFrameSource_Empty (function)
// Return value: SmartPtr[cv::superres::FrameSource (boxed)]
cv_return_value_void_X cv_core_cv_superres_createFrameSource_Empty() {
    try {
        Ptr<cv::superres::FrameSource> *ret = new Ptr<cv::superres::FrameSource>(cv::superres::createFrameSource_Empty());
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_superres_createFrameSource_Video_CUDA_String_fileName
// parsed: cv::superres::createFrameSource_Video_CUDA
// as:     cv::superres::createFrameSource_Video_CUDA (function)
// Arg ARG string fileName= string = 
// Return value: SmartPtr[cv::superres::FrameSource (boxed)]
cv_return_value_void_X cv_core_cv_superres_createFrameSource_Video_CUDA_String_fileName(const char* fileName) {
    try {
        Ptr<cv::superres::FrameSource> *ret = new Ptr<cv::superres::FrameSource>(cv::superres::createFrameSource_Video_CUDA(String(fileName)));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_superres_createFrameSource_Video_String_fileName
// parsed: cv::superres::createFrameSource_Video
// as:     cv::superres::createFrameSource_Video (function)
// Arg ARG string fileName= string = 
// Return value: SmartPtr[cv::superres::FrameSource (boxed)]
cv_return_value_void_X cv_core_cv_superres_createFrameSource_Video_String_fileName(const char* fileName) {
    try {
        Ptr<cv::superres::FrameSource> *ret = new Ptr<cv::superres::FrameSource>(cv::superres::createFrameSource_Video(String(fileName)));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_superres_createSuperResolution_BTVL1
// parsed: cv::superres::createSuperResolution_BTVL1
// as:     cv::superres::createSuperResolution_BTVL1 (function)
// Return value: SmartPtr[cv::superres::SuperResolution (boxed)]
cv_return_value_void_X cv_core_cv_superres_createSuperResolution_BTVL1() {
    try {
        Ptr<cv::superres::SuperResolution> *ret = new Ptr<cv::superres::SuperResolution>(cv::superres::createSuperResolution_BTVL1());
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_superres_createSuperResolution_BTVL1_CUDA
// parsed: cv::superres::createSuperResolution_BTVL1_CUDA
// as:     cv::superres::createSuperResolution_BTVL1_CUDA (function)
// Return value: SmartPtr[cv::superres::SuperResolution (boxed)]
cv_return_value_void_X cv_core_cv_superres_createSuperResolution_BTVL1_CUDA() {
    try {
        Ptr<cv::superres::SuperResolution> *ret = new Ptr<cv::superres::SuperResolution>(cv::superres::createSuperResolution_BTVL1_CUDA());
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_swap_Mat_a_Mat_b
// parsed: cv::swap
// as:     cv::swap (function)
// Arg ARG cv::Mat (boxed) a= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) b= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_swap_Mat_a_Mat_b(void* a, void* b) {
    try {
        cv::swap(*reinterpret_cast<cv::Mat*>(a), *reinterpret_cast<cv::Mat*>(b));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_tempfile_const_char_X_suffix
// parsed: cv::tempfile
// as:     cv::tempfile (function)
// Arg ARG RawPtr[Primitive(char)] * suffix= (ptr) RawPtr[Primitive(char)] = 0
// Return value: string
cv_return_value_char_X cv_core_cv_tempfile_const_char_X_suffix(const char* suffix) {
    try {
        String ret = cv::tempfile(suffix);
        return { Error::Code::StsOk, NULL, strdup(ret.c_str()) };
    } CVRS_CATCH(cv_return_value_char_X)
}

// cv_textureFlattening_Mat_src_Mat_mask_Mat_dst_float_low_threshold_float_high_threshold_int_kernel_size
// parsed: cv::textureFlattening
// as:     cv::textureFlattening (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) mask= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG Primitive(float) low_threshold= Primitive(float) = 30
// Arg ARG Primitive(float) high_threshold= Primitive(float) = 45
// Arg ARG Primitive(int) kernel_size= Primitive(int) = 3
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_textureFlattening_Mat_src_Mat_mask_Mat_dst_float_low_threshold_float_high_threshold_int_kernel_size(void* src, void* mask, void* dst, float low_threshold, float high_threshold, int kernel_size) {
    try {
        cv::textureFlattening(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(mask), *reinterpret_cast<cv::Mat*>(dst), low_threshold, high_threshold, kernel_size);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_threshold_Mat_src_Mat_dst_double_thresh_double_maxval_int_type
// parsed: cv::threshold
// as:     cv::threshold (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG Primitive(double) thresh= Primitive(double) = 
// Arg ARG Primitive(double) maxval= Primitive(double) = 
// Arg ARG Primitive(int) type= Primitive(int) = 
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_threshold_Mat_src_Mat_dst_double_thresh_double_maxval_int_type(void* src, void* dst, double thresh, double maxval, int type) {
    try {
        double ret = cv::threshold(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst), thresh, maxval, type);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_trace_Mat_mtx
// parsed: cv::trace
// as:     cv::trace (function)
// Arg ARG cv::Mat (boxed) mtx= cv::Mat (boxed) = 
// Return value: cv::Scalar (simple)
cv_return_value_ScalarWrapper cv_core_cv_trace_Mat_mtx(void* mtx) {
    try {
        cv::Scalar ret = cv::trace(*reinterpret_cast<cv::Mat*>(mtx));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<ScalarWrapper*>(&ret) };
    } CVRS_CATCH(cv_return_value_ScalarWrapper)
}

// cv_transform_Mat_src_Mat_dst_Mat_m
// parsed: cv::transform
// as:     cv::transform (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) m= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_transform_Mat_src_Mat_dst_Mat_m(void* src, void* dst, void* m) {
    try {
        cv::transform(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst), *reinterpret_cast<cv::Mat*>(m));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_transpose_Mat_src_Mat_dst
// parsed: cv::transpose
// as:     cv::transpose (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_transpose_Mat_src_Mat_dst(void* src, void* dst) {
    try {
        cv::transpose(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_triangulatePoints_Mat_projMatr1_Mat_projMatr2_Mat_projPoints1_Mat_projPoints2_Mat_points4D
// parsed: cv::triangulatePoints
// as:     cv::triangulatePoints (function)
// Arg ARG cv::Mat (boxed) projMatr1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) projMatr2= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) projPoints1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) projPoints2= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) points4D= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_triangulatePoints_Mat_projMatr1_Mat_projMatr2_Mat_projPoints1_Mat_projPoints2_Mat_points4D(void* projMatr1, void* projMatr2, void* projPoints1, void* projPoints2, void* points4D) {
    try {
        cv::triangulatePoints(*reinterpret_cast<cv::Mat*>(projMatr1), *reinterpret_cast<cv::Mat*>(projMatr2), *reinterpret_cast<cv::Mat*>(projPoints1), *reinterpret_cast<cv::Mat*>(projPoints2), *reinterpret_cast<cv::Mat*>(points4D));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_undistortPoints_Mat_src_Mat_dst_Mat_cameraMatrix_Mat_distCoeffs_Mat_R_Mat_P
// parsed: cv::undistortPoints
// as:     cv::undistortPoints (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) cameraMatrix= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) distCoeffs= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) R= cv::Mat (boxed) = noArray()
// Arg ARG cv::Mat (boxed) P= cv::Mat (boxed) = noArray()
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_undistortPoints_Mat_src_Mat_dst_Mat_cameraMatrix_Mat_distCoeffs_Mat_R_Mat_P(void* src, void* dst, void* cameraMatrix, void* distCoeffs, void* R, void* P) {
    try {
        cv::undistortPoints(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst), *reinterpret_cast<cv::Mat*>(cameraMatrix), *reinterpret_cast<cv::Mat*>(distCoeffs), *reinterpret_cast<cv::Mat*>(R), *reinterpret_cast<cv::Mat*>(P));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_undistortPoints_Mat_src_Mat_dst_Mat_cameraMatrix_Mat_distCoeffs_Mat_R_Mat_P_TermCriteria_criteria
// parsed: cv::undistortPoints
// as:     cv::undistortPoints (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) cameraMatrix= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) distCoeffs= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) R= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) P= cv::Mat (boxed) = 
// Arg ARG cv::TermCriteria (boxed) criteria= cv::TermCriteria (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_undistortPoints_Mat_src_Mat_dst_Mat_cameraMatrix_Mat_distCoeffs_Mat_R_Mat_P_TermCriteria_criteria(void* src, void* dst, void* cameraMatrix, void* distCoeffs, void* R, void* P, void* criteria) {
    try {
        cv::undistortPoints(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst), *reinterpret_cast<cv::Mat*>(cameraMatrix), *reinterpret_cast<cv::Mat*>(distCoeffs), *reinterpret_cast<cv::Mat*>(R), *reinterpret_cast<cv::Mat*>(P), *reinterpret_cast<cv::TermCriteria*>(criteria));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_undistort_Mat_src_Mat_dst_Mat_cameraMatrix_Mat_distCoeffs_Mat_newCameraMatrix
// parsed: cv::undistort
// as:     cv::undistort (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) cameraMatrix= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) distCoeffs= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) newCameraMatrix= cv::Mat (boxed) = noArray()
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_undistort_Mat_src_Mat_dst_Mat_cameraMatrix_Mat_distCoeffs_Mat_newCameraMatrix(void* src, void* dst, void* cameraMatrix, void* distCoeffs, void* newCameraMatrix) {
    try {
        cv::undistort(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst), *reinterpret_cast<cv::Mat*>(cameraMatrix), *reinterpret_cast<cv::Mat*>(distCoeffs), *reinterpret_cast<cv::Mat*>(newCameraMatrix));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_updateWindow_String_winname
// parsed: cv::updateWindow
// as:     cv::updateWindow (function)
// Arg ARG string winname= string = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_updateWindow_String_winname(const char* winname) {
    try {
        cv::updateWindow(String(winname));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_useOpenVX
// parsed: cv::useOpenVX
// as:     cv::useOpenVX (function)
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_useOpenVX() {
    try {
        bool ret = cv::useOpenVX();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_useOptimized
// parsed: cv::useOptimized
// as:     cv::useOptimized (function)
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_useOptimized() {
    try {
        bool ret = cv::useOptimized();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_utils_getThreadID
// parsed: cv::utils::getThreadID
// as:     cv::utils::getThreadID (function)
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_utils_getThreadID() {
    try {
        int ret = cv::utils::getThreadID();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_va_intel_convertFromVASurface_void_X_display_unsigned_int_surface_Size_size_Mat_dst
// parsed: cv::va_intel::convertFromVASurface
// as:     cv::va_intel::convertFromVASurface (function)
// Arg ARG RawPtr[Primitive(void)] * display= (ptr) RawPtr[Primitive(void)] = 
// Arg ARG Primitive(unsigned int) surface= Primitive(unsigned int) = 
// Arg ARG cv::Size (simple) size= cv::Size (simple) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_va_intel_convertFromVASurface_void_X_display_unsigned_int_surface_Size_size_Mat_dst(void* display, unsigned int surface, SizeWrapper size, void* dst) {
    try {
        cv::va_intel::convertFromVASurface(display, surface, *reinterpret_cast<cv::Size*>(&size), *reinterpret_cast<cv::Mat*>(dst));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_va_intel_convertToVASurface_void_X_display_Mat_src_unsigned_int_surface_Size_size
// parsed: cv::va_intel::convertToVASurface
// as:     cv::va_intel::convertToVASurface (function)
// Arg ARG RawPtr[Primitive(void)] * display= (ptr) RawPtr[Primitive(void)] = 
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG Primitive(unsigned int) surface= Primitive(unsigned int) = 
// Arg ARG cv::Size (simple) size= cv::Size (simple) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_va_intel_convertToVASurface_void_X_display_Mat_src_unsigned_int_surface_Size_size(void* display, void* src, unsigned int surface, SizeWrapper size) {
    try {
        cv::va_intel::convertToVASurface(display, *reinterpret_cast<cv::Mat*>(src), surface, *reinterpret_cast<cv::Size*>(&size));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_validateDisparity_Mat_disparity_Mat_cost_int_minDisparity_int_numberOfDisparities_int_disp12MaxDisp
// parsed: cv::validateDisparity
// as:     cv::validateDisparity (function)
// Arg ARG cv::Mat (boxed) disparity= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) cost= cv::Mat (boxed) = 
// Arg ARG Primitive(int) minDisparity= Primitive(int) = 
// Arg ARG Primitive(int) numberOfDisparities= Primitive(int) = 
// Arg ARG Primitive(int) disp12MaxDisp= Primitive(int) = 1
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_validateDisparity_Mat_disparity_Mat_cost_int_minDisparity_int_numberOfDisparities_int_disp12MaxDisp(void* disparity, void* cost, int minDisparity, int numberOfDisparities, int disp12MaxDisp) {
    try {
        cv::validateDisparity(*reinterpret_cast<cv::Mat*>(disparity), *reinterpret_cast<cv::Mat*>(cost), minDisparity, numberOfDisparities, disp12MaxDisp);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_vconcat_Mat_src1_Mat_src2_Mat_dst
// parsed: cv::vconcat
// as:     cv::vconcat (function)
// Arg ARG cv::Mat (boxed) src1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) src2= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_vconcat_Mat_src1_Mat_src2_Mat_dst(void* src1, void* src2, void* dst) {
    try {
        cv::vconcat(*reinterpret_cast<cv::Mat*>(src1), *reinterpret_cast<cv::Mat*>(src2), *reinterpret_cast<cv::Mat*>(dst));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_vconcat_VectorOfMat_src_Mat_dst
// parsed: cv::vconcat
// as:     cv::vconcat (function)
// Arg ARG Vector[cv::Mat (boxed)] src= Vector[cv::Mat (boxed)] = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_vconcat_VectorOfMat_src_Mat_dst(void* src, void* dst) {
    try {
        cv::vconcat(*reinterpret_cast<std::vector<cv::Mat>*>(src), *reinterpret_cast<cv::Mat*>(dst));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_vconcat_const_Mat_src_size_t_nsrc_Mat_dst
// parsed: cv::vconcat
// as:     cv::vconcat (function)
// Arg ARG RawPtr[cv::Mat (boxed)] * src= (ptr) RawPtr[cv::Mat (boxed)] = 
// Arg ARG Primitive(size_t) nsrc= Primitive(size_t) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_vconcat_const_Mat_src_size_t_nsrc_Mat_dst(const void* src, std::size_t nsrc, void* dst) {
    try {
        cv::vconcat(reinterpret_cast<const cv::Mat*>(src), nsrc, *reinterpret_cast<cv::Mat*>(dst));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_videostab_calcBlurriness_Mat_frame
// parsed: cv::videostab::calcBlurriness
// as:     cv::videostab::calcBlurriness (function)
// Arg ARG cv::Mat (boxed) frame= cv::Mat (boxed) = 
// Return value: Primitive(float)
cv_return_value_float cv_core_cv_videostab_calcBlurriness_Mat_frame(void* frame) {
    try {
        float ret = cv::videostab::calcBlurriness(*reinterpret_cast<cv::Mat*>(frame));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<float*>(&ret) };
    } CVRS_CATCH(cv_return_value_float)
}

// cv_videostab_calcFlowMask_Mat_flowX_Mat_flowY_Mat_errors_float_maxError_Mat_mask0_Mat_mask1_Mat_flowMask
// parsed: cv::videostab::calcFlowMask
// as:     cv::videostab::calcFlowMask (function)
// Arg ARG cv::Mat (boxed) flowX= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) flowY= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) errors= cv::Mat (boxed) = 
// Arg ARG Primitive(float) maxError= Primitive(float) = 
// Arg ARG cv::Mat (boxed) mask0= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) mask1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) flowMask= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_videostab_calcFlowMask_Mat_flowX_Mat_flowY_Mat_errors_float_maxError_Mat_mask0_Mat_mask1_Mat_flowMask(void* flowX, void* flowY, void* errors, float maxError, void* mask0, void* mask1, void* flowMask) {
    try {
        cv::videostab::calcFlowMask(*reinterpret_cast<cv::Mat*>(flowX), *reinterpret_cast<cv::Mat*>(flowY), *reinterpret_cast<cv::Mat*>(errors), maxError, *reinterpret_cast<cv::Mat*>(mask0), *reinterpret_cast<cv::Mat*>(mask1), *reinterpret_cast<cv::Mat*>(flowMask));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_videostab_completeFrameAccordingToFlow_Mat_flowMask_Mat_flowX_Mat_flowY_Mat_frame1_Mat_mask1_float_distThresh_Mat_frame0_Mat_mask0
// parsed: cv::videostab::completeFrameAccordingToFlow
// as:     cv::videostab::completeFrameAccordingToFlow (function)
// Arg ARG cv::Mat (boxed) flowMask= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) flowX= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) flowY= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) frame1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) mask1= cv::Mat (boxed) = 
// Arg ARG Primitive(float) distThresh= Primitive(float) = 
// Arg ARG cv::Mat (boxed) frame0= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) mask0= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_videostab_completeFrameAccordingToFlow_Mat_flowMask_Mat_flowX_Mat_flowY_Mat_frame1_Mat_mask1_float_distThresh_Mat_frame0_Mat_mask0(void* flowMask, void* flowX, void* flowY, void* frame1, void* mask1, float distThresh, void* frame0, void* mask0) {
    try {
        cv::videostab::completeFrameAccordingToFlow(*reinterpret_cast<cv::Mat*>(flowMask), *reinterpret_cast<cv::Mat*>(flowX), *reinterpret_cast<cv::Mat*>(flowY), *reinterpret_cast<cv::Mat*>(frame1), *reinterpret_cast<cv::Mat*>(mask1), distThresh, *reinterpret_cast<cv::Mat*>(frame0), *reinterpret_cast<cv::Mat*>(mask0));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_videostab_ensureInclusionConstraint_Mat_M_Size_size_float_trimRatio
// parsed: cv::videostab::ensureInclusionConstraint
// as:     cv::videostab::ensureInclusionConstraint (function)
// Arg ARG cv::Mat (boxed) M= cv::Mat (boxed) = 
// Arg ARG cv::Size (simple) size= cv::Size (simple) = 
// Arg ARG Primitive(float) trimRatio= Primitive(float) = 
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_videostab_ensureInclusionConstraint_Mat_M_Size_size_float_trimRatio(void* M, SizeWrapper size, float trimRatio) {
    try {
        cv::Mat ret = cv::videostab::ensureInclusionConstraint(*reinterpret_cast<cv::Mat*>(M), *reinterpret_cast<cv::Size*>(&size), trimRatio);
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_videostab_estimateGlobalMotionLeastSquares_Mat_points0_Mat_points1_int_model_float_X_rmse
// parsed: cv::videostab::estimateGlobalMotionLeastSquares
// as:     cv::videostab::estimateGlobalMotionLeastSquares (function)
// Arg ARG cv::Mat (boxed) points0= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) points1= cv::Mat (boxed) = 
// Arg ARG Primitive(int) model= Primitive(int) = MM_AFFINE
// Arg ARG RawPtr[Primitive(float)] * rmse= (ptr) RawPtr[Primitive(float)] = 0
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_videostab_estimateGlobalMotionLeastSquares_Mat_points0_Mat_points1_int_model_float_X_rmse(void* points0, void* points1, int model, float* rmse) {
    try {
        cv::Mat ret = cv::videostab::estimateGlobalMotionLeastSquares(*reinterpret_cast<cv::Mat*>(points0), *reinterpret_cast<cv::Mat*>(points1), model, rmse);
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_videostab_estimateOptimalTrimRatio_Mat_M_Size_size
// parsed: cv::videostab::estimateOptimalTrimRatio
// as:     cv::videostab::estimateOptimalTrimRatio (function)
// Arg ARG cv::Mat (boxed) M= cv::Mat (boxed) = 
// Arg ARG cv::Size (simple) size= cv::Size (simple) = 
// Return value: Primitive(float)
cv_return_value_float cv_core_cv_videostab_estimateOptimalTrimRatio_Mat_M_Size_size(void* M, SizeWrapper size) {
    try {
        float ret = cv::videostab::estimateOptimalTrimRatio(*reinterpret_cast<cv::Mat*>(M), *reinterpret_cast<cv::Size*>(&size));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<float*>(&ret) };
    } CVRS_CATCH(cv_return_value_float)
}

// cv_videostab_getMotion_int_from_int_to_VectorOfMat_motions
// parsed: cv::videostab::getMotion
// as:     cv::videostab::getMotion (function)
// Arg ARG Primitive(int) from= Primitive(int) = 
// Arg ARG Primitive(int) to= Primitive(int) = 
// Arg ARG Vector[cv::Mat (boxed)] motions= Vector[cv::Mat (boxed)] = 
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_videostab_getMotion_int_from_int_to_VectorOfMat_motions(int from, int to, void* motions) {
    try {
        cv::Mat ret = cv::videostab::getMotion(from, to, *reinterpret_cast<std::vector<cv::Mat>*>(motions));
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_waitKeyEx_int_delay
// parsed: cv::waitKeyEx
// as:     cv::waitKeyEx (function)
// Arg ARG Primitive(int) delay= Primitive(int) = 0
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_waitKeyEx_int_delay(int delay) {
    try {
        int ret = cv::waitKeyEx(delay);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_waitKey_int_delay
// parsed: cv::waitKey
// as:     cv::waitKey (function)
// Arg ARG Primitive(int) delay= Primitive(int) = 0
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_waitKey_int_delay(int delay) {
    try {
        int ret = cv::waitKey(delay);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_warpAffine_Mat_src_Mat_dst_Mat_M_Size_dsize_int_flags_int_borderMode_Scalar_borderValue
// parsed: cv::warpAffine
// as:     cv::warpAffine (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) M= cv::Mat (boxed) = 
// Arg ARG cv::Size (simple) dsize= cv::Size (simple) = 
// Arg ARG Primitive(int) flags= Primitive(int) = INTER_LINEAR
// Arg ARG Primitive(int) borderMode= Primitive(int) = BORDER_CONSTANT
// Arg ARG cv::Scalar (simple) borderValue= cv::Scalar (simple) = Scalar()
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_warpAffine_Mat_src_Mat_dst_Mat_M_Size_dsize_int_flags_int_borderMode_Scalar_borderValue(void* src, void* dst, void* M, SizeWrapper dsize, int flags, int borderMode, ScalarWrapper borderValue) {
    try {
        cv::warpAffine(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst), *reinterpret_cast<cv::Mat*>(M), *reinterpret_cast<cv::Size*>(&dsize), flags, borderMode, *reinterpret_cast<cv::Scalar*>(&borderValue));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_warpPerspective_Mat_src_Mat_dst_Mat_M_Size_dsize_int_flags_int_borderMode_Scalar_borderValue
// parsed: cv::warpPerspective
// as:     cv::warpPerspective (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) M= cv::Mat (boxed) = 
// Arg ARG cv::Size (simple) dsize= cv::Size (simple) = 
// Arg ARG Primitive(int) flags= Primitive(int) = INTER_LINEAR
// Arg ARG Primitive(int) borderMode= Primitive(int) = BORDER_CONSTANT
// Arg ARG cv::Scalar (simple) borderValue= cv::Scalar (simple) = Scalar()
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_warpPerspective_Mat_src_Mat_dst_Mat_M_Size_dsize_int_flags_int_borderMode_Scalar_borderValue(void* src, void* dst, void* M, SizeWrapper dsize, int flags, int borderMode, ScalarWrapper borderValue) {
    try {
        cv::warpPerspective(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst), *reinterpret_cast<cv::Mat*>(M), *reinterpret_cast<cv::Size*>(&dsize), flags, borderMode, *reinterpret_cast<cv::Scalar*>(&borderValue));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_warpPolar_Mat_src_Mat_dst_Size_dsize_Point2f_center_double_maxRadius_int_flags
// parsed: cv::warpPolar
// as:     cv::warpPolar (function)
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG cv::Size (simple) dsize= cv::Size (simple) = 
// Arg ARG cv::Point2f (simple) center= cv::Point2f (simple) = 
// Arg ARG Primitive(double) maxRadius= Primitive(double) = 
// Arg ARG Primitive(int) flags= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_warpPolar_Mat_src_Mat_dst_Size_dsize_Point2f_center_double_maxRadius_int_flags(void* src, void* dst, SizeWrapper dsize, Point2fWrapper center, double maxRadius, int flags) {
    try {
        cv::warpPolar(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst), *reinterpret_cast<cv::Size*>(&dsize), *reinterpret_cast<cv::Point2f*>(&center), maxRadius, flags);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_watershed_Mat_image_Mat_markers
// parsed: cv::watershed
// as:     cv::watershed (function)
// Arg ARG cv::Mat (boxed) image= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) markers= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_watershed_Mat_image_Mat_markers(void* image, void* markers) {
    try {
        cv::watershed(*reinterpret_cast<cv::Mat*>(image), *reinterpret_cast<cv::Mat*>(markers));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_wrapperEMD_Mat_signature1_Mat_signature2_int_distType_Mat_cost_PtrOffloat_lowerBound_Mat_flow
// parsed: cv::wrapperEMD
// as:     cv::wrapperEMD (function)
// Arg ARG cv::Mat (boxed) signature1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) signature2= cv::Mat (boxed) = 
// Arg ARG Primitive(int) distType= Primitive(int) = 
// Arg ARG cv::Mat (boxed) cost= cv::Mat (boxed) = noArray()
// Arg ARG SmartPtr[Primitive(float)] lowerBound= SmartPtr[Primitive(float)] = Ptr<float>()
// Arg ARG cv::Mat (boxed) flow= cv::Mat (boxed) = noArray()
// Return value: Primitive(float)
cv_return_value_float cv_core_cv_wrapperEMD_Mat_signature1_Mat_signature2_int_distType_Mat_cost_PtrOffloat_lowerBound_Mat_flow(void* signature1, void* signature2, int distType, void* cost, void* lowerBound, void* flow) {
    try {
        float ret = cv::wrapperEMD(*reinterpret_cast<cv::Mat*>(signature1), *reinterpret_cast<cv::Mat*>(signature2), distType, *reinterpret_cast<cv::Mat*>(cost), reinterpret_cast<float*>(lowerBound), *reinterpret_cast<cv::Mat*>(flow));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<float*>(&ret) };
    } CVRS_CATCH(cv_return_value_float)
}

// cv_AKAZE_setDescriptorType_int_dtype
// parsed: cv::AKAZE::setDescriptorType
// as:     cv::AKAZE::setDescriptorType (method) cv::AKAZE (trait) . setDescriptorType
// Arg ARG Primitive(int) dtype= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_AKAZE_setDescriptorType_int_dtype(void* instance, int dtype) {
    try {
        reinterpret_cast<cv::AKAZE*>(instance)->setDescriptorType(dtype);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_AKAZE_getDescriptorType_const
// parsed: cv::AKAZE::getDescriptorType
// as:     cv::AKAZE::getDescriptorType (method) cv::AKAZE (trait) . getDescriptorType
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_AKAZE_getDescriptorType_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::AKAZE*>(instance)->getDescriptorType();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_AKAZE_setDescriptorSize_int_dsize
// parsed: cv::AKAZE::setDescriptorSize
// as:     cv::AKAZE::setDescriptorSize (method) cv::AKAZE (trait) . setDescriptorSize
// Arg ARG Primitive(int) dsize= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_AKAZE_setDescriptorSize_int_dsize(void* instance, int dsize) {
    try {
        reinterpret_cast<cv::AKAZE*>(instance)->setDescriptorSize(dsize);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_AKAZE_getDescriptorSize_const
// parsed: cv::AKAZE::getDescriptorSize
// as:     cv::AKAZE::getDescriptorSize (method) cv::AKAZE (trait) . getDescriptorSize
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_AKAZE_getDescriptorSize_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::AKAZE*>(instance)->getDescriptorSize();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_AKAZE_setDescriptorChannels_int_dch
// parsed: cv::AKAZE::setDescriptorChannels
// as:     cv::AKAZE::setDescriptorChannels (method) cv::AKAZE (trait) . setDescriptorChannels
// Arg ARG Primitive(int) dch= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_AKAZE_setDescriptorChannels_int_dch(void* instance, int dch) {
    try {
        reinterpret_cast<cv::AKAZE*>(instance)->setDescriptorChannels(dch);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_AKAZE_getDescriptorChannels_const
// parsed: cv::AKAZE::getDescriptorChannels
// as:     cv::AKAZE::getDescriptorChannels (method) cv::AKAZE (trait) . getDescriptorChannels
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_AKAZE_getDescriptorChannels_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::AKAZE*>(instance)->getDescriptorChannels();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_AKAZE_setThreshold_double_threshold
// parsed: cv::AKAZE::setThreshold
// as:     cv::AKAZE::setThreshold (method) cv::AKAZE (trait) . setThreshold
// Arg ARG Primitive(double) threshold= Primitive(double) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_AKAZE_setThreshold_double_threshold(void* instance, double threshold) {
    try {
        reinterpret_cast<cv::AKAZE*>(instance)->setThreshold(threshold);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_AKAZE_getThreshold_const
// parsed: cv::AKAZE::getThreshold
// as:     cv::AKAZE::getThreshold (method) cv::AKAZE (trait) . getThreshold
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_AKAZE_getThreshold_const(void* instance) {
    try {
        double ret = reinterpret_cast<cv::AKAZE*>(instance)->getThreshold();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_AKAZE_setNOctaves_int_octaves
// parsed: cv::AKAZE::setNOctaves
// as:     cv::AKAZE::setNOctaves (method) cv::AKAZE (trait) . setNOctaves
// Arg ARG Primitive(int) octaves= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_AKAZE_setNOctaves_int_octaves(void* instance, int octaves) {
    try {
        reinterpret_cast<cv::AKAZE*>(instance)->setNOctaves(octaves);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_AKAZE_getNOctaves_const
// parsed: cv::AKAZE::getNOctaves
// as:     cv::AKAZE::getNOctaves (method) cv::AKAZE (trait) . getNOctaves
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_AKAZE_getNOctaves_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::AKAZE*>(instance)->getNOctaves();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_AKAZE_setNOctaveLayers_int_octaveLayers
// parsed: cv::AKAZE::setNOctaveLayers
// as:     cv::AKAZE::setNOctaveLayers (method) cv::AKAZE (trait) . setNOctaveLayers
// Arg ARG Primitive(int) octaveLayers= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_AKAZE_setNOctaveLayers_int_octaveLayers(void* instance, int octaveLayers) {
    try {
        reinterpret_cast<cv::AKAZE*>(instance)->setNOctaveLayers(octaveLayers);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_AKAZE_getNOctaveLayers_const
// parsed: cv::AKAZE::getNOctaveLayers
// as:     cv::AKAZE::getNOctaveLayers (method) cv::AKAZE (trait) . getNOctaveLayers
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_AKAZE_getNOctaveLayers_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::AKAZE*>(instance)->getNOctaveLayers();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_AKAZE_setDiffusivity_int_diff
// parsed: cv::AKAZE::setDiffusivity
// as:     cv::AKAZE::setDiffusivity (method) cv::AKAZE (trait) . setDiffusivity
// Arg ARG Primitive(int) diff= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_AKAZE_setDiffusivity_int_diff(void* instance, int diff) {
    try {
        reinterpret_cast<cv::AKAZE*>(instance)->setDiffusivity(diff);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_AKAZE_getDiffusivity_const
// parsed: cv::AKAZE::getDiffusivity
// as:     cv::AKAZE::getDiffusivity (method) cv::AKAZE (trait) . getDiffusivity
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_AKAZE_getDiffusivity_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::AKAZE*>(instance)->getDiffusivity();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_AKAZE_getDefaultName_const
// parsed: cv::AKAZE::getDefaultName
// as:     cv::AKAZE::getDefaultName (method) cv::AKAZE (trait) . getDefaultName
// Return value: string
cv_return_value_char_X cv_core_cv_AKAZE_getDefaultName_const(void* instance) {
    try {
        String ret = reinterpret_cast<cv::AKAZE*>(instance)->getDefaultName();
        return { Error::Code::StsOk, NULL, strdup(ret.c_str()) };
    } CVRS_CATCH(cv_return_value_char_X)
}

// cv_AKAZE_create_int_descriptor_type_int_descriptor_size_int_descriptor_channels_float_threshold_int_nOctaves_int_nOctaveLayers_int_diffusivity
// parsed: cv::AKAZE::create
// as:     cv::AKAZE::create (method) cv::AKAZE (trait) . create
// Arg ARG Primitive(int) descriptor_type= Primitive(int) = AKAZE::DESCRIPTOR_MLDB
// Arg ARG Primitive(int) descriptor_size= Primitive(int) = 0
// Arg ARG Primitive(int) descriptor_channels= Primitive(int) = 3
// Arg ARG Primitive(float) threshold= Primitive(float) = 0.001f
// Arg ARG Primitive(int) nOctaves= Primitive(int) = 4
// Arg ARG Primitive(int) nOctaveLayers= Primitive(int) = 4
// Arg ARG Primitive(int) diffusivity= Primitive(int) = KAZE::DIFF_PM_G2
// Return value: SmartPtr[cv::AKAZE (boxed)]
cv_return_value_void_X cv_core_cv_AKAZE_create_int_descriptor_type_int_descriptor_size_int_descriptor_channels_float_threshold_int_nOctaves_int_nOctaveLayers_int_diffusivity(int descriptor_type, int descriptor_size, int descriptor_channels, float threshold, int nOctaves, int nOctaveLayers, int diffusivity) {
    try {
        Ptr<cv::AKAZE> *ret = new Ptr<cv::AKAZE>(cv::AKAZE::create(descriptor_type, descriptor_size, descriptor_channels, threshold, nOctaves, nOctaveLayers, diffusivity));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_AffineTransformer_setFullAffine_bool_fullAffine
// parsed: cv::AffineTransformer::setFullAffine
// as:     cv::AffineTransformer::setFullAffine (method) cv::AffineTransformer (trait) . setFullAffine
// Arg ARG Primitive(bool) fullAffine= Primitive(bool) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_AffineTransformer_setFullAffine_bool_fullAffine(void* instance, bool fullAffine) {
    try {
        reinterpret_cast<cv::AffineTransformer*>(instance)->setFullAffine(fullAffine);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_AffineTransformer_getFullAffine_const
// parsed: cv::AffineTransformer::getFullAffine
// as:     cv::AffineTransformer::getFullAffine (method) cv::AffineTransformer (trait) . getFullAffine
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_AffineTransformer_getFullAffine_const(void* instance) {
    try {
        bool ret = reinterpret_cast<cv::AffineTransformer*>(instance)->getFullAffine();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// boxed class: cv::AffineWarper
void cv_delete_AffineWarper(void* instance) {
    delete (cv::AffineWarper*) instance;
}
// cv_AgastFeatureDetector_setThreshold_int_threshold
// parsed: cv::AgastFeatureDetector::setThreshold
// as:     cv::AgastFeatureDetector::setThreshold (method) cv::AgastFeatureDetector (trait) . setThreshold
// Arg ARG Primitive(int) threshold= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_AgastFeatureDetector_setThreshold_int_threshold(void* instance, int threshold) {
    try {
        reinterpret_cast<cv::AgastFeatureDetector*>(instance)->setThreshold(threshold);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_AgastFeatureDetector_getThreshold_const
// parsed: cv::AgastFeatureDetector::getThreshold
// as:     cv::AgastFeatureDetector::getThreshold (method) cv::AgastFeatureDetector (trait) . getThreshold
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_AgastFeatureDetector_getThreshold_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::AgastFeatureDetector*>(instance)->getThreshold();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_AgastFeatureDetector_setNonmaxSuppression_bool_f
// parsed: cv::AgastFeatureDetector::setNonmaxSuppression
// as:     cv::AgastFeatureDetector::setNonmaxSuppression (method) cv::AgastFeatureDetector (trait) . setNonmaxSuppression
// Arg ARG Primitive(bool) f= Primitive(bool) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_AgastFeatureDetector_setNonmaxSuppression_bool_f(void* instance, bool f) {
    try {
        reinterpret_cast<cv::AgastFeatureDetector*>(instance)->setNonmaxSuppression(f);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_AgastFeatureDetector_getNonmaxSuppression_const
// parsed: cv::AgastFeatureDetector::getNonmaxSuppression
// as:     cv::AgastFeatureDetector::getNonmaxSuppression (method) cv::AgastFeatureDetector (trait) . getNonmaxSuppression
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_AgastFeatureDetector_getNonmaxSuppression_const(void* instance) {
    try {
        bool ret = reinterpret_cast<cv::AgastFeatureDetector*>(instance)->getNonmaxSuppression();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_AgastFeatureDetector_setType_int_type
// parsed: cv::AgastFeatureDetector::setType
// as:     cv::AgastFeatureDetector::setType (method) cv::AgastFeatureDetector (trait) . setType
// Arg ARG Primitive(int) type= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_AgastFeatureDetector_setType_int_type(void* instance, int type) {
    try {
        reinterpret_cast<cv::AgastFeatureDetector*>(instance)->setType(type);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_AgastFeatureDetector_getType_const
// parsed: cv::AgastFeatureDetector::getType
// as:     cv::AgastFeatureDetector::getType (method) cv::AgastFeatureDetector (trait) . getType
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_AgastFeatureDetector_getType_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::AgastFeatureDetector*>(instance)->getType();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_AgastFeatureDetector_getDefaultName_const
// parsed: cv::AgastFeatureDetector::getDefaultName
// as:     cv::AgastFeatureDetector::getDefaultName (method) cv::AgastFeatureDetector (trait) . getDefaultName
// Return value: string
cv_return_value_char_X cv_core_cv_AgastFeatureDetector_getDefaultName_const(void* instance) {
    try {
        String ret = reinterpret_cast<cv::AgastFeatureDetector*>(instance)->getDefaultName();
        return { Error::Code::StsOk, NULL, strdup(ret.c_str()) };
    } CVRS_CATCH(cv_return_value_char_X)
}

// cv_AgastFeatureDetector_create_int_threshold_bool_nonmaxSuppression_int_type
// parsed: cv::AgastFeatureDetector::create
// as:     cv::AgastFeatureDetector::create (method) cv::AgastFeatureDetector (trait) . create
// Arg ARG Primitive(int) threshold= Primitive(int) = 10
// Arg ARG Primitive(bool) nonmaxSuppression= Primitive(bool) = true
// Arg ARG Primitive(int) type= Primitive(int) = AgastFeatureDetector::OAST_9_16
// Return value: SmartPtr[cv::AgastFeatureDetector (boxed)]
cv_return_value_void_X cv_core_cv_AgastFeatureDetector_create_int_threshold_bool_nonmaxSuppression_int_type(int threshold, bool nonmaxSuppression, int type) {
    try {
        Ptr<cv::AgastFeatureDetector> *ret = new Ptr<cv::AgastFeatureDetector>(cv::AgastFeatureDetector::create(threshold, nonmaxSuppression, type));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_Algorithm_clear
// parsed: cv::Algorithm::clear
// as:     cv::Algorithm::clear (method) cv::Algorithm (trait) . clear
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_Algorithm_clear(void* instance) {
    try {
        reinterpret_cast<cv::Algorithm*>(instance)->clear();
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_Algorithm_empty_const
// parsed: cv::Algorithm::empty
// as:     cv::Algorithm::empty (method) cv::Algorithm (trait) . empty
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_Algorithm_empty_const(void* instance) {
    try {
        bool ret = reinterpret_cast<cv::Algorithm*>(instance)->empty();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_Algorithm_save_const_String_filename
// parsed: cv::Algorithm::save
// as:     cv::Algorithm::save (method) cv::Algorithm (trait) . save
// Arg ARG string filename= string = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_Algorithm_save_const_String_filename(void* instance, const char* filename) {
    try {
        reinterpret_cast<cv::Algorithm*>(instance)->save(String(filename));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_Algorithm_getDefaultName_const
// parsed: cv::Algorithm::getDefaultName
// as:     cv::Algorithm::getDefaultName (method) cv::Algorithm (trait) . getDefaultName
// Return value: string
cv_return_value_char_X cv_core_cv_Algorithm_getDefaultName_const(void* instance) {
    try {
        String ret = reinterpret_cast<cv::Algorithm*>(instance)->getDefaultName();
        return { Error::Code::StsOk, NULL, strdup(ret.c_str()) };
    } CVRS_CATCH(cv_return_value_char_X)
}

// cv_AlignExposures_process_VectorOfMat_src_VectorOfMat_dst_Mat_times_Mat_response
// parsed: cv::AlignExposures::process
// as:     cv::AlignExposures::process (method) cv::AlignExposures (trait) . process
// Arg ARG Vector[cv::Mat (boxed)] src= Vector[cv::Mat (boxed)] = 
// Arg ARG Vector[cv::Mat (boxed)] dst= Vector[cv::Mat (boxed)] = 
// Arg ARG cv::Mat (boxed) times= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) response= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_AlignExposures_process_VectorOfMat_src_VectorOfMat_dst_Mat_times_Mat_response(void* instance, void* src, void* dst, void* times, void* response) {
    try {
        reinterpret_cast<cv::AlignExposures*>(instance)->process(*reinterpret_cast<std::vector<cv::Mat>*>(src), *reinterpret_cast<std::vector<cv::Mat>*>(dst), *reinterpret_cast<cv::Mat*>(times), *reinterpret_cast<cv::Mat*>(response));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_AlignMTB_process_VectorOfMat_src_VectorOfMat_dst_Mat_times_Mat_response
// parsed: cv::AlignMTB::process
// as:     cv::AlignMTB::process (method) cv::AlignMTB (trait) . process
// Arg ARG Vector[cv::Mat (boxed)] src= Vector[cv::Mat (boxed)] = 
// Arg ARG Vector[cv::Mat (boxed)] dst= Vector[cv::Mat (boxed)] = 
// Arg ARG cv::Mat (boxed) times= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) response= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_AlignMTB_process_VectorOfMat_src_VectorOfMat_dst_Mat_times_Mat_response(void* instance, void* src, void* dst, void* times, void* response) {
    try {
        reinterpret_cast<cv::AlignMTB*>(instance)->process(*reinterpret_cast<std::vector<cv::Mat>*>(src), *reinterpret_cast<std::vector<cv::Mat>*>(dst), *reinterpret_cast<cv::Mat*>(times), *reinterpret_cast<cv::Mat*>(response));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_AlignMTB_process_VectorOfMat_src_VectorOfMat_dst
// parsed: cv::AlignMTB::process
// as:     cv::AlignMTB::process (method) cv::AlignMTB (trait) . process
// Arg ARG Vector[cv::Mat (boxed)] src= Vector[cv::Mat (boxed)] = 
// Arg ARG Vector[cv::Mat (boxed)] dst= Vector[cv::Mat (boxed)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_AlignMTB_process_VectorOfMat_src_VectorOfMat_dst(void* instance, void* src, void* dst) {
    try {
        reinterpret_cast<cv::AlignMTB*>(instance)->process(*reinterpret_cast<std::vector<cv::Mat>*>(src), *reinterpret_cast<std::vector<cv::Mat>*>(dst));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_AlignMTB_calculateShift_Mat_img0_Mat_img1
// parsed: cv::AlignMTB::calculateShift
// as:     cv::AlignMTB::calculateShift (method) cv::AlignMTB (trait) . calculateShift
// Arg ARG cv::Mat (boxed) img0= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) img1= cv::Mat (boxed) = 
// Return value: cv::Point (simple)
cv_return_value_PointWrapper cv_core_cv_AlignMTB_calculateShift_Mat_img0_Mat_img1(void* instance, void* img0, void* img1) {
    try {
        cv::Point ret = reinterpret_cast<cv::AlignMTB*>(instance)->calculateShift(*reinterpret_cast<cv::Mat*>(img0), *reinterpret_cast<cv::Mat*>(img1));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<PointWrapper*>(&ret) };
    } CVRS_CATCH(cv_return_value_PointWrapper)
}

// cv_AlignMTB_shiftMat_Mat_src_Mat_dst_Point_shift
// parsed: cv::AlignMTB::shiftMat
// as:     cv::AlignMTB::shiftMat (method) cv::AlignMTB (trait) . shiftMat
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG cv::Point (simple) shift= cv::Point (simple) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_AlignMTB_shiftMat_Mat_src_Mat_dst_Point_shift(void* instance, void* src, void* dst, PointWrapper shift) {
    try {
        reinterpret_cast<cv::AlignMTB*>(instance)->shiftMat(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst), *reinterpret_cast<cv::Point*>(&shift));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_AlignMTB_computeBitmaps_Mat_img_Mat_tb_Mat_eb
// parsed: cv::AlignMTB::computeBitmaps
// as:     cv::AlignMTB::computeBitmaps (method) cv::AlignMTB (trait) . computeBitmaps
// Arg ARG cv::Mat (boxed) img= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) tb= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) eb= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_AlignMTB_computeBitmaps_Mat_img_Mat_tb_Mat_eb(void* instance, void* img, void* tb, void* eb) {
    try {
        reinterpret_cast<cv::AlignMTB*>(instance)->computeBitmaps(*reinterpret_cast<cv::Mat*>(img), *reinterpret_cast<cv::Mat*>(tb), *reinterpret_cast<cv::Mat*>(eb));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_AlignMTB_getMaxBits_const
// parsed: cv::AlignMTB::getMaxBits
// as:     cv::AlignMTB::getMaxBits (method) cv::AlignMTB (trait) . getMaxBits
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_AlignMTB_getMaxBits_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::AlignMTB*>(instance)->getMaxBits();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_AlignMTB_setMaxBits_int_max_bits
// parsed: cv::AlignMTB::setMaxBits
// as:     cv::AlignMTB::setMaxBits (method) cv::AlignMTB (trait) . setMaxBits
// Arg ARG Primitive(int) max_bits= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_AlignMTB_setMaxBits_int_max_bits(void* instance, int max_bits) {
    try {
        reinterpret_cast<cv::AlignMTB*>(instance)->setMaxBits(max_bits);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_AlignMTB_getExcludeRange_const
// parsed: cv::AlignMTB::getExcludeRange
// as:     cv::AlignMTB::getExcludeRange (method) cv::AlignMTB (trait) . getExcludeRange
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_AlignMTB_getExcludeRange_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::AlignMTB*>(instance)->getExcludeRange();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_AlignMTB_setExcludeRange_int_exclude_range
// parsed: cv::AlignMTB::setExcludeRange
// as:     cv::AlignMTB::setExcludeRange (method) cv::AlignMTB (trait) . setExcludeRange
// Arg ARG Primitive(int) exclude_range= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_AlignMTB_setExcludeRange_int_exclude_range(void* instance, int exclude_range) {
    try {
        reinterpret_cast<cv::AlignMTB*>(instance)->setExcludeRange(exclude_range);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_AlignMTB_getCut_const
// parsed: cv::AlignMTB::getCut
// as:     cv::AlignMTB::getCut (method) cv::AlignMTB (trait) . getCut
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_AlignMTB_getCut_const(void* instance) {
    try {
        bool ret = reinterpret_cast<cv::AlignMTB*>(instance)->getCut();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_AlignMTB_setCut_bool_value
// parsed: cv::AlignMTB::setCut
// as:     cv::AlignMTB::setCut (method) cv::AlignMTB (trait) . setCut
// Arg ARG Primitive(bool) value= Primitive(bool) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_AlignMTB_setCut_bool_value(void* instance, bool value) {
    try {
        reinterpret_cast<cv::AlignMTB*>(instance)->setCut(value);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// boxed class: cv::AutoLock
void cv_delete_AutoLock(void* instance) {
    delete (cv::AutoLock*) instance;
}
// boxed class: cv::BFMatcher
void cv_delete_BFMatcher(void* instance) {
    delete (cv::BFMatcher*) instance;
}
// cv_BFMatcher_BFMatcher_int_normType_bool_crossCheck
// parsed: cv::BFMatcher::BFMatcher
// as:     cv::BFMatcher::BFMatcher (constructor) cv::BFMatcher . new
// Arg ARG Primitive(int) normType= Primitive(int) = NORM_L2
// Arg ARG Primitive(bool) crossCheck= Primitive(bool) = false
// Return value: cv::BFMatcher (boxed)
cv_return_value_void_X cv_core_cv_BFMatcher_BFMatcher_int_normType_bool_crossCheck(int normType, bool crossCheck) {
    try {
        cv::BFMatcher* ret = new cv::BFMatcher(normType, crossCheck);
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_BFMatcher_isMaskSupported_const
// parsed: cv::BFMatcher::isMaskSupported
// as:     cv::BFMatcher::isMaskSupported (method) cv::BFMatcher . isMaskSupported
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_BFMatcher_isMaskSupported_const(void* instance) {
    try {
        bool ret = reinterpret_cast<cv::BFMatcher*>(instance)->isMaskSupported();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_BFMatcher_create_int_normType_bool_crossCheck
// parsed: cv::BFMatcher::create
// as:     cv::BFMatcher::create (method) cv::BFMatcher . create
// Arg ARG Primitive(int) normType= Primitive(int) = NORM_L2
// Arg ARG Primitive(bool) crossCheck= Primitive(bool) = false
// Return value: SmartPtr[cv::BFMatcher (boxed)]
cv_return_value_void_X cv_core_cv_BFMatcher_create_int_normType_bool_crossCheck(int normType, bool crossCheck) {
    try {
        Ptr<cv::BFMatcher> *ret = new Ptr<cv::BFMatcher>(cv::BFMatcher::create(normType, crossCheck));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_BFMatcher_clone_const_bool_emptyTrainData
// parsed: cv::BFMatcher::clone
// as:     cv::BFMatcher::clone (method) cv::BFMatcher . clone
// Arg ARG Primitive(bool) emptyTrainData= Primitive(bool) = false
// Return value: SmartPtr[cv::DescriptorMatcher (boxed)]
cv_return_value_void_X cv_core_cv_BFMatcher_clone_const_bool_emptyTrainData(void* instance, bool emptyTrainData) {
    try {
        Ptr<cv::DescriptorMatcher> *ret = new Ptr<cv::DescriptorMatcher>(reinterpret_cast<cv::BFMatcher*>(instance)->clone(emptyTrainData));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// boxed class: cv::BOWImgDescriptorExtractor
void cv_delete_BOWImgDescriptorExtractor(void* instance) {
    delete (cv::BOWImgDescriptorExtractor*) instance;
}
// cv_BOWImgDescriptorExtractor_BOWImgDescriptorExtractor_PtrOfFeature2D_dextractor_PtrOfDescriptorMatcher_dmatcher
// parsed: cv::BOWImgDescriptorExtractor::BOWImgDescriptorExtractor
// as:     cv::BOWImgDescriptorExtractor::BOWImgDescriptorExtractor (constructor) cv::BOWImgDescriptorExtractor . new
// Arg ARG SmartPtr[cv::Feature2D (boxed)] dextractor= SmartPtr[cv::Feature2D (boxed)] = 
// Arg ARG SmartPtr[cv::DescriptorMatcher (boxed)] dmatcher= SmartPtr[cv::DescriptorMatcher (boxed)] = 
// Return value: cv::BOWImgDescriptorExtractor (boxed)
cv_return_value_void_X cv_core_cv_BOWImgDescriptorExtractor_BOWImgDescriptorExtractor_PtrOfFeature2D_dextractor_PtrOfDescriptorMatcher_dmatcher(void* dextractor, void* dmatcher) {
    try {
        cv::BOWImgDescriptorExtractor* ret = new cv::BOWImgDescriptorExtractor(reinterpret_cast<cv::Feature2D*>(dextractor), reinterpret_cast<cv::DescriptorMatcher*>(dmatcher));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_BOWImgDescriptorExtractor_BOWImgDescriptorExtractor_PtrOfDescriptorMatcher_dmatcher
// parsed: cv::BOWImgDescriptorExtractor::BOWImgDescriptorExtractor
// as:     cv::BOWImgDescriptorExtractor::BOWImgDescriptorExtractor (constructor) cv::BOWImgDescriptorExtractor . new
// Arg ARG SmartPtr[cv::DescriptorMatcher (boxed)] dmatcher= SmartPtr[cv::DescriptorMatcher (boxed)] = 
// Return value: cv::BOWImgDescriptorExtractor (boxed)
cv_return_value_void_X cv_core_cv_BOWImgDescriptorExtractor_BOWImgDescriptorExtractor_PtrOfDescriptorMatcher_dmatcher(void* dmatcher) {
    try {
        cv::BOWImgDescriptorExtractor* ret = new cv::BOWImgDescriptorExtractor(reinterpret_cast<cv::DescriptorMatcher*>(dmatcher));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_BOWImgDescriptorExtractor_setVocabulary_Mat_vocabulary
// parsed: cv::BOWImgDescriptorExtractor::setVocabulary
// as:     cv::BOWImgDescriptorExtractor::setVocabulary (method) cv::BOWImgDescriptorExtractor . setVocabulary
// Arg ARG cv::Mat (boxed) vocabulary= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_BOWImgDescriptorExtractor_setVocabulary_Mat_vocabulary(void* instance, void* vocabulary) {
    try {
        reinterpret_cast<cv::BOWImgDescriptorExtractor*>(instance)->setVocabulary(*reinterpret_cast<cv::Mat*>(vocabulary));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_BOWImgDescriptorExtractor_getVocabulary_const
// parsed: cv::BOWImgDescriptorExtractor::getVocabulary
// as:     cv::BOWImgDescriptorExtractor::getVocabulary (method) cv::BOWImgDescriptorExtractor . getVocabulary
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_BOWImgDescriptorExtractor_getVocabulary_const(void* instance) {
    try {
        cv::Mat ret = reinterpret_cast<cv::BOWImgDescriptorExtractor*>(instance)->getVocabulary();
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_BOWImgDescriptorExtractor_compute_Mat_image_VectorOfKeyPoint_keypoints_Mat_imgDescriptor_VectorOfVectorOfint_pointIdxsOfClusters_Mat_descriptors
// parsed: cv::BOWImgDescriptorExtractor::compute
// as:     cv::BOWImgDescriptorExtractor::compute (method) cv::BOWImgDescriptorExtractor . compute
// Arg ARG cv::Mat (boxed) image= cv::Mat (boxed) = 
// Arg ARG Vector[cv::KeyPoint (simple)] keypoints= Vector[cv::KeyPoint (simple)] = 
// Arg ARG cv::Mat (boxed) imgDescriptor= cv::Mat (boxed) = 
// Arg ARG RawPtr[Vector[Vector[Primitive(int)]]] * pointIdxsOfClusters= (ptr) RawPtr[Vector[Vector[Primitive(int)]]] = 0
// Arg ARG RawPtr[cv::Mat (boxed)] * descriptors= (ptr) RawPtr[cv::Mat (boxed)] = 0
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_BOWImgDescriptorExtractor_compute_Mat_image_VectorOfKeyPoint_keypoints_Mat_imgDescriptor_VectorOfVectorOfint_pointIdxsOfClusters_Mat_descriptors(void* instance, void* image, void* keypoints, void* imgDescriptor, void* pointIdxsOfClusters, void* descriptors) {
    try {
        reinterpret_cast<cv::BOWImgDescriptorExtractor*>(instance)->compute(*reinterpret_cast<cv::Mat*>(image), *reinterpret_cast<std::vector<cv::KeyPoint>*>(keypoints), *reinterpret_cast<cv::Mat*>(imgDescriptor), reinterpret_cast<std::vector<std::vector<int>>*>(pointIdxsOfClusters), reinterpret_cast<cv::Mat*>(descriptors));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_BOWImgDescriptorExtractor_compute_Mat_keypointDescriptors_Mat_imgDescriptor_VectorOfVectorOfint_pointIdxsOfClusters
// parsed: cv::BOWImgDescriptorExtractor::compute
// as:     cv::BOWImgDescriptorExtractor::compute (method) cv::BOWImgDescriptorExtractor . compute
// Arg ARG cv::Mat (boxed) keypointDescriptors= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) imgDescriptor= cv::Mat (boxed) = 
// Arg ARG RawPtr[Vector[Vector[Primitive(int)]]] * pointIdxsOfClusters= (ptr) RawPtr[Vector[Vector[Primitive(int)]]] = 0
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_BOWImgDescriptorExtractor_compute_Mat_keypointDescriptors_Mat_imgDescriptor_VectorOfVectorOfint_pointIdxsOfClusters(void* instance, void* keypointDescriptors, void* imgDescriptor, void* pointIdxsOfClusters) {
    try {
        reinterpret_cast<cv::BOWImgDescriptorExtractor*>(instance)->compute(*reinterpret_cast<cv::Mat*>(keypointDescriptors), *reinterpret_cast<cv::Mat*>(imgDescriptor), reinterpret_cast<std::vector<std::vector<int>>*>(pointIdxsOfClusters));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_BOWImgDescriptorExtractor_compute2_Mat_image_VectorOfKeyPoint_keypoints_Mat_imgDescriptor
// parsed: cv::BOWImgDescriptorExtractor::compute2
// as:     cv::BOWImgDescriptorExtractor::compute2 (method) cv::BOWImgDescriptorExtractor . compute2
// Arg ARG cv::Mat (boxed) image= cv::Mat (boxed) = 
// Arg ARG Vector[cv::KeyPoint (simple)] keypoints= Vector[cv::KeyPoint (simple)] = 
// Arg ARG cv::Mat (boxed) imgDescriptor= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_BOWImgDescriptorExtractor_compute2_Mat_image_VectorOfKeyPoint_keypoints_Mat_imgDescriptor(void* instance, void* image, void* keypoints, void* imgDescriptor) {
    try {
        reinterpret_cast<cv::BOWImgDescriptorExtractor*>(instance)->compute2(*reinterpret_cast<cv::Mat*>(image), *reinterpret_cast<std::vector<cv::KeyPoint>*>(keypoints), *reinterpret_cast<cv::Mat*>(imgDescriptor));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_BOWImgDescriptorExtractor_descriptorSize_const
// parsed: cv::BOWImgDescriptorExtractor::descriptorSize
// as:     cv::BOWImgDescriptorExtractor::descriptorSize (method) cv::BOWImgDescriptorExtractor . descriptorSize
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_BOWImgDescriptorExtractor_descriptorSize_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::BOWImgDescriptorExtractor*>(instance)->descriptorSize();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_BOWImgDescriptorExtractor_descriptorType_const
// parsed: cv::BOWImgDescriptorExtractor::descriptorType
// as:     cv::BOWImgDescriptorExtractor::descriptorType (method) cv::BOWImgDescriptorExtractor . descriptorType
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_BOWImgDescriptorExtractor_descriptorType_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::BOWImgDescriptorExtractor*>(instance)->descriptorType();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// boxed class: cv::BOWKMeansTrainer
void cv_delete_BOWKMeansTrainer(void* instance) {
    delete (cv::BOWKMeansTrainer*) instance;
}
// cv_BOWKMeansTrainer_BOWKMeansTrainer_int_clusterCount_TermCriteria_termcrit_int_attempts_int_flags
// parsed: cv::BOWKMeansTrainer::BOWKMeansTrainer
// as:     cv::BOWKMeansTrainer::BOWKMeansTrainer (constructor) cv::BOWKMeansTrainer . new
// Arg ARG Primitive(int) clusterCount= Primitive(int) = 
// Arg ARG cv::TermCriteria (boxed) termcrit= cv::TermCriteria (boxed) = TermCriteria()
// Arg ARG Primitive(int) attempts= Primitive(int) = 3
// Arg ARG Primitive(int) flags= Primitive(int) = KMEANS_PP_CENTERS
// Return value: cv::BOWKMeansTrainer (boxed)
cv_return_value_void_X cv_core_cv_BOWKMeansTrainer_BOWKMeansTrainer_int_clusterCount_TermCriteria_termcrit_int_attempts_int_flags(int clusterCount, void* termcrit, int attempts, int flags) {
    try {
        cv::BOWKMeansTrainer* ret = new cv::BOWKMeansTrainer(clusterCount, *reinterpret_cast<cv::TermCriteria*>(termcrit), attempts, flags);
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_BOWKMeansTrainer_cluster_const
// parsed: cv::BOWKMeansTrainer::cluster
// as:     cv::BOWKMeansTrainer::cluster (method) cv::BOWKMeansTrainer . cluster
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_BOWKMeansTrainer_cluster_const(void* instance) {
    try {
        cv::Mat ret = reinterpret_cast<cv::BOWKMeansTrainer*>(instance)->cluster();
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_BOWKMeansTrainer_cluster_const_Mat_descriptors
// parsed: cv::BOWKMeansTrainer::cluster
// as:     cv::BOWKMeansTrainer::cluster (method) cv::BOWKMeansTrainer . cluster
// Arg ARG cv::Mat (boxed) descriptors= cv::Mat (boxed) = 
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_BOWKMeansTrainer_cluster_const_Mat_descriptors(void* instance, void* descriptors) {
    try {
        cv::Mat ret = reinterpret_cast<cv::BOWKMeansTrainer*>(instance)->cluster(*reinterpret_cast<cv::Mat*>(descriptors));
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_BOWTrainer_add_Mat_descriptors
// parsed: cv::BOWTrainer::add
// as:     cv::BOWTrainer::add (method) cv::BOWTrainer (trait) . add
// Arg ARG cv::Mat (boxed) descriptors= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_BOWTrainer_add_Mat_descriptors(void* instance, void* descriptors) {
    try {
        reinterpret_cast<cv::BOWTrainer*>(instance)->add(*reinterpret_cast<cv::Mat*>(descriptors));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_BOWTrainer_getDescriptors_const
// parsed: cv::BOWTrainer::getDescriptors
// as:     cv::BOWTrainer::getDescriptors (method) cv::BOWTrainer (trait) . getDescriptors
// Return value: Vector[cv::Mat (boxed)]
cv_return_value_void_X cv_core_cv_BOWTrainer_getDescriptors_const(void* instance) {
    try {
        std::vector<cv::Mat> ret = reinterpret_cast<cv::BOWTrainer*>(instance)->getDescriptors();
        return { Error::Code::StsOk, NULL, (void *)new std::vector<cv::Mat>(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_BOWTrainer_descriptorsCount_const
// parsed: cv::BOWTrainer::descriptorsCount
// as:     cv::BOWTrainer::descriptorsCount (method) cv::BOWTrainer (trait) . descriptorsCount
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_BOWTrainer_descriptorsCount_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::BOWTrainer*>(instance)->descriptorsCount();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_BOWTrainer_clear
// parsed: cv::BOWTrainer::clear
// as:     cv::BOWTrainer::clear (method) cv::BOWTrainer (trait) . clear
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_BOWTrainer_clear(void* instance) {
    try {
        reinterpret_cast<cv::BOWTrainer*>(instance)->clear();
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_BOWTrainer_cluster_const
// parsed: cv::BOWTrainer::cluster
// as:     cv::BOWTrainer::cluster (method) cv::BOWTrainer (trait) . cluster
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_BOWTrainer_cluster_const(void* instance) {
    try {
        cv::Mat ret = reinterpret_cast<cv::BOWTrainer*>(instance)->cluster();
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_BOWTrainer_cluster_const_Mat_descriptors
// parsed: cv::BOWTrainer::cluster
// as:     cv::BOWTrainer::cluster (method) cv::BOWTrainer (trait) . cluster
// Arg ARG cv::Mat (boxed) descriptors= cv::Mat (boxed) = 
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_BOWTrainer_cluster_const_Mat_descriptors(void* instance, void* descriptors) {
    try {
        cv::Mat ret = reinterpret_cast<cv::BOWTrainer*>(instance)->cluster(*reinterpret_cast<cv::Mat*>(descriptors));
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// boxed class: cv::BRISK
void cv_delete_BRISK(void* instance) {
    delete (cv::BRISK*) instance;
}
// cv_BRISK_create_int_thresh_int_octaves_float_patternScale
// parsed: cv::BRISK::create
// as:     cv::BRISK::create (method) cv::BRISK . create
// Arg ARG Primitive(int) thresh= Primitive(int) = 30
// Arg ARG Primitive(int) octaves= Primitive(int) = 3
// Arg ARG Primitive(float) patternScale= Primitive(float) = 1.0f
// Return value: SmartPtr[cv::BRISK (boxed)]
cv_return_value_void_X cv_core_cv_BRISK_create_int_thresh_int_octaves_float_patternScale(int thresh, int octaves, float patternScale) {
    try {
        Ptr<cv::BRISK> *ret = new Ptr<cv::BRISK>(cv::BRISK::create(thresh, octaves, patternScale));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_BRISK_create_VectorOffloat_radiusList_VectorOfint_numberList_float_dMax_float_dMin_VectorOfint_indexChange
// parsed: cv::BRISK::create
// as:     cv::BRISK::create (method) cv::BRISK . create
// Arg ARG Vector[Primitive(float)] radiusList= Vector[Primitive(float)] = 
// Arg ARG Vector[Primitive(int)] numberList= Vector[Primitive(int)] = 
// Arg ARG Primitive(float) dMax= Primitive(float) = 5.85f
// Arg ARG Primitive(float) dMin= Primitive(float) = 8.2f
// Arg ARG Vector[Primitive(int)] indexChange= Vector[Primitive(int)] = std::vector<int>()
// Return value: SmartPtr[cv::BRISK (boxed)]
cv_return_value_void_X cv_core_cv_BRISK_create_VectorOffloat_radiusList_VectorOfint_numberList_float_dMax_float_dMin_VectorOfint_indexChange(void* radiusList, void* numberList, float dMax, float dMin, void* indexChange) {
    try {
        Ptr<cv::BRISK> *ret = new Ptr<cv::BRISK>(cv::BRISK::create(*reinterpret_cast<std::vector<float>*>(radiusList), *reinterpret_cast<std::vector<int>*>(numberList), dMax, dMin, *reinterpret_cast<std::vector<int>*>(indexChange)));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_BRISK_create_int_thresh_int_octaves_VectorOffloat_radiusList_VectorOfint_numberList_float_dMax_float_dMin_VectorOfint_indexChange
// parsed: cv::BRISK::create
// as:     cv::BRISK::create (method) cv::BRISK . create
// Arg ARG Primitive(int) thresh= Primitive(int) = 
// Arg ARG Primitive(int) octaves= Primitive(int) = 
// Arg ARG Vector[Primitive(float)] radiusList= Vector[Primitive(float)] = 
// Arg ARG Vector[Primitive(int)] numberList= Vector[Primitive(int)] = 
// Arg ARG Primitive(float) dMax= Primitive(float) = 5.85f
// Arg ARG Primitive(float) dMin= Primitive(float) = 8.2f
// Arg ARG Vector[Primitive(int)] indexChange= Vector[Primitive(int)] = std::vector<int>()
// Return value: SmartPtr[cv::BRISK (boxed)]
cv_return_value_void_X cv_core_cv_BRISK_create_int_thresh_int_octaves_VectorOffloat_radiusList_VectorOfint_numberList_float_dMax_float_dMin_VectorOfint_indexChange(int thresh, int octaves, void* radiusList, void* numberList, float dMax, float dMin, void* indexChange) {
    try {
        Ptr<cv::BRISK> *ret = new Ptr<cv::BRISK>(cv::BRISK::create(thresh, octaves, *reinterpret_cast<std::vector<float>*>(radiusList), *reinterpret_cast<std::vector<int>*>(numberList), dMax, dMin, *reinterpret_cast<std::vector<int>*>(indexChange)));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_BRISK_getDefaultName_const
// parsed: cv::BRISK::getDefaultName
// as:     cv::BRISK::getDefaultName (method) cv::BRISK . getDefaultName
// Return value: string
cv_return_value_char_X cv_core_cv_BRISK_getDefaultName_const(void* instance) {
    try {
        String ret = reinterpret_cast<cv::BRISK*>(instance)->getDefaultName();
        return { Error::Code::StsOk, NULL, strdup(ret.c_str()) };
    } CVRS_CATCH(cv_return_value_char_X)
}

// cv_BackgroundSubtractor_apply_Mat_image_Mat_fgmask_double_learningRate
// parsed: cv::BackgroundSubtractor::apply
// as:     cv::BackgroundSubtractor::apply (method) cv::BackgroundSubtractor (trait) . apply
// Arg ARG cv::Mat (boxed) image= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) fgmask= cv::Mat (boxed) = 
// Arg ARG Primitive(double) learningRate= Primitive(double) = -1
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_BackgroundSubtractor_apply_Mat_image_Mat_fgmask_double_learningRate(void* instance, void* image, void* fgmask, double learningRate) {
    try {
        reinterpret_cast<cv::BackgroundSubtractor*>(instance)->apply(*reinterpret_cast<cv::Mat*>(image), *reinterpret_cast<cv::Mat*>(fgmask), learningRate);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_BackgroundSubtractor_getBackgroundImage_const_Mat_backgroundImage
// parsed: cv::BackgroundSubtractor::getBackgroundImage
// as:     cv::BackgroundSubtractor::getBackgroundImage (method) cv::BackgroundSubtractor (trait) . getBackgroundImage
// Arg ARG cv::Mat (boxed) backgroundImage= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_BackgroundSubtractor_getBackgroundImage_const_Mat_backgroundImage(void* instance, void* backgroundImage) {
    try {
        reinterpret_cast<cv::BackgroundSubtractor*>(instance)->getBackgroundImage(*reinterpret_cast<cv::Mat*>(backgroundImage));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_BackgroundSubtractorKNN_getHistory_const
// parsed: cv::BackgroundSubtractorKNN::getHistory
// as:     cv::BackgroundSubtractorKNN::getHistory (method) cv::BackgroundSubtractorKNN (trait) . getHistory
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_BackgroundSubtractorKNN_getHistory_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::BackgroundSubtractorKNN*>(instance)->getHistory();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_BackgroundSubtractorKNN_setHistory_int_history
// parsed: cv::BackgroundSubtractorKNN::setHistory
// as:     cv::BackgroundSubtractorKNN::setHistory (method) cv::BackgroundSubtractorKNN (trait) . setHistory
// Arg ARG Primitive(int) history= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_BackgroundSubtractorKNN_setHistory_int_history(void* instance, int history) {
    try {
        reinterpret_cast<cv::BackgroundSubtractorKNN*>(instance)->setHistory(history);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_BackgroundSubtractorKNN_getNSamples_const
// parsed: cv::BackgroundSubtractorKNN::getNSamples
// as:     cv::BackgroundSubtractorKNN::getNSamples (method) cv::BackgroundSubtractorKNN (trait) . getNSamples
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_BackgroundSubtractorKNN_getNSamples_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::BackgroundSubtractorKNN*>(instance)->getNSamples();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_BackgroundSubtractorKNN_setNSamples_int__nN
// parsed: cv::BackgroundSubtractorKNN::setNSamples
// as:     cv::BackgroundSubtractorKNN::setNSamples (method) cv::BackgroundSubtractorKNN (trait) . setNSamples
// Arg ARG Primitive(int) _nN= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_BackgroundSubtractorKNN_setNSamples_int__nN(void* instance, int _nN) {
    try {
        reinterpret_cast<cv::BackgroundSubtractorKNN*>(instance)->setNSamples(_nN);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_BackgroundSubtractorKNN_getDist2Threshold_const
// parsed: cv::BackgroundSubtractorKNN::getDist2Threshold
// as:     cv::BackgroundSubtractorKNN::getDist2Threshold (method) cv::BackgroundSubtractorKNN (trait) . getDist2Threshold
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_BackgroundSubtractorKNN_getDist2Threshold_const(void* instance) {
    try {
        double ret = reinterpret_cast<cv::BackgroundSubtractorKNN*>(instance)->getDist2Threshold();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_BackgroundSubtractorKNN_setDist2Threshold_double__dist2Threshold
// parsed: cv::BackgroundSubtractorKNN::setDist2Threshold
// as:     cv::BackgroundSubtractorKNN::setDist2Threshold (method) cv::BackgroundSubtractorKNN (trait) . setDist2Threshold
// Arg ARG Primitive(double) _dist2Threshold= Primitive(double) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_BackgroundSubtractorKNN_setDist2Threshold_double__dist2Threshold(void* instance, double _dist2Threshold) {
    try {
        reinterpret_cast<cv::BackgroundSubtractorKNN*>(instance)->setDist2Threshold(_dist2Threshold);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_BackgroundSubtractorKNN_getkNNSamples_const
// parsed: cv::BackgroundSubtractorKNN::getkNNSamples
// as:     cv::BackgroundSubtractorKNN::getkNNSamples (method) cv::BackgroundSubtractorKNN (trait) . getkNNSamples
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_BackgroundSubtractorKNN_getkNNSamples_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::BackgroundSubtractorKNN*>(instance)->getkNNSamples();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_BackgroundSubtractorKNN_setkNNSamples_int__nkNN
// parsed: cv::BackgroundSubtractorKNN::setkNNSamples
// as:     cv::BackgroundSubtractorKNN::setkNNSamples (method) cv::BackgroundSubtractorKNN (trait) . setkNNSamples
// Arg ARG Primitive(int) _nkNN= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_BackgroundSubtractorKNN_setkNNSamples_int__nkNN(void* instance, int _nkNN) {
    try {
        reinterpret_cast<cv::BackgroundSubtractorKNN*>(instance)->setkNNSamples(_nkNN);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_BackgroundSubtractorKNN_getDetectShadows_const
// parsed: cv::BackgroundSubtractorKNN::getDetectShadows
// as:     cv::BackgroundSubtractorKNN::getDetectShadows (method) cv::BackgroundSubtractorKNN (trait) . getDetectShadows
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_BackgroundSubtractorKNN_getDetectShadows_const(void* instance) {
    try {
        bool ret = reinterpret_cast<cv::BackgroundSubtractorKNN*>(instance)->getDetectShadows();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_BackgroundSubtractorKNN_setDetectShadows_bool_detectShadows
// parsed: cv::BackgroundSubtractorKNN::setDetectShadows
// as:     cv::BackgroundSubtractorKNN::setDetectShadows (method) cv::BackgroundSubtractorKNN (trait) . setDetectShadows
// Arg ARG Primitive(bool) detectShadows= Primitive(bool) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_BackgroundSubtractorKNN_setDetectShadows_bool_detectShadows(void* instance, bool detectShadows) {
    try {
        reinterpret_cast<cv::BackgroundSubtractorKNN*>(instance)->setDetectShadows(detectShadows);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_BackgroundSubtractorKNN_getShadowValue_const
// parsed: cv::BackgroundSubtractorKNN::getShadowValue
// as:     cv::BackgroundSubtractorKNN::getShadowValue (method) cv::BackgroundSubtractorKNN (trait) . getShadowValue
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_BackgroundSubtractorKNN_getShadowValue_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::BackgroundSubtractorKNN*>(instance)->getShadowValue();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_BackgroundSubtractorKNN_setShadowValue_int_value
// parsed: cv::BackgroundSubtractorKNN::setShadowValue
// as:     cv::BackgroundSubtractorKNN::setShadowValue (method) cv::BackgroundSubtractorKNN (trait) . setShadowValue
// Arg ARG Primitive(int) value= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_BackgroundSubtractorKNN_setShadowValue_int_value(void* instance, int value) {
    try {
        reinterpret_cast<cv::BackgroundSubtractorKNN*>(instance)->setShadowValue(value);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_BackgroundSubtractorKNN_getShadowThreshold_const
// parsed: cv::BackgroundSubtractorKNN::getShadowThreshold
// as:     cv::BackgroundSubtractorKNN::getShadowThreshold (method) cv::BackgroundSubtractorKNN (trait) . getShadowThreshold
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_BackgroundSubtractorKNN_getShadowThreshold_const(void* instance) {
    try {
        double ret = reinterpret_cast<cv::BackgroundSubtractorKNN*>(instance)->getShadowThreshold();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_BackgroundSubtractorKNN_setShadowThreshold_double_threshold
// parsed: cv::BackgroundSubtractorKNN::setShadowThreshold
// as:     cv::BackgroundSubtractorKNN::setShadowThreshold (method) cv::BackgroundSubtractorKNN (trait) . setShadowThreshold
// Arg ARG Primitive(double) threshold= Primitive(double) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_BackgroundSubtractorKNN_setShadowThreshold_double_threshold(void* instance, double threshold) {
    try {
        reinterpret_cast<cv::BackgroundSubtractorKNN*>(instance)->setShadowThreshold(threshold);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_BackgroundSubtractorMOG2_getHistory_const
// parsed: cv::BackgroundSubtractorMOG2::getHistory
// as:     cv::BackgroundSubtractorMOG2::getHistory (method) cv::BackgroundSubtractorMOG2 (trait) . getHistory
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_BackgroundSubtractorMOG2_getHistory_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::BackgroundSubtractorMOG2*>(instance)->getHistory();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_BackgroundSubtractorMOG2_setHistory_int_history
// parsed: cv::BackgroundSubtractorMOG2::setHistory
// as:     cv::BackgroundSubtractorMOG2::setHistory (method) cv::BackgroundSubtractorMOG2 (trait) . setHistory
// Arg ARG Primitive(int) history= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_BackgroundSubtractorMOG2_setHistory_int_history(void* instance, int history) {
    try {
        reinterpret_cast<cv::BackgroundSubtractorMOG2*>(instance)->setHistory(history);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_BackgroundSubtractorMOG2_getNMixtures_const
// parsed: cv::BackgroundSubtractorMOG2::getNMixtures
// as:     cv::BackgroundSubtractorMOG2::getNMixtures (method) cv::BackgroundSubtractorMOG2 (trait) . getNMixtures
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_BackgroundSubtractorMOG2_getNMixtures_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::BackgroundSubtractorMOG2*>(instance)->getNMixtures();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_BackgroundSubtractorMOG2_setNMixtures_int_nmixtures
// parsed: cv::BackgroundSubtractorMOG2::setNMixtures
// as:     cv::BackgroundSubtractorMOG2::setNMixtures (method) cv::BackgroundSubtractorMOG2 (trait) . setNMixtures
// Arg ARG Primitive(int) nmixtures= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_BackgroundSubtractorMOG2_setNMixtures_int_nmixtures(void* instance, int nmixtures) {
    try {
        reinterpret_cast<cv::BackgroundSubtractorMOG2*>(instance)->setNMixtures(nmixtures);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_BackgroundSubtractorMOG2_getBackgroundRatio_const
// parsed: cv::BackgroundSubtractorMOG2::getBackgroundRatio
// as:     cv::BackgroundSubtractorMOG2::getBackgroundRatio (method) cv::BackgroundSubtractorMOG2 (trait) . getBackgroundRatio
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_BackgroundSubtractorMOG2_getBackgroundRatio_const(void* instance) {
    try {
        double ret = reinterpret_cast<cv::BackgroundSubtractorMOG2*>(instance)->getBackgroundRatio();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_BackgroundSubtractorMOG2_setBackgroundRatio_double_ratio
// parsed: cv::BackgroundSubtractorMOG2::setBackgroundRatio
// as:     cv::BackgroundSubtractorMOG2::setBackgroundRatio (method) cv::BackgroundSubtractorMOG2 (trait) . setBackgroundRatio
// Arg ARG Primitive(double) ratio= Primitive(double) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_BackgroundSubtractorMOG2_setBackgroundRatio_double_ratio(void* instance, double ratio) {
    try {
        reinterpret_cast<cv::BackgroundSubtractorMOG2*>(instance)->setBackgroundRatio(ratio);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_BackgroundSubtractorMOG2_getVarThreshold_const
// parsed: cv::BackgroundSubtractorMOG2::getVarThreshold
// as:     cv::BackgroundSubtractorMOG2::getVarThreshold (method) cv::BackgroundSubtractorMOG2 (trait) . getVarThreshold
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_BackgroundSubtractorMOG2_getVarThreshold_const(void* instance) {
    try {
        double ret = reinterpret_cast<cv::BackgroundSubtractorMOG2*>(instance)->getVarThreshold();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_BackgroundSubtractorMOG2_setVarThreshold_double_varThreshold
// parsed: cv::BackgroundSubtractorMOG2::setVarThreshold
// as:     cv::BackgroundSubtractorMOG2::setVarThreshold (method) cv::BackgroundSubtractorMOG2 (trait) . setVarThreshold
// Arg ARG Primitive(double) varThreshold= Primitive(double) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_BackgroundSubtractorMOG2_setVarThreshold_double_varThreshold(void* instance, double varThreshold) {
    try {
        reinterpret_cast<cv::BackgroundSubtractorMOG2*>(instance)->setVarThreshold(varThreshold);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_BackgroundSubtractorMOG2_getVarThresholdGen_const
// parsed: cv::BackgroundSubtractorMOG2::getVarThresholdGen
// as:     cv::BackgroundSubtractorMOG2::getVarThresholdGen (method) cv::BackgroundSubtractorMOG2 (trait) . getVarThresholdGen
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_BackgroundSubtractorMOG2_getVarThresholdGen_const(void* instance) {
    try {
        double ret = reinterpret_cast<cv::BackgroundSubtractorMOG2*>(instance)->getVarThresholdGen();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_BackgroundSubtractorMOG2_setVarThresholdGen_double_varThresholdGen
// parsed: cv::BackgroundSubtractorMOG2::setVarThresholdGen
// as:     cv::BackgroundSubtractorMOG2::setVarThresholdGen (method) cv::BackgroundSubtractorMOG2 (trait) . setVarThresholdGen
// Arg ARG Primitive(double) varThresholdGen= Primitive(double) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_BackgroundSubtractorMOG2_setVarThresholdGen_double_varThresholdGen(void* instance, double varThresholdGen) {
    try {
        reinterpret_cast<cv::BackgroundSubtractorMOG2*>(instance)->setVarThresholdGen(varThresholdGen);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_BackgroundSubtractorMOG2_getVarInit_const
// parsed: cv::BackgroundSubtractorMOG2::getVarInit
// as:     cv::BackgroundSubtractorMOG2::getVarInit (method) cv::BackgroundSubtractorMOG2 (trait) . getVarInit
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_BackgroundSubtractorMOG2_getVarInit_const(void* instance) {
    try {
        double ret = reinterpret_cast<cv::BackgroundSubtractorMOG2*>(instance)->getVarInit();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_BackgroundSubtractorMOG2_setVarInit_double_varInit
// parsed: cv::BackgroundSubtractorMOG2::setVarInit
// as:     cv::BackgroundSubtractorMOG2::setVarInit (method) cv::BackgroundSubtractorMOG2 (trait) . setVarInit
// Arg ARG Primitive(double) varInit= Primitive(double) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_BackgroundSubtractorMOG2_setVarInit_double_varInit(void* instance, double varInit) {
    try {
        reinterpret_cast<cv::BackgroundSubtractorMOG2*>(instance)->setVarInit(varInit);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_BackgroundSubtractorMOG2_getVarMin_const
// parsed: cv::BackgroundSubtractorMOG2::getVarMin
// as:     cv::BackgroundSubtractorMOG2::getVarMin (method) cv::BackgroundSubtractorMOG2 (trait) . getVarMin
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_BackgroundSubtractorMOG2_getVarMin_const(void* instance) {
    try {
        double ret = reinterpret_cast<cv::BackgroundSubtractorMOG2*>(instance)->getVarMin();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_BackgroundSubtractorMOG2_setVarMin_double_varMin
// parsed: cv::BackgroundSubtractorMOG2::setVarMin
// as:     cv::BackgroundSubtractorMOG2::setVarMin (method) cv::BackgroundSubtractorMOG2 (trait) . setVarMin
// Arg ARG Primitive(double) varMin= Primitive(double) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_BackgroundSubtractorMOG2_setVarMin_double_varMin(void* instance, double varMin) {
    try {
        reinterpret_cast<cv::BackgroundSubtractorMOG2*>(instance)->setVarMin(varMin);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_BackgroundSubtractorMOG2_getVarMax_const
// parsed: cv::BackgroundSubtractorMOG2::getVarMax
// as:     cv::BackgroundSubtractorMOG2::getVarMax (method) cv::BackgroundSubtractorMOG2 (trait) . getVarMax
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_BackgroundSubtractorMOG2_getVarMax_const(void* instance) {
    try {
        double ret = reinterpret_cast<cv::BackgroundSubtractorMOG2*>(instance)->getVarMax();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_BackgroundSubtractorMOG2_setVarMax_double_varMax
// parsed: cv::BackgroundSubtractorMOG2::setVarMax
// as:     cv::BackgroundSubtractorMOG2::setVarMax (method) cv::BackgroundSubtractorMOG2 (trait) . setVarMax
// Arg ARG Primitive(double) varMax= Primitive(double) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_BackgroundSubtractorMOG2_setVarMax_double_varMax(void* instance, double varMax) {
    try {
        reinterpret_cast<cv::BackgroundSubtractorMOG2*>(instance)->setVarMax(varMax);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_BackgroundSubtractorMOG2_getComplexityReductionThreshold_const
// parsed: cv::BackgroundSubtractorMOG2::getComplexityReductionThreshold
// as:     cv::BackgroundSubtractorMOG2::getComplexityReductionThreshold (method) cv::BackgroundSubtractorMOG2 (trait) . getComplexityReductionThreshold
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_BackgroundSubtractorMOG2_getComplexityReductionThreshold_const(void* instance) {
    try {
        double ret = reinterpret_cast<cv::BackgroundSubtractorMOG2*>(instance)->getComplexityReductionThreshold();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_BackgroundSubtractorMOG2_setComplexityReductionThreshold_double_ct
// parsed: cv::BackgroundSubtractorMOG2::setComplexityReductionThreshold
// as:     cv::BackgroundSubtractorMOG2::setComplexityReductionThreshold (method) cv::BackgroundSubtractorMOG2 (trait) . setComplexityReductionThreshold
// Arg ARG Primitive(double) ct= Primitive(double) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_BackgroundSubtractorMOG2_setComplexityReductionThreshold_double_ct(void* instance, double ct) {
    try {
        reinterpret_cast<cv::BackgroundSubtractorMOG2*>(instance)->setComplexityReductionThreshold(ct);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_BackgroundSubtractorMOG2_getDetectShadows_const
// parsed: cv::BackgroundSubtractorMOG2::getDetectShadows
// as:     cv::BackgroundSubtractorMOG2::getDetectShadows (method) cv::BackgroundSubtractorMOG2 (trait) . getDetectShadows
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_BackgroundSubtractorMOG2_getDetectShadows_const(void* instance) {
    try {
        bool ret = reinterpret_cast<cv::BackgroundSubtractorMOG2*>(instance)->getDetectShadows();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_BackgroundSubtractorMOG2_setDetectShadows_bool_detectShadows
// parsed: cv::BackgroundSubtractorMOG2::setDetectShadows
// as:     cv::BackgroundSubtractorMOG2::setDetectShadows (method) cv::BackgroundSubtractorMOG2 (trait) . setDetectShadows
// Arg ARG Primitive(bool) detectShadows= Primitive(bool) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_BackgroundSubtractorMOG2_setDetectShadows_bool_detectShadows(void* instance, bool detectShadows) {
    try {
        reinterpret_cast<cv::BackgroundSubtractorMOG2*>(instance)->setDetectShadows(detectShadows);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_BackgroundSubtractorMOG2_getShadowValue_const
// parsed: cv::BackgroundSubtractorMOG2::getShadowValue
// as:     cv::BackgroundSubtractorMOG2::getShadowValue (method) cv::BackgroundSubtractorMOG2 (trait) . getShadowValue
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_BackgroundSubtractorMOG2_getShadowValue_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::BackgroundSubtractorMOG2*>(instance)->getShadowValue();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_BackgroundSubtractorMOG2_setShadowValue_int_value
// parsed: cv::BackgroundSubtractorMOG2::setShadowValue
// as:     cv::BackgroundSubtractorMOG2::setShadowValue (method) cv::BackgroundSubtractorMOG2 (trait) . setShadowValue
// Arg ARG Primitive(int) value= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_BackgroundSubtractorMOG2_setShadowValue_int_value(void* instance, int value) {
    try {
        reinterpret_cast<cv::BackgroundSubtractorMOG2*>(instance)->setShadowValue(value);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_BackgroundSubtractorMOG2_getShadowThreshold_const
// parsed: cv::BackgroundSubtractorMOG2::getShadowThreshold
// as:     cv::BackgroundSubtractorMOG2::getShadowThreshold (method) cv::BackgroundSubtractorMOG2 (trait) . getShadowThreshold
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_BackgroundSubtractorMOG2_getShadowThreshold_const(void* instance) {
    try {
        double ret = reinterpret_cast<cv::BackgroundSubtractorMOG2*>(instance)->getShadowThreshold();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_BackgroundSubtractorMOG2_setShadowThreshold_double_threshold
// parsed: cv::BackgroundSubtractorMOG2::setShadowThreshold
// as:     cv::BackgroundSubtractorMOG2::setShadowThreshold (method) cv::BackgroundSubtractorMOG2 (trait) . setShadowThreshold
// Arg ARG Primitive(double) threshold= Primitive(double) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_BackgroundSubtractorMOG2_setShadowThreshold_double_threshold(void* instance, double threshold) {
    try {
        reinterpret_cast<cv::BackgroundSubtractorMOG2*>(instance)->setShadowThreshold(threshold);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_BackgroundSubtractorMOG2_apply_Mat_image_Mat_fgmask_double_learningRate
// parsed: cv::BackgroundSubtractorMOG2::apply
// as:     cv::BackgroundSubtractorMOG2::apply (method) cv::BackgroundSubtractorMOG2 (trait) . apply
// Arg ARG cv::Mat (boxed) image= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) fgmask= cv::Mat (boxed) = 
// Arg ARG Primitive(double) learningRate= Primitive(double) = -1
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_BackgroundSubtractorMOG2_apply_Mat_image_Mat_fgmask_double_learningRate(void* instance, void* image, void* fgmask, double learningRate) {
    try {
        reinterpret_cast<cv::BackgroundSubtractorMOG2*>(instance)->apply(*reinterpret_cast<cv::Mat*>(image), *reinterpret_cast<cv::Mat*>(fgmask), learningRate);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_BaseCascadeClassifier_empty_const
// parsed: cv::BaseCascadeClassifier::empty
// as:     cv::BaseCascadeClassifier::empty (method) cv::BaseCascadeClassifier (trait) . empty
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_BaseCascadeClassifier_empty_const(void* instance) {
    try {
        bool ret = reinterpret_cast<cv::BaseCascadeClassifier*>(instance)->empty();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_BaseCascadeClassifier_load_String_filename
// parsed: cv::BaseCascadeClassifier::load
// as:     cv::BaseCascadeClassifier::load (method) cv::BaseCascadeClassifier (trait) . load
// Arg ARG string filename= string = 
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_BaseCascadeClassifier_load_String_filename(void* instance, const char* filename) {
    try {
        bool ret = reinterpret_cast<cv::BaseCascadeClassifier*>(instance)->load(String(filename));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_BaseCascadeClassifier_detectMultiScale_Mat_image_VectorOfRect_objects_double_scaleFactor_int_minNeighbors_int_flags_Size_minSize_Size_maxSize
// parsed: cv::BaseCascadeClassifier::detectMultiScale
// as:     cv::BaseCascadeClassifier::detectMultiScale (method) cv::BaseCascadeClassifier (trait) . detectMultiScale
// Arg ARG cv::Mat (boxed) image= cv::Mat (boxed) = 
// Arg ARG Vector[cv::Rect (simple)] objects= Vector[cv::Rect (simple)] = 
// Arg ARG Primitive(double) scaleFactor= Primitive(double) = 
// Arg ARG Primitive(int) minNeighbors= Primitive(int) = 
// Arg ARG Primitive(int) flags= Primitive(int) = 
// Arg ARG cv::Size (simple) minSize= cv::Size (simple) = 
// Arg ARG cv::Size (simple) maxSize= cv::Size (simple) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_BaseCascadeClassifier_detectMultiScale_Mat_image_VectorOfRect_objects_double_scaleFactor_int_minNeighbors_int_flags_Size_minSize_Size_maxSize(void* instance, void* image, void* objects, double scaleFactor, int minNeighbors, int flags, SizeWrapper minSize, SizeWrapper maxSize) {
    try {
        reinterpret_cast<cv::BaseCascadeClassifier*>(instance)->detectMultiScale(*reinterpret_cast<cv::Mat*>(image), *reinterpret_cast<std::vector<cv::Rect>*>(objects), scaleFactor, minNeighbors, flags, *reinterpret_cast<cv::Size*>(&minSize), *reinterpret_cast<cv::Size*>(&maxSize));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_BaseCascadeClassifier_detectMultiScale_Mat_image_VectorOfRect_objects_VectorOfint_numDetections_double_scaleFactor_int_minNeighbors_int_flags_Size_minSize_Size_maxSize
// parsed: cv::BaseCascadeClassifier::detectMultiScale
// as:     cv::BaseCascadeClassifier::detectMultiScale (method) cv::BaseCascadeClassifier (trait) . detectMultiScale
// Arg ARG cv::Mat (boxed) image= cv::Mat (boxed) = 
// Arg ARG Vector[cv::Rect (simple)] objects= Vector[cv::Rect (simple)] = 
// Arg ARG Vector[Primitive(int)] numDetections= Vector[Primitive(int)] = 
// Arg ARG Primitive(double) scaleFactor= Primitive(double) = 
// Arg ARG Primitive(int) minNeighbors= Primitive(int) = 
// Arg ARG Primitive(int) flags= Primitive(int) = 
// Arg ARG cv::Size (simple) minSize= cv::Size (simple) = 
// Arg ARG cv::Size (simple) maxSize= cv::Size (simple) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_BaseCascadeClassifier_detectMultiScale_Mat_image_VectorOfRect_objects_VectorOfint_numDetections_double_scaleFactor_int_minNeighbors_int_flags_Size_minSize_Size_maxSize(void* instance, void* image, void* objects, void* numDetections, double scaleFactor, int minNeighbors, int flags, SizeWrapper minSize, SizeWrapper maxSize) {
    try {
        reinterpret_cast<cv::BaseCascadeClassifier*>(instance)->detectMultiScale(*reinterpret_cast<cv::Mat*>(image), *reinterpret_cast<std::vector<cv::Rect>*>(objects), *reinterpret_cast<std::vector<int>*>(numDetections), scaleFactor, minNeighbors, flags, *reinterpret_cast<cv::Size*>(&minSize), *reinterpret_cast<cv::Size*>(&maxSize));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_BaseCascadeClassifier_detectMultiScale_Mat_image_VectorOfRect_objects_VectorOfint_rejectLevels_VectorOfdouble_levelWeights_double_scaleFactor_int_minNeighbors_int_flags_Size_minSize_Size_maxSize_bool_outputRejectLevels
// parsed: cv::BaseCascadeClassifier::detectMultiScale
// as:     cv::BaseCascadeClassifier::detectMultiScale (method) cv::BaseCascadeClassifier (trait) . detectMultiScale
// Arg ARG cv::Mat (boxed) image= cv::Mat (boxed) = 
// Arg ARG Vector[cv::Rect (simple)] objects= Vector[cv::Rect (simple)] = 
// Arg ARG Vector[Primitive(int)] rejectLevels= Vector[Primitive(int)] = 
// Arg ARG Vector[Primitive(double)] levelWeights= Vector[Primitive(double)] = 
// Arg ARG Primitive(double) scaleFactor= Primitive(double) = 
// Arg ARG Primitive(int) minNeighbors= Primitive(int) = 
// Arg ARG Primitive(int) flags= Primitive(int) = 
// Arg ARG cv::Size (simple) minSize= cv::Size (simple) = 
// Arg ARG cv::Size (simple) maxSize= cv::Size (simple) = 
// Arg ARG Primitive(bool) outputRejectLevels= Primitive(bool) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_BaseCascadeClassifier_detectMultiScale_Mat_image_VectorOfRect_objects_VectorOfint_rejectLevels_VectorOfdouble_levelWeights_double_scaleFactor_int_minNeighbors_int_flags_Size_minSize_Size_maxSize_bool_outputRejectLevels(void* instance, void* image, void* objects, void* rejectLevels, void* levelWeights, double scaleFactor, int minNeighbors, int flags, SizeWrapper minSize, SizeWrapper maxSize, bool outputRejectLevels) {
    try {
        reinterpret_cast<cv::BaseCascadeClassifier*>(instance)->detectMultiScale(*reinterpret_cast<cv::Mat*>(image), *reinterpret_cast<std::vector<cv::Rect>*>(objects), *reinterpret_cast<std::vector<int>*>(rejectLevels), *reinterpret_cast<std::vector<double>*>(levelWeights), scaleFactor, minNeighbors, flags, *reinterpret_cast<cv::Size*>(&minSize), *reinterpret_cast<cv::Size*>(&maxSize), outputRejectLevels);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_BaseCascadeClassifier_isOldFormatCascade_const
// parsed: cv::BaseCascadeClassifier::isOldFormatCascade
// as:     cv::BaseCascadeClassifier::isOldFormatCascade (method) cv::BaseCascadeClassifier (trait) . isOldFormatCascade
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_BaseCascadeClassifier_isOldFormatCascade_const(void* instance) {
    try {
        bool ret = reinterpret_cast<cv::BaseCascadeClassifier*>(instance)->isOldFormatCascade();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_BaseCascadeClassifier_getOriginalWindowSize_const
// parsed: cv::BaseCascadeClassifier::getOriginalWindowSize
// as:     cv::BaseCascadeClassifier::getOriginalWindowSize (method) cv::BaseCascadeClassifier (trait) . getOriginalWindowSize
// Return value: cv::Size (simple)
cv_return_value_SizeWrapper cv_core_cv_BaseCascadeClassifier_getOriginalWindowSize_const(void* instance) {
    try {
        cv::Size ret = reinterpret_cast<cv::BaseCascadeClassifier*>(instance)->getOriginalWindowSize();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<SizeWrapper*>(&ret) };
    } CVRS_CATCH(cv_return_value_SizeWrapper)
}

// cv_BaseCascadeClassifier_getFeatureType_const
// parsed: cv::BaseCascadeClassifier::getFeatureType
// as:     cv::BaseCascadeClassifier::getFeatureType (method) cv::BaseCascadeClassifier (trait) . getFeatureType
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_BaseCascadeClassifier_getFeatureType_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::BaseCascadeClassifier*>(instance)->getFeatureType();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_BaseCascadeClassifier_getOldCascade
// parsed: cv::BaseCascadeClassifier::getOldCascade
// as:     cv::BaseCascadeClassifier::getOldCascade (method) cv::BaseCascadeClassifier (trait) . getOldCascade
// Return value: RawPtr[Primitive(void)]
cv_return_value_void_X cv_core_cv_BaseCascadeClassifier_getOldCascade(void* instance) {
    try {
        void* ret = reinterpret_cast<cv::BaseCascadeClassifier*>(instance)->getOldCascade();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<void**>(&ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_BaseCascadeClassifier_setMaskGenerator_PtrOfMaskGenerator_maskGenerator
// parsed: cv::BaseCascadeClassifier::setMaskGenerator
// as:     cv::BaseCascadeClassifier::setMaskGenerator (method) cv::BaseCascadeClassifier (trait) . setMaskGenerator
// Arg ARG SmartPtr[cv::BaseCascadeClassifier::MaskGenerator (boxed)] maskGenerator= SmartPtr[cv::BaseCascadeClassifier::MaskGenerator (boxed)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_BaseCascadeClassifier_setMaskGenerator_PtrOfMaskGenerator_maskGenerator(void* instance, void* maskGenerator) {
    try {
        reinterpret_cast<cv::BaseCascadeClassifier*>(instance)->setMaskGenerator(reinterpret_cast<cv::BaseCascadeClassifier::MaskGenerator*>(maskGenerator));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_BaseCascadeClassifier_getMaskGenerator
// parsed: cv::BaseCascadeClassifier::getMaskGenerator
// as:     cv::BaseCascadeClassifier::getMaskGenerator (method) cv::BaseCascadeClassifier (trait) . getMaskGenerator
// Return value: SmartPtr[cv::BaseCascadeClassifier::MaskGenerator (boxed)]
cv_return_value_void_X cv_core_cv_BaseCascadeClassifier_getMaskGenerator(void* instance) {
    try {
        Ptr<cv::BaseCascadeClassifier::MaskGenerator> *ret = new Ptr<cv::BaseCascadeClassifier::MaskGenerator>(reinterpret_cast<cv::BaseCascadeClassifier*>(instance)->getMaskGenerator());
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_BaseCascadeClassifier_MaskGenerator_generateMask_Mat_src
// parsed: cv::BaseCascadeClassifier::MaskGenerator::generateMask
// as:     cv::BaseCascadeClassifier::MaskGenerator::generateMask (method) cv::BaseCascadeClassifier::MaskGenerator (trait) . generateMask
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_BaseCascadeClassifier_MaskGenerator_generateMask_Mat_src(void* instance, void* src) {
    try {
        cv::Mat ret = reinterpret_cast<cv::BaseCascadeClassifier::MaskGenerator*>(instance)->generateMask(*reinterpret_cast<cv::Mat*>(src));
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_BaseCascadeClassifier_MaskGenerator_initializeMask_Mat_unnamed_arg
// parsed: cv::BaseCascadeClassifier::MaskGenerator::initializeMask
// as:     cv::BaseCascadeClassifier::MaskGenerator::initializeMask (method) cv::BaseCascadeClassifier::MaskGenerator (trait) . initializeMask
// Arg ARG cv::Mat (boxed) unnamed_arg= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_BaseCascadeClassifier_MaskGenerator_initializeMask_Mat_unnamed_arg(void* instance, void* unnamed_arg) {
    try {
        reinterpret_cast<cv::BaseCascadeClassifier::MaskGenerator*>(instance)->initializeMask(*reinterpret_cast<cv::Mat*>(unnamed_arg));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_BufferPoolController_getReservedSize_const
// parsed: cv::BufferPoolController::getReservedSize
// as:     cv::BufferPoolController::getReservedSize (method) cv::BufferPoolController (trait) . getReservedSize
// Return value: Primitive(size_t)
cv_return_value_std_size_t cv_core_cv_BufferPoolController_getReservedSize_const(void* instance) {
    try {
        size_t ret = reinterpret_cast<cv::BufferPoolController*>(instance)->getReservedSize();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<std::size_t*>(&ret) };
    } CVRS_CATCH(cv_return_value_std_size_t)
}

// cv_BufferPoolController_getMaxReservedSize_const
// parsed: cv::BufferPoolController::getMaxReservedSize
// as:     cv::BufferPoolController::getMaxReservedSize (method) cv::BufferPoolController (trait) . getMaxReservedSize
// Return value: Primitive(size_t)
cv_return_value_std_size_t cv_core_cv_BufferPoolController_getMaxReservedSize_const(void* instance) {
    try {
        size_t ret = reinterpret_cast<cv::BufferPoolController*>(instance)->getMaxReservedSize();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<std::size_t*>(&ret) };
    } CVRS_CATCH(cv_return_value_std_size_t)
}

// cv_BufferPoolController_setMaxReservedSize_size_t_size
// parsed: cv::BufferPoolController::setMaxReservedSize
// as:     cv::BufferPoolController::setMaxReservedSize (method) cv::BufferPoolController (trait) . setMaxReservedSize
// Arg ARG Primitive(size_t) size= Primitive(size_t) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_BufferPoolController_setMaxReservedSize_size_t_size(void* instance, std::size_t size) {
    try {
        reinterpret_cast<cv::BufferPoolController*>(instance)->setMaxReservedSize(size);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_BufferPoolController_freeAllReservedBuffers
// parsed: cv::BufferPoolController::freeAllReservedBuffers
// as:     cv::BufferPoolController::freeAllReservedBuffers (method) cv::BufferPoolController (trait) . freeAllReservedBuffers
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_BufferPoolController_freeAllReservedBuffers(void* instance) {
    try {
        reinterpret_cast<cv::BufferPoolController*>(instance)->freeAllReservedBuffers();
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_CLAHE_apply_Mat_src_Mat_dst
// parsed: cv::CLAHE::apply
// as:     cv::CLAHE::apply (method) cv::CLAHE (trait) . apply
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_CLAHE_apply_Mat_src_Mat_dst(void* instance, void* src, void* dst) {
    try {
        reinterpret_cast<cv::CLAHE*>(instance)->apply(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_CLAHE_setClipLimit_double_clipLimit
// parsed: cv::CLAHE::setClipLimit
// as:     cv::CLAHE::setClipLimit (method) cv::CLAHE (trait) . setClipLimit
// Arg ARG Primitive(double) clipLimit= Primitive(double) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_CLAHE_setClipLimit_double_clipLimit(void* instance, double clipLimit) {
    try {
        reinterpret_cast<cv::CLAHE*>(instance)->setClipLimit(clipLimit);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_CLAHE_getClipLimit_const
// parsed: cv::CLAHE::getClipLimit
// as:     cv::CLAHE::getClipLimit (method) cv::CLAHE (trait) . getClipLimit
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_CLAHE_getClipLimit_const(void* instance) {
    try {
        double ret = reinterpret_cast<cv::CLAHE*>(instance)->getClipLimit();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_CLAHE_setTilesGridSize_Size_tileGridSize
// parsed: cv::CLAHE::setTilesGridSize
// as:     cv::CLAHE::setTilesGridSize (method) cv::CLAHE (trait) . setTilesGridSize
// Arg ARG cv::Size (simple) tileGridSize= cv::Size (simple) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_CLAHE_setTilesGridSize_Size_tileGridSize(void* instance, SizeWrapper tileGridSize) {
    try {
        reinterpret_cast<cv::CLAHE*>(instance)->setTilesGridSize(*reinterpret_cast<cv::Size*>(&tileGridSize));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_CLAHE_getTilesGridSize_const
// parsed: cv::CLAHE::getTilesGridSize
// as:     cv::CLAHE::getTilesGridSize (method) cv::CLAHE (trait) . getTilesGridSize
// Return value: cv::Size (simple)
cv_return_value_SizeWrapper cv_core_cv_CLAHE_getTilesGridSize_const(void* instance) {
    try {
        cv::Size ret = reinterpret_cast<cv::CLAHE*>(instance)->getTilesGridSize();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<SizeWrapper*>(&ret) };
    } CVRS_CATCH(cv_return_value_SizeWrapper)
}

// cv_CLAHE_collectGarbage
// parsed: cv::CLAHE::collectGarbage
// as:     cv::CLAHE::collectGarbage (method) cv::CLAHE (trait) . collectGarbage
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_CLAHE_collectGarbage(void* instance) {
    try {
        reinterpret_cast<cv::CLAHE*>(instance)->collectGarbage();
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_CalibrateCRF_process_VectorOfMat_src_Mat_dst_Mat_times
// parsed: cv::CalibrateCRF::process
// as:     cv::CalibrateCRF::process (method) cv::CalibrateCRF (trait) . process
// Arg ARG Vector[cv::Mat (boxed)] src= Vector[cv::Mat (boxed)] = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) times= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_CalibrateCRF_process_VectorOfMat_src_Mat_dst_Mat_times(void* instance, void* src, void* dst, void* times) {
    try {
        reinterpret_cast<cv::CalibrateCRF*>(instance)->process(*reinterpret_cast<std::vector<cv::Mat>*>(src), *reinterpret_cast<cv::Mat*>(dst), *reinterpret_cast<cv::Mat*>(times));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_CalibrateDebevec_getLambda_const
// parsed: cv::CalibrateDebevec::getLambda
// as:     cv::CalibrateDebevec::getLambda (method) cv::CalibrateDebevec (trait) . getLambda
// Return value: Primitive(float)
cv_return_value_float cv_core_cv_CalibrateDebevec_getLambda_const(void* instance) {
    try {
        float ret = reinterpret_cast<cv::CalibrateDebevec*>(instance)->getLambda();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<float*>(&ret) };
    } CVRS_CATCH(cv_return_value_float)
}

// cv_CalibrateDebevec_setLambda_float_lambda
// parsed: cv::CalibrateDebevec::setLambda
// as:     cv::CalibrateDebevec::setLambda (method) cv::CalibrateDebevec (trait) . setLambda
// Arg ARG Primitive(float) lambda= Primitive(float) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_CalibrateDebevec_setLambda_float_lambda(void* instance, float lambda) {
    try {
        reinterpret_cast<cv::CalibrateDebevec*>(instance)->setLambda(lambda);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_CalibrateDebevec_getSamples_const
// parsed: cv::CalibrateDebevec::getSamples
// as:     cv::CalibrateDebevec::getSamples (method) cv::CalibrateDebevec (trait) . getSamples
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_CalibrateDebevec_getSamples_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::CalibrateDebevec*>(instance)->getSamples();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_CalibrateDebevec_setSamples_int_samples
// parsed: cv::CalibrateDebevec::setSamples
// as:     cv::CalibrateDebevec::setSamples (method) cv::CalibrateDebevec (trait) . setSamples
// Arg ARG Primitive(int) samples= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_CalibrateDebevec_setSamples_int_samples(void* instance, int samples) {
    try {
        reinterpret_cast<cv::CalibrateDebevec*>(instance)->setSamples(samples);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_CalibrateDebevec_getRandom_const
// parsed: cv::CalibrateDebevec::getRandom
// as:     cv::CalibrateDebevec::getRandom (method) cv::CalibrateDebevec (trait) . getRandom
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_CalibrateDebevec_getRandom_const(void* instance) {
    try {
        bool ret = reinterpret_cast<cv::CalibrateDebevec*>(instance)->getRandom();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_CalibrateDebevec_setRandom_bool_random
// parsed: cv::CalibrateDebevec::setRandom
// as:     cv::CalibrateDebevec::setRandom (method) cv::CalibrateDebevec (trait) . setRandom
// Arg ARG Primitive(bool) random= Primitive(bool) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_CalibrateDebevec_setRandom_bool_random(void* instance, bool random) {
    try {
        reinterpret_cast<cv::CalibrateDebevec*>(instance)->setRandom(random);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_CalibrateRobertson_getMaxIter_const
// parsed: cv::CalibrateRobertson::getMaxIter
// as:     cv::CalibrateRobertson::getMaxIter (method) cv::CalibrateRobertson (trait) . getMaxIter
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_CalibrateRobertson_getMaxIter_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::CalibrateRobertson*>(instance)->getMaxIter();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_CalibrateRobertson_setMaxIter_int_max_iter
// parsed: cv::CalibrateRobertson::setMaxIter
// as:     cv::CalibrateRobertson::setMaxIter (method) cv::CalibrateRobertson (trait) . setMaxIter
// Arg ARG Primitive(int) max_iter= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_CalibrateRobertson_setMaxIter_int_max_iter(void* instance, int max_iter) {
    try {
        reinterpret_cast<cv::CalibrateRobertson*>(instance)->setMaxIter(max_iter);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_CalibrateRobertson_getThreshold_const
// parsed: cv::CalibrateRobertson::getThreshold
// as:     cv::CalibrateRobertson::getThreshold (method) cv::CalibrateRobertson (trait) . getThreshold
// Return value: Primitive(float)
cv_return_value_float cv_core_cv_CalibrateRobertson_getThreshold_const(void* instance) {
    try {
        float ret = reinterpret_cast<cv::CalibrateRobertson*>(instance)->getThreshold();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<float*>(&ret) };
    } CVRS_CATCH(cv_return_value_float)
}

// cv_CalibrateRobertson_setThreshold_float_threshold
// parsed: cv::CalibrateRobertson::setThreshold
// as:     cv::CalibrateRobertson::setThreshold (method) cv::CalibrateRobertson (trait) . setThreshold
// Arg ARG Primitive(float) threshold= Primitive(float) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_CalibrateRobertson_setThreshold_float_threshold(void* instance, float threshold) {
    try {
        reinterpret_cast<cv::CalibrateRobertson*>(instance)->setThreshold(threshold);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_CalibrateRobertson_getRadiance_const
// parsed: cv::CalibrateRobertson::getRadiance
// as:     cv::CalibrateRobertson::getRadiance (method) cv::CalibrateRobertson (trait) . getRadiance
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_CalibrateRobertson_getRadiance_const(void* instance) {
    try {
        cv::Mat ret = reinterpret_cast<cv::CalibrateRobertson*>(instance)->getRadiance();
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// boxed class: cv::CascadeClassifier
void cv_delete_CascadeClassifier(void* instance) {
    delete (cv::CascadeClassifier*) instance;
}
// cv_CascadeClassifier_CascadeClassifier
// parsed: cv::CascadeClassifier::CascadeClassifier
// as:     cv::CascadeClassifier::CascadeClassifier (constructor) cv::CascadeClassifier . new
// Return value: cv::CascadeClassifier (boxed)
cv_return_value_void_X cv_core_cv_CascadeClassifier_CascadeClassifier() {
    try {
        cv::CascadeClassifier* ret = new cv::CascadeClassifier();
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_CascadeClassifier_CascadeClassifier_String_filename
// parsed: cv::CascadeClassifier::CascadeClassifier
// as:     cv::CascadeClassifier::CascadeClassifier (constructor) cv::CascadeClassifier . new
// Arg ARG string filename= string = 
// Return value: cv::CascadeClassifier (boxed)
cv_return_value_void_X cv_core_cv_CascadeClassifier_CascadeClassifier_String_filename(const char* filename) {
    try {
        cv::CascadeClassifier* ret = new cv::CascadeClassifier(String(filename));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_CascadeClassifier_empty_const
// parsed: cv::CascadeClassifier::empty
// as:     cv::CascadeClassifier::empty (method) cv::CascadeClassifier . empty
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_CascadeClassifier_empty_const(void* instance) {
    try {
        bool ret = reinterpret_cast<cv::CascadeClassifier*>(instance)->empty();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_CascadeClassifier_load_String_filename
// parsed: cv::CascadeClassifier::load
// as:     cv::CascadeClassifier::load (method) cv::CascadeClassifier . load
// Arg ARG string filename= string = 
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_CascadeClassifier_load_String_filename(void* instance, const char* filename) {
    try {
        bool ret = reinterpret_cast<cv::CascadeClassifier*>(instance)->load(String(filename));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_CascadeClassifier_detectMultiScale_Mat_image_VectorOfRect_objects_double_scaleFactor_int_minNeighbors_int_flags_Size_minSize_Size_maxSize
// parsed: cv::CascadeClassifier::detectMultiScale
// as:     cv::CascadeClassifier::detectMultiScale (method) cv::CascadeClassifier . detectMultiScale
// Arg ARG cv::Mat (boxed) image= cv::Mat (boxed) = 
// Arg ARG Vector[cv::Rect (simple)] objects= Vector[cv::Rect (simple)] = 
// Arg ARG Primitive(double) scaleFactor= Primitive(double) = 1.1
// Arg ARG Primitive(int) minNeighbors= Primitive(int) = 3
// Arg ARG Primitive(int) flags= Primitive(int) = 0
// Arg ARG cv::Size (simple) minSize= cv::Size (simple) = Size()
// Arg ARG cv::Size (simple) maxSize= cv::Size (simple) = Size()
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_CascadeClassifier_detectMultiScale_Mat_image_VectorOfRect_objects_double_scaleFactor_int_minNeighbors_int_flags_Size_minSize_Size_maxSize(void* instance, void* image, void* objects, double scaleFactor, int minNeighbors, int flags, SizeWrapper minSize, SizeWrapper maxSize) {
    try {
        reinterpret_cast<cv::CascadeClassifier*>(instance)->detectMultiScale(*reinterpret_cast<cv::Mat*>(image), *reinterpret_cast<std::vector<cv::Rect>*>(objects), scaleFactor, minNeighbors, flags, *reinterpret_cast<cv::Size*>(&minSize), *reinterpret_cast<cv::Size*>(&maxSize));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_CascadeClassifier_detectMultiScale_Mat_image_VectorOfRect_objects_VectorOfint_numDetections_double_scaleFactor_int_minNeighbors_int_flags_Size_minSize_Size_maxSize
// parsed: cv::CascadeClassifier::detectMultiScale
// as:     cv::CascadeClassifier::detectMultiScale (method) cv::CascadeClassifier . detectMultiScale
// Arg ARG cv::Mat (boxed) image= cv::Mat (boxed) = 
// Arg ARG Vector[cv::Rect (simple)] objects= Vector[cv::Rect (simple)] = 
// Arg ARG Vector[Primitive(int)] numDetections= Vector[Primitive(int)] = 
// Arg ARG Primitive(double) scaleFactor= Primitive(double) = 1.1
// Arg ARG Primitive(int) minNeighbors= Primitive(int) = 3
// Arg ARG Primitive(int) flags= Primitive(int) = 0
// Arg ARG cv::Size (simple) minSize= cv::Size (simple) = Size()
// Arg ARG cv::Size (simple) maxSize= cv::Size (simple) = Size()
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_CascadeClassifier_detectMultiScale_Mat_image_VectorOfRect_objects_VectorOfint_numDetections_double_scaleFactor_int_minNeighbors_int_flags_Size_minSize_Size_maxSize(void* instance, void* image, void* objects, void* numDetections, double scaleFactor, int minNeighbors, int flags, SizeWrapper minSize, SizeWrapper maxSize) {
    try {
        reinterpret_cast<cv::CascadeClassifier*>(instance)->detectMultiScale(*reinterpret_cast<cv::Mat*>(image), *reinterpret_cast<std::vector<cv::Rect>*>(objects), *reinterpret_cast<std::vector<int>*>(numDetections), scaleFactor, minNeighbors, flags, *reinterpret_cast<cv::Size*>(&minSize), *reinterpret_cast<cv::Size*>(&maxSize));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_CascadeClassifier_detectMultiScale_Mat_image_VectorOfRect_objects_VectorOfint_rejectLevels_VectorOfdouble_levelWeights_double_scaleFactor_int_minNeighbors_int_flags_Size_minSize_Size_maxSize_bool_outputRejectLevels
// parsed: cv::CascadeClassifier::detectMultiScale
// as:     cv::CascadeClassifier::detectMultiScale (method) cv::CascadeClassifier . detectMultiScale
// Arg ARG cv::Mat (boxed) image= cv::Mat (boxed) = 
// Arg ARG Vector[cv::Rect (simple)] objects= Vector[cv::Rect (simple)] = 
// Arg ARG Vector[Primitive(int)] rejectLevels= Vector[Primitive(int)] = 
// Arg ARG Vector[Primitive(double)] levelWeights= Vector[Primitive(double)] = 
// Arg ARG Primitive(double) scaleFactor= Primitive(double) = 1.1
// Arg ARG Primitive(int) minNeighbors= Primitive(int) = 3
// Arg ARG Primitive(int) flags= Primitive(int) = 0
// Arg ARG cv::Size (simple) minSize= cv::Size (simple) = Size()
// Arg ARG cv::Size (simple) maxSize= cv::Size (simple) = Size()
// Arg ARG Primitive(bool) outputRejectLevels= Primitive(bool) = false
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_CascadeClassifier_detectMultiScale_Mat_image_VectorOfRect_objects_VectorOfint_rejectLevels_VectorOfdouble_levelWeights_double_scaleFactor_int_minNeighbors_int_flags_Size_minSize_Size_maxSize_bool_outputRejectLevels(void* instance, void* image, void* objects, void* rejectLevels, void* levelWeights, double scaleFactor, int minNeighbors, int flags, SizeWrapper minSize, SizeWrapper maxSize, bool outputRejectLevels) {
    try {
        reinterpret_cast<cv::CascadeClassifier*>(instance)->detectMultiScale(*reinterpret_cast<cv::Mat*>(image), *reinterpret_cast<std::vector<cv::Rect>*>(objects), *reinterpret_cast<std::vector<int>*>(rejectLevels), *reinterpret_cast<std::vector<double>*>(levelWeights), scaleFactor, minNeighbors, flags, *reinterpret_cast<cv::Size*>(&minSize), *reinterpret_cast<cv::Size*>(&maxSize), outputRejectLevels);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_CascadeClassifier_isOldFormatCascade_const
// parsed: cv::CascadeClassifier::isOldFormatCascade
// as:     cv::CascadeClassifier::isOldFormatCascade (method) cv::CascadeClassifier . isOldFormatCascade
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_CascadeClassifier_isOldFormatCascade_const(void* instance) {
    try {
        bool ret = reinterpret_cast<cv::CascadeClassifier*>(instance)->isOldFormatCascade();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_CascadeClassifier_getOriginalWindowSize_const
// parsed: cv::CascadeClassifier::getOriginalWindowSize
// as:     cv::CascadeClassifier::getOriginalWindowSize (method) cv::CascadeClassifier . getOriginalWindowSize
// Return value: cv::Size (simple)
cv_return_value_SizeWrapper cv_core_cv_CascadeClassifier_getOriginalWindowSize_const(void* instance) {
    try {
        cv::Size ret = reinterpret_cast<cv::CascadeClassifier*>(instance)->getOriginalWindowSize();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<SizeWrapper*>(&ret) };
    } CVRS_CATCH(cv_return_value_SizeWrapper)
}

// cv_CascadeClassifier_getFeatureType_const
// parsed: cv::CascadeClassifier::getFeatureType
// as:     cv::CascadeClassifier::getFeatureType (method) cv::CascadeClassifier . getFeatureType
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_CascadeClassifier_getFeatureType_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::CascadeClassifier*>(instance)->getFeatureType();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_CascadeClassifier_getOldCascade
// parsed: cv::CascadeClassifier::getOldCascade
// as:     cv::CascadeClassifier::getOldCascade (method) cv::CascadeClassifier . getOldCascade
// Return value: RawPtr[Primitive(void)]
cv_return_value_void_X cv_core_cv_CascadeClassifier_getOldCascade(void* instance) {
    try {
        void* ret = reinterpret_cast<cv::CascadeClassifier*>(instance)->getOldCascade();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<void**>(&ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_CascadeClassifier_convert_String_oldcascade_String_newcascade
// parsed: cv::CascadeClassifier::convert
// as:     cv::CascadeClassifier::convert (method) cv::CascadeClassifier . convert
// Arg ARG string oldcascade= string = 
// Arg ARG string newcascade= string = 
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_CascadeClassifier_convert_String_oldcascade_String_newcascade(const char* oldcascade, const char* newcascade) {
    try {
        bool ret = cv::CascadeClassifier::convert(String(oldcascade), String(newcascade));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_CascadeClassifier_setMaskGenerator_PtrOfMaskGenerator_maskGenerator
// parsed: cv::CascadeClassifier::setMaskGenerator
// as:     cv::CascadeClassifier::setMaskGenerator (method) cv::CascadeClassifier . setMaskGenerator
// Arg ARG SmartPtr[cv::BaseCascadeClassifier::MaskGenerator (boxed)] maskGenerator= SmartPtr[cv::BaseCascadeClassifier::MaskGenerator (boxed)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_CascadeClassifier_setMaskGenerator_PtrOfMaskGenerator_maskGenerator(void* instance, void* maskGenerator) {
    try {
        reinterpret_cast<cv::CascadeClassifier*>(instance)->setMaskGenerator(reinterpret_cast<cv::BaseCascadeClassifier::MaskGenerator*>(maskGenerator));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_CascadeClassifier_getMaskGenerator
// parsed: cv::CascadeClassifier::getMaskGenerator
// as:     cv::CascadeClassifier::getMaskGenerator (method) cv::CascadeClassifier . getMaskGenerator
// Return value: SmartPtr[cv::BaseCascadeClassifier::MaskGenerator (boxed)]
cv_return_value_void_X cv_core_cv_CascadeClassifier_getMaskGenerator(void* instance) {
    try {
        Ptr<cv::BaseCascadeClassifier::MaskGenerator> *ret = new Ptr<cv::BaseCascadeClassifier::MaskGenerator>(reinterpret_cast<cv::CascadeClassifier*>(instance)->getMaskGenerator());
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// boxed class: cv::ChiHistogramCostExtractor
void cv_delete_ChiHistogramCostExtractor(void* instance) {
    delete (cv::ChiHistogramCostExtractor*) instance;
}
// cv_CirclesGridFinderParameters2_CirclesGridFinderParameters2
// parsed: cv::CirclesGridFinderParameters2::CirclesGridFinderParameters2
// as:     cv::CirclesGridFinderParameters2::CirclesGridFinderParameters2 (constructor) cv::CirclesGridFinderParameters2 (simple) . new
// Return value: cv::CirclesGridFinderParameters2 (simple)
cv_return_value_CirclesGridFinderParameters2 cv_core_cv_CirclesGridFinderParameters2_CirclesGridFinderParameters2() {
    try {
        cv::CirclesGridFinderParameters2 ret;
        return { Error::Code::StsOk, NULL, *reinterpret_cast<cv::CirclesGridFinderParameters2*>(&ret) };
    } CVRS_CATCH(cv_return_value_CirclesGridFinderParameters2)
}

// boxed class: cv::CommandLineParser
void cv_delete_CommandLineParser(void* instance) {
    delete (cv::CommandLineParser*) instance;
}
// cv_CommandLineParser_CommandLineParser_CommandLineParser_parser
// parsed: cv::CommandLineParser::CommandLineParser
// as:     cv::CommandLineParser::CommandLineParser (constructor) cv::CommandLineParser . new
// Arg ARG cv::CommandLineParser (boxed) parser= cv::CommandLineParser (boxed) = 
// Return value: cv::CommandLineParser (boxed)
cv_return_value_void_X cv_core_cv_CommandLineParser_CommandLineParser_CommandLineParser_parser(void* parser) {
    try {
        cv::CommandLineParser* ret = new cv::CommandLineParser(*reinterpret_cast<cv::CommandLineParser*>(parser));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_CommandLineParser_getPathToApplication_const
// parsed: cv::CommandLineParser::getPathToApplication
// as:     cv::CommandLineParser::getPathToApplication (method) cv::CommandLineParser . getPathToApplication
// Return value: string
cv_return_value_char_X cv_core_cv_CommandLineParser_getPathToApplication_const(void* instance) {
    try {
        String ret = reinterpret_cast<cv::CommandLineParser*>(instance)->getPathToApplication();
        return { Error::Code::StsOk, NULL, strdup(ret.c_str()) };
    } CVRS_CATCH(cv_return_value_char_X)
}

// cv_CommandLineParser_has_const_String_name
// parsed: cv::CommandLineParser::has
// as:     cv::CommandLineParser::has (method) cv::CommandLineParser . has
// Arg ARG string name= string = 
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_CommandLineParser_has_const_String_name(void* instance, const char* name) {
    try {
        bool ret = reinterpret_cast<cv::CommandLineParser*>(instance)->has(String(name));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_CommandLineParser_check_const
// parsed: cv::CommandLineParser::check
// as:     cv::CommandLineParser::check (method) cv::CommandLineParser . check
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_CommandLineParser_check_const(void* instance) {
    try {
        bool ret = reinterpret_cast<cv::CommandLineParser*>(instance)->check();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_CommandLineParser_about_String_message
// parsed: cv::CommandLineParser::about
// as:     cv::CommandLineParser::about (method) cv::CommandLineParser . about
// Arg ARG string message= string = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_CommandLineParser_about_String_message(void* instance, const char* message) {
    try {
        reinterpret_cast<cv::CommandLineParser*>(instance)->about(String(message));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_CommandLineParser_printMessage_const
// parsed: cv::CommandLineParser::printMessage
// as:     cv::CommandLineParser::printMessage (method) cv::CommandLineParser . printMessage
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_CommandLineParser_printMessage_const(void* instance) {
    try {
        reinterpret_cast<cv::CommandLineParser*>(instance)->printMessage();
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_CommandLineParser_printErrors_const
// parsed: cv::CommandLineParser::printErrors
// as:     cv::CommandLineParser::printErrors (method) cv::CommandLineParser . printErrors
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_CommandLineParser_printErrors_const(void* instance) {
    try {
        reinterpret_cast<cv::CommandLineParser*>(instance)->printErrors();
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// boxed class: cv::CompressedRectilinearPortraitWarper
void cv_delete_CompressedRectilinearPortraitWarper(void* instance) {
    delete (cv::CompressedRectilinearPortraitWarper*) instance;
}
// cv_CompressedRectilinearPortraitWarper_CompressedRectilinearPortraitWarper_float_A_float_B
// parsed: cv::CompressedRectilinearPortraitWarper::CompressedRectilinearPortraitWarper
// as:     cv::CompressedRectilinearPortraitWarper::CompressedRectilinearPortraitWarper (constructor) cv::CompressedRectilinearPortraitWarper . new
// Arg ARG Primitive(float) A= Primitive(float) = 1
// Arg ARG Primitive(float) B= Primitive(float) = 1
// Return value: cv::CompressedRectilinearPortraitWarper (boxed)
cv_return_value_void_X cv_core_cv_CompressedRectilinearPortraitWarper_CompressedRectilinearPortraitWarper_float_A_float_B(float A, float B) {
    try {
        cv::CompressedRectilinearPortraitWarper* ret = new cv::CompressedRectilinearPortraitWarper(A, B);
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// boxed class: cv::CompressedRectilinearWarper
void cv_delete_CompressedRectilinearWarper(void* instance) {
    delete (cv::CompressedRectilinearWarper*) instance;
}
// cv_CompressedRectilinearWarper_CompressedRectilinearWarper_float_A_float_B
// parsed: cv::CompressedRectilinearWarper::CompressedRectilinearWarper
// as:     cv::CompressedRectilinearWarper::CompressedRectilinearWarper (constructor) cv::CompressedRectilinearWarper . new
// Arg ARG Primitive(float) A= Primitive(float) = 1
// Arg ARG Primitive(float) B= Primitive(float) = 1
// Return value: cv::CompressedRectilinearWarper (boxed)
cv_return_value_void_X cv_core_cv_CompressedRectilinearWarper_CompressedRectilinearWarper_float_A_float_B(float A, float B) {
    try {
        cv::CompressedRectilinearWarper* ret = new cv::CompressedRectilinearWarper(A, B);
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// boxed class: cv::ConjGradSolver
void cv_delete_ConjGradSolver(void* instance) {
    delete (cv::ConjGradSolver*) instance;
}
// cv_ConjGradSolver_create_PtrOfFunction_f_TermCriteria_termcrit
// parsed: cv::ConjGradSolver::create
// as:     cv::ConjGradSolver::create (method) cv::ConjGradSolver . create
// Arg ARG SmartPtr[cv::MinProblemSolver::Function (boxed)] f= SmartPtr[cv::MinProblemSolver::Function (boxed)] = Ptr<ConjGradSolver::Function>()
// Arg ARG cv::TermCriteria (boxed) termcrit= cv::TermCriteria (boxed) = TermCriteria(TermCriteria::MAX_ITER+TermCriteria::EPS,5000,0.000001)
// Return value: SmartPtr[cv::ConjGradSolver (boxed)]
cv_return_value_void_X cv_core_cv_ConjGradSolver_create_PtrOfFunction_f_TermCriteria_termcrit(void* f, void* termcrit) {
    try {
        Ptr<cv::ConjGradSolver> *ret = new Ptr<cv::ConjGradSolver>(cv::ConjGradSolver::create(reinterpret_cast<cv::MinProblemSolver::Function*>(f), *reinterpret_cast<cv::TermCriteria*>(termcrit)));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// boxed class: cv::CylindricalWarper
void cv_delete_CylindricalWarper(void* instance) {
    delete (cv::CylindricalWarper*) instance;
}
// cv_DMatch_DMatch
// parsed: cv::DMatch::DMatch
// as:     cv::DMatch::DMatch (constructor) cv::DMatch (simple) . new
// Return value: cv::DMatch (simple)
cv_return_value_DMatch cv_core_cv_DMatch_DMatch() {
    try {
        cv::DMatch ret;
        return { Error::Code::StsOk, NULL, *reinterpret_cast<cv::DMatch*>(&ret) };
    } CVRS_CATCH(cv_return_value_DMatch)
}

// cv_DMatch_DMatch_int__queryIdx_int__trainIdx_float__distance
// parsed: cv::DMatch::DMatch
// as:     cv::DMatch::DMatch (constructor) cv::DMatch (simple) . new
// Arg ARG Primitive(int) _queryIdx= Primitive(int) = 
// Arg ARG Primitive(int) _trainIdx= Primitive(int) = 
// Arg ARG Primitive(float) _distance= Primitive(float) = 
// Return value: cv::DMatch (simple)
cv_return_value_DMatch cv_core_cv_DMatch_DMatch_int__queryIdx_int__trainIdx_float__distance(int _queryIdx, int _trainIdx, float _distance) {
    try {
        cv::DMatch ret(_queryIdx, _trainIdx, _distance);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<cv::DMatch*>(&ret) };
    } CVRS_CATCH(cv_return_value_DMatch)
}

// cv_DMatch_DMatch_int__queryIdx_int__trainIdx_int__imgIdx_float__distance
// parsed: cv::DMatch::DMatch
// as:     cv::DMatch::DMatch (constructor) cv::DMatch (simple) . new
// Arg ARG Primitive(int) _queryIdx= Primitive(int) = 
// Arg ARG Primitive(int) _trainIdx= Primitive(int) = 
// Arg ARG Primitive(int) _imgIdx= Primitive(int) = 
// Arg ARG Primitive(float) _distance= Primitive(float) = 
// Return value: cv::DMatch (simple)
cv_return_value_DMatch cv_core_cv_DMatch_DMatch_int__queryIdx_int__trainIdx_int__imgIdx_float__distance(int _queryIdx, int _trainIdx, int _imgIdx, float _distance) {
    try {
        cv::DMatch ret(_queryIdx, _trainIdx, _imgIdx, _distance);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<cv::DMatch*>(&ret) };
    } CVRS_CATCH(cv_return_value_DMatch)
}

// cv_DenseOpticalFlow_calc_Mat_I0_Mat_I1_Mat_flow
// parsed: cv::DenseOpticalFlow::calc
// as:     cv::DenseOpticalFlow::calc (method) cv::DenseOpticalFlow (trait) . calc
// Arg ARG cv::Mat (boxed) I0= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) I1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) flow= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_DenseOpticalFlow_calc_Mat_I0_Mat_I1_Mat_flow(void* instance, void* I0, void* I1, void* flow) {
    try {
        reinterpret_cast<cv::DenseOpticalFlow*>(instance)->calc(*reinterpret_cast<cv::Mat*>(I0), *reinterpret_cast<cv::Mat*>(I1), *reinterpret_cast<cv::Mat*>(flow));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_DenseOpticalFlow_collectGarbage
// parsed: cv::DenseOpticalFlow::collectGarbage
// as:     cv::DenseOpticalFlow::collectGarbage (method) cv::DenseOpticalFlow (trait) . collectGarbage
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_DenseOpticalFlow_collectGarbage(void* instance) {
    try {
        reinterpret_cast<cv::DenseOpticalFlow*>(instance)->collectGarbage();
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_DescriptorMatcher_add_VectorOfMat_descriptors
// parsed: cv::DescriptorMatcher::add
// as:     cv::DescriptorMatcher::add (method) cv::DescriptorMatcher (trait) . add
// Arg ARG Vector[cv::Mat (boxed)] descriptors= Vector[cv::Mat (boxed)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_DescriptorMatcher_add_VectorOfMat_descriptors(void* instance, void* descriptors) {
    try {
        reinterpret_cast<cv::DescriptorMatcher*>(instance)->add(*reinterpret_cast<std::vector<cv::Mat>*>(descriptors));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_DescriptorMatcher_getTrainDescriptors_const
// parsed: cv::DescriptorMatcher::getTrainDescriptors
// as:     cv::DescriptorMatcher::getTrainDescriptors (method) cv::DescriptorMatcher (trait) . getTrainDescriptors
// Return value: Vector[cv::Mat (boxed)]
cv_return_value_void_X cv_core_cv_DescriptorMatcher_getTrainDescriptors_const(void* instance) {
    try {
        std::vector<cv::Mat> ret = reinterpret_cast<cv::DescriptorMatcher*>(instance)->getTrainDescriptors();
        return { Error::Code::StsOk, NULL, (void *)new std::vector<cv::Mat>(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_DescriptorMatcher_clear
// parsed: cv::DescriptorMatcher::clear
// as:     cv::DescriptorMatcher::clear (method) cv::DescriptorMatcher (trait) . clear
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_DescriptorMatcher_clear(void* instance) {
    try {
        reinterpret_cast<cv::DescriptorMatcher*>(instance)->clear();
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_DescriptorMatcher_empty_const
// parsed: cv::DescriptorMatcher::empty
// as:     cv::DescriptorMatcher::empty (method) cv::DescriptorMatcher (trait) . empty
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_DescriptorMatcher_empty_const(void* instance) {
    try {
        bool ret = reinterpret_cast<cv::DescriptorMatcher*>(instance)->empty();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_DescriptorMatcher_isMaskSupported_const
// parsed: cv::DescriptorMatcher::isMaskSupported
// as:     cv::DescriptorMatcher::isMaskSupported (method) cv::DescriptorMatcher (trait) . isMaskSupported
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_DescriptorMatcher_isMaskSupported_const(void* instance) {
    try {
        bool ret = reinterpret_cast<cv::DescriptorMatcher*>(instance)->isMaskSupported();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_DescriptorMatcher_train
// parsed: cv::DescriptorMatcher::train
// as:     cv::DescriptorMatcher::train (method) cv::DescriptorMatcher (trait) . train
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_DescriptorMatcher_train(void* instance) {
    try {
        reinterpret_cast<cv::DescriptorMatcher*>(instance)->train();
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_DescriptorMatcher_match_const_Mat_queryDescriptors_Mat_trainDescriptors_VectorOfDMatch_matches_Mat_mask
// parsed: cv::DescriptorMatcher::match
// as:     cv::DescriptorMatcher::match (method) cv::DescriptorMatcher (trait) . match
// Arg ARG cv::Mat (boxed) queryDescriptors= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) trainDescriptors= cv::Mat (boxed) = 
// Arg ARG Vector[cv::DMatch (simple)] matches= Vector[cv::DMatch (simple)] = 
// Arg ARG cv::Mat (boxed) mask= cv::Mat (boxed) = noArray()
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_DescriptorMatcher_match_const_Mat_queryDescriptors_Mat_trainDescriptors_VectorOfDMatch_matches_Mat_mask(void* instance, void* queryDescriptors, void* trainDescriptors, void* matches, void* mask) {
    try {
        reinterpret_cast<cv::DescriptorMatcher*>(instance)->match(*reinterpret_cast<cv::Mat*>(queryDescriptors), *reinterpret_cast<cv::Mat*>(trainDescriptors), *reinterpret_cast<std::vector<cv::DMatch>*>(matches), *reinterpret_cast<cv::Mat*>(mask));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_DescriptorMatcher_knnMatch_const_Mat_queryDescriptors_Mat_trainDescriptors_VectorOfVectorOfDMatch_matches_int_k_Mat_mask_bool_compactResult
// parsed: cv::DescriptorMatcher::knnMatch
// as:     cv::DescriptorMatcher::knnMatch (method) cv::DescriptorMatcher (trait) . knnMatch
// Arg ARG cv::Mat (boxed) queryDescriptors= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) trainDescriptors= cv::Mat (boxed) = 
// Arg ARG Vector[Vector[cv::DMatch (simple)]] matches= Vector[Vector[cv::DMatch (simple)]] = 
// Arg ARG Primitive(int) k= Primitive(int) = 
// Arg ARG cv::Mat (boxed) mask= cv::Mat (boxed) = noArray()
// Arg ARG Primitive(bool) compactResult= Primitive(bool) = false
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_DescriptorMatcher_knnMatch_const_Mat_queryDescriptors_Mat_trainDescriptors_VectorOfVectorOfDMatch_matches_int_k_Mat_mask_bool_compactResult(void* instance, void* queryDescriptors, void* trainDescriptors, void* matches, int k, void* mask, bool compactResult) {
    try {
        reinterpret_cast<cv::DescriptorMatcher*>(instance)->knnMatch(*reinterpret_cast<cv::Mat*>(queryDescriptors), *reinterpret_cast<cv::Mat*>(trainDescriptors), *reinterpret_cast<std::vector<std::vector<cv::DMatch>>*>(matches), k, *reinterpret_cast<cv::Mat*>(mask), compactResult);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_DescriptorMatcher_radiusMatch_const_Mat_queryDescriptors_Mat_trainDescriptors_VectorOfVectorOfDMatch_matches_float_maxDistance_Mat_mask_bool_compactResult
// parsed: cv::DescriptorMatcher::radiusMatch
// as:     cv::DescriptorMatcher::radiusMatch (method) cv::DescriptorMatcher (trait) . radiusMatch
// Arg ARG cv::Mat (boxed) queryDescriptors= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) trainDescriptors= cv::Mat (boxed) = 
// Arg ARG Vector[Vector[cv::DMatch (simple)]] matches= Vector[Vector[cv::DMatch (simple)]] = 
// Arg ARG Primitive(float) maxDistance= Primitive(float) = 
// Arg ARG cv::Mat (boxed) mask= cv::Mat (boxed) = noArray()
// Arg ARG Primitive(bool) compactResult= Primitive(bool) = false
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_DescriptorMatcher_radiusMatch_const_Mat_queryDescriptors_Mat_trainDescriptors_VectorOfVectorOfDMatch_matches_float_maxDistance_Mat_mask_bool_compactResult(void* instance, void* queryDescriptors, void* trainDescriptors, void* matches, float maxDistance, void* mask, bool compactResult) {
    try {
        reinterpret_cast<cv::DescriptorMatcher*>(instance)->radiusMatch(*reinterpret_cast<cv::Mat*>(queryDescriptors), *reinterpret_cast<cv::Mat*>(trainDescriptors), *reinterpret_cast<std::vector<std::vector<cv::DMatch>>*>(matches), maxDistance, *reinterpret_cast<cv::Mat*>(mask), compactResult);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_DescriptorMatcher_match_Mat_queryDescriptors_VectorOfDMatch_matches_VectorOfMat_masks
// parsed: cv::DescriptorMatcher::match
// as:     cv::DescriptorMatcher::match (method) cv::DescriptorMatcher (trait) . match
// Arg ARG cv::Mat (boxed) queryDescriptors= cv::Mat (boxed) = 
// Arg ARG Vector[cv::DMatch (simple)] matches= Vector[cv::DMatch (simple)] = 
// Arg ARG Vector[cv::Mat (boxed)] masks= Vector[cv::Mat (boxed)] = noArray()
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_DescriptorMatcher_match_Mat_queryDescriptors_VectorOfDMatch_matches_VectorOfMat_masks(void* instance, void* queryDescriptors, void* matches, void* masks) {
    try {
        reinterpret_cast<cv::DescriptorMatcher*>(instance)->match(*reinterpret_cast<cv::Mat*>(queryDescriptors), *reinterpret_cast<std::vector<cv::DMatch>*>(matches), *reinterpret_cast<std::vector<cv::Mat>*>(masks));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_DescriptorMatcher_knnMatch_Mat_queryDescriptors_VectorOfVectorOfDMatch_matches_int_k_VectorOfMat_masks_bool_compactResult
// parsed: cv::DescriptorMatcher::knnMatch
// as:     cv::DescriptorMatcher::knnMatch (method) cv::DescriptorMatcher (trait) . knnMatch
// Arg ARG cv::Mat (boxed) queryDescriptors= cv::Mat (boxed) = 
// Arg ARG Vector[Vector[cv::DMatch (simple)]] matches= Vector[Vector[cv::DMatch (simple)]] = 
// Arg ARG Primitive(int) k= Primitive(int) = 
// Arg ARG Vector[cv::Mat (boxed)] masks= Vector[cv::Mat (boxed)] = noArray()
// Arg ARG Primitive(bool) compactResult= Primitive(bool) = false
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_DescriptorMatcher_knnMatch_Mat_queryDescriptors_VectorOfVectorOfDMatch_matches_int_k_VectorOfMat_masks_bool_compactResult(void* instance, void* queryDescriptors, void* matches, int k, void* masks, bool compactResult) {
    try {
        reinterpret_cast<cv::DescriptorMatcher*>(instance)->knnMatch(*reinterpret_cast<cv::Mat*>(queryDescriptors), *reinterpret_cast<std::vector<std::vector<cv::DMatch>>*>(matches), k, *reinterpret_cast<std::vector<cv::Mat>*>(masks), compactResult);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_DescriptorMatcher_radiusMatch_Mat_queryDescriptors_VectorOfVectorOfDMatch_matches_float_maxDistance_VectorOfMat_masks_bool_compactResult
// parsed: cv::DescriptorMatcher::radiusMatch
// as:     cv::DescriptorMatcher::radiusMatch (method) cv::DescriptorMatcher (trait) . radiusMatch
// Arg ARG cv::Mat (boxed) queryDescriptors= cv::Mat (boxed) = 
// Arg ARG Vector[Vector[cv::DMatch (simple)]] matches= Vector[Vector[cv::DMatch (simple)]] = 
// Arg ARG Primitive(float) maxDistance= Primitive(float) = 
// Arg ARG Vector[cv::Mat (boxed)] masks= Vector[cv::Mat (boxed)] = noArray()
// Arg ARG Primitive(bool) compactResult= Primitive(bool) = false
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_DescriptorMatcher_radiusMatch_Mat_queryDescriptors_VectorOfVectorOfDMatch_matches_float_maxDistance_VectorOfMat_masks_bool_compactResult(void* instance, void* queryDescriptors, void* matches, float maxDistance, void* masks, bool compactResult) {
    try {
        reinterpret_cast<cv::DescriptorMatcher*>(instance)->radiusMatch(*reinterpret_cast<cv::Mat*>(queryDescriptors), *reinterpret_cast<std::vector<std::vector<cv::DMatch>>*>(matches), maxDistance, *reinterpret_cast<std::vector<cv::Mat>*>(masks), compactResult);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_DescriptorMatcher_write_const_String_fileName
// parsed: cv::DescriptorMatcher::write
// as:     cv::DescriptorMatcher::write (method) cv::DescriptorMatcher (trait) . write
// Arg ARG string fileName= string = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_DescriptorMatcher_write_const_String_fileName(void* instance, const char* fileName) {
    try {
        reinterpret_cast<cv::DescriptorMatcher*>(instance)->write(String(fileName));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_DescriptorMatcher_read_String_fileName
// parsed: cv::DescriptorMatcher::read
// as:     cv::DescriptorMatcher::read (method) cv::DescriptorMatcher (trait) . read
// Arg ARG string fileName= string = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_DescriptorMatcher_read_String_fileName(void* instance, const char* fileName) {
    try {
        reinterpret_cast<cv::DescriptorMatcher*>(instance)->read(String(fileName));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_DescriptorMatcher_clone_const_bool_emptyTrainData
// parsed: cv::DescriptorMatcher::clone
// as:     cv::DescriptorMatcher::clone (method) cv::DescriptorMatcher (trait) . clone
// Arg ARG Primitive(bool) emptyTrainData= Primitive(bool) = false
// Return value: SmartPtr[cv::DescriptorMatcher (boxed)]
cv_return_value_void_X cv_core_cv_DescriptorMatcher_clone_const_bool_emptyTrainData(void* instance, bool emptyTrainData) {
    try {
        Ptr<cv::DescriptorMatcher> *ret = new Ptr<cv::DescriptorMatcher>(reinterpret_cast<cv::DescriptorMatcher*>(instance)->clone(emptyTrainData));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_DescriptorMatcher_create_String_descriptorMatcherType
// parsed: cv::DescriptorMatcher::create
// as:     cv::DescriptorMatcher::create (method) cv::DescriptorMatcher (trait) . create
// Arg ARG string descriptorMatcherType= string = 
// Return value: SmartPtr[cv::DescriptorMatcher (boxed)]
cv_return_value_void_X cv_core_cv_DescriptorMatcher_create_String_descriptorMatcherType(const char* descriptorMatcherType) {
    try {
        Ptr<cv::DescriptorMatcher> *ret = new Ptr<cv::DescriptorMatcher>(cv::DescriptorMatcher::create(String(descriptorMatcherType)));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_DescriptorMatcher_create_int_matcherType
// parsed: cv::DescriptorMatcher::create
// as:     cv::DescriptorMatcher::create (method) cv::DescriptorMatcher (trait) . create
// Arg ARG Primitive(int) matcherType= Primitive(int) = 
// Return value: SmartPtr[cv::DescriptorMatcher (boxed)]
cv_return_value_void_X cv_core_cv_DescriptorMatcher_create_int_matcherType(int matcherType) {
    try {
        Ptr<cv::DescriptorMatcher> *ret = new Ptr<cv::DescriptorMatcher>(cv::DescriptorMatcher::create(matcherType));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// boxed class: cv::DetectionBasedTracker
void cv_delete_DetectionBasedTracker(void* instance) {
    delete (cv::DetectionBasedTracker*) instance;
}
// cv_DetectionBasedTracker_run
// parsed: cv::DetectionBasedTracker::run
// as:     cv::DetectionBasedTracker::run (method) cv::DetectionBasedTracker . run
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_DetectionBasedTracker_run(void* instance) {
    try {
        bool ret = reinterpret_cast<cv::DetectionBasedTracker*>(instance)->run();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_DetectionBasedTracker_stop
// parsed: cv::DetectionBasedTracker::stop
// as:     cv::DetectionBasedTracker::stop (method) cv::DetectionBasedTracker . stop
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_DetectionBasedTracker_stop(void* instance) {
    try {
        reinterpret_cast<cv::DetectionBasedTracker*>(instance)->stop();
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_DetectionBasedTracker_resetTracking
// parsed: cv::DetectionBasedTracker::resetTracking
// as:     cv::DetectionBasedTracker::resetTracking (method) cv::DetectionBasedTracker . resetTracking
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_DetectionBasedTracker_resetTracking(void* instance) {
    try {
        reinterpret_cast<cv::DetectionBasedTracker*>(instance)->resetTracking();
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_DetectionBasedTracker_process_Mat_imageGray
// parsed: cv::DetectionBasedTracker::process
// as:     cv::DetectionBasedTracker::process (method) cv::DetectionBasedTracker . process
// Arg ARG cv::Mat (boxed) imageGray= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_DetectionBasedTracker_process_Mat_imageGray(void* instance, void* imageGray) {
    try {
        reinterpret_cast<cv::DetectionBasedTracker*>(instance)->process(*reinterpret_cast<cv::Mat*>(imageGray));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_DetectionBasedTracker_setParameters_Parameters_params
// parsed: cv::DetectionBasedTracker::setParameters
// as:     cv::DetectionBasedTracker::setParameters (method) cv::DetectionBasedTracker . setParameters
// Arg ARG cv::DetectionBasedTracker::Parameters (boxed) params= cv::DetectionBasedTracker::Parameters (boxed) = 
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_DetectionBasedTracker_setParameters_Parameters_params(void* instance, void* params) {
    try {
        bool ret = reinterpret_cast<cv::DetectionBasedTracker*>(instance)->setParameters(*reinterpret_cast<cv::DetectionBasedTracker::Parameters*>(params));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_DetectionBasedTracker_getParameters_const
// parsed: cv::DetectionBasedTracker::getParameters
// as:     cv::DetectionBasedTracker::getParameters (method) cv::DetectionBasedTracker . getParameters
// Return value: cv::DetectionBasedTracker::Parameters (boxed)
cv_return_value_void_X cv_core_cv_DetectionBasedTracker_getParameters_const(void* instance) {
    try {
        cv::DetectionBasedTracker::Parameters ret = reinterpret_cast<cv::DetectionBasedTracker*>(instance)->getParameters();
        return { Error::Code::StsOk, NULL, new cv::DetectionBasedTracker::Parameters(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_DetectionBasedTracker_getObjects_const_VectorOfRect_result
// parsed: cv::DetectionBasedTracker::getObjects
// as:     cv::DetectionBasedTracker::getObjects (method) cv::DetectionBasedTracker . getObjects
// Arg ARG Vector[cv::Rect (simple)] result= Vector[cv::Rect (simple)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_DetectionBasedTracker_getObjects_const_VectorOfRect_result(void* instance, void* result) {
    try {
        reinterpret_cast<cv::DetectionBasedTracker*>(instance)->getObjects(*reinterpret_cast<std::vector<cv::Rect>*>(result));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_DetectionBasedTracker_getObjects_const_VectorOfExtObject_result
// parsed: cv::DetectionBasedTracker::getObjects
// as:     cv::DetectionBasedTracker::getObjects (method) cv::DetectionBasedTracker . getObjects
// Arg ARG Vector[cv::DetectionBasedTracker::ExtObject (boxed)] result= Vector[cv::DetectionBasedTracker::ExtObject (boxed)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_DetectionBasedTracker_getObjects_const_VectorOfExtObject_result(void* instance, void* result) {
    try {
        reinterpret_cast<cv::DetectionBasedTracker*>(instance)->getObjects(*reinterpret_cast<std::vector<cv::DetectionBasedTracker::ExtObject>*>(result));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_DetectionBasedTracker_addObject_Rect_location
// parsed: cv::DetectionBasedTracker::addObject
// as:     cv::DetectionBasedTracker::addObject (method) cv::DetectionBasedTracker . addObject
// Arg ARG cv::Rect (simple) location= cv::Rect (simple) = 
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_DetectionBasedTracker_addObject_Rect_location(void* instance, RectWrapper location) {
    try {
        int ret = reinterpret_cast<cv::DetectionBasedTracker*>(instance)->addObject(*reinterpret_cast<cv::Rect*>(&location));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// boxed class: cv::DetectionBasedTracker::ExtObject
void cv_delete_DetectionBasedTracker_ExtObject(void* instance) {
    delete (cv::DetectionBasedTracker::ExtObject*) instance;
}
// cv_DetectionBasedTracker_IDetector_detect_Mat_image_VectorOfRect_objects
// parsed: cv::DetectionBasedTracker::IDetector::detect
// as:     cv::DetectionBasedTracker::IDetector::detect (method) cv::DetectionBasedTracker::IDetector (trait) . detect
// Arg ARG cv::Mat (boxed) image= cv::Mat (boxed) = 
// Arg ARG Vector[cv::Rect (simple)] objects= Vector[cv::Rect (simple)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_DetectionBasedTracker_IDetector_detect_Mat_image_VectorOfRect_objects(void* instance, void* image, void* objects) {
    try {
        reinterpret_cast<cv::DetectionBasedTracker::IDetector*>(instance)->detect(*reinterpret_cast<cv::Mat*>(image), *reinterpret_cast<std::vector<cv::Rect>*>(objects));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_DetectionBasedTracker_IDetector_setMinObjectSize_Size_min
// parsed: cv::DetectionBasedTracker::IDetector::setMinObjectSize
// as:     cv::DetectionBasedTracker::IDetector::setMinObjectSize (method) cv::DetectionBasedTracker::IDetector (trait) . setMinObjectSize
// Arg ARG cv::Size (simple) min= cv::Size (simple) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_DetectionBasedTracker_IDetector_setMinObjectSize_Size_min(void* instance, SizeWrapper min) {
    try {
        reinterpret_cast<cv::DetectionBasedTracker::IDetector*>(instance)->setMinObjectSize(*reinterpret_cast<cv::Size*>(&min));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_DetectionBasedTracker_IDetector_setMaxObjectSize_Size_max
// parsed: cv::DetectionBasedTracker::IDetector::setMaxObjectSize
// as:     cv::DetectionBasedTracker::IDetector::setMaxObjectSize (method) cv::DetectionBasedTracker::IDetector (trait) . setMaxObjectSize
// Arg ARG cv::Size (simple) max= cv::Size (simple) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_DetectionBasedTracker_IDetector_setMaxObjectSize_Size_max(void* instance, SizeWrapper max) {
    try {
        reinterpret_cast<cv::DetectionBasedTracker::IDetector*>(instance)->setMaxObjectSize(*reinterpret_cast<cv::Size*>(&max));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_DetectionBasedTracker_IDetector_getMinObjectSize_const
// parsed: cv::DetectionBasedTracker::IDetector::getMinObjectSize
// as:     cv::DetectionBasedTracker::IDetector::getMinObjectSize (method) cv::DetectionBasedTracker::IDetector (trait) . getMinObjectSize
// Return value: cv::Size (simple)
cv_return_value_SizeWrapper cv_core_cv_DetectionBasedTracker_IDetector_getMinObjectSize_const(void* instance) {
    try {
        cv::Size ret = reinterpret_cast<cv::DetectionBasedTracker::IDetector*>(instance)->getMinObjectSize();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<SizeWrapper*>(&ret) };
    } CVRS_CATCH(cv_return_value_SizeWrapper)
}

// cv_DetectionBasedTracker_IDetector_getMaxObjectSize_const
// parsed: cv::DetectionBasedTracker::IDetector::getMaxObjectSize
// as:     cv::DetectionBasedTracker::IDetector::getMaxObjectSize (method) cv::DetectionBasedTracker::IDetector (trait) . getMaxObjectSize
// Return value: cv::Size (simple)
cv_return_value_SizeWrapper cv_core_cv_DetectionBasedTracker_IDetector_getMaxObjectSize_const(void* instance) {
    try {
        cv::Size ret = reinterpret_cast<cv::DetectionBasedTracker::IDetector*>(instance)->getMaxObjectSize();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<SizeWrapper*>(&ret) };
    } CVRS_CATCH(cv_return_value_SizeWrapper)
}

// cv_DetectionBasedTracker_IDetector_getScaleFactor
// parsed: cv::DetectionBasedTracker::IDetector::getScaleFactor
// as:     cv::DetectionBasedTracker::IDetector::getScaleFactor (method) cv::DetectionBasedTracker::IDetector (trait) . getScaleFactor
// Return value: Primitive(float)
cv_return_value_float cv_core_cv_DetectionBasedTracker_IDetector_getScaleFactor(void* instance) {
    try {
        float ret = reinterpret_cast<cv::DetectionBasedTracker::IDetector*>(instance)->getScaleFactor();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<float*>(&ret) };
    } CVRS_CATCH(cv_return_value_float)
}

// cv_DetectionBasedTracker_IDetector_setScaleFactor_float_value
// parsed: cv::DetectionBasedTracker::IDetector::setScaleFactor
// as:     cv::DetectionBasedTracker::IDetector::setScaleFactor (method) cv::DetectionBasedTracker::IDetector (trait) . setScaleFactor
// Arg ARG Primitive(float) value= Primitive(float) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_DetectionBasedTracker_IDetector_setScaleFactor_float_value(void* instance, float value) {
    try {
        reinterpret_cast<cv::DetectionBasedTracker::IDetector*>(instance)->setScaleFactor(value);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_DetectionBasedTracker_IDetector_getMinNeighbours
// parsed: cv::DetectionBasedTracker::IDetector::getMinNeighbours
// as:     cv::DetectionBasedTracker::IDetector::getMinNeighbours (method) cv::DetectionBasedTracker::IDetector (trait) . getMinNeighbours
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_DetectionBasedTracker_IDetector_getMinNeighbours(void* instance) {
    try {
        int ret = reinterpret_cast<cv::DetectionBasedTracker::IDetector*>(instance)->getMinNeighbours();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_DetectionBasedTracker_IDetector_setMinNeighbours_int_value
// parsed: cv::DetectionBasedTracker::IDetector::setMinNeighbours
// as:     cv::DetectionBasedTracker::IDetector::setMinNeighbours (method) cv::DetectionBasedTracker::IDetector (trait) . setMinNeighbours
// Arg ARG Primitive(int) value= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_DetectionBasedTracker_IDetector_setMinNeighbours_int_value(void* instance, int value) {
    try {
        reinterpret_cast<cv::DetectionBasedTracker::IDetector*>(instance)->setMinNeighbours(value);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// boxed class: cv::DetectionBasedTracker::Parameters
void cv_delete_DetectionBasedTracker_Parameters(void* instance) {
    delete (cv::DetectionBasedTracker::Parameters*) instance;
}
// cv_DetectionBasedTracker_Parameters_Parameters
// parsed: cv::DetectionBasedTracker::Parameters::Parameters
// as:     cv::DetectionBasedTracker::Parameters::Parameters (constructor) cv::DetectionBasedTracker::Parameters . new
// Return value: cv::DetectionBasedTracker::Parameters (boxed)
cv_return_value_void_X cv_core_cv_DetectionBasedTracker_Parameters_Parameters() {
    try {
        cv::DetectionBasedTracker::Parameters* ret = new cv::DetectionBasedTracker::Parameters();
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// boxed class: cv::DetectionROI
void cv_delete_DetectionROI(void* instance) {
    delete (cv::DetectionROI*) instance;
}
// cv_DownhillSolver_getInitStep_const_Mat_step
// parsed: cv::DownhillSolver::getInitStep
// as:     cv::DownhillSolver::getInitStep (method) cv::DownhillSolver (trait) . getInitStep
// Arg ARG cv::Mat (boxed) step= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_DownhillSolver_getInitStep_const_Mat_step(void* instance, void* step) {
    try {
        reinterpret_cast<cv::DownhillSolver*>(instance)->getInitStep(*reinterpret_cast<cv::Mat*>(step));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_DownhillSolver_setInitStep_Mat_step
// parsed: cv::DownhillSolver::setInitStep
// as:     cv::DownhillSolver::setInitStep (method) cv::DownhillSolver (trait) . setInitStep
// Arg ARG cv::Mat (boxed) step= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_DownhillSolver_setInitStep_Mat_step(void* instance, void* step) {
    try {
        reinterpret_cast<cv::DownhillSolver*>(instance)->setInitStep(*reinterpret_cast<cv::Mat*>(step));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_DownhillSolver_create_PtrOfFunction_f_Mat_initStep_TermCriteria_termcrit
// parsed: cv::DownhillSolver::create
// as:     cv::DownhillSolver::create (method) cv::DownhillSolver (trait) . create
// Arg ARG SmartPtr[cv::MinProblemSolver::Function (boxed)] f= SmartPtr[cv::MinProblemSolver::Function (boxed)] = Ptr<MinProblemSolver::Function>()
// Arg ARG cv::Mat (boxed) initStep= cv::Mat (boxed) = Mat_<double>(1,1,0.0)
// Arg ARG cv::TermCriteria (boxed) termcrit= cv::TermCriteria (boxed) = TermCriteria(TermCriteria::MAX_ITER+TermCriteria::EPS,5000,0.000001)
// Return value: SmartPtr[cv::DownhillSolver (boxed)]
cv_return_value_void_X cv_core_cv_DownhillSolver_create_PtrOfFunction_f_Mat_initStep_TermCriteria_termcrit(void* f, void* initStep, void* termcrit) {
    try {
        Ptr<cv::DownhillSolver> *ret = new Ptr<cv::DownhillSolver>(cv::DownhillSolver::create(reinterpret_cast<cv::MinProblemSolver::Function*>(f), *reinterpret_cast<cv::Mat*>(initStep), *reinterpret_cast<cv::TermCriteria*>(termcrit)));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// boxed class: cv::DrawMatchesFlags
void cv_delete_DrawMatchesFlags(void* instance) {
    delete (cv::DrawMatchesFlags*) instance;
}
// cv_DualTVL1OpticalFlow_getTau_const
// parsed: cv::DualTVL1OpticalFlow::getTau
// as:     cv::DualTVL1OpticalFlow::getTau (method) cv::DualTVL1OpticalFlow (trait) . getTau
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_DualTVL1OpticalFlow_getTau_const(void* instance) {
    try {
        double ret = reinterpret_cast<cv::DualTVL1OpticalFlow*>(instance)->getTau();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_DualTVL1OpticalFlow_setTau_double_val
// parsed: cv::DualTVL1OpticalFlow::setTau
// as:     cv::DualTVL1OpticalFlow::setTau (method) cv::DualTVL1OpticalFlow (trait) . setTau
// Arg ARG Primitive(double) val= Primitive(double) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_DualTVL1OpticalFlow_setTau_double_val(void* instance, double val) {
    try {
        reinterpret_cast<cv::DualTVL1OpticalFlow*>(instance)->setTau(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_DualTVL1OpticalFlow_getLambda_const
// parsed: cv::DualTVL1OpticalFlow::getLambda
// as:     cv::DualTVL1OpticalFlow::getLambda (method) cv::DualTVL1OpticalFlow (trait) . getLambda
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_DualTVL1OpticalFlow_getLambda_const(void* instance) {
    try {
        double ret = reinterpret_cast<cv::DualTVL1OpticalFlow*>(instance)->getLambda();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_DualTVL1OpticalFlow_setLambda_double_val
// parsed: cv::DualTVL1OpticalFlow::setLambda
// as:     cv::DualTVL1OpticalFlow::setLambda (method) cv::DualTVL1OpticalFlow (trait) . setLambda
// Arg ARG Primitive(double) val= Primitive(double) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_DualTVL1OpticalFlow_setLambda_double_val(void* instance, double val) {
    try {
        reinterpret_cast<cv::DualTVL1OpticalFlow*>(instance)->setLambda(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_DualTVL1OpticalFlow_getTheta_const
// parsed: cv::DualTVL1OpticalFlow::getTheta
// as:     cv::DualTVL1OpticalFlow::getTheta (method) cv::DualTVL1OpticalFlow (trait) . getTheta
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_DualTVL1OpticalFlow_getTheta_const(void* instance) {
    try {
        double ret = reinterpret_cast<cv::DualTVL1OpticalFlow*>(instance)->getTheta();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_DualTVL1OpticalFlow_setTheta_double_val
// parsed: cv::DualTVL1OpticalFlow::setTheta
// as:     cv::DualTVL1OpticalFlow::setTheta (method) cv::DualTVL1OpticalFlow (trait) . setTheta
// Arg ARG Primitive(double) val= Primitive(double) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_DualTVL1OpticalFlow_setTheta_double_val(void* instance, double val) {
    try {
        reinterpret_cast<cv::DualTVL1OpticalFlow*>(instance)->setTheta(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_DualTVL1OpticalFlow_getGamma_const
// parsed: cv::DualTVL1OpticalFlow::getGamma
// as:     cv::DualTVL1OpticalFlow::getGamma (method) cv::DualTVL1OpticalFlow (trait) . getGamma
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_DualTVL1OpticalFlow_getGamma_const(void* instance) {
    try {
        double ret = reinterpret_cast<cv::DualTVL1OpticalFlow*>(instance)->getGamma();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_DualTVL1OpticalFlow_setGamma_double_val
// parsed: cv::DualTVL1OpticalFlow::setGamma
// as:     cv::DualTVL1OpticalFlow::setGamma (method) cv::DualTVL1OpticalFlow (trait) . setGamma
// Arg ARG Primitive(double) val= Primitive(double) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_DualTVL1OpticalFlow_setGamma_double_val(void* instance, double val) {
    try {
        reinterpret_cast<cv::DualTVL1OpticalFlow*>(instance)->setGamma(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_DualTVL1OpticalFlow_getScalesNumber_const
// parsed: cv::DualTVL1OpticalFlow::getScalesNumber
// as:     cv::DualTVL1OpticalFlow::getScalesNumber (method) cv::DualTVL1OpticalFlow (trait) . getScalesNumber
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_DualTVL1OpticalFlow_getScalesNumber_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::DualTVL1OpticalFlow*>(instance)->getScalesNumber();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_DualTVL1OpticalFlow_setScalesNumber_int_val
// parsed: cv::DualTVL1OpticalFlow::setScalesNumber
// as:     cv::DualTVL1OpticalFlow::setScalesNumber (method) cv::DualTVL1OpticalFlow (trait) . setScalesNumber
// Arg ARG Primitive(int) val= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_DualTVL1OpticalFlow_setScalesNumber_int_val(void* instance, int val) {
    try {
        reinterpret_cast<cv::DualTVL1OpticalFlow*>(instance)->setScalesNumber(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_DualTVL1OpticalFlow_getWarpingsNumber_const
// parsed: cv::DualTVL1OpticalFlow::getWarpingsNumber
// as:     cv::DualTVL1OpticalFlow::getWarpingsNumber (method) cv::DualTVL1OpticalFlow (trait) . getWarpingsNumber
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_DualTVL1OpticalFlow_getWarpingsNumber_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::DualTVL1OpticalFlow*>(instance)->getWarpingsNumber();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_DualTVL1OpticalFlow_setWarpingsNumber_int_val
// parsed: cv::DualTVL1OpticalFlow::setWarpingsNumber
// as:     cv::DualTVL1OpticalFlow::setWarpingsNumber (method) cv::DualTVL1OpticalFlow (trait) . setWarpingsNumber
// Arg ARG Primitive(int) val= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_DualTVL1OpticalFlow_setWarpingsNumber_int_val(void* instance, int val) {
    try {
        reinterpret_cast<cv::DualTVL1OpticalFlow*>(instance)->setWarpingsNumber(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_DualTVL1OpticalFlow_getEpsilon_const
// parsed: cv::DualTVL1OpticalFlow::getEpsilon
// as:     cv::DualTVL1OpticalFlow::getEpsilon (method) cv::DualTVL1OpticalFlow (trait) . getEpsilon
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_DualTVL1OpticalFlow_getEpsilon_const(void* instance) {
    try {
        double ret = reinterpret_cast<cv::DualTVL1OpticalFlow*>(instance)->getEpsilon();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_DualTVL1OpticalFlow_setEpsilon_double_val
// parsed: cv::DualTVL1OpticalFlow::setEpsilon
// as:     cv::DualTVL1OpticalFlow::setEpsilon (method) cv::DualTVL1OpticalFlow (trait) . setEpsilon
// Arg ARG Primitive(double) val= Primitive(double) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_DualTVL1OpticalFlow_setEpsilon_double_val(void* instance, double val) {
    try {
        reinterpret_cast<cv::DualTVL1OpticalFlow*>(instance)->setEpsilon(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_DualTVL1OpticalFlow_getInnerIterations_const
// parsed: cv::DualTVL1OpticalFlow::getInnerIterations
// as:     cv::DualTVL1OpticalFlow::getInnerIterations (method) cv::DualTVL1OpticalFlow (trait) . getInnerIterations
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_DualTVL1OpticalFlow_getInnerIterations_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::DualTVL1OpticalFlow*>(instance)->getInnerIterations();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_DualTVL1OpticalFlow_setInnerIterations_int_val
// parsed: cv::DualTVL1OpticalFlow::setInnerIterations
// as:     cv::DualTVL1OpticalFlow::setInnerIterations (method) cv::DualTVL1OpticalFlow (trait) . setInnerIterations
// Arg ARG Primitive(int) val= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_DualTVL1OpticalFlow_setInnerIterations_int_val(void* instance, int val) {
    try {
        reinterpret_cast<cv::DualTVL1OpticalFlow*>(instance)->setInnerIterations(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_DualTVL1OpticalFlow_getOuterIterations_const
// parsed: cv::DualTVL1OpticalFlow::getOuterIterations
// as:     cv::DualTVL1OpticalFlow::getOuterIterations (method) cv::DualTVL1OpticalFlow (trait) . getOuterIterations
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_DualTVL1OpticalFlow_getOuterIterations_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::DualTVL1OpticalFlow*>(instance)->getOuterIterations();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_DualTVL1OpticalFlow_setOuterIterations_int_val
// parsed: cv::DualTVL1OpticalFlow::setOuterIterations
// as:     cv::DualTVL1OpticalFlow::setOuterIterations (method) cv::DualTVL1OpticalFlow (trait) . setOuterIterations
// Arg ARG Primitive(int) val= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_DualTVL1OpticalFlow_setOuterIterations_int_val(void* instance, int val) {
    try {
        reinterpret_cast<cv::DualTVL1OpticalFlow*>(instance)->setOuterIterations(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_DualTVL1OpticalFlow_getUseInitialFlow_const
// parsed: cv::DualTVL1OpticalFlow::getUseInitialFlow
// as:     cv::DualTVL1OpticalFlow::getUseInitialFlow (method) cv::DualTVL1OpticalFlow (trait) . getUseInitialFlow
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_DualTVL1OpticalFlow_getUseInitialFlow_const(void* instance) {
    try {
        bool ret = reinterpret_cast<cv::DualTVL1OpticalFlow*>(instance)->getUseInitialFlow();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_DualTVL1OpticalFlow_setUseInitialFlow_bool_val
// parsed: cv::DualTVL1OpticalFlow::setUseInitialFlow
// as:     cv::DualTVL1OpticalFlow::setUseInitialFlow (method) cv::DualTVL1OpticalFlow (trait) . setUseInitialFlow
// Arg ARG Primitive(bool) val= Primitive(bool) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_DualTVL1OpticalFlow_setUseInitialFlow_bool_val(void* instance, bool val) {
    try {
        reinterpret_cast<cv::DualTVL1OpticalFlow*>(instance)->setUseInitialFlow(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_DualTVL1OpticalFlow_getScaleStep_const
// parsed: cv::DualTVL1OpticalFlow::getScaleStep
// as:     cv::DualTVL1OpticalFlow::getScaleStep (method) cv::DualTVL1OpticalFlow (trait) . getScaleStep
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_DualTVL1OpticalFlow_getScaleStep_const(void* instance) {
    try {
        double ret = reinterpret_cast<cv::DualTVL1OpticalFlow*>(instance)->getScaleStep();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_DualTVL1OpticalFlow_setScaleStep_double_val
// parsed: cv::DualTVL1OpticalFlow::setScaleStep
// as:     cv::DualTVL1OpticalFlow::setScaleStep (method) cv::DualTVL1OpticalFlow (trait) . setScaleStep
// Arg ARG Primitive(double) val= Primitive(double) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_DualTVL1OpticalFlow_setScaleStep_double_val(void* instance, double val) {
    try {
        reinterpret_cast<cv::DualTVL1OpticalFlow*>(instance)->setScaleStep(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_DualTVL1OpticalFlow_getMedianFiltering_const
// parsed: cv::DualTVL1OpticalFlow::getMedianFiltering
// as:     cv::DualTVL1OpticalFlow::getMedianFiltering (method) cv::DualTVL1OpticalFlow (trait) . getMedianFiltering
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_DualTVL1OpticalFlow_getMedianFiltering_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::DualTVL1OpticalFlow*>(instance)->getMedianFiltering();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_DualTVL1OpticalFlow_setMedianFiltering_int_val
// parsed: cv::DualTVL1OpticalFlow::setMedianFiltering
// as:     cv::DualTVL1OpticalFlow::setMedianFiltering (method) cv::DualTVL1OpticalFlow (trait) . setMedianFiltering
// Arg ARG Primitive(int) val= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_DualTVL1OpticalFlow_setMedianFiltering_int_val(void* instance, int val) {
    try {
        reinterpret_cast<cv::DualTVL1OpticalFlow*>(instance)->setMedianFiltering(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_DualTVL1OpticalFlow_create_double_tau_double_lambda_double_theta_int_nscales_int_warps_double_epsilon_int_innnerIterations_int_outerIterations_double_scaleStep_double_gamma_int_medianFiltering_bool_useInitialFlow
// parsed: cv::DualTVL1OpticalFlow::create
// as:     cv::DualTVL1OpticalFlow::create (method) cv::DualTVL1OpticalFlow (trait) . create
// Arg ARG Primitive(double) tau= Primitive(double) = 0.25
// Arg ARG Primitive(double) lambda= Primitive(double) = 0.15
// Arg ARG Primitive(double) theta= Primitive(double) = 0.3
// Arg ARG Primitive(int) nscales= Primitive(int) = 5
// Arg ARG Primitive(int) warps= Primitive(int) = 5
// Arg ARG Primitive(double) epsilon= Primitive(double) = 0.01
// Arg ARG Primitive(int) innnerIterations= Primitive(int) = 30
// Arg ARG Primitive(int) outerIterations= Primitive(int) = 10
// Arg ARG Primitive(double) scaleStep= Primitive(double) = 0.8
// Arg ARG Primitive(double) gamma= Primitive(double) = 0.0
// Arg ARG Primitive(int) medianFiltering= Primitive(int) = 5
// Arg ARG Primitive(bool) useInitialFlow= Primitive(bool) = false
// Return value: SmartPtr[cv::DualTVL1OpticalFlow (boxed)]
cv_return_value_void_X cv_core_cv_DualTVL1OpticalFlow_create_double_tau_double_lambda_double_theta_int_nscales_int_warps_double_epsilon_int_innnerIterations_int_outerIterations_double_scaleStep_double_gamma_int_medianFiltering_bool_useInitialFlow(double tau, double lambda, double theta, int nscales, int warps, double epsilon, int innnerIterations, int outerIterations, double scaleStep, double gamma, int medianFiltering, bool useInitialFlow) {
    try {
        Ptr<cv::DualTVL1OpticalFlow> *ret = new Ptr<cv::DualTVL1OpticalFlow>(cv::DualTVL1OpticalFlow::create(tau, lambda, theta, nscales, warps, epsilon, innnerIterations, outerIterations, scaleStep, gamma, medianFiltering, useInitialFlow));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_EMDHistogramCostExtractor_setNormFlag_int_flag
// parsed: cv::EMDHistogramCostExtractor::setNormFlag
// as:     cv::EMDHistogramCostExtractor::setNormFlag (method) cv::EMDHistogramCostExtractor (trait) . setNormFlag
// Arg ARG Primitive(int) flag= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_EMDHistogramCostExtractor_setNormFlag_int_flag(void* instance, int flag) {
    try {
        reinterpret_cast<cv::EMDHistogramCostExtractor*>(instance)->setNormFlag(flag);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_EMDHistogramCostExtractor_getNormFlag_const
// parsed: cv::EMDHistogramCostExtractor::getNormFlag
// as:     cv::EMDHistogramCostExtractor::getNormFlag (method) cv::EMDHistogramCostExtractor (trait) . getNormFlag
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_EMDHistogramCostExtractor_getNormFlag_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::EMDHistogramCostExtractor*>(instance)->getNormFlag();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// boxed class: cv::EMDL1HistogramCostExtractor
void cv_delete_EMDL1HistogramCostExtractor(void* instance) {
    delete (cv::EMDL1HistogramCostExtractor*) instance;
}
// cv_FarnebackOpticalFlow_getNumLevels_const
// parsed: cv::FarnebackOpticalFlow::getNumLevels
// as:     cv::FarnebackOpticalFlow::getNumLevels (method) cv::FarnebackOpticalFlow (trait) . getNumLevels
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_FarnebackOpticalFlow_getNumLevels_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::FarnebackOpticalFlow*>(instance)->getNumLevels();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_FarnebackOpticalFlow_setNumLevels_int_numLevels
// parsed: cv::FarnebackOpticalFlow::setNumLevels
// as:     cv::FarnebackOpticalFlow::setNumLevels (method) cv::FarnebackOpticalFlow (trait) . setNumLevels
// Arg ARG Primitive(int) numLevels= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_FarnebackOpticalFlow_setNumLevels_int_numLevels(void* instance, int numLevels) {
    try {
        reinterpret_cast<cv::FarnebackOpticalFlow*>(instance)->setNumLevels(numLevels);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_FarnebackOpticalFlow_getPyrScale_const
// parsed: cv::FarnebackOpticalFlow::getPyrScale
// as:     cv::FarnebackOpticalFlow::getPyrScale (method) cv::FarnebackOpticalFlow (trait) . getPyrScale
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_FarnebackOpticalFlow_getPyrScale_const(void* instance) {
    try {
        double ret = reinterpret_cast<cv::FarnebackOpticalFlow*>(instance)->getPyrScale();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_FarnebackOpticalFlow_setPyrScale_double_pyrScale
// parsed: cv::FarnebackOpticalFlow::setPyrScale
// as:     cv::FarnebackOpticalFlow::setPyrScale (method) cv::FarnebackOpticalFlow (trait) . setPyrScale
// Arg ARG Primitive(double) pyrScale= Primitive(double) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_FarnebackOpticalFlow_setPyrScale_double_pyrScale(void* instance, double pyrScale) {
    try {
        reinterpret_cast<cv::FarnebackOpticalFlow*>(instance)->setPyrScale(pyrScale);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_FarnebackOpticalFlow_getFastPyramids_const
// parsed: cv::FarnebackOpticalFlow::getFastPyramids
// as:     cv::FarnebackOpticalFlow::getFastPyramids (method) cv::FarnebackOpticalFlow (trait) . getFastPyramids
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_FarnebackOpticalFlow_getFastPyramids_const(void* instance) {
    try {
        bool ret = reinterpret_cast<cv::FarnebackOpticalFlow*>(instance)->getFastPyramids();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_FarnebackOpticalFlow_setFastPyramids_bool_fastPyramids
// parsed: cv::FarnebackOpticalFlow::setFastPyramids
// as:     cv::FarnebackOpticalFlow::setFastPyramids (method) cv::FarnebackOpticalFlow (trait) . setFastPyramids
// Arg ARG Primitive(bool) fastPyramids= Primitive(bool) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_FarnebackOpticalFlow_setFastPyramids_bool_fastPyramids(void* instance, bool fastPyramids) {
    try {
        reinterpret_cast<cv::FarnebackOpticalFlow*>(instance)->setFastPyramids(fastPyramids);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_FarnebackOpticalFlow_getWinSize_const
// parsed: cv::FarnebackOpticalFlow::getWinSize
// as:     cv::FarnebackOpticalFlow::getWinSize (method) cv::FarnebackOpticalFlow (trait) . getWinSize
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_FarnebackOpticalFlow_getWinSize_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::FarnebackOpticalFlow*>(instance)->getWinSize();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_FarnebackOpticalFlow_setWinSize_int_winSize
// parsed: cv::FarnebackOpticalFlow::setWinSize
// as:     cv::FarnebackOpticalFlow::setWinSize (method) cv::FarnebackOpticalFlow (trait) . setWinSize
// Arg ARG Primitive(int) winSize= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_FarnebackOpticalFlow_setWinSize_int_winSize(void* instance, int winSize) {
    try {
        reinterpret_cast<cv::FarnebackOpticalFlow*>(instance)->setWinSize(winSize);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_FarnebackOpticalFlow_getNumIters_const
// parsed: cv::FarnebackOpticalFlow::getNumIters
// as:     cv::FarnebackOpticalFlow::getNumIters (method) cv::FarnebackOpticalFlow (trait) . getNumIters
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_FarnebackOpticalFlow_getNumIters_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::FarnebackOpticalFlow*>(instance)->getNumIters();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_FarnebackOpticalFlow_setNumIters_int_numIters
// parsed: cv::FarnebackOpticalFlow::setNumIters
// as:     cv::FarnebackOpticalFlow::setNumIters (method) cv::FarnebackOpticalFlow (trait) . setNumIters
// Arg ARG Primitive(int) numIters= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_FarnebackOpticalFlow_setNumIters_int_numIters(void* instance, int numIters) {
    try {
        reinterpret_cast<cv::FarnebackOpticalFlow*>(instance)->setNumIters(numIters);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_FarnebackOpticalFlow_getPolyN_const
// parsed: cv::FarnebackOpticalFlow::getPolyN
// as:     cv::FarnebackOpticalFlow::getPolyN (method) cv::FarnebackOpticalFlow (trait) . getPolyN
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_FarnebackOpticalFlow_getPolyN_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::FarnebackOpticalFlow*>(instance)->getPolyN();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_FarnebackOpticalFlow_setPolyN_int_polyN
// parsed: cv::FarnebackOpticalFlow::setPolyN
// as:     cv::FarnebackOpticalFlow::setPolyN (method) cv::FarnebackOpticalFlow (trait) . setPolyN
// Arg ARG Primitive(int) polyN= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_FarnebackOpticalFlow_setPolyN_int_polyN(void* instance, int polyN) {
    try {
        reinterpret_cast<cv::FarnebackOpticalFlow*>(instance)->setPolyN(polyN);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_FarnebackOpticalFlow_getPolySigma_const
// parsed: cv::FarnebackOpticalFlow::getPolySigma
// as:     cv::FarnebackOpticalFlow::getPolySigma (method) cv::FarnebackOpticalFlow (trait) . getPolySigma
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_FarnebackOpticalFlow_getPolySigma_const(void* instance) {
    try {
        double ret = reinterpret_cast<cv::FarnebackOpticalFlow*>(instance)->getPolySigma();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_FarnebackOpticalFlow_setPolySigma_double_polySigma
// parsed: cv::FarnebackOpticalFlow::setPolySigma
// as:     cv::FarnebackOpticalFlow::setPolySigma (method) cv::FarnebackOpticalFlow (trait) . setPolySigma
// Arg ARG Primitive(double) polySigma= Primitive(double) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_FarnebackOpticalFlow_setPolySigma_double_polySigma(void* instance, double polySigma) {
    try {
        reinterpret_cast<cv::FarnebackOpticalFlow*>(instance)->setPolySigma(polySigma);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_FarnebackOpticalFlow_getFlags_const
// parsed: cv::FarnebackOpticalFlow::getFlags
// as:     cv::FarnebackOpticalFlow::getFlags (method) cv::FarnebackOpticalFlow (trait) . getFlags
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_FarnebackOpticalFlow_getFlags_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::FarnebackOpticalFlow*>(instance)->getFlags();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_FarnebackOpticalFlow_setFlags_int_flags
// parsed: cv::FarnebackOpticalFlow::setFlags
// as:     cv::FarnebackOpticalFlow::setFlags (method) cv::FarnebackOpticalFlow (trait) . setFlags
// Arg ARG Primitive(int) flags= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_FarnebackOpticalFlow_setFlags_int_flags(void* instance, int flags) {
    try {
        reinterpret_cast<cv::FarnebackOpticalFlow*>(instance)->setFlags(flags);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_FarnebackOpticalFlow_create_int_numLevels_double_pyrScale_bool_fastPyramids_int_winSize_int_numIters_int_polyN_double_polySigma_int_flags
// parsed: cv::FarnebackOpticalFlow::create
// as:     cv::FarnebackOpticalFlow::create (method) cv::FarnebackOpticalFlow (trait) . create
// Arg ARG Primitive(int) numLevels= Primitive(int) = 5
// Arg ARG Primitive(double) pyrScale= Primitive(double) = 0.5
// Arg ARG Primitive(bool) fastPyramids= Primitive(bool) = false
// Arg ARG Primitive(int) winSize= Primitive(int) = 13
// Arg ARG Primitive(int) numIters= Primitive(int) = 10
// Arg ARG Primitive(int) polyN= Primitive(int) = 5
// Arg ARG Primitive(double) polySigma= Primitive(double) = 1.1
// Arg ARG Primitive(int) flags= Primitive(int) = 0
// Return value: SmartPtr[cv::FarnebackOpticalFlow (boxed)]
cv_return_value_void_X cv_core_cv_FarnebackOpticalFlow_create_int_numLevels_double_pyrScale_bool_fastPyramids_int_winSize_int_numIters_int_polyN_double_polySigma_int_flags(int numLevels, double pyrScale, bool fastPyramids, int winSize, int numIters, int polyN, double polySigma, int flags) {
    try {
        Ptr<cv::FarnebackOpticalFlow> *ret = new Ptr<cv::FarnebackOpticalFlow>(cv::FarnebackOpticalFlow::create(numLevels, pyrScale, fastPyramids, winSize, numIters, polyN, polySigma, flags));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_FastFeatureDetector_setThreshold_int_threshold
// parsed: cv::FastFeatureDetector::setThreshold
// as:     cv::FastFeatureDetector::setThreshold (method) cv::FastFeatureDetector (trait) . setThreshold
// Arg ARG Primitive(int) threshold= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_FastFeatureDetector_setThreshold_int_threshold(void* instance, int threshold) {
    try {
        reinterpret_cast<cv::FastFeatureDetector*>(instance)->setThreshold(threshold);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_FastFeatureDetector_getThreshold_const
// parsed: cv::FastFeatureDetector::getThreshold
// as:     cv::FastFeatureDetector::getThreshold (method) cv::FastFeatureDetector (trait) . getThreshold
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_FastFeatureDetector_getThreshold_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::FastFeatureDetector*>(instance)->getThreshold();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_FastFeatureDetector_setNonmaxSuppression_bool_f
// parsed: cv::FastFeatureDetector::setNonmaxSuppression
// as:     cv::FastFeatureDetector::setNonmaxSuppression (method) cv::FastFeatureDetector (trait) . setNonmaxSuppression
// Arg ARG Primitive(bool) f= Primitive(bool) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_FastFeatureDetector_setNonmaxSuppression_bool_f(void* instance, bool f) {
    try {
        reinterpret_cast<cv::FastFeatureDetector*>(instance)->setNonmaxSuppression(f);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_FastFeatureDetector_getNonmaxSuppression_const
// parsed: cv::FastFeatureDetector::getNonmaxSuppression
// as:     cv::FastFeatureDetector::getNonmaxSuppression (method) cv::FastFeatureDetector (trait) . getNonmaxSuppression
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_FastFeatureDetector_getNonmaxSuppression_const(void* instance) {
    try {
        bool ret = reinterpret_cast<cv::FastFeatureDetector*>(instance)->getNonmaxSuppression();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_FastFeatureDetector_setType_int_type
// parsed: cv::FastFeatureDetector::setType
// as:     cv::FastFeatureDetector::setType (method) cv::FastFeatureDetector (trait) . setType
// Arg ARG Primitive(int) type= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_FastFeatureDetector_setType_int_type(void* instance, int type) {
    try {
        reinterpret_cast<cv::FastFeatureDetector*>(instance)->setType(type);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_FastFeatureDetector_getType_const
// parsed: cv::FastFeatureDetector::getType
// as:     cv::FastFeatureDetector::getType (method) cv::FastFeatureDetector (trait) . getType
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_FastFeatureDetector_getType_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::FastFeatureDetector*>(instance)->getType();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_FastFeatureDetector_getDefaultName_const
// parsed: cv::FastFeatureDetector::getDefaultName
// as:     cv::FastFeatureDetector::getDefaultName (method) cv::FastFeatureDetector (trait) . getDefaultName
// Return value: string
cv_return_value_char_X cv_core_cv_FastFeatureDetector_getDefaultName_const(void* instance) {
    try {
        String ret = reinterpret_cast<cv::FastFeatureDetector*>(instance)->getDefaultName();
        return { Error::Code::StsOk, NULL, strdup(ret.c_str()) };
    } CVRS_CATCH(cv_return_value_char_X)
}

// cv_FastFeatureDetector_create_int_threshold_bool_nonmaxSuppression_int_type
// parsed: cv::FastFeatureDetector::create
// as:     cv::FastFeatureDetector::create (method) cv::FastFeatureDetector (trait) . create
// Arg ARG Primitive(int) threshold= Primitive(int) = 10
// Arg ARG Primitive(bool) nonmaxSuppression= Primitive(bool) = true
// Arg ARG Primitive(int) type= Primitive(int) = FastFeatureDetector::TYPE_9_16
// Return value: SmartPtr[cv::FastFeatureDetector (boxed)]
cv_return_value_void_X cv_core_cv_FastFeatureDetector_create_int_threshold_bool_nonmaxSuppression_int_type(int threshold, bool nonmaxSuppression, int type) {
    try {
        Ptr<cv::FastFeatureDetector> *ret = new Ptr<cv::FastFeatureDetector>(cv::FastFeatureDetector::create(threshold, nonmaxSuppression, type));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_Feature2D_detect_Mat_image_VectorOfKeyPoint_keypoints_Mat_mask
// parsed: cv::Feature2D::detect
// as:     cv::Feature2D::detect (method) cv::Feature2D (trait) . detect
// Arg ARG cv::Mat (boxed) image= cv::Mat (boxed) = 
// Arg ARG Vector[cv::KeyPoint (simple)] keypoints= Vector[cv::KeyPoint (simple)] = 
// Arg ARG cv::Mat (boxed) mask= cv::Mat (boxed) = noArray()
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_Feature2D_detect_Mat_image_VectorOfKeyPoint_keypoints_Mat_mask(void* instance, void* image, void* keypoints, void* mask) {
    try {
        reinterpret_cast<cv::Feature2D*>(instance)->detect(*reinterpret_cast<cv::Mat*>(image), *reinterpret_cast<std::vector<cv::KeyPoint>*>(keypoints), *reinterpret_cast<cv::Mat*>(mask));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_Feature2D_detect_VectorOfMat_images_VectorOfVectorOfKeyPoint_keypoints_VectorOfMat_masks
// parsed: cv::Feature2D::detect
// as:     cv::Feature2D::detect (method) cv::Feature2D (trait) . detect
// Arg ARG Vector[cv::Mat (boxed)] images= Vector[cv::Mat (boxed)] = 
// Arg ARG Vector[Vector[cv::KeyPoint (simple)]] keypoints= Vector[Vector[cv::KeyPoint (simple)]] = 
// Arg ARG Vector[cv::Mat (boxed)] masks= Vector[cv::Mat (boxed)] = noArray()
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_Feature2D_detect_VectorOfMat_images_VectorOfVectorOfKeyPoint_keypoints_VectorOfMat_masks(void* instance, void* images, void* keypoints, void* masks) {
    try {
        reinterpret_cast<cv::Feature2D*>(instance)->detect(*reinterpret_cast<std::vector<cv::Mat>*>(images), *reinterpret_cast<std::vector<std::vector<cv::KeyPoint>>*>(keypoints), *reinterpret_cast<std::vector<cv::Mat>*>(masks));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_Feature2D_compute_Mat_image_VectorOfKeyPoint_keypoints_Mat_descriptors
// parsed: cv::Feature2D::compute
// as:     cv::Feature2D::compute (method) cv::Feature2D (trait) . compute
// Arg ARG cv::Mat (boxed) image= cv::Mat (boxed) = 
// Arg ARG Vector[cv::KeyPoint (simple)] keypoints= Vector[cv::KeyPoint (simple)] = 
// Arg ARG cv::Mat (boxed) descriptors= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_Feature2D_compute_Mat_image_VectorOfKeyPoint_keypoints_Mat_descriptors(void* instance, void* image, void* keypoints, void* descriptors) {
    try {
        reinterpret_cast<cv::Feature2D*>(instance)->compute(*reinterpret_cast<cv::Mat*>(image), *reinterpret_cast<std::vector<cv::KeyPoint>*>(keypoints), *reinterpret_cast<cv::Mat*>(descriptors));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_Feature2D_compute_VectorOfMat_images_VectorOfVectorOfKeyPoint_keypoints_VectorOfMat_descriptors
// parsed: cv::Feature2D::compute
// as:     cv::Feature2D::compute (method) cv::Feature2D (trait) . compute
// Arg ARG Vector[cv::Mat (boxed)] images= Vector[cv::Mat (boxed)] = 
// Arg ARG Vector[Vector[cv::KeyPoint (simple)]] keypoints= Vector[Vector[cv::KeyPoint (simple)]] = 
// Arg ARG Vector[cv::Mat (boxed)] descriptors= Vector[cv::Mat (boxed)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_Feature2D_compute_VectorOfMat_images_VectorOfVectorOfKeyPoint_keypoints_VectorOfMat_descriptors(void* instance, void* images, void* keypoints, void** descriptors) {
    try {
        reinterpret_cast<cv::Feature2D*>(instance)->compute(*reinterpret_cast<std::vector<cv::Mat>*>(images), *reinterpret_cast<std::vector<std::vector<cv::KeyPoint>>*>(keypoints), *reinterpret_cast<std::vector<cv::Mat>*>(descriptors));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_Feature2D_detectAndCompute_Mat_image_Mat_mask_VectorOfKeyPoint_keypoints_Mat_descriptors_bool_useProvidedKeypoints
// parsed: cv::Feature2D::detectAndCompute
// as:     cv::Feature2D::detectAndCompute (method) cv::Feature2D (trait) . detectAndCompute
// Arg ARG cv::Mat (boxed) image= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) mask= cv::Mat (boxed) = 
// Arg ARG Vector[cv::KeyPoint (simple)] keypoints= Vector[cv::KeyPoint (simple)] = 
// Arg ARG cv::Mat (boxed) descriptors= cv::Mat (boxed) = 
// Arg ARG Primitive(bool) useProvidedKeypoints= Primitive(bool) = false
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_Feature2D_detectAndCompute_Mat_image_Mat_mask_VectorOfKeyPoint_keypoints_Mat_descriptors_bool_useProvidedKeypoints(void* instance, void* image, void* mask, void* keypoints, void* descriptors, bool useProvidedKeypoints) {
    try {
        reinterpret_cast<cv::Feature2D*>(instance)->detectAndCompute(*reinterpret_cast<cv::Mat*>(image), *reinterpret_cast<cv::Mat*>(mask), *reinterpret_cast<std::vector<cv::KeyPoint>*>(keypoints), *reinterpret_cast<cv::Mat*>(descriptors), useProvidedKeypoints);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_Feature2D_descriptorSize_const
// parsed: cv::Feature2D::descriptorSize
// as:     cv::Feature2D::descriptorSize (method) cv::Feature2D (trait) . descriptorSize
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_Feature2D_descriptorSize_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::Feature2D*>(instance)->descriptorSize();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_Feature2D_descriptorType_const
// parsed: cv::Feature2D::descriptorType
// as:     cv::Feature2D::descriptorType (method) cv::Feature2D (trait) . descriptorType
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_Feature2D_descriptorType_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::Feature2D*>(instance)->descriptorType();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_Feature2D_defaultNorm_const
// parsed: cv::Feature2D::defaultNorm
// as:     cv::Feature2D::defaultNorm (method) cv::Feature2D (trait) . defaultNorm
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_Feature2D_defaultNorm_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::Feature2D*>(instance)->defaultNorm();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_Feature2D_write_const_String_fileName
// parsed: cv::Feature2D::write
// as:     cv::Feature2D::write (method) cv::Feature2D (trait) . write
// Arg ARG string fileName= string = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_Feature2D_write_const_String_fileName(void* instance, const char* fileName) {
    try {
        reinterpret_cast<cv::Feature2D*>(instance)->write(String(fileName));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_Feature2D_read_String_fileName
// parsed: cv::Feature2D::read
// as:     cv::Feature2D::read (method) cv::Feature2D (trait) . read
// Arg ARG string fileName= string = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_Feature2D_read_String_fileName(void* instance, const char* fileName) {
    try {
        reinterpret_cast<cv::Feature2D*>(instance)->read(String(fileName));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_Feature2D_empty_const
// parsed: cv::Feature2D::empty
// as:     cv::Feature2D::empty (method) cv::Feature2D (trait) . empty
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_Feature2D_empty_const(void* instance) {
    try {
        bool ret = reinterpret_cast<cv::Feature2D*>(instance)->empty();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_Feature2D_getDefaultName_const
// parsed: cv::Feature2D::getDefaultName
// as:     cv::Feature2D::getDefaultName (method) cv::Feature2D (trait) . getDefaultName
// Return value: string
cv_return_value_char_X cv_core_cv_Feature2D_getDefaultName_const(void* instance) {
    try {
        String ret = reinterpret_cast<cv::Feature2D*>(instance)->getDefaultName();
        return { Error::Code::StsOk, NULL, strdup(ret.c_str()) };
    } CVRS_CATCH(cv_return_value_char_X)
}

// boxed class: cv::FisheyeWarper
void cv_delete_FisheyeWarper(void* instance) {
    delete (cv::FisheyeWarper*) instance;
}
// boxed class: cv::FlannBasedMatcher
void cv_delete_FlannBasedMatcher(void* instance) {
    delete (cv::FlannBasedMatcher*) instance;
}
// cv_FlannBasedMatcher_add_VectorOfMat_descriptors
// parsed: cv::FlannBasedMatcher::add
// as:     cv::FlannBasedMatcher::add (method) cv::FlannBasedMatcher . add
// Arg ARG Vector[cv::Mat (boxed)] descriptors= Vector[cv::Mat (boxed)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_FlannBasedMatcher_add_VectorOfMat_descriptors(void* instance, void* descriptors) {
    try {
        reinterpret_cast<cv::FlannBasedMatcher*>(instance)->add(*reinterpret_cast<std::vector<cv::Mat>*>(descriptors));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_FlannBasedMatcher_clear
// parsed: cv::FlannBasedMatcher::clear
// as:     cv::FlannBasedMatcher::clear (method) cv::FlannBasedMatcher . clear
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_FlannBasedMatcher_clear(void* instance) {
    try {
        reinterpret_cast<cv::FlannBasedMatcher*>(instance)->clear();
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_FlannBasedMatcher_train
// parsed: cv::FlannBasedMatcher::train
// as:     cv::FlannBasedMatcher::train (method) cv::FlannBasedMatcher . train
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_FlannBasedMatcher_train(void* instance) {
    try {
        reinterpret_cast<cv::FlannBasedMatcher*>(instance)->train();
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_FlannBasedMatcher_isMaskSupported_const
// parsed: cv::FlannBasedMatcher::isMaskSupported
// as:     cv::FlannBasedMatcher::isMaskSupported (method) cv::FlannBasedMatcher . isMaskSupported
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_FlannBasedMatcher_isMaskSupported_const(void* instance) {
    try {
        bool ret = reinterpret_cast<cv::FlannBasedMatcher*>(instance)->isMaskSupported();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_FlannBasedMatcher_create
// parsed: cv::FlannBasedMatcher::create
// as:     cv::FlannBasedMatcher::create (method) cv::FlannBasedMatcher . create
// Return value: SmartPtr[cv::FlannBasedMatcher (boxed)]
cv_return_value_void_X cv_core_cv_FlannBasedMatcher_create() {
    try {
        Ptr<cv::FlannBasedMatcher> *ret = new Ptr<cv::FlannBasedMatcher>(cv::FlannBasedMatcher::create());
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_FlannBasedMatcher_clone_const_bool_emptyTrainData
// parsed: cv::FlannBasedMatcher::clone
// as:     cv::FlannBasedMatcher::clone (method) cv::FlannBasedMatcher . clone
// Arg ARG Primitive(bool) emptyTrainData= Primitive(bool) = false
// Return value: SmartPtr[cv::DescriptorMatcher (boxed)]
cv_return_value_void_X cv_core_cv_FlannBasedMatcher_clone_const_bool_emptyTrainData(void* instance, bool emptyTrainData) {
    try {
        Ptr<cv::DescriptorMatcher> *ret = new Ptr<cv::DescriptorMatcher>(reinterpret_cast<cv::FlannBasedMatcher*>(instance)->clone(emptyTrainData));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_Formatted_next
// parsed: cv::Formatted::next
// as:     cv::Formatted::next (method) cv::Formatted (trait) . next
// Return value: RawPtr[Primitive(char)]
cv_return_value_const_char_X cv_core_cv_Formatted_next(void* instance) {
    try {
        const char* ret = reinterpret_cast<cv::Formatted*>(instance)->next();
        return { Error::Code::StsOk, NULL, strdup(ret) };
    } CVRS_CATCH(cv_return_value_const_char_X)
}

// cv_Formatted_reset
// parsed: cv::Formatted::reset
// as:     cv::Formatted::reset (method) cv::Formatted (trait) . reset
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_Formatted_reset(void* instance) {
    try {
        reinterpret_cast<cv::Formatted*>(instance)->reset();
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_Formatter_format_const_Mat_mtx
// parsed: cv::Formatter::format
// as:     cv::Formatter::format (method) cv::Formatter (trait) . format
// Arg ARG cv::Mat (boxed) mtx= cv::Mat (boxed) = 
// Return value: SmartPtr[cv::Formatted (boxed)]
cv_return_value_void_X cv_core_cv_Formatter_format_const_Mat_mtx(void* instance, void* mtx) {
    try {
        Ptr<cv::Formatted> *ret = new Ptr<cv::Formatted>(reinterpret_cast<cv::Formatter*>(instance)->format(*reinterpret_cast<cv::Mat*>(mtx)));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_Formatter_set32fPrecision_int_p
// parsed: cv::Formatter::set32fPrecision
// as:     cv::Formatter::set32fPrecision (method) cv::Formatter (trait) . set32fPrecision
// Arg ARG Primitive(int) p= Primitive(int) = 8
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_Formatter_set32fPrecision_int_p(void* instance, int p) {
    try {
        reinterpret_cast<cv::Formatter*>(instance)->set32fPrecision(p);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_Formatter_set64fPrecision_int_p
// parsed: cv::Formatter::set64fPrecision
// as:     cv::Formatter::set64fPrecision (method) cv::Formatter (trait) . set64fPrecision
// Arg ARG Primitive(int) p= Primitive(int) = 16
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_Formatter_set64fPrecision_int_p(void* instance, int p) {
    try {
        reinterpret_cast<cv::Formatter*>(instance)->set64fPrecision(p);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_Formatter_setMultiline_bool_ml
// parsed: cv::Formatter::setMultiline
// as:     cv::Formatter::setMultiline (method) cv::Formatter (trait) . setMultiline
// Arg ARG Primitive(bool) ml= Primitive(bool) = true
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_Formatter_setMultiline_bool_ml(void* instance, bool ml) {
    try {
        reinterpret_cast<cv::Formatter*>(instance)->setMultiline(ml);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_Formatter_get_int_fmt
// parsed: cv::Formatter::get
// as:     cv::Formatter::get (method) cv::Formatter (trait) . get
// Arg ARG Primitive(int) fmt= Primitive(int) = FMT_DEFAULT
// Return value: SmartPtr[cv::Formatter (boxed)]
cv_return_value_void_X cv_core_cv_Formatter_get_int_fmt(int fmt) {
    try {
        Ptr<cv::Formatter> *ret = new Ptr<cv::Formatter>(cv::Formatter::get(fmt));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_GFTTDetector_setMaxFeatures_int_maxFeatures
// parsed: cv::GFTTDetector::setMaxFeatures
// as:     cv::GFTTDetector::setMaxFeatures (method) cv::GFTTDetector (trait) . setMaxFeatures
// Arg ARG Primitive(int) maxFeatures= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_GFTTDetector_setMaxFeatures_int_maxFeatures(void* instance, int maxFeatures) {
    try {
        reinterpret_cast<cv::GFTTDetector*>(instance)->setMaxFeatures(maxFeatures);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_GFTTDetector_getMaxFeatures_const
// parsed: cv::GFTTDetector::getMaxFeatures
// as:     cv::GFTTDetector::getMaxFeatures (method) cv::GFTTDetector (trait) . getMaxFeatures
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_GFTTDetector_getMaxFeatures_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::GFTTDetector*>(instance)->getMaxFeatures();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_GFTTDetector_setQualityLevel_double_qlevel
// parsed: cv::GFTTDetector::setQualityLevel
// as:     cv::GFTTDetector::setQualityLevel (method) cv::GFTTDetector (trait) . setQualityLevel
// Arg ARG Primitive(double) qlevel= Primitive(double) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_GFTTDetector_setQualityLevel_double_qlevel(void* instance, double qlevel) {
    try {
        reinterpret_cast<cv::GFTTDetector*>(instance)->setQualityLevel(qlevel);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_GFTTDetector_getQualityLevel_const
// parsed: cv::GFTTDetector::getQualityLevel
// as:     cv::GFTTDetector::getQualityLevel (method) cv::GFTTDetector (trait) . getQualityLevel
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_GFTTDetector_getQualityLevel_const(void* instance) {
    try {
        double ret = reinterpret_cast<cv::GFTTDetector*>(instance)->getQualityLevel();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_GFTTDetector_setMinDistance_double_minDistance
// parsed: cv::GFTTDetector::setMinDistance
// as:     cv::GFTTDetector::setMinDistance (method) cv::GFTTDetector (trait) . setMinDistance
// Arg ARG Primitive(double) minDistance= Primitive(double) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_GFTTDetector_setMinDistance_double_minDistance(void* instance, double minDistance) {
    try {
        reinterpret_cast<cv::GFTTDetector*>(instance)->setMinDistance(minDistance);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_GFTTDetector_getMinDistance_const
// parsed: cv::GFTTDetector::getMinDistance
// as:     cv::GFTTDetector::getMinDistance (method) cv::GFTTDetector (trait) . getMinDistance
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_GFTTDetector_getMinDistance_const(void* instance) {
    try {
        double ret = reinterpret_cast<cv::GFTTDetector*>(instance)->getMinDistance();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_GFTTDetector_setBlockSize_int_blockSize
// parsed: cv::GFTTDetector::setBlockSize
// as:     cv::GFTTDetector::setBlockSize (method) cv::GFTTDetector (trait) . setBlockSize
// Arg ARG Primitive(int) blockSize= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_GFTTDetector_setBlockSize_int_blockSize(void* instance, int blockSize) {
    try {
        reinterpret_cast<cv::GFTTDetector*>(instance)->setBlockSize(blockSize);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_GFTTDetector_getBlockSize_const
// parsed: cv::GFTTDetector::getBlockSize
// as:     cv::GFTTDetector::getBlockSize (method) cv::GFTTDetector (trait) . getBlockSize
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_GFTTDetector_getBlockSize_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::GFTTDetector*>(instance)->getBlockSize();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_GFTTDetector_setHarrisDetector_bool_val
// parsed: cv::GFTTDetector::setHarrisDetector
// as:     cv::GFTTDetector::setHarrisDetector (method) cv::GFTTDetector (trait) . setHarrisDetector
// Arg ARG Primitive(bool) val= Primitive(bool) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_GFTTDetector_setHarrisDetector_bool_val(void* instance, bool val) {
    try {
        reinterpret_cast<cv::GFTTDetector*>(instance)->setHarrisDetector(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_GFTTDetector_getHarrisDetector_const
// parsed: cv::GFTTDetector::getHarrisDetector
// as:     cv::GFTTDetector::getHarrisDetector (method) cv::GFTTDetector (trait) . getHarrisDetector
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_GFTTDetector_getHarrisDetector_const(void* instance) {
    try {
        bool ret = reinterpret_cast<cv::GFTTDetector*>(instance)->getHarrisDetector();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_GFTTDetector_setK_double_k
// parsed: cv::GFTTDetector::setK
// as:     cv::GFTTDetector::setK (method) cv::GFTTDetector (trait) . setK
// Arg ARG Primitive(double) k= Primitive(double) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_GFTTDetector_setK_double_k(void* instance, double k) {
    try {
        reinterpret_cast<cv::GFTTDetector*>(instance)->setK(k);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_GFTTDetector_getK_const
// parsed: cv::GFTTDetector::getK
// as:     cv::GFTTDetector::getK (method) cv::GFTTDetector (trait) . getK
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_GFTTDetector_getK_const(void* instance) {
    try {
        double ret = reinterpret_cast<cv::GFTTDetector*>(instance)->getK();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_GFTTDetector_getDefaultName_const
// parsed: cv::GFTTDetector::getDefaultName
// as:     cv::GFTTDetector::getDefaultName (method) cv::GFTTDetector (trait) . getDefaultName
// Return value: string
cv_return_value_char_X cv_core_cv_GFTTDetector_getDefaultName_const(void* instance) {
    try {
        String ret = reinterpret_cast<cv::GFTTDetector*>(instance)->getDefaultName();
        return { Error::Code::StsOk, NULL, strdup(ret.c_str()) };
    } CVRS_CATCH(cv_return_value_char_X)
}

// cv_GFTTDetector_create_int_maxCorners_double_qualityLevel_double_minDistance_int_blockSize_bool_useHarrisDetector_double_k
// parsed: cv::GFTTDetector::create
// as:     cv::GFTTDetector::create (method) cv::GFTTDetector (trait) . create
// Arg ARG Primitive(int) maxCorners= Primitive(int) = 1000
// Arg ARG Primitive(double) qualityLevel= Primitive(double) = 0.01
// Arg ARG Primitive(double) minDistance= Primitive(double) = 1
// Arg ARG Primitive(int) blockSize= Primitive(int) = 3
// Arg ARG Primitive(bool) useHarrisDetector= Primitive(bool) = false
// Arg ARG Primitive(double) k= Primitive(double) = 0.04
// Return value: SmartPtr[cv::GFTTDetector (boxed)]
cv_return_value_void_X cv_core_cv_GFTTDetector_create_int_maxCorners_double_qualityLevel_double_minDistance_int_blockSize_bool_useHarrisDetector_double_k(int maxCorners, double qualityLevel, double minDistance, int blockSize, bool useHarrisDetector, double k) {
    try {
        Ptr<cv::GFTTDetector> *ret = new Ptr<cv::GFTTDetector>(cv::GFTTDetector::create(maxCorners, qualityLevel, minDistance, blockSize, useHarrisDetector, k));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_GFTTDetector_create_int_maxCorners_double_qualityLevel_double_minDistance_int_blockSize_int_gradiantSize_bool_useHarrisDetector_double_k
// parsed: cv::GFTTDetector::create
// as:     cv::GFTTDetector::create (method) cv::GFTTDetector (trait) . create
// Arg ARG Primitive(int) maxCorners= Primitive(int) = 
// Arg ARG Primitive(double) qualityLevel= Primitive(double) = 
// Arg ARG Primitive(double) minDistance= Primitive(double) = 
// Arg ARG Primitive(int) blockSize= Primitive(int) = 
// Arg ARG Primitive(int) gradiantSize= Primitive(int) = 
// Arg ARG Primitive(bool) useHarrisDetector= Primitive(bool) = false
// Arg ARG Primitive(double) k= Primitive(double) = 0.04
// Return value: SmartPtr[cv::GFTTDetector (boxed)]
cv_return_value_void_X cv_core_cv_GFTTDetector_create_int_maxCorners_double_qualityLevel_double_minDistance_int_blockSize_int_gradiantSize_bool_useHarrisDetector_double_k(int maxCorners, double qualityLevel, double minDistance, int blockSize, int gradiantSize, bool useHarrisDetector, double k) {
    try {
        Ptr<cv::GFTTDetector> *ret = new Ptr<cv::GFTTDetector>(cv::GFTTDetector::create(maxCorners, qualityLevel, minDistance, blockSize, gradiantSize, useHarrisDetector, k));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_GeneralizedHough_setTemplate_Mat_templ_Point_templCenter
// parsed: cv::GeneralizedHough::setTemplate
// as:     cv::GeneralizedHough::setTemplate (method) cv::GeneralizedHough (trait) . setTemplate
// Arg ARG cv::Mat (boxed) templ= cv::Mat (boxed) = 
// Arg ARG cv::Point (simple) templCenter= cv::Point (simple) = Point(-1, -1)
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_GeneralizedHough_setTemplate_Mat_templ_Point_templCenter(void* instance, void* templ, PointWrapper templCenter) {
    try {
        reinterpret_cast<cv::GeneralizedHough*>(instance)->setTemplate(*reinterpret_cast<cv::Mat*>(templ), *reinterpret_cast<cv::Point*>(&templCenter));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_GeneralizedHough_setTemplate_Mat_edges_Mat_dx_Mat_dy_Point_templCenter
// parsed: cv::GeneralizedHough::setTemplate
// as:     cv::GeneralizedHough::setTemplate (method) cv::GeneralizedHough (trait) . setTemplate
// Arg ARG cv::Mat (boxed) edges= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dx= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dy= cv::Mat (boxed) = 
// Arg ARG cv::Point (simple) templCenter= cv::Point (simple) = Point(-1, -1)
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_GeneralizedHough_setTemplate_Mat_edges_Mat_dx_Mat_dy_Point_templCenter(void* instance, void* edges, void* dx, void* dy, PointWrapper templCenter) {
    try {
        reinterpret_cast<cv::GeneralizedHough*>(instance)->setTemplate(*reinterpret_cast<cv::Mat*>(edges), *reinterpret_cast<cv::Mat*>(dx), *reinterpret_cast<cv::Mat*>(dy), *reinterpret_cast<cv::Point*>(&templCenter));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_GeneralizedHough_detect_Mat_image_Mat_positions_Mat_votes
// parsed: cv::GeneralizedHough::detect
// as:     cv::GeneralizedHough::detect (method) cv::GeneralizedHough (trait) . detect
// Arg ARG cv::Mat (boxed) image= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) positions= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) votes= cv::Mat (boxed) = noArray()
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_GeneralizedHough_detect_Mat_image_Mat_positions_Mat_votes(void* instance, void* image, void* positions, void* votes) {
    try {
        reinterpret_cast<cv::GeneralizedHough*>(instance)->detect(*reinterpret_cast<cv::Mat*>(image), *reinterpret_cast<cv::Mat*>(positions), *reinterpret_cast<cv::Mat*>(votes));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_GeneralizedHough_detect_Mat_edges_Mat_dx_Mat_dy_Mat_positions_Mat_votes
// parsed: cv::GeneralizedHough::detect
// as:     cv::GeneralizedHough::detect (method) cv::GeneralizedHough (trait) . detect
// Arg ARG cv::Mat (boxed) edges= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dx= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dy= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) positions= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) votes= cv::Mat (boxed) = noArray()
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_GeneralizedHough_detect_Mat_edges_Mat_dx_Mat_dy_Mat_positions_Mat_votes(void* instance, void* edges, void* dx, void* dy, void* positions, void* votes) {
    try {
        reinterpret_cast<cv::GeneralizedHough*>(instance)->detect(*reinterpret_cast<cv::Mat*>(edges), *reinterpret_cast<cv::Mat*>(dx), *reinterpret_cast<cv::Mat*>(dy), *reinterpret_cast<cv::Mat*>(positions), *reinterpret_cast<cv::Mat*>(votes));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_GeneralizedHough_setCannyLowThresh_int_cannyLowThresh
// parsed: cv::GeneralizedHough::setCannyLowThresh
// as:     cv::GeneralizedHough::setCannyLowThresh (method) cv::GeneralizedHough (trait) . setCannyLowThresh
// Arg ARG Primitive(int) cannyLowThresh= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_GeneralizedHough_setCannyLowThresh_int_cannyLowThresh(void* instance, int cannyLowThresh) {
    try {
        reinterpret_cast<cv::GeneralizedHough*>(instance)->setCannyLowThresh(cannyLowThresh);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_GeneralizedHough_getCannyLowThresh_const
// parsed: cv::GeneralizedHough::getCannyLowThresh
// as:     cv::GeneralizedHough::getCannyLowThresh (method) cv::GeneralizedHough (trait) . getCannyLowThresh
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_GeneralizedHough_getCannyLowThresh_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::GeneralizedHough*>(instance)->getCannyLowThresh();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_GeneralizedHough_setCannyHighThresh_int_cannyHighThresh
// parsed: cv::GeneralizedHough::setCannyHighThresh
// as:     cv::GeneralizedHough::setCannyHighThresh (method) cv::GeneralizedHough (trait) . setCannyHighThresh
// Arg ARG Primitive(int) cannyHighThresh= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_GeneralizedHough_setCannyHighThresh_int_cannyHighThresh(void* instance, int cannyHighThresh) {
    try {
        reinterpret_cast<cv::GeneralizedHough*>(instance)->setCannyHighThresh(cannyHighThresh);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_GeneralizedHough_getCannyHighThresh_const
// parsed: cv::GeneralizedHough::getCannyHighThresh
// as:     cv::GeneralizedHough::getCannyHighThresh (method) cv::GeneralizedHough (trait) . getCannyHighThresh
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_GeneralizedHough_getCannyHighThresh_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::GeneralizedHough*>(instance)->getCannyHighThresh();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_GeneralizedHough_setMinDist_double_minDist
// parsed: cv::GeneralizedHough::setMinDist
// as:     cv::GeneralizedHough::setMinDist (method) cv::GeneralizedHough (trait) . setMinDist
// Arg ARG Primitive(double) minDist= Primitive(double) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_GeneralizedHough_setMinDist_double_minDist(void* instance, double minDist) {
    try {
        reinterpret_cast<cv::GeneralizedHough*>(instance)->setMinDist(minDist);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_GeneralizedHough_getMinDist_const
// parsed: cv::GeneralizedHough::getMinDist
// as:     cv::GeneralizedHough::getMinDist (method) cv::GeneralizedHough (trait) . getMinDist
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_GeneralizedHough_getMinDist_const(void* instance) {
    try {
        double ret = reinterpret_cast<cv::GeneralizedHough*>(instance)->getMinDist();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_GeneralizedHough_setDp_double_dp
// parsed: cv::GeneralizedHough::setDp
// as:     cv::GeneralizedHough::setDp (method) cv::GeneralizedHough (trait) . setDp
// Arg ARG Primitive(double) dp= Primitive(double) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_GeneralizedHough_setDp_double_dp(void* instance, double dp) {
    try {
        reinterpret_cast<cv::GeneralizedHough*>(instance)->setDp(dp);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_GeneralizedHough_getDp_const
// parsed: cv::GeneralizedHough::getDp
// as:     cv::GeneralizedHough::getDp (method) cv::GeneralizedHough (trait) . getDp
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_GeneralizedHough_getDp_const(void* instance) {
    try {
        double ret = reinterpret_cast<cv::GeneralizedHough*>(instance)->getDp();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_GeneralizedHough_setMaxBufferSize_int_maxBufferSize
// parsed: cv::GeneralizedHough::setMaxBufferSize
// as:     cv::GeneralizedHough::setMaxBufferSize (method) cv::GeneralizedHough (trait) . setMaxBufferSize
// Arg ARG Primitive(int) maxBufferSize= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_GeneralizedHough_setMaxBufferSize_int_maxBufferSize(void* instance, int maxBufferSize) {
    try {
        reinterpret_cast<cv::GeneralizedHough*>(instance)->setMaxBufferSize(maxBufferSize);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_GeneralizedHough_getMaxBufferSize_const
// parsed: cv::GeneralizedHough::getMaxBufferSize
// as:     cv::GeneralizedHough::getMaxBufferSize (method) cv::GeneralizedHough (trait) . getMaxBufferSize
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_GeneralizedHough_getMaxBufferSize_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::GeneralizedHough*>(instance)->getMaxBufferSize();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_GeneralizedHoughBallard_setLevels_int_levels
// parsed: cv::GeneralizedHoughBallard::setLevels
// as:     cv::GeneralizedHoughBallard::setLevels (method) cv::GeneralizedHoughBallard (trait) . setLevels
// Arg ARG Primitive(int) levels= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_GeneralizedHoughBallard_setLevels_int_levels(void* instance, int levels) {
    try {
        reinterpret_cast<cv::GeneralizedHoughBallard*>(instance)->setLevels(levels);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_GeneralizedHoughBallard_getLevels_const
// parsed: cv::GeneralizedHoughBallard::getLevels
// as:     cv::GeneralizedHoughBallard::getLevels (method) cv::GeneralizedHoughBallard (trait) . getLevels
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_GeneralizedHoughBallard_getLevels_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::GeneralizedHoughBallard*>(instance)->getLevels();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_GeneralizedHoughBallard_setVotesThreshold_int_votesThreshold
// parsed: cv::GeneralizedHoughBallard::setVotesThreshold
// as:     cv::GeneralizedHoughBallard::setVotesThreshold (method) cv::GeneralizedHoughBallard (trait) . setVotesThreshold
// Arg ARG Primitive(int) votesThreshold= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_GeneralizedHoughBallard_setVotesThreshold_int_votesThreshold(void* instance, int votesThreshold) {
    try {
        reinterpret_cast<cv::GeneralizedHoughBallard*>(instance)->setVotesThreshold(votesThreshold);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_GeneralizedHoughBallard_getVotesThreshold_const
// parsed: cv::GeneralizedHoughBallard::getVotesThreshold
// as:     cv::GeneralizedHoughBallard::getVotesThreshold (method) cv::GeneralizedHoughBallard (trait) . getVotesThreshold
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_GeneralizedHoughBallard_getVotesThreshold_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::GeneralizedHoughBallard*>(instance)->getVotesThreshold();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_GeneralizedHoughGuil_setXi_double_xi
// parsed: cv::GeneralizedHoughGuil::setXi
// as:     cv::GeneralizedHoughGuil::setXi (method) cv::GeneralizedHoughGuil (trait) . setXi
// Arg ARG Primitive(double) xi= Primitive(double) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_GeneralizedHoughGuil_setXi_double_xi(void* instance, double xi) {
    try {
        reinterpret_cast<cv::GeneralizedHoughGuil*>(instance)->setXi(xi);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_GeneralizedHoughGuil_getXi_const
// parsed: cv::GeneralizedHoughGuil::getXi
// as:     cv::GeneralizedHoughGuil::getXi (method) cv::GeneralizedHoughGuil (trait) . getXi
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_GeneralizedHoughGuil_getXi_const(void* instance) {
    try {
        double ret = reinterpret_cast<cv::GeneralizedHoughGuil*>(instance)->getXi();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_GeneralizedHoughGuil_setLevels_int_levels
// parsed: cv::GeneralizedHoughGuil::setLevels
// as:     cv::GeneralizedHoughGuil::setLevels (method) cv::GeneralizedHoughGuil (trait) . setLevels
// Arg ARG Primitive(int) levels= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_GeneralizedHoughGuil_setLevels_int_levels(void* instance, int levels) {
    try {
        reinterpret_cast<cv::GeneralizedHoughGuil*>(instance)->setLevels(levels);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_GeneralizedHoughGuil_getLevels_const
// parsed: cv::GeneralizedHoughGuil::getLevels
// as:     cv::GeneralizedHoughGuil::getLevels (method) cv::GeneralizedHoughGuil (trait) . getLevels
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_GeneralizedHoughGuil_getLevels_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::GeneralizedHoughGuil*>(instance)->getLevels();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_GeneralizedHoughGuil_setAngleEpsilon_double_angleEpsilon
// parsed: cv::GeneralizedHoughGuil::setAngleEpsilon
// as:     cv::GeneralizedHoughGuil::setAngleEpsilon (method) cv::GeneralizedHoughGuil (trait) . setAngleEpsilon
// Arg ARG Primitive(double) angleEpsilon= Primitive(double) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_GeneralizedHoughGuil_setAngleEpsilon_double_angleEpsilon(void* instance, double angleEpsilon) {
    try {
        reinterpret_cast<cv::GeneralizedHoughGuil*>(instance)->setAngleEpsilon(angleEpsilon);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_GeneralizedHoughGuil_getAngleEpsilon_const
// parsed: cv::GeneralizedHoughGuil::getAngleEpsilon
// as:     cv::GeneralizedHoughGuil::getAngleEpsilon (method) cv::GeneralizedHoughGuil (trait) . getAngleEpsilon
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_GeneralizedHoughGuil_getAngleEpsilon_const(void* instance) {
    try {
        double ret = reinterpret_cast<cv::GeneralizedHoughGuil*>(instance)->getAngleEpsilon();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_GeneralizedHoughGuil_setMinAngle_double_minAngle
// parsed: cv::GeneralizedHoughGuil::setMinAngle
// as:     cv::GeneralizedHoughGuil::setMinAngle (method) cv::GeneralizedHoughGuil (trait) . setMinAngle
// Arg ARG Primitive(double) minAngle= Primitive(double) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_GeneralizedHoughGuil_setMinAngle_double_minAngle(void* instance, double minAngle) {
    try {
        reinterpret_cast<cv::GeneralizedHoughGuil*>(instance)->setMinAngle(minAngle);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_GeneralizedHoughGuil_getMinAngle_const
// parsed: cv::GeneralizedHoughGuil::getMinAngle
// as:     cv::GeneralizedHoughGuil::getMinAngle (method) cv::GeneralizedHoughGuil (trait) . getMinAngle
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_GeneralizedHoughGuil_getMinAngle_const(void* instance) {
    try {
        double ret = reinterpret_cast<cv::GeneralizedHoughGuil*>(instance)->getMinAngle();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_GeneralizedHoughGuil_setMaxAngle_double_maxAngle
// parsed: cv::GeneralizedHoughGuil::setMaxAngle
// as:     cv::GeneralizedHoughGuil::setMaxAngle (method) cv::GeneralizedHoughGuil (trait) . setMaxAngle
// Arg ARG Primitive(double) maxAngle= Primitive(double) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_GeneralizedHoughGuil_setMaxAngle_double_maxAngle(void* instance, double maxAngle) {
    try {
        reinterpret_cast<cv::GeneralizedHoughGuil*>(instance)->setMaxAngle(maxAngle);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_GeneralizedHoughGuil_getMaxAngle_const
// parsed: cv::GeneralizedHoughGuil::getMaxAngle
// as:     cv::GeneralizedHoughGuil::getMaxAngle (method) cv::GeneralizedHoughGuil (trait) . getMaxAngle
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_GeneralizedHoughGuil_getMaxAngle_const(void* instance) {
    try {
        double ret = reinterpret_cast<cv::GeneralizedHoughGuil*>(instance)->getMaxAngle();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_GeneralizedHoughGuil_setAngleStep_double_angleStep
// parsed: cv::GeneralizedHoughGuil::setAngleStep
// as:     cv::GeneralizedHoughGuil::setAngleStep (method) cv::GeneralizedHoughGuil (trait) . setAngleStep
// Arg ARG Primitive(double) angleStep= Primitive(double) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_GeneralizedHoughGuil_setAngleStep_double_angleStep(void* instance, double angleStep) {
    try {
        reinterpret_cast<cv::GeneralizedHoughGuil*>(instance)->setAngleStep(angleStep);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_GeneralizedHoughGuil_getAngleStep_const
// parsed: cv::GeneralizedHoughGuil::getAngleStep
// as:     cv::GeneralizedHoughGuil::getAngleStep (method) cv::GeneralizedHoughGuil (trait) . getAngleStep
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_GeneralizedHoughGuil_getAngleStep_const(void* instance) {
    try {
        double ret = reinterpret_cast<cv::GeneralizedHoughGuil*>(instance)->getAngleStep();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_GeneralizedHoughGuil_setAngleThresh_int_angleThresh
// parsed: cv::GeneralizedHoughGuil::setAngleThresh
// as:     cv::GeneralizedHoughGuil::setAngleThresh (method) cv::GeneralizedHoughGuil (trait) . setAngleThresh
// Arg ARG Primitive(int) angleThresh= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_GeneralizedHoughGuil_setAngleThresh_int_angleThresh(void* instance, int angleThresh) {
    try {
        reinterpret_cast<cv::GeneralizedHoughGuil*>(instance)->setAngleThresh(angleThresh);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_GeneralizedHoughGuil_getAngleThresh_const
// parsed: cv::GeneralizedHoughGuil::getAngleThresh
// as:     cv::GeneralizedHoughGuil::getAngleThresh (method) cv::GeneralizedHoughGuil (trait) . getAngleThresh
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_GeneralizedHoughGuil_getAngleThresh_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::GeneralizedHoughGuil*>(instance)->getAngleThresh();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_GeneralizedHoughGuil_setMinScale_double_minScale
// parsed: cv::GeneralizedHoughGuil::setMinScale
// as:     cv::GeneralizedHoughGuil::setMinScale (method) cv::GeneralizedHoughGuil (trait) . setMinScale
// Arg ARG Primitive(double) minScale= Primitive(double) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_GeneralizedHoughGuil_setMinScale_double_minScale(void* instance, double minScale) {
    try {
        reinterpret_cast<cv::GeneralizedHoughGuil*>(instance)->setMinScale(minScale);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_GeneralizedHoughGuil_getMinScale_const
// parsed: cv::GeneralizedHoughGuil::getMinScale
// as:     cv::GeneralizedHoughGuil::getMinScale (method) cv::GeneralizedHoughGuil (trait) . getMinScale
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_GeneralizedHoughGuil_getMinScale_const(void* instance) {
    try {
        double ret = reinterpret_cast<cv::GeneralizedHoughGuil*>(instance)->getMinScale();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_GeneralizedHoughGuil_setMaxScale_double_maxScale
// parsed: cv::GeneralizedHoughGuil::setMaxScale
// as:     cv::GeneralizedHoughGuil::setMaxScale (method) cv::GeneralizedHoughGuil (trait) . setMaxScale
// Arg ARG Primitive(double) maxScale= Primitive(double) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_GeneralizedHoughGuil_setMaxScale_double_maxScale(void* instance, double maxScale) {
    try {
        reinterpret_cast<cv::GeneralizedHoughGuil*>(instance)->setMaxScale(maxScale);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_GeneralizedHoughGuil_getMaxScale_const
// parsed: cv::GeneralizedHoughGuil::getMaxScale
// as:     cv::GeneralizedHoughGuil::getMaxScale (method) cv::GeneralizedHoughGuil (trait) . getMaxScale
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_GeneralizedHoughGuil_getMaxScale_const(void* instance) {
    try {
        double ret = reinterpret_cast<cv::GeneralizedHoughGuil*>(instance)->getMaxScale();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_GeneralizedHoughGuil_setScaleStep_double_scaleStep
// parsed: cv::GeneralizedHoughGuil::setScaleStep
// as:     cv::GeneralizedHoughGuil::setScaleStep (method) cv::GeneralizedHoughGuil (trait) . setScaleStep
// Arg ARG Primitive(double) scaleStep= Primitive(double) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_GeneralizedHoughGuil_setScaleStep_double_scaleStep(void* instance, double scaleStep) {
    try {
        reinterpret_cast<cv::GeneralizedHoughGuil*>(instance)->setScaleStep(scaleStep);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_GeneralizedHoughGuil_getScaleStep_const
// parsed: cv::GeneralizedHoughGuil::getScaleStep
// as:     cv::GeneralizedHoughGuil::getScaleStep (method) cv::GeneralizedHoughGuil (trait) . getScaleStep
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_GeneralizedHoughGuil_getScaleStep_const(void* instance) {
    try {
        double ret = reinterpret_cast<cv::GeneralizedHoughGuil*>(instance)->getScaleStep();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_GeneralizedHoughGuil_setScaleThresh_int_scaleThresh
// parsed: cv::GeneralizedHoughGuil::setScaleThresh
// as:     cv::GeneralizedHoughGuil::setScaleThresh (method) cv::GeneralizedHoughGuil (trait) . setScaleThresh
// Arg ARG Primitive(int) scaleThresh= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_GeneralizedHoughGuil_setScaleThresh_int_scaleThresh(void* instance, int scaleThresh) {
    try {
        reinterpret_cast<cv::GeneralizedHoughGuil*>(instance)->setScaleThresh(scaleThresh);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_GeneralizedHoughGuil_getScaleThresh_const
// parsed: cv::GeneralizedHoughGuil::getScaleThresh
// as:     cv::GeneralizedHoughGuil::getScaleThresh (method) cv::GeneralizedHoughGuil (trait) . getScaleThresh
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_GeneralizedHoughGuil_getScaleThresh_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::GeneralizedHoughGuil*>(instance)->getScaleThresh();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_GeneralizedHoughGuil_setPosThresh_int_posThresh
// parsed: cv::GeneralizedHoughGuil::setPosThresh
// as:     cv::GeneralizedHoughGuil::setPosThresh (method) cv::GeneralizedHoughGuil (trait) . setPosThresh
// Arg ARG Primitive(int) posThresh= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_GeneralizedHoughGuil_setPosThresh_int_posThresh(void* instance, int posThresh) {
    try {
        reinterpret_cast<cv::GeneralizedHoughGuil*>(instance)->setPosThresh(posThresh);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_GeneralizedHoughGuil_getPosThresh_const
// parsed: cv::GeneralizedHoughGuil::getPosThresh
// as:     cv::GeneralizedHoughGuil::getPosThresh (method) cv::GeneralizedHoughGuil (trait) . getPosThresh
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_GeneralizedHoughGuil_getPosThresh_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::GeneralizedHoughGuil*>(instance)->getPosThresh();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// boxed class: cv::HOGDescriptor
void cv_delete_HOGDescriptor(void* instance) {
    delete (cv::HOGDescriptor*) instance;
}
// cv_HOGDescriptor_HOGDescriptor_String_filename
// parsed: cv::HOGDescriptor::HOGDescriptor
// as:     cv::HOGDescriptor::HOGDescriptor (constructor) cv::HOGDescriptor . new
// Arg ARG string filename= string = 
// Return value: cv::HOGDescriptor (boxed)
cv_return_value_void_X cv_core_cv_HOGDescriptor_HOGDescriptor_String_filename(const char* filename) {
    try {
        cv::HOGDescriptor* ret = new cv::HOGDescriptor(String(filename));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_HOGDescriptor_HOGDescriptor_HOGDescriptor_d
// parsed: cv::HOGDescriptor::HOGDescriptor
// as:     cv::HOGDescriptor::HOGDescriptor (constructor) cv::HOGDescriptor . new
// Arg ARG cv::HOGDescriptor (boxed) d= cv::HOGDescriptor (boxed) = 
// Return value: cv::HOGDescriptor (boxed)
cv_return_value_void_X cv_core_cv_HOGDescriptor_HOGDescriptor_HOGDescriptor_d(void* d) {
    try {
        cv::HOGDescriptor* ret = new cv::HOGDescriptor(*reinterpret_cast<cv::HOGDescriptor*>(d));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_HOGDescriptor_getDescriptorSize_const
// parsed: cv::HOGDescriptor::getDescriptorSize
// as:     cv::HOGDescriptor::getDescriptorSize (method) cv::HOGDescriptor . getDescriptorSize
// Return value: Primitive(size_t)
cv_return_value_std_size_t cv_core_cv_HOGDescriptor_getDescriptorSize_const(void* instance) {
    try {
        size_t ret = reinterpret_cast<cv::HOGDescriptor*>(instance)->getDescriptorSize();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<std::size_t*>(&ret) };
    } CVRS_CATCH(cv_return_value_std_size_t)
}

// cv_HOGDescriptor_checkDetectorSize_const
// parsed: cv::HOGDescriptor::checkDetectorSize
// as:     cv::HOGDescriptor::checkDetectorSize (method) cv::HOGDescriptor . checkDetectorSize
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_HOGDescriptor_checkDetectorSize_const(void* instance) {
    try {
        bool ret = reinterpret_cast<cv::HOGDescriptor*>(instance)->checkDetectorSize();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_HOGDescriptor_getWinSigma_const
// parsed: cv::HOGDescriptor::getWinSigma
// as:     cv::HOGDescriptor::getWinSigma (method) cv::HOGDescriptor . getWinSigma
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_HOGDescriptor_getWinSigma_const(void* instance) {
    try {
        double ret = reinterpret_cast<cv::HOGDescriptor*>(instance)->getWinSigma();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_HOGDescriptor_setSVMDetector_Mat__svmdetector
// parsed: cv::HOGDescriptor::setSVMDetector
// as:     cv::HOGDescriptor::setSVMDetector (method) cv::HOGDescriptor . setSVMDetector
// Arg ARG cv::Mat (boxed) _svmdetector= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_HOGDescriptor_setSVMDetector_Mat__svmdetector(void* instance, void* _svmdetector) {
    try {
        reinterpret_cast<cv::HOGDescriptor*>(instance)->setSVMDetector(*reinterpret_cast<cv::Mat*>(_svmdetector));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_HOGDescriptor_load_String_filename_String_objname
// parsed: cv::HOGDescriptor::load
// as:     cv::HOGDescriptor::load (method) cv::HOGDescriptor . load
// Arg ARG string filename= string = 
// Arg ARG string objname= string = String()
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_HOGDescriptor_load_String_filename_String_objname(void* instance, const char* filename, const char* objname) {
    try {
        bool ret = reinterpret_cast<cv::HOGDescriptor*>(instance)->load(String(filename), String(objname));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_HOGDescriptor_save_const_String_filename_String_objname
// parsed: cv::HOGDescriptor::save
// as:     cv::HOGDescriptor::save (method) cv::HOGDescriptor . save
// Arg ARG string filename= string = 
// Arg ARG string objname= string = String()
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_HOGDescriptor_save_const_String_filename_String_objname(void* instance, const char* filename, const char* objname) {
    try {
        reinterpret_cast<cv::HOGDescriptor*>(instance)->save(String(filename), String(objname));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_HOGDescriptor_copyTo_const_HOGDescriptor_c
// parsed: cv::HOGDescriptor::copyTo
// as:     cv::HOGDescriptor::copyTo (method) cv::HOGDescriptor . copyTo
// Arg ARG cv::HOGDescriptor (boxed) c= cv::HOGDescriptor (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_HOGDescriptor_copyTo_const_HOGDescriptor_c(void* instance, void* c) {
    try {
        reinterpret_cast<cv::HOGDescriptor*>(instance)->copyTo(*reinterpret_cast<cv::HOGDescriptor*>(c));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_HOGDescriptor_compute_const_Mat_img_VectorOffloat_descriptors_Size_winStride_Size_padding_VectorOfPoint_locations
// parsed: cv::HOGDescriptor::compute
// as:     cv::HOGDescriptor::compute (method) cv::HOGDescriptor . compute
// Arg ARG cv::Mat (boxed) img= cv::Mat (boxed) = 
// Arg ARG Vector[Primitive(float)] descriptors= Vector[Primitive(float)] = 
// Arg ARG cv::Size (simple) winStride= cv::Size (simple) = Size()
// Arg ARG cv::Size (simple) padding= cv::Size (simple) = Size()
// Arg ARG Vector[cv::Point (simple)] locations= Vector[cv::Point (simple)] = std::vector<Point>()
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_HOGDescriptor_compute_const_Mat_img_VectorOffloat_descriptors_Size_winStride_Size_padding_VectorOfPoint_locations(void* instance, void* img, void* descriptors, SizeWrapper winStride, SizeWrapper padding, void* locations) {
    try {
        reinterpret_cast<cv::HOGDescriptor*>(instance)->compute(*reinterpret_cast<cv::Mat*>(img), *reinterpret_cast<std::vector<float>*>(descriptors), *reinterpret_cast<cv::Size*>(&winStride), *reinterpret_cast<cv::Size*>(&padding), *reinterpret_cast<std::vector<cv::Point>*>(locations));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_HOGDescriptor_detect_const_Mat_img_VectorOfPoint_foundLocations_VectorOfdouble_weights_double_hitThreshold_Size_winStride_Size_padding_VectorOfPoint_searchLocations
// parsed: cv::HOGDescriptor::detect
// as:     cv::HOGDescriptor::detect (method) cv::HOGDescriptor . detect
// Arg ARG cv::Mat (boxed) img= cv::Mat (boxed) = 
// Arg ARG Vector[cv::Point (simple)] foundLocations= Vector[cv::Point (simple)] = 
// Arg ARG Vector[Primitive(double)] weights= Vector[Primitive(double)] = 
// Arg ARG Primitive(double) hitThreshold= Primitive(double) = 0
// Arg ARG cv::Size (simple) winStride= cv::Size (simple) = Size()
// Arg ARG cv::Size (simple) padding= cv::Size (simple) = Size()
// Arg ARG Vector[cv::Point (simple)] searchLocations= Vector[cv::Point (simple)] = std::vector<Point>()
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_HOGDescriptor_detect_const_Mat_img_VectorOfPoint_foundLocations_VectorOfdouble_weights_double_hitThreshold_Size_winStride_Size_padding_VectorOfPoint_searchLocations(void* instance, void* img, void* foundLocations, void* weights, double hitThreshold, SizeWrapper winStride, SizeWrapper padding, void* searchLocations) {
    try {
        reinterpret_cast<cv::HOGDescriptor*>(instance)->detect(*reinterpret_cast<cv::Mat*>(img), *reinterpret_cast<std::vector<cv::Point>*>(foundLocations), *reinterpret_cast<std::vector<double>*>(weights), hitThreshold, *reinterpret_cast<cv::Size*>(&winStride), *reinterpret_cast<cv::Size*>(&padding), *reinterpret_cast<std::vector<cv::Point>*>(searchLocations));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_HOGDescriptor_detect_const_Mat_img_VectorOfPoint_foundLocations_double_hitThreshold_Size_winStride_Size_padding_VectorOfPoint_searchLocations
// parsed: cv::HOGDescriptor::detect
// as:     cv::HOGDescriptor::detect (method) cv::HOGDescriptor . detect
// Arg ARG cv::Mat (boxed) img= cv::Mat (boxed) = 
// Arg ARG Vector[cv::Point (simple)] foundLocations= Vector[cv::Point (simple)] = 
// Arg ARG Primitive(double) hitThreshold= Primitive(double) = 0
// Arg ARG cv::Size (simple) winStride= cv::Size (simple) = Size()
// Arg ARG cv::Size (simple) padding= cv::Size (simple) = Size()
// Arg ARG Vector[cv::Point (simple)] searchLocations= Vector[cv::Point (simple)] = std::vector<Point>()
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_HOGDescriptor_detect_const_Mat_img_VectorOfPoint_foundLocations_double_hitThreshold_Size_winStride_Size_padding_VectorOfPoint_searchLocations(void* instance, void* img, void* foundLocations, double hitThreshold, SizeWrapper winStride, SizeWrapper padding, void* searchLocations) {
    try {
        reinterpret_cast<cv::HOGDescriptor*>(instance)->detect(*reinterpret_cast<cv::Mat*>(img), *reinterpret_cast<std::vector<cv::Point>*>(foundLocations), hitThreshold, *reinterpret_cast<cv::Size*>(&winStride), *reinterpret_cast<cv::Size*>(&padding), *reinterpret_cast<std::vector<cv::Point>*>(searchLocations));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_HOGDescriptor_detectMultiScale_const_Mat_img_VectorOfRect_foundLocations_VectorOfdouble_foundWeights_double_hitThreshold_Size_winStride_Size_padding_double_scale_double_finalThreshold_bool_useMeanshiftGrouping
// parsed: cv::HOGDescriptor::detectMultiScale
// as:     cv::HOGDescriptor::detectMultiScale (method) cv::HOGDescriptor . detectMultiScale
// Arg ARG cv::Mat (boxed) img= cv::Mat (boxed) = 
// Arg ARG Vector[cv::Rect (simple)] foundLocations= Vector[cv::Rect (simple)] = 
// Arg ARG Vector[Primitive(double)] foundWeights= Vector[Primitive(double)] = 
// Arg ARG Primitive(double) hitThreshold= Primitive(double) = 0
// Arg ARG cv::Size (simple) winStride= cv::Size (simple) = Size()
// Arg ARG cv::Size (simple) padding= cv::Size (simple) = Size()
// Arg ARG Primitive(double) scale= Primitive(double) = 1.05
// Arg ARG Primitive(double) finalThreshold= Primitive(double) = 2.0
// Arg ARG Primitive(bool) useMeanshiftGrouping= Primitive(bool) = false
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_HOGDescriptor_detectMultiScale_const_Mat_img_VectorOfRect_foundLocations_VectorOfdouble_foundWeights_double_hitThreshold_Size_winStride_Size_padding_double_scale_double_finalThreshold_bool_useMeanshiftGrouping(void* instance, void* img, void* foundLocations, void* foundWeights, double hitThreshold, SizeWrapper winStride, SizeWrapper padding, double scale, double finalThreshold, bool useMeanshiftGrouping) {
    try {
        reinterpret_cast<cv::HOGDescriptor*>(instance)->detectMultiScale(*reinterpret_cast<cv::Mat*>(img), *reinterpret_cast<std::vector<cv::Rect>*>(foundLocations), *reinterpret_cast<std::vector<double>*>(foundWeights), hitThreshold, *reinterpret_cast<cv::Size*>(&winStride), *reinterpret_cast<cv::Size*>(&padding), scale, finalThreshold, useMeanshiftGrouping);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_HOGDescriptor_detectMultiScale_const_Mat_img_VectorOfRect_foundLocations_double_hitThreshold_Size_winStride_Size_padding_double_scale_double_finalThreshold_bool_useMeanshiftGrouping
// parsed: cv::HOGDescriptor::detectMultiScale
// as:     cv::HOGDescriptor::detectMultiScale (method) cv::HOGDescriptor . detectMultiScale
// Arg ARG cv::Mat (boxed) img= cv::Mat (boxed) = 
// Arg ARG Vector[cv::Rect (simple)] foundLocations= Vector[cv::Rect (simple)] = 
// Arg ARG Primitive(double) hitThreshold= Primitive(double) = 0
// Arg ARG cv::Size (simple) winStride= cv::Size (simple) = Size()
// Arg ARG cv::Size (simple) padding= cv::Size (simple) = Size()
// Arg ARG Primitive(double) scale= Primitive(double) = 1.05
// Arg ARG Primitive(double) finalThreshold= Primitive(double) = 2.0
// Arg ARG Primitive(bool) useMeanshiftGrouping= Primitive(bool) = false
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_HOGDescriptor_detectMultiScale_const_Mat_img_VectorOfRect_foundLocations_double_hitThreshold_Size_winStride_Size_padding_double_scale_double_finalThreshold_bool_useMeanshiftGrouping(void* instance, void* img, void* foundLocations, double hitThreshold, SizeWrapper winStride, SizeWrapper padding, double scale, double finalThreshold, bool useMeanshiftGrouping) {
    try {
        reinterpret_cast<cv::HOGDescriptor*>(instance)->detectMultiScale(*reinterpret_cast<cv::Mat*>(img), *reinterpret_cast<std::vector<cv::Rect>*>(foundLocations), hitThreshold, *reinterpret_cast<cv::Size*>(&winStride), *reinterpret_cast<cv::Size*>(&padding), scale, finalThreshold, useMeanshiftGrouping);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_HOGDescriptor_computeGradient_const_Mat_img_Mat_grad_Mat_angleOfs_Size_paddingTL_Size_paddingBR
// parsed: cv::HOGDescriptor::computeGradient
// as:     cv::HOGDescriptor::computeGradient (method) cv::HOGDescriptor . computeGradient
// Arg ARG cv::Mat (boxed) img= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) grad= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) angleOfs= cv::Mat (boxed) = 
// Arg ARG cv::Size (simple) paddingTL= cv::Size (simple) = Size()
// Arg ARG cv::Size (simple) paddingBR= cv::Size (simple) = Size()
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_HOGDescriptor_computeGradient_const_Mat_img_Mat_grad_Mat_angleOfs_Size_paddingTL_Size_paddingBR(void* instance, void* img, void* grad, void* angleOfs, SizeWrapper paddingTL, SizeWrapper paddingBR) {
    try {
        reinterpret_cast<cv::HOGDescriptor*>(instance)->computeGradient(*reinterpret_cast<cv::Mat*>(img), *reinterpret_cast<cv::Mat*>(grad), *reinterpret_cast<cv::Mat*>(angleOfs), *reinterpret_cast<cv::Size*>(&paddingTL), *reinterpret_cast<cv::Size*>(&paddingBR));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_HOGDescriptor_getDefaultPeopleDetector
// parsed: cv::HOGDescriptor::getDefaultPeopleDetector
// as:     cv::HOGDescriptor::getDefaultPeopleDetector (method) cv::HOGDescriptor . getDefaultPeopleDetector
// Return value: Vector[Primitive(float)]
cv_return_value_void_X cv_core_cv_HOGDescriptor_getDefaultPeopleDetector() {
    try {
        std::vector<float> ret = cv::HOGDescriptor::getDefaultPeopleDetector();
        return { Error::Code::StsOk, NULL, (void *)new std::vector<float>(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_HOGDescriptor_getDaimlerPeopleDetector
// parsed: cv::HOGDescriptor::getDaimlerPeopleDetector
// as:     cv::HOGDescriptor::getDaimlerPeopleDetector (method) cv::HOGDescriptor . getDaimlerPeopleDetector
// Return value: Vector[Primitive(float)]
cv_return_value_void_X cv_core_cv_HOGDescriptor_getDaimlerPeopleDetector() {
    try {
        std::vector<float> ret = cv::HOGDescriptor::getDaimlerPeopleDetector();
        return { Error::Code::StsOk, NULL, (void *)new std::vector<float>(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_HOGDescriptor_detectROI_const_Mat_img_VectorOfPoint_locations_VectorOfPoint_foundLocations_VectorOfdouble_confidences_double_hitThreshold_Size_winStride_Size_padding
// parsed: cv::HOGDescriptor::detectROI
// as:     cv::HOGDescriptor::detectROI (method) cv::HOGDescriptor . detectROI
// Arg ARG cv::Mat (boxed) img= cv::Mat (boxed) = 
// Arg ARG Vector[cv::Point (simple)] locations= Vector[cv::Point (simple)] = 
// Arg ARG Vector[cv::Point (simple)] foundLocations= Vector[cv::Point (simple)] = 
// Arg ARG Vector[Primitive(double)] confidences= Vector[Primitive(double)] = 
// Arg ARG Primitive(double) hitThreshold= Primitive(double) = 0
// Arg ARG cv::Size (simple) winStride= cv::Size (simple) = Size()
// Arg ARG cv::Size (simple) padding= cv::Size (simple) = Size()
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_HOGDescriptor_detectROI_const_Mat_img_VectorOfPoint_locations_VectorOfPoint_foundLocations_VectorOfdouble_confidences_double_hitThreshold_Size_winStride_Size_padding(void* instance, void* img, void* locations, void* foundLocations, void* confidences, double hitThreshold, SizeWrapper winStride, SizeWrapper padding) {
    try {
        reinterpret_cast<cv::HOGDescriptor*>(instance)->detectROI(*reinterpret_cast<cv::Mat*>(img), *reinterpret_cast<std::vector<cv::Point>*>(locations), *reinterpret_cast<std::vector<cv::Point>*>(foundLocations), *reinterpret_cast<std::vector<double>*>(confidences), hitThreshold, *reinterpret_cast<cv::Size*>(&winStride), *reinterpret_cast<cv::Size*>(&padding));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_HOGDescriptor_detectMultiScaleROI_const_Mat_img_VectorOfRect_foundLocations_VectorOfDetectionROI_locations_double_hitThreshold_int_groupThreshold
// parsed: cv::HOGDescriptor::detectMultiScaleROI
// as:     cv::HOGDescriptor::detectMultiScaleROI (method) cv::HOGDescriptor . detectMultiScaleROI
// Arg ARG cv::Mat (boxed) img= cv::Mat (boxed) = 
// Arg ARG Vector[cv::Rect (simple)] foundLocations= Vector[cv::Rect (simple)] = 
// Arg ARG Vector[cv::DetectionROI (boxed)] locations= Vector[cv::DetectionROI (boxed)] = 
// Arg ARG Primitive(double) hitThreshold= Primitive(double) = 0
// Arg ARG Primitive(int) groupThreshold= Primitive(int) = 0
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_HOGDescriptor_detectMultiScaleROI_const_Mat_img_VectorOfRect_foundLocations_VectorOfDetectionROI_locations_double_hitThreshold_int_groupThreshold(void* instance, void* img, void* foundLocations, void* locations, double hitThreshold, int groupThreshold) {
    try {
        reinterpret_cast<cv::HOGDescriptor*>(instance)->detectMultiScaleROI(*reinterpret_cast<cv::Mat*>(img), *reinterpret_cast<std::vector<cv::Rect>*>(foundLocations), *reinterpret_cast<std::vector<cv::DetectionROI>*>(locations), hitThreshold, groupThreshold);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_HOGDescriptor_readALTModel_String_modelfile
// parsed: cv::HOGDescriptor::readALTModel
// as:     cv::HOGDescriptor::readALTModel (method) cv::HOGDescriptor . readALTModel
// Arg ARG string modelfile= string = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_HOGDescriptor_readALTModel_String_modelfile(void* instance, const char* modelfile) {
    try {
        reinterpret_cast<cv::HOGDescriptor*>(instance)->readALTModel(String(modelfile));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_HOGDescriptor_groupRectangles_const_VectorOfRect_rectList_VectorOfdouble_weights_int_groupThreshold_double_eps
// parsed: cv::HOGDescriptor::groupRectangles
// as:     cv::HOGDescriptor::groupRectangles (method) cv::HOGDescriptor . groupRectangles
// Arg ARG Vector[cv::Rect (simple)] rectList= Vector[cv::Rect (simple)] = 
// Arg ARG Vector[Primitive(double)] weights= Vector[Primitive(double)] = 
// Arg ARG Primitive(int) groupThreshold= Primitive(int) = 
// Arg ARG Primitive(double) eps= Primitive(double) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_HOGDescriptor_groupRectangles_const_VectorOfRect_rectList_VectorOfdouble_weights_int_groupThreshold_double_eps(void* instance, void* rectList, void* weights, int groupThreshold, double eps) {
    try {
        reinterpret_cast<cv::HOGDescriptor*>(instance)->groupRectangles(*reinterpret_cast<std::vector<cv::Rect>*>(rectList), *reinterpret_cast<std::vector<double>*>(weights), groupThreshold, eps);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// boxed class: cv::Hamming
void cv_delete_Hamming(void* instance) {
    delete (cv::Hamming*) instance;
}
// cv_HausdorffDistanceExtractor_setDistanceFlag_int_distanceFlag
// parsed: cv::HausdorffDistanceExtractor::setDistanceFlag
// as:     cv::HausdorffDistanceExtractor::setDistanceFlag (method) cv::HausdorffDistanceExtractor (trait) . setDistanceFlag
// Arg ARG Primitive(int) distanceFlag= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_HausdorffDistanceExtractor_setDistanceFlag_int_distanceFlag(void* instance, int distanceFlag) {
    try {
        reinterpret_cast<cv::HausdorffDistanceExtractor*>(instance)->setDistanceFlag(distanceFlag);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_HausdorffDistanceExtractor_getDistanceFlag_const
// parsed: cv::HausdorffDistanceExtractor::getDistanceFlag
// as:     cv::HausdorffDistanceExtractor::getDistanceFlag (method) cv::HausdorffDistanceExtractor (trait) . getDistanceFlag
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_HausdorffDistanceExtractor_getDistanceFlag_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::HausdorffDistanceExtractor*>(instance)->getDistanceFlag();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_HausdorffDistanceExtractor_setRankProportion_float_rankProportion
// parsed: cv::HausdorffDistanceExtractor::setRankProportion
// as:     cv::HausdorffDistanceExtractor::setRankProportion (method) cv::HausdorffDistanceExtractor (trait) . setRankProportion
// Arg ARG Primitive(float) rankProportion= Primitive(float) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_HausdorffDistanceExtractor_setRankProportion_float_rankProportion(void* instance, float rankProportion) {
    try {
        reinterpret_cast<cv::HausdorffDistanceExtractor*>(instance)->setRankProportion(rankProportion);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_HausdorffDistanceExtractor_getRankProportion_const
// parsed: cv::HausdorffDistanceExtractor::getRankProportion
// as:     cv::HausdorffDistanceExtractor::getRankProportion (method) cv::HausdorffDistanceExtractor (trait) . getRankProportion
// Return value: Primitive(float)
cv_return_value_float cv_core_cv_HausdorffDistanceExtractor_getRankProportion_const(void* instance) {
    try {
        float ret = reinterpret_cast<cv::HausdorffDistanceExtractor*>(instance)->getRankProportion();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<float*>(&ret) };
    } CVRS_CATCH(cv_return_value_float)
}

// cv_HistogramCostExtractor_buildCostMatrix_Mat_descriptors1_Mat_descriptors2_Mat_costMatrix
// parsed: cv::HistogramCostExtractor::buildCostMatrix
// as:     cv::HistogramCostExtractor::buildCostMatrix (method) cv::HistogramCostExtractor (trait) . buildCostMatrix
// Arg ARG cv::Mat (boxed) descriptors1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) descriptors2= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) costMatrix= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_HistogramCostExtractor_buildCostMatrix_Mat_descriptors1_Mat_descriptors2_Mat_costMatrix(void* instance, void* descriptors1, void* descriptors2, void* costMatrix) {
    try {
        reinterpret_cast<cv::HistogramCostExtractor*>(instance)->buildCostMatrix(*reinterpret_cast<cv::Mat*>(descriptors1), *reinterpret_cast<cv::Mat*>(descriptors2), *reinterpret_cast<cv::Mat*>(costMatrix));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_HistogramCostExtractor_setNDummies_int_nDummies
// parsed: cv::HistogramCostExtractor::setNDummies
// as:     cv::HistogramCostExtractor::setNDummies (method) cv::HistogramCostExtractor (trait) . setNDummies
// Arg ARG Primitive(int) nDummies= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_HistogramCostExtractor_setNDummies_int_nDummies(void* instance, int nDummies) {
    try {
        reinterpret_cast<cv::HistogramCostExtractor*>(instance)->setNDummies(nDummies);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_HistogramCostExtractor_getNDummies_const
// parsed: cv::HistogramCostExtractor::getNDummies
// as:     cv::HistogramCostExtractor::getNDummies (method) cv::HistogramCostExtractor (trait) . getNDummies
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_HistogramCostExtractor_getNDummies_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::HistogramCostExtractor*>(instance)->getNDummies();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_HistogramCostExtractor_setDefaultCost_float_defaultCost
// parsed: cv::HistogramCostExtractor::setDefaultCost
// as:     cv::HistogramCostExtractor::setDefaultCost (method) cv::HistogramCostExtractor (trait) . setDefaultCost
// Arg ARG Primitive(float) defaultCost= Primitive(float) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_HistogramCostExtractor_setDefaultCost_float_defaultCost(void* instance, float defaultCost) {
    try {
        reinterpret_cast<cv::HistogramCostExtractor*>(instance)->setDefaultCost(defaultCost);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_HistogramCostExtractor_getDefaultCost_const
// parsed: cv::HistogramCostExtractor::getDefaultCost
// as:     cv::HistogramCostExtractor::getDefaultCost (method) cv::HistogramCostExtractor (trait) . getDefaultCost
// Return value: Primitive(float)
cv_return_value_float cv_core_cv_HistogramCostExtractor_getDefaultCost_const(void* instance) {
    try {
        float ret = reinterpret_cast<cv::HistogramCostExtractor*>(instance)->getDefaultCost();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<float*>(&ret) };
    } CVRS_CATCH(cv_return_value_float)
}

// cv_KAZE_setExtended_bool_extended
// parsed: cv::KAZE::setExtended
// as:     cv::KAZE::setExtended (method) cv::KAZE (trait) . setExtended
// Arg ARG Primitive(bool) extended= Primitive(bool) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_KAZE_setExtended_bool_extended(void* instance, bool extended) {
    try {
        reinterpret_cast<cv::KAZE*>(instance)->setExtended(extended);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_KAZE_getExtended_const
// parsed: cv::KAZE::getExtended
// as:     cv::KAZE::getExtended (method) cv::KAZE (trait) . getExtended
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_KAZE_getExtended_const(void* instance) {
    try {
        bool ret = reinterpret_cast<cv::KAZE*>(instance)->getExtended();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_KAZE_setUpright_bool_upright
// parsed: cv::KAZE::setUpright
// as:     cv::KAZE::setUpright (method) cv::KAZE (trait) . setUpright
// Arg ARG Primitive(bool) upright= Primitive(bool) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_KAZE_setUpright_bool_upright(void* instance, bool upright) {
    try {
        reinterpret_cast<cv::KAZE*>(instance)->setUpright(upright);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_KAZE_getUpright_const
// parsed: cv::KAZE::getUpright
// as:     cv::KAZE::getUpright (method) cv::KAZE (trait) . getUpright
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_KAZE_getUpright_const(void* instance) {
    try {
        bool ret = reinterpret_cast<cv::KAZE*>(instance)->getUpright();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_KAZE_setThreshold_double_threshold
// parsed: cv::KAZE::setThreshold
// as:     cv::KAZE::setThreshold (method) cv::KAZE (trait) . setThreshold
// Arg ARG Primitive(double) threshold= Primitive(double) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_KAZE_setThreshold_double_threshold(void* instance, double threshold) {
    try {
        reinterpret_cast<cv::KAZE*>(instance)->setThreshold(threshold);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_KAZE_getThreshold_const
// parsed: cv::KAZE::getThreshold
// as:     cv::KAZE::getThreshold (method) cv::KAZE (trait) . getThreshold
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_KAZE_getThreshold_const(void* instance) {
    try {
        double ret = reinterpret_cast<cv::KAZE*>(instance)->getThreshold();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_KAZE_setNOctaves_int_octaves
// parsed: cv::KAZE::setNOctaves
// as:     cv::KAZE::setNOctaves (method) cv::KAZE (trait) . setNOctaves
// Arg ARG Primitive(int) octaves= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_KAZE_setNOctaves_int_octaves(void* instance, int octaves) {
    try {
        reinterpret_cast<cv::KAZE*>(instance)->setNOctaves(octaves);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_KAZE_getNOctaves_const
// parsed: cv::KAZE::getNOctaves
// as:     cv::KAZE::getNOctaves (method) cv::KAZE (trait) . getNOctaves
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_KAZE_getNOctaves_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::KAZE*>(instance)->getNOctaves();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_KAZE_setNOctaveLayers_int_octaveLayers
// parsed: cv::KAZE::setNOctaveLayers
// as:     cv::KAZE::setNOctaveLayers (method) cv::KAZE (trait) . setNOctaveLayers
// Arg ARG Primitive(int) octaveLayers= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_KAZE_setNOctaveLayers_int_octaveLayers(void* instance, int octaveLayers) {
    try {
        reinterpret_cast<cv::KAZE*>(instance)->setNOctaveLayers(octaveLayers);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_KAZE_getNOctaveLayers_const
// parsed: cv::KAZE::getNOctaveLayers
// as:     cv::KAZE::getNOctaveLayers (method) cv::KAZE (trait) . getNOctaveLayers
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_KAZE_getNOctaveLayers_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::KAZE*>(instance)->getNOctaveLayers();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_KAZE_setDiffusivity_int_diff
// parsed: cv::KAZE::setDiffusivity
// as:     cv::KAZE::setDiffusivity (method) cv::KAZE (trait) . setDiffusivity
// Arg ARG Primitive(int) diff= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_KAZE_setDiffusivity_int_diff(void* instance, int diff) {
    try {
        reinterpret_cast<cv::KAZE*>(instance)->setDiffusivity(diff);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_KAZE_getDiffusivity_const
// parsed: cv::KAZE::getDiffusivity
// as:     cv::KAZE::getDiffusivity (method) cv::KAZE (trait) . getDiffusivity
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_KAZE_getDiffusivity_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::KAZE*>(instance)->getDiffusivity();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_KAZE_getDefaultName_const
// parsed: cv::KAZE::getDefaultName
// as:     cv::KAZE::getDefaultName (method) cv::KAZE (trait) . getDefaultName
// Return value: string
cv_return_value_char_X cv_core_cv_KAZE_getDefaultName_const(void* instance) {
    try {
        String ret = reinterpret_cast<cv::KAZE*>(instance)->getDefaultName();
        return { Error::Code::StsOk, NULL, strdup(ret.c_str()) };
    } CVRS_CATCH(cv_return_value_char_X)
}

// cv_KAZE_create_bool_extended_bool_upright_float_threshold_int_nOctaves_int_nOctaveLayers_int_diffusivity
// parsed: cv::KAZE::create
// as:     cv::KAZE::create (method) cv::KAZE (trait) . create
// Arg ARG Primitive(bool) extended= Primitive(bool) = false
// Arg ARG Primitive(bool) upright= Primitive(bool) = false
// Arg ARG Primitive(float) threshold= Primitive(float) = 0.001f
// Arg ARG Primitive(int) nOctaves= Primitive(int) = 4
// Arg ARG Primitive(int) nOctaveLayers= Primitive(int) = 4
// Arg ARG Primitive(int) diffusivity= Primitive(int) = KAZE::DIFF_PM_G2
// Return value: SmartPtr[cv::KAZE (boxed)]
cv_return_value_void_X cv_core_cv_KAZE_create_bool_extended_bool_upright_float_threshold_int_nOctaves_int_nOctaveLayers_int_diffusivity(bool extended, bool upright, float threshold, int nOctaves, int nOctaveLayers, int diffusivity) {
    try {
        Ptr<cv::KAZE> *ret = new Ptr<cv::KAZE>(cv::KAZE::create(extended, upright, threshold, nOctaves, nOctaveLayers, diffusivity));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// boxed class: cv::KalmanFilter
void cv_delete_KalmanFilter(void* instance) {
    delete (cv::KalmanFilter*) instance;
}
// cv_KalmanFilter_KalmanFilter
// parsed: cv::KalmanFilter::KalmanFilter
// as:     cv::KalmanFilter::KalmanFilter (constructor) cv::KalmanFilter . new
// Return value: cv::KalmanFilter (boxed)
cv_return_value_void_X cv_core_cv_KalmanFilter_KalmanFilter() {
    try {
        cv::KalmanFilter* ret = new cv::KalmanFilter();
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_KalmanFilter_KalmanFilter_int_dynamParams_int_measureParams_int_controlParams_int_type
// parsed: cv::KalmanFilter::KalmanFilter
// as:     cv::KalmanFilter::KalmanFilter (constructor) cv::KalmanFilter . new
// Arg ARG Primitive(int) dynamParams= Primitive(int) = 
// Arg ARG Primitive(int) measureParams= Primitive(int) = 
// Arg ARG Primitive(int) controlParams= Primitive(int) = 0
// Arg ARG Primitive(int) type= Primitive(int) = CV_32F
// Return value: cv::KalmanFilter (boxed)
cv_return_value_void_X cv_core_cv_KalmanFilter_KalmanFilter_int_dynamParams_int_measureParams_int_controlParams_int_type(int dynamParams, int measureParams, int controlParams, int type) {
    try {
        cv::KalmanFilter* ret = new cv::KalmanFilter(dynamParams, measureParams, controlParams, type);
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_KalmanFilter_init_int_dynamParams_int_measureParams_int_controlParams_int_type
// parsed: cv::KalmanFilter::init
// as:     cv::KalmanFilter::init (method) cv::KalmanFilter . init
// Arg ARG Primitive(int) dynamParams= Primitive(int) = 
// Arg ARG Primitive(int) measureParams= Primitive(int) = 
// Arg ARG Primitive(int) controlParams= Primitive(int) = 0
// Arg ARG Primitive(int) type= Primitive(int) = CV_32F
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_KalmanFilter_init_int_dynamParams_int_measureParams_int_controlParams_int_type(void* instance, int dynamParams, int measureParams, int controlParams, int type) {
    try {
        reinterpret_cast<cv::KalmanFilter*>(instance)->init(dynamParams, measureParams, controlParams, type);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_KalmanFilter_predict_Mat_control
// parsed: cv::KalmanFilter::predict
// as:     cv::KalmanFilter::predict (method) cv::KalmanFilter . predict
// Arg ARG cv::Mat (boxed) control= cv::Mat (boxed) = Mat()
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_KalmanFilter_predict_Mat_control(void* instance, void* control) {
    try {
        cv::Mat ret = reinterpret_cast<cv::KalmanFilter*>(instance)->predict(*reinterpret_cast<cv::Mat*>(control));
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_KalmanFilter_correct_Mat_measurement
// parsed: cv::KalmanFilter::correct
// as:     cv::KalmanFilter::correct (method) cv::KalmanFilter . correct
// Arg ARG cv::Mat (boxed) measurement= cv::Mat (boxed) = 
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_KalmanFilter_correct_Mat_measurement(void* instance, void* measurement) {
    try {
        cv::Mat ret = reinterpret_cast<cv::KalmanFilter*>(instance)->correct(*reinterpret_cast<cv::Mat*>(measurement));
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_KeyPoint_KeyPoint
// parsed: cv::KeyPoint::KeyPoint
// as:     cv::KeyPoint::KeyPoint (constructor) cv::KeyPoint (simple) . new
// Return value: cv::KeyPoint (simple)
cv_return_value_KeyPoint cv_core_cv_KeyPoint_KeyPoint() {
    try {
        cv::KeyPoint ret;
        return { Error::Code::StsOk, NULL, *reinterpret_cast<cv::KeyPoint*>(&ret) };
    } CVRS_CATCH(cv_return_value_KeyPoint)
}

// cv_KeyPoint_KeyPoint_Point2f__pt_float__size_float__angle_float__response_int__octave_int__class_id
// parsed: cv::KeyPoint::KeyPoint
// as:     cv::KeyPoint::KeyPoint (constructor) cv::KeyPoint (simple) . new
// Arg ARG cv::Point2f (simple) _pt= cv::Point2f (simple) = 
// Arg ARG Primitive(float) _size= Primitive(float) = 
// Arg ARG Primitive(float) _angle= Primitive(float) = -1
// Arg ARG Primitive(float) _response= Primitive(float) = 0
// Arg ARG Primitive(int) _octave= Primitive(int) = 0
// Arg ARG Primitive(int) _class_id= Primitive(int) = -1
// Return value: cv::KeyPoint (simple)
cv_return_value_KeyPoint cv_core_cv_KeyPoint_KeyPoint_Point2f__pt_float__size_float__angle_float__response_int__octave_int__class_id(Point2fWrapper _pt, float _size, float _angle, float _response, int _octave, int _class_id) {
    try {
        cv::KeyPoint ret(*reinterpret_cast<cv::Point2f*>(&_pt), _size, _angle, _response, _octave, _class_id);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<cv::KeyPoint*>(&ret) };
    } CVRS_CATCH(cv_return_value_KeyPoint)
}

// cv_KeyPoint_KeyPoint_float_x_float_y_float__size_float__angle_float__response_int__octave_int__class_id
// parsed: cv::KeyPoint::KeyPoint
// as:     cv::KeyPoint::KeyPoint (constructor) cv::KeyPoint (simple) . new
// Arg ARG Primitive(float) x= Primitive(float) = 
// Arg ARG Primitive(float) y= Primitive(float) = 
// Arg ARG Primitive(float) _size= Primitive(float) = 
// Arg ARG Primitive(float) _angle= Primitive(float) = -1
// Arg ARG Primitive(float) _response= Primitive(float) = 0
// Arg ARG Primitive(int) _octave= Primitive(int) = 0
// Arg ARG Primitive(int) _class_id= Primitive(int) = -1
// Return value: cv::KeyPoint (simple)
cv_return_value_KeyPoint cv_core_cv_KeyPoint_KeyPoint_float_x_float_y_float__size_float__angle_float__response_int__octave_int__class_id(float x, float y, float _size, float _angle, float _response, int _octave, int _class_id) {
    try {
        cv::KeyPoint ret(x, y, _size, _angle, _response, _octave, _class_id);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<cv::KeyPoint*>(&ret) };
    } CVRS_CATCH(cv_return_value_KeyPoint)
}

// cv_KeyPoint_hash_const
// parsed: cv::KeyPoint::hash
// as:     cv::KeyPoint::hash (method) cv::KeyPoint (simple) . hash
// Return value: Primitive(size_t)
cv_return_value_std_size_t cv_core_cv_KeyPoint_hash_const(cv::KeyPoint instance) {
    try {
        size_t ret = reinterpret_cast<cv::KeyPoint*>(&instance)->hash();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<std::size_t*>(&ret) };
    } CVRS_CATCH(cv_return_value_std_size_t)
}

// cv_KeyPoint_convert_VectorOfKeyPoint_keypoints_VectorOfPoint2f_points2f_VectorOfint_keypointIndexes
// parsed: cv::KeyPoint::convert
// as:     cv::KeyPoint::convert (method) cv::KeyPoint (simple) . convert
// Arg ARG Vector[cv::KeyPoint (simple)] keypoints= Vector[cv::KeyPoint (simple)] = 
// Arg ARG Vector[cv::Point2f (simple)] points2f= Vector[cv::Point2f (simple)] = 
// Arg ARG Vector[Primitive(int)] keypointIndexes= Vector[Primitive(int)] = std::vector<int>()
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_KeyPoint_convert_VectorOfKeyPoint_keypoints_VectorOfPoint2f_points2f_VectorOfint_keypointIndexes(void* keypoints, void* points2f, void* keypointIndexes) {
    try {
        cv::KeyPoint::convert(*reinterpret_cast<std::vector<cv::KeyPoint>*>(keypoints), *reinterpret_cast<std::vector<cv::Point2f>*>(points2f), *reinterpret_cast<std::vector<int>*>(keypointIndexes));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_KeyPoint_convert_VectorOfPoint2f_points2f_VectorOfKeyPoint_keypoints_float_size_float_response_int_octave_int_class_id
// parsed: cv::KeyPoint::convert
// as:     cv::KeyPoint::convert (method) cv::KeyPoint (simple) . convert
// Arg ARG Vector[cv::Point2f (simple)] points2f= Vector[cv::Point2f (simple)] = 
// Arg ARG Vector[cv::KeyPoint (simple)] keypoints= Vector[cv::KeyPoint (simple)] = 
// Arg ARG Primitive(float) size= Primitive(float) = 1
// Arg ARG Primitive(float) response= Primitive(float) = 1
// Arg ARG Primitive(int) octave= Primitive(int) = 0
// Arg ARG Primitive(int) class_id= Primitive(int) = -1
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_KeyPoint_convert_VectorOfPoint2f_points2f_VectorOfKeyPoint_keypoints_float_size_float_response_int_octave_int_class_id(void* points2f, void* keypoints, float size, float response, int octave, int class_id) {
    try {
        cv::KeyPoint::convert(*reinterpret_cast<std::vector<cv::Point2f>*>(points2f), *reinterpret_cast<std::vector<cv::KeyPoint>*>(keypoints), size, response, octave, class_id);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_KeyPoint_overlap_KeyPoint_kp1_KeyPoint_kp2
// parsed: cv::KeyPoint::overlap
// as:     cv::KeyPoint::overlap (method) cv::KeyPoint (simple) . overlap
// Arg ARG cv::KeyPoint (simple) kp1= cv::KeyPoint (simple) = 
// Arg ARG cv::KeyPoint (simple) kp2= cv::KeyPoint (simple) = 
// Return value: Primitive(float)
cv_return_value_float cv_core_cv_KeyPoint_overlap_KeyPoint_kp1_KeyPoint_kp2(cv::KeyPoint kp1, cv::KeyPoint kp2) {
    try {
        float ret = cv::KeyPoint::overlap(*reinterpret_cast<cv::KeyPoint*>(&kp1), *reinterpret_cast<cv::KeyPoint*>(&kp2));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<float*>(&ret) };
    } CVRS_CATCH(cv_return_value_float)
}

// boxed class: cv::KeyPointsFilter
void cv_delete_KeyPointsFilter(void* instance) {
    delete (cv::KeyPointsFilter*) instance;
}
// cv_KeyPointsFilter_KeyPointsFilter
// parsed: cv::KeyPointsFilter::KeyPointsFilter
// as:     cv::KeyPointsFilter::KeyPointsFilter (constructor) cv::KeyPointsFilter . new
// Return value: cv::KeyPointsFilter (boxed)
cv_return_value_void_X cv_core_cv_KeyPointsFilter_KeyPointsFilter() {
    try {
        cv::KeyPointsFilter* ret = new cv::KeyPointsFilter();
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_KeyPointsFilter_runByImageBorder_VectorOfKeyPoint_keypoints_Size_imageSize_int_borderSize
// parsed: cv::KeyPointsFilter::runByImageBorder
// as:     cv::KeyPointsFilter::runByImageBorder (method) cv::KeyPointsFilter . runByImageBorder
// Arg ARG Vector[cv::KeyPoint (simple)] keypoints= Vector[cv::KeyPoint (simple)] = 
// Arg ARG cv::Size (simple) imageSize= cv::Size (simple) = 
// Arg ARG Primitive(int) borderSize= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_KeyPointsFilter_runByImageBorder_VectorOfKeyPoint_keypoints_Size_imageSize_int_borderSize(void* keypoints, SizeWrapper imageSize, int borderSize) {
    try {
        cv::KeyPointsFilter::runByImageBorder(*reinterpret_cast<std::vector<cv::KeyPoint>*>(keypoints), *reinterpret_cast<cv::Size*>(&imageSize), borderSize);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_KeyPointsFilter_runByKeypointSize_VectorOfKeyPoint_keypoints_float_minSize_float_maxSize
// parsed: cv::KeyPointsFilter::runByKeypointSize
// as:     cv::KeyPointsFilter::runByKeypointSize (method) cv::KeyPointsFilter . runByKeypointSize
// Arg ARG Vector[cv::KeyPoint (simple)] keypoints= Vector[cv::KeyPoint (simple)] = 
// Arg ARG Primitive(float) minSize= Primitive(float) = 
// Arg ARG Primitive(float) maxSize= Primitive(float) = FLT_MAX
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_KeyPointsFilter_runByKeypointSize_VectorOfKeyPoint_keypoints_float_minSize_float_maxSize(void* keypoints, float minSize, float maxSize) {
    try {
        cv::KeyPointsFilter::runByKeypointSize(*reinterpret_cast<std::vector<cv::KeyPoint>*>(keypoints), minSize, maxSize);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_KeyPointsFilter_runByPixelsMask_VectorOfKeyPoint_keypoints_Mat_mask
// parsed: cv::KeyPointsFilter::runByPixelsMask
// as:     cv::KeyPointsFilter::runByPixelsMask (method) cv::KeyPointsFilter . runByPixelsMask
// Arg ARG Vector[cv::KeyPoint (simple)] keypoints= Vector[cv::KeyPoint (simple)] = 
// Arg ARG cv::Mat (boxed) mask= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_KeyPointsFilter_runByPixelsMask_VectorOfKeyPoint_keypoints_Mat_mask(void* keypoints, void* mask) {
    try {
        cv::KeyPointsFilter::runByPixelsMask(*reinterpret_cast<std::vector<cv::KeyPoint>*>(keypoints), *reinterpret_cast<cv::Mat*>(mask));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_KeyPointsFilter_removeDuplicated_VectorOfKeyPoint_keypoints
// parsed: cv::KeyPointsFilter::removeDuplicated
// as:     cv::KeyPointsFilter::removeDuplicated (method) cv::KeyPointsFilter . removeDuplicated
// Arg ARG Vector[cv::KeyPoint (simple)] keypoints= Vector[cv::KeyPoint (simple)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_KeyPointsFilter_removeDuplicated_VectorOfKeyPoint_keypoints(void* keypoints) {
    try {
        cv::KeyPointsFilter::removeDuplicated(*reinterpret_cast<std::vector<cv::KeyPoint>*>(keypoints));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_KeyPointsFilter_removeDuplicatedSorted_VectorOfKeyPoint_keypoints
// parsed: cv::KeyPointsFilter::removeDuplicatedSorted
// as:     cv::KeyPointsFilter::removeDuplicatedSorted (method) cv::KeyPointsFilter . removeDuplicatedSorted
// Arg ARG Vector[cv::KeyPoint (simple)] keypoints= Vector[cv::KeyPoint (simple)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_KeyPointsFilter_removeDuplicatedSorted_VectorOfKeyPoint_keypoints(void* keypoints) {
    try {
        cv::KeyPointsFilter::removeDuplicatedSorted(*reinterpret_cast<std::vector<cv::KeyPoint>*>(keypoints));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_KeyPointsFilter_retainBest_VectorOfKeyPoint_keypoints_int_npoints
// parsed: cv::KeyPointsFilter::retainBest
// as:     cv::KeyPointsFilter::retainBest (method) cv::KeyPointsFilter . retainBest
// Arg ARG Vector[cv::KeyPoint (simple)] keypoints= Vector[cv::KeyPoint (simple)] = 
// Arg ARG Primitive(int) npoints= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_KeyPointsFilter_retainBest_VectorOfKeyPoint_keypoints_int_npoints(void* keypoints, int npoints) {
    try {
        cv::KeyPointsFilter::retainBest(*reinterpret_cast<std::vector<cv::KeyPoint>*>(keypoints), npoints);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// boxed class: cv::LDA
void cv_delete_LDA(void* instance) {
    delete (cv::LDA*) instance;
}
// cv_LDA_LDA_int_num_components
// parsed: cv::LDA::LDA
// as:     cv::LDA::LDA (constructor) cv::LDA . new
// Arg ARG Primitive(int) num_components= Primitive(int) = 0
// Return value: cv::LDA (boxed)
cv_return_value_void_X cv_core_cv_LDA_LDA_int_num_components(int num_components) {
    try {
        cv::LDA* ret = new cv::LDA(num_components);
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_LDA_LDA_VectorOfMat_src_Mat_labels_int_num_components
// parsed: cv::LDA::LDA
// as:     cv::LDA::LDA (constructor) cv::LDA . new
// Arg ARG Vector[cv::Mat (boxed)] src= Vector[cv::Mat (boxed)] = 
// Arg ARG cv::Mat (boxed) labels= cv::Mat (boxed) = 
// Arg ARG Primitive(int) num_components= Primitive(int) = 0
// Return value: cv::LDA (boxed)
cv_return_value_void_X cv_core_cv_LDA_LDA_VectorOfMat_src_Mat_labels_int_num_components(void* src, void* labels, int num_components) {
    try {
        cv::LDA* ret = new cv::LDA(*reinterpret_cast<std::vector<cv::Mat>*>(src), *reinterpret_cast<cv::Mat*>(labels), num_components);
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_LDA_save_const_String_filename
// parsed: cv::LDA::save
// as:     cv::LDA::save (method) cv::LDA . save
// Arg ARG string filename= string = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_LDA_save_const_String_filename(void* instance, const char* filename) {
    try {
        reinterpret_cast<cv::LDA*>(instance)->save(String(filename));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_LDA_load_String_filename
// parsed: cv::LDA::load
// as:     cv::LDA::load (method) cv::LDA . load
// Arg ARG string filename= string = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_LDA_load_String_filename(void* instance, const char* filename) {
    try {
        reinterpret_cast<cv::LDA*>(instance)->load(String(filename));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_LDA_compute_VectorOfMat_src_Mat_labels
// parsed: cv::LDA::compute
// as:     cv::LDA::compute (method) cv::LDA . compute
// Arg ARG Vector[cv::Mat (boxed)] src= Vector[cv::Mat (boxed)] = 
// Arg ARG cv::Mat (boxed) labels= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_LDA_compute_VectorOfMat_src_Mat_labels(void* instance, void* src, void* labels) {
    try {
        reinterpret_cast<cv::LDA*>(instance)->compute(*reinterpret_cast<std::vector<cv::Mat>*>(src), *reinterpret_cast<cv::Mat*>(labels));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_LDA_project_Mat_src
// parsed: cv::LDA::project
// as:     cv::LDA::project (method) cv::LDA . project
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_LDA_project_Mat_src(void* instance, void* src) {
    try {
        cv::Mat ret = reinterpret_cast<cv::LDA*>(instance)->project(*reinterpret_cast<cv::Mat*>(src));
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_LDA_reconstruct_Mat_src
// parsed: cv::LDA::reconstruct
// as:     cv::LDA::reconstruct (method) cv::LDA . reconstruct
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_LDA_reconstruct_Mat_src(void* instance, void* src) {
    try {
        cv::Mat ret = reinterpret_cast<cv::LDA*>(instance)->reconstruct(*reinterpret_cast<cv::Mat*>(src));
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_LDA_eigenvectors_const
// parsed: cv::LDA::eigenvectors
// as:     cv::LDA::eigenvectors (method) cv::LDA . eigenvectors
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_LDA_eigenvectors_const(void* instance) {
    try {
        cv::Mat ret = reinterpret_cast<cv::LDA*>(instance)->eigenvectors();
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_LDA_eigenvalues_const
// parsed: cv::LDA::eigenvalues
// as:     cv::LDA::eigenvalues (method) cv::LDA . eigenvalues
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_LDA_eigenvalues_const(void* instance) {
    try {
        cv::Mat ret = reinterpret_cast<cv::LDA*>(instance)->eigenvalues();
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_LDA_subspaceProject_Mat_W_Mat_mean_Mat_src
// parsed: cv::LDA::subspaceProject
// as:     cv::LDA::subspaceProject (method) cv::LDA . subspaceProject
// Arg ARG cv::Mat (boxed) W= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) mean= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_LDA_subspaceProject_Mat_W_Mat_mean_Mat_src(void* W, void* mean, void* src) {
    try {
        cv::Mat ret = cv::LDA::subspaceProject(*reinterpret_cast<cv::Mat*>(W), *reinterpret_cast<cv::Mat*>(mean), *reinterpret_cast<cv::Mat*>(src));
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_LDA_subspaceReconstruct_Mat_W_Mat_mean_Mat_src
// parsed: cv::LDA::subspaceReconstruct
// as:     cv::LDA::subspaceReconstruct (method) cv::LDA . subspaceReconstruct
// Arg ARG cv::Mat (boxed) W= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) mean= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_LDA_subspaceReconstruct_Mat_W_Mat_mean_Mat_src(void* W, void* mean, void* src) {
    try {
        cv::Mat ret = cv::LDA::subspaceReconstruct(*reinterpret_cast<cv::Mat*>(W), *reinterpret_cast<cv::Mat*>(mean), *reinterpret_cast<cv::Mat*>(src));
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// boxed class: cv::LineIterator
void cv_delete_LineIterator(void* instance) {
    delete (cv::LineIterator*) instance;
}
// cv_LineIterator_LineIterator_Mat_img_Point_pt1_Point_pt2_int_connectivity_bool_leftToRight
// parsed: cv::LineIterator::LineIterator
// as:     cv::LineIterator::LineIterator (constructor) cv::LineIterator . new
// Arg ARG cv::Mat (boxed) img= cv::Mat (boxed) = 
// Arg ARG cv::Point (simple) pt1= cv::Point (simple) = 
// Arg ARG cv::Point (simple) pt2= cv::Point (simple) = 
// Arg ARG Primitive(int) connectivity= Primitive(int) = 8
// Arg ARG Primitive(bool) leftToRight= Primitive(bool) = false
// Return value: cv::LineIterator (boxed)
cv_return_value_void_X cv_core_cv_LineIterator_LineIterator_Mat_img_Point_pt1_Point_pt2_int_connectivity_bool_leftToRight(void* img, PointWrapper pt1, PointWrapper pt2, int connectivity, bool leftToRight) {
    try {
        cv::LineIterator* ret = new cv::LineIterator(*reinterpret_cast<cv::Mat*>(img), *reinterpret_cast<cv::Point*>(&pt1), *reinterpret_cast<cv::Point*>(&pt2), connectivity, leftToRight);
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_LineIterator_pos_const
// parsed: cv::LineIterator::pos
// as:     cv::LineIterator::pos (method) cv::LineIterator . pos
// Return value: cv::Point (simple)
cv_return_value_PointWrapper cv_core_cv_LineIterator_pos_const(void* instance) {
    try {
        cv::Point ret = reinterpret_cast<cv::LineIterator*>(instance)->pos();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<PointWrapper*>(&ret) };
    } CVRS_CATCH(cv_return_value_PointWrapper)
}

// cv_LineSegmentDetector_detect_Mat__image_Mat__lines_Mat_width_Mat_prec_Mat_nfa
// parsed: cv::LineSegmentDetector::detect
// as:     cv::LineSegmentDetector::detect (method) cv::LineSegmentDetector (trait) . detect
// Arg ARG cv::Mat (boxed) _image= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) _lines= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) width= cv::Mat (boxed) = noArray()
// Arg ARG cv::Mat (boxed) prec= cv::Mat (boxed) = noArray()
// Arg ARG cv::Mat (boxed) nfa= cv::Mat (boxed) = noArray()
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_LineSegmentDetector_detect_Mat__image_Mat__lines_Mat_width_Mat_prec_Mat_nfa(void* instance, void* _image, void* _lines, void* width, void* prec, void* nfa) {
    try {
        reinterpret_cast<cv::LineSegmentDetector*>(instance)->detect(*reinterpret_cast<cv::Mat*>(_image), *reinterpret_cast<cv::Mat*>(_lines), *reinterpret_cast<cv::Mat*>(width), *reinterpret_cast<cv::Mat*>(prec), *reinterpret_cast<cv::Mat*>(nfa));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_LineSegmentDetector_drawSegments_Mat__image_Mat_lines
// parsed: cv::LineSegmentDetector::drawSegments
// as:     cv::LineSegmentDetector::drawSegments (method) cv::LineSegmentDetector (trait) . drawSegments
// Arg ARG cv::Mat (boxed) _image= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) lines= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_LineSegmentDetector_drawSegments_Mat__image_Mat_lines(void* instance, void* _image, void* lines) {
    try {
        reinterpret_cast<cv::LineSegmentDetector*>(instance)->drawSegments(*reinterpret_cast<cv::Mat*>(_image), *reinterpret_cast<cv::Mat*>(lines));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_LineSegmentDetector_compareSegments_Size_size_Mat_lines1_Mat_lines2_Mat__image
// parsed: cv::LineSegmentDetector::compareSegments
// as:     cv::LineSegmentDetector::compareSegments (method) cv::LineSegmentDetector (trait) . compareSegments
// Arg ARG cv::Size (simple) size= cv::Size (simple) = 
// Arg ARG cv::Mat (boxed) lines1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) lines2= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) _image= cv::Mat (boxed) = noArray()
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_LineSegmentDetector_compareSegments_Size_size_Mat_lines1_Mat_lines2_Mat__image(void* instance, SizeWrapper size, void* lines1, void* lines2, void* _image) {
    try {
        int ret = reinterpret_cast<cv::LineSegmentDetector*>(instance)->compareSegments(*reinterpret_cast<cv::Size*>(&size), *reinterpret_cast<cv::Mat*>(lines1), *reinterpret_cast<cv::Mat*>(lines2), *reinterpret_cast<cv::Mat*>(_image));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_MSER_detectRegions_Mat_image_VectorOfVectorOfPoint_msers_VectorOfRect_bboxes
// parsed: cv::MSER::detectRegions
// as:     cv::MSER::detectRegions (method) cv::MSER (trait) . detectRegions
// Arg ARG cv::Mat (boxed) image= cv::Mat (boxed) = 
// Arg ARG Vector[Vector[cv::Point (simple)]] msers= Vector[Vector[cv::Point (simple)]] = 
// Arg ARG Vector[cv::Rect (simple)] bboxes= Vector[cv::Rect (simple)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_MSER_detectRegions_Mat_image_VectorOfVectorOfPoint_msers_VectorOfRect_bboxes(void* instance, void* image, void* msers, void* bboxes) {
    try {
        reinterpret_cast<cv::MSER*>(instance)->detectRegions(*reinterpret_cast<cv::Mat*>(image), *reinterpret_cast<std::vector<std::vector<cv::Point>>*>(msers), *reinterpret_cast<std::vector<cv::Rect>*>(bboxes));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_MSER_setDelta_int_delta
// parsed: cv::MSER::setDelta
// as:     cv::MSER::setDelta (method) cv::MSER (trait) . setDelta
// Arg ARG Primitive(int) delta= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_MSER_setDelta_int_delta(void* instance, int delta) {
    try {
        reinterpret_cast<cv::MSER*>(instance)->setDelta(delta);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_MSER_getDelta_const
// parsed: cv::MSER::getDelta
// as:     cv::MSER::getDelta (method) cv::MSER (trait) . getDelta
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_MSER_getDelta_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::MSER*>(instance)->getDelta();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_MSER_setMinArea_int_minArea
// parsed: cv::MSER::setMinArea
// as:     cv::MSER::setMinArea (method) cv::MSER (trait) . setMinArea
// Arg ARG Primitive(int) minArea= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_MSER_setMinArea_int_minArea(void* instance, int minArea) {
    try {
        reinterpret_cast<cv::MSER*>(instance)->setMinArea(minArea);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_MSER_getMinArea_const
// parsed: cv::MSER::getMinArea
// as:     cv::MSER::getMinArea (method) cv::MSER (trait) . getMinArea
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_MSER_getMinArea_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::MSER*>(instance)->getMinArea();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_MSER_setMaxArea_int_maxArea
// parsed: cv::MSER::setMaxArea
// as:     cv::MSER::setMaxArea (method) cv::MSER (trait) . setMaxArea
// Arg ARG Primitive(int) maxArea= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_MSER_setMaxArea_int_maxArea(void* instance, int maxArea) {
    try {
        reinterpret_cast<cv::MSER*>(instance)->setMaxArea(maxArea);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_MSER_getMaxArea_const
// parsed: cv::MSER::getMaxArea
// as:     cv::MSER::getMaxArea (method) cv::MSER (trait) . getMaxArea
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_MSER_getMaxArea_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::MSER*>(instance)->getMaxArea();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_MSER_setPass2Only_bool_f
// parsed: cv::MSER::setPass2Only
// as:     cv::MSER::setPass2Only (method) cv::MSER (trait) . setPass2Only
// Arg ARG Primitive(bool) f= Primitive(bool) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_MSER_setPass2Only_bool_f(void* instance, bool f) {
    try {
        reinterpret_cast<cv::MSER*>(instance)->setPass2Only(f);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_MSER_getPass2Only_const
// parsed: cv::MSER::getPass2Only
// as:     cv::MSER::getPass2Only (method) cv::MSER (trait) . getPass2Only
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_MSER_getPass2Only_const(void* instance) {
    try {
        bool ret = reinterpret_cast<cv::MSER*>(instance)->getPass2Only();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_MSER_getDefaultName_const
// parsed: cv::MSER::getDefaultName
// as:     cv::MSER::getDefaultName (method) cv::MSER (trait) . getDefaultName
// Return value: string
cv_return_value_char_X cv_core_cv_MSER_getDefaultName_const(void* instance) {
    try {
        String ret = reinterpret_cast<cv::MSER*>(instance)->getDefaultName();
        return { Error::Code::StsOk, NULL, strdup(ret.c_str()) };
    } CVRS_CATCH(cv_return_value_char_X)
}

// cv_MSER_create_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
// parsed: cv::MSER::create
// as:     cv::MSER::create (method) cv::MSER (trait) . create
// Arg ARG Primitive(int) _delta= Primitive(int) = 5
// Arg ARG Primitive(int) _min_area= Primitive(int) = 60
// Arg ARG Primitive(int) _max_area= Primitive(int) = 14400
// Arg ARG Primitive(double) _max_variation= Primitive(double) = 0.25
// Arg ARG Primitive(double) _min_diversity= Primitive(double) = .2
// Arg ARG Primitive(int) _max_evolution= Primitive(int) = 200
// Arg ARG Primitive(double) _area_threshold= Primitive(double) = 1.01
// Arg ARG Primitive(double) _min_margin= Primitive(double) = 0.003
// Arg ARG Primitive(int) _edge_blur_size= Primitive(int) = 5
// Return value: SmartPtr[cv::MSER (boxed)]
cv_return_value_void_X cv_core_cv_MSER_create_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(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) {
    try {
        Ptr<cv::MSER> *ret = new Ptr<cv::MSER>(cv::MSER::create(_delta, _min_area, _max_area, _max_variation, _min_diversity, _max_evolution, _area_threshold, _min_margin, _edge_blur_size));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// boxed class: cv::Mat
void cv_delete_Mat(void* instance) {
    delete (cv::Mat*) instance;
}
// cv_Mat_Mat
// parsed: cv::Mat::Mat
// as:     cv::Mat::Mat (constructor) cv::Mat . new
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_Mat_Mat() {
    try {
        cv::Mat* ret = new cv::Mat();
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_Mat_Mat_int_rows_int_cols_int_type
// parsed: cv::Mat::Mat
// as:     cv::Mat::Mat (constructor) cv::Mat . new
// Arg ARG Primitive(int) rows= Primitive(int) = 
// Arg ARG Primitive(int) cols= Primitive(int) = 
// Arg ARG Primitive(int) type= Primitive(int) = 
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_Mat_Mat_int_rows_int_cols_int_type(int rows, int cols, int type) {
    try {
        cv::Mat* ret = new cv::Mat(rows, cols, type);
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_Mat_Mat_Size_size_int_type
// parsed: cv::Mat::Mat
// as:     cv::Mat::Mat (constructor) cv::Mat . new
// Arg ARG cv::Size (simple) size= cv::Size (simple) = 
// Arg ARG Primitive(int) type= Primitive(int) = 
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_Mat_Mat_Size_size_int_type(SizeWrapper size, int type) {
    try {
        cv::Mat* ret = new cv::Mat(*reinterpret_cast<cv::Size*>(&size), type);
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_Mat_Mat_int_rows_int_cols_int_type_Scalar_s
// parsed: cv::Mat::Mat
// as:     cv::Mat::Mat (constructor) cv::Mat . new
// Arg ARG Primitive(int) rows= Primitive(int) = 
// Arg ARG Primitive(int) cols= Primitive(int) = 
// Arg ARG Primitive(int) type= Primitive(int) = 
// Arg ARG cv::Scalar (simple) s= cv::Scalar (simple) = 
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_Mat_Mat_int_rows_int_cols_int_type_Scalar_s(int rows, int cols, int type, ScalarWrapper s) {
    try {
        cv::Mat* ret = new cv::Mat(rows, cols, type, *reinterpret_cast<cv::Scalar*>(&s));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_Mat_Mat_Size_size_int_type_Scalar_s
// parsed: cv::Mat::Mat
// as:     cv::Mat::Mat (constructor) cv::Mat . new
// Arg ARG cv::Size (simple) size= cv::Size (simple) = 
// Arg ARG Primitive(int) type= Primitive(int) = 
// Arg ARG cv::Scalar (simple) s= cv::Scalar (simple) = 
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_Mat_Mat_Size_size_int_type_Scalar_s(SizeWrapper size, int type, ScalarWrapper s) {
    try {
        cv::Mat* ret = new cv::Mat(*reinterpret_cast<cv::Size*>(&size), type, *reinterpret_cast<cv::Scalar*>(&s));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_Mat_Mat_int_ndims_const_int_X_sizes_int_type
// parsed: cv::Mat::Mat
// as:     cv::Mat::Mat (constructor) cv::Mat . new
// Arg ARG Primitive(int) ndims= Primitive(int) = 
// Arg ARG RawPtr[Primitive(int)] * sizes= (ptr) RawPtr[Primitive(int)] = 
// Arg ARG Primitive(int) type= Primitive(int) = 
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_Mat_Mat_int_ndims_const_int_X_sizes_int_type(int ndims, const int* sizes, int type) {
    try {
        cv::Mat* ret = new cv::Mat(ndims, sizes, type);
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_Mat_Mat_VectorOfint_sizes_int_type
// parsed: cv::Mat::Mat
// as:     cv::Mat::Mat (constructor) cv::Mat . new
// Arg ARG Vector[Primitive(int)] sizes= Vector[Primitive(int)] = 
// Arg ARG Primitive(int) type= Primitive(int) = 
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_Mat_Mat_VectorOfint_sizes_int_type(void* sizes, int type) {
    try {
        cv::Mat* ret = new cv::Mat(*reinterpret_cast<std::vector<int>*>(sizes), type);
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_Mat_Mat_int_ndims_const_int_X_sizes_int_type_Scalar_s
// parsed: cv::Mat::Mat
// as:     cv::Mat::Mat (constructor) cv::Mat . new
// Arg ARG Primitive(int) ndims= Primitive(int) = 
// Arg ARG RawPtr[Primitive(int)] * sizes= (ptr) RawPtr[Primitive(int)] = 
// Arg ARG Primitive(int) type= Primitive(int) = 
// Arg ARG cv::Scalar (simple) s= cv::Scalar (simple) = 
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_Mat_Mat_int_ndims_const_int_X_sizes_int_type_Scalar_s(int ndims, const int* sizes, int type, ScalarWrapper s) {
    try {
        cv::Mat* ret = new cv::Mat(ndims, sizes, type, *reinterpret_cast<cv::Scalar*>(&s));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_Mat_Mat_VectorOfint_sizes_int_type_Scalar_s
// parsed: cv::Mat::Mat
// as:     cv::Mat::Mat (constructor) cv::Mat . new
// Arg ARG Vector[Primitive(int)] sizes= Vector[Primitive(int)] = 
// Arg ARG Primitive(int) type= Primitive(int) = 
// Arg ARG cv::Scalar (simple) s= cv::Scalar (simple) = 
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_Mat_Mat_VectorOfint_sizes_int_type_Scalar_s(void* sizes, int type, ScalarWrapper s) {
    try {
        cv::Mat* ret = new cv::Mat(*reinterpret_cast<std::vector<int>*>(sizes), type, *reinterpret_cast<cv::Scalar*>(&s));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_Mat_Mat_Mat_m
// parsed: cv::Mat::Mat
// as:     cv::Mat::Mat (constructor) cv::Mat . new
// Arg ARG cv::Mat (boxed) m= cv::Mat (boxed) = 
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_Mat_Mat_Mat_m(void* m) {
    try {
        cv::Mat* ret = new cv::Mat(*reinterpret_cast<cv::Mat*>(m));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_Mat_Mat_int_rows_int_cols_int_type_void_X_data_size_t_step
// parsed: cv::Mat::Mat
// as:     cv::Mat::Mat (constructor) cv::Mat . new
// Arg ARG Primitive(int) rows= Primitive(int) = 
// Arg ARG Primitive(int) cols= Primitive(int) = 
// Arg ARG Primitive(int) type= Primitive(int) = 
// Arg ARG RawPtr[Primitive(void)] * data= (ptr) RawPtr[Primitive(void)] = 
// Arg ARG Primitive(size_t) step= Primitive(size_t) = AUTO_STEP
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_Mat_Mat_int_rows_int_cols_int_type_void_X_data_size_t_step(int rows, int cols, int type, void* data, std::size_t step) {
    try {
        cv::Mat* ret = new cv::Mat(rows, cols, type, data, step);
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_Mat_Mat_Size_size_int_type_void_X_data_size_t_step
// parsed: cv::Mat::Mat
// as:     cv::Mat::Mat (constructor) cv::Mat . new
// Arg ARG cv::Size (simple) size= cv::Size (simple) = 
// Arg ARG Primitive(int) type= Primitive(int) = 
// Arg ARG RawPtr[Primitive(void)] * data= (ptr) RawPtr[Primitive(void)] = 
// Arg ARG Primitive(size_t) step= Primitive(size_t) = AUTO_STEP
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_Mat_Mat_Size_size_int_type_void_X_data_size_t_step(SizeWrapper size, int type, void* data, std::size_t step) {
    try {
        cv::Mat* ret = new cv::Mat(*reinterpret_cast<cv::Size*>(&size), type, data, step);
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_Mat_Mat_int_ndims_const_int_X_sizes_int_type_void_X_data_const_size_t_X_steps
// parsed: cv::Mat::Mat
// as:     cv::Mat::Mat (constructor) cv::Mat . new
// Arg ARG Primitive(int) ndims= Primitive(int) = 
// Arg ARG RawPtr[Primitive(int)] * sizes= (ptr) RawPtr[Primitive(int)] = 
// Arg ARG Primitive(int) type= Primitive(int) = 
// Arg ARG RawPtr[Primitive(void)] * data= (ptr) RawPtr[Primitive(void)] = 
// Arg ARG RawPtr[Primitive(size_t)] * steps= (ptr) RawPtr[Primitive(size_t)] = 0
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_Mat_Mat_int_ndims_const_int_X_sizes_int_type_void_X_data_const_size_t_X_steps(int ndims, const int* sizes, int type, void* data, const size_t* steps) {
    try {
        cv::Mat* ret = new cv::Mat(ndims, sizes, type, data, steps);
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_Mat_Mat_VectorOfint_sizes_int_type_void_X_data_const_size_t_X_steps
// parsed: cv::Mat::Mat
// as:     cv::Mat::Mat (constructor) cv::Mat . new
// Arg ARG Vector[Primitive(int)] sizes= Vector[Primitive(int)] = 
// Arg ARG Primitive(int) type= Primitive(int) = 
// Arg ARG RawPtr[Primitive(void)] * data= (ptr) RawPtr[Primitive(void)] = 
// Arg ARG RawPtr[Primitive(size_t)] * steps= (ptr) RawPtr[Primitive(size_t)] = 0
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_Mat_Mat_VectorOfint_sizes_int_type_void_X_data_const_size_t_X_steps(void* sizes, int type, void* data, const size_t* steps) {
    try {
        cv::Mat* ret = new cv::Mat(*reinterpret_cast<std::vector<int>*>(sizes), type, data, steps);
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_Mat_Mat_Mat_m_Range_rowRange_Range_colRange
// parsed: cv::Mat::Mat
// as:     cv::Mat::Mat (constructor) cv::Mat . new
// Arg ARG cv::Mat (boxed) m= cv::Mat (boxed) = 
// Arg ARG cv::Range (boxed) rowRange= cv::Range (boxed) = 
// Arg ARG cv::Range (boxed) colRange= cv::Range (boxed) = Range::all()
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_Mat_Mat_Mat_m_Range_rowRange_Range_colRange(void* m, void* rowRange, void* colRange) {
    try {
        cv::Mat* ret = new cv::Mat(*reinterpret_cast<cv::Mat*>(m), *reinterpret_cast<cv::Range*>(rowRange), *reinterpret_cast<cv::Range*>(colRange));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_Mat_Mat_Mat_m_Rect_roi
// parsed: cv::Mat::Mat
// as:     cv::Mat::Mat (constructor) cv::Mat . new
// Arg ARG cv::Mat (boxed) m= cv::Mat (boxed) = 
// Arg ARG cv::Rect (simple) roi= cv::Rect (simple) = 
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_Mat_Mat_Mat_m_Rect_roi(void* m, RectWrapper roi) {
    try {
        cv::Mat* ret = new cv::Mat(*reinterpret_cast<cv::Mat*>(m), *reinterpret_cast<cv::Rect*>(&roi));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_Mat_Mat_Mat_m_const_Range_ranges
// parsed: cv::Mat::Mat
// as:     cv::Mat::Mat (constructor) cv::Mat . new
// Arg ARG cv::Mat (boxed) m= cv::Mat (boxed) = 
// Arg ARG RawPtr[cv::Range (boxed)] * ranges= (ptr) RawPtr[cv::Range (boxed)] = 
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_Mat_Mat_Mat_m_const_Range_ranges(void* m, const void* ranges) {
    try {
        cv::Mat* ret = new cv::Mat(*reinterpret_cast<cv::Mat*>(m), reinterpret_cast<const cv::Range*>(ranges));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_Mat_Mat_Mat_m_VectorOfRange_ranges
// parsed: cv::Mat::Mat
// as:     cv::Mat::Mat (constructor) cv::Mat . new
// Arg ARG cv::Mat (boxed) m= cv::Mat (boxed) = 
// Arg ARG Vector[cv::Range (boxed)] ranges= Vector[cv::Range (boxed)] = 
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_Mat_Mat_Mat_m_VectorOfRange_ranges(void* m, void* ranges) {
    try {
        cv::Mat* ret = new cv::Mat(*reinterpret_cast<cv::Mat*>(m), *reinterpret_cast<std::vector<cv::Range>*>(ranges));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_Mat_row_const_int_y
// parsed: cv::Mat::row
// as:     cv::Mat::row (method) cv::Mat . row
// Arg ARG Primitive(int) y= Primitive(int) = 
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_Mat_row_const_int_y(void* instance, int y) {
    try {
        cv::Mat ret = reinterpret_cast<cv::Mat*>(instance)->row(y);
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_Mat_col_const_int_x
// parsed: cv::Mat::col
// as:     cv::Mat::col (method) cv::Mat . col
// Arg ARG Primitive(int) x= Primitive(int) = 
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_Mat_col_const_int_x(void* instance, int x) {
    try {
        cv::Mat ret = reinterpret_cast<cv::Mat*>(instance)->col(x);
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_Mat_rowRange_const_int_startrow_int_endrow
// parsed: cv::Mat::rowRange
// as:     cv::Mat::rowRange (method) cv::Mat . rowRange
// Arg ARG Primitive(int) startrow= Primitive(int) = 
// Arg ARG Primitive(int) endrow= Primitive(int) = 
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_Mat_rowRange_const_int_startrow_int_endrow(void* instance, int startrow, int endrow) {
    try {
        cv::Mat ret = reinterpret_cast<cv::Mat*>(instance)->rowRange(startrow, endrow);
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_Mat_rowRange_const_Range_r
// parsed: cv::Mat::rowRange
// as:     cv::Mat::rowRange (method) cv::Mat . rowRange
// Arg ARG cv::Range (boxed) r= cv::Range (boxed) = 
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_Mat_rowRange_const_Range_r(void* instance, void* r) {
    try {
        cv::Mat ret = reinterpret_cast<cv::Mat*>(instance)->rowRange(*reinterpret_cast<cv::Range*>(r));
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_Mat_colRange_const_int_startcol_int_endcol
// parsed: cv::Mat::colRange
// as:     cv::Mat::colRange (method) cv::Mat . colRange
// Arg ARG Primitive(int) startcol= Primitive(int) = 
// Arg ARG Primitive(int) endcol= Primitive(int) = 
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_Mat_colRange_const_int_startcol_int_endcol(void* instance, int startcol, int endcol) {
    try {
        cv::Mat ret = reinterpret_cast<cv::Mat*>(instance)->colRange(startcol, endcol);
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_Mat_colRange_const_Range_r
// parsed: cv::Mat::colRange
// as:     cv::Mat::colRange (method) cv::Mat . colRange
// Arg ARG cv::Range (boxed) r= cv::Range (boxed) = 
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_Mat_colRange_const_Range_r(void* instance, void* r) {
    try {
        cv::Mat ret = reinterpret_cast<cv::Mat*>(instance)->colRange(*reinterpret_cast<cv::Range*>(r));
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_Mat_diag_const_int_d
// parsed: cv::Mat::diag
// as:     cv::Mat::diag (method) cv::Mat . diag
// Arg ARG Primitive(int) d= Primitive(int) = 0
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_Mat_diag_const_int_d(void* instance, int d) {
    try {
        cv::Mat ret = reinterpret_cast<cv::Mat*>(instance)->diag(d);
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_Mat_diag_Mat_d
// parsed: cv::Mat::diag
// as:     cv::Mat::diag (method) cv::Mat . diag
// Arg ARG cv::Mat (boxed) d= cv::Mat (boxed) = 
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_Mat_diag_Mat_d(void* d) {
    try {
        cv::Mat ret = cv::Mat::diag(*reinterpret_cast<cv::Mat*>(d));
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_Mat_clone_const
// parsed: cv::Mat::clone
// as:     cv::Mat::clone (method) cv::Mat . clone
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_Mat_clone_const(void* instance) {
    try {
        cv::Mat ret = reinterpret_cast<cv::Mat*>(instance)->clone();
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_Mat_copyTo_const_Mat_m
// parsed: cv::Mat::copyTo
// as:     cv::Mat::copyTo (method) cv::Mat . copyTo
// Arg ARG cv::Mat (boxed) m= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_Mat_copyTo_const_Mat_m(void* instance, void* m) {
    try {
        reinterpret_cast<cv::Mat*>(instance)->copyTo(*reinterpret_cast<cv::Mat*>(m));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_Mat_copyTo_const_Mat_m_Mat_mask
// parsed: cv::Mat::copyTo
// as:     cv::Mat::copyTo (method) cv::Mat . copyTo
// Arg ARG cv::Mat (boxed) m= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) mask= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_Mat_copyTo_const_Mat_m_Mat_mask(void* instance, void* m, void* mask) {
    try {
        reinterpret_cast<cv::Mat*>(instance)->copyTo(*reinterpret_cast<cv::Mat*>(m), *reinterpret_cast<cv::Mat*>(mask));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_Mat_convertTo_const_Mat_m_int_rtype_double_alpha_double_beta
// parsed: cv::Mat::convertTo
// as:     cv::Mat::convertTo (method) cv::Mat . convertTo
// Arg ARG cv::Mat (boxed) m= cv::Mat (boxed) = 
// Arg ARG Primitive(int) rtype= Primitive(int) = 
// Arg ARG Primitive(double) alpha= Primitive(double) = 1
// Arg ARG Primitive(double) beta= Primitive(double) = 0
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_Mat_convertTo_const_Mat_m_int_rtype_double_alpha_double_beta(void* instance, void* m, int rtype, double alpha, double beta) {
    try {
        reinterpret_cast<cv::Mat*>(instance)->convertTo(*reinterpret_cast<cv::Mat*>(m), rtype, alpha, beta);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_Mat_assignTo_const_Mat_m_int_type
// parsed: cv::Mat::assignTo
// as:     cv::Mat::assignTo (method) cv::Mat . assignTo
// Arg ARG cv::Mat (boxed) m= cv::Mat (boxed) = 
// Arg ARG Primitive(int) type= Primitive(int) = -1
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_Mat_assignTo_const_Mat_m_int_type(void* instance, void* m, int type) {
    try {
        reinterpret_cast<cv::Mat*>(instance)->assignTo(*reinterpret_cast<cv::Mat*>(m), type);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_Mat_setTo_Mat_value_Mat_mask
// parsed: cv::Mat::setTo
// as:     cv::Mat::setTo (method) cv::Mat . setTo
// Arg ARG cv::Mat (boxed) value= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) mask= cv::Mat (boxed) = noArray()
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_Mat_setTo_Mat_value_Mat_mask(void* instance, void* value, void* mask) {
    try {
        cv::Mat ret = reinterpret_cast<cv::Mat*>(instance)->setTo(*reinterpret_cast<cv::Mat*>(value), *reinterpret_cast<cv::Mat*>(mask));
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_Mat_reshape_const_int_cn_int_rows
// parsed: cv::Mat::reshape
// as:     cv::Mat::reshape (method) cv::Mat . reshape
// Arg ARG Primitive(int) cn= Primitive(int) = 
// Arg ARG Primitive(int) rows= Primitive(int) = 0
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_Mat_reshape_const_int_cn_int_rows(void* instance, int cn, int rows) {
    try {
        cv::Mat ret = reinterpret_cast<cv::Mat*>(instance)->reshape(cn, rows);
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_Mat_reshape_const_int_cn_int_newndims_const_int_X_newsz
// parsed: cv::Mat::reshape
// as:     cv::Mat::reshape (method) cv::Mat . reshape
// Arg ARG Primitive(int) cn= Primitive(int) = 
// Arg ARG Primitive(int) newndims= Primitive(int) = 
// Arg ARG RawPtr[Primitive(int)] * newsz= (ptr) RawPtr[Primitive(int)] = 
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_Mat_reshape_const_int_cn_int_newndims_const_int_X_newsz(void* instance, int cn, int newndims, const int* newsz) {
    try {
        cv::Mat ret = reinterpret_cast<cv::Mat*>(instance)->reshape(cn, newndims, newsz);
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_Mat_reshape_const_int_cn_VectorOfint_newshape
// parsed: cv::Mat::reshape
// as:     cv::Mat::reshape (method) cv::Mat . reshape
// Arg ARG Primitive(int) cn= Primitive(int) = 
// Arg ARG Vector[Primitive(int)] newshape= Vector[Primitive(int)] = 
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_Mat_reshape_const_int_cn_VectorOfint_newshape(void* instance, int cn, void* newshape) {
    try {
        cv::Mat ret = reinterpret_cast<cv::Mat*>(instance)->reshape(cn, *reinterpret_cast<std::vector<int>*>(newshape));
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_Mat_cross_const_Mat_m
// parsed: cv::Mat::cross
// as:     cv::Mat::cross (method) cv::Mat . cross
// Arg ARG cv::Mat (boxed) m= cv::Mat (boxed) = 
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_Mat_cross_const_Mat_m(void* instance, void* m) {
    try {
        cv::Mat ret = reinterpret_cast<cv::Mat*>(instance)->cross(*reinterpret_cast<cv::Mat*>(m));
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_Mat_dot_const_Mat_m
// parsed: cv::Mat::dot
// as:     cv::Mat::dot (method) cv::Mat . dot
// Arg ARG cv::Mat (boxed) m= cv::Mat (boxed) = 
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_Mat_dot_const_Mat_m(void* instance, void* m) {
    try {
        double ret = reinterpret_cast<cv::Mat*>(instance)->dot(*reinterpret_cast<cv::Mat*>(m));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_Mat_create_int_ndims_const_int_X_sizes_int_type
// parsed: cv::Mat::create
// as:     cv::Mat::create (method) cv::Mat . create
// Arg ARG Primitive(int) ndims= Primitive(int) = 
// Arg ARG RawPtr[Primitive(int)] * sizes= (ptr) RawPtr[Primitive(int)] = 
// Arg ARG Primitive(int) type= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_Mat_create_int_ndims_const_int_X_sizes_int_type(void* instance, int ndims, const int* sizes, int type) {
    try {
        reinterpret_cast<cv::Mat*>(instance)->create(ndims, sizes, type);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_Mat_create_VectorOfint_sizes_int_type
// parsed: cv::Mat::create
// as:     cv::Mat::create (method) cv::Mat . create
// Arg ARG Vector[Primitive(int)] sizes= Vector[Primitive(int)] = 
// Arg ARG Primitive(int) type= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_Mat_create_VectorOfint_sizes_int_type(void* instance, void* sizes, int type) {
    try {
        reinterpret_cast<cv::Mat*>(instance)->create(*reinterpret_cast<std::vector<int>*>(sizes), type);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_Mat_addref
// parsed: cv::Mat::addref
// as:     cv::Mat::addref (method) cv::Mat . addref
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_Mat_addref(void* instance) {
    try {
        reinterpret_cast<cv::Mat*>(instance)->addref();
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_Mat_release
// parsed: cv::Mat::release
// as:     cv::Mat::release (method) cv::Mat . release
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_Mat_release(void* instance) {
    try {
        reinterpret_cast<cv::Mat*>(instance)->release();
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_Mat_deallocate
// parsed: cv::Mat::deallocate
// as:     cv::Mat::deallocate (method) cv::Mat . deallocate
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_Mat_deallocate(void* instance) {
    try {
        reinterpret_cast<cv::Mat*>(instance)->deallocate();
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_Mat_copySize_Mat_m
// parsed: cv::Mat::copySize
// as:     cv::Mat::copySize (method) cv::Mat . copySize
// Arg ARG cv::Mat (boxed) m= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_Mat_copySize_Mat_m(void* instance, void* m) {
    try {
        reinterpret_cast<cv::Mat*>(instance)->copySize(*reinterpret_cast<cv::Mat*>(m));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_Mat_reserve_size_t_sz
// parsed: cv::Mat::reserve
// as:     cv::Mat::reserve (method) cv::Mat . reserve
// Arg ARG Primitive(size_t) sz= Primitive(size_t) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_Mat_reserve_size_t_sz(void* instance, std::size_t sz) {
    try {
        reinterpret_cast<cv::Mat*>(instance)->reserve(sz);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_Mat_reserveBuffer_size_t_sz
// parsed: cv::Mat::reserveBuffer
// as:     cv::Mat::reserveBuffer (method) cv::Mat . reserveBuffer
// Arg ARG Primitive(size_t) sz= Primitive(size_t) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_Mat_reserveBuffer_size_t_sz(void* instance, std::size_t sz) {
    try {
        reinterpret_cast<cv::Mat*>(instance)->reserveBuffer(sz);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_Mat_resize_size_t_sz
// parsed: cv::Mat::resize
// as:     cv::Mat::resize (method) cv::Mat . resize
// Arg ARG Primitive(size_t) sz= Primitive(size_t) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_Mat_resize_size_t_sz(void* instance, std::size_t sz) {
    try {
        reinterpret_cast<cv::Mat*>(instance)->resize(sz);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_Mat_resize_size_t_sz_Scalar_s
// parsed: cv::Mat::resize
// as:     cv::Mat::resize (method) cv::Mat . resize
// Arg ARG Primitive(size_t) sz= Primitive(size_t) = 
// Arg ARG cv::Scalar (simple) s= cv::Scalar (simple) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_Mat_resize_size_t_sz_Scalar_s(void* instance, std::size_t sz, ScalarWrapper s) {
    try {
        reinterpret_cast<cv::Mat*>(instance)->resize(sz, *reinterpret_cast<cv::Scalar*>(&s));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_Mat_push_back__const_void_X_elem
// parsed: cv::Mat::push_back_
// as:     cv::Mat::push_back_ (method) cv::Mat . push_back_
// Arg ARG RawPtr[Primitive(void)] * elem= (ptr) RawPtr[Primitive(void)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_Mat_push_back__const_void_X_elem(void* instance, const void* elem) {
    try {
        reinterpret_cast<cv::Mat*>(instance)->push_back_(elem);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_Mat_push_back_Mat_m
// parsed: cv::Mat::push_back
// as:     cv::Mat::push_back (method) cv::Mat . push_back
// Arg ARG cv::Mat (boxed) m= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_Mat_push_back_Mat_m(void* instance, void* m) {
    try {
        reinterpret_cast<cv::Mat*>(instance)->push_back(*reinterpret_cast<cv::Mat*>(m));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_Mat_pop_back_size_t_nelems
// parsed: cv::Mat::pop_back
// as:     cv::Mat::pop_back (method) cv::Mat . pop_back
// Arg ARG Primitive(size_t) nelems= Primitive(size_t) = 1
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_Mat_pop_back_size_t_nelems(void* instance, std::size_t nelems) {
    try {
        reinterpret_cast<cv::Mat*>(instance)->pop_back(nelems);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_Mat_locateROI_const_Size_wholeSize_Point_ofs
// parsed: cv::Mat::locateROI
// as:     cv::Mat::locateROI (method) cv::Mat . locateROI
// Arg ARG cv::Size (simple) wholeSize= cv::Size (simple) = 
// Arg ARG cv::Point (simple) ofs= cv::Point (simple) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_Mat_locateROI_const_Size_wholeSize_Point_ofs(void* instance, SizeWrapper wholeSize, PointWrapper ofs) {
    try {
        reinterpret_cast<cv::Mat*>(instance)->locateROI(*reinterpret_cast<cv::Size*>(&wholeSize), *reinterpret_cast<cv::Point*>(&ofs));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_Mat_adjustROI_int_dtop_int_dbottom_int_dleft_int_dright
// parsed: cv::Mat::adjustROI
// as:     cv::Mat::adjustROI (method) cv::Mat . adjustROI
// Arg ARG Primitive(int) dtop= Primitive(int) = 
// Arg ARG Primitive(int) dbottom= Primitive(int) = 
// Arg ARG Primitive(int) dleft= Primitive(int) = 
// Arg ARG Primitive(int) dright= Primitive(int) = 
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_Mat_adjustROI_int_dtop_int_dbottom_int_dleft_int_dright(void* instance, int dtop, int dbottom, int dleft, int dright) {
    try {
        cv::Mat ret = reinterpret_cast<cv::Mat*>(instance)->adjustROI(dtop, dbottom, dleft, dright);
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_Mat_isContinuous_const
// parsed: cv::Mat::isContinuous
// as:     cv::Mat::isContinuous (method) cv::Mat . isContinuous
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_Mat_isContinuous_const(void* instance) {
    try {
        bool ret = reinterpret_cast<cv::Mat*>(instance)->isContinuous();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_Mat_isSubmatrix_const
// parsed: cv::Mat::isSubmatrix
// as:     cv::Mat::isSubmatrix (method) cv::Mat . isSubmatrix
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_Mat_isSubmatrix_const(void* instance) {
    try {
        bool ret = reinterpret_cast<cv::Mat*>(instance)->isSubmatrix();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_Mat_elemSize_const
// parsed: cv::Mat::elemSize
// as:     cv::Mat::elemSize (method) cv::Mat . elemSize
// Return value: Primitive(size_t)
cv_return_value_std_size_t cv_core_cv_Mat_elemSize_const(void* instance) {
    try {
        size_t ret = reinterpret_cast<cv::Mat*>(instance)->elemSize();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<std::size_t*>(&ret) };
    } CVRS_CATCH(cv_return_value_std_size_t)
}

// cv_Mat_elemSize1_const
// parsed: cv::Mat::elemSize1
// as:     cv::Mat::elemSize1 (method) cv::Mat . elemSize1
// Return value: Primitive(size_t)
cv_return_value_std_size_t cv_core_cv_Mat_elemSize1_const(void* instance) {
    try {
        size_t ret = reinterpret_cast<cv::Mat*>(instance)->elemSize1();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<std::size_t*>(&ret) };
    } CVRS_CATCH(cv_return_value_std_size_t)
}

// cv_Mat_type_const
// parsed: cv::Mat::type
// as:     cv::Mat::type (method) cv::Mat . type
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_Mat_type_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::Mat*>(instance)->type();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_Mat_depth_const
// parsed: cv::Mat::depth
// as:     cv::Mat::depth (method) cv::Mat . depth
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_Mat_depth_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::Mat*>(instance)->depth();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_Mat_channels_const
// parsed: cv::Mat::channels
// as:     cv::Mat::channels (method) cv::Mat . channels
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_Mat_channels_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::Mat*>(instance)->channels();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_Mat_step1_const_int_i
// parsed: cv::Mat::step1
// as:     cv::Mat::step1 (method) cv::Mat . step1
// Arg ARG Primitive(int) i= Primitive(int) = 0
// Return value: Primitive(size_t)
cv_return_value_std_size_t cv_core_cv_Mat_step1_const_int_i(void* instance, int i) {
    try {
        size_t ret = reinterpret_cast<cv::Mat*>(instance)->step1(i);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<std::size_t*>(&ret) };
    } CVRS_CATCH(cv_return_value_std_size_t)
}

// cv_Mat_empty_const
// parsed: cv::Mat::empty
// as:     cv::Mat::empty (method) cv::Mat . empty
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_Mat_empty_const(void* instance) {
    try {
        bool ret = reinterpret_cast<cv::Mat*>(instance)->empty();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_Mat_total_const
// parsed: cv::Mat::total
// as:     cv::Mat::total (method) cv::Mat . total
// Return value: Primitive(size_t)
cv_return_value_std_size_t cv_core_cv_Mat_total_const(void* instance) {
    try {
        size_t ret = reinterpret_cast<cv::Mat*>(instance)->total();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<std::size_t*>(&ret) };
    } CVRS_CATCH(cv_return_value_std_size_t)
}

// cv_Mat_total_const_int_startDim_int_endDim
// parsed: cv::Mat::total
// as:     cv::Mat::total (method) cv::Mat . total
// Arg ARG Primitive(int) startDim= Primitive(int) = 
// Arg ARG Primitive(int) endDim= Primitive(int) = INT_MAX
// Return value: Primitive(size_t)
cv_return_value_std_size_t cv_core_cv_Mat_total_const_int_startDim_int_endDim(void* instance, int startDim, int endDim) {
    try {
        size_t ret = reinterpret_cast<cv::Mat*>(instance)->total(startDim, endDim);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<std::size_t*>(&ret) };
    } CVRS_CATCH(cv_return_value_std_size_t)
}

// cv_Mat_checkVector_const_int_elemChannels_int_depth_bool_requireContinuous
// parsed: cv::Mat::checkVector
// as:     cv::Mat::checkVector (method) cv::Mat . checkVector
// Arg ARG Primitive(int) elemChannels= Primitive(int) = 
// Arg ARG Primitive(int) depth= Primitive(int) = -1
// Arg ARG Primitive(bool) requireContinuous= Primitive(bool) = true
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_Mat_checkVector_const_int_elemChannels_int_depth_bool_requireContinuous(void* instance, int elemChannels, int depth, bool requireContinuous) {
    try {
        int ret = reinterpret_cast<cv::Mat*>(instance)->checkVector(elemChannels, depth, requireContinuous);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_Mat_ptr_int_i0
// parsed: cv::Mat::ptr
// as:     cv::Mat::ptr (method) cv::Mat . ptr
// Arg ARG Primitive(int) i0= Primitive(int) = 0
// Return value: RawPtr[Primitive(uchar)]
cv_return_value_unsigned_char_X cv_core_cv_Mat_ptr_int_i0(void* instance, int i0) {
    try {
        uchar* ret = reinterpret_cast<cv::Mat*>(instance)->ptr(i0);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<uchar**>(&ret) };
    } CVRS_CATCH(cv_return_value_unsigned_char_X)
}

// cv_Mat_ptr_const_int_i0
// parsed: cv::Mat::ptr
// as:     cv::Mat::ptr (method) cv::Mat . ptr
// Arg ARG Primitive(int) i0= Primitive(int) = 0
// Return value: RawPtr[Primitive(uchar)]
cv_return_value_const_unsigned_char_X cv_core_cv_Mat_ptr_const_int_i0(void* instance, int i0) {
    try {
        const uchar* ret = reinterpret_cast<cv::Mat*>(instance)->ptr(i0);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<const uchar**>(&ret) };
    } CVRS_CATCH(cv_return_value_const_unsigned_char_X)
}

// cv_Mat_ptr_int_row_int_col
// parsed: cv::Mat::ptr
// as:     cv::Mat::ptr (method) cv::Mat . ptr
// Arg ARG Primitive(int) row= Primitive(int) = 
// Arg ARG Primitive(int) col= Primitive(int) = 
// Return value: RawPtr[Primitive(uchar)]
cv_return_value_unsigned_char_X cv_core_cv_Mat_ptr_int_row_int_col(void* instance, int row, int col) {
    try {
        uchar* ret = reinterpret_cast<cv::Mat*>(instance)->ptr(row, col);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<uchar**>(&ret) };
    } CVRS_CATCH(cv_return_value_unsigned_char_X)
}

// cv_Mat_ptr_const_int_row_int_col
// parsed: cv::Mat::ptr
// as:     cv::Mat::ptr (method) cv::Mat . ptr
// Arg ARG Primitive(int) row= Primitive(int) = 
// Arg ARG Primitive(int) col= Primitive(int) = 
// Return value: RawPtr[Primitive(uchar)]
cv_return_value_const_unsigned_char_X cv_core_cv_Mat_ptr_const_int_row_int_col(void* instance, int row, int col) {
    try {
        const uchar* ret = reinterpret_cast<cv::Mat*>(instance)->ptr(row, col);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<const uchar**>(&ret) };
    } CVRS_CATCH(cv_return_value_const_unsigned_char_X)
}

// cv_Mat_ptr_int_i0_int_i1_int_i2
// parsed: cv::Mat::ptr
// as:     cv::Mat::ptr (method) cv::Mat . ptr
// Arg ARG Primitive(int) i0= Primitive(int) = 
// Arg ARG Primitive(int) i1= Primitive(int) = 
// Arg ARG Primitive(int) i2= Primitive(int) = 
// Return value: RawPtr[Primitive(uchar)]
cv_return_value_unsigned_char_X cv_core_cv_Mat_ptr_int_i0_int_i1_int_i2(void* instance, int i0, int i1, int i2) {
    try {
        uchar* ret = reinterpret_cast<cv::Mat*>(instance)->ptr(i0, i1, i2);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<uchar**>(&ret) };
    } CVRS_CATCH(cv_return_value_unsigned_char_X)
}

// cv_Mat_ptr_const_int_i0_int_i1_int_i2
// parsed: cv::Mat::ptr
// as:     cv::Mat::ptr (method) cv::Mat . ptr
// Arg ARG Primitive(int) i0= Primitive(int) = 
// Arg ARG Primitive(int) i1= Primitive(int) = 
// Arg ARG Primitive(int) i2= Primitive(int) = 
// Return value: RawPtr[Primitive(uchar)]
cv_return_value_const_unsigned_char_X cv_core_cv_Mat_ptr_const_int_i0_int_i1_int_i2(void* instance, int i0, int i1, int i2) {
    try {
        const uchar* ret = reinterpret_cast<cv::Mat*>(instance)->ptr(i0, i1, i2);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<const uchar**>(&ret) };
    } CVRS_CATCH(cv_return_value_const_unsigned_char_X)
}

// cv_Mat_ptr_const_int_X_idx
// parsed: cv::Mat::ptr
// as:     cv::Mat::ptr (method) cv::Mat . ptr
// Arg ARG RawPtr[Primitive(int)] * idx= (ptr) RawPtr[Primitive(int)] = 
// Return value: RawPtr[Primitive(uchar)]
cv_return_value_unsigned_char_X cv_core_cv_Mat_ptr_const_int_X_idx(void* instance, const int* idx) {
    try {
        uchar* ret = reinterpret_cast<cv::Mat*>(instance)->ptr(idx);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<uchar**>(&ret) };
    } CVRS_CATCH(cv_return_value_unsigned_char_X)
}

// cv_Mat_ptr_const_const_int_X_idx
// parsed: cv::Mat::ptr
// as:     cv::Mat::ptr (method) cv::Mat . ptr
// Arg ARG RawPtr[Primitive(int)] * idx= (ptr) RawPtr[Primitive(int)] = 
// Return value: RawPtr[Primitive(uchar)]
cv_return_value_const_unsigned_char_X cv_core_cv_Mat_ptr_const_const_int_X_idx(void* instance, const int* idx) {
    try {
        const uchar* ret = reinterpret_cast<cv::Mat*>(instance)->ptr(idx);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<const uchar**>(&ret) };
    } CVRS_CATCH(cv_return_value_const_unsigned_char_X)
}

// cv_Mat_updateContinuityFlag
// parsed: cv::Mat::updateContinuityFlag
// as:     cv::Mat::updateContinuityFlag (method) cv::Mat . updateContinuityFlag
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_Mat_updateContinuityFlag(void* instance) {
    try {
        reinterpret_cast<cv::Mat*>(instance)->updateContinuityFlag();
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_Mat_size_const
// parsed: cv::Mat::size
// as:     cv::Mat::size (method) cv::Mat . size
// Return value: cv::Size (simple)
cv_return_value_SizeWrapper cv_core_cv_Mat_size_const(void* instance) {
    try {
        cv::Size ret = reinterpret_cast<cv::Mat*>(instance)->size();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<SizeWrapper*>(&ret) };
    } CVRS_CATCH(cv_return_value_SizeWrapper)
}

// boxed class: cv::MatExpr
void cv_delete_MatExpr(void* instance) {
    delete (cv::MatExpr*) instance;
}
// cv_MatExpr_size_const
// parsed: cv::MatExpr::size
// as:     cv::MatExpr::size (method) cv::MatExpr . size
// Return value: cv::Size (simple)
cv_return_value_SizeWrapper cv_core_cv_MatExpr_size_const(void* instance) {
    try {
        cv::Size ret = reinterpret_cast<cv::MatExpr*>(instance)->size();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<SizeWrapper*>(&ret) };
    } CVRS_CATCH(cv_return_value_SizeWrapper)
}

// cv_MatExpr_type_const
// parsed: cv::MatExpr::type
// as:     cv::MatExpr::type (method) cv::MatExpr . type
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_MatExpr_type_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::MatExpr*>(instance)->type();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_MatExpr_cross_const_Mat_m
// parsed: cv::MatExpr::cross
// as:     cv::MatExpr::cross (method) cv::MatExpr . cross
// Arg ARG cv::Mat (boxed) m= cv::Mat (boxed) = 
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_MatExpr_cross_const_Mat_m(void* instance, void* m) {
    try {
        cv::Mat ret = reinterpret_cast<cv::MatExpr*>(instance)->cross(*reinterpret_cast<cv::Mat*>(m));
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_MatExpr_dot_const_Mat_m
// parsed: cv::MatExpr::dot
// as:     cv::MatExpr::dot (method) cv::MatExpr . dot
// Arg ARG cv::Mat (boxed) m= cv::Mat (boxed) = 
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_MatExpr_dot_const_Mat_m(void* instance, void* m) {
    try {
        double ret = reinterpret_cast<cv::MatExpr*>(instance)->dot(*reinterpret_cast<cv::Mat*>(m));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// boxed class: cv::MatSize
void cv_delete_MatSize(void* instance) {
    delete (cv::MatSize*) instance;
}
// cv_MatSize_MatSize_int_X__p
// parsed: cv::MatSize::MatSize
// as:     cv::MatSize::MatSize (constructor) cv::MatSize . new
// Arg ARG RawPtr[Primitive(int)] * _p= (ptr) RawPtr[Primitive(int)] = 
// Return value: cv::MatSize (boxed)
cv_return_value_void_X cv_core_cv_MatSize_MatSize_int_X__p(int* _p) {
    try {
        cv::MatSize* ret = new cv::MatSize(_p);
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_MatSize_dims_const
// parsed: cv::MatSize::dims
// as:     cv::MatSize::dims (method) cv::MatSize . dims
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_MatSize_dims_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::MatSize*>(instance)->dims();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// boxed class: cv::MatStep
void cv_delete_MatStep(void* instance) {
    delete (cv::MatStep*) instance;
}
// cv_MatStep_MatStep
// parsed: cv::MatStep::MatStep
// as:     cv::MatStep::MatStep (constructor) cv::MatStep . new
// Return value: cv::MatStep (boxed)
cv_return_value_void_X cv_core_cv_MatStep_MatStep() {
    try {
        cv::MatStep* ret = new cv::MatStep();
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_MatStep_MatStep_size_t_s
// parsed: cv::MatStep::MatStep
// as:     cv::MatStep::MatStep (constructor) cv::MatStep . new
// Arg ARG Primitive(size_t) s= Primitive(size_t) = 
// Return value: cv::MatStep (boxed)
cv_return_value_void_X cv_core_cv_MatStep_MatStep_size_t_s(std::size_t s) {
    try {
        cv::MatStep* ret = new cv::MatStep(s);
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// boxed class: cv::Matx_AddOp
void cv_delete_Matx_AddOp(void* instance) {
    delete (cv::Matx_AddOp*) instance;
}
// cv_Matx_AddOp_Matx_AddOp
// parsed: cv::Matx_AddOp::Matx_AddOp
// as:     cv::Matx_AddOp::Matx_AddOp (constructor) cv::Matx_AddOp . new
// Return value: cv::Matx_AddOp (boxed)
cv_return_value_void_X cv_core_cv_Matx_AddOp_Matx_AddOp() {
    try {
        cv::Matx_AddOp* ret = new cv::Matx_AddOp();
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_Matx_AddOp_Matx_AddOp_Matx_AddOp_unnamed_arg
// parsed: cv::Matx_AddOp::Matx_AddOp
// as:     cv::Matx_AddOp::Matx_AddOp (constructor) cv::Matx_AddOp . new
// Arg ARG cv::Matx_AddOp (boxed) unnamed_arg= cv::Matx_AddOp (boxed) = 
// Return value: cv::Matx_AddOp (boxed)
cv_return_value_void_X cv_core_cv_Matx_AddOp_Matx_AddOp_Matx_AddOp_unnamed_arg(void* unnamed_arg) {
    try {
        cv::Matx_AddOp* ret = new cv::Matx_AddOp(*reinterpret_cast<cv::Matx_AddOp*>(unnamed_arg));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// boxed class: cv::Matx_DivOp
void cv_delete_Matx_DivOp(void* instance) {
    delete (cv::Matx_DivOp*) instance;
}
// cv_Matx_DivOp_Matx_DivOp
// parsed: cv::Matx_DivOp::Matx_DivOp
// as:     cv::Matx_DivOp::Matx_DivOp (constructor) cv::Matx_DivOp . new
// Return value: cv::Matx_DivOp (boxed)
cv_return_value_void_X cv_core_cv_Matx_DivOp_Matx_DivOp() {
    try {
        cv::Matx_DivOp* ret = new cv::Matx_DivOp();
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_Matx_DivOp_Matx_DivOp_Matx_DivOp_unnamed_arg
// parsed: cv::Matx_DivOp::Matx_DivOp
// as:     cv::Matx_DivOp::Matx_DivOp (constructor) cv::Matx_DivOp . new
// Arg ARG cv::Matx_DivOp (boxed) unnamed_arg= cv::Matx_DivOp (boxed) = 
// Return value: cv::Matx_DivOp (boxed)
cv_return_value_void_X cv_core_cv_Matx_DivOp_Matx_DivOp_Matx_DivOp_unnamed_arg(void* unnamed_arg) {
    try {
        cv::Matx_DivOp* ret = new cv::Matx_DivOp(*reinterpret_cast<cv::Matx_DivOp*>(unnamed_arg));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// boxed class: cv::Matx_MatMulOp
void cv_delete_Matx_MatMulOp(void* instance) {
    delete (cv::Matx_MatMulOp*) instance;
}
// cv_Matx_MatMulOp_Matx_MatMulOp
// parsed: cv::Matx_MatMulOp::Matx_MatMulOp
// as:     cv::Matx_MatMulOp::Matx_MatMulOp (constructor) cv::Matx_MatMulOp . new
// Return value: cv::Matx_MatMulOp (boxed)
cv_return_value_void_X cv_core_cv_Matx_MatMulOp_Matx_MatMulOp() {
    try {
        cv::Matx_MatMulOp* ret = new cv::Matx_MatMulOp();
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_Matx_MatMulOp_Matx_MatMulOp_Matx_MatMulOp_unnamed_arg
// parsed: cv::Matx_MatMulOp::Matx_MatMulOp
// as:     cv::Matx_MatMulOp::Matx_MatMulOp (constructor) cv::Matx_MatMulOp . new
// Arg ARG cv::Matx_MatMulOp (boxed) unnamed_arg= cv::Matx_MatMulOp (boxed) = 
// Return value: cv::Matx_MatMulOp (boxed)
cv_return_value_void_X cv_core_cv_Matx_MatMulOp_Matx_MatMulOp_Matx_MatMulOp_unnamed_arg(void* unnamed_arg) {
    try {
        cv::Matx_MatMulOp* ret = new cv::Matx_MatMulOp(*reinterpret_cast<cv::Matx_MatMulOp*>(unnamed_arg));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// boxed class: cv::Matx_MulOp
void cv_delete_Matx_MulOp(void* instance) {
    delete (cv::Matx_MulOp*) instance;
}
// cv_Matx_MulOp_Matx_MulOp
// parsed: cv::Matx_MulOp::Matx_MulOp
// as:     cv::Matx_MulOp::Matx_MulOp (constructor) cv::Matx_MulOp . new
// Return value: cv::Matx_MulOp (boxed)
cv_return_value_void_X cv_core_cv_Matx_MulOp_Matx_MulOp() {
    try {
        cv::Matx_MulOp* ret = new cv::Matx_MulOp();
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_Matx_MulOp_Matx_MulOp_Matx_MulOp_unnamed_arg
// parsed: cv::Matx_MulOp::Matx_MulOp
// as:     cv::Matx_MulOp::Matx_MulOp (constructor) cv::Matx_MulOp . new
// Arg ARG cv::Matx_MulOp (boxed) unnamed_arg= cv::Matx_MulOp (boxed) = 
// Return value: cv::Matx_MulOp (boxed)
cv_return_value_void_X cv_core_cv_Matx_MulOp_Matx_MulOp_Matx_MulOp_unnamed_arg(void* unnamed_arg) {
    try {
        cv::Matx_MulOp* ret = new cv::Matx_MulOp(*reinterpret_cast<cv::Matx_MulOp*>(unnamed_arg));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// boxed class: cv::Matx_ScaleOp
void cv_delete_Matx_ScaleOp(void* instance) {
    delete (cv::Matx_ScaleOp*) instance;
}
// cv_Matx_ScaleOp_Matx_ScaleOp
// parsed: cv::Matx_ScaleOp::Matx_ScaleOp
// as:     cv::Matx_ScaleOp::Matx_ScaleOp (constructor) cv::Matx_ScaleOp . new
// Return value: cv::Matx_ScaleOp (boxed)
cv_return_value_void_X cv_core_cv_Matx_ScaleOp_Matx_ScaleOp() {
    try {
        cv::Matx_ScaleOp* ret = new cv::Matx_ScaleOp();
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_Matx_ScaleOp_Matx_ScaleOp_Matx_ScaleOp_unnamed_arg
// parsed: cv::Matx_ScaleOp::Matx_ScaleOp
// as:     cv::Matx_ScaleOp::Matx_ScaleOp (constructor) cv::Matx_ScaleOp . new
// Arg ARG cv::Matx_ScaleOp (boxed) unnamed_arg= cv::Matx_ScaleOp (boxed) = 
// Return value: cv::Matx_ScaleOp (boxed)
cv_return_value_void_X cv_core_cv_Matx_ScaleOp_Matx_ScaleOp_Matx_ScaleOp_unnamed_arg(void* unnamed_arg) {
    try {
        cv::Matx_ScaleOp* ret = new cv::Matx_ScaleOp(*reinterpret_cast<cv::Matx_ScaleOp*>(unnamed_arg));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// boxed class: cv::Matx_SubOp
void cv_delete_Matx_SubOp(void* instance) {
    delete (cv::Matx_SubOp*) instance;
}
// cv_Matx_SubOp_Matx_SubOp
// parsed: cv::Matx_SubOp::Matx_SubOp
// as:     cv::Matx_SubOp::Matx_SubOp (constructor) cv::Matx_SubOp . new
// Return value: cv::Matx_SubOp (boxed)
cv_return_value_void_X cv_core_cv_Matx_SubOp_Matx_SubOp() {
    try {
        cv::Matx_SubOp* ret = new cv::Matx_SubOp();
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_Matx_SubOp_Matx_SubOp_Matx_SubOp_unnamed_arg
// parsed: cv::Matx_SubOp::Matx_SubOp
// as:     cv::Matx_SubOp::Matx_SubOp (constructor) cv::Matx_SubOp . new
// Arg ARG cv::Matx_SubOp (boxed) unnamed_arg= cv::Matx_SubOp (boxed) = 
// Return value: cv::Matx_SubOp (boxed)
cv_return_value_void_X cv_core_cv_Matx_SubOp_Matx_SubOp_Matx_SubOp_unnamed_arg(void* unnamed_arg) {
    try {
        cv::Matx_SubOp* ret = new cv::Matx_SubOp(*reinterpret_cast<cv::Matx_SubOp*>(unnamed_arg));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// boxed class: cv::Matx_TOp
void cv_delete_Matx_TOp(void* instance) {
    delete (cv::Matx_TOp*) instance;
}
// cv_Matx_TOp_Matx_TOp
// parsed: cv::Matx_TOp::Matx_TOp
// as:     cv::Matx_TOp::Matx_TOp (constructor) cv::Matx_TOp . new
// Return value: cv::Matx_TOp (boxed)
cv_return_value_void_X cv_core_cv_Matx_TOp_Matx_TOp() {
    try {
        cv::Matx_TOp* ret = new cv::Matx_TOp();
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_Matx_TOp_Matx_TOp_Matx_TOp_unnamed_arg
// parsed: cv::Matx_TOp::Matx_TOp
// as:     cv::Matx_TOp::Matx_TOp (constructor) cv::Matx_TOp . new
// Arg ARG cv::Matx_TOp (boxed) unnamed_arg= cv::Matx_TOp (boxed) = 
// Return value: cv::Matx_TOp (boxed)
cv_return_value_void_X cv_core_cv_Matx_TOp_Matx_TOp_Matx_TOp_unnamed_arg(void* unnamed_arg) {
    try {
        cv::Matx_TOp* ret = new cv::Matx_TOp(*reinterpret_cast<cv::Matx_TOp*>(unnamed_arg));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// boxed class: cv::MercatorWarper
void cv_delete_MercatorWarper(void* instance) {
    delete (cv::MercatorWarper*) instance;
}
// cv_MergeDebevec_process_VectorOfMat_src_Mat_dst_Mat_times_Mat_response
// parsed: cv::MergeDebevec::process
// as:     cv::MergeDebevec::process (method) cv::MergeDebevec (trait) . process
// Arg ARG Vector[cv::Mat (boxed)] src= Vector[cv::Mat (boxed)] = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) times= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) response= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_MergeDebevec_process_VectorOfMat_src_Mat_dst_Mat_times_Mat_response(void* instance, void* src, void* dst, void* times, void* response) {
    try {
        reinterpret_cast<cv::MergeDebevec*>(instance)->process(*reinterpret_cast<std::vector<cv::Mat>*>(src), *reinterpret_cast<cv::Mat*>(dst), *reinterpret_cast<cv::Mat*>(times), *reinterpret_cast<cv::Mat*>(response));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_MergeDebevec_process_VectorOfMat_src_Mat_dst_Mat_times
// parsed: cv::MergeDebevec::process
// as:     cv::MergeDebevec::process (method) cv::MergeDebevec (trait) . process
// Arg ARG Vector[cv::Mat (boxed)] src= Vector[cv::Mat (boxed)] = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) times= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_MergeDebevec_process_VectorOfMat_src_Mat_dst_Mat_times(void* instance, void* src, void* dst, void* times) {
    try {
        reinterpret_cast<cv::MergeDebevec*>(instance)->process(*reinterpret_cast<std::vector<cv::Mat>*>(src), *reinterpret_cast<cv::Mat*>(dst), *reinterpret_cast<cv::Mat*>(times));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_MergeExposures_process_VectorOfMat_src_Mat_dst_Mat_times_Mat_response
// parsed: cv::MergeExposures::process
// as:     cv::MergeExposures::process (method) cv::MergeExposures (trait) . process
// Arg ARG Vector[cv::Mat (boxed)] src= Vector[cv::Mat (boxed)] = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) times= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) response= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_MergeExposures_process_VectorOfMat_src_Mat_dst_Mat_times_Mat_response(void* instance, void* src, void* dst, void* times, void* response) {
    try {
        reinterpret_cast<cv::MergeExposures*>(instance)->process(*reinterpret_cast<std::vector<cv::Mat>*>(src), *reinterpret_cast<cv::Mat*>(dst), *reinterpret_cast<cv::Mat*>(times), *reinterpret_cast<cv::Mat*>(response));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_MergeMertens_process_VectorOfMat_src_Mat_dst_Mat_times_Mat_response
// parsed: cv::MergeMertens::process
// as:     cv::MergeMertens::process (method) cv::MergeMertens (trait) . process
// Arg ARG Vector[cv::Mat (boxed)] src= Vector[cv::Mat (boxed)] = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) times= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) response= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_MergeMertens_process_VectorOfMat_src_Mat_dst_Mat_times_Mat_response(void* instance, void* src, void* dst, void* times, void* response) {
    try {
        reinterpret_cast<cv::MergeMertens*>(instance)->process(*reinterpret_cast<std::vector<cv::Mat>*>(src), *reinterpret_cast<cv::Mat*>(dst), *reinterpret_cast<cv::Mat*>(times), *reinterpret_cast<cv::Mat*>(response));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_MergeMertens_process_VectorOfMat_src_Mat_dst
// parsed: cv::MergeMertens::process
// as:     cv::MergeMertens::process (method) cv::MergeMertens (trait) . process
// Arg ARG Vector[cv::Mat (boxed)] src= Vector[cv::Mat (boxed)] = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_MergeMertens_process_VectorOfMat_src_Mat_dst(void* instance, void* src, void* dst) {
    try {
        reinterpret_cast<cv::MergeMertens*>(instance)->process(*reinterpret_cast<std::vector<cv::Mat>*>(src), *reinterpret_cast<cv::Mat*>(dst));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_MergeMertens_getContrastWeight_const
// parsed: cv::MergeMertens::getContrastWeight
// as:     cv::MergeMertens::getContrastWeight (method) cv::MergeMertens (trait) . getContrastWeight
// Return value: Primitive(float)
cv_return_value_float cv_core_cv_MergeMertens_getContrastWeight_const(void* instance) {
    try {
        float ret = reinterpret_cast<cv::MergeMertens*>(instance)->getContrastWeight();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<float*>(&ret) };
    } CVRS_CATCH(cv_return_value_float)
}

// cv_MergeMertens_setContrastWeight_float_contrast_weiht
// parsed: cv::MergeMertens::setContrastWeight
// as:     cv::MergeMertens::setContrastWeight (method) cv::MergeMertens (trait) . setContrastWeight
// Arg ARG Primitive(float) contrast_weiht= Primitive(float) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_MergeMertens_setContrastWeight_float_contrast_weiht(void* instance, float contrast_weiht) {
    try {
        reinterpret_cast<cv::MergeMertens*>(instance)->setContrastWeight(contrast_weiht);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_MergeMertens_getSaturationWeight_const
// parsed: cv::MergeMertens::getSaturationWeight
// as:     cv::MergeMertens::getSaturationWeight (method) cv::MergeMertens (trait) . getSaturationWeight
// Return value: Primitive(float)
cv_return_value_float cv_core_cv_MergeMertens_getSaturationWeight_const(void* instance) {
    try {
        float ret = reinterpret_cast<cv::MergeMertens*>(instance)->getSaturationWeight();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<float*>(&ret) };
    } CVRS_CATCH(cv_return_value_float)
}

// cv_MergeMertens_setSaturationWeight_float_saturation_weight
// parsed: cv::MergeMertens::setSaturationWeight
// as:     cv::MergeMertens::setSaturationWeight (method) cv::MergeMertens (trait) . setSaturationWeight
// Arg ARG Primitive(float) saturation_weight= Primitive(float) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_MergeMertens_setSaturationWeight_float_saturation_weight(void* instance, float saturation_weight) {
    try {
        reinterpret_cast<cv::MergeMertens*>(instance)->setSaturationWeight(saturation_weight);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_MergeMertens_getExposureWeight_const
// parsed: cv::MergeMertens::getExposureWeight
// as:     cv::MergeMertens::getExposureWeight (method) cv::MergeMertens (trait) . getExposureWeight
// Return value: Primitive(float)
cv_return_value_float cv_core_cv_MergeMertens_getExposureWeight_const(void* instance) {
    try {
        float ret = reinterpret_cast<cv::MergeMertens*>(instance)->getExposureWeight();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<float*>(&ret) };
    } CVRS_CATCH(cv_return_value_float)
}

// cv_MergeMertens_setExposureWeight_float_exposure_weight
// parsed: cv::MergeMertens::setExposureWeight
// as:     cv::MergeMertens::setExposureWeight (method) cv::MergeMertens (trait) . setExposureWeight
// Arg ARG Primitive(float) exposure_weight= Primitive(float) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_MergeMertens_setExposureWeight_float_exposure_weight(void* instance, float exposure_weight) {
    try {
        reinterpret_cast<cv::MergeMertens*>(instance)->setExposureWeight(exposure_weight);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_MergeRobertson_process_VectorOfMat_src_Mat_dst_Mat_times_Mat_response
// parsed: cv::MergeRobertson::process
// as:     cv::MergeRobertson::process (method) cv::MergeRobertson (trait) . process
// Arg ARG Vector[cv::Mat (boxed)] src= Vector[cv::Mat (boxed)] = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) times= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) response= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_MergeRobertson_process_VectorOfMat_src_Mat_dst_Mat_times_Mat_response(void* instance, void* src, void* dst, void* times, void* response) {
    try {
        reinterpret_cast<cv::MergeRobertson*>(instance)->process(*reinterpret_cast<std::vector<cv::Mat>*>(src), *reinterpret_cast<cv::Mat*>(dst), *reinterpret_cast<cv::Mat*>(times), *reinterpret_cast<cv::Mat*>(response));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_MergeRobertson_process_VectorOfMat_src_Mat_dst_Mat_times
// parsed: cv::MergeRobertson::process
// as:     cv::MergeRobertson::process (method) cv::MergeRobertson (trait) . process
// Arg ARG Vector[cv::Mat (boxed)] src= Vector[cv::Mat (boxed)] = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) times= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_MergeRobertson_process_VectorOfMat_src_Mat_dst_Mat_times(void* instance, void* src, void* dst, void* times) {
    try {
        reinterpret_cast<cv::MergeRobertson*>(instance)->process(*reinterpret_cast<std::vector<cv::Mat>*>(src), *reinterpret_cast<cv::Mat*>(dst), *reinterpret_cast<cv::Mat*>(times));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_MinProblemSolver_getFunction_const
// parsed: cv::MinProblemSolver::getFunction
// as:     cv::MinProblemSolver::getFunction (method) cv::MinProblemSolver (trait) . getFunction
// Return value: SmartPtr[cv::MinProblemSolver::Function (boxed)]
cv_return_value_void_X cv_core_cv_MinProblemSolver_getFunction_const(void* instance) {
    try {
        Ptr<cv::MinProblemSolver::Function> *ret = new Ptr<cv::MinProblemSolver::Function>(reinterpret_cast<cv::MinProblemSolver*>(instance)->getFunction());
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_MinProblemSolver_setFunction_PtrOfFunction_f
// parsed: cv::MinProblemSolver::setFunction
// as:     cv::MinProblemSolver::setFunction (method) cv::MinProblemSolver (trait) . setFunction
// Arg ARG SmartPtr[cv::MinProblemSolver::Function (boxed)] f= SmartPtr[cv::MinProblemSolver::Function (boxed)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_MinProblemSolver_setFunction_PtrOfFunction_f(void* instance, void* f) {
    try {
        reinterpret_cast<cv::MinProblemSolver*>(instance)->setFunction(reinterpret_cast<cv::MinProblemSolver::Function*>(f));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_MinProblemSolver_getTermCriteria_const
// parsed: cv::MinProblemSolver::getTermCriteria
// as:     cv::MinProblemSolver::getTermCriteria (method) cv::MinProblemSolver (trait) . getTermCriteria
// Return value: cv::TermCriteria (boxed)
cv_return_value_void_X cv_core_cv_MinProblemSolver_getTermCriteria_const(void* instance) {
    try {
        cv::TermCriteria ret = reinterpret_cast<cv::MinProblemSolver*>(instance)->getTermCriteria();
        return { Error::Code::StsOk, NULL, new cv::TermCriteria(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_MinProblemSolver_setTermCriteria_TermCriteria_termcrit
// parsed: cv::MinProblemSolver::setTermCriteria
// as:     cv::MinProblemSolver::setTermCriteria (method) cv::MinProblemSolver (trait) . setTermCriteria
// Arg ARG cv::TermCriteria (boxed) termcrit= cv::TermCriteria (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_MinProblemSolver_setTermCriteria_TermCriteria_termcrit(void* instance, void* termcrit) {
    try {
        reinterpret_cast<cv::MinProblemSolver*>(instance)->setTermCriteria(*reinterpret_cast<cv::TermCriteria*>(termcrit));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_MinProblemSolver_minimize_Mat_x
// parsed: cv::MinProblemSolver::minimize
// as:     cv::MinProblemSolver::minimize (method) cv::MinProblemSolver (trait) . minimize
// Arg ARG cv::Mat (boxed) x= cv::Mat (boxed) = 
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_MinProblemSolver_minimize_Mat_x(void* instance, void* x) {
    try {
        double ret = reinterpret_cast<cv::MinProblemSolver*>(instance)->minimize(*reinterpret_cast<cv::Mat*>(x));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_MinProblemSolver_Function_getDims_const
// parsed: cv::MinProblemSolver::Function::getDims
// as:     cv::MinProblemSolver::Function::getDims (method) cv::MinProblemSolver::Function (trait) . getDims
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_MinProblemSolver_Function_getDims_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::MinProblemSolver::Function*>(instance)->getDims();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_MinProblemSolver_Function_getGradientEps_const
// parsed: cv::MinProblemSolver::Function::getGradientEps
// as:     cv::MinProblemSolver::Function::getGradientEps (method) cv::MinProblemSolver::Function (trait) . getGradientEps
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_MinProblemSolver_Function_getGradientEps_const(void* instance) {
    try {
        double ret = reinterpret_cast<cv::MinProblemSolver::Function*>(instance)->getGradientEps();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_MinProblemSolver_Function_calc_const_const_double_X_x
// parsed: cv::MinProblemSolver::Function::calc
// as:     cv::MinProblemSolver::Function::calc (method) cv::MinProblemSolver::Function (trait) . calc
// Arg ARG RawPtr[Primitive(double)] * x= (ptr) RawPtr[Primitive(double)] = 
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_MinProblemSolver_Function_calc_const_const_double_X_x(void* instance, const double* x) {
    try {
        double ret = reinterpret_cast<cv::MinProblemSolver::Function*>(instance)->calc(x);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_MinProblemSolver_Function_getGradient_const_double_X_x_double_X_grad
// parsed: cv::MinProblemSolver::Function::getGradient
// as:     cv::MinProblemSolver::Function::getGradient (method) cv::MinProblemSolver::Function (trait) . getGradient
// Arg ARG RawPtr[Primitive(double)] * x= (ptr) RawPtr[Primitive(double)] = 
// Arg ARG RawPtr[Primitive(double)] * grad= (ptr) RawPtr[Primitive(double)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_MinProblemSolver_Function_getGradient_const_double_X_x_double_X_grad(void* instance, const double* x, double* grad) {
    try {
        reinterpret_cast<cv::MinProblemSolver::Function*>(instance)->getGradient(x, grad);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_Moments_Moments
// parsed: cv::Moments::Moments
// as:     cv::Moments::Moments (constructor) cv::Moments (simple) . new
// Return value: cv::Moments (simple)
cv_return_value_Moments cv_core_cv_Moments_Moments() {
    try {
        cv::Moments ret;
        return { Error::Code::StsOk, NULL, *reinterpret_cast<cv::Moments*>(&ret) };
    } CVRS_CATCH(cv_return_value_Moments)
}

// cv_Moments_Moments_double_m00_double_m10_double_m01_double_m20_double_m11_double_m02_double_m30_double_m21_double_m12_double_m03
// parsed: cv::Moments::Moments
// as:     cv::Moments::Moments (constructor) cv::Moments (simple) . new
// Arg ARG Primitive(double) m00= Primitive(double) = 
// Arg ARG Primitive(double) m10= Primitive(double) = 
// Arg ARG Primitive(double) m01= Primitive(double) = 
// Arg ARG Primitive(double) m20= Primitive(double) = 
// Arg ARG Primitive(double) m11= Primitive(double) = 
// Arg ARG Primitive(double) m02= Primitive(double) = 
// Arg ARG Primitive(double) m30= Primitive(double) = 
// Arg ARG Primitive(double) m21= Primitive(double) = 
// Arg ARG Primitive(double) m12= Primitive(double) = 
// Arg ARG Primitive(double) m03= Primitive(double) = 
// Return value: cv::Moments (simple)
cv_return_value_Moments cv_core_cv_Moments_Moments_double_m00_double_m10_double_m01_double_m20_double_m11_double_m02_double_m30_double_m21_double_m12_double_m03(double m00, double m10, double m01, double m20, double m11, double m02, double m30, double m21, double m12, double m03) {
    try {
        cv::Moments ret(m00, m10, m01, m20, m11, m02, m30, m21, m12, m03);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<cv::Moments*>(&ret) };
    } CVRS_CATCH(cv_return_value_Moments)
}

// boxed class: cv::Mutex
void cv_delete_Mutex(void* instance) {
    delete (cv::Mutex*) instance;
}
// cv_Mutex_Mutex
// parsed: cv::Mutex::Mutex
// as:     cv::Mutex::Mutex (constructor) cv::Mutex . new
// Return value: cv::Mutex (boxed)
cv_return_value_void_X cv_core_cv_Mutex_Mutex() {
    try {
        cv::Mutex* ret = new cv::Mutex();
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_Mutex_Mutex_Mutex_m
// parsed: cv::Mutex::Mutex
// as:     cv::Mutex::Mutex (constructor) cv::Mutex . new
// Arg ARG cv::Mutex (boxed) m= cv::Mutex (boxed) = 
// Return value: cv::Mutex (boxed)
cv_return_value_void_X cv_core_cv_Mutex_Mutex_Mutex_m(void* m) {
    try {
        cv::Mutex* ret = new cv::Mutex(*reinterpret_cast<cv::Mutex*>(m));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_Mutex_lock
// parsed: cv::Mutex::lock
// as:     cv::Mutex::lock (method) cv::Mutex . lock
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_Mutex_lock(void* instance) {
    try {
        reinterpret_cast<cv::Mutex*>(instance)->lock();
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_Mutex_trylock
// parsed: cv::Mutex::trylock
// as:     cv::Mutex::trylock (method) cv::Mutex . trylock
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_Mutex_trylock(void* instance) {
    try {
        bool ret = reinterpret_cast<cv::Mutex*>(instance)->trylock();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_Mutex_unlock
// parsed: cv::Mutex::unlock
// as:     cv::Mutex::unlock (method) cv::Mutex . unlock
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_Mutex_unlock(void* instance) {
    try {
        reinterpret_cast<cv::Mutex*>(instance)->unlock();
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// boxed class: cv::NAryMatIterator
void cv_delete_NAryMatIterator(void* instance) {
    delete (cv::NAryMatIterator*) instance;
}
// cv_NAryMatIterator_NAryMatIterator
// parsed: cv::NAryMatIterator::NAryMatIterator
// as:     cv::NAryMatIterator::NAryMatIterator (constructor) cv::NAryMatIterator . new
// Return value: cv::NAryMatIterator (boxed)
cv_return_value_void_X cv_core_cv_NAryMatIterator_NAryMatIterator() {
    try {
        cv::NAryMatIterator* ret = new cv::NAryMatIterator();
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_NormHistogramCostExtractor_setNormFlag_int_flag
// parsed: cv::NormHistogramCostExtractor::setNormFlag
// as:     cv::NormHistogramCostExtractor::setNormFlag (method) cv::NormHistogramCostExtractor (trait) . setNormFlag
// Arg ARG Primitive(int) flag= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_NormHistogramCostExtractor_setNormFlag_int_flag(void* instance, int flag) {
    try {
        reinterpret_cast<cv::NormHistogramCostExtractor*>(instance)->setNormFlag(flag);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_NormHistogramCostExtractor_getNormFlag_const
// parsed: cv::NormHistogramCostExtractor::getNormFlag
// as:     cv::NormHistogramCostExtractor::getNormFlag (method) cv::NormHistogramCostExtractor (trait) . getNormFlag
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_NormHistogramCostExtractor_getNormFlag_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::NormHistogramCostExtractor*>(instance)->getNormFlag();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_ORB_setMaxFeatures_int_maxFeatures
// parsed: cv::ORB::setMaxFeatures
// as:     cv::ORB::setMaxFeatures (method) cv::ORB (trait) . setMaxFeatures
// Arg ARG Primitive(int) maxFeatures= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ORB_setMaxFeatures_int_maxFeatures(void* instance, int maxFeatures) {
    try {
        reinterpret_cast<cv::ORB*>(instance)->setMaxFeatures(maxFeatures);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ORB_getMaxFeatures_const
// parsed: cv::ORB::getMaxFeatures
// as:     cv::ORB::getMaxFeatures (method) cv::ORB (trait) . getMaxFeatures
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_ORB_getMaxFeatures_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::ORB*>(instance)->getMaxFeatures();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_ORB_setScaleFactor_double_scaleFactor
// parsed: cv::ORB::setScaleFactor
// as:     cv::ORB::setScaleFactor (method) cv::ORB (trait) . setScaleFactor
// Arg ARG Primitive(double) scaleFactor= Primitive(double) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ORB_setScaleFactor_double_scaleFactor(void* instance, double scaleFactor) {
    try {
        reinterpret_cast<cv::ORB*>(instance)->setScaleFactor(scaleFactor);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ORB_getScaleFactor_const
// parsed: cv::ORB::getScaleFactor
// as:     cv::ORB::getScaleFactor (method) cv::ORB (trait) . getScaleFactor
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_ORB_getScaleFactor_const(void* instance) {
    try {
        double ret = reinterpret_cast<cv::ORB*>(instance)->getScaleFactor();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_ORB_setNLevels_int_nlevels
// parsed: cv::ORB::setNLevels
// as:     cv::ORB::setNLevels (method) cv::ORB (trait) . setNLevels
// Arg ARG Primitive(int) nlevels= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ORB_setNLevels_int_nlevels(void* instance, int nlevels) {
    try {
        reinterpret_cast<cv::ORB*>(instance)->setNLevels(nlevels);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ORB_getNLevels_const
// parsed: cv::ORB::getNLevels
// as:     cv::ORB::getNLevels (method) cv::ORB (trait) . getNLevels
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_ORB_getNLevels_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::ORB*>(instance)->getNLevels();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_ORB_setEdgeThreshold_int_edgeThreshold
// parsed: cv::ORB::setEdgeThreshold
// as:     cv::ORB::setEdgeThreshold (method) cv::ORB (trait) . setEdgeThreshold
// Arg ARG Primitive(int) edgeThreshold= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ORB_setEdgeThreshold_int_edgeThreshold(void* instance, int edgeThreshold) {
    try {
        reinterpret_cast<cv::ORB*>(instance)->setEdgeThreshold(edgeThreshold);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ORB_getEdgeThreshold_const
// parsed: cv::ORB::getEdgeThreshold
// as:     cv::ORB::getEdgeThreshold (method) cv::ORB (trait) . getEdgeThreshold
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_ORB_getEdgeThreshold_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::ORB*>(instance)->getEdgeThreshold();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_ORB_setFirstLevel_int_firstLevel
// parsed: cv::ORB::setFirstLevel
// as:     cv::ORB::setFirstLevel (method) cv::ORB (trait) . setFirstLevel
// Arg ARG Primitive(int) firstLevel= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ORB_setFirstLevel_int_firstLevel(void* instance, int firstLevel) {
    try {
        reinterpret_cast<cv::ORB*>(instance)->setFirstLevel(firstLevel);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ORB_getFirstLevel_const
// parsed: cv::ORB::getFirstLevel
// as:     cv::ORB::getFirstLevel (method) cv::ORB (trait) . getFirstLevel
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_ORB_getFirstLevel_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::ORB*>(instance)->getFirstLevel();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_ORB_setWTA_K_int_wta_k
// parsed: cv::ORB::setWTA_K
// as:     cv::ORB::setWTA_K (method) cv::ORB (trait) . setWTA_K
// Arg ARG Primitive(int) wta_k= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ORB_setWTA_K_int_wta_k(void* instance, int wta_k) {
    try {
        reinterpret_cast<cv::ORB*>(instance)->setWTA_K(wta_k);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ORB_getWTA_K_const
// parsed: cv::ORB::getWTA_K
// as:     cv::ORB::getWTA_K (method) cv::ORB (trait) . getWTA_K
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_ORB_getWTA_K_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::ORB*>(instance)->getWTA_K();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_ORB_setScoreType_int_scoreType
// parsed: cv::ORB::setScoreType
// as:     cv::ORB::setScoreType (method) cv::ORB (trait) . setScoreType
// Arg ARG Primitive(int) scoreType= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ORB_setScoreType_int_scoreType(void* instance, int scoreType) {
    try {
        reinterpret_cast<cv::ORB*>(instance)->setScoreType(scoreType);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ORB_getScoreType_const
// parsed: cv::ORB::getScoreType
// as:     cv::ORB::getScoreType (method) cv::ORB (trait) . getScoreType
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_ORB_getScoreType_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::ORB*>(instance)->getScoreType();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_ORB_setPatchSize_int_patchSize
// parsed: cv::ORB::setPatchSize
// as:     cv::ORB::setPatchSize (method) cv::ORB (trait) . setPatchSize
// Arg ARG Primitive(int) patchSize= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ORB_setPatchSize_int_patchSize(void* instance, int patchSize) {
    try {
        reinterpret_cast<cv::ORB*>(instance)->setPatchSize(patchSize);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ORB_getPatchSize_const
// parsed: cv::ORB::getPatchSize
// as:     cv::ORB::getPatchSize (method) cv::ORB (trait) . getPatchSize
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_ORB_getPatchSize_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::ORB*>(instance)->getPatchSize();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_ORB_setFastThreshold_int_fastThreshold
// parsed: cv::ORB::setFastThreshold
// as:     cv::ORB::setFastThreshold (method) cv::ORB (trait) . setFastThreshold
// Arg ARG Primitive(int) fastThreshold= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ORB_setFastThreshold_int_fastThreshold(void* instance, int fastThreshold) {
    try {
        reinterpret_cast<cv::ORB*>(instance)->setFastThreshold(fastThreshold);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ORB_getFastThreshold_const
// parsed: cv::ORB::getFastThreshold
// as:     cv::ORB::getFastThreshold (method) cv::ORB (trait) . getFastThreshold
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_ORB_getFastThreshold_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::ORB*>(instance)->getFastThreshold();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_ORB_getDefaultName_const
// parsed: cv::ORB::getDefaultName
// as:     cv::ORB::getDefaultName (method) cv::ORB (trait) . getDefaultName
// Return value: string
cv_return_value_char_X cv_core_cv_ORB_getDefaultName_const(void* instance) {
    try {
        String ret = reinterpret_cast<cv::ORB*>(instance)->getDefaultName();
        return { Error::Code::StsOk, NULL, strdup(ret.c_str()) };
    } CVRS_CATCH(cv_return_value_char_X)
}

// cv_ORB_create_int_nfeatures_float_scaleFactor_int_nlevels_int_edgeThreshold_int_firstLevel_int_WTA_K_int_scoreType_int_patchSize_int_fastThreshold
// parsed: cv::ORB::create
// as:     cv::ORB::create (method) cv::ORB (trait) . create
// Arg ARG Primitive(int) nfeatures= Primitive(int) = 500
// Arg ARG Primitive(float) scaleFactor= Primitive(float) = 1.2f
// Arg ARG Primitive(int) nlevels= Primitive(int) = 8
// Arg ARG Primitive(int) edgeThreshold= Primitive(int) = 31
// Arg ARG Primitive(int) firstLevel= Primitive(int) = 0
// Arg ARG Primitive(int) WTA_K= Primitive(int) = 2
// Arg ARG Primitive(int) scoreType= Primitive(int) = ORB::HARRIS_SCORE
// Arg ARG Primitive(int) patchSize= Primitive(int) = 31
// Arg ARG Primitive(int) fastThreshold= Primitive(int) = 20
// Return value: SmartPtr[cv::ORB (boxed)]
cv_return_value_void_X cv_core_cv_ORB_create_int_nfeatures_float_scaleFactor_int_nlevels_int_edgeThreshold_int_firstLevel_int_WTA_K_int_scoreType_int_patchSize_int_fastThreshold(int nfeatures, float scaleFactor, int nlevels, int edgeThreshold, int firstLevel, int WTA_K, int scoreType, int patchSize, int fastThreshold) {
    try {
        Ptr<cv::ORB> *ret = new Ptr<cv::ORB>(cv::ORB::create(nfeatures, scaleFactor, nlevels, edgeThreshold, firstLevel, WTA_K, scoreType, patchSize, fastThreshold));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// boxed class: cv::PCA
void cv_delete_PCA(void* instance) {
    delete (cv::PCA*) instance;
}
// cv_PCA_PCA
// parsed: cv::PCA::PCA
// as:     cv::PCA::PCA (constructor) cv::PCA . new
// Return value: cv::PCA (boxed)
cv_return_value_void_X cv_core_cv_PCA_PCA() {
    try {
        cv::PCA* ret = new cv::PCA();
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_PCA_PCA_Mat_data_Mat_mean_int_flags_int_maxComponents
// parsed: cv::PCA::PCA
// as:     cv::PCA::PCA (constructor) cv::PCA . new
// Arg ARG cv::Mat (boxed) data= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) mean= cv::Mat (boxed) = 
// Arg ARG Primitive(int) flags= Primitive(int) = 
// Arg ARG Primitive(int) maxComponents= Primitive(int) = 0
// Return value: cv::PCA (boxed)
cv_return_value_void_X cv_core_cv_PCA_PCA_Mat_data_Mat_mean_int_flags_int_maxComponents(void* data, void* mean, int flags, int maxComponents) {
    try {
        cv::PCA* ret = new cv::PCA(*reinterpret_cast<cv::Mat*>(data), *reinterpret_cast<cv::Mat*>(mean), flags, maxComponents);
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_PCA_PCA_Mat_data_Mat_mean_int_flags_double_retainedVariance
// parsed: cv::PCA::PCA
// as:     cv::PCA::PCA (constructor) cv::PCA . new
// Arg ARG cv::Mat (boxed) data= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) mean= cv::Mat (boxed) = 
// Arg ARG Primitive(int) flags= Primitive(int) = 
// Arg ARG Primitive(double) retainedVariance= Primitive(double) = 
// Return value: cv::PCA (boxed)
cv_return_value_void_X cv_core_cv_PCA_PCA_Mat_data_Mat_mean_int_flags_double_retainedVariance(void* data, void* mean, int flags, double retainedVariance) {
    try {
        cv::PCA* ret = new cv::PCA(*reinterpret_cast<cv::Mat*>(data), *reinterpret_cast<cv::Mat*>(mean), flags, retainedVariance);
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_PCA_project_const_Mat_vec
// parsed: cv::PCA::project
// as:     cv::PCA::project (method) cv::PCA . project
// Arg ARG cv::Mat (boxed) vec= cv::Mat (boxed) = 
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_PCA_project_const_Mat_vec(void* instance, void* vec) {
    try {
        cv::Mat ret = reinterpret_cast<cv::PCA*>(instance)->project(*reinterpret_cast<cv::Mat*>(vec));
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_PCA_project_const_Mat_vec_Mat_result
// parsed: cv::PCA::project
// as:     cv::PCA::project (method) cv::PCA . project
// Arg ARG cv::Mat (boxed) vec= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) result= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_PCA_project_const_Mat_vec_Mat_result(void* instance, void* vec, void* result) {
    try {
        reinterpret_cast<cv::PCA*>(instance)->project(*reinterpret_cast<cv::Mat*>(vec), *reinterpret_cast<cv::Mat*>(result));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_PCA_backProject_const_Mat_vec
// parsed: cv::PCA::backProject
// as:     cv::PCA::backProject (method) cv::PCA . backProject
// Arg ARG cv::Mat (boxed) vec= cv::Mat (boxed) = 
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_PCA_backProject_const_Mat_vec(void* instance, void* vec) {
    try {
        cv::Mat ret = reinterpret_cast<cv::PCA*>(instance)->backProject(*reinterpret_cast<cv::Mat*>(vec));
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_PCA_backProject_const_Mat_vec_Mat_result
// parsed: cv::PCA::backProject
// as:     cv::PCA::backProject (method) cv::PCA . backProject
// Arg ARG cv::Mat (boxed) vec= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) result= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_PCA_backProject_const_Mat_vec_Mat_result(void* instance, void* vec, void* result) {
    try {
        reinterpret_cast<cv::PCA*>(instance)->backProject(*reinterpret_cast<cv::Mat*>(vec), *reinterpret_cast<cv::Mat*>(result));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// boxed class: cv::PaniniPortraitWarper
void cv_delete_PaniniPortraitWarper(void* instance) {
    delete (cv::PaniniPortraitWarper*) instance;
}
// cv_PaniniPortraitWarper_PaniniPortraitWarper_float_A_float_B
// parsed: cv::PaniniPortraitWarper::PaniniPortraitWarper
// as:     cv::PaniniPortraitWarper::PaniniPortraitWarper (constructor) cv::PaniniPortraitWarper . new
// Arg ARG Primitive(float) A= Primitive(float) = 1
// Arg ARG Primitive(float) B= Primitive(float) = 1
// Return value: cv::PaniniPortraitWarper (boxed)
cv_return_value_void_X cv_core_cv_PaniniPortraitWarper_PaniniPortraitWarper_float_A_float_B(float A, float B) {
    try {
        cv::PaniniPortraitWarper* ret = new cv::PaniniPortraitWarper(A, B);
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// boxed class: cv::PaniniWarper
void cv_delete_PaniniWarper(void* instance) {
    delete (cv::PaniniWarper*) instance;
}
// cv_PaniniWarper_PaniniWarper_float_A_float_B
// parsed: cv::PaniniWarper::PaniniWarper
// as:     cv::PaniniWarper::PaniniWarper (constructor) cv::PaniniWarper . new
// Arg ARG Primitive(float) A= Primitive(float) = 1
// Arg ARG Primitive(float) B= Primitive(float) = 1
// Return value: cv::PaniniWarper (boxed)
cv_return_value_void_X cv_core_cv_PaniniWarper_PaniniWarper_float_A_float_B(float A, float B) {
    try {
        cv::PaniniWarper* ret = new cv::PaniniWarper(A, B);
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// boxed class: cv::ParallelLoopBodyLambdaWrapper
void cv_delete_ParallelLoopBodyLambdaWrapper(void* instance) {
    delete (cv::ParallelLoopBodyLambdaWrapper*) instance;
}
// boxed class: cv::Param
void cv_delete_Param(void* instance) {
    delete (cv::Param*) instance;
}
// boxed class: cv::PlaneWarper
void cv_delete_PlaneWarper(void* instance) {
    delete (cv::PlaneWarper*) instance;
}
// boxed class: cv::QRCodeDetector
void cv_delete_QRCodeDetector(void* instance) {
    delete (cv::QRCodeDetector*) instance;
}
// cv_QRCodeDetector_QRCodeDetector
// parsed: cv::QRCodeDetector::QRCodeDetector
// as:     cv::QRCodeDetector::QRCodeDetector (constructor) cv::QRCodeDetector . new
// Return value: cv::QRCodeDetector (boxed)
cv_return_value_void_X cv_core_cv_QRCodeDetector_QRCodeDetector() {
    try {
        cv::QRCodeDetector* ret = new cv::QRCodeDetector();
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_QRCodeDetector_setEpsX_double_epsX
// parsed: cv::QRCodeDetector::setEpsX
// as:     cv::QRCodeDetector::setEpsX (method) cv::QRCodeDetector . setEpsX
// Arg ARG Primitive(double) epsX= Primitive(double) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_QRCodeDetector_setEpsX_double_epsX(void* instance, double epsX) {
    try {
        reinterpret_cast<cv::QRCodeDetector*>(instance)->setEpsX(epsX);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_QRCodeDetector_setEpsY_double_epsY
// parsed: cv::QRCodeDetector::setEpsY
// as:     cv::QRCodeDetector::setEpsY (method) cv::QRCodeDetector . setEpsY
// Arg ARG Primitive(double) epsY= Primitive(double) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_QRCodeDetector_setEpsY_double_epsY(void* instance, double epsY) {
    try {
        reinterpret_cast<cv::QRCodeDetector*>(instance)->setEpsY(epsY);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_QRCodeDetector_detect_const_Mat_img_Mat_points
// parsed: cv::QRCodeDetector::detect
// as:     cv::QRCodeDetector::detect (method) cv::QRCodeDetector . detect
// Arg ARG cv::Mat (boxed) img= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) points= cv::Mat (boxed) = 
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_QRCodeDetector_detect_const_Mat_img_Mat_points(void* instance, void* img, void* points) {
    try {
        bool ret = reinterpret_cast<cv::QRCodeDetector*>(instance)->detect(*reinterpret_cast<cv::Mat*>(img), *reinterpret_cast<cv::Mat*>(points));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// boxed class: cv::QtFont
void cv_delete_QtFont(void* instance) {
    delete (cv::QtFont*) instance;
}
// cv_Range_size_const
// parsed: cv::Range::size
// as:     cv::Range::size (method) cv::Range (trait) . size
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_Range_size_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::Range*>(instance)->size();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_Range_empty_const
// parsed: cv::Range::empty
// as:     cv::Range::empty (method) cv::Range (trait) . empty
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_Range_empty_const(void* instance) {
    try {
        bool ret = reinterpret_cast<cv::Range*>(instance)->empty();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_Range_all
// parsed: cv::Range::all
// as:     cv::Range::all (method) cv::Range (trait) . all
// Return value: cv::Range (boxed)
cv_return_value_void_X cv_core_cv_Range_all(void* instance) {
    try {
        cv::Range ret = reinterpret_cast<cv::Range*>(instance)->all();
        return { Error::Code::StsOk, NULL, new cv::Range(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// boxed class: cv::RotatedRect
void cv_delete_RotatedRect(void* instance) {
    delete (cv::RotatedRect*) instance;
}
// RotatedRect_get_angle
// parsed: RotatedRect::get_angle
// as:     RotatedRect::get_angle (method) cv::RotatedRect . get_angle
// Return value: Primitive(float)
cv_return_value_float cv_core_RotatedRect_get_angle(void* instance) {
    try {
        float ret = reinterpret_cast<cv::RotatedRect*>(instance)->angle;
        return { Error::Code::StsOk, NULL, *reinterpret_cast<float*>(&ret) };
    } CVRS_CATCH(cv_return_value_float)
}

// RotatedRect_get_center
// parsed: RotatedRect::get_center
// as:     RotatedRect::get_center (method) cv::RotatedRect . get_center
// Return value: cv::Point2f (simple)
cv_return_value_Point2fWrapper cv_core_RotatedRect_get_center(void* instance) {
    try {
        cv::Point2f ret = reinterpret_cast<cv::RotatedRect*>(instance)->center;
        return { Error::Code::StsOk, NULL, *reinterpret_cast<Point2fWrapper*>(&ret) };
    } CVRS_CATCH(cv_return_value_Point2fWrapper)
}

// RotatedRect_get_size
// parsed: RotatedRect::get_size
// as:     RotatedRect::get_size (method) cv::RotatedRect . get_size
// Return value: cv::Size2f (simple)
cv_return_value_Size2fWrapper cv_core_RotatedRect_get_size(void* instance) {
    try {
        cv::Size2f ret = reinterpret_cast<cv::RotatedRect*>(instance)->size;
        return { Error::Code::StsOk, NULL, *reinterpret_cast<Size2fWrapper*>(&ret) };
    } CVRS_CATCH(cv_return_value_Size2fWrapper)
}

// cv_RotatedRect_RotatedRect
// parsed: cv::RotatedRect::RotatedRect
// as:     cv::RotatedRect::RotatedRect (constructor) cv::RotatedRect . new
// Return value: cv::RotatedRect (boxed)
cv_return_value_void_X cv_core_cv_RotatedRect_RotatedRect() {
    try {
        cv::RotatedRect* ret = new cv::RotatedRect();
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_RotatedRect_RotatedRect_Point2f_center_Size2f_size_float_angle
// parsed: cv::RotatedRect::RotatedRect
// as:     cv::RotatedRect::RotatedRect (constructor) cv::RotatedRect . new
// Arg ARG cv::Point2f (simple) center= cv::Point2f (simple) = 
// Arg ARG cv::Size2f (simple) size= cv::Size2f (simple) = 
// Arg ARG Primitive(float) angle= Primitive(float) = 
// Return value: cv::RotatedRect (boxed)
cv_return_value_void_X cv_core_cv_RotatedRect_RotatedRect_Point2f_center_Size2f_size_float_angle(Point2fWrapper center, Size2fWrapper size, float angle) {
    try {
        cv::RotatedRect* ret = new cv::RotatedRect(*reinterpret_cast<cv::Point2f*>(&center), *reinterpret_cast<cv::Size2f*>(&size), angle);
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_RotatedRect_RotatedRect_Point2f_point1_Point2f_point2_Point2f_point3
// parsed: cv::RotatedRect::RotatedRect
// as:     cv::RotatedRect::RotatedRect (constructor) cv::RotatedRect . new
// Arg ARG cv::Point2f (simple) point1= cv::Point2f (simple) = 
// Arg ARG cv::Point2f (simple) point2= cv::Point2f (simple) = 
// Arg ARG cv::Point2f (simple) point3= cv::Point2f (simple) = 
// Return value: cv::RotatedRect (boxed)
cv_return_value_void_X cv_core_cv_RotatedRect_RotatedRect_Point2f_point1_Point2f_point2_Point2f_point3(Point2fWrapper point1, Point2fWrapper point2, Point2fWrapper point3) {
    try {
        cv::RotatedRect* ret = new cv::RotatedRect(*reinterpret_cast<cv::Point2f*>(&point1), *reinterpret_cast<cv::Point2f*>(&point2), *reinterpret_cast<cv::Point2f*>(&point3));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_RotatedRect_points_const_Point2f_X_pts
// parsed: cv::RotatedRect::points
// as:     cv::RotatedRect::points (method) cv::RotatedRect . points
// Arg ARG RawPtr[cv::Point2f (simple)] * pts= (ptr) RawPtr[cv::Point2f (simple)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_RotatedRect_points_const_Point2f_X_pts(void* instance, cv::Point2f* pts) {
    try {
        reinterpret_cast<cv::RotatedRect*>(instance)->points(reinterpret_cast<cv::Point2f*>(&pts));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_RotatedRect_boundingRect_const
// parsed: cv::RotatedRect::boundingRect
// as:     cv::RotatedRect::boundingRect (method) cv::RotatedRect . boundingRect
// Return value: cv::Rect (simple)
cv_return_value_RectWrapper cv_core_cv_RotatedRect_boundingRect_const(void* instance) {
    try {
        cv::Rect ret = reinterpret_cast<cv::RotatedRect*>(instance)->boundingRect();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<RectWrapper*>(&ret) };
    } CVRS_CATCH(cv_return_value_RectWrapper)
}

// cv_RotatedRect_boundingRect2f_const
// parsed: cv::RotatedRect::boundingRect2f
// as:     cv::RotatedRect::boundingRect2f (method) cv::RotatedRect . boundingRect2f
// Return value: cv::Rect2f (simple)
cv_return_value_Rect2fWrapper cv_core_cv_RotatedRect_boundingRect2f_const(void* instance) {
    try {
        cv::Rect2f ret = reinterpret_cast<cv::RotatedRect*>(instance)->boundingRect2f();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<Rect2fWrapper*>(&ret) };
    } CVRS_CATCH(cv_return_value_Rect2fWrapper)
}

// cv_ShapeContextDistanceExtractor_setAngularBins_int_nAngularBins
// parsed: cv::ShapeContextDistanceExtractor::setAngularBins
// as:     cv::ShapeContextDistanceExtractor::setAngularBins (method) cv::ShapeContextDistanceExtractor (trait) . setAngularBins
// Arg ARG Primitive(int) nAngularBins= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ShapeContextDistanceExtractor_setAngularBins_int_nAngularBins(void* instance, int nAngularBins) {
    try {
        reinterpret_cast<cv::ShapeContextDistanceExtractor*>(instance)->setAngularBins(nAngularBins);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ShapeContextDistanceExtractor_getAngularBins_const
// parsed: cv::ShapeContextDistanceExtractor::getAngularBins
// as:     cv::ShapeContextDistanceExtractor::getAngularBins (method) cv::ShapeContextDistanceExtractor (trait) . getAngularBins
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_ShapeContextDistanceExtractor_getAngularBins_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::ShapeContextDistanceExtractor*>(instance)->getAngularBins();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_ShapeContextDistanceExtractor_setRadialBins_int_nRadialBins
// parsed: cv::ShapeContextDistanceExtractor::setRadialBins
// as:     cv::ShapeContextDistanceExtractor::setRadialBins (method) cv::ShapeContextDistanceExtractor (trait) . setRadialBins
// Arg ARG Primitive(int) nRadialBins= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ShapeContextDistanceExtractor_setRadialBins_int_nRadialBins(void* instance, int nRadialBins) {
    try {
        reinterpret_cast<cv::ShapeContextDistanceExtractor*>(instance)->setRadialBins(nRadialBins);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ShapeContextDistanceExtractor_getRadialBins_const
// parsed: cv::ShapeContextDistanceExtractor::getRadialBins
// as:     cv::ShapeContextDistanceExtractor::getRadialBins (method) cv::ShapeContextDistanceExtractor (trait) . getRadialBins
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_ShapeContextDistanceExtractor_getRadialBins_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::ShapeContextDistanceExtractor*>(instance)->getRadialBins();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_ShapeContextDistanceExtractor_setInnerRadius_float_innerRadius
// parsed: cv::ShapeContextDistanceExtractor::setInnerRadius
// as:     cv::ShapeContextDistanceExtractor::setInnerRadius (method) cv::ShapeContextDistanceExtractor (trait) . setInnerRadius
// Arg ARG Primitive(float) innerRadius= Primitive(float) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ShapeContextDistanceExtractor_setInnerRadius_float_innerRadius(void* instance, float innerRadius) {
    try {
        reinterpret_cast<cv::ShapeContextDistanceExtractor*>(instance)->setInnerRadius(innerRadius);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ShapeContextDistanceExtractor_getInnerRadius_const
// parsed: cv::ShapeContextDistanceExtractor::getInnerRadius
// as:     cv::ShapeContextDistanceExtractor::getInnerRadius (method) cv::ShapeContextDistanceExtractor (trait) . getInnerRadius
// Return value: Primitive(float)
cv_return_value_float cv_core_cv_ShapeContextDistanceExtractor_getInnerRadius_const(void* instance) {
    try {
        float ret = reinterpret_cast<cv::ShapeContextDistanceExtractor*>(instance)->getInnerRadius();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<float*>(&ret) };
    } CVRS_CATCH(cv_return_value_float)
}

// cv_ShapeContextDistanceExtractor_setOuterRadius_float_outerRadius
// parsed: cv::ShapeContextDistanceExtractor::setOuterRadius
// as:     cv::ShapeContextDistanceExtractor::setOuterRadius (method) cv::ShapeContextDistanceExtractor (trait) . setOuterRadius
// Arg ARG Primitive(float) outerRadius= Primitive(float) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ShapeContextDistanceExtractor_setOuterRadius_float_outerRadius(void* instance, float outerRadius) {
    try {
        reinterpret_cast<cv::ShapeContextDistanceExtractor*>(instance)->setOuterRadius(outerRadius);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ShapeContextDistanceExtractor_getOuterRadius_const
// parsed: cv::ShapeContextDistanceExtractor::getOuterRadius
// as:     cv::ShapeContextDistanceExtractor::getOuterRadius (method) cv::ShapeContextDistanceExtractor (trait) . getOuterRadius
// Return value: Primitive(float)
cv_return_value_float cv_core_cv_ShapeContextDistanceExtractor_getOuterRadius_const(void* instance) {
    try {
        float ret = reinterpret_cast<cv::ShapeContextDistanceExtractor*>(instance)->getOuterRadius();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<float*>(&ret) };
    } CVRS_CATCH(cv_return_value_float)
}

// cv_ShapeContextDistanceExtractor_setRotationInvariant_bool_rotationInvariant
// parsed: cv::ShapeContextDistanceExtractor::setRotationInvariant
// as:     cv::ShapeContextDistanceExtractor::setRotationInvariant (method) cv::ShapeContextDistanceExtractor (trait) . setRotationInvariant
// Arg ARG Primitive(bool) rotationInvariant= Primitive(bool) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ShapeContextDistanceExtractor_setRotationInvariant_bool_rotationInvariant(void* instance, bool rotationInvariant) {
    try {
        reinterpret_cast<cv::ShapeContextDistanceExtractor*>(instance)->setRotationInvariant(rotationInvariant);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ShapeContextDistanceExtractor_getRotationInvariant_const
// parsed: cv::ShapeContextDistanceExtractor::getRotationInvariant
// as:     cv::ShapeContextDistanceExtractor::getRotationInvariant (method) cv::ShapeContextDistanceExtractor (trait) . getRotationInvariant
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_ShapeContextDistanceExtractor_getRotationInvariant_const(void* instance) {
    try {
        bool ret = reinterpret_cast<cv::ShapeContextDistanceExtractor*>(instance)->getRotationInvariant();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_ShapeContextDistanceExtractor_setShapeContextWeight_float_shapeContextWeight
// parsed: cv::ShapeContextDistanceExtractor::setShapeContextWeight
// as:     cv::ShapeContextDistanceExtractor::setShapeContextWeight (method) cv::ShapeContextDistanceExtractor (trait) . setShapeContextWeight
// Arg ARG Primitive(float) shapeContextWeight= Primitive(float) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ShapeContextDistanceExtractor_setShapeContextWeight_float_shapeContextWeight(void* instance, float shapeContextWeight) {
    try {
        reinterpret_cast<cv::ShapeContextDistanceExtractor*>(instance)->setShapeContextWeight(shapeContextWeight);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ShapeContextDistanceExtractor_getShapeContextWeight_const
// parsed: cv::ShapeContextDistanceExtractor::getShapeContextWeight
// as:     cv::ShapeContextDistanceExtractor::getShapeContextWeight (method) cv::ShapeContextDistanceExtractor (trait) . getShapeContextWeight
// Return value: Primitive(float)
cv_return_value_float cv_core_cv_ShapeContextDistanceExtractor_getShapeContextWeight_const(void* instance) {
    try {
        float ret = reinterpret_cast<cv::ShapeContextDistanceExtractor*>(instance)->getShapeContextWeight();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<float*>(&ret) };
    } CVRS_CATCH(cv_return_value_float)
}

// cv_ShapeContextDistanceExtractor_setImageAppearanceWeight_float_imageAppearanceWeight
// parsed: cv::ShapeContextDistanceExtractor::setImageAppearanceWeight
// as:     cv::ShapeContextDistanceExtractor::setImageAppearanceWeight (method) cv::ShapeContextDistanceExtractor (trait) . setImageAppearanceWeight
// Arg ARG Primitive(float) imageAppearanceWeight= Primitive(float) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ShapeContextDistanceExtractor_setImageAppearanceWeight_float_imageAppearanceWeight(void* instance, float imageAppearanceWeight) {
    try {
        reinterpret_cast<cv::ShapeContextDistanceExtractor*>(instance)->setImageAppearanceWeight(imageAppearanceWeight);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ShapeContextDistanceExtractor_getImageAppearanceWeight_const
// parsed: cv::ShapeContextDistanceExtractor::getImageAppearanceWeight
// as:     cv::ShapeContextDistanceExtractor::getImageAppearanceWeight (method) cv::ShapeContextDistanceExtractor (trait) . getImageAppearanceWeight
// Return value: Primitive(float)
cv_return_value_float cv_core_cv_ShapeContextDistanceExtractor_getImageAppearanceWeight_const(void* instance) {
    try {
        float ret = reinterpret_cast<cv::ShapeContextDistanceExtractor*>(instance)->getImageAppearanceWeight();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<float*>(&ret) };
    } CVRS_CATCH(cv_return_value_float)
}

// cv_ShapeContextDistanceExtractor_setBendingEnergyWeight_float_bendingEnergyWeight
// parsed: cv::ShapeContextDistanceExtractor::setBendingEnergyWeight
// as:     cv::ShapeContextDistanceExtractor::setBendingEnergyWeight (method) cv::ShapeContextDistanceExtractor (trait) . setBendingEnergyWeight
// Arg ARG Primitive(float) bendingEnergyWeight= Primitive(float) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ShapeContextDistanceExtractor_setBendingEnergyWeight_float_bendingEnergyWeight(void* instance, float bendingEnergyWeight) {
    try {
        reinterpret_cast<cv::ShapeContextDistanceExtractor*>(instance)->setBendingEnergyWeight(bendingEnergyWeight);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ShapeContextDistanceExtractor_getBendingEnergyWeight_const
// parsed: cv::ShapeContextDistanceExtractor::getBendingEnergyWeight
// as:     cv::ShapeContextDistanceExtractor::getBendingEnergyWeight (method) cv::ShapeContextDistanceExtractor (trait) . getBendingEnergyWeight
// Return value: Primitive(float)
cv_return_value_float cv_core_cv_ShapeContextDistanceExtractor_getBendingEnergyWeight_const(void* instance) {
    try {
        float ret = reinterpret_cast<cv::ShapeContextDistanceExtractor*>(instance)->getBendingEnergyWeight();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<float*>(&ret) };
    } CVRS_CATCH(cv_return_value_float)
}

// cv_ShapeContextDistanceExtractor_setImages_Mat_image1_Mat_image2
// parsed: cv::ShapeContextDistanceExtractor::setImages
// as:     cv::ShapeContextDistanceExtractor::setImages (method) cv::ShapeContextDistanceExtractor (trait) . setImages
// Arg ARG cv::Mat (boxed) image1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) image2= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ShapeContextDistanceExtractor_setImages_Mat_image1_Mat_image2(void* instance, void* image1, void* image2) {
    try {
        reinterpret_cast<cv::ShapeContextDistanceExtractor*>(instance)->setImages(*reinterpret_cast<cv::Mat*>(image1), *reinterpret_cast<cv::Mat*>(image2));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ShapeContextDistanceExtractor_getImages_const_Mat_image1_Mat_image2
// parsed: cv::ShapeContextDistanceExtractor::getImages
// as:     cv::ShapeContextDistanceExtractor::getImages (method) cv::ShapeContextDistanceExtractor (trait) . getImages
// Arg ARG cv::Mat (boxed) image1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) image2= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ShapeContextDistanceExtractor_getImages_const_Mat_image1_Mat_image2(void* instance, void* image1, void* image2) {
    try {
        reinterpret_cast<cv::ShapeContextDistanceExtractor*>(instance)->getImages(*reinterpret_cast<cv::Mat*>(image1), *reinterpret_cast<cv::Mat*>(image2));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ShapeContextDistanceExtractor_setIterations_int_iterations
// parsed: cv::ShapeContextDistanceExtractor::setIterations
// as:     cv::ShapeContextDistanceExtractor::setIterations (method) cv::ShapeContextDistanceExtractor (trait) . setIterations
// Arg ARG Primitive(int) iterations= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ShapeContextDistanceExtractor_setIterations_int_iterations(void* instance, int iterations) {
    try {
        reinterpret_cast<cv::ShapeContextDistanceExtractor*>(instance)->setIterations(iterations);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ShapeContextDistanceExtractor_getIterations_const
// parsed: cv::ShapeContextDistanceExtractor::getIterations
// as:     cv::ShapeContextDistanceExtractor::getIterations (method) cv::ShapeContextDistanceExtractor (trait) . getIterations
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_ShapeContextDistanceExtractor_getIterations_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::ShapeContextDistanceExtractor*>(instance)->getIterations();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_ShapeContextDistanceExtractor_setCostExtractor_PtrOfHistogramCostExtractor_comparer
// parsed: cv::ShapeContextDistanceExtractor::setCostExtractor
// as:     cv::ShapeContextDistanceExtractor::setCostExtractor (method) cv::ShapeContextDistanceExtractor (trait) . setCostExtractor
// Arg ARG SmartPtr[cv::HistogramCostExtractor (boxed)] comparer= SmartPtr[cv::HistogramCostExtractor (boxed)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ShapeContextDistanceExtractor_setCostExtractor_PtrOfHistogramCostExtractor_comparer(void* instance, void* comparer) {
    try {
        reinterpret_cast<cv::ShapeContextDistanceExtractor*>(instance)->setCostExtractor(reinterpret_cast<cv::HistogramCostExtractor*>(comparer));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ShapeContextDistanceExtractor_getCostExtractor_const
// parsed: cv::ShapeContextDistanceExtractor::getCostExtractor
// as:     cv::ShapeContextDistanceExtractor::getCostExtractor (method) cv::ShapeContextDistanceExtractor (trait) . getCostExtractor
// Return value: SmartPtr[cv::HistogramCostExtractor (boxed)]
cv_return_value_void_X cv_core_cv_ShapeContextDistanceExtractor_getCostExtractor_const(void* instance) {
    try {
        Ptr<cv::HistogramCostExtractor> *ret = new Ptr<cv::HistogramCostExtractor>(reinterpret_cast<cv::ShapeContextDistanceExtractor*>(instance)->getCostExtractor());
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_ShapeContextDistanceExtractor_setStdDev_float_sigma
// parsed: cv::ShapeContextDistanceExtractor::setStdDev
// as:     cv::ShapeContextDistanceExtractor::setStdDev (method) cv::ShapeContextDistanceExtractor (trait) . setStdDev
// Arg ARG Primitive(float) sigma= Primitive(float) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ShapeContextDistanceExtractor_setStdDev_float_sigma(void* instance, float sigma) {
    try {
        reinterpret_cast<cv::ShapeContextDistanceExtractor*>(instance)->setStdDev(sigma);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ShapeContextDistanceExtractor_getStdDev_const
// parsed: cv::ShapeContextDistanceExtractor::getStdDev
// as:     cv::ShapeContextDistanceExtractor::getStdDev (method) cv::ShapeContextDistanceExtractor (trait) . getStdDev
// Return value: Primitive(float)
cv_return_value_float cv_core_cv_ShapeContextDistanceExtractor_getStdDev_const(void* instance) {
    try {
        float ret = reinterpret_cast<cv::ShapeContextDistanceExtractor*>(instance)->getStdDev();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<float*>(&ret) };
    } CVRS_CATCH(cv_return_value_float)
}

// cv_ShapeDistanceExtractor_computeDistance_Mat_contour1_Mat_contour2
// parsed: cv::ShapeDistanceExtractor::computeDistance
// as:     cv::ShapeDistanceExtractor::computeDistance (method) cv::ShapeDistanceExtractor (trait) . computeDistance
// Arg ARG cv::Mat (boxed) contour1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) contour2= cv::Mat (boxed) = 
// Return value: Primitive(float)
cv_return_value_float cv_core_cv_ShapeDistanceExtractor_computeDistance_Mat_contour1_Mat_contour2(void* instance, void* contour1, void* contour2) {
    try {
        float ret = reinterpret_cast<cv::ShapeDistanceExtractor*>(instance)->computeDistance(*reinterpret_cast<cv::Mat*>(contour1), *reinterpret_cast<cv::Mat*>(contour2));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<float*>(&ret) };
    } CVRS_CATCH(cv_return_value_float)
}

// cv_ShapeTransformer_estimateTransformation_Mat_transformingShape_Mat_targetShape_VectorOfDMatch_matches
// parsed: cv::ShapeTransformer::estimateTransformation
// as:     cv::ShapeTransformer::estimateTransformation (method) cv::ShapeTransformer (trait) . estimateTransformation
// Arg ARG cv::Mat (boxed) transformingShape= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) targetShape= cv::Mat (boxed) = 
// Arg ARG Vector[cv::DMatch (simple)] matches= Vector[cv::DMatch (simple)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ShapeTransformer_estimateTransformation_Mat_transformingShape_Mat_targetShape_VectorOfDMatch_matches(void* instance, void* transformingShape, void* targetShape, void* matches) {
    try {
        reinterpret_cast<cv::ShapeTransformer*>(instance)->estimateTransformation(*reinterpret_cast<cv::Mat*>(transformingShape), *reinterpret_cast<cv::Mat*>(targetShape), *reinterpret_cast<std::vector<cv::DMatch>*>(matches));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ShapeTransformer_applyTransformation_Mat_input_Mat_output
// parsed: cv::ShapeTransformer::applyTransformation
// as:     cv::ShapeTransformer::applyTransformation (method) cv::ShapeTransformer (trait) . applyTransformation
// Arg ARG cv::Mat (boxed) input= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) output= cv::Mat (boxed) = noArray()
// Return value: Primitive(float)
cv_return_value_float cv_core_cv_ShapeTransformer_applyTransformation_Mat_input_Mat_output(void* instance, void* input, void* output) {
    try {
        float ret = reinterpret_cast<cv::ShapeTransformer*>(instance)->applyTransformation(*reinterpret_cast<cv::Mat*>(input), *reinterpret_cast<cv::Mat*>(output));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<float*>(&ret) };
    } CVRS_CATCH(cv_return_value_float)
}

// cv_ShapeTransformer_warpImage_const_Mat_transformingImage_Mat_output_int_flags_int_borderMode_Scalar_borderValue
// parsed: cv::ShapeTransformer::warpImage
// as:     cv::ShapeTransformer::warpImage (method) cv::ShapeTransformer (trait) . warpImage
// Arg ARG cv::Mat (boxed) transformingImage= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) output= cv::Mat (boxed) = 
// Arg ARG Primitive(int) flags= Primitive(int) = INTER_LINEAR
// Arg ARG Primitive(int) borderMode= Primitive(int) = BORDER_CONSTANT
// Arg ARG cv::Scalar (simple) borderValue= cv::Scalar (simple) = Scalar()
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ShapeTransformer_warpImage_const_Mat_transformingImage_Mat_output_int_flags_int_borderMode_Scalar_borderValue(void* instance, void* transformingImage, void* output, int flags, int borderMode, ScalarWrapper borderValue) {
    try {
        reinterpret_cast<cv::ShapeTransformer*>(instance)->warpImage(*reinterpret_cast<cv::Mat*>(transformingImage), *reinterpret_cast<cv::Mat*>(output), flags, borderMode, *reinterpret_cast<cv::Scalar*>(&borderValue));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// boxed class: cv::SimilarRects
void cv_delete_SimilarRects(void* instance) {
    delete (cv::SimilarRects*) instance;
}
// boxed class: cv::SimpleBlobDetector
void cv_delete_SimpleBlobDetector(void* instance) {
    delete (cv::SimpleBlobDetector*) instance;
}
// cv_SimpleBlobDetector_create_SimpleBlobDetector_Params_parameters
// parsed: cv::SimpleBlobDetector::create
// as:     cv::SimpleBlobDetector::create (method) cv::SimpleBlobDetector . create
// Arg ARG cv::SimpleBlobDetector::Params (simple) parameters= cv::SimpleBlobDetector::Params (simple) = SimpleBlobDetector::Params()
// Return value: SmartPtr[cv::SimpleBlobDetector (boxed)]
cv_return_value_void_X cv_core_cv_SimpleBlobDetector_create_SimpleBlobDetector_Params_parameters(cv::SimpleBlobDetector::Params parameters) {
    try {
        Ptr<cv::SimpleBlobDetector> *ret = new Ptr<cv::SimpleBlobDetector>(cv::SimpleBlobDetector::create(*reinterpret_cast<cv::SimpleBlobDetector::Params*>(&parameters)));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_SimpleBlobDetector_getDefaultName_const
// parsed: cv::SimpleBlobDetector::getDefaultName
// as:     cv::SimpleBlobDetector::getDefaultName (method) cv::SimpleBlobDetector . getDefaultName
// Return value: string
cv_return_value_char_X cv_core_cv_SimpleBlobDetector_getDefaultName_const(void* instance) {
    try {
        String ret = reinterpret_cast<cv::SimpleBlobDetector*>(instance)->getDefaultName();
        return { Error::Code::StsOk, NULL, strdup(ret.c_str()) };
    } CVRS_CATCH(cv_return_value_char_X)
}

// cv_SimpleBlobDetector_Params_Params
// parsed: cv::SimpleBlobDetector::Params::Params
// as:     cv::SimpleBlobDetector::Params::Params (constructor) cv::SimpleBlobDetector::Params (simple) . new
// Return value: cv::SimpleBlobDetector::Params (simple)
cv_return_value_SimpleBlobDetector_Params cv_core_cv_SimpleBlobDetector_Params_Params() {
    try {
        cv::SimpleBlobDetector::Params ret;
        return { Error::Code::StsOk, NULL, *reinterpret_cast<cv::SimpleBlobDetector::Params*>(&ret) };
    } CVRS_CATCH(cv_return_value_SimpleBlobDetector_Params)
}

// cv_SparseOpticalFlow_calc_Mat_prevImg_Mat_nextImg_Mat_prevPts_Mat_nextPts_Mat_status_Mat_err
// parsed: cv::SparseOpticalFlow::calc
// as:     cv::SparseOpticalFlow::calc (method) cv::SparseOpticalFlow (trait) . calc
// Arg ARG cv::Mat (boxed) prevImg= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) nextImg= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) prevPts= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) nextPts= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) status= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) err= cv::Mat (boxed) = cv::noArray()
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_SparseOpticalFlow_calc_Mat_prevImg_Mat_nextImg_Mat_prevPts_Mat_nextPts_Mat_status_Mat_err(void* instance, void* prevImg, void* nextImg, void* prevPts, void* nextPts, void* status, void* err) {
    try {
        reinterpret_cast<cv::SparseOpticalFlow*>(instance)->calc(*reinterpret_cast<cv::Mat*>(prevImg), *reinterpret_cast<cv::Mat*>(nextImg), *reinterpret_cast<cv::Mat*>(prevPts), *reinterpret_cast<cv::Mat*>(nextPts), *reinterpret_cast<cv::Mat*>(status), *reinterpret_cast<cv::Mat*>(err));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_SparsePyrLKOpticalFlow_getWinSize_const
// parsed: cv::SparsePyrLKOpticalFlow::getWinSize
// as:     cv::SparsePyrLKOpticalFlow::getWinSize (method) cv::SparsePyrLKOpticalFlow (trait) . getWinSize
// Return value: cv::Size (simple)
cv_return_value_SizeWrapper cv_core_cv_SparsePyrLKOpticalFlow_getWinSize_const(void* instance) {
    try {
        cv::Size ret = reinterpret_cast<cv::SparsePyrLKOpticalFlow*>(instance)->getWinSize();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<SizeWrapper*>(&ret) };
    } CVRS_CATCH(cv_return_value_SizeWrapper)
}

// cv_SparsePyrLKOpticalFlow_setWinSize_Size_winSize
// parsed: cv::SparsePyrLKOpticalFlow::setWinSize
// as:     cv::SparsePyrLKOpticalFlow::setWinSize (method) cv::SparsePyrLKOpticalFlow (trait) . setWinSize
// Arg ARG cv::Size (simple) winSize= cv::Size (simple) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_SparsePyrLKOpticalFlow_setWinSize_Size_winSize(void* instance, SizeWrapper winSize) {
    try {
        reinterpret_cast<cv::SparsePyrLKOpticalFlow*>(instance)->setWinSize(*reinterpret_cast<cv::Size*>(&winSize));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_SparsePyrLKOpticalFlow_getMaxLevel_const
// parsed: cv::SparsePyrLKOpticalFlow::getMaxLevel
// as:     cv::SparsePyrLKOpticalFlow::getMaxLevel (method) cv::SparsePyrLKOpticalFlow (trait) . getMaxLevel
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_SparsePyrLKOpticalFlow_getMaxLevel_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::SparsePyrLKOpticalFlow*>(instance)->getMaxLevel();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_SparsePyrLKOpticalFlow_setMaxLevel_int_maxLevel
// parsed: cv::SparsePyrLKOpticalFlow::setMaxLevel
// as:     cv::SparsePyrLKOpticalFlow::setMaxLevel (method) cv::SparsePyrLKOpticalFlow (trait) . setMaxLevel
// Arg ARG Primitive(int) maxLevel= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_SparsePyrLKOpticalFlow_setMaxLevel_int_maxLevel(void* instance, int maxLevel) {
    try {
        reinterpret_cast<cv::SparsePyrLKOpticalFlow*>(instance)->setMaxLevel(maxLevel);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_SparsePyrLKOpticalFlow_getTermCriteria_const
// parsed: cv::SparsePyrLKOpticalFlow::getTermCriteria
// as:     cv::SparsePyrLKOpticalFlow::getTermCriteria (method) cv::SparsePyrLKOpticalFlow (trait) . getTermCriteria
// Return value: cv::TermCriteria (boxed)
cv_return_value_void_X cv_core_cv_SparsePyrLKOpticalFlow_getTermCriteria_const(void* instance) {
    try {
        cv::TermCriteria ret = reinterpret_cast<cv::SparsePyrLKOpticalFlow*>(instance)->getTermCriteria();
        return { Error::Code::StsOk, NULL, new cv::TermCriteria(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_SparsePyrLKOpticalFlow_setTermCriteria_TermCriteria_crit
// parsed: cv::SparsePyrLKOpticalFlow::setTermCriteria
// as:     cv::SparsePyrLKOpticalFlow::setTermCriteria (method) cv::SparsePyrLKOpticalFlow (trait) . setTermCriteria
// Arg ARG cv::TermCriteria (boxed) crit= cv::TermCriteria (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_SparsePyrLKOpticalFlow_setTermCriteria_TermCriteria_crit(void* instance, void* crit) {
    try {
        reinterpret_cast<cv::SparsePyrLKOpticalFlow*>(instance)->setTermCriteria(*reinterpret_cast<cv::TermCriteria*>(crit));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_SparsePyrLKOpticalFlow_getFlags_const
// parsed: cv::SparsePyrLKOpticalFlow::getFlags
// as:     cv::SparsePyrLKOpticalFlow::getFlags (method) cv::SparsePyrLKOpticalFlow (trait) . getFlags
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_SparsePyrLKOpticalFlow_getFlags_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::SparsePyrLKOpticalFlow*>(instance)->getFlags();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_SparsePyrLKOpticalFlow_setFlags_int_flags
// parsed: cv::SparsePyrLKOpticalFlow::setFlags
// as:     cv::SparsePyrLKOpticalFlow::setFlags (method) cv::SparsePyrLKOpticalFlow (trait) . setFlags
// Arg ARG Primitive(int) flags= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_SparsePyrLKOpticalFlow_setFlags_int_flags(void* instance, int flags) {
    try {
        reinterpret_cast<cv::SparsePyrLKOpticalFlow*>(instance)->setFlags(flags);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_SparsePyrLKOpticalFlow_getMinEigThreshold_const
// parsed: cv::SparsePyrLKOpticalFlow::getMinEigThreshold
// as:     cv::SparsePyrLKOpticalFlow::getMinEigThreshold (method) cv::SparsePyrLKOpticalFlow (trait) . getMinEigThreshold
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_SparsePyrLKOpticalFlow_getMinEigThreshold_const(void* instance) {
    try {
        double ret = reinterpret_cast<cv::SparsePyrLKOpticalFlow*>(instance)->getMinEigThreshold();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_SparsePyrLKOpticalFlow_setMinEigThreshold_double_minEigThreshold
// parsed: cv::SparsePyrLKOpticalFlow::setMinEigThreshold
// as:     cv::SparsePyrLKOpticalFlow::setMinEigThreshold (method) cv::SparsePyrLKOpticalFlow (trait) . setMinEigThreshold
// Arg ARG Primitive(double) minEigThreshold= Primitive(double) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_SparsePyrLKOpticalFlow_setMinEigThreshold_double_minEigThreshold(void* instance, double minEigThreshold) {
    try {
        reinterpret_cast<cv::SparsePyrLKOpticalFlow*>(instance)->setMinEigThreshold(minEigThreshold);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_SparsePyrLKOpticalFlow_create_Size_winSize_int_maxLevel_TermCriteria_crit_int_flags_double_minEigThreshold
// parsed: cv::SparsePyrLKOpticalFlow::create
// as:     cv::SparsePyrLKOpticalFlow::create (method) cv::SparsePyrLKOpticalFlow (trait) . create
// Arg ARG cv::Size (simple) winSize= cv::Size (simple) = Size(21, 21)
// Arg ARG Primitive(int) maxLevel= Primitive(int) = 3
// Arg ARG cv::TermCriteria (boxed) crit= cv::TermCriteria (boxed) = TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, 0.01)
// Arg ARG Primitive(int) flags= Primitive(int) = 0
// Arg ARG Primitive(double) minEigThreshold= Primitive(double) = 1e-4
// Return value: SmartPtr[cv::SparsePyrLKOpticalFlow (boxed)]
cv_return_value_void_X cv_core_cv_SparsePyrLKOpticalFlow_create_Size_winSize_int_maxLevel_TermCriteria_crit_int_flags_double_minEigThreshold(SizeWrapper winSize, int maxLevel, void* crit, int flags, double minEigThreshold) {
    try {
        Ptr<cv::SparsePyrLKOpticalFlow> *ret = new Ptr<cv::SparsePyrLKOpticalFlow>(cv::SparsePyrLKOpticalFlow::create(*reinterpret_cast<cv::Size*>(&winSize), maxLevel, *reinterpret_cast<cv::TermCriteria*>(crit), flags, minEigThreshold));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// boxed class: cv::SphericalWarper
void cv_delete_SphericalWarper(void* instance) {
    delete (cv::SphericalWarper*) instance;
}
// cv_StereoBM_getPreFilterType_const
// parsed: cv::StereoBM::getPreFilterType
// as:     cv::StereoBM::getPreFilterType (method) cv::StereoBM (trait) . getPreFilterType
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_StereoBM_getPreFilterType_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::StereoBM*>(instance)->getPreFilterType();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_StereoBM_setPreFilterType_int_preFilterType
// parsed: cv::StereoBM::setPreFilterType
// as:     cv::StereoBM::setPreFilterType (method) cv::StereoBM (trait) . setPreFilterType
// Arg ARG Primitive(int) preFilterType= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_StereoBM_setPreFilterType_int_preFilterType(void* instance, int preFilterType) {
    try {
        reinterpret_cast<cv::StereoBM*>(instance)->setPreFilterType(preFilterType);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_StereoBM_getPreFilterSize_const
// parsed: cv::StereoBM::getPreFilterSize
// as:     cv::StereoBM::getPreFilterSize (method) cv::StereoBM (trait) . getPreFilterSize
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_StereoBM_getPreFilterSize_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::StereoBM*>(instance)->getPreFilterSize();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_StereoBM_setPreFilterSize_int_preFilterSize
// parsed: cv::StereoBM::setPreFilterSize
// as:     cv::StereoBM::setPreFilterSize (method) cv::StereoBM (trait) . setPreFilterSize
// Arg ARG Primitive(int) preFilterSize= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_StereoBM_setPreFilterSize_int_preFilterSize(void* instance, int preFilterSize) {
    try {
        reinterpret_cast<cv::StereoBM*>(instance)->setPreFilterSize(preFilterSize);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_StereoBM_getPreFilterCap_const
// parsed: cv::StereoBM::getPreFilterCap
// as:     cv::StereoBM::getPreFilterCap (method) cv::StereoBM (trait) . getPreFilterCap
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_StereoBM_getPreFilterCap_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::StereoBM*>(instance)->getPreFilterCap();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_StereoBM_setPreFilterCap_int_preFilterCap
// parsed: cv::StereoBM::setPreFilterCap
// as:     cv::StereoBM::setPreFilterCap (method) cv::StereoBM (trait) . setPreFilterCap
// Arg ARG Primitive(int) preFilterCap= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_StereoBM_setPreFilterCap_int_preFilterCap(void* instance, int preFilterCap) {
    try {
        reinterpret_cast<cv::StereoBM*>(instance)->setPreFilterCap(preFilterCap);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_StereoBM_getTextureThreshold_const
// parsed: cv::StereoBM::getTextureThreshold
// as:     cv::StereoBM::getTextureThreshold (method) cv::StereoBM (trait) . getTextureThreshold
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_StereoBM_getTextureThreshold_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::StereoBM*>(instance)->getTextureThreshold();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_StereoBM_setTextureThreshold_int_textureThreshold
// parsed: cv::StereoBM::setTextureThreshold
// as:     cv::StereoBM::setTextureThreshold (method) cv::StereoBM (trait) . setTextureThreshold
// Arg ARG Primitive(int) textureThreshold= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_StereoBM_setTextureThreshold_int_textureThreshold(void* instance, int textureThreshold) {
    try {
        reinterpret_cast<cv::StereoBM*>(instance)->setTextureThreshold(textureThreshold);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_StereoBM_getUniquenessRatio_const
// parsed: cv::StereoBM::getUniquenessRatio
// as:     cv::StereoBM::getUniquenessRatio (method) cv::StereoBM (trait) . getUniquenessRatio
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_StereoBM_getUniquenessRatio_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::StereoBM*>(instance)->getUniquenessRatio();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_StereoBM_setUniquenessRatio_int_uniquenessRatio
// parsed: cv::StereoBM::setUniquenessRatio
// as:     cv::StereoBM::setUniquenessRatio (method) cv::StereoBM (trait) . setUniquenessRatio
// Arg ARG Primitive(int) uniquenessRatio= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_StereoBM_setUniquenessRatio_int_uniquenessRatio(void* instance, int uniquenessRatio) {
    try {
        reinterpret_cast<cv::StereoBM*>(instance)->setUniquenessRatio(uniquenessRatio);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_StereoBM_getSmallerBlockSize_const
// parsed: cv::StereoBM::getSmallerBlockSize
// as:     cv::StereoBM::getSmallerBlockSize (method) cv::StereoBM (trait) . getSmallerBlockSize
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_StereoBM_getSmallerBlockSize_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::StereoBM*>(instance)->getSmallerBlockSize();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_StereoBM_setSmallerBlockSize_int_blockSize
// parsed: cv::StereoBM::setSmallerBlockSize
// as:     cv::StereoBM::setSmallerBlockSize (method) cv::StereoBM (trait) . setSmallerBlockSize
// Arg ARG Primitive(int) blockSize= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_StereoBM_setSmallerBlockSize_int_blockSize(void* instance, int blockSize) {
    try {
        reinterpret_cast<cv::StereoBM*>(instance)->setSmallerBlockSize(blockSize);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_StereoBM_getROI1_const
// parsed: cv::StereoBM::getROI1
// as:     cv::StereoBM::getROI1 (method) cv::StereoBM (trait) . getROI1
// Return value: cv::Rect (simple)
cv_return_value_RectWrapper cv_core_cv_StereoBM_getROI1_const(void* instance) {
    try {
        cv::Rect ret = reinterpret_cast<cv::StereoBM*>(instance)->getROI1();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<RectWrapper*>(&ret) };
    } CVRS_CATCH(cv_return_value_RectWrapper)
}

// cv_StereoBM_setROI1_Rect_roi1
// parsed: cv::StereoBM::setROI1
// as:     cv::StereoBM::setROI1 (method) cv::StereoBM (trait) . setROI1
// Arg ARG cv::Rect (simple) roi1= cv::Rect (simple) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_StereoBM_setROI1_Rect_roi1(void* instance, RectWrapper roi1) {
    try {
        reinterpret_cast<cv::StereoBM*>(instance)->setROI1(*reinterpret_cast<cv::Rect*>(&roi1));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_StereoBM_getROI2_const
// parsed: cv::StereoBM::getROI2
// as:     cv::StereoBM::getROI2 (method) cv::StereoBM (trait) . getROI2
// Return value: cv::Rect (simple)
cv_return_value_RectWrapper cv_core_cv_StereoBM_getROI2_const(void* instance) {
    try {
        cv::Rect ret = reinterpret_cast<cv::StereoBM*>(instance)->getROI2();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<RectWrapper*>(&ret) };
    } CVRS_CATCH(cv_return_value_RectWrapper)
}

// cv_StereoBM_setROI2_Rect_roi2
// parsed: cv::StereoBM::setROI2
// as:     cv::StereoBM::setROI2 (method) cv::StereoBM (trait) . setROI2
// Arg ARG cv::Rect (simple) roi2= cv::Rect (simple) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_StereoBM_setROI2_Rect_roi2(void* instance, RectWrapper roi2) {
    try {
        reinterpret_cast<cv::StereoBM*>(instance)->setROI2(*reinterpret_cast<cv::Rect*>(&roi2));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_StereoBM_create_int_numDisparities_int_blockSize
// parsed: cv::StereoBM::create
// as:     cv::StereoBM::create (method) cv::StereoBM (trait) . create
// Arg ARG Primitive(int) numDisparities= Primitive(int) = 0
// Arg ARG Primitive(int) blockSize= Primitive(int) = 21
// Return value: SmartPtr[cv::StereoBM (boxed)]
cv_return_value_void_X cv_core_cv_StereoBM_create_int_numDisparities_int_blockSize(int numDisparities, int blockSize) {
    try {
        Ptr<cv::StereoBM> *ret = new Ptr<cv::StereoBM>(cv::StereoBM::create(numDisparities, blockSize));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_StereoMatcher_compute_Mat_left_Mat_right_Mat_disparity
// parsed: cv::StereoMatcher::compute
// as:     cv::StereoMatcher::compute (method) cv::StereoMatcher (trait) . compute
// Arg ARG cv::Mat (boxed) left= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) right= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) disparity= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_StereoMatcher_compute_Mat_left_Mat_right_Mat_disparity(void* instance, void* left, void* right, void* disparity) {
    try {
        reinterpret_cast<cv::StereoMatcher*>(instance)->compute(*reinterpret_cast<cv::Mat*>(left), *reinterpret_cast<cv::Mat*>(right), *reinterpret_cast<cv::Mat*>(disparity));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_StereoMatcher_getMinDisparity_const
// parsed: cv::StereoMatcher::getMinDisparity
// as:     cv::StereoMatcher::getMinDisparity (method) cv::StereoMatcher (trait) . getMinDisparity
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_StereoMatcher_getMinDisparity_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::StereoMatcher*>(instance)->getMinDisparity();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_StereoMatcher_setMinDisparity_int_minDisparity
// parsed: cv::StereoMatcher::setMinDisparity
// as:     cv::StereoMatcher::setMinDisparity (method) cv::StereoMatcher (trait) . setMinDisparity
// Arg ARG Primitive(int) minDisparity= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_StereoMatcher_setMinDisparity_int_minDisparity(void* instance, int minDisparity) {
    try {
        reinterpret_cast<cv::StereoMatcher*>(instance)->setMinDisparity(minDisparity);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_StereoMatcher_getNumDisparities_const
// parsed: cv::StereoMatcher::getNumDisparities
// as:     cv::StereoMatcher::getNumDisparities (method) cv::StereoMatcher (trait) . getNumDisparities
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_StereoMatcher_getNumDisparities_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::StereoMatcher*>(instance)->getNumDisparities();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_StereoMatcher_setNumDisparities_int_numDisparities
// parsed: cv::StereoMatcher::setNumDisparities
// as:     cv::StereoMatcher::setNumDisparities (method) cv::StereoMatcher (trait) . setNumDisparities
// Arg ARG Primitive(int) numDisparities= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_StereoMatcher_setNumDisparities_int_numDisparities(void* instance, int numDisparities) {
    try {
        reinterpret_cast<cv::StereoMatcher*>(instance)->setNumDisparities(numDisparities);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_StereoMatcher_getBlockSize_const
// parsed: cv::StereoMatcher::getBlockSize
// as:     cv::StereoMatcher::getBlockSize (method) cv::StereoMatcher (trait) . getBlockSize
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_StereoMatcher_getBlockSize_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::StereoMatcher*>(instance)->getBlockSize();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_StereoMatcher_setBlockSize_int_blockSize
// parsed: cv::StereoMatcher::setBlockSize
// as:     cv::StereoMatcher::setBlockSize (method) cv::StereoMatcher (trait) . setBlockSize
// Arg ARG Primitive(int) blockSize= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_StereoMatcher_setBlockSize_int_blockSize(void* instance, int blockSize) {
    try {
        reinterpret_cast<cv::StereoMatcher*>(instance)->setBlockSize(blockSize);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_StereoMatcher_getSpeckleWindowSize_const
// parsed: cv::StereoMatcher::getSpeckleWindowSize
// as:     cv::StereoMatcher::getSpeckleWindowSize (method) cv::StereoMatcher (trait) . getSpeckleWindowSize
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_StereoMatcher_getSpeckleWindowSize_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::StereoMatcher*>(instance)->getSpeckleWindowSize();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_StereoMatcher_setSpeckleWindowSize_int_speckleWindowSize
// parsed: cv::StereoMatcher::setSpeckleWindowSize
// as:     cv::StereoMatcher::setSpeckleWindowSize (method) cv::StereoMatcher (trait) . setSpeckleWindowSize
// Arg ARG Primitive(int) speckleWindowSize= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_StereoMatcher_setSpeckleWindowSize_int_speckleWindowSize(void* instance, int speckleWindowSize) {
    try {
        reinterpret_cast<cv::StereoMatcher*>(instance)->setSpeckleWindowSize(speckleWindowSize);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_StereoMatcher_getSpeckleRange_const
// parsed: cv::StereoMatcher::getSpeckleRange
// as:     cv::StereoMatcher::getSpeckleRange (method) cv::StereoMatcher (trait) . getSpeckleRange
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_StereoMatcher_getSpeckleRange_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::StereoMatcher*>(instance)->getSpeckleRange();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_StereoMatcher_setSpeckleRange_int_speckleRange
// parsed: cv::StereoMatcher::setSpeckleRange
// as:     cv::StereoMatcher::setSpeckleRange (method) cv::StereoMatcher (trait) . setSpeckleRange
// Arg ARG Primitive(int) speckleRange= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_StereoMatcher_setSpeckleRange_int_speckleRange(void* instance, int speckleRange) {
    try {
        reinterpret_cast<cv::StereoMatcher*>(instance)->setSpeckleRange(speckleRange);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_StereoMatcher_getDisp12MaxDiff_const
// parsed: cv::StereoMatcher::getDisp12MaxDiff
// as:     cv::StereoMatcher::getDisp12MaxDiff (method) cv::StereoMatcher (trait) . getDisp12MaxDiff
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_StereoMatcher_getDisp12MaxDiff_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::StereoMatcher*>(instance)->getDisp12MaxDiff();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_StereoMatcher_setDisp12MaxDiff_int_disp12MaxDiff
// parsed: cv::StereoMatcher::setDisp12MaxDiff
// as:     cv::StereoMatcher::setDisp12MaxDiff (method) cv::StereoMatcher (trait) . setDisp12MaxDiff
// Arg ARG Primitive(int) disp12MaxDiff= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_StereoMatcher_setDisp12MaxDiff_int_disp12MaxDiff(void* instance, int disp12MaxDiff) {
    try {
        reinterpret_cast<cv::StereoMatcher*>(instance)->setDisp12MaxDiff(disp12MaxDiff);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_StereoSGBM_getPreFilterCap_const
// parsed: cv::StereoSGBM::getPreFilterCap
// as:     cv::StereoSGBM::getPreFilterCap (method) cv::StereoSGBM (trait) . getPreFilterCap
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_StereoSGBM_getPreFilterCap_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::StereoSGBM*>(instance)->getPreFilterCap();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_StereoSGBM_setPreFilterCap_int_preFilterCap
// parsed: cv::StereoSGBM::setPreFilterCap
// as:     cv::StereoSGBM::setPreFilterCap (method) cv::StereoSGBM (trait) . setPreFilterCap
// Arg ARG Primitive(int) preFilterCap= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_StereoSGBM_setPreFilterCap_int_preFilterCap(void* instance, int preFilterCap) {
    try {
        reinterpret_cast<cv::StereoSGBM*>(instance)->setPreFilterCap(preFilterCap);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_StereoSGBM_getUniquenessRatio_const
// parsed: cv::StereoSGBM::getUniquenessRatio
// as:     cv::StereoSGBM::getUniquenessRatio (method) cv::StereoSGBM (trait) . getUniquenessRatio
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_StereoSGBM_getUniquenessRatio_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::StereoSGBM*>(instance)->getUniquenessRatio();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_StereoSGBM_setUniquenessRatio_int_uniquenessRatio
// parsed: cv::StereoSGBM::setUniquenessRatio
// as:     cv::StereoSGBM::setUniquenessRatio (method) cv::StereoSGBM (trait) . setUniquenessRatio
// Arg ARG Primitive(int) uniquenessRatio= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_StereoSGBM_setUniquenessRatio_int_uniquenessRatio(void* instance, int uniquenessRatio) {
    try {
        reinterpret_cast<cv::StereoSGBM*>(instance)->setUniquenessRatio(uniquenessRatio);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_StereoSGBM_getP1_const
// parsed: cv::StereoSGBM::getP1
// as:     cv::StereoSGBM::getP1 (method) cv::StereoSGBM (trait) . getP1
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_StereoSGBM_getP1_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::StereoSGBM*>(instance)->getP1();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_StereoSGBM_setP1_int_P1
// parsed: cv::StereoSGBM::setP1
// as:     cv::StereoSGBM::setP1 (method) cv::StereoSGBM (trait) . setP1
// Arg ARG Primitive(int) P1= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_StereoSGBM_setP1_int_P1(void* instance, int P1) {
    try {
        reinterpret_cast<cv::StereoSGBM*>(instance)->setP1(P1);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_StereoSGBM_getP2_const
// parsed: cv::StereoSGBM::getP2
// as:     cv::StereoSGBM::getP2 (method) cv::StereoSGBM (trait) . getP2
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_StereoSGBM_getP2_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::StereoSGBM*>(instance)->getP2();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_StereoSGBM_setP2_int_P2
// parsed: cv::StereoSGBM::setP2
// as:     cv::StereoSGBM::setP2 (method) cv::StereoSGBM (trait) . setP2
// Arg ARG Primitive(int) P2= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_StereoSGBM_setP2_int_P2(void* instance, int P2) {
    try {
        reinterpret_cast<cv::StereoSGBM*>(instance)->setP2(P2);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_StereoSGBM_getMode_const
// parsed: cv::StereoSGBM::getMode
// as:     cv::StereoSGBM::getMode (method) cv::StereoSGBM (trait) . getMode
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_StereoSGBM_getMode_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::StereoSGBM*>(instance)->getMode();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_StereoSGBM_setMode_int_mode
// parsed: cv::StereoSGBM::setMode
// as:     cv::StereoSGBM::setMode (method) cv::StereoSGBM (trait) . setMode
// Arg ARG Primitive(int) mode= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_StereoSGBM_setMode_int_mode(void* instance, int mode) {
    try {
        reinterpret_cast<cv::StereoSGBM*>(instance)->setMode(mode);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_StereoSGBM_create_int_minDisparity_int_numDisparities_int_blockSize_int_P1_int_P2_int_disp12MaxDiff_int_preFilterCap_int_uniquenessRatio_int_speckleWindowSize_int_speckleRange_int_mode
// parsed: cv::StereoSGBM::create
// as:     cv::StereoSGBM::create (method) cv::StereoSGBM (trait) . create
// Arg ARG Primitive(int) minDisparity= Primitive(int) = 0
// Arg ARG Primitive(int) numDisparities= Primitive(int) = 16
// Arg ARG Primitive(int) blockSize= Primitive(int) = 3
// Arg ARG Primitive(int) P1= Primitive(int) = 0
// Arg ARG Primitive(int) P2= Primitive(int) = 0
// Arg ARG Primitive(int) disp12MaxDiff= Primitive(int) = 0
// Arg ARG Primitive(int) preFilterCap= Primitive(int) = 0
// Arg ARG Primitive(int) uniquenessRatio= Primitive(int) = 0
// Arg ARG Primitive(int) speckleWindowSize= Primitive(int) = 0
// Arg ARG Primitive(int) speckleRange= Primitive(int) = 0
// Arg ARG Primitive(int) mode= Primitive(int) = StereoSGBM::MODE_SGBM
// Return value: SmartPtr[cv::StereoSGBM (boxed)]
cv_return_value_void_X cv_core_cv_StereoSGBM_create_int_minDisparity_int_numDisparities_int_blockSize_int_P1_int_P2_int_disp12MaxDiff_int_preFilterCap_int_uniquenessRatio_int_speckleWindowSize_int_speckleRange_int_mode(int minDisparity, int numDisparities, int blockSize, int P1, int P2, int disp12MaxDiff, int preFilterCap, int uniquenessRatio, int speckleWindowSize, int speckleRange, int mode) {
    try {
        Ptr<cv::StereoSGBM> *ret = new Ptr<cv::StereoSGBM>(cv::StereoSGBM::create(minDisparity, numDisparities, blockSize, P1, P2, disp12MaxDiff, preFilterCap, uniquenessRatio, speckleWindowSize, speckleRange, mode));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// boxed class: cv::StereographicWarper
void cv_delete_StereographicWarper(void* instance) {
    delete (cv::StereographicWarper*) instance;
}
// boxed class: cv::Stitcher
void cv_delete_Stitcher(void* instance) {
    delete (cv::Stitcher*) instance;
}
// cv_Stitcher_createDefault_bool_try_use_gpu
// parsed: cv::Stitcher::createDefault
// as:     cv::Stitcher::createDefault (method) cv::Stitcher . createDefault
// Arg ARG Primitive(bool) try_use_gpu= Primitive(bool) = false
// Return value: cv::Stitcher (boxed)
cv_return_value_void_X cv_core_cv_Stitcher_createDefault_bool_try_use_gpu(bool try_use_gpu) {
    try {
        cv::Stitcher ret = cv::Stitcher::createDefault(try_use_gpu);
        return { Error::Code::StsOk, NULL, new cv::Stitcher(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_Stitcher_registrationResol_const
// parsed: cv::Stitcher::registrationResol
// as:     cv::Stitcher::registrationResol (method) cv::Stitcher . registrationResol
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_Stitcher_registrationResol_const(void* instance) {
    try {
        double ret = reinterpret_cast<cv::Stitcher*>(instance)->registrationResol();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_Stitcher_setRegistrationResol_double_resol_mpx
// parsed: cv::Stitcher::setRegistrationResol
// as:     cv::Stitcher::setRegistrationResol (method) cv::Stitcher . setRegistrationResol
// Arg ARG Primitive(double) resol_mpx= Primitive(double) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_Stitcher_setRegistrationResol_double_resol_mpx(void* instance, double resol_mpx) {
    try {
        reinterpret_cast<cv::Stitcher*>(instance)->setRegistrationResol(resol_mpx);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_Stitcher_seamEstimationResol_const
// parsed: cv::Stitcher::seamEstimationResol
// as:     cv::Stitcher::seamEstimationResol (method) cv::Stitcher . seamEstimationResol
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_Stitcher_seamEstimationResol_const(void* instance) {
    try {
        double ret = reinterpret_cast<cv::Stitcher*>(instance)->seamEstimationResol();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_Stitcher_setSeamEstimationResol_double_resol_mpx
// parsed: cv::Stitcher::setSeamEstimationResol
// as:     cv::Stitcher::setSeamEstimationResol (method) cv::Stitcher . setSeamEstimationResol
// Arg ARG Primitive(double) resol_mpx= Primitive(double) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_Stitcher_setSeamEstimationResol_double_resol_mpx(void* instance, double resol_mpx) {
    try {
        reinterpret_cast<cv::Stitcher*>(instance)->setSeamEstimationResol(resol_mpx);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_Stitcher_compositingResol_const
// parsed: cv::Stitcher::compositingResol
// as:     cv::Stitcher::compositingResol (method) cv::Stitcher . compositingResol
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_Stitcher_compositingResol_const(void* instance) {
    try {
        double ret = reinterpret_cast<cv::Stitcher*>(instance)->compositingResol();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_Stitcher_setCompositingResol_double_resol_mpx
// parsed: cv::Stitcher::setCompositingResol
// as:     cv::Stitcher::setCompositingResol (method) cv::Stitcher . setCompositingResol
// Arg ARG Primitive(double) resol_mpx= Primitive(double) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_Stitcher_setCompositingResol_double_resol_mpx(void* instance, double resol_mpx) {
    try {
        reinterpret_cast<cv::Stitcher*>(instance)->setCompositingResol(resol_mpx);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_Stitcher_panoConfidenceThresh_const
// parsed: cv::Stitcher::panoConfidenceThresh
// as:     cv::Stitcher::panoConfidenceThresh (method) cv::Stitcher . panoConfidenceThresh
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_Stitcher_panoConfidenceThresh_const(void* instance) {
    try {
        double ret = reinterpret_cast<cv::Stitcher*>(instance)->panoConfidenceThresh();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_Stitcher_setPanoConfidenceThresh_double_conf_thresh
// parsed: cv::Stitcher::setPanoConfidenceThresh
// as:     cv::Stitcher::setPanoConfidenceThresh (method) cv::Stitcher . setPanoConfidenceThresh
// Arg ARG Primitive(double) conf_thresh= Primitive(double) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_Stitcher_setPanoConfidenceThresh_double_conf_thresh(void* instance, double conf_thresh) {
    try {
        reinterpret_cast<cv::Stitcher*>(instance)->setPanoConfidenceThresh(conf_thresh);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_Stitcher_waveCorrection_const
// parsed: cv::Stitcher::waveCorrection
// as:     cv::Stitcher::waveCorrection (method) cv::Stitcher . waveCorrection
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_Stitcher_waveCorrection_const(void* instance) {
    try {
        bool ret = reinterpret_cast<cv::Stitcher*>(instance)->waveCorrection();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_Stitcher_setWaveCorrection_bool_flag
// parsed: cv::Stitcher::setWaveCorrection
// as:     cv::Stitcher::setWaveCorrection (method) cv::Stitcher . setWaveCorrection
// Arg ARG Primitive(bool) flag= Primitive(bool) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_Stitcher_setWaveCorrection_bool_flag(void* instance, bool flag) {
    try {
        reinterpret_cast<cv::Stitcher*>(instance)->setWaveCorrection(flag);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_Stitcher_matchingMask_const
// parsed: cv::Stitcher::matchingMask
// as:     cv::Stitcher::matchingMask (method) cv::Stitcher . matchingMask
// Return value: cv::UMat (boxed)
cv_return_value_void_X cv_core_cv_Stitcher_matchingMask_const(void* instance) {
    try {
        cv::UMat ret = reinterpret_cast<cv::Stitcher*>(instance)->matchingMask();
        return { Error::Code::StsOk, NULL, new cv::UMat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_Stitcher_setMatchingMask_UMat_mask
// parsed: cv::Stitcher::setMatchingMask
// as:     cv::Stitcher::setMatchingMask (method) cv::Stitcher . setMatchingMask
// Arg ARG cv::UMat (boxed) mask= cv::UMat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_Stitcher_setMatchingMask_UMat_mask(void* instance, void* mask) {
    try {
        reinterpret_cast<cv::Stitcher*>(instance)->setMatchingMask(*reinterpret_cast<cv::UMat*>(mask));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_Stitcher_component_const
// parsed: cv::Stitcher::component
// as:     cv::Stitcher::component (method) cv::Stitcher . component
// Return value: Vector[Primitive(int)]
cv_return_value_void_X cv_core_cv_Stitcher_component_const(void* instance) {
    try {
        std::vector<int> ret = reinterpret_cast<cv::Stitcher*>(instance)->component();
        return { Error::Code::StsOk, NULL, (void *)new std::vector<int>(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_Stitcher_workScale_const
// parsed: cv::Stitcher::workScale
// as:     cv::Stitcher::workScale (method) cv::Stitcher . workScale
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_Stitcher_workScale_const(void* instance) {
    try {
        double ret = reinterpret_cast<cv::Stitcher*>(instance)->workScale();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// boxed class: cv::Subdiv2D
void cv_delete_Subdiv2D(void* instance) {
    delete (cv::Subdiv2D*) instance;
}
// cv_Subdiv2D_Subdiv2D
// parsed: cv::Subdiv2D::Subdiv2D
// as:     cv::Subdiv2D::Subdiv2D (constructor) cv::Subdiv2D . new
// Return value: cv::Subdiv2D (boxed)
cv_return_value_void_X cv_core_cv_Subdiv2D_Subdiv2D() {
    try {
        cv::Subdiv2D* ret = new cv::Subdiv2D();
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_Subdiv2D_Subdiv2D_Rect_rect
// parsed: cv::Subdiv2D::Subdiv2D
// as:     cv::Subdiv2D::Subdiv2D (constructor) cv::Subdiv2D . new
// Arg ARG cv::Rect (simple) rect= cv::Rect (simple) = 
// Return value: cv::Subdiv2D (boxed)
cv_return_value_void_X cv_core_cv_Subdiv2D_Subdiv2D_Rect_rect(RectWrapper rect) {
    try {
        cv::Subdiv2D* ret = new cv::Subdiv2D(*reinterpret_cast<cv::Rect*>(&rect));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_Subdiv2D_initDelaunay_Rect_rect
// parsed: cv::Subdiv2D::initDelaunay
// as:     cv::Subdiv2D::initDelaunay (method) cv::Subdiv2D . initDelaunay
// Arg ARG cv::Rect (simple) rect= cv::Rect (simple) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_Subdiv2D_initDelaunay_Rect_rect(void* instance, RectWrapper rect) {
    try {
        reinterpret_cast<cv::Subdiv2D*>(instance)->initDelaunay(*reinterpret_cast<cv::Rect*>(&rect));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_Subdiv2D_insert_Point2f_pt
// parsed: cv::Subdiv2D::insert
// as:     cv::Subdiv2D::insert (method) cv::Subdiv2D . insert
// Arg ARG cv::Point2f (simple) pt= cv::Point2f (simple) = 
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_Subdiv2D_insert_Point2f_pt(void* instance, Point2fWrapper pt) {
    try {
        int ret = reinterpret_cast<cv::Subdiv2D*>(instance)->insert(*reinterpret_cast<cv::Point2f*>(&pt));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_Subdiv2D_insert_VectorOfPoint2f_ptvec
// parsed: cv::Subdiv2D::insert
// as:     cv::Subdiv2D::insert (method) cv::Subdiv2D . insert
// Arg ARG Vector[cv::Point2f (simple)] ptvec= Vector[cv::Point2f (simple)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_Subdiv2D_insert_VectorOfPoint2f_ptvec(void* instance, void* ptvec) {
    try {
        reinterpret_cast<cv::Subdiv2D*>(instance)->insert(*reinterpret_cast<std::vector<cv::Point2f>*>(ptvec));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_Subdiv2D_locate_Point2f_pt_int_edge_int_vertex
// parsed: cv::Subdiv2D::locate
// as:     cv::Subdiv2D::locate (method) cv::Subdiv2D . locate
// Arg ARG cv::Point2f (simple) pt= cv::Point2f (simple) = 
// Arg ARG Primitive(int) edge= Primitive(int) = 
// Arg ARG Primitive(int) vertex= Primitive(int) = 
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_Subdiv2D_locate_Point2f_pt_int_edge_int_vertex(void* instance, Point2fWrapper pt, int edge, int vertex) {
    try {
        int ret = reinterpret_cast<cv::Subdiv2D*>(instance)->locate(*reinterpret_cast<cv::Point2f*>(&pt), edge, vertex);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_Subdiv2D_findNearest_Point2f_pt_Point2f_X_nearestPt
// parsed: cv::Subdiv2D::findNearest
// as:     cv::Subdiv2D::findNearest (method) cv::Subdiv2D . findNearest
// Arg ARG cv::Point2f (simple) pt= cv::Point2f (simple) = 
// Arg ARG RawPtr[cv::Point2f (simple)] * nearestPt= (ptr) RawPtr[cv::Point2f (simple)] = 0
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_Subdiv2D_findNearest_Point2f_pt_Point2f_X_nearestPt(void* instance, Point2fWrapper pt, cv::Point2f* nearestPt) {
    try {
        int ret = reinterpret_cast<cv::Subdiv2D*>(instance)->findNearest(*reinterpret_cast<cv::Point2f*>(&pt), reinterpret_cast<cv::Point2f*>(&nearestPt));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_Subdiv2D_getEdgeList_const_VectorOfVec4f_edgeList
// parsed: cv::Subdiv2D::getEdgeList
// as:     cv::Subdiv2D::getEdgeList (method) cv::Subdiv2D . getEdgeList
// Arg ARG Vector[cv::Vec4f (simple)] edgeList= Vector[cv::Vec4f (simple)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_Subdiv2D_getEdgeList_const_VectorOfVec4f_edgeList(void* instance, void* edgeList) {
    try {
        reinterpret_cast<cv::Subdiv2D*>(instance)->getEdgeList(*reinterpret_cast<std::vector<cv::Vec4f>*>(edgeList));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_Subdiv2D_getLeadingEdgeList_const_VectorOfint_leadingEdgeList
// parsed: cv::Subdiv2D::getLeadingEdgeList
// as:     cv::Subdiv2D::getLeadingEdgeList (method) cv::Subdiv2D . getLeadingEdgeList
// Arg ARG Vector[Primitive(int)] leadingEdgeList= Vector[Primitive(int)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_Subdiv2D_getLeadingEdgeList_const_VectorOfint_leadingEdgeList(void* instance, void* leadingEdgeList) {
    try {
        reinterpret_cast<cv::Subdiv2D*>(instance)->getLeadingEdgeList(*reinterpret_cast<std::vector<int>*>(leadingEdgeList));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_Subdiv2D_getTriangleList_const_VectorOfVec6f_triangleList
// parsed: cv::Subdiv2D::getTriangleList
// as:     cv::Subdiv2D::getTriangleList (method) cv::Subdiv2D . getTriangleList
// Arg ARG Vector[cv::Vec6f (simple)] triangleList= Vector[cv::Vec6f (simple)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_Subdiv2D_getTriangleList_const_VectorOfVec6f_triangleList(void* instance, void* triangleList) {
    try {
        reinterpret_cast<cv::Subdiv2D*>(instance)->getTriangleList(*reinterpret_cast<std::vector<cv::Vec6f>*>(triangleList));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_Subdiv2D_getVoronoiFacetList_VectorOfint_idx_VectorOfVectorOfPoint2f_facetList_VectorOfPoint2f_facetCenters
// parsed: cv::Subdiv2D::getVoronoiFacetList
// as:     cv::Subdiv2D::getVoronoiFacetList (method) cv::Subdiv2D . getVoronoiFacetList
// Arg ARG Vector[Primitive(int)] idx= Vector[Primitive(int)] = 
// Arg ARG Vector[Vector[cv::Point2f (simple)]] facetList= Vector[Vector[cv::Point2f (simple)]] = 
// Arg ARG Vector[cv::Point2f (simple)] facetCenters= Vector[cv::Point2f (simple)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_Subdiv2D_getVoronoiFacetList_VectorOfint_idx_VectorOfVectorOfPoint2f_facetList_VectorOfPoint2f_facetCenters(void* instance, void* idx, void* facetList, void* facetCenters) {
    try {
        reinterpret_cast<cv::Subdiv2D*>(instance)->getVoronoiFacetList(*reinterpret_cast<std::vector<int>*>(idx), *reinterpret_cast<std::vector<std::vector<cv::Point2f>>*>(facetList), *reinterpret_cast<std::vector<cv::Point2f>*>(facetCenters));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_Subdiv2D_getVertex_const_int_vertex_int_X_firstEdge
// parsed: cv::Subdiv2D::getVertex
// as:     cv::Subdiv2D::getVertex (method) cv::Subdiv2D . getVertex
// Arg ARG Primitive(int) vertex= Primitive(int) = 
// Arg ARG RawPtr[Primitive(int)] * firstEdge= (ptr) RawPtr[Primitive(int)] = 0
// Return value: cv::Point2f (simple)
cv_return_value_Point2fWrapper cv_core_cv_Subdiv2D_getVertex_const_int_vertex_int_X_firstEdge(void* instance, int vertex, int* firstEdge) {
    try {
        cv::Point2f ret = reinterpret_cast<cv::Subdiv2D*>(instance)->getVertex(vertex, firstEdge);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<Point2fWrapper*>(&ret) };
    } CVRS_CATCH(cv_return_value_Point2fWrapper)
}

// cv_Subdiv2D_getEdge_const_int_edge_int_nextEdgeType
// parsed: cv::Subdiv2D::getEdge
// as:     cv::Subdiv2D::getEdge (method) cv::Subdiv2D . getEdge
// Arg ARG Primitive(int) edge= Primitive(int) = 
// Arg ARG Primitive(int) nextEdgeType= Primitive(int) = 
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_Subdiv2D_getEdge_const_int_edge_int_nextEdgeType(void* instance, int edge, int nextEdgeType) {
    try {
        int ret = reinterpret_cast<cv::Subdiv2D*>(instance)->getEdge(edge, nextEdgeType);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_Subdiv2D_nextEdge_const_int_edge
// parsed: cv::Subdiv2D::nextEdge
// as:     cv::Subdiv2D::nextEdge (method) cv::Subdiv2D . nextEdge
// Arg ARG Primitive(int) edge= Primitive(int) = 
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_Subdiv2D_nextEdge_const_int_edge(void* instance, int edge) {
    try {
        int ret = reinterpret_cast<cv::Subdiv2D*>(instance)->nextEdge(edge);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_Subdiv2D_rotateEdge_const_int_edge_int_rotate
// parsed: cv::Subdiv2D::rotateEdge
// as:     cv::Subdiv2D::rotateEdge (method) cv::Subdiv2D . rotateEdge
// Arg ARG Primitive(int) edge= Primitive(int) = 
// Arg ARG Primitive(int) rotate= Primitive(int) = 
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_Subdiv2D_rotateEdge_const_int_edge_int_rotate(void* instance, int edge, int rotate) {
    try {
        int ret = reinterpret_cast<cv::Subdiv2D*>(instance)->rotateEdge(edge, rotate);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_Subdiv2D_symEdge_const_int_edge
// parsed: cv::Subdiv2D::symEdge
// as:     cv::Subdiv2D::symEdge (method) cv::Subdiv2D . symEdge
// Arg ARG Primitive(int) edge= Primitive(int) = 
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_Subdiv2D_symEdge_const_int_edge(void* instance, int edge) {
    try {
        int ret = reinterpret_cast<cv::Subdiv2D*>(instance)->symEdge(edge);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_Subdiv2D_edgeOrg_const_int_edge_Point2f_X_orgpt
// parsed: cv::Subdiv2D::edgeOrg
// as:     cv::Subdiv2D::edgeOrg (method) cv::Subdiv2D . edgeOrg
// Arg ARG Primitive(int) edge= Primitive(int) = 
// Arg ARG RawPtr[cv::Point2f (simple)] * orgpt= (ptr) RawPtr[cv::Point2f (simple)] = 0
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_Subdiv2D_edgeOrg_const_int_edge_Point2f_X_orgpt(void* instance, int edge, cv::Point2f* orgpt) {
    try {
        int ret = reinterpret_cast<cv::Subdiv2D*>(instance)->edgeOrg(edge, reinterpret_cast<cv::Point2f*>(&orgpt));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_Subdiv2D_edgeDst_const_int_edge_Point2f_X_dstpt
// parsed: cv::Subdiv2D::edgeDst
// as:     cv::Subdiv2D::edgeDst (method) cv::Subdiv2D . edgeDst
// Arg ARG Primitive(int) edge= Primitive(int) = 
// Arg ARG RawPtr[cv::Point2f (simple)] * dstpt= (ptr) RawPtr[cv::Point2f (simple)] = 0
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_Subdiv2D_edgeDst_const_int_edge_Point2f_X_dstpt(void* instance, int edge, cv::Point2f* dstpt) {
    try {
        int ret = reinterpret_cast<cv::Subdiv2D*>(instance)->edgeDst(edge, reinterpret_cast<cv::Point2f*>(&dstpt));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// boxed class: cv::TermCriteria
void cv_delete_TermCriteria(void* instance) {
    delete (cv::TermCriteria*) instance;
}
// cv_TermCriteria_TermCriteria
// parsed: cv::TermCriteria::TermCriteria
// as:     cv::TermCriteria::TermCriteria (constructor) cv::TermCriteria . new
// Return value: cv::TermCriteria (boxed)
cv_return_value_void_X cv_core_cv_TermCriteria_TermCriteria() {
    try {
        cv::TermCriteria* ret = new cv::TermCriteria();
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_TermCriteria_TermCriteria_int_type_int_maxCount_double_epsilon
// parsed: cv::TermCriteria::TermCriteria
// as:     cv::TermCriteria::TermCriteria (constructor) cv::TermCriteria . new
// Arg ARG Primitive(int) type= Primitive(int) = 
// Arg ARG Primitive(int) maxCount= Primitive(int) = 
// Arg ARG Primitive(double) epsilon= Primitive(double) = 
// Return value: cv::TermCriteria (boxed)
cv_return_value_void_X cv_core_cv_TermCriteria_TermCriteria_int_type_int_maxCount_double_epsilon(int type, int maxCount, double epsilon) {
    try {
        cv::TermCriteria* ret = new cv::TermCriteria(type, maxCount, epsilon);
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_TermCriteria_isValid_const
// parsed: cv::TermCriteria::isValid
// as:     cv::TermCriteria::isValid (method) cv::TermCriteria . isValid
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_TermCriteria_isValid_const(void* instance) {
    try {
        bool ret = reinterpret_cast<cv::TermCriteria*>(instance)->isValid();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_ThinPlateSplineShapeTransformer_setRegularizationParameter_double_beta
// parsed: cv::ThinPlateSplineShapeTransformer::setRegularizationParameter
// as:     cv::ThinPlateSplineShapeTransformer::setRegularizationParameter (method) cv::ThinPlateSplineShapeTransformer (trait) . setRegularizationParameter
// Arg ARG Primitive(double) beta= Primitive(double) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ThinPlateSplineShapeTransformer_setRegularizationParameter_double_beta(void* instance, double beta) {
    try {
        reinterpret_cast<cv::ThinPlateSplineShapeTransformer*>(instance)->setRegularizationParameter(beta);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ThinPlateSplineShapeTransformer_getRegularizationParameter_const
// parsed: cv::ThinPlateSplineShapeTransformer::getRegularizationParameter
// as:     cv::ThinPlateSplineShapeTransformer::getRegularizationParameter (method) cv::ThinPlateSplineShapeTransformer (trait) . getRegularizationParameter
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_ThinPlateSplineShapeTransformer_getRegularizationParameter_const(void* instance) {
    try {
        double ret = reinterpret_cast<cv::ThinPlateSplineShapeTransformer*>(instance)->getRegularizationParameter();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// boxed class: cv::TickMeter
void cv_delete_TickMeter(void* instance) {
    delete (cv::TickMeter*) instance;
}
// cv_TickMeter_TickMeter
// parsed: cv::TickMeter::TickMeter
// as:     cv::TickMeter::TickMeter (constructor) cv::TickMeter . new
// Return value: cv::TickMeter (boxed)
cv_return_value_void_X cv_core_cv_TickMeter_TickMeter() {
    try {
        cv::TickMeter* ret = new cv::TickMeter();
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_TickMeter_start
// parsed: cv::TickMeter::start
// as:     cv::TickMeter::start (method) cv::TickMeter . start
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_TickMeter_start(void* instance) {
    try {
        reinterpret_cast<cv::TickMeter*>(instance)->start();
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_TickMeter_stop
// parsed: cv::TickMeter::stop
// as:     cv::TickMeter::stop (method) cv::TickMeter . stop
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_TickMeter_stop(void* instance) {
    try {
        reinterpret_cast<cv::TickMeter*>(instance)->stop();
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_TickMeter_getTimeTicks_const
// parsed: cv::TickMeter::getTimeTicks
// as:     cv::TickMeter::getTimeTicks (method) cv::TickMeter . getTimeTicks
// Return value: Primitive(int64)
cv_return_value_int64 cv_core_cv_TickMeter_getTimeTicks_const(void* instance) {
    try {
        int64 ret = reinterpret_cast<cv::TickMeter*>(instance)->getTimeTicks();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int64*>(&ret) };
    } CVRS_CATCH(cv_return_value_int64)
}

// cv_TickMeter_getTimeMicro_const
// parsed: cv::TickMeter::getTimeMicro
// as:     cv::TickMeter::getTimeMicro (method) cv::TickMeter . getTimeMicro
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_TickMeter_getTimeMicro_const(void* instance) {
    try {
        double ret = reinterpret_cast<cv::TickMeter*>(instance)->getTimeMicro();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_TickMeter_getTimeMilli_const
// parsed: cv::TickMeter::getTimeMilli
// as:     cv::TickMeter::getTimeMilli (method) cv::TickMeter . getTimeMilli
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_TickMeter_getTimeMilli_const(void* instance) {
    try {
        double ret = reinterpret_cast<cv::TickMeter*>(instance)->getTimeMilli();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_TickMeter_getTimeSec_const
// parsed: cv::TickMeter::getTimeSec
// as:     cv::TickMeter::getTimeSec (method) cv::TickMeter . getTimeSec
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_TickMeter_getTimeSec_const(void* instance) {
    try {
        double ret = reinterpret_cast<cv::TickMeter*>(instance)->getTimeSec();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_TickMeter_getCounter_const
// parsed: cv::TickMeter::getCounter
// as:     cv::TickMeter::getCounter (method) cv::TickMeter . getCounter
// Return value: Primitive(int64)
cv_return_value_int64 cv_core_cv_TickMeter_getCounter_const(void* instance) {
    try {
        int64 ret = reinterpret_cast<cv::TickMeter*>(instance)->getCounter();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int64*>(&ret) };
    } CVRS_CATCH(cv_return_value_int64)
}

// cv_TickMeter_reset
// parsed: cv::TickMeter::reset
// as:     cv::TickMeter::reset (method) cv::TickMeter . reset
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_TickMeter_reset(void* instance) {
    try {
        reinterpret_cast<cv::TickMeter*>(instance)->reset();
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_Tonemap_process_Mat_src_Mat_dst
// parsed: cv::Tonemap::process
// as:     cv::Tonemap::process (method) cv::Tonemap (trait) . process
// Arg ARG cv::Mat (boxed) src= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) dst= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_Tonemap_process_Mat_src_Mat_dst(void* instance, void* src, void* dst) {
    try {
        reinterpret_cast<cv::Tonemap*>(instance)->process(*reinterpret_cast<cv::Mat*>(src), *reinterpret_cast<cv::Mat*>(dst));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_Tonemap_getGamma_const
// parsed: cv::Tonemap::getGamma
// as:     cv::Tonemap::getGamma (method) cv::Tonemap (trait) . getGamma
// Return value: Primitive(float)
cv_return_value_float cv_core_cv_Tonemap_getGamma_const(void* instance) {
    try {
        float ret = reinterpret_cast<cv::Tonemap*>(instance)->getGamma();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<float*>(&ret) };
    } CVRS_CATCH(cv_return_value_float)
}

// cv_Tonemap_setGamma_float_gamma
// parsed: cv::Tonemap::setGamma
// as:     cv::Tonemap::setGamma (method) cv::Tonemap (trait) . setGamma
// Arg ARG Primitive(float) gamma= Primitive(float) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_Tonemap_setGamma_float_gamma(void* instance, float gamma) {
    try {
        reinterpret_cast<cv::Tonemap*>(instance)->setGamma(gamma);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_TonemapDrago_getSaturation_const
// parsed: cv::TonemapDrago::getSaturation
// as:     cv::TonemapDrago::getSaturation (method) cv::TonemapDrago (trait) . getSaturation
// Return value: Primitive(float)
cv_return_value_float cv_core_cv_TonemapDrago_getSaturation_const(void* instance) {
    try {
        float ret = reinterpret_cast<cv::TonemapDrago*>(instance)->getSaturation();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<float*>(&ret) };
    } CVRS_CATCH(cv_return_value_float)
}

// cv_TonemapDrago_setSaturation_float_saturation
// parsed: cv::TonemapDrago::setSaturation
// as:     cv::TonemapDrago::setSaturation (method) cv::TonemapDrago (trait) . setSaturation
// Arg ARG Primitive(float) saturation= Primitive(float) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_TonemapDrago_setSaturation_float_saturation(void* instance, float saturation) {
    try {
        reinterpret_cast<cv::TonemapDrago*>(instance)->setSaturation(saturation);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_TonemapDrago_getBias_const
// parsed: cv::TonemapDrago::getBias
// as:     cv::TonemapDrago::getBias (method) cv::TonemapDrago (trait) . getBias
// Return value: Primitive(float)
cv_return_value_float cv_core_cv_TonemapDrago_getBias_const(void* instance) {
    try {
        float ret = reinterpret_cast<cv::TonemapDrago*>(instance)->getBias();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<float*>(&ret) };
    } CVRS_CATCH(cv_return_value_float)
}

// cv_TonemapDrago_setBias_float_bias
// parsed: cv::TonemapDrago::setBias
// as:     cv::TonemapDrago::setBias (method) cv::TonemapDrago (trait) . setBias
// Arg ARG Primitive(float) bias= Primitive(float) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_TonemapDrago_setBias_float_bias(void* instance, float bias) {
    try {
        reinterpret_cast<cv::TonemapDrago*>(instance)->setBias(bias);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_TonemapMantiuk_getScale_const
// parsed: cv::TonemapMantiuk::getScale
// as:     cv::TonemapMantiuk::getScale (method) cv::TonemapMantiuk (trait) . getScale
// Return value: Primitive(float)
cv_return_value_float cv_core_cv_TonemapMantiuk_getScale_const(void* instance) {
    try {
        float ret = reinterpret_cast<cv::TonemapMantiuk*>(instance)->getScale();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<float*>(&ret) };
    } CVRS_CATCH(cv_return_value_float)
}

// cv_TonemapMantiuk_setScale_float_scale
// parsed: cv::TonemapMantiuk::setScale
// as:     cv::TonemapMantiuk::setScale (method) cv::TonemapMantiuk (trait) . setScale
// Arg ARG Primitive(float) scale= Primitive(float) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_TonemapMantiuk_setScale_float_scale(void* instance, float scale) {
    try {
        reinterpret_cast<cv::TonemapMantiuk*>(instance)->setScale(scale);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_TonemapMantiuk_getSaturation_const
// parsed: cv::TonemapMantiuk::getSaturation
// as:     cv::TonemapMantiuk::getSaturation (method) cv::TonemapMantiuk (trait) . getSaturation
// Return value: Primitive(float)
cv_return_value_float cv_core_cv_TonemapMantiuk_getSaturation_const(void* instance) {
    try {
        float ret = reinterpret_cast<cv::TonemapMantiuk*>(instance)->getSaturation();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<float*>(&ret) };
    } CVRS_CATCH(cv_return_value_float)
}

// cv_TonemapMantiuk_setSaturation_float_saturation
// parsed: cv::TonemapMantiuk::setSaturation
// as:     cv::TonemapMantiuk::setSaturation (method) cv::TonemapMantiuk (trait) . setSaturation
// Arg ARG Primitive(float) saturation= Primitive(float) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_TonemapMantiuk_setSaturation_float_saturation(void* instance, float saturation) {
    try {
        reinterpret_cast<cv::TonemapMantiuk*>(instance)->setSaturation(saturation);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_TonemapReinhard_getIntensity_const
// parsed: cv::TonemapReinhard::getIntensity
// as:     cv::TonemapReinhard::getIntensity (method) cv::TonemapReinhard (trait) . getIntensity
// Return value: Primitive(float)
cv_return_value_float cv_core_cv_TonemapReinhard_getIntensity_const(void* instance) {
    try {
        float ret = reinterpret_cast<cv::TonemapReinhard*>(instance)->getIntensity();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<float*>(&ret) };
    } CVRS_CATCH(cv_return_value_float)
}

// cv_TonemapReinhard_setIntensity_float_intensity
// parsed: cv::TonemapReinhard::setIntensity
// as:     cv::TonemapReinhard::setIntensity (method) cv::TonemapReinhard (trait) . setIntensity
// Arg ARG Primitive(float) intensity= Primitive(float) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_TonemapReinhard_setIntensity_float_intensity(void* instance, float intensity) {
    try {
        reinterpret_cast<cv::TonemapReinhard*>(instance)->setIntensity(intensity);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_TonemapReinhard_getLightAdaptation_const
// parsed: cv::TonemapReinhard::getLightAdaptation
// as:     cv::TonemapReinhard::getLightAdaptation (method) cv::TonemapReinhard (trait) . getLightAdaptation
// Return value: Primitive(float)
cv_return_value_float cv_core_cv_TonemapReinhard_getLightAdaptation_const(void* instance) {
    try {
        float ret = reinterpret_cast<cv::TonemapReinhard*>(instance)->getLightAdaptation();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<float*>(&ret) };
    } CVRS_CATCH(cv_return_value_float)
}

// cv_TonemapReinhard_setLightAdaptation_float_light_adapt
// parsed: cv::TonemapReinhard::setLightAdaptation
// as:     cv::TonemapReinhard::setLightAdaptation (method) cv::TonemapReinhard (trait) . setLightAdaptation
// Arg ARG Primitive(float) light_adapt= Primitive(float) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_TonemapReinhard_setLightAdaptation_float_light_adapt(void* instance, float light_adapt) {
    try {
        reinterpret_cast<cv::TonemapReinhard*>(instance)->setLightAdaptation(light_adapt);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_TonemapReinhard_getColorAdaptation_const
// parsed: cv::TonemapReinhard::getColorAdaptation
// as:     cv::TonemapReinhard::getColorAdaptation (method) cv::TonemapReinhard (trait) . getColorAdaptation
// Return value: Primitive(float)
cv_return_value_float cv_core_cv_TonemapReinhard_getColorAdaptation_const(void* instance) {
    try {
        float ret = reinterpret_cast<cv::TonemapReinhard*>(instance)->getColorAdaptation();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<float*>(&ret) };
    } CVRS_CATCH(cv_return_value_float)
}

// cv_TonemapReinhard_setColorAdaptation_float_color_adapt
// parsed: cv::TonemapReinhard::setColorAdaptation
// as:     cv::TonemapReinhard::setColorAdaptation (method) cv::TonemapReinhard (trait) . setColorAdaptation
// Arg ARG Primitive(float) color_adapt= Primitive(float) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_TonemapReinhard_setColorAdaptation_float_color_adapt(void* instance, float color_adapt) {
    try {
        reinterpret_cast<cv::TonemapReinhard*>(instance)->setColorAdaptation(color_adapt);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// boxed class: cv::TransverseMercatorWarper
void cv_delete_TransverseMercatorWarper(void* instance) {
    delete (cv::TransverseMercatorWarper*) instance;
}
// boxed class: cv::UMat
void cv_delete_UMat(void* instance) {
    delete (cv::UMat*) instance;
}
// cv_UMat_getMat_const_int_flags
// parsed: cv::UMat::getMat
// as:     cv::UMat::getMat (method) cv::UMat . getMat
// Arg ARG Primitive(int) flags= Primitive(int) = 
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_UMat_getMat_const_int_flags(void* instance, int flags) {
    try {
        cv::Mat ret = reinterpret_cast<cv::UMat*>(instance)->getMat(flags);
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_UMat_copyTo_const_Mat_m
// parsed: cv::UMat::copyTo
// as:     cv::UMat::copyTo (method) cv::UMat . copyTo
// Arg ARG cv::Mat (boxed) m= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_UMat_copyTo_const_Mat_m(void* instance, void* m) {
    try {
        reinterpret_cast<cv::UMat*>(instance)->copyTo(*reinterpret_cast<cv::Mat*>(m));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_UMat_copyTo_const_Mat_m_Mat_mask
// parsed: cv::UMat::copyTo
// as:     cv::UMat::copyTo (method) cv::UMat . copyTo
// Arg ARG cv::Mat (boxed) m= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) mask= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_UMat_copyTo_const_Mat_m_Mat_mask(void* instance, void* m, void* mask) {
    try {
        reinterpret_cast<cv::UMat*>(instance)->copyTo(*reinterpret_cast<cv::Mat*>(m), *reinterpret_cast<cv::Mat*>(mask));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_UMat_convertTo_const_Mat_m_int_rtype_double_alpha_double_beta
// parsed: cv::UMat::convertTo
// as:     cv::UMat::convertTo (method) cv::UMat . convertTo
// Arg ARG cv::Mat (boxed) m= cv::Mat (boxed) = 
// Arg ARG Primitive(int) rtype= Primitive(int) = 
// Arg ARG Primitive(double) alpha= Primitive(double) = 1
// Arg ARG Primitive(double) beta= Primitive(double) = 0
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_UMat_convertTo_const_Mat_m_int_rtype_double_alpha_double_beta(void* instance, void* m, int rtype, double alpha, double beta) {
    try {
        reinterpret_cast<cv::UMat*>(instance)->convertTo(*reinterpret_cast<cv::Mat*>(m), rtype, alpha, beta);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_UMat_dot_const_Mat_m
// parsed: cv::UMat::dot
// as:     cv::UMat::dot (method) cv::UMat . dot
// Arg ARG cv::Mat (boxed) m= cv::Mat (boxed) = 
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_UMat_dot_const_Mat_m(void* instance, void* m) {
    try {
        double ret = reinterpret_cast<cv::UMat*>(instance)->dot(*reinterpret_cast<cv::Mat*>(m));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_UMat_addref
// parsed: cv::UMat::addref
// as:     cv::UMat::addref (method) cv::UMat . addref
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_UMat_addref(void* instance) {
    try {
        reinterpret_cast<cv::UMat*>(instance)->addref();
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_UMat_release
// parsed: cv::UMat::release
// as:     cv::UMat::release (method) cv::UMat . release
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_UMat_release(void* instance) {
    try {
        reinterpret_cast<cv::UMat*>(instance)->release();
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_UMat_deallocate
// parsed: cv::UMat::deallocate
// as:     cv::UMat::deallocate (method) cv::UMat . deallocate
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_UMat_deallocate(void* instance) {
    try {
        reinterpret_cast<cv::UMat*>(instance)->deallocate();
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_UMat_locateROI_const_Size_wholeSize_Point_ofs
// parsed: cv::UMat::locateROI
// as:     cv::UMat::locateROI (method) cv::UMat . locateROI
// Arg ARG cv::Size (simple) wholeSize= cv::Size (simple) = 
// Arg ARG cv::Point (simple) ofs= cv::Point (simple) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_UMat_locateROI_const_Size_wholeSize_Point_ofs(void* instance, SizeWrapper wholeSize, PointWrapper ofs) {
    try {
        reinterpret_cast<cv::UMat*>(instance)->locateROI(*reinterpret_cast<cv::Size*>(&wholeSize), *reinterpret_cast<cv::Point*>(&ofs));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_UMat_isContinuous_const
// parsed: cv::UMat::isContinuous
// as:     cv::UMat::isContinuous (method) cv::UMat . isContinuous
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_UMat_isContinuous_const(void* instance) {
    try {
        bool ret = reinterpret_cast<cv::UMat*>(instance)->isContinuous();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_UMat_isSubmatrix_const
// parsed: cv::UMat::isSubmatrix
// as:     cv::UMat::isSubmatrix (method) cv::UMat . isSubmatrix
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_UMat_isSubmatrix_const(void* instance) {
    try {
        bool ret = reinterpret_cast<cv::UMat*>(instance)->isSubmatrix();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_UMat_elemSize_const
// parsed: cv::UMat::elemSize
// as:     cv::UMat::elemSize (method) cv::UMat . elemSize
// Return value: Primitive(size_t)
cv_return_value_std_size_t cv_core_cv_UMat_elemSize_const(void* instance) {
    try {
        size_t ret = reinterpret_cast<cv::UMat*>(instance)->elemSize();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<std::size_t*>(&ret) };
    } CVRS_CATCH(cv_return_value_std_size_t)
}

// cv_UMat_elemSize1_const
// parsed: cv::UMat::elemSize1
// as:     cv::UMat::elemSize1 (method) cv::UMat . elemSize1
// Return value: Primitive(size_t)
cv_return_value_std_size_t cv_core_cv_UMat_elemSize1_const(void* instance) {
    try {
        size_t ret = reinterpret_cast<cv::UMat*>(instance)->elemSize1();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<std::size_t*>(&ret) };
    } CVRS_CATCH(cv_return_value_std_size_t)
}

// cv_UMat_type_const
// parsed: cv::UMat::type
// as:     cv::UMat::type (method) cv::UMat . type
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_UMat_type_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::UMat*>(instance)->type();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_UMat_depth_const
// parsed: cv::UMat::depth
// as:     cv::UMat::depth (method) cv::UMat . depth
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_UMat_depth_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::UMat*>(instance)->depth();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_UMat_channels_const
// parsed: cv::UMat::channels
// as:     cv::UMat::channels (method) cv::UMat . channels
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_UMat_channels_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::UMat*>(instance)->channels();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_UMat_step1_const_int_i
// parsed: cv::UMat::step1
// as:     cv::UMat::step1 (method) cv::UMat . step1
// Arg ARG Primitive(int) i= Primitive(int) = 0
// Return value: Primitive(size_t)
cv_return_value_std_size_t cv_core_cv_UMat_step1_const_int_i(void* instance, int i) {
    try {
        size_t ret = reinterpret_cast<cv::UMat*>(instance)->step1(i);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<std::size_t*>(&ret) };
    } CVRS_CATCH(cv_return_value_std_size_t)
}

// cv_UMat_empty_const
// parsed: cv::UMat::empty
// as:     cv::UMat::empty (method) cv::UMat . empty
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_UMat_empty_const(void* instance) {
    try {
        bool ret = reinterpret_cast<cv::UMat*>(instance)->empty();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_UMat_total_const
// parsed: cv::UMat::total
// as:     cv::UMat::total (method) cv::UMat . total
// Return value: Primitive(size_t)
cv_return_value_std_size_t cv_core_cv_UMat_total_const(void* instance) {
    try {
        size_t ret = reinterpret_cast<cv::UMat*>(instance)->total();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<std::size_t*>(&ret) };
    } CVRS_CATCH(cv_return_value_std_size_t)
}

// cv_UMat_checkVector_const_int_elemChannels_int_depth_bool_requireContinuous
// parsed: cv::UMat::checkVector
// as:     cv::UMat::checkVector (method) cv::UMat . checkVector
// Arg ARG Primitive(int) elemChannels= Primitive(int) = 
// Arg ARG Primitive(int) depth= Primitive(int) = -1
// Arg ARG Primitive(bool) requireContinuous= Primitive(bool) = true
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_UMat_checkVector_const_int_elemChannels_int_depth_bool_requireContinuous(void* instance, int elemChannels, int depth, bool requireContinuous) {
    try {
        int ret = reinterpret_cast<cv::UMat*>(instance)->checkVector(elemChannels, depth, requireContinuous);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_UMat_handle_const_int_accessFlags
// parsed: cv::UMat::handle
// as:     cv::UMat::handle (method) cv::UMat . handle
// Arg ARG Primitive(int) accessFlags= Primitive(int) = 
// Return value: RawPtr[Primitive(void)]
cv_return_value_void_X cv_core_cv_UMat_handle_const_int_accessFlags(void* instance, int accessFlags) {
    try {
        void* ret = reinterpret_cast<cv::UMat*>(instance)->handle(accessFlags);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<void**>(&ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_UMat_ndoffset_const_size_t_X_ofs
// parsed: cv::UMat::ndoffset
// as:     cv::UMat::ndoffset (method) cv::UMat . ndoffset
// Arg ARG RawPtr[Primitive(size_t)] * ofs= (ptr) RawPtr[Primitive(size_t)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_UMat_ndoffset_const_size_t_X_ofs(void* instance, size_t* ofs) {
    try {
        reinterpret_cast<cv::UMat*>(instance)->ndoffset(ofs);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_UMat_updateContinuityFlag
// parsed: cv::UMat::updateContinuityFlag
// as:     cv::UMat::updateContinuityFlag (method) cv::UMat . updateContinuityFlag
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_UMat_updateContinuityFlag(void* instance) {
    try {
        reinterpret_cast<cv::UMat*>(instance)->updateContinuityFlag();
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// boxed class: cv::UMatData
void cv_delete_UMatData(void* instance) {
    delete (cv::UMatData*) instance;
}
// cv_UMatData_lock
// parsed: cv::UMatData::lock
// as:     cv::UMatData::lock (method) cv::UMatData . lock
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_UMatData_lock(void* instance) {
    try {
        reinterpret_cast<cv::UMatData*>(instance)->lock();
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_UMatData_unlock
// parsed: cv::UMatData::unlock
// as:     cv::UMatData::unlock (method) cv::UMatData . unlock
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_UMatData_unlock(void* instance) {
    try {
        reinterpret_cast<cv::UMatData*>(instance)->unlock();
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_UMatData_hostCopyObsolete_const
// parsed: cv::UMatData::hostCopyObsolete
// as:     cv::UMatData::hostCopyObsolete (method) cv::UMatData . hostCopyObsolete
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_UMatData_hostCopyObsolete_const(void* instance) {
    try {
        bool ret = reinterpret_cast<cv::UMatData*>(instance)->hostCopyObsolete();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_UMatData_deviceCopyObsolete_const
// parsed: cv::UMatData::deviceCopyObsolete
// as:     cv::UMatData::deviceCopyObsolete (method) cv::UMatData . deviceCopyObsolete
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_UMatData_deviceCopyObsolete_const(void* instance) {
    try {
        bool ret = reinterpret_cast<cv::UMatData*>(instance)->deviceCopyObsolete();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_UMatData_deviceMemMapped_const
// parsed: cv::UMatData::deviceMemMapped
// as:     cv::UMatData::deviceMemMapped (method) cv::UMatData . deviceMemMapped
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_UMatData_deviceMemMapped_const(void* instance) {
    try {
        bool ret = reinterpret_cast<cv::UMatData*>(instance)->deviceMemMapped();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_UMatData_copyOnMap_const
// parsed: cv::UMatData::copyOnMap
// as:     cv::UMatData::copyOnMap (method) cv::UMatData . copyOnMap
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_UMatData_copyOnMap_const(void* instance) {
    try {
        bool ret = reinterpret_cast<cv::UMatData*>(instance)->copyOnMap();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_UMatData_tempUMat_const
// parsed: cv::UMatData::tempUMat
// as:     cv::UMatData::tempUMat (method) cv::UMatData . tempUMat
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_UMatData_tempUMat_const(void* instance) {
    try {
        bool ret = reinterpret_cast<cv::UMatData*>(instance)->tempUMat();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_UMatData_tempCopiedUMat_const
// parsed: cv::UMatData::tempCopiedUMat
// as:     cv::UMatData::tempCopiedUMat (method) cv::UMatData . tempCopiedUMat
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_UMatData_tempCopiedUMat_const(void* instance) {
    try {
        bool ret = reinterpret_cast<cv::UMatData*>(instance)->tempCopiedUMat();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_UMatData_markHostCopyObsolete_bool_flag
// parsed: cv::UMatData::markHostCopyObsolete
// as:     cv::UMatData::markHostCopyObsolete (method) cv::UMatData . markHostCopyObsolete
// Arg ARG Primitive(bool) flag= Primitive(bool) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_UMatData_markHostCopyObsolete_bool_flag(void* instance, bool flag) {
    try {
        reinterpret_cast<cv::UMatData*>(instance)->markHostCopyObsolete(flag);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_UMatData_markDeviceCopyObsolete_bool_flag
// parsed: cv::UMatData::markDeviceCopyObsolete
// as:     cv::UMatData::markDeviceCopyObsolete (method) cv::UMatData . markDeviceCopyObsolete
// Arg ARG Primitive(bool) flag= Primitive(bool) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_UMatData_markDeviceCopyObsolete_bool_flag(void* instance, bool flag) {
    try {
        reinterpret_cast<cv::UMatData*>(instance)->markDeviceCopyObsolete(flag);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_UMatData_markDeviceMemMapped_bool_flag
// parsed: cv::UMatData::markDeviceMemMapped
// as:     cv::UMatData::markDeviceMemMapped (method) cv::UMatData . markDeviceMemMapped
// Arg ARG Primitive(bool) flag= Primitive(bool) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_UMatData_markDeviceMemMapped_bool_flag(void* instance, bool flag) {
    try {
        reinterpret_cast<cv::UMatData*>(instance)->markDeviceMemMapped(flag);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// boxed class: cv::VideoCapture
void cv_delete_VideoCapture(void* instance) {
    delete (cv::VideoCapture*) instance;
}
// cv_VideoCapture_VideoCapture
// parsed: cv::VideoCapture::VideoCapture
// as:     cv::VideoCapture::VideoCapture (constructor) cv::VideoCapture . new
// Return value: cv::VideoCapture (boxed)
cv_return_value_void_X cv_core_cv_VideoCapture_VideoCapture() {
    try {
        cv::VideoCapture* ret = new cv::VideoCapture();
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_VideoCapture_VideoCapture_String_filename
// parsed: cv::VideoCapture::VideoCapture
// as:     cv::VideoCapture::VideoCapture (constructor) cv::VideoCapture . new
// Arg ARG string filename= string = 
// Return value: cv::VideoCapture (boxed)
cv_return_value_void_X cv_core_cv_VideoCapture_VideoCapture_String_filename(const char* filename) {
    try {
        cv::VideoCapture* ret = new cv::VideoCapture(String(filename));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_VideoCapture_VideoCapture_String_filename_int_apiPreference
// parsed: cv::VideoCapture::VideoCapture
// as:     cv::VideoCapture::VideoCapture (constructor) cv::VideoCapture . new
// Arg ARG string filename= string = 
// Arg ARG Primitive(int) apiPreference= Primitive(int) = 
// Return value: cv::VideoCapture (boxed)
cv_return_value_void_X cv_core_cv_VideoCapture_VideoCapture_String_filename_int_apiPreference(const char* filename, int apiPreference) {
    try {
        cv::VideoCapture* ret = new cv::VideoCapture(String(filename), apiPreference);
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_VideoCapture_VideoCapture_int_index
// parsed: cv::VideoCapture::VideoCapture
// as:     cv::VideoCapture::VideoCapture (constructor) cv::VideoCapture . new
// Arg ARG Primitive(int) index= Primitive(int) = 
// Return value: cv::VideoCapture (boxed)
cv_return_value_void_X cv_core_cv_VideoCapture_VideoCapture_int_index(int index) {
    try {
        cv::VideoCapture* ret = new cv::VideoCapture(index);
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_VideoCapture_VideoCapture_int_index_int_apiPreference
// parsed: cv::VideoCapture::VideoCapture
// as:     cv::VideoCapture::VideoCapture (constructor) cv::VideoCapture . new
// Arg ARG Primitive(int) index= Primitive(int) = 
// Arg ARG Primitive(int) apiPreference= Primitive(int) = 
// Return value: cv::VideoCapture (boxed)
cv_return_value_void_X cv_core_cv_VideoCapture_VideoCapture_int_index_int_apiPreference(int index, int apiPreference) {
    try {
        cv::VideoCapture* ret = new cv::VideoCapture(index, apiPreference);
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_VideoCapture_open_String_filename
// parsed: cv::VideoCapture::open
// as:     cv::VideoCapture::open (method) cv::VideoCapture . open
// Arg ARG string filename= string = 
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_VideoCapture_open_String_filename(void* instance, const char* filename) {
    try {
        bool ret = reinterpret_cast<cv::VideoCapture*>(instance)->open(String(filename));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_VideoCapture_open_int_index
// parsed: cv::VideoCapture::open
// as:     cv::VideoCapture::open (method) cv::VideoCapture . open
// Arg ARG Primitive(int) index= Primitive(int) = 
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_VideoCapture_open_int_index(void* instance, int index) {
    try {
        bool ret = reinterpret_cast<cv::VideoCapture*>(instance)->open(index);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_VideoCapture_open_int_cameraNum_int_apiPreference
// parsed: cv::VideoCapture::open
// as:     cv::VideoCapture::open (method) cv::VideoCapture . open
// Arg ARG Primitive(int) cameraNum= Primitive(int) = 
// Arg ARG Primitive(int) apiPreference= Primitive(int) = 
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_VideoCapture_open_int_cameraNum_int_apiPreference(void* instance, int cameraNum, int apiPreference) {
    try {
        bool ret = reinterpret_cast<cv::VideoCapture*>(instance)->open(cameraNum, apiPreference);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_VideoCapture_isOpened_const
// parsed: cv::VideoCapture::isOpened
// as:     cv::VideoCapture::isOpened (method) cv::VideoCapture . isOpened
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_VideoCapture_isOpened_const(void* instance) {
    try {
        bool ret = reinterpret_cast<cv::VideoCapture*>(instance)->isOpened();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_VideoCapture_release
// parsed: cv::VideoCapture::release
// as:     cv::VideoCapture::release (method) cv::VideoCapture . release
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_VideoCapture_release(void* instance) {
    try {
        reinterpret_cast<cv::VideoCapture*>(instance)->release();
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_VideoCapture_grab
// parsed: cv::VideoCapture::grab
// as:     cv::VideoCapture::grab (method) cv::VideoCapture . grab
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_VideoCapture_grab(void* instance) {
    try {
        bool ret = reinterpret_cast<cv::VideoCapture*>(instance)->grab();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_VideoCapture_retrieve_Mat_image_int_flag
// parsed: cv::VideoCapture::retrieve
// as:     cv::VideoCapture::retrieve (method) cv::VideoCapture . retrieve
// Arg ARG cv::Mat (boxed) image= cv::Mat (boxed) = 
// Arg ARG Primitive(int) flag= Primitive(int) = 0
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_VideoCapture_retrieve_Mat_image_int_flag(void* instance, void* image, int flag) {
    try {
        bool ret = reinterpret_cast<cv::VideoCapture*>(instance)->retrieve(*reinterpret_cast<cv::Mat*>(image), flag);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_VideoCapture_read_Mat_image
// parsed: cv::VideoCapture::read
// as:     cv::VideoCapture::read (method) cv::VideoCapture . read
// Arg ARG cv::Mat (boxed) image= cv::Mat (boxed) = 
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_VideoCapture_read_Mat_image(void* instance, void* image) {
    try {
        bool ret = reinterpret_cast<cv::VideoCapture*>(instance)->read(*reinterpret_cast<cv::Mat*>(image));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_VideoCapture_set_int_propId_double_value
// parsed: cv::VideoCapture::set
// as:     cv::VideoCapture::set (method) cv::VideoCapture . set
// Arg ARG Primitive(int) propId= Primitive(int) = 
// Arg ARG Primitive(double) value= Primitive(double) = 
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_VideoCapture_set_int_propId_double_value(void* instance, int propId, double value) {
    try {
        bool ret = reinterpret_cast<cv::VideoCapture*>(instance)->set(propId, value);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_VideoCapture_get_const_int_propId
// parsed: cv::VideoCapture::get
// as:     cv::VideoCapture::get (method) cv::VideoCapture . get
// Arg ARG Primitive(int) propId= Primitive(int) = 
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_VideoCapture_get_const_int_propId(void* instance, int propId) {
    try {
        double ret = reinterpret_cast<cv::VideoCapture*>(instance)->get(propId);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_VideoCapture_open_String_filename_int_apiPreference
// parsed: cv::VideoCapture::open
// as:     cv::VideoCapture::open (method) cv::VideoCapture . open
// Arg ARG string filename= string = 
// Arg ARG Primitive(int) apiPreference= Primitive(int) = 
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_VideoCapture_open_String_filename_int_apiPreference(void* instance, const char* filename, int apiPreference) {
    try {
        bool ret = reinterpret_cast<cv::VideoCapture*>(instance)->open(String(filename), apiPreference);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_VideoCapture_getBackendName_const
// parsed: cv::VideoCapture::getBackendName
// as:     cv::VideoCapture::getBackendName (method) cv::VideoCapture . getBackendName
// Return value: string
cv_return_value_char_X cv_core_cv_VideoCapture_getBackendName_const(void* instance) {
    try {
        String ret = reinterpret_cast<cv::VideoCapture*>(instance)->getBackendName();
        return { Error::Code::StsOk, NULL, strdup(ret.c_str()) };
    } CVRS_CATCH(cv_return_value_char_X)
}

// boxed class: cv::VideoWriter
void cv_delete_VideoWriter(void* instance) {
    delete (cv::VideoWriter*) instance;
}
// cv_VideoWriter_VideoWriter
// parsed: cv::VideoWriter::VideoWriter
// as:     cv::VideoWriter::VideoWriter (constructor) cv::VideoWriter . new
// Return value: cv::VideoWriter (boxed)
cv_return_value_void_X cv_core_cv_VideoWriter_VideoWriter() {
    try {
        cv::VideoWriter* ret = new cv::VideoWriter();
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_VideoWriter_VideoWriter_String_filename_int_fourcc_double_fps_Size_frameSize_bool_isColor
// parsed: cv::VideoWriter::VideoWriter
// as:     cv::VideoWriter::VideoWriter (constructor) cv::VideoWriter . new
// Arg ARG string filename= string = 
// Arg ARG Primitive(int) fourcc= Primitive(int) = 
// Arg ARG Primitive(double) fps= Primitive(double) = 
// Arg ARG cv::Size (simple) frameSize= cv::Size (simple) = 
// Arg ARG Primitive(bool) isColor= Primitive(bool) = true
// Return value: cv::VideoWriter (boxed)
cv_return_value_void_X cv_core_cv_VideoWriter_VideoWriter_String_filename_int_fourcc_double_fps_Size_frameSize_bool_isColor(const char* filename, int fourcc, double fps, SizeWrapper frameSize, bool isColor) {
    try {
        cv::VideoWriter* ret = new cv::VideoWriter(String(filename), fourcc, fps, *reinterpret_cast<cv::Size*>(&frameSize), isColor);
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_VideoWriter_VideoWriter_String_filename_int_apiPreference_int_fourcc_double_fps_Size_frameSize_bool_isColor
// parsed: cv::VideoWriter::VideoWriter
// as:     cv::VideoWriter::VideoWriter (constructor) cv::VideoWriter . new
// Arg ARG string filename= string = 
// Arg ARG Primitive(int) apiPreference= Primitive(int) = 
// Arg ARG Primitive(int) fourcc= Primitive(int) = 
// Arg ARG Primitive(double) fps= Primitive(double) = 
// Arg ARG cv::Size (simple) frameSize= cv::Size (simple) = 
// Arg ARG Primitive(bool) isColor= Primitive(bool) = true
// Return value: cv::VideoWriter (boxed)
cv_return_value_void_X cv_core_cv_VideoWriter_VideoWriter_String_filename_int_apiPreference_int_fourcc_double_fps_Size_frameSize_bool_isColor(const char* filename, int apiPreference, int fourcc, double fps, SizeWrapper frameSize, bool isColor) {
    try {
        cv::VideoWriter* ret = new cv::VideoWriter(String(filename), apiPreference, fourcc, fps, *reinterpret_cast<cv::Size*>(&frameSize), isColor);
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_VideoWriter_open_String_filename_int_fourcc_double_fps_Size_frameSize_bool_isColor
// parsed: cv::VideoWriter::open
// as:     cv::VideoWriter::open (method) cv::VideoWriter . open
// Arg ARG string filename= string = 
// Arg ARG Primitive(int) fourcc= Primitive(int) = 
// Arg ARG Primitive(double) fps= Primitive(double) = 
// Arg ARG cv::Size (simple) frameSize= cv::Size (simple) = 
// Arg ARG Primitive(bool) isColor= Primitive(bool) = true
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_VideoWriter_open_String_filename_int_fourcc_double_fps_Size_frameSize_bool_isColor(void* instance, const char* filename, int fourcc, double fps, SizeWrapper frameSize, bool isColor) {
    try {
        bool ret = reinterpret_cast<cv::VideoWriter*>(instance)->open(String(filename), fourcc, fps, *reinterpret_cast<cv::Size*>(&frameSize), isColor);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_VideoWriter_open_String_filename_int_apiPreference_int_fourcc_double_fps_Size_frameSize_bool_isColor
// parsed: cv::VideoWriter::open
// as:     cv::VideoWriter::open (method) cv::VideoWriter . open
// Arg ARG string filename= string = 
// Arg ARG Primitive(int) apiPreference= Primitive(int) = 
// Arg ARG Primitive(int) fourcc= Primitive(int) = 
// Arg ARG Primitive(double) fps= Primitive(double) = 
// Arg ARG cv::Size (simple) frameSize= cv::Size (simple) = 
// Arg ARG Primitive(bool) isColor= Primitive(bool) = true
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_VideoWriter_open_String_filename_int_apiPreference_int_fourcc_double_fps_Size_frameSize_bool_isColor(void* instance, const char* filename, int apiPreference, int fourcc, double fps, SizeWrapper frameSize, bool isColor) {
    try {
        bool ret = reinterpret_cast<cv::VideoWriter*>(instance)->open(String(filename), apiPreference, fourcc, fps, *reinterpret_cast<cv::Size*>(&frameSize), isColor);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_VideoWriter_isOpened_const
// parsed: cv::VideoWriter::isOpened
// as:     cv::VideoWriter::isOpened (method) cv::VideoWriter . isOpened
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_VideoWriter_isOpened_const(void* instance) {
    try {
        bool ret = reinterpret_cast<cv::VideoWriter*>(instance)->isOpened();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_VideoWriter_release
// parsed: cv::VideoWriter::release
// as:     cv::VideoWriter::release (method) cv::VideoWriter . release
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_VideoWriter_release(void* instance) {
    try {
        reinterpret_cast<cv::VideoWriter*>(instance)->release();
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_VideoWriter_write_Mat_image
// parsed: cv::VideoWriter::write
// as:     cv::VideoWriter::write (method) cv::VideoWriter . write
// Arg ARG cv::Mat (boxed) image= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_VideoWriter_write_Mat_image(void* instance, void* image) {
    try {
        reinterpret_cast<cv::VideoWriter*>(instance)->write(*reinterpret_cast<cv::Mat*>(image));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_VideoWriter_set_int_propId_double_value
// parsed: cv::VideoWriter::set
// as:     cv::VideoWriter::set (method) cv::VideoWriter . set
// Arg ARG Primitive(int) propId= Primitive(int) = 
// Arg ARG Primitive(double) value= Primitive(double) = 
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_VideoWriter_set_int_propId_double_value(void* instance, int propId, double value) {
    try {
        bool ret = reinterpret_cast<cv::VideoWriter*>(instance)->set(propId, value);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_VideoWriter_get_const_int_propId
// parsed: cv::VideoWriter::get
// as:     cv::VideoWriter::get (method) cv::VideoWriter . get
// Arg ARG Primitive(int) propId= Primitive(int) = 
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_VideoWriter_get_const_int_propId(void* instance, int propId) {
    try {
        double ret = reinterpret_cast<cv::VideoWriter*>(instance)->get(propId);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_VideoWriter_fourcc_char_c1_char_c2_char_c3_char_c4
// parsed: cv::VideoWriter::fourcc
// as:     cv::VideoWriter::fourcc (method) cv::VideoWriter . fourcc
// Arg ARG Primitive(char) c1= Primitive(char) = 
// Arg ARG Primitive(char) c2= Primitive(char) = 
// Arg ARG Primitive(char) c3= Primitive(char) = 
// Arg ARG Primitive(char) c4= Primitive(char) = 
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_VideoWriter_fourcc_char_c1_char_c2_char_c3_char_c4(char c1, char c2, char c3, char c4) {
    try {
        int ret = cv::VideoWriter::fourcc(c1, c2, c3, c4);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_VideoWriter_getBackendName_const
// parsed: cv::VideoWriter::getBackendName
// as:     cv::VideoWriter::getBackendName (method) cv::VideoWriter . getBackendName
// Return value: string
cv_return_value_char_X cv_core_cv_VideoWriter_getBackendName_const(void* instance) {
    try {
        String ret = reinterpret_cast<cv::VideoWriter*>(instance)->getBackendName();
        return { Error::Code::StsOk, NULL, strdup(ret.c_str()) };
    } CVRS_CATCH(cv_return_value_char_X)
}

// boxed class: cv::dnn::AbsLayer
void cv_delete_AbsLayer(void* instance) {
    delete (cv::dnn::AbsLayer*) instance;
}
// cv_dnn_ActivationLayer_forwardSlice_const_const_float_X_src_float_X_dst_int_len_size_t_outPlaneSize_int_cn0_int_cn1
// parsed: cv::dnn::ActivationLayer::forwardSlice
// as:     cv::dnn::ActivationLayer::forwardSlice (method) cv::dnn::ActivationLayer (trait) . forwardSlice
// Arg ARG RawPtr[Primitive(float)] * src= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG RawPtr[Primitive(float)] * dst= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG Primitive(int) len= Primitive(int) = 
// Arg ARG Primitive(size_t) outPlaneSize= Primitive(size_t) = 
// Arg ARG Primitive(int) cn0= Primitive(int) = 
// Arg ARG Primitive(int) cn1= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_dnn_ActivationLayer_forwardSlice_const_const_float_X_src_float_X_dst_int_len_size_t_outPlaneSize_int_cn0_int_cn1(void* instance, const float* src, float* dst, int len, std::size_t outPlaneSize, int cn0, int cn1) {
    try {
        reinterpret_cast<cv::dnn::ActivationLayer*>(instance)->forwardSlice(src, dst, len, outPlaneSize, cn0, cn1);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// boxed class: cv::dnn::BNLLLayer
void cv_delete_BNLLLayer(void* instance) {
    delete (cv::dnn::BNLLLayer*) instance;
}
// boxed class: cv::dnn::BackendNode
void cv_delete_BackendNode(void* instance) {
    delete (cv::dnn::BackendNode*) instance;
}
// cv_dnn_BackendNode_BackendNode_int_backendId
// parsed: cv::dnn::BackendNode::BackendNode
// as:     cv::dnn::BackendNode::BackendNode (constructor) cv::dnn::BackendNode . new
// Arg ARG Primitive(int) backendId= Primitive(int) = 
// Return value: cv::dnn::BackendNode (boxed)
cv_return_value_void_X cv_core_cv_dnn_BackendNode_BackendNode_int_backendId(int backendId) {
    try {
        cv::dnn::BackendNode* ret = new cv::dnn::BackendNode(backendId);
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_dnn_BackendWrapper_copyToHost
// parsed: cv::dnn::BackendWrapper::copyToHost
// as:     cv::dnn::BackendWrapper::copyToHost (method) cv::dnn::BackendWrapper (trait) . copyToHost
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_dnn_BackendWrapper_copyToHost(void* instance) {
    try {
        reinterpret_cast<cv::dnn::BackendWrapper*>(instance)->copyToHost();
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_dnn_BackendWrapper_setHostDirty
// parsed: cv::dnn::BackendWrapper::setHostDirty
// as:     cv::dnn::BackendWrapper::setHostDirty (method) cv::dnn::BackendWrapper (trait) . setHostDirty
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_dnn_BackendWrapper_setHostDirty(void* instance) {
    try {
        reinterpret_cast<cv::dnn::BackendWrapper*>(instance)->setHostDirty();
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// boxed class: cv::dnn::BatchNormLayer
void cv_delete_BatchNormLayer(void* instance) {
    delete (cv::dnn::BatchNormLayer*) instance;
}
// boxed class: cv::dnn::BlankLayer
void cv_delete_BlankLayer(void* instance) {
    delete (cv::dnn::BlankLayer*) instance;
}
// boxed class: cv::dnn::ChannelsPReLULayer
void cv_delete_ChannelsPReLULayer(void* instance) {
    delete (cv::dnn::ChannelsPReLULayer*) instance;
}
// boxed class: cv::dnn::ConcatLayer
void cv_delete_ConcatLayer(void* instance) {
    delete (cv::dnn::ConcatLayer*) instance;
}
// boxed class: cv::dnn::ConstLayer
void cv_delete_ConstLayer(void* instance) {
    delete (cv::dnn::ConstLayer*) instance;
}
// boxed class: cv::dnn::ConvolutionLayer
void cv_delete_ConvolutionLayer(void* instance) {
    delete (cv::dnn::ConvolutionLayer*) instance;
}
// boxed class: cv::dnn::CropAndResizeLayer
void cv_delete_CropAndResizeLayer(void* instance) {
    delete (cv::dnn::CropAndResizeLayer*) instance;
}
// boxed class: cv::dnn::CropLayer
void cv_delete_CropLayer(void* instance) {
    delete (cv::dnn::CropLayer*) instance;
}
// boxed class: cv::dnn::DeconvolutionLayer
void cv_delete_DeconvolutionLayer(void* instance) {
    delete (cv::dnn::DeconvolutionLayer*) instance;
}
// boxed class: cv::dnn::DetectionOutputLayer
void cv_delete_DetectionOutputLayer(void* instance) {
    delete (cv::dnn::DetectionOutputLayer*) instance;
}
// cv_dnn_Dict_has_const_String_key
// parsed: cv::dnn::Dict::has
// as:     cv::dnn::Dict::has (method) cv::dnn::Dict (trait) . has
// Arg ARG string key= string = 
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_dnn_Dict_has_const_String_key(void* instance, const char* key) {
    try {
        bool ret = reinterpret_cast<cv::dnn::Dict*>(instance)->has(String(key));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_dnn_Dict_ptr_String_key
// parsed: cv::dnn::Dict::ptr
// as:     cv::dnn::Dict::ptr (method) cv::dnn::Dict (trait) . ptr
// Arg ARG string key= string = 
// Return value: cv::dnn::DictValue (boxed)
cv_return_value_void_X cv_core_cv_dnn_Dict_ptr_String_key(void* instance, const char* key) {
    try {
        cv::dnn::DictValue ret = reinterpret_cast<cv::dnn::Dict*>(instance)->ptr(String(key));
        return { Error::Code::StsOk, NULL, new cv::dnn::DictValue(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_dnn_Dict_ptr_const_String_key
// parsed: cv::dnn::Dict::ptr
// as:     cv::dnn::Dict::ptr (method) cv::dnn::Dict (trait) . ptr
// Arg ARG string key= string = 
// Return value: cv::dnn::DictValue (boxed)
cv_return_value_void_X cv_core_cv_dnn_Dict_ptr_const_String_key(void* instance, const char* key) {
    try {
        cv::dnn::DictValue ret = reinterpret_cast<cv::dnn::Dict*>(instance)->ptr(String(key));
        return { Error::Code::StsOk, NULL, new cv::dnn::DictValue(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_dnn_Dict_get_const_String_key
// parsed: cv::dnn::Dict::get
// as:     cv::dnn::Dict::get (method) cv::dnn::Dict (trait) . get
// Arg ARG string key= string = 
// Return value: cv::dnn::DictValue (boxed)
cv_return_value_void_X cv_core_cv_dnn_Dict_get_const_String_key(void* instance, const char* key) {
    try {
        cv::dnn::DictValue ret = reinterpret_cast<cv::dnn::Dict*>(instance)->get(String(key));
        return { Error::Code::StsOk, NULL, new cv::dnn::DictValue(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_dnn_Dict_erase_String_key
// parsed: cv::dnn::Dict::erase
// as:     cv::dnn::Dict::erase (method) cv::dnn::Dict (trait) . erase
// Arg ARG string key= string = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_dnn_Dict_erase_String_key(void* instance, const char* key) {
    try {
        reinterpret_cast<cv::dnn::Dict*>(instance)->erase(String(key));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// boxed class: cv::dnn::DictValue
void cv_delete_DictValue(void* instance) {
    delete (cv::dnn::DictValue*) instance;
}
// cv_dnn_DictValue_DictValue_DictValue_r
// parsed: cv::dnn::DictValue::DictValue
// as:     cv::dnn::DictValue::DictValue (constructor) cv::dnn::DictValue . new
// Arg ARG cv::dnn::DictValue (boxed) r= cv::dnn::DictValue (boxed) = 
// Return value: cv::dnn::DictValue (boxed)
cv_return_value_void_X cv_core_cv_dnn_DictValue_DictValue_DictValue_r(void* r) {
    try {
        cv::dnn::DictValue* ret = new cv::dnn::DictValue(*reinterpret_cast<cv::dnn::DictValue*>(r));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_dnn_DictValue_size_const
// parsed: cv::dnn::DictValue::size
// as:     cv::dnn::DictValue::size (method) cv::dnn::DictValue . size
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_dnn_DictValue_size_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::dnn::DictValue*>(instance)->size();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_dnn_DictValue_isInt_const
// parsed: cv::dnn::DictValue::isInt
// as:     cv::dnn::DictValue::isInt (method) cv::dnn::DictValue . isInt
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_dnn_DictValue_isInt_const(void* instance) {
    try {
        bool ret = reinterpret_cast<cv::dnn::DictValue*>(instance)->isInt();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_dnn_DictValue_isString_const
// parsed: cv::dnn::DictValue::isString
// as:     cv::dnn::DictValue::isString (method) cv::dnn::DictValue . isString
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_dnn_DictValue_isString_const(void* instance) {
    try {
        bool ret = reinterpret_cast<cv::dnn::DictValue*>(instance)->isString();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_dnn_DictValue_isReal_const
// parsed: cv::dnn::DictValue::isReal
// as:     cv::dnn::DictValue::isReal (method) cv::dnn::DictValue . isReal
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_dnn_DictValue_isReal_const(void* instance) {
    try {
        bool ret = reinterpret_cast<cv::dnn::DictValue*>(instance)->isReal();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_dnn_DictValue_getIntValue_const_int_idx
// parsed: cv::dnn::DictValue::getIntValue
// as:     cv::dnn::DictValue::getIntValue (method) cv::dnn::DictValue . getIntValue
// Arg ARG Primitive(int) idx= Primitive(int) = -1
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_dnn_DictValue_getIntValue_const_int_idx(void* instance, int idx) {
    try {
        int ret = reinterpret_cast<cv::dnn::DictValue*>(instance)->getIntValue(idx);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_dnn_DictValue_getRealValue_const_int_idx
// parsed: cv::dnn::DictValue::getRealValue
// as:     cv::dnn::DictValue::getRealValue (method) cv::dnn::DictValue . getRealValue
// Arg ARG Primitive(int) idx= Primitive(int) = -1
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_dnn_DictValue_getRealValue_const_int_idx(void* instance, int idx) {
    try {
        double ret = reinterpret_cast<cv::dnn::DictValue*>(instance)->getRealValue(idx);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_dnn_DictValue_getStringValue_const_int_idx
// parsed: cv::dnn::DictValue::getStringValue
// as:     cv::dnn::DictValue::getStringValue (method) cv::dnn::DictValue . getStringValue
// Arg ARG Primitive(int) idx= Primitive(int) = -1
// Return value: string
cv_return_value_char_X cv_core_cv_dnn_DictValue_getStringValue_const_int_idx(void* instance, int idx) {
    try {
        String ret = reinterpret_cast<cv::dnn::DictValue*>(instance)->getStringValue(idx);
        return { Error::Code::StsOk, NULL, strdup(ret.c_str()) };
    } CVRS_CATCH(cv_return_value_char_X)
}

// boxed class: cv::dnn::ELULayer
void cv_delete_ELULayer(void* instance) {
    delete (cv::dnn::ELULayer*) instance;
}
// boxed class: cv::dnn::EltwiseLayer
void cv_delete_EltwiseLayer(void* instance) {
    delete (cv::dnn::EltwiseLayer*) instance;
}
// boxed class: cv::dnn::FlattenLayer
void cv_delete_FlattenLayer(void* instance) {
    delete (cv::dnn::FlattenLayer*) instance;
}
// boxed class: cv::dnn::InnerProductLayer
void cv_delete_InnerProductLayer(void* instance) {
    delete (cv::dnn::InnerProductLayer*) instance;
}
// boxed class: cv::dnn::InterpLayer
void cv_delete_InterpLayer(void* instance) {
    delete (cv::dnn::InterpLayer*) instance;
}
// boxed class: cv::dnn::LRNLayer
void cv_delete_LRNLayer(void* instance) {
    delete (cv::dnn::LRNLayer*) instance;
}
// cv_dnn_LSTMLayer_setWeights_Mat_Wh_Mat_Wx_Mat_b
// parsed: cv::dnn::LSTMLayer::setWeights
// as:     cv::dnn::LSTMLayer::setWeights (method) cv::dnn::LSTMLayer (trait) . setWeights
// Arg ARG cv::Mat (boxed) Wh= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) Wx= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) b= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_dnn_LSTMLayer_setWeights_Mat_Wh_Mat_Wx_Mat_b(void* instance, void* Wh, void* Wx, void* b) {
    try {
        reinterpret_cast<cv::dnn::LSTMLayer*>(instance)->setWeights(*reinterpret_cast<cv::Mat*>(Wh), *reinterpret_cast<cv::Mat*>(Wx), *reinterpret_cast<cv::Mat*>(b));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_dnn_LSTMLayer_setUseTimstampsDim_bool_use
// parsed: cv::dnn::LSTMLayer::setUseTimstampsDim
// as:     cv::dnn::LSTMLayer::setUseTimstampsDim (method) cv::dnn::LSTMLayer (trait) . setUseTimstampsDim
// Arg ARG Primitive(bool) use= Primitive(bool) = true
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_dnn_LSTMLayer_setUseTimstampsDim_bool_use(void* instance, bool use) {
    try {
        reinterpret_cast<cv::dnn::LSTMLayer*>(instance)->setUseTimstampsDim(use);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_dnn_LSTMLayer_setProduceCellOutput_bool_produce
// parsed: cv::dnn::LSTMLayer::setProduceCellOutput
// as:     cv::dnn::LSTMLayer::setProduceCellOutput (method) cv::dnn::LSTMLayer (trait) . setProduceCellOutput
// Arg ARG Primitive(bool) produce= Primitive(bool) = false
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_dnn_LSTMLayer_setProduceCellOutput_bool_produce(void* instance, bool produce) {
    try {
        reinterpret_cast<cv::dnn::LSTMLayer*>(instance)->setProduceCellOutput(produce);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_dnn_LSTMLayer_inputNameToIndex_String_inputName
// parsed: cv::dnn::LSTMLayer::inputNameToIndex
// as:     cv::dnn::LSTMLayer::inputNameToIndex (method) cv::dnn::LSTMLayer (trait) . inputNameToIndex
// Arg ARG string inputName= string = 
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_dnn_LSTMLayer_inputNameToIndex_String_inputName(void* instance, const char* inputName) {
    try {
        int ret = reinterpret_cast<cv::dnn::LSTMLayer*>(instance)->inputNameToIndex(String(inputName));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_dnn_LSTMLayer_outputNameToIndex_String_outputName
// parsed: cv::dnn::LSTMLayer::outputNameToIndex
// as:     cv::dnn::LSTMLayer::outputNameToIndex (method) cv::dnn::LSTMLayer (trait) . outputNameToIndex
// Arg ARG string outputName= string = 
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_dnn_LSTMLayer_outputNameToIndex_String_outputName(void* instance, const char* outputName) {
    try {
        int ret = reinterpret_cast<cv::dnn::LSTMLayer*>(instance)->outputNameToIndex(String(outputName));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_dnn_Layer_finalize_VectorOfMat_inputs_VectorOfMat_outputs
// parsed: cv::dnn::Layer::finalize
// as:     cv::dnn::Layer::finalize (method) cv::dnn::Layer (trait) . finalize
// Arg ARG Vector[cv::Mat (boxed)] inputs= Vector[cv::Mat (boxed)] = 
// Arg ARG Vector[cv::Mat (boxed)] outputs= Vector[cv::Mat (boxed)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_dnn_Layer_finalize_VectorOfMat_inputs_VectorOfMat_outputs(void* instance, void* inputs, void** outputs) {
    try {
        reinterpret_cast<cv::dnn::Layer*>(instance)->finalize(*reinterpret_cast<std::vector<cv::Mat>*>(inputs), *reinterpret_cast<std::vector<cv::Mat>*>(outputs));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_dnn_Layer_forward_VectorOfMat_inputs_VectorOfMat_outputs_VectorOfMat_internals
// parsed: cv::dnn::Layer::forward
// as:     cv::dnn::Layer::forward (method) cv::dnn::Layer (trait) . forward
// Arg ARG Vector[cv::Mat (boxed)] inputs= Vector[cv::Mat (boxed)] = 
// Arg ARG Vector[cv::Mat (boxed)] outputs= Vector[cv::Mat (boxed)] = 
// Arg ARG Vector[cv::Mat (boxed)] internals= Vector[cv::Mat (boxed)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_dnn_Layer_forward_VectorOfMat_inputs_VectorOfMat_outputs_VectorOfMat_internals(void* instance, void* inputs, void** outputs, void** internals) {
    try {
        reinterpret_cast<cv::dnn::Layer*>(instance)->forward(*reinterpret_cast<std::vector<cv::Mat>*>(inputs), *reinterpret_cast<std::vector<cv::Mat>*>(outputs), *reinterpret_cast<std::vector<cv::Mat>*>(internals));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_dnn_Layer_forward_fallback_VectorOfMat_inputs_VectorOfMat_outputs_VectorOfMat_internals
// parsed: cv::dnn::Layer::forward_fallback
// as:     cv::dnn::Layer::forward_fallback (method) cv::dnn::Layer (trait) . forward_fallback
// Arg ARG Vector[cv::Mat (boxed)] inputs= Vector[cv::Mat (boxed)] = 
// Arg ARG Vector[cv::Mat (boxed)] outputs= Vector[cv::Mat (boxed)] = 
// Arg ARG Vector[cv::Mat (boxed)] internals= Vector[cv::Mat (boxed)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_dnn_Layer_forward_fallback_VectorOfMat_inputs_VectorOfMat_outputs_VectorOfMat_internals(void* instance, void* inputs, void** outputs, void** internals) {
    try {
        reinterpret_cast<cv::dnn::Layer*>(instance)->forward_fallback(*reinterpret_cast<std::vector<cv::Mat>*>(inputs), *reinterpret_cast<std::vector<cv::Mat>*>(outputs), *reinterpret_cast<std::vector<cv::Mat>*>(internals));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_dnn_Layer_finalize_VectorOfMat_inputs
// parsed: cv::dnn::Layer::finalize
// as:     cv::dnn::Layer::finalize (method) cv::dnn::Layer (trait) . finalize
// Arg ARG Vector[cv::Mat (boxed)] inputs= Vector[cv::Mat (boxed)] = 
// Return value: Vector[cv::Mat (boxed)]
cv_return_value_void_X cv_core_cv_dnn_Layer_finalize_VectorOfMat_inputs(void* instance, void* inputs) {
    try {
        std::vector<cv::Mat> ret = reinterpret_cast<cv::dnn::Layer*>(instance)->finalize(*reinterpret_cast<std::vector<cv::Mat>*>(inputs));
        return { Error::Code::StsOk, NULL, (void *)new std::vector<cv::Mat>(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_dnn_Layer_run_VectorOfMat_inputs_VectorOfMat_outputs_VectorOfMat_internals
// parsed: cv::dnn::Layer::run
// as:     cv::dnn::Layer::run (method) cv::dnn::Layer (trait) . run
// Arg ARG Vector[cv::Mat (boxed)] inputs= Vector[cv::Mat (boxed)] = 
// Arg ARG Vector[cv::Mat (boxed)] outputs= Vector[cv::Mat (boxed)] = 
// Arg ARG Vector[cv::Mat (boxed)] internals= Vector[cv::Mat (boxed)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_dnn_Layer_run_VectorOfMat_inputs_VectorOfMat_outputs_VectorOfMat_internals(void* instance, void* inputs, void* outputs, void* internals) {
    try {
        reinterpret_cast<cv::dnn::Layer*>(instance)->run(*reinterpret_cast<std::vector<cv::Mat>*>(inputs), *reinterpret_cast<std::vector<cv::Mat>*>(outputs), *reinterpret_cast<std::vector<cv::Mat>*>(internals));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_dnn_Layer_inputNameToIndex_String_inputName
// parsed: cv::dnn::Layer::inputNameToIndex
// as:     cv::dnn::Layer::inputNameToIndex (method) cv::dnn::Layer (trait) . inputNameToIndex
// Arg ARG string inputName= string = 
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_dnn_Layer_inputNameToIndex_String_inputName(void* instance, const char* inputName) {
    try {
        int ret = reinterpret_cast<cv::dnn::Layer*>(instance)->inputNameToIndex(String(inputName));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_dnn_Layer_outputNameToIndex_String_outputName
// parsed: cv::dnn::Layer::outputNameToIndex
// as:     cv::dnn::Layer::outputNameToIndex (method) cv::dnn::Layer (trait) . outputNameToIndex
// Arg ARG string outputName= string = 
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_dnn_Layer_outputNameToIndex_String_outputName(void* instance, const char* outputName) {
    try {
        int ret = reinterpret_cast<cv::dnn::Layer*>(instance)->outputNameToIndex(String(outputName));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_dnn_Layer_supportBackend_int_backendId
// parsed: cv::dnn::Layer::supportBackend
// as:     cv::dnn::Layer::supportBackend (method) cv::dnn::Layer (trait) . supportBackend
// Arg ARG Primitive(int) backendId= Primitive(int) = 
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_dnn_Layer_supportBackend_int_backendId(void* instance, int backendId) {
    try {
        bool ret = reinterpret_cast<cv::dnn::Layer*>(instance)->supportBackend(backendId);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_dnn_Layer_initHalide_VectorOfPtrOfBackendWrapper_inputs
// parsed: cv::dnn::Layer::initHalide
// as:     cv::dnn::Layer::initHalide (method) cv::dnn::Layer (trait) . initHalide
// Arg ARG Vector[SmartPtr[cv::dnn::BackendWrapper (boxed)]] inputs= Vector[SmartPtr[cv::dnn::BackendWrapper (boxed)]] = 
// Return value: SmartPtr[cv::dnn::BackendNode (boxed)]
cv_return_value_void_X cv_core_cv_dnn_Layer_initHalide_VectorOfPtrOfBackendWrapper_inputs(void* instance, void* inputs) {
    try {
        Ptr<cv::dnn::BackendNode> *ret = new Ptr<cv::dnn::BackendNode>(reinterpret_cast<cv::dnn::Layer*>(instance)->initHalide(*reinterpret_cast<std::vector<Ptr<cv::dnn::BackendWrapper>>*>(inputs)));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_dnn_Layer_initInfEngine_VectorOfPtrOfBackendWrapper_inputs
// parsed: cv::dnn::Layer::initInfEngine
// as:     cv::dnn::Layer::initInfEngine (method) cv::dnn::Layer (trait) . initInfEngine
// Arg ARG Vector[SmartPtr[cv::dnn::BackendWrapper (boxed)]] inputs= Vector[SmartPtr[cv::dnn::BackendWrapper (boxed)]] = 
// Return value: SmartPtr[cv::dnn::BackendNode (boxed)]
cv_return_value_void_X cv_core_cv_dnn_Layer_initInfEngine_VectorOfPtrOfBackendWrapper_inputs(void* instance, void* inputs) {
    try {
        Ptr<cv::dnn::BackendNode> *ret = new Ptr<cv::dnn::BackendNode>(reinterpret_cast<cv::dnn::Layer*>(instance)->initInfEngine(*reinterpret_cast<std::vector<Ptr<cv::dnn::BackendWrapper>>*>(inputs)));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_dnn_Layer_tryAttach_PtrOfBackendNode_node
// parsed: cv::dnn::Layer::tryAttach
// as:     cv::dnn::Layer::tryAttach (method) cv::dnn::Layer (trait) . tryAttach
// Arg ARG SmartPtr[cv::dnn::BackendNode (boxed)] node= SmartPtr[cv::dnn::BackendNode (boxed)] = 
// Return value: SmartPtr[cv::dnn::BackendNode (boxed)]
cv_return_value_void_X cv_core_cv_dnn_Layer_tryAttach_PtrOfBackendNode_node(void* instance, void* node) {
    try {
        Ptr<cv::dnn::BackendNode> *ret = new Ptr<cv::dnn::BackendNode>(reinterpret_cast<cv::dnn::Layer*>(instance)->tryAttach(reinterpret_cast<cv::dnn::BackendNode*>(node)));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_dnn_Layer_setActivation_PtrOfActivationLayer_layer
// parsed: cv::dnn::Layer::setActivation
// as:     cv::dnn::Layer::setActivation (method) cv::dnn::Layer (trait) . setActivation
// Arg ARG SmartPtr[cv::dnn::ActivationLayer (boxed)] layer= SmartPtr[cv::dnn::ActivationLayer (boxed)] = 
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_dnn_Layer_setActivation_PtrOfActivationLayer_layer(void* instance, void* layer) {
    try {
        bool ret = reinterpret_cast<cv::dnn::Layer*>(instance)->setActivation(reinterpret_cast<cv::dnn::ActivationLayer*>(layer));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_dnn_Layer_getScaleShift_const_Mat_scale_Mat_shift
// parsed: cv::dnn::Layer::getScaleShift
// as:     cv::dnn::Layer::getScaleShift (method) cv::dnn::Layer (trait) . getScaleShift
// Arg ARG cv::Mat (boxed) scale= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) shift= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_dnn_Layer_getScaleShift_const_Mat_scale_Mat_shift(void* instance, void* scale, void* shift) {
    try {
        reinterpret_cast<cv::dnn::Layer*>(instance)->getScaleShift(*reinterpret_cast<cv::Mat*>(scale), *reinterpret_cast<cv::Mat*>(shift));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_dnn_Layer_unsetAttached
// parsed: cv::dnn::Layer::unsetAttached
// as:     cv::dnn::Layer::unsetAttached (method) cv::dnn::Layer (trait) . unsetAttached
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_dnn_Layer_unsetAttached(void* instance) {
    try {
        reinterpret_cast<cv::dnn::Layer*>(instance)->unsetAttached();
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_dnn_Layer_getMemoryShapes_const_VectorOfVectorOfint_inputs_int_requiredOutputs_VectorOfVectorOfint_outputs_VectorOfVectorOfint_internals
// parsed: cv::dnn::Layer::getMemoryShapes
// as:     cv::dnn::Layer::getMemoryShapes (method) cv::dnn::Layer (trait) . getMemoryShapes
// Arg ARG Vector[Vector[Primitive(int)]] inputs= Vector[Vector[Primitive(int)]] = 
// Arg ARG Primitive(int) requiredOutputs= Primitive(int) = 
// Arg ARG Vector[Vector[Primitive(int)]] outputs= Vector[Vector[Primitive(int)]] = 
// Arg ARG Vector[Vector[Primitive(int)]] internals= Vector[Vector[Primitive(int)]] = 
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_dnn_Layer_getMemoryShapes_const_VectorOfVectorOfint_inputs_int_requiredOutputs_VectorOfVectorOfint_outputs_VectorOfVectorOfint_internals(void* instance, void* inputs, int requiredOutputs, void* outputs, void* internals) {
    try {
        bool ret = reinterpret_cast<cv::dnn::Layer*>(instance)->getMemoryShapes(*reinterpret_cast<std::vector<std::vector<int>>*>(inputs), requiredOutputs, *reinterpret_cast<std::vector<std::vector<int>>*>(outputs), *reinterpret_cast<std::vector<std::vector<int>>*>(internals));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_dnn_Layer_getFLOPS_const_VectorOfVectorOfint_inputs_VectorOfVectorOfint_outputs
// parsed: cv::dnn::Layer::getFLOPS
// as:     cv::dnn::Layer::getFLOPS (method) cv::dnn::Layer (trait) . getFLOPS
// Arg ARG Vector[Vector[Primitive(int)]] inputs= Vector[Vector[Primitive(int)]] = 
// Arg ARG Vector[Vector[Primitive(int)]] outputs= Vector[Vector[Primitive(int)]] = 
// Return value: Primitive(int64)
cv_return_value_int64 cv_core_cv_dnn_Layer_getFLOPS_const_VectorOfVectorOfint_inputs_VectorOfVectorOfint_outputs(void* instance, void* inputs, void* outputs) {
    try {
        int64 ret = reinterpret_cast<cv::dnn::Layer*>(instance)->getFLOPS(*reinterpret_cast<std::vector<std::vector<int>>*>(inputs), *reinterpret_cast<std::vector<std::vector<int>>*>(outputs));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int64*>(&ret) };
    } CVRS_CATCH(cv_return_value_int64)
}

// boxed class: cv::dnn::LayerFactory
void cv_delete_LayerFactory(void* instance) {
    delete (cv::dnn::LayerFactory*) instance;
}
// cv_dnn_LayerFactory_unregisterLayer_String_type
// parsed: cv::dnn::LayerFactory::unregisterLayer
// as:     cv::dnn::LayerFactory::unregisterLayer (method) cv::dnn::LayerFactory . unregisterLayer
// Arg ARG string type= string = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_dnn_LayerFactory_unregisterLayer_String_type(const char* type) {
    try {
        cv::dnn::LayerFactory::unregisterLayer(String(type));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// boxed class: cv::dnn::LayerParams
void cv_delete_LayerParams(void* instance) {
    delete (cv::dnn::LayerParams*) instance;
}
// boxed class: cv::dnn::MVNLayer
void cv_delete_MVNLayer(void* instance) {
    delete (cv::dnn::MVNLayer*) instance;
}
// boxed class: cv::dnn::MaxUnpoolLayer
void cv_delete_MaxUnpoolLayer(void* instance) {
    delete (cv::dnn::MaxUnpoolLayer*) instance;
}
// cv_dnn_Net_Net
// parsed: cv::dnn::Net::Net
// as:     cv::dnn::Net::Net (constructor) cv::dnn::Net (simple) . new
// Return value: cv::dnn::Net (simple)
cv_return_value_Net cv_core_cv_dnn_Net_Net() {
    try {
        cv::dnn::Net ret;
        return { Error::Code::StsOk, NULL, *reinterpret_cast<cv::dnn::Net*>(&ret) };
    } CVRS_CATCH(cv_return_value_Net)
}

// cv_dnn_Net_readFromModelOptimizer_String_xml_String_bin
// parsed: cv::dnn::Net::readFromModelOptimizer
// as:     cv::dnn::Net::readFromModelOptimizer (method) cv::dnn::Net (simple) . readFromModelOptimizer
// Arg ARG string xml= string = 
// Arg ARG string bin= string = 
// Return value: cv::dnn::Net (simple)
cv_return_value_Net cv_core_cv_dnn_Net_readFromModelOptimizer_String_xml_String_bin(const char* xml, const char* bin) {
    try {
        cv::dnn::Net ret = cv::dnn::Net::readFromModelOptimizer(String(xml), String(bin));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<cv::dnn::Net*>(&ret) };
    } CVRS_CATCH(cv_return_value_Net)
}

// cv_dnn_Net_empty_const
// parsed: cv::dnn::Net::empty
// as:     cv::dnn::Net::empty (method) cv::dnn::Net (simple) . empty
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_dnn_Net_empty_const(cv::dnn::Net instance) {
    try {
        bool ret = reinterpret_cast<cv::dnn::Net*>(&instance)->empty();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_dnn_Net_addLayer_String_name_String_type_LayerParams_params
// parsed: cv::dnn::Net::addLayer
// as:     cv::dnn::Net::addLayer (method) cv::dnn::Net (simple) . addLayer
// Arg ARG string name= string = 
// Arg ARG string type= string = 
// Arg ARG cv::dnn::LayerParams (boxed) params= cv::dnn::LayerParams (boxed) = 
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_dnn_Net_addLayer_String_name_String_type_LayerParams_params(cv::dnn::Net instance, const char* name, const char* type, void* params) {
    try {
        int ret = reinterpret_cast<cv::dnn::Net*>(&instance)->addLayer(String(name), String(type), *reinterpret_cast<cv::dnn::LayerParams*>(params));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_dnn_Net_addLayerToPrev_String_name_String_type_LayerParams_params
// parsed: cv::dnn::Net::addLayerToPrev
// as:     cv::dnn::Net::addLayerToPrev (method) cv::dnn::Net (simple) . addLayerToPrev
// Arg ARG string name= string = 
// Arg ARG string type= string = 
// Arg ARG cv::dnn::LayerParams (boxed) params= cv::dnn::LayerParams (boxed) = 
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_dnn_Net_addLayerToPrev_String_name_String_type_LayerParams_params(cv::dnn::Net instance, const char* name, const char* type, void* params) {
    try {
        int ret = reinterpret_cast<cv::dnn::Net*>(&instance)->addLayerToPrev(String(name), String(type), *reinterpret_cast<cv::dnn::LayerParams*>(params));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_dnn_Net_getLayerId_String_layer
// parsed: cv::dnn::Net::getLayerId
// as:     cv::dnn::Net::getLayerId (method) cv::dnn::Net (simple) . getLayerId
// Arg ARG string layer= string = 
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_dnn_Net_getLayerId_String_layer(cv::dnn::Net instance, const char* layer) {
    try {
        int ret = reinterpret_cast<cv::dnn::Net*>(&instance)->getLayerId(String(layer));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_dnn_Net_getLayerNames_const
// parsed: cv::dnn::Net::getLayerNames
// as:     cv::dnn::Net::getLayerNames (method) cv::dnn::Net (simple) . getLayerNames
// Return value: Vector[string]
cv_return_value_void_X cv_core_cv_dnn_Net_getLayerNames_const(cv::dnn::Net instance) {
    try {
        std::vector<String> ret = reinterpret_cast<cv::dnn::Net*>(&instance)->getLayerNames();
        return { Error::Code::StsOk, NULL, (void *)new std::vector<String>(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_dnn_Net_connect_String_outPin_String_inpPin
// parsed: cv::dnn::Net::connect
// as:     cv::dnn::Net::connect (method) cv::dnn::Net (simple) . connect
// Arg ARG string outPin= string = 
// Arg ARG string inpPin= string = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_dnn_Net_connect_String_outPin_String_inpPin(cv::dnn::Net instance, const char* outPin, const char* inpPin) {
    try {
        reinterpret_cast<cv::dnn::Net*>(&instance)->connect(String(outPin), String(inpPin));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_dnn_Net_connect_int_outLayerId_int_outNum_int_inpLayerId_int_inpNum
// parsed: cv::dnn::Net::connect
// as:     cv::dnn::Net::connect (method) cv::dnn::Net (simple) . connect
// Arg ARG Primitive(int) outLayerId= Primitive(int) = 
// Arg ARG Primitive(int) outNum= Primitive(int) = 
// Arg ARG Primitive(int) inpLayerId= Primitive(int) = 
// Arg ARG Primitive(int) inpNum= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_dnn_Net_connect_int_outLayerId_int_outNum_int_inpLayerId_int_inpNum(cv::dnn::Net instance, int outLayerId, int outNum, int inpLayerId, int inpNum) {
    try {
        reinterpret_cast<cv::dnn::Net*>(&instance)->connect(outLayerId, outNum, inpLayerId, inpNum);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_dnn_Net_setInputsNames_VectorOfString_inputBlobNames
// parsed: cv::dnn::Net::setInputsNames
// as:     cv::dnn::Net::setInputsNames (method) cv::dnn::Net (simple) . setInputsNames
// Arg ARG Vector[string] inputBlobNames= Vector[string] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_dnn_Net_setInputsNames_VectorOfString_inputBlobNames(cv::dnn::Net instance, void* inputBlobNames) {
    try {
        reinterpret_cast<cv::dnn::Net*>(&instance)->setInputsNames(*reinterpret_cast<std::vector<String>*>(inputBlobNames));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_dnn_Net_forward_String_outputName
// parsed: cv::dnn::Net::forward
// as:     cv::dnn::Net::forward (method) cv::dnn::Net (simple) . forward
// Arg ARG string outputName= string = String()
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_dnn_Net_forward_String_outputName(cv::dnn::Net instance, const char* outputName) {
    try {
        cv::Mat ret = reinterpret_cast<cv::dnn::Net*>(&instance)->forward(String(outputName));
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_dnn_Net_forward_VectorOfMat_outputBlobs_String_outputName
// parsed: cv::dnn::Net::forward
// as:     cv::dnn::Net::forward (method) cv::dnn::Net (simple) . forward
// Arg ARG Vector[cv::Mat (boxed)] outputBlobs= Vector[cv::Mat (boxed)] = 
// Arg ARG string outputName= string = String()
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_dnn_Net_forward_VectorOfMat_outputBlobs_String_outputName(cv::dnn::Net instance, void** outputBlobs, const char* outputName) {
    try {
        reinterpret_cast<cv::dnn::Net*>(&instance)->forward(*reinterpret_cast<std::vector<cv::Mat>*>(outputBlobs), String(outputName));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_dnn_Net_forward_VectorOfMat_outputBlobs_VectorOfString_outBlobNames
// parsed: cv::dnn::Net::forward
// as:     cv::dnn::Net::forward (method) cv::dnn::Net (simple) . forward
// Arg ARG Vector[cv::Mat (boxed)] outputBlobs= Vector[cv::Mat (boxed)] = 
// Arg ARG Vector[string] outBlobNames= Vector[string] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_dnn_Net_forward_VectorOfMat_outputBlobs_VectorOfString_outBlobNames(cv::dnn::Net instance, void** outputBlobs, void* outBlobNames) {
    try {
        reinterpret_cast<cv::dnn::Net*>(&instance)->forward(*reinterpret_cast<std::vector<cv::Mat>*>(outputBlobs), *reinterpret_cast<std::vector<String>*>(outBlobNames));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_dnn_Net_forward_VectorOfVectorOfMat_outputBlobs_VectorOfString_outBlobNames
// parsed: cv::dnn::Net::forward
// as:     cv::dnn::Net::forward (method) cv::dnn::Net (simple) . forward
// Arg ARG Vector[Vector[cv::Mat (boxed)]] outputBlobs= Vector[Vector[cv::Mat (boxed)]] = 
// Arg ARG Vector[string] outBlobNames= Vector[string] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_dnn_Net_forward_VectorOfVectorOfMat_outputBlobs_VectorOfString_outBlobNames(cv::dnn::Net instance, void* outputBlobs, void* outBlobNames) {
    try {
        reinterpret_cast<cv::dnn::Net*>(&instance)->forward(*reinterpret_cast<std::vector<std::vector<cv::Mat>>*>(outputBlobs), *reinterpret_cast<std::vector<String>*>(outBlobNames));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_dnn_Net_setHalideScheduler_String_scheduler
// parsed: cv::dnn::Net::setHalideScheduler
// as:     cv::dnn::Net::setHalideScheduler (method) cv::dnn::Net (simple) . setHalideScheduler
// Arg ARG string scheduler= string = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_dnn_Net_setHalideScheduler_String_scheduler(cv::dnn::Net instance, const char* scheduler) {
    try {
        reinterpret_cast<cv::dnn::Net*>(&instance)->setHalideScheduler(String(scheduler));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_dnn_Net_setPreferableBackend_int_backendId
// parsed: cv::dnn::Net::setPreferableBackend
// as:     cv::dnn::Net::setPreferableBackend (method) cv::dnn::Net (simple) . setPreferableBackend
// Arg ARG Primitive(int) backendId= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_dnn_Net_setPreferableBackend_int_backendId(cv::dnn::Net instance, int backendId) {
    try {
        reinterpret_cast<cv::dnn::Net*>(&instance)->setPreferableBackend(backendId);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_dnn_Net_setPreferableTarget_int_targetId
// parsed: cv::dnn::Net::setPreferableTarget
// as:     cv::dnn::Net::setPreferableTarget (method) cv::dnn::Net (simple) . setPreferableTarget
// Arg ARG Primitive(int) targetId= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_dnn_Net_setPreferableTarget_int_targetId(cv::dnn::Net instance, int targetId) {
    try {
        reinterpret_cast<cv::dnn::Net*>(&instance)->setPreferableTarget(targetId);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_dnn_Net_setInput_Mat_blob_String_name_double_scalefactor_Scalar_mean
// parsed: cv::dnn::Net::setInput
// as:     cv::dnn::Net::setInput (method) cv::dnn::Net (simple) . setInput
// Arg ARG cv::Mat (boxed) blob= cv::Mat (boxed) = 
// Arg ARG string name= string = ""
// Arg ARG Primitive(double) scalefactor= Primitive(double) = 1.0
// Arg ARG cv::Scalar (simple) mean= cv::Scalar (simple) = Scalar()
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_dnn_Net_setInput_Mat_blob_String_name_double_scalefactor_Scalar_mean(cv::dnn::Net instance, void* blob, const char* name, double scalefactor, ScalarWrapper mean) {
    try {
        reinterpret_cast<cv::dnn::Net*>(&instance)->setInput(*reinterpret_cast<cv::Mat*>(blob), String(name), scalefactor, *reinterpret_cast<cv::Scalar*>(&mean));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_dnn_Net_setParam_DictValue_layer_int_numParam_Mat_blob
// parsed: cv::dnn::Net::setParam
// as:     cv::dnn::Net::setParam (method) cv::dnn::Net (simple) . setParam
// Arg ARG cv::dnn::DictValue (boxed) layer= cv::dnn::DictValue (boxed) = 
// Arg ARG Primitive(int) numParam= Primitive(int) = 
// Arg ARG cv::Mat (boxed) blob= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_dnn_Net_setParam_DictValue_layer_int_numParam_Mat_blob(cv::dnn::Net instance, void* layer, int numParam, void* blob) {
    try {
        reinterpret_cast<cv::dnn::Net*>(&instance)->setParam(*reinterpret_cast<cv::dnn::DictValue*>(layer), numParam, *reinterpret_cast<cv::Mat*>(blob));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_dnn_Net_getParam_DictValue_layer_int_numParam
// parsed: cv::dnn::Net::getParam
// as:     cv::dnn::Net::getParam (method) cv::dnn::Net (simple) . getParam
// Arg ARG cv::dnn::DictValue (boxed) layer= cv::dnn::DictValue (boxed) = 
// Arg ARG Primitive(int) numParam= Primitive(int) = 0
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_dnn_Net_getParam_DictValue_layer_int_numParam(cv::dnn::Net instance, void* layer, int numParam) {
    try {
        cv::Mat ret = reinterpret_cast<cv::dnn::Net*>(&instance)->getParam(*reinterpret_cast<cv::dnn::DictValue*>(layer), numParam);
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_dnn_Net_getUnconnectedOutLayers_const
// parsed: cv::dnn::Net::getUnconnectedOutLayers
// as:     cv::dnn::Net::getUnconnectedOutLayers (method) cv::dnn::Net (simple) . getUnconnectedOutLayers
// Return value: Vector[Primitive(int)]
cv_return_value_void_X cv_core_cv_dnn_Net_getUnconnectedOutLayers_const(cv::dnn::Net instance) {
    try {
        std::vector<int> ret = reinterpret_cast<cv::dnn::Net*>(&instance)->getUnconnectedOutLayers();
        return { Error::Code::StsOk, NULL, (void *)new std::vector<int>(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_dnn_Net_getUnconnectedOutLayersNames_const
// parsed: cv::dnn::Net::getUnconnectedOutLayersNames
// as:     cv::dnn::Net::getUnconnectedOutLayersNames (method) cv::dnn::Net (simple) . getUnconnectedOutLayersNames
// Return value: Vector[string]
cv_return_value_void_X cv_core_cv_dnn_Net_getUnconnectedOutLayersNames_const(cv::dnn::Net instance) {
    try {
        std::vector<String> ret = reinterpret_cast<cv::dnn::Net*>(&instance)->getUnconnectedOutLayersNames();
        return { Error::Code::StsOk, NULL, (void *)new std::vector<String>(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_dnn_Net_getLayersShapes_const_VectorOfVectorOfint_netInputShapes_VectorOfint_layersIds_VectorOfVectorOfVectorOfint_inLayersShapes_VectorOfVectorOfVectorOfint_outLayersShapes
// parsed: cv::dnn::Net::getLayersShapes
// as:     cv::dnn::Net::getLayersShapes (method) cv::dnn::Net (simple) . getLayersShapes
// Arg ARG Vector[Vector[Primitive(int)]] netInputShapes= Vector[Vector[Primitive(int)]] = 
// Arg ARG Vector[Primitive(int)] layersIds= Vector[Primitive(int)] = 
// Arg ARG Vector[Vector[Vector[Primitive(int)]]] inLayersShapes= Vector[Vector[Vector[Primitive(int)]]] = 
// Arg ARG Vector[Vector[Vector[Primitive(int)]]] outLayersShapes= Vector[Vector[Vector[Primitive(int)]]] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_dnn_Net_getLayersShapes_const_VectorOfVectorOfint_netInputShapes_VectorOfint_layersIds_VectorOfVectorOfVectorOfint_inLayersShapes_VectorOfVectorOfVectorOfint_outLayersShapes(cv::dnn::Net instance, void* netInputShapes, void* layersIds, void* inLayersShapes, void* outLayersShapes) {
    try {
        reinterpret_cast<cv::dnn::Net*>(&instance)->getLayersShapes(*reinterpret_cast<std::vector<std::vector<int>>*>(netInputShapes), *reinterpret_cast<std::vector<int>*>(layersIds), *reinterpret_cast<std::vector<std::vector<std::vector<int>>>*>(inLayersShapes), *reinterpret_cast<std::vector<std::vector<std::vector<int>>>*>(outLayersShapes));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_dnn_Net_getLayerShapes_const_VectorOfVectorOfint_netInputShapes_int_layerId_VectorOfVectorOfint_inLayerShapes_VectorOfVectorOfint_outLayerShapes
// parsed: cv::dnn::Net::getLayerShapes
// as:     cv::dnn::Net::getLayerShapes (method) cv::dnn::Net (simple) . getLayerShapes
// Arg ARG Vector[Vector[Primitive(int)]] netInputShapes= Vector[Vector[Primitive(int)]] = 
// Arg ARG Primitive(int) layerId= Primitive(int) = 
// Arg ARG Vector[Vector[Primitive(int)]] inLayerShapes= Vector[Vector[Primitive(int)]] = 
// Arg ARG Vector[Vector[Primitive(int)]] outLayerShapes= Vector[Vector[Primitive(int)]] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_dnn_Net_getLayerShapes_const_VectorOfVectorOfint_netInputShapes_int_layerId_VectorOfVectorOfint_inLayerShapes_VectorOfVectorOfint_outLayerShapes(cv::dnn::Net instance, void* netInputShapes, int layerId, void* inLayerShapes, void* outLayerShapes) {
    try {
        reinterpret_cast<cv::dnn::Net*>(&instance)->getLayerShapes(*reinterpret_cast<std::vector<std::vector<int>>*>(netInputShapes), layerId, *reinterpret_cast<std::vector<std::vector<int>>*>(inLayerShapes), *reinterpret_cast<std::vector<std::vector<int>>*>(outLayerShapes));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_dnn_Net_getFLOPS_const_VectorOfVectorOfint_netInputShapes
// parsed: cv::dnn::Net::getFLOPS
// as:     cv::dnn::Net::getFLOPS (method) cv::dnn::Net (simple) . getFLOPS
// Arg ARG Vector[Vector[Primitive(int)]] netInputShapes= Vector[Vector[Primitive(int)]] = 
// Return value: Primitive(int64)
cv_return_value_int64 cv_core_cv_dnn_Net_getFLOPS_const_VectorOfVectorOfint_netInputShapes(cv::dnn::Net instance, void* netInputShapes) {
    try {
        int64 ret = reinterpret_cast<cv::dnn::Net*>(&instance)->getFLOPS(*reinterpret_cast<std::vector<std::vector<int>>*>(netInputShapes));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int64*>(&ret) };
    } CVRS_CATCH(cv_return_value_int64)
}

// cv_dnn_Net_getFLOPS_const_int_layerId_VectorOfVectorOfint_netInputShapes
// parsed: cv::dnn::Net::getFLOPS
// as:     cv::dnn::Net::getFLOPS (method) cv::dnn::Net (simple) . getFLOPS
// Arg ARG Primitive(int) layerId= Primitive(int) = 
// Arg ARG Vector[Vector[Primitive(int)]] netInputShapes= Vector[Vector[Primitive(int)]] = 
// Return value: Primitive(int64)
cv_return_value_int64 cv_core_cv_dnn_Net_getFLOPS_const_int_layerId_VectorOfVectorOfint_netInputShapes(cv::dnn::Net instance, int layerId, void* netInputShapes) {
    try {
        int64 ret = reinterpret_cast<cv::dnn::Net*>(&instance)->getFLOPS(layerId, *reinterpret_cast<std::vector<std::vector<int>>*>(netInputShapes));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int64*>(&ret) };
    } CVRS_CATCH(cv_return_value_int64)
}

// cv_dnn_Net_getLayerTypes_const_VectorOfString_layersTypes
// parsed: cv::dnn::Net::getLayerTypes
// as:     cv::dnn::Net::getLayerTypes (method) cv::dnn::Net (simple) . getLayerTypes
// Arg ARG Vector[string] layersTypes= Vector[string] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_dnn_Net_getLayerTypes_const_VectorOfString_layersTypes(cv::dnn::Net instance, void* layersTypes) {
    try {
        reinterpret_cast<cv::dnn::Net*>(&instance)->getLayerTypes(*reinterpret_cast<std::vector<String>*>(layersTypes));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_dnn_Net_getLayersCount_const_String_layerType
// parsed: cv::dnn::Net::getLayersCount
// as:     cv::dnn::Net::getLayersCount (method) cv::dnn::Net (simple) . getLayersCount
// Arg ARG string layerType= string = 
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_dnn_Net_getLayersCount_const_String_layerType(cv::dnn::Net instance, const char* layerType) {
    try {
        int ret = reinterpret_cast<cv::dnn::Net*>(&instance)->getLayersCount(String(layerType));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_dnn_Net_getMemoryConsumption_const_VectorOfVectorOfint_netInputShapes_size_t_weights_size_t_blobs
// parsed: cv::dnn::Net::getMemoryConsumption
// as:     cv::dnn::Net::getMemoryConsumption (method) cv::dnn::Net (simple) . getMemoryConsumption
// Arg ARG Vector[Vector[Primitive(int)]] netInputShapes= Vector[Vector[Primitive(int)]] = 
// Arg ARG Primitive(size_t) weights= Primitive(size_t) = 
// Arg ARG Primitive(size_t) blobs= Primitive(size_t) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_dnn_Net_getMemoryConsumption_const_VectorOfVectorOfint_netInputShapes_size_t_weights_size_t_blobs(cv::dnn::Net instance, void* netInputShapes, std::size_t weights, std::size_t blobs) {
    try {
        reinterpret_cast<cv::dnn::Net*>(&instance)->getMemoryConsumption(*reinterpret_cast<std::vector<std::vector<int>>*>(netInputShapes), weights, blobs);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_dnn_Net_getMemoryConsumption_const_int_layerId_VectorOfVectorOfint_netInputShapes_size_t_weights_size_t_blobs
// parsed: cv::dnn::Net::getMemoryConsumption
// as:     cv::dnn::Net::getMemoryConsumption (method) cv::dnn::Net (simple) . getMemoryConsumption
// Arg ARG Primitive(int) layerId= Primitive(int) = 
// Arg ARG Vector[Vector[Primitive(int)]] netInputShapes= Vector[Vector[Primitive(int)]] = 
// Arg ARG Primitive(size_t) weights= Primitive(size_t) = 
// Arg ARG Primitive(size_t) blobs= Primitive(size_t) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_dnn_Net_getMemoryConsumption_const_int_layerId_VectorOfVectorOfint_netInputShapes_size_t_weights_size_t_blobs(cv::dnn::Net instance, int layerId, void* netInputShapes, std::size_t weights, std::size_t blobs) {
    try {
        reinterpret_cast<cv::dnn::Net*>(&instance)->getMemoryConsumption(layerId, *reinterpret_cast<std::vector<std::vector<int>>*>(netInputShapes), weights, blobs);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_dnn_Net_getMemoryConsumption_const_VectorOfVectorOfint_netInputShapes_VectorOfint_layerIds_VectorOfsize_t_weights_VectorOfsize_t_blobs
// parsed: cv::dnn::Net::getMemoryConsumption
// as:     cv::dnn::Net::getMemoryConsumption (method) cv::dnn::Net (simple) . getMemoryConsumption
// Arg ARG Vector[Vector[Primitive(int)]] netInputShapes= Vector[Vector[Primitive(int)]] = 
// Arg ARG Vector[Primitive(int)] layerIds= Vector[Primitive(int)] = 
// Arg ARG Vector[Primitive(size_t)] weights= Vector[Primitive(size_t)] = 
// Arg ARG Vector[Primitive(size_t)] blobs= Vector[Primitive(size_t)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_dnn_Net_getMemoryConsumption_const_VectorOfVectorOfint_netInputShapes_VectorOfint_layerIds_VectorOfsize_t_weights_VectorOfsize_t_blobs(cv::dnn::Net instance, void* netInputShapes, void* layerIds, void* weights, void* blobs) {
    try {
        reinterpret_cast<cv::dnn::Net*>(&instance)->getMemoryConsumption(*reinterpret_cast<std::vector<std::vector<int>>*>(netInputShapes), *reinterpret_cast<std::vector<int>*>(layerIds), *reinterpret_cast<std::vector<size_t>*>(weights), *reinterpret_cast<std::vector<size_t>*>(blobs));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_dnn_Net_enableFusion_bool_fusion
// parsed: cv::dnn::Net::enableFusion
// as:     cv::dnn::Net::enableFusion (method) cv::dnn::Net (simple) . enableFusion
// Arg ARG Primitive(bool) fusion= Primitive(bool) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_dnn_Net_enableFusion_bool_fusion(cv::dnn::Net instance, bool fusion) {
    try {
        reinterpret_cast<cv::dnn::Net*>(&instance)->enableFusion(fusion);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_dnn_Net_getPerfProfile_VectorOfdouble_timings
// parsed: cv::dnn::Net::getPerfProfile
// as:     cv::dnn::Net::getPerfProfile (method) cv::dnn::Net (simple) . getPerfProfile
// Arg ARG Vector[Primitive(double)] timings= Vector[Primitive(double)] = 
// Return value: Primitive(int64)
cv_return_value_int64 cv_core_cv_dnn_Net_getPerfProfile_VectorOfdouble_timings(cv::dnn::Net instance, void* timings) {
    try {
        int64 ret = reinterpret_cast<cv::dnn::Net*>(&instance)->getPerfProfile(*reinterpret_cast<std::vector<double>*>(timings));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int64*>(&ret) };
    } CVRS_CATCH(cv_return_value_int64)
}

// boxed class: cv::dnn::NormalizeBBoxLayer
void cv_delete_NormalizeBBoxLayer(void* instance) {
    delete (cv::dnn::NormalizeBBoxLayer*) instance;
}
// boxed class: cv::dnn::PaddingLayer
void cv_delete_PaddingLayer(void* instance) {
    delete (cv::dnn::PaddingLayer*) instance;
}
// boxed class: cv::dnn::PermuteLayer
void cv_delete_PermuteLayer(void* instance) {
    delete (cv::dnn::PermuteLayer*) instance;
}
// boxed class: cv::dnn::PoolingLayer
void cv_delete_PoolingLayer(void* instance) {
    delete (cv::dnn::PoolingLayer*) instance;
}
// boxed class: cv::dnn::PowerLayer
void cv_delete_PowerLayer(void* instance) {
    delete (cv::dnn::PowerLayer*) instance;
}
// boxed class: cv::dnn::PriorBoxLayer
void cv_delete_PriorBoxLayer(void* instance) {
    delete (cv::dnn::PriorBoxLayer*) instance;
}
// boxed class: cv::dnn::ProposalLayer
void cv_delete_ProposalLayer(void* instance) {
    delete (cv::dnn::ProposalLayer*) instance;
}
// cv_dnn_RNNLayer_setWeights_Mat_Wxh_Mat_bh_Mat_Whh_Mat_Who_Mat_bo
// parsed: cv::dnn::RNNLayer::setWeights
// as:     cv::dnn::RNNLayer::setWeights (method) cv::dnn::RNNLayer (trait) . setWeights
// Arg ARG cv::Mat (boxed) Wxh= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) bh= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) Whh= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) Who= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) bo= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_dnn_RNNLayer_setWeights_Mat_Wxh_Mat_bh_Mat_Whh_Mat_Who_Mat_bo(void* instance, void* Wxh, void* bh, void* Whh, void* Who, void* bo) {
    try {
        reinterpret_cast<cv::dnn::RNNLayer*>(instance)->setWeights(*reinterpret_cast<cv::Mat*>(Wxh), *reinterpret_cast<cv::Mat*>(bh), *reinterpret_cast<cv::Mat*>(Whh), *reinterpret_cast<cv::Mat*>(Who), *reinterpret_cast<cv::Mat*>(bo));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_dnn_RNNLayer_setProduceHiddenOutput_bool_produce
// parsed: cv::dnn::RNNLayer::setProduceHiddenOutput
// as:     cv::dnn::RNNLayer::setProduceHiddenOutput (method) cv::dnn::RNNLayer (trait) . setProduceHiddenOutput
// Arg ARG Primitive(bool) produce= Primitive(bool) = false
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_dnn_RNNLayer_setProduceHiddenOutput_bool_produce(void* instance, bool produce) {
    try {
        reinterpret_cast<cv::dnn::RNNLayer*>(instance)->setProduceHiddenOutput(produce);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// boxed class: cv::dnn::ReLU6Layer
void cv_delete_ReLU6Layer(void* instance) {
    delete (cv::dnn::ReLU6Layer*) instance;
}
// boxed class: cv::dnn::ReLULayer
void cv_delete_ReLULayer(void* instance) {
    delete (cv::dnn::ReLULayer*) instance;
}
// boxed class: cv::dnn::RegionLayer
void cv_delete_RegionLayer(void* instance) {
    delete (cv::dnn::RegionLayer*) instance;
}
// boxed class: cv::dnn::ReorgLayer
void cv_delete_ReorgLayer(void* instance) {
    delete (cv::dnn::ReorgLayer*) instance;
}
// boxed class: cv::dnn::ReshapeLayer
void cv_delete_ReshapeLayer(void* instance) {
    delete (cv::dnn::ReshapeLayer*) instance;
}
// boxed class: cv::dnn::ResizeLayer
void cv_delete_ResizeLayer(void* instance) {
    delete (cv::dnn::ResizeLayer*) instance;
}
// boxed class: cv::dnn::ScaleLayer
void cv_delete_ScaleLayer(void* instance) {
    delete (cv::dnn::ScaleLayer*) instance;
}
// boxed class: cv::dnn::ShiftLayer
void cv_delete_ShiftLayer(void* instance) {
    delete (cv::dnn::ShiftLayer*) instance;
}
// boxed class: cv::dnn::ShuffleChannelLayer
void cv_delete_ShuffleChannelLayer(void* instance) {
    delete (cv::dnn::ShuffleChannelLayer*) instance;
}
// boxed class: cv::dnn::SigmoidLayer
void cv_delete_SigmoidLayer(void* instance) {
    delete (cv::dnn::SigmoidLayer*) instance;
}
// boxed class: cv::dnn::SliceLayer
void cv_delete_SliceLayer(void* instance) {
    delete (cv::dnn::SliceLayer*) instance;
}
// boxed class: cv::dnn::SoftmaxLayer
void cv_delete_SoftmaxLayer(void* instance) {
    delete (cv::dnn::SoftmaxLayer*) instance;
}
// boxed class: cv::dnn::SplitLayer
void cv_delete_SplitLayer(void* instance) {
    delete (cv::dnn::SplitLayer*) instance;
}
// boxed class: cv::dnn::TanHLayer
void cv_delete_TanHLayer(void* instance) {
    delete (cv::dnn::TanHLayer*) instance;
}
// boxed class: cv::float16_t
void cv_delete_float16_t(void* instance) {
    delete (cv::float16_t*) instance;
}
// cv_float16_t_float16_t
// parsed: cv::float16_t::float16_t
// as:     cv::float16_t::float16_t (constructor) cv::float16_t . new
// Return value: cv::float16_t (boxed)
cv_return_value_void_X cv_core_cv_float16_t_float16_t() {
    try {
        cv::float16_t* ret = new cv::float16_t();
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_float16_t_float16_t_float_x
// parsed: cv::float16_t::float16_t
// as:     cv::float16_t::float16_t (constructor) cv::float16_t . new
// Arg ARG Primitive(float) x= Primitive(float) = 
// Return value: cv::float16_t (boxed)
cv_return_value_void_X cv_core_cv_float16_t_float16_t_float_x(float x) {
    try {
        cv::float16_t* ret = new cv::float16_t(x);
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_float16_t_fromBits_ushort_w
// parsed: cv::float16_t::fromBits
// as:     cv::float16_t::fromBits (method) cv::float16_t . fromBits
// Arg ARG Primitive(ushort) w= Primitive(ushort) = 
// Return value: cv::float16_t (boxed)
cv_return_value_void_X cv_core_cv_float16_t_fromBits_ushort_w(unsigned short w) {
    try {
        cv::float16_t ret = cv::float16_t::fromBits(w);
        return { Error::Code::StsOk, NULL, new cv::float16_t(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_float16_t_zero
// parsed: cv::float16_t::zero
// as:     cv::float16_t::zero (method) cv::float16_t . zero
// Return value: cv::float16_t (boxed)
cv_return_value_void_X cv_core_cv_float16_t_zero() {
    try {
        cv::float16_t ret = cv::float16_t::zero();
        return { Error::Code::StsOk, NULL, new cv::float16_t(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_float16_t_bits_const
// parsed: cv::float16_t::bits
// as:     cv::float16_t::bits (method) cv::float16_t . bits
// Return value: Primitive(ushort)
cv_return_value_unsigned_short cv_core_cv_float16_t_bits_const(void* instance) {
    try {
        ushort ret = reinterpret_cast<cv::float16_t*>(instance)->bits();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<unsigned short*>(&ret) };
    } CVRS_CATCH(cv_return_value_unsigned_short)
}

// boxed class: cv::instr::NodeData
void cv_delete_NodeData(void* instance) {
    delete (cv::instr::NodeData*) instance;
}
// cv_instr_NodeData_NodeData_NodeData_ref
// parsed: cv::instr::NodeData::NodeData
// as:     cv::instr::NodeData::NodeData (constructor) cv::instr::NodeData . new
// Arg ARG cv::instr::NodeData (boxed) ref= cv::instr::NodeData (boxed) = 
// Return value: cv::instr::NodeData (boxed)
cv_return_value_void_X cv_core_cv_instr_NodeData_NodeData_NodeData_ref(void* ref) {
    try {
        cv::instr::NodeData* ret = new cv::instr::NodeData(*reinterpret_cast<cv::instr::NodeData*>(ref));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_instr_NodeData_getTotalMs_const
// parsed: cv::instr::NodeData::getTotalMs
// as:     cv::instr::NodeData::getTotalMs (method) cv::instr::NodeData . getTotalMs
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_instr_NodeData_getTotalMs_const(void* instance) {
    try {
        double ret = reinterpret_cast<cv::instr::NodeData*>(instance)->getTotalMs();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_instr_NodeData_getMeanMs_const
// parsed: cv::instr::NodeData::getMeanMs
// as:     cv::instr::NodeData::getMeanMs (method) cv::instr::NodeData . getMeanMs
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_instr_NodeData_getMeanMs_const(void* instance) {
    try {
        double ret = reinterpret_cast<cv::instr::NodeData*>(instance)->getMeanMs();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// boxed class: cv::instr::NodeDataTls
void cv_delete_NodeDataTls(void* instance) {
    delete (cv::instr::NodeDataTls*) instance;
}
// cv_instr_NodeDataTls_NodeDataTls
// parsed: cv::instr::NodeDataTls::NodeDataTls
// as:     cv::instr::NodeDataTls::NodeDataTls (constructor) cv::instr::NodeDataTls . new
// Return value: cv::instr::NodeDataTls (boxed)
cv_return_value_void_X cv_core_cv_instr_NodeDataTls_NodeDataTls() {
    try {
        cv::instr::NodeDataTls* ret = new cv::instr::NodeDataTls();
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_ml_ANN_MLP_setTrainMethod_int_method_double_param1_double_param2
// parsed: cv::ml::ANN_MLP::setTrainMethod
// as:     cv::ml::ANN_MLP::setTrainMethod (method) cv::ml::ANN_MLP (trait) . setTrainMethod
// Arg ARG Primitive(int) method= Primitive(int) = 
// Arg ARG Primitive(double) param1= Primitive(double) = 0
// Arg ARG Primitive(double) param2= Primitive(double) = 0
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ml_ANN_MLP_setTrainMethod_int_method_double_param1_double_param2(void* instance, int method, double param1, double param2) {
    try {
        reinterpret_cast<cv::ml::ANN_MLP*>(instance)->setTrainMethod(method, param1, param2);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ml_ANN_MLP_getTrainMethod_const
// parsed: cv::ml::ANN_MLP::getTrainMethod
// as:     cv::ml::ANN_MLP::getTrainMethod (method) cv::ml::ANN_MLP (trait) . getTrainMethod
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_ml_ANN_MLP_getTrainMethod_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::ml::ANN_MLP*>(instance)->getTrainMethod();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_ml_ANN_MLP_setActivationFunction_int_type_double_param1_double_param2
// parsed: cv::ml::ANN_MLP::setActivationFunction
// as:     cv::ml::ANN_MLP::setActivationFunction (method) cv::ml::ANN_MLP (trait) . setActivationFunction
// Arg ARG Primitive(int) type= Primitive(int) = 
// Arg ARG Primitive(double) param1= Primitive(double) = 0
// Arg ARG Primitive(double) param2= Primitive(double) = 0
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ml_ANN_MLP_setActivationFunction_int_type_double_param1_double_param2(void* instance, int type, double param1, double param2) {
    try {
        reinterpret_cast<cv::ml::ANN_MLP*>(instance)->setActivationFunction(type, param1, param2);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ml_ANN_MLP_setLayerSizes_Mat__layer_sizes
// parsed: cv::ml::ANN_MLP::setLayerSizes
// as:     cv::ml::ANN_MLP::setLayerSizes (method) cv::ml::ANN_MLP (trait) . setLayerSizes
// Arg ARG cv::Mat (boxed) _layer_sizes= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ml_ANN_MLP_setLayerSizes_Mat__layer_sizes(void* instance, void* _layer_sizes) {
    try {
        reinterpret_cast<cv::ml::ANN_MLP*>(instance)->setLayerSizes(*reinterpret_cast<cv::Mat*>(_layer_sizes));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ml_ANN_MLP_getLayerSizes_const
// parsed: cv::ml::ANN_MLP::getLayerSizes
// as:     cv::ml::ANN_MLP::getLayerSizes (method) cv::ml::ANN_MLP (trait) . getLayerSizes
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_ml_ANN_MLP_getLayerSizes_const(void* instance) {
    try {
        cv::Mat ret = reinterpret_cast<cv::ml::ANN_MLP*>(instance)->getLayerSizes();
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_ml_ANN_MLP_getTermCriteria_const
// parsed: cv::ml::ANN_MLP::getTermCriteria
// as:     cv::ml::ANN_MLP::getTermCriteria (method) cv::ml::ANN_MLP (trait) . getTermCriteria
// Return value: cv::TermCriteria (boxed)
cv_return_value_void_X cv_core_cv_ml_ANN_MLP_getTermCriteria_const(void* instance) {
    try {
        cv::TermCriteria ret = reinterpret_cast<cv::ml::ANN_MLP*>(instance)->getTermCriteria();
        return { Error::Code::StsOk, NULL, new cv::TermCriteria(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_ml_ANN_MLP_setTermCriteria_TermCriteria_val
// parsed: cv::ml::ANN_MLP::setTermCriteria
// as:     cv::ml::ANN_MLP::setTermCriteria (method) cv::ml::ANN_MLP (trait) . setTermCriteria
// Arg ARG cv::TermCriteria (boxed) val= cv::TermCriteria (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ml_ANN_MLP_setTermCriteria_TermCriteria_val(void* instance, void* val) {
    try {
        reinterpret_cast<cv::ml::ANN_MLP*>(instance)->setTermCriteria(*reinterpret_cast<cv::TermCriteria*>(val));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ml_ANN_MLP_getBackpropWeightScale_const
// parsed: cv::ml::ANN_MLP::getBackpropWeightScale
// as:     cv::ml::ANN_MLP::getBackpropWeightScale (method) cv::ml::ANN_MLP (trait) . getBackpropWeightScale
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_ml_ANN_MLP_getBackpropWeightScale_const(void* instance) {
    try {
        double ret = reinterpret_cast<cv::ml::ANN_MLP*>(instance)->getBackpropWeightScale();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_ml_ANN_MLP_setBackpropWeightScale_double_val
// parsed: cv::ml::ANN_MLP::setBackpropWeightScale
// as:     cv::ml::ANN_MLP::setBackpropWeightScale (method) cv::ml::ANN_MLP (trait) . setBackpropWeightScale
// Arg ARG Primitive(double) val= Primitive(double) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ml_ANN_MLP_setBackpropWeightScale_double_val(void* instance, double val) {
    try {
        reinterpret_cast<cv::ml::ANN_MLP*>(instance)->setBackpropWeightScale(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ml_ANN_MLP_getBackpropMomentumScale_const
// parsed: cv::ml::ANN_MLP::getBackpropMomentumScale
// as:     cv::ml::ANN_MLP::getBackpropMomentumScale (method) cv::ml::ANN_MLP (trait) . getBackpropMomentumScale
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_ml_ANN_MLP_getBackpropMomentumScale_const(void* instance) {
    try {
        double ret = reinterpret_cast<cv::ml::ANN_MLP*>(instance)->getBackpropMomentumScale();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_ml_ANN_MLP_setBackpropMomentumScale_double_val
// parsed: cv::ml::ANN_MLP::setBackpropMomentumScale
// as:     cv::ml::ANN_MLP::setBackpropMomentumScale (method) cv::ml::ANN_MLP (trait) . setBackpropMomentumScale
// Arg ARG Primitive(double) val= Primitive(double) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ml_ANN_MLP_setBackpropMomentumScale_double_val(void* instance, double val) {
    try {
        reinterpret_cast<cv::ml::ANN_MLP*>(instance)->setBackpropMomentumScale(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ml_ANN_MLP_getRpropDW0_const
// parsed: cv::ml::ANN_MLP::getRpropDW0
// as:     cv::ml::ANN_MLP::getRpropDW0 (method) cv::ml::ANN_MLP (trait) . getRpropDW0
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_ml_ANN_MLP_getRpropDW0_const(void* instance) {
    try {
        double ret = reinterpret_cast<cv::ml::ANN_MLP*>(instance)->getRpropDW0();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_ml_ANN_MLP_setRpropDW0_double_val
// parsed: cv::ml::ANN_MLP::setRpropDW0
// as:     cv::ml::ANN_MLP::setRpropDW0 (method) cv::ml::ANN_MLP (trait) . setRpropDW0
// Arg ARG Primitive(double) val= Primitive(double) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ml_ANN_MLP_setRpropDW0_double_val(void* instance, double val) {
    try {
        reinterpret_cast<cv::ml::ANN_MLP*>(instance)->setRpropDW0(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ml_ANN_MLP_getRpropDWPlus_const
// parsed: cv::ml::ANN_MLP::getRpropDWPlus
// as:     cv::ml::ANN_MLP::getRpropDWPlus (method) cv::ml::ANN_MLP (trait) . getRpropDWPlus
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_ml_ANN_MLP_getRpropDWPlus_const(void* instance) {
    try {
        double ret = reinterpret_cast<cv::ml::ANN_MLP*>(instance)->getRpropDWPlus();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_ml_ANN_MLP_setRpropDWPlus_double_val
// parsed: cv::ml::ANN_MLP::setRpropDWPlus
// as:     cv::ml::ANN_MLP::setRpropDWPlus (method) cv::ml::ANN_MLP (trait) . setRpropDWPlus
// Arg ARG Primitive(double) val= Primitive(double) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ml_ANN_MLP_setRpropDWPlus_double_val(void* instance, double val) {
    try {
        reinterpret_cast<cv::ml::ANN_MLP*>(instance)->setRpropDWPlus(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ml_ANN_MLP_getRpropDWMinus_const
// parsed: cv::ml::ANN_MLP::getRpropDWMinus
// as:     cv::ml::ANN_MLP::getRpropDWMinus (method) cv::ml::ANN_MLP (trait) . getRpropDWMinus
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_ml_ANN_MLP_getRpropDWMinus_const(void* instance) {
    try {
        double ret = reinterpret_cast<cv::ml::ANN_MLP*>(instance)->getRpropDWMinus();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_ml_ANN_MLP_setRpropDWMinus_double_val
// parsed: cv::ml::ANN_MLP::setRpropDWMinus
// as:     cv::ml::ANN_MLP::setRpropDWMinus (method) cv::ml::ANN_MLP (trait) . setRpropDWMinus
// Arg ARG Primitive(double) val= Primitive(double) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ml_ANN_MLP_setRpropDWMinus_double_val(void* instance, double val) {
    try {
        reinterpret_cast<cv::ml::ANN_MLP*>(instance)->setRpropDWMinus(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ml_ANN_MLP_getRpropDWMin_const
// parsed: cv::ml::ANN_MLP::getRpropDWMin
// as:     cv::ml::ANN_MLP::getRpropDWMin (method) cv::ml::ANN_MLP (trait) . getRpropDWMin
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_ml_ANN_MLP_getRpropDWMin_const(void* instance) {
    try {
        double ret = reinterpret_cast<cv::ml::ANN_MLP*>(instance)->getRpropDWMin();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_ml_ANN_MLP_setRpropDWMin_double_val
// parsed: cv::ml::ANN_MLP::setRpropDWMin
// as:     cv::ml::ANN_MLP::setRpropDWMin (method) cv::ml::ANN_MLP (trait) . setRpropDWMin
// Arg ARG Primitive(double) val= Primitive(double) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ml_ANN_MLP_setRpropDWMin_double_val(void* instance, double val) {
    try {
        reinterpret_cast<cv::ml::ANN_MLP*>(instance)->setRpropDWMin(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ml_ANN_MLP_getRpropDWMax_const
// parsed: cv::ml::ANN_MLP::getRpropDWMax
// as:     cv::ml::ANN_MLP::getRpropDWMax (method) cv::ml::ANN_MLP (trait) . getRpropDWMax
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_ml_ANN_MLP_getRpropDWMax_const(void* instance) {
    try {
        double ret = reinterpret_cast<cv::ml::ANN_MLP*>(instance)->getRpropDWMax();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_ml_ANN_MLP_setRpropDWMax_double_val
// parsed: cv::ml::ANN_MLP::setRpropDWMax
// as:     cv::ml::ANN_MLP::setRpropDWMax (method) cv::ml::ANN_MLP (trait) . setRpropDWMax
// Arg ARG Primitive(double) val= Primitive(double) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ml_ANN_MLP_setRpropDWMax_double_val(void* instance, double val) {
    try {
        reinterpret_cast<cv::ml::ANN_MLP*>(instance)->setRpropDWMax(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ml_ANN_MLP_getAnnealInitialT_const
// parsed: cv::ml::ANN_MLP::getAnnealInitialT
// as:     cv::ml::ANN_MLP::getAnnealInitialT (method) cv::ml::ANN_MLP (trait) . getAnnealInitialT
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_ml_ANN_MLP_getAnnealInitialT_const(void* instance) {
    try {
        double ret = reinterpret_cast<cv::ml::ANN_MLP*>(instance)->getAnnealInitialT();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_ml_ANN_MLP_setAnnealInitialT_double_val
// parsed: cv::ml::ANN_MLP::setAnnealInitialT
// as:     cv::ml::ANN_MLP::setAnnealInitialT (method) cv::ml::ANN_MLP (trait) . setAnnealInitialT
// Arg ARG Primitive(double) val= Primitive(double) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ml_ANN_MLP_setAnnealInitialT_double_val(void* instance, double val) {
    try {
        reinterpret_cast<cv::ml::ANN_MLP*>(instance)->setAnnealInitialT(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ml_ANN_MLP_getAnnealFinalT_const
// parsed: cv::ml::ANN_MLP::getAnnealFinalT
// as:     cv::ml::ANN_MLP::getAnnealFinalT (method) cv::ml::ANN_MLP (trait) . getAnnealFinalT
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_ml_ANN_MLP_getAnnealFinalT_const(void* instance) {
    try {
        double ret = reinterpret_cast<cv::ml::ANN_MLP*>(instance)->getAnnealFinalT();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_ml_ANN_MLP_setAnnealFinalT_double_val
// parsed: cv::ml::ANN_MLP::setAnnealFinalT
// as:     cv::ml::ANN_MLP::setAnnealFinalT (method) cv::ml::ANN_MLP (trait) . setAnnealFinalT
// Arg ARG Primitive(double) val= Primitive(double) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ml_ANN_MLP_setAnnealFinalT_double_val(void* instance, double val) {
    try {
        reinterpret_cast<cv::ml::ANN_MLP*>(instance)->setAnnealFinalT(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ml_ANN_MLP_getAnnealCoolingRatio_const
// parsed: cv::ml::ANN_MLP::getAnnealCoolingRatio
// as:     cv::ml::ANN_MLP::getAnnealCoolingRatio (method) cv::ml::ANN_MLP (trait) . getAnnealCoolingRatio
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_ml_ANN_MLP_getAnnealCoolingRatio_const(void* instance) {
    try {
        double ret = reinterpret_cast<cv::ml::ANN_MLP*>(instance)->getAnnealCoolingRatio();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_ml_ANN_MLP_setAnnealCoolingRatio_double_val
// parsed: cv::ml::ANN_MLP::setAnnealCoolingRatio
// as:     cv::ml::ANN_MLP::setAnnealCoolingRatio (method) cv::ml::ANN_MLP (trait) . setAnnealCoolingRatio
// Arg ARG Primitive(double) val= Primitive(double) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ml_ANN_MLP_setAnnealCoolingRatio_double_val(void* instance, double val) {
    try {
        reinterpret_cast<cv::ml::ANN_MLP*>(instance)->setAnnealCoolingRatio(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ml_ANN_MLP_getAnnealItePerStep_const
// parsed: cv::ml::ANN_MLP::getAnnealItePerStep
// as:     cv::ml::ANN_MLP::getAnnealItePerStep (method) cv::ml::ANN_MLP (trait) . getAnnealItePerStep
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_ml_ANN_MLP_getAnnealItePerStep_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::ml::ANN_MLP*>(instance)->getAnnealItePerStep();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_ml_ANN_MLP_setAnnealItePerStep_int_val
// parsed: cv::ml::ANN_MLP::setAnnealItePerStep
// as:     cv::ml::ANN_MLP::setAnnealItePerStep (method) cv::ml::ANN_MLP (trait) . setAnnealItePerStep
// Arg ARG Primitive(int) val= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ml_ANN_MLP_setAnnealItePerStep_int_val(void* instance, int val) {
    try {
        reinterpret_cast<cv::ml::ANN_MLP*>(instance)->setAnnealItePerStep(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ml_ANN_MLP_getWeights_const_int_layerIdx
// parsed: cv::ml::ANN_MLP::getWeights
// as:     cv::ml::ANN_MLP::getWeights (method) cv::ml::ANN_MLP (trait) . getWeights
// Arg ARG Primitive(int) layerIdx= Primitive(int) = 
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_ml_ANN_MLP_getWeights_const_int_layerIdx(void* instance, int layerIdx) {
    try {
        cv::Mat ret = reinterpret_cast<cv::ml::ANN_MLP*>(instance)->getWeights(layerIdx);
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_ml_ANN_MLP_create
// parsed: cv::ml::ANN_MLP::create
// as:     cv::ml::ANN_MLP::create (method) cv::ml::ANN_MLP (trait) . create
// Return value: SmartPtr[cv::ml::ANN_MLP (boxed)]
cv_return_value_void_X cv_core_cv_ml_ANN_MLP_create() {
    try {
        Ptr<cv::ml::ANN_MLP> *ret = new Ptr<cv::ml::ANN_MLP>(cv::ml::ANN_MLP::create());
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_ml_ANN_MLP_load_String_filepath
// parsed: cv::ml::ANN_MLP::load
// as:     cv::ml::ANN_MLP::load (method) cv::ml::ANN_MLP (trait) . load
// Arg ARG string filepath= string = 
// Return value: SmartPtr[cv::ml::ANN_MLP (boxed)]
cv_return_value_void_X cv_core_cv_ml_ANN_MLP_load_String_filepath(const char* filepath) {
    try {
        Ptr<cv::ml::ANN_MLP> *ret = new Ptr<cv::ml::ANN_MLP>(cv::ml::ANN_MLP::load(String(filepath)));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_ml_ANN_MLP_ANNEAL_getAnnealInitialT_const
// parsed: cv::ml::ANN_MLP_ANNEAL::getAnnealInitialT
// as:     cv::ml::ANN_MLP_ANNEAL::getAnnealInitialT (method) cv::ml::ANN_MLP_ANNEAL (trait) . getAnnealInitialT
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_ml_ANN_MLP_ANNEAL_getAnnealInitialT_const(void* instance) {
    try {
        double ret = reinterpret_cast<cv::ml::ANN_MLP_ANNEAL*>(instance)->getAnnealInitialT();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_ml_ANN_MLP_ANNEAL_setAnnealInitialT_double_val
// parsed: cv::ml::ANN_MLP_ANNEAL::setAnnealInitialT
// as:     cv::ml::ANN_MLP_ANNEAL::setAnnealInitialT (method) cv::ml::ANN_MLP_ANNEAL (trait) . setAnnealInitialT
// Arg ARG Primitive(double) val= Primitive(double) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ml_ANN_MLP_ANNEAL_setAnnealInitialT_double_val(void* instance, double val) {
    try {
        reinterpret_cast<cv::ml::ANN_MLP_ANNEAL*>(instance)->setAnnealInitialT(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ml_ANN_MLP_ANNEAL_getAnnealFinalT_const
// parsed: cv::ml::ANN_MLP_ANNEAL::getAnnealFinalT
// as:     cv::ml::ANN_MLP_ANNEAL::getAnnealFinalT (method) cv::ml::ANN_MLP_ANNEAL (trait) . getAnnealFinalT
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_ml_ANN_MLP_ANNEAL_getAnnealFinalT_const(void* instance) {
    try {
        double ret = reinterpret_cast<cv::ml::ANN_MLP_ANNEAL*>(instance)->getAnnealFinalT();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_ml_ANN_MLP_ANNEAL_setAnnealFinalT_double_val
// parsed: cv::ml::ANN_MLP_ANNEAL::setAnnealFinalT
// as:     cv::ml::ANN_MLP_ANNEAL::setAnnealFinalT (method) cv::ml::ANN_MLP_ANNEAL (trait) . setAnnealFinalT
// Arg ARG Primitive(double) val= Primitive(double) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ml_ANN_MLP_ANNEAL_setAnnealFinalT_double_val(void* instance, double val) {
    try {
        reinterpret_cast<cv::ml::ANN_MLP_ANNEAL*>(instance)->setAnnealFinalT(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ml_ANN_MLP_ANNEAL_getAnnealCoolingRatio_const
// parsed: cv::ml::ANN_MLP_ANNEAL::getAnnealCoolingRatio
// as:     cv::ml::ANN_MLP_ANNEAL::getAnnealCoolingRatio (method) cv::ml::ANN_MLP_ANNEAL (trait) . getAnnealCoolingRatio
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_ml_ANN_MLP_ANNEAL_getAnnealCoolingRatio_const(void* instance) {
    try {
        double ret = reinterpret_cast<cv::ml::ANN_MLP_ANNEAL*>(instance)->getAnnealCoolingRatio();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_ml_ANN_MLP_ANNEAL_setAnnealCoolingRatio_double_val
// parsed: cv::ml::ANN_MLP_ANNEAL::setAnnealCoolingRatio
// as:     cv::ml::ANN_MLP_ANNEAL::setAnnealCoolingRatio (method) cv::ml::ANN_MLP_ANNEAL (trait) . setAnnealCoolingRatio
// Arg ARG Primitive(double) val= Primitive(double) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ml_ANN_MLP_ANNEAL_setAnnealCoolingRatio_double_val(void* instance, double val) {
    try {
        reinterpret_cast<cv::ml::ANN_MLP_ANNEAL*>(instance)->setAnnealCoolingRatio(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ml_ANN_MLP_ANNEAL_getAnnealItePerStep_const
// parsed: cv::ml::ANN_MLP_ANNEAL::getAnnealItePerStep
// as:     cv::ml::ANN_MLP_ANNEAL::getAnnealItePerStep (method) cv::ml::ANN_MLP_ANNEAL (trait) . getAnnealItePerStep
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_ml_ANN_MLP_ANNEAL_getAnnealItePerStep_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::ml::ANN_MLP_ANNEAL*>(instance)->getAnnealItePerStep();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_ml_ANN_MLP_ANNEAL_setAnnealItePerStep_int_val
// parsed: cv::ml::ANN_MLP_ANNEAL::setAnnealItePerStep
// as:     cv::ml::ANN_MLP_ANNEAL::setAnnealItePerStep (method) cv::ml::ANN_MLP_ANNEAL (trait) . setAnnealItePerStep
// Arg ARG Primitive(int) val= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ml_ANN_MLP_ANNEAL_setAnnealItePerStep_int_val(void* instance, int val) {
    try {
        reinterpret_cast<cv::ml::ANN_MLP_ANNEAL*>(instance)->setAnnealItePerStep(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ml_Boost_getBoostType_const
// parsed: cv::ml::Boost::getBoostType
// as:     cv::ml::Boost::getBoostType (method) cv::ml::Boost (trait) . getBoostType
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_ml_Boost_getBoostType_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::ml::Boost*>(instance)->getBoostType();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_ml_Boost_setBoostType_int_val
// parsed: cv::ml::Boost::setBoostType
// as:     cv::ml::Boost::setBoostType (method) cv::ml::Boost (trait) . setBoostType
// Arg ARG Primitive(int) val= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ml_Boost_setBoostType_int_val(void* instance, int val) {
    try {
        reinterpret_cast<cv::ml::Boost*>(instance)->setBoostType(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ml_Boost_getWeakCount_const
// parsed: cv::ml::Boost::getWeakCount
// as:     cv::ml::Boost::getWeakCount (method) cv::ml::Boost (trait) . getWeakCount
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_ml_Boost_getWeakCount_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::ml::Boost*>(instance)->getWeakCount();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_ml_Boost_setWeakCount_int_val
// parsed: cv::ml::Boost::setWeakCount
// as:     cv::ml::Boost::setWeakCount (method) cv::ml::Boost (trait) . setWeakCount
// Arg ARG Primitive(int) val= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ml_Boost_setWeakCount_int_val(void* instance, int val) {
    try {
        reinterpret_cast<cv::ml::Boost*>(instance)->setWeakCount(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ml_Boost_getWeightTrimRate_const
// parsed: cv::ml::Boost::getWeightTrimRate
// as:     cv::ml::Boost::getWeightTrimRate (method) cv::ml::Boost (trait) . getWeightTrimRate
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_ml_Boost_getWeightTrimRate_const(void* instance) {
    try {
        double ret = reinterpret_cast<cv::ml::Boost*>(instance)->getWeightTrimRate();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_ml_Boost_setWeightTrimRate_double_val
// parsed: cv::ml::Boost::setWeightTrimRate
// as:     cv::ml::Boost::setWeightTrimRate (method) cv::ml::Boost (trait) . setWeightTrimRate
// Arg ARG Primitive(double) val= Primitive(double) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ml_Boost_setWeightTrimRate_double_val(void* instance, double val) {
    try {
        reinterpret_cast<cv::ml::Boost*>(instance)->setWeightTrimRate(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ml_Boost_create
// parsed: cv::ml::Boost::create
// as:     cv::ml::Boost::create (method) cv::ml::Boost (trait) . create
// Return value: SmartPtr[cv::ml::Boost (boxed)]
cv_return_value_void_X cv_core_cv_ml_Boost_create() {
    try {
        Ptr<cv::ml::Boost> *ret = new Ptr<cv::ml::Boost>(cv::ml::Boost::create());
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_ml_Boost_load_String_filepath_String_nodeName
// parsed: cv::ml::Boost::load
// as:     cv::ml::Boost::load (method) cv::ml::Boost (trait) . load
// Arg ARG string filepath= string = 
// Arg ARG string nodeName= string = String()
// Return value: SmartPtr[cv::ml::Boost (boxed)]
cv_return_value_void_X cv_core_cv_ml_Boost_load_String_filepath_String_nodeName(const char* filepath, const char* nodeName) {
    try {
        Ptr<cv::ml::Boost> *ret = new Ptr<cv::ml::Boost>(cv::ml::Boost::load(String(filepath), String(nodeName)));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_ml_DTrees_getMaxCategories_const
// parsed: cv::ml::DTrees::getMaxCategories
// as:     cv::ml::DTrees::getMaxCategories (method) cv::ml::DTrees (trait) . getMaxCategories
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_ml_DTrees_getMaxCategories_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::ml::DTrees*>(instance)->getMaxCategories();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_ml_DTrees_setMaxCategories_int_val
// parsed: cv::ml::DTrees::setMaxCategories
// as:     cv::ml::DTrees::setMaxCategories (method) cv::ml::DTrees (trait) . setMaxCategories
// Arg ARG Primitive(int) val= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ml_DTrees_setMaxCategories_int_val(void* instance, int val) {
    try {
        reinterpret_cast<cv::ml::DTrees*>(instance)->setMaxCategories(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ml_DTrees_getMaxDepth_const
// parsed: cv::ml::DTrees::getMaxDepth
// as:     cv::ml::DTrees::getMaxDepth (method) cv::ml::DTrees (trait) . getMaxDepth
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_ml_DTrees_getMaxDepth_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::ml::DTrees*>(instance)->getMaxDepth();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_ml_DTrees_setMaxDepth_int_val
// parsed: cv::ml::DTrees::setMaxDepth
// as:     cv::ml::DTrees::setMaxDepth (method) cv::ml::DTrees (trait) . setMaxDepth
// Arg ARG Primitive(int) val= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ml_DTrees_setMaxDepth_int_val(void* instance, int val) {
    try {
        reinterpret_cast<cv::ml::DTrees*>(instance)->setMaxDepth(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ml_DTrees_getMinSampleCount_const
// parsed: cv::ml::DTrees::getMinSampleCount
// as:     cv::ml::DTrees::getMinSampleCount (method) cv::ml::DTrees (trait) . getMinSampleCount
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_ml_DTrees_getMinSampleCount_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::ml::DTrees*>(instance)->getMinSampleCount();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_ml_DTrees_setMinSampleCount_int_val
// parsed: cv::ml::DTrees::setMinSampleCount
// as:     cv::ml::DTrees::setMinSampleCount (method) cv::ml::DTrees (trait) . setMinSampleCount
// Arg ARG Primitive(int) val= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ml_DTrees_setMinSampleCount_int_val(void* instance, int val) {
    try {
        reinterpret_cast<cv::ml::DTrees*>(instance)->setMinSampleCount(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ml_DTrees_getCVFolds_const
// parsed: cv::ml::DTrees::getCVFolds
// as:     cv::ml::DTrees::getCVFolds (method) cv::ml::DTrees (trait) . getCVFolds
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_ml_DTrees_getCVFolds_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::ml::DTrees*>(instance)->getCVFolds();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_ml_DTrees_setCVFolds_int_val
// parsed: cv::ml::DTrees::setCVFolds
// as:     cv::ml::DTrees::setCVFolds (method) cv::ml::DTrees (trait) . setCVFolds
// Arg ARG Primitive(int) val= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ml_DTrees_setCVFolds_int_val(void* instance, int val) {
    try {
        reinterpret_cast<cv::ml::DTrees*>(instance)->setCVFolds(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ml_DTrees_getUseSurrogates_const
// parsed: cv::ml::DTrees::getUseSurrogates
// as:     cv::ml::DTrees::getUseSurrogates (method) cv::ml::DTrees (trait) . getUseSurrogates
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_ml_DTrees_getUseSurrogates_const(void* instance) {
    try {
        bool ret = reinterpret_cast<cv::ml::DTrees*>(instance)->getUseSurrogates();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_ml_DTrees_setUseSurrogates_bool_val
// parsed: cv::ml::DTrees::setUseSurrogates
// as:     cv::ml::DTrees::setUseSurrogates (method) cv::ml::DTrees (trait) . setUseSurrogates
// Arg ARG Primitive(bool) val= Primitive(bool) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ml_DTrees_setUseSurrogates_bool_val(void* instance, bool val) {
    try {
        reinterpret_cast<cv::ml::DTrees*>(instance)->setUseSurrogates(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ml_DTrees_getUse1SERule_const
// parsed: cv::ml::DTrees::getUse1SERule
// as:     cv::ml::DTrees::getUse1SERule (method) cv::ml::DTrees (trait) . getUse1SERule
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_ml_DTrees_getUse1SERule_const(void* instance) {
    try {
        bool ret = reinterpret_cast<cv::ml::DTrees*>(instance)->getUse1SERule();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_ml_DTrees_setUse1SERule_bool_val
// parsed: cv::ml::DTrees::setUse1SERule
// as:     cv::ml::DTrees::setUse1SERule (method) cv::ml::DTrees (trait) . setUse1SERule
// Arg ARG Primitive(bool) val= Primitive(bool) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ml_DTrees_setUse1SERule_bool_val(void* instance, bool val) {
    try {
        reinterpret_cast<cv::ml::DTrees*>(instance)->setUse1SERule(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ml_DTrees_getTruncatePrunedTree_const
// parsed: cv::ml::DTrees::getTruncatePrunedTree
// as:     cv::ml::DTrees::getTruncatePrunedTree (method) cv::ml::DTrees (trait) . getTruncatePrunedTree
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_ml_DTrees_getTruncatePrunedTree_const(void* instance) {
    try {
        bool ret = reinterpret_cast<cv::ml::DTrees*>(instance)->getTruncatePrunedTree();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_ml_DTrees_setTruncatePrunedTree_bool_val
// parsed: cv::ml::DTrees::setTruncatePrunedTree
// as:     cv::ml::DTrees::setTruncatePrunedTree (method) cv::ml::DTrees (trait) . setTruncatePrunedTree
// Arg ARG Primitive(bool) val= Primitive(bool) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ml_DTrees_setTruncatePrunedTree_bool_val(void* instance, bool val) {
    try {
        reinterpret_cast<cv::ml::DTrees*>(instance)->setTruncatePrunedTree(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ml_DTrees_getRegressionAccuracy_const
// parsed: cv::ml::DTrees::getRegressionAccuracy
// as:     cv::ml::DTrees::getRegressionAccuracy (method) cv::ml::DTrees (trait) . getRegressionAccuracy
// Return value: Primitive(float)
cv_return_value_float cv_core_cv_ml_DTrees_getRegressionAccuracy_const(void* instance) {
    try {
        float ret = reinterpret_cast<cv::ml::DTrees*>(instance)->getRegressionAccuracy();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<float*>(&ret) };
    } CVRS_CATCH(cv_return_value_float)
}

// cv_ml_DTrees_setRegressionAccuracy_float_val
// parsed: cv::ml::DTrees::setRegressionAccuracy
// as:     cv::ml::DTrees::setRegressionAccuracy (method) cv::ml::DTrees (trait) . setRegressionAccuracy
// Arg ARG Primitive(float) val= Primitive(float) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ml_DTrees_setRegressionAccuracy_float_val(void* instance, float val) {
    try {
        reinterpret_cast<cv::ml::DTrees*>(instance)->setRegressionAccuracy(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ml_DTrees_getPriors_const
// parsed: cv::ml::DTrees::getPriors
// as:     cv::ml::DTrees::getPriors (method) cv::ml::DTrees (trait) . getPriors
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_ml_DTrees_getPriors_const(void* instance) {
    try {
        cv::Mat ret = reinterpret_cast<cv::ml::DTrees*>(instance)->getPriors();
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_ml_DTrees_setPriors_Mat_val
// parsed: cv::ml::DTrees::setPriors
// as:     cv::ml::DTrees::setPriors (method) cv::ml::DTrees (trait) . setPriors
// Arg ARG cv::Mat (boxed) val= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ml_DTrees_setPriors_Mat_val(void* instance, void* val) {
    try {
        reinterpret_cast<cv::ml::DTrees*>(instance)->setPriors(*reinterpret_cast<cv::Mat*>(val));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ml_DTrees_getRoots_const
// parsed: cv::ml::DTrees::getRoots
// as:     cv::ml::DTrees::getRoots (method) cv::ml::DTrees (trait) . getRoots
// Return value: Vector[Primitive(int)]
cv_return_value_void_X cv_core_cv_ml_DTrees_getRoots_const(void* instance) {
    try {
        std::vector<int> ret = reinterpret_cast<cv::ml::DTrees*>(instance)->getRoots();
        return { Error::Code::StsOk, NULL, (void *)new std::vector<int>(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_ml_DTrees_getSplits_const
// parsed: cv::ml::DTrees::getSplits
// as:     cv::ml::DTrees::getSplits (method) cv::ml::DTrees (trait) . getSplits
// Return value: Vector[cv::ml::DTrees::Split (boxed)]
cv_return_value_void_X cv_core_cv_ml_DTrees_getSplits_const(void* instance) {
    try {
        std::vector<cv::ml::DTrees::Split> ret = reinterpret_cast<cv::ml::DTrees*>(instance)->getSplits();
        return { Error::Code::StsOk, NULL, (void *)new std::vector<cv::ml::DTrees::Split>(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_ml_DTrees_getSubsets_const
// parsed: cv::ml::DTrees::getSubsets
// as:     cv::ml::DTrees::getSubsets (method) cv::ml::DTrees (trait) . getSubsets
// Return value: Vector[Primitive(int)]
cv_return_value_void_X cv_core_cv_ml_DTrees_getSubsets_const(void* instance) {
    try {
        std::vector<int> ret = reinterpret_cast<cv::ml::DTrees*>(instance)->getSubsets();
        return { Error::Code::StsOk, NULL, (void *)new std::vector<int>(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_ml_DTrees_create
// parsed: cv::ml::DTrees::create
// as:     cv::ml::DTrees::create (method) cv::ml::DTrees (trait) . create
// Return value: SmartPtr[cv::ml::DTrees (boxed)]
cv_return_value_void_X cv_core_cv_ml_DTrees_create() {
    try {
        Ptr<cv::ml::DTrees> *ret = new Ptr<cv::ml::DTrees>(cv::ml::DTrees::create());
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_ml_DTrees_load_String_filepath_String_nodeName
// parsed: cv::ml::DTrees::load
// as:     cv::ml::DTrees::load (method) cv::ml::DTrees (trait) . load
// Arg ARG string filepath= string = 
// Arg ARG string nodeName= string = String()
// Return value: SmartPtr[cv::ml::DTrees (boxed)]
cv_return_value_void_X cv_core_cv_ml_DTrees_load_String_filepath_String_nodeName(const char* filepath, const char* nodeName) {
    try {
        Ptr<cv::ml::DTrees> *ret = new Ptr<cv::ml::DTrees>(cv::ml::DTrees::load(String(filepath), String(nodeName)));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// boxed class: cv::ml::DTrees::Node
void cv_delete_DTrees_Node(void* instance) {
    delete (cv::ml::DTrees::Node*) instance;
}
// boxed class: cv::ml::DTrees::Split
void cv_delete_DTrees_Split(void* instance) {
    delete (cv::ml::DTrees::Split*) instance;
}
// cv_ml_DTrees_Split_Split
// parsed: cv::ml::DTrees::Split::Split
// as:     cv::ml::DTrees::Split::Split (constructor) cv::ml::DTrees::Split . new
// Return value: cv::ml::DTrees::Split (boxed)
cv_return_value_void_X cv_core_cv_ml_DTrees_Split_Split() {
    try {
        cv::ml::DTrees::Split* ret = new cv::ml::DTrees::Split();
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_ml_EM_getClustersNumber_const
// parsed: cv::ml::EM::getClustersNumber
// as:     cv::ml::EM::getClustersNumber (method) cv::ml::EM (trait) . getClustersNumber
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_ml_EM_getClustersNumber_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::ml::EM*>(instance)->getClustersNumber();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_ml_EM_setClustersNumber_int_val
// parsed: cv::ml::EM::setClustersNumber
// as:     cv::ml::EM::setClustersNumber (method) cv::ml::EM (trait) . setClustersNumber
// Arg ARG Primitive(int) val= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ml_EM_setClustersNumber_int_val(void* instance, int val) {
    try {
        reinterpret_cast<cv::ml::EM*>(instance)->setClustersNumber(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ml_EM_getCovarianceMatrixType_const
// parsed: cv::ml::EM::getCovarianceMatrixType
// as:     cv::ml::EM::getCovarianceMatrixType (method) cv::ml::EM (trait) . getCovarianceMatrixType
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_ml_EM_getCovarianceMatrixType_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::ml::EM*>(instance)->getCovarianceMatrixType();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_ml_EM_setCovarianceMatrixType_int_val
// parsed: cv::ml::EM::setCovarianceMatrixType
// as:     cv::ml::EM::setCovarianceMatrixType (method) cv::ml::EM (trait) . setCovarianceMatrixType
// Arg ARG Primitive(int) val= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ml_EM_setCovarianceMatrixType_int_val(void* instance, int val) {
    try {
        reinterpret_cast<cv::ml::EM*>(instance)->setCovarianceMatrixType(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ml_EM_getTermCriteria_const
// parsed: cv::ml::EM::getTermCriteria
// as:     cv::ml::EM::getTermCriteria (method) cv::ml::EM (trait) . getTermCriteria
// Return value: cv::TermCriteria (boxed)
cv_return_value_void_X cv_core_cv_ml_EM_getTermCriteria_const(void* instance) {
    try {
        cv::TermCriteria ret = reinterpret_cast<cv::ml::EM*>(instance)->getTermCriteria();
        return { Error::Code::StsOk, NULL, new cv::TermCriteria(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_ml_EM_setTermCriteria_TermCriteria_val
// parsed: cv::ml::EM::setTermCriteria
// as:     cv::ml::EM::setTermCriteria (method) cv::ml::EM (trait) . setTermCriteria
// Arg ARG cv::TermCriteria (boxed) val= cv::TermCriteria (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ml_EM_setTermCriteria_TermCriteria_val(void* instance, void* val) {
    try {
        reinterpret_cast<cv::ml::EM*>(instance)->setTermCriteria(*reinterpret_cast<cv::TermCriteria*>(val));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ml_EM_getWeights_const
// parsed: cv::ml::EM::getWeights
// as:     cv::ml::EM::getWeights (method) cv::ml::EM (trait) . getWeights
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_ml_EM_getWeights_const(void* instance) {
    try {
        cv::Mat ret = reinterpret_cast<cv::ml::EM*>(instance)->getWeights();
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_ml_EM_getMeans_const
// parsed: cv::ml::EM::getMeans
// as:     cv::ml::EM::getMeans (method) cv::ml::EM (trait) . getMeans
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_ml_EM_getMeans_const(void* instance) {
    try {
        cv::Mat ret = reinterpret_cast<cv::ml::EM*>(instance)->getMeans();
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_ml_EM_getCovs_const_VectorOfMat_covs
// parsed: cv::ml::EM::getCovs
// as:     cv::ml::EM::getCovs (method) cv::ml::EM (trait) . getCovs
// Arg ARG Vector[cv::Mat (boxed)] covs= Vector[cv::Mat (boxed)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ml_EM_getCovs_const_VectorOfMat_covs(void* instance, void* covs) {
    try {
        reinterpret_cast<cv::ml::EM*>(instance)->getCovs(*reinterpret_cast<std::vector<cv::Mat>*>(covs));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ml_EM_predict_const_Mat_samples_Mat_results_int_flags
// parsed: cv::ml::EM::predict
// as:     cv::ml::EM::predict (method) cv::ml::EM (trait) . predict
// Arg ARG cv::Mat (boxed) samples= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) results= cv::Mat (boxed) = noArray()
// Arg ARG Primitive(int) flags= Primitive(int) = 0
// Return value: Primitive(float)
cv_return_value_float cv_core_cv_ml_EM_predict_const_Mat_samples_Mat_results_int_flags(void* instance, void* samples, void* results, int flags) {
    try {
        float ret = reinterpret_cast<cv::ml::EM*>(instance)->predict(*reinterpret_cast<cv::Mat*>(samples), *reinterpret_cast<cv::Mat*>(results), flags);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<float*>(&ret) };
    } CVRS_CATCH(cv_return_value_float)
}

// cv_ml_EM_predict2_const_Mat_sample_Mat_probs
// parsed: cv::ml::EM::predict2
// as:     cv::ml::EM::predict2 (method) cv::ml::EM (trait) . predict2
// Arg ARG cv::Mat (boxed) sample= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) probs= cv::Mat (boxed) = 
// Return value: cv::Vec2d (simple)
cv_return_value_Vec2dWrapper cv_core_cv_ml_EM_predict2_const_Mat_sample_Mat_probs(void* instance, void* sample, void* probs) {
    try {
        cv::Vec2d ret = reinterpret_cast<cv::ml::EM*>(instance)->predict2(*reinterpret_cast<cv::Mat*>(sample), *reinterpret_cast<cv::Mat*>(probs));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<Vec2dWrapper*>(&ret) };
    } CVRS_CATCH(cv_return_value_Vec2dWrapper)
}

// cv_ml_EM_trainEM_Mat_samples_Mat_logLikelihoods_Mat_labels_Mat_probs
// parsed: cv::ml::EM::trainEM
// as:     cv::ml::EM::trainEM (method) cv::ml::EM (trait) . trainEM
// Arg ARG cv::Mat (boxed) samples= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) logLikelihoods= cv::Mat (boxed) = noArray()
// Arg ARG cv::Mat (boxed) labels= cv::Mat (boxed) = noArray()
// Arg ARG cv::Mat (boxed) probs= cv::Mat (boxed) = noArray()
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_ml_EM_trainEM_Mat_samples_Mat_logLikelihoods_Mat_labels_Mat_probs(void* instance, void* samples, void* logLikelihoods, void* labels, void* probs) {
    try {
        bool ret = reinterpret_cast<cv::ml::EM*>(instance)->trainEM(*reinterpret_cast<cv::Mat*>(samples), *reinterpret_cast<cv::Mat*>(logLikelihoods), *reinterpret_cast<cv::Mat*>(labels), *reinterpret_cast<cv::Mat*>(probs));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_ml_EM_trainE_Mat_samples_Mat_means0_Mat_covs0_Mat_weights0_Mat_logLikelihoods_Mat_labels_Mat_probs
// parsed: cv::ml::EM::trainE
// as:     cv::ml::EM::trainE (method) cv::ml::EM (trait) . trainE
// Arg ARG cv::Mat (boxed) samples= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) means0= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) covs0= cv::Mat (boxed) = noArray()
// Arg ARG cv::Mat (boxed) weights0= cv::Mat (boxed) = noArray()
// Arg ARG cv::Mat (boxed) logLikelihoods= cv::Mat (boxed) = noArray()
// Arg ARG cv::Mat (boxed) labels= cv::Mat (boxed) = noArray()
// Arg ARG cv::Mat (boxed) probs= cv::Mat (boxed) = noArray()
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_ml_EM_trainE_Mat_samples_Mat_means0_Mat_covs0_Mat_weights0_Mat_logLikelihoods_Mat_labels_Mat_probs(void* instance, void* samples, void* means0, void* covs0, void* weights0, void* logLikelihoods, void* labels, void* probs) {
    try {
        bool ret = reinterpret_cast<cv::ml::EM*>(instance)->trainE(*reinterpret_cast<cv::Mat*>(samples), *reinterpret_cast<cv::Mat*>(means0), *reinterpret_cast<cv::Mat*>(covs0), *reinterpret_cast<cv::Mat*>(weights0), *reinterpret_cast<cv::Mat*>(logLikelihoods), *reinterpret_cast<cv::Mat*>(labels), *reinterpret_cast<cv::Mat*>(probs));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_ml_EM_trainM_Mat_samples_Mat_probs0_Mat_logLikelihoods_Mat_labels_Mat_probs
// parsed: cv::ml::EM::trainM
// as:     cv::ml::EM::trainM (method) cv::ml::EM (trait) . trainM
// Arg ARG cv::Mat (boxed) samples= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) probs0= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) logLikelihoods= cv::Mat (boxed) = noArray()
// Arg ARG cv::Mat (boxed) labels= cv::Mat (boxed) = noArray()
// Arg ARG cv::Mat (boxed) probs= cv::Mat (boxed) = noArray()
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_ml_EM_trainM_Mat_samples_Mat_probs0_Mat_logLikelihoods_Mat_labels_Mat_probs(void* instance, void* samples, void* probs0, void* logLikelihoods, void* labels, void* probs) {
    try {
        bool ret = reinterpret_cast<cv::ml::EM*>(instance)->trainM(*reinterpret_cast<cv::Mat*>(samples), *reinterpret_cast<cv::Mat*>(probs0), *reinterpret_cast<cv::Mat*>(logLikelihoods), *reinterpret_cast<cv::Mat*>(labels), *reinterpret_cast<cv::Mat*>(probs));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_ml_EM_create
// parsed: cv::ml::EM::create
// as:     cv::ml::EM::create (method) cv::ml::EM (trait) . create
// Return value: SmartPtr[cv::ml::EM (boxed)]
cv_return_value_void_X cv_core_cv_ml_EM_create() {
    try {
        Ptr<cv::ml::EM> *ret = new Ptr<cv::ml::EM>(cv::ml::EM::create());
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_ml_EM_load_String_filepath_String_nodeName
// parsed: cv::ml::EM::load
// as:     cv::ml::EM::load (method) cv::ml::EM (trait) . load
// Arg ARG string filepath= string = 
// Arg ARG string nodeName= string = String()
// Return value: SmartPtr[cv::ml::EM (boxed)]
cv_return_value_void_X cv_core_cv_ml_EM_load_String_filepath_String_nodeName(const char* filepath, const char* nodeName) {
    try {
        Ptr<cv::ml::EM> *ret = new Ptr<cv::ml::EM>(cv::ml::EM::load(String(filepath), String(nodeName)));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_ml_KNearest_getDefaultK_const
// parsed: cv::ml::KNearest::getDefaultK
// as:     cv::ml::KNearest::getDefaultK (method) cv::ml::KNearest (trait) . getDefaultK
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_ml_KNearest_getDefaultK_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::ml::KNearest*>(instance)->getDefaultK();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_ml_KNearest_setDefaultK_int_val
// parsed: cv::ml::KNearest::setDefaultK
// as:     cv::ml::KNearest::setDefaultK (method) cv::ml::KNearest (trait) . setDefaultK
// Arg ARG Primitive(int) val= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ml_KNearest_setDefaultK_int_val(void* instance, int val) {
    try {
        reinterpret_cast<cv::ml::KNearest*>(instance)->setDefaultK(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ml_KNearest_getIsClassifier_const
// parsed: cv::ml::KNearest::getIsClassifier
// as:     cv::ml::KNearest::getIsClassifier (method) cv::ml::KNearest (trait) . getIsClassifier
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_ml_KNearest_getIsClassifier_const(void* instance) {
    try {
        bool ret = reinterpret_cast<cv::ml::KNearest*>(instance)->getIsClassifier();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_ml_KNearest_setIsClassifier_bool_val
// parsed: cv::ml::KNearest::setIsClassifier
// as:     cv::ml::KNearest::setIsClassifier (method) cv::ml::KNearest (trait) . setIsClassifier
// Arg ARG Primitive(bool) val= Primitive(bool) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ml_KNearest_setIsClassifier_bool_val(void* instance, bool val) {
    try {
        reinterpret_cast<cv::ml::KNearest*>(instance)->setIsClassifier(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ml_KNearest_getEmax_const
// parsed: cv::ml::KNearest::getEmax
// as:     cv::ml::KNearest::getEmax (method) cv::ml::KNearest (trait) . getEmax
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_ml_KNearest_getEmax_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::ml::KNearest*>(instance)->getEmax();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_ml_KNearest_setEmax_int_val
// parsed: cv::ml::KNearest::setEmax
// as:     cv::ml::KNearest::setEmax (method) cv::ml::KNearest (trait) . setEmax
// Arg ARG Primitive(int) val= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ml_KNearest_setEmax_int_val(void* instance, int val) {
    try {
        reinterpret_cast<cv::ml::KNearest*>(instance)->setEmax(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ml_KNearest_getAlgorithmType_const
// parsed: cv::ml::KNearest::getAlgorithmType
// as:     cv::ml::KNearest::getAlgorithmType (method) cv::ml::KNearest (trait) . getAlgorithmType
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_ml_KNearest_getAlgorithmType_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::ml::KNearest*>(instance)->getAlgorithmType();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_ml_KNearest_setAlgorithmType_int_val
// parsed: cv::ml::KNearest::setAlgorithmType
// as:     cv::ml::KNearest::setAlgorithmType (method) cv::ml::KNearest (trait) . setAlgorithmType
// Arg ARG Primitive(int) val= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ml_KNearest_setAlgorithmType_int_val(void* instance, int val) {
    try {
        reinterpret_cast<cv::ml::KNearest*>(instance)->setAlgorithmType(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ml_KNearest_findNearest_const_Mat_samples_int_k_Mat_results_Mat_neighborResponses_Mat_dist
// parsed: cv::ml::KNearest::findNearest
// as:     cv::ml::KNearest::findNearest (method) cv::ml::KNearest (trait) . findNearest
// Arg ARG cv::Mat (boxed) samples= cv::Mat (boxed) = 
// Arg ARG Primitive(int) k= Primitive(int) = 
// Arg ARG cv::Mat (boxed) results= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) neighborResponses= cv::Mat (boxed) = noArray()
// Arg ARG cv::Mat (boxed) dist= cv::Mat (boxed) = noArray()
// Return value: Primitive(float)
cv_return_value_float cv_core_cv_ml_KNearest_findNearest_const_Mat_samples_int_k_Mat_results_Mat_neighborResponses_Mat_dist(void* instance, void* samples, int k, void* results, void* neighborResponses, void* dist) {
    try {
        float ret = reinterpret_cast<cv::ml::KNearest*>(instance)->findNearest(*reinterpret_cast<cv::Mat*>(samples), k, *reinterpret_cast<cv::Mat*>(results), *reinterpret_cast<cv::Mat*>(neighborResponses), *reinterpret_cast<cv::Mat*>(dist));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<float*>(&ret) };
    } CVRS_CATCH(cv_return_value_float)
}

// cv_ml_KNearest_create
// parsed: cv::ml::KNearest::create
// as:     cv::ml::KNearest::create (method) cv::ml::KNearest (trait) . create
// Return value: SmartPtr[cv::ml::KNearest (boxed)]
cv_return_value_void_X cv_core_cv_ml_KNearest_create() {
    try {
        Ptr<cv::ml::KNearest> *ret = new Ptr<cv::ml::KNearest>(cv::ml::KNearest::create());
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_ml_LogisticRegression_getLearningRate_const
// parsed: cv::ml::LogisticRegression::getLearningRate
// as:     cv::ml::LogisticRegression::getLearningRate (method) cv::ml::LogisticRegression (trait) . getLearningRate
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_ml_LogisticRegression_getLearningRate_const(void* instance) {
    try {
        double ret = reinterpret_cast<cv::ml::LogisticRegression*>(instance)->getLearningRate();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_ml_LogisticRegression_setLearningRate_double_val
// parsed: cv::ml::LogisticRegression::setLearningRate
// as:     cv::ml::LogisticRegression::setLearningRate (method) cv::ml::LogisticRegression (trait) . setLearningRate
// Arg ARG Primitive(double) val= Primitive(double) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ml_LogisticRegression_setLearningRate_double_val(void* instance, double val) {
    try {
        reinterpret_cast<cv::ml::LogisticRegression*>(instance)->setLearningRate(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ml_LogisticRegression_getIterations_const
// parsed: cv::ml::LogisticRegression::getIterations
// as:     cv::ml::LogisticRegression::getIterations (method) cv::ml::LogisticRegression (trait) . getIterations
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_ml_LogisticRegression_getIterations_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::ml::LogisticRegression*>(instance)->getIterations();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_ml_LogisticRegression_setIterations_int_val
// parsed: cv::ml::LogisticRegression::setIterations
// as:     cv::ml::LogisticRegression::setIterations (method) cv::ml::LogisticRegression (trait) . setIterations
// Arg ARG Primitive(int) val= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ml_LogisticRegression_setIterations_int_val(void* instance, int val) {
    try {
        reinterpret_cast<cv::ml::LogisticRegression*>(instance)->setIterations(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ml_LogisticRegression_getRegularization_const
// parsed: cv::ml::LogisticRegression::getRegularization
// as:     cv::ml::LogisticRegression::getRegularization (method) cv::ml::LogisticRegression (trait) . getRegularization
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_ml_LogisticRegression_getRegularization_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::ml::LogisticRegression*>(instance)->getRegularization();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_ml_LogisticRegression_setRegularization_int_val
// parsed: cv::ml::LogisticRegression::setRegularization
// as:     cv::ml::LogisticRegression::setRegularization (method) cv::ml::LogisticRegression (trait) . setRegularization
// Arg ARG Primitive(int) val= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ml_LogisticRegression_setRegularization_int_val(void* instance, int val) {
    try {
        reinterpret_cast<cv::ml::LogisticRegression*>(instance)->setRegularization(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ml_LogisticRegression_getTrainMethod_const
// parsed: cv::ml::LogisticRegression::getTrainMethod
// as:     cv::ml::LogisticRegression::getTrainMethod (method) cv::ml::LogisticRegression (trait) . getTrainMethod
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_ml_LogisticRegression_getTrainMethod_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::ml::LogisticRegression*>(instance)->getTrainMethod();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_ml_LogisticRegression_setTrainMethod_int_val
// parsed: cv::ml::LogisticRegression::setTrainMethod
// as:     cv::ml::LogisticRegression::setTrainMethod (method) cv::ml::LogisticRegression (trait) . setTrainMethod
// Arg ARG Primitive(int) val= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ml_LogisticRegression_setTrainMethod_int_val(void* instance, int val) {
    try {
        reinterpret_cast<cv::ml::LogisticRegression*>(instance)->setTrainMethod(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ml_LogisticRegression_getMiniBatchSize_const
// parsed: cv::ml::LogisticRegression::getMiniBatchSize
// as:     cv::ml::LogisticRegression::getMiniBatchSize (method) cv::ml::LogisticRegression (trait) . getMiniBatchSize
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_ml_LogisticRegression_getMiniBatchSize_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::ml::LogisticRegression*>(instance)->getMiniBatchSize();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_ml_LogisticRegression_setMiniBatchSize_int_val
// parsed: cv::ml::LogisticRegression::setMiniBatchSize
// as:     cv::ml::LogisticRegression::setMiniBatchSize (method) cv::ml::LogisticRegression (trait) . setMiniBatchSize
// Arg ARG Primitive(int) val= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ml_LogisticRegression_setMiniBatchSize_int_val(void* instance, int val) {
    try {
        reinterpret_cast<cv::ml::LogisticRegression*>(instance)->setMiniBatchSize(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ml_LogisticRegression_getTermCriteria_const
// parsed: cv::ml::LogisticRegression::getTermCriteria
// as:     cv::ml::LogisticRegression::getTermCriteria (method) cv::ml::LogisticRegression (trait) . getTermCriteria
// Return value: cv::TermCriteria (boxed)
cv_return_value_void_X cv_core_cv_ml_LogisticRegression_getTermCriteria_const(void* instance) {
    try {
        cv::TermCriteria ret = reinterpret_cast<cv::ml::LogisticRegression*>(instance)->getTermCriteria();
        return { Error::Code::StsOk, NULL, new cv::TermCriteria(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_ml_LogisticRegression_setTermCriteria_TermCriteria_val
// parsed: cv::ml::LogisticRegression::setTermCriteria
// as:     cv::ml::LogisticRegression::setTermCriteria (method) cv::ml::LogisticRegression (trait) . setTermCriteria
// Arg ARG cv::TermCriteria (boxed) val= cv::TermCriteria (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ml_LogisticRegression_setTermCriteria_TermCriteria_val(void* instance, void* val) {
    try {
        reinterpret_cast<cv::ml::LogisticRegression*>(instance)->setTermCriteria(*reinterpret_cast<cv::TermCriteria*>(val));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ml_LogisticRegression_predict_const_Mat_samples_Mat_results_int_flags
// parsed: cv::ml::LogisticRegression::predict
// as:     cv::ml::LogisticRegression::predict (method) cv::ml::LogisticRegression (trait) . predict
// Arg ARG cv::Mat (boxed) samples= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) results= cv::Mat (boxed) = noArray()
// Arg ARG Primitive(int) flags= Primitive(int) = 0
// Return value: Primitive(float)
cv_return_value_float cv_core_cv_ml_LogisticRegression_predict_const_Mat_samples_Mat_results_int_flags(void* instance, void* samples, void* results, int flags) {
    try {
        float ret = reinterpret_cast<cv::ml::LogisticRegression*>(instance)->predict(*reinterpret_cast<cv::Mat*>(samples), *reinterpret_cast<cv::Mat*>(results), flags);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<float*>(&ret) };
    } CVRS_CATCH(cv_return_value_float)
}

// cv_ml_LogisticRegression_get_learnt_thetas_const
// parsed: cv::ml::LogisticRegression::get_learnt_thetas
// as:     cv::ml::LogisticRegression::get_learnt_thetas (method) cv::ml::LogisticRegression (trait) . get_learnt_thetas
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_ml_LogisticRegression_get_learnt_thetas_const(void* instance) {
    try {
        cv::Mat ret = reinterpret_cast<cv::ml::LogisticRegression*>(instance)->get_learnt_thetas();
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_ml_LogisticRegression_create
// parsed: cv::ml::LogisticRegression::create
// as:     cv::ml::LogisticRegression::create (method) cv::ml::LogisticRegression (trait) . create
// Return value: SmartPtr[cv::ml::LogisticRegression (boxed)]
cv_return_value_void_X cv_core_cv_ml_LogisticRegression_create() {
    try {
        Ptr<cv::ml::LogisticRegression> *ret = new Ptr<cv::ml::LogisticRegression>(cv::ml::LogisticRegression::create());
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_ml_LogisticRegression_load_String_filepath_String_nodeName
// parsed: cv::ml::LogisticRegression::load
// as:     cv::ml::LogisticRegression::load (method) cv::ml::LogisticRegression (trait) . load
// Arg ARG string filepath= string = 
// Arg ARG string nodeName= string = String()
// Return value: SmartPtr[cv::ml::LogisticRegression (boxed)]
cv_return_value_void_X cv_core_cv_ml_LogisticRegression_load_String_filepath_String_nodeName(const char* filepath, const char* nodeName) {
    try {
        Ptr<cv::ml::LogisticRegression> *ret = new Ptr<cv::ml::LogisticRegression>(cv::ml::LogisticRegression::load(String(filepath), String(nodeName)));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_ml_NormalBayesClassifier_predictProb_const_Mat_inputs_Mat_outputs_Mat_outputProbs_int_flags
// parsed: cv::ml::NormalBayesClassifier::predictProb
// as:     cv::ml::NormalBayesClassifier::predictProb (method) cv::ml::NormalBayesClassifier (trait) . predictProb
// Arg ARG cv::Mat (boxed) inputs= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) outputs= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) outputProbs= cv::Mat (boxed) = 
// Arg ARG Primitive(int) flags= Primitive(int) = 0
// Return value: Primitive(float)
cv_return_value_float cv_core_cv_ml_NormalBayesClassifier_predictProb_const_Mat_inputs_Mat_outputs_Mat_outputProbs_int_flags(void* instance, void* inputs, void* outputs, void* outputProbs, int flags) {
    try {
        float ret = reinterpret_cast<cv::ml::NormalBayesClassifier*>(instance)->predictProb(*reinterpret_cast<cv::Mat*>(inputs), *reinterpret_cast<cv::Mat*>(outputs), *reinterpret_cast<cv::Mat*>(outputProbs), flags);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<float*>(&ret) };
    } CVRS_CATCH(cv_return_value_float)
}

// cv_ml_NormalBayesClassifier_create
// parsed: cv::ml::NormalBayesClassifier::create
// as:     cv::ml::NormalBayesClassifier::create (method) cv::ml::NormalBayesClassifier (trait) . create
// Return value: SmartPtr[cv::ml::NormalBayesClassifier (boxed)]
cv_return_value_void_X cv_core_cv_ml_NormalBayesClassifier_create() {
    try {
        Ptr<cv::ml::NormalBayesClassifier> *ret = new Ptr<cv::ml::NormalBayesClassifier>(cv::ml::NormalBayesClassifier::create());
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_ml_NormalBayesClassifier_load_String_filepath_String_nodeName
// parsed: cv::ml::NormalBayesClassifier::load
// as:     cv::ml::NormalBayesClassifier::load (method) cv::ml::NormalBayesClassifier (trait) . load
// Arg ARG string filepath= string = 
// Arg ARG string nodeName= string = String()
// Return value: SmartPtr[cv::ml::NormalBayesClassifier (boxed)]
cv_return_value_void_X cv_core_cv_ml_NormalBayesClassifier_load_String_filepath_String_nodeName(const char* filepath, const char* nodeName) {
    try {
        Ptr<cv::ml::NormalBayesClassifier> *ret = new Ptr<cv::ml::NormalBayesClassifier>(cv::ml::NormalBayesClassifier::load(String(filepath), String(nodeName)));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// boxed class: cv::ml::ParamGrid
void cv_delete_ParamGrid(void* instance) {
    delete (cv::ml::ParamGrid*) instance;
}
// cv_ml_ParamGrid_ParamGrid
// parsed: cv::ml::ParamGrid::ParamGrid
// as:     cv::ml::ParamGrid::ParamGrid (constructor) cv::ml::ParamGrid . new
// Return value: cv::ml::ParamGrid (boxed)
cv_return_value_void_X cv_core_cv_ml_ParamGrid_ParamGrid() {
    try {
        cv::ml::ParamGrid* ret = new cv::ml::ParamGrid();
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_ml_ParamGrid_ParamGrid_double__minVal_double__maxVal_double__logStep
// parsed: cv::ml::ParamGrid::ParamGrid
// as:     cv::ml::ParamGrid::ParamGrid (constructor) cv::ml::ParamGrid . new
// Arg ARG Primitive(double) _minVal= Primitive(double) = 
// Arg ARG Primitive(double) _maxVal= Primitive(double) = 
// Arg ARG Primitive(double) _logStep= Primitive(double) = 
// Return value: cv::ml::ParamGrid (boxed)
cv_return_value_void_X cv_core_cv_ml_ParamGrid_ParamGrid_double__minVal_double__maxVal_double__logStep(double _minVal, double _maxVal, double _logStep) {
    try {
        cv::ml::ParamGrid* ret = new cv::ml::ParamGrid(_minVal, _maxVal, _logStep);
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_ml_ParamGrid_create_double_minVal_double_maxVal_double_logstep
// parsed: cv::ml::ParamGrid::create
// as:     cv::ml::ParamGrid::create (method) cv::ml::ParamGrid . create
// Arg ARG Primitive(double) minVal= Primitive(double) = 0.
// Arg ARG Primitive(double) maxVal= Primitive(double) = 0.
// Arg ARG Primitive(double) logstep= Primitive(double) = 1.
// Return value: SmartPtr[cv::ml::ParamGrid (boxed)]
cv_return_value_void_X cv_core_cv_ml_ParamGrid_create_double_minVal_double_maxVal_double_logstep(double minVal, double maxVal, double logstep) {
    try {
        Ptr<cv::ml::ParamGrid> *ret = new Ptr<cv::ml::ParamGrid>(cv::ml::ParamGrid::create(minVal, maxVal, logstep));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_ml_RTrees_getCalculateVarImportance_const
// parsed: cv::ml::RTrees::getCalculateVarImportance
// as:     cv::ml::RTrees::getCalculateVarImportance (method) cv::ml::RTrees (trait) . getCalculateVarImportance
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_ml_RTrees_getCalculateVarImportance_const(void* instance) {
    try {
        bool ret = reinterpret_cast<cv::ml::RTrees*>(instance)->getCalculateVarImportance();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_ml_RTrees_setCalculateVarImportance_bool_val
// parsed: cv::ml::RTrees::setCalculateVarImportance
// as:     cv::ml::RTrees::setCalculateVarImportance (method) cv::ml::RTrees (trait) . setCalculateVarImportance
// Arg ARG Primitive(bool) val= Primitive(bool) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ml_RTrees_setCalculateVarImportance_bool_val(void* instance, bool val) {
    try {
        reinterpret_cast<cv::ml::RTrees*>(instance)->setCalculateVarImportance(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ml_RTrees_getActiveVarCount_const
// parsed: cv::ml::RTrees::getActiveVarCount
// as:     cv::ml::RTrees::getActiveVarCount (method) cv::ml::RTrees (trait) . getActiveVarCount
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_ml_RTrees_getActiveVarCount_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::ml::RTrees*>(instance)->getActiveVarCount();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_ml_RTrees_setActiveVarCount_int_val
// parsed: cv::ml::RTrees::setActiveVarCount
// as:     cv::ml::RTrees::setActiveVarCount (method) cv::ml::RTrees (trait) . setActiveVarCount
// Arg ARG Primitive(int) val= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ml_RTrees_setActiveVarCount_int_val(void* instance, int val) {
    try {
        reinterpret_cast<cv::ml::RTrees*>(instance)->setActiveVarCount(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ml_RTrees_getTermCriteria_const
// parsed: cv::ml::RTrees::getTermCriteria
// as:     cv::ml::RTrees::getTermCriteria (method) cv::ml::RTrees (trait) . getTermCriteria
// Return value: cv::TermCriteria (boxed)
cv_return_value_void_X cv_core_cv_ml_RTrees_getTermCriteria_const(void* instance) {
    try {
        cv::TermCriteria ret = reinterpret_cast<cv::ml::RTrees*>(instance)->getTermCriteria();
        return { Error::Code::StsOk, NULL, new cv::TermCriteria(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_ml_RTrees_setTermCriteria_TermCriteria_val
// parsed: cv::ml::RTrees::setTermCriteria
// as:     cv::ml::RTrees::setTermCriteria (method) cv::ml::RTrees (trait) . setTermCriteria
// Arg ARG cv::TermCriteria (boxed) val= cv::TermCriteria (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ml_RTrees_setTermCriteria_TermCriteria_val(void* instance, void* val) {
    try {
        reinterpret_cast<cv::ml::RTrees*>(instance)->setTermCriteria(*reinterpret_cast<cv::TermCriteria*>(val));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ml_RTrees_getVarImportance_const
// parsed: cv::ml::RTrees::getVarImportance
// as:     cv::ml::RTrees::getVarImportance (method) cv::ml::RTrees (trait) . getVarImportance
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_ml_RTrees_getVarImportance_const(void* instance) {
    try {
        cv::Mat ret = reinterpret_cast<cv::ml::RTrees*>(instance)->getVarImportance();
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_ml_RTrees_getVotes_const_Mat_samples_Mat_results_int_flags
// parsed: cv::ml::RTrees::getVotes
// as:     cv::ml::RTrees::getVotes (method) cv::ml::RTrees (trait) . getVotes
// Arg ARG cv::Mat (boxed) samples= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) results= cv::Mat (boxed) = 
// Arg ARG Primitive(int) flags= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ml_RTrees_getVotes_const_Mat_samples_Mat_results_int_flags(void* instance, void* samples, void* results, int flags) {
    try {
        reinterpret_cast<cv::ml::RTrees*>(instance)->getVotes(*reinterpret_cast<cv::Mat*>(samples), *reinterpret_cast<cv::Mat*>(results), flags);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ml_RTrees_create
// parsed: cv::ml::RTrees::create
// as:     cv::ml::RTrees::create (method) cv::ml::RTrees (trait) . create
// Return value: SmartPtr[cv::ml::RTrees (boxed)]
cv_return_value_void_X cv_core_cv_ml_RTrees_create() {
    try {
        Ptr<cv::ml::RTrees> *ret = new Ptr<cv::ml::RTrees>(cv::ml::RTrees::create());
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_ml_RTrees_load_String_filepath_String_nodeName
// parsed: cv::ml::RTrees::load
// as:     cv::ml::RTrees::load (method) cv::ml::RTrees (trait) . load
// Arg ARG string filepath= string = 
// Arg ARG string nodeName= string = String()
// Return value: SmartPtr[cv::ml::RTrees (boxed)]
cv_return_value_void_X cv_core_cv_ml_RTrees_load_String_filepath_String_nodeName(const char* filepath, const char* nodeName) {
    try {
        Ptr<cv::ml::RTrees> *ret = new Ptr<cv::ml::RTrees>(cv::ml::RTrees::load(String(filepath), String(nodeName)));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_ml_SVM_getType_const
// parsed: cv::ml::SVM::getType
// as:     cv::ml::SVM::getType (method) cv::ml::SVM (trait) . getType
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_ml_SVM_getType_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::ml::SVM*>(instance)->getType();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_ml_SVM_setType_int_val
// parsed: cv::ml::SVM::setType
// as:     cv::ml::SVM::setType (method) cv::ml::SVM (trait) . setType
// Arg ARG Primitive(int) val= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ml_SVM_setType_int_val(void* instance, int val) {
    try {
        reinterpret_cast<cv::ml::SVM*>(instance)->setType(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ml_SVM_getGamma_const
// parsed: cv::ml::SVM::getGamma
// as:     cv::ml::SVM::getGamma (method) cv::ml::SVM (trait) . getGamma
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_ml_SVM_getGamma_const(void* instance) {
    try {
        double ret = reinterpret_cast<cv::ml::SVM*>(instance)->getGamma();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_ml_SVM_setGamma_double_val
// parsed: cv::ml::SVM::setGamma
// as:     cv::ml::SVM::setGamma (method) cv::ml::SVM (trait) . setGamma
// Arg ARG Primitive(double) val= Primitive(double) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ml_SVM_setGamma_double_val(void* instance, double val) {
    try {
        reinterpret_cast<cv::ml::SVM*>(instance)->setGamma(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ml_SVM_getCoef0_const
// parsed: cv::ml::SVM::getCoef0
// as:     cv::ml::SVM::getCoef0 (method) cv::ml::SVM (trait) . getCoef0
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_ml_SVM_getCoef0_const(void* instance) {
    try {
        double ret = reinterpret_cast<cv::ml::SVM*>(instance)->getCoef0();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_ml_SVM_setCoef0_double_val
// parsed: cv::ml::SVM::setCoef0
// as:     cv::ml::SVM::setCoef0 (method) cv::ml::SVM (trait) . setCoef0
// Arg ARG Primitive(double) val= Primitive(double) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ml_SVM_setCoef0_double_val(void* instance, double val) {
    try {
        reinterpret_cast<cv::ml::SVM*>(instance)->setCoef0(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ml_SVM_getDegree_const
// parsed: cv::ml::SVM::getDegree
// as:     cv::ml::SVM::getDegree (method) cv::ml::SVM (trait) . getDegree
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_ml_SVM_getDegree_const(void* instance) {
    try {
        double ret = reinterpret_cast<cv::ml::SVM*>(instance)->getDegree();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_ml_SVM_setDegree_double_val
// parsed: cv::ml::SVM::setDegree
// as:     cv::ml::SVM::setDegree (method) cv::ml::SVM (trait) . setDegree
// Arg ARG Primitive(double) val= Primitive(double) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ml_SVM_setDegree_double_val(void* instance, double val) {
    try {
        reinterpret_cast<cv::ml::SVM*>(instance)->setDegree(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ml_SVM_getC_const
// parsed: cv::ml::SVM::getC
// as:     cv::ml::SVM::getC (method) cv::ml::SVM (trait) . getC
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_ml_SVM_getC_const(void* instance) {
    try {
        double ret = reinterpret_cast<cv::ml::SVM*>(instance)->getC();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_ml_SVM_setC_double_val
// parsed: cv::ml::SVM::setC
// as:     cv::ml::SVM::setC (method) cv::ml::SVM (trait) . setC
// Arg ARG Primitive(double) val= Primitive(double) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ml_SVM_setC_double_val(void* instance, double val) {
    try {
        reinterpret_cast<cv::ml::SVM*>(instance)->setC(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ml_SVM_getNu_const
// parsed: cv::ml::SVM::getNu
// as:     cv::ml::SVM::getNu (method) cv::ml::SVM (trait) . getNu
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_ml_SVM_getNu_const(void* instance) {
    try {
        double ret = reinterpret_cast<cv::ml::SVM*>(instance)->getNu();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_ml_SVM_setNu_double_val
// parsed: cv::ml::SVM::setNu
// as:     cv::ml::SVM::setNu (method) cv::ml::SVM (trait) . setNu
// Arg ARG Primitive(double) val= Primitive(double) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ml_SVM_setNu_double_val(void* instance, double val) {
    try {
        reinterpret_cast<cv::ml::SVM*>(instance)->setNu(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ml_SVM_getP_const
// parsed: cv::ml::SVM::getP
// as:     cv::ml::SVM::getP (method) cv::ml::SVM (trait) . getP
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_ml_SVM_getP_const(void* instance) {
    try {
        double ret = reinterpret_cast<cv::ml::SVM*>(instance)->getP();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_ml_SVM_setP_double_val
// parsed: cv::ml::SVM::setP
// as:     cv::ml::SVM::setP (method) cv::ml::SVM (trait) . setP
// Arg ARG Primitive(double) val= Primitive(double) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ml_SVM_setP_double_val(void* instance, double val) {
    try {
        reinterpret_cast<cv::ml::SVM*>(instance)->setP(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ml_SVM_getClassWeights_const
// parsed: cv::ml::SVM::getClassWeights
// as:     cv::ml::SVM::getClassWeights (method) cv::ml::SVM (trait) . getClassWeights
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_ml_SVM_getClassWeights_const(void* instance) {
    try {
        cv::Mat ret = reinterpret_cast<cv::ml::SVM*>(instance)->getClassWeights();
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_ml_SVM_setClassWeights_Mat_val
// parsed: cv::ml::SVM::setClassWeights
// as:     cv::ml::SVM::setClassWeights (method) cv::ml::SVM (trait) . setClassWeights
// Arg ARG cv::Mat (boxed) val= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ml_SVM_setClassWeights_Mat_val(void* instance, void* val) {
    try {
        reinterpret_cast<cv::ml::SVM*>(instance)->setClassWeights(*reinterpret_cast<cv::Mat*>(val));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ml_SVM_getTermCriteria_const
// parsed: cv::ml::SVM::getTermCriteria
// as:     cv::ml::SVM::getTermCriteria (method) cv::ml::SVM (trait) . getTermCriteria
// Return value: cv::TermCriteria (boxed)
cv_return_value_void_X cv_core_cv_ml_SVM_getTermCriteria_const(void* instance) {
    try {
        cv::TermCriteria ret = reinterpret_cast<cv::ml::SVM*>(instance)->getTermCriteria();
        return { Error::Code::StsOk, NULL, new cv::TermCriteria(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_ml_SVM_setTermCriteria_TermCriteria_val
// parsed: cv::ml::SVM::setTermCriteria
// as:     cv::ml::SVM::setTermCriteria (method) cv::ml::SVM (trait) . setTermCriteria
// Arg ARG cv::TermCriteria (boxed) val= cv::TermCriteria (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ml_SVM_setTermCriteria_TermCriteria_val(void* instance, void* val) {
    try {
        reinterpret_cast<cv::ml::SVM*>(instance)->setTermCriteria(*reinterpret_cast<cv::TermCriteria*>(val));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ml_SVM_getKernelType_const
// parsed: cv::ml::SVM::getKernelType
// as:     cv::ml::SVM::getKernelType (method) cv::ml::SVM (trait) . getKernelType
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_ml_SVM_getKernelType_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::ml::SVM*>(instance)->getKernelType();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_ml_SVM_setKernel_int_kernelType
// parsed: cv::ml::SVM::setKernel
// as:     cv::ml::SVM::setKernel (method) cv::ml::SVM (trait) . setKernel
// Arg ARG Primitive(int) kernelType= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ml_SVM_setKernel_int_kernelType(void* instance, int kernelType) {
    try {
        reinterpret_cast<cv::ml::SVM*>(instance)->setKernel(kernelType);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ml_SVM_setCustomKernel_PtrOfKernel__kernel
// parsed: cv::ml::SVM::setCustomKernel
// as:     cv::ml::SVM::setCustomKernel (method) cv::ml::SVM (trait) . setCustomKernel
// Arg ARG SmartPtr[cv::ml::SVM::Kernel (boxed)] _kernel= SmartPtr[cv::ml::SVM::Kernel (boxed)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ml_SVM_setCustomKernel_PtrOfKernel__kernel(void* instance, void* _kernel) {
    try {
        reinterpret_cast<cv::ml::SVM*>(instance)->setCustomKernel(reinterpret_cast<cv::ml::SVM::Kernel*>(_kernel));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ml_SVM_trainAuto_PtrOfTrainData_data_int_kFold_ParamGrid_Cgrid_ParamGrid_gammaGrid_ParamGrid_pGrid_ParamGrid_nuGrid_ParamGrid_coeffGrid_ParamGrid_degreeGrid_bool_balanced
// parsed: cv::ml::SVM::trainAuto
// as:     cv::ml::SVM::trainAuto (method) cv::ml::SVM (trait) . trainAuto
// Arg ARG SmartPtr[cv::ml::TrainData (boxed)] data= SmartPtr[cv::ml::TrainData (boxed)] = 
// Arg ARG Primitive(int) kFold= Primitive(int) = 10
// Arg ARG cv::ml::ParamGrid (boxed) Cgrid= cv::ml::ParamGrid (boxed) = getDefaultGrid(C)
// Arg ARG cv::ml::ParamGrid (boxed) gammaGrid= cv::ml::ParamGrid (boxed) = getDefaultGrid(GAMMA)
// Arg ARG cv::ml::ParamGrid (boxed) pGrid= cv::ml::ParamGrid (boxed) = getDefaultGrid(P)
// Arg ARG cv::ml::ParamGrid (boxed) nuGrid= cv::ml::ParamGrid (boxed) = getDefaultGrid(NU)
// Arg ARG cv::ml::ParamGrid (boxed) coeffGrid= cv::ml::ParamGrid (boxed) = getDefaultGrid(COEF)
// Arg ARG cv::ml::ParamGrid (boxed) degreeGrid= cv::ml::ParamGrid (boxed) = getDefaultGrid(DEGREE)
// Arg ARG Primitive(bool) balanced= Primitive(bool) = false
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_ml_SVM_trainAuto_PtrOfTrainData_data_int_kFold_ParamGrid_Cgrid_ParamGrid_gammaGrid_ParamGrid_pGrid_ParamGrid_nuGrid_ParamGrid_coeffGrid_ParamGrid_degreeGrid_bool_balanced(void* instance, void* data, int kFold, void* Cgrid, void* gammaGrid, void* pGrid, void* nuGrid, void* coeffGrid, void* degreeGrid, bool balanced) {
    try {
        bool ret = reinterpret_cast<cv::ml::SVM*>(instance)->trainAuto(reinterpret_cast<cv::ml::TrainData*>(data), kFold, *reinterpret_cast<cv::ml::ParamGrid*>(Cgrid), *reinterpret_cast<cv::ml::ParamGrid*>(gammaGrid), *reinterpret_cast<cv::ml::ParamGrid*>(pGrid), *reinterpret_cast<cv::ml::ParamGrid*>(nuGrid), *reinterpret_cast<cv::ml::ParamGrid*>(coeffGrid), *reinterpret_cast<cv::ml::ParamGrid*>(degreeGrid), balanced);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_ml_SVM_trainAuto_Mat_samples_int_layout_Mat_responses_int_kFold_PtrOfParamGrid_Cgrid_PtrOfParamGrid_gammaGrid_PtrOfParamGrid_pGrid_PtrOfParamGrid_nuGrid_PtrOfParamGrid_coeffGrid_PtrOfParamGrid_degreeGrid_bool_balanced
// parsed: cv::ml::SVM::trainAuto
// as:     cv::ml::SVM::trainAuto (method) cv::ml::SVM (trait) . trainAuto
// Arg ARG cv::Mat (boxed) samples= cv::Mat (boxed) = 
// Arg ARG Primitive(int) layout= Primitive(int) = 
// Arg ARG cv::Mat (boxed) responses= cv::Mat (boxed) = 
// Arg ARG Primitive(int) kFold= Primitive(int) = 10
// Arg ARG SmartPtr[cv::ml::ParamGrid (boxed)] Cgrid= SmartPtr[cv::ml::ParamGrid (boxed)] = SVM::getDefaultGridPtr(SVM::C)
// Arg ARG SmartPtr[cv::ml::ParamGrid (boxed)] gammaGrid= SmartPtr[cv::ml::ParamGrid (boxed)] = SVM::getDefaultGridPtr(SVM::GAMMA)
// Arg ARG SmartPtr[cv::ml::ParamGrid (boxed)] pGrid= SmartPtr[cv::ml::ParamGrid (boxed)] = SVM::getDefaultGridPtr(SVM::P)
// Arg ARG SmartPtr[cv::ml::ParamGrid (boxed)] nuGrid= SmartPtr[cv::ml::ParamGrid (boxed)] = SVM::getDefaultGridPtr(SVM::NU)
// Arg ARG SmartPtr[cv::ml::ParamGrid (boxed)] coeffGrid= SmartPtr[cv::ml::ParamGrid (boxed)] = SVM::getDefaultGridPtr(SVM::COEF)
// Arg ARG SmartPtr[cv::ml::ParamGrid (boxed)] degreeGrid= SmartPtr[cv::ml::ParamGrid (boxed)] = SVM::getDefaultGridPtr(SVM::DEGREE)
// Arg ARG Primitive(bool) balanced= Primitive(bool) = false
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_ml_SVM_trainAuto_Mat_samples_int_layout_Mat_responses_int_kFold_PtrOfParamGrid_Cgrid_PtrOfParamGrid_gammaGrid_PtrOfParamGrid_pGrid_PtrOfParamGrid_nuGrid_PtrOfParamGrid_coeffGrid_PtrOfParamGrid_degreeGrid_bool_balanced(void* instance, void* samples, int layout, void* responses, int kFold, void* Cgrid, void* gammaGrid, void* pGrid, void* nuGrid, void* coeffGrid, void* degreeGrid, bool balanced) {
    try {
        bool ret = reinterpret_cast<cv::ml::SVM*>(instance)->trainAuto(*reinterpret_cast<cv::Mat*>(samples), layout, *reinterpret_cast<cv::Mat*>(responses), kFold, reinterpret_cast<cv::ml::ParamGrid*>(Cgrid), reinterpret_cast<cv::ml::ParamGrid*>(gammaGrid), reinterpret_cast<cv::ml::ParamGrid*>(pGrid), reinterpret_cast<cv::ml::ParamGrid*>(nuGrid), reinterpret_cast<cv::ml::ParamGrid*>(coeffGrid), reinterpret_cast<cv::ml::ParamGrid*>(degreeGrid), balanced);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_ml_SVM_getSupportVectors_const
// parsed: cv::ml::SVM::getSupportVectors
// as:     cv::ml::SVM::getSupportVectors (method) cv::ml::SVM (trait) . getSupportVectors
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_ml_SVM_getSupportVectors_const(void* instance) {
    try {
        cv::Mat ret = reinterpret_cast<cv::ml::SVM*>(instance)->getSupportVectors();
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_ml_SVM_getUncompressedSupportVectors_const
// parsed: cv::ml::SVM::getUncompressedSupportVectors
// as:     cv::ml::SVM::getUncompressedSupportVectors (method) cv::ml::SVM (trait) . getUncompressedSupportVectors
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_ml_SVM_getUncompressedSupportVectors_const(void* instance) {
    try {
        cv::Mat ret = reinterpret_cast<cv::ml::SVM*>(instance)->getUncompressedSupportVectors();
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_ml_SVM_getDecisionFunction_const_int_i_Mat_alpha_Mat_svidx
// parsed: cv::ml::SVM::getDecisionFunction
// as:     cv::ml::SVM::getDecisionFunction (method) cv::ml::SVM (trait) . getDecisionFunction
// Arg ARG Primitive(int) i= Primitive(int) = 
// Arg ARG cv::Mat (boxed) alpha= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) svidx= cv::Mat (boxed) = 
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_ml_SVM_getDecisionFunction_const_int_i_Mat_alpha_Mat_svidx(void* instance, int i, void* alpha, void* svidx) {
    try {
        double ret = reinterpret_cast<cv::ml::SVM*>(instance)->getDecisionFunction(i, *reinterpret_cast<cv::Mat*>(alpha), *reinterpret_cast<cv::Mat*>(svidx));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_ml_SVM_getDefaultGrid_int_param_id
// parsed: cv::ml::SVM::getDefaultGrid
// as:     cv::ml::SVM::getDefaultGrid (method) cv::ml::SVM (trait) . getDefaultGrid
// Arg ARG Primitive(int) param_id= Primitive(int) = 
// Return value: cv::ml::ParamGrid (boxed)
cv_return_value_void_X cv_core_cv_ml_SVM_getDefaultGrid_int_param_id(int param_id) {
    try {
        cv::ml::ParamGrid ret = cv::ml::SVM::getDefaultGrid(param_id);
        return { Error::Code::StsOk, NULL, new cv::ml::ParamGrid(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_ml_SVM_getDefaultGridPtr_int_param_id
// parsed: cv::ml::SVM::getDefaultGridPtr
// as:     cv::ml::SVM::getDefaultGridPtr (method) cv::ml::SVM (trait) . getDefaultGridPtr
// Arg ARG Primitive(int) param_id= Primitive(int) = 
// Return value: SmartPtr[cv::ml::ParamGrid (boxed)]
cv_return_value_void_X cv_core_cv_ml_SVM_getDefaultGridPtr_int_param_id(int param_id) {
    try {
        Ptr<cv::ml::ParamGrid> *ret = new Ptr<cv::ml::ParamGrid>(cv::ml::SVM::getDefaultGridPtr(param_id));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_ml_SVM_create
// parsed: cv::ml::SVM::create
// as:     cv::ml::SVM::create (method) cv::ml::SVM (trait) . create
// Return value: SmartPtr[cv::ml::SVM (boxed)]
cv_return_value_void_X cv_core_cv_ml_SVM_create() {
    try {
        Ptr<cv::ml::SVM> *ret = new Ptr<cv::ml::SVM>(cv::ml::SVM::create());
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_ml_SVM_load_String_filepath
// parsed: cv::ml::SVM::load
// as:     cv::ml::SVM::load (method) cv::ml::SVM (trait) . load
// Arg ARG string filepath= string = 
// Return value: SmartPtr[cv::ml::SVM (boxed)]
cv_return_value_void_X cv_core_cv_ml_SVM_load_String_filepath(const char* filepath) {
    try {
        Ptr<cv::ml::SVM> *ret = new Ptr<cv::ml::SVM>(cv::ml::SVM::load(String(filepath)));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_ml_SVM_Kernel_getType_const
// parsed: cv::ml::SVM::Kernel::getType
// as:     cv::ml::SVM::Kernel::getType (method) cv::ml::SVM::Kernel (trait) . getType
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_ml_SVM_Kernel_getType_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::ml::SVM::Kernel*>(instance)->getType();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_ml_SVM_Kernel_calc_int_vcount_int_n_const_float_X_vecs_const_float_X_another_float_X_results
// parsed: cv::ml::SVM::Kernel::calc
// as:     cv::ml::SVM::Kernel::calc (method) cv::ml::SVM::Kernel (trait) . calc
// Arg ARG Primitive(int) vcount= Primitive(int) = 
// Arg ARG Primitive(int) n= Primitive(int) = 
// Arg ARG RawPtr[Primitive(float)] * vecs= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG RawPtr[Primitive(float)] * another= (ptr) RawPtr[Primitive(float)] = 
// Arg ARG RawPtr[Primitive(float)] * results= (ptr) RawPtr[Primitive(float)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ml_SVM_Kernel_calc_int_vcount_int_n_const_float_X_vecs_const_float_X_another_float_X_results(void* instance, int vcount, int n, const float* vecs, const float* another, float* results) {
    try {
        reinterpret_cast<cv::ml::SVM::Kernel*>(instance)->calc(vcount, n, vecs, another, results);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ml_SVMSGD_getWeights
// parsed: cv::ml::SVMSGD::getWeights
// as:     cv::ml::SVMSGD::getWeights (method) cv::ml::SVMSGD (trait) . getWeights
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_ml_SVMSGD_getWeights(void* instance) {
    try {
        cv::Mat ret = reinterpret_cast<cv::ml::SVMSGD*>(instance)->getWeights();
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_ml_SVMSGD_getShift
// parsed: cv::ml::SVMSGD::getShift
// as:     cv::ml::SVMSGD::getShift (method) cv::ml::SVMSGD (trait) . getShift
// Return value: Primitive(float)
cv_return_value_float cv_core_cv_ml_SVMSGD_getShift(void* instance) {
    try {
        float ret = reinterpret_cast<cv::ml::SVMSGD*>(instance)->getShift();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<float*>(&ret) };
    } CVRS_CATCH(cv_return_value_float)
}

// cv_ml_SVMSGD_setOptimalParameters_int_svmsgdType_int_marginType
// parsed: cv::ml::SVMSGD::setOptimalParameters
// as:     cv::ml::SVMSGD::setOptimalParameters (method) cv::ml::SVMSGD (trait) . setOptimalParameters
// Arg ARG Primitive(int) svmsgdType= Primitive(int) = SVMSGD::ASGD
// Arg ARG Primitive(int) marginType= Primitive(int) = SVMSGD::SOFT_MARGIN
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ml_SVMSGD_setOptimalParameters_int_svmsgdType_int_marginType(void* instance, int svmsgdType, int marginType) {
    try {
        reinterpret_cast<cv::ml::SVMSGD*>(instance)->setOptimalParameters(svmsgdType, marginType);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ml_SVMSGD_getSvmsgdType_const
// parsed: cv::ml::SVMSGD::getSvmsgdType
// as:     cv::ml::SVMSGD::getSvmsgdType (method) cv::ml::SVMSGD (trait) . getSvmsgdType
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_ml_SVMSGD_getSvmsgdType_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::ml::SVMSGD*>(instance)->getSvmsgdType();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_ml_SVMSGD_setSvmsgdType_int_svmsgdType
// parsed: cv::ml::SVMSGD::setSvmsgdType
// as:     cv::ml::SVMSGD::setSvmsgdType (method) cv::ml::SVMSGD (trait) . setSvmsgdType
// Arg ARG Primitive(int) svmsgdType= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ml_SVMSGD_setSvmsgdType_int_svmsgdType(void* instance, int svmsgdType) {
    try {
        reinterpret_cast<cv::ml::SVMSGD*>(instance)->setSvmsgdType(svmsgdType);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ml_SVMSGD_getMarginType_const
// parsed: cv::ml::SVMSGD::getMarginType
// as:     cv::ml::SVMSGD::getMarginType (method) cv::ml::SVMSGD (trait) . getMarginType
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_ml_SVMSGD_getMarginType_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::ml::SVMSGD*>(instance)->getMarginType();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_ml_SVMSGD_setMarginType_int_marginType
// parsed: cv::ml::SVMSGD::setMarginType
// as:     cv::ml::SVMSGD::setMarginType (method) cv::ml::SVMSGD (trait) . setMarginType
// Arg ARG Primitive(int) marginType= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ml_SVMSGD_setMarginType_int_marginType(void* instance, int marginType) {
    try {
        reinterpret_cast<cv::ml::SVMSGD*>(instance)->setMarginType(marginType);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ml_SVMSGD_getMarginRegularization_const
// parsed: cv::ml::SVMSGD::getMarginRegularization
// as:     cv::ml::SVMSGD::getMarginRegularization (method) cv::ml::SVMSGD (trait) . getMarginRegularization
// Return value: Primitive(float)
cv_return_value_float cv_core_cv_ml_SVMSGD_getMarginRegularization_const(void* instance) {
    try {
        float ret = reinterpret_cast<cv::ml::SVMSGD*>(instance)->getMarginRegularization();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<float*>(&ret) };
    } CVRS_CATCH(cv_return_value_float)
}

// cv_ml_SVMSGD_setMarginRegularization_float_marginRegularization
// parsed: cv::ml::SVMSGD::setMarginRegularization
// as:     cv::ml::SVMSGD::setMarginRegularization (method) cv::ml::SVMSGD (trait) . setMarginRegularization
// Arg ARG Primitive(float) marginRegularization= Primitive(float) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ml_SVMSGD_setMarginRegularization_float_marginRegularization(void* instance, float marginRegularization) {
    try {
        reinterpret_cast<cv::ml::SVMSGD*>(instance)->setMarginRegularization(marginRegularization);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ml_SVMSGD_getInitialStepSize_const
// parsed: cv::ml::SVMSGD::getInitialStepSize
// as:     cv::ml::SVMSGD::getInitialStepSize (method) cv::ml::SVMSGD (trait) . getInitialStepSize
// Return value: Primitive(float)
cv_return_value_float cv_core_cv_ml_SVMSGD_getInitialStepSize_const(void* instance) {
    try {
        float ret = reinterpret_cast<cv::ml::SVMSGD*>(instance)->getInitialStepSize();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<float*>(&ret) };
    } CVRS_CATCH(cv_return_value_float)
}

// cv_ml_SVMSGD_setInitialStepSize_float_InitialStepSize
// parsed: cv::ml::SVMSGD::setInitialStepSize
// as:     cv::ml::SVMSGD::setInitialStepSize (method) cv::ml::SVMSGD (trait) . setInitialStepSize
// Arg ARG Primitive(float) InitialStepSize= Primitive(float) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ml_SVMSGD_setInitialStepSize_float_InitialStepSize(void* instance, float InitialStepSize) {
    try {
        reinterpret_cast<cv::ml::SVMSGD*>(instance)->setInitialStepSize(InitialStepSize);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ml_SVMSGD_getStepDecreasingPower_const
// parsed: cv::ml::SVMSGD::getStepDecreasingPower
// as:     cv::ml::SVMSGD::getStepDecreasingPower (method) cv::ml::SVMSGD (trait) . getStepDecreasingPower
// Return value: Primitive(float)
cv_return_value_float cv_core_cv_ml_SVMSGD_getStepDecreasingPower_const(void* instance) {
    try {
        float ret = reinterpret_cast<cv::ml::SVMSGD*>(instance)->getStepDecreasingPower();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<float*>(&ret) };
    } CVRS_CATCH(cv_return_value_float)
}

// cv_ml_SVMSGD_setStepDecreasingPower_float_stepDecreasingPower
// parsed: cv::ml::SVMSGD::setStepDecreasingPower
// as:     cv::ml::SVMSGD::setStepDecreasingPower (method) cv::ml::SVMSGD (trait) . setStepDecreasingPower
// Arg ARG Primitive(float) stepDecreasingPower= Primitive(float) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ml_SVMSGD_setStepDecreasingPower_float_stepDecreasingPower(void* instance, float stepDecreasingPower) {
    try {
        reinterpret_cast<cv::ml::SVMSGD*>(instance)->setStepDecreasingPower(stepDecreasingPower);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ml_SVMSGD_getTermCriteria_const
// parsed: cv::ml::SVMSGD::getTermCriteria
// as:     cv::ml::SVMSGD::getTermCriteria (method) cv::ml::SVMSGD (trait) . getTermCriteria
// Return value: cv::TermCriteria (boxed)
cv_return_value_void_X cv_core_cv_ml_SVMSGD_getTermCriteria_const(void* instance) {
    try {
        cv::TermCriteria ret = reinterpret_cast<cv::ml::SVMSGD*>(instance)->getTermCriteria();
        return { Error::Code::StsOk, NULL, new cv::TermCriteria(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_ml_SVMSGD_setTermCriteria_TermCriteria_val
// parsed: cv::ml::SVMSGD::setTermCriteria
// as:     cv::ml::SVMSGD::setTermCriteria (method) cv::ml::SVMSGD (trait) . setTermCriteria
// Arg ARG cv::TermCriteria (boxed) val= cv::TermCriteria (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ml_SVMSGD_setTermCriteria_TermCriteria_val(void* instance, void* val) {
    try {
        reinterpret_cast<cv::ml::SVMSGD*>(instance)->setTermCriteria(*reinterpret_cast<cv::TermCriteria*>(val));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ml_SVMSGD_create
// parsed: cv::ml::SVMSGD::create
// as:     cv::ml::SVMSGD::create (method) cv::ml::SVMSGD (trait) . create
// Return value: SmartPtr[cv::ml::SVMSGD (boxed)]
cv_return_value_void_X cv_core_cv_ml_SVMSGD_create() {
    try {
        Ptr<cv::ml::SVMSGD> *ret = new Ptr<cv::ml::SVMSGD>(cv::ml::SVMSGD::create());
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_ml_SVMSGD_load_String_filepath_String_nodeName
// parsed: cv::ml::SVMSGD::load
// as:     cv::ml::SVMSGD::load (method) cv::ml::SVMSGD (trait) . load
// Arg ARG string filepath= string = 
// Arg ARG string nodeName= string = String()
// Return value: SmartPtr[cv::ml::SVMSGD (boxed)]
cv_return_value_void_X cv_core_cv_ml_SVMSGD_load_String_filepath_String_nodeName(const char* filepath, const char* nodeName) {
    try {
        Ptr<cv::ml::SVMSGD> *ret = new Ptr<cv::ml::SVMSGD>(cv::ml::SVMSGD::load(String(filepath), String(nodeName)));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_ml_StatModel_getVarCount_const
// parsed: cv::ml::StatModel::getVarCount
// as:     cv::ml::StatModel::getVarCount (method) cv::ml::StatModel (trait) . getVarCount
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_ml_StatModel_getVarCount_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::ml::StatModel*>(instance)->getVarCount();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_ml_StatModel_empty_const
// parsed: cv::ml::StatModel::empty
// as:     cv::ml::StatModel::empty (method) cv::ml::StatModel (trait) . empty
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_ml_StatModel_empty_const(void* instance) {
    try {
        bool ret = reinterpret_cast<cv::ml::StatModel*>(instance)->empty();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_ml_StatModel_isTrained_const
// parsed: cv::ml::StatModel::isTrained
// as:     cv::ml::StatModel::isTrained (method) cv::ml::StatModel (trait) . isTrained
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_ml_StatModel_isTrained_const(void* instance) {
    try {
        bool ret = reinterpret_cast<cv::ml::StatModel*>(instance)->isTrained();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_ml_StatModel_isClassifier_const
// parsed: cv::ml::StatModel::isClassifier
// as:     cv::ml::StatModel::isClassifier (method) cv::ml::StatModel (trait) . isClassifier
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_ml_StatModel_isClassifier_const(void* instance) {
    try {
        bool ret = reinterpret_cast<cv::ml::StatModel*>(instance)->isClassifier();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_ml_StatModel_train_PtrOfTrainData_trainData_int_flags
// parsed: cv::ml::StatModel::train
// as:     cv::ml::StatModel::train (method) cv::ml::StatModel (trait) . train
// Arg ARG SmartPtr[cv::ml::TrainData (boxed)] trainData= SmartPtr[cv::ml::TrainData (boxed)] = 
// Arg ARG Primitive(int) flags= Primitive(int) = 0
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_ml_StatModel_train_PtrOfTrainData_trainData_int_flags(void* instance, void* trainData, int flags) {
    try {
        bool ret = reinterpret_cast<cv::ml::StatModel*>(instance)->train(reinterpret_cast<cv::ml::TrainData*>(trainData), flags);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_ml_StatModel_train_Mat_samples_int_layout_Mat_responses
// parsed: cv::ml::StatModel::train
// as:     cv::ml::StatModel::train (method) cv::ml::StatModel (trait) . train
// Arg ARG cv::Mat (boxed) samples= cv::Mat (boxed) = 
// Arg ARG Primitive(int) layout= Primitive(int) = 
// Arg ARG cv::Mat (boxed) responses= cv::Mat (boxed) = 
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_ml_StatModel_train_Mat_samples_int_layout_Mat_responses(void* instance, void* samples, int layout, void* responses) {
    try {
        bool ret = reinterpret_cast<cv::ml::StatModel*>(instance)->train(*reinterpret_cast<cv::Mat*>(samples), layout, *reinterpret_cast<cv::Mat*>(responses));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_ml_StatModel_calcError_const_PtrOfTrainData_data_bool_test_Mat_resp
// parsed: cv::ml::StatModel::calcError
// as:     cv::ml::StatModel::calcError (method) cv::ml::StatModel (trait) . calcError
// Arg ARG SmartPtr[cv::ml::TrainData (boxed)] data= SmartPtr[cv::ml::TrainData (boxed)] = 
// Arg ARG Primitive(bool) test= Primitive(bool) = 
// Arg ARG cv::Mat (boxed) resp= cv::Mat (boxed) = 
// Return value: Primitive(float)
cv_return_value_float cv_core_cv_ml_StatModel_calcError_const_PtrOfTrainData_data_bool_test_Mat_resp(void* instance, void* data, bool test, void* resp) {
    try {
        float ret = reinterpret_cast<cv::ml::StatModel*>(instance)->calcError(reinterpret_cast<cv::ml::TrainData*>(data), test, *reinterpret_cast<cv::Mat*>(resp));
        return { Error::Code::StsOk, NULL, *reinterpret_cast<float*>(&ret) };
    } CVRS_CATCH(cv_return_value_float)
}

// cv_ml_StatModel_predict_const_Mat_samples_Mat_results_int_flags
// parsed: cv::ml::StatModel::predict
// as:     cv::ml::StatModel::predict (method) cv::ml::StatModel (trait) . predict
// Arg ARG cv::Mat (boxed) samples= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) results= cv::Mat (boxed) = noArray()
// Arg ARG Primitive(int) flags= Primitive(int) = 0
// Return value: Primitive(float)
cv_return_value_float cv_core_cv_ml_StatModel_predict_const_Mat_samples_Mat_results_int_flags(void* instance, void* samples, void* results, int flags) {
    try {
        float ret = reinterpret_cast<cv::ml::StatModel*>(instance)->predict(*reinterpret_cast<cv::Mat*>(samples), *reinterpret_cast<cv::Mat*>(results), flags);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<float*>(&ret) };
    } CVRS_CATCH(cv_return_value_float)
}

// cv_ml_TrainData_missingValue
// parsed: cv::ml::TrainData::missingValue
// as:     cv::ml::TrainData::missingValue (method) cv::ml::TrainData (trait) . missingValue
// Return value: Primitive(float)
cv_return_value_float cv_core_cv_ml_TrainData_missingValue(void* instance) {
    try {
        float ret = reinterpret_cast<cv::ml::TrainData*>(instance)->missingValue();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<float*>(&ret) };
    } CVRS_CATCH(cv_return_value_float)
}

// cv_ml_TrainData_getLayout_const
// parsed: cv::ml::TrainData::getLayout
// as:     cv::ml::TrainData::getLayout (method) cv::ml::TrainData (trait) . getLayout
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_ml_TrainData_getLayout_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::ml::TrainData*>(instance)->getLayout();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_ml_TrainData_getNTrainSamples_const
// parsed: cv::ml::TrainData::getNTrainSamples
// as:     cv::ml::TrainData::getNTrainSamples (method) cv::ml::TrainData (trait) . getNTrainSamples
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_ml_TrainData_getNTrainSamples_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::ml::TrainData*>(instance)->getNTrainSamples();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_ml_TrainData_getNTestSamples_const
// parsed: cv::ml::TrainData::getNTestSamples
// as:     cv::ml::TrainData::getNTestSamples (method) cv::ml::TrainData (trait) . getNTestSamples
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_ml_TrainData_getNTestSamples_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::ml::TrainData*>(instance)->getNTestSamples();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_ml_TrainData_getNSamples_const
// parsed: cv::ml::TrainData::getNSamples
// as:     cv::ml::TrainData::getNSamples (method) cv::ml::TrainData (trait) . getNSamples
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_ml_TrainData_getNSamples_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::ml::TrainData*>(instance)->getNSamples();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_ml_TrainData_getNVars_const
// parsed: cv::ml::TrainData::getNVars
// as:     cv::ml::TrainData::getNVars (method) cv::ml::TrainData (trait) . getNVars
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_ml_TrainData_getNVars_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::ml::TrainData*>(instance)->getNVars();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_ml_TrainData_getNAllVars_const
// parsed: cv::ml::TrainData::getNAllVars
// as:     cv::ml::TrainData::getNAllVars (method) cv::ml::TrainData (trait) . getNAllVars
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_ml_TrainData_getNAllVars_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::ml::TrainData*>(instance)->getNAllVars();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_ml_TrainData_getSample_const_Mat_varIdx_int_sidx_float_X_buf
// parsed: cv::ml::TrainData::getSample
// as:     cv::ml::TrainData::getSample (method) cv::ml::TrainData (trait) . getSample
// Arg ARG cv::Mat (boxed) varIdx= cv::Mat (boxed) = 
// Arg ARG Primitive(int) sidx= Primitive(int) = 
// Arg ARG RawPtr[Primitive(float)] * buf= (ptr) RawPtr[Primitive(float)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ml_TrainData_getSample_const_Mat_varIdx_int_sidx_float_X_buf(void* instance, void* varIdx, int sidx, float* buf) {
    try {
        reinterpret_cast<cv::ml::TrainData*>(instance)->getSample(*reinterpret_cast<cv::Mat*>(varIdx), sidx, buf);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ml_TrainData_getSamples_const
// parsed: cv::ml::TrainData::getSamples
// as:     cv::ml::TrainData::getSamples (method) cv::ml::TrainData (trait) . getSamples
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_ml_TrainData_getSamples_const(void* instance) {
    try {
        cv::Mat ret = reinterpret_cast<cv::ml::TrainData*>(instance)->getSamples();
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_ml_TrainData_getMissing_const
// parsed: cv::ml::TrainData::getMissing
// as:     cv::ml::TrainData::getMissing (method) cv::ml::TrainData (trait) . getMissing
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_ml_TrainData_getMissing_const(void* instance) {
    try {
        cv::Mat ret = reinterpret_cast<cv::ml::TrainData*>(instance)->getMissing();
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_ml_TrainData_getTrainSamples_const_int_layout_bool_compressSamples_bool_compressVars
// parsed: cv::ml::TrainData::getTrainSamples
// as:     cv::ml::TrainData::getTrainSamples (method) cv::ml::TrainData (trait) . getTrainSamples
// Arg ARG Primitive(int) layout= Primitive(int) = ROW_SAMPLE
// Arg ARG Primitive(bool) compressSamples= Primitive(bool) = true
// Arg ARG Primitive(bool) compressVars= Primitive(bool) = true
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_ml_TrainData_getTrainSamples_const_int_layout_bool_compressSamples_bool_compressVars(void* instance, int layout, bool compressSamples, bool compressVars) {
    try {
        cv::Mat ret = reinterpret_cast<cv::ml::TrainData*>(instance)->getTrainSamples(layout, compressSamples, compressVars);
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_ml_TrainData_getTrainResponses_const
// parsed: cv::ml::TrainData::getTrainResponses
// as:     cv::ml::TrainData::getTrainResponses (method) cv::ml::TrainData (trait) . getTrainResponses
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_ml_TrainData_getTrainResponses_const(void* instance) {
    try {
        cv::Mat ret = reinterpret_cast<cv::ml::TrainData*>(instance)->getTrainResponses();
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_ml_TrainData_getTrainNormCatResponses_const
// parsed: cv::ml::TrainData::getTrainNormCatResponses
// as:     cv::ml::TrainData::getTrainNormCatResponses (method) cv::ml::TrainData (trait) . getTrainNormCatResponses
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_ml_TrainData_getTrainNormCatResponses_const(void* instance) {
    try {
        cv::Mat ret = reinterpret_cast<cv::ml::TrainData*>(instance)->getTrainNormCatResponses();
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_ml_TrainData_getTestResponses_const
// parsed: cv::ml::TrainData::getTestResponses
// as:     cv::ml::TrainData::getTestResponses (method) cv::ml::TrainData (trait) . getTestResponses
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_ml_TrainData_getTestResponses_const(void* instance) {
    try {
        cv::Mat ret = reinterpret_cast<cv::ml::TrainData*>(instance)->getTestResponses();
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_ml_TrainData_getTestNormCatResponses_const
// parsed: cv::ml::TrainData::getTestNormCatResponses
// as:     cv::ml::TrainData::getTestNormCatResponses (method) cv::ml::TrainData (trait) . getTestNormCatResponses
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_ml_TrainData_getTestNormCatResponses_const(void* instance) {
    try {
        cv::Mat ret = reinterpret_cast<cv::ml::TrainData*>(instance)->getTestNormCatResponses();
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_ml_TrainData_getResponses_const
// parsed: cv::ml::TrainData::getResponses
// as:     cv::ml::TrainData::getResponses (method) cv::ml::TrainData (trait) . getResponses
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_ml_TrainData_getResponses_const(void* instance) {
    try {
        cv::Mat ret = reinterpret_cast<cv::ml::TrainData*>(instance)->getResponses();
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_ml_TrainData_getNormCatResponses_const
// parsed: cv::ml::TrainData::getNormCatResponses
// as:     cv::ml::TrainData::getNormCatResponses (method) cv::ml::TrainData (trait) . getNormCatResponses
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_ml_TrainData_getNormCatResponses_const(void* instance) {
    try {
        cv::Mat ret = reinterpret_cast<cv::ml::TrainData*>(instance)->getNormCatResponses();
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_ml_TrainData_getSampleWeights_const
// parsed: cv::ml::TrainData::getSampleWeights
// as:     cv::ml::TrainData::getSampleWeights (method) cv::ml::TrainData (trait) . getSampleWeights
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_ml_TrainData_getSampleWeights_const(void* instance) {
    try {
        cv::Mat ret = reinterpret_cast<cv::ml::TrainData*>(instance)->getSampleWeights();
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_ml_TrainData_getTrainSampleWeights_const
// parsed: cv::ml::TrainData::getTrainSampleWeights
// as:     cv::ml::TrainData::getTrainSampleWeights (method) cv::ml::TrainData (trait) . getTrainSampleWeights
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_ml_TrainData_getTrainSampleWeights_const(void* instance) {
    try {
        cv::Mat ret = reinterpret_cast<cv::ml::TrainData*>(instance)->getTrainSampleWeights();
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_ml_TrainData_getTestSampleWeights_const
// parsed: cv::ml::TrainData::getTestSampleWeights
// as:     cv::ml::TrainData::getTestSampleWeights (method) cv::ml::TrainData (trait) . getTestSampleWeights
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_ml_TrainData_getTestSampleWeights_const(void* instance) {
    try {
        cv::Mat ret = reinterpret_cast<cv::ml::TrainData*>(instance)->getTestSampleWeights();
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_ml_TrainData_getVarIdx_const
// parsed: cv::ml::TrainData::getVarIdx
// as:     cv::ml::TrainData::getVarIdx (method) cv::ml::TrainData (trait) . getVarIdx
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_ml_TrainData_getVarIdx_const(void* instance) {
    try {
        cv::Mat ret = reinterpret_cast<cv::ml::TrainData*>(instance)->getVarIdx();
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_ml_TrainData_getVarType_const
// parsed: cv::ml::TrainData::getVarType
// as:     cv::ml::TrainData::getVarType (method) cv::ml::TrainData (trait) . getVarType
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_ml_TrainData_getVarType_const(void* instance) {
    try {
        cv::Mat ret = reinterpret_cast<cv::ml::TrainData*>(instance)->getVarType();
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_ml_TrainData_getVarSymbolFlags_const
// parsed: cv::ml::TrainData::getVarSymbolFlags
// as:     cv::ml::TrainData::getVarSymbolFlags (method) cv::ml::TrainData (trait) . getVarSymbolFlags
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_ml_TrainData_getVarSymbolFlags_const(void* instance) {
    try {
        cv::Mat ret = reinterpret_cast<cv::ml::TrainData*>(instance)->getVarSymbolFlags();
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_ml_TrainData_getResponseType_const
// parsed: cv::ml::TrainData::getResponseType
// as:     cv::ml::TrainData::getResponseType (method) cv::ml::TrainData (trait) . getResponseType
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_ml_TrainData_getResponseType_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::ml::TrainData*>(instance)->getResponseType();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_ml_TrainData_getTrainSampleIdx_const
// parsed: cv::ml::TrainData::getTrainSampleIdx
// as:     cv::ml::TrainData::getTrainSampleIdx (method) cv::ml::TrainData (trait) . getTrainSampleIdx
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_ml_TrainData_getTrainSampleIdx_const(void* instance) {
    try {
        cv::Mat ret = reinterpret_cast<cv::ml::TrainData*>(instance)->getTrainSampleIdx();
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_ml_TrainData_getTestSampleIdx_const
// parsed: cv::ml::TrainData::getTestSampleIdx
// as:     cv::ml::TrainData::getTestSampleIdx (method) cv::ml::TrainData (trait) . getTestSampleIdx
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_ml_TrainData_getTestSampleIdx_const(void* instance) {
    try {
        cv::Mat ret = reinterpret_cast<cv::ml::TrainData*>(instance)->getTestSampleIdx();
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_ml_TrainData_getValues_const_int_vi_Mat_sidx_float_X_values
// parsed: cv::ml::TrainData::getValues
// as:     cv::ml::TrainData::getValues (method) cv::ml::TrainData (trait) . getValues
// Arg ARG Primitive(int) vi= Primitive(int) = 
// Arg ARG cv::Mat (boxed) sidx= cv::Mat (boxed) = 
// Arg ARG RawPtr[Primitive(float)] * values= (ptr) RawPtr[Primitive(float)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ml_TrainData_getValues_const_int_vi_Mat_sidx_float_X_values(void* instance, int vi, void* sidx, float* values) {
    try {
        reinterpret_cast<cv::ml::TrainData*>(instance)->getValues(vi, *reinterpret_cast<cv::Mat*>(sidx), values);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ml_TrainData_getNormCatValues_const_int_vi_Mat_sidx_int_X_values
// parsed: cv::ml::TrainData::getNormCatValues
// as:     cv::ml::TrainData::getNormCatValues (method) cv::ml::TrainData (trait) . getNormCatValues
// Arg ARG Primitive(int) vi= Primitive(int) = 
// Arg ARG cv::Mat (boxed) sidx= cv::Mat (boxed) = 
// Arg ARG RawPtr[Primitive(int)] * values= (ptr) RawPtr[Primitive(int)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ml_TrainData_getNormCatValues_const_int_vi_Mat_sidx_int_X_values(void* instance, int vi, void* sidx, int* values) {
    try {
        reinterpret_cast<cv::ml::TrainData*>(instance)->getNormCatValues(vi, *reinterpret_cast<cv::Mat*>(sidx), values);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ml_TrainData_getDefaultSubstValues_const
// parsed: cv::ml::TrainData::getDefaultSubstValues
// as:     cv::ml::TrainData::getDefaultSubstValues (method) cv::ml::TrainData (trait) . getDefaultSubstValues
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_ml_TrainData_getDefaultSubstValues_const(void* instance) {
    try {
        cv::Mat ret = reinterpret_cast<cv::ml::TrainData*>(instance)->getDefaultSubstValues();
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_ml_TrainData_getCatCount_const_int_vi
// parsed: cv::ml::TrainData::getCatCount
// as:     cv::ml::TrainData::getCatCount (method) cv::ml::TrainData (trait) . getCatCount
// Arg ARG Primitive(int) vi= Primitive(int) = 
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_ml_TrainData_getCatCount_const_int_vi(void* instance, int vi) {
    try {
        int ret = reinterpret_cast<cv::ml::TrainData*>(instance)->getCatCount(vi);
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_ml_TrainData_getClassLabels_const
// parsed: cv::ml::TrainData::getClassLabels
// as:     cv::ml::TrainData::getClassLabels (method) cv::ml::TrainData (trait) . getClassLabels
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_ml_TrainData_getClassLabels_const(void* instance) {
    try {
        cv::Mat ret = reinterpret_cast<cv::ml::TrainData*>(instance)->getClassLabels();
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_ml_TrainData_getCatOfs_const
// parsed: cv::ml::TrainData::getCatOfs
// as:     cv::ml::TrainData::getCatOfs (method) cv::ml::TrainData (trait) . getCatOfs
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_ml_TrainData_getCatOfs_const(void* instance) {
    try {
        cv::Mat ret = reinterpret_cast<cv::ml::TrainData*>(instance)->getCatOfs();
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_ml_TrainData_getCatMap_const
// parsed: cv::ml::TrainData::getCatMap
// as:     cv::ml::TrainData::getCatMap (method) cv::ml::TrainData (trait) . getCatMap
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_ml_TrainData_getCatMap_const(void* instance) {
    try {
        cv::Mat ret = reinterpret_cast<cv::ml::TrainData*>(instance)->getCatMap();
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_ml_TrainData_setTrainTestSplit_int_count_bool_shuffle
// parsed: cv::ml::TrainData::setTrainTestSplit
// as:     cv::ml::TrainData::setTrainTestSplit (method) cv::ml::TrainData (trait) . setTrainTestSplit
// Arg ARG Primitive(int) count= Primitive(int) = 
// Arg ARG Primitive(bool) shuffle= Primitive(bool) = true
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ml_TrainData_setTrainTestSplit_int_count_bool_shuffle(void* instance, int count, bool shuffle) {
    try {
        reinterpret_cast<cv::ml::TrainData*>(instance)->setTrainTestSplit(count, shuffle);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ml_TrainData_setTrainTestSplitRatio_double_ratio_bool_shuffle
// parsed: cv::ml::TrainData::setTrainTestSplitRatio
// as:     cv::ml::TrainData::setTrainTestSplitRatio (method) cv::ml::TrainData (trait) . setTrainTestSplitRatio
// Arg ARG Primitive(double) ratio= Primitive(double) = 
// Arg ARG Primitive(bool) shuffle= Primitive(bool) = true
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ml_TrainData_setTrainTestSplitRatio_double_ratio_bool_shuffle(void* instance, double ratio, bool shuffle) {
    try {
        reinterpret_cast<cv::ml::TrainData*>(instance)->setTrainTestSplitRatio(ratio, shuffle);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ml_TrainData_shuffleTrainTest
// parsed: cv::ml::TrainData::shuffleTrainTest
// as:     cv::ml::TrainData::shuffleTrainTest (method) cv::ml::TrainData (trait) . shuffleTrainTest
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ml_TrainData_shuffleTrainTest(void* instance) {
    try {
        reinterpret_cast<cv::ml::TrainData*>(instance)->shuffleTrainTest();
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ml_TrainData_getTestSamples_const
// parsed: cv::ml::TrainData::getTestSamples
// as:     cv::ml::TrainData::getTestSamples (method) cv::ml::TrainData (trait) . getTestSamples
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_ml_TrainData_getTestSamples_const(void* instance) {
    try {
        cv::Mat ret = reinterpret_cast<cv::ml::TrainData*>(instance)->getTestSamples();
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_ml_TrainData_getNames_const_VectorOfString_names
// parsed: cv::ml::TrainData::getNames
// as:     cv::ml::TrainData::getNames (method) cv::ml::TrainData (trait) . getNames
// Arg ARG Vector[string] names= Vector[string] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_ml_TrainData_getNames_const_VectorOfString_names(void* instance, void* names) {
    try {
        reinterpret_cast<cv::ml::TrainData*>(instance)->getNames(*reinterpret_cast<std::vector<String>*>(names));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_ml_TrainData_getSubVector_Mat_vec_Mat_idx
// parsed: cv::ml::TrainData::getSubVector
// as:     cv::ml::TrainData::getSubVector (method) cv::ml::TrainData (trait) . getSubVector
// Arg ARG cv::Mat (boxed) vec= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) idx= cv::Mat (boxed) = 
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_ml_TrainData_getSubVector_Mat_vec_Mat_idx(void* vec, void* idx) {
    try {
        cv::Mat ret = cv::ml::TrainData::getSubVector(*reinterpret_cast<cv::Mat*>(vec), *reinterpret_cast<cv::Mat*>(idx));
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_ml_TrainData_getSubMatrix_Mat_matrix_Mat_idx_int_layout
// parsed: cv::ml::TrainData::getSubMatrix
// as:     cv::ml::TrainData::getSubMatrix (method) cv::ml::TrainData (trait) . getSubMatrix
// Arg ARG cv::Mat (boxed) matrix= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) idx= cv::Mat (boxed) = 
// Arg ARG Primitive(int) layout= Primitive(int) = 
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_ml_TrainData_getSubMatrix_Mat_matrix_Mat_idx_int_layout(void* matrix, void* idx, int layout) {
    try {
        cv::Mat ret = cv::ml::TrainData::getSubMatrix(*reinterpret_cast<cv::Mat*>(matrix), *reinterpret_cast<cv::Mat*>(idx), layout);
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_ml_TrainData_create_Mat_samples_int_layout_Mat_responses_Mat_varIdx_Mat_sampleIdx_Mat_sampleWeights_Mat_varType
// parsed: cv::ml::TrainData::create
// as:     cv::ml::TrainData::create (method) cv::ml::TrainData (trait) . create
// Arg ARG cv::Mat (boxed) samples= cv::Mat (boxed) = 
// Arg ARG Primitive(int) layout= Primitive(int) = 
// Arg ARG cv::Mat (boxed) responses= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) varIdx= cv::Mat (boxed) = noArray()
// Arg ARG cv::Mat (boxed) sampleIdx= cv::Mat (boxed) = noArray()
// Arg ARG cv::Mat (boxed) sampleWeights= cv::Mat (boxed) = noArray()
// Arg ARG cv::Mat (boxed) varType= cv::Mat (boxed) = noArray()
// Return value: SmartPtr[cv::ml::TrainData (boxed)]
cv_return_value_void_X cv_core_cv_ml_TrainData_create_Mat_samples_int_layout_Mat_responses_Mat_varIdx_Mat_sampleIdx_Mat_sampleWeights_Mat_varType(void* samples, int layout, void* responses, void* varIdx, void* sampleIdx, void* sampleWeights, void* varType) {
    try {
        Ptr<cv::ml::TrainData> *ret = new Ptr<cv::ml::TrainData>(cv::ml::TrainData::create(*reinterpret_cast<cv::Mat*>(samples), layout, *reinterpret_cast<cv::Mat*>(responses), *reinterpret_cast<cv::Mat*>(varIdx), *reinterpret_cast<cv::Mat*>(sampleIdx), *reinterpret_cast<cv::Mat*>(sampleWeights), *reinterpret_cast<cv::Mat*>(varType)));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// boxed class: cv::softdouble
void cv_delete_softdouble(void* instance) {
    delete (cv::softdouble*) instance;
}
// cv_softdouble_softdouble_softdouble_c
// parsed: cv::softdouble::softdouble
// as:     cv::softdouble::softdouble (constructor) cv::softdouble . new
// Arg ARG cv::softdouble (boxed) c= cv::softdouble (boxed) = 
// Return value: cv::softdouble (boxed)
cv_return_value_void_X cv_core_cv_softdouble_softdouble_softdouble_c(void* c) {
    try {
        cv::softdouble* ret = new cv::softdouble(*reinterpret_cast<cv::softdouble*>(c));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_softdouble_fromRaw_uint64_t_a
// parsed: cv::softdouble::fromRaw
// as:     cv::softdouble::fromRaw (method) cv::softdouble . fromRaw
// Arg ARG Primitive(uint64_t) a= Primitive(uint64_t) = 
// Return value: cv::softdouble (boxed)
cv_return_value_void_X cv_core_cv_softdouble_fromRaw_uint64_t_a(uint64_t a) {
    try {
        cv::softdouble ret = cv::softdouble::fromRaw(a);
        return { Error::Code::StsOk, NULL, new cv::softdouble(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_softdouble_softdouble_int_a
// parsed: cv::softdouble::softdouble
// as:     cv::softdouble::softdouble (constructor) cv::softdouble . new
// Arg ARG Primitive(int) a= Primitive(int) = 
// Return value: cv::softdouble (boxed)
cv_return_value_void_X cv_core_cv_softdouble_softdouble_int_a(int a) {
    try {
        cv::softdouble* ret = new cv::softdouble(a);
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_softdouble_softdouble_double_a
// parsed: cv::softdouble::softdouble
// as:     cv::softdouble::softdouble (constructor) cv::softdouble . new
// Arg ARG Primitive(double) a= Primitive(double) = 
// Return value: cv::softdouble (boxed)
cv_return_value_void_X cv_core_cv_softdouble_softdouble_double_a(double a) {
    try {
        cv::softdouble* ret = new cv::softdouble(a);
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_softdouble_isNaN_const
// parsed: cv::softdouble::isNaN
// as:     cv::softdouble::isNaN (method) cv::softdouble . isNaN
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_softdouble_isNaN_const(void* instance) {
    try {
        bool ret = reinterpret_cast<cv::softdouble*>(instance)->isNaN();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_softdouble_isInf_const
// parsed: cv::softdouble::isInf
// as:     cv::softdouble::isInf (method) cv::softdouble . isInf
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_softdouble_isInf_const(void* instance) {
    try {
        bool ret = reinterpret_cast<cv::softdouble*>(instance)->isInf();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_softdouble_isSubnormal_const
// parsed: cv::softdouble::isSubnormal
// as:     cv::softdouble::isSubnormal (method) cv::softdouble . isSubnormal
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_softdouble_isSubnormal_const(void* instance) {
    try {
        bool ret = reinterpret_cast<cv::softdouble*>(instance)->isSubnormal();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_softdouble_getSign_const
// parsed: cv::softdouble::getSign
// as:     cv::softdouble::getSign (method) cv::softdouble . getSign
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_softdouble_getSign_const(void* instance) {
    try {
        bool ret = reinterpret_cast<cv::softdouble*>(instance)->getSign();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_softdouble_setSign_const_bool_sign
// parsed: cv::softdouble::setSign
// as:     cv::softdouble::setSign (method) cv::softdouble . setSign
// Arg ARG Primitive(bool) sign= Primitive(bool) = 
// Return value: cv::softdouble (boxed)
cv_return_value_void_X cv_core_cv_softdouble_setSign_const_bool_sign(void* instance, bool sign) {
    try {
        cv::softdouble ret = reinterpret_cast<cv::softdouble*>(instance)->setSign(sign);
        return { Error::Code::StsOk, NULL, new cv::softdouble(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_softdouble_getExp_const
// parsed: cv::softdouble::getExp
// as:     cv::softdouble::getExp (method) cv::softdouble . getExp
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_softdouble_getExp_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::softdouble*>(instance)->getExp();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_softdouble_setExp_const_int_e
// parsed: cv::softdouble::setExp
// as:     cv::softdouble::setExp (method) cv::softdouble . setExp
// Arg ARG Primitive(int) e= Primitive(int) = 
// Return value: cv::softdouble (boxed)
cv_return_value_void_X cv_core_cv_softdouble_setExp_const_int_e(void* instance, int e) {
    try {
        cv::softdouble ret = reinterpret_cast<cv::softdouble*>(instance)->setExp(e);
        return { Error::Code::StsOk, NULL, new cv::softdouble(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_softdouble_getFrac_const
// parsed: cv::softdouble::getFrac
// as:     cv::softdouble::getFrac (method) cv::softdouble . getFrac
// Return value: cv::softdouble (boxed)
cv_return_value_void_X cv_core_cv_softdouble_getFrac_const(void* instance) {
    try {
        cv::softdouble ret = reinterpret_cast<cv::softdouble*>(instance)->getFrac();
        return { Error::Code::StsOk, NULL, new cv::softdouble(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_softdouble_setFrac_const_softdouble_s
// parsed: cv::softdouble::setFrac
// as:     cv::softdouble::setFrac (method) cv::softdouble . setFrac
// Arg ARG cv::softdouble (boxed) s= cv::softdouble (boxed) = 
// Return value: cv::softdouble (boxed)
cv_return_value_void_X cv_core_cv_softdouble_setFrac_const_softdouble_s(void* instance, void* s) {
    try {
        cv::softdouble ret = reinterpret_cast<cv::softdouble*>(instance)->setFrac(*reinterpret_cast<cv::softdouble*>(s));
        return { Error::Code::StsOk, NULL, new cv::softdouble(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_softdouble_zero
// parsed: cv::softdouble::zero
// as:     cv::softdouble::zero (method) cv::softdouble . zero
// Return value: cv::softdouble (boxed)
cv_return_value_void_X cv_core_cv_softdouble_zero() {
    try {
        cv::softdouble ret = cv::softdouble::zero();
        return { Error::Code::StsOk, NULL, new cv::softdouble(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_softdouble_inf
// parsed: cv::softdouble::inf
// as:     cv::softdouble::inf (method) cv::softdouble . inf
// Return value: cv::softdouble (boxed)
cv_return_value_void_X cv_core_cv_softdouble_inf() {
    try {
        cv::softdouble ret = cv::softdouble::inf();
        return { Error::Code::StsOk, NULL, new cv::softdouble(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_softdouble_nan
// parsed: cv::softdouble::nan
// as:     cv::softdouble::nan (method) cv::softdouble . nan
// Return value: cv::softdouble (boxed)
cv_return_value_void_X cv_core_cv_softdouble_nan() {
    try {
        cv::softdouble ret = cv::softdouble::nan();
        return { Error::Code::StsOk, NULL, new cv::softdouble(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_softdouble_one
// parsed: cv::softdouble::one
// as:     cv::softdouble::one (method) cv::softdouble . one
// Return value: cv::softdouble (boxed)
cv_return_value_void_X cv_core_cv_softdouble_one() {
    try {
        cv::softdouble ret = cv::softdouble::one();
        return { Error::Code::StsOk, NULL, new cv::softdouble(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_softdouble_min
// parsed: cv::softdouble::min
// as:     cv::softdouble::min (method) cv::softdouble . min
// Return value: cv::softdouble (boxed)
cv_return_value_void_X cv_core_cv_softdouble_min() {
    try {
        cv::softdouble ret = cv::softdouble::min();
        return { Error::Code::StsOk, NULL, new cv::softdouble(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_softdouble_eps
// parsed: cv::softdouble::eps
// as:     cv::softdouble::eps (method) cv::softdouble . eps
// Return value: cv::softdouble (boxed)
cv_return_value_void_X cv_core_cv_softdouble_eps() {
    try {
        cv::softdouble ret = cv::softdouble::eps();
        return { Error::Code::StsOk, NULL, new cv::softdouble(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_softdouble_max
// parsed: cv::softdouble::max
// as:     cv::softdouble::max (method) cv::softdouble . max
// Return value: cv::softdouble (boxed)
cv_return_value_void_X cv_core_cv_softdouble_max() {
    try {
        cv::softdouble ret = cv::softdouble::max();
        return { Error::Code::StsOk, NULL, new cv::softdouble(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_softdouble_pi
// parsed: cv::softdouble::pi
// as:     cv::softdouble::pi (method) cv::softdouble . pi
// Return value: cv::softdouble (boxed)
cv_return_value_void_X cv_core_cv_softdouble_pi() {
    try {
        cv::softdouble ret = cv::softdouble::pi();
        return { Error::Code::StsOk, NULL, new cv::softdouble(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// boxed class: cv::softfloat
void cv_delete_softfloat(void* instance) {
    delete (cv::softfloat*) instance;
}
// cv_softfloat_softfloat
// parsed: cv::softfloat::softfloat
// as:     cv::softfloat::softfloat (constructor) cv::softfloat . new
// Return value: cv::softfloat (boxed)
cv_return_value_void_X cv_core_cv_softfloat_softfloat() {
    try {
        cv::softfloat* ret = new cv::softfloat();
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_softfloat_softfloat_softfloat_c
// parsed: cv::softfloat::softfloat
// as:     cv::softfloat::softfloat (constructor) cv::softfloat . new
// Arg ARG cv::softfloat (boxed) c= cv::softfloat (boxed) = 
// Return value: cv::softfloat (boxed)
cv_return_value_void_X cv_core_cv_softfloat_softfloat_softfloat_c(void* c) {
    try {
        cv::softfloat* ret = new cv::softfloat(*reinterpret_cast<cv::softfloat*>(c));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_softfloat_fromRaw_uint32_t_a
// parsed: cv::softfloat::fromRaw
// as:     cv::softfloat::fromRaw (method) cv::softfloat . fromRaw
// Arg ARG Primitive(uint32_t) a= Primitive(uint32_t) = 
// Return value: cv::softfloat (boxed)
cv_return_value_void_X cv_core_cv_softfloat_fromRaw_uint32_t_a(uint32_t a) {
    try {
        cv::softfloat ret = cv::softfloat::fromRaw(a);
        return { Error::Code::StsOk, NULL, new cv::softfloat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_softfloat_softfloat_int_a
// parsed: cv::softfloat::softfloat
// as:     cv::softfloat::softfloat (constructor) cv::softfloat . new
// Arg ARG Primitive(int) a= Primitive(int) = 
// Return value: cv::softfloat (boxed)
cv_return_value_void_X cv_core_cv_softfloat_softfloat_int_a(int a) {
    try {
        cv::softfloat* ret = new cv::softfloat(a);
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_softfloat_softfloat_float_a
// parsed: cv::softfloat::softfloat
// as:     cv::softfloat::softfloat (constructor) cv::softfloat . new
// Arg ARG Primitive(float) a= Primitive(float) = 
// Return value: cv::softfloat (boxed)
cv_return_value_void_X cv_core_cv_softfloat_softfloat_float_a(float a) {
    try {
        cv::softfloat* ret = new cv::softfloat(a);
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_softfloat_isNaN_const
// parsed: cv::softfloat::isNaN
// as:     cv::softfloat::isNaN (method) cv::softfloat . isNaN
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_softfloat_isNaN_const(void* instance) {
    try {
        bool ret = reinterpret_cast<cv::softfloat*>(instance)->isNaN();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_softfloat_isInf_const
// parsed: cv::softfloat::isInf
// as:     cv::softfloat::isInf (method) cv::softfloat . isInf
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_softfloat_isInf_const(void* instance) {
    try {
        bool ret = reinterpret_cast<cv::softfloat*>(instance)->isInf();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_softfloat_isSubnormal_const
// parsed: cv::softfloat::isSubnormal
// as:     cv::softfloat::isSubnormal (method) cv::softfloat . isSubnormal
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_softfloat_isSubnormal_const(void* instance) {
    try {
        bool ret = reinterpret_cast<cv::softfloat*>(instance)->isSubnormal();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_softfloat_getSign_const
// parsed: cv::softfloat::getSign
// as:     cv::softfloat::getSign (method) cv::softfloat . getSign
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_softfloat_getSign_const(void* instance) {
    try {
        bool ret = reinterpret_cast<cv::softfloat*>(instance)->getSign();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_softfloat_setSign_const_bool_sign
// parsed: cv::softfloat::setSign
// as:     cv::softfloat::setSign (method) cv::softfloat . setSign
// Arg ARG Primitive(bool) sign= Primitive(bool) = 
// Return value: cv::softfloat (boxed)
cv_return_value_void_X cv_core_cv_softfloat_setSign_const_bool_sign(void* instance, bool sign) {
    try {
        cv::softfloat ret = reinterpret_cast<cv::softfloat*>(instance)->setSign(sign);
        return { Error::Code::StsOk, NULL, new cv::softfloat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_softfloat_getExp_const
// parsed: cv::softfloat::getExp
// as:     cv::softfloat::getExp (method) cv::softfloat . getExp
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_softfloat_getExp_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::softfloat*>(instance)->getExp();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_softfloat_setExp_const_int_e
// parsed: cv::softfloat::setExp
// as:     cv::softfloat::setExp (method) cv::softfloat . setExp
// Arg ARG Primitive(int) e= Primitive(int) = 
// Return value: cv::softfloat (boxed)
cv_return_value_void_X cv_core_cv_softfloat_setExp_const_int_e(void* instance, int e) {
    try {
        cv::softfloat ret = reinterpret_cast<cv::softfloat*>(instance)->setExp(e);
        return { Error::Code::StsOk, NULL, new cv::softfloat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_softfloat_getFrac_const
// parsed: cv::softfloat::getFrac
// as:     cv::softfloat::getFrac (method) cv::softfloat . getFrac
// Return value: cv::softfloat (boxed)
cv_return_value_void_X cv_core_cv_softfloat_getFrac_const(void* instance) {
    try {
        cv::softfloat ret = reinterpret_cast<cv::softfloat*>(instance)->getFrac();
        return { Error::Code::StsOk, NULL, new cv::softfloat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_softfloat_setFrac_const_softfloat_s
// parsed: cv::softfloat::setFrac
// as:     cv::softfloat::setFrac (method) cv::softfloat . setFrac
// Arg ARG cv::softfloat (boxed) s= cv::softfloat (boxed) = 
// Return value: cv::softfloat (boxed)
cv_return_value_void_X cv_core_cv_softfloat_setFrac_const_softfloat_s(void* instance, void* s) {
    try {
        cv::softfloat ret = reinterpret_cast<cv::softfloat*>(instance)->setFrac(*reinterpret_cast<cv::softfloat*>(s));
        return { Error::Code::StsOk, NULL, new cv::softfloat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_softfloat_zero
// parsed: cv::softfloat::zero
// as:     cv::softfloat::zero (method) cv::softfloat . zero
// Return value: cv::softfloat (boxed)
cv_return_value_void_X cv_core_cv_softfloat_zero() {
    try {
        cv::softfloat ret = cv::softfloat::zero();
        return { Error::Code::StsOk, NULL, new cv::softfloat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_softfloat_inf
// parsed: cv::softfloat::inf
// as:     cv::softfloat::inf (method) cv::softfloat . inf
// Return value: cv::softfloat (boxed)
cv_return_value_void_X cv_core_cv_softfloat_inf() {
    try {
        cv::softfloat ret = cv::softfloat::inf();
        return { Error::Code::StsOk, NULL, new cv::softfloat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_softfloat_nan
// parsed: cv::softfloat::nan
// as:     cv::softfloat::nan (method) cv::softfloat . nan
// Return value: cv::softfloat (boxed)
cv_return_value_void_X cv_core_cv_softfloat_nan() {
    try {
        cv::softfloat ret = cv::softfloat::nan();
        return { Error::Code::StsOk, NULL, new cv::softfloat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_softfloat_one
// parsed: cv::softfloat::one
// as:     cv::softfloat::one (method) cv::softfloat . one
// Return value: cv::softfloat (boxed)
cv_return_value_void_X cv_core_cv_softfloat_one() {
    try {
        cv::softfloat ret = cv::softfloat::one();
        return { Error::Code::StsOk, NULL, new cv::softfloat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_softfloat_min
// parsed: cv::softfloat::min
// as:     cv::softfloat::min (method) cv::softfloat . min
// Return value: cv::softfloat (boxed)
cv_return_value_void_X cv_core_cv_softfloat_min() {
    try {
        cv::softfloat ret = cv::softfloat::min();
        return { Error::Code::StsOk, NULL, new cv::softfloat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_softfloat_eps
// parsed: cv::softfloat::eps
// as:     cv::softfloat::eps (method) cv::softfloat . eps
// Return value: cv::softfloat (boxed)
cv_return_value_void_X cv_core_cv_softfloat_eps() {
    try {
        cv::softfloat ret = cv::softfloat::eps();
        return { Error::Code::StsOk, NULL, new cv::softfloat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_softfloat_max
// parsed: cv::softfloat::max
// as:     cv::softfloat::max (method) cv::softfloat . max
// Return value: cv::softfloat (boxed)
cv_return_value_void_X cv_core_cv_softfloat_max() {
    try {
        cv::softfloat ret = cv::softfloat::max();
        return { Error::Code::StsOk, NULL, new cv::softfloat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_softfloat_pi
// parsed: cv::softfloat::pi
// as:     cv::softfloat::pi (method) cv::softfloat . pi
// Return value: cv::softfloat (boxed)
cv_return_value_void_X cv_core_cv_softfloat_pi() {
    try {
        cv::softfloat ret = cv::softfloat::pi();
        return { Error::Code::StsOk, NULL, new cv::softfloat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_superres_FrameSource_nextFrame_Mat_frame
// parsed: cv::superres::FrameSource::nextFrame
// as:     cv::superres::FrameSource::nextFrame (method) cv::superres::FrameSource (trait) . nextFrame
// Arg ARG cv::Mat (boxed) frame= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_superres_FrameSource_nextFrame_Mat_frame(void* instance, void* frame) {
    try {
        reinterpret_cast<cv::superres::FrameSource*>(instance)->nextFrame(*reinterpret_cast<cv::Mat*>(frame));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_superres_FrameSource_reset
// parsed: cv::superres::FrameSource::reset
// as:     cv::superres::FrameSource::reset (method) cv::superres::FrameSource (trait) . reset
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_superres_FrameSource_reset(void* instance) {
    try {
        reinterpret_cast<cv::superres::FrameSource*>(instance)->reset();
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_superres_SuperResolution_setInput_PtrOfFrameSource_frameSource
// parsed: cv::superres::SuperResolution::setInput
// as:     cv::superres::SuperResolution::setInput (method) cv::superres::SuperResolution (trait) . setInput
// Arg ARG SmartPtr[cv::superres::FrameSource (boxed)] frameSource= SmartPtr[cv::superres::FrameSource (boxed)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_superres_SuperResolution_setInput_PtrOfFrameSource_frameSource(void* instance, void* frameSource) {
    try {
        reinterpret_cast<cv::superres::SuperResolution*>(instance)->setInput(reinterpret_cast<cv::superres::FrameSource*>(frameSource));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_superres_SuperResolution_nextFrame_Mat_frame
// parsed: cv::superres::SuperResolution::nextFrame
// as:     cv::superres::SuperResolution::nextFrame (method) cv::superres::SuperResolution (trait) . nextFrame
// Arg ARG cv::Mat (boxed) frame= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_superres_SuperResolution_nextFrame_Mat_frame(void* instance, void* frame) {
    try {
        reinterpret_cast<cv::superres::SuperResolution*>(instance)->nextFrame(*reinterpret_cast<cv::Mat*>(frame));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_superres_SuperResolution_reset
// parsed: cv::superres::SuperResolution::reset
// as:     cv::superres::SuperResolution::reset (method) cv::superres::SuperResolution (trait) . reset
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_superres_SuperResolution_reset(void* instance) {
    try {
        reinterpret_cast<cv::superres::SuperResolution*>(instance)->reset();
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_superres_SuperResolution_collectGarbage
// parsed: cv::superres::SuperResolution::collectGarbage
// as:     cv::superres::SuperResolution::collectGarbage (method) cv::superres::SuperResolution (trait) . collectGarbage
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_superres_SuperResolution_collectGarbage(void* instance) {
    try {
        reinterpret_cast<cv::superres::SuperResolution*>(instance)->collectGarbage();
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_superres_SuperResolution_getScale_const
// parsed: cv::superres::SuperResolution::getScale
// as:     cv::superres::SuperResolution::getScale (method) cv::superres::SuperResolution (trait) . getScale
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_superres_SuperResolution_getScale_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::superres::SuperResolution*>(instance)->getScale();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_superres_SuperResolution_setScale_int_val
// parsed: cv::superres::SuperResolution::setScale
// as:     cv::superres::SuperResolution::setScale (method) cv::superres::SuperResolution (trait) . setScale
// Arg ARG Primitive(int) val= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_superres_SuperResolution_setScale_int_val(void* instance, int val) {
    try {
        reinterpret_cast<cv::superres::SuperResolution*>(instance)->setScale(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_superres_SuperResolution_getIterations_const
// parsed: cv::superres::SuperResolution::getIterations
// as:     cv::superres::SuperResolution::getIterations (method) cv::superres::SuperResolution (trait) . getIterations
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_superres_SuperResolution_getIterations_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::superres::SuperResolution*>(instance)->getIterations();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_superres_SuperResolution_setIterations_int_val
// parsed: cv::superres::SuperResolution::setIterations
// as:     cv::superres::SuperResolution::setIterations (method) cv::superres::SuperResolution (trait) . setIterations
// Arg ARG Primitive(int) val= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_superres_SuperResolution_setIterations_int_val(void* instance, int val) {
    try {
        reinterpret_cast<cv::superres::SuperResolution*>(instance)->setIterations(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_superres_SuperResolution_getTau_const
// parsed: cv::superres::SuperResolution::getTau
// as:     cv::superres::SuperResolution::getTau (method) cv::superres::SuperResolution (trait) . getTau
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_superres_SuperResolution_getTau_const(void* instance) {
    try {
        double ret = reinterpret_cast<cv::superres::SuperResolution*>(instance)->getTau();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_superres_SuperResolution_setTau_double_val
// parsed: cv::superres::SuperResolution::setTau
// as:     cv::superres::SuperResolution::setTau (method) cv::superres::SuperResolution (trait) . setTau
// Arg ARG Primitive(double) val= Primitive(double) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_superres_SuperResolution_setTau_double_val(void* instance, double val) {
    try {
        reinterpret_cast<cv::superres::SuperResolution*>(instance)->setTau(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_superres_SuperResolution_getLabmda_const
// parsed: cv::superres::SuperResolution::getLabmda
// as:     cv::superres::SuperResolution::getLabmda (method) cv::superres::SuperResolution (trait) . getLabmda
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_superres_SuperResolution_getLabmda_const(void* instance) {
    try {
        double ret = reinterpret_cast<cv::superres::SuperResolution*>(instance)->getLabmda();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_superres_SuperResolution_setLabmda_double_val
// parsed: cv::superres::SuperResolution::setLabmda
// as:     cv::superres::SuperResolution::setLabmda (method) cv::superres::SuperResolution (trait) . setLabmda
// Arg ARG Primitive(double) val= Primitive(double) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_superres_SuperResolution_setLabmda_double_val(void* instance, double val) {
    try {
        reinterpret_cast<cv::superres::SuperResolution*>(instance)->setLabmda(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_superres_SuperResolution_getAlpha_const
// parsed: cv::superres::SuperResolution::getAlpha
// as:     cv::superres::SuperResolution::getAlpha (method) cv::superres::SuperResolution (trait) . getAlpha
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_superres_SuperResolution_getAlpha_const(void* instance) {
    try {
        double ret = reinterpret_cast<cv::superres::SuperResolution*>(instance)->getAlpha();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_superres_SuperResolution_setAlpha_double_val
// parsed: cv::superres::SuperResolution::setAlpha
// as:     cv::superres::SuperResolution::setAlpha (method) cv::superres::SuperResolution (trait) . setAlpha
// Arg ARG Primitive(double) val= Primitive(double) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_superres_SuperResolution_setAlpha_double_val(void* instance, double val) {
    try {
        reinterpret_cast<cv::superres::SuperResolution*>(instance)->setAlpha(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_superres_SuperResolution_getKernelSize_const
// parsed: cv::superres::SuperResolution::getKernelSize
// as:     cv::superres::SuperResolution::getKernelSize (method) cv::superres::SuperResolution (trait) . getKernelSize
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_superres_SuperResolution_getKernelSize_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::superres::SuperResolution*>(instance)->getKernelSize();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_superres_SuperResolution_setKernelSize_int_val
// parsed: cv::superres::SuperResolution::setKernelSize
// as:     cv::superres::SuperResolution::setKernelSize (method) cv::superres::SuperResolution (trait) . setKernelSize
// Arg ARG Primitive(int) val= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_superres_SuperResolution_setKernelSize_int_val(void* instance, int val) {
    try {
        reinterpret_cast<cv::superres::SuperResolution*>(instance)->setKernelSize(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_superres_SuperResolution_getBlurKernelSize_const
// parsed: cv::superres::SuperResolution::getBlurKernelSize
// as:     cv::superres::SuperResolution::getBlurKernelSize (method) cv::superres::SuperResolution (trait) . getBlurKernelSize
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_superres_SuperResolution_getBlurKernelSize_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::superres::SuperResolution*>(instance)->getBlurKernelSize();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_superres_SuperResolution_setBlurKernelSize_int_val
// parsed: cv::superres::SuperResolution::setBlurKernelSize
// as:     cv::superres::SuperResolution::setBlurKernelSize (method) cv::superres::SuperResolution (trait) . setBlurKernelSize
// Arg ARG Primitive(int) val= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_superres_SuperResolution_setBlurKernelSize_int_val(void* instance, int val) {
    try {
        reinterpret_cast<cv::superres::SuperResolution*>(instance)->setBlurKernelSize(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_superres_SuperResolution_getBlurSigma_const
// parsed: cv::superres::SuperResolution::getBlurSigma
// as:     cv::superres::SuperResolution::getBlurSigma (method) cv::superres::SuperResolution (trait) . getBlurSigma
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_superres_SuperResolution_getBlurSigma_const(void* instance) {
    try {
        double ret = reinterpret_cast<cv::superres::SuperResolution*>(instance)->getBlurSigma();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// cv_superres_SuperResolution_setBlurSigma_double_val
// parsed: cv::superres::SuperResolution::setBlurSigma
// as:     cv::superres::SuperResolution::setBlurSigma (method) cv::superres::SuperResolution (trait) . setBlurSigma
// Arg ARG Primitive(double) val= Primitive(double) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_superres_SuperResolution_setBlurSigma_double_val(void* instance, double val) {
    try {
        reinterpret_cast<cv::superres::SuperResolution*>(instance)->setBlurSigma(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_superres_SuperResolution_getTemporalAreaRadius_const
// parsed: cv::superres::SuperResolution::getTemporalAreaRadius
// as:     cv::superres::SuperResolution::getTemporalAreaRadius (method) cv::superres::SuperResolution (trait) . getTemporalAreaRadius
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_superres_SuperResolution_getTemporalAreaRadius_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::superres::SuperResolution*>(instance)->getTemporalAreaRadius();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_superres_SuperResolution_setTemporalAreaRadius_int_val
// parsed: cv::superres::SuperResolution::setTemporalAreaRadius
// as:     cv::superres::SuperResolution::setTemporalAreaRadius (method) cv::superres::SuperResolution (trait) . setTemporalAreaRadius
// Arg ARG Primitive(int) val= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_superres_SuperResolution_setTemporalAreaRadius_int_val(void* instance, int val) {
    try {
        reinterpret_cast<cv::superres::SuperResolution*>(instance)->setTemporalAreaRadius(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// boxed class: cv::videostab::ColorAverageInpainter
void cv_delete_ColorAverageInpainter(void* instance) {
    delete (cv::videostab::ColorAverageInpainter*) instance;
}
// cv_videostab_ColorAverageInpainter_inpaint_int_idx_Mat_frame_Mat_mask
// parsed: cv::videostab::ColorAverageInpainter::inpaint
// as:     cv::videostab::ColorAverageInpainter::inpaint (method) cv::videostab::ColorAverageInpainter . inpaint
// Arg ARG Primitive(int) idx= Primitive(int) = 
// Arg ARG cv::Mat (boxed) frame= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) mask= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_videostab_ColorAverageInpainter_inpaint_int_idx_Mat_frame_Mat_mask(void* instance, int idx, void* frame, void* mask) {
    try {
        reinterpret_cast<cv::videostab::ColorAverageInpainter*>(instance)->inpaint(idx, *reinterpret_cast<cv::Mat*>(frame), *reinterpret_cast<cv::Mat*>(mask));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// boxed class: cv::videostab::ColorInpainter
void cv_delete_ColorInpainter(void* instance) {
    delete (cv::videostab::ColorInpainter*) instance;
}
// cv_videostab_ColorInpainter_ColorInpainter_int_method_double_radius
// parsed: cv::videostab::ColorInpainter::ColorInpainter
// as:     cv::videostab::ColorInpainter::ColorInpainter (constructor) cv::videostab::ColorInpainter . new
// Arg ARG Primitive(int) method= Primitive(int) = INPAINT_TELEA
// Arg ARG Primitive(double) radius= Primitive(double) = 2.
// Return value: cv::videostab::ColorInpainter (boxed)
cv_return_value_void_X cv_core_cv_videostab_ColorInpainter_ColorInpainter_int_method_double_radius(int method, double radius) {
    try {
        cv::videostab::ColorInpainter* ret = new cv::videostab::ColorInpainter(method, radius);
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_videostab_ColorInpainter_inpaint_int_idx_Mat_frame_Mat_mask
// parsed: cv::videostab::ColorInpainter::inpaint
// as:     cv::videostab::ColorInpainter::inpaint (method) cv::videostab::ColorInpainter . inpaint
// Arg ARG Primitive(int) idx= Primitive(int) = 
// Arg ARG cv::Mat (boxed) frame= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) mask= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_videostab_ColorInpainter_inpaint_int_idx_Mat_frame_Mat_mask(void* instance, int idx, void* frame, void* mask) {
    try {
        reinterpret_cast<cv::videostab::ColorInpainter*>(instance)->inpaint(idx, *reinterpret_cast<cv::Mat*>(frame), *reinterpret_cast<cv::Mat*>(mask));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// boxed class: cv::videostab::ConsistentMosaicInpainter
void cv_delete_ConsistentMosaicInpainter(void* instance) {
    delete (cv::videostab::ConsistentMosaicInpainter*) instance;
}
// cv_videostab_ConsistentMosaicInpainter_ConsistentMosaicInpainter
// parsed: cv::videostab::ConsistentMosaicInpainter::ConsistentMosaicInpainter
// as:     cv::videostab::ConsistentMosaicInpainter::ConsistentMosaicInpainter (constructor) cv::videostab::ConsistentMosaicInpainter . new
// Return value: cv::videostab::ConsistentMosaicInpainter (boxed)
cv_return_value_void_X cv_core_cv_videostab_ConsistentMosaicInpainter_ConsistentMosaicInpainter() {
    try {
        cv::videostab::ConsistentMosaicInpainter* ret = new cv::videostab::ConsistentMosaicInpainter();
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_videostab_ConsistentMosaicInpainter_setStdevThresh_float_val
// parsed: cv::videostab::ConsistentMosaicInpainter::setStdevThresh
// as:     cv::videostab::ConsistentMosaicInpainter::setStdevThresh (method) cv::videostab::ConsistentMosaicInpainter . setStdevThresh
// Arg ARG Primitive(float) val= Primitive(float) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_videostab_ConsistentMosaicInpainter_setStdevThresh_float_val(void* instance, float val) {
    try {
        reinterpret_cast<cv::videostab::ConsistentMosaicInpainter*>(instance)->setStdevThresh(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_videostab_ConsistentMosaicInpainter_stdevThresh_const
// parsed: cv::videostab::ConsistentMosaicInpainter::stdevThresh
// as:     cv::videostab::ConsistentMosaicInpainter::stdevThresh (method) cv::videostab::ConsistentMosaicInpainter . stdevThresh
// Return value: Primitive(float)
cv_return_value_float cv_core_cv_videostab_ConsistentMosaicInpainter_stdevThresh_const(void* instance) {
    try {
        float ret = reinterpret_cast<cv::videostab::ConsistentMosaicInpainter*>(instance)->stdevThresh();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<float*>(&ret) };
    } CVRS_CATCH(cv_return_value_float)
}

// cv_videostab_ConsistentMosaicInpainter_inpaint_int_idx_Mat_frame_Mat_mask
// parsed: cv::videostab::ConsistentMosaicInpainter::inpaint
// as:     cv::videostab::ConsistentMosaicInpainter::inpaint (method) cv::videostab::ConsistentMosaicInpainter . inpaint
// Arg ARG Primitive(int) idx= Primitive(int) = 
// Arg ARG cv::Mat (boxed) frame= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) mask= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_videostab_ConsistentMosaicInpainter_inpaint_int_idx_Mat_frame_Mat_mask(void* instance, int idx, void* frame, void* mask) {
    try {
        reinterpret_cast<cv::videostab::ConsistentMosaicInpainter*>(instance)->inpaint(idx, *reinterpret_cast<cv::Mat*>(frame), *reinterpret_cast<cv::Mat*>(mask));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_videostab_DeblurerBase_setRadius_int_val
// parsed: cv::videostab::DeblurerBase::setRadius
// as:     cv::videostab::DeblurerBase::setRadius (method) cv::videostab::DeblurerBase (trait) . setRadius
// Arg ARG Primitive(int) val= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_videostab_DeblurerBase_setRadius_int_val(void* instance, int val) {
    try {
        reinterpret_cast<cv::videostab::DeblurerBase*>(instance)->setRadius(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_videostab_DeblurerBase_radius_const
// parsed: cv::videostab::DeblurerBase::radius
// as:     cv::videostab::DeblurerBase::radius (method) cv::videostab::DeblurerBase (trait) . radius
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_videostab_DeblurerBase_radius_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::videostab::DeblurerBase*>(instance)->radius();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_videostab_DeblurerBase_deblur_int_idx_Mat_frame
// parsed: cv::videostab::DeblurerBase::deblur
// as:     cv::videostab::DeblurerBase::deblur (method) cv::videostab::DeblurerBase (trait) . deblur
// Arg ARG Primitive(int) idx= Primitive(int) = 
// Arg ARG cv::Mat (boxed) frame= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_videostab_DeblurerBase_deblur_int_idx_Mat_frame(void* instance, int idx, void* frame) {
    try {
        reinterpret_cast<cv::videostab::DeblurerBase*>(instance)->deblur(idx, *reinterpret_cast<cv::Mat*>(frame));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_videostab_DeblurerBase_setFrames_VectorOfMat_val
// parsed: cv::videostab::DeblurerBase::setFrames
// as:     cv::videostab::DeblurerBase::setFrames (method) cv::videostab::DeblurerBase (trait) . setFrames
// Arg ARG Vector[cv::Mat (boxed)] val= Vector[cv::Mat (boxed)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_videostab_DeblurerBase_setFrames_VectorOfMat_val(void* instance, void* val) {
    try {
        reinterpret_cast<cv::videostab::DeblurerBase*>(instance)->setFrames(*reinterpret_cast<std::vector<cv::Mat>*>(val));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_videostab_DeblurerBase_frames_const
// parsed: cv::videostab::DeblurerBase::frames
// as:     cv::videostab::DeblurerBase::frames (method) cv::videostab::DeblurerBase (trait) . frames
// Return value: Vector[cv::Mat (boxed)]
cv_return_value_void_X cv_core_cv_videostab_DeblurerBase_frames_const(void* instance) {
    try {
        std::vector<cv::Mat> ret = reinterpret_cast<cv::videostab::DeblurerBase*>(instance)->frames();
        return { Error::Code::StsOk, NULL, (void *)new std::vector<cv::Mat>(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_videostab_DeblurerBase_setMotions_VectorOfMat_val
// parsed: cv::videostab::DeblurerBase::setMotions
// as:     cv::videostab::DeblurerBase::setMotions (method) cv::videostab::DeblurerBase (trait) . setMotions
// Arg ARG Vector[cv::Mat (boxed)] val= Vector[cv::Mat (boxed)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_videostab_DeblurerBase_setMotions_VectorOfMat_val(void* instance, void* val) {
    try {
        reinterpret_cast<cv::videostab::DeblurerBase*>(instance)->setMotions(*reinterpret_cast<std::vector<cv::Mat>*>(val));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_videostab_DeblurerBase_motions_const
// parsed: cv::videostab::DeblurerBase::motions
// as:     cv::videostab::DeblurerBase::motions (method) cv::videostab::DeblurerBase (trait) . motions
// Return value: Vector[cv::Mat (boxed)]
cv_return_value_void_X cv_core_cv_videostab_DeblurerBase_motions_const(void* instance) {
    try {
        std::vector<cv::Mat> ret = reinterpret_cast<cv::videostab::DeblurerBase*>(instance)->motions();
        return { Error::Code::StsOk, NULL, (void *)new std::vector<cv::Mat>(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_videostab_DeblurerBase_setBlurrinessRates_VectorOffloat_val
// parsed: cv::videostab::DeblurerBase::setBlurrinessRates
// as:     cv::videostab::DeblurerBase::setBlurrinessRates (method) cv::videostab::DeblurerBase (trait) . setBlurrinessRates
// Arg ARG Vector[Primitive(float)] val= Vector[Primitive(float)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_videostab_DeblurerBase_setBlurrinessRates_VectorOffloat_val(void* instance, void* val) {
    try {
        reinterpret_cast<cv::videostab::DeblurerBase*>(instance)->setBlurrinessRates(*reinterpret_cast<std::vector<float>*>(val));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_videostab_DeblurerBase_blurrinessRates_const
// parsed: cv::videostab::DeblurerBase::blurrinessRates
// as:     cv::videostab::DeblurerBase::blurrinessRates (method) cv::videostab::DeblurerBase (trait) . blurrinessRates
// Return value: Vector[Primitive(float)]
cv_return_value_void_X cv_core_cv_videostab_DeblurerBase_blurrinessRates_const(void* instance) {
    try {
        std::vector<float> ret = reinterpret_cast<cv::videostab::DeblurerBase*>(instance)->blurrinessRates();
        return { Error::Code::StsOk, NULL, (void *)new std::vector<float>(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// boxed class: cv::videostab::FastMarchingMethod
void cv_delete_FastMarchingMethod(void* instance) {
    delete (cv::videostab::FastMarchingMethod*) instance;
}
// cv_videostab_FastMarchingMethod_distanceMap_const
// parsed: cv::videostab::FastMarchingMethod::distanceMap
// as:     cv::videostab::FastMarchingMethod::distanceMap (method) cv::videostab::FastMarchingMethod . distanceMap
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_videostab_FastMarchingMethod_distanceMap_const(void* instance) {
    try {
        cv::Mat ret = reinterpret_cast<cv::videostab::FastMarchingMethod*>(instance)->distanceMap();
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// boxed class: cv::videostab::FromFileMotionReader
void cv_delete_FromFileMotionReader(void* instance) {
    delete (cv::videostab::FromFileMotionReader*) instance;
}
// cv_videostab_FromFileMotionReader_FromFileMotionReader_String_path
// parsed: cv::videostab::FromFileMotionReader::FromFileMotionReader
// as:     cv::videostab::FromFileMotionReader::FromFileMotionReader (constructor) cv::videostab::FromFileMotionReader . new
// Arg ARG string path= string = 
// Return value: cv::videostab::FromFileMotionReader (boxed)
cv_return_value_void_X cv_core_cv_videostab_FromFileMotionReader_FromFileMotionReader_String_path(const char* path) {
    try {
        cv::videostab::FromFileMotionReader* ret = new cv::videostab::FromFileMotionReader(String(path));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_videostab_FromFileMotionReader_estimate_Mat_frame0_Mat_frame1_bool_X_ok
// parsed: cv::videostab::FromFileMotionReader::estimate
// as:     cv::videostab::FromFileMotionReader::estimate (method) cv::videostab::FromFileMotionReader . estimate
// Arg ARG cv::Mat (boxed) frame0= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) frame1= cv::Mat (boxed) = 
// Arg ARG RawPtr[Primitive(bool)] * ok= (ptr) RawPtr[Primitive(bool)] = 0
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_videostab_FromFileMotionReader_estimate_Mat_frame0_Mat_frame1_bool_X_ok(void* instance, void* frame0, void* frame1, bool* ok) {
    try {
        cv::Mat ret = reinterpret_cast<cv::videostab::FromFileMotionReader*>(instance)->estimate(*reinterpret_cast<cv::Mat*>(frame0), *reinterpret_cast<cv::Mat*>(frame1), ok);
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// boxed class: cv::videostab::GaussianMotionFilter
void cv_delete_GaussianMotionFilter(void* instance) {
    delete (cv::videostab::GaussianMotionFilter*) instance;
}
// cv_videostab_GaussianMotionFilter_GaussianMotionFilter_int_radius_float_stdev
// parsed: cv::videostab::GaussianMotionFilter::GaussianMotionFilter
// as:     cv::videostab::GaussianMotionFilter::GaussianMotionFilter (constructor) cv::videostab::GaussianMotionFilter . new
// Arg ARG Primitive(int) radius= Primitive(int) = 15
// Arg ARG Primitive(float) stdev= Primitive(float) = -1.f
// Return value: cv::videostab::GaussianMotionFilter (boxed)
cv_return_value_void_X cv_core_cv_videostab_GaussianMotionFilter_GaussianMotionFilter_int_radius_float_stdev(int radius, float stdev) {
    try {
        cv::videostab::GaussianMotionFilter* ret = new cv::videostab::GaussianMotionFilter(radius, stdev);
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_videostab_GaussianMotionFilter_setParams_int_radius_float_stdev
// parsed: cv::videostab::GaussianMotionFilter::setParams
// as:     cv::videostab::GaussianMotionFilter::setParams (method) cv::videostab::GaussianMotionFilter . setParams
// Arg ARG Primitive(int) radius= Primitive(int) = 
// Arg ARG Primitive(float) stdev= Primitive(float) = -1.f
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_videostab_GaussianMotionFilter_setParams_int_radius_float_stdev(void* instance, int radius, float stdev) {
    try {
        reinterpret_cast<cv::videostab::GaussianMotionFilter*>(instance)->setParams(radius, stdev);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_videostab_GaussianMotionFilter_radius_const
// parsed: cv::videostab::GaussianMotionFilter::radius
// as:     cv::videostab::GaussianMotionFilter::radius (method) cv::videostab::GaussianMotionFilter . radius
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_videostab_GaussianMotionFilter_radius_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::videostab::GaussianMotionFilter*>(instance)->radius();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_videostab_GaussianMotionFilter_stdev_const
// parsed: cv::videostab::GaussianMotionFilter::stdev
// as:     cv::videostab::GaussianMotionFilter::stdev (method) cv::videostab::GaussianMotionFilter . stdev
// Return value: Primitive(float)
cv_return_value_float cv_core_cv_videostab_GaussianMotionFilter_stdev_const(void* instance) {
    try {
        float ret = reinterpret_cast<cv::videostab::GaussianMotionFilter*>(instance)->stdev();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<float*>(&ret) };
    } CVRS_CATCH(cv_return_value_float)
}

// cv_videostab_GaussianMotionFilter_GaussianMotionFilter_int__radius_float__stdev
// parsed: cv::videostab::GaussianMotionFilter::GaussianMotionFilter
// as:     cv::videostab::GaussianMotionFilter::GaussianMotionFilter (constructor) cv::videostab::GaussianMotionFilter . new
// Arg ARG Primitive(int) _radius= Primitive(int) = 
// Arg ARG Primitive(float) _stdev= Primitive(float) = 
// Return value: cv::videostab::GaussianMotionFilter (boxed)
cv_return_value_void_X cv_core_cv_videostab_GaussianMotionFilter_GaussianMotionFilter_int__radius_float__stdev(int _radius, float _stdev) {
    try {
        cv::videostab::GaussianMotionFilter* ret = new cv::videostab::GaussianMotionFilter(_radius, _stdev);
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_videostab_IDenseOptFlowEstimator_run_Mat_frame0_Mat_frame1_Mat_flowX_Mat_flowY_Mat_errors
// parsed: cv::videostab::IDenseOptFlowEstimator::run
// as:     cv::videostab::IDenseOptFlowEstimator::run (method) cv::videostab::IDenseOptFlowEstimator (trait) . run
// Arg ARG cv::Mat (boxed) frame0= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) frame1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) flowX= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) flowY= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) errors= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_videostab_IDenseOptFlowEstimator_run_Mat_frame0_Mat_frame1_Mat_flowX_Mat_flowY_Mat_errors(void* instance, void* frame0, void* frame1, void* flowX, void* flowY, void* errors) {
    try {
        reinterpret_cast<cv::videostab::IDenseOptFlowEstimator*>(instance)->run(*reinterpret_cast<cv::Mat*>(frame0), *reinterpret_cast<cv::Mat*>(frame1), *reinterpret_cast<cv::Mat*>(flowX), *reinterpret_cast<cv::Mat*>(flowY), *reinterpret_cast<cv::Mat*>(errors));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_videostab_IFrameSource_reset
// parsed: cv::videostab::IFrameSource::reset
// as:     cv::videostab::IFrameSource::reset (method) cv::videostab::IFrameSource (trait) . reset
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_videostab_IFrameSource_reset(void* instance) {
    try {
        reinterpret_cast<cv::videostab::IFrameSource*>(instance)->reset();
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_videostab_IFrameSource_nextFrame
// parsed: cv::videostab::IFrameSource::nextFrame
// as:     cv::videostab::IFrameSource::nextFrame (method) cv::videostab::IFrameSource (trait) . nextFrame
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_videostab_IFrameSource_nextFrame(void* instance) {
    try {
        cv::Mat ret = reinterpret_cast<cv::videostab::IFrameSource*>(instance)->nextFrame();
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_videostab_IOutlierRejector_process_Size_frameSize_Mat_points0_Mat_points1_Mat_mask
// parsed: cv::videostab::IOutlierRejector::process
// as:     cv::videostab::IOutlierRejector::process (method) cv::videostab::IOutlierRejector (trait) . process
// Arg ARG cv::Size (simple) frameSize= cv::Size (simple) = 
// Arg ARG cv::Mat (boxed) points0= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) points1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) mask= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_videostab_IOutlierRejector_process_Size_frameSize_Mat_points0_Mat_points1_Mat_mask(void* instance, SizeWrapper frameSize, void* points0, void* points1, void* mask) {
    try {
        reinterpret_cast<cv::videostab::IOutlierRejector*>(instance)->process(*reinterpret_cast<cv::Size*>(&frameSize), *reinterpret_cast<cv::Mat*>(points0), *reinterpret_cast<cv::Mat*>(points1), *reinterpret_cast<cv::Mat*>(mask));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_videostab_ISparseOptFlowEstimator_run_Mat_frame0_Mat_frame1_Mat_points0_Mat_points1_Mat_status_Mat_errors
// parsed: cv::videostab::ISparseOptFlowEstimator::run
// as:     cv::videostab::ISparseOptFlowEstimator::run (method) cv::videostab::ISparseOptFlowEstimator (trait) . run
// Arg ARG cv::Mat (boxed) frame0= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) frame1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) points0= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) points1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) status= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) errors= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_videostab_ISparseOptFlowEstimator_run_Mat_frame0_Mat_frame1_Mat_points0_Mat_points1_Mat_status_Mat_errors(void* instance, void* frame0, void* frame1, void* points0, void* points1, void* status, void* errors) {
    try {
        reinterpret_cast<cv::videostab::ISparseOptFlowEstimator*>(instance)->run(*reinterpret_cast<cv::Mat*>(frame0), *reinterpret_cast<cv::Mat*>(frame1), *reinterpret_cast<cv::Mat*>(points0), *reinterpret_cast<cv::Mat*>(points1), *reinterpret_cast<cv::Mat*>(status), *reinterpret_cast<cv::Mat*>(errors));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_videostab_ImageMotionEstimatorBase_estimate_Mat_frame0_Mat_frame1_bool_X_ok
// parsed: cv::videostab::ImageMotionEstimatorBase::estimate
// as:     cv::videostab::ImageMotionEstimatorBase::estimate (method) cv::videostab::ImageMotionEstimatorBase (trait) . estimate
// Arg ARG cv::Mat (boxed) frame0= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) frame1= cv::Mat (boxed) = 
// Arg ARG RawPtr[Primitive(bool)] * ok= (ptr) RawPtr[Primitive(bool)] = 0
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_videostab_ImageMotionEstimatorBase_estimate_Mat_frame0_Mat_frame1_bool_X_ok(void* instance, void* frame0, void* frame1, bool* ok) {
    try {
        cv::Mat ret = reinterpret_cast<cv::videostab::ImageMotionEstimatorBase*>(instance)->estimate(*reinterpret_cast<cv::Mat*>(frame0), *reinterpret_cast<cv::Mat*>(frame1), ok);
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_videostab_InpainterBase_setRadius_int_val
// parsed: cv::videostab::InpainterBase::setRadius
// as:     cv::videostab::InpainterBase::setRadius (method) cv::videostab::InpainterBase (trait) . setRadius
// Arg ARG Primitive(int) val= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_videostab_InpainterBase_setRadius_int_val(void* instance, int val) {
    try {
        reinterpret_cast<cv::videostab::InpainterBase*>(instance)->setRadius(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_videostab_InpainterBase_radius_const
// parsed: cv::videostab::InpainterBase::radius
// as:     cv::videostab::InpainterBase::radius (method) cv::videostab::InpainterBase (trait) . radius
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_videostab_InpainterBase_radius_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::videostab::InpainterBase*>(instance)->radius();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_videostab_InpainterBase_inpaint_int_idx_Mat_frame_Mat_mask
// parsed: cv::videostab::InpainterBase::inpaint
// as:     cv::videostab::InpainterBase::inpaint (method) cv::videostab::InpainterBase (trait) . inpaint
// Arg ARG Primitive(int) idx= Primitive(int) = 
// Arg ARG cv::Mat (boxed) frame= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) mask= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_videostab_InpainterBase_inpaint_int_idx_Mat_frame_Mat_mask(void* instance, int idx, void* frame, void* mask) {
    try {
        reinterpret_cast<cv::videostab::InpainterBase*>(instance)->inpaint(idx, *reinterpret_cast<cv::Mat*>(frame), *reinterpret_cast<cv::Mat*>(mask));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_videostab_InpainterBase_setFrames_VectorOfMat_val
// parsed: cv::videostab::InpainterBase::setFrames
// as:     cv::videostab::InpainterBase::setFrames (method) cv::videostab::InpainterBase (trait) . setFrames
// Arg ARG Vector[cv::Mat (boxed)] val= Vector[cv::Mat (boxed)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_videostab_InpainterBase_setFrames_VectorOfMat_val(void* instance, void* val) {
    try {
        reinterpret_cast<cv::videostab::InpainterBase*>(instance)->setFrames(*reinterpret_cast<std::vector<cv::Mat>*>(val));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_videostab_InpainterBase_frames_const
// parsed: cv::videostab::InpainterBase::frames
// as:     cv::videostab::InpainterBase::frames (method) cv::videostab::InpainterBase (trait) . frames
// Return value: Vector[cv::Mat (boxed)]
cv_return_value_void_X cv_core_cv_videostab_InpainterBase_frames_const(void* instance) {
    try {
        std::vector<cv::Mat> ret = reinterpret_cast<cv::videostab::InpainterBase*>(instance)->frames();
        return { Error::Code::StsOk, NULL, (void *)new std::vector<cv::Mat>(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_videostab_InpainterBase_setMotions_VectorOfMat_val
// parsed: cv::videostab::InpainterBase::setMotions
// as:     cv::videostab::InpainterBase::setMotions (method) cv::videostab::InpainterBase (trait) . setMotions
// Arg ARG Vector[cv::Mat (boxed)] val= Vector[cv::Mat (boxed)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_videostab_InpainterBase_setMotions_VectorOfMat_val(void* instance, void* val) {
    try {
        reinterpret_cast<cv::videostab::InpainterBase*>(instance)->setMotions(*reinterpret_cast<std::vector<cv::Mat>*>(val));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_videostab_InpainterBase_motions_const
// parsed: cv::videostab::InpainterBase::motions
// as:     cv::videostab::InpainterBase::motions (method) cv::videostab::InpainterBase (trait) . motions
// Return value: Vector[cv::Mat (boxed)]
cv_return_value_void_X cv_core_cv_videostab_InpainterBase_motions_const(void* instance) {
    try {
        std::vector<cv::Mat> ret = reinterpret_cast<cv::videostab::InpainterBase*>(instance)->motions();
        return { Error::Code::StsOk, NULL, (void *)new std::vector<cv::Mat>(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_videostab_InpainterBase_setStabilizedFrames_VectorOfMat_val
// parsed: cv::videostab::InpainterBase::setStabilizedFrames
// as:     cv::videostab::InpainterBase::setStabilizedFrames (method) cv::videostab::InpainterBase (trait) . setStabilizedFrames
// Arg ARG Vector[cv::Mat (boxed)] val= Vector[cv::Mat (boxed)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_videostab_InpainterBase_setStabilizedFrames_VectorOfMat_val(void* instance, void* val) {
    try {
        reinterpret_cast<cv::videostab::InpainterBase*>(instance)->setStabilizedFrames(*reinterpret_cast<std::vector<cv::Mat>*>(val));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_videostab_InpainterBase_stabilizedFrames_const
// parsed: cv::videostab::InpainterBase::stabilizedFrames
// as:     cv::videostab::InpainterBase::stabilizedFrames (method) cv::videostab::InpainterBase (trait) . stabilizedFrames
// Return value: Vector[cv::Mat (boxed)]
cv_return_value_void_X cv_core_cv_videostab_InpainterBase_stabilizedFrames_const(void* instance) {
    try {
        std::vector<cv::Mat> ret = reinterpret_cast<cv::videostab::InpainterBase*>(instance)->stabilizedFrames();
        return { Error::Code::StsOk, NULL, (void *)new std::vector<cv::Mat>(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_videostab_InpainterBase_setStabilizationMotions_VectorOfMat_val
// parsed: cv::videostab::InpainterBase::setStabilizationMotions
// as:     cv::videostab::InpainterBase::setStabilizationMotions (method) cv::videostab::InpainterBase (trait) . setStabilizationMotions
// Arg ARG Vector[cv::Mat (boxed)] val= Vector[cv::Mat (boxed)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_videostab_InpainterBase_setStabilizationMotions_VectorOfMat_val(void* instance, void* val) {
    try {
        reinterpret_cast<cv::videostab::InpainterBase*>(instance)->setStabilizationMotions(*reinterpret_cast<std::vector<cv::Mat>*>(val));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_videostab_InpainterBase_stabilizationMotions_const
// parsed: cv::videostab::InpainterBase::stabilizationMotions
// as:     cv::videostab::InpainterBase::stabilizationMotions (method) cv::videostab::InpainterBase (trait) . stabilizationMotions
// Return value: Vector[cv::Mat (boxed)]
cv_return_value_void_X cv_core_cv_videostab_InpainterBase_stabilizationMotions_const(void* instance) {
    try {
        std::vector<cv::Mat> ret = reinterpret_cast<cv::videostab::InpainterBase*>(instance)->stabilizationMotions();
        return { Error::Code::StsOk, NULL, (void *)new std::vector<cv::Mat>(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// boxed class: cv::videostab::InpaintingPipeline
void cv_delete_InpaintingPipeline(void* instance) {
    delete (cv::videostab::InpaintingPipeline*) instance;
}
// cv_videostab_InpaintingPipeline_pushBack_PtrOfInpainterBase_inpainter
// parsed: cv::videostab::InpaintingPipeline::pushBack
// as:     cv::videostab::InpaintingPipeline::pushBack (method) cv::videostab::InpaintingPipeline . pushBack
// Arg ARG SmartPtr[cv::videostab::InpainterBase (boxed)] inpainter= SmartPtr[cv::videostab::InpainterBase (boxed)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_videostab_InpaintingPipeline_pushBack_PtrOfInpainterBase_inpainter(void* instance, void* inpainter) {
    try {
        reinterpret_cast<cv::videostab::InpaintingPipeline*>(instance)->pushBack(reinterpret_cast<cv::videostab::InpainterBase*>(inpainter));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_videostab_InpaintingPipeline_empty_const
// parsed: cv::videostab::InpaintingPipeline::empty
// as:     cv::videostab::InpaintingPipeline::empty (method) cv::videostab::InpaintingPipeline . empty
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_videostab_InpaintingPipeline_empty_const(void* instance) {
    try {
        bool ret = reinterpret_cast<cv::videostab::InpaintingPipeline*>(instance)->empty();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_videostab_InpaintingPipeline_setRadius_int_val
// parsed: cv::videostab::InpaintingPipeline::setRadius
// as:     cv::videostab::InpaintingPipeline::setRadius (method) cv::videostab::InpaintingPipeline . setRadius
// Arg ARG Primitive(int) val= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_videostab_InpaintingPipeline_setRadius_int_val(void* instance, int val) {
    try {
        reinterpret_cast<cv::videostab::InpaintingPipeline*>(instance)->setRadius(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_videostab_InpaintingPipeline_setFrames_VectorOfMat_val
// parsed: cv::videostab::InpaintingPipeline::setFrames
// as:     cv::videostab::InpaintingPipeline::setFrames (method) cv::videostab::InpaintingPipeline . setFrames
// Arg ARG Vector[cv::Mat (boxed)] val= Vector[cv::Mat (boxed)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_videostab_InpaintingPipeline_setFrames_VectorOfMat_val(void* instance, void* val) {
    try {
        reinterpret_cast<cv::videostab::InpaintingPipeline*>(instance)->setFrames(*reinterpret_cast<std::vector<cv::Mat>*>(val));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_videostab_InpaintingPipeline_setMotions_VectorOfMat_val
// parsed: cv::videostab::InpaintingPipeline::setMotions
// as:     cv::videostab::InpaintingPipeline::setMotions (method) cv::videostab::InpaintingPipeline . setMotions
// Arg ARG Vector[cv::Mat (boxed)] val= Vector[cv::Mat (boxed)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_videostab_InpaintingPipeline_setMotions_VectorOfMat_val(void* instance, void* val) {
    try {
        reinterpret_cast<cv::videostab::InpaintingPipeline*>(instance)->setMotions(*reinterpret_cast<std::vector<cv::Mat>*>(val));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_videostab_InpaintingPipeline_setStabilizedFrames_VectorOfMat_val
// parsed: cv::videostab::InpaintingPipeline::setStabilizedFrames
// as:     cv::videostab::InpaintingPipeline::setStabilizedFrames (method) cv::videostab::InpaintingPipeline . setStabilizedFrames
// Arg ARG Vector[cv::Mat (boxed)] val= Vector[cv::Mat (boxed)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_videostab_InpaintingPipeline_setStabilizedFrames_VectorOfMat_val(void* instance, void* val) {
    try {
        reinterpret_cast<cv::videostab::InpaintingPipeline*>(instance)->setStabilizedFrames(*reinterpret_cast<std::vector<cv::Mat>*>(val));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_videostab_InpaintingPipeline_setStabilizationMotions_VectorOfMat_val
// parsed: cv::videostab::InpaintingPipeline::setStabilizationMotions
// as:     cv::videostab::InpaintingPipeline::setStabilizationMotions (method) cv::videostab::InpaintingPipeline . setStabilizationMotions
// Arg ARG Vector[cv::Mat (boxed)] val= Vector[cv::Mat (boxed)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_videostab_InpaintingPipeline_setStabilizationMotions_VectorOfMat_val(void* instance, void* val) {
    try {
        reinterpret_cast<cv::videostab::InpaintingPipeline*>(instance)->setStabilizationMotions(*reinterpret_cast<std::vector<cv::Mat>*>(val));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_videostab_InpaintingPipeline_inpaint_int_idx_Mat_frame_Mat_mask
// parsed: cv::videostab::InpaintingPipeline::inpaint
// as:     cv::videostab::InpaintingPipeline::inpaint (method) cv::videostab::InpaintingPipeline . inpaint
// Arg ARG Primitive(int) idx= Primitive(int) = 
// Arg ARG cv::Mat (boxed) frame= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) mask= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_videostab_InpaintingPipeline_inpaint_int_idx_Mat_frame_Mat_mask(void* instance, int idx, void* frame, void* mask) {
    try {
        reinterpret_cast<cv::videostab::InpaintingPipeline*>(instance)->inpaint(idx, *reinterpret_cast<cv::Mat*>(frame), *reinterpret_cast<cv::Mat*>(mask));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// boxed class: cv::videostab::KeypointBasedMotionEstimator
void cv_delete_KeypointBasedMotionEstimator(void* instance) {
    delete (cv::videostab::KeypointBasedMotionEstimator*) instance;
}
// cv_videostab_KeypointBasedMotionEstimator_KeypointBasedMotionEstimator_PtrOfMotionEstimatorBase_estimator
// parsed: cv::videostab::KeypointBasedMotionEstimator::KeypointBasedMotionEstimator
// as:     cv::videostab::KeypointBasedMotionEstimator::KeypointBasedMotionEstimator (constructor) cv::videostab::KeypointBasedMotionEstimator . new
// Arg ARG SmartPtr[cv::videostab::MotionEstimatorBase (boxed)] estimator= SmartPtr[cv::videostab::MotionEstimatorBase (boxed)] = 
// Return value: cv::videostab::KeypointBasedMotionEstimator (boxed)
cv_return_value_void_X cv_core_cv_videostab_KeypointBasedMotionEstimator_KeypointBasedMotionEstimator_PtrOfMotionEstimatorBase_estimator(void* estimator) {
    try {
        cv::videostab::KeypointBasedMotionEstimator* ret = new cv::videostab::KeypointBasedMotionEstimator(reinterpret_cast<cv::videostab::MotionEstimatorBase*>(estimator));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_videostab_KeypointBasedMotionEstimator_setDetector_PtrOfFeature2D_val
// parsed: cv::videostab::KeypointBasedMotionEstimator::setDetector
// as:     cv::videostab::KeypointBasedMotionEstimator::setDetector (method) cv::videostab::KeypointBasedMotionEstimator . setDetector
// Arg ARG SmartPtr[cv::Feature2D (boxed)] val= SmartPtr[cv::Feature2D (boxed)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_videostab_KeypointBasedMotionEstimator_setDetector_PtrOfFeature2D_val(void* instance, void* val) {
    try {
        reinterpret_cast<cv::videostab::KeypointBasedMotionEstimator*>(instance)->setDetector(reinterpret_cast<cv::Feature2D*>(val));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_videostab_KeypointBasedMotionEstimator_detector_const
// parsed: cv::videostab::KeypointBasedMotionEstimator::detector
// as:     cv::videostab::KeypointBasedMotionEstimator::detector (method) cv::videostab::KeypointBasedMotionEstimator . detector
// Return value: SmartPtr[cv::Feature2D (boxed)]
cv_return_value_void_X cv_core_cv_videostab_KeypointBasedMotionEstimator_detector_const(void* instance) {
    try {
        Ptr<cv::Feature2D> *ret = new Ptr<cv::Feature2D>(reinterpret_cast<cv::videostab::KeypointBasedMotionEstimator*>(instance)->detector());
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_videostab_KeypointBasedMotionEstimator_estimate_Mat_frame0_Mat_frame1_bool_X_ok
// parsed: cv::videostab::KeypointBasedMotionEstimator::estimate
// as:     cv::videostab::KeypointBasedMotionEstimator::estimate (method) cv::videostab::KeypointBasedMotionEstimator . estimate
// Arg ARG cv::Mat (boxed) frame0= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) frame1= cv::Mat (boxed) = 
// Arg ARG RawPtr[Primitive(bool)] * ok= (ptr) RawPtr[Primitive(bool)] = 0
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_videostab_KeypointBasedMotionEstimator_estimate_Mat_frame0_Mat_frame1_bool_X_ok(void* instance, void* frame0, void* frame1, bool* ok) {
    try {
        cv::Mat ret = reinterpret_cast<cv::videostab::KeypointBasedMotionEstimator*>(instance)->estimate(*reinterpret_cast<cv::Mat*>(frame0), *reinterpret_cast<cv::Mat*>(frame1), ok);
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// boxed class: cv::videostab::LogToStdout
void cv_delete_LogToStdout(void* instance) {
    delete (cv::videostab::LogToStdout*) instance;
}
// boxed class: cv::videostab::LpMotionStabilizer
void cv_delete_LpMotionStabilizer(void* instance) {
    delete (cv::videostab::LpMotionStabilizer*) instance;
}
// cv_videostab_LpMotionStabilizer_setFrameSize_Size_val
// parsed: cv::videostab::LpMotionStabilizer::setFrameSize
// as:     cv::videostab::LpMotionStabilizer::setFrameSize (method) cv::videostab::LpMotionStabilizer . setFrameSize
// Arg ARG cv::Size (simple) val= cv::Size (simple) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_videostab_LpMotionStabilizer_setFrameSize_Size_val(void* instance, SizeWrapper val) {
    try {
        reinterpret_cast<cv::videostab::LpMotionStabilizer*>(instance)->setFrameSize(*reinterpret_cast<cv::Size*>(&val));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_videostab_LpMotionStabilizer_frameSize_const
// parsed: cv::videostab::LpMotionStabilizer::frameSize
// as:     cv::videostab::LpMotionStabilizer::frameSize (method) cv::videostab::LpMotionStabilizer . frameSize
// Return value: cv::Size (simple)
cv_return_value_SizeWrapper cv_core_cv_videostab_LpMotionStabilizer_frameSize_const(void* instance) {
    try {
        cv::Size ret = reinterpret_cast<cv::videostab::LpMotionStabilizer*>(instance)->frameSize();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<SizeWrapper*>(&ret) };
    } CVRS_CATCH(cv_return_value_SizeWrapper)
}

// cv_videostab_LpMotionStabilizer_setTrimRatio_float_val
// parsed: cv::videostab::LpMotionStabilizer::setTrimRatio
// as:     cv::videostab::LpMotionStabilizer::setTrimRatio (method) cv::videostab::LpMotionStabilizer . setTrimRatio
// Arg ARG Primitive(float) val= Primitive(float) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_videostab_LpMotionStabilizer_setTrimRatio_float_val(void* instance, float val) {
    try {
        reinterpret_cast<cv::videostab::LpMotionStabilizer*>(instance)->setTrimRatio(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_videostab_LpMotionStabilizer_trimRatio_const
// parsed: cv::videostab::LpMotionStabilizer::trimRatio
// as:     cv::videostab::LpMotionStabilizer::trimRatio (method) cv::videostab::LpMotionStabilizer . trimRatio
// Return value: Primitive(float)
cv_return_value_float cv_core_cv_videostab_LpMotionStabilizer_trimRatio_const(void* instance) {
    try {
        float ret = reinterpret_cast<cv::videostab::LpMotionStabilizer*>(instance)->trimRatio();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<float*>(&ret) };
    } CVRS_CATCH(cv_return_value_float)
}

// cv_videostab_LpMotionStabilizer_setWeight1_float_val
// parsed: cv::videostab::LpMotionStabilizer::setWeight1
// as:     cv::videostab::LpMotionStabilizer::setWeight1 (method) cv::videostab::LpMotionStabilizer . setWeight1
// Arg ARG Primitive(float) val= Primitive(float) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_videostab_LpMotionStabilizer_setWeight1_float_val(void* instance, float val) {
    try {
        reinterpret_cast<cv::videostab::LpMotionStabilizer*>(instance)->setWeight1(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_videostab_LpMotionStabilizer_weight1_const
// parsed: cv::videostab::LpMotionStabilizer::weight1
// as:     cv::videostab::LpMotionStabilizer::weight1 (method) cv::videostab::LpMotionStabilizer . weight1
// Return value: Primitive(float)
cv_return_value_float cv_core_cv_videostab_LpMotionStabilizer_weight1_const(void* instance) {
    try {
        float ret = reinterpret_cast<cv::videostab::LpMotionStabilizer*>(instance)->weight1();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<float*>(&ret) };
    } CVRS_CATCH(cv_return_value_float)
}

// cv_videostab_LpMotionStabilizer_setWeight2_float_val
// parsed: cv::videostab::LpMotionStabilizer::setWeight2
// as:     cv::videostab::LpMotionStabilizer::setWeight2 (method) cv::videostab::LpMotionStabilizer . setWeight2
// Arg ARG Primitive(float) val= Primitive(float) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_videostab_LpMotionStabilizer_setWeight2_float_val(void* instance, float val) {
    try {
        reinterpret_cast<cv::videostab::LpMotionStabilizer*>(instance)->setWeight2(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_videostab_LpMotionStabilizer_weight2_const
// parsed: cv::videostab::LpMotionStabilizer::weight2
// as:     cv::videostab::LpMotionStabilizer::weight2 (method) cv::videostab::LpMotionStabilizer . weight2
// Return value: Primitive(float)
cv_return_value_float cv_core_cv_videostab_LpMotionStabilizer_weight2_const(void* instance) {
    try {
        float ret = reinterpret_cast<cv::videostab::LpMotionStabilizer*>(instance)->weight2();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<float*>(&ret) };
    } CVRS_CATCH(cv_return_value_float)
}

// cv_videostab_LpMotionStabilizer_setWeight3_float_val
// parsed: cv::videostab::LpMotionStabilizer::setWeight3
// as:     cv::videostab::LpMotionStabilizer::setWeight3 (method) cv::videostab::LpMotionStabilizer . setWeight3
// Arg ARG Primitive(float) val= Primitive(float) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_videostab_LpMotionStabilizer_setWeight3_float_val(void* instance, float val) {
    try {
        reinterpret_cast<cv::videostab::LpMotionStabilizer*>(instance)->setWeight3(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_videostab_LpMotionStabilizer_weight3_const
// parsed: cv::videostab::LpMotionStabilizer::weight3
// as:     cv::videostab::LpMotionStabilizer::weight3 (method) cv::videostab::LpMotionStabilizer . weight3
// Return value: Primitive(float)
cv_return_value_float cv_core_cv_videostab_LpMotionStabilizer_weight3_const(void* instance) {
    try {
        float ret = reinterpret_cast<cv::videostab::LpMotionStabilizer*>(instance)->weight3();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<float*>(&ret) };
    } CVRS_CATCH(cv_return_value_float)
}

// cv_videostab_LpMotionStabilizer_setWeight4_float_val
// parsed: cv::videostab::LpMotionStabilizer::setWeight4
// as:     cv::videostab::LpMotionStabilizer::setWeight4 (method) cv::videostab::LpMotionStabilizer . setWeight4
// Arg ARG Primitive(float) val= Primitive(float) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_videostab_LpMotionStabilizer_setWeight4_float_val(void* instance, float val) {
    try {
        reinterpret_cast<cv::videostab::LpMotionStabilizer*>(instance)->setWeight4(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_videostab_LpMotionStabilizer_weight4_const
// parsed: cv::videostab::LpMotionStabilizer::weight4
// as:     cv::videostab::LpMotionStabilizer::weight4 (method) cv::videostab::LpMotionStabilizer . weight4
// Return value: Primitive(float)
cv_return_value_float cv_core_cv_videostab_LpMotionStabilizer_weight4_const(void* instance) {
    try {
        float ret = reinterpret_cast<cv::videostab::LpMotionStabilizer*>(instance)->weight4();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<float*>(&ret) };
    } CVRS_CATCH(cv_return_value_float)
}

// boxed class: cv::videostab::MoreAccurateMotionWobbleSuppressor
void cv_delete_MoreAccurateMotionWobbleSuppressor(void* instance) {
    delete (cv::videostab::MoreAccurateMotionWobbleSuppressor*) instance;
}
// cv_videostab_MoreAccurateMotionWobbleSuppressor_suppress_int_idx_Mat_frame_Mat_result
// parsed: cv::videostab::MoreAccurateMotionWobbleSuppressor::suppress
// as:     cv::videostab::MoreAccurateMotionWobbleSuppressor::suppress (method) cv::videostab::MoreAccurateMotionWobbleSuppressor . suppress
// Arg ARG Primitive(int) idx= Primitive(int) = 
// Arg ARG cv::Mat (boxed) frame= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) result= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_videostab_MoreAccurateMotionWobbleSuppressor_suppress_int_idx_Mat_frame_Mat_result(void* instance, int idx, void* frame, void* result) {
    try {
        reinterpret_cast<cv::videostab::MoreAccurateMotionWobbleSuppressor*>(instance)->suppress(idx, *reinterpret_cast<cv::Mat*>(frame), *reinterpret_cast<cv::Mat*>(result));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_videostab_MoreAccurateMotionWobbleSuppressorBase_setPeriod_int_val
// parsed: cv::videostab::MoreAccurateMotionWobbleSuppressorBase::setPeriod
// as:     cv::videostab::MoreAccurateMotionWobbleSuppressorBase::setPeriod (method) cv::videostab::MoreAccurateMotionWobbleSuppressorBase (trait) . setPeriod
// Arg ARG Primitive(int) val= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_videostab_MoreAccurateMotionWobbleSuppressorBase_setPeriod_int_val(void* instance, int val) {
    try {
        reinterpret_cast<cv::videostab::MoreAccurateMotionWobbleSuppressorBase*>(instance)->setPeriod(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_videostab_MoreAccurateMotionWobbleSuppressorBase_period_const
// parsed: cv::videostab::MoreAccurateMotionWobbleSuppressorBase::period
// as:     cv::videostab::MoreAccurateMotionWobbleSuppressorBase::period (method) cv::videostab::MoreAccurateMotionWobbleSuppressorBase (trait) . period
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_videostab_MoreAccurateMotionWobbleSuppressorBase_period_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::videostab::MoreAccurateMotionWobbleSuppressorBase*>(instance)->period();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_videostab_MotionEstimatorBase_estimate_Mat_points0_Mat_points1_bool_X_ok
// parsed: cv::videostab::MotionEstimatorBase::estimate
// as:     cv::videostab::MotionEstimatorBase::estimate (method) cv::videostab::MotionEstimatorBase (trait) . estimate
// Arg ARG cv::Mat (boxed) points0= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) points1= cv::Mat (boxed) = 
// Arg ARG RawPtr[Primitive(bool)] * ok= (ptr) RawPtr[Primitive(bool)] = 0
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_videostab_MotionEstimatorBase_estimate_Mat_points0_Mat_points1_bool_X_ok(void* instance, void* points0, void* points1, bool* ok) {
    try {
        cv::Mat ret = reinterpret_cast<cv::videostab::MotionEstimatorBase*>(instance)->estimate(*reinterpret_cast<cv::Mat*>(points0), *reinterpret_cast<cv::Mat*>(points1), ok);
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// boxed class: cv::videostab::MotionEstimatorL1
void cv_delete_MotionEstimatorL1(void* instance) {
    delete (cv::videostab::MotionEstimatorL1*) instance;
}
// cv_videostab_MotionEstimatorL1_estimate_Mat_points0_Mat_points1_bool_X_ok
// parsed: cv::videostab::MotionEstimatorL1::estimate
// as:     cv::videostab::MotionEstimatorL1::estimate (method) cv::videostab::MotionEstimatorL1 . estimate
// Arg ARG cv::Mat (boxed) points0= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) points1= cv::Mat (boxed) = 
// Arg ARG RawPtr[Primitive(bool)] * ok= (ptr) RawPtr[Primitive(bool)] = 0
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_videostab_MotionEstimatorL1_estimate_Mat_points0_Mat_points1_bool_X_ok(void* instance, void* points0, void* points1, bool* ok) {
    try {
        cv::Mat ret = reinterpret_cast<cv::videostab::MotionEstimatorL1*>(instance)->estimate(*reinterpret_cast<cv::Mat*>(points0), *reinterpret_cast<cv::Mat*>(points1), ok);
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// boxed class: cv::videostab::MotionEstimatorRansacL2
void cv_delete_MotionEstimatorRansacL2(void* instance) {
    delete (cv::videostab::MotionEstimatorRansacL2*) instance;
}
// cv_videostab_MotionEstimatorRansacL2_setMinInlierRatio_float_val
// parsed: cv::videostab::MotionEstimatorRansacL2::setMinInlierRatio
// as:     cv::videostab::MotionEstimatorRansacL2::setMinInlierRatio (method) cv::videostab::MotionEstimatorRansacL2 . setMinInlierRatio
// Arg ARG Primitive(float) val= Primitive(float) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_videostab_MotionEstimatorRansacL2_setMinInlierRatio_float_val(void* instance, float val) {
    try {
        reinterpret_cast<cv::videostab::MotionEstimatorRansacL2*>(instance)->setMinInlierRatio(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_videostab_MotionEstimatorRansacL2_minInlierRatio_const
// parsed: cv::videostab::MotionEstimatorRansacL2::minInlierRatio
// as:     cv::videostab::MotionEstimatorRansacL2::minInlierRatio (method) cv::videostab::MotionEstimatorRansacL2 . minInlierRatio
// Return value: Primitive(float)
cv_return_value_float cv_core_cv_videostab_MotionEstimatorRansacL2_minInlierRatio_const(void* instance) {
    try {
        float ret = reinterpret_cast<cv::videostab::MotionEstimatorRansacL2*>(instance)->minInlierRatio();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<float*>(&ret) };
    } CVRS_CATCH(cv_return_value_float)
}

// cv_videostab_MotionEstimatorRansacL2_estimate_Mat_points0_Mat_points1_bool_X_ok
// parsed: cv::videostab::MotionEstimatorRansacL2::estimate
// as:     cv::videostab::MotionEstimatorRansacL2::estimate (method) cv::videostab::MotionEstimatorRansacL2 . estimate
// Arg ARG cv::Mat (boxed) points0= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) points1= cv::Mat (boxed) = 
// Arg ARG RawPtr[Primitive(bool)] * ok= (ptr) RawPtr[Primitive(bool)] = 0
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_videostab_MotionEstimatorRansacL2_estimate_Mat_points0_Mat_points1_bool_X_ok(void* instance, void* points0, void* points1, bool* ok) {
    try {
        cv::Mat ret = reinterpret_cast<cv::videostab::MotionEstimatorRansacL2*>(instance)->estimate(*reinterpret_cast<cv::Mat*>(points0), *reinterpret_cast<cv::Mat*>(points1), ok);
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// boxed class: cv::videostab::MotionInpainter
void cv_delete_MotionInpainter(void* instance) {
    delete (cv::videostab::MotionInpainter*) instance;
}
// cv_videostab_MotionInpainter_MotionInpainter
// parsed: cv::videostab::MotionInpainter::MotionInpainter
// as:     cv::videostab::MotionInpainter::MotionInpainter (constructor) cv::videostab::MotionInpainter . new
// Return value: cv::videostab::MotionInpainter (boxed)
cv_return_value_void_X cv_core_cv_videostab_MotionInpainter_MotionInpainter() {
    try {
        cv::videostab::MotionInpainter* ret = new cv::videostab::MotionInpainter();
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_videostab_MotionInpainter_setFlowErrorThreshold_float_val
// parsed: cv::videostab::MotionInpainter::setFlowErrorThreshold
// as:     cv::videostab::MotionInpainter::setFlowErrorThreshold (method) cv::videostab::MotionInpainter . setFlowErrorThreshold
// Arg ARG Primitive(float) val= Primitive(float) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_videostab_MotionInpainter_setFlowErrorThreshold_float_val(void* instance, float val) {
    try {
        reinterpret_cast<cv::videostab::MotionInpainter*>(instance)->setFlowErrorThreshold(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_videostab_MotionInpainter_flowErrorThreshold_const
// parsed: cv::videostab::MotionInpainter::flowErrorThreshold
// as:     cv::videostab::MotionInpainter::flowErrorThreshold (method) cv::videostab::MotionInpainter . flowErrorThreshold
// Return value: Primitive(float)
cv_return_value_float cv_core_cv_videostab_MotionInpainter_flowErrorThreshold_const(void* instance) {
    try {
        float ret = reinterpret_cast<cv::videostab::MotionInpainter*>(instance)->flowErrorThreshold();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<float*>(&ret) };
    } CVRS_CATCH(cv_return_value_float)
}

// cv_videostab_MotionInpainter_setDistThreshold_float_val
// parsed: cv::videostab::MotionInpainter::setDistThreshold
// as:     cv::videostab::MotionInpainter::setDistThreshold (method) cv::videostab::MotionInpainter . setDistThreshold
// Arg ARG Primitive(float) val= Primitive(float) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_videostab_MotionInpainter_setDistThreshold_float_val(void* instance, float val) {
    try {
        reinterpret_cast<cv::videostab::MotionInpainter*>(instance)->setDistThreshold(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_videostab_MotionInpainter_distThresh_const
// parsed: cv::videostab::MotionInpainter::distThresh
// as:     cv::videostab::MotionInpainter::distThresh (method) cv::videostab::MotionInpainter . distThresh
// Return value: Primitive(float)
cv_return_value_float cv_core_cv_videostab_MotionInpainter_distThresh_const(void* instance) {
    try {
        float ret = reinterpret_cast<cv::videostab::MotionInpainter*>(instance)->distThresh();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<float*>(&ret) };
    } CVRS_CATCH(cv_return_value_float)
}

// cv_videostab_MotionInpainter_setBorderMode_int_val
// parsed: cv::videostab::MotionInpainter::setBorderMode
// as:     cv::videostab::MotionInpainter::setBorderMode (method) cv::videostab::MotionInpainter . setBorderMode
// Arg ARG Primitive(int) val= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_videostab_MotionInpainter_setBorderMode_int_val(void* instance, int val) {
    try {
        reinterpret_cast<cv::videostab::MotionInpainter*>(instance)->setBorderMode(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_videostab_MotionInpainter_borderMode_const
// parsed: cv::videostab::MotionInpainter::borderMode
// as:     cv::videostab::MotionInpainter::borderMode (method) cv::videostab::MotionInpainter . borderMode
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_videostab_MotionInpainter_borderMode_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::videostab::MotionInpainter*>(instance)->borderMode();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_videostab_MotionInpainter_inpaint_int_idx_Mat_frame_Mat_mask
// parsed: cv::videostab::MotionInpainter::inpaint
// as:     cv::videostab::MotionInpainter::inpaint (method) cv::videostab::MotionInpainter . inpaint
// Arg ARG Primitive(int) idx= Primitive(int) = 
// Arg ARG cv::Mat (boxed) frame= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) mask= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_videostab_MotionInpainter_inpaint_int_idx_Mat_frame_Mat_mask(void* instance, int idx, void* frame, void* mask) {
    try {
        reinterpret_cast<cv::videostab::MotionInpainter*>(instance)->inpaint(idx, *reinterpret_cast<cv::Mat*>(frame), *reinterpret_cast<cv::Mat*>(mask));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// boxed class: cv::videostab::MotionStabilizationPipeline
void cv_delete_MotionStabilizationPipeline(void* instance) {
    delete (cv::videostab::MotionStabilizationPipeline*) instance;
}
// cv_videostab_MotionStabilizationPipeline_pushBack_PtrOfIMotionStabilizer_stabilizer
// parsed: cv::videostab::MotionStabilizationPipeline::pushBack
// as:     cv::videostab::MotionStabilizationPipeline::pushBack (method) cv::videostab::MotionStabilizationPipeline . pushBack
// Arg ARG SmartPtr[cv::videostab::IMotionStabilizer (boxed)] stabilizer= SmartPtr[cv::videostab::IMotionStabilizer (boxed)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_videostab_MotionStabilizationPipeline_pushBack_PtrOfIMotionStabilizer_stabilizer(void* instance, void* stabilizer) {
    try {
        reinterpret_cast<cv::videostab::MotionStabilizationPipeline*>(instance)->pushBack(reinterpret_cast<cv::videostab::IMotionStabilizer*>(stabilizer));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_videostab_MotionStabilizationPipeline_empty_const
// parsed: cv::videostab::MotionStabilizationPipeline::empty
// as:     cv::videostab::MotionStabilizationPipeline::empty (method) cv::videostab::MotionStabilizationPipeline . empty
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_videostab_MotionStabilizationPipeline_empty_const(void* instance) {
    try {
        bool ret = reinterpret_cast<cv::videostab::MotionStabilizationPipeline*>(instance)->empty();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// boxed class: cv::videostab::NullDeblurer
void cv_delete_NullDeblurer(void* instance) {
    delete (cv::videostab::NullDeblurer*) instance;
}
// cv_videostab_NullDeblurer_deblur_int_unnamed_arg_Mat_unnamed_arg_1
// parsed: cv::videostab::NullDeblurer::deblur
// as:     cv::videostab::NullDeblurer::deblur (method) cv::videostab::NullDeblurer . deblur
// Arg ARG Primitive(int) unnamed_arg= Primitive(int) = 
// Arg ARG cv::Mat (boxed) unnamed_arg_1= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_videostab_NullDeblurer_deblur_int_unnamed_arg_Mat_unnamed_arg_1(void* instance, int unnamed_arg, void* unnamed_arg_1) {
    try {
        reinterpret_cast<cv::videostab::NullDeblurer*>(instance)->deblur(unnamed_arg, *reinterpret_cast<cv::Mat*>(unnamed_arg_1));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// boxed class: cv::videostab::NullFrameSource
void cv_delete_NullFrameSource(void* instance) {
    delete (cv::videostab::NullFrameSource*) instance;
}
// cv_videostab_NullFrameSource_reset
// parsed: cv::videostab::NullFrameSource::reset
// as:     cv::videostab::NullFrameSource::reset (method) cv::videostab::NullFrameSource . reset
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_videostab_NullFrameSource_reset(void* instance) {
    try {
        reinterpret_cast<cv::videostab::NullFrameSource*>(instance)->reset();
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_videostab_NullFrameSource_nextFrame
// parsed: cv::videostab::NullFrameSource::nextFrame
// as:     cv::videostab::NullFrameSource::nextFrame (method) cv::videostab::NullFrameSource . nextFrame
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_videostab_NullFrameSource_nextFrame(void* instance) {
    try {
        cv::Mat ret = reinterpret_cast<cv::videostab::NullFrameSource*>(instance)->nextFrame();
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// boxed class: cv::videostab::NullInpainter
void cv_delete_NullInpainter(void* instance) {
    delete (cv::videostab::NullInpainter*) instance;
}
// cv_videostab_NullInpainter_inpaint_int_unnamed_arg_Mat_unnamed_arg_1_Mat_unnamed_arg_2
// parsed: cv::videostab::NullInpainter::inpaint
// as:     cv::videostab::NullInpainter::inpaint (method) cv::videostab::NullInpainter . inpaint
// Arg ARG Primitive(int) unnamed_arg= Primitive(int) = 
// Arg ARG cv::Mat (boxed) unnamed_arg_1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) unnamed_arg_2= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_videostab_NullInpainter_inpaint_int_unnamed_arg_Mat_unnamed_arg_1_Mat_unnamed_arg_2(void* instance, int unnamed_arg, void* unnamed_arg_1, void* unnamed_arg_2) {
    try {
        reinterpret_cast<cv::videostab::NullInpainter*>(instance)->inpaint(unnamed_arg, *reinterpret_cast<cv::Mat*>(unnamed_arg_1), *reinterpret_cast<cv::Mat*>(unnamed_arg_2));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// boxed class: cv::videostab::NullLog
void cv_delete_NullLog(void* instance) {
    delete (cv::videostab::NullLog*) instance;
}
// boxed class: cv::videostab::NullOutlierRejector
void cv_delete_NullOutlierRejector(void* instance) {
    delete (cv::videostab::NullOutlierRejector*) instance;
}
// cv_videostab_NullOutlierRejector_process_Size_frameSize_Mat_points0_Mat_points1_Mat_mask
// parsed: cv::videostab::NullOutlierRejector::process
// as:     cv::videostab::NullOutlierRejector::process (method) cv::videostab::NullOutlierRejector . process
// Arg ARG cv::Size (simple) frameSize= cv::Size (simple) = 
// Arg ARG cv::Mat (boxed) points0= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) points1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) mask= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_videostab_NullOutlierRejector_process_Size_frameSize_Mat_points0_Mat_points1_Mat_mask(void* instance, SizeWrapper frameSize, void* points0, void* points1, void* mask) {
    try {
        reinterpret_cast<cv::videostab::NullOutlierRejector*>(instance)->process(*reinterpret_cast<cv::Size*>(&frameSize), *reinterpret_cast<cv::Mat*>(points0), *reinterpret_cast<cv::Mat*>(points1), *reinterpret_cast<cv::Mat*>(mask));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// boxed class: cv::videostab::NullWobbleSuppressor
void cv_delete_NullWobbleSuppressor(void* instance) {
    delete (cv::videostab::NullWobbleSuppressor*) instance;
}
// cv_videostab_NullWobbleSuppressor_suppress_int_idx_Mat_frame_Mat_result
// parsed: cv::videostab::NullWobbleSuppressor::suppress
// as:     cv::videostab::NullWobbleSuppressor::suppress (method) cv::videostab::NullWobbleSuppressor . suppress
// Arg ARG Primitive(int) idx= Primitive(int) = 
// Arg ARG cv::Mat (boxed) frame= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) result= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_videostab_NullWobbleSuppressor_suppress_int_idx_Mat_frame_Mat_result(void* instance, int idx, void* frame, void* result) {
    try {
        reinterpret_cast<cv::videostab::NullWobbleSuppressor*>(instance)->suppress(idx, *reinterpret_cast<cv::Mat*>(frame), *reinterpret_cast<cv::Mat*>(result));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// boxed class: cv::videostab::OnePassStabilizer
void cv_delete_OnePassStabilizer(void* instance) {
    delete (cv::videostab::OnePassStabilizer*) instance;
}
// cv_videostab_OnePassStabilizer_OnePassStabilizer
// parsed: cv::videostab::OnePassStabilizer::OnePassStabilizer
// as:     cv::videostab::OnePassStabilizer::OnePassStabilizer (constructor) cv::videostab::OnePassStabilizer . new
// Return value: cv::videostab::OnePassStabilizer (boxed)
cv_return_value_void_X cv_core_cv_videostab_OnePassStabilizer_OnePassStabilizer() {
    try {
        cv::videostab::OnePassStabilizer* ret = new cv::videostab::OnePassStabilizer();
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_videostab_OnePassStabilizer_setMotionFilter_PtrOfMotionFilterBase_val
// parsed: cv::videostab::OnePassStabilizer::setMotionFilter
// as:     cv::videostab::OnePassStabilizer::setMotionFilter (method) cv::videostab::OnePassStabilizer . setMotionFilter
// Arg ARG SmartPtr[cv::videostab::MotionFilterBase (boxed)] val= SmartPtr[cv::videostab::MotionFilterBase (boxed)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_videostab_OnePassStabilizer_setMotionFilter_PtrOfMotionFilterBase_val(void* instance, void* val) {
    try {
        reinterpret_cast<cv::videostab::OnePassStabilizer*>(instance)->setMotionFilter(reinterpret_cast<cv::videostab::MotionFilterBase*>(val));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_videostab_OnePassStabilizer_motionFilter_const
// parsed: cv::videostab::OnePassStabilizer::motionFilter
// as:     cv::videostab::OnePassStabilizer::motionFilter (method) cv::videostab::OnePassStabilizer . motionFilter
// Return value: SmartPtr[cv::videostab::MotionFilterBase (boxed)]
cv_return_value_void_X cv_core_cv_videostab_OnePassStabilizer_motionFilter_const(void* instance) {
    try {
        Ptr<cv::videostab::MotionFilterBase> *ret = new Ptr<cv::videostab::MotionFilterBase>(reinterpret_cast<cv::videostab::OnePassStabilizer*>(instance)->motionFilter());
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_videostab_OnePassStabilizer_reset
// parsed: cv::videostab::OnePassStabilizer::reset
// as:     cv::videostab::OnePassStabilizer::reset (method) cv::videostab::OnePassStabilizer . reset
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_videostab_OnePassStabilizer_reset(void* instance) {
    try {
        reinterpret_cast<cv::videostab::OnePassStabilizer*>(instance)->reset();
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_videostab_OnePassStabilizer_nextFrame
// parsed: cv::videostab::OnePassStabilizer::nextFrame
// as:     cv::videostab::OnePassStabilizer::nextFrame (method) cv::videostab::OnePassStabilizer . nextFrame
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_videostab_OnePassStabilizer_nextFrame(void* instance) {
    try {
        cv::Mat ret = reinterpret_cast<cv::videostab::OnePassStabilizer*>(instance)->nextFrame();
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_videostab_PyrLkOptFlowEstimatorBase_setWinSize_Size_val
// parsed: cv::videostab::PyrLkOptFlowEstimatorBase::setWinSize
// as:     cv::videostab::PyrLkOptFlowEstimatorBase::setWinSize (method) cv::videostab::PyrLkOptFlowEstimatorBase (trait) . setWinSize
// Arg ARG cv::Size (simple) val= cv::Size (simple) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_videostab_PyrLkOptFlowEstimatorBase_setWinSize_Size_val(void* instance, SizeWrapper val) {
    try {
        reinterpret_cast<cv::videostab::PyrLkOptFlowEstimatorBase*>(instance)->setWinSize(*reinterpret_cast<cv::Size*>(&val));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_videostab_PyrLkOptFlowEstimatorBase_winSize_const
// parsed: cv::videostab::PyrLkOptFlowEstimatorBase::winSize
// as:     cv::videostab::PyrLkOptFlowEstimatorBase::winSize (method) cv::videostab::PyrLkOptFlowEstimatorBase (trait) . winSize
// Return value: cv::Size (simple)
cv_return_value_SizeWrapper cv_core_cv_videostab_PyrLkOptFlowEstimatorBase_winSize_const(void* instance) {
    try {
        cv::Size ret = reinterpret_cast<cv::videostab::PyrLkOptFlowEstimatorBase*>(instance)->winSize();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<SizeWrapper*>(&ret) };
    } CVRS_CATCH(cv_return_value_SizeWrapper)
}

// cv_videostab_PyrLkOptFlowEstimatorBase_setMaxLevel_int_val
// parsed: cv::videostab::PyrLkOptFlowEstimatorBase::setMaxLevel
// as:     cv::videostab::PyrLkOptFlowEstimatorBase::setMaxLevel (method) cv::videostab::PyrLkOptFlowEstimatorBase (trait) . setMaxLevel
// Arg ARG Primitive(int) val= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_videostab_PyrLkOptFlowEstimatorBase_setMaxLevel_int_val(void* instance, int val) {
    try {
        reinterpret_cast<cv::videostab::PyrLkOptFlowEstimatorBase*>(instance)->setMaxLevel(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_videostab_PyrLkOptFlowEstimatorBase_maxLevel_const
// parsed: cv::videostab::PyrLkOptFlowEstimatorBase::maxLevel
// as:     cv::videostab::PyrLkOptFlowEstimatorBase::maxLevel (method) cv::videostab::PyrLkOptFlowEstimatorBase (trait) . maxLevel
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_videostab_PyrLkOptFlowEstimatorBase_maxLevel_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::videostab::PyrLkOptFlowEstimatorBase*>(instance)->maxLevel();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// boxed class: cv::videostab::RansacParams
void cv_delete_RansacParams(void* instance) {
    delete (cv::videostab::RansacParams*) instance;
}
// cv_videostab_RansacParams_niters_const
// parsed: cv::videostab::RansacParams::niters
// as:     cv::videostab::RansacParams::niters (method) cv::videostab::RansacParams . niters
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_videostab_RansacParams_niters_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::videostab::RansacParams*>(instance)->niters();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// boxed class: cv::videostab::SparsePyrLkOptFlowEstimator
void cv_delete_SparsePyrLkOptFlowEstimator(void* instance) {
    delete (cv::videostab::SparsePyrLkOptFlowEstimator*) instance;
}
// cv_videostab_SparsePyrLkOptFlowEstimator_run_Mat_frame0_Mat_frame1_Mat_points0_Mat_points1_Mat_status_Mat_errors
// parsed: cv::videostab::SparsePyrLkOptFlowEstimator::run
// as:     cv::videostab::SparsePyrLkOptFlowEstimator::run (method) cv::videostab::SparsePyrLkOptFlowEstimator . run
// Arg ARG cv::Mat (boxed) frame0= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) frame1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) points0= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) points1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) status= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) errors= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_videostab_SparsePyrLkOptFlowEstimator_run_Mat_frame0_Mat_frame1_Mat_points0_Mat_points1_Mat_status_Mat_errors(void* instance, void* frame0, void* frame1, void* points0, void* points1, void* status, void* errors) {
    try {
        reinterpret_cast<cv::videostab::SparsePyrLkOptFlowEstimator*>(instance)->run(*reinterpret_cast<cv::Mat*>(frame0), *reinterpret_cast<cv::Mat*>(frame1), *reinterpret_cast<cv::Mat*>(points0), *reinterpret_cast<cv::Mat*>(points1), *reinterpret_cast<cv::Mat*>(status), *reinterpret_cast<cv::Mat*>(errors));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_videostab_StabilizerBase_setLog_PtrOfILog_ilog
// parsed: cv::videostab::StabilizerBase::setLog
// as:     cv::videostab::StabilizerBase::setLog (method) cv::videostab::StabilizerBase (trait) . setLog
// Arg ARG SmartPtr[cv::videostab::ILog (boxed)] ilog= SmartPtr[cv::videostab::ILog (boxed)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_videostab_StabilizerBase_setLog_PtrOfILog_ilog(void* instance, void* ilog) {
    try {
        reinterpret_cast<cv::videostab::StabilizerBase*>(instance)->setLog(reinterpret_cast<cv::videostab::ILog*>(ilog));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_videostab_StabilizerBase_log_const
// parsed: cv::videostab::StabilizerBase::log
// as:     cv::videostab::StabilizerBase::log (method) cv::videostab::StabilizerBase (trait) . log
// Return value: SmartPtr[cv::videostab::ILog (boxed)]
cv_return_value_void_X cv_core_cv_videostab_StabilizerBase_log_const(void* instance) {
    try {
        Ptr<cv::videostab::ILog> *ret = new Ptr<cv::videostab::ILog>(reinterpret_cast<cv::videostab::StabilizerBase*>(instance)->log());
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_videostab_StabilizerBase_setRadius_int_val
// parsed: cv::videostab::StabilizerBase::setRadius
// as:     cv::videostab::StabilizerBase::setRadius (method) cv::videostab::StabilizerBase (trait) . setRadius
// Arg ARG Primitive(int) val= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_videostab_StabilizerBase_setRadius_int_val(void* instance, int val) {
    try {
        reinterpret_cast<cv::videostab::StabilizerBase*>(instance)->setRadius(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_videostab_StabilizerBase_radius_const
// parsed: cv::videostab::StabilizerBase::radius
// as:     cv::videostab::StabilizerBase::radius (method) cv::videostab::StabilizerBase (trait) . radius
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_videostab_StabilizerBase_radius_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::videostab::StabilizerBase*>(instance)->radius();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_videostab_StabilizerBase_setFrameSource_PtrOfIFrameSource_val
// parsed: cv::videostab::StabilizerBase::setFrameSource
// as:     cv::videostab::StabilizerBase::setFrameSource (method) cv::videostab::StabilizerBase (trait) . setFrameSource
// Arg ARG SmartPtr[cv::videostab::IFrameSource (boxed)] val= SmartPtr[cv::videostab::IFrameSource (boxed)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_videostab_StabilizerBase_setFrameSource_PtrOfIFrameSource_val(void* instance, void* val) {
    try {
        reinterpret_cast<cv::videostab::StabilizerBase*>(instance)->setFrameSource(reinterpret_cast<cv::videostab::IFrameSource*>(val));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_videostab_StabilizerBase_frameSource_const
// parsed: cv::videostab::StabilizerBase::frameSource
// as:     cv::videostab::StabilizerBase::frameSource (method) cv::videostab::StabilizerBase (trait) . frameSource
// Return value: SmartPtr[cv::videostab::IFrameSource (boxed)]
cv_return_value_void_X cv_core_cv_videostab_StabilizerBase_frameSource_const(void* instance) {
    try {
        Ptr<cv::videostab::IFrameSource> *ret = new Ptr<cv::videostab::IFrameSource>(reinterpret_cast<cv::videostab::StabilizerBase*>(instance)->frameSource());
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_videostab_StabilizerBase_setMotionEstimator_PtrOfImageMotionEstimatorBase_val
// parsed: cv::videostab::StabilizerBase::setMotionEstimator
// as:     cv::videostab::StabilizerBase::setMotionEstimator (method) cv::videostab::StabilizerBase (trait) . setMotionEstimator
// Arg ARG SmartPtr[cv::videostab::ImageMotionEstimatorBase (boxed)] val= SmartPtr[cv::videostab::ImageMotionEstimatorBase (boxed)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_videostab_StabilizerBase_setMotionEstimator_PtrOfImageMotionEstimatorBase_val(void* instance, void* val) {
    try {
        reinterpret_cast<cv::videostab::StabilizerBase*>(instance)->setMotionEstimator(reinterpret_cast<cv::videostab::ImageMotionEstimatorBase*>(val));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_videostab_StabilizerBase_motionEstimator_const
// parsed: cv::videostab::StabilizerBase::motionEstimator
// as:     cv::videostab::StabilizerBase::motionEstimator (method) cv::videostab::StabilizerBase (trait) . motionEstimator
// Return value: SmartPtr[cv::videostab::ImageMotionEstimatorBase (boxed)]
cv_return_value_void_X cv_core_cv_videostab_StabilizerBase_motionEstimator_const(void* instance) {
    try {
        Ptr<cv::videostab::ImageMotionEstimatorBase> *ret = new Ptr<cv::videostab::ImageMotionEstimatorBase>(reinterpret_cast<cv::videostab::StabilizerBase*>(instance)->motionEstimator());
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_videostab_StabilizerBase_setDeblurer_PtrOfDeblurerBase_val
// parsed: cv::videostab::StabilizerBase::setDeblurer
// as:     cv::videostab::StabilizerBase::setDeblurer (method) cv::videostab::StabilizerBase (trait) . setDeblurer
// Arg ARG SmartPtr[cv::videostab::DeblurerBase (boxed)] val= SmartPtr[cv::videostab::DeblurerBase (boxed)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_videostab_StabilizerBase_setDeblurer_PtrOfDeblurerBase_val(void* instance, void* val) {
    try {
        reinterpret_cast<cv::videostab::StabilizerBase*>(instance)->setDeblurer(reinterpret_cast<cv::videostab::DeblurerBase*>(val));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_videostab_StabilizerBase_deblurrer_const
// parsed: cv::videostab::StabilizerBase::deblurrer
// as:     cv::videostab::StabilizerBase::deblurrer (method) cv::videostab::StabilizerBase (trait) . deblurrer
// Return value: SmartPtr[cv::videostab::DeblurerBase (boxed)]
cv_return_value_void_X cv_core_cv_videostab_StabilizerBase_deblurrer_const(void* instance) {
    try {
        Ptr<cv::videostab::DeblurerBase> *ret = new Ptr<cv::videostab::DeblurerBase>(reinterpret_cast<cv::videostab::StabilizerBase*>(instance)->deblurrer());
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_videostab_StabilizerBase_setTrimRatio_float_val
// parsed: cv::videostab::StabilizerBase::setTrimRatio
// as:     cv::videostab::StabilizerBase::setTrimRatio (method) cv::videostab::StabilizerBase (trait) . setTrimRatio
// Arg ARG Primitive(float) val= Primitive(float) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_videostab_StabilizerBase_setTrimRatio_float_val(void* instance, float val) {
    try {
        reinterpret_cast<cv::videostab::StabilizerBase*>(instance)->setTrimRatio(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_videostab_StabilizerBase_trimRatio_const
// parsed: cv::videostab::StabilizerBase::trimRatio
// as:     cv::videostab::StabilizerBase::trimRatio (method) cv::videostab::StabilizerBase (trait) . trimRatio
// Return value: Primitive(float)
cv_return_value_float cv_core_cv_videostab_StabilizerBase_trimRatio_const(void* instance) {
    try {
        float ret = reinterpret_cast<cv::videostab::StabilizerBase*>(instance)->trimRatio();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<float*>(&ret) };
    } CVRS_CATCH(cv_return_value_float)
}

// cv_videostab_StabilizerBase_setCorrectionForInclusion_bool_val
// parsed: cv::videostab::StabilizerBase::setCorrectionForInclusion
// as:     cv::videostab::StabilizerBase::setCorrectionForInclusion (method) cv::videostab::StabilizerBase (trait) . setCorrectionForInclusion
// Arg ARG Primitive(bool) val= Primitive(bool) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_videostab_StabilizerBase_setCorrectionForInclusion_bool_val(void* instance, bool val) {
    try {
        reinterpret_cast<cv::videostab::StabilizerBase*>(instance)->setCorrectionForInclusion(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_videostab_StabilizerBase_doCorrectionForInclusion_const
// parsed: cv::videostab::StabilizerBase::doCorrectionForInclusion
// as:     cv::videostab::StabilizerBase::doCorrectionForInclusion (method) cv::videostab::StabilizerBase (trait) . doCorrectionForInclusion
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_videostab_StabilizerBase_doCorrectionForInclusion_const(void* instance) {
    try {
        bool ret = reinterpret_cast<cv::videostab::StabilizerBase*>(instance)->doCorrectionForInclusion();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_videostab_StabilizerBase_setBorderMode_int_val
// parsed: cv::videostab::StabilizerBase::setBorderMode
// as:     cv::videostab::StabilizerBase::setBorderMode (method) cv::videostab::StabilizerBase (trait) . setBorderMode
// Arg ARG Primitive(int) val= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_videostab_StabilizerBase_setBorderMode_int_val(void* instance, int val) {
    try {
        reinterpret_cast<cv::videostab::StabilizerBase*>(instance)->setBorderMode(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_videostab_StabilizerBase_borderMode_const
// parsed: cv::videostab::StabilizerBase::borderMode
// as:     cv::videostab::StabilizerBase::borderMode (method) cv::videostab::StabilizerBase (trait) . borderMode
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_videostab_StabilizerBase_borderMode_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::videostab::StabilizerBase*>(instance)->borderMode();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_videostab_StabilizerBase_setInpainter_PtrOfInpainterBase_val
// parsed: cv::videostab::StabilizerBase::setInpainter
// as:     cv::videostab::StabilizerBase::setInpainter (method) cv::videostab::StabilizerBase (trait) . setInpainter
// Arg ARG SmartPtr[cv::videostab::InpainterBase (boxed)] val= SmartPtr[cv::videostab::InpainterBase (boxed)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_videostab_StabilizerBase_setInpainter_PtrOfInpainterBase_val(void* instance, void* val) {
    try {
        reinterpret_cast<cv::videostab::StabilizerBase*>(instance)->setInpainter(reinterpret_cast<cv::videostab::InpainterBase*>(val));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_videostab_StabilizerBase_inpainter_const
// parsed: cv::videostab::StabilizerBase::inpainter
// as:     cv::videostab::StabilizerBase::inpainter (method) cv::videostab::StabilizerBase (trait) . inpainter
// Return value: SmartPtr[cv::videostab::InpainterBase (boxed)]
cv_return_value_void_X cv_core_cv_videostab_StabilizerBase_inpainter_const(void* instance) {
    try {
        Ptr<cv::videostab::InpainterBase> *ret = new Ptr<cv::videostab::InpainterBase>(reinterpret_cast<cv::videostab::StabilizerBase*>(instance)->inpainter());
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// boxed class: cv::videostab::ToFileMotionWriter
void cv_delete_ToFileMotionWriter(void* instance) {
    delete (cv::videostab::ToFileMotionWriter*) instance;
}
// cv_videostab_ToFileMotionWriter_ToFileMotionWriter_String_path_PtrOfImageMotionEstimatorBase_estimator
// parsed: cv::videostab::ToFileMotionWriter::ToFileMotionWriter
// as:     cv::videostab::ToFileMotionWriter::ToFileMotionWriter (constructor) cv::videostab::ToFileMotionWriter . new
// Arg ARG string path= string = 
// Arg ARG SmartPtr[cv::videostab::ImageMotionEstimatorBase (boxed)] estimator= SmartPtr[cv::videostab::ImageMotionEstimatorBase (boxed)] = 
// Return value: cv::videostab::ToFileMotionWriter (boxed)
cv_return_value_void_X cv_core_cv_videostab_ToFileMotionWriter_ToFileMotionWriter_String_path_PtrOfImageMotionEstimatorBase_estimator(const char* path, void* estimator) {
    try {
        cv::videostab::ToFileMotionWriter* ret = new cv::videostab::ToFileMotionWriter(String(path), reinterpret_cast<cv::videostab::ImageMotionEstimatorBase*>(estimator));
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_videostab_ToFileMotionWriter_estimate_Mat_frame0_Mat_frame1_bool_X_ok
// parsed: cv::videostab::ToFileMotionWriter::estimate
// as:     cv::videostab::ToFileMotionWriter::estimate (method) cv::videostab::ToFileMotionWriter . estimate
// Arg ARG cv::Mat (boxed) frame0= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) frame1= cv::Mat (boxed) = 
// Arg ARG RawPtr[Primitive(bool)] * ok= (ptr) RawPtr[Primitive(bool)] = 0
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_videostab_ToFileMotionWriter_estimate_Mat_frame0_Mat_frame1_bool_X_ok(void* instance, void* frame0, void* frame1, bool* ok) {
    try {
        cv::Mat ret = reinterpret_cast<cv::videostab::ToFileMotionWriter*>(instance)->estimate(*reinterpret_cast<cv::Mat*>(frame0), *reinterpret_cast<cv::Mat*>(frame1), ok);
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// boxed class: cv::videostab::TranslationBasedLocalOutlierRejector
void cv_delete_TranslationBasedLocalOutlierRejector(void* instance) {
    delete (cv::videostab::TranslationBasedLocalOutlierRejector*) instance;
}
// cv_videostab_TranslationBasedLocalOutlierRejector_TranslationBasedLocalOutlierRejector
// parsed: cv::videostab::TranslationBasedLocalOutlierRejector::TranslationBasedLocalOutlierRejector
// as:     cv::videostab::TranslationBasedLocalOutlierRejector::TranslationBasedLocalOutlierRejector (constructor) cv::videostab::TranslationBasedLocalOutlierRejector . new
// Return value: cv::videostab::TranslationBasedLocalOutlierRejector (boxed)
cv_return_value_void_X cv_core_cv_videostab_TranslationBasedLocalOutlierRejector_TranslationBasedLocalOutlierRejector() {
    try {
        cv::videostab::TranslationBasedLocalOutlierRejector* ret = new cv::videostab::TranslationBasedLocalOutlierRejector();
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_videostab_TranslationBasedLocalOutlierRejector_setCellSize_Size_val
// parsed: cv::videostab::TranslationBasedLocalOutlierRejector::setCellSize
// as:     cv::videostab::TranslationBasedLocalOutlierRejector::setCellSize (method) cv::videostab::TranslationBasedLocalOutlierRejector . setCellSize
// Arg ARG cv::Size (simple) val= cv::Size (simple) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_videostab_TranslationBasedLocalOutlierRejector_setCellSize_Size_val(void* instance, SizeWrapper val) {
    try {
        reinterpret_cast<cv::videostab::TranslationBasedLocalOutlierRejector*>(instance)->setCellSize(*reinterpret_cast<cv::Size*>(&val));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_videostab_TranslationBasedLocalOutlierRejector_cellSize_const
// parsed: cv::videostab::TranslationBasedLocalOutlierRejector::cellSize
// as:     cv::videostab::TranslationBasedLocalOutlierRejector::cellSize (method) cv::videostab::TranslationBasedLocalOutlierRejector . cellSize
// Return value: cv::Size (simple)
cv_return_value_SizeWrapper cv_core_cv_videostab_TranslationBasedLocalOutlierRejector_cellSize_const(void* instance) {
    try {
        cv::Size ret = reinterpret_cast<cv::videostab::TranslationBasedLocalOutlierRejector*>(instance)->cellSize();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<SizeWrapper*>(&ret) };
    } CVRS_CATCH(cv_return_value_SizeWrapper)
}

// cv_videostab_TranslationBasedLocalOutlierRejector_process_Size_frameSize_Mat_points0_Mat_points1_Mat_mask
// parsed: cv::videostab::TranslationBasedLocalOutlierRejector::process
// as:     cv::videostab::TranslationBasedLocalOutlierRejector::process (method) cv::videostab::TranslationBasedLocalOutlierRejector . process
// Arg ARG cv::Size (simple) frameSize= cv::Size (simple) = 
// Arg ARG cv::Mat (boxed) points0= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) points1= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) mask= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_videostab_TranslationBasedLocalOutlierRejector_process_Size_frameSize_Mat_points0_Mat_points1_Mat_mask(void* instance, SizeWrapper frameSize, void* points0, void* points1, void* mask) {
    try {
        reinterpret_cast<cv::videostab::TranslationBasedLocalOutlierRejector*>(instance)->process(*reinterpret_cast<cv::Size*>(&frameSize), *reinterpret_cast<cv::Mat*>(points0), *reinterpret_cast<cv::Mat*>(points1), *reinterpret_cast<cv::Mat*>(mask));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// boxed class: cv::videostab::TwoPassStabilizer
void cv_delete_TwoPassStabilizer(void* instance) {
    delete (cv::videostab::TwoPassStabilizer*) instance;
}
// cv_videostab_TwoPassStabilizer_TwoPassStabilizer
// parsed: cv::videostab::TwoPassStabilizer::TwoPassStabilizer
// as:     cv::videostab::TwoPassStabilizer::TwoPassStabilizer (constructor) cv::videostab::TwoPassStabilizer . new
// Return value: cv::videostab::TwoPassStabilizer (boxed)
cv_return_value_void_X cv_core_cv_videostab_TwoPassStabilizer_TwoPassStabilizer() {
    try {
        cv::videostab::TwoPassStabilizer* ret = new cv::videostab::TwoPassStabilizer();
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_videostab_TwoPassStabilizer_setMotionStabilizer_PtrOfIMotionStabilizer_val
// parsed: cv::videostab::TwoPassStabilizer::setMotionStabilizer
// as:     cv::videostab::TwoPassStabilizer::setMotionStabilizer (method) cv::videostab::TwoPassStabilizer . setMotionStabilizer
// Arg ARG SmartPtr[cv::videostab::IMotionStabilizer (boxed)] val= SmartPtr[cv::videostab::IMotionStabilizer (boxed)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_videostab_TwoPassStabilizer_setMotionStabilizer_PtrOfIMotionStabilizer_val(void* instance, void* val) {
    try {
        reinterpret_cast<cv::videostab::TwoPassStabilizer*>(instance)->setMotionStabilizer(reinterpret_cast<cv::videostab::IMotionStabilizer*>(val));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_videostab_TwoPassStabilizer_motionStabilizer_const
// parsed: cv::videostab::TwoPassStabilizer::motionStabilizer
// as:     cv::videostab::TwoPassStabilizer::motionStabilizer (method) cv::videostab::TwoPassStabilizer . motionStabilizer
// Return value: SmartPtr[cv::videostab::IMotionStabilizer (boxed)]
cv_return_value_void_X cv_core_cv_videostab_TwoPassStabilizer_motionStabilizer_const(void* instance) {
    try {
        Ptr<cv::videostab::IMotionStabilizer> *ret = new Ptr<cv::videostab::IMotionStabilizer>(reinterpret_cast<cv::videostab::TwoPassStabilizer*>(instance)->motionStabilizer());
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_videostab_TwoPassStabilizer_setEstimateTrimRatio_bool_val
// parsed: cv::videostab::TwoPassStabilizer::setEstimateTrimRatio
// as:     cv::videostab::TwoPassStabilizer::setEstimateTrimRatio (method) cv::videostab::TwoPassStabilizer . setEstimateTrimRatio
// Arg ARG Primitive(bool) val= Primitive(bool) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_videostab_TwoPassStabilizer_setEstimateTrimRatio_bool_val(void* instance, bool val) {
    try {
        reinterpret_cast<cv::videostab::TwoPassStabilizer*>(instance)->setEstimateTrimRatio(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_videostab_TwoPassStabilizer_mustEstimateTrimaRatio_const
// parsed: cv::videostab::TwoPassStabilizer::mustEstimateTrimaRatio
// as:     cv::videostab::TwoPassStabilizer::mustEstimateTrimaRatio (method) cv::videostab::TwoPassStabilizer . mustEstimateTrimaRatio
// Return value: Primitive(bool)
cv_return_value_bool cv_core_cv_videostab_TwoPassStabilizer_mustEstimateTrimaRatio_const(void* instance) {
    try {
        bool ret = reinterpret_cast<cv::videostab::TwoPassStabilizer*>(instance)->mustEstimateTrimaRatio();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<bool*>(&ret) };
    } CVRS_CATCH(cv_return_value_bool)
}

// cv_videostab_TwoPassStabilizer_reset
// parsed: cv::videostab::TwoPassStabilizer::reset
// as:     cv::videostab::TwoPassStabilizer::reset (method) cv::videostab::TwoPassStabilizer . reset
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_videostab_TwoPassStabilizer_reset(void* instance) {
    try {
        reinterpret_cast<cv::videostab::TwoPassStabilizer*>(instance)->reset();
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_videostab_TwoPassStabilizer_nextFrame
// parsed: cv::videostab::TwoPassStabilizer::nextFrame
// as:     cv::videostab::TwoPassStabilizer::nextFrame (method) cv::videostab::TwoPassStabilizer . nextFrame
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_videostab_TwoPassStabilizer_nextFrame(void* instance) {
    try {
        cv::Mat ret = reinterpret_cast<cv::videostab::TwoPassStabilizer*>(instance)->nextFrame();
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// boxed class: cv::videostab::VideoFileSource
void cv_delete_VideoFileSource(void* instance) {
    delete (cv::videostab::VideoFileSource*) instance;
}
// cv_videostab_VideoFileSource_VideoFileSource_String_path_bool_volatileFrame
// parsed: cv::videostab::VideoFileSource::VideoFileSource
// as:     cv::videostab::VideoFileSource::VideoFileSource (constructor) cv::videostab::VideoFileSource . new
// Arg ARG string path= string = 
// Arg ARG Primitive(bool) volatileFrame= Primitive(bool) = false
// Return value: cv::videostab::VideoFileSource (boxed)
cv_return_value_void_X cv_core_cv_videostab_VideoFileSource_VideoFileSource_String_path_bool_volatileFrame(const char* path, bool volatileFrame) {
    try {
        cv::videostab::VideoFileSource* ret = new cv::videostab::VideoFileSource(String(path), volatileFrame);
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_videostab_VideoFileSource_reset
// parsed: cv::videostab::VideoFileSource::reset
// as:     cv::videostab::VideoFileSource::reset (method) cv::videostab::VideoFileSource . reset
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_videostab_VideoFileSource_reset(void* instance) {
    try {
        reinterpret_cast<cv::videostab::VideoFileSource*>(instance)->reset();
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_videostab_VideoFileSource_nextFrame
// parsed: cv::videostab::VideoFileSource::nextFrame
// as:     cv::videostab::VideoFileSource::nextFrame (method) cv::videostab::VideoFileSource . nextFrame
// Return value: cv::Mat (boxed)
cv_return_value_void_X cv_core_cv_videostab_VideoFileSource_nextFrame(void* instance) {
    try {
        cv::Mat ret = reinterpret_cast<cv::videostab::VideoFileSource*>(instance)->nextFrame();
        return { Error::Code::StsOk, NULL, new cv::Mat(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_videostab_VideoFileSource_width
// parsed: cv::videostab::VideoFileSource::width
// as:     cv::videostab::VideoFileSource::width (method) cv::videostab::VideoFileSource . width
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_videostab_VideoFileSource_width(void* instance) {
    try {
        int ret = reinterpret_cast<cv::videostab::VideoFileSource*>(instance)->width();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_videostab_VideoFileSource_height
// parsed: cv::videostab::VideoFileSource::height
// as:     cv::videostab::VideoFileSource::height (method) cv::videostab::VideoFileSource . height
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_videostab_VideoFileSource_height(void* instance) {
    try {
        int ret = reinterpret_cast<cv::videostab::VideoFileSource*>(instance)->height();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_videostab_VideoFileSource_count
// parsed: cv::videostab::VideoFileSource::count
// as:     cv::videostab::VideoFileSource::count (method) cv::videostab::VideoFileSource . count
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_videostab_VideoFileSource_count(void* instance) {
    try {
        int ret = reinterpret_cast<cv::videostab::VideoFileSource*>(instance)->count();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_videostab_VideoFileSource_fps
// parsed: cv::videostab::VideoFileSource::fps
// as:     cv::videostab::VideoFileSource::fps (method) cv::videostab::VideoFileSource . fps
// Return value: Primitive(double)
cv_return_value_double cv_core_cv_videostab_VideoFileSource_fps(void* instance) {
    try {
        double ret = reinterpret_cast<cv::videostab::VideoFileSource*>(instance)->fps();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<double*>(&ret) };
    } CVRS_CATCH(cv_return_value_double)
}

// boxed class: cv::videostab::WeightingDeblurer
void cv_delete_WeightingDeblurer(void* instance) {
    delete (cv::videostab::WeightingDeblurer*) instance;
}
// cv_videostab_WeightingDeblurer_WeightingDeblurer
// parsed: cv::videostab::WeightingDeblurer::WeightingDeblurer
// as:     cv::videostab::WeightingDeblurer::WeightingDeblurer (constructor) cv::videostab::WeightingDeblurer . new
// Return value: cv::videostab::WeightingDeblurer (boxed)
cv_return_value_void_X cv_core_cv_videostab_WeightingDeblurer_WeightingDeblurer() {
    try {
        cv::videostab::WeightingDeblurer* ret = new cv::videostab::WeightingDeblurer();
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_videostab_WeightingDeblurer_setSensitivity_float_val
// parsed: cv::videostab::WeightingDeblurer::setSensitivity
// as:     cv::videostab::WeightingDeblurer::setSensitivity (method) cv::videostab::WeightingDeblurer . setSensitivity
// Arg ARG Primitive(float) val= Primitive(float) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_videostab_WeightingDeblurer_setSensitivity_float_val(void* instance, float val) {
    try {
        reinterpret_cast<cv::videostab::WeightingDeblurer*>(instance)->setSensitivity(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_videostab_WeightingDeblurer_sensitivity_const
// parsed: cv::videostab::WeightingDeblurer::sensitivity
// as:     cv::videostab::WeightingDeblurer::sensitivity (method) cv::videostab::WeightingDeblurer . sensitivity
// Return value: Primitive(float)
cv_return_value_float cv_core_cv_videostab_WeightingDeblurer_sensitivity_const(void* instance) {
    try {
        float ret = reinterpret_cast<cv::videostab::WeightingDeblurer*>(instance)->sensitivity();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<float*>(&ret) };
    } CVRS_CATCH(cv_return_value_float)
}

// cv_videostab_WeightingDeblurer_deblur_int_idx_Mat_frame
// parsed: cv::videostab::WeightingDeblurer::deblur
// as:     cv::videostab::WeightingDeblurer::deblur (method) cv::videostab::WeightingDeblurer . deblur
// Arg ARG Primitive(int) idx= Primitive(int) = 
// Arg ARG cv::Mat (boxed) frame= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_videostab_WeightingDeblurer_deblur_int_idx_Mat_frame(void* instance, int idx, void* frame) {
    try {
        reinterpret_cast<cv::videostab::WeightingDeblurer*>(instance)->deblur(idx, *reinterpret_cast<cv::Mat*>(frame));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_videostab_WobbleSuppressorBase_setMotionEstimator_PtrOfImageMotionEstimatorBase_val
// parsed: cv::videostab::WobbleSuppressorBase::setMotionEstimator
// as:     cv::videostab::WobbleSuppressorBase::setMotionEstimator (method) cv::videostab::WobbleSuppressorBase (trait) . setMotionEstimator
// Arg ARG SmartPtr[cv::videostab::ImageMotionEstimatorBase (boxed)] val= SmartPtr[cv::videostab::ImageMotionEstimatorBase (boxed)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_videostab_WobbleSuppressorBase_setMotionEstimator_PtrOfImageMotionEstimatorBase_val(void* instance, void* val) {
    try {
        reinterpret_cast<cv::videostab::WobbleSuppressorBase*>(instance)->setMotionEstimator(reinterpret_cast<cv::videostab::ImageMotionEstimatorBase*>(val));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_videostab_WobbleSuppressorBase_motionEstimator_const
// parsed: cv::videostab::WobbleSuppressorBase::motionEstimator
// as:     cv::videostab::WobbleSuppressorBase::motionEstimator (method) cv::videostab::WobbleSuppressorBase (trait) . motionEstimator
// Return value: SmartPtr[cv::videostab::ImageMotionEstimatorBase (boxed)]
cv_return_value_void_X cv_core_cv_videostab_WobbleSuppressorBase_motionEstimator_const(void* instance) {
    try {
        Ptr<cv::videostab::ImageMotionEstimatorBase> *ret = new Ptr<cv::videostab::ImageMotionEstimatorBase>(reinterpret_cast<cv::videostab::WobbleSuppressorBase*>(instance)->motionEstimator());
        return { Error::Code::StsOk, NULL, ret };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_videostab_WobbleSuppressorBase_suppress_int_idx_Mat_frame_Mat_result
// parsed: cv::videostab::WobbleSuppressorBase::suppress
// as:     cv::videostab::WobbleSuppressorBase::suppress (method) cv::videostab::WobbleSuppressorBase (trait) . suppress
// Arg ARG Primitive(int) idx= Primitive(int) = 
// Arg ARG cv::Mat (boxed) frame= cv::Mat (boxed) = 
// Arg ARG cv::Mat (boxed) result= cv::Mat (boxed) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_videostab_WobbleSuppressorBase_suppress_int_idx_Mat_frame_Mat_result(void* instance, int idx, void* frame, void* result) {
    try {
        reinterpret_cast<cv::videostab::WobbleSuppressorBase*>(instance)->suppress(idx, *reinterpret_cast<cv::Mat*>(frame), *reinterpret_cast<cv::Mat*>(result));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_videostab_WobbleSuppressorBase_setFrameCount_int_val
// parsed: cv::videostab::WobbleSuppressorBase::setFrameCount
// as:     cv::videostab::WobbleSuppressorBase::setFrameCount (method) cv::videostab::WobbleSuppressorBase (trait) . setFrameCount
// Arg ARG Primitive(int) val= Primitive(int) = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_videostab_WobbleSuppressorBase_setFrameCount_int_val(void* instance, int val) {
    try {
        reinterpret_cast<cv::videostab::WobbleSuppressorBase*>(instance)->setFrameCount(val);
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_videostab_WobbleSuppressorBase_frameCount_const
// parsed: cv::videostab::WobbleSuppressorBase::frameCount
// as:     cv::videostab::WobbleSuppressorBase::frameCount (method) cv::videostab::WobbleSuppressorBase (trait) . frameCount
// Return value: Primitive(int)
cv_return_value_int cv_core_cv_videostab_WobbleSuppressorBase_frameCount_const(void* instance) {
    try {
        int ret = reinterpret_cast<cv::videostab::WobbleSuppressorBase*>(instance)->frameCount();
        return { Error::Code::StsOk, NULL, *reinterpret_cast<int*>(&ret) };
    } CVRS_CATCH(cv_return_value_int)
}

// cv_videostab_WobbleSuppressorBase_setMotions_VectorOfMat_val
// parsed: cv::videostab::WobbleSuppressorBase::setMotions
// as:     cv::videostab::WobbleSuppressorBase::setMotions (method) cv::videostab::WobbleSuppressorBase (trait) . setMotions
// Arg ARG Vector[cv::Mat (boxed)] val= Vector[cv::Mat (boxed)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_videostab_WobbleSuppressorBase_setMotions_VectorOfMat_val(void* instance, void* val) {
    try {
        reinterpret_cast<cv::videostab::WobbleSuppressorBase*>(instance)->setMotions(*reinterpret_cast<std::vector<cv::Mat>*>(val));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_videostab_WobbleSuppressorBase_motions_const
// parsed: cv::videostab::WobbleSuppressorBase::motions
// as:     cv::videostab::WobbleSuppressorBase::motions (method) cv::videostab::WobbleSuppressorBase (trait) . motions
// Return value: Vector[cv::Mat (boxed)]
cv_return_value_void_X cv_core_cv_videostab_WobbleSuppressorBase_motions_const(void* instance) {
    try {
        std::vector<cv::Mat> ret = reinterpret_cast<cv::videostab::WobbleSuppressorBase*>(instance)->motions();
        return { Error::Code::StsOk, NULL, (void *)new std::vector<cv::Mat>(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_videostab_WobbleSuppressorBase_setMotions2_VectorOfMat_val
// parsed: cv::videostab::WobbleSuppressorBase::setMotions2
// as:     cv::videostab::WobbleSuppressorBase::setMotions2 (method) cv::videostab::WobbleSuppressorBase (trait) . setMotions2
// Arg ARG Vector[cv::Mat (boxed)] val= Vector[cv::Mat (boxed)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_videostab_WobbleSuppressorBase_setMotions2_VectorOfMat_val(void* instance, void* val) {
    try {
        reinterpret_cast<cv::videostab::WobbleSuppressorBase*>(instance)->setMotions2(*reinterpret_cast<std::vector<cv::Mat>*>(val));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_videostab_WobbleSuppressorBase_motions2_const
// parsed: cv::videostab::WobbleSuppressorBase::motions2
// as:     cv::videostab::WobbleSuppressorBase::motions2 (method) cv::videostab::WobbleSuppressorBase (trait) . motions2
// Return value: Vector[cv::Mat (boxed)]
cv_return_value_void_X cv_core_cv_videostab_WobbleSuppressorBase_motions2_const(void* instance) {
    try {
        std::vector<cv::Mat> ret = reinterpret_cast<cv::videostab::WobbleSuppressorBase*>(instance)->motions2();
        return { Error::Code::StsOk, NULL, (void *)new std::vector<cv::Mat>(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}

// cv_videostab_WobbleSuppressorBase_setStabilizationMotions_VectorOfMat_val
// parsed: cv::videostab::WobbleSuppressorBase::setStabilizationMotions
// as:     cv::videostab::WobbleSuppressorBase::setStabilizationMotions (method) cv::videostab::WobbleSuppressorBase (trait) . setStabilizationMotions
// Arg ARG Vector[cv::Mat (boxed)] val= Vector[cv::Mat (boxed)] = 
// Return value: Primitive(void)
cv_return_value_void cv_core_cv_videostab_WobbleSuppressorBase_setStabilizationMotions_VectorOfMat_val(void* instance, void* val) {
    try {
        reinterpret_cast<cv::videostab::WobbleSuppressorBase*>(instance)->setStabilizationMotions(*reinterpret_cast<std::vector<cv::Mat>*>(val));
        return { Error::Code::StsOk, NULL };
    } CVRS_CATCH(cv_return_value_void)
}

// cv_videostab_WobbleSuppressorBase_stabilizationMotions_const
// parsed: cv::videostab::WobbleSuppressorBase::stabilizationMotions
// as:     cv::videostab::WobbleSuppressorBase::stabilizationMotions (method) cv::videostab::WobbleSuppressorBase (trait) . stabilizationMotions
// Return value: Vector[cv::Mat (boxed)]
cv_return_value_void_X cv_core_cv_videostab_WobbleSuppressorBase_stabilizationMotions_const(void* instance) {
    try {
        std::vector<cv::Mat> ret = reinterpret_cast<cv::videostab::WobbleSuppressorBase*>(instance)->stabilizationMotions();
        return { Error::Code::StsOk, NULL, (void *)new std::vector<cv::Mat>(ret) };
    } CVRS_CATCH(cv_return_value_void_X)
}



} // extern "C"