color.h

/*
    This file is part of Nori, a simple educational ray tracer
 
    Copyright (c) 2015 by Wenzel Jakob
 
    Nori is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License Version 3
    as published by the Free Software Foundation.
 
    Nori is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
 
#if !defined(__NORI_COLOR_H)
#define __NORI_COLOR_H
 
#include <nori/common.h>
 
NORI_NAMESPACE_BEGIN
 
struct Color3f : public Eigen::Array3f {
public:
    typedef Eigen::Array3f Base;
 
    Color3f(float value = 0.f) : Base(value, value, value) { }
 
    Color3f(float r, float g, float b) : Base(r, g, b) { }
 
    template <typename Derived> Color3f(const Eigen::ArrayBase<Derived>& p) 
        : Base(p) { }
 
    template <typename Derived> Color3f &operator=(const Eigen::ArrayBase<Derived>& p) {
        this->Base::operator=(p);
        return *this;
    }
 
    float &r() { return x(); }
    const float &r() const { return x(); }
    float &g() { return y(); }
    const float &g() const { return y(); }
    float &b() { return z(); }
    const float &b() const { return z(); }
 
    Color3f clamp() const { return Color3f(std::max(r(), 0.0f),
        std::max(g(), 0.0f), std::max(b(), 0.0f)); }
 
    bool isValid() const;
 
    Color3f toLinearRGB() const;
 
    Color3f toSRGB() const;
 
    float getLuminance() const;
 
    std::string toString() const {
        return tfm::format("[%f, %f, %f]", coeff(0), coeff(1), coeff(2));
    }
};
 
struct Color4f : public Eigen::Array4f {
public:
    typedef Eigen::Array4f Base;
 
    Color4f() : Base(0.0f, 0.0f, 0.0f, 0.0f) { }
 
    Color4f(const Color3f &c) : Base(c.r(), c.g(), c.b(), 1.0f) { }
 
    Color4f(float r, float g, float b, float w) : Base(r, g, b, w) { }
 
    template <typename Derived> Color4f(const Eigen::ArrayBase<Derived>& p) 
        : Base(p) { }
 
    template <typename Derived> Color4f &operator=(const Eigen::ArrayBase<Derived>& p) {
        this->Base::operator=(p);
        return *this;
    }
 
    Color3f divideByFilterWeight() const {
        if (w() != 0)
            return head<3>() / w();
        else
            return Color3f(0.0f);
    }
 
    std::string toString() const {
        return tfm::format("[%f, %f, %f, %f]", coeff(0), coeff(1), coeff(2), coeff(3));
    }
};
 
NORI_NAMESPACE_END
 
#endif /* __NORI_COLOR_H */