Added flexible spectral range and default value to uniform spectrum plugin

Author: leroyvn

src/spectra/tests/test_uniform.py

@@ -0,0 +1,73 @@
+import pytest
+
+import enoki as ek
+import mitsuba
+
+
+def make_spectrum(value=None, lambda_min=None, lambda_max=None):
+    from mitsuba.core.xml import load_string
+    
+    xml_value = f"""<float name="value" value="{value}"/>""" \
+        if value is not None else ""
+    xml_lambda_min = f"""<float name="lambda_min" value="{lambda_min}"/>""" \
+        if lambda_min is not None else ""
+    xml_lambda_max = f"""<float name="lambda_max" value="{lambda_max}"/>""" \
+        if lambda_max is not None else ""
+
+    xml_spectrum = f"""
+        <spectrum version="2.0.0" type="uniform">
+            {xml_value}
+            {xml_lambda_min}
+            {xml_lambda_max}
+        </spectrum>
+        """
+    return load_string(xml_spectrum)
+
+
+def test_construct(variant_scalar_spectral):
+    assert make_spectrum() is not None
+    assert make_spectrum(value=2.) is not None
+    assert make_spectrum(value=2., lambda_min=400., lambda_max=500.) is not None
+
+    with pytest.raises(RuntimeError):
+        make_spectrum(lambda_min=500., lambda_max=400.)
+
+
+def test_eval(variant_scalar_spectral):
+    from mitsuba.render import SurfaceInteraction3f
+    si = SurfaceInteraction3f()
+
+    value = 2.
+    lambda_min = 400.
+    lambda_max = 500.
+    dlambda = lambda_max - lambda_min
+
+    s = make_spectrum(value, lambda_min, lambda_max)
+    wavelengths = [390., 400., 450., 510.]
+    values = [0, value, value, 0]
+
+    si.wavelengths = wavelengths
+    assert ek.allclose(s.eval(si), values)
+    assert ek.allclose(
+        s.pdf(si), [1. / dlambda if value else 0. for value in values])
+
+    assert ek.allclose(s.eval_1(si), value)
+
+    with pytest.raises(RuntimeError) as excinfo:
+        s.eval_3(si)
+    assert 'not implemented' in str(excinfo.value)
+
+
+def test_sample(variant_scalar_spectral):
+    from mitsuba.render import SurfaceInteraction3f
+    from mitsuba.core import MTS_WAVELENGTH_MIN, MTS_WAVELENGTH_MAX
+    dlambda = MTS_WAVELENGTH_MAX - MTS_WAVELENGTH_MIN
+
+    value = 0.5
+    s = make_spectrum(value)
+
+    si = SurfaceInteraction3f()
+    assert ek.allclose(s.sample(si, 0), [MTS_WAVELENGTH_MIN, value * dlambda])
+    assert ek.allclose(s.sample(si, .5), [
+                       MTS_WAVELENGTH_MIN + .5 * dlambda, value * dlambda])
+    assert ek.allclose(s.sample(si, 1), [MTS_WAVELENGTH_MAX, value * dlambda])

src/spectra/uniform.cpp

@@ -1,6 +1,6 @@
-#include <mitsuba/render/texture.h>
-#include <mitsuba/render/interaction.h>
 #include <mitsuba/core/properties.h>
+#include <mitsuba/render/interaction.h>
+#include <mitsuba/render/texture.h>
 
 NAMESPACE_BEGIN(mitsuba)
 
@@ -11,7 +11,8 @@ NAMESPACE_BEGIN(mitsuba)
 Uniform spectrum (:monosp:`uniform`)
 ------------------------------------
 
-This spectrum returns a constant reflectance or emission value between 360 and 830nm.
+This spectrum returns a constant reflectance or emission value between 360 and
+830nm.
 
  */
 
@@ -20,26 +21,40 @@ class UniformSpectrum final : public Texture<Float, Spectrum> {
 public:
     MTS_IMPORT_TYPES(Texture)
 
-    UniformSpectrum(const Properties &props) : Texture(props) {
-        m_value = props.float_("value");
+    UniformSpectrum(const Properties &props)
+        : Texture(props), m_value(1.f), m_lambda_min(MTS_WAVELENGTH_MIN),
+          m_lambda_max(MTS_WAVELENGTH_MAX) {
+        if (props.has_property("value"))
+            m_value = props.float_("value");
+
+        if (props.has_property("lambda_min"))
+            m_lambda_min = max(props.float_("lambda_min"), MTS_WAVELENGTH_MIN);
+
+        if (props.has_property("lambda_max"))
+            m_lambda_max = min(props.float_("lambda_max"), MTS_WAVELENGTH_MAX);
+
+        if (!(m_lambda_min < m_lambda_max))
+            Throw(
+                "UniformSpectrum: 'lambda_min' must be less than 'lambda_max'");
     }
 
     UnpolarizedSpectrum eval(const SurfaceInteraction3f &si,
                              Mask active) const override {
         MTS_MASKED_FUNCTION(ProfilerPhase::TextureEvaluate, active);
 
         if constexpr (is_spectral_v<Spectrum>) {
-            auto active_w = (si.wavelengths >= MTS_WAVELENGTH_MIN) &&
-                            (si.wavelengths <= MTS_WAVELENGTH_MAX);
+            auto active_w = (si.wavelengths >= m_lambda_min) &&
+                            (si.wavelengths <= m_lambda_max);
 
             return select(active_w, UnpolarizedSpectrum(m_value),
-                                    UnpolarizedSpectrum(0.f));
+                          UnpolarizedSpectrum(0.f));
         } else {
             return m_value;
         }
     }
 
-    Float eval_1(const SurfaceInteraction3f & /* it */, Mask active) const override {
+    Float eval_1(const SurfaceInteraction3f & /* it */,
+                 Mask active) const override {
         MTS_MASKED_FUNCTION(ProfilerPhase::TextureEvaluate, active);
         return m_value;
     }
@@ -48,24 +63,25 @@ class UniformSpectrum final : public Texture<Float, Spectrum> {
         MTS_MASKED_FUNCTION(ProfilerPhase::TextureEvaluate, active);
 
         if constexpr (is_spectral_v<Spectrum>) {
-            auto active_w = (si.wavelengths >= MTS_WAVELENGTH_MIN) &&
-                            (si.wavelengths <= MTS_WAVELENGTH_MAX);
+            auto active_w = (si.wavelengths >= m_lambda_min) &&
+                            (si.wavelengths <= m_lambda_max);
 
             return select(active_w,
-                Wavelength(1.f / (MTS_WAVELENGTH_MAX - MTS_WAVELENGTH_MIN)), Wavelength(0.f));
+                          Wavelength(1.f / (m_lambda_max - m_lambda_min)),
+                          Wavelength(0.f));
         } else {
             NotImplementedError("pdf");
         }
     }
 
-    std::pair<Wavelength, UnpolarizedSpectrum> sample(const SurfaceInteraction3f &/*si*/,
-                                                      const Wavelength &sample,
-                                                      Mask active) const override {
+    std::pair<Wavelength, UnpolarizedSpectrum>
+    sample(const SurfaceInteraction3f & /*si*/, const Wavelength &sample,
+           Mask active) const override {
         MTS_MASKED_FUNCTION(ProfilerPhase::TextureSample, active);
 
         if constexpr (is_spectral_v<Spectrum>) {
-            return { MTS_WAVELENGTH_MIN + (MTS_WAVELENGTH_MAX - MTS_WAVELENGTH_MIN) * sample,
-                     m_value * (MTS_WAVELENGTH_MAX - MTS_WAVELENGTH_MIN) };
+            return { m_lambda_min + (m_lambda_max - m_lambda_min) * sample,
+                     m_value * (m_lambda_max - m_lambda_min) };
         } else {
             ENOKI_MARK_USED(sample);
             NotImplementedError("sample");
@@ -76,15 +92,25 @@ class UniformSpectrum final : public Texture<Float, Spectrum> {
 
     void traverse(TraversalCallback *callback) override {
         callback->put_parameter("value", m_value);
+        callback->put_parameter("value", m_lambda_min);
+        callback->put_parameter("value", m_lambda_max);
     }
 
     std::string to_string() const override {
-        return tfm::format("UniformSpectrum[value=%f]", m_value);
+        std::ostringstream oss;
+        oss << "UniformSpectrum[" << std::endl
+            << "  value = " << m_value << std::endl
+            << "  lambda_min = " << m_lambda_min << std::endl
+            << "  lambda_max = " << m_lambda_max << std::endl
+            << "]";
+        return oss.str();
     }
 
     MTS_DECLARE_CLASS()
 private:
     Float m_value;
+    ScalarFloat m_lambda_min;
+    ScalarFloat m_lambda_max;
 };
 
 MTS_IMPLEMENT_CLASS_VARIANT(UniformSpectrum, Texture)