class cv::AlignMTB

Overview

This algorithm converts images to median threshold bitmaps (1 for pixels brighter than median luminance and 0 otherwise) and than aligns the resulting bitmaps using bit operations. More…

#include <photo.hpp>

class AlignMTB: public cv::AlignExposures
{
public:
    // methods

    virtual
    Point
    calculateShift(
        InputArray img0,
        InputArray img1
        ) = 0;

    virtual
    void
    computeBitmaps(
        InputArray img,
        OutputArray tb,
        OutputArray eb
        ) = 0;

    virtual
    bool
    getCut() const = 0;

    virtual
    int
    getExcludeRange() const = 0;

    virtual
    int
    getMaxBits() const = 0;

    virtual
    void
    process(
        InputArrayOfArrays src,
        std::vector<Mat>& dst,
        InputArray times,
        InputArray response
        ) = 0;

    virtual
    void
    process(
        InputArrayOfArrays src,
        std::vector<Mat>& dst
        ) = 0;

    virtual
    void
    setCut(bool value) = 0;

    virtual
    void
    setExcludeRange(int exclude_range) = 0;

    virtual
    void
    setMaxBits(int max_bits) = 0;

    virtual
    void
    shiftMat(
        InputArray src,
        OutputArray dst,
        const Point shift
        ) = 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
    process(
        InputArrayOfArrays src,
        std::vector<Mat>& dst,
        InputArray times,
        InputArray response
        ) = 0;

protected:
    // methods

    void
    writeFormat(FileStorage& fs) const;

Detailed Documentation

This algorithm converts images to median threshold bitmaps (1 for pixels brighter than median luminance and 0 otherwise) and than aligns the resulting bitmaps using bit operations.

It is invariant to exposure, so exposure values and camera response are not necessary.

In this implementation new image regions are filled with zeros.

For more information see [90].

Methods

virtual
Point
calculateShift(
    InputArray img0,
    InputArray img1
    ) = 0

Calculates shift between two images, i. e. how to shift the second image to correspond it with the first.

Parameters:

img0	first image
img1	second image

virtual
void
computeBitmaps(
    InputArray img,
    OutputArray tb,
    OutputArray eb
    ) = 0

Computes median threshold and exclude bitmaps of given image.

Parameters:

img	input image
tb	median threshold bitmap
eb	exclude bitmap

virtual
void
process(
    InputArrayOfArrays src,
    std::vector<Mat>& dst,
    InputArray times,
    InputArray response
    ) = 0

Aligns images.

Parameters:

src	vector of input images
dst	vector of aligned images
times	vector of exposure time values for each image
response	256x1 matrix with inverse camera response function for each pixel value, it should have the same number of channels as images.

virtual
void
process(
    InputArrayOfArrays src,
    std::vector<Mat>& dst
    ) = 0

Short version of process, that doesn’t take extra arguments.

Parameters:

src	vector of input images
dst	vector of aligned images

virtual
void
shiftMat(
    InputArray src,
    OutputArray dst,
    const Point shift
    ) = 0

Helper function, that shift Mat filling new regions with zeros.

Parameters:

src	input image
dst	result image
shift	shift value