opencv/opencv_contrib
1
0
Fork 0
mirror of https://github.com/opencv/opencv_contrib.git synced 2025-10-18 17:24:28 +08:00
Code Issues Releases Wiki Activity

Added LSD sample. Removed python macros.

Browse Source
This commit is contained in:
biagio montesano
2014-08-12 16:17:24 +02:00
parent 4c0d7579ad
commit 30ed727767
3 changed files with 187 additions and 64 deletions
Download Patch File Download Diff File Expand all files Collapse all files

126
modules/line_descriptor/include/opencv2/line_descriptor/descriptor.hpp
View File

@@ -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 );
}

123
modules/line_descriptor/samples/lsd_lines_extraction.cpp Normal file
View File

@@ -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 <opencv2/line_descriptor.hpp>
#include "opencv2/core/utility.hpp"
#include "opencv2/core/private.hpp"
#include <opencv2/imgproc.hpp>
#include <opencv2/features2d.hpp>
#include <opencv2/highgui.hpp>
#include <iostream>
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 <path_to_input_image>" << endl;
}
int main( int argc, char** argv )
{
/* get parameters from comand line */
CommandLineParser parser( argc, argv, keys );
String image_path = parser.get<String>( 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<LSDDetector> bd = LSDDetector::createLSDDetector();
/* create a structure to store extracted lines */
vector<KeyLine> 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();
}

2
modules/line_descriptor/samples/matching.cpp
View File

@@ -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<LSDDetector> lsd = LSDDetector::createLSDDetector();