Use regular AOVs to export diagnostic AOVs

sandbox/tests/unit tests/inputs/test_projectfilereader_configurationblocks.appleseed

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<project format_revision="26">
+<project format_revision="27">
     <scene>
         <camera name="camera" model="pinhole_camera">
             <parameter name="film_dimensions" value="0.025 0.025" />

src/appleseed/CMakeLists.txt

@@ -1399,6 +1399,8 @@ set (renderer_modeling_aov_sources
     renderer/modeling/aov/denoiseraov.h
     renderer/modeling/aov/depthaov.cpp
     renderer/modeling/aov/depthaov.h
+    renderer/modeling/aov/diagnosticaov.cpp
+    renderer/modeling/aov/diagnosticaov.h
     renderer/modeling/aov/diffuseaov.cpp
     renderer/modeling/aov/diffuseaov.h
     renderer/modeling/aov/emissionaov.cpp

src/appleseed/renderer/api/aov.h

@@ -37,6 +37,7 @@
 #include "renderer/modeling/aov/aovfactoryregistrar.h"
 #include "renderer/modeling/aov/aovtraits.h"
 #include "renderer/modeling/aov/depthaov.h"
+#include "renderer/modeling/aov/diagnosticaov.h"
 #include "renderer/modeling/aov/diffuseaov.h"
 #include "renderer/modeling/aov/emissionaov.h"
 #include "renderer/modeling/aov/glossyaov.h"

src/appleseed/renderer/kernel/aov/tilestack.h

@@ -62,6 +62,12 @@ class TileStack
        const size_t                 i,
        const foundation::Color4f&   color) const;
 
+    foundation::Tile& get_tile(
+       const size_t                 index);
+
+    const foundation::Tile& get_tile(
+       const size_t                 index) const;
+
   private:
     foundation::Tile*   m_tiles[MaxAOVCount];
     size_t              m_size;
@@ -99,6 +105,20 @@ inline void TileStack::set_pixel(
     m_tiles[i]->set_pixel(x, y, color);
 }
 
+inline foundation::Tile& TileStack::get_tile(
+    const size_t                index)
+{
+    assert(index < m_size);
+    return *m_tiles[index];
+}
+
+inline const foundation::Tile& TileStack::get_tile(
+    const size_t                index) const
+{
+    assert(index < m_size);
+    return *m_tiles[index];
+}
+
 }       // namespace renderer
 
 #endif  // !APPLESEED_RENDERER_KERNEL_AOV_TILESTACK_H

src/appleseed/renderer/kernel/rendering/final/adaptivepixelrenderer.cpp

@@ -42,6 +42,7 @@
 #include "renderer/kernel/rendering/pixelrendererbase.h"
 #include "renderer/kernel/rendering/shadingresultframebuffer.h"
 #include "renderer/kernel/shading/shadingresult.h"
+#include "renderer/modeling/aov/aov.h"
 #include "renderer/modeling/frame/frame.h"
 #include "renderer/utility/settingsparsing.h"
 
@@ -89,19 +90,11 @@ namespace
           : PixelRendererBase(frame, thread_index, params)
           , m_params(params)
           , m_sample_renderer(factory->create(thread_index))
+          , m_sample_aov_tile(nullptr)
+          , m_variation_aov_tile(nullptr)
         {
-            if (are_diagnostics_enabled())
-            {
-                m_variation_aov_index = frame.create_extra_aov_image("variation");
-                m_samples_aov_index = frame.create_extra_aov_image("samples");
-
-                if ((thread_index == 0) && (m_variation_aov_index == ~size_t(0) || m_samples_aov_index == ~size_t(0)))
-                {
-                    RENDERER_LOG_WARNING(
-                        "could not create some of the diagnostic aovs, maximum number of aovs (" FMT_SIZE_T ") reached.",
-                        MaxAOVCount);
-                }
-            }
+            m_variation_aov_index = frame.aovs().get_index("pixel_variation");
+            m_sample_aov_index = frame.aovs().get_index("pixel_sample");
         }
 
         void release() override
@@ -115,22 +108,27 @@ namespace
                 "adaptive pixel renderer settings:\n"
                 "  min samples                   %s\n"
                 "  max samples                   %s\n"
-                "  max variation                 %f\n"
-                "  diagnostics                   %s",
+                "  max variation                 %f",
                 pretty_uint(m_params.m_min_samples).c_str(),
                 pretty_uint(m_params.m_max_samples).c_str(),
-                m_params.m_max_variation,
-                are_diagnostics_enabled() ? "on" : "off");
+                m_params.m_max_variation);
 
             m_sample_renderer->print_settings();
         }
 
         void on_tile_begin(
             const Frame&            frame,
+            const size_t            tile_x,
+            const size_t            tile_y,
             Tile&                   tile,
             TileStack&              aov_tiles) override
         {
-            PixelRendererBase::on_tile_begin(frame, tile, aov_tiles);
+            PixelRendererBase::on_tile_begin(
+                frame,
+                tile_x,
+                tile_y,
+                tile,
+                aov_tiles);
 
             m_scratch_fb_half_width = truncate<int>(ceil(frame.get_filter().get_xradius()));
             m_scratch_fb_half_height = truncate<int>(ceil(frame.get_filter().get_yradius()));
@@ -142,40 +140,29 @@ namespace
                     frame.aov_images().size(),
                     frame.get_filter()));
 
-            if (are_diagnostics_enabled())
-            {
-                m_diagnostics.reset(new Tile(
-                    tile.get_width(), tile.get_height(), 2, PixelFormatFloat));
-            }
+            if (m_sample_aov_index != ~size_t(0))
+                m_sample_aov_tile = &frame.aovs().get_by_index(m_sample_aov_index)->get_image().tile(tile_x, tile_y);
+
+            if (m_variation_aov_index != ~size_t(0))
+                m_variation_aov_tile = &frame.aovs().get_by_index(m_variation_aov_index)->get_image().tile(tile_x, tile_y);
         }
 
         void on_tile_end(
             const Frame&            frame,
+            const size_t            tile_x,
+            const size_t            tile_y,
             Tile&                   tile,
             TileStack&              aov_tiles) override
         {
-            PixelRendererBase::on_tile_end(frame, tile, aov_tiles);
-
-            if (are_diagnostics_enabled())
-            {
-                const size_t width = tile.get_width();
-                const size_t height = tile.get_height();
-
-                for (size_t y = 0; y < height; ++y)
-                {
-                    for (size_t x = 0; x < width; ++x)
-                    {
-                        Color<float, 2> values;
-                        m_diagnostics->get_pixel(x, y, values);
-
-                        if (m_variation_aov_index != ~size_t(0))
-                            aov_tiles.set_pixel(x, y, m_variation_aov_index, scalar_to_color(values[0]));
-
-                        if (m_samples_aov_index != ~size_t(0))
-                            aov_tiles.set_pixel(x, y, m_samples_aov_index, scalar_to_color(values[1]));
-                    }
-                }
-            }
+            PixelRendererBase::on_tile_end(
+                frame,
+                tile_x,
+                tile_y,
+                tile,
+                aov_tiles);
+
+            m_sample_aov_tile = nullptr;
+            m_variation_aov_tile = nullptr;
         }
 
         void render_pixel(
@@ -293,28 +280,36 @@ namespace
             }
 
             // Store diagnostics values in the diagnostics tile.
-            if (are_diagnostics_enabled() && tile_bbox.contains(pt))
+            if ((m_sample_aov_tile || m_variation_aov_tile) && tile_bbox.contains(pt))
             {
-                Color<float, 2> values;
-
-                values[0] =
-                    saturate(
-                        max(
-                            trackers[0].get_variation(),
-                            trackers[1].get_variation(),
-                            trackers[2].get_variation())
-                        / m_params.m_max_variation);
-
-                values[1] =
-                    m_params.m_min_samples == m_params.m_max_samples
-                        ? 1.0f
-                        : fit(
-                            static_cast<float>(trackers[0].get_size()),
-                            static_cast<float>(m_params.m_min_samples),
-                            static_cast<float>(m_params.m_max_samples),
-                            0.0f, 1.0f);
-
-                m_diagnostics->set_pixel(pt.x, pt.y, values);
+                Color4f value(0.0f, 0.0f, 0.0f, 1.0f);
+
+                if (m_sample_aov_tile)
+                {
+                    value[0] =
+                        m_params.m_min_samples == m_params.m_max_samples
+                            ? 1.0f
+                            : fit(
+                                static_cast<float>(trackers[0].get_size()),
+                                static_cast<float>(m_params.m_min_samples),
+                                static_cast<float>(m_params.m_max_samples),
+                                0.0f, 1.0f);
+
+                    m_sample_aov_tile->set_pixel(pt.x, pt.y, value);
+                }
+
+                if (m_variation_aov_tile)
+                {
+                    value[0] =
+                        saturate(
+                            max(
+                                trackers[0].get_variation(),
+                                trackers[1].get_variation(),
+                                trackers[2].get_variation())
+                            / m_params.m_max_variation);
+
+                    m_variation_aov_tile->set_pixel(pt.x, pt.y, value);
+                }
             }
 
             on_pixel_end(pi, pt, tile_bbox, aov_accumulators);
@@ -350,18 +345,12 @@ namespace
         const Parameters                        m_params;
         auto_release_ptr<ISampleRenderer>       m_sample_renderer;
         size_t                                  m_variation_aov_index;
-        size_t                                  m_samples_aov_index;
+        size_t                                  m_sample_aov_index;
         int                                     m_scratch_fb_half_width;
         int                                     m_scratch_fb_half_height;
         unique_ptr<ShadingResultFrameBuffer>    m_scratch_fb;
-        unique_ptr<Tile>                        m_diagnostics;
-
-        static Color4f scalar_to_color(const float value)
-        {
-            static const Color4f Blue(0.0f, 0.0f, 1.0f, 1.0f);
-            static const Color4f Red(1.0f, 0.0f, 0.0f, 1.0f);
-            return lerp(Blue, Red, saturate(value));
-        }
+        Tile*                                   m_sample_aov_tile;
+        Tile*                                   m_variation_aov_tile;
     };
 }
 
@@ -397,7 +386,7 @@ IPixelRenderer* AdaptivePixelRendererFactory::create(
 
 Dictionary AdaptivePixelRendererFactory::get_params_metadata()
 {
-    Dictionary metadata = PixelRendererBaseFactory::get_params_metadata();
+    Dictionary metadata;
 
     metadata.dictionaries().insert(
         "min_samples",

src/appleseed/renderer/kernel/rendering/final/adaptivepixelrenderer.h

@@ -31,7 +31,7 @@
 #define APPLESEED_RENDERER_KERNEL_RENDERING_FINAL_ADAPTIVEPIXELRENDERER_H
 
 // appleseed.renderer headers.
-#include "renderer/kernel/rendering/pixelrendererbase.h"
+#include "renderer/kernel/rendering/ipixelrenderer.h"
 #include "renderer/utility/paramarray.h"
 
 // appleseed.foundation headers.
@@ -53,7 +53,7 @@ namespace renderer
 //
 
 class AdaptivePixelRendererFactory
-  : public PixelRendererBaseFactory
+  : public IPixelRendererFactory
 {
   public:
     // Constructor.

src/appleseed/renderer/kernel/rendering/final/uniformpixelrenderer.cpp

@@ -113,12 +113,10 @@ namespace
                 "uniform pixel renderer settings:\n"
                 "  samples                       %s\n"
                 "  force antialiasing            %s\n"
-                "  decorrelate pixels            %s\n"
-                "  diagnostics                   %s",
+                "  decorrelate pixels            %s",
                 pretty_uint(m_params.m_samples).c_str(),
                 m_params.m_force_aa ? "on" : "off",
-                m_params.m_decorrelate ? "on" : "off",
-                are_diagnostics_enabled() ? "on" : "off");
+                m_params.m_decorrelate ? "on" : "off");
 
             m_sample_renderer->print_settings();
         }
@@ -324,7 +322,7 @@ IPixelRenderer* UniformPixelRendererFactory::create(
 
 Dictionary UniformPixelRendererFactory::get_params_metadata()
 {
-    Dictionary metadata = PixelRendererBaseFactory::get_params_metadata();
+    Dictionary metadata;
 
     metadata.dictionaries().insert(
         "samples",

src/appleseed/renderer/kernel/rendering/final/uniformpixelrenderer.h

@@ -31,7 +31,7 @@
 #define APPLESEED_RENDERER_KERNEL_RENDERING_FINAL_UNIFORMPIXELRENDERER_H
 
 // appleseed.renderer headers.
-#include "renderer/kernel/rendering/pixelrendererbase.h"
+#include "renderer/kernel/rendering/ipixelrenderer.h"
 #include "renderer/utility/paramarray.h"
 
 // appleseed.foundation headers.
@@ -53,7 +53,7 @@ namespace renderer
 //
 
 class UniformPixelRendererFactory
-  : public PixelRendererBaseFactory
+  : public IPixelRendererFactory
 {
   public:
     // Constructor.

src/appleseed/renderer/kernel/rendering/generic/generictilerenderer.cpp

@@ -157,16 +157,21 @@ namespace
             padded_tile_bbox.max.x = tile_bbox.max.x + m_margin_width;
             padded_tile_bbox.max.y = tile_bbox.max.y + m_margin_height;
 
-            // Inform the pixel renderer that we are about to render a tile.
-            m_pixel_renderer->on_tile_begin(frame, tile, aov_tiles);
-
             // Inform the AOV accumulators that we are about to render a tile.
             m_aov_accumulators.on_tile_begin(
                 frame,
                 tile_x,
                 tile_y,
                 m_pixel_renderer->get_max_samples_per_pixel());
 
+            // Inform the pixel renderer that we are about to render a tile.
+            m_pixel_renderer->on_tile_begin(
+                frame,
+                tile_x,
+                tile_y,
+                tile,
+                aov_tiles);
+
             // Create the framebuffer into which we will accumulate the samples.
             ShadingResultFrameBuffer* framebuffer =
                 m_framebuffer_factory->create(
@@ -219,11 +224,16 @@ namespace
             // Release the framebuffer.
             m_framebuffer_factory->destroy(framebuffer);
 
+            // Inform the pixel renderer that we are done rendering the tile.
+            m_pixel_renderer->on_tile_end(
+                frame,
+                tile_x,
+                tile_y,
+                tile,
+                aov_tiles);
+
             // Inform the AOV accumulators that we are done rendering a tile.
             m_aov_accumulators.on_tile_end(frame, tile_x, tile_y);
-
-            // Inform the pixel renderer that we are done rendering the tile.
-            m_pixel_renderer->on_tile_end(frame, tile, aov_tiles);
         }
 
         StatisticsVector get_statistics() const override

src/appleseed/renderer/kernel/rendering/ipixelrenderer.h

@@ -63,12 +63,16 @@ class IPixelRenderer
     // This method is called before a tile gets rendered.
     virtual void on_tile_begin(
         const Frame&                frame,
+        const size_t                tile_x,
+        const size_t                tile_y,
         foundation::Tile&           tile,
         TileStack&                  aov_tiles) = 0;
 
     // This method is called after a tile has been rendered.
     virtual void on_tile_end(
         const Frame&                frame,
+        const size_t                tile_x,
+        const size_t                tile_y,
         foundation::Tile&           tile,
         TileStack&                  aov_tiles) = 0;