Image.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/numeric/numeric.hpp>
#include <aliceVision/image/pixelTypes.hpp>
 
//---------------------------------
//  Universal Image Processing Algorithm
//-- Container for a 2D image
//-- This class ensure that the image have a width and a height
//-- and a 2D array of T data.
//-
//-- Data is saved in row major format
//-- Pixel access is done with operator(y,x)
//  [2/3/2011 pierre MOULON]
//---------------------------
namespace aliceVision {
namespace image {
template<typename T>
class Image : public Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor>
{
  public:
    typedef T Tpixel;  //-- Pixel data type
    typedef Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor> Base;
 
    inline Image() { Base::resize(0, 0); }
 
    inline Image(int width, int height, bool fInit = false, const T val = T())
    {
        Base::resize(height, width);
        if (fInit)
        {
            Base::fill(val);
        }
    };
 
    inline Image(const Base& I)
      : Base(I)
    {}
 
    inline Image(Base&& src)
      : Base(std::move(src))
    {}
 
    inline Image& operator=(const Base& I)
    {
        Base::operator=(I);
        return *this;
    }
 
    virtual ~Image() = default;
    //-- Image construction method
    //------------------------------
 
    inline void resize(int width, int height, bool fInit = true, const T val = T())
    {
        Base::resize(height, width);
        if (fInit)
        {
            Base::fill(val);
        }
    }
 
    //------------------------------
    //-- accessors/getters methods
    inline int width() const { return static_cast<int>(Base::cols()); }
 
    inline int height() const { return static_cast<int>(Base::rows()); }
 
    inline int depth() const { return sizeof(Tpixel); }
 
    inline unsigned long long int memorySize() const
    {
        return static_cast<unsigned long long int>(width()) * static_cast<unsigned long long int>(height()) *
               static_cast<unsigned long long int>(depth());
    }
 
    inline int channels() const { return NbChannels<Tpixel>::size; }
 
    inline const T& operator()(int y, int x) const { return Base::operator()(y, x); }
 
    inline T& operator()(int y, int x) { return Base::operator()(y, x); }
 
    inline const T& operator()(int i) const { return Base::operator()(i); }
    inline T& operator()(int i) { return Base::operator()(i); }
 
    inline const Base& getMat() const { return (*this); }
    inline Base& getMat() { return (*this); }
 
    //-- accessors/getters methods
    //------------------------------
 
    inline bool contains(int y, int x) const { return 0 <= x && x < Base::cols() && 0 <= y && y < Base::rows(); }
 
    template<typename T1>
    friend Image<T1> operator+(const Image<T1>& imgA, const Image<T1>& imgB);
 
    template<typename T1>
    friend Image<T1> operator-(const Image<T1>& imgA, const Image<T1>& imgB);
 
    template<class UnaryFunction>
    bool perPixelOperation(UnaryFunction f)
    {
        for (auto row : this->rowwise())
        {
            std::transform(row.begin(), row.end(), row.begin(), f);
        }
 
        return true;
    }
 
  protected:
    //-- Image data are stored by inheritance of a matrix
};
 
template<typename T1>
Image<T1> operator+(const Image<T1>& imgA, const Image<T1>& imgB)
{
    return Image<T1>(imgA.Image<T1>::operator+(imgB));
}
 
template<typename T1>
Image<T1> operator-(const Image<T1>& imgA, const Image<T1>& imgB)
{
    return Image<T1>(imgA.Image<T1>::operator-(imgB));
}
 
template<typename T>
T getInterpolateColor(const Image<T>& img, double y, double x)
{
    const int xp = std::min(static_cast<int>(x), img.width() - 2);
    const int yp = std::min(static_cast<int>(y), img.height() - 2);
 
    // precision to 4 decimal places
    const float ui = x - static_cast<float>(xp);
    const float vi = y - static_cast<float>(yp);
 
    const T lu = img(yp, xp);
    const T ru = img(yp, (xp + 1));
    const T rd = img((yp + 1), (xp + 1));
    const T ld = img((yp + 1), xp);
 
    // bilinear interpolation of the pixel intensity value
    const T u = lu + (ru - lu) * ui;
    const T d = ld + (rd - ld) * ui;
    const T out = u + (d - u) * vi;
    return out;
}
}  // namespace image
}  // namespace aliceVision