sift.hpp

Go to the documentation of this file.

#ifndef SIFT_HPP
#define SIFT_HPP

#include <cmath>
#include <array>
#include <vector>

#include <vigra/multi_array.hxx>
#include <vigra/matrix.hxx>

#include "types.hpp"
#include "matrix.hpp"
#include "octaveelem.hpp"
#include "interestpoint.hpp"

namespace sift {
    class Sift {
        public:
            const bool subpixel;
        private:
            const f32_t _sigma;
            const f32_t _k;
            
            const u16_t _dogsPerEpoch;

            const u16_t _octaves;

            Matrix<OctaveElem> _gaussians;

            Matrix<vigra::MultiArray<2, f32_t>> _magnitudes;

            Matrix<vigra::MultiArray<2, f32_t>> _orientations;

        public:
            explicit 
                Sift(u16_t dogsPerEpoch = 3, u16_t octaves = 3, f32_t sigma = 1.6, 
                        f32_t k = std::sqrt(2), bool subpixel = false) : 
                        subpixel(subpixel), _sigma(sigma), _k(k), _dogsPerEpoch(dogsPerEpoch), 
                        _octaves(octaves) {
                    }

            std::vector<InterestPoint> calculate(vigra::MultiArray<2, f32_t>&);

        private:
            void _createDecriptors(std::vector<InterestPoint>&);

            std::vector<f32_t> _eliminateVectorThreshold(std::vector<f32_t>&) const;
            
            void _createMagnitudePyramid();

            void _createOrientationPyramid();

            void _eliminateEdgeResponses(std::vector<InterestPoint>&,  const Matrix<OctaveElem>&) const;

            const std::set<f32_t> _findPeaks(const std::array<f32_t, 36>&) const;

            void _orientationAssignment(std::vector<InterestPoint>&);

            const Point<u16_t, u16_t> _findNearestGaussian(f32_t);

            void _findScaleSpaceExtrema(const Matrix<OctaveElem>&, std::vector<InterestPoint>&) const;

            const Matrix<OctaveElem> _createDOGs(vigra::MultiArray<2, f32_t>&);
    };
}
#endif //SIFT_HPP