Merge pull request #169 from mshabunin/remove-algorithm-factory

Remove algorithm factory

modules/bgsegm/src/bgfg_gaussmix.cpp

@@ -122,8 +122,6 @@ public:
         bgmodel = Scalar::all(0);
     }
 
-    virtual AlgorithmInfo* info() const { return 0; }
-
     virtual void getBackgroundImage(OutputArray) const
     {
         CV_Error( Error::StsNotImplemented, "" );

modules/bgsegm/src/bgfg_gmg.cpp

@@ -81,8 +81,6 @@ public:
     {
     }
 
-    virtual AlgorithmInfo* info() const { return 0; }
-
     /**
      * Validate parameters and set up data structures for appropriate image size.
      * Must call before running on data.

modules/datasets/samples/ar_hmdb_benchmark.cpp

@@ -188,17 +188,16 @@ int main(int argc, char *argv[])
         fillData(path, curr, flann_index, trainData, trainLabels);
 
         printf("train svm\n");
-        SVM::Params params;
-        params.svmType = SVM::C_SVC;
-        params.kernelType = SVM::POLY; //SVM::RBF;
-        params.degree = 0.5;
-        params.gamma = 1;
-        params.coef0 = 1;
-        params.C = 1;
-        params.nu = 0.5;
-        params.p = 0;
-        params.termCrit = TermCriteria(TermCriteria::MAX_ITER+TermCriteria::EPS, 1000, 0.01);
-        Ptr<SVM> svm = SVM::create(params);
+        Ptr<SVM> svm = SVM::create();
+        svm->setType(SVM::C_SVC);
+        svm->setKernel(SVM::POLY); //SVM::RBF;
+        svm->setDegree(0.5);
+        svm->setGamma(1);
+        svm->setCoef0(1);
+        svm->setC(1);
+        svm->setNu(0.5);
+        svm->setP(0);
+        svm->setTermCriteria(TermCriteria(TermCriteria::MAX_ITER+TermCriteria::EPS, 1000, 0.01));
         svm->train(trainData, ROW_SAMPLE, trainLabels);
 
         // prepare to predict

modules/face/samples/facerec_demo.cpp

@@ -128,7 +128,7 @@ int main(int argc, const char *argv[]) {
     //
     //      cv::createEigenFaceRecognizer(10, 123.0);
     //
-    Ptr<FaceRecognizer> model = createEigenFaceRecognizer();
+    Ptr<BasicFaceRecognizer> model = createEigenFaceRecognizer();
     for( int i = 0; i < nlabels; i++ )
         model->setLabelInfo(i, labelsInfo[i]);
     model->train(images, labels);
@@ -162,16 +162,16 @@ int main(int argc, const char *argv[]) {
         // to 0.0 without retraining the model. This can be useful if
         // you are evaluating the model:
         //
-        model->set("threshold", 0.0);
+        model->setThreshold(0.0);
         // Now the threshold of this model is set to 0.0. A prediction
         // now returns -1, as it's impossible to have a distance below
         // it
         predictedLabel = model->predict(testSample);
         cout << "Predicted class = " << predictedLabel << endl;
         // Here is how to get the eigenvalues of this Eigenfaces model:
-        Mat eigenvalues = model->getMat("eigenvalues");
+        Mat eigenvalues = model->getEigenValues();
         // And we can do the same to display the Eigenvectors (read Eigenfaces):
-        Mat W = model->getMat("eigenvectors");
+        Mat W = model->getEigenVectors();
         // From this we will display the (at most) first 10 Eigenfaces:
         for (int i = 0; i < min(10, W.cols); i++) {
             string msg = format("Eigenvalue #%d = %.5f", i, eigenvalues.at<double>(i));

modules/face/src/eigen_faces.cpp

+/*
+ * Copyright (c) 2011,2012. Philipp Wagner <bytefish[at]gmx[dot]de>.
+ * Released to public domain under terms of the BSD Simplified license.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions 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.
+ *   * Neither the name of the organization nor the names of its contributors
+ *     may be used to endorse or promote products derived from this software
+ *     without specific prior written permission.
+ *
+ *   See <http://www.opensource.org/licenses/bsd-license>
+ */
+#include "precomp.hpp"
+#include "face_basic.hpp"
+#include <set>
+#include <limits>
+#include <iostream>
+
+namespace cv
+{
+namespace face
+{
+
+// Turk, M., and Pentland, A. "Eigenfaces for recognition.". Journal of
+// Cognitive Neuroscience 3 (1991), 71–86.
+class Eigenfaces : public BasicFaceRecognizerImpl
+{
+
+public:
+    // Initializes an empty Eigenfaces model.
+    Eigenfaces(int num_components = 0, double threshold = DBL_MAX)
+        : BasicFaceRecognizerImpl(num_components, threshold)
+    {}
+
+    // Computes an Eigenfaces model with images in src and corresponding labels
+    // in labels.
+    void train(InputArrayOfArrays src, InputArray labels);
+
+    // Predicts the label of a query image in src.
+    int predict(InputArray src) const;
+
+    // Predicts the label and confidence for a given sample.
+    void predict(InputArray _src, int &label, double &dist) const;
+};
+
+//------------------------------------------------------------------------------
+// Eigenfaces
+//------------------------------------------------------------------------------
+void Eigenfaces::train(InputArrayOfArrays _src, InputArray _local_labels) {
+    if(_src.total() == 0) {
+        String error_message = format("Empty training data was given. You'll need more than one sample to learn a model.");
+        CV_Error(Error::StsBadArg, error_message);
+    } else if(_local_labels.getMat().type() != CV_32SC1) {
+        String error_message = format("Labels must be given as integer (CV_32SC1). Expected %d, but was %d.", CV_32SC1, _local_labels.type());
+        CV_Error(Error::StsBadArg, error_message);
+    }
+    // make sure data has correct size
+    if(_src.total() > 1) {
+        for(int i = 1; i < static_cast<int>(_src.total()); i++) {
+            if(_src.getMat(i-1).total() != _src.getMat(i).total()) {
+                String error_message = format("In the Eigenfaces method all input samples (training images) must be of equal size! Expected %d pixels, but was %d pixels.", _src.getMat(i-1).total(), _src.getMat(i).total());
+                CV_Error(Error::StsUnsupportedFormat, error_message);
+            }
+        }
+    }
+    // get labels
+    Mat labels = _local_labels.getMat();
+    // observations in row
+    Mat data = asRowMatrix(_src, CV_64FC1);
+
+    // number of samples
+   int n = data.rows;
+    // assert there are as much samples as labels
+    if(static_cast<int>(labels.total()) != n) {
+        String error_message = format("The number of samples (src) must equal the number of labels (labels)! len(src)=%d, len(labels)=%d.", n, labels.total());
+        CV_Error(Error::StsBadArg, error_message);
+    }
+    // clear existing model data
+    _labels.release();
+    _projections.clear();
+    // clip number of components to be valid
+    if((_num_components <= 0) || (_num_components > n))
+        _num_components = n;
+
+    // perform the PCA
+    PCA pca(data, Mat(), PCA::DATA_AS_ROW, _num_components);
+    // copy the PCA results
+    _mean = pca.mean.reshape(1,1); // store the mean vector
+    _eigenvalues = pca.eigenvalues.clone(); // eigenvalues by row
+    transpose(pca.eigenvectors, _eigenvectors); // eigenvectors by column
+    // store labels for prediction
+    _labels = labels.clone();
+    // save projections
+    for(int sampleIdx = 0; sampleIdx < data.rows; sampleIdx++) {
+        Mat p = LDA::subspaceProject(_eigenvectors, _mean, data.row(sampleIdx));
+        _projections.push_back(p);
+    }
+}
+
+void Eigenfaces::predict(InputArray _src, int &minClass, double &minDist) const {
+    // get data
+    Mat src = _src.getMat();
+    // make sure the user is passing correct data
+    if(_projections.empty()) {
+        // throw error if no data (or simply return -1?)
+        String error_message = "This Eigenfaces model is not computed yet. Did you call Eigenfaces::train?";
+        CV_Error(Error::StsError, error_message);
+    } else if(_eigenvectors.rows != static_cast<int>(src.total())) {
+        // check data alignment just for clearer exception messages
+        String error_message = format("Wrong input image size. Reason: Training and Test images must be of equal size! Expected an image with %d elements, but got %d.", _eigenvectors.rows, src.total());
+        CV_Error(Error::StsBadArg, error_message);
+    }
+    // project into PCA subspace
+    Mat q = LDA::subspaceProject(_eigenvectors, _mean, src.reshape(1,1));
+    minDist = DBL_MAX;
+    minClass = -1;
+    for(size_t sampleIdx = 0; sampleIdx < _projections.size(); sampleIdx++) {
+        double dist = norm(_projections[sampleIdx], q, NORM_L2);
+        if((dist < minDist) && (dist < _threshold)) {
+            minDist = dist;
+            minClass = _labels.at<int>((int)sampleIdx);
+        }
+    }
+}
+
+int Eigenfaces::predict(InputArray _src) const {
+    int label;
+    double dummy;
+    predict(_src, label, dummy);
+    return label;
+}
+
+Ptr<BasicFaceRecognizer> createEigenFaceRecognizer(int num_components, double threshold)
+{
+    return makePtr<Eigenfaces>(num_components, threshold);
+}
+
+}
+}

modules/face/src/face_basic.hpp

+#ifndef __OPENCV_FACE_BASIC_HPP
+#define __OPENCV_FACE_BASIC_HPP
+
+#include "opencv2/face.hpp"
+#include "precomp.hpp"
+
+#include <set>
+#include <limits>
+#include <iostream>
+
+using namespace cv;
+
+// Reads a sequence from a FileNode::SEQ with type _Tp into a result vector.
+template<typename _Tp>
+inline void readFileNodeList(const FileNode& fn, std::vector<_Tp>& result) {
+    if (fn.type() == FileNode::SEQ) {
+        for (FileNodeIterator it = fn.begin(); it != fn.end();) {
+            _Tp item;
+            it >> item;
+            result.push_back(item);
+        }
+    }
+}
+
+// Writes the a list of given items to a cv::FileStorage.
+template<typename _Tp>
+inline void writeFileNodeList(FileStorage& fs, const String& name,
+                              const std::vector<_Tp>& items) {
+    // typedefs
+    typedef typename std::vector<_Tp>::const_iterator constVecIterator;
+    // write the elements in item to fs
+    fs << name << "[";
+    for (constVecIterator it = items.begin(); it != items.end(); ++it) {
+        fs << *it;
+    }
+    fs << "]";
+}
+
+inline Mat asRowMatrix(InputArrayOfArrays src, int rtype, double alpha=1, double beta=0) {
+    // make sure the input data is a vector of matrices or vector of vector
+    if(src.kind() != _InputArray::STD_VECTOR_MAT && src.kind() != _InputArray::STD_VECTOR_VECTOR) {
+        String error_message = "The data is expected as InputArray::STD_VECTOR_MAT (a std::vector<Mat>) or _InputArray::STD_VECTOR_VECTOR (a std::vector< std::vector<...> >).";
+        CV_Error(Error::StsBadArg, error_message);
+    }
+    // number of samples
+    size_t n = src.total();
+    // return empty matrix if no matrices given
+    if(n == 0)
+        return Mat();
+    // dimensionality of (reshaped) samples
+    size_t d = src.getMat(0).total();
+    // create data matrix
+    Mat data((int)n, (int)d, rtype);
+    // now copy data
+    for(unsigned int i = 0; i < n; i++) {
+        // make sure data can be reshaped, throw exception if not!
+        if(src.getMat(i).total() != d) {
+            String error_message = format("Wrong number of elements in matrix #%d! Expected %d was %d.", i, d, src.getMat(i).total());
+            CV_Error(Error::StsBadArg, error_message);
+        }
+        // get a hold of the current row
+        Mat xi = data.row(i);
+        // make reshape happy by cloning for non-continuous matrices
+        if(src.getMat(i).isContinuous()) {
+            src.getMat(i).reshape(1, 1).convertTo(xi, rtype, alpha, beta);
+        } else {
+            src.getMat(i).clone().reshape(1, 1).convertTo(xi, rtype, alpha, beta);
+        }
+    }
+    return data;
+}
+
+// Utility structure to load/save face label info (a pair of int and string) via FileStorage
+struct LabelInfo
+{
+    LabelInfo():label(-1), value("") {}
+    LabelInfo(int _label, const String &_value): label(_label), value(_value) {}
+    int label;
+    String value;
+    void write(cv::FileStorage& fs) const
+    {
+        fs << "{" << "label" << label << "value" << value << "}";
+    }
+    void read(const cv::FileNode& node)
+    {
+        label = (int)node["label"];
+        value = (String)node["value"];
+    }
+    std::ostream& operator<<(std::ostream& out)
+    {
+        out << "{ label = " << label << ", " << "value = " << value.c_str() << "}";
+        return out;
+    }
+};
+
+inline void write(cv::FileStorage& fs, const String&, const LabelInfo& x)
+{
+    x.write(fs);
+}
+
+inline void read(const cv::FileNode& node, LabelInfo& x, const LabelInfo& default_value = LabelInfo())
+{
+    if(node.empty())
+        x = default_value;
+    else
+        x.read(node);
+}
+
+
+class BasicFaceRecognizerImpl : public cv::face::BasicFaceRecognizer
+{
+public:
+    BasicFaceRecognizerImpl(int num_components = 0, double threshold = DBL_MAX)
+        : _num_components(num_components), _threshold(threshold)
+    {}
+
+    void load(const FileStorage& fs)
+    {
+        //read matrices
+        fs["num_components"] >> _num_components;
+        fs["mean"] >> _mean;
+        fs["eigenvalues"] >> _eigenvalues;
+        fs["eigenvectors"] >> _eigenvectors;
+        // read sequences
+        readFileNodeList(fs["projections"], _projections);
+        fs["labels"] >> _labels;
+        const FileNode& fn = fs["labelsInfo"];
+        if (fn.type() == FileNode::SEQ)
+        {
+           _labelsInfo.clear();
+           for (FileNodeIterator it = fn.begin(); it != fn.end();)
+           {
+               LabelInfo item;
+               it >> item;
+               _labelsInfo.insert(std::make_pair(item.label, item.value));
+           }
+        }
+    }
+
+    void save(FileStorage& fs) const
+    {
+        // write matrices
+        fs << "num_components" << _num_components;
+        fs << "mean" << _mean;
+        fs << "eigenvalues" << _eigenvalues;
+        fs << "eigenvectors" << _eigenvectors;
+        // write sequences
+        writeFileNodeList(fs, "projections", _projections);
+        fs << "labels" << _labels;
+        fs << "labelsInfo" << "[";
+        for (std::map<int, String>::const_iterator it = _labelsInfo.begin(); it != _labelsInfo.end(); it++)
+            fs << LabelInfo(it->first, it->second);
+        fs << "]";
+    }
+
+    CV_IMPL_PROPERTY(int, NumComponents, _num_components)
+    CV_IMPL_PROPERTY(double, Threshold, _threshold)
+    CV_IMPL_PROPERTY_RO(std::vector<cv::Mat>, Projections, _projections)
+    CV_IMPL_PROPERTY_RO(cv::Mat, Labels, _labels)
+    CV_IMPL_PROPERTY_RO(cv::Mat, EigenValues, _eigenvalues)
+    CV_IMPL_PROPERTY_RO(cv::Mat, EigenVectors, _eigenvectors)
+    CV_IMPL_PROPERTY_RO(cv::Mat, Mean, _mean)
+
+protected:
+    int _num_components;
+    double _threshold;
+    std::vector<Mat> _projections;
+    Mat _labels;
+    Mat _eigenvectors;
+    Mat _eigenvalues;
+    Mat _mean;
+};
+
+#endif // __OPENCV_FACE_BASIC_HPP
+

modules/face/src/fisher_faces.cpp

+/*
+ * Copyright (c) 2011,2012. Philipp Wagner <bytefish[at]gmx[dot]de>.
+ * Released to public domain under terms of the BSD Simplified license.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions 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.
+ *   * Neither the name of the organization nor the names of its contributors
+ *     may be used to endorse or promote products derived from this software
+ *     without specific prior written permission.
+ *
+ *   See <http://www.opensource.org/licenses/bsd-license>
+ */
+#include "precomp.hpp"
+#include "face_basic.hpp"
+
+namespace cv { namespace face {
+
+// Belhumeur, P. N., Hespanha, J., and Kriegman, D. "Eigenfaces vs. Fisher-
+// faces: Recognition using class specific linear projection.". IEEE
+// Transactions on Pattern Analysis and Machine Intelligence 19, 7 (1997),
+// 711–720.
+class Fisherfaces: public BasicFaceRecognizerImpl
+{
+public:
+    // Initializes an empty Fisherfaces model.
+    Fisherfaces(int num_components = 0, double threshold = DBL_MAX)
+        : BasicFaceRecognizerImpl(num_components, threshold)
+    { }
+
+    // Computes a Fisherfaces model with images in src and corresponding labels
+    // in labels.
+    void train(InputArrayOfArrays src, InputArray labels);
+
+    // Predicts the label of a query image in src.
+    int predict(InputArray src) const;
+
+    // Predicts the label and confidence for a given sample.
+    void predict(InputArray _src, int &label, double &dist) const;
+};
+
+// Removes duplicate elements in a given vector.
+template<typename _Tp>
+inline std::vector<_Tp> remove_dups(const std::vector<_Tp>& src) {
+    typedef typename std::set<_Tp>::const_iterator constSetIterator;
+    typedef typename std::vector<_Tp>::const_iterator constVecIterator;
+    std::set<_Tp> set_elems;
+    for (constVecIterator it = src.begin(); it != src.end(); ++it)
+        set_elems.insert(*it);
+    std::vector<_Tp> elems;
+    for (constSetIterator it = set_elems.begin(); it != set_elems.end(); ++it)
+        elems.push_back(*it);
+    return elems;
+}
+
+//------------------------------------------------------------------------------
+// Fisherfaces
+//------------------------------------------------------------------------------
+void Fisherfaces::train(InputArrayOfArrays src, InputArray _lbls) {
+    if(src.total() == 0) {
+        String error_message = format("Empty training data was given. You'll need more than one sample to learn a model.");
+        CV_Error(Error::StsBadArg, error_message);
+    } else if(_lbls.getMat().type() != CV_32SC1) {
+        String error_message = format("Labels must be given as integer (CV_32SC1). Expected %d, but was %d.", CV_32SC1, _lbls.type());
+        CV_Error(Error::StsBadArg, error_message);
+    }
+    // make sure data has correct size
+    if(src.total() > 1) {
+        for(int i = 1; i < static_cast<int>(src.total()); i++) {
+            if(src.getMat(i-1).total() != src.getMat(i).total()) {
+                String error_message = format("In the Fisherfaces method all input samples (training images) must be of equal size! Expected %d pixels, but was %d pixels.", src.getMat(i-1).total(), src.getMat(i).total());
+                CV_Error(Error::StsUnsupportedFormat, error_message);
+            }
+        }
+    }
+    // get data
+    Mat labels = _lbls.getMat();
+    Mat data = asRowMatrix(src, CV_64FC1);
+    // number of samples
+    int N = data.rows;
+    // make sure labels are passed in correct shape
+    if(labels.total() != (size_t) N) {
+        String error_message = format("The number of samples (src) must equal the number of labels (labels)! len(src)=%d, len(labels)=%d.", N, labels.total());
+        CV_Error(Error::StsBadArg, error_message);
+    } else if(labels.rows != 1 && labels.cols != 1) {
+        String error_message = format("Expected the labels in a matrix with one row or column! Given dimensions are rows=%s, cols=%d.", labels.rows, labels.cols);
+       CV_Error(Error::StsBadArg, error_message);
+    }
+    // clear existing model data
+    _labels.release();
+    _projections.clear();
+    // safely copy from cv::Mat to std::vector
+    std::vector<int> ll;
+    for(unsigned int i = 0; i < labels.total(); i++) {
+        ll.push_back(labels.at<int>(i));
+    }
+    // get the number of unique classes
+    int C = (int) remove_dups(ll).size();
+    // clip number of components to be a valid number
+    if((_num_components <= 0) || (_num_components > (C-1)))
+        _num_components = (C-1);
+    // perform a PCA and keep (N-C) components
+    PCA pca(data, Mat(), PCA::DATA_AS_ROW, (N-C));
+    // project the data and perform a LDA on it
+    LDA lda(pca.project(data),labels, _num_components);
+    // store the total mean vector
+    _mean = pca.mean.reshape(1,1);
+    // store labels
+    _labels = labels.clone();
+    // store the eigenvalues of the discriminants
+    lda.eigenvalues().convertTo(_eigenvalues, CV_64FC1);
+    // Now calculate the projection matrix as pca.eigenvectors * lda.eigenvectors.
+    // Note: OpenCV stores the eigenvectors by row, so we need to transpose it!
+    gemm(pca.eigenvectors, lda.eigenvectors(), 1.0, Mat(), 0.0, _eigenvectors, GEMM_1_T);
+    // store the projections of the original data
+    for(int sampleIdx = 0; sampleIdx < data.rows; sampleIdx++) {
+        Mat p = LDA::subspaceProject(_eigenvectors, _mean, data.row(sampleIdx));
+        _projections.push_back(p);
+    }
+}
+
+void Fisherfaces::predict(InputArray _src, int &minClass, double &minDist) const {
+    Mat src = _src.getMat();
+    // check data alignment just for clearer exception messages
+    if(_projections.empty()) {
+        // throw error if no data (or simply return -1?)
+        String error_message = "This Fisherfaces model is not computed yet. Did you call Fisherfaces::train?";
+        CV_Error(Error::StsBadArg, error_message);
+    } else if(src.total() != (size_t) _eigenvectors.rows) {
+        String error_message = format("Wrong input image size. Reason: Training and Test images must be of equal size! Expected an image with %d elements, but got %d.", _eigenvectors.rows, src.total());
+        CV_Error(Error::StsBadArg, error_message);
+    }
+    // project into LDA subspace
+    Mat q = LDA::subspaceProject(_eigenvectors, _mean, src.reshape(1,1));
+    // find 1-nearest neighbor
+    minDist = DBL_MAX;
+    minClass = -1;
+    for(size_t sampleIdx = 0; sampleIdx < _projections.size(); sampleIdx++) {
+        double dist = norm(_projections[sampleIdx], q, NORM_L2);
+        if((dist < minDist) && (dist < _threshold)) {
+            minDist = dist;
+            minClass = _labels.at<int>((int)sampleIdx);
+        }
+    }
+}
+
+int Fisherfaces::predict(InputArray _src) const {
+    int label;
+    double dummy;
+    predict(_src, label, dummy);
+    return label;
+}
+
+Ptr<BasicFaceRecognizer> createFisherFaceRecognizer(int num_components, double threshold)
+{
+    return makePtr<Fisherfaces>(num_components, threshold);
+}
+
+} }

modules/face/src/precomp.hpp

@@ -43,12 +43,16 @@
 #ifndef __OPENCV_PRECOMP_H__
 #define __OPENCV_PRECOMP_H__
 
-#include "opencv2/face.hpp"
 #include "opencv2/imgproc.hpp"
 #include "opencv2/core.hpp"
 #include "opencv2/core/utility.hpp"
 #include "opencv2/core/private.hpp"
-
+#include "opencv2/core/persistence.hpp"
 #include <map>
+#include <iostream>
+#include <set>
+#include <limits>
+#include <iostream>
 
 #endif
+

modules/line_descriptor/include/opencv2/line_descriptor.hpp

@@ -116,10 +116,4 @@ generates an 8 bit string. Concatenating 32 comparison strings, we get the 256-b
 representation of a single LBD.
 */
 
-namespace cv
-{
-CV_EXPORTS bool initModule_line_descriptor( void );
-
-}
-
 #endif 

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

@@ -74,8 +74,6 @@ namespace line_descriptor
 //! @addtogroup line_descriptor
 //! @{
 
-CV_EXPORTS bool initModule_line_descriptor();
-
 /** @brief A class to represent a line
 
 As aformentioned, it is been necessary to design a class that fully stores the information needed to
@@ -307,9 +305,6 @@ class CV_EXPORTS BinaryDescriptor : public Algorithm
   virtual void computeImpl( const Mat& imageSrc, std::vector<KeyLine>& keylines, Mat& descriptors, bool returnFloatDescr,
                             bool useDetectionData ) const;
 
-  /** function inherited from Algorithm */
-  AlgorithmInfo* info() const;
-
  private:
   /** struct to represent lines extracted from an octave */
   struct OctaveLine
@@ -911,10 +906,6 @@ void detectImpl( const Mat& imageSrc, std::vector<KeyLine>& keylines, int numOct
 
 /* matrices for Gaussian pyramids */
 std::vector<cv::Mat> gaussianPyrs;
-
-protected:
-/* function inherited from Algorithm */
-AlgorithmInfo* info() const;
 };
 
 /** @brief furnishes all functionalities for querying a dataset provided by user or internal to
@@ -1068,10 +1059,6 @@ BinaryDescriptorMatcher();
 {
 }
 
-protected:
-/** function inherited from Algorithm */
-AlgorithmInfo* info() const;
-
 private:
 class BucketGroup
 {

modules/line_descriptor/src/line_descriptor_init.cpp

-/*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 "precomp.hpp"
-
-namespace cv
-{
-namespace line_descriptor
-{
-
-CV_INIT_ALGORITHM( BinaryDescriptor, "BINARY.DESCRIPTOR", );
-CV_INIT_ALGORITHM( BinaryDescriptorMatcher, "BINARY.DESCRIPTOR.MATCHER", );
-CV_INIT_ALGORITHM( LSDDetector, "LSDDETECTOR", );
-
-bool initModule_line_descriptor( void )
-{
-  bool all = true;
-  all &= !BinaryDescriptor_info_auto.name().empty();
-  all &= !BinaryDescriptorMatcher_info_auto.name().empty();
-  all &= !LSDDetector_info_auto.name().empty();
-
-  return all;
-}
-
-}
-}

modules/optflow/src/deepflow.cpp

@@ -56,8 +56,6 @@ public:
     void calc( InputArray I0, InputArray I1, InputOutputArray flow );
     void collectGarbage();
 
-//    AlgorithmInfo* info() const;
-
 protected:
     float sigma; // Gaussian smoothing parameter
     int minSize; // minimal dimension of an image in the pyramid

modules/optflow/src/interfaces.cpp

@@ -56,7 +56,6 @@ public:
     OpticalFlowSimpleFlow();
     void calc(InputArray I0, InputArray I1, InputOutputArray flow);
     void collectGarbage();
-//    AlgorithmInfo* info() const;
 
 protected:
     int layers;
@@ -129,7 +128,6 @@ public:
     OpticalFlowFarneback();
     void calc(InputArray I0, InputArray I1, InputOutputArray flow);
     void collectGarbage();
-//    AlgorithmInfo* info() const;
 protected:
     int numLevels;
     double pyrScale;

modules/rgbd/include/opencv2/rgbd.hpp

@@ -137,9 +137,6 @@ namespace rgbd
 
     ~RgbdNormals();
 
-    AlgorithmInfo*
-    info() const;
-
     /** Given a set of 3d points in a depth image, compute the normals at each point.
      * @param points a rows x cols x 3 matrix of CV_32F/CV64F or a rows x cols x 1 CV_U16S
      * @param normals a rows x cols x 3 matrix
@@ -153,14 +150,13 @@ namespace rgbd
     void
     initialize() const;
 
-    /** Return the current method in that normal computer
-     * @return
-     */
-    int
-    method() const
-    {
-      return method_;
-    }
+    CV_IMPL_PROPERTY(int, Rows, rows_)
+    CV_IMPL_PROPERTY(int, Cols, cols_)
+    CV_IMPL_PROPERTY(int, WindowSize, window_size_)
+    CV_IMPL_PROPERTY(int, Depth, depth_)
+    CV_IMPL_PROPERTY_S(cv::Mat, K, K_)
+    CV_IMPL_PROPERTY(int, Method, method_)
+
   protected:
     void
     initialize_normals_impl(int rows, int cols, int depth, const Mat & K, int window_size, int method) const;
@@ -204,9 +200,6 @@ namespace rgbd
 
     ~DepthCleaner();
 
-    AlgorithmInfo*
-    info() const;
-
     /** Given a set of 3d points in a depth image, compute the normals at each point.
      * @param points a rows x cols x 3 matrix of CV_32F/CV64F or a rows x cols x 1 CV_U16S
      * @param depth a rows x cols matrix of the cleaned up depth
@@ -220,14 +213,10 @@ namespace rgbd
     void
     initialize() const;
 
-    /** Return the current method in that normal computer
-     * @return
-     */
-    int
-    method() const
-    {
-      return method_;
-    }
+    CV_IMPL_PROPERTY(int, WindowSize, window_size_)
+    CV_IMPL_PROPERTY(int, Depth, depth_)
+    CV_IMPL_PROPERTY(int, Method, method_)
+
   protected:
     void
     initialize_cleaner_impl() const;
@@ -316,8 +305,14 @@ namespace rgbd
     void
     operator()(InputArray points3d, OutputArray mask, OutputArray plane_coefficients);
 
-    AlgorithmInfo*
-    info() const;
+    CV_IMPL_PROPERTY(int, BlockSize, block_size_)
+    CV_IMPL_PROPERTY(int, MinSize, min_size_)
+    CV_IMPL_PROPERTY(int, Method, method_)
+    CV_IMPL_PROPERTY(double, Threshold, threshold_)
+    CV_IMPL_PROPERTY(double, SensorErrorA, sensor_error_a_)
+    CV_IMPL_PROPERTY(double, SensorErrorB, sensor_error_b_)
+    CV_IMPL_PROPERTY(double, SensorErrorC, sensor_error_c_)
+
   private:
     /** The method to use to compute the planes */
     int method_;
@@ -469,6 +464,19 @@ namespace rgbd
      */
     virtual Size prepareFrameCache(Ptr<OdometryFrame>& frame, int cacheType) const;
 
+    static Ptr<Odometry> create(const String & odometryType);
+
+    //TODO: which properties are common for all Odometry successors?
+    CV_PURE_PROPERTY_S(cv::Mat, CameraMatrix)
+//    CV_PURE_PROPERTY(double, MinDepth)
+//    CV_PURE_PROPERTY(double, MaxDepth)
+//    CV_PURE_PROPERTY(double, MaxDepthDiff)
+//    CV_PURE_PROPERTY_S(cv::Mat, IterationCounts)
+//    CV_PURE_PROPERTY(double, MaxPointsPart)
+    CV_PURE_PROPERTY(int, TransformType)
+//    CV_PURE_PROPERTY(double, MaxTranslation)
+//    CV_PURE_PROPERTY(double, MaxRotation)
+
   protected:
     virtual void
     checkParams() const = 0;
@@ -504,8 +512,16 @@ namespace rgbd
 
     virtual Size prepareFrameCache(Ptr<OdometryFrame>& frame, int cacheType) const;
 
-    AlgorithmInfo*
-    info() const;
+    CV_IMPL_PROPERTY_S(cv::Mat, CameraMatrix, cameraMatrix)
+    CV_IMPL_PROPERTY(double, MinDepth, minDepth)
+    CV_IMPL_PROPERTY(double, MaxDepth, maxDepth)
+    CV_IMPL_PROPERTY(double, MaxDepthDiff, maxDepthDiff)
+    CV_IMPL_PROPERTY_S(cv::Mat, IterationCounts, iterCounts)
+    CV_IMPL_PROPERTY_S(cv::Mat, MinGradientMagnitudes, minGradientMagnitudes)
+    CV_IMPL_PROPERTY(double, MaxPointsPart, maxPointsPart)
+    CV_IMPL_PROPERTY(int, TransformType, transformType)
+    CV_IMPL_PROPERTY(double, MaxTranslation, maxTranslation)
+    CV_IMPL_PROPERTY(double, MaxRotation, maxRotation)
 
   protected:
     virtual void
@@ -553,8 +569,16 @@ namespace rgbd
 
     virtual Size prepareFrameCache(Ptr<OdometryFrame>& frame, int cacheType) const;
 
-    AlgorithmInfo*
-    info() const;
+    CV_IMPL_PROPERTY_S(cv::Mat, CameraMatrix, cameraMatrix)
+    CV_IMPL_PROPERTY(double, MinDepth, minDepth)
+    CV_IMPL_PROPERTY(double, MaxDepth, maxDepth)
+    CV_IMPL_PROPERTY(double, MaxDepthDiff, maxDepthDiff)
+    CV_IMPL_PROPERTY_S(cv::Mat, IterationCounts, iterCounts)
+    CV_IMPL_PROPERTY(double, MaxPointsPart, maxPointsPart)
+    CV_IMPL_PROPERTY(int, TransformType, transformType)
+    CV_IMPL_PROPERTY(double, MaxTranslation, maxTranslation)
+    CV_IMPL_PROPERTY(double, MaxRotation, maxRotation)
+    CV_IMPL_PROPERTY_RO(Ptr<RgbdNormals>, NormalsComputer, normalsComputer)
 
   protected:
     virtual void
@@ -607,8 +631,17 @@ namespace rgbd
 
     virtual Size prepareFrameCache(Ptr<OdometryFrame>& frame, int cacheType) const;
 
-    AlgorithmInfo*
-    info() const;
+    CV_IMPL_PROPERTY_S(cv::Mat, CameraMatrix, cameraMatrix)
+    CV_IMPL_PROPERTY(double, MinDepth, minDepth)
+    CV_IMPL_PROPERTY(double, MaxDepth, maxDepth)
+    CV_IMPL_PROPERTY(double, MaxDepthDiff, maxDepthDiff)
+    CV_IMPL_PROPERTY(double, MaxPointsPart, maxPointsPart)
+    CV_IMPL_PROPERTY_S(cv::Mat, IterationCounts, iterCounts)
+    CV_IMPL_PROPERTY_S(cv::Mat, MinGradientMagnitudes, minGradientMagnitudes)
+    CV_IMPL_PROPERTY(int, TransformType, transformType)
+    CV_IMPL_PROPERTY(double, MaxTranslation, maxTranslation)
+    CV_IMPL_PROPERTY(double, MaxRotation, maxRotation)
+    CV_IMPL_PROPERTY_RO(Ptr<RgbdNormals>, NormalsComputer, normalsComputer)
 
   protected:
     virtual void
@@ -669,3 +702,4 @@ namespace rgbd
 #endif
 
 /* End of file. */
+

modules/rgbd/samples/odometry_evaluation.cpp

@@ -173,13 +173,13 @@ int main(int argc, char** argv)
 
     Ptr<OdometryFrame> frame_prev = Ptr<OdometryFrame>(new OdometryFrame()),
                            frame_curr = Ptr<OdometryFrame>(new OdometryFrame());
-    Ptr<Odometry> odometry = Algorithm::create<Odometry>("RGBD." + string(argv[3]) + "Odometry");
+    Ptr<Odometry> odometry = Odometry::create("RGBD." + string(argv[3]) + "Odometry");
     if(odometry.empty())
     {
         cout << "Can not create Odometry algorithm. Check the passed odometry name." << endl;
         return -1;
     }
-    odometry->set("cameraMatrix", cameraMatrix);
+    odometry->setCameraMatrix(cameraMatrix);
 
     MyTickMeter gtm;
     int count = 0;

modules/rgbd/src/odometry.cpp

@@ -1069,6 +1069,17 @@ Size Odometry::prepareFrameCache(Ptr<OdometryFrame> &frame, int /*cacheType*/) c
     return Size();
 }
 
+Ptr<Odometry> Odometry::create(const String & odometryType)
+{
+    if (odometryType == "RgbdOdometry")
+        return makePtr<RgbdOdometry>();
+    else if (odometryType == "ICPOdometry")
+        return makePtr<ICPOdometry>();
+    else if (odometryType == "RgbdICPOdometry")
+        return makePtr<RgbdICPOdometry>();
+    return Ptr<Odometry>();
+}
+
 //
 RgbdOdometry::RgbdOdometry() :
     minDepth(DEFAULT_MIN_DEPTH()),
@@ -1229,10 +1240,15 @@ Size ICPOdometry::prepareFrameCache(Ptr<OdometryFrame>& frame, int cacheType) co
             else
             {
                 if(normalsComputer.empty() ||
-                   normalsComputer->get<int>("rows") != frame->depth.rows ||
-                   normalsComputer->get<int>("cols") != frame->depth.cols ||
-                   norm(normalsComputer->get<Mat>("K"), cameraMatrix) > FLT_EPSILON)
-                   normalsComputer = Ptr<RgbdNormals>(new RgbdNormals(frame->depth.rows, frame->depth.cols, frame->depth.depth(), cameraMatrix, normalWinSize, normalMethod));
+                   normalsComputer->getRows() != frame->depth.rows ||
+                   normalsComputer->getCols() != frame->depth.cols ||
+                   norm(normalsComputer->getK(), cameraMatrix) > FLT_EPSILON)
+                   normalsComputer = makePtr<RgbdNormals>(frame->depth.rows,
+                                                          frame->depth.cols,
+                                                          frame->depth.depth(),
+                                                          cameraMatrix,
+                                                          normalWinSize,
+                                                          normalMethod);
 
                 (*normalsComputer)(frame->pyramidCloud[0], frame->normals);
             }
@@ -1338,10 +1354,15 @@ Size RgbdICPOdometry::prepareFrameCache(Ptr<OdometryFrame>& frame, int cacheType
             else
             {
                 if(normalsComputer.empty() ||
-                   normalsComputer->get<int>("rows") != frame->depth.rows ||
-                   normalsComputer->get<int>("cols") != frame->depth.cols ||
-                   norm(normalsComputer->get<Mat>("K"), cameraMatrix) > FLT_EPSILON)
-                   normalsComputer = Ptr<RgbdNormals>(new RgbdNormals(frame->depth.rows, frame->depth.cols, frame->depth.depth(), cameraMatrix, normalWinSize, normalMethod));
+                   normalsComputer->getRows() != frame->depth.rows ||
+                   normalsComputer->getCols() != frame->depth.cols ||
+                   norm(normalsComputer->getK(), cameraMatrix) > FLT_EPSILON)
+                   normalsComputer = makePtr<RgbdNormals>(frame->depth.rows,
+                                                          frame->depth.cols,
+                                                          frame->depth.depth(),
+                                                          cameraMatrix,
+                                                          normalWinSize,
+                                                          normalMethod);
 
                 (*normalsComputer)(frame->pyramidCloud[0], frame->normals);
             }

modules/rgbd/src/rgbd_init.cpp

-/*
- * Software License Agreement (BSD License)
- *
- *  Copyright (c) 2012, Willow Garage, Inc.
- *  All rights reserved.
- *
- *  Redistribution and use in source and binary forms, with or without
- *  modification, are permitted provided that the following conditions
- *  are met:
- *
- *   * Redistributions of source code must retain the above copyright
- *     notice, this list of conditions and the following disclaimer.
- *   * Redistributions 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.
- *   * Neither the name of Willow Garage, Inc. nor the names of its
- *     contributors may 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
- *  COPYRIGHT OWNER 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.
- *
- */
-
-#include <opencv2/core.hpp>
-#include <opencv2/rgbd.hpp>
-#include "opencv2/core/utility.hpp"
-#include "opencv2/core/private.hpp"
-
-namespace cv
-{
-namespace rgbd
-{
-  CV_INIT_ALGORITHM(DepthCleaner, "RGBD.DepthCleaner",
-      obj.info()->addParam(obj, "window_size", obj.window_size_);
-      obj.info()->addParam(obj, "depth", obj.depth_);
-      obj.info()->addParam(obj, "method", obj.method_))
-
-  CV_INIT_ALGORITHM(RgbdNormals, "RGBD.RgbdNormals",
-      obj.info()->addParam(obj, "rows", obj.rows_);
-      obj.info()->addParam(obj, "cols", obj.cols_);
-      obj.info()->addParam(obj, "window_size", obj.window_size_);
-      obj.info()->addParam(obj, "depth", obj.depth_);
-      obj.info()->addParam(obj, "K", obj.K_);
-      obj.info()->addParam(obj, "method", obj.method_))
-
-  CV_INIT_ALGORITHM(RgbdPlane, "RGBD.RgbdPlane",
-      obj.info()->addParam(obj, "block_size", obj.block_size_);
-      obj.info()->addParam(obj, "min_size", obj.min_size_);
-      obj.info()->addParam(obj, "method", obj.method_);
-      obj.info()->addParam(obj, "threshold", obj.threshold_);
-      obj.info()->addParam(obj, "sensor_error_a", obj.sensor_error_a_);
-      obj.info()->addParam(obj, "sensor_error_b", obj.sensor_error_b_);
-      obj.info()->addParam(obj, "sensor_error_c", obj.sensor_error_c_))
-
-  CV_INIT_ALGORITHM(RgbdOdometry, "RGBD.RgbdOdometry",
-      obj.info()->addParam(obj, "cameraMatrix", obj.cameraMatrix);
-      obj.info()->addParam(obj, "minDepth", obj.minDepth);
-      obj.info()->addParam(obj, "maxDepth", obj.maxDepth);
-      obj.info()->addParam(obj, "maxDepthDiff", obj.maxDepthDiff);
-      obj.info()->addParam(obj, "iterCounts", obj.iterCounts);
-      obj.info()->addParam(obj, "minGradientMagnitudes", obj.minGradientMagnitudes);
-      obj.info()->addParam(obj, "maxPointsPart", obj.maxPointsPart);
-      obj.info()->addParam(obj, "transformType", obj.transformType);
-      obj.info()->addParam(obj, "maxTranslation", obj.maxTranslation);
-      obj.info()->addParam(obj, "maxRotation", obj.maxRotation);)
-
-  CV_INIT_ALGORITHM(ICPOdometry, "RGBD.ICPOdometry",
-      obj.info()->addParam(obj, "cameraMatrix", obj.cameraMatrix);
-      obj.info()->addParam(obj, "minDepth", obj.minDepth);
-      obj.info()->addParam(obj, "maxDepth", obj.maxDepth);
-      obj.info()->addParam(obj, "maxDepthDiff", obj.maxDepthDiff);
-      obj.info()->addParam(obj, "maxPointsPart", obj.maxPointsPart);
-      obj.info()->addParam(obj, "iterCounts", obj.iterCounts);
-      obj.info()->addParam(obj, "transformType", obj.transformType);
-      obj.info()->addParam(obj, "maxTranslation", obj.maxTranslation);
-      obj.info()->addParam(obj, "maxRotation", obj.maxRotation);
-      obj.info()->addParam<RgbdNormals>(obj, "normalsComputer", obj.normalsComputer, true, NULL, NULL);)
-
-  CV_INIT_ALGORITHM(RgbdICPOdometry, "RGBD.RgbdICPOdometry",
-      obj.info()->addParam(obj, "cameraMatrix", obj.cameraMatrix);
-      obj.info()->addParam(obj, "minDepth", obj.minDepth);
-      obj.info()->addParam(obj, "maxDepth", obj.maxDepth);
-      obj.info()->addParam(obj, "maxDepthDiff", obj.maxDepthDiff);
-      obj.info()->addParam(obj, "maxPointsPart", obj.maxPointsPart);
-      obj.info()->addParam(obj, "iterCounts", obj.iterCounts);
-      obj.info()->addParam(obj, "minGradientMagnitudes", obj.minGradientMagnitudes);
-      obj.info()->addParam(obj, "transformType", obj.transformType);
-      obj.info()->addParam(obj, "maxTranslation", obj.maxTranslation);
-      obj.info()->addParam(obj, "maxRotation", obj.maxRotation);
-      obj.info()->addParam<RgbdNormals>(obj, "normalsComputer", obj.normalsComputer, true, NULL, NULL);)
-
-  bool
-  initModule_rgbd(void);
-  bool
-  initModule_rgbd(void)
-  {
-    bool all = true;
-    all &= !RgbdNormals_info_auto.name().empty();
-    all &= !RgbdPlane_info_auto.name().empty();
-    all &= !RgbdOdometry_info_auto.name().empty();
-    all &= !ICPOdometry_info_auto.name().empty();
-    all &= !RgbdICPOdometry_info_auto.name().empty();
-    return all;
-  }
-}
-}
-

modules/rgbd/test/test_normal.cpp

@@ -309,7 +309,7 @@ protected:
     TickMeter tm;
     tm.start();
     Mat in_normals;
-    if (normals_computer.method() == RgbdNormals::RGBD_NORMALS_METHOD_LINEMOD)
+    if (normals_computer.getMethod() == RgbdNormals::RGBD_NORMALS_METHOD_LINEMOD)
     {
       std::vector<Mat> channels;
       split(points3d, channels);

modules/rgbd/test/test_odometry.cpp

@@ -241,7 +241,7 @@ void CV_OdometryTest::run(int)
     if(!readData(image, depth))
         return;
         
-    odometry->set("cameraMatrix", K);
+    odometry->setCameraMatrix(K);
     
     Mat calcRt;
     
@@ -338,18 +338,18 @@ void CV_OdometryTest::run(int)
 
 TEST(RGBD_Odometry_Rgbd, algorithmic)
 {
-    cv::rgbd::CV_OdometryTest test(cv::Algorithm::create<cv::rgbd::Odometry>("RGBD.RgbdOdometry"), 0.99, 0.94);
+    cv::rgbd::CV_OdometryTest test(cv::rgbd::Odometry::create("RGBD.RgbdOdometry"), 0.99, 0.94);
     test.safe_run();
 }
 
 TEST(RGBD_Odometry_ICP, algorithmic)
 {
-    cv::rgbd::CV_OdometryTest test(cv::Algorithm::create<cv::rgbd::Odometry>("RGBD.ICPOdometry"), 0.99, 0.99);
+    cv::rgbd::CV_OdometryTest test(cv::rgbd::Odometry::create("RGBD.ICPOdometry"), 0.99, 0.99);
     test.safe_run();
 }
 
 TEST(RGBD_Odometry_RgbdICP, algorithmic)
 {
-    cv::rgbd::CV_OdometryTest test(cv::Algorithm::create<cv::rgbd::Odometry>("RGBD.RgbdICPOdometry"), 0.99, 0.99);
+    cv::rgbd::CV_OdometryTest test(cv::rgbd::Odometry::create("RGBD.RgbdICPOdometry"), 0.99, 0.99);
     test.safe_run();
 }

modules/saliency/include/opencv2/saliency.hpp

@@ -80,12 +80,4 @@ To see how API works, try tracker demo:
 
 */
 
-namespace cv
-{
-namespace saliency
-{
-CV_EXPORTS bool initModule_saliency( void );
-}
-}
-
 #endif //__OPENCV_SALIENCY_HPP__

modules/saliency/include/opencv2/saliency/saliencySpecializedClasses.hpp

@@ -47,6 +47,7 @@
 #include <string>
 #include <iostream>
 #include <stdint.h>
+#include "opencv2/core.hpp"
 
 namespace cv
 {
@@ -75,9 +76,11 @@ public:
   void read( const FileNode& fn );
   void write( FileStorage& fs ) const;
 
+  CV_IMPL_PROPERTY(int, ImageWidth, resImWidth)
+  CV_IMPL_PROPERTY(int, ImageHeight, resImHeight)
+
 protected:
   bool computeSaliencyImpl( const InputArray image, OutputArray saliencyMap );
-  AlgorithmInfo* info() const;
   int resImWidth;
   int resImHeight;
 
@@ -111,6 +114,9 @@ public:
   */
   bool init();
 
+  CV_IMPL_PROPERTY(int, ImageWidth, imageWidth)
+  CV_IMPL_PROPERTY(int, ImageHeight, imageHeight)
+
 protected:
   /** @brief Performs all the operations and calls all internal functions necessary for the accomplishment of the
     Fast Self-tuning Background Subtraction Algorithm algorithm.
@@ -121,7 +127,6 @@ protected:
         stream).
   */
   bool computeSaliencyImpl( const InputArray image, OutputArray saliencyMap );
-  AlgorithmInfo* info() const;
 
 private:
 
@@ -200,6 +205,10 @@ public:
      */
   void setBBResDir( std::string resultsDir );
 
+  CV_IMPL_PROPERTY(double, Base, _base)
+  CV_IMPL_PROPERTY(int, NSS, _NSS)
+  CV_IMPL_PROPERTY(int, W, _W)
+
 protected:
   /** @brief Performs all the operations and calls all internal functions necessary for the
   accomplishment of the Binarized normed gradients algorithm.
@@ -211,7 +220,6 @@ protected:
     represented by a *Vec4i* for (minX, minY, maxX, maxY).
      */
   bool computeSaliencyImpl( const InputArray image, OutputArray objectnessBoundingBox );
-  AlgorithmInfo* info() const;
 
 private:
 

modules/saliency/src/saliency.cpp

@@ -53,9 +53,13 @@ Saliency::~Saliency()
 
 Ptr<Saliency> Saliency::create( const String& saliencyType )
 {
-
-  return Algorithm::create<Saliency>( "SALIENCY." + saliencyType );
-
+    if (saliencyType == "SPECTRAL_RESIDUAL")
+        return makePtr<StaticSaliencySpectralResidual>();
+    else if (saliencyType == "BING")
+        return makePtr<ObjectnessBING>();
+    else if (saliencyType == "BinWangApr2014")
+        return makePtr<MotionSaliencyBinWangApr2014>();
+    return Ptr<Saliency>();
 }
 
 bool Saliency::computeSaliency( const InputArray image, OutputArray saliencyMap )

modules/saliency/src/saliency_init.cpp

-/*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, OpenCV Foundation, 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 "precomp.hpp"
-#include "opencv2/saliency.hpp"
-
-namespace cv
-{
-namespace saliency
-{
-
-CV_INIT_ALGORITHM( StaticSaliencySpectralResidual, "SALIENCY.SPECTRAL_RESIDUAL",
-                   obj.info()->addParam( obj, "resImWidth", obj.resImWidth); obj.info()->addParam( obj, "resImHeight", obj.resImHeight) );
-
-
-CV_INIT_ALGORITHM(
-    ObjectnessBING, "SALIENCY.BING",
-    obj.info()->addParam(obj, "_base", obj._base); obj.info()->addParam(obj, "_NSS", obj._NSS); obj.info()->addParam(obj, "_W", obj._W) );
-
-CV_INIT_ALGORITHM( MotionSaliencyBinWangApr2014, "SALIENCY.BinWangApr2014",
-                   obj.info()->addParam( obj, "imageWidth", obj.imageWidth); obj.info()->addParam( obj, "imageHeight", obj.imageHeight) );
-
-bool initModule_saliency( void )
-{
-  bool all = true;
-  all &= !StaticSaliencySpectralResidual_info_auto.name().empty();
-  //all &= !MotionSaliencySuBSENSE_info_auto.name().empty();
-  all &= !MotionSaliencyBinWangApr2014_info_auto.name().empty();
-  all &= !ObjectnessBING_info_auto.name().empty();
-
-  return all;
-}
-
-}  // namespace saliency
-}  // namespace cv

modules/tracking/include/opencv2/tracking.hpp

@@ -327,10 +327,6 @@ The first argument is the name of the tracker and the second is a video source.
 
 */
 
-namespace cv
-{
-CV_EXPORTS bool initModule_tracking(void);
-}
-
 #include "opencv2/tracking/tracker.hpp"
+
 #endif //__OPENCV_TRACKING_LENLEN

modules/tracking/include/opencv2/tracking/tracker.hpp

@@ -574,7 +574,6 @@ class CV_EXPORTS_W Tracker : public virtual Algorithm
   Ptr<TrackerFeatureSet> featureSet;
   Ptr<TrackerSampler> sampler;
   Ptr<TrackerModel> model;
-  virtual AlgorithmInfo* info() const;
 };
 
 /************************************ Specific TrackerStateEstimator Classes ************************************/

modules/tracking/src/tracker.cpp

@@ -104,10 +104,6 @@ bool Tracker::update( const Mat& image, Rect2d& boundingBox )
   return updateImpl( image, boundingBox );
 }
 
-AlgorithmInfo* Tracker::info() const{
-    return 0;
-}
-
 Ptr<Tracker> Tracker::create( const String& trackerType )
 {
   BOILERPLATE_CODE("MIL",TrackerMIL);

modules/tracking/src/tracking_init.cpp

-/*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) 2013, OpenCV Foundation, 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 "precomp.hpp"
-#include "opencv2/tracking.hpp"
-
-namespace cv
-{
-
-bool initModule_tracking(void)
-{
-  return true;
-}
-
-}

modules/xfeatures2d/include/opencv2/xfeatures2d/cuda.hpp

@@ -152,7 +152,7 @@ public:
     //! max keypoints = min(keypointsRatio * img.size().area(), 65535)
     float keypointsRatio;
 
-    GpuMat sum, mask1, maskSum, intBuffer;
+    GpuMat sum, mask1, maskSum;
 
     GpuMat det, trace;
 

modules/xfeatures2d/samples/bagofwords_classification.cpp

@@ -2327,14 +2327,14 @@ static void removeBowImageDescriptorsByCount( vector<ObdImage>& images, vector<M
     CV_Assert( bowImageDescriptors.size() == objectPresent.size() );
 }
 
-static void setSVMParams( SVM::Params& svmParams, Mat& class_wts_cv, const Mat& responses, bool balanceClasses )
+static void setSVMParams( Ptr<SVM> & svm, const Mat& responses, bool balanceClasses )
 {
     int pos_ex = countNonZero(responses == 1);
     int neg_ex = countNonZero(responses == -1);
     cout << pos_ex << " positive training samples; " << neg_ex << " negative training samples" << endl;
 
-    svmParams.svmType = SVM::C_SVC;
-    svmParams.kernelType = SVM::RBF;
+    svm->setType(SVM::C_SVC);
+    svm->setKernel(SVM::RBF);
     if( balanceClasses )
     {
         Mat class_wts( 2, 1, CV_32FC1 );
@@ -2351,8 +2351,7 @@ static void setSVMParams( SVM::Params& svmParams, Mat& class_wts_cv, const Mat&
             class_wts.at<float>(0) = static_cast<float>(neg_ex)/static_cast<float>(pos_ex+neg_ex);
             class_wts.at<float>(1) = static_cast<float>(pos_ex)/static_cast<float>(pos_ex+neg_ex);
         }
-        class_wts_cv = class_wts;
-        svmParams.classWeights = class_wts_cv;
+        svm->setClassWeights(class_wts);
     }
 }
 
@@ -2440,10 +2439,8 @@ static Ptr<SVM> trainSVMClassifier( const SVMTrainParamsExt& svmParamsExt, const
         }
 
         cout << "TRAINING SVM FOR CLASS ..." << objClassName << "..." << endl;
-        SVM::Params svmParams;
-        Mat class_wts_cv;
-        setSVMParams( svmParams, class_wts_cv, responses, svmParamsExt.balanceClasses );
-        svm = SVM::create(svmParams);
+        svm = SVM::create();
+        setSVMParams( svm, responses, svmParamsExt.balanceClasses );
         ParamGrid c_grid, gamma_grid, p_grid, nu_grid, coef_grid, degree_grid;
         setSVMTrainAutoParams( c_grid, gamma_grid,  p_grid, nu_grid, coef_grid, degree_grid );
 

modules/xfeatures2d/src/surf.cuda.cpp

@@ -146,13 +146,13 @@ namespace
 
             bindImgTex(img);
 
-            cuda::integral(img, surf_.sum, surf_.intBuffer);
+            cuda::integral(img, surf_.sum);
             sumOffset = bindSumTex(surf_.sum);
 
             if (use_mask)
             {
                 cuda::min(mask, 1.0, surf_.mask1);
-                cuda::integral(surf_.mask1, surf_.maskSum, surf_.intBuffer);
+                cuda::integral(surf_.mask1, surf_.maskSum);
                 maskOffset = bindMaskSumTex(surf_.maskSum);
             }
         }
@@ -425,7 +425,6 @@ void cv::cuda::SURF_CUDA::releaseMemory()
     sum.release();
     mask1.release();
     maskSum.release();
-    intBuffer.release();
     det.release();
     trace.release();
     maxPosBuffer.release();

modules/ximgproc/include/opencv2/ximgproc/edge_filter.hpp

@@ -216,6 +216,13 @@ public:
     CV_WRAP virtual void collectGarbage() = 0;
 
     CV_WRAP static Ptr<AdaptiveManifoldFilter> create();
+
+    CV_PURE_PROPERTY(double, SigmaS)
+    CV_PURE_PROPERTY(double, SigmaR)
+    CV_PURE_PROPERTY(int, TreeHeight)
+    CV_PURE_PROPERTY(int, PCAIterations)
+    CV_PURE_PROPERTY(bool, AdjustOutliers)
+    CV_PURE_PROPERTY(bool, UseRNG)
 };
 
 /** @brief Factory method, create instance of AdaptiveManifoldFilter and produce some initialization routines.

modules/ximgproc/src/adaptive_manifold_filter_n.cpp

@@ -107,14 +107,19 @@ static void splitChannels(InputArrayOfArrays src, vector<Mat>& dst)
 class AdaptiveManifoldFilterN : public AdaptiveManifoldFilter
 {
 public:
-    AlgorithmInfo* info() const;
-
     AdaptiveManifoldFilterN();
 
     void filter(InputArray src, OutputArray dst, InputArray joint);
 
     void collectGarbage();
 
+    CV_IMPL_PROPERTY(double, SigmaS, sigma_s_)
+    CV_IMPL_PROPERTY(double, SigmaR, sigma_r_)
+    CV_IMPL_PROPERTY(int, TreeHeight, tree_height_)
+    CV_IMPL_PROPERTY(int, PCAIterations, num_pca_iterations_)
+    CV_IMPL_PROPERTY(bool, AdjustOutliers, adjust_outliers_)
+    CV_IMPL_PROPERTY(bool, UseRNG, useRNG)
+
 protected:
 
     bool adjust_outliers_;
@@ -261,14 +266,6 @@ private: /*Parallelization routines*/
 
 };
 
-CV_INIT_ALGORITHM(AdaptiveManifoldFilterN, "AdaptiveManifoldFilter",
-    obj.info()->addParam(obj, "sigma_s", obj.sigma_s_, false, 0, 0, "Filter spatial standard deviation");
-    obj.info()->addParam(obj, "sigma_r", obj.sigma_r_, false, 0, 0, "Filter range standard deviation");
-    obj.info()->addParam(obj, "tree_height", obj.tree_height_, false, 0, 0, "Height of the manifold tree (default = -1 : automatically computed)");
-    obj.info()->addParam(obj, "num_pca_iterations", obj.num_pca_iterations_, false, 0, 0, "Number of iterations to computed the eigenvector v1");
-    obj.info()->addParam(obj, "adjust_outliers", obj.adjust_outliers_, false, 0, 0, "Specify adjust outliers using Eq. 9 or not");
-    obj.info()->addParam(obj, "use_RNG", obj.useRNG, false, 0, 0, "Specify use random to compute eigenvector or not");)
-
 AdaptiveManifoldFilterN::AdaptiveManifoldFilterN()
 {
     sigma_s_ = 16.0;
@@ -852,19 +849,17 @@ Ptr<AdaptiveManifoldFilter> AdaptiveManifoldFilter::create()
     return Ptr<AdaptiveManifoldFilter>(new AdaptiveManifoldFilterN());
 }
 
-CV_EXPORTS_W
 Ptr<AdaptiveManifoldFilter> createAMFilter(double sigma_s, double sigma_r, bool adjust_outliers)
 {
     Ptr<AdaptiveManifoldFilter> amf(new AdaptiveManifoldFilterN());
     
-    amf->set("sigma_s", sigma_s);
-    amf->set("sigma_r", sigma_r);
-    amf->set("adjust_outliers", adjust_outliers);
+    amf->setSigmaS(sigma_s);
+    amf->setSigmaR(sigma_r);
+    amf->setAdjustOutliers(adjust_outliers);
 
     return amf;
 }
 
-CV_EXPORTS_W
 void amFilter(InputArray joint, InputArray src, OutputArray dst, double sigma_s, double sigma_r, bool adjust_outliers)
 {
     Ptr<AdaptiveManifoldFilter> amf = createAMFilter(sigma_s, sigma_r, adjust_outliers);
@@ -872,4 +867,4 @@ void amFilter(InputArray joint, InputArray src, OutputArray dst, double sigma_s,
 }
 
 }
-}
\ No newline at end of file
+}

modules/ximgproc/test/test_adaptive_manifold.cpp

@@ -139,7 +139,7 @@ TEST(AdaptiveManifoldTest, AuthorsReferenceAccuracy)
 
         Mat res;
         Ptr<AdaptiveManifoldFilter> amf = createAMFilter(sigma_s, sigma_r, false);
-        amf->setBool("use_RNG", false);
+        amf->setUseRNG(false);
         amf->filter(srcImg, res, srcImg);
         amf->collectGarbage();
 
@@ -155,7 +155,7 @@ TEST(AdaptiveManifoldTest, AuthorsReferenceAccuracy)
 
         Mat res;
         Ptr<AdaptiveManifoldFilter> amf = createAMFilter(sigma_s, sigma_r, true);
-        amf->setBool("use_RNG", false);
+        amf->setUseRNG(false);
         amf->filter(srcImg, res, srcImg);
         amf->collectGarbage();
 
@@ -216,4 +216,4 @@ INSTANTIATE_TEST_CASE_P(TypicalSet, AdaptiveManifoldRefImplTest,
     Values("cv/shared/lena.png", "cv/edgefilter/kodim23.png", "cv/npr/test4.png")
 ));
 
-}
\ No newline at end of file
+}

modules/ximgproc/test/test_adaptive_manifold_ref_impl.cpp

@@ -179,14 +179,19 @@ namespace
     class AdaptiveManifoldFilterRefImpl : public AdaptiveManifoldFilter
     {
     public:
-        AlgorithmInfo* info() const;
-
         AdaptiveManifoldFilterRefImpl();
 
         void filter(InputArray src, OutputArray dst, InputArray joint);
 
         void collectGarbage();
 
+        CV_IMPL_PROPERTY(double, SigmaS, sigma_s_)
+        CV_IMPL_PROPERTY(double, SigmaR, sigma_r_)
+        CV_IMPL_PROPERTY(int, TreeHeight, tree_height_)
+        CV_IMPL_PROPERTY(int, PCAIterations, num_pca_iterations_)
+        CV_IMPL_PROPERTY(bool, AdjustOutliers, adjust_outliers_)
+        CV_IMPL_PROPERTY(bool, UseRNG, useRNG)
+
     protected:
         bool adjust_outliers_;
         double sigma_s_;
@@ -237,14 +242,6 @@ namespace
         min_pixel_dist_to_manifold_squared_.release();
     }
 
-    CV_INIT_ALGORITHM(AdaptiveManifoldFilterRefImpl, "AdaptiveManifoldFilterRefImpl",
-                      obj.info()->addParam(obj, "sigma_s", obj.sigma_s_, false, 0, 0, "Filter spatial standard deviation");
-                      obj.info()->addParam(obj, "sigma_r", obj.sigma_r_, false, 0, 0, "Filter range standard deviation");
-                      obj.info()->addParam(obj, "tree_height", obj.tree_height_, false, 0, 0, "Height of the manifold tree (default = -1 : automatically computed)");
-                      obj.info()->addParam(obj, "num_pca_iterations", obj.num_pca_iterations_, false, 0, 0, "Number of iterations to computed the eigenvector v1");
-                      obj.info()->addParam(obj, "adjust_outliers", obj.adjust_outliers_, false, 0, 0, "Specify supress outliers using Eq. 9 or not");
-                      obj.info()->addParam(obj, "use_RNG", obj.useRNG, false, 0, 0, "Specify use random to compute eigenvector or not");)
-
     inline double Log2(double n)
     {
         return log(n) / log(2.0);
@@ -974,11 +971,11 @@ Ptr<AdaptiveManifoldFilter> createAMFilterRefImpl(double sigma_s, double sigma_r
 {
     Ptr<AdaptiveManifoldFilter> amf(new AdaptiveManifoldFilterRefImpl());
     
-    amf->set("sigma_s", sigma_s);
-    amf->set("sigma_r", sigma_r);
-    amf->set("adjust_outliers", adjust_outliers);
+    amf->setSigmaS(sigma_s);
+    amf->setSigmaR(sigma_r);
+    amf->setAdjustOutliers(adjust_outliers);
 
     return amf;
 }
 
-}
\ No newline at end of file
+}

modules/xobjdetect/include/opencv2/xobjdetect.hpp

@@ -153,17 +153,6 @@ public:
      */
     virtual float predict(
         const Ptr<FeatureEvaluator>& feature_evaluator) const = 0;
-
-    /** @brief Write WaldBoost to FileStorage
-    @param fs FileStorage for output
-     */
-    virtual void write(FileStorage& fs) const = 0;
-
-    /** @brief Write WaldBoost to FileNode
-
-    @param node FileNode for reading
-     */
-    virtual void read(const FileNode& node) = 0;
 };
 
 /** @brief Construct WaldBoost object.