text: #include "ocvrs_common.hpp"
  #include <opencv2/cudafeatures2d.hpp>
  #include "cudafeatures2d_types.hpp"
  
  extern "C" {
  	Result<cv::Ptr<cv::cuda::DescriptorMatcher>*> cv_cuda_DescriptorMatcher_createBFMatcher_int(int normType) {
  		try {
  			cv::Ptr<cv::cuda::DescriptorMatcher> ret = cv::cuda::DescriptorMatcher::createBFMatcher(normType);
  			return Ok(new cv::Ptr<cv::cuda::DescriptorMatcher>(ret));
  		} OCVRS_CATCH(OCVRS_TYPE(Result<cv::Ptr<cv::cuda::DescriptorMatcher>*>))
  	}
  	
  	Result<bool> cv_cuda_DescriptorMatcher_isMaskSupported_const(const cv::cuda::DescriptorMatcher* instance) {
  		try {
  			bool ret = instance->isMaskSupported();
  			return Ok<bool>(ret);
  		} OCVRS_CATCH(OCVRS_TYPE(Result<bool>))
  	}
  	
  	Result_void cv_cuda_DescriptorMatcher_add_const_vector_GpuMat_R(cv::cuda::DescriptorMatcher* instance, const std::vector<cv::cuda::GpuMat>* descriptors) {
  		try {
  			instance->add(*descriptors);
  			return Ok();
  		} OCVRS_CATCH(OCVRS_TYPE(Result_void))
  	}
  	
  	Result<const std::vector<cv::cuda::GpuMat>*> cv_cuda_DescriptorMatcher_getTrainDescriptors_const(const cv::cuda::DescriptorMatcher* instance) {
  		try {
  			const std::vector<cv::cuda::GpuMat> ret = instance->getTrainDescriptors();
  			return Ok(new const std::vector<cv::cuda::GpuMat>(ret));
  		} OCVRS_CATCH(OCVRS_TYPE(Result<const std::vector<cv::cuda::GpuMat>*>))
  	}
  	
  	Result_void cv_cuda_DescriptorMatcher_clear(cv::cuda::DescriptorMatcher* instance) {
  		try {
  			instance->clear();
  			return Ok();
  		} OCVRS_CATCH(OCVRS_TYPE(Result_void))
  	}
  	
  	Result<bool> cv_cuda_DescriptorMatcher_empty_const(const cv::cuda::DescriptorMatcher* instance) {
  		try {
  			bool ret = instance->empty();
  			return Ok<bool>(ret);
  		} OCVRS_CATCH(OCVRS_TYPE(Result<bool>))
  	}
  	
  	Result_void cv_cuda_DescriptorMatcher_train(cv::cuda::DescriptorMatcher* instance) {
  		try {
  			instance->train();
  			return Ok();
  		} OCVRS_CATCH(OCVRS_TYPE(Result_void))
  	}
  	
  	Result_void cv_cuda_DescriptorMatcher_match_const__InputArrayR_const__InputArrayR_vector_DMatch_R_const__InputArrayR(cv::cuda::DescriptorMatcher* instance, const cv::_InputArray* queryDescriptors, const cv::_InputArray* trainDescriptors, std::vector<cv::DMatch>* matches, const cv::_InputArray* mask) {
  		try {
  			instance->match(*queryDescriptors, *trainDescriptors, *matches, *mask);
  			return Ok();
  		} OCVRS_CATCH(OCVRS_TYPE(Result_void))
  	}
  	
  	Result_void cv_cuda_DescriptorMatcher_match_const__InputArrayR_vector_DMatch_R_const_vector_GpuMat_R(cv::cuda::DescriptorMatcher* instance, const cv::_InputArray* queryDescriptors, std::vector<cv::DMatch>* matches, const std::vector<cv::cuda::GpuMat>* masks) {
  		try {
  			instance->match(*queryDescriptors, *matches, *masks);
  			return Ok();
  		} OCVRS_CATCH(OCVRS_TYPE(Result_void))
  	}
  	
  	Result_void cv_cuda_DescriptorMatcher_matchAsync_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__InputArrayR_StreamR(cv::cuda::DescriptorMatcher* instance, const cv::_InputArray* queryDescriptors, const cv::_InputArray* trainDescriptors, const cv::_OutputArray* matches, const cv::_InputArray* mask, cv::cuda::Stream* stream) {
  		try {
  			instance->matchAsync(*queryDescriptors, *trainDescriptors, *matches, *mask, *stream);
  			return Ok();
  		} OCVRS_CATCH(OCVRS_TYPE(Result_void))
  	}
  	
  	Result_void cv_cuda_DescriptorMatcher_matchAsync_const__InputArrayR_const__OutputArrayR_const_vector_GpuMat_R_StreamR(cv::cuda::DescriptorMatcher* instance, const cv::_InputArray* queryDescriptors, const cv::_OutputArray* matches, const std::vector<cv::cuda::GpuMat>* masks, cv::cuda::Stream* stream) {
  		try {
  			instance->matchAsync(*queryDescriptors, *matches, *masks, *stream);
  			return Ok();
  		} OCVRS_CATCH(OCVRS_TYPE(Result_void))
  	}
  	
  	Result_void cv_cuda_DescriptorMatcher_matchConvert_const__InputArrayR_vector_DMatch_R(cv::cuda::DescriptorMatcher* instance, const cv::_InputArray* gpu_matches, std::vector<cv::DMatch>* matches) {
  		try {
  			instance->matchConvert(*gpu_matches, *matches);
  			return Ok();
  		} OCVRS_CATCH(OCVRS_TYPE(Result_void))
  	}
  	
  	Result_void cv_cuda_DescriptorMatcher_knnMatch_const__InputArrayR_const__InputArrayR_vector_vector_DMatch__R_int_const__InputArrayR_bool(cv::cuda::DescriptorMatcher* instance, const cv::_InputArray* queryDescriptors, const cv::_InputArray* trainDescriptors, std::vector<std::vector<cv::DMatch>>* matches, int k, const cv::_InputArray* mask, bool compactResult) {
  		try {
  			instance->knnMatch(*queryDescriptors, *trainDescriptors, *matches, k, *mask, compactResult);
  			return Ok();
  		} OCVRS_CATCH(OCVRS_TYPE(Result_void))
  	}
  	
  	Result_void cv_cuda_DescriptorMatcher_knnMatch_const__InputArrayR_vector_vector_DMatch__R_int_const_vector_GpuMat_R_bool(cv::cuda::DescriptorMatcher* instance, const cv::_InputArray* queryDescriptors, std::vector<std::vector<cv::DMatch>>* matches, int k, const std::vector<cv::cuda::GpuMat>* masks, bool compactResult) {
  		try {
  			instance->knnMatch(*queryDescriptors, *matches, k, *masks, compactResult);
  			return Ok();
  		} OCVRS_CATCH(OCVRS_TYPE(Result_void))
  	}
  	
  	Result_void cv_cuda_DescriptorMatcher_knnMatchAsync_const__InputArrayR_const__InputArrayR_const__OutputArrayR_int_const__InputArrayR_StreamR(cv::cuda::DescriptorMatcher* instance, const cv::_InputArray* queryDescriptors, const cv::_InputArray* trainDescriptors, const cv::_OutputArray* matches, int k, const cv::_InputArray* mask, cv::cuda::Stream* stream) {
  		try {
  			instance->knnMatchAsync(*queryDescriptors, *trainDescriptors, *matches, k, *mask, *stream);
  			return Ok();
  		} OCVRS_CATCH(OCVRS_TYPE(Result_void))
  	}
  	
  	Result_void cv_cuda_DescriptorMatcher_knnMatchAsync_const__InputArrayR_const__OutputArrayR_int_const_vector_GpuMat_R_StreamR(cv::cuda::DescriptorMatcher* instance, const cv::_InputArray* queryDescriptors, const cv::_OutputArray* matches, int k, const std::vector<cv::cuda::GpuMat>* masks, cv::cuda::Stream* stream) {
  		try {
  			instance->knnMatchAsync(*queryDescriptors, *matches, k, *masks, *stream);
  			return Ok();
  		} OCVRS_CATCH(OCVRS_TYPE(Result_void))
  	}
  	
  	Result_void cv_cuda_DescriptorMatcher_knnMatchConvert_const__InputArrayR_vector_vector_DMatch__R_bool(cv::cuda::DescriptorMatcher* instance, const cv::_InputArray* gpu_matches, std::vector<std::vector<cv::DMatch>>* matches, bool compactResult) {
  		try {
  			instance->knnMatchConvert(*gpu_matches, *matches, compactResult);
  			return Ok();
  		} OCVRS_CATCH(OCVRS_TYPE(Result_void))
  	}
  	
  	Result_void cv_cuda_DescriptorMatcher_radiusMatch_const__InputArrayR_const__InputArrayR_vector_vector_DMatch__R_float_const__InputArrayR_bool(cv::cuda::DescriptorMatcher* instance, const cv::_InputArray* queryDescriptors, const cv::_InputArray* trainDescriptors, std::vector<std::vector<cv::DMatch>>* matches, float maxDistance, const cv::_InputArray* mask, bool compactResult) {
  		try {
  			instance->radiusMatch(*queryDescriptors, *trainDescriptors, *matches, maxDistance, *mask, compactResult);
  			return Ok();
  		} OCVRS_CATCH(OCVRS_TYPE(Result_void))
  	}
  	
  	Result_void cv_cuda_DescriptorMatcher_radiusMatch_const__InputArrayR_vector_vector_DMatch__R_float_const_vector_GpuMat_R_bool(cv::cuda::DescriptorMatcher* instance, const cv::_InputArray* queryDescriptors, std::vector<std::vector<cv::DMatch>>* matches, float maxDistance, const std::vector<cv::cuda::GpuMat>* masks, bool compactResult) {
  		try {
  			instance->radiusMatch(*queryDescriptors, *matches, maxDistance, *masks, compactResult);
  			return Ok();
  		} OCVRS_CATCH(OCVRS_TYPE(Result_void))
  	}
  	
  	Result_void cv_cuda_DescriptorMatcher_radiusMatchAsync_const__InputArrayR_const__InputArrayR_const__OutputArrayR_float_const__InputArrayR_StreamR(cv::cuda::DescriptorMatcher* instance, const cv::_InputArray* queryDescriptors, const cv::_InputArray* trainDescriptors, const cv::_OutputArray* matches, float maxDistance, const cv::_InputArray* mask, cv::cuda::Stream* stream) {
  		try {
  			instance->radiusMatchAsync(*queryDescriptors, *trainDescriptors, *matches, maxDistance, *mask, *stream);
  			return Ok();
  		} OCVRS_CATCH(OCVRS_TYPE(Result_void))
  	}
  	
  	Result_void cv_cuda_DescriptorMatcher_radiusMatchAsync_const__InputArrayR_const__OutputArrayR_float_const_vector_GpuMat_R_StreamR(cv::cuda::DescriptorMatcher* instance, const cv::_InputArray* queryDescriptors, const cv::_OutputArray* matches, float maxDistance, const std::vector<cv::cuda::GpuMat>* masks, cv::cuda::Stream* stream) {
  		try {
  			instance->radiusMatchAsync(*queryDescriptors, *matches, maxDistance, *masks, *stream);
  			return Ok();
  		} OCVRS_CATCH(OCVRS_TYPE(Result_void))
  	}
  	
  	Result_void cv_cuda_DescriptorMatcher_radiusMatchConvert_const__InputArrayR_vector_vector_DMatch__R_bool(cv::cuda::DescriptorMatcher* instance, const cv::_InputArray* gpu_matches, std::vector<std::vector<cv::DMatch>>* matches, bool compactResult) {
  		try {
  			instance->radiusMatchConvert(*gpu_matches, *matches, compactResult);
  			return Ok();
  		} OCVRS_CATCH(OCVRS_TYPE(Result_void))
  	}
  	
  	Result<cv::Ptr<cv::cuda::FastFeatureDetector>*> cv_cuda_FastFeatureDetector_create_int_bool_int_int(int threshold, bool nonmaxSuppression, int type, int max_npoints) {
  		try {
  			cv::Ptr<cv::cuda::FastFeatureDetector> ret = cv::cuda::FastFeatureDetector::create(threshold, nonmaxSuppression, type, max_npoints);
  			return Ok(new cv::Ptr<cv::cuda::FastFeatureDetector>(ret));
  		} OCVRS_CATCH(OCVRS_TYPE(Result<cv::Ptr<cv::cuda::FastFeatureDetector>*>))
  	}
  	
  	Result_void cv_cuda_FastFeatureDetector_setMaxNumPoints_int(cv::cuda::FastFeatureDetector* instance, int max_npoints) {
  		try {
  			instance->setMaxNumPoints(max_npoints);
  			return Ok();
  		} OCVRS_CATCH(OCVRS_TYPE(Result_void))
  	}
  	
  	Result<int> cv_cuda_FastFeatureDetector_getMaxNumPoints_const(const cv::cuda::FastFeatureDetector* instance) {
  		try {
  			int ret = instance->getMaxNumPoints();
  			return Ok<int>(ret);
  		} OCVRS_CATCH(OCVRS_TYPE(Result<int>))
  	}
  	
  	Result_void cv_cuda_Feature2DAsync_detectAsync_const__InputArrayR_const__OutputArrayR_const__InputArrayR_StreamR(cv::cuda::Feature2DAsync* instance, const cv::_InputArray* image, const cv::_OutputArray* keypoints, const cv::_InputArray* mask, cv::cuda::Stream* stream) {
  		try {
  			instance->detectAsync(*image, *keypoints, *mask, *stream);
  			return Ok();
  		} OCVRS_CATCH(OCVRS_TYPE(Result_void))
  	}
  	
  	Result_void cv_cuda_Feature2DAsync_computeAsync_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_StreamR(cv::cuda::Feature2DAsync* instance, const cv::_InputArray* image, const cv::_OutputArray* keypoints, const cv::_OutputArray* descriptors, cv::cuda::Stream* stream) {
  		try {
  			instance->computeAsync(*image, *keypoints, *descriptors, *stream);
  			return Ok();
  		} OCVRS_CATCH(OCVRS_TYPE(Result_void))
  	}
  	
  	Result_void cv_cuda_Feature2DAsync_detectAndComputeAsync_const__InputArrayR_const__InputArrayR_const__OutputArrayR_const__OutputArrayR_bool_StreamR(cv::cuda::Feature2DAsync* instance, const cv::_InputArray* image, const cv::_InputArray* mask, const cv::_OutputArray* keypoints, const cv::_OutputArray* descriptors, bool useProvidedKeypoints, cv::cuda::Stream* stream) {
  		try {
  			instance->detectAndComputeAsync(*image, *mask, *keypoints, *descriptors, useProvidedKeypoints, *stream);
  			return Ok();
  		} OCVRS_CATCH(OCVRS_TYPE(Result_void))
  	}
  	
  	Result_void cv_cuda_Feature2DAsync_convert_const__InputArrayR_vector_KeyPoint_R(cv::cuda::Feature2DAsync* instance, const cv::_InputArray* gpu_keypoints, std::vector<cv::KeyPoint>* keypoints) {
  		try {
  			instance->convert(*gpu_keypoints, *keypoints);
  			return Ok();
  		} OCVRS_CATCH(OCVRS_TYPE(Result_void))
  	}
  	
  	Result<cv::Ptr<cv::cuda::ORB>*> cv_cuda_ORB_create_int_float_int_int_int_int_int_int_int_bool(int nfeatures, float scaleFactor, int nlevels, int edgeThreshold, int firstLevel, int WTA_K, int scoreType, int patchSize, int fastThreshold, bool blurForDescriptor) {
  		try {
  			cv::Ptr<cv::cuda::ORB> ret = cv::cuda::ORB::create(nfeatures, scaleFactor, nlevels, edgeThreshold, firstLevel, WTA_K, scoreType, patchSize, fastThreshold, blurForDescriptor);
  			return Ok(new cv::Ptr<cv::cuda::ORB>(ret));
  		} OCVRS_CATCH(OCVRS_TYPE(Result<cv::Ptr<cv::cuda::ORB>*>))
  	}
  	
  	Result_void cv_cuda_ORB_setBlurForDescriptor_bool(cv::cuda::ORB* instance, bool blurForDescriptor) {
  		try {
  			instance->setBlurForDescriptor(blurForDescriptor);
  			return Ok();
  		} OCVRS_CATCH(OCVRS_TYPE(Result_void))
  	}
  	
  	Result<bool> cv_cuda_ORB_getBlurForDescriptor_const(const cv::cuda::ORB* instance) {
  		try {
  			bool ret = instance->getBlurForDescriptor();
  			return Ok<bool>(ret);
  		} OCVRS_CATCH(OCVRS_TYPE(Result<bool>))
  	}
  	
  }
  