Merge pull request #12310 from cv3d:chunks/enum_interface

* Cleanup macros and enable expansion of `__VA_ARGS__` for Visual Studio

* Macros for enum-arguments backwards compatibility

* Convert struct Param to enum struct

* Enabled ParamType.type for enum types

* Enabled `cv.read` and `cv.write` for enum types

* Rename unnamed enum to AAKAZE.DescriptorType

* Rename unnamed enum to AccessFlag

* Rename unnamed enum to AgastFeatureDetector.DetectorType

* Convert struct DrawMatchesFlags to enum struct

* Rename unnamed enum to FastFeatureDetector.DetectorType

* Rename unnamed enum to Formatter.FormatType

* Rename unnamed enum to HOGDescriptor.HistogramNormType

* Rename unnamed enum to DescriptorMatcher.MatcherType

* Rename unnamed enum to KAZE.DiffusivityType

* Rename unnamed enum to ORB.ScoreType

* Rename unnamed enum to UMatData.MemoryFlag

* Rename unnamed enum to _InputArray.KindFlag

* Rename unnamed enum to _OutputArray.DepthMask

* Convert normType enums to static const NormTypes

* Avoid conflicts with ElemType

* Rename unnamed enum to DescriptorStorageFormat

modules/features2d/src/agast.cpp

@@ -7446,7 +7446,7 @@ static void OAST_9_16(InputArray _img, std::vector<KeyPoint>& keypoints, int thr
 
 #else // !(defined __i386__ || defined(_M_IX86) || defined __x86_64__ || defined(_M_X64))
 
-static void AGAST_ALL(InputArray _img, std::vector<KeyPoint>& keypoints, int threshold, int agasttype)
+static void AGAST_ALL(InputArray _img, std::vector<KeyPoint>& keypoints, int threshold, AgastFeatureDetector::DetectorType agasttype)
 {
     cv::Mat img;
     if(!_img.getMat().isContinuous())
@@ -7944,8 +7944,8 @@ void AGAST(InputArray _img, std::vector<KeyPoint>& keypoints, int threshold, boo
 class AgastFeatureDetector_Impl CV_FINAL : public AgastFeatureDetector
 {
 public:
-    AgastFeatureDetector_Impl( int _threshold, bool _nonmaxSuppression, int _type )
-    : threshold(_threshold), nonmaxSuppression(_nonmaxSuppression), type((short)_type)
+    AgastFeatureDetector_Impl( int _threshold, bool _nonmaxSuppression, DetectorType _type )
+    : threshold(_threshold), nonmaxSuppression(_nonmaxSuppression), type(_type)
     {}
 
     void detect( InputArray _image, std::vector<KeyPoint>& keypoints, InputArray _mask ) CV_OVERRIDE
@@ -7998,20 +7998,20 @@ public:
     void setNonmaxSuppression(bool f) CV_OVERRIDE { nonmaxSuppression = f; }
     bool getNonmaxSuppression() const CV_OVERRIDE { return nonmaxSuppression; }
 
-    void setType(int type_) CV_OVERRIDE { type = type_; }
-    int getType() const CV_OVERRIDE { return type; }
+    void setType(DetectorType type_) CV_OVERRIDE{ type = type_; }
+    DetectorType getType() const CV_OVERRIDE{ return type; }
 
     int threshold;
     bool nonmaxSuppression;
-    int type;
+    DetectorType type;
 };
 
-Ptr<AgastFeatureDetector> AgastFeatureDetector::create( int threshold, bool nonmaxSuppression, int type )
+Ptr<AgastFeatureDetector> AgastFeatureDetector::create( int threshold, bool nonmaxSuppression, AgastFeatureDetector::DetectorType type )
 {
     return makePtr<AgastFeatureDetector_Impl>(threshold, nonmaxSuppression, type);
 }
 
-void AGAST(InputArray _img, std::vector<KeyPoint>& keypoints, int threshold, bool nonmax_suppression, int type)
+void AGAST(InputArray _img, std::vector<KeyPoint>& keypoints, int threshold, bool nonmax_suppression, AgastFeatureDetector::DetectorType type)
 {
     CV_INSTRUMENT_REGION();
 

modules/features2d/src/agast_score.cpp

@@ -47,7 +47,7 @@ The references are:
 namespace cv
 {
 
-void makeAgastOffsets(int pixel[16], int rowStride, int type)
+void makeAgastOffsets(int pixel[16], int rowStride, AgastFeatureDetector::DetectorType type)
 {
     static const int offsets16[][2] =
     {
@@ -9400,7 +9400,7 @@ int agast_tree_search(const uint32_t table_struct32[], int pixel_[], const unsig
 }
 
 // universal pixel mask
-int AGAST_ALL_SCORE(const uchar* ptr, const int pixel[], int threshold, int agasttype)
+int AGAST_ALL_SCORE(const uchar* ptr, const int pixel[], int threshold, AgastFeatureDetector::DetectorType agasttype)
 {
     int bmin = threshold;
     int bmax = 255;

modules/features2d/src/agast_score.hpp

@@ -54,13 +54,13 @@ namespace cv
 
 #if !(defined __i386__ || defined(_M_IX86) || defined __x86_64__ || defined(_M_X64))
 int agast_tree_search(const uint32_t table_struct32[], int pixel_[], const unsigned char* const ptr, int threshold);
-int AGAST_ALL_SCORE(const uchar* ptr, const int pixel[], int threshold, int agasttype);
+int AGAST_ALL_SCORE(const uchar* ptr, const int pixel[], int threshold, AgastFeatureDetector::DetectorType agasttype);
 #endif //!(defined __i386__ || defined(_M_IX86) || defined __x86_64__ || defined(_M_X64))
 
 
-void makeAgastOffsets(int pixel[16], int row_stride, int type);
+void makeAgastOffsets(int pixel[16], int row_stride, AgastFeatureDetector::DetectorType type);
 
-template<int type>
+template<AgastFeatureDetector::DetectorType type>
 int agast_cornerScore(const uchar* ptr, const int pixel[], int threshold);
 
 

modules/features2d/src/akaze.cpp

@@ -60,8 +60,8 @@ namespace cv
     class AKAZE_Impl : public AKAZE
     {
     public:
-        AKAZE_Impl(int _descriptor_type, int _descriptor_size, int _descriptor_channels,
-                 float _threshold, int _octaves, int _sublevels, int _diffusivity)
+        AKAZE_Impl(DescriptorType _descriptor_type, int _descriptor_size, int _descriptor_channels,
+                 float _threshold, int _octaves, int _sublevels, KAZE::DiffusivityType _diffusivity)
         : descriptor(_descriptor_type)
         , descriptor_channels(_descriptor_channels)
         , descriptor_size(_descriptor_size)
@@ -77,8 +77,8 @@ namespace cv
 
         }
 
-        void setDescriptorType(int dtype) CV_OVERRIDE { descriptor = dtype; }
-        int getDescriptorType() const CV_OVERRIDE { return descriptor; }
+        void setDescriptorType(DescriptorType dtype) CV_OVERRIDE{ descriptor = dtype; }
+        DescriptorType getDescriptorType() const CV_OVERRIDE{ return descriptor; }
 
         void setDescriptorSize(int dsize) CV_OVERRIDE { descriptor_size = dsize; }
         int getDescriptorSize() const CV_OVERRIDE { return descriptor_size; }
@@ -95,8 +95,8 @@ namespace cv
         void setNOctaveLayers(int octaveLayers_) CV_OVERRIDE { sublevels = octaveLayers_; }
         int getNOctaveLayers() const CV_OVERRIDE { return sublevels; }
 
-        void setDiffusivity(int diff_) CV_OVERRIDE { diffusivity = diff_; }
-        int getDiffusivity() const CV_OVERRIDE { return diffusivity; }
+        void setDiffusivity(KAZE::DiffusivityType diff_) CV_OVERRIDE{ diffusivity = diff_; }
+        KAZE::DiffusivityType getDiffusivity() const CV_OVERRIDE{ return diffusivity; }
 
         // returns the descriptor size in bytes
         int descriptorSize() const CV_OVERRIDE
@@ -218,28 +218,28 @@ namespace cv
 
         void read(const FileNode& fn) CV_OVERRIDE
         {
-            descriptor = (int)fn["descriptor"];
+            descriptor = static_cast<DescriptorType>((int)fn["descriptor"]);
             descriptor_channels = (int)fn["descriptor_channels"];
             descriptor_size = (int)fn["descriptor_size"];
             threshold = (float)fn["threshold"];
             octaves = (int)fn["octaves"];
             sublevels = (int)fn["sublevels"];
-            diffusivity = (int)fn["diffusivity"];
+            diffusivity = static_cast<KAZE::DiffusivityType>((int)fn["diffusivity"]);
         }
 
-        int descriptor;
+        DescriptorType descriptor;
         int descriptor_channels;
         int descriptor_size;
         float threshold;
         int octaves;
         int sublevels;
-        int diffusivity;
+        KAZE::DiffusivityType diffusivity;
     };
 
-    Ptr<AKAZE> AKAZE::create(int descriptor_type,
+    Ptr<AKAZE> AKAZE::create(DescriptorType descriptor_type,
                              int descriptor_size, int descriptor_channels,
                              float threshold, int octaves,
-                             int sublevels, int diffusivity)
+                             int sublevels, KAZE::DiffusivityType diffusivity)
     {
         return makePtr<AKAZE_Impl>(descriptor_type, descriptor_size, descriptor_channels,
                                    threshold, octaves, sublevels, diffusivity);

modules/features2d/src/draw.cpp

@@ -50,12 +50,12 @@ namespace cv
 /*
  * Functions to draw keypoints and matches.
  */
-static inline void _drawKeypoint( InputOutputArray img, const KeyPoint& p, const Scalar& color, int flags )
+static inline void _drawKeypoint( InputOutputArray img, const KeyPoint& p, const Scalar& color, DrawMatchesFlags flags )
 {
     CV_Assert( !img.empty() );
     Point center( cvRound(p.pt.x * draw_multiplier), cvRound(p.pt.y * draw_multiplier) );
 
-    if( flags & DrawMatchesFlags::DRAW_RICH_KEYPOINTS )
+    if( !!(flags & DrawMatchesFlags::DRAW_RICH_KEYPOINTS) )
     {
         int radius = cvRound(p.size/2 * draw_multiplier); // KeyPoint::size is a diameter
 
@@ -89,7 +89,7 @@ static inline void _drawKeypoint( InputOutputArray img, const KeyPoint& p, const
 }
 
 void drawKeypoints( InputArray image, const std::vector<KeyPoint>& keypoints, InputOutputArray outImage,
-                    const Scalar& _color, int flags )
+                    const Scalar& _color, DrawMatchesFlags flags )
 {
     CV_INSTRUMENT_REGION();
 
@@ -125,12 +125,12 @@ void drawKeypoints( InputArray image, const std::vector<KeyPoint>& keypoints, In
 static void _prepareImgAndDrawKeypoints( InputArray img1, const std::vector<KeyPoint>& keypoints1,
                                          InputArray img2, const std::vector<KeyPoint>& keypoints2,
                                          InputOutputArray _outImg, Mat& outImg1, Mat& outImg2,
-                                         const Scalar& singlePointColor, int flags )
+                                         const Scalar& singlePointColor, DrawMatchesFlags flags )
 {
     Mat outImg;
     Size img1size = img1.size(), img2size = img2.size();
     Size size( img1size.width + img2size.width, MAX(img1size.height, img2size.height) );
-    if( flags & DrawMatchesFlags::DRAW_OVER_OUTIMG )
+    if( !!(flags & DrawMatchesFlags::DRAW_OVER_OUTIMG) )
     {
         outImg = _outImg.getMat();
         if( size.width > outImg.cols || size.height > outImg.rows )
@@ -169,7 +169,7 @@ static void _prepareImgAndDrawKeypoints( InputArray img1, const std::vector<KeyP
 }
 
 static inline void _drawMatch( InputOutputArray outImg, InputOutputArray outImg1, InputOutputArray outImg2 ,
-                          const KeyPoint& kp1, const KeyPoint& kp2, const Scalar& matchColor, int flags )
+                          const KeyPoint& kp1, const KeyPoint& kp2, const Scalar& matchColor, DrawMatchesFlags flags )
 {
     RNG& rng = theRNG();
     bool isRandMatchColor = matchColor == Scalar::all(-1);
@@ -192,7 +192,7 @@ void drawMatches( InputArray img1, const std::vector<KeyPoint>& keypoints1,
                   InputArray img2, const std::vector<KeyPoint>& keypoints2,
                   const std::vector<DMatch>& matches1to2, InputOutputArray outImg,
                   const Scalar& matchColor, const Scalar& singlePointColor,
-                  const std::vector<char>& matchesMask, int flags )
+                  const std::vector<char>& matchesMask, DrawMatchesFlags flags )
 {
     if( !matchesMask.empty() && matchesMask.size() != matches1to2.size() )
         CV_Error( Error::StsBadSize, "matchesMask must have the same size as matches1to2" );
@@ -221,7 +221,7 @@ void drawMatches( InputArray img1, const std::vector<KeyPoint>& keypoints1,
                   InputArray img2, const std::vector<KeyPoint>& keypoints2,
                   const std::vector<std::vector<DMatch> >& matches1to2, InputOutputArray outImg,
                   const Scalar& matchColor, const Scalar& singlePointColor,
-                  const std::vector<std::vector<char> >& matchesMask, int flags )
+                  const std::vector<std::vector<char> >& matchesMask, DrawMatchesFlags flags )
 {
     if( !matchesMask.empty() && matchesMask.size() != matches1to2.size() )
         CV_Error( Error::StsBadSize, "matchesMask must have the same size as matches1to2" );

modules/features2d/src/fast.cpp

@@ -415,7 +415,7 @@ static bool openvx_FAST(InputArray _img, std::vector<KeyPoint>& keypoints,
 
 #endif
 
-static inline int hal_FAST(cv::Mat& src, std::vector<KeyPoint>& keypoints, int threshold, bool nonmax_suppression, int type)
+static inline int hal_FAST(cv::Mat& src, std::vector<KeyPoint>& keypoints, int threshold, bool nonmax_suppression, FastFeatureDetector::DetectorType type)
 {
     if (threshold > 20)
         return CV_HAL_ERROR_NOT_IMPLEMENTED;
@@ -472,7 +472,7 @@ static inline int hal_FAST(cv::Mat& src, std::vector<KeyPoint>& keypoints, int t
     return CV_HAL_ERROR_OK;
 }
 
-void FAST(InputArray _img, std::vector<KeyPoint>& keypoints, int threshold, bool nonmax_suppression, int type)
+void FAST(InputArray _img, std::vector<KeyPoint>& keypoints, int threshold, bool nonmax_suppression, FastFeatureDetector::DetectorType type)
 {
     CV_INSTRUMENT_REGION();
 
@@ -514,8 +514,8 @@ void FAST(InputArray _img, std::vector<KeyPoint>& keypoints, int threshold, bool
 class FastFeatureDetector_Impl CV_FINAL : public FastFeatureDetector
 {
 public:
-    FastFeatureDetector_Impl( int _threshold, bool _nonmaxSuppression, int _type )
-    : threshold(_threshold), nonmaxSuppression(_nonmaxSuppression), type((short)_type)
+    FastFeatureDetector_Impl( int _threshold, bool _nonmaxSuppression, FastFeatureDetector::DetectorType _type )
+    : threshold(_threshold), nonmaxSuppression(_nonmaxSuppression), type(_type)
     {}
 
     void detect( InputArray _image, std::vector<KeyPoint>& keypoints, InputArray _mask ) CV_OVERRIDE
@@ -548,7 +548,7 @@ public:
         else if(prop == NONMAX_SUPPRESSION)
             nonmaxSuppression = value != 0;
         else if(prop == FAST_N)
-            type = cvRound(value);
+            type = static_cast<FastFeatureDetector::DetectorType>(cvRound(value));
         else
             CV_Error(Error::StsBadArg, "");
     }
@@ -560,7 +560,7 @@ public:
         if(prop == NONMAX_SUPPRESSION)
             return nonmaxSuppression;
         if(prop == FAST_N)
-            return type;
+            return static_cast<int>(type);
         CV_Error(Error::StsBadArg, "");
         return 0;
     }
@@ -571,15 +571,15 @@ public:
     void setNonmaxSuppression(bool f) CV_OVERRIDE { nonmaxSuppression = f; }
     bool getNonmaxSuppression() const CV_OVERRIDE { return nonmaxSuppression; }
 
-    void setType(int type_) CV_OVERRIDE { type = type_; }
-    int getType() const CV_OVERRIDE { return type; }
+    void setType(FastFeatureDetector::DetectorType type_) CV_OVERRIDE{ type = type_; }
+    FastFeatureDetector::DetectorType getType() const CV_OVERRIDE{ return type; }
 
     int threshold;
     bool nonmaxSuppression;
-    int type;
+    FastFeatureDetector::DetectorType type;
 };
 
-Ptr<FastFeatureDetector> FastFeatureDetector::create( int threshold, bool nonmaxSuppression, int type )
+Ptr<FastFeatureDetector> FastFeatureDetector::create( int threshold, bool nonmaxSuppression, FastFeatureDetector::DetectorType type )
 {
     return makePtr<FastFeatureDetector_Impl>(threshold, nonmaxSuppression, type);
 }

modules/features2d/src/hal_replacement.hpp

@@ -66,7 +66,7 @@
    @param width,height Source image dimensions
    @param type FAST type
 */
-inline int hal_ni_FAST_dense(const uchar* src_data, size_t src_step, uchar* dst_data, size_t dst_step, int width, int height, int type) { return CV_HAL_ERROR_NOT_IMPLEMENTED; }
+inline int hal_ni_FAST_dense(const uchar* src_data, size_t src_step, uchar* dst_data, size_t dst_step, int width, int height, cv::FastFeatureDetector::DetectorType type) { return CV_HAL_ERROR_NOT_IMPLEMENTED; }
 
 //! @cond IGNORED
 #define cv_hal_FAST_dense hal_ni_FAST_dense
@@ -94,7 +94,7 @@ inline int hal_ni_FAST_NMS(const uchar* src_data, size_t src_step, uchar* dst_da
    @param nonmax_suppression Indicates if make nonmaxima suppression or not.
    @param type FAST type
 */
-inline int hal_ni_FAST(const uchar* src_data, size_t src_step, int width, int height, uchar* keypoints_data, size_t* keypoints_count, int threshold, bool nonmax_suppression, int type) { return CV_HAL_ERROR_NOT_IMPLEMENTED; }
+inline int hal_ni_FAST(const uchar* src_data, size_t src_step, int width, int height, uchar* keypoints_data, size_t* keypoints_count, int threshold, bool nonmax_suppression, int /*cv::FastFeatureDetector::DetectorType*/ type) { return CV_HAL_ERROR_NOT_IMPLEMENTED; }
 
 //! @cond IGNORED
 #define cv_hal_FAST hal_ni_FAST

modules/features2d/src/kaze.cpp

@@ -57,7 +57,7 @@ namespace cv
     {
     public:
         KAZE_Impl(bool _extended, bool _upright, float _threshold, int _octaves,
-                   int _sublevels, int _diffusivity)
+                   int _sublevels, KAZE::DiffusivityType _diffusivity)
         : extended(_extended)
         , upright(_upright)
         , threshold(_threshold)
@@ -84,8 +84,8 @@ namespace cv
         void setNOctaveLayers(int octaveLayers_) CV_OVERRIDE { sublevels = octaveLayers_; }
         int getNOctaveLayers() const CV_OVERRIDE { return sublevels; }
 
-        void setDiffusivity(int diff_) CV_OVERRIDE { diffusivity = diff_; }
-        int getDiffusivity() const CV_OVERRIDE { return diffusivity; }
+        void setDiffusivity(KAZE::DiffusivityType diff_) CV_OVERRIDE{ diffusivity = diff_; }
+        KAZE::DiffusivityType getDiffusivity() const CV_OVERRIDE{ return diffusivity; }
 
         // returns the descriptor size in bytes
         int descriptorSize() const CV_OVERRIDE
@@ -178,7 +178,7 @@ namespace cv
             threshold = (float)fn["threshold"];
             octaves = (int)fn["octaves"];
             sublevels = (int)fn["sublevels"];
-            diffusivity = (int)fn["diffusivity"];
+            diffusivity = static_cast<KAZE::DiffusivityType>((int)fn["diffusivity"]);
         }
 
         bool extended;
@@ -186,13 +186,13 @@ namespace cv
         float threshold;
         int octaves;
         int sublevels;
-        int diffusivity;
+        KAZE::DiffusivityType diffusivity;
     };
 
     Ptr<KAZE> KAZE::create(bool extended, bool upright,
                             float threshold,
                             int octaves, int sublevels,
-                            int diffusivity)
+                            KAZE::DiffusivityType diffusivity)
     {
         return makePtr<KAZE_Impl>(extended, upright, threshold, octaves, sublevels, diffusivity);
     }

modules/features2d/src/kaze/AKAZEConfig.h

@@ -45,12 +45,12 @@ struct AKAZEOptions {
     float soffset;                  ///< Base scale offset (sigma units)
     float derivative_factor;        ///< Factor for the multiscale derivatives
     float sderivatives;             ///< Smoothing factor for the derivatives
-    int diffusivity;   ///< Diffusivity type
+    KAZE::DiffusivityType diffusivity;   ///< Diffusivity type
 
     float dthreshold;               ///< Detector response threshold to accept point
     float min_dthreshold;           ///< Minimum detector threshold to accept a point
 
-    int descriptor;     ///< Type of descriptor
+    AKAZE::DescriptorType descriptor;     ///< Type of descriptor
     int descriptor_size;            ///< Size of the descriptor in bits. 0->Full size
     int descriptor_channels;        ///< Number of channels in the descriptor (1, 2, 3)
     int descriptor_pattern_size;    ///< Actual patch size is 2*pattern_size*point.scale

modules/features2d/src/kaze/AKAZEFeatures.cpp

@@ -377,7 +377,7 @@ ocl_pm_g2(InputArray Lx_, InputArray Ly_, OutputArray Lflow_, float kcontrast)
 #endif // HAVE_OPENCL
 
 static inline void
-compute_diffusivity(InputArray Lx, InputArray Ly, OutputArray Lflow, float kcontrast, int diffusivity)
+compute_diffusivity(InputArray Lx, InputArray Ly, OutputArray Lflow, float kcontrast, KAZE::DiffusivityType diffusivity)
 {
   CV_INSTRUMENT_REGION();
 
@@ -398,7 +398,7 @@ compute_diffusivity(InputArray Lx, InputArray Ly, OutputArray Lflow, float kcont
       charbonnier_diffusivity(Lx, Ly, Lflow, kcontrast);
     break;
     default:
-      CV_Error(diffusivity, "Diffusivity is not supported");
+      CV_Error_(Error::StsError, ("Diffusivity is not supported: %d", static_cast<int>(diffusivity)));
     break;
   }
 }

modules/features2d/src/kaze/KAZEConfig.h

@@ -36,7 +36,7 @@ struct KAZEOptions {
     {
     }
 
-    int diffusivity;
+    KAZE::DiffusivityType diffusivity;
     float soffset;
     int omax;
     int nsublevels;

modules/features2d/src/matchers.cpp

@@ -1049,7 +1049,7 @@ Ptr<DescriptorMatcher> DescriptorMatcher::create( const String& descriptorMatche
     return dm;
 }
 
-Ptr<DescriptorMatcher> DescriptorMatcher::create(int matcherType)
+Ptr<DescriptorMatcher> DescriptorMatcher::create( const MatcherType& matcherType )
 {
 
 

modules/features2d/src/orb.cpp

@@ -655,7 +655,7 @@ class ORB_Impl CV_FINAL : public ORB
 {
 public:
     explicit ORB_Impl(int _nfeatures, float _scaleFactor, int _nlevels, int _edgeThreshold,
-             int _firstLevel, int _WTA_K, int _scoreType, int _patchSize, int _fastThreshold) :
+             int _firstLevel, int _WTA_K, ORB::ScoreType _scoreType, int _patchSize, int _fastThreshold) :
         nfeatures(_nfeatures), scaleFactor(_scaleFactor), nlevels(_nlevels),
         edgeThreshold(_edgeThreshold), firstLevel(_firstLevel), wta_k(_WTA_K),
         scoreType(_scoreType), patchSize(_patchSize), fastThreshold(_fastThreshold)
@@ -679,8 +679,8 @@ public:
     void setWTA_K(int wta_k_) CV_OVERRIDE { wta_k = wta_k_; }
     int getWTA_K() const CV_OVERRIDE { return wta_k; }
 
-    void setScoreType(int scoreType_) CV_OVERRIDE { scoreType = scoreType_; }
-    int getScoreType() const CV_OVERRIDE { return scoreType; }
+    void setScoreType(ORB::ScoreType scoreType_) CV_OVERRIDE{ scoreType = scoreType_; }
+    ORB::ScoreType getScoreType() const CV_OVERRIDE{ return scoreType; }
 
     void setPatchSize(int patchSize_) CV_OVERRIDE { patchSize = patchSize_; }
     int getPatchSize() const CV_OVERRIDE { return patchSize; }
@@ -707,7 +707,7 @@ protected:
     int edgeThreshold;
     int firstLevel;
     int wta_k;
-    int scoreType;
+    ORB::ScoreType scoreType;
     int patchSize;
     int fastThreshold;
 };
@@ -775,7 +775,7 @@ static void computeKeyPoints(const Mat& imagePyramid,
                              const std::vector<float>& layerScale,
                              std::vector<KeyPoint>& allKeypoints,
                              int nfeatures, double scaleFactor,
-                             int edgeThreshold, int patchSize, int scoreType,
+                             int edgeThreshold, int patchSize, ORB::ScoreType scoreType,
                              bool useOCL, int fastThreshold  )
 {
 #ifndef HAVE_OPENCL
@@ -1195,7 +1195,7 @@ void ORB_Impl::detectAndCompute( InputArray _image, InputArray _mask,
 }
 
 Ptr<ORB> ORB::create(int nfeatures, float scaleFactor, int nlevels, int edgeThreshold,
-           int firstLevel, int wta_k, int scoreType, int patchSize, int fastThreshold)
+           int firstLevel, int wta_k, ORB::ScoreType scoreType, int patchSize, int fastThreshold)
 {
     CV_Assert(firstLevel >= 0);
     return makePtr<ORB_Impl>(nfeatures, scaleFactor, nlevels, edgeThreshold,