dpdf.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_DISCRETE_PDF_H)
#define __NORI_DISCRETE_PDF_H
 
#include <nori/common.h>
 
NORI_NAMESPACE_BEGIN
 
struct DiscretePDF {
public:
    explicit DiscretePDF(size_t nEntries = 0) {
        reserve(nEntries);
        clear();
    }
 
    void clear() {
        m_cdf.clear();
        m_cdf.push_back(0.0f);
        m_normalized = false;
    }
 
    void reserve(size_t nEntries) {
        m_cdf.reserve(nEntries+1);
    }
 
    void append(float pdfValue) {
        m_cdf.push_back(m_cdf[m_cdf.size()-1] + pdfValue);
    }
 
    size_t size() const {
        return m_cdf.size()-1;
    }
 
    float operator[](size_t entry) const {
        return m_cdf[entry+1] - m_cdf[entry];
    }
 
    bool isNormalized() const {
        return m_normalized;
    }
 
    float getSum() const {
        return m_sum;
    }
 
    float getNormalization() const {
        return m_normalization;
    }
 
    float normalize() {
        m_sum = m_cdf[m_cdf.size()-1];
        if (m_sum > 0) {
            m_normalization = 1.0f / m_sum;
            for (size_t i=1; i<m_cdf.size(); ++i) 
                m_cdf[i] *= m_normalization;
            m_cdf[m_cdf.size()-1] = 1.0f;
            m_normalized = true;
        } else {
            m_normalization = 0.0f;
        }
        return m_sum;
    }
 
    size_t sample(float sampleValue) const {
        std::vector<float>::const_iterator entry = 
                std::lower_bound(m_cdf.begin(), m_cdf.end(), sampleValue);
        size_t index = (size_t) std::max((ptrdiff_t) 0, entry - m_cdf.begin() - 1);
        return std::min(index, m_cdf.size()-2);
    }
 
    size_t sample(float sampleValue, float &pdf) const {
        size_t index = sample(sampleValue);
        pdf = operator[](index);
        return index;
    }
 
    size_t sampleReuse(float &sampleValue) const {
        size_t index = sample(sampleValue);
        sampleValue = (sampleValue - m_cdf[index])
            / (m_cdf[index + 1] - m_cdf[index]);
        return index;
    }
 
    size_t sampleReuse(float &sampleValue, float &pdf) const {
        size_t index = sample(sampleValue, pdf);
        sampleValue = (sampleValue - m_cdf[index])
            / (m_cdf[index + 1] - m_cdf[index]);
        return index;
    }
 
    std::string toString() const {
        std::string result = tfm::format("DiscretePDF[sum=%f, "
            "normalized=%f, pdf = {", m_sum, m_normalized);
 
        for (size_t i=0; i<m_cdf.size(); ++i) {
            result += std::to_string(operator[](i));
            if (i != m_cdf.size()-1)
                result += ", ";
        }
        return result + "}]";
    }
private:
    std::vector<float> m_cdf;
    float m_sum, m_normalization;
    bool m_normalized;
};
 
NORI_NAMESPACE_END
 
#endif /* __NORI_DISCRETE_PDF_H */