rfilter.cpp

/*
    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/>.
*/
 
#include <nori/rfilter.h>
 
NORI_NAMESPACE_BEGIN
 
class GaussianFilter : public ReconstructionFilter {
public:
    GaussianFilter(const PropertyList &propList) {
        /* Half filter size */
        m_radius = propList.getFloat("radius", 2.0f);
        /* Standard deviation of the Gaussian */
        m_stddev = propList.getFloat("stddev", 0.5f);
    }
 
    float eval(float x) const {
        float alpha = -1.0f / (2.0f * m_stddev*m_stddev);
        return std::max(0.0f, 
            std::exp(alpha * x * x) - 
            std::exp(alpha * m_radius * m_radius));
    }
 
    virtual std::string toString() const override {
        return tfm::format("GaussianFilter[radius=%f, stddev=%f]", m_radius, m_stddev);
    }
protected:
    float m_stddev;
};
 
class MitchellNetravaliFilter : public ReconstructionFilter {
public:
    MitchellNetravaliFilter(const PropertyList &propList) {
        /* Filter size in pixels */
        m_radius = propList.getFloat("radius", 2.0f);
        /* B parameter from the paper */
        m_B = propList.getFloat("B", 1.0f / 3.0f);
        /* C parameter from the paper */
        m_C = propList.getFloat("C", 1.0f / 3.0f);
    }
 
    float eval(float x) const {
        x = std::abs(2.0f * x / m_radius);
        float x2 = x*x, x3 = x2*x;
 
        if (x < 1) {
            return 1.0f/6.0f * ((12-9*m_B-6*m_C)*x3 
                    + (-18+12*m_B+6*m_C) * x2 + (6-2*m_B));
        } else if (x < 2) {
            return 1.0f/6.0f * ((-m_B-6*m_C)*x3 + (6*m_B+30*m_C) * x2
                    + (-12*m_B-48*m_C)*x + (8*m_B + 24*m_C));
        } else {
            return 0.0f;
        }
    }
 
    virtual std::string toString() const override {
        return tfm::format("MitchellNetravaliFilter[radius=%f, B=%f, C=%f]", m_radius, m_B, m_C);
    }
protected:
    float m_B, m_C;
};
 
class TentFilter : public ReconstructionFilter {
public:
    TentFilter(const PropertyList &) {
        m_radius = 1.0f;
    }
 
    float eval(float x) const {
        return std::max(0.0f, 1.0f - std::abs(x));
    }
    
    virtual std::string toString() const override {
        return "TentFilter[]";
    }
};
 
class BoxFilter : public ReconstructionFilter {
public:
    BoxFilter(const PropertyList &) {
        m_radius = 0.5f;
    }
 
    float eval(float) const {
        return 1.0f;
    }
    
    virtual std::string toString() const override {
        return "BoxFilter[]";
    }
};
 
NORI_REGISTER_CLASS(GaussianFilter, "gaussian");
NORI_REGISTER_CLASS(MitchellNetravaliFilter, "mitchell");
NORI_REGISTER_CLASS(TentFilter, "tent");
NORI_REGISTER_CLASS(BoxFilter, "box");
 
NORI_NAMESPACE_END