pixelTypes.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"
 
namespace aliceVision {
namespace image {
 
template<typename T>
class Rgb : public Eigen::Matrix<T, 3, 1, 0, 3, 1>
{
    using Base = Eigen::Matrix<T, 3, 1, 0, 3, 1>;
    using TBase = T;
 
  public:
    //------------------------------
    //-- construction method
    inline Rgb(T red, T green, T blue)
      : Base(red, green, blue)
    {}
 
    explicit inline Rgb(const Base& val)
      : Base(val)
    {}
 
    explicit inline Rgb(const T val = 0)
      : Base(val, val, val)
    {}
    //-- construction method
    //------------------------------
 
    //------------------------------
    //-- accessors/getters methods
    inline const T& r() const { return (*this)(0); }
 
    inline T& r() { return (*this)(0); }
 
    inline const T& g() const { return (*this)(1); }
 
    inline T& g() { return (*this)(1); }
 
    inline const T& b() const { return (*this)(2); }
 
    inline T& b() { return (*this)(2); }
 
    inline operator T() const { return T(0.299 * r() + 0.587 * g() + 0.114 * b()); }
 
    //-- accessors/getters methods
    //------------------------------
 
    friend std::ostream& operator<<(std::ostream& os, const Rgb& col)
    {
        os << " {";
        for (int i = 0; i < 2; ++i)
        {
            os << col(i) << ",";
        }
        os << col(2) << "} ";
        return os;
    }
 
    inline Rgb operator-(const Rgb& other) const { return Rgb(((*this)(0) - other(0)), ((*this)(1) - other(1)), ((*this)(2) - other(2))); }
 
    inline Rgb operator+(const Rgb& other) const { return Rgb(((*this)(0) + other(0)), ((*this)(1) + other(1)), ((*this)(2) + other(2))); }
 
    inline Rgb operator*(const Rgb& other) const { return Rgb(((*this)(0) * other(0)), ((*this)(1) * other(1)), ((*this)(2) * other(2))); }
 
    template<typename Z>
    inline Rgb operator/(const Z& val) const
    {
        return Rgb(T((Z)((*this)(0)) / val), T((Z)((*this)(1)) / val), T((Z)((*this)(2)) / val));
    }
 
    template<typename Z>
    inline Rgb operator*(const Z& val) const
    {
        return Rgb(T((Z)(*this)(0) * val), T((Z)(*this)(1) * val), T((Z)(*this)(2) * val));
    }
};
 
using RGBColor = Rgb<unsigned char>;
using RGBfColor = Rgb<float>;
 
template<typename T>
class Rgba : public Eigen::Matrix<T, 4, 1, 0, 4, 1>
{
    using Base = Eigen::Matrix<T, 4, 1, 0, 4, 1>;
 
  public:
    //------------------------------
    //-- construction method
    inline Rgba(const T red, const T green, const T blue, const T alpha = T(1))
      : Base(red, green, blue, alpha)
    {}
 
    explicit inline Rgba(const Base& val)
      : Base(val)
    {}
 
    explicit inline Rgba(const T val)
      : Base(val, val, val, T(1))
    {}
 
    explicit inline Rgba()
      : Base(T(0), T(0), T(0), T(0))
    {}
 
    inline Rgba(const RGBColor& val, const T alpha)
      : Base(val.r(), val.g(), val.b(), alpha)
    {}
 
    //-- construction method
    //------------------------------
 
    //------------------------------
    //-- accessors/getters methods
    inline const T& r() const { return (*this)(0); }
    inline T& r() { return (*this)(0); }
    inline const T& g() const { return (*this)(1); }
    inline T& g() { return (*this)(1); }
    inline const T& b() const { return (*this)(2); }
    inline T& b() { return (*this)(2); }
    inline const T& a() const { return (*this)(3); }
    inline T& a() { return (*this)(3); }
 
    inline operator T() const { return T(0.299 * r() + 0.587 * g() + 0.114 * b()); }
    //-- accessors/getters methods
    //------------------------------
    friend std::ostream& operator<<(std::ostream& os, const Rgba& col)
    {
        os << " {";
        for (int i = 0; i < 3; ++i)
        {
            os << col(i) << ",";
        }
        os << col(3) << "} ";
        return os;
    }
 
    template<class Z>
    inline Rgba operator/(const Z& val) const
    {
        return Rgba(T((Z)(*this)(0) / val), T((Z)(*this)(1) / val), T((Z)(*this)(2) / val), T((Z)(*this)(3) / val));
    }
 
    template<class Z>
    inline Rgba operator*(const Z& val) const
    {
        return Rgba(T((Z)(*this)(0) * val), T((Z)(*this)(1) * val), T((Z)(*this)(2) * val), T((Z)(*this)(3) * val));
    }
 
    inline Rgba operator+(const Rgba& other) const
    {
        return Rgba(((*this)(0) + other(0)), ((*this)(1) + other(1)), ((*this)(2) + other(2)), ((*this)(3) + other(3)));
    }
};
 
typedef Rgba<unsigned char> RGBAColor;
typedef Rgba<float> RGBAfColor;
 
using RGBAColor = Rgba<unsigned char>;
using RGBAfColor = Rgba<float>;
 
const RGBColor WHITE(255, 255, 255);
const RGBColor BLACK(0, 0, 0);
const RGBColor BLUE(0, 0, 255);
const RGBColor RED(255, 0, 0);
const RGBColor GREEN(0, 255, 0);
const RGBColor YELLOW(255, 255, 0);
const RGBColor CYAN(0, 255, 255);
const RGBColor MAGENTA(255, 0, 255);
 
const RGBfColor FWHITE(1.0f, 1.0f, 1.0f);
const RGBfColor FBLACK(.0f, .0f, .0f);
 
template<typename T>
struct NbChannels
{
    // no size parameter, so no default value.
    // An error will be raise at compile time if this type traits is not defined.
};
 
template<>
struct NbChannels<unsigned char>
{
    static const int size = 1;
};
template<>
struct NbChannels<float>
{
    static const int size = 1;
};
template<>
struct NbChannels<RGBColor>
{
    static const int size = 3;
};
template<>
struct NbChannels<RGBfColor>
{
    static const int size = 3;
};
template<>
struct NbChannels<RGBAColor>
{
    static const int size = 4;
};
template<>
struct NbChannels<RGBAfColor>
{
    static const int size = 4;
};
 
}  // namespace image
}  // namespace aliceVision