#ifndef __OPENCV_FEATURES_2D_MANUAL_HPP__ #define __OPENCV_FEATURES_2D_MANUAL_HPP__ #include "opencv2/opencv_modules.hpp" #ifdef HAVE_OPENCV_FEATURES2D #include "opencv2/features2d.hpp" #undef SIMPLEBLOB // to solve conflict with wincrypt.h on windows namespace cv { class CV_EXPORTS_AS(FeatureDetector) javaFeatureDetector : public FeatureDetector { public: #if 0 //DO NOT REMOVE! The block is required for sources parser CV_WRAP void detect( const Mat& image, CV_OUT std::vector& keypoints, const Mat& mask=Mat() ) const; CV_WRAP void detect( const std::vector& images, CV_OUT std::vector >& keypoints, const std::vector& masks=std::vector() ) const; CV_WRAP virtual bool empty() const; #endif enum { FAST = 1, STAR = 2, SIFT = 3, SURF = 4, ORB = 5, MSER = 6, GFTT = 7, HARRIS = 8, SIMPLEBLOB = 9, DENSE = 10, BRISK = 11, GRIDDETECTOR = 1000, GRID_FAST = GRIDDETECTOR + FAST, GRID_STAR = GRIDDETECTOR + STAR, GRID_SIFT = GRIDDETECTOR + SIFT, GRID_SURF = GRIDDETECTOR + SURF, GRID_ORB = GRIDDETECTOR + ORB, GRID_MSER = GRIDDETECTOR + MSER, GRID_GFTT = GRIDDETECTOR + GFTT, GRID_HARRIS = GRIDDETECTOR + HARRIS, GRID_SIMPLEBLOB = GRIDDETECTOR + SIMPLEBLOB, GRID_DENSE = GRIDDETECTOR + DENSE, GRID_BRISK = GRIDDETECTOR + BRISK, PYRAMIDDETECTOR = 2000, PYRAMID_FAST = PYRAMIDDETECTOR + FAST, PYRAMID_STAR = PYRAMIDDETECTOR + STAR, PYRAMID_SIFT = PYRAMIDDETECTOR + SIFT, PYRAMID_SURF = PYRAMIDDETECTOR + SURF, PYRAMID_ORB = PYRAMIDDETECTOR + ORB, PYRAMID_MSER = PYRAMIDDETECTOR + MSER, PYRAMID_GFTT = PYRAMIDDETECTOR + GFTT, PYRAMID_HARRIS = PYRAMIDDETECTOR + HARRIS, PYRAMID_SIMPLEBLOB = PYRAMIDDETECTOR + SIMPLEBLOB, PYRAMID_DENSE = PYRAMIDDETECTOR + DENSE, PYRAMID_BRISK = PYRAMIDDETECTOR + BRISK, DYNAMICDETECTOR = 3000, DYNAMIC_FAST = DYNAMICDETECTOR + FAST, DYNAMIC_STAR = DYNAMICDETECTOR + STAR, DYNAMIC_SIFT = DYNAMICDETECTOR + SIFT, DYNAMIC_SURF = DYNAMICDETECTOR + SURF, DYNAMIC_ORB = DYNAMICDETECTOR + ORB, DYNAMIC_MSER = DYNAMICDETECTOR + MSER, DYNAMIC_GFTT = DYNAMICDETECTOR + GFTT, DYNAMIC_HARRIS = DYNAMICDETECTOR + HARRIS, DYNAMIC_SIMPLEBLOB = DYNAMICDETECTOR + SIMPLEBLOB, DYNAMIC_DENSE = DYNAMICDETECTOR + DENSE, DYNAMIC_BRISK = DYNAMICDETECTOR + BRISK }; //supported: FAST STAR SIFT SURF ORB MSER GFTT HARRIS BRISK Grid(XXXX) Pyramid(XXXX) Dynamic(XXXX) //not supported: SimpleBlob, Dense CV_WRAP static javaFeatureDetector* create( int detectorType ) { String name; if (detectorType > DYNAMICDETECTOR) { name = "Dynamic"; detectorType -= DYNAMICDETECTOR; } if (detectorType > PYRAMIDDETECTOR) { name = "Pyramid"; detectorType -= PYRAMIDDETECTOR; } if (detectorType > GRIDDETECTOR) { name = "Grid"; detectorType -= GRIDDETECTOR; } switch(detectorType) { case FAST: name = name + "FAST"; break; case STAR: name = name + "STAR"; break; case SIFT: name = name + "SIFT"; break; case SURF: name = name + "SURF"; break; case ORB: name = name + "ORB"; break; case MSER: name = name + "MSER"; break; case GFTT: name = name + "GFTT"; break; case HARRIS: name = name + "HARRIS"; break; case SIMPLEBLOB: name = name + "SimpleBlob"; break; case DENSE: name = name + "Dense"; break; case BRISK: name = name + "BRISK"; break; default: CV_Error( CV_StsBadArg, "Specified feature detector type is not supported." ); break; } Ptr detector = FeatureDetector::create(name); detector.addref(); return (javaFeatureDetector*)((FeatureDetector*) detector); } CV_WRAP void write( const String& fileName ) const { FileStorage fs(fileName, FileStorage::WRITE); ((FeatureDetector*)this)->write(fs); fs.release(); } CV_WRAP void read( const String& fileName ) { FileStorage fs(fileName, FileStorage::READ); ((FeatureDetector*)this)->read(fs.root()); fs.release(); } }; class CV_EXPORTS_AS(DescriptorMatcher) javaDescriptorMatcher : public DescriptorMatcher { public: #if 0 //DO NOT REMOVE! The block is required for sources parser CV_WRAP virtual bool isMaskSupported() const; CV_WRAP virtual void add( const std::vector& descriptors ); CV_WRAP const std::vector& getTrainDescriptors() const; CV_WRAP virtual void clear(); CV_WRAP virtual bool empty() const; CV_WRAP virtual void train(); CV_WRAP void match( const Mat& queryDescriptors, const Mat& trainDescriptors, CV_OUT std::vector& matches, const Mat& mask=Mat() ) const; CV_WRAP void knnMatch( const Mat& queryDescriptors, const Mat& trainDescriptors, CV_OUT std::vector >& matches, int k, const Mat& mask=Mat(), bool compactResult=false ) const; CV_WRAP void radiusMatch( const Mat& queryDescriptors, const Mat& trainDescriptors, CV_OUT std::vector >& matches, float maxDistance, const Mat& mask=Mat(), bool compactResult=false ) const; CV_WRAP void match( const Mat& queryDescriptors, CV_OUT std::vector& matches, const std::vector& masks=std::vector() ); CV_WRAP void knnMatch( const Mat& queryDescriptors, CV_OUT std::vector >& matches, int k, const std::vector& masks=std::vector(), bool compactResult=false ); CV_WRAP void radiusMatch( const Mat& queryDescriptors, CV_OUT std::vector >& matches, float maxDistance, const std::vector& masks=std::vector(), bool compactResult=false ); #endif enum { FLANNBASED = 1, BRUTEFORCE = 2, BRUTEFORCE_L1 = 3, BRUTEFORCE_HAMMING = 4, BRUTEFORCE_HAMMINGLUT = 5, BRUTEFORCE_SL2 = 6 }; CV_WRAP_AS(clone) javaDescriptorMatcher* jclone( bool emptyTrainData=false ) const { Ptr matcher = this->clone(emptyTrainData); matcher.addref(); return (javaDescriptorMatcher*)((DescriptorMatcher*) matcher); } //supported: FlannBased, BruteForce, BruteForce-L1, BruteForce-Hamming, BruteForce-HammingLUT CV_WRAP static javaDescriptorMatcher* create( int matcherType ) { String name; switch(matcherType) { case FLANNBASED: name = "FlannBased"; break; case BRUTEFORCE: name = "BruteForce"; break; case BRUTEFORCE_L1: name = "BruteForce-L1"; break; case BRUTEFORCE_HAMMING: name = "BruteForce-Hamming"; break; case BRUTEFORCE_HAMMINGLUT: name = "BruteForce-HammingLUT"; break; case BRUTEFORCE_SL2: name = "BruteForce-SL2"; break; default: CV_Error( CV_StsBadArg, "Specified descriptor matcher type is not supported." ); break; } Ptr matcher = DescriptorMatcher::create(name); matcher.addref(); return (javaDescriptorMatcher*)((DescriptorMatcher*) matcher); } CV_WRAP void write( const String& fileName ) const { FileStorage fs(fileName, FileStorage::WRITE); ((DescriptorMatcher*)this)->write(fs); fs.release(); } CV_WRAP void read( const String& fileName ) { FileStorage fs(fileName, FileStorage::READ); ((DescriptorMatcher*)this)->read(fs.root()); fs.release(); } }; class CV_EXPORTS_AS(DescriptorExtractor) javaDescriptorExtractor : public DescriptorExtractor { public: #if 0 //DO NOT REMOVE! The block is required for sources parser CV_WRAP void compute( const Mat& image, CV_IN_OUT std::vector& keypoints, Mat& descriptors ) const; CV_WRAP void compute( const std::vector& images, CV_IN_OUT std::vector >& keypoints, CV_OUT std::vector& descriptors ) const; CV_WRAP virtual int descriptorSize() const; CV_WRAP virtual int descriptorType() const; CV_WRAP virtual bool empty() const; #endif enum { SIFT = 1, SURF = 2, ORB = 3, BRIEF = 4, BRISK = 5, FREAK = 6, OPPONENTEXTRACTOR = 1000, OPPONENT_SIFT = OPPONENTEXTRACTOR + SIFT, OPPONENT_SURF = OPPONENTEXTRACTOR + SURF, OPPONENT_ORB = OPPONENTEXTRACTOR + ORB, OPPONENT_BRIEF = OPPONENTEXTRACTOR + BRIEF, OPPONENT_BRISK = OPPONENTEXTRACTOR + BRISK, OPPONENT_FREAK = OPPONENTEXTRACTOR + FREAK }; //supported SIFT, SURF, ORB, BRIEF, BRISK, FREAK, Opponent(XXXX) //not supported: Calonder CV_WRAP static javaDescriptorExtractor* create( int extractorType ) { String name; if (extractorType > OPPONENTEXTRACTOR) { name = "Opponent"; extractorType -= OPPONENTEXTRACTOR; } switch(extractorType) { case SIFT: name = name + "SIFT"; break; case SURF: name = name + "SURF"; break; case ORB: name = name + "ORB"; break; case BRIEF: name = name + "BRIEF"; break; case BRISK: name = name + "BRISK"; break; case FREAK: name = name + "FREAK"; break; default: CV_Error( CV_StsBadArg, "Specified descriptor extractor type is not supported." ); break; } Ptr extractor = DescriptorExtractor::create(name); extractor.addref(); return (javaDescriptorExtractor*)((DescriptorExtractor*) extractor); } CV_WRAP void write( const String& fileName ) const { FileStorage fs(fileName, FileStorage::WRITE); ((DescriptorExtractor*)this)->write(fs); fs.release(); } CV_WRAP void read( const String& fileName ) { FileStorage fs(fileName, FileStorage::READ); ((DescriptorExtractor*)this)->read(fs.root()); fs.release(); } }; class CV_EXPORTS_AS(GenericDescriptorMatcher) javaGenericDescriptorMatcher : public GenericDescriptorMatcher { public: #if 0 //DO NOT REMOVE! The block is required for sources parser CV_WRAP virtual void add( const std::vector& images, std::vector >& keypoints ); CV_WRAP const std::vector& getTrainImages() const; CV_WRAP const std::vector >& getTrainKeypoints() const; CV_WRAP virtual void clear(); CV_WRAP virtual bool isMaskSupported(); CV_WRAP virtual void train(); CV_WRAP void classify( const Mat& queryImage, CV_IN_OUT std::vector& queryKeypoints, const Mat& trainImage, std::vector& trainKeypoints ) const; CV_WRAP void classify( const Mat& queryImage, CV_IN_OUT std::vector& queryKeypoints ); CV_WRAP void match( const Mat& queryImage, std::vector& queryKeypoints, const Mat& trainImage, std::vector& trainKeypoints, CV_OUT std::vector& matches, const Mat& mask=Mat() ) const; CV_WRAP void knnMatch( const Mat& queryImage, std::vector& queryKeypoints, const Mat& trainImage, std::vector& trainKeypoints, CV_OUT std::vector >& matches, int k, const Mat& mask=Mat(), bool compactResult=false ) const; CV_WRAP void radiusMatch( const Mat& queryImage, std::vector& queryKeypoints, const Mat& trainImage, std::vector& trainKeypoints, CV_OUT std::vector >& matches, float maxDistance, const Mat& mask=Mat(), bool compactResult=false ) const; CV_WRAP void match( const Mat& queryImage, std::vector& queryKeypoints, CV_OUT std::vector& matches, const std::vector& masks=std::vector() ); CV_WRAP void knnMatch( const Mat& queryImage, std::vector& queryKeypoints, CV_OUT std::vector >& matches, int k, const std::vector& masks=std::vector(), bool compactResult=false ); CV_WRAP void radiusMatch( const Mat& queryImage, std::vector& queryKeypoints, CV_OUT std::vector >& matches, float maxDistance, const std::vector& masks=std::vector(), bool compactResult=false ); CV_WRAP virtual bool empty() const; #endif enum { ONEWAY = 1, FERN = 2 }; CV_WRAP_AS(clone) javaGenericDescriptorMatcher* jclone( bool emptyTrainData=false ) const { Ptr matcher = this->clone(emptyTrainData); matcher.addref(); return (javaGenericDescriptorMatcher*)((GenericDescriptorMatcher*) matcher); } //supported: OneWay, Fern //unsupported: Vector CV_WRAP static javaGenericDescriptorMatcher* create( int matcherType ) { String name; switch(matcherType) { case ONEWAY: name = "ONEWAY"; break; case FERN: name = "FERN"; break; default: CV_Error( CV_StsBadArg, "Specified generic descriptor matcher type is not supported." ); break; } Ptr matcher = GenericDescriptorMatcher::create(name); matcher.addref(); return (javaGenericDescriptorMatcher*)((GenericDescriptorMatcher*) matcher); } CV_WRAP void write( const String& fileName ) const { FileStorage fs(fileName, FileStorage::WRITE); ((GenericDescriptorMatcher*)this)->write(fs); fs.release(); } CV_WRAP void read( const String& fileName ) { FileStorage fs(fileName, FileStorage::READ); ((GenericDescriptorMatcher*)this)->read(fs.root()); fs.release(); } }; #if 0 //DO NOT REMOVE! The block is required for sources parser enum { DRAW_OVER_OUTIMG = 1, // Output image matrix will not be created (Mat::create). // Matches will be drawn on existing content of output image. NOT_DRAW_SINGLE_POINTS = 2, // Single keypoints will not be drawn. DRAW_RICH_KEYPOINTS = 4 // For each keypoint the circle around keypoint with keypoint size and // orientation will be drawn. }; // Draw keypoints. CV_EXPORTS_W void drawKeypoints( const Mat& image, const std::vector& keypoints, Mat& outImage, const Scalar& color=Scalar::all(-1), int flags=0 ); // Draws matches of keypints from two images on output image. CV_EXPORTS_W void drawMatches( const Mat& img1, const std::vector& keypoints1, const Mat& img2, const std::vector& keypoints2, const std::vector& matches1to2, Mat& outImg, const Scalar& matchColor=Scalar::all(-1), const Scalar& singlePointColor=Scalar::all(-1), const std::vector& matchesMask=std::vector(), int flags=0 ); CV_EXPORTS_AS(drawMatches2) void drawMatches( const Mat& img1, const std::vector& keypoints1, const Mat& img2, const std::vector& keypoints2, const std::vector >& matches1to2, Mat& outImg, const Scalar& matchColor=Scalar::all(-1), const Scalar& singlePointColor=Scalar::all(-1), const std::vector >& matchesMask=std::vector >(), int flags=0); #endif } //cv #endif // HAVE_OPENCV_FEATURES2D #endif // __OPENCV_FEATURES_2D_MANUAL_HPP__