reat: add regionToRender to RenderSettings

Latios96 · Jul 16, 2024 · b95a029 · b95a029
1 parent cf0d968
commit b95a029
Show file tree

Hide file tree

Showing 20 changed files with 158 additions and 25 deletions.
diff --git a/src/crayg/src/basics/Bound2d.h b/src/crayg/src/basics/Bound2d.h
@@ -72,3 +72,13 @@ typedef Bounds2d<int> Bounds2di;
 }
 
 template <typename T> struct fmt::formatter<crayg::Bounds2d<T>> : ostream_formatter {};
+
+template <typename T> struct fmt::formatter<std::optional<crayg::Bounds2d<T>>> {
+    template <typename ParseContext> constexpr auto parse(ParseContext &ctx) {
+        return ctx.begin();
+    }
+
+    template <typename FormatContext> auto format(std::optional<crayg::Bounds2d<T>> const &bounds, FormatContext &ctx) {
+        return fmt::format_to(ctx.out(), "{}", bounds.has_value() ? fmt::format("{}", *bounds) : "<empty>");
+    };
+};
diff --git a/src/crayg/src/image/ImageMetadata.cpp b/src/crayg/src/image/ImageMetadata.cpp
@@ -16,6 +16,7 @@ const std::string ImageMetadataTokens::RENDER_SETTINGS_ADAPTIVE_MAX_ERROR = "cra
 const std::string ImageMetadataTokens::RENDER_SETTINGS_SAMPLES_PER_ADAPTIVE_PASS =
     "crayg/renderSettings/samplesPerAdaptivePass";
 const std::string ImageMetadataTokens::RENDER_SETTINGS_USE_SPECTRAL_LENSING = "crayg/renderSettings/useSpectralLensing";
+const std::string ImageMetadataTokens::RENDER_SETTINGS_REGION_TO_RENDER = "crayg/renderSettings/regionToRender";
 const std::string ImageMetadataTokens::CAMERA_NAME = "crayg/camera/name";
 const std::string ImageMetadataTokens::CAMERA_FOCAL_LENGTH = "crayg/camera/focalLength";
 const std::string ImageMetadataTokens::CAMERA_FILM_BACK_SIZE = "crayg/camera/filmBackSize";

diff --git a/src/crayg/src/image/ImageMetadata.h b/src/crayg/src/image/ImageMetadata.h
@@ -27,6 +27,7 @@ class ImageMetadataTokens {
     static const std::string RENDER_SETTINGS_ADAPTIVE_MAX_ERROR;
     static const std::string RENDER_SETTINGS_SAMPLES_PER_ADAPTIVE_PASS;
     static const std::string RENDER_SETTINGS_USE_SPECTRAL_LENSING;
+    static const std::string RENDER_SETTINGS_REGION_TO_RENDER;
     static const std::string CAMERA_NAME;
     static const std::string CAMERA_FOCAL_LENGTH;
     static const std::string CAMERA_FILM_BACK_SIZE;

diff --git a/src/crayg/src/scene/RenderSettings.cpp b/src/crayg/src/scene/RenderSettings.cpp
@@ -1,16 +1,18 @@
 #include "RenderSettings.h"
+#include <regex>
 #include <utils/ToStringHelper.h>
 
 namespace crayg {
 
 RenderSettings::RenderSettings(const Resolution &resolution, int maxSamples, IntegratorType integratorType,
                                IntegratorSettings integratorSettings, IntersectorType intersectorType,
                                BucketSequenceType bucketSequenceType, BucketSamplerType bucketSamplerType,
-                               float maxError, int samplesPerAdaptivePass, bool useSpectralLensing)
+                               float maxError, int samplesPerAdaptivePass, bool useSpectralLensing,
+                               const std::optional<Bounds2di> &regionToRender)
     : resolution(resolution), maxSamples(maxSamples), integratorType(integratorType),
       integratorSettings(integratorSettings), intersectorType(intersectorType), bucketSequenceType(bucketSequenceType),
       bucketSamplerType(bucketSamplerType), adaptiveMaxError(maxError), samplesPerAdaptivePass(samplesPerAdaptivePass),
-      useSpectralLensing(useSpectralLensing) {
+      useSpectralLensing(useSpectralLensing), regionToRender(regionToRender) {
 }
 
 RenderSettings::RenderSettings() : resolution(Resolution(0, 0)) {
@@ -23,14 +25,15 @@ RenderSettings::RenderSettings(const RenderSettings &renderSettings)
       intersectorType(renderSettings.intersectorType), bucketSequenceType(renderSettings.bucketSequenceType),
       bucketSamplerType(renderSettings.bucketSamplerType), adaptiveMaxError(renderSettings.adaptiveMaxError),
       samplesPerAdaptivePass(renderSettings.samplesPerAdaptivePass),
-      useSpectralLensing(renderSettings.useSpectralLensing) {
+      useSpectralLensing(renderSettings.useSpectralLensing), regionToRender(renderSettings.regionToRender) {
 }
 
 bool RenderSettings::operator==(const RenderSettings &rhs) const {
     return resolution == rhs.resolution && maxSamples == rhs.maxSamples && integratorType == rhs.integratorType &&
            integratorSettings == rhs.integratorSettings && intersectorType == rhs.intersectorType &&
            bucketSamplerType == rhs.bucketSamplerType && adaptiveMaxError == rhs.adaptiveMaxError &&
-           samplesPerAdaptivePass == rhs.samplesPerAdaptivePass && useSpectralLensing == rhs.useSpectralLensing;
+           samplesPerAdaptivePass == rhs.samplesPerAdaptivePass && useSpectralLensing == rhs.useSpectralLensing &&
+           regionToRender == rhs.regionToRender;
 }
 
 bool RenderSettings::operator!=(const RenderSettings &rhs) const {
@@ -40,7 +43,7 @@ bool RenderSettings::operator!=(const RenderSettings &rhs) const {
 RenderSettings RenderSettings::createDefault() {
     return RenderSettings(crayg::Resolution(1280, 720), 16, IntegratorType::RAYTRACING, IntegratorSettings(),
                           IntersectorType::EMBREE, BucketSequenceType::MORTON, BucketSamplerType::ADAPTIVE, 0.007f, 8,
-                          false);
+                          false, std::nullopt);
 }
 
 std::ostream &operator<<(std::ostream &os, const RenderSettings &renderSettings) {
@@ -55,8 +58,34 @@ std::ostream &operator<<(std::ostream &os, const RenderSettings &renderSettings)
               .addMember("adaptiveMaxError", renderSettings.adaptiveMaxError)
               .addMember("samplesPerAdaptivePass", renderSettings.samplesPerAdaptivePass)
               .addMember("useSpectralLensing", renderSettings.useSpectralLensing)
+              .addMember("regionToRender", renderSettings.regionToRender)
               .finish();
     return os;
 }
 
+Bounds2di parseRegionFromString(const std::string &str) {
+    std::vector<int> integers;
+    std::regex integerRegex("\\d+");
+    std::sregex_iterator iter(str.begin(), str.end(), integerRegex);
+    std::sregex_iterator end;
+
+    while (iter != end) {
+        std::smatch match = *iter;
+        try {
+            integers.push_back(std::stoi(match.str()));
+        } catch (const std::invalid_argument &e) {
+            // Not a valid integer
+        } catch (const std::out_of_range &e) {
+            // Integer out of range
+        }
+        ++iter;
+    }
+
+    if (integers.size() != 4) {
+        CRAYG_LOG_AND_THROW_MESSAGE(fmt::format("Invalid format for region: {}, supported is [(0,1),(2,3)]", str));
+    }
+
+    return Bounds2di({integers[0], integers[1]}, {integers[2], integers[3]});
+}
+
 }
diff --git a/src/crayg/src/scene/RenderSettings.h b/src/crayg/src/scene/RenderSettings.h
@@ -1,23 +1,28 @@
 #pragma once
 
+#include "basics/Bound2d.h"
 #include "image/imageiterators/buckets/BucketSequenceType.h"
 #include "integrators/IntegratorSettings.h"
 #include "integrators/IntegratorType.h"
 #include "intersectors/IntersectorType.h"
 #include "renderer/bucketsamplers/BucketSamplerType.h"
 #include <basics/Resolution.h>
 #include <fmt/ostream.h>
+#include <optional>
 
 namespace crayg {
 
+Bounds2di parseRegionFromString(const std::string &str);
+
 class RenderSettings {
   public:
     RenderSettings();
     RenderSettings(const RenderSettings &renderSettings);
     explicit RenderSettings(const Resolution &resolution, int maxSamples, IntegratorType integratorType,
                             IntegratorSettings integratorSettings, IntersectorType intersectorType,
                             BucketSequenceType bucketSequenceType, BucketSamplerType bucketSamplerType, float maxError,
-                            int samplesPerAdaptivePass, bool useSpectralLensing);
+                            int samplesPerAdaptivePass, bool useSpectralLensing,
+                            const std::optional<Bounds2di> &regionToRender);
 
     static RenderSettings createDefault();
 
@@ -36,6 +41,7 @@ class RenderSettings {
     float adaptiveMaxError = 0.007f;
     int samplesPerAdaptivePass = 8;
     bool useSpectralLensing = false;
+    std::optional<Bounds2di> regionToRender;
 };
 
 }

diff --git a/src/crayg/src/sceneIO/read/usd/UsdRenderSettingsReader.cpp b/src/crayg/src/sceneIO/read/usd/UsdRenderSettingsReader.cpp
@@ -23,6 +23,7 @@ std::shared_ptr<crayg::RenderSettings> crayg::UsdRenderSettingsReader::read() {
     const float adaptiveMaxError = readAdaptiveMaxError();
     const int samplesPerAdaptivePass = readSamplesPerAdaptivePass();
     const int useSpectralLensing = readUseSpectralLensing();
+    const std::optional<Bounds2di> regionToRender = readRegionToRender();
 
     renderSettings->resolution = resolution;
     renderSettings->maxSamples = maxSamples;
@@ -34,6 +35,7 @@ std::shared_ptr<crayg::RenderSettings> crayg::UsdRenderSettingsReader::read() {
     renderSettings->adaptiveMaxError = adaptiveMaxError;
     renderSettings->samplesPerAdaptivePass = samplesPerAdaptivePass;
     renderSettings->useSpectralLensing = useSpectralLensing;
+    renderSettings->regionToRender = regionToRender;
 
     return renderSettings;
 }
@@ -127,4 +129,13 @@ int UsdRenderSettingsReader::readUseSpectralLensing() {
                                                     RenderSettings::createDefault().useSpectralLensing);
 }
 
+std::optional<Bounds2di> UsdRenderSettingsReader::readRegionToRender() {
+    auto usdAttr = usdPrim.GetPrim().GetAttribute(pxr::TfToken("regionToRender"));
+    if (!usdAttr) {
+        return RenderSettings::createDefault().regionToRender;
+    }
+    const auto regionToRender = UsdUtils::getStaticAttributeValueAs<pxr::GfVec4i>(usdAttr);
+    return Bounds2di({regionToRender[0], regionToRender[1]}, {regionToRender[2], regionToRender[3]});
+}
+
 }
diff --git a/src/crayg/src/sceneIO/read/usd/UsdRenderSettingsReader.h b/src/crayg/src/sceneIO/read/usd/UsdRenderSettingsReader.h
@@ -28,6 +28,7 @@ class UsdRenderSettingsReader : public BaseUsdReader<pxr::UsdRenderSettings, Ren
     float readAdaptiveMaxError();
     int readSamplesPerAdaptivePass();
     int readUseSpectralLensing();
+    std::optional<Bounds2di> readRegionToRender();
 };
 
 }
diff --git a/src/crayg/src/sceneIO/write/usd/UsdRenderSettingsWriter.cpp b/src/crayg/src/sceneIO/write/usd/UsdRenderSettingsWriter.cpp
@@ -24,6 +24,7 @@ pxr::UsdRenderSettings UsdRenderSettingsWriter::write(pxr::UsdStagePtr stage) {
     writeAdaptiveMaxError(usdRenderSettings);
     writeSamplesPerAdaptivePass(usdRenderSettings);
     writeUseSpectralLensing(usdRenderSettings);
+    writeRegionToRender(usdRenderSettings);
 
     return usdRenderSettings;
 }
@@ -77,4 +78,14 @@ void UsdRenderSettingsWriter::writeUseSpectralLensing(const pxr::UsdRenderSettin
                                     renderSettings.useSpectralLensing ? 1 : 0);
 }
 
+void UsdRenderSettingsWriter::writeRegionToRender(const pxr::UsdRenderSettings &usdRenderSettings) const {
+    if (!renderSettings.regionToRender) {
+        return;
+    }
+    usdRenderSettings.GetPrim()
+        .CreateAttribute(pxr::TfToken("regionToRender"), pxr::SdfValueTypeNames->Int4)
+        .Set(pxr::GfVec4i(renderSettings.regionToRender->min.x, renderSettings.regionToRender->min.y,
+                          renderSettings.regionToRender->max.x, renderSettings.regionToRender->max.y));
+}
+
 } // crayg
diff --git a/src/crayg/src/sceneIO/write/usd/UsdRenderSettingsWriter.h b/src/crayg/src/sceneIO/write/usd/UsdRenderSettingsWriter.h
@@ -23,6 +23,7 @@ class UsdRenderSettingsWriter {
     void writeAdaptiveMaxError(const pxr::UsdRenderSettings &usdRenderSettings) const;
     void writeSamplesPerAdaptivePass(const pxr::UsdRenderSettings &usdRenderSettings) const;
     void writeUseSpectralLensing(const pxr::UsdRenderSettings &usdRenderSettings) const;
+    void writeRegionToRender(const pxr::UsdRenderSettings &usdRenderSettings) const;
 };
 
 } // crayg
diff --git a/src/crayg/src/utils/ImageMetadataCollector.cpp b/src/crayg/src/utils/ImageMetadataCollector.cpp
@@ -63,6 +63,13 @@ void ImageMetadataCollector::collectRenderSettingsIfPresent(ImageMetadata &image
                         scene->renderSettings.samplesPerAdaptivePass);
     imageMetadata.write(ImageMetadataTokens::RENDER_SETTINGS_USE_SPECTRAL_LENSING,
                         scene->renderSettings.useSpectralLensing ? 1 : 0);
+    imageMetadata.write(ImageMetadataTokens::RENDER_SETTINGS_REGION_TO_RENDER,
+                        scene->renderSettings.regionToRender.has_value()
+                            ? fmt::format("[({},{}),({},{})]", scene->renderSettings.regionToRender->min.x,
+                                          scene->renderSettings.regionToRender->min.y,
+                                          scene->renderSettings.regionToRender->max.x,
+                                          scene->renderSettings.regionToRender->max.y)
+                            : "none");
     collectIntegratorSettings(imageMetadata);
 }
 

diff --git a/src/crayg/tests/CMakeLists.txt b/src/crayg/tests/CMakeLists.txt
@@ -93,6 +93,7 @@ set(UNIT_TEST_SOURCE_LIST
     TestReadableFormatter.cpp
     TestRectLight.cpp
     TestRemainingTimeCalculator.cpp
+    TestRenderSettings.cpp
     TestResolution.cpp
     TestSampleAccumulator.cpp
     TestScene.cpp

diff --git a/src/crayg/tests/TestImageMetadataCollector.cpp b/src/crayg/tests/TestImageMetadataCollector.cpp
@@ -31,10 +31,10 @@ TEST_CASE("TestImageMetadataCollector::collect") {
 
     SECTION("should collect render settings") {
         Scene scene;
-        scene.renderSettings =
-            RenderSettings(Resolution(1280, 720), 4, IntegratorType::RAYTRACING,
-                           IntegratorSettings({{"AMBIENT_OCCLUSION:sampleCount", {8}}}), IntersectorType::EMBREE,
-                           BucketSequenceType::LINE_BY_LINE, BucketSamplerType::ADAPTIVE, 0.007f, 8, false);
+        scene.renderSettings = RenderSettings(Resolution(1280, 720), 4, IntegratorType::RAYTRACING,
+                                              IntegratorSettings({{"AMBIENT_OCCLUSION:sampleCount", {8}}}),
+                                              IntersectorType::EMBREE, BucketSequenceType::LINE_BY_LINE,
+                                              BucketSamplerType::ADAPTIVE, 0.007f, 8, false, Bounds2di({0, 1}, {2, 3}));
         ImageMetadataCollector imageMetadataCollector;
         imageMetadataCollector.scene = &scene;
         ImageMetadata imageMetadata = imageMetadataCollector.collectMetadata();
@@ -49,6 +49,8 @@ TEST_CASE("TestImageMetadataCollector::collect") {
         REQUIRE(imageMetadata.read<float>(ImageMetadataTokens::RENDER_SETTINGS_ADAPTIVE_MAX_ERROR) == 0.007f);
         REQUIRE(imageMetadata.read<int>(ImageMetadataTokens::RENDER_SETTINGS_SAMPLES_PER_ADAPTIVE_PASS) == 8);
         REQUIRE(imageMetadata.read<int>(ImageMetadataTokens::RENDER_SETTINGS_USE_SPECTRAL_LENSING) == 0);
+        REQUIRE(imageMetadata.read<std::string>(ImageMetadataTokens::RENDER_SETTINGS_REGION_TO_RENDER) ==
+                "[(0,1),(2,3)]");
         REQUIRE(imageMetadata.read<int>("crayg/renderSettings/integratorSettings/AMBIENT_OCCLUSION:sampleCount") == 8);
     }
 

diff --git a/src/crayg/tests/TestRenderSettings.cpp b/src/crayg/tests/TestRenderSettings.cpp
@@ -0,0 +1,20 @@
+#include "scene/RenderSettings.h"
+#include <catch2/catch.hpp>
+
+namespace crayg {
+
+TEST_CASE("RenderSettings::parseRegionFromString") {
+
+    SECTION("should parse region") {
+        const Bounds2di parsed = parseRegionFromString("[(0,0),(400,500)]");
+
+        REQUIRE(parsed == Bounds2di({0, 0}, {400, 500}));
+    }
+
+    SECTION("should not parse region") {
+        REQUIRE_THROWS_WITH(parseRegionFromString("[(0,0),(500)]"),
+                            Catch::Equals("Invalid format for region: [(0,0),(500)], supported is [(0,1),(2,3)]"));
+    }
+}
+
+}
diff --git a/src/crayg/tests/TestUsdRenderSettingsReader.cpp b/src/crayg/tests/TestUsdRenderSettingsReader.cpp
@@ -33,6 +33,9 @@ TEST_CASE("UsdRenderSettingsReader::read") {
         usdRenderSettings.GetPrim()
             .CreateAttribute(pxr::TfToken("samplesPerAdaptivePass"), pxr::SdfValueTypeNames->Int)
             .Set(16);
+        usdRenderSettings.GetPrim()
+            .CreateAttribute(pxr::TfToken("regionToRender"), pxr::SdfValueTypeNames->Int4)
+            .Set(pxr::GfVec4i(0, 1, 2, 3));
         usdRenderSettings.GetPrim()
             .CreateAttribute(pxr::TfToken("useSpectralLensing"), pxr::SdfValueTypeNames->Int)
             .Set(1);
@@ -44,7 +47,7 @@ TEST_CASE("UsdRenderSettingsReader::read") {
                 RenderSettings(crayg::Resolution(800, 600), 2, IntegratorType::DEBUG,
                                IntegratorSettings({{"DEBUG:someToken", {std::string("someTokenValue")}}}),
                                IntersectorType::EMBREE, BucketSequenceType::LINE_BY_LINE, BucketSamplerType::UNIFORM,
-                               0.1f, 16, true));
+                               0.1f, 16, true, Bounds2di({0, 1}, {2, 3})));
     }
 
     SECTION("should fallback to default values") {

diff --git a/src/crayg/tests/TestUsdRenderSettingsWriter.cpp b/src/crayg/tests/TestUsdRenderSettingsWriter.cpp
@@ -13,7 +13,7 @@ TEST_CASE("UsdRenderSettingsWriter::write") {
         const RenderSettings renderSettings(Resolution(1280, 720), 4, IntegratorType::RAYTRACING,
                                             IntegratorSettings({{"AMBIENT_OCCLUSION:sampleCount", {8}}}),
                                             IntersectorType::EMBREE, BucketSequenceType::LINE_BY_LINE,
-                                            BucketSamplerType::ADAPTIVE, 0.007f, 8, true);
+                                            BucketSamplerType::ADAPTIVE, 0.007f, 8, true, Bounds2di({0, 1}, {2, 3}));
 
         UsdRenderSettingsWriter usdRenderSettingsWriter(renderSettings);
         usdRenderSettingsWriter.write(stage);
@@ -39,6 +39,8 @@ TEST_CASE("UsdRenderSettingsWriter::write") {
             usdRenderSettings.GetPrim().GetAttribute(pxr::TfToken("samplesPerAdaptivePass")));
         const int useSpectralLensing = UsdUtils::getStaticAttributeValueAs<int>(
             usdRenderSettings.GetPrim().GetAttribute(pxr::TfToken("useSpectralLensing")));
+        const pxr::GfVec4i regionToRender = UsdUtils::getStaticAttributeValueAs<pxr::GfVec4i>(
+            usdRenderSettings.GetPrim().GetAttribute(pxr::TfToken("regionToRender")));
         REQUIRE(resolution == pxr::GfVec2i(1280, 720));
         REQUIRE(maxSamples == 4);
         REQUIRE(integratorType == pxr::TfToken("RAYTRACING"));
@@ -49,6 +51,7 @@ TEST_CASE("UsdRenderSettingsWriter::write") {
         REQUIRE(adaptiveMaxError == 0.007f);
         REQUIRE(samplesPerAdaptivePass == 8);
         REQUIRE(useSpectralLensing == 1);
+        REQUIRE(regionToRender == pxr::GfVec4i(0, 1, 2, 3));
     }
 }
 

diff --git a/src/crayg/tests/TestUsdStageReader.cpp b/src/crayg/tests/TestUsdStageReader.cpp
@@ -187,7 +187,7 @@ TEST_CASE("UsdStageReader::readStageToScene") {
         REQUIRE(scene.renderSettings == RenderSettings(Resolution(800, 600), 2, IntegratorType::RAYTRACING,
                                                        IntegratorSettings(), IntersectorType::EMBREE,
                                                        BucketSequenceType::LINE_BY_LINE, BucketSamplerType::ADAPTIVE,
-                                                       0.007f, 8, false));
+                                                       0.007f, 8, false, std::nullopt));
     }
 
     SECTION("providing a cameraName in translationOptions should use this camera") {

diff --git a/src/standalone/src/CliParser.cpp b/src/standalone/src/CliParser.cpp
@@ -136,10 +136,13 @@ CliParseResult CliParser::parse() {
     app.add_option("--samplesPerAdaptivePass", renderSettingsOverride.samplesPerAdaptivePass,
                    "Override samples per adaptive pass");
 
-    std::optional<bool> useSpectralLensing;
     app.add_flag("--useSpectralLensing", renderSettingsOverride.useSpectralLensing,
                  "Override if spectral lens simulation should be used");
 
+    std::string regionToRender;
+    app.add_flag("--regionToRender", regionToRender,
+                 "Render only a specified region, provide in [(min_x,mix_y),(max_x,max_y)]");
+
     try {
         app.parse(argc, argv);
 
@@ -156,6 +159,10 @@ CliParseResult CliParser::parse() {
         parseIntegratorSettings<std::string>(renderSettingsOverride.integratorSettingsOverrides,
                                              integratorSettingsStringOverrides);
 
+        if (!regionToRender.empty()) {
+            renderSettingsOverride.regionToRender = parseRegionFromString(regionToRender);
+        }
+
         return CliParseResult(CliArgs(sceneFileName, imageOutputPath,
                                       !cameraName.empty() ? std::make_optional(cameraName) : std::nullopt,
                                       renderSettingsOverride, parsedVariantSelections),