@ARTICLE{Najman2014,

author={Y. {Xu} and P. {Monasse} and T. {Géraud} and L. {Najman}},

journal={IEEE Transactions on Image Processing},

title={Tree-Based Morse Regions: A Topological Approach to Local Feature Detection},

year={2014},

volume={23},

number={12},

pages={5612-5625},

abstract={This paper introduces a topological approach to local invariant feature detection motivated by Morse theory. We use the critical points of the graph of the intensity image, revealing directly the topology information as initial interest points. Critical points are selected from what we call a tree-based shape-space. In particular, they are selected from both the connected components of the upper level sets of the image (the Max-tree) and those of the lower level sets (the Min-tree). They correspond to specific nodes on those two trees: 1) to the leaves (extrema) and 2) to the nodes having bifurcation (saddle points). We then associate to each critical point the largest region that contains it and is topologically equivalent in its tree. We call such largest regions the tree-based Morse regions (TBMRs). The TBMR can be seen as a variant of maximally stable extremal region (MSER), which are contrasted regions. Contrarily to MSER, TBMR relies only on topological information and thus fully inherit the invariance properties of the space of shapes (e.g., invariance to affine contrast changes and covariance to continuous transformations). In particular, TBMR extracts the regions independently of the contrast, which makes it truly contrast invariant. Furthermore, it is quasi-parameter free. TBMR extraction is fast, having the same complexity as MSER. Experimentally, TBMR achieves a repeatability on par with state-of-the-art methods, but obtains a significantly higher number of features. Both the accuracy and robustness of TBMR are demonstrated by applications to image registration and 3D reconstruction.},

keywords={feature extraction;image reconstruction;image registration;trees (mathematics);tree-based Morse regions;topological approach;local invariant feature detection;Morse theory;intensity image;initial interest points;critical points;tree-based shape-space;upper level image sets;Max-tree;lower level sets;Min-tree;saddle points;bifurcation;maximally stable extremal region variant;MSER;topological information;TBMR extraction;3D reconstruction;image registration;Feature extraction;Detectors;Shape;Time complexity;Level set;Three-dimensional displays;Image registration;Min/Max tree;local features;affine region detectors;image registration;3D reconstruction;Min/Max tree;local features;affine region detectors;image registration;3D reconstruction},

doi={10.1109/TIP.2014.2364127},

ISSN={1941-0042},

month={Dec},}

}

class CV_EXPORTS_W AffineFeature2D : public Feature2D

class CV_EXPORTS_W TBMR : public AffineFeature2D

{

CV_WRAP static Ptr<TBMR> create(int min_area = 60,

float max_area_relative = 0.01f,

float scale_factor = 1.25f,

int n_scales = -1);

CV_WRAP virtual void setMinArea(int minArea) = 0;

CV_WRAP virtual int getMinArea() const = 0;

CV_WRAP virtual void setMaxAreaRelative(float maxArea) = 0;

CV_WRAP virtual float getMaxAreaRelative() const = 0;

CV_WRAP virtual void setScaleFactor(float scale_factor) = 0;

CV_WRAP virtual float getScaleFactor() const = 0;

CV_WRAP virtual void setNScales(int n_scales) = 0;

CV_WRAP virtual int getNScales() const = 0;

};

#include "msd_pyramid.hpp"

#ifndef __OPENCV_XFEATURES2D_MSD_PYRAMID_HPP__

#define __OPENCV_XFEATURES2D_MSD_PYRAMID_HPP__

#include "precomp.hpp"

namespace cv

{

namespace xfeatures2d

{

class MSDImagePyramid

{

// Multi-threaded construction of the scale-space pyramid

struct MSDImagePyramidBuilder : ParallelLoopBody

{

MSDImagePyramidBuilder(const cv::Mat& _im, std::vector<cv::Mat>* _m_imPyr, float _scaleFactor)

{

im = &_im;

m_imPyr = _m_imPyr;

scaleFactor = _scaleFactor;

}

void operator()(const Range& range) const CV_OVERRIDE

{

for (int lvl = range.start; lvl < range.end; lvl++)

{

float scale = 1 / std::pow(scaleFactor, (float) lvl);

(*m_imPyr)[lvl] = cv::Mat(cv::Size(cvRound(im->cols * scale), cvRound(im->rows * scale)), im->type());

cv::resize(*im, (*m_imPyr)[lvl], cv::Size((*m_imPyr)[lvl].cols, (*m_imPyr)[lvl].rows), 0.0, 0.0, cv::INTER_AREA);

}

}

const cv::Mat* im;

std::vector<cv::Mat>* m_imPyr;

float scaleFactor;

};

MSDImagePyramid(const cv::Mat &im, const int nLevels, const float scaleFactor = 1.6f)

{

m_nLevels = nLevels;

m_scaleFactor = scaleFactor;

m_imPyr.clear();

m_imPyr.resize(nLevels);

m_imPyr[0] = im.clone();

if (m_nLevels > 1)

{

parallel_for_(Range(1, nLevels), MSDImagePyramidBuilder(im, &m_imPyr, scaleFactor));

}

}

~MSDImagePyramid() {};

const std::vector<cv::Mat> getImPyr() const

{

return m_imPyr;

};

std::vector<cv::Mat> m_imPyr;

int m_nLevels;

float m_scaleFactor;

};

}

}

#endif