ImageDescriber_SIFT.hpp

// This file is part of the AliceVision project.
// Copyright (c) 2016 AliceVision contributors.
// Copyright (c) 2012 openMVG contributors.
// This Source Code Form is subject to the terms of the Mozilla Public License,
// v. 2.0. If a copy of the MPL was not distributed with this file,
// You can obtain one at https://mozilla.org/MPL/2.0/.
 
#pragma once
 
#include <aliceVision/config.hpp>
#include <aliceVision/feature/sift/ImageDescriber_SIFT_vlfeat.hpp>
 
#if ALICEVISION_IS_DEFINED(ALICEVISION_HAVE_POPSIFT)
    #include <aliceVision/gpu/gpu.hpp>
    #include <aliceVision/feature/sift/ImageDescriber_SIFT_popSIFT.hpp>
#endif
 
namespace aliceVision {
namespace feature {
 
class ImageDescriber_SIFT : public ImageDescriber
{
  public:
    explicit ImageDescriber_SIFT(const SiftParams& params = SiftParams(), bool isOriented = true)
      : _params(params),
        _isOriented(isOriented)
    {
#if ALICEVISION_IS_DEFINED(ALICEVISION_HAVE_POPSIFT)
        setUseCuda(gpu::gpuSupportCUDA(3, 0));
#else
        setUseCuda(false);
#endif
    }
 
    bool useCuda() const override { return _imageDescriberImpl->useCuda(); }
 
    bool useFloatImage() const override { return _imageDescriberImpl->useFloatImage(); }
 
    EImageDescriberType getDescriberType() const override { return _imageDescriberImpl->getDescriberType(); }
 
    std::size_t getMemoryConsumption(std::size_t width, std::size_t height) const override
    {
        return _imageDescriberImpl->getMemoryConsumption(width, height);
    }
 
    void setUpRight(bool upRight) override { _isOriented = !upRight; }
 
    void setUseCuda(bool useCuda) override
    {
        if (_imageDescriberImpl != nullptr && this->useCuda() == useCuda)
            return;
 
#if ALICEVISION_IS_DEFINED(ALICEVISION_HAVE_POPSIFT)
        if (useCuda)
        {
            _imageDescriberImpl.release();  // release first to ensure that we don't create the new ImageDescriber before destroying the previous one
            _imageDescriberImpl.reset(new ImageDescriber_SIFT_popSIFT(_params, _isOriented));
            return;
        }
#endif
 
        _imageDescriberImpl.release();  // release first to ensure that we don't create the new ImageDescriber before destroying the previous one
        _imageDescriberImpl.reset(new ImageDescriber_SIFT_vlfeat(_params, _isOriented));
    }
 
    void setCudaPipe(int pipe) override { _imageDescriberImpl->setCudaPipe(pipe); }
 
    void setConfigurationPreset(ConfigurationPreset preset) override
    {
        _params.setPreset(preset);
        _imageDescriberImpl->setConfigurationPreset(preset);
    }
 
    bool describe(const image::Image<unsigned char>& image,
                  std::unique_ptr<Regions>& regions,
                  const image::Image<unsigned char>* mask = nullptr) override
    {
        return _imageDescriberImpl->describe(image, regions, mask);
    }
 
    bool describe(const image::Image<float>& image, std::unique_ptr<Regions>& regions, const image::Image<unsigned char>* mask = nullptr) override
    {
        return _imageDescriberImpl->describe(image, regions, mask);
    }
 
    void allocate(std::unique_ptr<Regions>& regions) const override { _imageDescriberImpl->allocate(regions); }
 
    ~ImageDescriber_SIFT() override = default;
 
  private:
    SiftParams _params;
    std::unique_ptr<ImageDescriber> _imageDescriberImpl = nullptr;
    bool _isOriented = true;
};
 
}  // namespace feature
}  // namespace aliceVision