~AlgorithmInfo();
void get(const Algorithm* algo, const char* name, int argType, void* value) const;
void set(Algorithm* algo, const char* name, int argType, const void* value) const;
- void addParam_(const Algorithm* algo, const char* name, int argType,
- const void* value, bool readOnly,
+ void addParam_(Algorithm& algo, const char* name, int argType,
+ void* value, bool readOnly,
Algorithm::Getter getter, Algorithm::Setter setter,
const string& help=string());
string paramHelp(const char* name) const;
void read(Algorithm* algo, const FileNode& fn) const;
string name() const;
- void addParam(const Algorithm* algo, const char* name,
- const int& value, bool readOnly=false,
+ void addParam(Algorithm& algo, const char* name,
+ int& value, bool readOnly=false,
int (Algorithm::*getter)()=0,
void (Algorithm::*setter)(int)=0,
const string& help=string());
- void addParam(const Algorithm* algo, const char* name,
- const bool& value, bool readOnly=false,
+ void addParam(Algorithm& algo, const char* name,
+ bool& value, bool readOnly=false,
int (Algorithm::*getter)()=0,
void (Algorithm::*setter)(int)=0,
const string& help=string());
- void addParam(const Algorithm* algo, const char* name,
- const double& value, bool readOnly=false,
+ void addParam(Algorithm& algo, const char* name,
+ double& value, bool readOnly=false,
double (Algorithm::*getter)()=0,
void (Algorithm::*setter)(double)=0,
const string& help=string());
- void addParam(const Algorithm* algo, const char* name,
- const string& value, bool readOnly=false,
+ void addParam(Algorithm& algo, const char* name,
+ string& value, bool readOnly=false,
string (Algorithm::*getter)()=0,
void (Algorithm::*setter)(const string&)=0,
const string& help=string());
- void addParam(const Algorithm* algo, const char* name,
- const Mat& value, bool readOnly=false,
+ void addParam(Algorithm& algo, const char* name,
+ Mat& value, bool readOnly=false,
Mat (Algorithm::*getter)()=0,
void (Algorithm::*setter)(const Mat&)=0,
const string& help=string());
- void addParam(const Algorithm* algo, const char* name,
- const Ptr<Algorithm>& value, bool readOnly=false,
+ void addParam(Algorithm& algo, const char* name,
+ Ptr<Algorithm>& value, bool readOnly=false,
Ptr<Algorithm> (Algorithm::*getter)()=0,
void (Algorithm::*setter)(const Ptr<Algorithm>&)=0,
const string& help=string());
}
-void AlgorithmInfo::addParam_(const Algorithm* algo, const char* name, int argType,
- const void* value, bool readOnly,
+void AlgorithmInfo::addParam_(Algorithm& algo, const char* name, int argType,
+ void* value, bool readOnly,
Algorithm::Getter getter, Algorithm::Setter setter,
const string& help)
{
argType == Param::REAL || argType == Param::STRING ||
argType == Param::MAT || argType == Param::ALGORITHM );
data->params.add(string(name), Param(argType, readOnly,
- (int)((size_t)value - (size_t)(void*)algo),
+ (int)((size_t)value - (size_t)(void*)&algo),
getter, setter, help));
}
-void AlgorithmInfo::addParam(const Algorithm* algo, const char* name,
- const int& value, bool readOnly,
+void AlgorithmInfo::addParam(Algorithm& algo, const char* name,
+ int& value, bool readOnly,
int (Algorithm::*getter)(),
void (Algorithm::*setter)(int),
const string& help)
(Algorithm::Getter)getter, (Algorithm::Setter)setter, help);
}
-void AlgorithmInfo::addParam(const Algorithm* algo, const char* name,
- const bool& value, bool readOnly,
+void AlgorithmInfo::addParam(Algorithm& algo, const char* name,
+ bool& value, bool readOnly,
int (Algorithm::*getter)(),
void (Algorithm::*setter)(int),
const string& help)
(Algorithm::Getter)getter, (Algorithm::Setter)setter, help);
}
-void AlgorithmInfo::addParam(const Algorithm* algo, const char* name,
- const double& value, bool readOnly,
+void AlgorithmInfo::addParam(Algorithm& algo, const char* name,
+ double& value, bool readOnly,
double (Algorithm::*getter)(),
void (Algorithm::*setter)(double),
const string& help)
(Algorithm::Getter)getter, (Algorithm::Setter)setter, help);
}
-void AlgorithmInfo::addParam(const Algorithm* algo, const char* name,
- const string& value, bool readOnly,
+void AlgorithmInfo::addParam(Algorithm& algo, const char* name,
+ string& value, bool readOnly,
string (Algorithm::*getter)(),
void (Algorithm::*setter)(const string&),
const string& help)
(Algorithm::Getter)getter, (Algorithm::Setter)setter, help);
}
-void AlgorithmInfo::addParam(const Algorithm* algo, const char* name,
- const Mat& value, bool readOnly,
+void AlgorithmInfo::addParam(Algorithm& algo, const char* name,
+ Mat& value, bool readOnly,
Mat (Algorithm::*getter)(),
void (Algorithm::*setter)(const Mat&),
const string& help)
(Algorithm::Getter)getter, (Algorithm::Setter)setter, help);
}
-void AlgorithmInfo::addParam(const Algorithm* algo, const char* name,
- const Ptr<Algorithm>& value, bool readOnly,
+void AlgorithmInfo::addParam(Algorithm& algo, const char* name,
+ Ptr<Algorithm>& value, bool readOnly,
Ptr<Algorithm> (Algorithm::*getter)(),
void (Algorithm::*setter)(const Ptr<Algorithm>&),
const string& help)
protected:
virtual void detectImpl( const Mat& image, vector<KeyPoint>& keypoints, const Mat& mask=Mat() ) const;
- float initFeatureScale;
+ double initFeatureScale;
int featureScaleLevels;
- float featureScaleMul;
+ double featureScaleMul;
int initXyStep;
int initImgBound;
static volatile bool initialized = false;
if( !initialized )
{
- 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);
+ GFTTDetector obj;
+ gftt_info.addParam(obj, "nfeatures", obj.nfeatures);
+ gftt_info.addParam(obj, "qualityLevel", obj.qualityLevel);
+ gftt_info.addParam(obj, "minDistance", obj.minDistance);
+ gftt_info.addParam(obj, "useHarrisDetector", obj.useHarrisDetector);
+ gftt_info.addParam(obj, "k", obj.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);
+ harris_info.addParam(obj, "nfeatures", obj.nfeatures);
+ harris_info.addParam(obj, "qualityLevel", obj.qualityLevel);
+ harris_info.addParam(obj, "minDistance", obj.minDistance);
+ harris_info.addParam(obj, "useHarrisDetector", obj.useHarrisDetector);
+ harris_info.addParam(obj, "k", obj.k);
initialized = true;
}
static Algorithm* createDense() { return new DenseFeatureDetector; }
-
+static AlgorithmInfo dense_info("Feature2D.Dense", createDense);
+
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);
+ DenseFeatureDetector obj;
+ dense_info.addParam(obj, "initFeatureScale", obj.initFeatureScale);
+ dense_info.addParam(obj, "featureScaleLevels", obj.featureScaleLevels);
+ dense_info.addParam(obj, "featureScaleMul", obj.featureScaleMul);
+ dense_info.addParam(obj, "initXyStep", obj.initXyStep);
+ dense_info.addParam(obj, "initImgBound", obj.initImgBound);
+ dense_info.addParam(obj, "varyXyStepWithScale", obj.varyXyStepWithScale);
+ dense_info.addParam(obj, "varyImgBoundWithScale", obj.varyImgBoundWithScale);
initialized = true;
}
- return &info_;
+ return &dense_info;
}
/*
static volatile bool initialized = false;
if( !initialized )
{
- fast_info.addParam(this, "threshold", threshold);
- fast_info.addParam(this, "nonmaxSuppression", nonmaxSuppression);
+ FastFeatureDetector obj;
+ fast_info.addParam(obj, "threshold", obj.threshold);
+ fast_info.addParam(obj, "nonmaxSuppression", obj.nonmaxSuppression);
initialized = true;
}
static volatile bool initialized = false;
if( !initialized )
{
- mser_info.addParam(this, "delta", delta);
- mser_info.addParam(this, "minArea", minArea);
- mser_info.addParam(this, "maxArea", maxArea);
- mser_info.addParam(this, "maxVariation", maxVariation);
- mser_info.addParam(this, "minDiversity", minDiversity);
- mser_info.addParam(this, "maxEvolution", maxEvolution);
- mser_info.addParam(this, "areaThreshold", areaThreshold);
- mser_info.addParam(this, "minMargin", minMargin);
- mser_info.addParam(this, "edgeBlurSize", edgeBlurSize);
+ MSER obj;
+ mser_info.addParam(obj, "delta", obj.delta);
+ mser_info.addParam(obj, "minArea", obj.minArea);
+ mser_info.addParam(obj, "maxArea", obj.maxArea);
+ mser_info.addParam(obj, "maxVariation", obj.maxVariation);
+ mser_info.addParam(obj, "minDiversity", obj.minDiversity);
+ mser_info.addParam(obj, "maxEvolution", obj.maxEvolution);
+ mser_info.addParam(obj, "areaThreshold", obj.areaThreshold);
+ mser_info.addParam(obj, "minMargin", obj.minMargin);
+ mser_info.addParam(obj, "edgeBlurSize", obj.edgeBlurSize);
initialized = true;
}
static volatile bool initialized = false;
if( !initialized )
{
- orb_info.addParam(this, "nFeatures", nfeatures);
- orb_info.addParam(this, "scaleFactor", scaleFactor);
- orb_info.addParam(this, "nLevels", nlevels);
- orb_info.addParam(this, "firstLevel", firstLevel);
- orb_info.addParam(this, "edgeThreshold", edgeThreshold);
- orb_info.addParam(this, "patchSize", patchSize);
- orb_info.addParam(this, "WTA_K", WTA_K);
- orb_info.addParam(this, "scoreType", scoreType);
+ ORB obj;
+ orb_info.addParam(obj, "nFeatures", obj.nfeatures);
+ orb_info.addParam(obj, "scaleFactor", obj.scaleFactor);
+ orb_info.addParam(obj, "nLevels", obj.nlevels);
+ orb_info.addParam(obj, "firstLevel", obj.firstLevel);
+ orb_info.addParam(obj, "edgeThreshold", obj.edgeThreshold);
+ orb_info.addParam(obj, "patchSize", obj.patchSize);
+ orb_info.addParam(obj, "WTA_K", obj.WTA_K);
+ orb_info.addParam(obj, "scoreType", obj.scoreType);
initialized = true;
}
static volatile bool initialized = false;
if( !initialized )
{
- star_info.addParam(this, "maxSize", maxSize);
- star_info.addParam(this, "responseThreshold", responseThreshold);
- star_info.addParam(this, "lineThresholdProjected", lineThresholdProjected);
- star_info.addParam(this, "lineThresholdBinarized", lineThresholdBinarized);
- star_info.addParam(this, "suppressNonmaxSize", suppressNonmaxSize);
+ StarDetector obj;
+ star_info.addParam(obj, "maxSize", obj.maxSize);
+ star_info.addParam(obj, "responseThreshold", obj.responseThreshold);
+ star_info.addParam(obj, "lineThresholdProjected", obj.lineThresholdProjected);
+ star_info.addParam(obj, "lineThresholdBinarized", obj.lineThresholdBinarized);
+ star_info.addParam(obj, "suppressNonmaxSize", obj.suppressNonmaxSize);
initialized = true;
}
static volatile bool initialized = false;
if( !initialized )
{
- sift_info.addParam(this, "nFeatures", nfeatures);
- sift_info.addParam(this, "nOctaveLayers", nOctaveLayers);
- sift_info.addParam(this, "contrastThreshold", contrastThreshold);
- sift_info.addParam(this, "edgeThreshold", edgeThreshold);
- sift_info.addParam(this, "sigma", sigma);
+ SIFT obj;
+ sift_info.addParam(obj, "nFeatures", obj.nfeatures);
+ sift_info.addParam(obj, "nOctaveLayers", obj.nOctaveLayers);
+ sift_info.addParam(obj, "contrastThreshold", obj.contrastThreshold);
+ sift_info.addParam(obj, "edgeThreshold", obj.edgeThreshold);
+ sift_info.addParam(obj, "sigma", obj.sigma);
initialized = true;
}
static volatile bool initialized = false;
if( !initialized )
{
- surf_info.addParam(this, "hessianThreshold", hessianThreshold);
- surf_info.addParam(this, "nOctaves", nOctaves);
- surf_info.addParam(this, "nOctaveLayers", nOctaveLayers);
- surf_info.addParam(this, "extended", extended);
- surf_info.addParam(this, "upright", upright);
+ SURF obj;
+ surf_info.addParam(obj, "hessianThreshold", obj.hessianThreshold);
+ surf_info.addParam(obj, "nOctaves", obj.nOctaves);
+ surf_info.addParam(obj, "nOctaveLayers", obj.nOctaveLayers);
+ surf_info.addParam(obj, "extended", obj.extended);
+ surf_info.addParam(obj, "upright", obj.upright);
initialized = true;
}
void VocData::readFileToString(const string filename, string& file_contents)
{
std::ifstream ifs(filename.c_str());
- if (ifs == false) CV_Error(CV_StsError,"could not open text file");
+ if (!ifs.is_open()) CV_Error(CV_StsError,"could not open text file");
stringstream oss;
oss << ifs.rdbuf();