Added LSD sample. Removed python macros.

modules/line_descriptor/include/opencv2/line_descriptor/descriptor.hpp

@@ -62,155 +62,155 @@ struct CV_EXPORTS KeyLine
 {
  public:
   /* orientation of the line */
-  CV_PROP_RW
+  /*CV_PROP_RW*/
   float angle;
 
   /* object ID, that can be used to cluster keylines by the line they represent */
-  CV_PROP_RW
+  /*CV_PROP_RW*/
   int class_id;
 
   /* octave (pyramid layer), from which the keyline has been extracted */
-  CV_PROP_RW
+  /*CV_PROP_RW*/
   int octave;
 
   /* coordinates of the middlepoint */
-  CV_PROP_RW
+  /*CV_PROP_RW*/
   Point2f pt;
 
   /* the response, by which the strongest keylines have been selected.
    It's represented by the ratio between line's length and maximum between
    image's width and height */
-  CV_PROP_RW
+  /*CV_PROP_RW*/
   float response;
 
   /* minimum area containing line */
-  CV_PROP_RW
+  /*CV_PROP_RW*/
   float size;
 
   /* lines's extremes in original image */
-  CV_PROP_RW
-  float startPointX;CV_PROP_RW
-  float startPointY;CV_PROP_RW
-  float endPointX;CV_PROP_RW
+  /*CV_PROP_RW*/
+  float startPointX;/*CV_PROP_RW*/
+  float startPointY;/*CV_PROP_RW*/
+  float endPointX;/*CV_PROP_RW*/
   float endPointY;
 
   /* line's extremes in image it was extracted from */
-  CV_PROP_RW
-  float sPointInOctaveX;CV_PROP_RW
-  float sPointInOctaveY;CV_PROP_RW
-  float ePointInOctaveX;CV_PROP_RW
+  /*CV_PROP_RW*/
+  float sPointInOctaveX;/*CV_PROP_RW*/
+  float sPointInOctaveY;/*CV_PROP_RW*/
+  float ePointInOctaveX;/*CV_PROP_RW*/
   float ePointInOctaveY;
 
   /* the length of line */
-  CV_PROP_RW
+  /*CV_PROP_RW*/
   float lineLength;
 
   /* number of pixels covered by the line */
-  CV_PROP_RW
+  /*CV_PROP_RW*/
   int numOfPixels;
 
   /* constructor */
-  CV_WRAP
+  /*CV_WRAP*/
   KeyLine()
   {
   }
 };
 
-class CV_EXPORTS_W BinaryDescriptor : public Algorithm
+class CV_EXPORTS BinaryDescriptor : public Algorithm
 {
 
  public:
   struct CV_EXPORTS Params
   {
-    CV_WRAP
+    /*CV_WRAP*/
     Params();
 
     /* the number of image octaves (default = 1) */
-    CV_PROP_RW
+    /*CV_PROP_RW*/
     int numOfOctave_;
 
     /* the width of band; (default: 7) */
-    CV_PROP_RW
+    /*CV_PROP_RW*/
     int widthOfBand_;
 
     /* image's reduction ratio in construction of Gaussian pyramids */
-    CV_PROP_RW
+    /*CV_PROP_RW*/
     int reductionRatio;
 
-    CV_PROP_RW
+    /*CV_PROP_RW*/
     int ksize_;
 
     /* read parameters from a FileNode object and store them (struct function) */
-    CV_WRAP
+    /*CV_WRAP*/
     void read( const FileNode& fn );
 
     /* store parameters to a FileStorage object (struct function) */
-    CV_WRAP
+    /*CV_WRAP*/
     void write( FileStorage& fs ) const;
 
   };
 
   /* constructor */
-  CV_WRAP
+  /*CV_WRAP*/
   BinaryDescriptor( const BinaryDescriptor::Params &parameters = BinaryDescriptor::Params() );
 
   /* constructors with smart pointers */
-  CV_WRAP
-  static Ptr<BinaryDescriptor> createBinaryDescriptor();CV_WRAP
+  /*CV_WRAP*/
+  static Ptr<BinaryDescriptor> createBinaryDescriptor();/*CV_WRAP*/
   static Ptr<BinaryDescriptor> createBinaryDescriptor( Params parameters );
 
   /* destructor */
   ~BinaryDescriptor();
 
   /* setters and getters */
-  CV_WRAP
-  int getNumOfOctaves();CV_WRAP
-  void setNumOfOctaves( int octaves );CV_WRAP
-  int getWidthOfBand();CV_WRAP
-  void setWidthOfBand( int width );CV_WRAP
-  int getReductionRatio();CV_WRAP
+  /*CV_WRAP*/
+  int getNumOfOctaves();/*CV_WRAP*/
+  void setNumOfOctaves( int octaves );/*CV_WRAP*/
+  int getWidthOfBand();/*CV_WRAP*/
+  void setWidthOfBand( int width );/*CV_WRAP*/
+  int getReductionRatio();/*CV_WRAP*/
   void setReductionRatio( int rRatio );
 
   /* reads parameters from a FileNode object and store them (class function ) */
-  CV_WRAP
+  /*CV_WRAP*/
   virtual void read( const cv::FileNode& fn );
 
   /* stores parameters to a FileStorage object (class function) */
-  CV_WRAP
+  /*CV_WRAP*/
   virtual void write( cv::FileStorage& fs ) const;
 
   /* requires line detection (only one image) */
-  CV_WRAP
+  /*CV_WRAP*/
   void detect( const Mat& image, CV_OUT std::vector<KeyLine>& keypoints, const Mat& mask = Mat() );
 
   /* requires line detection (more than one image) */
-  CV_WRAP
+  /*CV_WRAP*/
   void detect( const std::vector<Mat>& images, std::vector<std::vector<KeyLine> >& keylines, const std::vector<Mat>& masks =
                    std::vector<Mat>() ) const;
 
   /* requires descriptors computation (only one image) */
-  CV_WRAP
+  /*CV_WRAP*/
   void compute( const Mat& image, CV_OUT CV_IN_OUT std::vector<KeyLine>& keylines, CV_OUT Mat& descriptors, bool returnFloatDescr = false ) const;
 
   /* requires descriptors computation (more than one image) */
-  CV_WRAP
+  /*CV_WRAP*/
   void compute( const std::vector<Mat>& images, std::vector<std::vector<KeyLine> >& keylines, std::vector<Mat>& descriptors, bool returnFloatDescr =
                     false ) const;
 
   /* returns descriptor size */
-  CV_WRAP
+  /*CV_WRAP*/
   int descriptorSize() const;
 
   /* returns data type */
-  CV_WRAP
+  /*CV_WRAP*/
   int descriptorType() const;
 
   /* returns norm mode */
-  CV_WRAP
+  /*CV_WRAP*/
   int defaultNorm() const;
 
   /* definition of operator () */
-  CV_WRAP_AS(detectAndCompute)
+  //CV_WRAP_AS(detectAndCompute)
   virtual void operator()( InputArray image, InputArray mask, CV_OUT std::vector<KeyLine>& keylines, OutputArray descriptors,
                            bool useProvidedKeyLines = false, bool returnFloatDescr = false ) const;
 
@@ -268,27 +268,27 @@ class CV_EXPORTS_W BinaryDescriptor : public Algorithm
 
 };
 
-class CV_EXPORTS_W LSDDetector : public Algorithm
+class CV_EXPORTS LSDDetector : public Algorithm
 {
  public:
 
   /* constructor */
-  CV_WRAP
+  /*CV_WRAP*/
   LSDDetector()
   {
   }
   ;
 
   /* constructor with smart pointer */
-  CV_WRAP
+  /*CV_WRAP*/
   static Ptr<LSDDetector> createLSDDetector();
 
   /* requires line detection (only one image) */
-  CV_WRAP
+  /*CV_WRAP*/
   void detect( const Mat& image, CV_OUT std::vector<KeyLine>& keypoints, int scale, int numOctaves, const Mat& mask = Mat() );
 
   /* requires line detection (more than one image) */
-  CV_WRAP
+  /*CV_WRAP*/
   void detect( const std::vector<Mat>& images, std::vector<std::vector<KeyLine> >& keylines, int scale, int numOctaves,
                const std::vector<Mat>& masks = std::vector<Mat>() ) const;
 
@@ -307,63 +307,63 @@ class CV_EXPORTS_W LSDDetector : public Algorithm
   AlgorithmInfo* info() const;
 };
 
-class CV_EXPORTS_W BinaryDescriptorMatcher : public Algorithm
+class CV_EXPORTS BinaryDescriptorMatcher : public Algorithm
 {
 
  public:
   /* for every input descriptor,
    find the best matching one (for a pair of images) */
-  CV_WRAP
+  /*CV_WRAP*/
   void match( const Mat& queryDescriptors, const Mat& trainDescriptors, std::vector<DMatch>& matches, const Mat& mask = Mat() ) const;
 
   /* for every input descriptor,
    find the best matching one (from one image to a set) */
-  CV_WRAP
+  /*CV_WRAP*/
   void match( const Mat& queryDescriptors, std::vector<DMatch>& matches, const std::vector<Mat>& masks = std::vector<Mat>() );
 
   /* for every input descriptor,
    find the best k matching descriptors (for a pair of images) */
-  CV_WRAP
+  /*CV_WRAP*/
   void knnMatch( const Mat& queryDescriptors, const Mat& trainDescriptors, std::vector<std::vector<DMatch> >& matches, int k, const Mat& mask = Mat(),
                  bool compactResult = false ) const;
 
   /* for every input descriptor,
    find the best k matching descriptors (from one image to a set) */
-  CV_WRAP
+  /*CV_WRAP*/
   void knnMatch( const Mat& queryDescriptors, std::vector<std::vector<DMatch> >& matches, int k, const std::vector<Mat>& masks = std::vector<Mat>(),
                  bool compactResult = false );
 
   /* for every input descriptor, find all the ones falling in a
    certain matching radius (for a pair of images) */
-  CV_WRAP
+  /*CV_WRAP*/
   void radiusMatch( const Mat& queryDescriptors, const Mat& trainDescriptors, std::vector<std::vector<DMatch> >& matches, float maxDistance,
                     const Mat& mask = Mat(), bool compactResult = false ) const;
 
   /* for every input descriptor, find all the ones falling in a
    certain matching radius (from one image to a set) */
-  CV_WRAP
+  /*CV_WRAP*/
   void radiusMatch( const Mat& queryDescriptors, std::vector<std::vector<DMatch> >& matches, float maxDistance, const std::vector<Mat>& masks =
                         std::vector<Mat>(),
                     bool compactResult = false );
 
   /* store new descriptors to be inserted in dataset */
-  CV_WRAP
+  /*CV_WRAP*/
   void add( const std::vector<Mat>& descriptors );
 
   /* store new descriptors into dataset */
-  CV_WRAP
+  /*CV_WRAP*/
   void train();
 
   /* constructor with smart pointer */
-  CV_WRAP
+  /*CV_WRAP*/
   static Ptr<BinaryDescriptorMatcher> createBinaryDescriptorMatcher();
 
   /* clear dataset and internal data */
-  CV_WRAP
+  /*CV_WRAP*/
   void clear();
 
   /* constructor */
-  CV_WRAP
+  /*CV_WRAP*/
   BinaryDescriptorMatcher();
 
   /* destructor */
@@ -420,13 +420,13 @@ struct CV_EXPORTS DrawLinesMatchesFlags
 };
 
 /* draw matches between two images */
-CV_EXPORTS_W void drawLineMatches( const Mat& img1, const std::vector<KeyLine>& keylines1, const Mat& img2, const std::vector<KeyLine>& keylines2,
+CV_EXPORTS void drawLineMatches( const Mat& img1, const std::vector<KeyLine>& keylines1, const Mat& img2, const std::vector<KeyLine>& keylines2,
                                    const std::vector<DMatch>& matches1to2, Mat& outImg, const Scalar& matchColor = Scalar::all( -1 ),
                                    const Scalar& singleLineColor = Scalar::all( -1 ), const std::vector<char>& matchesMask = std::vector<char>(),
                                    int flags = DrawLinesMatchesFlags::DEFAULT );
 
 /* draw extracted lines on original image */
-CV_EXPORTS_W void drawKeylines( const Mat& image, const std::vector<KeyLine>& keylines, Mat& outImage, const Scalar& color = Scalar::all( -1 ),
+CV_EXPORTS void drawKeylines( const Mat& image, const std::vector<KeyLine>& keylines, Mat& outImage, const Scalar& color = Scalar::all( -1 ),
                                 int flags = DrawLinesMatchesFlags::DEFAULT );
 
 }