class cv::MSER

Overview

Maximally stable extremal region extractor. More…

#include <features2d.hpp>

class MSER: public cv::Feature2D
{
public:
    // methods

    static
    Ptr<MSER>
    create(
        int _delta = 5,
        int _min_area = 60,
        int _max_area = 14400,
        double _max_variation = 0.25,
        double _min_diversity = .2,
        int _max_evolution = 200,
        double _area_threshold = 1.01,
        double _min_margin = 0.003,
        int _edge_blur_size = 5
        );

    virtual
    void
    detectRegions(
        InputArray image,
        std::vector<std::vector<Point>>& msers,
        std::vector<Rect>& bboxes
        ) = 0;

    virtual
    int
    getDelta() const = 0;

    virtual
    int
    getMaxArea() const = 0;

    virtual
    int
    getMinArea() const = 0;

    virtual
    bool
    getPass2Only() const = 0;

    virtual
    void
    setDelta(int delta) = 0;

    virtual
    void
    setMaxArea(int maxArea) = 0;

    virtual
    void
    setMinArea(int minArea) = 0;

    virtual
    void
    setPass2Only(bool f) = 0;
};

Inherited Members

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

    virtual
    void
    compute(
        InputArray image,
        std::vector<KeyPoint>& keypoints,
        OutputArray descriptors
        );

    virtual
    void
    compute(
        InputArrayOfArrays images,
        std::vector<std::vector<KeyPoint>>& keypoints,
        OutputArrayOfArrays descriptors
        );

    virtual
    int
    defaultNorm() const;

    virtual
    int
    descriptorSize() const;

    virtual
    int
    descriptorType() const;

    virtual
    void
    detect(
        InputArray image,
        std::vector<KeyPoint>& keypoints,
        InputArray mask = noArray()
        );

    virtual
    void
    detect(
        InputArrayOfArrays images,
        std::vector<std::vector<KeyPoint>>& keypoints,
        InputArrayOfArrays masks = noArray()
        );

    virtual
    void
    detectAndCompute(
        InputArray image,
        InputArray mask,
        std::vector<KeyPoint>& keypoints,
        OutputArray descriptors,
        bool useProvidedKeypoints = false
        );

    virtual
    bool
    empty() const;

    void
    read(const String& fileName);

    virtual
    void
    read(const FileNode& fn);

    void
    write(const String& fileName) const;

    virtual
    void
    write(FileStorage& fs) const;

protected:
    // methods

    void
    writeFormat(FileStorage& fs) const;

Detailed Documentation

Maximally stable extremal region extractor.

The class encapsulates all the parameters of the MSER extraction algorithm (see wiki article).

• there are two different implementation of MSER: one for grey image, one for color image
• the grey image algorithm is taken from: [62]; the paper claims to be faster than union-find method; it actually get 1.5~2m/s on my centrino L7200 1.2GHz laptop.
• the color image algorithm is taken from: [28]; it should be much slower than grey image method ( 3~4 times ); the chi_table.h file is taken directly from paper’s source code which is distributed under GPL.
• (Python) A complete example showing the use of the MSER detector can be found at samples/python/mser.py

Methods

static
Ptr<MSER>
create(
    int _delta = 5,
    int _min_area = 60,
    int _max_area = 14400,
    double _max_variation = 0.25,
    double _min_diversity = .2,
    int _max_evolution = 200,
    double _area_threshold = 1.01,
    double _min_margin = 0.003,
    int _edge_blur_size = 5
    )

Full consturctor for MSER detector.

Parameters:

_delta	it compares \((size_{i}-size_{i-delta})/size_{i-delta}\)
_min_area	prune the area which smaller than minArea
_max_area	prune the area which bigger than maxArea
_max_variation	prune the area have simliar size to its children
_min_diversity	for color image, trace back to cut off mser with diversity less than min_diversity
_max_evolution	for color image, the evolution steps
_area_threshold	for color image, the area threshold to cause re-initialize
_min_margin	for color image, ignore too small margin
_edge_blur_size	for color image, the aperture size for edge blur

virtual
void
detectRegions(
    InputArray image,
    std::vector<std::vector<Point>>& msers,
    std::vector<Rect>& bboxes
    ) = 0

Detect MSER regions.

Parameters:

image	input image (8UC1, 8UC3 or 8UC4, must be greater or equal than 3x3)
msers	resulting list of point sets
bboxes	resulting bounding boxes