class cv::Algorithm

Overview

This is a base class for all more or less complex algorithms in OpenCV. More…

#include <core.hpp>

class Algorithm
{
public:
    // methods

    virtual
    void
    clear();

    virtual
    bool
    empty() const;

    virtual
    String
    getDefaultName() const;

    virtual
    void
    read(const FileNode& fn);

    virtual
    void
    save(const String& filename) const;

    virtual
    void
    write(FileStorage& fs) const;

    template <typename _Tp>
    static
    Ptr<_Tp>
    load(
        const String& filename,
        const String& objname = String()
        );

    template <typename _Tp>
    static
    Ptr<_Tp>
    loadFromString(
        const String& strModel,
        const String& objname = String()
        );

    template <typename _Tp>
    static
    Ptr<_Tp>
    read(const FileNode& fn);

protected:
    // methods

    void
    writeFormat(FileStorage& fs) const;
};

// direct descendants

class AlignExposures;
class BackgroundSubtractor;
class BaseCascadeClassifier;
class CalibrateCRF;
class CLAHE;
class CannyEdgeDetector;
class CascadeClassifier;
class Convolution;
class CornernessCriteria;
class CornersDetector;
class DenseOpticalFlow;
class DescriptorMatcher;
class DFT;
class DisparityBilateralFilter;
class Filter;
class HOG;
class HoughCirclesDetector;
class HoughLinesDetector;
class HoughSegmentDetector;
class ImagePyramid;
class LookUpTable;
class SparseOpticalFlow;
class TemplateMatching;
class DenseOpticalFlow;
class DescriptorMatcher;
class Feature2D;
class GeneralizedHough;
class HistogramCostExtractor;
class LineSegmentDetector;
class MergeExposures;
class MinProblemSolver;
class StatModel;
class Kernel;
class ShapeDistanceExtractor;
class ShapeTransformer;
class SparseOpticalFlow;
class StereoMatcher;
class DenseOpticalFlowExt;
class SuperResolution;
class Tonemap;

Detailed Documentation

This is a base class for all more or less complex algorithms in OpenCV.

especially for classes of algorithms, for which there can be multiple implementations. The examples are stereo correspondence (for which there are algorithms like block matching, semi-global block matching, graph-cut etc.), background subtraction (which can be done using mixture-of-gaussians models, codebook-based algorithm etc.), optical flow (block matching, Lucas-Kanade, Horn-Schunck etc.).

Here is example of SIFT use in your application via Algorithm interface:

#include "opencv2/opencv.hpp"
#include "opencv2/xfeatures2d.hpp"
using namespace cv::xfeatures2d;

Ptr<Feature2D> sift = SIFT::create();
FileStorage fs("sift_params.xml", FileStorage::READ);
if( fs.isOpened() ) // if we have file with parameters, read them
{
    sift->read(fs["sift_params"]);
    fs.release();
}
else // else modify the parameters and store them; user can later edit the file to use different parameters
{
    sift->setContrastThreshold(0.01f); // lower the contrast threshold, compared to the default value
    {
        WriteStructContext ws(fs, "sift_params", CV_NODE_MAP);
        sift->write(fs);
    }
}
Mat image = imread("myimage.png", 0), descriptors;
vector<KeyPoint> keypoints;
sift->detectAndCompute(image, noArray(), keypoints, descriptors);

Methods

virtual
void
clear()

Clears the algorithm state.

virtual
bool
empty() const

Returns true if the Algorithm is empty (e.g. in the very beginning or after unsuccessful read.

virtual
String
getDefaultName() const

Returns the algorithm string identifier. This string is used as top level xml/yml node tag when the object is saved to a file or string.

virtual
void
read(const FileNode& fn)

Reads algorithm parameters from a file storage.

virtual
void
save(const String& filename) const

Saves the algorithm to a file. In order to make this method work, the derived class must implement Algorithm::write(FileStorage& fs).

virtual
void
write(FileStorage& fs) const

Stores algorithm parameters in a file storage.

template <typename _Tp>
static
Ptr<_Tp>
load(
    const String& filename,
    const String& objname = String()
    )

Loads algorithm from the file.

This is static template method of Algorithm. It’s usage is following (in the case of SVM):

Ptr<SVM> svm = Algorithm::load<SVM>("my_svm_model.xml");

In order to make this method work, the derived class must overwrite Algorithm::read (const FileNode & fn).

Parameters:

filename	Name of the file to read.
objname	The optional name of the node to read (if empty, the first top-level node will be used)

template <typename _Tp>
static
Ptr<_Tp>
loadFromString(
    const String& strModel,
    const String& objname = String()
    )

Loads algorithm from a String.

This is static template method of Algorithm. It’s usage is following (in the case of SVM):

Ptr<SVM> svm = Algorithm::loadFromString<SVM>(myStringModel);

Parameters:

strModel	The string variable containing the model you want to load.
objname	The optional name of the node to read (if empty, the first top-level node will be used)

template <typename _Tp>
static
Ptr<_Tp>
read(const FileNode& fn)

Reads algorithm from the file node.

This is static template method of Algorithm. It’s usage is following (in the case of SVM):

cv::FileStorage fsRead("example.xml", FileStorage::READ);
Ptr<SVM> svm = Algorithm::read<SVM>(fsRead.root());

In order to make this method work, the derived class must overwrite Algorithm::read (const FileNode & fn) and also have static create() method without parameters (or with all the optional parameters)