lot's of changes; nonfree & photo modules added; SIFT & SURF -> nonfree module; Inpainting -> photo; refactored features2d (ORB is still failing tests), optimized brute-force matcher and made it non-template.
This commit is contained in:
Vadim Pisarevsky
@@ -45,6 +45,7 @@ using namespace std;
|
||||
|
||||
namespace cv
|
||||
{
|
||||
|
||||
/*
|
||||
* FeatureDetector
|
||||
*/
|
||||
@@ -71,11 +72,11 @@ void FeatureDetector::detect(const vector<Mat>& imageCollection, vector<vector<K
|
||||
detect( imageCollection[i], pointCollection[i], masks.empty() ? Mat() : masks[i] );
|
||||
}
|
||||
|
||||
void FeatureDetector::read( const FileNode& )
|
||||
/*void FeatureDetector::read( const FileNode& )
|
||||
{}
|
||||
|
||||
void FeatureDetector::write( FileStorage& ) const
|
||||
{}
|
||||
{}*/
|
||||
|
||||
bool FeatureDetector::empty() const
|
||||
{
|
||||
@@ -89,387 +90,91 @@ void FeatureDetector::removeInvalidPoints( const Mat& mask, vector<KeyPoint>& ke
|
||||
|
||||
Ptr<FeatureDetector> FeatureDetector::create( const string& detectorType )
|
||||
{
|
||||
FeatureDetector* fd = 0;
|
||||
size_t pos = 0;
|
||||
|
||||
if( !detectorType.compare( "FAST" ) )
|
||||
if( detectorType.find("Grid") == 0 )
|
||||
{
|
||||
fd = new FastFeatureDetector();
|
||||
return new GridAdaptedFeatureDetector(FeatureDetector::create(
|
||||
detectorType.substr(strlen("Grid"))));
|
||||
}
|
||||
else if( !detectorType.compare( "STAR" ) )
|
||||
|
||||
if( detectorType.find("Pyramid") == 0 )
|
||||
{
|
||||
fd = new StarFeatureDetector();
|
||||
return new PyramidAdaptedFeatureDetector(FeatureDetector::create(
|
||||
detectorType.substr(strlen("Pyramid"))));
|
||||
}
|
||||
else if( !detectorType.compare( "SIFT" ) )
|
||||
|
||||
if( detectorType.find("Dynamic") == 0 )
|
||||
{
|
||||
fd = new SiftFeatureDetector();
|
||||
return new DynamicAdaptedFeatureDetector(AdjusterAdapter::create(
|
||||
detectorType.substr(strlen("Dynamic"))));
|
||||
}
|
||||
else if( !detectorType.compare( "SURF" ) )
|
||||
|
||||
if( detectorType.compare( "HARRIS" ) == 0 )
|
||||
{
|
||||
fd = new SurfFeatureDetector();
|
||||
}
|
||||
else if( !detectorType.compare( "ORB" ) )
|
||||
{
|
||||
fd = new OrbFeatureDetector();
|
||||
}
|
||||
else if( !detectorType.compare( "MSER" ) )
|
||||
{
|
||||
fd = new MserFeatureDetector();
|
||||
}
|
||||
else if( !detectorType.compare( "GFTT" ) )
|
||||
{
|
||||
fd = new GoodFeaturesToTrackDetector();
|
||||
}
|
||||
else if( !detectorType.compare( "HARRIS" ) )
|
||||
{
|
||||
GoodFeaturesToTrackDetector::Params params;
|
||||
params.useHarrisDetector = true;
|
||||
fd = new GoodFeaturesToTrackDetector(params);
|
||||
}
|
||||
else if( !detectorType.compare( "Dense" ) )
|
||||
{
|
||||
fd = new DenseFeatureDetector();
|
||||
}
|
||||
else if( !detectorType.compare( "SimpleBlob" ) )
|
||||
{
|
||||
fd = new SimpleBlobDetector();
|
||||
}
|
||||
else if( (pos=detectorType.find("Grid")) == 0 )
|
||||
{
|
||||
pos += string("Grid").size();
|
||||
fd = new GridAdaptedFeatureDetector( FeatureDetector::create(detectorType.substr(pos)) );
|
||||
}
|
||||
else if( (pos=detectorType.find("Pyramid")) == 0 )
|
||||
{
|
||||
pos += string("Pyramid").size();
|
||||
fd = new PyramidAdaptedFeatureDetector( FeatureDetector::create(detectorType.substr(pos)) );
|
||||
}
|
||||
else if( (pos=detectorType.find("Dynamic")) == 0 )
|
||||
{
|
||||
pos += string("Dynamic").size();
|
||||
fd = new DynamicAdaptedFeatureDetector( AdjusterAdapter::create(detectorType.substr(pos)) );
|
||||
Ptr<FeatureDetector> fd = FeatureDetector::create("GFTT");
|
||||
fd->set("useHarrisDetector", true);
|
||||
return fd;
|
||||
}
|
||||
|
||||
return fd;
|
||||
return Algorithm::create<FeatureDetector>("Feature2D." + detectorType);
|
||||
}
|
||||
|
||||
/*
|
||||
* FastFeatureDetector
|
||||
*/
|
||||
FastFeatureDetector::FastFeatureDetector( int _threshold, bool _nonmaxSuppression )
|
||||
: threshold(_threshold), nonmaxSuppression(_nonmaxSuppression)
|
||||
{}
|
||||
|
||||
void FastFeatureDetector::read (const FileNode& fn)
|
||||
{
|
||||
threshold = fn["threshold"];
|
||||
nonmaxSuppression = (int)fn["nonmaxSuppression"] ? true : false;
|
||||
}
|
||||
|
||||
void FastFeatureDetector::write (FileStorage& fs) const
|
||||
{
|
||||
fs << "threshold" << threshold;
|
||||
fs << "nonmaxSuppression" << nonmaxSuppression;
|
||||
}
|
||||
|
||||
void FastFeatureDetector::detectImpl( const Mat& image, vector<KeyPoint>& keypoints, const Mat& mask ) const
|
||||
{
|
||||
Mat grayImage = image;
|
||||
if( image.type() != CV_8U ) cvtColor( image, grayImage, CV_BGR2GRAY );
|
||||
FAST( grayImage, keypoints, threshold, nonmaxSuppression );
|
||||
KeyPointsFilter::runByPixelsMask( keypoints, mask );
|
||||
}
|
||||
|
||||
/*
|
||||
* GoodFeaturesToTrackDetector
|
||||
*/
|
||||
GoodFeaturesToTrackDetector::Params::Params( int _maxCorners, double _qualityLevel, double _minDistance,
|
||||
int _blockSize, bool _useHarrisDetector, double _k ) :
|
||||
maxCorners(_maxCorners), qualityLevel(_qualityLevel), minDistance(_minDistance),
|
||||
GFTTDetector::GFTTDetector( int _nfeatures, double _qualityLevel,
|
||||
double _minDistance, int _blockSize,
|
||||
bool _useHarrisDetector, double _k )
|
||||
: nfeatures(_nfeatures), qualityLevel(_qualityLevel), minDistance(_minDistance),
|
||||
blockSize(_blockSize), useHarrisDetector(_useHarrisDetector), k(_k)
|
||||
{}
|
||||
|
||||
void GoodFeaturesToTrackDetector::Params::read (const FileNode& fn)
|
||||
{
|
||||
maxCorners = fn["maxCorners"];
|
||||
qualityLevel = fn["qualityLevel"];
|
||||
minDistance = fn["minDistance"];
|
||||
blockSize = fn["blockSize"];
|
||||
useHarrisDetector = (int)fn["useHarrisDetector"] != 0;
|
||||
k = fn["k"];
|
||||
}
|
||||
|
||||
void GoodFeaturesToTrackDetector::Params::write (FileStorage& fs) const
|
||||
{
|
||||
fs << "maxCorners" << maxCorners;
|
||||
fs << "qualityLevel" << qualityLevel;
|
||||
fs << "minDistance" << minDistance;
|
||||
fs << "blockSize" << blockSize;
|
||||
fs << "useHarrisDetector" << useHarrisDetector;
|
||||
fs << "k" << k;
|
||||
}
|
||||
|
||||
GoodFeaturesToTrackDetector::GoodFeaturesToTrackDetector( const Params& _params ) : params(_params)
|
||||
{}
|
||||
|
||||
GoodFeaturesToTrackDetector::GoodFeaturesToTrackDetector( int maxCorners, double qualityLevel,
|
||||
double minDistance, int blockSize,
|
||||
bool useHarrisDetector, double k )
|
||||
{
|
||||
params = Params( maxCorners, qualityLevel, minDistance, blockSize, useHarrisDetector, k );
|
||||
}
|
||||
|
||||
void GoodFeaturesToTrackDetector::read (const FileNode& fn)
|
||||
{
|
||||
params.read(fn);
|
||||
}
|
||||
|
||||
void GoodFeaturesToTrackDetector::write (FileStorage& fs) const
|
||||
{
|
||||
params.write(fs);
|
||||
}
|
||||
|
||||
void GoodFeaturesToTrackDetector::detectImpl( const Mat& image, vector<KeyPoint>& keypoints, const Mat& mask) const
|
||||
void GFTTDetector::detectImpl( const Mat& image, vector<KeyPoint>& keypoints, const Mat& mask) const
|
||||
{
|
||||
Mat grayImage = image;
|
||||
if( image.type() != CV_8U ) cvtColor( image, grayImage, CV_BGR2GRAY );
|
||||
|
||||
vector<Point2f> corners;
|
||||
goodFeaturesToTrack( grayImage, corners, params.maxCorners, params.qualityLevel, params.minDistance, mask,
|
||||
params.blockSize, params.useHarrisDetector, params.k );
|
||||
goodFeaturesToTrack( grayImage, corners, nfeatures, qualityLevel, minDistance, mask,
|
||||
blockSize, useHarrisDetector, k );
|
||||
keypoints.resize(corners.size());
|
||||
vector<Point2f>::const_iterator corner_it = corners.begin();
|
||||
vector<KeyPoint>::iterator keypoint_it = keypoints.begin();
|
||||
for( ; corner_it != corners.end(); ++corner_it, ++keypoint_it )
|
||||
{
|
||||
*keypoint_it = KeyPoint( *corner_it, (float)params.blockSize );
|
||||
*keypoint_it = KeyPoint( *corner_it, (float)blockSize );
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* MserFeatureDetector
|
||||
*/
|
||||
MserFeatureDetector::MserFeatureDetector( int delta, int minArea, int maxArea,
|
||||
double maxVariation, double minDiversity,
|
||||
int maxEvolution, double areaThreshold,
|
||||
double minMargin, int edgeBlurSize )
|
||||
: mser( delta, minArea, maxArea, maxVariation, minDiversity,
|
||||
maxEvolution, areaThreshold, minMargin, edgeBlurSize )
|
||||
{}
|
||||
|
||||
MserFeatureDetector::MserFeatureDetector( CvMSERParams params )
|
||||
: mser( params.delta, params.minArea, params.maxArea, params.maxVariation, params.minDiversity,
|
||||
params.maxEvolution, params.areaThreshold, params.minMargin, params.edgeBlurSize )
|
||||
{}
|
||||
|
||||
void MserFeatureDetector::read (const FileNode& fn)
|
||||
static Algorithm* createGFTT() { return new GFTTDetector; }
|
||||
static Algorithm* createHarris()
|
||||
{
|
||||
int delta = fn["delta"];
|
||||
int minArea = fn["minArea"];
|
||||
int maxArea = fn["maxArea"];
|
||||
float maxVariation = fn["maxVariation"];
|
||||
float minDiversity = fn["minDiversity"];
|
||||
int maxEvolution = fn["maxEvolution"];
|
||||
double areaThreshold = fn["areaThreshold"];
|
||||
double minMargin = fn["minMargin"];
|
||||
int edgeBlurSize = fn["edgeBlurSize"];
|
||||
|
||||
mser = MSER( delta, minArea, maxArea, maxVariation, minDiversity,
|
||||
maxEvolution, areaThreshold, minMargin, edgeBlurSize );
|
||||
GFTTDetector* d = new GFTTDetector;
|
||||
d->set("useHarris", true);
|
||||
return d;
|
||||
}
|
||||
|
||||
void MserFeatureDetector::write (FileStorage& fs) const
|
||||
static AlgorithmInfo gftt_info("Feature2D.GFTT", createGFTT);
|
||||
static AlgorithmInfo harris_info("Feature2D.HARRIS", createHarris);
|
||||
|
||||
AlgorithmInfo* GFTTDetector::info() const
|
||||
{
|
||||
//fs << "algorithm" << getAlgorithmName ();
|
||||
|
||||
fs << "delta" << mser.delta;
|
||||
fs << "minArea" << mser.minArea;
|
||||
fs << "maxArea" << mser.maxArea;
|
||||
fs << "maxVariation" << mser.maxVariation;
|
||||
fs << "minDiversity" << mser.minDiversity;
|
||||
fs << "maxEvolution" << mser.maxEvolution;
|
||||
fs << "areaThreshold" << mser.areaThreshold;
|
||||
fs << "minMargin" << mser.minMargin;
|
||||
fs << "edgeBlurSize" << mser.edgeBlurSize;
|
||||
}
|
||||
|
||||
|
||||
void MserFeatureDetector::detectImpl( const Mat& image, vector<KeyPoint>& keypoints, const Mat& mask ) const
|
||||
{
|
||||
vector<vector<Point> > msers;
|
||||
|
||||
mser(image, msers, mask);
|
||||
|
||||
vector<vector<Point> >::const_iterator contour_it = msers.begin();
|
||||
for( ; contour_it != msers.end(); ++contour_it )
|
||||
static volatile bool initialized = false;
|
||||
if( !initialized )
|
||||
{
|
||||
// TODO check transformation from MSER region to KeyPoint
|
||||
RotatedRect rect = fitEllipse(Mat(*contour_it));
|
||||
float diam = sqrt(rect.size.height*rect.size.width);
|
||||
|
||||
if( diam > std::numeric_limits<float>::epsilon() )
|
||||
keypoints.push_back( KeyPoint( rect.center, diam, rect.angle) );
|
||||
gftt_info.addParam(this, "nfeatures", nfeatures);
|
||||
gftt_info.addParam(this, "qualityLevel", qualityLevel);
|
||||
gftt_info.addParam(this, "minDistance", minDistance);
|
||||
gftt_info.addParam(this, "useHarrisDetector", useHarrisDetector);
|
||||
gftt_info.addParam(this, "k", k);
|
||||
|
||||
harris_info.addParam(this, "nfeatures", nfeatures);
|
||||
harris_info.addParam(this, "qualityLevel", qualityLevel);
|
||||
harris_info.addParam(this, "minDistance", minDistance);
|
||||
harris_info.addParam(this, "useHarrisDetector", useHarrisDetector);
|
||||
harris_info.addParam(this, "k", k);
|
||||
|
||||
initialized = true;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* StarFeatureDetector
|
||||
*/
|
||||
|
||||
StarFeatureDetector::StarFeatureDetector( const CvStarDetectorParams& params )
|
||||
: star( params.maxSize, params.responseThreshold, params.lineThresholdProjected,
|
||||
params.lineThresholdBinarized, params.suppressNonmaxSize)
|
||||
{}
|
||||
|
||||
StarFeatureDetector::StarFeatureDetector(int maxSize, int responseThreshold,
|
||||
int lineThresholdProjected,
|
||||
int lineThresholdBinarized,
|
||||
int suppressNonmaxSize)
|
||||
: star( maxSize, responseThreshold, lineThresholdProjected,
|
||||
lineThresholdBinarized, suppressNonmaxSize)
|
||||
{}
|
||||
|
||||
void StarFeatureDetector::read (const FileNode& fn)
|
||||
{
|
||||
int maxSize = fn["maxSize"];
|
||||
int responseThreshold = fn["responseThreshold"];
|
||||
int lineThresholdProjected = fn["lineThresholdProjected"];
|
||||
int lineThresholdBinarized = fn["lineThresholdBinarized"];
|
||||
int suppressNonmaxSize = fn["suppressNonmaxSize"];
|
||||
|
||||
star = StarDetector( maxSize, responseThreshold, lineThresholdProjected,
|
||||
lineThresholdBinarized, suppressNonmaxSize);
|
||||
}
|
||||
|
||||
void StarFeatureDetector::write (FileStorage& fs) const
|
||||
{
|
||||
//fs << "algorithm" << getAlgorithmName ();
|
||||
|
||||
fs << "maxSize" << star.maxSize;
|
||||
fs << "responseThreshold" << star.responseThreshold;
|
||||
fs << "lineThresholdProjected" << star.lineThresholdProjected;
|
||||
fs << "lineThresholdBinarized" << star.lineThresholdBinarized;
|
||||
fs << "suppressNonmaxSize" << star.suppressNonmaxSize;
|
||||
}
|
||||
|
||||
void StarFeatureDetector::detectImpl( const Mat& image, vector<KeyPoint>& keypoints, const Mat& mask ) const
|
||||
{
|
||||
Mat grayImage = image;
|
||||
if( image.type() != CV_8U ) cvtColor( image, grayImage, CV_BGR2GRAY );
|
||||
|
||||
star(grayImage, keypoints);
|
||||
KeyPointsFilter::runByPixelsMask( keypoints, mask );
|
||||
}
|
||||
|
||||
/*
|
||||
* SiftFeatureDetector
|
||||
*/
|
||||
SiftFeatureDetector::SiftFeatureDetector( const SIFT::DetectorParams &detectorParams,
|
||||
const SIFT::CommonParams &commonParams )
|
||||
: sift(detectorParams.threshold, detectorParams.edgeThreshold,
|
||||
commonParams.nOctaves, commonParams.nOctaveLayers, commonParams.firstOctave, commonParams.angleMode)
|
||||
{
|
||||
}
|
||||
|
||||
SiftFeatureDetector::SiftFeatureDetector( double threshold, double edgeThreshold,
|
||||
int nOctaves, int nOctaveLayers, int firstOctave, int angleMode ) :
|
||||
sift(threshold, edgeThreshold, nOctaves, nOctaveLayers, firstOctave, angleMode)
|
||||
{
|
||||
}
|
||||
|
||||
void SiftFeatureDetector::read( const FileNode& fn )
|
||||
{
|
||||
double threshold = fn["threshold"];
|
||||
double edgeThreshold = fn["edgeThreshold"];
|
||||
int nOctaves = fn["nOctaves"];
|
||||
int nOctaveLayers = fn["nOctaveLayers"];
|
||||
int firstOctave = fn["firstOctave"];
|
||||
int angleMode = fn["angleMode"];
|
||||
|
||||
sift = SIFT(threshold, edgeThreshold, nOctaves, nOctaveLayers, firstOctave, angleMode);
|
||||
}
|
||||
|
||||
void SiftFeatureDetector::write (FileStorage& fs) const
|
||||
{
|
||||
//fs << "algorithm" << getAlgorithmName ();
|
||||
|
||||
SIFT::CommonParams commParams = sift.getCommonParams ();
|
||||
SIFT::DetectorParams detectorParams = sift.getDetectorParams ();
|
||||
fs << "threshold" << detectorParams.threshold;
|
||||
fs << "edgeThreshold" << detectorParams.edgeThreshold;
|
||||
fs << "nOctaves" << commParams.nOctaves;
|
||||
fs << "nOctaveLayers" << commParams.nOctaveLayers;
|
||||
fs << "firstOctave" << commParams.firstOctave;
|
||||
fs << "angleMode" << commParams.angleMode;
|
||||
}
|
||||
|
||||
|
||||
void SiftFeatureDetector::detectImpl( const Mat& image, vector<KeyPoint>& keypoints, const Mat& mask ) const
|
||||
{
|
||||
Mat grayImage = image;
|
||||
if( image.type() != CV_8U ) cvtColor( image, grayImage, CV_BGR2GRAY );
|
||||
|
||||
sift(grayImage, mask, keypoints);
|
||||
}
|
||||
|
||||
/*
|
||||
* SurfFeatureDetector
|
||||
*/
|
||||
SurfFeatureDetector::SurfFeatureDetector( double hessianThreshold, int octaves, int octaveLayers, bool upright )
|
||||
: surf(hessianThreshold, octaves, octaveLayers, false, upright)
|
||||
{}
|
||||
|
||||
void SurfFeatureDetector::read (const FileNode& fn)
|
||||
{
|
||||
double hessianThreshold = fn["hessianThreshold"];
|
||||
int octaves = fn["octaves"];
|
||||
int octaveLayers = fn["octaveLayers"];
|
||||
bool upright = (int)fn["upright"] != 0;
|
||||
|
||||
surf = SURF( hessianThreshold, octaves, octaveLayers, false, upright );
|
||||
}
|
||||
|
||||
void SurfFeatureDetector::write (FileStorage& fs) const
|
||||
{
|
||||
//fs << "algorithm" << getAlgorithmName ();
|
||||
|
||||
fs << "hessianThreshold" << surf.hessianThreshold;
|
||||
fs << "octaves" << surf.nOctaves;
|
||||
fs << "octaveLayers" << surf.nOctaveLayers;
|
||||
fs << "upright" << surf.upright;
|
||||
}
|
||||
|
||||
void SurfFeatureDetector::detectImpl( const Mat& image, vector<KeyPoint>& keypoints, const Mat& mask ) const
|
||||
{
|
||||
Mat grayImage = image;
|
||||
if( image.type() != CV_8U ) cvtColor( image, grayImage, CV_BGR2GRAY );
|
||||
|
||||
surf(grayImage, mask, keypoints);
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
/** Default constructor
|
||||
* @param n_features the number of desired features
|
||||
*/
|
||||
OrbFeatureDetector::OrbFeatureDetector(size_t n_features, ORB::CommonParams params)
|
||||
{
|
||||
orb_ = ORB(n_features, params);
|
||||
}
|
||||
|
||||
void OrbFeatureDetector::read(const FileNode& fn)
|
||||
{
|
||||
orb_.read(fn);
|
||||
}
|
||||
|
||||
void OrbFeatureDetector::write(FileStorage& fs) const
|
||||
{
|
||||
orb_.write(fs);
|
||||
}
|
||||
|
||||
void OrbFeatureDetector::detectImpl(const cv::Mat& image, std::vector<cv::KeyPoint>& keypoints, const cv::Mat& mask) const
|
||||
{
|
||||
orb_(image, mask, keypoints);
|
||||
return &gftt_info;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
@@ -477,7 +182,7 @@ void OrbFeatureDetector::detectImpl(const cv::Mat& image, std::vector<cv::KeyPoi
|
||||
/*
|
||||
* DenseFeatureDetector
|
||||
*/
|
||||
DenseFeatureDetector::Params::Params( float _initFeatureScale, int _featureScaleLevels,
|
||||
DenseFeatureDetector::DenseFeatureDetector( float _initFeatureScale, int _featureScaleLevels,
|
||||
float _featureScaleMul, int _initXyStep,
|
||||
int _initImgBound, bool _varyXyStepWithScale,
|
||||
bool _varyImgBoundWithScale ) :
|
||||
@@ -486,51 +191,13 @@ DenseFeatureDetector::Params::Params( float _initFeatureScale, int _featureScale
|
||||
varyXyStepWithScale(_varyXyStepWithScale), varyImgBoundWithScale(_varyImgBoundWithScale)
|
||||
{}
|
||||
|
||||
void DenseFeatureDetector::Params::read( const FileNode& fn )
|
||||
{
|
||||
initFeatureScale = fn["initFeatureScale"];
|
||||
featureScaleLevels = fn["featureScaleLevels"];
|
||||
featureScaleMul = fn["featureScaleMul"];
|
||||
|
||||
initXyStep = fn["initXyStep"];
|
||||
initImgBound = fn["initImgBound"];
|
||||
|
||||
varyXyStepWithScale = (int)fn["varyXyStepWithScale"] != 0 ? true : false;
|
||||
varyImgBoundWithScale = (int)fn["varyImgBoundWithScale"] != 0 ? true : false;
|
||||
}
|
||||
|
||||
void DenseFeatureDetector::Params::write( FileStorage& fs ) const
|
||||
{
|
||||
fs << "initFeatureScale" << initFeatureScale;
|
||||
fs << "featureScaleLevels" << featureScaleLevels;
|
||||
fs << "featureScaleMul" << featureScaleMul;
|
||||
|
||||
fs << "initXyStep" << initXyStep;
|
||||
fs << "initImgBound" << initImgBound;
|
||||
|
||||
fs << "varyXyStepWithScale" << (int)varyXyStepWithScale;
|
||||
fs << "varyImgBoundWithScale" << (int)varyImgBoundWithScale;
|
||||
}
|
||||
|
||||
DenseFeatureDetector::DenseFeatureDetector(const DenseFeatureDetector::Params &_params) : params(_params)
|
||||
{}
|
||||
|
||||
void DenseFeatureDetector::read( const FileNode &fn )
|
||||
{
|
||||
params.read(fn);
|
||||
}
|
||||
|
||||
void DenseFeatureDetector::write( FileStorage &fs ) const
|
||||
{
|
||||
params.write(fs);
|
||||
}
|
||||
|
||||
void DenseFeatureDetector::detectImpl( const Mat& image, vector<KeyPoint>& keypoints, const Mat& mask ) const
|
||||
{
|
||||
float curScale = params.initFeatureScale;
|
||||
int curStep = params.initXyStep;
|
||||
int curBound = params.initImgBound;
|
||||
for( int curLevel = 0; curLevel < params.featureScaleLevels; curLevel++ )
|
||||
float curScale = initFeatureScale;
|
||||
int curStep = initXyStep;
|
||||
int curBound = initImgBound;
|
||||
for( int curLevel = 0; curLevel < featureScaleLevels; curLevel++ )
|
||||
{
|
||||
for( int x = curBound; x < image.cols - curBound; x += curStep )
|
||||
{
|
||||
@@ -540,13 +207,35 @@ void DenseFeatureDetector::detectImpl( const Mat& image, vector<KeyPoint>& keypo
|
||||
}
|
||||
}
|
||||
|
||||
curScale = curScale * params.featureScaleMul;
|
||||
if( params.varyXyStepWithScale ) curStep = static_cast<int>( curStep * params.featureScaleMul + 0.5f );
|
||||
if( params.varyImgBoundWithScale ) curBound = static_cast<int>( curBound * params.featureScaleMul + 0.5f );
|
||||
curScale = curScale * featureScaleMul;
|
||||
if( varyXyStepWithScale ) curStep = static_cast<int>( curStep * featureScaleMul + 0.5f );
|
||||
if( varyImgBoundWithScale ) curBound = static_cast<int>( curBound * featureScaleMul + 0.5f );
|
||||
}
|
||||
|
||||
KeyPointsFilter::runByPixelsMask( keypoints, mask );
|
||||
}
|
||||
|
||||
|
||||
static Algorithm* createDense() { return new DenseFeatureDetector; }
|
||||
|
||||
AlgorithmInfo* DenseFeatureDetector::info() const
|
||||
{
|
||||
static AlgorithmInfo info_("Feature2D.Dense", createDense);
|
||||
static volatile bool initialized = false;
|
||||
if( !initialized )
|
||||
{
|
||||
info_.addParam(this, "initFeatureScale", initFeatureScale);
|
||||
info_.addParam(this, "featureScaleLevels", featureScaleLevels);
|
||||
info_.addParam(this, "featureScaleMul", featureScaleMul);
|
||||
info_.addParam(this, "initXyStep", initXyStep);
|
||||
info_.addParam(this, "initImgBound", initImgBound);
|
||||
info_.addParam(this, "varyXyStepWithScale", varyXyStepWithScale);
|
||||
info_.addParam(this, "varyImgBoundWithScale", varyImgBoundWithScale);
|
||||
|
||||
initialized = true;
|
||||
}
|
||||
return &info_;
|
||||
}
|
||||
|
||||
/*
|
||||
* GridAdaptedFeatureDetector
|
||||
|
||||
Reference in New Issue
Block a user