diff --git a/modules/line_descriptor/include/opencv2/line_descriptor/descriptor.hpp b/modules/line_descriptor/include/opencv2/line_descriptor/descriptor.hpp index 0fd78c25e..1d973d664 100644 --- a/modules/line_descriptor/include/opencv2/line_descriptor/descriptor.hpp +++ b/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 ¶meters = BinaryDescriptor::Params() ); /* constructors with smart pointers */ - CV_WRAP - static Ptr createBinaryDescriptor();CV_WRAP + /*CV_WRAP*/ + static Ptr createBinaryDescriptor();/*CV_WRAP*/ static Ptr 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& keypoints, const Mat& mask = Mat() ); /* requires line detection (more than one image) */ - CV_WRAP + /*CV_WRAP*/ void detect( const std::vector& images, std::vector >& keylines, const std::vector& masks = std::vector() ) const; /* requires descriptors computation (only one image) */ - CV_WRAP + /*CV_WRAP*/ void compute( const Mat& image, CV_OUT CV_IN_OUT std::vector& 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& images, std::vector >& keylines, std::vector& 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& 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 createLSDDetector(); /* requires line detection (only one image) */ - CV_WRAP + /*CV_WRAP*/ void detect( const Mat& image, CV_OUT std::vector& 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& images, std::vector >& keylines, int scale, int numOctaves, const std::vector& masks = std::vector() ) 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& 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& matches, const std::vector& masks = std::vector() ); /* 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 >& 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 >& matches, int k, const std::vector& masks = std::vector(), 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 >& 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 >& matches, float maxDistance, const std::vector& masks = std::vector(), bool compactResult = false ); /* store new descriptors to be inserted in dataset */ - CV_WRAP + /*CV_WRAP*/ void add( const std::vector& descriptors ); /* store new descriptors into dataset */ - CV_WRAP + /*CV_WRAP*/ void train(); /* constructor with smart pointer */ - CV_WRAP + /*CV_WRAP*/ static Ptr 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& keylines1, const Mat& img2, const std::vector& keylines2, +CV_EXPORTS void drawLineMatches( const Mat& img1, const std::vector& keylines1, const Mat& img2, const std::vector& keylines2, const std::vector& matches1to2, Mat& outImg, const Scalar& matchColor = Scalar::all( -1 ), const Scalar& singleLineColor = Scalar::all( -1 ), const std::vector& matchesMask = std::vector(), int flags = DrawLinesMatchesFlags::DEFAULT ); /* draw extracted lines on original image */ -CV_EXPORTS_W void drawKeylines( const Mat& image, const std::vector& keylines, Mat& outImage, const Scalar& color = Scalar::all( -1 ), +CV_EXPORTS void drawKeylines( const Mat& image, const std::vector& keylines, Mat& outImage, const Scalar& color = Scalar::all( -1 ), int flags = DrawLinesMatchesFlags::DEFAULT ); } diff --git a/modules/line_descriptor/samples/lsd_lines_extraction.cpp b/modules/line_descriptor/samples/lsd_lines_extraction.cpp new file mode 100644 index 000000000..60b25bb18 --- /dev/null +++ b/modules/line_descriptor/samples/lsd_lines_extraction.cpp @@ -0,0 +1,123 @@ +/*M/////////////////////////////////////////////////////////////////////////////////////// + // + // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. + // + // By downloading, copying, installing or using the software you agree to this license. + // If you do not agree to this license, do not download, install, + // copy or use the software. + // + // + // License Agreement + // For Open Source Computer Vision Library + // + // Copyright (C) 2014, Biagio Montesano, all rights reserved. + // Third party copyrights are property of their respective owners. + // + // Redistribution and use in source and binary forms, with or without modification, + // are permitted provided that the following conditions are met: + // + // * Redistribution's of source code must retain the above copyright notice, + // this list of conditions and the following disclaimer. + // + // * Redistribution's in binary form must reproduce the above copyright notice, + // this list of conditions and the following disclaimer in the documentation + // and/or other materials provided with the distribution. + // + // * The name of the copyright holders may not be used to endorse or promote products + // derived from this software without specific prior written permission. + // + // This software is provided by the copyright holders and contributors "as is" and + // any express or implied warranties, including, but not limited to, the implied + // warranties of merchantability and fitness for a particular purpose are disclaimed. + // In no event shall the Intel Corporation or contributors be liable for any direct, + // indirect, incidental, special, exemplary, or consequential damages + // (including, but not limited to, procurement of substitute goods or services; + // loss of use, data, or profits; or business interruption) however caused + // and on any theory of liability, whether in contract, strict liability, + // or tort (including negligence or otherwise) arising in any way out of + // the use of this software, even if advised of the possibility of such damage. + // + //M*/ + +#include + +#include "opencv2/core/utility.hpp" +#include "opencv2/core/private.hpp" +#include +#include +#include + +#include + +using namespace cv; +using namespace std; + +static const char* keys = +{ "{@image_path | | Image path }" }; + +static void help() +{ + cout << "\nThis example shows the functionalities of lines extraction " << "furnished by BinaryDescriptor class\n" + << "Please, run this sample using a command in the form\n" << "./example_line_descriptor_lines_extraction " << endl; +} + +int main( int argc, char** argv ) +{ + /* get parameters from comand line */ + CommandLineParser parser( argc, argv, keys ); + String image_path = parser.get( 0 ); + + if( image_path.empty() ) + { + help(); + return -1; + } + + /* load image */ + cv::Mat imageMat = imread( image_path, 1 ); + if( imageMat.data == NULL ) + { + std::cout << "Error, image could not be loaded. Please, check its path" << std::endl; + return -1; + } + + /* create a random binary mask */ + cv::Mat mask = Mat::ones( imageMat.size(), CV_8UC1 ); + + /* create a pointer to a BinaryDescriptor object with deafult parameters */ + Ptr bd = LSDDetector::createLSDDetector(); + + /* create a structure to store extracted lines */ + vector lines; + + /* extract lines */ + cv::Mat output = imageMat.clone(); + bd->detect( imageMat, lines, 2, 1, mask ); + + /* draw lines extracted from octave 0 */ + if( output.channels() == 1 ) + cvtColor( output, output, COLOR_GRAY2BGR ); + for ( size_t i = 0; i < lines.size(); i++ ) + { + KeyLine kl = lines[i]; + if( kl.octave == 0) + { + /* get a random color */ + int R = ( rand() % (int) ( 255 + 1 ) ); + int G = ( rand() % (int) ( 255 + 1 ) ); + int B = ( rand() % (int) ( 255 + 1 ) ); + + /* get extremes of line */ + Point pt1 = Point2f( kl.startPointX, kl.startPointY ); + Point pt2 = Point2f( kl.endPointX, kl.endPointY ); + + /* draw line */ + line( output, pt1, pt2, Scalar( B, G, R ), 3 ); + } + + } + + /* show lines on image */ + imshow( "LSD lines", output ); + waitKey(); +} diff --git a/modules/line_descriptor/samples/matching.cpp b/modules/line_descriptor/samples/matching.cpp index 568d65274..4d1c3a75e 100644 --- a/modules/line_descriptor/samples/matching.cpp +++ b/modules/line_descriptor/samples/matching.cpp @@ -146,7 +146,7 @@ int main( int argc, char** argv ) imshow( "Matches", outImg ); waitKey(); - + imwrite("/home/ubisum/Desktop/images/matches.jpg", outImg); /* create an LSD detector */ Ptr lsd = LSDDetector::createLSDDetector();