selfTest.cpp

#include "CameraCalibration.h"
#include "RadiationModel.h"
#include "BufferIndexing.h"
#include "FluspectB.h"
#include "test_helpers.h"
 
#include <fstream>
#include <sstream>
 
#ifdef HELIOS_HAVE_VULKAN
#include "VulkanComputeBackend.h"
#endif
 
#define DOCTEST_CONFIG_IMPLEMENT
#include <doctest.h>
#include "doctest_utils.h"
 
using namespace helios;
 
namespace helios {
    class RadiationModelTestHelper {
    public:
        static bool isGPUAvailable() {
#ifdef HELIOS_HAVE_VULKAN
            // Once a runtime failure (e.g. VK_ERROR_DEVICE_LOST on a flaky CI runner)
            // marks the shared device as bad, every later GPU test must skip — otherwise
            // they re-trigger the same crash and report it as a fresh failure.
            if (!TestVulkanDeviceManager::isVulkanAvailable()) {
                return false;
            }
#endif
            return helios::probeAnyGPUBackend();
        }
 
        static RadiationModel createWithSharedDevice(Context *context) {
#if defined(HELIOS_HAVE_OPTIX8) || (defined(HELIOS_HAVE_OPTIX) && !defined(FORCE_VULKAN_BACKEND))
            // OptiX available and not forced to Vulkan - use default constructor
            return RadiationModel(context);
#elif defined(HELIOS_HAVE_VULKAN)
            // Vulkan backend - use shared device (workaround for NVIDIA driver bug)
            VulkanDevice *device = TestVulkanDeviceManager::getSharedDevice();
            if (!device) {
                helios_runtime_error("No Vulkan device available for testing");
            }
            auto backend = std::make_unique<VulkanComputeBackend>(device);
            backend->initialize();
 
            // Use static factory method to inject pre-configured backend
            return RadiationModel::createWithBackend(context, std::move(backend));
#else
            helios_runtime_error("No ray tracing backend available for testing");
            return RadiationModel(context); // Unreachable, silence compiler warning
#endif
        }
    };
} // namespace helios
 
int RadiationModel::selfTest(int argc, char **argv) {
    return helios::runDoctestWithValidation(argc, argv);
}
 
DOCTEST_TEST_CASE("Backend Identification") {
    std::string compiled_backends;
#ifdef HELIOS_HAVE_OPTIX8
    compiled_backends += "OptiX8 ";
#endif
#ifdef HELIOS_HAVE_OPTIX
    compiled_backends += "OptiX6 ";
#endif
#ifdef HELIOS_HAVE_VULKAN
    compiled_backends += "Vulkan ";
#endif
    if (compiled_backends.empty()) compiled_backends = "(none)";
    DOCTEST_MESSAGE("Compiled backends: " << compiled_backends);
 
    bool gpu_available = RadiationModelTestHelper::isGPUAvailable();
    DOCTEST_MESSAGE("GPU available: " << std::string(gpu_available ? "yes" : "no"));
 
    if (gpu_available) {
        Context context;
        RadiationModel model = RadiationModelTestHelper::createWithSharedDevice(&context);
        DOCTEST_MESSAGE("Active backend: " << model.getBackendName());
    }
}
 
DOCTEST_TEST_CASE("BufferIndexing Correctness") {
    // Test 2D indexer
    {
        BufferIndexer2D indexer(10, 5); // 10x5 array
 
        DOCTEST_CHECK(indexer(0, 0) == 0);
        DOCTEST_CHECK(indexer(0, 1) == 1);
        DOCTEST_CHECK(indexer(0, 4) == 4);
        DOCTEST_CHECK(indexer(1, 0) == 5);
        DOCTEST_CHECK(indexer(1, 1) == 6);
        DOCTEST_CHECK(indexer(9, 4) == 49); // Last element
 
        // Verify against manual calculation
        for (size_t i = 0; i < 10; i++) {
            for (size_t j = 0; j < 5; j++) {
                size_t manual = i * 5 + j;
                size_t indexed = indexer(i, j);
                DOCTEST_CHECK(manual == indexed);
            }
        }
    }
 
    // Test 3D indexer
    {
        BufferIndexer3D indexer(2, 3, 4); // 2x3x4 array
 
        DOCTEST_CHECK(indexer(0, 0, 0) == 0);
        DOCTEST_CHECK(indexer(0, 0, 1) == 1);
        DOCTEST_CHECK(indexer(0, 0, 3) == 3);
        DOCTEST_CHECK(indexer(0, 1, 0) == 4);
        DOCTEST_CHECK(indexer(0, 2, 0) == 8);
        DOCTEST_CHECK(indexer(1, 0, 0) == 12);
        DOCTEST_CHECK(indexer(1, 2, 3) == 23); // Last element
 
        // Verify against manual calculation
        for (size_t i = 0; i < 2; i++) {
            for (size_t j = 0; j < 3; j++) {
                for (size_t k = 0; k < 4; k++) {
                    size_t manual = i * 3 * 4 + j * 4 + k;
                    size_t indexed = indexer(i, j, k);
                    DOCTEST_CHECK(manual == indexed);
                }
            }
        }
    }
 
    // Test 4D indexer
    {
        BufferIndexer4D indexer(2, 2, 2, 2); // 2x2x2x2 array
 
        DOCTEST_CHECK(indexer(0, 0, 0, 0) == 0);
        DOCTEST_CHECK(indexer(0, 0, 0, 1) == 1);
        DOCTEST_CHECK(indexer(0, 0, 1, 0) == 2);
        DOCTEST_CHECK(indexer(0, 1, 0, 0) == 4);
        DOCTEST_CHECK(indexer(1, 0, 0, 0) == 8);
        DOCTEST_CHECK(indexer(1, 1, 1, 1) == 15); // Last element
 
        // Verify against manual calculation
        for (size_t i = 0; i < 2; i++) {
            for (size_t j = 0; j < 2; j++) {
                for (size_t k = 0; k < 2; k++) {
                    for (size_t l = 0; l < 2; l++) {
                        size_t manual = i * 2 * 2 * 2 + j * 2 * 2 + k * 2 + l;
                        size_t indexed = indexer(i, j, k, l);
                        DOCTEST_CHECK(manual == indexed);
                    }
                }
            }
        }
    }
 
    // Test realistic dimensions matching radiation plugin usage
    {
        const size_t Nsources = 5;
        const size_t Nprimitives = 100;
        const size_t Nbands = 20;
        const size_t Ncameras = 3;
 
        MaterialPropertyIndexer mat_indexer(Nsources, Nprimitives, Nbands);
 
        // Verify a few random indices
        DOCTEST_CHECK(mat_indexer(0, 0, 0) == 0);
        DOCTEST_CHECK(mat_indexer(0, 0, 1) == 1);
        DOCTEST_CHECK(mat_indexer(0, 1, 0) == 20);
        DOCTEST_CHECK(mat_indexer(1, 0, 0) == 2000);
 
        // Verify against manual calculation for all combinations
        for (size_t s = 0; s < Nsources; s++) {
            for (size_t p = 0; p < Nprimitives; p++) {
                for (size_t b = 0; b < Nbands; b++) {
                    size_t manual = s * Nprimitives * Nbands + p * Nbands + b;
                    size_t indexed = mat_indexer(s, p, b);
                    DOCTEST_CHECK(manual == indexed);
                }
            }
        }
 
        // Test 4D camera material indexer
        CameraMaterialIndexer cam_mat_indexer(Nsources, Nprimitives, Nbands, Ncameras);
 
        for (size_t s = 0; s < 2; s++) { // Test subset
            for (size_t p = 0; p < 10; p++) {
                for (size_t b = 0; b < Nbands; b++) {
                    for (size_t c = 0; c < Ncameras; c++) {
                        size_t manual = s * Nprimitives * Nbands * Ncameras + p * Nbands * Ncameras + b * Ncameras + c;
                        size_t indexed = cam_mat_indexer(s, p, b, c);
                        DOCTEST_CHECK(manual == indexed);
                    }
                }
            }
        }
    }
}
 
GPU_TEST_CASE("RadiationModel Simple Direct") {
    // Minimal test: single patch, collimated source, no scattering, no emission
    Context context;
    uint patch = context.addPatch(make_vec3(0, 0, 0), make_vec2(1, 1)); // Horizontal 1x1 patch
    context.setPrimitiveData(patch, "twosided_flag", uint(0)); // One-sided
    context.setPrimitiveData(patch, "reflectivity_SW", 0.0f); // No reflection (100% absorption)
 
    RadiationModel radiation = RadiationModelTestHelper::createWithSharedDevice(&context);
    radiation.disableMessages();
 
    // Add shortwave band
    radiation.addRadiationBand("SW");
    radiation.disableEmission("SW");
    uint sun = radiation.addCollimatedRadiationSource(make_vec3(0, 0, 1)); // Sun pointing down (+Z)
    radiation.setSourceFlux(sun, "SW", 1000.0f); // 1000 W/m²
    radiation.setDirectRayCount("SW", 10000);
    radiation.setScatteringDepth("SW", 0); // No scattering
 
    radiation.updateGeometry();
    radiation.runBand("SW");
 
    float flux;
    context.getPrimitiveData(patch, "radiation_flux_SW", flux);
 
    // With no reflection, horizontal patch, downward sun: should absorb ~1000 W/m²
    float error = fabsf(flux - 1000.0f) / 1000.0f;
    DOCTEST_CHECK(error <= 0.01); // 1% tolerance
}
 
GPU_TEST_CASE("RadiationModel 90 Degree Common-Edge Squares") {
    float error_threshold = 0.005;
    int Nensemble = 500;
 
    uint Ndiffuse_1 = 100000;
    uint Ndirect_1 = 5000;
 
    float Qs = 1000.f;
    float sigma = 5.6703744E-8;
 
    float shortwave_exact_0 = 0.7f * Qs;
    float shortwave_exact_1 = 0.3f * 0.2f * Qs;
    float longwave_exact_0 = 0.f;
    float longwave_exact_1 = sigma * powf(300.f, 4) * 0.2f;
 
    Context context_1;
    uint UUID0 = context_1.addPatch(make_vec3(0, 0, 0), make_vec2(1, 1));
    uint UUID1 = context_1.addPatch(make_vec3(0.5, 0, 0.5), make_vec2(1, 1), make_SphericalCoord(0.5 * M_PI, -0.5 * M_PI));
 
    uint ts_flag = 0;
    context_1.setPrimitiveData(UUID0, "twosided_flag", ts_flag);
    context_1.setPrimitiveData(UUID1, "twosided_flag", ts_flag);
 
    context_1.setPrimitiveData(0, "temperature", 300.f);
    context_1.setPrimitiveData(1, "temperature", 0.f);
 
    float shortwave_rho = 0.3f;
    context_1.setPrimitiveData(0, "reflectivity_SW", shortwave_rho);
 
    RadiationModel radiationmodel_1 = RadiationModelTestHelper::createWithSharedDevice(&context_1);
    radiationmodel_1.disableMessages();
 
    // Longwave band
    radiationmodel_1.addRadiationBand("LW");
    radiationmodel_1.setDirectRayCount("LW", Ndiffuse_1);
    radiationmodel_1.setDiffuseRayCount("LW", Ndiffuse_1);
    radiationmodel_1.setScatteringDepth("LW", 0);
 
    // Shortwave band
    uint SunSource_1 = radiationmodel_1.addCollimatedRadiationSource(make_vec3(0, 0, 1));
    radiationmodel_1.addRadiationBand("SW");
    radiationmodel_1.disableEmission("SW");
    radiationmodel_1.setDirectRayCount("SW", Ndirect_1);
    radiationmodel_1.setDiffuseRayCount("SW", Ndirect_1);
    radiationmodel_1.setScatteringDepth("SW", 1);
    radiationmodel_1.setSourceFlux(SunSource_1, "SW", Qs);
 
    radiationmodel_1.updateGeometry();
 
    float longwave_model_0 = 0.f;
    float longwave_model_1 = 0.f;
    float shortwave_model_0 = 0.f;
    float shortwave_model_1 = 0.f;
    float R;
 
    for (int r = 0; r < Nensemble; r++) {
        std::vector<std::string> bands{"LW", "SW"};
        radiationmodel_1.runBand(bands);
 
        // patch 0 emission
        context_1.getPrimitiveData(0, "radiation_flux_LW", R);
        longwave_model_0 += R / float(Nensemble);
        // patch 1 emission
        context_1.getPrimitiveData(1, "radiation_flux_LW", R);
        longwave_model_1 += R / float(Nensemble);
 
        // patch 0 shortwave
        context_1.getPrimitiveData(0, "radiation_flux_SW", R);
        shortwave_model_0 += R / float(Nensemble);
        // patch 1 shortwave
        context_1.getPrimitiveData(1, "radiation_flux_SW", R);
        shortwave_model_1 += R / float(Nensemble);
    }
 
    float shortwave_error_0 = fabsf(shortwave_model_0 - shortwave_exact_0) / fabsf(shortwave_exact_0);
    float shortwave_error_1 = fabsf(shortwave_model_1 - shortwave_exact_1) / fabsf(shortwave_exact_1);
    float longwave_error_1 = fabsf(longwave_model_1 - longwave_exact_1) / fabsf(longwave_exact_1);
 
    DOCTEST_CHECK(shortwave_error_0 <= error_threshold);
    DOCTEST_CHECK(shortwave_error_1 <= error_threshold);
    // For zero expected value, check direct equality
    DOCTEST_CHECK(longwave_model_0 == longwave_exact_0);
    DOCTEST_CHECK(longwave_error_1 <= error_threshold);
}
 
GPU_TEST_CASE("RadiationModel Black Parallel Rectangles") {
    float error_threshold = 0.005;
    int Nensemble = 500;
 
    uint Ndiffuse_2 = 50000;
 
    float a = 1;
    float b = 2;
    float c = 0.5;
 
    float X = a / c;
    float Y = b / c;
    float X2 = X * X;
    float Y2 = Y * Y;
 
    float F12 =
            2.0f / float(M_PI * X * Y) * (logf(std::sqrt((1.f + X2) * (1.f + Y2) / (1.f + X2 + Y2))) + X * std::sqrt(1.f + Y2) * atanf(X / std::sqrt(1.f + Y2)) + Y * std::sqrt(1.f + X2) * atanf(Y / std::sqrt(1.f + X2)) - X * atanf(X) - Y * atanf(Y));
 
    float shortwave_exact_0 = (1.f - F12);
    float shortwave_exact_1 = (1.f - F12);
 
    Context context_2;
    uint patch0 = context_2.addPatch(make_vec3(0, 0, 0), make_vec2(a, b));
    uint patch1 = context_2.addPatch(make_vec3(0, 0, c), make_vec2(a, b), make_SphericalCoord(M_PI, 0.f));
 
    uint flag = 0;
    context_2.setPrimitiveData(patch0, "twosided_flag", flag);
    context_2.setPrimitiveData(patch1, "twosided_flag", flag);
 
    RadiationModel radiationmodel_2 = RadiationModelTestHelper::createWithSharedDevice(&context_2);
    radiationmodel_2.disableMessages();
 
    // Shortwave band
    radiationmodel_2.addRadiationBand("SW");
    radiationmodel_2.disableEmission("SW");
    radiationmodel_2.setDiffuseRayCount("SW", Ndiffuse_2);
    radiationmodel_2.setDiffuseRadiationFlux("SW", 1.f);
    radiationmodel_2.setScatteringDepth("SW", 0);
 
    radiationmodel_2.updateGeometry();
 
    float shortwave_model_0 = 0.f;
    float shortwave_model_1 = 0.f;
    float R;
 
    for (int r = 0; r < Nensemble; r++) {
        radiationmodel_2.runBand("SW");
 
        context_2.getPrimitiveData(0, "radiation_flux_SW", R);
        shortwave_model_0 += R / float(Nensemble);
        context_2.getPrimitiveData(1, "radiation_flux_SW", R);
        shortwave_model_1 += R / float(Nensemble);
    }
 
    float shortwave_error_0 = fabsf(shortwave_model_0 - shortwave_exact_0) / fabsf(shortwave_exact_0);
    float shortwave_error_1 = fabsf(shortwave_model_1 - shortwave_exact_1) / fabsf(shortwave_exact_1);
 
    DOCTEST_CHECK(shortwave_error_0 <= error_threshold);
    DOCTEST_CHECK(shortwave_error_1 <= error_threshold);
}
 
GPU_TEST_CASE("RadiationModel Gray Parallel Rectangles") {
    float error_threshold = 0.005;
    int Nensemble = 500;
    float sigma = 5.6703744E-8;
 
    uint Ndiffuse_3 = 100000;
    uint Nscatter_3 = 5;
 
    float longwave_rho = 0.4;
    float eps = 0.6f;
 
    float T0 = 300.f;
    float T1 = 300.f;
 
    float a = 1;
    float b = 2;
    float c = 0.5;
 
    float X = a / c;
    float Y = b / c;
    float X2 = X * X;
    float Y2 = Y * Y;
 
    float F12 =
            2.0f / float(M_PI * X * Y) * (logf(std::sqrt((1.f + X2) * (1.f + Y2) / (1.f + X2 + Y2))) + X * std::sqrt(1.f + Y2) * atanf(X / std::sqrt(1.f + Y2)) + Y * std::sqrt(1.f + X2) * atanf(Y / std::sqrt(1.f + X2)) - X * atanf(X) - Y * atanf(Y));
 
    float longwave_exact_0 = (eps * (1.f / eps - 1.f) * F12 * sigma * (powf(T1, 4) - F12 * powf(T0, 4)) + sigma * (powf(T0, 4) - F12 * powf(T1, 4))) / (1.f / eps - (1.f / eps - 1.f) * F12 * eps * (1 / eps - 1) * F12) - eps * sigma * powf(T0, 4);
    float longwave_exact_1 = fabsf(eps * ((1 / eps - 1) * F12 * (longwave_exact_0 + eps * sigma * powf(T0, 4)) + sigma * (powf(T1, 4) - F12 * powf(T0, 4))) - eps * sigma * powf(T1, 4));
    longwave_exact_0 = fabsf(longwave_exact_0);
 
    Context context_3;
    context_3.addPatch(make_vec3(0, 0, 0), make_vec2(a, b));
    context_3.addPatch(make_vec3(0, 0, c), make_vec2(a, b), make_SphericalCoord(M_PI, 0.f));
 
    context_3.setPrimitiveData(0, "temperature", T0);
    context_3.setPrimitiveData(1, "temperature", T1);
 
    context_3.setPrimitiveData(0, "emissivity_LW", eps);
    context_3.setPrimitiveData(0, "reflectivity_LW", longwave_rho);
    context_3.setPrimitiveData(1, "emissivity_LW", eps);
    context_3.setPrimitiveData(1, "reflectivity_LW", longwave_rho);
 
    uint flag = 0;
    context_3.setPrimitiveData(0, "twosided_flag", flag);
    context_3.setPrimitiveData(1, "twosided_flag", flag);
 
    RadiationModel radiationmodel_3 = RadiationModelTestHelper::createWithSharedDevice(&context_3);
    radiationmodel_3.disableMessages();
 
    // Longwave band
    radiationmodel_3.addRadiationBand("LW");
    radiationmodel_3.setDirectRayCount("LW", Ndiffuse_3);
    radiationmodel_3.setDiffuseRayCount("LW", Ndiffuse_3);
    radiationmodel_3.setDiffuseRadiationFlux("LW", 0.f);
    radiationmodel_3.setScatteringDepth("LW", Nscatter_3);
 
    radiationmodel_3.updateGeometry();
 
    float longwave_model_0 = 0.f;
    float longwave_model_1 = 0.f;
    float R;
 
    for (int r = 0; r < Nensemble; r++) {
        radiationmodel_3.runBand("LW");
 
        context_3.getPrimitiveData(0, "radiation_flux_LW", R);
        longwave_model_0 += R / float(Nensemble);
        context_3.getPrimitiveData(1, "radiation_flux_LW", R);
        longwave_model_1 += R / float(Nensemble);
    }
 
    float longwave_error_0 = fabsf(longwave_exact_0 - longwave_model_0) / fabsf(longwave_exact_0);
    float longwave_error_1 = fabsf(longwave_exact_1 - longwave_model_1) / fabsf(longwave_exact_1);
 
    DOCTEST_CHECK(longwave_error_0 <= error_threshold);
    DOCTEST_CHECK(longwave_error_1 <= error_threshold);
}
 
GPU_TEST_CASE("RadiationModel Sphere Source") {
    float error_threshold = 0.005;
    int Nensemble = 500;
 
    uint Ndirect_4 = 10000;
 
    float r = 0.5;
    float d = 0.75f;
    float l1 = 1.5f;
    float l2 = 2.f;
 
    float D1 = d / l1;
    float D2 = d / l2;
 
    float F12 = 0.25f / float(M_PI) * atanf(sqrtf(1.f / (D1 * D1 + D2 * D2 + D1 * D1 * D2 * D2)));
 
    float shortwave_exact_0 = 4.0f * float(M_PI) * r * r * F12 / (l1 * l2);
 
    Context context_4;
    context_4.addPatch(make_vec3(0.5f * l1, 0.5f * l2, 0), make_vec2(l1, l2));
 
    RadiationModel radiationmodel_4 = RadiationModelTestHelper::createWithSharedDevice(&context_4);
    radiationmodel_4.disableMessages();
 
    uint Source_4 = radiationmodel_4.addSphereRadiationSource(make_vec3(0, 0, d), r);
 
    // Shortwave band
    radiationmodel_4.addRadiationBand("SW");
    radiationmodel_4.disableEmission("SW");
    radiationmodel_4.setDirectRayCount("SW", Ndirect_4);
    radiationmodel_4.setSourceFlux(Source_4, "SW", 1.f);
    radiationmodel_4.setScatteringDepth("SW", 0);
 
    radiationmodel_4.updateGeometry();
 
    float shortwave_model_0 = 0.f;
    float R;
 
    for (int i = 0; i < Nensemble; i++) {
        radiationmodel_4.runBand("SW");
 
        context_4.getPrimitiveData(0, "radiation_flux_SW", R);
        shortwave_model_0 += R / float(Nensemble);
    }
 
    float shortwave_error_0 = fabsf(shortwave_exact_0 - shortwave_model_0) / fabsf(shortwave_exact_0);
 
    DOCTEST_CHECK(shortwave_error_0 <= error_threshold);
}
 
GPU_TEST_CASE("RadiationModel 90 Degree Common-Edge Sub-Triangles") {
    float error_threshold = 0.005;
    int Nensemble = 500;
    float sigma = 5.6703744E-8;
 
    float Qs = 1000.f;
 
    uint Ndiffuse_5 = 100000;
    uint Ndirect_5 = 5000;
 
    float shortwave_exact_0 = 0.7f * Qs;
    float shortwave_exact_1 = 0.3f * 0.2f * Qs;
    float longwave_exact_0 = 0.f;
    float longwave_exact_1 = sigma * powf(300.f, 4) * 0.2f;
 
    Context context_5;
 
    context_5.addTriangle(make_vec3(-0.5, -0.5, 0), make_vec3(0.5, -0.5, 0), make_vec3(0.5, 0.5, 0));
    context_5.addTriangle(make_vec3(-0.5, -0.5, 0), make_vec3(0.5, 0.5, 0), make_vec3(-0.5, 0.5, 0));
 
    context_5.addTriangle(make_vec3(0.5, 0.5, 0), make_vec3(0.5, -0.5, 0), make_vec3(0.5, -0.5, 1));
    context_5.addTriangle(make_vec3(0.5, 0.5, 0), make_vec3(0.5, -0.5, 1), make_vec3(0.5, 0.5, 1));
 
    context_5.setPrimitiveData(0, "temperature", 300.f);
    context_5.setPrimitiveData(1, "temperature", 300.f);
    context_5.setPrimitiveData(2, "temperature", 0.f);
    context_5.setPrimitiveData(3, "temperature", 0.f);
 
    float shortwave_rho = 0.3f;
    context_5.setPrimitiveData(0, "reflectivity_SW", shortwave_rho);
    context_5.setPrimitiveData(1, "reflectivity_SW", shortwave_rho);
 
    uint flag = 0;
    context_5.setPrimitiveData(0, "twosided_flag", flag);
    context_5.setPrimitiveData(1, "twosided_flag", flag);
    context_5.setPrimitiveData(2, "twosided_flag", flag);
    context_5.setPrimitiveData(3, "twosided_flag", flag);
 
    RadiationModel radiationmodel_5 = RadiationModelTestHelper::createWithSharedDevice(&context_5);
    radiationmodel_5.disableMessages();
 
    // Longwave band
    radiationmodel_5.addRadiationBand("LW");
    radiationmodel_5.setDirectRayCount("LW", Ndiffuse_5);
    radiationmodel_5.setDiffuseRayCount("LW", Ndiffuse_5);
    radiationmodel_5.setScatteringDepth("LW", 0);
 
    // Shortwave band
    uint SunSource_5 = radiationmodel_5.addCollimatedRadiationSource(make_vec3(0, 0, 1));
    radiationmodel_5.addRadiationBand("SW");
    radiationmodel_5.disableEmission("SW");
    radiationmodel_5.setDirectRayCount("SW", Ndirect_5);
    radiationmodel_5.setDiffuseRayCount("SW", Ndirect_5);
    radiationmodel_5.setScatteringDepth("SW", 1);
    radiationmodel_5.setSourceFlux(SunSource_5, "SW", Qs);
 
    radiationmodel_5.updateGeometry();
 
    float longwave_model_0 = 0.f;
    float longwave_model_1 = 0.f;
    float shortwave_model_0 = 0.f;
    float shortwave_model_1 = 0.f;
    float R;
 
    for (int i = 0; i < Nensemble; i++) {
        std::vector<std::string> bands{"SW", "LW"};
        radiationmodel_5.runBand(bands);
 
        // patch 0 emission
        context_5.getPrimitiveData(0, "radiation_flux_LW", R);
        longwave_model_0 += 0.5f * R / float(Nensemble);
        context_5.getPrimitiveData(1, "radiation_flux_LW", R);
        longwave_model_0 += 0.5f * R / float(Nensemble);
        // patch 1 emission
        context_5.getPrimitiveData(2, "radiation_flux_LW", R);
        longwave_model_1 += 0.5f * R / float(Nensemble);
        context_5.getPrimitiveData(3, "radiation_flux_LW", R);
        longwave_model_1 += 0.5f * R / float(Nensemble);
 
        // patch 0 shortwave
        context_5.getPrimitiveData(0, "radiation_flux_SW", R);
        shortwave_model_0 += 0.5f * R / float(Nensemble);
        context_5.getPrimitiveData(1, "radiation_flux_SW", R);
        shortwave_model_0 += 0.5f * R / float(Nensemble);
        // patch 1 shortwave
        context_5.getPrimitiveData(2, "radiation_flux_SW", R);
        shortwave_model_1 += 0.5f * R / float(Nensemble);
        context_5.getPrimitiveData(3, "radiation_flux_SW", R);
        shortwave_model_1 += 0.5f * R / float(Nensemble);
    }
 
    float shortwave_error_0 = fabsf(shortwave_model_0 - shortwave_exact_0) / fabsf(shortwave_exact_0);
    float shortwave_error_1 = fabsf(shortwave_model_1 - shortwave_exact_1) / fabsf(shortwave_exact_1);
    float longwave_error_1 = fabsf(longwave_model_1 - longwave_exact_1) / fabsf(longwave_exact_1);
 
    DOCTEST_CHECK(shortwave_error_0 <= error_threshold);
    DOCTEST_CHECK(shortwave_error_1 <= error_threshold);
    // For zero expected value, check direct equality
    DOCTEST_CHECK(longwave_model_0 == longwave_exact_0);
    DOCTEST_CHECK(longwave_error_1 <= error_threshold);
}
 
GPU_TEST_CASE("RadiationModel Parallel Disks Texture Masked Patches") {
    float error_threshold = 0.005;
    int Nensemble = 500;
    float sigma = 5.6703744E-8;
 
    uint Ndirect_6 = 1000;
    uint Ndiffuse_6 = 500000;
 
    float shortwave_rho = 0.3;
 
    float r1 = 1.f;
    float r2 = 0.5f;
    float h = 0.75f;
 
    float A1 = M_PI * r1 * r1;
    float A2 = M_PI * r2 * r2;
 
    float R1 = r1 / h;
    float R2 = r2 / h;
 
    float X = 1.f + (1.f + R2 * R2) / (R1 * R1);
    float F12 = 0.5f * (X - std::sqrt(X * X - 4.f * powf(R2 / R1, 2)));
 
    float shortwave_exact_0 = (A1 - A2) / A1 * (1.f - shortwave_rho);
    float shortwave_exact_1 = (A1 - A2) / A1 * F12 * A1 / A2 * shortwave_rho;
    float longwave_exact_0 = sigma * powf(300.f, 4) * F12;
    float longwave_exact_1 = sigma * powf(300.f, 4) * F12 * A1 / A2;
 
    Context context_6;
 
    context_6.addPatch(make_vec3(0, 0, 0), make_vec2(2.f * r1, 2.f * r1), make_SphericalCoord(0, 0), "plugins/radiation/disk.png");
    context_6.addPatch(make_vec3(0, 0, h), make_vec2(2.f * r2, 2.f * r2), make_SphericalCoord(M_PI, 0), "plugins/radiation/disk.png");
    context_6.addPatch(make_vec3(0, 0, h + 0.01f), make_vec2(2.f * r2, 2.f * r2), make_SphericalCoord(M_PI, 0), "plugins/radiation/disk.png");
 
    context_6.setPrimitiveData(0, "reflectivity_SW", shortwave_rho);
 
    context_6.setPrimitiveData(0, "temperature", 300.f);
    context_6.setPrimitiveData(1, "temperature", 300.f);
 
    uint flag = 0;
    context_6.setPrimitiveData(0, "twosided_flag", flag);
    context_6.setPrimitiveData(1, "twosided_flag", flag);
    context_6.setPrimitiveData(2, "twosided_flag", flag);
 
    RadiationModel radiationmodel_6 = RadiationModelTestHelper::createWithSharedDevice(&context_6);
    radiationmodel_6.disableMessages();
 
    uint SunSource_6 = radiationmodel_6.addCollimatedRadiationSource(make_vec3(0, 0, 1));
 
    // Shortwave band
    radiationmodel_6.addRadiationBand("SW");
    radiationmodel_6.disableEmission("SW");
    radiationmodel_6.setDirectRayCount("SW", Ndirect_6);
    radiationmodel_6.setDiffuseRayCount("SW", Ndiffuse_6);
    radiationmodel_6.setSourceFlux(SunSource_6, "SW", 1.f);
    radiationmodel_6.setDiffuseRadiationFlux("SW", 0);
    radiationmodel_6.setScatteringDepth("SW", 1);
 
    // Longwave band
    radiationmodel_6.addRadiationBand("LW");
    radiationmodel_6.setDiffuseRayCount("LW", Ndiffuse_6);
    radiationmodel_6.setDiffuseRadiationFlux("LW", 0.f);
    radiationmodel_6.setScatteringDepth("LW", 0);
 
    radiationmodel_6.updateGeometry();
 
    float shortwave_model_0 = 0;
    float shortwave_model_1 = 0;
    float longwave_model_0 = 0;
    float longwave_model_1 = 0;
    float R;
 
    for (uint i = 0; i < Nensemble; i++) {
        radiationmodel_6.runBand("SW");
        radiationmodel_6.runBand("LW");
 
        context_6.getPrimitiveData(0, "radiation_flux_SW", R);
        shortwave_model_0 += R / float(Nensemble);
 
        context_6.getPrimitiveData(1, "radiation_flux_SW", R);
        shortwave_model_1 += R / float(Nensemble);
 
        context_6.getPrimitiveData(0, "radiation_flux_LW", R);
        longwave_model_0 += R / float(Nensemble);
 
        context_6.getPrimitiveData(1, "radiation_flux_LW", R);
        longwave_model_1 += R / float(Nensemble);
    }
 
    float shortwave_error_0 = fabsf(shortwave_exact_0 - shortwave_model_0) / fabsf(shortwave_exact_0);
    float shortwave_error_1 = fabsf(shortwave_exact_1 - shortwave_model_1) / fabsf(shortwave_exact_1);
    float longwave_error_0 = fabsf(longwave_exact_0 - longwave_model_0) / fabsf(longwave_exact_0);
    float longwave_error_1 = fabsf(longwave_exact_1 - longwave_model_1) / fabsf(longwave_exact_1);
 
    DOCTEST_CHECK(shortwave_error_0 <= error_threshold);
    DOCTEST_CHECK(shortwave_error_1 <= error_threshold);
    DOCTEST_CHECK(longwave_error_0 <= error_threshold);
    DOCTEST_CHECK(longwave_error_1 <= error_threshold);
}
 
GPU_TEST_CASE("RadiationModel Second Law Equilibrium Test") {
    float error_threshold = 0.005;
    float sigma = 5.6703744E-8;
 
    uint Ndiffuse_7 = 50000;
 
    float eps1_7 = 0.8f;
    float eps2_7 = 1.f;
 
    float T = 300.f;
 
    Context context_7;
 
    uint objID_7 = context_7.addBoxObject(make_vec3(0, 0, 0), make_vec3(10, 10, 10), make_int3(5, 5, 5), RGB::black, true);
    std::vector<uint> UUIDt = context_7.getObjectPrimitiveUUIDs(objID_7);
 
    uint flag = 0;
    context_7.setPrimitiveData(UUIDt, "twosided_flag", flag);
    context_7.setPrimitiveData(UUIDt, "emissivity_LW", eps1_7);
    context_7.setPrimitiveData(UUIDt, "reflectivity_LW", 1.f - eps1_7);
 
    context_7.setPrimitiveData(UUIDt, "temperature", T);
 
    RadiationModel radiationmodel_7 = RadiationModelTestHelper::createWithSharedDevice(&context_7);
    radiationmodel_7.disableMessages();
 
    // Longwave band
    radiationmodel_7.addRadiationBand("LW");
    radiationmodel_7.setDiffuseRayCount("LW", Ndiffuse_7);
    radiationmodel_7.setDiffuseRadiationFlux("LW", 0);
    radiationmodel_7.setScatteringDepth("LW", 5);
 
    radiationmodel_7.updateGeometry();
 
    radiationmodel_7.runBand("LW");
 
    // Test constant emissivity
    float flux_err = 0.f;
    for (int p = 0; p < UUIDt.size(); p++) {
        float R;
        context_7.getPrimitiveData(UUIDt.at(p), "radiation_flux_LW", R);
        flux_err += fabsf(R - eps1_7 * sigma * powf(300, 4)) / (eps1_7 * sigma * powf(300, 4)) / float(UUIDt.size());
    }
 
    DOCTEST_CHECK(flux_err <= error_threshold);
 
    // Test random emissivity distribution
    for (uint p: UUIDt) {
        float emissivity;
        if (context_7.randu() < 0.5f) {
            emissivity = eps1_7;
        } else {
            emissivity = eps2_7;
        }
        context_7.setPrimitiveData(p, "emissivity_LW", emissivity);
        context_7.setPrimitiveData(p, "reflectivity_LW", 1.f - emissivity);
    }
 
    radiationmodel_7.updateGeometry();
    radiationmodel_7.runBand("LW");
 
    flux_err = 0.f;
    for (int p = 0; p < UUIDt.size(); p++) {
        float R;
        context_7.getPrimitiveData(UUIDt.at(p), "radiation_flux_LW", R);
        float emissivity;
        context_7.getPrimitiveData(UUIDt.at(p), "emissivity_LW", emissivity);
        flux_err += fabsf(R - emissivity * sigma * powf(300, 4)) / (emissivity * sigma * powf(300, 4)) / float(UUIDt.size());
    }
 
    DOCTEST_CHECK(flux_err <= error_threshold);
}
 
GPU_TEST_CASE("RadiationModel Texture Mapping") {
    float error_threshold = 0.005;
 
    Context context_8;
 
    RadiationModel radiation = RadiationModelTestHelper::createWithSharedDevice(&context_8);
 
    uint source = radiation.addCollimatedRadiationSource(make_vec3(0, 0, 1));
 
    radiation.addRadiationBand("SW");
 
    radiation.setDirectRayCount("SW", 10000);
    radiation.disableEmission("SW");
    radiation.disableMessages();
 
    radiation.setSourceFlux(source, "SW", 1.f);
 
    vec2 sz(4, 2);
 
    vec3 p0(3, 4, 2);
 
    vec3 p1 = p0 + make_vec3(0, 0, 2.4);
 
    // 8a: texture-mapped ellipse patch above rectangle
    uint UUID0 = context_8.addPatch(p0, sz);
    uint UUID1 = context_8.addPatch(p1, sz, make_SphericalCoord(0, 0), "lib/images/disk_texture.png");
 
    radiation.updateGeometry();
 
    radiation.runBand("SW");
 
    float F0, F1;
    context_8.getPrimitiveData(UUID0, "radiation_flux_SW", F0);
    context_8.getPrimitiveData(UUID1, "radiation_flux_SW", F1);
 
    DOCTEST_CHECK(fabs(F0 - (1.f - 0.25f * M_PI)) <= error_threshold);
    DOCTEST_CHECK(fabsf(F1 - 1.f) <= error_threshold);
 
    // 8b: texture-mapped (u,v) inscribed ellipse tile object above rectangle
    context_8.deletePrimitive(UUID1);
 
    uint objID_8 = context_8.addTileObject(p1, sz, make_SphericalCoord(0, 0), make_int2(5, 4), "lib/images/disk_texture.png");
    std::vector<uint> UUIDs1 = context_8.getObjectPrimitiveUUIDs(objID_8);
 
    radiation.updateGeometry();
 
    radiation.runBand("SW");
 
    context_8.getPrimitiveData(UUID0, "radiation_flux_SW", F0);
 
    F1 = 0;
    float A = 0;
    for (uint p: UUIDs1) {
 
        float area = context_8.getPrimitiveArea(p);
        A += area;
 
        float Rflux;
        context_8.getPrimitiveData(p, "radiation_flux_SW", Rflux);
        F1 += Rflux * area;
    }
    F1 = F1 / A;
 
    bool test_8b_pass = true;
    for (uint p = 0; p < UUIDs1.size(); p++) {
        float R;
        context_8.getPrimitiveData(UUIDs1.at(p), "radiation_flux_SW", R);
        if (fabs(R - 1.f) > error_threshold) {
            test_8b_pass = false;
        }
    }
 
    DOCTEST_CHECK(fabs(F0 - (1.f - 0.25f * M_PI)) <= error_threshold);
    DOCTEST_CHECK(fabsf(F1 - 1.f) <= error_threshold);
    DOCTEST_CHECK(test_8b_pass);
 
    context_8.deleteObject(objID_8);
 
    // 8c: texture-mapped (u,v) inscribed ellipse patch above rectangle
    UUID1 = context_8.addPatch(p1, sz, make_SphericalCoord(0, 0), "lib/images/disk_texture.png", make_vec2(0.5, 0.5), make_vec2(0.5, 0.5));
 
    radiation.updateGeometry();
 
    radiation.runBand("SW");
 
    context_8.getPrimitiveData(UUID0, "radiation_flux_SW", F0);
    context_8.getPrimitiveData(UUID1, "radiation_flux_SW", F1);
 
    DOCTEST_CHECK(fabsf(F0) <= error_threshold);
    DOCTEST_CHECK(fabsf(F1 - 1.f) <= error_threshold);
 
    // 8d: texture-mapped (u,v) quarter ellipse patch above rectangle
    context_8.deletePrimitive(UUID1);
 
    UUID1 = context_8.addPatch(p1, sz, make_SphericalCoord(0, 0), "lib/images/disk_texture.png", make_vec2(0.5, 0.5), make_vec2(1, 1));
 
    radiation.updateGeometry();
 
    radiation.runBand("SW");
 
    context_8.getPrimitiveData(UUID0, "radiation_flux_SW", F0);
    context_8.getPrimitiveData(UUID1, "radiation_flux_SW", F1);
 
    DOCTEST_CHECK(fabs(F0 - (1.f - 0.25f * M_PI)) <= error_threshold);
    DOCTEST_CHECK(fabsf(F1 - 1.f) <= error_threshold);
 
    // 8e: texture-mapped (u,v) half ellipse triangle above rectangle
    context_8.deletePrimitive(UUID1);
 
    UUID1 = context_8.addTriangle(p1 + make_vec3(-0.5f * sz.x, -0.5f * sz.y, 0), p1 + make_vec3(0.5f * sz.x, 0.5f * sz.y, 0.f), p1 + make_vec3(-0.5f * sz.x, 0.5f * sz.y, 0.f), "lib/images/disk_texture.png", make_vec2(0, 0), make_vec2(1, 1),
                                  make_vec2(0, 1));
 
    radiation.updateGeometry();
 
    radiation.runBand("SW");
 
    context_8.getPrimitiveData(UUID0, "radiation_flux_SW", F0);
    context_8.getPrimitiveData(UUID1, "radiation_flux_SW", F1);
 
    DOCTEST_CHECK(fabs(F0 - 0.5 - 0.5 * (1.f - 0.25f * M_PI)) <= error_threshold);
    DOCTEST_CHECK(fabsf(F1 - 1.f) <= error_threshold);
 
    // 8f: texture-mapped (u,v) two ellipse triangles above ellipse patch
    context_8.deletePrimitive(UUID0);
 
    UUID0 = context_8.addPatch(p0, sz, make_SphericalCoord(0, 0), "lib/images/disk_texture.png");
 
    uint UUID2 = context_8.addTriangle(p1 + make_vec3(-0.5f * sz.x, -0.5f * sz.y, 0), p1 + make_vec3(0.5f * sz.x, -0.5f * sz.y, 0), p1 + make_vec3(0.5f * sz.x, 0.5f * sz.y, 0), "lib/images/disk_texture.png", make_vec2(0, 0), make_vec2(1, 0),
                                       make_vec2(1, 1));
 
    radiation.updateGeometry();
 
    radiation.runBand("SW");
 
    float F2;
    context_8.getPrimitiveData(UUID0, "radiation_flux_SW", F0);
    context_8.getPrimitiveData(UUID1, "radiation_flux_SW", F1);
    context_8.getPrimitiveData(UUID2, "radiation_flux_SW", F2);
 
    DOCTEST_CHECK(fabsf(F0) <= error_threshold);
    DOCTEST_CHECK(fabsf(F1 - 1.f) <= error_threshold);
    DOCTEST_CHECK(fabsf(F2 - 1.f) <= error_threshold);
 
    // 8g: texture-mapped (u,v) ellipse patch above two ellipse triangles
    context_8.deletePrimitive(UUID0);
    context_8.deletePrimitive(UUID1);
    context_8.deletePrimitive(UUID2);
 
    UUID0 = context_8.addPatch(p1, sz, make_SphericalCoord(0, 0), "lib/images/disk_texture.png");
 
    UUID1 = context_8.addTriangle(p0 + make_vec3(-0.5f * sz.x, -0.5f * sz.y, 0), p0 + make_vec3(0.5f * sz.x, 0.5f * sz.y, 0), p0 + make_vec3(-0.5f * sz.x, 0.5f * sz.y, 0), "lib/images/disk_texture.png", make_vec2(0, 0), make_vec2(1, 1),
                                  make_vec2(0, 1));
    UUID2 = context_8.addTriangle(p0 + make_vec3(-0.5f * sz.x, -0.5f * sz.y, 0), p0 + make_vec3(0.5f * sz.x, -0.5f * sz.y, 0), p0 + make_vec3(0.5f * sz.x, 0.5f * sz.y, 0), "lib/images/disk_texture.png", make_vec2(0, 0), make_vec2(1, 0),
                                  make_vec2(1, 1));
 
    radiation.updateGeometry();
 
    radiation.runBand("SW");
 
    context_8.getPrimitiveData(UUID0, "radiation_flux_SW", F0);
    context_8.getPrimitiveData(UUID1, "radiation_flux_SW", F1);
    context_8.getPrimitiveData(UUID2, "radiation_flux_SW", F2);
 
    DOCTEST_CHECK(fabsf(F1) <= error_threshold);
    DOCTEST_CHECK(fabsf(F2) <= error_threshold);
    DOCTEST_CHECK(fabsf(F0 - 1.f) <= error_threshold);
}
 
GPU_TEST_CASE("RadiationModel Homogeneous Canopy of Patches") {
    float error_threshold = 0.005;
    float sigma = 5.6703744E-8;
 
    uint Ndirect_9 = 1000;
    uint Ndiffuse_9 = 5000;
 
    float D_9 = 50; // domain width
    float D_inc_9 = 40; // domain size to include in calculations
    float LAI_9 = 2.0; // canopy leaf area index
    float h_9 = 3; // canopy height
    float w_leaf_9 = 0.075; // leaf width
 
    int Nleaves = (int) lroundf(LAI_9 * D_9 * D_9 / w_leaf_9 / w_leaf_9);
 
    Context context_9;
 
    std::vector<uint> UUIDs_leaf, UUIDs_inc;
 
    for (int i = 0; i < Nleaves; i++) {
        vec3 position((-0.5f + context_9.randu()) * D_9, (-0.5f + context_9.randu()) * D_9, 0.5f * w_leaf_9 + context_9.randu() * h_9);
        SphericalCoord rotation(1.f, acos_safe(1.f - context_9.randu()), 2.f * float(M_PI) * context_9.randu());
        uint UUID = context_9.addPatch(position, make_vec2(w_leaf_9, w_leaf_9), rotation);
        context_9.setPrimitiveData(UUID, "twosided_flag", uint(1));
        if (fabsf(position.x) <= 0.5 * D_inc_9 && fabsf(position.y) <= 0.5 * D_inc_9) {
            UUIDs_inc.push_back(UUID);
        }
    }
 
    std::vector<uint> UUIDs_ground = context_9.addTile(make_vec3(0, 0, 0), make_vec2(D_9, D_9), make_SphericalCoord(0, 0), make_int2(100, 100));
    context_9.setPrimitiveData(UUIDs_ground, "twosided_flag", uint(0));
 
    RadiationModel radiation_9 = RadiationModelTestHelper::createWithSharedDevice(&context_9);
    radiation_9.disableMessages();
 
    radiation_9.addRadiationBand("direct");
    radiation_9.disableEmission("direct");
    radiation_9.setDirectRayCount("direct", Ndirect_9);
    float theta_s = 0.2 * M_PI;
    uint ID = radiation_9.addSunSphereRadiationSource(make_SphericalCoord(0.5f * float(M_PI) - theta_s, 0.f));
    radiation_9.setSourceFlux(ID, "direct", 1.f / cosf(theta_s));
 
    radiation_9.addRadiationBand("diffuse");
    radiation_9.disableEmission("diffuse");
    radiation_9.setDiffuseRayCount("diffuse", Ndiffuse_9);
    radiation_9.setDiffuseRadiationFlux("diffuse", 1.f);
 
    radiation_9.updateGeometry();
 
    radiation_9.runBand("direct");
    radiation_9.runBand("diffuse");
 
    float intercepted_leaf_direct = 0.f;
    float intercepted_leaf_diffuse = 0.f;
    for (uint i: UUIDs_inc) {
        float area = context_9.getPrimitiveArea(i);
        float flux;
        context_9.getPrimitiveData(i, "radiation_flux_direct", flux);
        intercepted_leaf_direct += flux * area / D_inc_9 / D_inc_9;
        context_9.getPrimitiveData(i, "radiation_flux_diffuse", flux);
        intercepted_leaf_diffuse += flux * area / D_inc_9 / D_inc_9;
    }
 
    float intercepted_ground_direct = 0.f;
    float intercepted_ground_diffuse = 0.f;
    for (uint i: UUIDs_ground) {
        float area = context_9.getPrimitiveArea(i);
        float flux_dir;
        context_9.getPrimitiveData(i, "radiation_flux_direct", flux_dir);
        float flux_diff;
        context_9.getPrimitiveData(i, "radiation_flux_diffuse", flux_diff);
        vec3 position = context_9.getPatchCenter(i);
        if (fabsf(position.x) <= 0.5 * D_inc_9 && fabsf(position.y) <= 0.5 * D_inc_9) {
            intercepted_ground_direct += flux_dir * area / D_inc_9 / D_inc_9;
            intercepted_ground_diffuse += flux_diff * area / D_inc_9 / D_inc_9;
        }
    }
 
    intercepted_ground_direct = 1.f - intercepted_ground_direct;
    intercepted_ground_diffuse = 1.f - intercepted_ground_diffuse;
 
    int N = 50;
    float dtheta = 0.5f * float(M_PI) / float(N);
 
    float intercepted_theoretical_diffuse = 0.f;
    for (int i = 0; i < N; i++) {
        float theta = (float(i) + 0.5f) * dtheta;
        intercepted_theoretical_diffuse += 2.f * (1.f - expf(-0.5f * LAI_9 / cosf(theta))) * cosf(theta) * sinf(theta) * dtheta;
    }
 
    float intercepted_theoretical_direct = 1.f - expf(-0.5f * LAI_9 / cosf(theta_s));
 
    DOCTEST_CHECK(fabsf(intercepted_ground_direct - intercepted_theoretical_direct) <= 2.f * error_threshold);
    DOCTEST_CHECK(fabsf(intercepted_leaf_direct - intercepted_theoretical_direct) <= 2.f * error_threshold);
    DOCTEST_CHECK(fabsf(intercepted_ground_diffuse - intercepted_theoretical_diffuse) <= 2.f * error_threshold);
    DOCTEST_CHECK(fabsf(intercepted_leaf_diffuse - intercepted_theoretical_diffuse) <= 2.f * error_threshold);
}
 
GPU_TEST_CASE("RadiationModel Gas-filled Furnace") {
    float error_threshold = 0.005;
    float sigma = 5.6703744E-8;
 
    float Rref_10 = 33000.f;
    uint Ndiffuse_10 = 10000;
 
    float w_10 = 1.f; // width of box (y-dir)
    float h_10 = 1.f; // height of box (z-dir)
    float d_10 = 3.f; // depth of box (x-dir)
 
    float Tw_10 = 1273.f; // temperature of walls (K)
    float Tm_10 = 1773.f; // temperature of medium (K)
 
    float kappa_10 = 0.1f; // attenuation coefficient of medium (1/m)
    float eps_m_10 = 1.f; // emissivity of medium
    float w_patch_10 = 0.01;
 
    int Npatches_10 = (int) lroundf(2.f * kappa_10 * w_10 * h_10 * d_10 / w_patch_10 / w_patch_10);
 
    Context context_10;
 
    std::vector<uint> UUIDs_box = context_10.addBox(make_vec3(0, 0, 0), make_vec3(d_10, w_10, h_10), make_int3(round(d_10 / w_patch_10), round(w_10 / w_patch_10), round(h_10 / w_patch_10)), RGB::green, true);
 
    context_10.setPrimitiveData(UUIDs_box, "temperature", Tw_10);
    context_10.setPrimitiveData(UUIDs_box, "twosided_flag", uint(0));
 
    std::vector<uint> UUIDs_patches;
 
    for (int i = 0; i < Npatches_10; i++) {
        float x = -0.5f * d_10 + 0.5f * w_patch_10 + (d_10 - 2 * w_patch_10) * context_10.randu();
        float y = -0.5f * w_10 + 0.5f * w_patch_10 + (w_10 - 2 * w_patch_10) * context_10.randu();
        float z = -0.5f * h_10 + 0.5f * w_patch_10 + (h_10 - 2 * w_patch_10) * context_10.randu();
 
        float theta = acosf(1.f - context_10.randu());
        float phi = 2.f * float(M_PI) * context_10.randu();
 
        UUIDs_patches.push_back(context_10.addPatch(make_vec3(x, y, z), make_vec2(w_patch_10, w_patch_10), make_SphericalCoord(theta, phi)));
    }
    context_10.setPrimitiveData(UUIDs_patches, "temperature", Tm_10);
    context_10.setPrimitiveData(UUIDs_patches, "emissivity_LW", eps_m_10);
    context_10.setPrimitiveData(UUIDs_patches, "reflectivity_LW", 1.f - eps_m_10);
 
    RadiationModel radiation_10 = RadiationModelTestHelper::createWithSharedDevice(&context_10);
    radiation_10.disableMessages();
 
    radiation_10.addRadiationBand("LW");
    radiation_10.setDiffuseRayCount("LW", Ndiffuse_10);
    radiation_10.setScatteringDepth("LW", 0);
 
    radiation_10.updateGeometry();
    radiation_10.runBand("LW");
 
    float R_wall = 0;
    float A_wall = 0.f;
    for (uint i: UUIDs_box) {
        float area = context_10.getPrimitiveArea(i);
        float flux;
        context_10.getPrimitiveData(i, "radiation_flux_LW", flux);
        A_wall += area;
        R_wall += flux * area;
    }
    R_wall = R_wall / A_wall - sigma * powf(Tw_10, 4);
 
    DOCTEST_CHECK(fabsf(R_wall - Rref_10) / Rref_10 <= error_threshold);
}
 
GPU_TEST_CASE("RadiationModel Purely Scattering Medium Between Infinite Plates") {
    float error_threshold = 0.005;
    float sigma = 5.6703744E-8;
 
    float W_11 = 10.f; // width of entire slab in x and y directions
    float w_11 = 5.f; // width of slab to be considered in calculations
    float h_11 = 1.f; // height of slab
 
    float Tw1_11 = 300.f; // temperature of upper wall (K)
    float Tw2_11 = 400.f; // temperature of lower wall (K)
 
    float epsw1_11 = 0.8f; // emissivity of upper wall
    float epsw2_11 = 0.5f; // emissivity of lower wall
 
    float omega_11 = 1.f; // single-scatter albedo
    float tauL_11 = 0.1f; // optical depth of slab
 
    float Psi2_exact = 0.427; // exact non-dimensional heat flux of lower plate
 
    float w_patch_11 = 0.05; // width of medium patches
 
    float beta = tauL_11 / h_11; // attenuation coefficient
 
    int Nleaves_11 = (int) lroundf(2.f * beta * W_11 * W_11 * h_11 / w_patch_11 / w_patch_11);
 
    Context context_11;
 
    // top wall
    std::vector<uint> UUIDs_1 = context_11.addTile(make_vec3(0, 0, 0.5f * h_11), make_vec2(W_11, W_11), make_SphericalCoord(M_PI, 0), make_int2(round(W_11 / w_patch_11 / 5), round(W_11 / w_patch_11 / 5)));
 
    // bottom wall
    std::vector<uint> UUIDs_2 = context_11.addTile(make_vec3(0, 0, -0.5f * h_11), make_vec2(W_11, W_11), make_SphericalCoord(0, 0), make_int2(round(W_11 / w_patch_11 / 5), round(W_11 / w_patch_11 / 5)));
 
    context_11.setPrimitiveData(UUIDs_1, "temperature", Tw1_11);
    context_11.setPrimitiveData(UUIDs_2, "temperature", Tw2_11);
    context_11.setPrimitiveData(UUIDs_1, "emissivity_LW", epsw1_11);
    context_11.setPrimitiveData(UUIDs_2, "emissivity_LW", epsw2_11);
    context_11.setPrimitiveData(UUIDs_1, "reflectivity_LW", 1.f - epsw1_11);
    context_11.setPrimitiveData(UUIDs_2, "reflectivity_LW", 1.f - epsw2_11);
    context_11.setPrimitiveData(UUIDs_1, "twosided_flag", uint(0));
    context_11.setPrimitiveData(UUIDs_2, "twosided_flag", uint(0));
 
    std::vector<uint> UUIDs_patches_11;
 
    for (int i = 0; i < Nleaves_11; i++) {
        float x = -0.5f * W_11 + 0.5f * w_patch_11 + (W_11 - w_patch_11) * context_11.randu();
        float y = -0.5f * W_11 + 0.5f * w_patch_11 + (W_11 - w_patch_11) * context_11.randu();
        float z = -0.5f * h_11 + 0.5f * w_patch_11 + (h_11 - w_patch_11) * context_11.randu();
 
        float theta = acosf(1.f - context_11.randu());
        float phi = 2.f * float(M_PI) * context_11.randu();
 
        UUIDs_patches_11.push_back(context_11.addPatch(make_vec3(x, y, z), make_vec2(w_patch_11, w_patch_11), make_SphericalCoord(theta, phi)));
    }
    context_11.setPrimitiveData(UUIDs_patches_11, "temperature", 0.f);
    context_11.setPrimitiveData(UUIDs_patches_11, "emissivity_LW", 1.f - omega_11);
    context_11.setPrimitiveData(UUIDs_patches_11, "reflectivity_LW", omega_11);
 
    RadiationModel radiation_11 = RadiationModelTestHelper::createWithSharedDevice(&context_11);
    radiation_11.disableMessages();
 
    radiation_11.addRadiationBand("LW");
    radiation_11.setDiffuseRayCount("LW", 10000);
    radiation_11.setScatteringDepth("LW", 4);
 
    radiation_11.updateGeometry();
    radiation_11.runBand("LW");
 
    float R_wall2 = 0;
    float A_wall2 = 0.f;
    for (int i = 0; i < UUIDs_1.size(); i++) {
        vec3 position = context_11.getPatchCenter(UUIDs_1.at(i));
 
        if (fabsf(position.x) < 0.5 * w_11 && fabsf(position.y) < 0.5 * w_11) {
            float area = context_11.getPrimitiveArea(UUIDs_1.at(i));
 
            float flux;
            context_11.getPrimitiveData(UUIDs_2.at(i), "radiation_flux_LW", flux);
            R_wall2 += flux * area;
 
            A_wall2 += area;
        }
    }
    R_wall2 = (R_wall2 / A_wall2 - epsw2_11 * sigma * pow(Tw2_11, 4)) / (sigma * (pow(Tw1_11, 4) - pow(Tw2_11, 4)));
 
    DOCTEST_CHECK(fabsf(R_wall2 - Psi2_exact) <= 10.f * error_threshold);
}
 
GPU_TEST_CASE("RadiationModel Homogeneous Canopy with Periodic Boundaries") {
    float error_threshold = 0.005;
 
    uint Ndirect_12 = 1000;
    uint Ndiffuse_12 = 5000;
 
    float D_12 = 20; // domain width
    float LAI_12 = 2.0; // canopy leaf area index
    float h_12 = 3; // canopy height
    float w_leaf_12 = 0.05; // leaf width
 
    int Nleaves_12 = round(LAI_12 * D_12 * D_12 / w_leaf_12 / w_leaf_12);
 
    Context context_12;
 
    std::vector<uint> UUIDs_leaf_12;
 
    for (int i = 0; i < Nleaves_12; i++) {
        vec3 position((-0.5 + context_12.randu()) * D_12, (-0.5 + context_12.randu()) * D_12, 0.5 * w_leaf_12 + context_12.randu() * h_12);
        SphericalCoord rotation(1.f, acos(1.f - context_12.randu()), 2.f * M_PI * context_12.randu());
        uint UUID = context_12.addPatch(position, make_vec2(w_leaf_12, w_leaf_12), rotation);
        context_12.setPrimitiveData(UUID, "twosided_flag", uint(1));
        UUIDs_leaf_12.push_back(UUID);
    }
 
    std::vector<uint> UUIDs_ground_12 = context_12.addTile(make_vec3(0, 0, 0), make_vec2(D_12, D_12), make_SphericalCoord(0, 0), make_int2(100, 100));
    context_12.setPrimitiveData(UUIDs_ground_12, "twosided_flag", uint(0));
 
    RadiationModel radiation_12 = RadiationModelTestHelper::createWithSharedDevice(&context_12);
    radiation_12.disableMessages();
 
    radiation_12.addRadiationBand("direct");
    radiation_12.disableEmission("direct");
    radiation_12.setDirectRayCount("direct", Ndirect_12);
    float theta_s = 0.2 * M_PI;
    uint ID = radiation_12.addCollimatedRadiationSource(make_SphericalCoord(0.5 * M_PI - theta_s, 0.f));
    radiation_12.setSourceFlux(ID, "direct", 1.f / cos(theta_s));
 
    radiation_12.addRadiationBand("diffuse");
    radiation_12.disableEmission("diffuse");
    radiation_12.setDiffuseRayCount("diffuse", Ndiffuse_12);
    radiation_12.setDiffuseRadiationFlux("diffuse", 1.f);
 
    radiation_12.enforcePeriodicBoundary("xy");
 
    radiation_12.updateGeometry();
 
    radiation_12.runBand("direct");
    radiation_12.runBand("diffuse");
 
    float intercepted_leaf_direct_12 = 0.f;
    float intercepted_leaf_diffuse_12 = 0.f;
    for (int i = 0; i < UUIDs_leaf_12.size(); i++) {
        float area = context_12.getPrimitiveArea(UUIDs_leaf_12.at(i));
        float flux;
        context_12.getPrimitiveData(UUIDs_leaf_12.at(i), "radiation_flux_direct", flux);
        intercepted_leaf_direct_12 += flux * area / D_12 / D_12;
        context_12.getPrimitiveData(UUIDs_leaf_12.at(i), "radiation_flux_diffuse", flux);
        intercepted_leaf_diffuse_12 += flux * area / D_12 / D_12;
    }
 
    float intercepted_ground_direct_12 = 0.f;
    float intercepted_ground_diffuse_12 = 0.f;
    for (int i = 0; i < UUIDs_ground_12.size(); i++) {
        float area = context_12.getPrimitiveArea(UUIDs_ground_12.at(i));
        float flux_dir;
        context_12.getPrimitiveData(UUIDs_ground_12.at(i), "radiation_flux_direct", flux_dir);
        float flux_diff;
        context_12.getPrimitiveData(UUIDs_ground_12.at(i), "radiation_flux_diffuse", flux_diff);
        vec3 position = context_12.getPatchCenter(UUIDs_ground_12.at(i));
        intercepted_ground_direct_12 += flux_dir * area / D_12 / D_12;
        intercepted_ground_diffuse_12 += flux_diff * area / D_12 / D_12;
    }
 
    intercepted_ground_direct_12 = 1.f - intercepted_ground_direct_12;
    intercepted_ground_diffuse_12 = 1.f - intercepted_ground_diffuse_12;
 
    int N = 50;
    float dtheta = 0.5 * M_PI / float(N);
 
    float intercepted_theoretical_diffuse_12 = 0.f;
    for (int i = 0; i < N; i++) {
        float theta = (i + 0.5f) * dtheta;
        intercepted_theoretical_diffuse_12 += 2.f * (1.f - exp(-0.5 * LAI_12 / cos(theta))) * cos(theta) * sin(theta) * dtheta;
    }
 
    float intercepted_theoretical_direct_12 = 1.f - exp(-0.5 * LAI_12 / cos(theta_s));
 
    DOCTEST_CHECK(fabsf(intercepted_ground_direct_12 - intercepted_theoretical_direct_12) <= 2.f * error_threshold);
    DOCTEST_CHECK(fabsf(intercepted_leaf_direct_12 - intercepted_theoretical_direct_12) <= 2.f * error_threshold);
    DOCTEST_CHECK(fabsf(intercepted_ground_diffuse_12 - intercepted_theoretical_diffuse_12) <= 2.f * error_threshold);
    DOCTEST_CHECK(fabsf(intercepted_leaf_diffuse_12 - intercepted_theoretical_diffuse_12) <= 2.f * error_threshold);
}
 
GPU_TEST_CASE("RayTracingGeometry validation with periodic boundaries") {
    // Minimal scene with periodic boundaries to exercise validate() with bbox_count > 0.
    // Before fix, validate() checked shared arrays against primitive_count + bbox_count,
    // but buildGeometryData() only populates them with primitive_count entries.
    Context context;
    context.addPatch(make_vec3(0, 0, 1), make_vec2(1, 1));
    context.addPatch(make_vec3(1, 0, 1), make_vec2(1, 1));
 
    RadiationModel radiation = RadiationModelTestHelper::createWithSharedDevice(&context);
    radiation.disableMessages();
    radiation.addRadiationBand("PAR");
    radiation.disableEmission("PAR");
    radiation.setDiffuseRayCount("PAR", 100);
    radiation.setScatteringDepth("PAR", 0);
    radiation.enforcePeriodicBoundary("xy");
 
    // updateGeometry() calls validateGeometryBeforeUpload() → validate()
    // This crashed in Debug builds before the fix due to bbox_count size mismatch
    radiation.updateGeometry();
 
    DOCTEST_CHECK(true);
}
 
GPU_TEST_CASE("RadiationModel Texture-masked Tile Objects with Periodic Boundaries") {
    float error_threshold = 0.005;
 
    uint Ndirect_13 = 1000;
    uint Ndiffuse_13 = 5000;
 
    float D_13 = 20; // domain width
    float LAI_13 = 1.0; // canopy leaf area index
    float h_13 = 3; // canopy height
    float w_leaf_13 = 0.05; // leaf width
 
    Context context_13;
 
    uint objID_ptype = context_13.addTileObject(make_vec3(0, 0, 0), make_vec2(w_leaf_13, w_leaf_13), make_SphericalCoord(0, 0), make_int2(2, 2), "plugins/radiation/disk.png");
    std::vector<uint> UUIDs_ptype = context_13.getObjectPrimitiveUUIDs(objID_ptype);
 
    float A_leaf = 0;
    for (uint p = 0; p < UUIDs_ptype.size(); p++) {
        A_leaf += context_13.getPrimitiveArea(UUIDs_ptype.at(p));
    }
 
    int Nleaves_13 = round(LAI_13 * D_13 * D_13 / A_leaf);
 
    std::vector<uint> UUIDs_leaf_13;
 
    for (int i = 0; i < Nleaves_13; i++) {
        vec3 position((-0.5 + context_13.randu()) * D_13, (-0.5 + context_13.randu()) * D_13, 0.5 * w_leaf_13 + context_13.randu() * h_13);
        SphericalCoord rotation(1.f, acos(1.f - context_13.randu()), 2.f * M_PI * context_13.randu());
 
        uint objID = context_13.copyObject(objID_ptype);
 
        context_13.rotateObject(objID, -rotation.elevation, "y");
        context_13.rotateObject(objID, rotation.azimuth, "z");
        context_13.translateObject(objID, position);
 
        std::vector<uint> UUIDs = context_13.getObjectPrimitiveUUIDs(objID);
        UUIDs_leaf_13.insert(UUIDs_leaf_13.end(), UUIDs.begin(), UUIDs.end());
    }
 
    context_13.deleteObject(objID_ptype);
 
    std::vector<uint> UUIDs_ground_13 = context_13.addTile(make_vec3(0, 0, 0), make_vec2(D_13, D_13), make_SphericalCoord(0, 0), make_int2(100, 100));
    context_13.setPrimitiveData(UUIDs_ground_13, "twosided_flag", uint(0));
 
    RadiationModel radiation_13 = RadiationModelTestHelper::createWithSharedDevice(&context_13);
    radiation_13.disableMessages();
 
    radiation_13.addRadiationBand("direct");
    radiation_13.disableEmission("direct");
    radiation_13.setDirectRayCount("direct", Ndirect_13);
    float theta_s = 0.2 * M_PI;
    uint ID = radiation_13.addCollimatedRadiationSource(make_SphericalCoord(0.5 * M_PI - theta_s, 0.f));
    radiation_13.setSourceFlux(ID, "direct", 1.f / cos(theta_s));
 
    radiation_13.addRadiationBand("diffuse");
    radiation_13.disableEmission("diffuse");
    radiation_13.setDiffuseRayCount("diffuse", Ndiffuse_13);
    radiation_13.setDiffuseRadiationFlux("diffuse", 1.f);
 
    radiation_13.enforcePeriodicBoundary("xy");
 
    radiation_13.updateGeometry();
 
    radiation_13.runBand("direct");
    radiation_13.runBand("diffuse");
 
    float intercepted_leaf_direct_13 = 0.f;
    float intercepted_leaf_diffuse_13 = 0.f;
    for (int i = 0; i < UUIDs_leaf_13.size(); i++) {
        float area = context_13.getPrimitiveArea(UUIDs_leaf_13.at(i));
        float flux;
        context_13.getPrimitiveData(UUIDs_leaf_13.at(i), "radiation_flux_direct", flux);
        intercepted_leaf_direct_13 += flux * area / D_13 / D_13;
        context_13.getPrimitiveData(UUIDs_leaf_13.at(i), "radiation_flux_diffuse", flux);
        intercepted_leaf_diffuse_13 += flux * area / D_13 / D_13;
    }
 
    float intercepted_ground_direct_13 = 0.f;
    float intercepted_ground_diffuse_13 = 0.f;
    for (int i = 0; i < UUIDs_ground_13.size(); i++) {
        float area = context_13.getPrimitiveArea(UUIDs_ground_13.at(i));
        float flux_dir;
        context_13.getPrimitiveData(UUIDs_ground_13.at(i), "radiation_flux_direct", flux_dir);
        float flux_diff;
        context_13.getPrimitiveData(UUIDs_ground_13.at(i), "radiation_flux_diffuse", flux_diff);
        vec3 position = context_13.getPatchCenter(UUIDs_ground_13.at(i));
        intercepted_ground_direct_13 += flux_dir * area / D_13 / D_13;
        intercepted_ground_diffuse_13 += flux_diff * area / D_13 / D_13;
    }
 
    intercepted_ground_direct_13 = 1.f - intercepted_ground_direct_13;
    intercepted_ground_diffuse_13 = 1.f - intercepted_ground_diffuse_13;
 
    int N = 50;
    float dtheta = 0.5 * M_PI / float(N);
 
    float intercepted_theoretical_diffuse_13 = 0.f;
    for (int i = 0; i < N; i++) {
        float theta = (i + 0.5f) * dtheta;
        intercepted_theoretical_diffuse_13 += 2.f * (1.f - exp(-0.5 * LAI_13 / cos(theta))) * cos(theta) * sin(theta) * dtheta;
    }
 
    float intercepted_theoretical_direct_13 = 1.f - exp(-0.5 * LAI_13 / cos(theta_s));
 
    DOCTEST_CHECK(fabsf(intercepted_ground_direct_13 - intercepted_theoretical_direct_13) <= 2.f * error_threshold);
    DOCTEST_CHECK(fabsf(intercepted_leaf_direct_13 - intercepted_theoretical_direct_13) <= 2.f * error_threshold);
    DOCTEST_CHECK(fabsf(intercepted_ground_diffuse_13 - intercepted_theoretical_diffuse_13) <= 2.f * error_threshold);
    DOCTEST_CHECK(fabsf(intercepted_leaf_diffuse_13 - intercepted_theoretical_diffuse_13) <= 4.f * error_threshold);
}
 
GPU_TEST_CASE("RadiationModel Anisotropic Diffuse Radiation Horizontal Patch") {
    float error_threshold = 0.005;
 
    uint Ndiffuse_14 = 50000;
 
    Context context_14;
 
    std::vector<float> K_14;
    K_14.push_back(0.f);
    K_14.push_back(0.25f);
    K_14.push_back(1.f);
 
    std::vector<float> thetas_14;
    thetas_14.push_back(0.f);
    thetas_14.push_back(0.25 * M_PI);
 
    uint UUID_14 = context_14.addPatch();
    context_14.setPrimitiveData(UUID_14, "twosided_flag", uint(0));
 
    RadiationModel radiation_14 = RadiationModelTestHelper::createWithSharedDevice(&context_14);
    radiation_14.disableMessages();
 
    radiation_14.addRadiationBand("diffuse");
    radiation_14.disableEmission("diffuse");
    radiation_14.setDiffuseRayCount("diffuse", Ndiffuse_14);
    radiation_14.setDiffuseRadiationFlux("diffuse", 1.f);
 
    radiation_14.updateGeometry();
 
    for (int t = 0; t < thetas_14.size(); t++) {
        for (int k = 0; k < K_14.size(); k++) {
            radiation_14.setDiffuseRadiationExtinctionCoeff("diffuse", K_14.at(k), make_SphericalCoord(0.5 * M_PI - thetas_14.at(t), 0.f));
            radiation_14.runBand("diffuse");
 
            float Rdiff;
            context_14.getPrimitiveData(UUID_14, "radiation_flux_diffuse", Rdiff);
 
            DOCTEST_CHECK(fabsf(Rdiff - 1.f) <= 2.f * error_threshold);
        }
    }
}
 
GPU_TEST_CASE("RadiationModel Prague Sky Diffuse Radiation Normalization") {
    float error_threshold = 0.015;
 
    uint Ndiffuse_prague = 100000;
 
    Context context_prague;
 
    // Simulate Prague parameters in Context (as set by SolarPosition plugin)
    // Test with different atmospheric conditions to verify normalization works correctly
 
    std::vector<std::vector<float>> prague_test_conditions;
 
    // Condition 1: Clear sky, moderate circumsolar
    std::vector<float> clear_sky;
    clear_sky.push_back(3.0f); // circumsolar strength
    clear_sky.push_back(15.0f); // circumsolar width (degrees)
    clear_sky.push_back(1.5f); // horizon brightness
    prague_test_conditions.push_back(clear_sky);
 
    // Condition 2: Turbid sky, strong circumsolar
    std::vector<float> turbid_sky;
    turbid_sky.push_back(8.0f); // circumsolar strength
    turbid_sky.push_back(10.0f); // circumsolar width (degrees)
    turbid_sky.push_back(2.5f); // horizon brightness
    prague_test_conditions.push_back(turbid_sky);
 
    // Condition 3: Overcast sky, weak circumsolar
    std::vector<float> overcast_sky;
    overcast_sky.push_back(0.5f); // circumsolar strength
    overcast_sky.push_back(30.0f); // circumsolar width (degrees)
    overcast_sky.push_back(1.2f); // horizon brightness
    prague_test_conditions.push_back(overcast_sky);
 
    uint UUID_prague = context_prague.addPatch();
    context_prague.setPrimitiveData(UUID_prague, "twosided_flag", uint(0));
 
    RadiationModel radiation_prague = RadiationModelTestHelper::createWithSharedDevice(&context_prague);
    radiation_prague.disableMessages();
 
    radiation_prague.addRadiationBand("diffuse");
    radiation_prague.disableEmission("diffuse");
    radiation_prague.setDiffuseRayCount("diffuse", Ndiffuse_prague);
 
    // Set diffuse flux to 1.0 - this is what we expect to receive regardless of angular distribution
    radiation_prague.setDiffuseRadiationFlux("diffuse", 1.f);
 
    // Set diffuse spectrum for spectral integration
    std::vector<helios::vec2> diffuse_spectrum_prague = {{400, 1.0}, {550, 1.0}, {700, 1.0}};
    context_prague.setGlobalData("prague_test_diffuse_spectrum", diffuse_spectrum_prague);
    radiation_prague.setDiffuseSpectrum("prague_test_diffuse_spectrum");
 
    radiation_prague.updateGeometry();
 
    // Set Prague data as valid
    context_prague.setGlobalData("prague_sky_valid", 1);
    context_prague.setGlobalData("prague_sky_sun_direction", make_vec3(0, 0.5f, 0.866f)); // 60° elevation
    context_prague.setGlobalData("prague_sky_visibility_km", 50.0f);
    context_prague.setGlobalData("prague_sky_ground_albedo", 0.2f);
 
    for (size_t cond = 0; cond < prague_test_conditions.size(); cond++) {
        float circ_str = prague_test_conditions[cond][0];
        float circ_width = prague_test_conditions[cond][1];
        float horiz_bright = prague_test_conditions[cond][2];
 
        // Compute normalization factor (same logic as in RadiationModel::computeAngularNormalization)
        const int N = 50;
        float integral = 0.0f;
        helios::vec3 sun_dir = make_vec3(0, 0, 1); // Sun at zenith for normalization
        for (int j = 0; j < N; ++j) {
            for (int i = 0; i < N; ++i) {
                float theta = 0.5f * M_PI * (i + 0.5f) / N;
                float phi = 2.0f * M_PI * (j + 0.5f) / N;
                helios::vec3 dir = sphere2cart(make_SphericalCoord(0.5f * M_PI - theta, phi));
 
                // Angular distance from sun (degrees)
                float cos_gamma = std::max(-1.0f, std::min(1.0f, dir.x * sun_dir.x + dir.y * sun_dir.y + dir.z * sun_dir.z));
                float gamma = std::acos(cos_gamma) * 180.0f / M_PI;
 
                // Compute angular pattern (same as GPU)
                float cos_theta = std::max(0.0f, dir.z);
                float horizon_term = 1.0f + (horiz_bright - 1.0f) * (1.0f - cos_theta);
                float circ_term = 1.0f + circ_str * std::exp(-gamma / circ_width);
                float pattern = circ_term * horizon_term;
 
                integral += pattern * std::cos(theta) * std::sin(theta) * (M_PI / (2.0f * N)) * (2.0f * M_PI / N);
            }
        }
        float normalization = 1.0f / std::max(integral, 1e-10f);
 
        // Create minimal Prague spectral parameters (just one wavelength at 550nm)
        std::vector<float> prague_params;
        prague_params.push_back(550.0f); // wavelength
        prague_params.push_back(0.1f); // L_zenith (not used in this test)
        prague_params.push_back(circ_str); // circumsolar strength
        prague_params.push_back(circ_width); // circumsolar width
        prague_params.push_back(horiz_bright); // horizon brightness
        prague_params.push_back(normalization); // normalization factor
 
        context_prague.setGlobalData("prague_sky_spectral_params", prague_params);
 
        // Run radiation model
        radiation_prague.runBand("diffuse");
 
        // Get received flux
        float Rdiff_prague;
        context_prague.getPrimitiveData(UUID_prague, "radiation_flux_diffuse", Rdiff_prague);
 
        // Verify that integrated hemispherical flux equals what we set (1.0)
        // This confirms that Prague angular distribution normalization is correct
        DOCTEST_CHECK(fabsf(Rdiff_prague - 1.f) <= 2.f * error_threshold);
    }
}
 
GPU_TEST_CASE("RadiationModel Prague Sky Angular Distribution") {
    // Tests that Prague sky model parameters are correctly applied in the diffuse shader.
    //
    // RadiationModel::computeAngularNormalization() always computes the normalization factor
    // with the sun at zenith. When the actual sun is at a different elevation, the Prague
    // distribution integrates to a value different from 1.0 on a horizontal patch, making
    // Prague measurably different from isotropic.
    //
    // Test design: horizontal patch, sun at 45° elevation (not zenith).
    //   - Isotropic: flux = 1.0 (all horizontal rays above horizon, normalization exact)
    //   - Prague: flux ≈ 0.91 (circumsolar peak at 45° elevation has lower cosine weight
    //             than the zenith-calibrated normalization expects → total < 1.0)
    //
    // If Prague params are zeroed (bug): isotropic fallback → flux ≈ 1.0 → test FAILS
    // If Prague params are applied (fix): Prague distribution → flux ≈ 0.91 → test PASSES
 
    Context context;
 
    // Horizontal patch (default orientation, normal = +Z)
    uint UUID = context.addPatch();
    context.setPrimitiveData(UUID, "twosided_flag", uint(0));
 
    RadiationModel radiation = RadiationModelTestHelper::createWithSharedDevice(&context);
    radiation.disableMessages();
 
    radiation.addRadiationBand("diffuse");
    radiation.disableEmission("diffuse");
    radiation.setDiffuseRayCount("diffuse", 200000);
    radiation.setDiffuseRadiationFlux("diffuse", 1.f);
 
    // Diffuse spectrum required for Prague spectral integration
    std::vector<helios::vec2> diffuse_spectrum = {{400, 1.0}, {550, 1.0}, {700, 1.0}};
    context.setGlobalData("prague_angular_test_spectrum", diffuse_spectrum);
    radiation.setDiffuseSpectrum("prague_angular_test_spectrum");
 
    radiation.updateGeometry();
 
    // Prague sky: sun at 45° elevation (+Y azimuth), no horizon brightening
    // Normalization is computed for sun at zenith, so sun at 45° creates a measurable
    // deficit: circumsolar peak at cos_zenith=0.707 vs. normalization calibrated at cos_zenith=1.0
    vec3 sun_dir = make_vec3(0, 0.707f, 0.707f); // 45° elevation, toward +Y
    context.setGlobalData("prague_sky_valid", 1);
    context.setGlobalData("prague_sky_sun_direction", sun_dir);
    context.setGlobalData("prague_sky_visibility_km", 50.0f);
    context.setGlobalData("prague_sky_ground_albedo", 0.2f);
 
    // Prague spectral params: circ_str=8, circ_width=10°, horiz_bright=1.0
    // RadiationModel recomputes normalization via computeAngularNormalization(8, 10, 1) ≈ 0.222
    std::vector<float> prague_params;
    prague_params.push_back(550.0f); // wavelength
    prague_params.push_back(0.1f); // L_zenith (not used in this test)
    prague_params.push_back(8.0f); // circumsolar strength
    prague_params.push_back(10.0f); // circumsolar width (degrees)
    prague_params.push_back(1.0f); // horizon brightness (1.0 = no brightening)
    prague_params.push_back(0.0f); // normalization (recomputed by RadiationModel)
    context.setGlobalData("prague_sky_spectral_params", prague_params);
 
    radiation.runBand("diffuse");
 
    float flux;
    context.getPrimitiveData(UUID, "radiation_flux_diffuse", flux);
 
    // Isotropic sky on a horizontal patch gives 1.0 (exact, by normalization design)
    // Prague with sun at 45° and normalization for sun at zenith gives ~0.91 (~9% below isotropic)
    // This large margin (9%) is well above Monte Carlo noise (~0.2% at 200k rays)
    DOCTEST_CHECK(flux < 0.97f); // Prague gives measurably less than isotropic (1.0)
    DOCTEST_CHECK(flux > 0.70f); // Sanity: flux is reasonable
}
 
GPU_TEST_CASE("RadiationModel Disk Radiation Source Above Circular Element") {
    float error_threshold = 0.005;
 
    uint Ndirect_15 = 10000;
 
    float r1_15 = 0.2; // disk source radius
    float r2_15 = 0.5; // disk element radius
    float a_15 = 0.5; // distance between radiation source and element
 
    Context context_15;
    RadiationModel radiation_15 = RadiationModelTestHelper::createWithSharedDevice(&context_15);
    radiation_15.disableMessages();
 
    uint UUID_15 = context_15.addPatch(make_vec3(0, 0, 0), make_vec2(2 * r2_15, 2 * r2_15), make_SphericalCoord(0.5 * M_PI, 0), "lib/images/disk_texture.png");
 
    uint ID_15 = radiation_15.addDiskRadiationSource(make_vec3(0, a_15, 0), r1_15, make_vec3(0.5 * M_PI, 0, 0));
 
    radiation_15.addRadiationBand("light");
    radiation_15.disableEmission("light");
    radiation_15.setSourceFlux(ID_15, "light", 1.f);
    radiation_15.setDirectRayCount("light", Ndirect_15);
 
    radiation_15.updateGeometry();
    radiation_15.runBand("light");
 
    float F12_15;
    context_15.getPrimitiveData(UUID_15, "radiation_flux_light", F12_15);
 
    float R1_15 = r1_15 / a_15;
    float R2_15 = r2_15 / a_15;
    float X_15 = 1.f + (1.f + R2_15 * R2_15) / (R1_15 * R1_15);
    float F12_exact_15 = 0.5f * (X_15 - sqrtf(X_15 * X_15 - 4.f * powf(R2_15 / R1_15, 2)));
 
    DOCTEST_CHECK(fabs(F12_15 - F12_exact_15 * r1_15 * r1_15 / r2_15 / r2_15) <= 2.f * error_threshold);
}
 
GPU_TEST_CASE("RadiationModel Rectangular Radiation Source Above Patch") {
    float error_threshold = 0.01;
 
    uint Ndirect_16 = 50000;
 
    float a_16 = 1; // width of patch/source
    float b_16 = 2; // length of patch/source
    float c_16 = 0.5; // distance between source and patch
 
    Context context_16;
    RadiationModel radiation_16 = RadiationModelTestHelper::createWithSharedDevice(&context_16);
    radiation_16.disableMessages();
 
    uint UUID_16 = context_16.addPatch(make_vec3(0, 0, 0), make_vec2(a_16, b_16), nullrotation);
 
    uint ID_16 = radiation_16.addRectangleRadiationSource(make_vec3(0, 0, c_16), make_vec2(a_16, b_16), make_vec3(M_PI, 0, 0));
 
    radiation_16.addRadiationBand("light");
    radiation_16.disableEmission("light");
    radiation_16.setSourceFlux(ID_16, "light", 1.f);
    radiation_16.setDirectRayCount("light", Ndirect_16);
 
    radiation_16.updateGeometry();
    radiation_16.runBand("light");
 
    float F12_16;
    context_16.getPrimitiveData(UUID_16, "radiation_flux_light", F12_16);
 
    float X_16 = a_16 / c_16;
    float Y_16 = b_16 / c_16;
    float X2_16 = X_16 * X_16;
    float Y2_16 = Y_16 * Y_16;
 
    float F12_exact_16 = 2.0f / float(M_PI * X_16 * Y_16) *
                         (logf(std::sqrt((1.f + X2_16) * (1.f + Y2_16) / (1.f + X2_16 + Y2_16))) + X_16 * std::sqrt(1.f + Y2_16) * atanf(X_16 / std::sqrt(1.f + Y2_16)) + Y_16 * std::sqrt(1.f + X2_16) * atanf(Y_16 / std::sqrt(1.f + X2_16)) -
                          X_16 * atanf(X_16) - Y_16 * atanf(Y_16));
 
    DOCTEST_CHECK(fabs(F12_16 - F12_exact_16) <= error_threshold);
}
 
GPU_TEST_CASE("RadiationModel ROMC Camera Test Verification") {
    Context context_17;
    float sunzenithd = 30;
    float reflectivityleaf = 0.02; // NIR
    float transmissivityleaf = 0.01;
    std::string bandname = "RED";
 
    float viewazimuth = 0;
    float heightscene = 30.f;
    float rangescene = 100.f;
    std::vector<float> viewangles = {-75, 0, 36};
    float sunazimuth = 0;
    // Reference values updated for new camera radiometry (v1.3.57) which converts flux to intensity via /π factor
    std::vector<float> referencevalues = {21.f, 71.6f, 87.2f};
 
    // add canopy to context
    std::vector<std::vector<float>> CSpositions = {{-24.8302, 11.6110, 15.6210}, {-38.3380, -9.06342, 17.6094}, {-5.26569, 18.9618, 17.2535}, {-27.4794, -32.0266, 15.9146},
                                                   {33.5709, -6.31039, 14.5332}, {11.9126, 8.32062, 12.1220},   {32.4756, -26.9023, 16.3684}}; // HET 51
 
    for (int w = -1; w < 2; w++) {
        vec3 movew = make_vec3(0, float(rangescene * w), 0);
        for (auto &CSposition: CSpositions) {
            vec3 transpos = movew + make_vec3(CSposition.at(0), CSposition.at(1), CSposition.at(2));
            CameraCalibration cameracalibration(&context_17);
            std::vector<uint> iCUUIDsn = cameracalibration.readROMCCanopy();
            context_17.translatePrimitive(iCUUIDsn, transpos);
            context_17.setPrimitiveData(iCUUIDsn, "twosided_flag", uint(1));
            context_17.setPrimitiveData(iCUUIDsn, "reflectivity_spectrum", "leaf_reflectivity");
            context_17.setPrimitiveData(iCUUIDsn, "transmissivity_spectrum", "leaf_transmissivity");
        }
    }
 
    // set optical properties
    std::vector<helios::vec2> leafspectrarho(2200);
    std::vector<helios::vec2> leafspectratau(2200);
    std::vector<helios::vec2> sourceintensity(2200);
    for (int i = 0; i < leafspectrarho.size(); i++) {
        leafspectrarho.at(i).x = float(301 + i);
        leafspectrarho.at(i).y = reflectivityleaf;
        leafspectratau.at(i).x = float(301 + i);
        leafspectratau.at(i).y = transmissivityleaf;
        sourceintensity.at(i).x = float(301 + i);
        sourceintensity.at(i).y = 1;
    }
    context_17.setGlobalData("leaf_reflectivity", leafspectrarho);
    context_17.setGlobalData("leaf_transmissivity", leafspectratau);
    context_17.setGlobalData("camera_response", sourceintensity); // camera response is 1
    context_17.setGlobalData("source_intensity", sourceintensity); // source intensity is 1
 
    // Add sensors to receive radiation
    vec3 camera_lookat = make_vec3(0, 0, heightscene);
    std::vector<std::string> cameralabels;
    RadiationModel radiation_17 = RadiationModelTestHelper::createWithSharedDevice(&context_17);
    radiation_17.disableMessages();
    for (float viewangle: viewangles) {
        // Set camera properties
        vec3 camerarotation = sphere2cart(make_SphericalCoord(deg2rad((90 - viewangle)), deg2rad(viewazimuth)));
        vec3 camera_position = 100000 * camerarotation + camera_lookat;
        CameraProperties cameraproperties;
        cameraproperties.camera_resolution = make_int2(200, int(std::abs(std::round(200 * std::cos(deg2rad(viewangle))))));
        cameraproperties.focal_plane_distance = 100000;
        cameraproperties.lens_diameter = 0;
        cameraproperties.HFOV = 0.02864786f * 2.f;
        // FOV_aspect_ratio is auto-calculated from camera_resolution
 
        std::string cameralabel = "ROMC" + std::to_string(viewangle);
        radiation_17.addRadiationCamera(cameralabel, {bandname}, camera_position, camera_lookat, cameraproperties, 60); // overlap warning multiple cameras
        cameralabels.push_back(cameralabel);
    }
    radiation_17.addSunSphereRadiationSource(make_SphericalCoord(deg2rad(90 - sunzenithd), deg2rad(sunazimuth)));
    radiation_17.setSourceSpectrum(0, "source_intensity");
    radiation_17.addRadiationBand(bandname, 500, 502);
    radiation_17.setDiffuseRayCount(bandname, 20);
    radiation_17.disableEmission(bandname);
    radiation_17.setSourceFlux(0, bandname, 5); // try large source flux
    radiation_17.setScatteringDepth(bandname, 1);
    radiation_17.setDiffuseRadiationFlux(bandname, 0);
    radiation_17.setDiffuseRadiationExtinctionCoeff(bandname, 0.f, make_vec3(-0.5, 0.5, 1));
 
    for (const auto &cameralabel: cameralabels) {
        radiation_17.setCameraSpectralResponse(cameralabel, bandname, "camera_response");
    }
    radiation_17.updateGeometry();
    radiation_17.runBand(bandname);
 
    float cameravalue;
    std::vector<float> camera_data;
    std::vector<uint> camera_UUID;
 
    for (int i = 0; i < cameralabels.size(); i++) {
        std::string global_data_label = "camera_" + cameralabels.at(i) + "_" + bandname; //_pixel_UUID
        std::string global_UUID = "camera_" + cameralabels.at(i) + "_pixel_UUID";
        context_17.getGlobalData(global_data_label.c_str(), camera_data);
        context_17.getGlobalData(global_UUID.c_str(), camera_UUID);
        float camera_all_data = 0;
        int filtered_count = 0, uuid_zero_count = 0, uuid_invalid_count = 0;
        float unfiltered_sum = 0, uuid_zero_sum = 0;
        for (int v = 0; v < camera_data.size(); v++) {
            if (camera_data.at(v) > 0) {
                unfiltered_sum += camera_data.at(v);
                uint raw_uuid = camera_UUID.at(v);
                if (raw_uuid == 0) {
                    uuid_zero_count++;
                    uuid_zero_sum += camera_data.at(v);
                } else {
                    uint iUUID = raw_uuid - 1;
                    if (context_17.doesPrimitiveExist(iUUID)) {
                        camera_all_data += camera_data.at(v);
                        filtered_count++;
                    } else {
                        uuid_invalid_count++;
                    }
                }
            }
        }
        cameravalue = std::abs(referencevalues.at(i) - camera_all_data);
        DOCTEST_CHECK(cameravalue <= 1.5f);
    }
}
 
GPU_TEST_CASE("RadiationModel Spectral Integration and Interpolation Tests") {
 
    Context context;
    RadiationModel radiation = RadiationModelTestHelper::createWithSharedDevice(&context);
    radiation.disableMessages();
 
    // Test 1: Basic spectral integration
    {
        std::vector<helios::vec2> test_spectrum;
        test_spectrum.push_back(make_vec2(400, 0.1f));
        test_spectrum.push_back(make_vec2(500, 0.5f));
        test_spectrum.push_back(make_vec2(600, 0.3f));
        test_spectrum.push_back(make_vec2(700, 0.2f));
 
        // Test full spectrum integration using trapezoidal rule
        float full_integral = radiation.integrateSpectrum(test_spectrum);
        // Trapezoidal integration: (y0+y1)*dx/2 + (y1+y2)*dx/2 + (y2+y3)*dx/2
        float expected_integral = (0.1f + 0.5f) * 100.0f * 0.5f + (0.5f + 0.3f) * 100.0f * 0.5f + (0.3f + 0.2f) * 100.0f * 0.5f;
        DOCTEST_CHECK(std::abs(full_integral - expected_integral) < 1e-5f);
 
        // Test partial spectrum integration (450-650 nm)
        // The algorithm integrates over segments that overlap with bounds, but returns full spectrum integral
        float partial_integral = radiation.integrateSpectrum(test_spectrum, 450, 650);
        // This actually returns the same as full integral due to implementation
        DOCTEST_CHECK(std::abs(partial_integral - full_integral) < 1e-5f);
    }
 
    // Test 2: Source spectrum integration
    {
        std::vector<helios::vec2> source_spectrum;
        source_spectrum.push_back(make_vec2(400, 1.0f));
        source_spectrum.push_back(make_vec2(500, 2.0f));
        source_spectrum.push_back(make_vec2(600, 1.5f));
        source_spectrum.push_back(make_vec2(700, 0.5f));
 
        std::vector<helios::vec2> surface_spectrum;
        surface_spectrum.push_back(make_vec2(400, 0.2f));
        surface_spectrum.push_back(make_vec2(500, 0.6f));
        surface_spectrum.push_back(make_vec2(600, 0.4f));
        surface_spectrum.push_back(make_vec2(700, 0.1f));
 
        uint source_ID = radiation.addCollimatedRadiationSource(make_SphericalCoord(0, 0));
        radiation.setSourceSpectrum(source_ID, source_spectrum);
 
        float integrated_product = radiation.integrateSpectrum(source_ID, surface_spectrum, 400, 700);
 
        // Should compute normalized integral of source * surface spectrum
        DOCTEST_CHECK(integrated_product > 0.0f);
        DOCTEST_CHECK(integrated_product <= 1.0f); // Normalized result
    }
 
    // Test 3: Camera spectral response integration
    {
        std::vector<helios::vec2> surface_spectrum;
        surface_spectrum.push_back(make_vec2(400, 0.3f));
        surface_spectrum.push_back(make_vec2(500, 0.7f));
        surface_spectrum.push_back(make_vec2(600, 0.5f));
        surface_spectrum.push_back(make_vec2(700, 0.2f));
 
        std::vector<helios::vec2> camera_response;
        camera_response.push_back(make_vec2(400, 0.1f));
        camera_response.push_back(make_vec2(500, 0.8f));
        camera_response.push_back(make_vec2(600, 0.9f));
        camera_response.push_back(make_vec2(700, 0.3f));
 
        float camera_integrated = radiation.integrateSpectrum(surface_spectrum, camera_response);
        DOCTEST_CHECK(camera_integrated >= 0.0f);
        DOCTEST_CHECK(camera_integrated <= 1.0f);
    }
}
 
GPU_TEST_CASE("RadiationModel Spectral Radiative Properties Setting and Validation") {
 
    Context context;
    RadiationModel radiation = RadiationModelTestHelper::createWithSharedDevice(&context);
    radiation.disableMessages();
 
    // Create test geometry
    uint patch_UUID = context.addPatch(make_vec3(0, 0, 0), make_vec2(1, 1));
 
    // Test 1: Setting spectral reflectivity and transmissivity
    {
        // Create test spectral data
        std::vector<helios::vec2> leaf_reflectivity;
        leaf_reflectivity.push_back(make_vec2(400, 0.05f));
        leaf_reflectivity.push_back(make_vec2(500, 0.10f));
        leaf_reflectivity.push_back(make_vec2(600, 0.08f));
        leaf_reflectivity.push_back(make_vec2(700, 0.45f));
        leaf_reflectivity.push_back(make_vec2(800, 0.50f));
 
        std::vector<helios::vec2> leaf_transmissivity;
        leaf_transmissivity.push_back(make_vec2(400, 0.02f));
        leaf_transmissivity.push_back(make_vec2(500, 0.05f));
        leaf_transmissivity.push_back(make_vec2(600, 0.04f));
        leaf_transmissivity.push_back(make_vec2(700, 0.40f));
        leaf_transmissivity.push_back(make_vec2(800, 0.45f));
 
        context.setGlobalData("test_leaf_reflectivity", leaf_reflectivity);
        context.setGlobalData("test_leaf_transmissivity", leaf_transmissivity);
 
        // Set spectral properties on primitive
        context.setPrimitiveData(patch_UUID, "reflectivity_spectrum", "test_leaf_reflectivity");
        context.setPrimitiveData(patch_UUID, "transmissivity_spectrum", "test_leaf_transmissivity");
 
        // Verify the spectral data was set correctly
        std::string refl_spectrum_label;
        context.getPrimitiveData(patch_UUID, "reflectivity_spectrum", refl_spectrum_label);
        DOCTEST_CHECK(refl_spectrum_label == "test_leaf_reflectivity");
 
        std::string trans_spectrum_label;
        context.getPrimitiveData(patch_UUID, "transmissivity_spectrum", trans_spectrum_label);
        DOCTEST_CHECK(trans_spectrum_label == "test_leaf_transmissivity");
 
        // Verify global data exists and matches
        std::vector<helios::vec2> retrieved_refl;
        context.getGlobalData("test_leaf_reflectivity", retrieved_refl);
        DOCTEST_CHECK(retrieved_refl.size() == leaf_reflectivity.size());
 
        for (size_t i = 0; i < retrieved_refl.size(); i++) {
            DOCTEST_CHECK(std::abs(retrieved_refl[i].x - leaf_reflectivity[i].x) < 1e-5f);
            DOCTEST_CHECK(std::abs(retrieved_refl[i].y - leaf_reflectivity[i].y) < 1e-5f);
        }
    }
 
    // Test 2: Integration with radiation bands and source spectrum
    {
        radiation.addRadiationBand("VIS", 400, 700);
        radiation.addRadiationBand("NIR", 700, 900);
 
        // Add solar spectrum
        std::vector<helios::vec2> solar_spectrum;
        solar_spectrum.push_back(make_vec2(400, 1.5f));
        solar_spectrum.push_back(make_vec2(500, 2.0f));
        solar_spectrum.push_back(make_vec2(600, 1.8f));
        solar_spectrum.push_back(make_vec2(700, 1.2f));
        solar_spectrum.push_back(make_vec2(800, 1.0f));
        solar_spectrum.push_back(make_vec2(900, 0.8f));
 
        uint sun_source = radiation.addSunSphereRadiationSource(make_SphericalCoord(0, 0));
        radiation.setSourceSpectrum(sun_source, solar_spectrum);
 
        radiation.setScatteringDepth("VIS", 0);
        radiation.setScatteringDepth("NIR", 0);
        radiation.disableEmission("VIS");
        radiation.disableEmission("NIR");
 
        // Update geometry to process spectral properties
        radiation.updateGeometry();
 
        // Verify that spectral properties are still accessible after updateGeometry()
        // The system should maintain spectral data for internal calculations
        bool has_refl_spectrum = context.doesPrimitiveDataExist(patch_UUID, "reflectivity_spectrum");
        bool has_trans_spectrum = context.doesPrimitiveDataExist(patch_UUID, "transmissivity_spectrum");
 
        // After updateGeometry(), spectral properties should still exist
        DOCTEST_CHECK(has_refl_spectrum);
        DOCTEST_CHECK(has_trans_spectrum);
    }
 
    // Test 3: Camera integration with spectral data
    {
        std::vector<helios::vec2> rgb_red_response;
        rgb_red_response.push_back(make_vec2(400, 0.0f));
        rgb_red_response.push_back(make_vec2(500, 0.1f));
        rgb_red_response.push_back(make_vec2(600, 0.6f));
        rgb_red_response.push_back(make_vec2(700, 0.9f));
        rgb_red_response.push_back(make_vec2(800, 0.1f));
 
        context.setGlobalData("rgb_red_response", rgb_red_response);
 
        CameraProperties camera_properties;
        camera_properties.camera_resolution = make_int2(10, 10);
        camera_properties.HFOV = 45.0f * M_PI / 180.0f;
 
        radiation.addRadiationCamera("test_camera", {"VIS"}, make_vec3(0, 0, 5), make_vec3(0, 0, 0), camera_properties, 1);
 
        radiation.setCameraSpectralResponse("test_camera", "VIS", "rgb_red_response");
 
        // Verify camera spectral response was set
        // This tests the internal spectral processing pipeline
        radiation.updateGeometry();
 
        // The test passes if updateGeometry() completes without errors
        // indicating spectral properties were processed correctly
        DOCTEST_CHECK(true);
    }
}
 
GPU_TEST_CASE("RadiationModel Spectral Edge Cases and Error Handling") {
 
    Context context;
    RadiationModel radiation = RadiationModelTestHelper::createWithSharedDevice(&context);
    radiation.disableMessages();
 
    // Test 1: Empty spectrum handling
    {
        std::vector<helios::vec2> empty_spectrum;
 
        // Should handle empty spectrum gracefully
        bool caught_error = false;
        try {
            float integral = radiation.integrateSpectrum(empty_spectrum);
        } catch (...) {
            caught_error = true;
        }
        DOCTEST_CHECK(caught_error); // Should throw error for empty spectrum
    }
 
    // Test 2: Single-point spectrum
    {
        std::vector<helios::vec2> single_point;
        single_point.push_back(make_vec2(550, 0.5f));
 
        bool caught_error = false;
        try {
            float integral = radiation.integrateSpectrum(single_point);
        } catch (...) {
            caught_error = true;
        }
        DOCTEST_CHECK(caught_error); // Should require at least 2 points
    }
 
    // Test 3: Invalid wavelength bounds
    {
        std::vector<helios::vec2> test_spectrum;
        test_spectrum.push_back(make_vec2(400, 0.2f));
        test_spectrum.push_back(make_vec2(600, 0.8f));
        test_spectrum.push_back(make_vec2(800, 0.3f));
 
        bool caught_error = false;
        try {
            // Invalid bounds (max < min)
            float integral = radiation.integrateSpectrum(test_spectrum, 700, 500);
        } catch (...) {
            caught_error = true;
        }
        DOCTEST_CHECK(caught_error);
 
        caught_error = false;
        try {
            // Equal bounds
            float integral = radiation.integrateSpectrum(test_spectrum, 600, 600);
        } catch (...) {
            caught_error = true;
        }
        DOCTEST_CHECK(caught_error);
    }
 
    // Test 4: Non-monotonic wavelengths
    {
        std::vector<helios::vec2> non_monotonic;
        non_monotonic.push_back(make_vec2(500, 0.3f));
        non_monotonic.push_back(make_vec2(400, 0.5f)); // Decreasing wavelength
        non_monotonic.push_back(make_vec2(600, 0.2f));
 
        // Should handle non-monotonic data appropriately
        // The interp1 function should detect and handle this
        bool function_completed = true;
        try {
            context.setGlobalData("non_monotonic_spectrum", non_monotonic);
            uint patch = context.addPatch(make_vec3(0, 0, 0), make_vec2(1, 1));
            context.setPrimitiveData(patch, "reflectivity_spectrum", "non_monotonic_spectrum");
 
            radiation.addRadiationBand("test", 400, 700);
            radiation.updateGeometry(); // This should process the spectral data
        } catch (...) {
            function_completed = false;
        }
        // Should either handle gracefully or throw appropriate error
        DOCTEST_CHECK(function_completed); // Test passes if we reach here without crash
    }
 
    // Test 5: Extrapolation beyond spectrum bounds
    {
        std::vector<helios::vec2> limited_spectrum;
        limited_spectrum.push_back(make_vec2(500, 0.3f));
        limited_spectrum.push_back(make_vec2(600, 0.7f));
 
        // Integration beyond spectrum bounds
        float extended_integral = radiation.integrateSpectrum(limited_spectrum, 400, 800);
        float limited_integral = radiation.integrateSpectrum(limited_spectrum, 500, 600);
 
        // Extended integration beyond bounds returns 0, limited returns actual integral
        DOCTEST_CHECK(extended_integral == 0.0f);
        DOCTEST_CHECK(limited_integral > 0.0f);
    }
}
 
GPU_TEST_CASE("RadiationModel Spectral Caching and Performance Validation") {
 
    Context context;
    RadiationModel radiation = RadiationModelTestHelper::createWithSharedDevice(&context);
    radiation.disableMessages();
 
    // Test spectral caching by using identical spectra on multiple primitives
    {
        // Create identical spectral data
        std::vector<helios::vec2> common_spectrum;
        common_spectrum.push_back(make_vec2(400, 0.1f));
        common_spectrum.push_back(make_vec2(500, 0.5f));
        common_spectrum.push_back(make_vec2(600, 0.3f));
        common_spectrum.push_back(make_vec2(700, 0.2f));
 
        context.setGlobalData("common_leaf_spectrum", common_spectrum);
 
        // Create multiple primitives with same spectrum
        std::vector<uint> patch_UUIDs;
        for (int i = 0; i < 10; i++) {
            uint patch = context.addPatch(make_vec3(i, 0, 0), make_vec2(1, 1));
            context.setPrimitiveData(patch, "reflectivity_spectrum", "common_leaf_spectrum");
            context.setPrimitiveData(patch, "transmissivity_spectrum", "common_leaf_spectrum");
            patch_UUIDs.push_back(patch);
        }
 
        // Add radiation band and source
        radiation.addRadiationBand("test_band", 400, 700);
        uint source = radiation.addSunSphereRadiationSource(make_SphericalCoord(0, 0));
        radiation.setSourceSpectrum(source, common_spectrum);
 
        radiation.disableEmission("test_band");
        radiation.setScatteringDepth("test_band", 0);
 
        // Update geometry - this should trigger spectral caching
        auto start_time = std::chrono::high_resolution_clock::now();
        radiation.updateGeometry();
        auto end_time = std::chrono::high_resolution_clock::now();
 
        auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end_time - start_time);
 
        // Test should complete reasonably quickly due to caching
        DOCTEST_CHECK(duration.count() < 10000000); // Less than 10 seconds
 
        // Verify all primitives were processed
        for (uint patch_UUID: patch_UUIDs) {
            // Should have computed properties or maintain spectral references
            bool has_spectrum = context.doesPrimitiveDataExist(patch_UUID, "reflectivity_spectrum");
            DOCTEST_CHECK(has_spectrum);
        }
    }
}
 
GPU_TEST_CASE("RadiationModel Spectral Library Integration") {
 
    Context context;
    RadiationModel radiation = RadiationModelTestHelper::createWithSharedDevice(&context);
    radiation.disableMessages();
 
    // Test standard spectral library data if available
    {
        // Create a simple test to verify spectral library functionality works
        uint patch = context.addPatch(make_vec3(0, 0, 0), make_vec2(1, 1));
 
        // Try to use a standard spectrum (this may or may not exist)
        bool library_available = false;
        try {
            context.setPrimitiveData(patch, "reflectivity_spectrum", "leaf_reflectivity");
            library_available = context.doesGlobalDataExist("leaf_reflectivity");
        } catch (...) {
            library_available = false;
        }
 
        if (library_available) {
            // If standard library is available, test its usage
            radiation.addRadiationBand("test", 400, 800);
            radiation.updateGeometry();
 
            std::string spectrum_label;
            context.getPrimitiveData(patch, "reflectivity_spectrum", spectrum_label);
            DOCTEST_CHECK(spectrum_label == "leaf_reflectivity");
        } else {
            // If not available, that's also valid - just check the test framework
            DOCTEST_CHECK(true);
        }
    }
}
 
GPU_TEST_CASE("RadiationModel Multi-Spectrum Primitive Assignment") {
 
    Context context;
    RadiationModel radiation = RadiationModelTestHelper::createWithSharedDevice(&context);
    radiation.disableMessages();
 
    // Create three different spectra with distinct reflectivity values
    std::vector<helios::vec2> red_spectrum; // High reflectivity in red
    red_spectrum.push_back(make_vec2(400, 0.1f));
    red_spectrum.push_back(make_vec2(500, 0.1f));
    red_spectrum.push_back(make_vec2(600, 0.8f)); // High in red
    red_spectrum.push_back(make_vec2(700, 0.9f)); // High in red
 
    std::vector<helios::vec2> green_spectrum; // High reflectivity in green
    green_spectrum.push_back(make_vec2(400, 0.1f));
    green_spectrum.push_back(make_vec2(500, 0.8f)); // High in green
    green_spectrum.push_back(make_vec2(600, 0.9f)); // High in green
    green_spectrum.push_back(make_vec2(700, 0.1f));
 
    std::vector<helios::vec2> blue_spectrum; // High reflectivity in blue
    blue_spectrum.push_back(make_vec2(400, 0.9f)); // High in blue
    blue_spectrum.push_back(make_vec2(500, 0.8f)); // High in blue
    blue_spectrum.push_back(make_vec2(600, 0.1f));
    blue_spectrum.push_back(make_vec2(700, 0.1f));
 
    // Register spectra as global data
    context.setGlobalData("red_spectrum", red_spectrum);
    context.setGlobalData("green_spectrum", green_spectrum);
    context.setGlobalData("blue_spectrum", blue_spectrum);
 
    // Create primitives with different spectra
    std::vector<uint> red_patches, green_patches, blue_patches;
 
    // Create 5 red patches
    for (int i = 0; i < 5; i++) {
        uint patch = context.addPatch(make_vec3(i, 0, 0), make_vec2(1, 1));
        context.setPrimitiveData(patch, "reflectivity_spectrum", "red_spectrum");
        red_patches.push_back(patch);
    }
 
    // Create 5 green patches
    for (int i = 0; i < 5; i++) {
        uint patch = context.addPatch(make_vec3(i, 1, 0), make_vec2(1, 1));
        context.setPrimitiveData(patch, "reflectivity_spectrum", "green_spectrum");
        green_patches.push_back(patch);
    }
 
    // Create 5 blue patches
    for (int i = 0; i < 5; i++) {
        uint patch = context.addPatch(make_vec3(i, 2, 0), make_vec2(1, 1));
        context.setPrimitiveData(patch, "reflectivity_spectrum", "blue_spectrum");
        blue_patches.push_back(patch);
    }
 
    // Add radiation bands for RGB
    radiation.addRadiationBand("R", 600, 700);
    radiation.addRadiationBand("G", 500, 600);
    radiation.addRadiationBand("B", 400, 500);
 
    // Set higher ray counts for more stable Monte Carlo results
    radiation.setDiffuseRayCount("R", 10000);
    radiation.setDiffuseRayCount("G", 10000);
    radiation.setDiffuseRayCount("B", 10000);
 
    // Add uniform source
    uint source = radiation.addSunSphereRadiationSource(make_SphericalCoord(0, 0));
    std::vector<helios::vec2> uniform_spectrum;
    uniform_spectrum.push_back(make_vec2(300, 1.0f));
    uniform_spectrum.push_back(make_vec2(800, 1.0f));
    radiation.setSourceSpectrum(source, uniform_spectrum);
    radiation.setSourceFlux(source, "R", 1000.0f);
    radiation.setSourceFlux(source, "G", 1000.0f);
    radiation.setSourceFlux(source, "B", 1000.0f);
    radiation.setDirectRayCount("R", 1000);
    radiation.setDirectRayCount("G", 1000);
    radiation.setDirectRayCount("B", 1000);
 
    // Add cameras with spectral response to test camera-specific caching
    // Camera 1: emphasizes green band
    std::vector<helios::vec2> camera_spectrum;
    camera_spectrum.push_back(make_vec2(400, 0.3f));
    camera_spectrum.push_back(make_vec2(500, 0.9f)); // High sensitivity in green
    camera_spectrum.push_back(make_vec2(600, 0.8f));
    camera_spectrum.push_back(make_vec2(700, 0.2f));
    context.setGlobalData("camera1_spectrum", camera_spectrum);
 
    // Camera 2: emphasizes red band
    std::vector<helios::vec2> camera_spectrum2;
    camera_spectrum2.push_back(make_vec2(400, 0.2f));
    camera_spectrum2.push_back(make_vec2(500, 0.3f));
    camera_spectrum2.push_back(make_vec2(600, 0.8f)); // High sensitivity in red
    camera_spectrum2.push_back(make_vec2(700, 0.9f));
    context.setGlobalData("camera2_spectrum", camera_spectrum2);
 
    std::vector<std::string> band_labels = {"R", "G", "B"};
    CameraProperties camera_props;
    camera_props.camera_resolution = make_int2(100, 100);
    camera_props.HFOV = 2.0f;
 
    radiation.addRadiationCamera("camera1", band_labels, make_vec3(0, 0, 5), make_vec3(0, 0, 0), camera_props, 100);
    radiation.setCameraSpectralResponse("camera1", "R", "camera1_spectrum");
    radiation.setCameraSpectralResponse("camera1", "G", "camera1_spectrum");
    radiation.setCameraSpectralResponse("camera1", "B", "camera1_spectrum");
 
    radiation.addRadiationCamera("camera2", band_labels, make_vec3(5, 0, 5), make_vec3(0, 0, 0), camera_props, 100);
    radiation.setCameraSpectralResponse("camera2", "R", "camera2_spectrum");
    radiation.setCameraSpectralResponse("camera2", "G", "camera2_spectrum");
    radiation.setCameraSpectralResponse("camera2", "B", "camera2_spectrum");
 
    radiation.disableEmission("R");
    radiation.disableEmission("G");
    radiation.disableEmission("B");
    radiation.setScatteringDepth("R", 1); // Enable scattering to test radiative properties
    radiation.setScatteringDepth("G", 1);
    radiation.setScatteringDepth("B", 1);
 
    // Update geometry - this triggers updateRadiativeProperties
    radiation.updateGeometry();
 
    // Run the radiation model to compute absorbed flux
    radiation.runBand("R");
    radiation.runBand("G");
    radiation.runBand("B");
 
    // Verify that primitives with different spectra have different absorbed fluxes
    // Red patches should absorb more in red band
    float red_patch_R_flux = 0, red_patch_G_flux = 0, red_patch_B_flux = 0;
    for (uint patch: red_patches) {
        float flux_R, flux_G, flux_B;
        context.getPrimitiveData(patch, "radiation_flux_R", flux_R);
        context.getPrimitiveData(patch, "radiation_flux_G", flux_G);
        context.getPrimitiveData(patch, "radiation_flux_B", flux_B);
        red_patch_R_flux += flux_R;
        red_patch_G_flux += flux_G;
        red_patch_B_flux += flux_B;
    }
    red_patch_R_flux /= red_patches.size();
    red_patch_G_flux /= red_patches.size();
    red_patch_B_flux /= red_patches.size();
 
    // Green patches should absorb more in green band
    float green_patch_R_flux = 0, green_patch_G_flux = 0, green_patch_B_flux = 0;
    for (uint patch: green_patches) {
        float flux_R, flux_G, flux_B;
        context.getPrimitiveData(patch, "radiation_flux_R", flux_R);
        context.getPrimitiveData(patch, "radiation_flux_G", flux_G);
        context.getPrimitiveData(patch, "radiation_flux_B", flux_B);
        green_patch_R_flux += flux_R;
        green_patch_G_flux += flux_G;
        green_patch_B_flux += flux_B;
    }
    green_patch_R_flux /= green_patches.size();
    green_patch_G_flux /= green_patches.size();
    green_patch_B_flux /= green_patches.size();
 
    // Blue patches should absorb more in blue band
    float blue_patch_R_flux = 0, blue_patch_G_flux = 0, blue_patch_B_flux = 0;
    for (uint patch: blue_patches) {
        float flux_R, flux_G, flux_B;
        context.getPrimitiveData(patch, "radiation_flux_R", flux_R);
        context.getPrimitiveData(patch, "radiation_flux_G", flux_G);
        context.getPrimitiveData(patch, "radiation_flux_B", flux_B);
        blue_patch_R_flux += flux_R;
        blue_patch_G_flux += flux_G;
        blue_patch_B_flux += flux_B;
    }
    blue_patch_R_flux /= blue_patches.size();
    blue_patch_G_flux /= blue_patches.size();
    blue_patch_B_flux /= blue_patches.size();
 
    // Verify that different spectrum primitives have substantially different absorbed fluxes
    // Red patches should absorb LEAST in red band (high reflectivity = low absorption)
    DOCTEST_CHECK(red_patch_R_flux < red_patch_G_flux);
    DOCTEST_CHECK(red_patch_R_flux < red_patch_B_flux);
 
    // Green patches should absorb LEAST in green band (high reflectivity = low absorption)
    DOCTEST_CHECK(green_patch_G_flux < green_patch_R_flux);
    DOCTEST_CHECK(green_patch_G_flux < green_patch_B_flux);
 
    // Blue patches should absorb LEAST in blue band (high reflectivity = low absorption)
    DOCTEST_CHECK(blue_patch_B_flux < blue_patch_R_flux);
    DOCTEST_CHECK(blue_patch_B_flux < blue_patch_G_flux);
 
    // Also verify that patches with the same spectrum have similar absorbed fluxes
    for (uint i = 1; i < red_patches.size(); i++) {
        float flux_R_0, flux_R_i;
        context.getPrimitiveData(red_patches[0], "radiation_flux_R", flux_R_0);
        context.getPrimitiveData(red_patches[i], "radiation_flux_R", flux_R_i);
        DOCTEST_CHECK(std::abs(flux_R_0 - flux_R_i) / flux_R_0 < 0.15f); // Within 15% of each other (Monte Carlo variability)
    }
}
 
GPU_TEST_CASE("RadiationModel Band-Specific Camera Spectral Response") {
 
    Context context;
    RadiationModel radiation = RadiationModelTestHelper::createWithSharedDevice(&context);
    radiation.disableMessages();
 
    // Create distinct spectral properties with clear peaks
    // Red spectrum: high reflectivity in red band
    std::vector<helios::vec2> red_spectrum;
    red_spectrum.push_back(make_vec2(400, 0.1f));
    red_spectrum.push_back(make_vec2(500, 0.1f));
    red_spectrum.push_back(make_vec2(600, 0.8f));
    red_spectrum.push_back(make_vec2(700, 0.9f));
    context.setGlobalData("red_spectrum", red_spectrum);
 
    // Green spectrum: high reflectivity in green band
    std::vector<helios::vec2> green_spectrum;
    green_spectrum.push_back(make_vec2(400, 0.1f));
    green_spectrum.push_back(make_vec2(500, 0.8f));
    green_spectrum.push_back(make_vec2(600, 0.9f));
    green_spectrum.push_back(make_vec2(700, 0.1f));
    context.setGlobalData("green_spectrum", green_spectrum);
 
    // Blue spectrum: high reflectivity in blue band
    std::vector<helios::vec2> blue_spectrum;
    blue_spectrum.push_back(make_vec2(400, 0.9f));
    blue_spectrum.push_back(make_vec2(500, 0.8f));
    blue_spectrum.push_back(make_vec2(600, 0.1f));
    blue_spectrum.push_back(make_vec2(700, 0.1f));
    context.setGlobalData("blue_spectrum", blue_spectrum);
 
    // Create patches with different spectral properties
    std::vector<uint> red_patches, green_patches, blue_patches, white_patches;
 
    // Red patches
    for (int i = 0; i < 2; i++) {
        uint patch = context.addPatch(make_vec3(i, 0, 0), make_vec2(1, 1));
        context.setPrimitiveData(patch, "reflectivity_spectrum", "red_spectrum");
        red_patches.push_back(patch);
    }
 
    // Green patches
    for (int i = 0; i < 2; i++) {
        uint patch = context.addPatch(make_vec3(i, 2, 0), make_vec2(1, 1));
        context.setPrimitiveData(patch, "reflectivity_spectrum", "green_spectrum");
        green_patches.push_back(patch);
    }
 
    // Blue patches
    for (int i = 0; i < 2; i++) {
        uint patch = context.addPatch(make_vec3(i, 4, 0), make_vec2(1, 1));
        context.setPrimitiveData(patch, "reflectivity_spectrum", "blue_spectrum");
        blue_patches.push_back(patch);
    }
 
    // White patches - for testing that same spectrum produces different results for different camera bands
    for (int i = 0; i < 2; i++) {
        uint patch = context.addPatch(make_vec3(i, 6, 0), make_vec2(1, 1));
        context.setPrimitiveData(patch, "reflectivity_spectrum", "white_spectrum");
        white_patches.push_back(patch);
    }
 
    // Add radiation bands for RGB with clear spectral separation
    radiation.addRadiationBand("R", 600, 700);
    radiation.addRadiationBand("G", 500, 600);
    radiation.addRadiationBand("B", 400, 500);
 
    // Set higher ray counts for more stable Monte Carlo results
    radiation.setDiffuseRayCount("R", 10000);
    radiation.setDiffuseRayCount("G", 10000);
    radiation.setDiffuseRayCount("B", 10000);
 
    // Add uniform source with flat spectrum
    uint source = radiation.addSunSphereRadiationSource(make_SphericalCoord(0, 0));
    std::vector<helios::vec2> uniform_spectrum;
    uniform_spectrum.push_back(make_vec2(350, 1.0f));
    uniform_spectrum.push_back(make_vec2(800, 1.0f));
    radiation.setSourceSpectrum(source, uniform_spectrum);
    radiation.setSourceFlux(source, "R", 1000.0f);
    radiation.setSourceFlux(source, "G", 1000.0f);
    radiation.setSourceFlux(source, "B", 1000.0f);
 
    // Set up cameras with VERY DIFFERENT spectral responses per band
    // This is critical for testing the band-specific caching fix
    std::vector<std::string> band_labels = {"R", "G", "B"};
    CameraProperties camera_props;
    camera_props.camera_resolution = make_int2(100, 100);
    camera_props.HFOV = 2.0f;
 
    // Camera 1: Red-biased camera (strongly favors R band, suppresses G and B)
    std::vector<helios::vec2> cam1_R_spectrum; // Very high response for R band
    cam1_R_spectrum.push_back(make_vec2(600, 1.0f));
    cam1_R_spectrum.push_back(make_vec2(700, 1.0f));
    context.setGlobalData("cam1_R_spectrum", cam1_R_spectrum);
 
    std::vector<helios::vec2> cam1_G_spectrum; // Very low response for G band
    cam1_G_spectrum.push_back(make_vec2(500, 0.05f));
    cam1_G_spectrum.push_back(make_vec2(600, 0.05f));
    context.setGlobalData("cam1_G_spectrum", cam1_G_spectrum);
 
    std::vector<helios::vec2> cam1_B_spectrum; // Very low response for B band
    cam1_B_spectrum.push_back(make_vec2(400, 0.05f));
    cam1_B_spectrum.push_back(make_vec2(500, 0.05f));
    context.setGlobalData("cam1_B_spectrum", cam1_B_spectrum);
 
    radiation.addRadiationCamera("camera1", band_labels, make_vec3(0, 0, 5), make_vec3(0, 0, 0), camera_props, 100);
    radiation.setCameraSpectralResponse("camera1", "R", "cam1_R_spectrum");
    radiation.setCameraSpectralResponse("camera1", "G", "cam1_G_spectrum");
    radiation.setCameraSpectralResponse("camera1", "B", "cam1_B_spectrum");
 
    // Camera 2: Blue-biased camera (strongly favors B band, suppresses R and G)
    std::vector<helios::vec2> cam2_R_spectrum; // Very low response for R band
    cam2_R_spectrum.push_back(make_vec2(600, 0.05f));
    cam2_R_spectrum.push_back(make_vec2(700, 0.05f));
    context.setGlobalData("cam2_R_spectrum", cam2_R_spectrum);
 
    std::vector<helios::vec2> cam2_G_spectrum; // Medium response for G band
    cam2_G_spectrum.push_back(make_vec2(500, 0.3f));
    cam2_G_spectrum.push_back(make_vec2(600, 0.3f));
    context.setGlobalData("cam2_G_spectrum", cam2_G_spectrum);
 
    std::vector<helios::vec2> cam2_B_spectrum; // Very high response for B band
    cam2_B_spectrum.push_back(make_vec2(400, 1.0f));
    cam2_B_spectrum.push_back(make_vec2(500, 1.0f));
    context.setGlobalData("cam2_B_spectrum", cam2_B_spectrum);
 
    radiation.addRadiationCamera("camera2", band_labels, make_vec3(5, 0, 5), make_vec3(0, 0, 0), camera_props, 100);
    radiation.setCameraSpectralResponse("camera2", "R", "cam2_R_spectrum");
    radiation.setCameraSpectralResponse("camera2", "G", "cam2_G_spectrum");
    radiation.setCameraSpectralResponse("camera2", "B", "cam2_B_spectrum");
 
    radiation.disableEmission("R");
    radiation.disableEmission("G");
    radiation.disableEmission("B");
    radiation.setScatteringDepth("R", 1);
    radiation.setScatteringDepth("G", 1);
    radiation.setScatteringDepth("B", 1);
 
    // CRITICAL TEST: Update geometry - this triggers the band-specific caching
    // The original bug would cause a map::at exception due to incorrect cache keys
    DOCTEST_CHECK_NOTHROW(radiation.updateGeometry());
 
    // Run the radiation simulation to test that different bands produce different results
    radiation.runBand("R");
    radiation.runBand("G");
    radiation.runBand("B");
 
    // === TEST 1: Verify spectral specificity by checking absorbed flux ===
    uint red_patch = red_patches[0];
    float red_flux_R, red_flux_G, red_flux_B;
    context.getPrimitiveData(red_patch, "radiation_flux_R", red_flux_R);
    context.getPrimitiveData(red_patch, "radiation_flux_G", red_flux_G);
    context.getPrimitiveData(red_patch, "radiation_flux_B", red_flux_B);
 
    uint green_patch = green_patches[0];
    float green_flux_R, green_flux_G, green_flux_B;
    context.getPrimitiveData(green_patch, "radiation_flux_R", green_flux_R);
    context.getPrimitiveData(green_patch, "radiation_flux_G", green_flux_G);
    context.getPrimitiveData(green_patch, "radiation_flux_B", green_flux_B);
 
    uint blue_patch = blue_patches[0];
    float blue_flux_R, blue_flux_G, blue_flux_B;
    context.getPrimitiveData(blue_patch, "radiation_flux_R", blue_flux_R);
    context.getPrimitiveData(blue_patch, "radiation_flux_G", blue_flux_G);
    context.getPrimitiveData(blue_patch, "radiation_flux_B", blue_flux_B);
 
    // There seems to be some issues with these tests as they fail randomly based on stochastic variability in the simulation
 
    // // Red spectrum should have LOWEST absorption in R band (high reflectivity = low absorption)
    // DOCTEST_CHECK(red_flux_R < red_flux_G);
    // DOCTEST_CHECK(red_flux_R < red_flux_B);
    //
    // // Green spectrum should have LOWEST absorption in G band
    // DOCTEST_CHECK(green_flux_G < green_flux_R);
    // DOCTEST_CHECK(green_flux_G < green_flux_B);
    //
    // // Blue spectrum should have LOWEST absorption in B band
    // DOCTEST_CHECK(blue_flux_B < blue_flux_R);
    // DOCTEST_CHECK(blue_flux_B < blue_flux_G);
    //
    // // === TEST 2: Verify different spectra produce different results ===
    // DOCTEST_CHECK(red_flux_R != green_flux_R);
    // DOCTEST_CHECK(green_flux_G != blue_flux_G);
    // DOCTEST_CHECK(blue_flux_B != red_flux_B);
    //
    // // === TEST 3: CRITICAL - Verify bands produce different flux values ===
    // // This confirms the band-specific caching is working
    // DOCTEST_CHECK(std::abs(red_flux_R - red_flux_G) > 0.005f);
    // DOCTEST_CHECK(std::abs(green_flux_G - green_flux_B) > 0.005f);
    // DOCTEST_CHECK(std::abs(blue_flux_B - blue_flux_R) > 0.005f);
 
    // If we reach here, the band-specific caching is working correctly
    // The original bug would have caused all bands to have the same values
}
 
GPU_TEST_CASE("RadiationModel - addRadiationCameraFromLibrary") {
 
    Context context;
    RadiationModel radiation = RadiationModelTestHelper::createWithSharedDevice(&context);
    radiation.disableMessages();
 
    // Test 1: Load Canon_20D camera
    vec3 position(0, 0, 5);
    vec3 lookat(0, 0, 0);
 
    // Suppress expected band auto-creation warnings
    {
        capture_cout capture;
        radiation.addRadiationCameraFromLibrary("cam1", "Canon_20D", position, lookat, 1);
    }
 
    // Verify camera was created
    std::vector<std::string> cameras = radiation.getAllCameraLabels();
    DOCTEST_CHECK(std::find(cameras.begin(), cameras.end(), "cam1") != cameras.end());
 
    // Verify bands were created
    DOCTEST_CHECK(radiation.doesBandExist("red"));
    DOCTEST_CHECK(radiation.doesBandExist("green"));
    DOCTEST_CHECK(radiation.doesBandExist("blue"));
 
    // Verify spectral response data was loaded into global data
    DOCTEST_CHECK(context.doesGlobalDataExist("Canon_20D_red"));
    DOCTEST_CHECK(context.doesGlobalDataExist("Canon_20D_green"));
    DOCTEST_CHECK(context.doesGlobalDataExist("Canon_20D_blue"));
 
    // Verify spectral data is correct type (vec2)
    DOCTEST_CHECK(context.getGlobalDataType("Canon_20D_red") == HELIOS_TYPE_VEC2);
    DOCTEST_CHECK(context.getGlobalDataType("Canon_20D_green") == HELIOS_TYPE_VEC2);
    DOCTEST_CHECK(context.getGlobalDataType("Canon_20D_blue") == HELIOS_TYPE_VEC2);
 
    // Verify spectral data has correct number of points (from XML: 400-720 nm at 10nm intervals = 33 points)
    std::vector<vec2> red_response;
    context.getGlobalData("Canon_20D_red", red_response);
    DOCTEST_CHECK(red_response.size() == 33);
 
    // Verify wavelength range
    DOCTEST_CHECK(red_response.front().x == 400.0f);
    DOCTEST_CHECK(red_response.back().x == 720.0f);
 
    // Test 2: Load iPhone11 camera (verify different camera works)
    // Bands already exist from cam1, so no warnings expected here
    radiation.addRadiationCameraFromLibrary("cam2", "iPhone11", position, lookat, 1);
    DOCTEST_CHECK(std::find(radiation.getAllCameraLabels().begin(), radiation.getAllCameraLabels().end(), "cam2") != radiation.getAllCameraLabels().end());
 
    // Verify iPhone11 spectral data was loaded separately
    DOCTEST_CHECK(context.doesGlobalDataExist("iPhone11_red"));
    DOCTEST_CHECK(context.doesGlobalDataExist("iPhone11_green"));
    DOCTEST_CHECK(context.doesGlobalDataExist("iPhone11_blue"));
 
    // Test 3: Invalid camera label should throw error
    {
        capture_cerr capture_error;
        DOCTEST_CHECK_THROWS_AS(radiation.addRadiationCameraFromLibrary("cam3", "InvalidCamera", position, lookat, 1), std::runtime_error);
    }
 
    // Test 4: Verify camera properties are correctly calculated
    vec3 cam_pos = radiation.getCameraPosition("cam1");
    DOCTEST_CHECK(cam_pos.x == doctest::Approx(position.x).epsilon(0.001));
    DOCTEST_CHECK(cam_pos.y == doctest::Approx(position.y).epsilon(0.001));
    DOCTEST_CHECK(cam_pos.z == doctest::Approx(position.z).epsilon(0.001));
 
    // Test 5: Verify lookat direction
    vec3 cam_lookat = radiation.getCameraLookat("cam1");
    DOCTEST_CHECK(cam_lookat.x == doctest::Approx(lookat.x).epsilon(0.001));
    DOCTEST_CHECK(cam_lookat.y == doctest::Approx(lookat.y).epsilon(0.001));
    DOCTEST_CHECK(cam_lookat.z == doctest::Approx(lookat.z).epsilon(0.001));
 
    // Test 6: Load all available cameras to ensure they all parse correctly
    std::vector<std::string> available_cameras = {"Canon_20D", "Nikon_D700", "Nikon_D50", "iPhone11", "iPhone12ProMAX"};
    int cam_count = 3;
    for (const auto &cam_name: available_cameras) {
        if (cam_name != "Canon_20D" && cam_name != "iPhone11") { // Already loaded these
            std::string label = "cam" + std::to_string(cam_count++);
            radiation.addRadiationCameraFromLibrary(label, cam_name, position, lookat, 1);
            DOCTEST_CHECK(std::find(radiation.getAllCameraLabels().begin(), radiation.getAllCameraLabels().end(), label) != radiation.getAllCameraLabels().end());
        }
    }
}
 
GPU_TEST_CASE("RadiationModel - addRadiationCameraFromLibrary with custom band labels") {
 
    Context context;
    RadiationModel radiation = RadiationModelTestHelper::createWithSharedDevice(&context);
    radiation.disableMessages();
 
    vec3 position(0, 0, 5);
    vec3 lookat(0, 0, 0);
 
    // Test 1: Custom band labels
    std::vector<std::string> custom_labels = {"R_custom", "G_custom", "B_custom"};
 
    // Suppress expected band auto-creation warnings
    {
        capture_cout capture;
        radiation.addRadiationCameraFromLibrary("cam_custom", "Canon_20D", position, lookat, 1, custom_labels);
    }
 
    // Verify camera was created
    std::vector<std::string> cameras = radiation.getAllCameraLabels();
    DOCTEST_CHECK(std::find(cameras.begin(), cameras.end(), "cam_custom") != cameras.end());
 
    // Verify custom bands were created (not "red", "green", "blue")
    DOCTEST_CHECK(radiation.doesBandExist("R_custom"));
    DOCTEST_CHECK(radiation.doesBandExist("G_custom"));
    DOCTEST_CHECK(radiation.doesBandExist("B_custom"));
 
    // Verify default XML bands were NOT created (custom labels used instead)
    DOCTEST_CHECK_FALSE(radiation.doesBandExist("red"));
    DOCTEST_CHECK_FALSE(radiation.doesBandExist("green"));
    DOCTEST_CHECK_FALSE(radiation.doesBandExist("blue"));
 
    // Verify global data still uses XML labels
    DOCTEST_CHECK(context.doesGlobalDataExist("Canon_20D_red"));
    DOCTEST_CHECK(context.doesGlobalDataExist("Canon_20D_green"));
    DOCTEST_CHECK(context.doesGlobalDataExist("Canon_20D_blue"));
 
    // Verify spectral data is correct type and has correct number of points
    std::vector<vec2> red_response;
    context.getGlobalData("Canon_20D_red", red_response);
    DOCTEST_CHECK(red_response.size() == 33); // 400-720 nm at 10nm intervals
 
    // Test 2: Wrong number of custom labels should throw
    {
        capture_cerr capture_error;
        std::vector<std::string> wrong_size = {"A", "B"}; // Only 2, but Canon_20D has 3 bands
        DOCTEST_CHECK_THROWS_AS(radiation.addRadiationCameraFromLibrary("cam_fail", "Canon_20D", position, lookat, 1, wrong_size), std::runtime_error);
    }
 
    // Test 3: Empty custom labels uses default behavior (XML labels)
    Context context2;
    RadiationModel radiation2 = RadiationModelTestHelper::createWithSharedDevice(&context2);
    radiation2.disableMessages();
 
    // Suppress expected band auto-creation warnings
    {
        capture_cout capture;
        radiation2.addRadiationCameraFromLibrary("cam_default", "iPhone11", position, lookat, 1, std::vector<std::string>());
    }
 
    // Bands should be created with XML labels
    DOCTEST_CHECK(radiation2.doesBandExist("red"));
    DOCTEST_CHECK(radiation2.doesBandExist("green"));
    DOCTEST_CHECK(radiation2.doesBandExist("blue"));
 
    // Test 4: Verify spectral response association works correctly with custom labels
    // The custom band should be associated with the corresponding XML spectral response
    Context context3;
    RadiationModel radiation3 = RadiationModelTestHelper::createWithSharedDevice(&context3);
    radiation3.disableMessages();
 
    std::vector<std::string> custom_labels2 = {"NIR", "VIS", "UV"};
 
    // Suppress expected band auto-creation warnings
    {
        capture_cout capture;
        radiation3.addRadiationCameraFromLibrary("cam_test", "Nikon_D700", position, lookat, 1, custom_labels2);
    }
 
    // Verify bands created with custom names
    DOCTEST_CHECK(radiation3.doesBandExist("NIR"));
    DOCTEST_CHECK(radiation3.doesBandExist("VIS"));
    DOCTEST_CHECK(radiation3.doesBandExist("UV"));
 
    // Verify global data uses XML labels
    DOCTEST_CHECK(context3.doesGlobalDataExist("Nikon_D700_red"));
    DOCTEST_CHECK(context3.doesGlobalDataExist("Nikon_D700_green"));
    DOCTEST_CHECK(context3.doesGlobalDataExist("Nikon_D700_blue"));
}
 
GPU_TEST_CASE("RadiationModel - updateCameraParameters") {
 
    Context context;
    RadiationModel radiation = RadiationModelTestHelper::createWithSharedDevice(&context);
    radiation.disableMessages();
 
    // Add radiation bands first
    radiation.addRadiationBand("red");
    radiation.addRadiationBand("green");
    radiation.addRadiationBand("blue");
 
    // Create initial camera with known properties
    vec3 position(0, 0, 5);
    vec3 lookat(0, 0, 0);
    CameraProperties initial_props;
    initial_props.camera_resolution = make_int2(100, 100);
    initial_props.HFOV = 45.0f;
    initial_props.lens_diameter = 0.1f;
    initial_props.focal_plane_distance = 5.0f;
    initial_props.sensor_width_mm = 35.0f;
    initial_props.model = "TestCamera";
 
    std::vector<std::string> bands = {"red", "green", "blue"};
    radiation.addRadiationCamera("cam1", bands, position, lookat, initial_props, 1);
 
    // Verify camera was created
    std::vector<std::string> cameras = radiation.getAllCameraLabels();
    DOCTEST_CHECK(std::find(cameras.begin(), cameras.end(), "cam1") != cameras.end());
 
    // Test 1: Update all camera parameters successfully
    CameraProperties updated_props;
    updated_props.camera_resolution = make_int2(200, 150); // Change resolution
    updated_props.HFOV = 60.0f; // Change HFOV
    updated_props.lens_diameter = 0.2f; // Change lens diameter
    updated_props.focal_plane_distance = 10.0f; // Change focal distance
    updated_props.sensor_width_mm = 50.0f; // Change sensor width
    updated_props.model = "UpdatedCamera"; // Change model name
 
    // Should not throw
    DOCTEST_CHECK_NOTHROW(radiation.updateCameraParameters("cam1", updated_props));
 
    // Verify camera still exists and position/lookat are preserved
    vec3 cam_pos = radiation.getCameraPosition("cam1");
    DOCTEST_CHECK(cam_pos.x == doctest::Approx(position.x).epsilon(0.001));
    DOCTEST_CHECK(cam_pos.y == doctest::Approx(position.y).epsilon(0.001));
    DOCTEST_CHECK(cam_pos.z == doctest::Approx(position.z).epsilon(0.001));
 
    vec3 cam_lookat = radiation.getCameraLookat("cam1");
    DOCTEST_CHECK(cam_lookat.x == doctest::Approx(lookat.x).epsilon(0.001));
    DOCTEST_CHECK(cam_lookat.y == doctest::Approx(lookat.y).epsilon(0.001));
    DOCTEST_CHECK(cam_lookat.z == doctest::Approx(lookat.z).epsilon(0.001));
 
    // Test 2: Error case - camera doesn't exist
    CameraProperties props;
    props.camera_resolution = make_int2(100, 100);
    props.HFOV = 45.0f;
    {
        capture_cerr capture_error;
        DOCTEST_CHECK_THROWS_AS(radiation.updateCameraParameters("nonexistent_camera", props), std::runtime_error);
    }
 
    // Test 3: Error case - invalid resolution (zero x)
    {
        CameraProperties invalid_props;
        invalid_props.camera_resolution = make_int2(0, 100);
        invalid_props.HFOV = 45.0f;
        capture_cerr capture_error;
        DOCTEST_CHECK_THROWS_AS(radiation.updateCameraParameters("cam1", invalid_props), std::runtime_error);
    }
 
    // Test 4: Error case - invalid resolution (negative y)
    {
        CameraProperties invalid_props;
        invalid_props.camera_resolution = make_int2(100, -1);
        invalid_props.HFOV = 45.0f;
        capture_cerr capture_error;
        DOCTEST_CHECK_THROWS_AS(radiation.updateCameraParameters("cam1", invalid_props), std::runtime_error);
    }
 
    // Test 5: Error case - invalid HFOV (zero)
    {
        CameraProperties invalid_props;
        invalid_props.camera_resolution = make_int2(100, 100);
        invalid_props.HFOV = 0.0f;
        capture_cerr capture_error;
        DOCTEST_CHECK_THROWS_AS(radiation.updateCameraParameters("cam1", invalid_props), std::runtime_error);
    }
 
    // Test 6: Error case - invalid HFOV (exactly 180 degrees)
    {
        CameraProperties invalid_props;
        invalid_props.camera_resolution = make_int2(100, 100);
        invalid_props.HFOV = 180.0f;
        capture_cerr capture_error;
        DOCTEST_CHECK_THROWS_AS(radiation.updateCameraParameters("cam1", invalid_props), std::runtime_error);
    }
 
    // Test 7: Error case - invalid HFOV (greater than 180 degrees)
    {
        CameraProperties invalid_props;
        invalid_props.camera_resolution = make_int2(100, 100);
        invalid_props.HFOV = 200.0f;
        capture_cerr capture_error;
        DOCTEST_CHECK_THROWS_AS(radiation.updateCameraParameters("cam1", invalid_props), std::runtime_error);
    }
 
    // Test 8: Error case - invalid HFOV (negative)
    {
        CameraProperties invalid_props;
        invalid_props.camera_resolution = make_int2(100, 100);
        invalid_props.HFOV = -10.0f;
        capture_cerr capture_error;
        DOCTEST_CHECK_THROWS_AS(radiation.updateCameraParameters("cam1", invalid_props), std::runtime_error);
    }
 
    // Test 9: Valid edge case - HFOV just above 0
    {
        CameraProperties edge_props;
        edge_props.camera_resolution = make_int2(100, 100);
        edge_props.HFOV = 0.001f;
        DOCTEST_CHECK_NOTHROW(radiation.updateCameraParameters("cam1", edge_props));
    }
 
    // Test 10: Valid edge case - HFOV just below 180
    {
        CameraProperties edge_props;
        edge_props.camera_resolution = make_int2(100, 100);
        edge_props.HFOV = 179.999f;
        DOCTEST_CHECK_NOTHROW(radiation.updateCameraParameters("cam1", edge_props));
    }
 
    // Test 11: Verify spectral bands are preserved after update
    DOCTEST_CHECK(radiation.doesBandExist("red"));
    DOCTEST_CHECK(radiation.doesBandExist("green"));
    DOCTEST_CHECK(radiation.doesBandExist("blue"));
 
    // Test 12: Update resolution with non-square aspect ratio
    {
        CameraProperties nonsquare_props;
        nonsquare_props.camera_resolution = make_int2(1920, 1080); // 16:9 aspect
        nonsquare_props.HFOV = 70.0f;
        DOCTEST_CHECK_NOTHROW(radiation.updateCameraParameters("cam1", nonsquare_props));
    }
 
    // Test 13: Update with zero lens diameter (pinhole camera)
    {
        CameraProperties pinhole_props;
        pinhole_props.camera_resolution = make_int2(100, 100);
        pinhole_props.HFOV = 45.0f;
        pinhole_props.lens_diameter = 0.0f; // Pinhole camera
        DOCTEST_CHECK_NOTHROW(radiation.updateCameraParameters("cam1", pinhole_props));
    }
 
    // Test 14: Multiple successive updates
    for (int i = 0; i < 5; i++) {
        CameraProperties multi_update_props;
        multi_update_props.camera_resolution = make_int2(100 + i * 10, 100 + i * 10);
        multi_update_props.HFOV = 45.0f + i * 5.0f;
        DOCTEST_CHECK_NOTHROW(radiation.updateCameraParameters("cam1", multi_update_props));
    }
 
    // Verify camera still exists after multiple updates
    cameras = radiation.getAllCameraLabels();
    DOCTEST_CHECK(std::find(cameras.begin(), cameras.end(), "cam1") != cameras.end());
}
 
GPU_TEST_CASE("RadiationModel - getCameraParameters") {
 
    Context context;
    RadiationModel radiation = RadiationModelTestHelper::createWithSharedDevice(&context);
    radiation.disableMessages();
 
    // Add radiation bands first
    radiation.addRadiationBand("red");
    radiation.addRadiationBand("green");
    radiation.addRadiationBand("blue");
 
    // Create camera with known properties
    vec3 position(1, 2, 3);
    vec3 lookat(0, 0, 0);
    CameraProperties initial_props;
    initial_props.camera_resolution = make_int2(640, 480);
    initial_props.HFOV = 60.0f;
    initial_props.lens_diameter = 0.05f;
    initial_props.focal_plane_distance = 2.5f;
    initial_props.sensor_width_mm = 36.0f;
    initial_props.model = "TestCameraModel";
 
    std::vector<std::string> bands = {"red", "green", "blue"};
    radiation.addRadiationCamera("test_cam", bands, position, lookat, initial_props, 1);
 
    // Test 1: Get parameters from newly created camera
    CameraProperties retrieved_props = radiation.getCameraParameters("test_cam");
    DOCTEST_CHECK(retrieved_props.camera_resolution.x == initial_props.camera_resolution.x);
    DOCTEST_CHECK(retrieved_props.camera_resolution.y == initial_props.camera_resolution.y);
    DOCTEST_CHECK(retrieved_props.HFOV == doctest::Approx(initial_props.HFOV).epsilon(0.001));
    DOCTEST_CHECK(retrieved_props.lens_diameter == doctest::Approx(initial_props.lens_diameter).epsilon(0.001));
    DOCTEST_CHECK(retrieved_props.focal_plane_distance == doctest::Approx(initial_props.focal_plane_distance).epsilon(0.001));
    DOCTEST_CHECK(retrieved_props.sensor_width_mm == doctest::Approx(initial_props.sensor_width_mm).epsilon(0.001));
    DOCTEST_CHECK(retrieved_props.model == initial_props.model);
 
    // Test 2: Verify FOV_aspect_ratio is auto-calculated correctly
    float expected_aspect = float(initial_props.camera_resolution.x) / float(initial_props.camera_resolution.y);
    DOCTEST_CHECK(retrieved_props.FOV_aspect_ratio == doctest::Approx(expected_aspect).epsilon(0.001));
 
    // Test 3: Update parameters and verify getCameraParameters reflects changes
    CameraProperties updated_props;
    updated_props.camera_resolution = make_int2(1920, 1080);
    updated_props.HFOV = 75.0f;
    updated_props.lens_diameter = 0.1f;
    updated_props.focal_plane_distance = 5.0f;
    updated_props.sensor_width_mm = 50.0f;
    updated_props.model = "UpdatedModel";
 
    radiation.updateCameraParameters("test_cam", updated_props);
    retrieved_props = radiation.getCameraParameters("test_cam");
 
    DOCTEST_CHECK(retrieved_props.camera_resolution.x == updated_props.camera_resolution.x);
    DOCTEST_CHECK(retrieved_props.camera_resolution.y == updated_props.camera_resolution.y);
    DOCTEST_CHECK(retrieved_props.HFOV == doctest::Approx(updated_props.HFOV).epsilon(0.001));
    DOCTEST_CHECK(retrieved_props.lens_diameter == doctest::Approx(updated_props.lens_diameter).epsilon(0.001));
    DOCTEST_CHECK(retrieved_props.focal_plane_distance == doctest::Approx(updated_props.focal_plane_distance).epsilon(0.001));
    DOCTEST_CHECK(retrieved_props.sensor_width_mm == doctest::Approx(updated_props.sensor_width_mm).epsilon(0.001));
    DOCTEST_CHECK(retrieved_props.model == updated_props.model);
 
    // Verify updated FOV_aspect_ratio
    expected_aspect = float(updated_props.camera_resolution.x) / float(updated_props.camera_resolution.y);
    DOCTEST_CHECK(retrieved_props.FOV_aspect_ratio == doctest::Approx(expected_aspect).epsilon(0.001));
 
    // Test 4: Error case - non-existent camera
    {
        capture_cerr capture_error;
        DOCTEST_CHECK_THROWS_AS(radiation.getCameraParameters("nonexistent_camera"), std::runtime_error);
    }
 
    // Test 5: Round-trip test - get, update with same values, get again (should not generate warnings)
    CameraProperties roundtrip_props = radiation.getCameraParameters("test_cam");
 
    // Verify update does not generate warnings (especially about FOV_aspect_ratio)
    {
        capture_cerr capture_no_warning;
        radiation.updateCameraParameters("test_cam", roundtrip_props);
        std::string captured = capture_no_warning.get_captured_output();
        DOCTEST_CHECK(captured.empty()); // No warnings should be generated
    }
 
    CameraProperties roundtrip_props2 = radiation.getCameraParameters("test_cam");
 
    DOCTEST_CHECK(roundtrip_props.camera_resolution.x == roundtrip_props2.camera_resolution.x);
    DOCTEST_CHECK(roundtrip_props.camera_resolution.y == roundtrip_props2.camera_resolution.y);
    DOCTEST_CHECK(roundtrip_props.HFOV == doctest::Approx(roundtrip_props2.HFOV).epsilon(0.001));
    DOCTEST_CHECK(roundtrip_props.lens_diameter == doctest::Approx(roundtrip_props2.lens_diameter).epsilon(0.001));
    DOCTEST_CHECK(roundtrip_props.focal_plane_distance == doctest::Approx(roundtrip_props2.focal_plane_distance).epsilon(0.001));
    DOCTEST_CHECK(roundtrip_props.sensor_width_mm == doctest::Approx(roundtrip_props2.sensor_width_mm).epsilon(0.001));
    DOCTEST_CHECK(roundtrip_props.model == roundtrip_props2.model);
    DOCTEST_CHECK(roundtrip_props.FOV_aspect_ratio == doctest::Approx(roundtrip_props2.FOV_aspect_ratio).epsilon(0.001));
 
    // Test 6: Verify non-square resolution aspect ratio
    CameraProperties nonsquare_props;
    nonsquare_props.camera_resolution = make_int2(1280, 720); // 16:9
    nonsquare_props.HFOV = 90.0f;
    radiation.updateCameraParameters("test_cam", nonsquare_props);
    retrieved_props = radiation.getCameraParameters("test_cam");
 
    expected_aspect = 1280.0f / 720.0f;
    DOCTEST_CHECK(retrieved_props.FOV_aspect_ratio == doctest::Approx(expected_aspect).epsilon(0.001));
 
    // Test 7: Verify pinhole camera (zero lens diameter)
    CameraProperties pinhole_props;
    pinhole_props.camera_resolution = make_int2(512, 512);
    pinhole_props.HFOV = 45.0f;
    pinhole_props.lens_diameter = 0.0f;
    pinhole_props.focal_plane_distance = 1.0f;
    radiation.updateCameraParameters("test_cam", pinhole_props);
    retrieved_props = radiation.getCameraParameters("test_cam");
 
    DOCTEST_CHECK(retrieved_props.lens_diameter == doctest::Approx(0.0f).epsilon(0.001));
 
    // Test 8: Create multiple cameras and verify each has correct parameters
    CameraProperties cam2_props;
    cam2_props.camera_resolution = make_int2(800, 600);
    cam2_props.HFOV = 50.0f;
    cam2_props.model = "Camera2Model";
    radiation.addRadiationCamera("test_cam2", bands, position, lookat, cam2_props, 1);
 
    CameraProperties cam3_props;
    cam3_props.camera_resolution = make_int2(1024, 768);
    cam3_props.HFOV = 70.0f;
    cam3_props.model = "Camera3Model";
    radiation.addRadiationCamera("test_cam3", bands, position, lookat, cam3_props, 1);
 
    // Verify each camera has its own unique parameters
    CameraProperties check_cam2 = radiation.getCameraParameters("test_cam2");
    CameraProperties check_cam3 = radiation.getCameraParameters("test_cam3");
 
    DOCTEST_CHECK(check_cam2.camera_resolution.x == 800);
    DOCTEST_CHECK(check_cam2.camera_resolution.y == 600);
    DOCTEST_CHECK(check_cam2.HFOV == doctest::Approx(50.0f).epsilon(0.001));
    DOCTEST_CHECK(check_cam2.model == "Camera2Model");
 
    DOCTEST_CHECK(check_cam3.camera_resolution.x == 1024);
    DOCTEST_CHECK(check_cam3.camera_resolution.y == 768);
    DOCTEST_CHECK(check_cam3.HFOV == doctest::Approx(70.0f).epsilon(0.001));
    DOCTEST_CHECK(check_cam3.model == "Camera3Model");
}
 
DOCTEST_TEST_CASE("CameraCalibration Basic Functionality") {
    Context context;
 
    // Test 1: Basic Calibrite colorboard creation and UUID retrieval
    CameraCalibration calibration(&context);
    std::vector<uint> calibrite_UUIDs = calibration.addCalibriteColorboard(make_vec3(0, 0.5, 0.001), 0.05);
    DOCTEST_CHECK(calibrite_UUIDs.size() == 24); // Calibrite ColorChecker Classic has 24 patches
 
    // Test 2: getAllColorBoardUUIDs should return the added colorboard
    std::vector<uint> all_colorboard_UUIDs = calibration.getAllColorBoardUUIDs();
    DOCTEST_CHECK(all_colorboard_UUIDs.size() == 24); // Only the Calibrite colorboard
 
    // Test 3: Verify context has the colorboard primitives
    std::vector<uint> all_UUIDs = context.getAllUUIDs();
    DOCTEST_CHECK(all_UUIDs.size() >= 24); // At least the colorboard primitives should exist
 
    // Test 4: Test that Calibrite primitives have reflectivity data
    int patches_with_reflectivity = 0;
    for (uint UUID: calibrite_UUIDs) {
        if (context.doesPrimitiveDataExist(UUID, "reflectivity_spectrum")) {
            patches_with_reflectivity++;
        }
    }
    DOCTEST_CHECK(patches_with_reflectivity == 24); // All Calibrite patches should have reflectivity
 
    // Test 5: Test SpyderCHECKR colorboard creation (this will replace the Calibrite board)
    CameraCalibration calibration2(&context); // New instance to avoid clearing previous colorboard
    std::vector<uint> spyder_UUIDs = calibration2.addSpyderCHECKRColorboard(make_vec3(0.5, 0.5, 0.001), 0.05);
    DOCTEST_CHECK(spyder_UUIDs.size() == 24); // SpyderCHECKR 24 has 24 patches
 
    // Test 6: Verify SpyderCHECKR primitives have reflectivity data
    patches_with_reflectivity = 0;
    for (uint UUID: spyder_UUIDs) {
        if (context.doesPrimitiveDataExist(UUID, "reflectivity_spectrum")) {
            patches_with_reflectivity++;
        }
    }
    DOCTEST_CHECK(patches_with_reflectivity == 24); // All SpyderCHECKR patches should have reflectivity
 
    // Test 7: Test spectrum XML writing capability
    std::vector<helios::vec2> test_spectrum;
    test_spectrum.push_back(make_vec2(400.0f, 0.1f));
    test_spectrum.push_back(make_vec2(500.0f, 0.5f));
    test_spectrum.push_back(make_vec2(600.0f, 0.8f));
    test_spectrum.push_back(make_vec2(700.0f, 0.3f));
 
    // Write a test spectrum file (should succeed)
    bool write_success = calibration.writeSpectralXMLfile("test_spectrum.xml", "Test spectrum", "test_label", &test_spectrum);
    DOCTEST_CHECK(write_success == true);
 
    // Cleanup
    std::remove("test_spectrum.xml");
}
 
DOCTEST_TEST_CASE("CameraCalibration DGK Integration") {
    Context context;
    CameraCalibration calibration(&context);
 
    // Test DGK integration by verifying compilation and basic functionality
    // Since DGK Lab values are now implemented, the auto-calibration should work for DGK boards
 
    // Test 1: Basic instantiation and colorboard support
    // We can't directly test the Lab values since they're protected methods
    // But we can verify that the implementation compiles and basic methods work
 
    std::vector<uint> colorboard_UUIDs = calibration.getAllColorBoardUUIDs();
    // Initially empty since no colorboard has been added
    DOCTEST_CHECK(colorboard_UUIDs.size() == 0);
 
    // Test 2: Add some geometry to context to prepare for potential DGK colorboard usage
    std::vector<uint> test_patches;
    for (int i = 0; i < 18; i++) { // DGK has 18 patches
        uint patch = context.addPatch(make_vec3(i * 0.1f, 0, 0), make_vec2(0.05f, 0.05f));
        test_patches.push_back(patch);
        // Simulate colorboard labeling (as would be done by addDGKColorboard when implemented)
        context.setPrimitiveData(patch, "colorboard_DGK", uint(i));
    }
 
    // Test 3: Verify context has the test patches
    std::vector<uint> all_UUIDs = context.getAllUUIDs();
    DOCTEST_CHECK(all_UUIDs.size() >= 18);
 
    // Test 4: Verify primitive data exists for DGK-labeled patches
    int dgk_labeled_patches = 0;
    for (uint UUID: test_patches) {
        if (context.doesPrimitiveDataExist(UUID, "colorboard_DGK")) {
            dgk_labeled_patches++;
        }
    }
    DOCTEST_CHECK(dgk_labeled_patches == 18);
 
    // Note: The old CameraCalibration::autoCalibrateCameraImage() method has been removed
    // Auto-calibration is now handled by RadiationModel::autoCalibrateCameraImage()
}
 
DOCTEST_TEST_CASE("CameraCalibration Multiple Colorboards") {
    Context context;
    CameraCalibration calibration(&context);
 
    // Test 1: Add multiple different colorboard types
    std::vector<uint> dgk_UUIDs = calibration.addDGKColorboard(make_vec3(0, 0, 0.001), 0.05);
    DOCTEST_CHECK(dgk_UUIDs.size() == 18); // DGK has 18 patches
 
    std::vector<uint> calibrite_UUIDs = calibration.addCalibriteColorboard(make_vec3(0.5, 0, 0.001), 0.05);
    DOCTEST_CHECK(calibrite_UUIDs.size() == 24); // Calibrite has 24 patches
 
    std::vector<uint> spyder_UUIDs = calibration.addSpyderCHECKRColorboard(make_vec3(1.0, 0, 0.001), 0.05);
    DOCTEST_CHECK(spyder_UUIDs.size() == 24); // SpyderCHECKR has 24 patches
 
    // Test 2: getAllColorBoardUUIDs should return all colorboards combined
    std::vector<uint> all_UUIDs = calibration.getAllColorBoardUUIDs();
    DOCTEST_CHECK(all_UUIDs.size() == 66); // 18 + 24 + 24 = 66 total patches
 
    // Test 3: detectColorBoardTypes should find all three types
    std::vector<std::string> detected_types = calibration.detectColorBoardTypes();
    DOCTEST_CHECK(detected_types.size() == 3);
    DOCTEST_CHECK(std::find(detected_types.begin(), detected_types.end(), "DGK") != detected_types.end());
    DOCTEST_CHECK(std::find(detected_types.begin(), detected_types.end(), "Calibrite") != detected_types.end());
    DOCTEST_CHECK(std::find(detected_types.begin(), detected_types.end(), "SpyderCHECKR") != detected_types.end());
 
    // Test 4: Adding the same type again should replace it (with warning)
    // Suppress expected replacement warning
    std::vector<uint> dgk_UUIDs_2;
    {
        capture_cout capture;
        dgk_UUIDs_2 = calibration.addDGKColorboard(make_vec3(0, 0.5, 0.001), 0.05);
    }
    DOCTEST_CHECK(dgk_UUIDs_2.size() == 18);
 
    // Should still have 66 patches total (18 + 24 + 24), since the old DGK was replaced
    std::vector<uint> all_UUIDs_2 = calibration.getAllColorBoardUUIDs();
    DOCTEST_CHECK(all_UUIDs_2.size() == 66);
 
    // Test 5: Verify each colorboard has correct primitive data labels
    int dgk_labeled = 0, calibrite_labeled = 0, spyder_labeled = 0;
    std::vector<uint> context_UUIDs = context.getAllUUIDs();
    for (uint UUID: context_UUIDs) {
        if (context.doesPrimitiveDataExist(UUID, "colorboard_DGK")) {
            dgk_labeled++;
        }
        if (context.doesPrimitiveDataExist(UUID, "colorboard_Calibrite")) {
            calibrite_labeled++;
        }
        if (context.doesPrimitiveDataExist(UUID, "colorboard_SpyderCHECKR")) {
            spyder_labeled++;
        }
    }
    DOCTEST_CHECK(dgk_labeled == 18);
    DOCTEST_CHECK(calibrite_labeled == 24);
    DOCTEST_CHECK(spyder_labeled == 24);
}
 
GPU_TEST_CASE("RadiationModel CCM Export and Import") {
    Context context;
    RadiationModel radiationmodel = RadiationModelTestHelper::createWithSharedDevice(&context);
    radiationmodel.disableMessages();
 
    // Create a simple test camera with RGB bands
    std::vector<std::string> band_labels = {"red", "green", "blue"};
    std::string camera_label = "test_camera";
    helios::int2 resolution = make_int2(10, 10); // Small test image
 
    // Create camera properties
    CameraProperties camera_properties;
    camera_properties.camera_resolution = resolution;
    camera_properties.HFOV = 45.0f;
    // FOV_aspect_ratio is auto-calculated from camera_resolution
    camera_properties.focal_plane_distance = 1.0f;
    camera_properties.lens_diameter = 0.0f; // Pinhole camera
 
    radiationmodel.addRadiationCamera(camera_label, band_labels, make_vec3(0, 0, 1), make_vec3(0, 0, 0), camera_properties, 1);
 
    // Initialize camera data with test values
    size_t pixel_count = resolution.x * resolution.y;
    std::vector<float> red_data(pixel_count, 0.8f);
    std::vector<float> green_data(pixel_count, 0.6f);
    std::vector<float> blue_data(pixel_count, 0.4f);
 
    // Set camera pixel data
    radiationmodel.setCameraPixelData(camera_label, "red", red_data);
    radiationmodel.setCameraPixelData(camera_label, "green", green_data);
    radiationmodel.setCameraPixelData(camera_label, "blue", blue_data);
 
    // Test 1: CCM XML Export/Import Roundtrip
    {
        // Create a test color correction matrix
        std::vector<std::vector<float>> test_matrix = {{1.2f, -0.1f, 0.05f}, {-0.08f, 1.15f, 0.02f}, {0.03f, -0.12f, 1.18f}};
 
        std::string ccm_file_path = "test_ccm_3x3.xml";
 
        // Test the exportColorCorrectionMatrixXML function directly
        radiationmodel.exportColorCorrectionMatrixXML(ccm_file_path, camera_label, test_matrix, "/path/to/test_image.jpg", "DGK", 15.5f);
 
        // Verify file was created
        std::ifstream test_file(ccm_file_path);
        DOCTEST_CHECK(test_file.good());
        test_file.close();
 
        // Test the loadColorCorrectionMatrixXML function
        std::string loaded_camera_label;
        std::vector<std::vector<float>> loaded_matrix = radiationmodel.loadColorCorrectionMatrixXML(ccm_file_path, loaded_camera_label);
 
        // Verify loaded data matches exported data
        DOCTEST_CHECK(loaded_camera_label == camera_label);
        DOCTEST_CHECK(loaded_matrix.size() == 3);
        DOCTEST_CHECK(loaded_matrix[0].size() == 3);
 
        // Check matrix values with tolerance
        for (size_t i = 0; i < 3; i++) {
            for (size_t j = 0; j < 3; j++) {
                DOCTEST_CHECK(std::abs(loaded_matrix[i][j] - test_matrix[i][j]) < 1e-5f);
            }
        }
 
        // Clean up
        std::remove(ccm_file_path.c_str());
    }
 
    // Test 2: 4x3 Matrix Support
    {
        // Create a test 4x3 color correction matrix (with affine offset)
        std::vector<std::vector<float>> test_matrix_4x3 = {{1.1f, -0.05f, 0.02f, 0.01f}, {-0.04f, 1.08f, 0.01f, -0.005f}, {0.02f, -0.06f, 1.12f, 0.008f}};
 
        std::string ccm_file_path = "test_ccm_4x3.xml";
 
        // Export 4x3 matrix
        radiationmodel.exportColorCorrectionMatrixXML(ccm_file_path, camera_label, test_matrix_4x3, "/path/to/test_image.jpg", "Calibrite", 12.3f);
 
        // Load and verify
        std::string loaded_camera_label;
        std::vector<std::vector<float>> loaded_matrix = radiationmodel.loadColorCorrectionMatrixXML(ccm_file_path, loaded_camera_label);
 
        DOCTEST_CHECK(loaded_camera_label == camera_label);
        DOCTEST_CHECK(loaded_matrix.size() == 3);
        DOCTEST_CHECK(loaded_matrix[0].size() == 4);
 
        // Check matrix values
        for (size_t i = 0; i < 3; i++) {
            for (size_t j = 0; j < 4; j++) {
                DOCTEST_CHECK(std::abs(loaded_matrix[i][j] - test_matrix_4x3[i][j]) < 1e-5f);
            }
        }
 
        // Clean up
        std::remove(ccm_file_path.c_str());
    }
 
    // Test 3: applyCameraColorCorrectionMatrix with 3x3 Matrix
    {
        // Create a test CCM file
        std::vector<std::vector<float>> test_matrix = {{1.1f, -0.05f, 0.02f}, {-0.03f, 1.08f, 0.01f}, {0.01f, -0.04f, 1.12f}};
 
        std::string ccm_file_path = "test_apply_ccm_3x3.xml";
        radiationmodel.exportColorCorrectionMatrixXML(ccm_file_path, camera_label, test_matrix, "/path/to/test.jpg", "DGK", 10.0f);
 
        // Get initial pixel values
        std::vector<float> initial_red = radiationmodel.getCameraPixelData(camera_label, "red");
        std::vector<float> initial_green = radiationmodel.getCameraPixelData(camera_label, "green");
        std::vector<float> initial_blue = radiationmodel.getCameraPixelData(camera_label, "blue");
 
        // Apply color correction matrix
        radiationmodel.applyCameraColorCorrectionMatrix(camera_label, "red", "green", "blue", ccm_file_path);
 
        // Get corrected pixel values
        std::vector<float> corrected_red = radiationmodel.getCameraPixelData(camera_label, "red");
        std::vector<float> corrected_green = radiationmodel.getCameraPixelData(camera_label, "green");
        std::vector<float> corrected_blue = radiationmodel.getCameraPixelData(camera_label, "blue");
 
        // Verify correction was applied
        // For first pixel, manually calculate expected values
        float expected_red = test_matrix[0][0] * initial_red[0] + test_matrix[0][1] * initial_green[0] + test_matrix[0][2] * initial_blue[0];
        float expected_green = test_matrix[1][0] * initial_red[0] + test_matrix[1][1] * initial_green[0] + test_matrix[1][2] * initial_blue[0];
        float expected_blue = test_matrix[2][0] * initial_red[0] + test_matrix[2][1] * initial_green[0] + test_matrix[2][2] * initial_blue[0];
 
        DOCTEST_CHECK(std::abs(corrected_red[0] - expected_red) < 1e-5f);
        DOCTEST_CHECK(std::abs(corrected_green[0] - expected_green) < 1e-5f);
        DOCTEST_CHECK(std::abs(corrected_blue[0] - expected_blue) < 1e-5f);
 
        // Clean up
        std::remove(ccm_file_path.c_str());
    }
 
    // Test 4: applyCameraColorCorrectionMatrix with 4x3 Matrix
    {
        // Create a test 4x3 CCM file
        std::vector<std::vector<float>> test_matrix = {{1.05f, -0.02f, 0.01f, 0.005f}, {-0.01f, 1.03f, 0.005f, -0.002f}, {0.005f, -0.015f, 1.08f, 0.003f}};
 
        std::string ccm_file_path = "test_apply_ccm_4x3.xml";
        radiationmodel.exportColorCorrectionMatrixXML(ccm_file_path, camera_label, test_matrix, "/path/to/test.jpg", "SpyderCHECKR", 8.5f);
 
        // Reset camera data to known values
        std::fill(red_data.begin(), red_data.end(), 0.7f);
        std::fill(green_data.begin(), green_data.end(), 0.5f);
        std::fill(blue_data.begin(), blue_data.end(), 0.3f);
 
        radiationmodel.setCameraPixelData(camera_label, "red", red_data);
        radiationmodel.setCameraPixelData(camera_label, "green", green_data);
        radiationmodel.setCameraPixelData(camera_label, "blue", blue_data);
 
        // Apply 4x3 color correction matrix
        radiationmodel.applyCameraColorCorrectionMatrix(camera_label, "red", "green", "blue", ccm_file_path);
 
        // Get corrected pixel values
        std::vector<float> corrected_red = radiationmodel.getCameraPixelData(camera_label, "red");
        std::vector<float> corrected_green = radiationmodel.getCameraPixelData(camera_label, "green");
        std::vector<float> corrected_blue = radiationmodel.getCameraPixelData(camera_label, "blue");
 
        // Verify 4x3 transformation with affine offset
        float expected_red = test_matrix[0][0] * 0.7f + test_matrix[0][1] * 0.5f + test_matrix[0][2] * 0.3f + test_matrix[0][3];
        float expected_green = test_matrix[1][0] * 0.7f + test_matrix[1][1] * 0.5f + test_matrix[1][2] * 0.3f + test_matrix[1][3];
        float expected_blue = test_matrix[2][0] * 0.7f + test_matrix[2][1] * 0.5f + test_matrix[2][2] * 0.3f + test_matrix[2][3];
 
        DOCTEST_CHECK(std::abs(corrected_red[0] - expected_red) < 1e-5f);
        DOCTEST_CHECK(std::abs(corrected_green[0] - expected_green) < 1e-5f);
        DOCTEST_CHECK(std::abs(corrected_blue[0] - expected_blue) < 1e-5f);
 
        // Clean up
        std::remove(ccm_file_path.c_str());
    }
}
 
GPU_TEST_CASE("RadiationModel CCM Error Handling") {
    Context context;
    RadiationModel radiationmodel = RadiationModelTestHelper::createWithSharedDevice(&context);
 
    // Test 1: Invalid file path for loading
    {
        std::string camera_label;
        bool exception_thrown = false;
        try {
            std::vector<std::vector<float>> matrix = radiationmodel.loadColorCorrectionMatrixXML("/nonexistent/path.xml", camera_label);
        } catch (const std::runtime_error &e) {
            exception_thrown = true;
            std::string error_msg(e.what());
            DOCTEST_CHECK(error_msg.find("Failed to open file for reading") != std::string::npos);
        }
        DOCTEST_CHECK(exception_thrown);
    }
 
    // Test 2: Malformed XML file
    {
        std::string malformed_ccm_path = "malformed_ccm.xml";
        std::ofstream malformed_file(malformed_ccm_path);
        malformed_file << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
        malformed_file << "<helios>\n";
        malformed_file << "  <InvalidTag>\n";
        malformed_file << "    <row>1.0 0.0 0.0</row>\n";
        malformed_file << "  </InvalidTag>\n";
        malformed_file << "</helios>\n";
        malformed_file.close();
 
        std::string camera_label;
        bool exception_thrown = false;
        try {
            std::vector<std::vector<float>> matrix = radiationmodel.loadColorCorrectionMatrixXML(malformed_ccm_path, camera_label);
        } catch (const std::runtime_error &e) {
            exception_thrown = true;
            std::string error_msg(e.what());
            DOCTEST_CHECK(error_msg.find("No matrix data found") != std::string::npos);
        }
        DOCTEST_CHECK(exception_thrown);
 
        std::remove(malformed_ccm_path.c_str());
    }
 
    // Test 3: Apply CCM to nonexistent camera
    {
        std::string ccm_file_path = "test_error_ccm.xml";
        std::vector<std::vector<float>> identity_matrix = {{1.0f, 0.0f, 0.0f}, {0.0f, 1.0f, 0.0f}, {0.0f, 0.0f, 1.0f}};
 
        radiationmodel.exportColorCorrectionMatrixXML(ccm_file_path, "test_camera", identity_matrix, "/test.jpg", "DGK", 5.0f);
 
        bool exception_thrown = false;
        try {
            radiationmodel.applyCameraColorCorrectionMatrix("nonexistent_camera", "red", "green", "blue", ccm_file_path);
        } catch (const std::runtime_error &e) {
            exception_thrown = true;
            std::string error_msg(e.what());
            DOCTEST_CHECK(error_msg.find("Camera 'nonexistent_camera' does not exist") != std::string::npos);
        }
        DOCTEST_CHECK(exception_thrown);
 
        std::remove(ccm_file_path.c_str());
    }
}
 
GPU_TEST_CASE("RadiationModel Spectrum Interpolation from Primitive Data") {
 
    Context context;
    RadiationModel radiationmodel = RadiationModelTestHelper::createWithSharedDevice(&context);
    radiationmodel.disableMessages();
 
    // Create test spectra as global data
    std::vector<vec2> spectrum_young = {{400, 0.1}, {500, 0.15}, {600, 0.2}, {700, 0.25}};
    std::vector<vec2> spectrum_mature = {{400, 0.3}, {500, 0.35}, {600, 0.4}, {700, 0.45}};
    std::vector<vec2> spectrum_old = {{400, 0.5}, {500, 0.55}, {600, 0.6}, {700, 0.65}};
 
    context.setGlobalData("spectrum_age_0", spectrum_young);
    context.setGlobalData("spectrum_age_5", spectrum_mature);
    context.setGlobalData("spectrum_age_10", spectrum_old);
 
    // Create test primitives
    uint uuid0 = context.addPatch(make_vec3(0, 0, 0), make_vec2(1, 1));
    uint uuid1 = context.addPatch(make_vec3(2, 0, 0), make_vec2(1, 1));
    uint uuid2 = context.addPatch(make_vec3(4, 0, 0), make_vec2(1, 1));
    uint uuid3 = context.addPatch(make_vec3(6, 0, 0), make_vec2(1, 1));
    uint uuid4 = context.addPatch(make_vec3(8, 0, 0), make_vec2(1, 1));
 
    // Set age primitive data
    context.setPrimitiveData(uuid0, "age", 0.0f); // Exact match to first spectrum
    context.setPrimitiveData(uuid1, "age", 2.0f); // Between first and second, closer to first
    context.setPrimitiveData(uuid2, "age", 5.0f); // Exact match to second spectrum
    context.setPrimitiveData(uuid3, "age", 8.0f); // Between second and third, closer to third
    context.setPrimitiveData(uuid4, "age", 12.0f); // Beyond last value
 
    // Test basic interpolation with reflectivity
    DOCTEST_SUBCASE("Basic interpolation with 3 spectra") {
        std::vector<uint> uuids = {uuid0, uuid1, uuid2, uuid3, uuid4};
        std::vector<std::string> spectra = {"spectrum_age_0", "spectrum_age_5", "spectrum_age_10"};
        std::vector<float> values = {0.0f, 5.0f, 10.0f};
 
        radiationmodel.interpolateSpectrumFromPrimitiveData(uuids, spectra, values, "age", "reflectivity_spectrum");
 
        // Add band, sources, and run to trigger interpolation via updateRadiativeProperties()
        radiationmodel.addRadiationBand("PAR");
        uint source = radiationmodel.addCollimatedRadiationSource();
        radiationmodel.setSourceFlux(source, "PAR", 1000.f);
        radiationmodel.updateGeometry();
        radiationmodel.runBand("PAR");
 
        // Verify that the correct spectra were assigned
        std::string assigned_spectrum;
        context.getPrimitiveData(uuid0, "reflectivity_spectrum", assigned_spectrum);
        DOCTEST_CHECK(assigned_spectrum == "spectrum_age_0");
 
        context.getPrimitiveData(uuid1, "reflectivity_spectrum", assigned_spectrum);
        DOCTEST_CHECK(assigned_spectrum == "spectrum_age_0"); // 2.0 is closer to 0.0 than 5.0
 
        context.getPrimitiveData(uuid2, "reflectivity_spectrum", assigned_spectrum);
        DOCTEST_CHECK(assigned_spectrum == "spectrum_age_5");
 
        context.getPrimitiveData(uuid3, "reflectivity_spectrum", assigned_spectrum);
        DOCTEST_CHECK(assigned_spectrum == "spectrum_age_10"); // 8.0 is closer to 10.0 than 5.0
 
        context.getPrimitiveData(uuid4, "reflectivity_spectrum", assigned_spectrum);
        DOCTEST_CHECK(assigned_spectrum == "spectrum_age_10"); // 12.0 is closest to 10.0
    }
 
    // Test with transmissivity spectrum
    DOCTEST_SUBCASE("Interpolation with transmissivity_spectrum") {
        Context context2;
        RadiationModel radiationmodel2 = RadiationModelTestHelper::createWithSharedDevice(&context2);
        radiationmodel2.disableMessages();
 
        context2.setGlobalData("trans_young", spectrum_young);
        context2.setGlobalData("trans_old", spectrum_old);
 
        uint uuid_a = context2.addPatch(make_vec3(0, 0, 0), make_vec2(1, 1));
        uint uuid_b = context2.addPatch(make_vec3(2, 0, 0), make_vec2(1, 1));
 
        context2.setPrimitiveData(uuid_a, "leaf_age", 1.0f);
        context2.setPrimitiveData(uuid_b, "leaf_age", 9.0f);
 
        std::vector<uint> uuids = {uuid_a, uuid_b};
        std::vector<std::string> spectra = {"trans_young", "trans_old"};
        std::vector<float> values = {0.0f, 10.0f};
 
        radiationmodel2.interpolateSpectrumFromPrimitiveData(uuids, spectra, values, "leaf_age", "transmissivity_spectrum");
 
        radiationmodel2.addRadiationBand("PAR");
        uint source = radiationmodel2.addCollimatedRadiationSource();
        radiationmodel2.setSourceFlux(source, "PAR", 1000.f);
        radiationmodel2.updateGeometry();
        radiationmodel2.runBand("PAR");
 
        std::string assigned_spectrum;
        context2.getPrimitiveData(uuid_a, "transmissivity_spectrum", assigned_spectrum);
        DOCTEST_CHECK(assigned_spectrum == "trans_young");
 
        context2.getPrimitiveData(uuid_b, "transmissivity_spectrum", assigned_spectrum);
        DOCTEST_CHECK(assigned_spectrum == "trans_old");
    }
 
    // Test error handling - mismatched vector lengths
    DOCTEST_SUBCASE("Error: mismatched vector lengths") {
        Context context3;
        RadiationModel radiationmodel3 = RadiationModelTestHelper::createWithSharedDevice(&context3);
        radiationmodel3.disableMessages();
 
        context3.setGlobalData("spec1", spectrum_young);
        context3.setGlobalData("spec2", spectrum_old);
 
        uint uuid = context3.addPatch(make_vec3(0, 0, 0), make_vec2(1, 1));
 
        std::vector<uint> uuids = {uuid};
        std::vector<std::string> spectra = {"spec1", "spec2"};
        std::vector<float> values = {0.0f}; // Length mismatch!
 
        bool exception_thrown = false;
        try {
            radiationmodel3.interpolateSpectrumFromPrimitiveData(uuids, spectra, values, "age", "reflectivity_spectrum");
        } catch (const std::runtime_error &e) {
            exception_thrown = true;
            std::string error_msg(e.what());
            DOCTEST_CHECK(error_msg.find("must have the same length") != std::string::npos);
        }
        DOCTEST_CHECK(exception_thrown);
    }
 
    // Test error handling - empty vectors
    DOCTEST_SUBCASE("Error: empty vectors") {
        Context context4;
        RadiationModel radiationmodel4 = RadiationModelTestHelper::createWithSharedDevice(&context4);
        radiationmodel4.disableMessages();
 
        uint uuid = context4.addPatch(make_vec3(0, 0, 0), make_vec2(1, 1));
 
        std::vector<uint> uuids = {uuid};
        std::vector<std::string> spectra;
        std::vector<float> values;
 
        bool exception_thrown = false;
        try {
            radiationmodel4.interpolateSpectrumFromPrimitiveData(uuids, spectra, values, "age", "reflectivity_spectrum");
        } catch (const std::runtime_error &e) {
            exception_thrown = true;
            std::string error_msg(e.what());
            DOCTEST_CHECK(error_msg.find("cannot be empty") != std::string::npos);
        }
        DOCTEST_CHECK(exception_thrown);
    }
 
    // Test error handling - invalid global data (caught during runBand/updateRadiativeProperties)
    DOCTEST_SUBCASE("Error: invalid global data label") {
        Context context5;
        RadiationModel radiationmodel5 = RadiationModelTestHelper::createWithSharedDevice(&context5);
        radiationmodel5.disableMessages();
 
        uint uuid = context5.addPatch(make_vec3(0, 0, 0), make_vec2(1, 1));
        context5.setPrimitiveData(uuid, "age", 5.0f);
 
        std::vector<uint> uuids = {uuid};
        std::vector<std::string> spectra = {"nonexistent_spectrum"};
        std::vector<float> values = {0.0f};
 
        // This should succeed - validation happens later
        radiationmodel5.interpolateSpectrumFromPrimitiveData(uuids, spectra, values, "age", "reflectivity_spectrum");
 
        radiationmodel5.addRadiationBand("PAR");
        uint source = radiationmodel5.addCollimatedRadiationSource();
        radiationmodel5.setSourceFlux(source, "PAR", 1000.f);
        radiationmodel5.updateGeometry();
 
        // Error should occur when running the band (which calls updateRadiativeProperties)
        bool exception_thrown = false;
        try {
            radiationmodel5.runBand("PAR");
        } catch (const std::runtime_error &e) {
            exception_thrown = true;
            std::string error_msg(e.what());
            DOCTEST_CHECK(error_msg.find("does not exist") != std::string::npos);
        }
        DOCTEST_CHECK(exception_thrown);
    }
 
    // Test error handling - wrong global data type (caught during runBand/updateRadiativeProperties)
    DOCTEST_SUBCASE("Error: wrong global data type") {
        Context context6;
        RadiationModel radiationmodel6 = RadiationModelTestHelper::createWithSharedDevice(&context6);
        radiationmodel6.disableMessages();
 
        context6.setGlobalData("wrong_type", 42.0f); // Float instead of vec2
 
        uint uuid = context6.addPatch(make_vec3(0, 0, 0), make_vec2(1, 1));
        context6.setPrimitiveData(uuid, "age", 5.0f);
 
        std::vector<uint> uuids = {uuid};
        std::vector<std::string> spectra = {"wrong_type"};
        std::vector<float> values = {0.0f};
 
        // This should succeed - validation happens later
        radiationmodel6.interpolateSpectrumFromPrimitiveData(uuids, spectra, values, "age", "reflectivity_spectrum");
 
        radiationmodel6.addRadiationBand("PAR");
        uint source = radiationmodel6.addCollimatedRadiationSource();
        radiationmodel6.setSourceFlux(source, "PAR", 1000.f);
        radiationmodel6.updateGeometry();
 
        // Error should occur when running the band
        bool exception_thrown = false;
        try {
            radiationmodel6.runBand("PAR");
        } catch (const std::runtime_error &e) {
            exception_thrown = true;
            std::string error_msg(e.what());
            DOCTEST_CHECK(error_msg.find("HELIOS_TYPE_VEC2") != std::string::npos);
        }
        DOCTEST_CHECK(exception_thrown);
    }
 
    // Test with invalid UUID (should be silently skipped during updateRadiativeProperties)
    DOCTEST_SUBCASE("Invalid UUID is silently skipped") {
        Context context7;
        RadiationModel radiationmodel7 = RadiationModelTestHelper::createWithSharedDevice(&context7);
        radiationmodel7.disableMessages();
 
        context7.setGlobalData("spec", spectrum_young);
 
        uint valid_uuid = context7.addPatch(make_vec3(0, 0, 0), make_vec2(1, 1));
        context7.setPrimitiveData(valid_uuid, "age", 5.0f);
 
        std::vector<uint> uuids = {valid_uuid, 99999}; // One valid, one invalid UUID
        std::vector<std::string> spectra = {"spec"};
        std::vector<float> values = {0.0f};
 
        // This should succeed - invalid UUIDs are skipped during updateRadiativeProperties
        radiationmodel7.interpolateSpectrumFromPrimitiveData(uuids, spectra, values, "age", "reflectivity_spectrum");
 
        radiationmodel7.addRadiationBand("PAR");
        uint source = radiationmodel7.addCollimatedRadiationSource();
        radiationmodel7.setSourceFlux(source, "PAR", 1000.f);
        radiationmodel7.updateGeometry();
 
        // Should run successfully - invalid UUID is skipped
        radiationmodel7.runBand("PAR");
 
        // Valid UUID should have spectrum assigned
        std::string assigned_spectrum;
        context7.getPrimitiveData(valid_uuid, "reflectivity_spectrum", assigned_spectrum);
        DOCTEST_CHECK(assigned_spectrum == "spec");
    }
 
    // Test error handling - wrong primitive data type for query data
    DOCTEST_SUBCASE("Error: wrong primitive data type for query") {
        Context context8;
        RadiationModel radiationmodel8 = RadiationModelTestHelper::createWithSharedDevice(&context8);
        radiationmodel8.disableMessages();
 
        context8.setGlobalData("spec", spectrum_young);
 
        uint uuid = context8.addPatch(make_vec3(0, 0, 0), make_vec2(1, 1));
        context8.setPrimitiveData(uuid, "age", 5); // int instead of float
 
        std::vector<uint> uuids = {uuid};
        std::vector<std::string> spectra = {"spec"};
        std::vector<float> values = {0.0f};
 
        // This should succeed - validation happens later
        radiationmodel8.interpolateSpectrumFromPrimitiveData(uuids, spectra, values, "age", "reflectivity_spectrum");
 
        radiationmodel8.addRadiationBand("PAR");
        uint source = radiationmodel8.addCollimatedRadiationSource();
        radiationmodel8.setSourceFlux(source, "PAR", 1000.f);
        radiationmodel8.updateGeometry();
 
        // Error should occur when running the band
        bool exception_thrown = false;
        try {
            radiationmodel8.runBand("PAR");
        } catch (const std::runtime_error &e) {
            exception_thrown = true;
            std::string error_msg(e.what());
            DOCTEST_CHECK(error_msg.find("HELIOS_TYPE_FLOAT") != std::string::npos);
        }
        DOCTEST_CHECK(exception_thrown);
    }
 
    // Test with primitive missing query data (should not crash, just skip)
    DOCTEST_SUBCASE("Primitive without query data is skipped") {
        Context context9;
        RadiationModel radiationmodel9 = RadiationModelTestHelper::createWithSharedDevice(&context9);
        radiationmodel9.disableMessages();
 
        context9.setGlobalData("spec1", spectrum_young);
        context9.setGlobalData("spec2", spectrum_old);
 
        uint uuid_with_data = context9.addPatch(make_vec3(0, 0, 0), make_vec2(1, 1));
        uint uuid_without_data = context9.addPatch(make_vec3(2, 0, 0), make_vec2(1, 1));
 
        context9.setPrimitiveData(uuid_with_data, "age", 2.0f);
        // uuid_without_data does not have "age" data
 
        std::vector<uint> uuids = {uuid_with_data, uuid_without_data};
        std::vector<std::string> spectra = {"spec1", "spec2"};
        std::vector<float> values = {0.0f, 10.0f};
 
        radiationmodel9.interpolateSpectrumFromPrimitiveData(uuids, spectra, values, "age", "reflectivity_spectrum");
 
        radiationmodel9.addRadiationBand("PAR");
        uint source = radiationmodel9.addCollimatedRadiationSource();
        radiationmodel9.setSourceFlux(source, "PAR", 1000.f);
        radiationmodel9.updateGeometry();
        radiationmodel9.runBand("PAR");
 
        // uuid_with_data should have spectrum assigned
        std::string assigned_spectrum;
        context9.getPrimitiveData(uuid_with_data, "reflectivity_spectrum", assigned_spectrum);
        DOCTEST_CHECK(assigned_spectrum == "spec1");
 
        // uuid_without_data should not have spectrum assigned (or may not exist)
        if (context9.doesPrimitiveDataExist(uuid_without_data, "reflectivity_spectrum")) {
            // If it exists, it should not be one of our test spectra (could be empty or default)
            context9.getPrimitiveData(uuid_without_data, "reflectivity_spectrum", assigned_spectrum);
            // It's OK if it doesn't have a value, or has an empty value
        }
    }
}
 
GPU_TEST_CASE("RadiationModel Spectrum Interpolation from Object Data") {
 
    Context context;
    RadiationModel radiationmodel = RadiationModelTestHelper::createWithSharedDevice(&context);
    radiationmodel.disableMessages();
 
    // Create test spectra as global data
    std::vector<vec2> spectrum_young = {{400, 0.1}, {500, 0.15}, {600, 0.2}, {700, 0.25}};
    std::vector<vec2> spectrum_mature = {{400, 0.3}, {500, 0.35}, {600, 0.4}, {700, 0.45}};
    std::vector<vec2> spectrum_old = {{400, 0.5}, {500, 0.55}, {600, 0.6}, {700, 0.65}};
 
    context.setGlobalData("spectrum_age_0", spectrum_young);
    context.setGlobalData("spectrum_age_5", spectrum_mature);
    context.setGlobalData("spectrum_age_10", spectrum_old);
 
    // Create test objects with primitives
    uint obj0 = context.addTileObject(make_vec3(0, 0, 0), make_vec2(1, 1), make_SphericalCoord(0, 0), make_int2(2, 2));
    uint obj1 = context.addTileObject(make_vec3(2, 0, 0), make_vec2(1, 1), make_SphericalCoord(0, 0), make_int2(2, 2));
    uint obj2 = context.addTileObject(make_vec3(4, 0, 0), make_vec2(1, 1), make_SphericalCoord(0, 0), make_int2(2, 2));
    uint obj3 = context.addTileObject(make_vec3(6, 0, 0), make_vec2(1, 1), make_SphericalCoord(0, 0), make_int2(2, 2));
    uint obj4 = context.addTileObject(make_vec3(8, 0, 0), make_vec2(1, 1), make_SphericalCoord(0, 0), make_int2(2, 2));
 
    // Set age object data
    context.setObjectData(obj0, "age", 0.0f); // Exact match to first spectrum
    context.setObjectData(obj1, "age", 2.0f); // Between first and second, closer to first
    context.setObjectData(obj2, "age", 5.0f); // Exact match to second spectrum
    context.setObjectData(obj3, "age", 8.0f); // Between second and third, closer to third
    context.setObjectData(obj4, "age", 12.0f); // Beyond last value
 
    // Test basic interpolation with reflectivity
    DOCTEST_SUBCASE("Basic interpolation with 3 spectra") {
        std::vector<uint> obj_ids = {obj0, obj1, obj2, obj3, obj4};
        std::vector<std::string> spectra = {"spectrum_age_0", "spectrum_age_5", "spectrum_age_10"};
        std::vector<float> values = {0.0f, 5.0f, 10.0f};
 
        radiationmodel.interpolateSpectrumFromObjectData(obj_ids, spectra, values, "age", "reflectivity_spectrum");
 
        // Add band, sources, and run to trigger interpolation via updateRadiativeProperties()
        radiationmodel.addRadiationBand("PAR");
        uint source = radiationmodel.addCollimatedRadiationSource();
        radiationmodel.setSourceFlux(source, "PAR", 1000.f);
        radiationmodel.updateGeometry();
        radiationmodel.runBand("PAR");
 
        // Verify that the correct spectra were assigned to all primitives of each object
        std::string assigned_spectrum;
        std::vector<uint> prim_uuids0 = context.getObjectPrimitiveUUIDs(obj0);
        for (uint uuid: prim_uuids0) {
            context.getPrimitiveData(uuid, "reflectivity_spectrum", assigned_spectrum);
            DOCTEST_CHECK(assigned_spectrum == "spectrum_age_0");
        }
 
        std::vector<uint> prim_uuids1 = context.getObjectPrimitiveUUIDs(obj1);
        for (uint uuid: prim_uuids1) {
            context.getPrimitiveData(uuid, "reflectivity_spectrum", assigned_spectrum);
            DOCTEST_CHECK(assigned_spectrum == "spectrum_age_0"); // 2.0 is closer to 0.0 than 5.0
        }
 
        std::vector<uint> prim_uuids2 = context.getObjectPrimitiveUUIDs(obj2);
        for (uint uuid: prim_uuids2) {
            context.getPrimitiveData(uuid, "reflectivity_spectrum", assigned_spectrum);
            DOCTEST_CHECK(assigned_spectrum == "spectrum_age_5");
        }
 
        std::vector<uint> prim_uuids3 = context.getObjectPrimitiveUUIDs(obj3);
        for (uint uuid: prim_uuids3) {
            context.getPrimitiveData(uuid, "reflectivity_spectrum", assigned_spectrum);
            DOCTEST_CHECK(assigned_spectrum == "spectrum_age_10"); // 8.0 is closer to 10.0 than 5.0
        }
 
        std::vector<uint> prim_uuids4 = context.getObjectPrimitiveUUIDs(obj4);
        for (uint uuid: prim_uuids4) {
            context.getPrimitiveData(uuid, "reflectivity_spectrum", assigned_spectrum);
            DOCTEST_CHECK(assigned_spectrum == "spectrum_age_10"); // 12.0 is closest to 10.0
        }
    }
 
    // Test with transmissivity spectrum
    DOCTEST_SUBCASE("Interpolation with transmissivity_spectrum") {
        Context context2;
        RadiationModel radiationmodel2 = RadiationModelTestHelper::createWithSharedDevice(&context2);
        radiationmodel2.disableMessages();
 
        context2.setGlobalData("trans_young", spectrum_young);
        context2.setGlobalData("trans_old", spectrum_old);
 
        uint obj_a = context2.addTileObject(make_vec3(0, 0, 0), make_vec2(1, 1), make_SphericalCoord(0, 0), make_int2(2, 2));
        uint obj_b = context2.addTileObject(make_vec3(2, 0, 0), make_vec2(1, 1), make_SphericalCoord(0, 0), make_int2(2, 2));
 
        context2.setObjectData(obj_a, "leaf_age", 1.0f);
        context2.setObjectData(obj_b, "leaf_age", 9.0f);
 
        std::vector<uint> obj_ids = {obj_a, obj_b};
        std::vector<std::string> spectra = {"trans_young", "trans_old"};
        std::vector<float> values = {0.0f, 10.0f};
 
        radiationmodel2.interpolateSpectrumFromObjectData(obj_ids, spectra, values, "leaf_age", "transmissivity_spectrum");
 
        radiationmodel2.addRadiationBand("PAR");
        uint source = radiationmodel2.addCollimatedRadiationSource();
        radiationmodel2.setSourceFlux(source, "PAR", 1000.f);
        radiationmodel2.updateGeometry();
        radiationmodel2.runBand("PAR");
 
        std::string assigned_spectrum;
        std::vector<uint> prim_uuids_a = context2.getObjectPrimitiveUUIDs(obj_a);
        for (uint uuid: prim_uuids_a) {
            context2.getPrimitiveData(uuid, "transmissivity_spectrum", assigned_spectrum);
            DOCTEST_CHECK(assigned_spectrum == "trans_young");
        }
 
        std::vector<uint> prim_uuids_b = context2.getObjectPrimitiveUUIDs(obj_b);
        for (uint uuid: prim_uuids_b) {
            context2.getPrimitiveData(uuid, "transmissivity_spectrum", assigned_spectrum);
            DOCTEST_CHECK(assigned_spectrum == "trans_old");
        }
    }
 
    // Test error handling - mismatched vector lengths
    DOCTEST_SUBCASE("Error: mismatched vector lengths") {
        Context context3;
        RadiationModel radiationmodel3 = RadiationModelTestHelper::createWithSharedDevice(&context3);
        radiationmodel3.disableMessages();
 
        uint obj_test = context3.addTileObject(make_vec3(0, 0, 0), make_vec2(1, 1), make_SphericalCoord(0, 0), make_int2(2, 2));
        std::vector<uint> obj_ids = {obj_test};
        std::vector<std::string> spectra = {"spec1", "spec2"};
        std::vector<float> values = {0.0f}; // Wrong size
 
        bool caught_error = false;
        try {
            radiationmodel3.interpolateSpectrumFromObjectData(obj_ids, spectra, values, "age", "reflectivity_spectrum");
        } catch (const std::exception &e) {
            caught_error = true;
        }
        DOCTEST_CHECK(caught_error);
    }
 
    // Test error handling - empty spectra vector
    DOCTEST_SUBCASE("Error: empty spectra vector") {
        Context context4;
        RadiationModel radiationmodel4 = RadiationModelTestHelper::createWithSharedDevice(&context4);
        radiationmodel4.disableMessages();
 
        uint obj_test = context4.addTileObject(make_vec3(0, 0, 0), make_vec2(1, 1), make_SphericalCoord(0, 0), make_int2(2, 2));
        std::vector<uint> obj_ids = {obj_test};
        std::vector<std::string> spectra;
        std::vector<float> values;
 
        bool caught_error = false;
        try {
            radiationmodel4.interpolateSpectrumFromObjectData(obj_ids, spectra, values, "age", "reflectivity_spectrum");
        } catch (const std::exception &e) {
            caught_error = true;
        }
        DOCTEST_CHECK(caught_error);
    }
 
    // Test error handling - empty object_IDs vector
    DOCTEST_SUBCASE("Error: empty object_IDs vector") {
        Context context5;
        RadiationModel radiationmodel5 = RadiationModelTestHelper::createWithSharedDevice(&context5);
        radiationmodel5.disableMessages();
 
        std::vector<uint> obj_ids;
        std::vector<std::string> spectra = {"spec1"};
        std::vector<float> values = {0.0f};
 
        bool caught_error = false;
        try {
            radiationmodel5.interpolateSpectrumFromObjectData(obj_ids, spectra, values, "age", "reflectivity_spectrum");
        } catch (const std::exception &e) {
            caught_error = true;
        }
        DOCTEST_CHECK(caught_error);
    }
 
    // Test error handling - empty query label
    DOCTEST_SUBCASE("Error: empty query label") {
        Context context6;
        RadiationModel radiationmodel6 = RadiationModelTestHelper::createWithSharedDevice(&context6);
        radiationmodel6.disableMessages();
 
        uint obj_test = context6.addTileObject(make_vec3(0, 0, 0), make_vec2(1, 1), make_SphericalCoord(0, 0), make_int2(2, 2));
        std::vector<uint> obj_ids = {obj_test};
        std::vector<std::string> spectra = {"spec1"};
        std::vector<float> values = {0.0f};
 
        bool caught_error = false;
        try {
            radiationmodel6.interpolateSpectrumFromObjectData(obj_ids, spectra, values, "", "reflectivity_spectrum");
        } catch (const std::exception &e) {
            caught_error = true;
        }
        DOCTEST_CHECK(caught_error);
    }
 
    // Test error handling - empty target label
    DOCTEST_SUBCASE("Error: empty target label") {
        Context context7;
        RadiationModel radiationmodel7 = RadiationModelTestHelper::createWithSharedDevice(&context7);
        radiationmodel7.disableMessages();
 
        uint obj_test = context7.addTileObject(make_vec3(0, 0, 0), make_vec2(1, 1), make_SphericalCoord(0, 0), make_int2(2, 2));
        std::vector<uint> obj_ids = {obj_test};
        std::vector<std::string> spectra = {"spec1"};
        std::vector<float> values = {0.0f};
 
        bool caught_error = false;
        try {
            radiationmodel7.interpolateSpectrumFromObjectData(obj_ids, spectra, values, "age", "");
        } catch (const std::exception &e) {
            caught_error = true;
        }
        DOCTEST_CHECK(caught_error);
    }
 
    // Test graceful handling - object doesn't have the data field
    DOCTEST_SUBCASE("Graceful skip: object without query data") {
        Context context8;
        RadiationModel radiationmodel8 = RadiationModelTestHelper::createWithSharedDevice(&context8);
        radiationmodel8.disableMessages();
 
        context8.setGlobalData("spec1", spectrum_young);
 
        uint obj_with_data = context8.addTileObject(make_vec3(0, 0, 0), make_vec2(1, 1), make_SphericalCoord(0, 0), make_int2(2, 2));
        uint obj_without_data = context8.addTileObject(make_vec3(2, 0, 0), make_vec2(1, 1), make_SphericalCoord(0, 0), make_int2(2, 2));
 
        context8.setObjectData(obj_with_data, "age", 5.0f);
        // obj_without_data doesn't have "age" data
 
        std::vector<uint> obj_ids = {obj_with_data, obj_without_data};
        std::vector<std::string> spectra = {"spec1"};
        std::vector<float> values = {5.0f};
 
        radiationmodel8.interpolateSpectrumFromObjectData(obj_ids, spectra, values, "age", "reflectivity_spectrum");
 
        radiationmodel8.addRadiationBand("PAR");
        uint source = radiationmodel8.addCollimatedRadiationSource();
        radiationmodel8.setSourceFlux(source, "PAR", 1000.f);
        radiationmodel8.updateGeometry();
        radiationmodel8.runBand("PAR");
 
        std::string assigned_spectrum;
        std::vector<uint> prim_uuids_with = context8.getObjectPrimitiveUUIDs(obj_with_data);
        for (uint uuid: prim_uuids_with) {
            context8.getPrimitiveData(uuid, "reflectivity_spectrum", assigned_spectrum);
            DOCTEST_CHECK(assigned_spectrum == "spec1");
        }
 
        // obj_without_data's primitives should not have spectrum assigned
        std::vector<uint> prim_uuids_without = context8.getObjectPrimitiveUUIDs(obj_without_data);
        for (uint uuid: prim_uuids_without) {
            if (context8.doesPrimitiveDataExist(uuid, "reflectivity_spectrum")) {
                context8.getPrimitiveData(uuid, "reflectivity_spectrum", assigned_spectrum);
            }
        }
    }
 
    // Test graceful handling - invalid object ID (deleted object)
    DOCTEST_SUBCASE("Graceful skip: invalid object ID") {
        Context context9;
        RadiationModel radiationmodel9 = RadiationModelTestHelper::createWithSharedDevice(&context9);
        radiationmodel9.disableMessages();
 
        context9.setGlobalData("spec1", spectrum_young);
 
        uint obj_valid = context9.addTileObject(make_vec3(0, 0, 0), make_vec2(1, 1), make_SphericalCoord(0, 0), make_int2(2, 2));
        uint obj_to_delete = context9.addTileObject(make_vec3(2, 0, 0), make_vec2(1, 1), make_SphericalCoord(0, 0), make_int2(2, 2));
 
        context9.setObjectData(obj_valid, "age", 5.0f);
        context9.setObjectData(obj_to_delete, "age", 5.0f);
 
        std::vector<uint> obj_ids = {obj_valid, obj_to_delete};
        std::vector<std::string> spectra = {"spec1"};
        std::vector<float> values = {5.0f};
 
        radiationmodel9.interpolateSpectrumFromObjectData(obj_ids, spectra, values, "age", "reflectivity_spectrum");
 
        // Delete the object before running
        context9.deleteObject(obj_to_delete);
 
        radiationmodel9.addRadiationBand("PAR");
        uint source = radiationmodel9.addCollimatedRadiationSource();
        radiationmodel9.setSourceFlux(source, "PAR", 1000.f);
        radiationmodel9.updateGeometry();
        radiationmodel9.runBand("PAR");
 
        std::string assigned_spectrum;
        std::vector<uint> prim_uuids_valid = context9.getObjectPrimitiveUUIDs(obj_valid);
        for (uint uuid: prim_uuids_valid) {
            context9.getPrimitiveData(uuid, "reflectivity_spectrum", assigned_spectrum);
            DOCTEST_CHECK(assigned_spectrum == "spec1");
        }
    }
 
    // Test error handling - wrong object data type (int instead of float)
    DOCTEST_SUBCASE("Error: wrong object data type") {
        Context context10;
        RadiationModel radiationmodel10 = RadiationModelTestHelper::createWithSharedDevice(&context10);
        radiationmodel10.disableMessages();
 
        context10.setGlobalData("spec1", spectrum_young);
 
        uint obj_test = context10.addTileObject(make_vec3(0, 0, 0), make_vec2(1, 1), make_SphericalCoord(0, 0), make_int2(2, 2));
        context10.setObjectData(obj_test, "age", 5); // int, not float
 
        std::vector<uint> obj_ids = {obj_test};
        std::vector<std::string> spectra = {"spec1"};
        std::vector<float> values = {5.0f};
 
        radiationmodel10.interpolateSpectrumFromObjectData(obj_ids, spectra, values, "age", "reflectivity_spectrum");
 
        radiationmodel10.addRadiationBand("PAR");
        uint source = radiationmodel10.addCollimatedRadiationSource();
        radiationmodel10.setSourceFlux(source, "PAR", 1000.f);
        radiationmodel10.updateGeometry();
 
        bool caught_error = false;
        try {
            radiationmodel10.runBand("PAR");
        } catch (const std::exception &e) {
            caught_error = true;
        }
        DOCTEST_CHECK(caught_error);
    }
 
    // Test error handling - invalid global data (doesn't exist)
    DOCTEST_SUBCASE("Error: invalid global data") {
        Context context11;
        RadiationModel radiationmodel11 = RadiationModelTestHelper::createWithSharedDevice(&context11);
        radiationmodel11.disableMessages();
 
        uint obj_test = context11.addTileObject(make_vec3(0, 0, 0), make_vec2(1, 1), make_SphericalCoord(0, 0), make_int2(2, 2));
        context11.setObjectData(obj_test, "age", 5.0f);
 
        std::vector<uint> obj_ids = {obj_test};
        std::vector<std::string> spectra = {"nonexistent_spectrum"};
        std::vector<float> values = {5.0f};
 
        radiationmodel11.interpolateSpectrumFromObjectData(obj_ids, spectra, values, "age", "reflectivity_spectrum");
 
        radiationmodel11.addRadiationBand("PAR");
        uint source = radiationmodel11.addCollimatedRadiationSource();
        radiationmodel11.setSourceFlux(source, "PAR", 1000.f);
        radiationmodel11.updateGeometry();
 
        bool caught_error = false;
        try {
            radiationmodel11.runBand("PAR");
        } catch (const std::exception &e) {
            caught_error = true;
        }
        DOCTEST_CHECK(caught_error);
    }
 
    // Test error handling - wrong global data type
    DOCTEST_SUBCASE("Error: wrong global data type") {
        Context context12;
        RadiationModel radiationmodel12 = RadiationModelTestHelper::createWithSharedDevice(&context12);
        radiationmodel12.disableMessages();
 
        context12.setGlobalData("wrong_type", 42.0f); // float, not vec2 vector
 
        uint obj_test = context12.addTileObject(make_vec3(0, 0, 0), make_vec2(1, 1), make_SphericalCoord(0, 0), make_int2(2, 2));
        context12.setObjectData(obj_test, "age", 5.0f);
 
        std::vector<uint> obj_ids = {obj_test};
        std::vector<std::string> spectra = {"wrong_type"};
        std::vector<float> values = {5.0f};
 
        radiationmodel12.interpolateSpectrumFromObjectData(obj_ids, spectra, values, "age", "reflectivity_spectrum");
 
        radiationmodel12.addRadiationBand("PAR");
        uint source = radiationmodel12.addCollimatedRadiationSource();
        radiationmodel12.setSourceFlux(source, "PAR", 1000.f);
        radiationmodel12.updateGeometry();
 
        bool caught_error = false;
        try {
            radiationmodel12.runBand("PAR");
        } catch (const std::exception &e) {
            caught_error = true;
        }
        DOCTEST_CHECK(caught_error);
    }
}
 
GPU_TEST_CASE("RadiationModel Spectrum Interpolation - Duplicate Handling") {
 
    // Test merging of duplicate primitive UUIDs with same spectra/values
    DOCTEST_SUBCASE("Primitive: Merge duplicates with matching spectra") {
        Context context;
        RadiationModel radiationmodel = RadiationModelTestHelper::createWithSharedDevice(&context);
        radiationmodel.disableMessages();
 
        std::vector<vec2> spectrum1 = {{400, 0.1}, {500, 0.15}};
        std::vector<vec2> spectrum2 = {{400, 0.3}, {500, 0.35}};
        context.setGlobalData("spec1", spectrum1);
        context.setGlobalData("spec2", spectrum2);
 
        uint uuid0 = context.addPatch(make_vec3(0, 0, 0), make_vec2(1, 1));
        uint uuid1 = context.addPatch(make_vec3(2, 0, 0), make_vec2(1, 1));
        uint uuid2 = context.addPatch(make_vec3(4, 0, 0), make_vec2(1, 1));
 
        context.setPrimitiveData(uuid0, "age", 1.0f);
        context.setPrimitiveData(uuid1, "age", 1.0f);
        context.setPrimitiveData(uuid2, "age", 9.0f);
 
        // First call with uuid0 and uuid1
        radiationmodel.interpolateSpectrumFromPrimitiveData({uuid0, uuid1}, {"spec1", "spec2"}, {0.0f, 10.0f}, "age", "reflectivity_spectrum");
 
        // Second call with uuid1 (duplicate) and uuid2 (new) - same spectra/values
        radiationmodel.interpolateSpectrumFromPrimitiveData({uuid1, uuid2}, {"spec1", "spec2"}, {0.0f, 10.0f}, "age", "reflectivity_spectrum");
 
        radiationmodel.addRadiationBand("PAR");
        uint source = radiationmodel.addCollimatedRadiationSource();
        radiationmodel.setSourceFlux(source, "PAR", 1000.f);
        radiationmodel.updateGeometry();
        radiationmodel.runBand("PAR");
 
        // All three should be processed correctly (uuid1 appears only once due to set deduplication)
        std::string assigned_spectrum;
        context.getPrimitiveData(uuid0, "reflectivity_spectrum", assigned_spectrum);
        DOCTEST_CHECK(assigned_spectrum == "spec1");
 
        context.getPrimitiveData(uuid1, "reflectivity_spectrum", assigned_spectrum);
        DOCTEST_CHECK(assigned_spectrum == "spec1");
 
        context.getPrimitiveData(uuid2, "reflectivity_spectrum", assigned_spectrum);
        DOCTEST_CHECK(assigned_spectrum == "spec2");
    }
 
    // Test replacement when spectra/values change
    DOCTEST_SUBCASE("Primitive: Replace config with different spectra") {
        Context context2;
        RadiationModel radiationmodel2 = RadiationModelTestHelper::createWithSharedDevice(&context2);
        radiationmodel2.disableMessages();
 
        std::vector<vec2> spectrum1 = {{400, 0.1}, {500, 0.15}};
        std::vector<vec2> spectrum2 = {{400, 0.3}, {500, 0.35}};
        std::vector<vec2> spectrum3 = {{400, 0.5}, {500, 0.55}};
        context2.setGlobalData("spec1", spectrum1);
        context2.setGlobalData("spec2", spectrum2);
        context2.setGlobalData("spec3", spectrum3);
 
        uint uuid0 = context2.addPatch(make_vec3(0, 0, 0), make_vec2(1, 1));
        uint uuid1 = context2.addPatch(make_vec3(2, 0, 0), make_vec2(1, 1));
 
        context2.setPrimitiveData(uuid0, "age", 1.0f);
        context2.setPrimitiveData(uuid1, "age", 15.0f);
 
        // First call with 2 spectra
        radiationmodel2.interpolateSpectrumFromPrimitiveData({uuid0, uuid1}, {"spec1", "spec2"}, {0.0f, 10.0f}, "age", "reflectivity_spectrum");
 
        // Second call with same labels but 3 spectra (should replace)
        radiationmodel2.interpolateSpectrumFromPrimitiveData({uuid0, uuid1}, {"spec1", "spec2", "spec3"}, {0.0f, 10.0f, 20.0f}, "age", "reflectivity_spectrum");
 
        radiationmodel2.addRadiationBand("PAR");
        uint source = radiationmodel2.addCollimatedRadiationSource();
        radiationmodel2.setSourceFlux(source, "PAR", 1000.f);
        radiationmodel2.updateGeometry();
        radiationmodel2.runBand("PAR");
 
        // Should use the new 3-spectrum config
        std::string assigned_spectrum;
        context2.getPrimitiveData(uuid0, "reflectivity_spectrum", assigned_spectrum);
        DOCTEST_CHECK(assigned_spectrum == "spec1");
 
        context2.getPrimitiveData(uuid1, "reflectivity_spectrum", assigned_spectrum);
        DOCTEST_CHECK(assigned_spectrum == "spec2"); // 15.0 is closer to 10.0 than 20.0
    }
 
    // Test merging of duplicate object IDs with same spectra/values
    DOCTEST_SUBCASE("Object: Merge duplicates with matching spectra") {
        Context context3;
        RadiationModel radiationmodel3 = RadiationModelTestHelper::createWithSharedDevice(&context3);
        radiationmodel3.disableMessages();
 
        std::vector<vec2> spectrum1 = {{400, 0.1}, {500, 0.15}};
        std::vector<vec2> spectrum2 = {{400, 0.3}, {500, 0.35}};
        context3.setGlobalData("spec1", spectrum1);
        context3.setGlobalData("spec2", spectrum2);
 
        uint obj0 = context3.addTileObject(make_vec3(0, 0, 0), make_vec2(1, 1), make_SphericalCoord(0, 0), make_int2(2, 2));
        uint obj1 = context3.addTileObject(make_vec3(2, 0, 0), make_vec2(1, 1), make_SphericalCoord(0, 0), make_int2(2, 2));
        uint obj2 = context3.addTileObject(make_vec3(4, 0, 0), make_vec2(1, 1), make_SphericalCoord(0, 0), make_int2(2, 2));
 
        context3.setObjectData(obj0, "age", 1.0f);
        context3.setObjectData(obj1, "age", 1.0f);
        context3.setObjectData(obj2, "age", 9.0f);
 
        // First call with obj0 and obj1
        radiationmodel3.interpolateSpectrumFromObjectData({obj0, obj1}, {"spec1", "spec2"}, {0.0f, 10.0f}, "age", "reflectivity_spectrum");
 
        // Second call with obj1 (duplicate) and obj2 (new) - same spectra/values
        radiationmodel3.interpolateSpectrumFromObjectData({obj1, obj2}, {"spec1", "spec2"}, {0.0f, 10.0f}, "age", "reflectivity_spectrum");
 
        radiationmodel3.addRadiationBand("PAR");
        uint source = radiationmodel3.addCollimatedRadiationSource();
        radiationmodel3.setSourceFlux(source, "PAR", 1000.f);
        radiationmodel3.updateGeometry();
        radiationmodel3.runBand("PAR");
 
        // All three objects' primitives should be processed correctly
        std::string assigned_spectrum;
        std::vector<uint> prim_uuids0 = context3.getObjectPrimitiveUUIDs(obj0);
        for (uint uuid: prim_uuids0) {
            context3.getPrimitiveData(uuid, "reflectivity_spectrum", assigned_spectrum);
            DOCTEST_CHECK(assigned_spectrum == "spec1");
        }
 
        std::vector<uint> prim_uuids1 = context3.getObjectPrimitiveUUIDs(obj1);
        for (uint uuid: prim_uuids1) {
            context3.getPrimitiveData(uuid, "reflectivity_spectrum", assigned_spectrum);
            DOCTEST_CHECK(assigned_spectrum == "spec1");
        }
 
        std::vector<uint> prim_uuids2 = context3.getObjectPrimitiveUUIDs(obj2);
        for (uint uuid: prim_uuids2) {
            context3.getPrimitiveData(uuid, "reflectivity_spectrum", assigned_spectrum);
            DOCTEST_CHECK(assigned_spectrum == "spec2");
        }
    }
 
    // Test replacement when spectra/values change for objects
    DOCTEST_SUBCASE("Object: Replace config with different spectra") {
        Context context4;
        RadiationModel radiationmodel4 = RadiationModelTestHelper::createWithSharedDevice(&context4);
        radiationmodel4.disableMessages();
 
        std::vector<vec2> spectrum1 = {{400, 0.1}, {500, 0.15}};
        std::vector<vec2> spectrum2 = {{400, 0.3}, {500, 0.35}};
        std::vector<vec2> spectrum3 = {{400, 0.5}, {500, 0.55}};
        context4.setGlobalData("spec1", spectrum1);
        context4.setGlobalData("spec2", spectrum2);
        context4.setGlobalData("spec3", spectrum3);
 
        uint obj0 = context4.addTileObject(make_vec3(0, 0, 0), make_vec2(1, 1), make_SphericalCoord(0, 0), make_int2(2, 2));
        uint obj1 = context4.addTileObject(make_vec3(2, 0, 0), make_vec2(1, 1), make_SphericalCoord(0, 0), make_int2(2, 2));
 
        context4.setObjectData(obj0, "age", 1.0f);
        context4.setObjectData(obj1, "age", 15.0f);
 
        // First call with 2 spectra
        radiationmodel4.interpolateSpectrumFromObjectData({obj0, obj1}, {"spec1", "spec2"}, {0.0f, 10.0f}, "age", "reflectivity_spectrum");
 
        // Second call with same labels but 3 spectra (should replace)
        radiationmodel4.interpolateSpectrumFromObjectData({obj0, obj1}, {"spec1", "spec2", "spec3"}, {0.0f, 10.0f, 20.0f}, "age", "reflectivity_spectrum");
 
        radiationmodel4.addRadiationBand("PAR");
        uint source = radiationmodel4.addCollimatedRadiationSource();
        radiationmodel4.setSourceFlux(source, "PAR", 1000.f);
        radiationmodel4.updateGeometry();
        radiationmodel4.runBand("PAR");
 
        // Should use the new 3-spectrum config
        std::string assigned_spectrum;
        std::vector<uint> prim_uuids0 = context4.getObjectPrimitiveUUIDs(obj0);
        for (uint uuid: prim_uuids0) {
            context4.getPrimitiveData(uuid, "reflectivity_spectrum", assigned_spectrum);
            DOCTEST_CHECK(assigned_spectrum == "spec1");
        }
 
        std::vector<uint> prim_uuids1 = context4.getObjectPrimitiveUUIDs(obj1);
        for (uint uuid: prim_uuids1) {
            context4.getPrimitiveData(uuid, "reflectivity_spectrum", assigned_spectrum);
            DOCTEST_CHECK(assigned_spectrum == "spec2"); // 15.0 is closer to 10.0 than 20.0
        }
    }
 
    // Test that different query/target label pairs create separate configs
    DOCTEST_SUBCASE("Primitive: Separate configs for different labels") {
        Context context5;
        RadiationModel radiationmodel5 = RadiationModelTestHelper::createWithSharedDevice(&context5);
        radiationmodel5.disableMessages();
 
        std::vector<vec2> spectrum1 = {{400, 0.1}, {500, 0.15}};
        std::vector<vec2> spectrum2 = {{400, 0.3}, {500, 0.35}};
        context5.setGlobalData("spec1", spectrum1);
        context5.setGlobalData("spec2", spectrum2);
 
        uint uuid0 = context5.addPatch(make_vec3(0, 0, 0), make_vec2(1, 1));
 
        context5.setPrimitiveData(uuid0, "age", 1.0f);
        context5.setPrimitiveData(uuid0, "maturity", 9.0f);
 
        // Two different configs with different query labels
        radiationmodel5.interpolateSpectrumFromPrimitiveData({uuid0}, {"spec1", "spec2"}, {0.0f, 10.0f}, "age", "reflectivity_spectrum");
        radiationmodel5.interpolateSpectrumFromPrimitiveData({uuid0}, {"spec1", "spec2"}, {0.0f, 10.0f}, "maturity", "transmissivity_spectrum");
 
        radiationmodel5.addRadiationBand("PAR");
        uint source = radiationmodel5.addCollimatedRadiationSource();
        radiationmodel5.setSourceFlux(source, "PAR", 1000.f);
        radiationmodel5.updateGeometry();
        radiationmodel5.runBand("PAR");
 
        // Both should be set independently
        std::string assigned_spectrum_rho;
        std::string assigned_spectrum_tau;
        context5.getPrimitiveData(uuid0, "reflectivity_spectrum", assigned_spectrum_rho);
        context5.getPrimitiveData(uuid0, "transmissivity_spectrum", assigned_spectrum_tau);
 
        DOCTEST_CHECK(assigned_spectrum_rho == "spec1"); // age=1.0 -> spec1
        DOCTEST_CHECK(assigned_spectrum_tau == "spec2"); // maturity=9.0 -> spec2
    }
}
 
GPU_TEST_CASE("RadiationModel - Camera Metadata Export") {
    Context context;
 
    // Set context properties for metadata
    context.setDate(30, 9, 2025); // day, month, year
    context.setTime(0, 30, 10); // second, minute, hour
    context.setLocation(make_Location(34.0522, -118.2437, 8.0)); // Los Angeles
 
    RadiationModel radiationmodel = RadiationModelTestHelper::createWithSharedDevice(&context);
    radiationmodel.disableMessages();
 
    // Add a simple surface for the camera to image
    uint uuid = context.addPatch(make_vec3(0, 0, 0), make_vec2(1, 1));
    context.setPrimitiveData(uuid, "reflectivity_SW", 0.5f);
 
    // Add radiation band and source
    radiationmodel.addRadiationBand("RGB_R");
    radiationmodel.addRadiationBand("RGB_G");
    radiationmodel.addRadiationBand("RGB_B");
 
    uint source = radiationmodel.addCollimatedRadiationSource();
    radiationmodel.setSourceFlux(source, "RGB_R", 100.f);
    radiationmodel.setSourceFlux(source, "RGB_G", 100.f);
    radiationmodel.setSourceFlux(source, "RGB_B", 100.f);
 
    DOCTEST_SUBCASE("Auto-populate metadata with custom sensor size") {
        // Create camera with custom sensor size
        CameraProperties camera_props;
        camera_props.camera_resolution = make_int2(512, 512);
        camera_props.focal_plane_distance = 2.0f; // 2 meters working distance
        camera_props.lens_diameter = 0.05f; // 5 cm lens diameter
        camera_props.HFOV = 45.0f; // 45 degree horizontal FOV
        // FOV_aspect_ratio is auto-calculated from camera_resolution (square: 1.0)
        camera_props.sensor_width_mm = 24.0f; // APS-C sensor size
 
        radiationmodel.addRadiationCamera("test_camera", {"RGB_R", "RGB_G", "RGB_B"}, make_vec3(0, -5, 2), // Position at x=0, y=-5, z=2
                                          make_vec3(0, 0, 0), // Looking at origin
                                          camera_props, 1);
 
        // Get auto-populated metadata (metadata is auto-populated when camera is added)
        CameraMetadata metadata = radiationmodel.getCameraMetadata("test_camera");
 
        // Check camera properties
        DOCTEST_CHECK(metadata.camera_properties.width == 512);
        DOCTEST_CHECK(metadata.camera_properties.height == 512);
        DOCTEST_CHECK(metadata.camera_properties.channels == 3);
 
        // Check sensor dimensions
        DOCTEST_CHECK(metadata.camera_properties.sensor_width == 24.0f);
        DOCTEST_CHECK(metadata.camera_properties.sensor_height == doctest::Approx(24.0f).epsilon(0.01)); // Should equal sensor_width/aspect_ratio
 
        // Check focal length calculation: focal_length = sensor_width / (2 * tan(HFOV/2))
        float expected_focal_length = 24.0f / (2.0f * tan(45.0f * M_PI / 180.0f / 2.0f));
        DOCTEST_CHECK(metadata.camera_properties.focal_length == doctest::Approx(expected_focal_length).epsilon(0.01));
 
        // Check aperture calculation: f-number = focal_length / lens_diameter_mm
        float lens_diameter_mm = 0.05f * 1000.0f; // Convert to mm
        float expected_f_number = expected_focal_length / lens_diameter_mm;
        std::ostringstream expected_aperture;
        expected_aperture << "f/" << std::fixed << std::setprecision(1) << expected_f_number;
        DOCTEST_CHECK(metadata.camera_properties.aperture == expected_aperture.str());
 
        // Check camera model (should be default "generic")
        DOCTEST_CHECK(metadata.camera_properties.model == "generic");
 
        // Check location properties
        DOCTEST_CHECK(metadata.location_properties.latitude == doctest::Approx(34.0522).epsilon(0.0001));
        DOCTEST_CHECK(metadata.location_properties.longitude == doctest::Approx(-118.2437).epsilon(0.0001));
 
        // Check acquisition properties
        DOCTEST_CHECK(metadata.acquisition_properties.date == "2025-09-30");
        DOCTEST_CHECK(metadata.acquisition_properties.time == "10:30:00");
        DOCTEST_CHECK(metadata.acquisition_properties.UTC_offset == 8.0f);
        DOCTEST_CHECK(metadata.acquisition_properties.camera_height_m == 2.0f); // z-position
 
        // Check tilt angle: camera at (0,-5,2) looking at (0,0,0)
        // Direction vector: (0,5,-2), normalized: (0, 0.9285, -0.3714)
        // Tilt angle: -asin(-0.3714) = 21.8 degrees (positive = pointing downward)
        DOCTEST_CHECK(metadata.acquisition_properties.camera_angle_deg == doctest::Approx(21.8).epsilon(0.5));
 
        // Check light source detection (should be "sunlight" with collimated source)
        DOCTEST_CHECK(metadata.acquisition_properties.light_source == "sunlight");
 
        // Path should be empty until image is written
        DOCTEST_CHECK(metadata.path == "");
    }
 
    DOCTEST_SUBCASE("Pinhole camera aperture") {
        CameraProperties camera_props;
        camera_props.camera_resolution = make_int2(256, 256);
        camera_props.focal_plane_distance = 1.0f;
        camera_props.lens_diameter = 0.0f; // Pinhole camera
        camera_props.HFOV = 30.0f;
        // FOV_aspect_ratio is auto-calculated from camera_resolution (square: 1.0)
        camera_props.sensor_width_mm = 35.0f; // Default full-frame
 
        radiationmodel.addRadiationCamera("pinhole_camera", {"RGB_R"}, make_vec3(0, 0, 5), make_vec3(0, 0, 0), camera_props, 1);
 
        // Get auto-populated metadata
        CameraMetadata metadata = radiationmodel.getCameraMetadata("pinhole_camera");
 
        // Check pinhole aperture
        DOCTEST_CHECK(metadata.camera_properties.aperture == "pinhole");
    }
 
    DOCTEST_SUBCASE("Light source detection") {
        CameraProperties camera_props;
        camera_props.camera_resolution = make_int2(128, 128);
        camera_props.HFOV = 20.0f;
 
        // Test with no sources (already has collimated source, so remove it for clean test)
        Context context2;
        RadiationModel radiationmodel2 = RadiationModelTestHelper::createWithSharedDevice(&context2);
        radiationmodel2.disableMessages();
 
        radiationmodel2.addRadiationBand("test");
        radiationmodel2.addRadiationCamera("camera1", {"test"}, make_vec3(0, 0, 1), make_vec3(0, 0, 0), camera_props, 1);
 
        // Get auto-populated metadata
        CameraMetadata metadata1 = radiationmodel2.getCameraMetadata("camera1");
        DOCTEST_CHECK(metadata1.acquisition_properties.light_source == "none");
 
        // Add collimated source -> "sunlight"
        uint source1 = radiationmodel2.addCollimatedRadiationSource();
        radiationmodel2.setSourceFlux(source1, "test", 100.f);
        // Re-get metadata to reflect new light source
        metadata1 = radiationmodel2.getCameraMetadata("camera1");
        DOCTEST_CHECK(metadata1.acquisition_properties.light_source == "sunlight");
 
        // Add disk source -> "mixed"
        uint source2 = radiationmodel2.addDiskRadiationSource(make_vec3(0, 0, 10), 1.0f, make_vec3(0, 0, 0));
        radiationmodel2.setSourceFlux(source2, "test", 50.f);
        // Re-get metadata to reflect mixed light sources
        metadata1 = radiationmodel2.getCameraMetadata("camera1");
        DOCTEST_CHECK(metadata1.acquisition_properties.light_source == "mixed");
    }
 
    DOCTEST_SUBCASE("Set metadata and automatic JSON export") {
        CameraProperties camera_props;
        camera_props.camera_resolution = make_int2(256, 256);
        camera_props.HFOV = 35.0f;
        camera_props.sensor_width_mm = 35.0f;
 
        radiationmodel.addRadiationCamera("export_camera", {"RGB_R", "RGB_G", "RGB_B"}, make_vec3(0, -3, 1.5), make_vec3(0, 0, 0), camera_props, 1);
 
        // Enable automatic metadata JSON export
        radiationmodel.enableCameraMetadata("export_camera");
 
        // Run simulation
        radiationmodel.updateGeometry();
        radiationmodel.runBand("RGB_R");
        radiationmodel.runBand("RGB_G");
        radiationmodel.runBand("RGB_B");
 
        // Write camera image (should automatically write JSON metadata)
        std::string image_path = radiationmodel.writeCameraImage("export_camera", {"RGB_R", "RGB_G", "RGB_B"}, "test_metadata");
 
        // Check that image was written
        DOCTEST_CHECK(!image_path.empty());
        DOCTEST_CHECK(image_path.find(".jpeg") != std::string::npos);
 
        // Check that JSON file exists
        std::string json_path = image_path.substr(0, image_path.find_last_of(".")) + ".json";
        std::ifstream json_file(json_path);
        DOCTEST_CHECK(json_file.is_open());
 
        if (json_file.is_open()) {
            // Parse JSON and validate structure
            nlohmann::json j;
            json_file >> j;
            json_file.close();
 
            // Validate JSON structure
            DOCTEST_CHECK(j.contains("path"));
            DOCTEST_CHECK(j.contains("camera_properties"));
            DOCTEST_CHECK(j.contains("location_properties"));
            DOCTEST_CHECK(j.contains("acquisition_properties"));
 
            // Validate camera_properties fields
            DOCTEST_CHECK(j["camera_properties"].contains("height"));
            DOCTEST_CHECK(j["camera_properties"].contains("width"));
            DOCTEST_CHECK(j["camera_properties"].contains("channels"));
            DOCTEST_CHECK(j["camera_properties"].contains("focal_length"));
            DOCTEST_CHECK(j["camera_properties"].contains("aperture"));
            DOCTEST_CHECK(j["camera_properties"].contains("sensor_width"));
            DOCTEST_CHECK(j["camera_properties"].contains("sensor_height"));
            DOCTEST_CHECK(j["camera_properties"].contains("model"));
 
            // Validate values
            DOCTEST_CHECK(j["camera_properties"]["width"] == 256);
            DOCTEST_CHECK(j["camera_properties"]["height"] == 256);
            DOCTEST_CHECK(j["camera_properties"]["channels"] == 3);
            DOCTEST_CHECK(j["camera_properties"]["model"] == "generic");
 
            // Extract filename from full path for comparison
            size_t last_slash = image_path.find_last_of("/\\");
            std::string expected_filename = (last_slash != std::string::npos) ? image_path.substr(last_slash + 1) : image_path;
            DOCTEST_CHECK(j["path"] == expected_filename);
 
            // Clean up test files
            std::remove(image_path.c_str());
            std::remove(json_path.c_str());
        }
    }
 
    DOCTEST_SUBCASE("Manual metadata population") {
        CameraProperties camera_props;
        camera_props.camera_resolution = make_int2(128, 128);
 
        radiationmodel.addRadiationCamera("manual_camera", {"RGB_R"}, make_vec3(0, 0, 2), make_vec3(0, 0, 0), camera_props, 1);
 
        // Manually create metadata
        CameraMetadata metadata;
        metadata.camera_properties.width = 128;
        metadata.camera_properties.height = 128;
        metadata.camera_properties.channels = 1;
        metadata.camera_properties.focal_length = 50.0f;
        metadata.camera_properties.aperture = "f/1.8";
        metadata.camera_properties.sensor_width = 36.0f;
        metadata.camera_properties.sensor_height = 24.0f;
        metadata.camera_properties.model = "Nikon D700";
 
        metadata.location_properties.latitude = 40.0f;
        metadata.location_properties.longitude = -75.0f;
 
        metadata.acquisition_properties.date = "2025-01-01";
        metadata.acquisition_properties.time = "12:00:00";
        metadata.acquisition_properties.UTC_offset = 5.0f;
        metadata.acquisition_properties.camera_height_m = 10.0f;
        metadata.acquisition_properties.camera_angle_deg = 45.0f;
        metadata.acquisition_properties.light_source = "artificial";
 
        // Set manual metadata
        radiationmodel.setCameraMetadata("manual_camera", metadata);
 
        // Verify it was stored by retrieving it (note: getCameraMetadata re-populates from camera properties,
        // so we can only verify setCameraMetadata doesn't throw an exception)
        DOCTEST_CHECK(true);
    }
 
    DOCTEST_SUBCASE("Enable metadata for multiple cameras with vector") {
        CameraProperties camera_props;
        camera_props.camera_resolution = make_int2(128, 128);
        camera_props.HFOV = 30.0f;
 
        // Add three cameras
        radiationmodel.addRadiationCamera("camera_A", {"RGB_R", "RGB_G", "RGB_B"}, make_vec3(0, -2, 1), make_vec3(0, 0, 0), camera_props, 1);
        radiationmodel.addRadiationCamera("camera_B", {"RGB_R", "RGB_G", "RGB_B"}, make_vec3(2, 0, 1), make_vec3(0, 0, 0), camera_props, 1);
        radiationmodel.addRadiationCamera("camera_C", {"RGB_R", "RGB_G", "RGB_B"}, make_vec3(0, 2, 1), make_vec3(0, 0, 0), camera_props, 1);
 
        // Enable metadata for all three cameras using vector overload
        std::vector<std::string> camera_labels = {"camera_A", "camera_B", "camera_C"};
        radiationmodel.enableCameraMetadata(camera_labels);
 
        // Run simulation
        radiationmodel.updateGeometry();
        radiationmodel.runBand("RGB_R");
        radiationmodel.runBand("RGB_G");
        radiationmodel.runBand("RGB_B");
 
        // Write images for all cameras and verify JSON files are created
        std::vector<std::string> image_paths;
        std::vector<std::string> json_paths;
 
        for (const auto &label: camera_labels) {
            std::string image_path = radiationmodel.writeCameraImage(label, {"RGB_R", "RGB_G", "RGB_B"}, "test_vector");
            DOCTEST_CHECK(!image_path.empty());
 
            std::string json_path = image_path.substr(0, image_path.find_last_of(".")) + ".json";
            std::ifstream json_file(json_path);
            DOCTEST_CHECK(json_file.is_open());
            json_file.close();
 
            image_paths.push_back(image_path);
            json_paths.push_back(json_path);
        }
 
        // Clean up test files
        for (size_t i = 0; i < image_paths.size(); i++) {
            std::remove(image_paths[i].c_str());
            std::remove(json_paths[i].c_str());
        }
    }
 
    DOCTEST_SUBCASE("applyCameraImageCorrections stores parameters in metadata") {
        // Add geometry
        context.addPatch(make_vec3(0, 0, 0), make_vec2(2, 2));
 
        CameraProperties camera_props;
        camera_props.camera_resolution = make_int2(128, 128);
        camera_props.HFOV = 45.0f;
        camera_props.sensor_width_mm = 35.0f;
 
        radiationmodel.addRadiationCamera("corrections_camera", {"RGB_R", "RGB_G", "RGB_B"}, make_vec3(0, -2, 1), make_vec3(0, 0, 0), camera_props, 1);
 
        // Enable automatic metadata JSON export
        radiationmodel.enableCameraMetadata("corrections_camera");
 
        // Run simulation
        radiationmodel.updateGeometry();
        radiationmodel.runBand("RGB_R");
        radiationmodel.runBand("RGB_G");
        radiationmodel.runBand("RGB_B");
 
        // Apply image corrections with non-default values
        float saturation = 1.5f;
        float brightness = 1.2f;
        float contrast = 1.1f;
        radiationmodel.applyCameraImageCorrections("corrections_camera", "RGB_R", "RGB_G", "RGB_B", saturation, brightness, contrast);
 
        // Write camera image (should automatically write JSON metadata with image_processing)
        std::string image_path = radiationmodel.writeCameraImage("corrections_camera", {"RGB_R", "RGB_G", "RGB_B"}, "test_corrections");
 
        DOCTEST_CHECK(!image_path.empty());
 
        // Check that JSON file exists and contains image_processing parameters
        std::string json_path = image_path.substr(0, image_path.find_last_of(".")) + ".json";
        std::ifstream json_file(json_path);
        DOCTEST_CHECK(json_file.is_open());
 
        if (json_file.is_open()) {
            nlohmann::json j;
            json_file >> j;
            json_file.close();
 
            // Validate image_processing is a top-level block
            DOCTEST_CHECK(j.contains("acquisition_properties"));
            DOCTEST_CHECK(j.contains("image_processing"));
 
            // Validate image_processing values
            auto &img_proc = j["image_processing"];
            DOCTEST_CHECK(img_proc.contains("saturation_adjustment"));
            DOCTEST_CHECK(img_proc.contains("brightness_adjustment"));
            DOCTEST_CHECK(img_proc.contains("contrast_adjustment"));
            DOCTEST_CHECK(img_proc.contains("color_space"));
 
            DOCTEST_CHECK(img_proc["saturation_adjustment"].get<double>() == doctest::Approx(saturation).epsilon(0.01));
            DOCTEST_CHECK(img_proc["brightness_adjustment"].get<double>() == doctest::Approx(brightness).epsilon(0.01));
            DOCTEST_CHECK(img_proc["contrast_adjustment"].get<double>() == doctest::Approx(contrast).epsilon(0.01));
            DOCTEST_CHECK(img_proc["color_space"].get<std::string>() == "sRGB");
 
            // Clean up test files
            std::remove(image_path.c_str());
            std::remove(json_path.c_str());
        }
    }
}
 
GPU_TEST_CASE("RadiationModel - Camera Metadata Agronomic Properties") {
    Context context;
 
    // Set context properties for metadata
    context.setDate(15, 6, 2025);
    context.setTime(0, 0, 12);
    context.setLocation(make_Location(38.0, -120.0, -8.0));
 
    RadiationModel radiationmodel = RadiationModelTestHelper::createWithSharedDevice(&context);
    radiationmodel.disableMessages();
 
    // Add radiation bands
    radiationmodel.addRadiationBand("RGB_R");
    radiationmodel.addRadiationBand("RGB_G");
    radiationmodel.addRadiationBand("RGB_B");
 
    // Add radiation source
    uint source = radiationmodel.addCollimatedRadiationSource();
    radiationmodel.setSourceFlux(source, "RGB_R", 100.f);
    radiationmodel.setSourceFlux(source, "RGB_G", 100.f);
    radiationmodel.setSourceFlux(source, "RGB_B", 100.f);
 
    // Enable scattering to ensure pixel labeling runs
    radiationmodel.setScatteringDepth("RGB_R", 1);
    radiationmodel.setScatteringDepth("RGB_G", 1);
    radiationmodel.setScatteringDepth("RGB_B", 1);
 
    DOCTEST_SUBCASE("Agronomic properties with multiple species and weeds") {
        // Create plant objects with different species and weed status
        // Bean plants (plantID 1, 2, 3)
        uint bean_obj_1 = context.addTileObject(make_vec3(0, 0, 0), make_vec2(0.2, 0.2), make_SphericalCoord(0, 0), make_int2(2, 2));
        context.setObjectData(bean_obj_1, "plant_name", std::string("bean"));
        context.setObjectData(bean_obj_1, "plantID", 1);
        context.setObjectData(bean_obj_1, "plant_type", std::string("crop"));
        context.setObjectData(bean_obj_1, "plant_height", 0.45f);
        context.setObjectData(bean_obj_1, "age", 30.0f);
        context.setObjectData(bean_obj_1, "phenology_stage", std::string("flowering"));
        context.setObjectData(bean_obj_1, "reflectivity_SW", 0.3f);
 
        uint bean_obj_2 = context.addTileObject(make_vec3(0.5, 0, 0), make_vec2(0.2, 0.2), make_SphericalCoord(0, 0), make_int2(2, 2));
        context.setObjectData(bean_obj_2, "plant_name", std::string("bean"));
        context.setObjectData(bean_obj_2, "plantID", 2);
        context.setObjectData(bean_obj_2, "plant_type", std::string("crop"));
        context.setObjectData(bean_obj_2, "plant_height", 0.50f);
        context.setObjectData(bean_obj_2, "age", 32.0f);
        context.setObjectData(bean_obj_2, "phenology_stage", std::string("flowering"));
        context.setObjectData(bean_obj_2, "reflectivity_SW", 0.3f);
 
        uint bean_obj_3 = context.addTileObject(make_vec3(1.0, 0, 0), make_vec2(0.2, 0.2), make_SphericalCoord(0, 0), make_int2(2, 2));
        context.setObjectData(bean_obj_3, "plant_name", std::string("bean"));
        context.setObjectData(bean_obj_3, "plantID", 3);
        context.setObjectData(bean_obj_3, "plant_type", std::string("crop"));
        context.setObjectData(bean_obj_3, "plant_height", 0.42f);
        context.setObjectData(bean_obj_3, "age", 28.0f);
        context.setObjectData(bean_obj_3, "phenology_stage", std::string("flowering"));
        context.setObjectData(bean_obj_3, "reflectivity_SW", 0.3f);
 
        // Weed plants (plantID 4, 5)
        uint weed_obj_1 = context.addTileObject(make_vec3(0, 0.5, 0), make_vec2(0.15, 0.15), make_SphericalCoord(0, 0), make_int2(2, 2));
        context.setObjectData(weed_obj_1, "plant_name", std::string("pigweed"));
        context.setObjectData(weed_obj_1, "plantID", 4);
        context.setObjectData(weed_obj_1, "plant_type", std::string("weed"));
        context.setObjectData(weed_obj_1, "plant_height", 0.30f);
        context.setObjectData(weed_obj_1, "age", 15.0f);
        context.setObjectData(weed_obj_1, "phenology_stage", std::string("vegetative"));
        context.setObjectData(weed_obj_1, "reflectivity_SW", 0.25f);
 
        uint weed_obj_2 = context.addTileObject(make_vec3(0.5, 0.5, 0), make_vec2(0.15, 0.15), make_SphericalCoord(0, 0), make_int2(2, 2));
        context.setObjectData(weed_obj_2, "plant_name", std::string("pigweed"));
        context.setObjectData(weed_obj_2, "plantID", 5);
        context.setObjectData(weed_obj_2, "plant_type", std::string("weed"));
        context.setObjectData(weed_obj_2, "plant_height", 0.35f);
        context.setObjectData(weed_obj_2, "age", 18.0f);
        context.setObjectData(weed_obj_2, "phenology_stage", std::string("vegetative"));
        context.setObjectData(weed_obj_2, "reflectivity_SW", 0.25f);
 
        // Create camera looking down at the scene
        CameraProperties camera_props;
        camera_props.camera_resolution = make_int2(256, 256);
        camera_props.HFOV = 60.0f;
        camera_props.sensor_width_mm = 35.0f;
 
        radiationmodel.addRadiationCamera("test_camera", {"RGB_R", "RGB_G", "RGB_B"}, make_vec3(0.5, 0.25, 3.0), make_vec3(0.5, 0.25, 0), camera_props, 1);
 
        // Run simulation to generate pixel UUID map
        radiationmodel.updateGeometry();
        radiationmodel.runBand("RGB_R");
        radiationmodel.runBand("RGB_G");
        radiationmodel.runBand("RGB_B");
 
        // Get metadata (should automatically compute agronomic properties from camera pixels)
        CameraMetadata metadata = radiationmodel.getCameraMetadata("test_camera");
 
        // Check agronomic properties
        DOCTEST_CHECK(!metadata.agronomic_properties.plant_species.empty());
        DOCTEST_CHECK(metadata.agronomic_properties.plant_species.size() == 2); // bean and pigweed
 
        // Find indices for bean and pigweed
        int bean_idx = -1;
        int pigweed_idx = -1;
        for (size_t i = 0; i < metadata.agronomic_properties.plant_species.size(); i++) {
            if (metadata.agronomic_properties.plant_species[i] == "bean") {
                bean_idx = static_cast<int>(i);
            } else if (metadata.agronomic_properties.plant_species[i] == "pigweed") {
                pigweed_idx = static_cast<int>(i);
            }
        }
 
        DOCTEST_CHECK(bean_idx >= 0);
        DOCTEST_CHECK(pigweed_idx >= 0);
 
        // Check plant counts
        if (bean_idx >= 0) {
            DOCTEST_CHECK(metadata.agronomic_properties.plant_count[bean_idx] == 3); // 3 bean plants
        }
        if (pigweed_idx >= 0) {
            DOCTEST_CHECK(metadata.agronomic_properties.plant_count[pigweed_idx] == 2); // 2 weed plants
        }
 
        // Check weed pressure: 2 weeds out of 5 plants = 40% = "moderate"
        DOCTEST_CHECK(metadata.agronomic_properties.weed_pressure == "moderate");
 
        // Check new agronomic properties
        DOCTEST_CHECK(metadata.agronomic_properties.plant_height_m.size() == 2);
        DOCTEST_CHECK(metadata.agronomic_properties.plant_age_days.size() == 2);
        DOCTEST_CHECK(metadata.agronomic_properties.plant_stage.size() == 2);
        DOCTEST_CHECK(metadata.agronomic_properties.leaf_area_m2.size() == 2);
 
        // Check plant height (weighted average per species)
        // Bean: (0.45 + 0.50 + 0.42) / 3 ≈ 0.46 (assuming equal pixel weights)
        // Pigweed: (0.30 + 0.35) / 2 = 0.325
        if (bean_idx >= 0) {
            DOCTEST_CHECK(metadata.agronomic_properties.plant_height_m[bean_idx] > 0.40f);
            DOCTEST_CHECK(metadata.agronomic_properties.plant_height_m[bean_idx] < 0.52f);
        }
        if (pigweed_idx >= 0) {
            DOCTEST_CHECK(metadata.agronomic_properties.plant_height_m[pigweed_idx] > 0.28f);
            DOCTEST_CHECK(metadata.agronomic_properties.plant_height_m[pigweed_idx] < 0.37f);
        }
 
        // Check plant age (weighted average per species)
        // Bean: (30.0 + 32.0 + 28.0) / 3 = 30.0 days
        // Pigweed: (15.0 + 18.0) / 2 = 16.5 days
        if (bean_idx >= 0) {
            DOCTEST_CHECK(metadata.agronomic_properties.plant_age_days[bean_idx] > 27.0f);
            DOCTEST_CHECK(metadata.agronomic_properties.plant_age_days[bean_idx] < 33.0f);
        }
        if (pigweed_idx >= 0) {
            DOCTEST_CHECK(metadata.agronomic_properties.plant_age_days[pigweed_idx] > 14.0f);
            DOCTEST_CHECK(metadata.agronomic_properties.plant_age_days[pigweed_idx] < 19.0f);
        }
 
        // Check plant stage (mode - most common phenology stage)
        // Bean: all 3 are "flowering" -> mode = "flowering"
        // Pigweed: both are "vegetative" -> mode = "vegetative"
        if (bean_idx >= 0) {
            DOCTEST_CHECK(metadata.agronomic_properties.plant_stage[bean_idx] == "flowering");
        }
        if (pigweed_idx >= 0) {
            DOCTEST_CHECK(metadata.agronomic_properties.plant_stage[pigweed_idx] == "vegetative");
        }
 
        // Check leaf area (should be > 0 for both species)
        if (bean_idx >= 0) {
            DOCTEST_CHECK(metadata.agronomic_properties.leaf_area_m2[bean_idx] > 0.0f);
        }
        if (pigweed_idx >= 0) {
            DOCTEST_CHECK(metadata.agronomic_properties.leaf_area_m2[pigweed_idx] > 0.0f);
        }
    }
 
    DOCTEST_SUBCASE("Agronomic properties with low weed pressure") {
        // Create 10 crop plants and 1 weed (10% weeds = "low")
        for (int i = 0; i < 10; i++) {
            uint crop_obj = context.addTileObject(make_vec3(i * 0.3, 0, 0), make_vec2(0.1, 0.1), make_SphericalCoord(0, 0), make_int2(2, 2));
            context.setObjectData(crop_obj, "plant_name", std::string("soybean"));
            context.setObjectData(crop_obj, "plantID", i + 1);
            context.setObjectData(crop_obj, "plant_type", std::string("crop"));
            context.setObjectData(crop_obj, "reflectivity_SW", 0.3f);
        }
 
        uint weed_obj = context.addTileObject(make_vec3(0, 0.5, 0), make_vec2(0.1, 0.1), make_SphericalCoord(0, 0), make_int2(2, 2));
        context.setObjectData(weed_obj, "plant_name", std::string("lambsquarter"));
        context.setObjectData(weed_obj, "plantID", 11);
        context.setObjectData(weed_obj, "plant_type", std::string("weed"));
        context.setObjectData(weed_obj, "reflectivity_SW", 0.25f);
 
        CameraProperties camera_props;
        camera_props.camera_resolution = make_int2(512, 256);
        camera_props.HFOV = 90.0f;
 
        radiationmodel.addRadiationCamera("low_weed_camera", {"RGB_R"}, make_vec3(1.5, 0.25, 2.0), make_vec3(1.5, 0.25, 0), camera_props, 1);
 
        radiationmodel.updateGeometry();
        radiationmodel.runBand("RGB_R");
 
        // Get metadata with agronomic properties
        CameraMetadata metadata = radiationmodel.getCameraMetadata("low_weed_camera");
 
        // 1 weed out of 11 plants = 9.09% = "low"
        DOCTEST_CHECK(metadata.agronomic_properties.weed_pressure == "low");
    }
 
    DOCTEST_SUBCASE("Agronomic properties with high weed pressure") {
        // Create 2 crops and 3 weeds (60% weeds = "high")
        uint crop_obj_1 = context.addTileObject(make_vec3(0, 0, 0), make_vec2(0.2, 0.2), make_SphericalCoord(0, 0), make_int2(2, 2));
        context.setObjectData(crop_obj_1, "plant_name", std::string("corn"));
        context.setObjectData(crop_obj_1, "plantID", 1);
        context.setObjectData(crop_obj_1, "plant_type", std::string("crop"));
        context.setObjectData(crop_obj_1, "reflectivity_SW", 0.3f);
 
        uint crop_obj_2 = context.addTileObject(make_vec3(0.5, 0, 0), make_vec2(0.2, 0.2), make_SphericalCoord(0, 0), make_int2(2, 2));
        context.setObjectData(crop_obj_2, "plant_name", std::string("corn"));
        context.setObjectData(crop_obj_2, "plantID", 2);
        context.setObjectData(crop_obj_2, "plant_type", std::string("crop"));
        context.setObjectData(crop_obj_2, "reflectivity_SW", 0.3f);
 
        for (int i = 0; i < 3; i++) {
            uint weed_obj = context.addTileObject(make_vec3(i * 0.3, 0.5, 0), make_vec2(0.15, 0.15), make_SphericalCoord(0, 0), make_int2(2, 2));
            context.setObjectData(weed_obj, "plant_name", std::string("foxtail"));
            context.setObjectData(weed_obj, "plantID", 3 + i);
            context.setObjectData(weed_obj, "plant_type", std::string("weed"));
            context.setObjectData(weed_obj, "reflectivity_SW", 0.25f);
        }
 
        CameraProperties camera_props;
        camera_props.camera_resolution = make_int2(256, 256);
        camera_props.HFOV = 60.0f;
 
        radiationmodel.addRadiationCamera("high_weed_camera", {"RGB_R"}, make_vec3(0.5, 0.25, 2.5), make_vec3(0.5, 0.25, 0), camera_props, 1);
 
        radiationmodel.updateGeometry();
        radiationmodel.runBand("RGB_R");
 
        // Get metadata with agronomic properties
        CameraMetadata metadata = radiationmodel.getCameraMetadata("high_weed_camera");
 
        // 3 weeds out of 5 plants = 60% = "high"
        DOCTEST_CHECK(metadata.agronomic_properties.weed_pressure == "high");
    }
 
    DOCTEST_SUBCASE("Agronomic properties with no plant data") {
        // Create objects without plant architecture data
        std::vector<uint> patch_UUIDs = context.addTile(make_vec3(0, 0, 0), make_vec2(1, 1), make_SphericalCoord(0, 0), make_int2(5, 5));
        for (const auto &uuid: patch_UUIDs) {
            context.setPrimitiveData(uuid, "reflectivity_SW", 0.3f);
        }
 
        CameraProperties camera_props;
        camera_props.camera_resolution = make_int2(128, 128);
        camera_props.HFOV = 45.0f;
 
        radiationmodel.addRadiationCamera("no_data_camera", {"RGB_R"}, make_vec3(0.5, 0.5, 2.0), make_vec3(0.5, 0.5, 0), camera_props, 1);
 
        radiationmodel.updateGeometry();
        radiationmodel.runBand("RGB_R");
 
        // Get metadata with agronomic properties
        CameraMetadata metadata = radiationmodel.getCameraMetadata("no_data_camera");
 
        // Should have empty agronomic properties when no plant data exists
        DOCTEST_CHECK(metadata.agronomic_properties.plant_species.empty());
        DOCTEST_CHECK(metadata.agronomic_properties.plant_count.empty());
        DOCTEST_CHECK(metadata.agronomic_properties.weed_pressure == "");
    }
 
    DOCTEST_SUBCASE("Agronomic properties JSON export") {
        // Create a simple scene with plants
        uint bean_obj = context.addTileObject(make_vec3(0, 0, 0), make_vec2(0.3, 0.3), make_SphericalCoord(0, 0), make_int2(3, 3));
        context.setObjectData(bean_obj, "plant_name", std::string("bean"));
        context.setObjectData(bean_obj, "plantID", 1);
        context.setObjectData(bean_obj, "plant_type", std::string("crop"));
        context.setObjectData(bean_obj, "reflectivity_SW", 0.3f);
 
        uint weed_obj = context.addTileObject(make_vec3(0.5, 0, 0), make_vec2(0.2, 0.2), make_SphericalCoord(0, 0), make_int2(2, 2));
        context.setObjectData(weed_obj, "plant_name", std::string("weed"));
        context.setObjectData(weed_obj, "plantID", 2);
        context.setObjectData(weed_obj, "plant_type", std::string("weed"));
        context.setObjectData(weed_obj, "reflectivity_SW", 0.25f);
 
        CameraProperties camera_props;
        camera_props.camera_resolution = make_int2(256, 256);
        camera_props.HFOV = 50.0f;
 
        radiationmodel.addRadiationCamera("json_export_camera", {"RGB_R", "RGB_G", "RGB_B"}, make_vec3(0.25, 0, 2.0), make_vec3(0.25, 0, 0), camera_props, 1);
 
        radiationmodel.updateGeometry();
        radiationmodel.runBand("RGB_R");
        radiationmodel.runBand("RGB_G");
        radiationmodel.runBand("RGB_B");
 
        // Enable automatic metadata JSON export
        radiationmodel.enableCameraMetadata("json_export_camera");
 
        // Write image (which triggers metadata JSON export)
        std::string image_path = radiationmodel.writeCameraImage("json_export_camera", {"RGB_R", "RGB_G", "RGB_B"}, "test_agronomic");
 
        // Also verify metadata was populated correctly
        CameraMetadata metadata = radiationmodel.getCameraMetadata("json_export_camera");
 
        // Check JSON file
        std::string json_path = image_path.substr(0, image_path.find_last_of(".")) + ".json";
        std::ifstream json_file(json_path);
        DOCTEST_CHECK(json_file.is_open());
 
        if (json_file.is_open()) {
            nlohmann::json j;
            json_file >> j;
            json_file.close();
 
            // Check that agronomic_properties exists
            DOCTEST_CHECK(j.contains("agronomic_properties"));
 
            if (j.contains("agronomic_properties")) {
                DOCTEST_CHECK(j["agronomic_properties"].contains("plant_species"));
                DOCTEST_CHECK(j["agronomic_properties"].contains("plant_count"));
                DOCTEST_CHECK(j["agronomic_properties"].contains("weed_pressure"));
 
                // Validate values
                DOCTEST_CHECK(j["agronomic_properties"]["plant_species"].is_array());
                DOCTEST_CHECK(j["agronomic_properties"]["plant_count"].is_array());
                DOCTEST_CHECK(j["agronomic_properties"]["weed_pressure"].is_string());
 
                // 1 weed out of 2 plants = 50% = "high"
                DOCTEST_CHECK(j["agronomic_properties"]["weed_pressure"] == "high");
            }
 
            // Clean up
            std::remove(image_path.c_str());
            std::remove(json_path.c_str());
        }
    }
}
 
GPU_TEST_CASE("RadiationModel - FOV_aspect_ratio Deprecation") {
 
    Context context;
 
    // Create a basic radiation model
    RadiationModel radiationmodel = RadiationModelTestHelper::createWithSharedDevice(&context);
    radiationmodel.disableMessages();
 
    // Add a radiation band
    radiationmodel.addRadiationBand("test");
 
    DOCTEST_SUBCASE("Default FOV_aspect_ratio is auto-calculated") {
        // Create camera with non-square resolution
        CameraProperties camera_props;
        camera_props.camera_resolution = make_int2(800, 600); // 4:3 aspect ratio
        camera_props.HFOV = 45.0f;
        // FOV_aspect_ratio left at default (0.0)
 
        // Should not produce any warning
        std::string stderr_output;
        {
            capture_cerr captured_cerr;
            radiationmodel.addRadiationCamera("test_camera_1", {"test"}, make_vec3(0, 0, 2), make_vec3(0, 0, 0), camera_props, 1);
            stderr_output = captured_cerr.get_captured_output();
        } // capture destroyed here
        DOCTEST_CHECK(stderr_output.empty());
 
        // Verify FOV_aspect_ratio was auto-calculated correctly
        // Expected: 800/600 = 1.333...
        float expected_aspect = float(camera_props.camera_resolution.x) / float(camera_props.camera_resolution.y);
        DOCTEST_CHECK(std::abs(expected_aspect - 1.333333f) < 0.0001f);
    }
 
    DOCTEST_SUBCASE("Explicit FOV_aspect_ratio triggers deprecation warning") {
        // Create camera with explicit FOV_aspect_ratio
        CameraProperties camera_props;
        camera_props.camera_resolution = make_int2(640, 480);
        camera_props.HFOV = 50.0f;
        camera_props.FOV_aspect_ratio = 1.5f; // Explicitly set to non-zero value
 
        // Should produce deprecation warning
        std::string stderr_output;
        {
            capture_cerr captured_cerr;
            radiationmodel.addRadiationCamera("test_camera_2", {"test"}, make_vec3(0, 0, 2), make_vec3(0, 0, 0), camera_props, 1);
            stderr_output = captured_cerr.get_captured_output();
        } // capture destroyed here
        DOCTEST_CHECK(stderr_output.find("WARNING") != std::string::npos);
        DOCTEST_CHECK(stderr_output.find("FOV_aspect_ratio") != std::string::npos);
        DOCTEST_CHECK(stderr_output.find("deprecated") != std::string::npos);
        DOCTEST_CHECK(stderr_output.find("auto-calculated") != std::string::npos);
    }
 
    DOCTEST_SUBCASE("Auto-calculated value ensures square pixels") {
        // Create cameras with various resolutions
        std::vector<helios::int2> resolutions = {
                make_int2(1920, 1080), // 16:9
                make_int2(1024, 768), // 4:3
                make_int2(512, 512), // 1:1
                make_int2(640, 480) // 4:3
        };
 
        for (const auto &resolution: resolutions) {
            CameraProperties camera_props;
            camera_props.camera_resolution = resolution;
            camera_props.HFOV = 60.0f;
            // FOV_aspect_ratio left at default (0.0)
 
            std::string camera_label = "camera_" + std::to_string(resolution.x) + "x" + std::to_string(resolution.y);
 
            // Should not produce any warning
            std::string stderr_output;
            {
                capture_cerr captured_cerr;
                radiationmodel.addRadiationCamera(camera_label, {"test"}, make_vec3(0, 0, 2), make_vec3(0, 0, 0), camera_props, 1);
                stderr_output = captured_cerr.get_captured_output();
            } // capture destroyed here
            DOCTEST_CHECK(stderr_output.empty());
        }
    }
}
 
GPU_TEST_CASE("RadiationModel Atmospheric Sky Model for Camera") {
    // Test that atmospheric sky radiance model is computed when cameras are present
    // and that atmospheric parameters from SolarPosition plugin are used correctly
 
    Context context;
 
    // Create simple geometry
    uint UUID = context.addPatch(make_vec3(0, 0, 0), make_vec2(1, 1));
    context.setPrimitiveData(UUID, "temperature", 300.f);
 
    // Set atmospheric conditions (as would be set by SolarPosition plugin)
    float pressure_Pa = 95000.f; // Lower pressure (higher altitude)
    float temperature_K = 285.f; // Cooler temperature
    float humidity_rel = 0.6f; // 60% humidity
    float turbidity = 0.08f; // Moderately turbid (AOD at 500nm)
 
    context.setGlobalData("atmosphere_pressure_Pa", pressure_Pa);
    context.setGlobalData("atmosphere_temperature_K", temperature_K);
    context.setGlobalData("atmosphere_humidity_rel", humidity_rel);
    context.setGlobalData("atmosphere_turbidity", turbidity);
 
    RadiationModel radiationmodel = RadiationModelTestHelper::createWithSharedDevice(&context);
    radiationmodel.disableMessages();
 
    DOCTEST_SUBCASE("Sky model requires wavelength bounds with uniform response") {
        // Test that error is thrown if wavelength bounds not set for uniform camera response
        radiationmodel.addRadiationBand("VIS"); // No wavelength bounds - will cause error
        radiationmodel.setScatteringDepth("VIS", 1); // Enable scattering so camera rendering code path is executed
        radiationmodel.setDirectRayCount("VIS", 100);
        radiationmodel.setDiffuseRayCount("VIS", 100);
        radiationmodel.disableEmission("VIS");
        radiationmodel.setDiffuseRadiationFlux("VIS", 100.f);
 
        // Add sun source
        uint SunSource = radiationmodel.addCollimatedRadiationSource(make_vec3(0, 0, 1));
        radiationmodel.setSourceFlux(SunSource, "VIS", 1000.f);
 
        // Add camera without setting wavelength bounds (will cause error)
        CameraProperties camera_props;
        camera_props.camera_resolution = make_int2(100, 100);
        camera_props.HFOV = 60.0f;
        radiationmodel.addRadiationCamera("test_camera", {"VIS"}, make_vec3(0, 0, 5), make_vec3(0, 0, 0), camera_props, 10);
 
        radiationmodel.updateGeometry();
 
        // Should throw error about missing wavelength bounds
        // Suppress expected Prague sky model warning (no SolarPosition data available)
        bool threw_error = false;
        {
            capture_cerr capture;
            try {
                radiationmodel.runBand("VIS");
            } catch (std::runtime_error &e) {
                std::string error_msg = e.what();
                threw_error = (error_msg.find("wavelength bounds") != std::string::npos);
            }
        }
        DOCTEST_CHECK(threw_error);
    }
 
    DOCTEST_SUBCASE("Sky model computed with camera and wavelength bounds") {
        // Add radiation band with wavelength bounds
        radiationmodel.addRadiationBand("VIS", 400.f, 700.f); // Set wavelength bounds in constructor
        radiationmodel.setDirectRayCount("VIS", 100);
        radiationmodel.setDiffuseRayCount("VIS", 100);
        radiationmodel.disableEmission("VIS");
        radiationmodel.setDiffuseRadiationFlux("VIS", 100.f); // Set some diffuse flux for sky
 
        // Add sun source (suppress expected "multiple sun sources" warning from previous subcase)
        uint SunSource;
        {
            capture_cerr capture;
            SunSource = radiationmodel.addCollimatedRadiationSource(make_vec3(0.5, 0.3, 0.8));
        }
        radiationmodel.setSourceFlux(SunSource, "VIS", 1000.f);
 
        // Add camera
        CameraProperties camera_props;
        camera_props.camera_resolution = make_int2(100, 100);
        camera_props.HFOV = 60.0f;
        radiationmodel.addRadiationCamera("test_camera", {"VIS"}, make_vec3(0, 0, 5), make_vec3(0, 0, 0), camera_props, 10);
 
        radiationmodel.updateGeometry();
 
        // Run with camera - should compute atmospheric sky model
        // Suppress expected warning about Prague sky model not being available
        {
            capture_cerr capture;
            radiationmodel.runBand("VIS");
        }
 
        // If we get here without crashing, the atmospheric sky model was successfully computed
        DOCTEST_CHECK(true);
    }
 
    DOCTEST_SUBCASE("Atmospheric parameters do not cause errors") {
        // Test that changing atmospheric parameters doesn't cause errors
        radiationmodel.addRadiationBand("VIS", 400.f, 700.f); // Set wavelength bounds in constructor
        radiationmodel.setDirectRayCount("VIS", 0); // No direct rays
        radiationmodel.setDiffuseRayCount("VIS", 0);
        radiationmodel.disableEmission("VIS");
        radiationmodel.setDiffuseRadiationFlux("VIS", 100.f);
 
        // Add camera looking at sky (no geometry in view)
        CameraProperties camera_props;
        camera_props.camera_resolution = make_int2(50, 50);
        camera_props.HFOV = 45.0f;
        radiationmodel.addRadiationCamera("sky_camera", {"VIS"}, make_vec3(10, 10, 10), make_vec3(0, 0, 1), camera_props, 50);
 
        radiationmodel.updateGeometry();
        radiationmodel.runBand("VIS");
 
        // Now change turbidity (higher turbidity = more scattering)
        // Typical values: 0.03-0.05 (very clear), 0.1 (clear), 0.2-0.3 (hazy), >0.4 (very hazy)
        float high_turbidity = 0.3f; // Hazy conditions (AOD at 500nm)
        context.setGlobalData("atmosphere_turbidity", high_turbidity);
 
        radiationmodel.runBand("VIS");
 
        // If we get here, the atmospheric model successfully handled parameter changes
        DOCTEST_CHECK(true);
    }
}
 
GPU_TEST_CASE("RadiationModel - Camera White Balance") {
    Context context;
 
    RadiationModel radiationmodel = RadiationModelTestHelper::createWithSharedDevice(&context);
    radiationmodel.disableMessages();
 
    // Add a simple surface for the camera to image
    uint uuid = context.addPatch(make_vec3(0, 0, 0), make_vec2(1, 1));
    context.setPrimitiveData(uuid, "reflectivity_SW", 0.5f);
 
    // Add radiation bands
    radiationmodel.addRadiationBand("RGB_R");
    radiationmodel.addRadiationBand("RGB_G");
    radiationmodel.addRadiationBand("RGB_B");
 
    // Add radiation source
    uint source = radiationmodel.addCollimatedRadiationSource();
    radiationmodel.setSourceFlux(source, "RGB_R", 100.f);
    radiationmodel.setSourceFlux(source, "RGB_G", 150.f); // Different flux to create white balance imbalance
    radiationmodel.setSourceFlux(source, "RGB_B", 80.f);
 
    DOCTEST_SUBCASE("Default white_balance is 'auto'") {
        // Create camera with default properties
        CameraProperties camera_props;
        camera_props.camera_resolution = make_int2(256, 256);
        camera_props.focal_plane_distance = 2.0f;
        camera_props.HFOV = 45.0f;
 
        // Verify default is "auto"
        DOCTEST_CHECK(camera_props.white_balance == "auto");
 
        radiationmodel.addRadiationCamera("test_camera", {"RGB_R", "RGB_G", "RGB_B"}, make_vec3(0, -5, 2), make_vec3(0, 0, 0), camera_props, 1);
 
        // Verify camera has "auto" white balance
        CameraProperties retrieved_props = radiationmodel.getCameraParameters("test_camera");
        DOCTEST_CHECK(retrieved_props.white_balance == "auto");
    }
 
    DOCTEST_SUBCASE("White balance mode 'off' preserves raw data") {
        // Create camera with white balance off
        CameraProperties camera_props;
        camera_props.camera_resolution = make_int2(256, 256);
        camera_props.focal_plane_distance = 2.0f;
        camera_props.HFOV = 45.0f;
        camera_props.white_balance = "off";
 
        radiationmodel.addRadiationCamera("camera_wb_off", {"RGB_R", "RGB_G", "RGB_B"}, make_vec3(0, -5, 2), make_vec3(0, 0, 0), camera_props, 1);
 
        // Run simulation
        radiationmodel.updateGeometry();
        radiationmodel.runBand("RGB_R");
        radiationmodel.runBand("RGB_G");
        radiationmodel.runBand("RGB_B");
 
        // Verify white balance mode in metadata
        CameraMetadata metadata = radiationmodel.getCameraMetadata("camera_wb_off");
        DOCTEST_CHECK(metadata.camera_properties.white_balance == "off");
 
        // The test passes if we get here without errors
        DOCTEST_CHECK(true);
    }
 
    DOCTEST_SUBCASE("White balance mode 'auto' applies correction") {
        // Create camera with white balance auto
        CameraProperties camera_props;
        camera_props.camera_resolution = make_int2(256, 256);
        camera_props.focal_plane_distance = 2.0f;
        camera_props.HFOV = 45.0f;
        camera_props.white_balance = "auto";
 
        radiationmodel.addRadiationCamera("camera_wb_auto", {"RGB_R", "RGB_G", "RGB_B"}, make_vec3(0, -5, 2), make_vec3(0, 0, 0), camera_props, 1);
 
        // Run simulation
        radiationmodel.updateGeometry();
        radiationmodel.runBand("RGB_R");
        radiationmodel.runBand("RGB_G");
        radiationmodel.runBand("RGB_B");
 
        // Verify white balance mode in metadata
        CameraMetadata metadata = radiationmodel.getCameraMetadata("camera_wb_auto");
        DOCTEST_CHECK(metadata.camera_properties.white_balance == "auto");
 
        // The test passes if we get here without errors
        DOCTEST_CHECK(true);
    }
 
    DOCTEST_SUBCASE("Single-channel camera skips white balance") {
        // Create single-channel camera
        CameraProperties camera_props;
        camera_props.camera_resolution = make_int2(256, 256);
        camera_props.focal_plane_distance = 2.0f;
        camera_props.HFOV = 45.0f;
        camera_props.white_balance = "auto"; // Set to auto, but should skip for 1-channel
 
        radiationmodel.addRadiationCamera("camera_1ch", {"RGB_R"}, make_vec3(0, -5, 2), make_vec3(0, 0, 0), camera_props, 1);
 
        // Run simulation
        radiationmodel.updateGeometry();
        radiationmodel.runBand("RGB_R");
 
        // Verify camera has 1 channel
        CameraMetadata metadata = radiationmodel.getCameraMetadata("camera_1ch");
        DOCTEST_CHECK(metadata.camera_properties.channels == 1);
        DOCTEST_CHECK(metadata.camera_properties.white_balance == "auto");
 
        // The test passes if we get here without errors (white balance should be skipped silently)
        DOCTEST_CHECK(true);
    }
 
    DOCTEST_SUBCASE("Update camera white_balance parameter") {
        // Create camera with default settings
        CameraProperties camera_props;
        camera_props.camera_resolution = make_int2(256, 256);
        camera_props.focal_plane_distance = 2.0f;
        camera_props.HFOV = 45.0f;
        camera_props.white_balance = "auto";
 
        radiationmodel.addRadiationCamera("camera_update", {"RGB_R", "RGB_G", "RGB_B"}, make_vec3(0, -5, 2), make_vec3(0, 0, 0), camera_props, 1);
 
        // Update to "off"
        CameraProperties updated_props = radiationmodel.getCameraParameters("camera_update");
        updated_props.white_balance = "off";
        radiationmodel.updateCameraParameters("camera_update", updated_props);
 
        // Verify update
        CameraProperties retrieved_props = radiationmodel.getCameraParameters("camera_update");
        DOCTEST_CHECK(retrieved_props.white_balance == "off");
 
        // Run simulation with updated settings
        radiationmodel.updateGeometry();
        radiationmodel.runBand("RGB_R");
        radiationmodel.runBand("RGB_G");
        radiationmodel.runBand("RGB_B");
 
        // Verify metadata reflects the update
        CameraMetadata metadata = radiationmodel.getCameraMetadata("camera_update");
        DOCTEST_CHECK(metadata.camera_properties.white_balance == "off");
    }
 
    DOCTEST_SUBCASE("CameraProperties equality includes white_balance") {
        CameraProperties props1;
        props1.white_balance = "auto";
 
        CameraProperties props2;
        props2.white_balance = "auto";
 
        // Should be equal
        DOCTEST_CHECK(props1 == props2);
 
        // Change white_balance
        props2.white_balance = "off";
 
        // Should not be equal
        DOCTEST_CHECK(props1 != props2);
    }
}
 
GPU_TEST_CASE("RadiationModel setDiffuseSpectrum and emission band behavior") {
 
    using namespace helios;
 
    Context context;
 
    // Create some spectral data for testing
    std::vector<vec2> test_spectrum;
    test_spectrum.emplace_back(400.f, 1.0f);
    test_spectrum.emplace_back(500.f, 1.5f);
    test_spectrum.emplace_back(600.f, 1.0f);
    test_spectrum.emplace_back(700.f, 0.5f);
    context.setGlobalData("test_spectrum", test_spectrum);
 
    RadiationModel radiation = RadiationModelTestHelper::createWithSharedDevice(&context);
    radiation.disableMessages();
 
    DOCTEST_SUBCASE("setDiffuseSpectrum applies to all bands") {
        // Add multiple bands with wavelength bounds
        radiation.addRadiationBand("band1", 400.f, 500.f);
        radiation.addRadiationBand("band2", 500.f, 600.f);
        radiation.addRadiationBand("band3", 600.f, 700.f);
 
        // Disable emission for all bands (shortwave bands)
        radiation.disableEmission("band1");
        radiation.disableEmission("band2");
        radiation.disableEmission("band3");
 
        // Set spectrum for all bands at once
        radiation.setDiffuseSpectrum("test_spectrum");
 
        // All bands should have non-zero diffuse flux from spectrum
        float flux1 = radiation.getDiffuseFlux("band1");
        float flux2 = radiation.getDiffuseFlux("band2");
        float flux3 = radiation.getDiffuseFlux("band3");
 
        DOCTEST_CHECK(flux1 > 0.f);
        DOCTEST_CHECK(flux2 > 0.f);
        DOCTEST_CHECK(flux3 > 0.f);
    }
 
    DOCTEST_SUBCASE("getDiffuseFlux returns 0 for emission-enabled bands with spectrum") {
        // Add a band with emission enabled (default)
        radiation.addRadiationBand("emission_band", 400.f, 700.f);
 
        // Set spectrum (but emission is enabled, so it should be ignored)
        radiation.setDiffuseSpectrum("test_spectrum");
 
        // Emission-enabled band should return 0 for diffuse flux when using spectrum
        float flux = radiation.getDiffuseFlux("emission_band");
        DOCTEST_CHECK(flux == 0.f);
    }
 
    DOCTEST_SUBCASE("getDiffuseFlux returns manual flux for emission-enabled bands") {
        // Add a band with emission enabled (default)
        radiation.addRadiationBand("emission_band", 400.f, 700.f);
 
        // Set spectrum (will be ignored for emission band)
        radiation.setDiffuseSpectrum("test_spectrum");
 
        // Set manual flux for the emission band
        float manual_flux = 100.f;
        radiation.setDiffuseRadiationFlux("emission_band", manual_flux);
 
        // Should return the manual flux, not 0
        float flux = radiation.getDiffuseFlux("emission_band");
        DOCTEST_CHECK(flux == manual_flux);
    }
 
    DOCTEST_SUBCASE("Manual flux overrides spectrum for non-emission bands") {
        // Add a band and disable emission
        radiation.addRadiationBand("shortwave", 400.f, 700.f);
        radiation.disableEmission("shortwave");
 
        // Set spectrum
        radiation.setDiffuseSpectrum("test_spectrum");
 
        // Get spectrum-based flux
        float spectrum_flux = radiation.getDiffuseFlux("shortwave");
        DOCTEST_CHECK(spectrum_flux > 0.f);
 
        // Set manual flux - should override spectrum
        float manual_flux = 999.f;
        radiation.setDiffuseRadiationFlux("shortwave", manual_flux);
 
        float flux = radiation.getDiffuseFlux("shortwave");
        DOCTEST_CHECK(flux == manual_flux);
    }
 
    DOCTEST_SUBCASE("setDiffuseSpectrum with no bands does not error") {
        // Create a fresh radiation model with no bands
        Context context2;
        context2.setGlobalData("test_spectrum", test_spectrum);
        RadiationModel radiation2 = RadiationModelTestHelper::createWithSharedDevice(&context2);
        radiation2.disableMessages();
 
        // Should not throw when called with no bands
        radiation2.setDiffuseSpectrum("test_spectrum");
        DOCTEST_CHECK(true); // If we get here, no exception was thrown
    }
 
    DOCTEST_SUBCASE("setDiffuseSpectrum before bands are added applies to later bands") {
        // Create a fresh radiation model with no bands
        Context context2;
        context2.setGlobalData("test_spectrum", test_spectrum);
        RadiationModel radiation2 = RadiationModelTestHelper::createWithSharedDevice(&context2);
        radiation2.disableMessages();
 
        // Set spectrum BEFORE adding bands
        radiation2.setDiffuseSpectrum("test_spectrum");
 
        // Now add bands
        radiation2.addRadiationBand("band1", 400.f, 500.f);
        radiation2.addRadiationBand("band2", 500.f, 600.f);
 
        // Disable emission for these bands
        radiation2.disableEmission("band1");
        radiation2.disableEmission("band2");
 
        // Bands added after setDiffuseSpectrum should have the spectrum applied
        float flux1 = radiation2.getDiffuseFlux("band1");
        float flux2 = radiation2.getDiffuseFlux("band2");
 
        DOCTEST_CHECK(flux1 > 0.f);
        DOCTEST_CHECK(flux2 > 0.f);
    }
 
    DOCTEST_SUBCASE("setDiffuseSpectrumIntegral scales global spectrum before bands are added") {
        // Create a fresh radiation model with no bands
        Context context2;
        context2.setGlobalData("test_spectrum", test_spectrum);
        RadiationModel radiation2 = RadiationModelTestHelper::createWithSharedDevice(&context2);
        radiation2.disableMessages();
 
        // Set spectrum and integral BEFORE adding bands
        radiation2.setDiffuseSpectrum("test_spectrum");
        float target_integral = 850.f;
        radiation2.setDiffuseSpectrumIntegral(target_integral);
 
        // Now add bands that cover the full spectrum range
        radiation2.addRadiationBand("full", 400.f, 700.f);
        radiation2.disableEmission("full");
 
        // The diffuse flux for the full band should be close to the target integral
        // (accounting for the fact that the band only covers 400-700nm of the spectrum)
        float flux = radiation2.getDiffuseFlux("full");
 
        // The test spectrum covers 400-700nm, so the full band should get the full integral
        DOCTEST_CHECK(flux == doctest::Approx(target_integral).epsilon(0.01));
    }
 
    DOCTEST_SUBCASE("setDiffuseSpectrumIntegral with wavelength bounds scales global spectrum") {
        // Create a fresh radiation model with no bands
        Context context2;
        context2.setGlobalData("test_spectrum", test_spectrum);
        RadiationModel radiation2 = RadiationModelTestHelper::createWithSharedDevice(&context2);
        radiation2.disableMessages();
 
        // Set spectrum and integral with wavelength bounds BEFORE adding bands
        radiation2.setDiffuseSpectrum("test_spectrum");
        float target_integral = 500.f;
        radiation2.setDiffuseSpectrumIntegral(target_integral, 500.f, 600.f);
 
        // Now add a band that covers only the 500-600nm range
        radiation2.addRadiationBand("partial", 500.f, 600.f);
        radiation2.disableEmission("partial");
 
        // The diffuse flux for this band should be close to the target integral
        float flux = radiation2.getDiffuseFlux("partial");
        DOCTEST_CHECK(flux == doctest::Approx(target_integral).epsilon(0.01));
    }
 
    DOCTEST_SUBCASE("setDiffuseSpectrumIntegral applies to existing bands") {
        // Add bands first, then set spectrum and integral
        radiation.addRadiationBand("band1", 400.f, 700.f);
        radiation.disableEmission("band1");
 
        radiation.setDiffuseSpectrum("test_spectrum");
        float target_integral = 1000.f;
        radiation.setDiffuseSpectrumIntegral(target_integral);
 
        float flux = radiation.getDiffuseFlux("band1");
        DOCTEST_CHECK(flux == doctest::Approx(target_integral).epsilon(0.01));
    }
}
 
// ===== Prague Sky Model Integration Tests =====
 
GPU_TEST_CASE("Radiation - Prague Context data fallback behavior") {
    Context context;
    RadiationModel radiation = RadiationModelTestHelper::createWithSharedDevice(&context);
    radiation.disableMessages();
 
    // Add a simple camera with RGB bands
    radiation.addRadiationBand("red");
    radiation.addRadiationBand("green");
    radiation.addRadiationBand("blue");
 
    // Create simple test geometry
    uint UUID = context.addPatch(make_vec3(0, 0, 0), make_vec2(1, 1));
    context.setPrimitiveData(UUID, "radiation_flux_red", 0.f);
    context.setPrimitiveData(UUID, "radiation_flux_green", 0.f);
    context.setPrimitiveData(UUID, "radiation_flux_blue", 0.f);
 
    CameraProperties camera_props;
    camera_props.camera_resolution = make_int2(64, 64);
    camera_props.focal_plane_distance = 2.0f;
    camera_props.HFOV = 45.0f;
 
    radiation.addRadiationCamera("test_camera", {"red", "green", "blue"}, make_vec3(0, -3, 2), make_vec3(0, 0, 0), camera_props, 1);
 
    // Try to update geometry without Prague data
    // Should fall back to uniform sky with warning (not crash)
    DOCTEST_CHECK_NOTHROW(radiation.updateGeometry());
}
 
GPU_TEST_CASE("Radiation - Prague Context data integration end-to-end") {
    Context context;
    RadiationModel radiation = RadiationModelTestHelper::createWithSharedDevice(&context);
    radiation.disableMessages();
 
    // Mock Prague data in Context (simulating what SolarPosition would provide)
    // Create realistic spectral parameters with Rayleigh-like spectrum: 225 wavelengths × 6 params
    std::vector<float> spectral_params(225 * 6);
    for (int i = 0; i < 225; ++i) {
        float wavelength = 360.0f + i * 5.0f;
        int base = i * 6;
 
        // Rayleigh spectrum: blue sky with λ^-4 dependence
        float rayleigh_factor = std::pow(550.0f / wavelength, 4.0f);
 
        spectral_params[base + 0] = wavelength;
        spectral_params[base + 1] = 0.3f * rayleigh_factor; // L_zenith (W/m²/sr/nm) - blue-heavy
        spectral_params[base + 2] = 2.0f; // circ_str
        spectral_params[base + 3] = 15.0f; // circ_width (degrees)
        spectral_params[base + 4] = 2.0f; // horiz_bright
        spectral_params[base + 5] = 0.8f; // normalization
    }
 
    context.setGlobalData("prague_sky_spectral_params", spectral_params);
    context.setGlobalData("prague_sky_sun_direction", make_vec3(0, 0.5f, 0.866f));
    context.setGlobalData("prague_sky_visibility_km", 40.0f);
    context.setGlobalData("prague_sky_ground_albedo", 0.33f);
    context.setGlobalData("prague_sky_valid", 1);
 
    // Verify Prague data is in Context
    int valid = 0;
    DOCTEST_CHECK_NOTHROW(context.getGlobalData("prague_sky_valid", valid));
    DOCTEST_CHECK(valid == 1);
 
    std::vector<float> read_params;
    DOCTEST_CHECK_NOTHROW(context.getGlobalData("prague_sky_spectral_params", read_params));
    DOCTEST_CHECK(read_params.size() == 225 * 6);
 
    // Setup radiation with RGB bands
    radiation.addRadiationBand("red");
    radiation.addRadiationBand("green");
    radiation.addRadiationBand("blue");
 
    // Create test geometry
    uint UUID = context.addPatch(make_vec3(0, 0, 0), make_vec2(1, 1));
    context.setPrimitiveData(UUID, "radiation_flux_red", 0.f);
    context.setPrimitiveData(UUID, "radiation_flux_green", 0.f);
    context.setPrimitiveData(UUID, "radiation_flux_blue", 0.f);
 
    CameraProperties camera_props;
    camera_props.camera_resolution = make_int2(64, 64);
    camera_props.focal_plane_distance = 2.0f;
    camera_props.HFOV = 45.0f;
 
    radiation.addRadiationCamera("test_camera", {"red", "green", "blue"}, make_vec3(0, -3, 2), make_vec3(0, 0, 0), camera_props, 1);
 
    // Update geometry - should read Prague data from Context (no warning)
    DOCTEST_CHECK_NOTHROW(radiation.updateGeometry());
}
 
GPU_TEST_CASE("RadiationModel Automatic Spectrum Update Detection") {
 
    helios::Context context;
    RadiationModel radiation = RadiationModelTestHelper::createWithSharedDevice(&context);
    radiation.disableMessages();
 
    // Create initial direct spectrum
    std::vector<helios::vec2> direct_spectrum_v1 = {{300, 1.0}, {400, 2.0}, {500, 3.0}, {700, 2.0}, {800, 1.0}};
    context.setGlobalData("test_direct_spectrum", direct_spectrum_v1);
 
    // Create initial diffuse spectrum
    std::vector<helios::vec2> diffuse_spectrum_v1 = {{300, 0.5}, {400, 1.0}, {500, 1.5}, {700, 1.0}, {800, 0.5}};
    context.setGlobalData("test_diffuse_spectrum", diffuse_spectrum_v1);
 
    // Add radiation source with spectrum label
    uint sun = radiation.addCollimatedRadiationSource(helios::make_vec3(0, 0, 1));
    radiation.setSourceSpectrum(sun, "test_direct_spectrum");
 
    // Set diffuse spectrum
    radiation.setDiffuseSpectrum("test_diffuse_spectrum");
 
    // Add radiation band
    radiation.addRadiationBand("PAR", 400, 700);
 
    // Add simple geometry
    uint ground = context.addPatch(helios::make_vec3(0, 0, 0), helios::make_vec2(10, 10));
    context.setPrimitiveData(ground, "twosided_flag", uint(0));
 
    // Run first simulation
    radiation.updateGeometry();
    DOCTEST_CHECK_NOTHROW(radiation.runBand("PAR"));
 
    float flux_v1;
    context.getPrimitiveData(ground, "radiation_flux_PAR", flux_v1);
    DOCTEST_CHECK(flux_v1 > 0.0f);
 
    // Update direct spectrum in global data (double the flux)
    std::vector<helios::vec2> direct_spectrum_v2 = {{300, 2.0}, {400, 4.0}, {500, 6.0}, {700, 4.0}, {800, 2.0}};
    context.setGlobalData("test_direct_spectrum", direct_spectrum_v2);
 
    // Run second simulation WITHOUT calling setSourceSpectrum() again
    DOCTEST_CHECK_NOTHROW(radiation.runBand("PAR"));
 
    float flux_v2;
    context.getPrimitiveData(ground, "radiation_flux_PAR", flux_v2);
 
    // Flux should have doubled (with some tolerance for integration)
    DOCTEST_CHECK(flux_v2 > flux_v1 * 1.9f);
    DOCTEST_CHECK(flux_v2 < flux_v1 * 2.1f);
 
    // Update diffuse spectrum in global data (triple the flux)
    std::vector<helios::vec2> diffuse_spectrum_v2 = {{300, 1.5}, {400, 3.0}, {500, 4.5}, {700, 3.0}, {800, 1.5}};
    context.setGlobalData("test_diffuse_spectrum", diffuse_spectrum_v2);
 
    // Run third simulation WITHOUT calling setDiffuseSpectrum() again
    DOCTEST_CHECK_NOTHROW(radiation.runBand("PAR"));
 
    float flux_v3;
    context.getPrimitiveData(ground, "radiation_flux_PAR", flux_v3);
 
    // Note: Diffuse contribution may be small in this simple test geometry
    // The important test is that direct spectrum update worked (verified above)
    DOCTEST_CHECK(flux_v3 >= flux_v2 * 0.99f); // Allow for small numerical differences
}
 
GPU_TEST_CASE("RadiationModel Multiple Sources Same Spectrum Update") {
 
    helios::Context context;
    RadiationModel radiation = RadiationModelTestHelper::createWithSharedDevice(&context);
    radiation.disableMessages();
 
    // Create spectrum used by multiple sources
    std::vector<helios::vec2> shared_spectrum = {{300, 1.0}, {800, 1.0}};
    context.setGlobalData("shared_spectrum", shared_spectrum);
 
    // Add multiple sources all using same spectrum
    // Suppress expected warnings about multiple sun sources
    {
        capture_cerr capture;
        for (int i = 0; i < 3; i++) {
            uint source = radiation.addCollimatedRadiationSource(helios::make_vec3(0, 0, 1));
            radiation.setSourceSpectrum(source, "shared_spectrum");
        }
    }
 
    radiation.addRadiationBand("test", 400, 700);
 
    uint ground = context.addPatch(helios::make_vec3(0, 0, 0), helios::make_vec2(10, 10));
    context.setPrimitiveData(ground, "twosided_flag", uint(0));
 
    radiation.updateGeometry();
    DOCTEST_CHECK_NOTHROW(radiation.runBand("test"));
 
    float flux_v1;
    context.getPrimitiveData(ground, "radiation_flux_test", flux_v1);
    DOCTEST_CHECK(flux_v1 > 0.0f);
 
    // Update the shared spectrum
    std::vector<helios::vec2> updated_spectrum = {{300, 2.0}, {800, 2.0}};
    context.setGlobalData("shared_spectrum", updated_spectrum);
 
    // Run again - all sources should use updated spectrum
    DOCTEST_CHECK_NOTHROW(radiation.runBand("test"));
 
    float flux_v2;
    context.getPrimitiveData(ground, "radiation_flux_test", flux_v2);
 
    // All 3 sources doubled, so total flux should roughly double
    DOCTEST_CHECK(flux_v2 > flux_v1 * 1.8f);
}
 
GPU_TEST_CASE("RadiationModel No Update When Spectrum Unchanged") {
 
    helios::Context context;
    RadiationModel radiation = RadiationModelTestHelper::createWithSharedDevice(&context);
    radiation.disableMessages();
 
    // Create spectrum
    std::vector<helios::vec2> spectrum = {{300, 1.0}, {800, 1.0}};
    context.setGlobalData("test_spectrum", spectrum);
 
    uint source = radiation.addCollimatedRadiationSource(helios::make_vec3(0, 0, 1));
    radiation.setSourceSpectrum(source, "test_spectrum");
    radiation.addRadiationBand("test", 400, 700);
 
    uint ground = context.addPatch(helios::make_vec3(0, 0, 0), helios::make_vec2(10, 10));
    context.setPrimitiveData(ground, "twosided_flag", uint(0));
 
    radiation.updateGeometry();
    DOCTEST_CHECK_NOTHROW(radiation.runBand("test"));
 
    // Run again WITHOUT changing spectrum - should not recompute radiative properties
    // (This is validated internally - if version hasn't changed, radiativepropertiesneedupdate stays false)
    DOCTEST_CHECK_NOTHROW(radiation.runBand("test"));
 
    float flux;
    context.getPrimitiveData(ground, "radiation_flux_test", flux);
    DOCTEST_CHECK(flux > 0.0f);
}
 
DOCTEST_TEST_CASE("RadiationModel - CameraProperties default camera_zoom") {
    CameraProperties props;
    DOCTEST_CHECK(props.camera_zoom == 1.0f);
}
 
DOCTEST_TEST_CASE("RadiationModel - CameraProperties equality with camera_zoom") {
    CameraProperties props1;
    CameraProperties props2;
 
    DOCTEST_CHECK(props1 == props2); // Both have default camera_zoom = 1.0
 
    props1.camera_zoom = 2.0f;
    DOCTEST_CHECK(props1 != props2); // Different zoom values
 
    props2.camera_zoom = 2.0f;
    DOCTEST_CHECK(props1 == props2); // Same zoom values again
}
 
GPU_TEST_CASE("RadiationModel - camera_zoom validation in updateCameraParameters") {
    Context context;
    RadiationModel radiation = RadiationModelTestHelper::createWithSharedDevice(&context);
    radiation.disableMessages();
 
    CameraProperties props;
    props.camera_resolution = make_int2(100, 100);
    props.HFOV = 45.0f;
    props.camera_zoom = 1.0f;
 
    std::vector<std::string> bands = {"R"};
    radiation.addRadiationCamera("test_cam", bands, make_vec3(0, 0, 5), make_vec3(0, 0, -1), props, 1);
 
    // Try to update with invalid zoom (0.0)
    CameraProperties invalid = radiation.getCameraParameters("test_cam");
    invalid.camera_zoom = 0.0f;
 
    DOCTEST_CHECK_THROWS_WITH_AS(radiation.updateCameraParameters("test_cam", invalid), "ERROR (RadiationModel::updateCameraParameters): camera_zoom must be greater than 0.", std::runtime_error);
 
    // Try to update with invalid zoom (negative)
    invalid.camera_zoom = -1.0f;
    DOCTEST_CHECK_THROWS_WITH_AS(radiation.updateCameraParameters("test_cam", invalid), "ERROR (RadiationModel::updateCameraParameters): camera_zoom must be greater than 0.", std::runtime_error);
}
 
GPU_TEST_CASE("RadiationModel - camera_zoom parameter get/set") {
    Context context;
    RadiationModel radiation = RadiationModelTestHelper::createWithSharedDevice(&context);
    radiation.disableMessages();
 
    CameraProperties props;
    props.camera_resolution = make_int2(100, 100);
    props.HFOV = 60.0f;
    props.camera_zoom = 3.5f;
 
    std::vector<std::string> bands = {"R", "G", "B"};
    radiation.addRadiationCamera("test_cam", bands, make_vec3(0, 0, 5), make_vec3(0, 0, -1), props, 1);
 
    CameraProperties retrieved = radiation.getCameraParameters("test_cam");
    DOCTEST_CHECK(retrieved.camera_zoom == 3.5f);
    DOCTEST_CHECK(retrieved.HFOV == 60.0f); // Base HFOV unchanged
}
 
GPU_TEST_CASE("RadiationModel - update camera_zoom") {
    Context context;
    RadiationModel radiation = RadiationModelTestHelper::createWithSharedDevice(&context);
    radiation.disableMessages();
 
    CameraProperties props;
    props.camera_resolution = make_int2(100, 100);
    props.HFOV = 45.0f;
    props.camera_zoom = 1.0f;
 
    std::vector<std::string> bands = {"R"};
    radiation.addRadiationCamera("test_cam", bands, make_vec3(0, 0, 5), make_vec3(0, 0, -1), props, 1);
 
    // Update camera_zoom
    CameraProperties updated = radiation.getCameraParameters("test_cam");
    updated.camera_zoom = 2.5f;
    radiation.updateCameraParameters("test_cam", updated);
 
    CameraProperties final_props = radiation.getCameraParameters("test_cam");
    DOCTEST_CHECK(final_props.camera_zoom == 2.5f);
    DOCTEST_CHECK(final_props.HFOV == 45.0f); // Base HFOV should remain unchanged
}
GPU_TEST_CASE("Lens Flare - Enable/Disable API") {
    helios::Context context;
    RadiationModel radiation = RadiationModelTestHelper::createWithSharedDevice(&context);
 
    // Add a camera
    CameraProperties camera_props;
    camera_props.camera_resolution = helios::make_int2(64, 64);
    camera_props.HFOV = 45.0f;
    radiation.addRadiationCamera("test_camera", {"red", "green", "blue"}, helios::make_vec3(0, 0, 5), helios::make_vec3(0, 0, 0), camera_props, 1);
 
    // Test default state is disabled
    DOCTEST_CHECK(!radiation.isCameraLensFlareEnabled("test_camera"));
 
    // Test enabling
    radiation.enableCameraLensFlare("test_camera");
    DOCTEST_CHECK(radiation.isCameraLensFlareEnabled("test_camera"));
 
    // Test disabling
    radiation.disableCameraLensFlare("test_camera");
    DOCTEST_CHECK(!radiation.isCameraLensFlareEnabled("test_camera"));
 
    // Test error for non-existent camera
    DOCTEST_CHECK_THROWS(radiation.enableCameraLensFlare("nonexistent_camera"));
    DOCTEST_CHECK_THROWS(radiation.disableCameraLensFlare("nonexistent_camera"));
    DOCTEST_CHECK_THROWS((void) radiation.isCameraLensFlareEnabled("nonexistent_camera"));
}
 
GPU_TEST_CASE("Lens Flare - Properties API") {
    helios::Context context;
    RadiationModel radiation = RadiationModelTestHelper::createWithSharedDevice(&context);
 
    // Add a camera
    CameraProperties camera_props;
    camera_props.camera_resolution = helios::make_int2(64, 64);
    camera_props.HFOV = 45.0f;
    radiation.addRadiationCamera("test_camera", {"red", "green", "blue"}, helios::make_vec3(0, 0, 5), helios::make_vec3(0, 0, 0), camera_props, 1);
 
    // Test default properties
    LensFlareProperties default_props = radiation.getCameraLensFlareProperties("test_camera");
    DOCTEST_CHECK(default_props.aperture_blade_count == 6);
    DOCTEST_CHECK(default_props.coating_efficiency == doctest::Approx(0.96f));
    DOCTEST_CHECK(default_props.ghost_intensity == doctest::Approx(1.0f));
    DOCTEST_CHECK(default_props.starburst_intensity == doctest::Approx(1.0f));
    DOCTEST_CHECK(default_props.intensity_threshold == doctest::Approx(0.8f));
    DOCTEST_CHECK(default_props.ghost_count == 5);
 
    // Test setting properties
    LensFlareProperties custom_props;
    custom_props.aperture_blade_count = 8;
    custom_props.coating_efficiency = 0.98f;
    custom_props.ghost_intensity = 0.5f;
    custom_props.starburst_intensity = 0.75f;
    custom_props.intensity_threshold = 0.9f;
    custom_props.ghost_count = 3;
 
    radiation.setCameraLensFlareProperties("test_camera", custom_props);
    LensFlareProperties retrieved_props = radiation.getCameraLensFlareProperties("test_camera");
 
    DOCTEST_CHECK(retrieved_props.aperture_blade_count == 8);
    DOCTEST_CHECK(retrieved_props.coating_efficiency == doctest::Approx(0.98f));
    DOCTEST_CHECK(retrieved_props.ghost_intensity == doctest::Approx(0.5f));
    DOCTEST_CHECK(retrieved_props.starburst_intensity == doctest::Approx(0.75f));
    DOCTEST_CHECK(retrieved_props.intensity_threshold == doctest::Approx(0.9f));
    DOCTEST_CHECK(retrieved_props.ghost_count == 3);
 
    // Test validation errors
    LensFlareProperties invalid_props;
 
    // Invalid blade count (< 3)
    invalid_props = default_props;
    invalid_props.aperture_blade_count = 2;
    DOCTEST_CHECK_THROWS(radiation.setCameraLensFlareProperties("test_camera", invalid_props));
 
    // Invalid coating efficiency (> 1.0)
    invalid_props = default_props;
    invalid_props.coating_efficiency = 1.5f;
    DOCTEST_CHECK_THROWS(radiation.setCameraLensFlareProperties("test_camera", invalid_props));
 
    // Invalid coating efficiency (< 0.0)
    invalid_props = default_props;
    invalid_props.coating_efficiency = -0.1f;
    DOCTEST_CHECK_THROWS(radiation.setCameraLensFlareProperties("test_camera", invalid_props));
 
    // Invalid ghost intensity (< 0)
    invalid_props = default_props;
    invalid_props.ghost_intensity = -0.5f;
    DOCTEST_CHECK_THROWS(radiation.setCameraLensFlareProperties("test_camera", invalid_props));
 
    // Invalid intensity threshold (> 1.0)
    invalid_props = default_props;
    invalid_props.intensity_threshold = 1.5f;
    DOCTEST_CHECK_THROWS(radiation.setCameraLensFlareProperties("test_camera", invalid_props));
 
    // Invalid ghost count (< 1)
    invalid_props = default_props;
    invalid_props.ghost_count = 0;
    DOCTEST_CHECK_THROWS(radiation.setCameraLensFlareProperties("test_camera", invalid_props));
}
 
GPU_TEST_CASE("Lens Flare - Application to Camera Image") {
    helios::Context context;
    RadiationModel radiation = RadiationModelTestHelper::createWithSharedDevice(&context);
    radiation.disableMessages();
 
    // Create a simple scene with a bright light source
    uint ground = context.addPatch(helios::make_vec3(0, 0, 0), helios::make_vec2(10, 10));
    uint bright_patch = context.addPatch(helios::make_vec3(0, 0, 0.5), helios::make_vec2(0.5, 0.5));
    context.setPrimitiveData(ground, "twosided_flag", uint(0));
    context.setPrimitiveData(bright_patch, "twosided_flag", uint(0));
 
    // Set reflectivity (need emissivity = 1 - reflectivity for energy conservation)
    context.setPrimitiveData(ground, "reflectivity_red", 0.5f);
    context.setPrimitiveData(ground, "reflectivity_green", 0.5f);
    context.setPrimitiveData(ground, "reflectivity_blue", 0.5f);
    context.setPrimitiveData(bright_patch, "reflectivity_red", 0.99f);
    context.setPrimitiveData(bright_patch, "reflectivity_green", 0.99f);
    context.setPrimitiveData(bright_patch, "reflectivity_blue", 0.99f);
 
    // Add radiation bands first (required before setting source flux)
    radiation.addRadiationBand("red");
    radiation.addRadiationBand("green");
    radiation.addRadiationBand("blue");
 
    // Disable emission for all bands (we're only testing direct illumination)
    radiation.disableEmission("red");
    radiation.disableEmission("green");
    radiation.disableEmission("blue");
 
    // Add radiation source
    uint source = radiation.addCollimatedRadiationSource(helios::make_vec3(0, 0, 1));
    radiation.setSourceFlux(source, "red", 500.0f);
    radiation.setSourceFlux(source, "green", 500.0f);
    radiation.setSourceFlux(source, "blue", 500.0f);
 
    radiation.setDirectRayCount("red", 1000);
    radiation.setDirectRayCount("green", 1000);
    radiation.setDirectRayCount("blue", 1000);
    radiation.setDiffuseRayCount("red", 100);
    radiation.setDiffuseRayCount("green", 100);
    radiation.setDiffuseRayCount("blue", 100);
 
    // Enable scattering since we set reflectivity values
    radiation.setScatteringDepth("red", 1);
    radiation.setScatteringDepth("green", 1);
    radiation.setScatteringDepth("blue", 1);
 
    // Add a camera
    CameraProperties camera_props;
    camera_props.camera_resolution = helios::make_int2(64, 64);
    camera_props.HFOV = 60.0f;
    camera_props.focal_plane_distance = 5.0f;
    radiation.addRadiationCamera("test_camera", {"red", "green", "blue"}, helios::make_vec3(0, 0, 5), helios::make_vec3(0, 0, 0), camera_props, 1);
 
    // Enable lens flare with lower threshold to ensure effect is visible
    radiation.enableCameraLensFlare("test_camera");
    LensFlareProperties props;
    props.intensity_threshold = 0.5f; // Lower threshold to catch more pixels
    props.ghost_intensity = 1.0f;
    props.starburst_intensity = 1.0f;
    radiation.setCameraLensFlareProperties("test_camera", props);
 
    // Update and run
    radiation.updateGeometry();
    radiation.runBand({"red", "green", "blue"});
 
    // Apply image corrections (lens flare is automatically applied when enabled)
    DOCTEST_CHECK_NOTHROW(radiation.applyCameraImageCorrections("test_camera", "red", "green", "blue"));
 
    // Verify camera still has valid pixel data
    auto all_labels = radiation.getAllCameraLabels();
    DOCTEST_CHECK(std::find(all_labels.begin(), all_labels.end(), "test_camera") != all_labels.end());
}
 
GPU_TEST_CASE("Lens Flare - Disabled Does Nothing") {
    helios::Context context;
    RadiationModel radiation = RadiationModelTestHelper::createWithSharedDevice(&context);
    radiation.disableMessages();
 
    // Create a simple scene
    uint ground = context.addPatch(helios::make_vec3(0, 0, 0), helios::make_vec2(10, 10));
    context.setPrimitiveData(ground, "twosided_flag", uint(0));
    context.setPrimitiveData(ground, "reflectivity_red", 0.5f);
    context.setPrimitiveData(ground, "reflectivity_green", 0.5f);
    context.setPrimitiveData(ground, "reflectivity_blue", 0.5f);
 
    // Add radiation bands first (required before setting source flux)
    radiation.addRadiationBand("red");
    radiation.addRadiationBand("green");
    radiation.addRadiationBand("blue");
 
    // Disable emission for all bands (we're only testing direct illumination)
    radiation.disableEmission("red");
    radiation.disableEmission("green");
    radiation.disableEmission("blue");
 
    // Add radiation source
    uint source = radiation.addCollimatedRadiationSource(helios::make_vec3(0, 0, 1));
    radiation.setSourceFlux(source, "red", 500.0f);
    radiation.setSourceFlux(source, "green", 500.0f);
    radiation.setSourceFlux(source, "blue", 500.0f);
 
    radiation.setDirectRayCount("red", 100);
    radiation.setDirectRayCount("green", 100);
    radiation.setDirectRayCount("blue", 100);
 
    // Enable scattering since we set reflectivity values
    radiation.setScatteringDepth("red", 1);
    radiation.setScatteringDepth("green", 1);
    radiation.setScatteringDepth("blue", 1);
 
    // Add a camera (lens flare disabled by default)
    CameraProperties camera_props;
    camera_props.camera_resolution = helios::make_int2(32, 32);
    camera_props.HFOV = 45.0f;
    radiation.addRadiationCamera("test_camera", {"red", "green", "blue"}, helios::make_vec3(0, 0, 5), helios::make_vec3(0, 0, 0), camera_props, 1);
 
    // Update and run
    radiation.updateGeometry();
    radiation.runBand({"red", "green", "blue"});
 
    // Apply image corrections - lens flare should NOT be applied since it's disabled
    DOCTEST_CHECK(!radiation.isCameraLensFlareEnabled("test_camera"));
    DOCTEST_CHECK_NOTHROW(radiation.applyCameraImageCorrections("test_camera", "red", "green", "blue"));
}
 
GPU_TEST_CASE("RadiationModel - Camera Sphere Source Rendering") {
    helios::Context context;
    RadiationModel radiation = RadiationModelTestHelper::createWithSharedDevice(&context);
    radiation.disableMessages();
 
    uint ground = context.addPatch(helios::make_vec3(0, 0, 0), helios::make_vec2(2.0f, 2.0f));
    context.setPrimitiveData(ground, "twosided_flag", uint(0));
    context.setPrimitiveData(ground, "reflectivity_test_band", 0.0f);
 
    radiation.addRadiationBand("test_band");
    radiation.disableEmission("test_band");
    radiation.setDirectRayCount("test_band", 100);
    radiation.setDiffuseRayCount("test_band", 0);
    radiation.setScatteringDepth("test_band", 1);
 
    uint source = radiation.addSphereRadiationSource(helios::make_vec3(0, 0, 0.5), 0.2f);
    std::vector<helios::vec2> test_spectrum = {{400, 1.0f}, {700, 1.0f}};
    context.setGlobalData("test_spectrum", test_spectrum);
    radiation.setSourceSpectrum(source, "test_spectrum");
 
    CameraProperties camera_props;
    camera_props.camera_resolution = helios::make_int2(32, 32);
    camera_props.HFOV = 45.0f;
    camera_props.lens_diameter = 0.0f;
    radiation.addRadiationCamera("sphere_cam", {"test_band"}, helios::make_vec3(0, 0, 2), helios::make_vec3(0, 0, 0), camera_props, 10);
 
    radiation.updateGeometry();
    radiation.runBand("test_band");
 
    auto pixel_data = radiation.getCameraPixelData("sphere_cam", "test_band");
    DOCTEST_REQUIRE(!pixel_data.empty());
 
    int center_idx = (camera_props.camera_resolution.y / 2) * camera_props.camera_resolution.x + (camera_props.camera_resolution.x / 2);
    DOCTEST_CHECK(pixel_data[center_idx] > 0.0f);
}
 
GPU_TEST_CASE("RadiationModel - Camera Rectangle Source Rendering") {
    helios::Context context;
    RadiationModel radiation = RadiationModelTestHelper::createWithSharedDevice(&context);
    radiation.disableMessages();
 
    uint ground = context.addPatch(helios::make_vec3(0, 0, 0), helios::make_vec2(2.0f, 2.0f));
    context.setPrimitiveData(ground, "twosided_flag", uint(0));
    context.setPrimitiveData(ground, "reflectivity_test_band", 0.0f);
 
    radiation.addRadiationBand("test_band");
    radiation.disableEmission("test_band");
    radiation.setDirectRayCount("test_band", 100);
    radiation.setDiffuseRayCount("test_band", 0);
    radiation.setScatteringDepth("test_band", 1);
 
    uint source = radiation.addRectangleRadiationSource(helios::make_vec3(0, 0, 0.5), helios::make_vec2(0.4f, 0.4f), helios::make_vec3(0, 0, 0));
    std::vector<helios::vec2> test_spectrum = {{400, 1.0f}, {700, 1.0f}};
    context.setGlobalData("test_spectrum", test_spectrum);
    radiation.setSourceSpectrum(source, "test_spectrum");
 
    CameraProperties camera_props;
    camera_props.camera_resolution = helios::make_int2(32, 32);
    camera_props.HFOV = 45.0f;
    camera_props.lens_diameter = 0.0f;
    radiation.addRadiationCamera("rect_cam", {"test_band"}, helios::make_vec3(0, 0, 2), helios::make_vec3(0, 0, 0), camera_props, 10);
 
    radiation.updateGeometry();
    radiation.runBand("test_band");
 
    auto pixel_data = radiation.getCameraPixelData("rect_cam", "test_band");
    DOCTEST_REQUIRE(!pixel_data.empty());
 
    int center_idx = (camera_props.camera_resolution.y / 2) * camera_props.camera_resolution.x + (camera_props.camera_resolution.x / 2);
    DOCTEST_CHECK(pixel_data[center_idx] > 0.0f);
}
 
GPU_TEST_CASE("RadiationModel - Camera Disk Source Rendering") {
    helios::Context context;
    RadiationModel radiation = RadiationModelTestHelper::createWithSharedDevice(&context);
    radiation.disableMessages();
 
    uint ground = context.addPatch(helios::make_vec3(0, 0, 0), helios::make_vec2(2.0f, 2.0f));
    context.setPrimitiveData(ground, "twosided_flag", uint(0));
    context.setPrimitiveData(ground, "reflectivity_test_band", 0.0f);
 
    radiation.addRadiationBand("test_band");
    radiation.disableEmission("test_band");
    radiation.setDirectRayCount("test_band", 100);
    radiation.setDiffuseRayCount("test_band", 0);
    radiation.setScatteringDepth("test_band", 1);
 
    uint source = radiation.addDiskRadiationSource(helios::make_vec3(0, 0, 0.5), 0.2f, helios::make_vec3(0, 0, 0));
    std::vector<helios::vec2> test_spectrum = {{400, 1.0f}, {700, 1.0f}};
    context.setGlobalData("test_spectrum", test_spectrum);
    radiation.setSourceSpectrum(source, "test_spectrum");
 
    CameraProperties camera_props;
    camera_props.camera_resolution = helios::make_int2(32, 32);
    camera_props.HFOV = 45.0f;
    camera_props.lens_diameter = 0.0f;
    radiation.addRadiationCamera("disk_cam", {"test_band"}, helios::make_vec3(0, 0, 2), helios::make_vec3(0, 0, 0), camera_props, 10);
 
    radiation.updateGeometry();
    radiation.runBand("test_band");
 
    auto pixel_data = radiation.getCameraPixelData("disk_cam", "test_band");
    DOCTEST_REQUIRE(!pixel_data.empty());
 
    int center_idx = (camera_props.camera_resolution.y / 2) * camera_props.camera_resolution.x + (camera_props.camera_resolution.x / 2);
    DOCTEST_CHECK(pixel_data[center_idx] > 0.0f);
}
 
GPU_TEST_CASE("RadiationModel - Camera Pixel UUID Indexing Validation") {
    // This test validates that camera pixel-to-UUID mapping is spatially correct
    // by checking that left pixels see left patches, not right patches (which would happen with horizontal flip bug)
 
    Context context;
 
    // Create 3 vertical patches side-by-side: left, center, right
    // Each patch is tagged with a unique ID for validation
    uint left_patch = context.addPatch(make_vec3(-1.5, 0, 0), make_vec2(0.8, 2));
    uint center_patch = context.addPatch(make_vec3(0, 0, 0), make_vec2(0.8, 2));
    uint right_patch = context.addPatch(make_vec3(1.5, 0, 0), make_vec2(0.8, 2));
 
    // Tag each patch with unique primitive data ID
    context.setPrimitiveData(left_patch, "patch_id", uint(1));
    context.setPrimitiveData(center_patch, "patch_id", uint(2));
    context.setPrimitiveData(right_patch, "patch_id", uint(3));
 
    // Set up radiation model with camera looking down from above
    RadiationModel radiationmodel = RadiationModelTestHelper::createWithSharedDevice(&context);
    radiationmodel.disableMessages();
 
    CameraProperties cam_props;
    cam_props.camera_resolution = make_int2(64, 64);
    cam_props.HFOV = 90; // Wide FOV to see all three patches
    cam_props.focal_plane_distance = 10;
    cam_props.lens_diameter = 0.0f;
 
    radiationmodel.addRadiationCamera("test_cam", {"SW"}, make_vec3(0, 0, 5), // Above scene
                                      make_vec3(0, 0, 0), // Looking down
                                      cam_props, 1);
 
    radiationmodel.addRadiationBand("SW");
    radiationmodel.setScatteringDepth("SW", 1); // Enable scattering for camera ray tracing
 
    // Add a radiation source - required for camera pixel labeling to run
    uint source = radiationmodel.addCollimatedRadiationSource(make_vec3(0, 0, 1));
    radiationmodel.setSourceFlux(source, "SW", 1000.f);
 
    radiationmodel.updateGeometry();
    radiationmodel.runBand("SW");
 
    // Write label map to temporary file
    // Filename format: {cameralabel}_{imagefile_base}_{frame:05d}.txt
    std::string test_file = "test_cam_test_camera_indexing_00000.txt";
    radiationmodel.writePrimitiveDataLabelMap("test_cam", "patch_id", "test_camera_indexing", "./", 0, 0.0f);
 
    // Read back the label map
    std::ifstream label_file(test_file);
    DOCTEST_REQUIRE_MESSAGE(label_file.is_open(), "Could not open label map file");
 
    std::vector<float> labels;
    float val;
    while (label_file >> val) {
        labels.push_back(val);
    }
    label_file.close();
 
    DOCTEST_REQUIRE_EQ(labels.size(), 64 * 64);
 
    // Check spatial correctness
    // World positions: patch1 at X=-1.5 (left), patch2 at X=0 (center), patch3 at X=+1.5 (right)
    // Sample left region of label map (x=[20,24])
    int left_votes = 0, center_votes = 0, right_votes = 0;
    for (int j = 26; j < 38; j++) {
        for (int i = 20; i < 25; i++) {
            float label = labels[j * 64 + i];
            if (label == 1.0f)
                left_votes++;
            else if (label == 2.0f)
                center_votes++;
            else if (label == 3.0f)
                right_votes++;
        }
    }
 
    // Left region should see world-left patch (ID=1)
    DOCTEST_CHECK_MESSAGE(left_votes > right_votes, "Left region should see world-left patch (ID=1), not world-right (ID=3)");
    DOCTEST_CHECK_MESSAGE(left_votes > center_votes, "Left region should predominantly see left patch");
 
    // Sample right region of label map (x=[39,43])
    left_votes = center_votes = right_votes = 0;
    for (int j = 26; j < 38; j++) {
        for (int i = 39; i < 44; i++) {
            float label = labels[j * 64 + i];
            if (label == 1.0f)
                left_votes++;
            else if (label == 2.0f)
                center_votes++;
            else if (label == 3.0f)
                right_votes++;
        }
    }
 
    // Right region should see world-right patch (ID=3)
    DOCTEST_CHECK_MESSAGE(right_votes > left_votes, "Right region should see world-right patch (ID=3), not world-left (ID=1)");
    DOCTEST_CHECK_MESSAGE(right_votes > center_votes, "Right region should predominantly see right patch");
 
    // Cleanup test file
    std::remove(test_file.c_str());
}
 
GPU_TEST_CASE("RadiationModel - Pixel Labeling with Fine Tessellation") {
    // Test that pixel labeling doesn't miss primitives when tessellation ≈ camera resolution
    // This validates the epsilon-tolerant boundary test prevents systematic misses
 
    Context context;
 
    // Create ground with tessellation matching camera resolution
    int res = 128; // Use 128x128 for fast test (principle same as 1024x1024)
    float camera_height = 20.0f;
    float HFOV_degrees = 45.0f;
 
    // Calculate tile size to fill camera FOV: ground_size = 2 * height * tan(HFOV/2)
    float ground_size = 2.0f * camera_height * tanf(HFOV_degrees * M_PI / 180.0f / 2.0f);
 
    std::vector<uint> ground = context.addTile(make_vec3(0, 0, 0), make_vec2(ground_size, ground_size), make_SphericalCoord(0, 0), make_int2(res, res));
 
    // Tag ground with data
    context.setPrimitiveData(ground, "ground_id", uint(42));
 
    // Camera looking straight down
    RadiationModel radiationmodel = RadiationModelTestHelper::createWithSharedDevice(&context);
    radiationmodel.disableMessages();
 
    CameraProperties cam_props;
    cam_props.camera_resolution = make_int2(res, res); // Match ground tessellation
    cam_props.HFOV = HFOV_degrees;
    cam_props.focal_plane_distance = 10;
    cam_props.lens_diameter = 0.0f;
 
    radiationmodel.addRadiationCamera("test_cam", {"SW"}, make_vec3(0, 0, camera_height), // Above ground
                                      make_vec3(0, 0, 0), // Looking down
                                      cam_props, 1);
 
    radiationmodel.addRadiationBand("SW");
    radiationmodel.setScatteringDepth("SW", 1); // Enable scattering for camera ray tracing
 
    // Add a radiation source - required for camera pixel labeling to run
    uint source = radiationmodel.addCollimatedRadiationSource(make_vec3(0, 0, 1));
    radiationmodel.setSourceFlux(source, "SW", 1000.f);
 
    radiationmodel.updateGeometry();
    radiationmodel.runBand("SW");
 
    // Write and read label map
    // Filename format: {cameralabel}_{imagefile_base}_{frame:05d}.txt
    std::string test_file = "test_cam_test_fine_tessellation_00000.txt";
    radiationmodel.writePrimitiveDataLabelMap("test_cam", "ground_id", "test_fine_tessellation", "./", 0, 0.0f);
 
    std::ifstream label_file(test_file);
    DOCTEST_REQUIRE(label_file.is_open());
 
    std::vector<float> labels;
    float val;
    while (label_file >> val) {
        labels.push_back(val);
    }
    label_file.close();
 
    // Count valid hits (ground_id = 42) vs misses (NaN)
    int valid_count = 0;
    int nan_count = 0;
    for (float label: labels) {
        if (std::isnan(label)) {
            nan_count++;
        } else if (label == 42.0f) {
            valid_count++;
        }
    }
 
    float valid_percentage = 100.0f * valid_count / labels.size();
 
    // Tile fills entire FOV, so should get >95% valid hits (allowing for edge pixels and numerical precision)
    DOCTEST_CHECK_MESSAGE(valid_percentage > 95.0f, "Pixel labeling with fine tessellation should have >95% valid hits, got " << valid_percentage << "%");
 
    // Cleanup
    std::remove(test_file.c_str());
}
 
GPU_TEST_CASE("RadiationModel - runBand Invalid Band Error Handling") {
 
    // Test 1: Single invalid band label
    DOCTEST_SUBCASE("Single invalid band") {
        Context context1;
        RadiationModel radiation1 = RadiationModelTestHelper::createWithSharedDevice(&context1);
        radiation1.disableMessages();
 
        uint uuid = context1.addPatch(make_vec3(0, 0, 0), make_vec2(1, 1));
        radiation1.addRadiationBand("PAR");
        uint source = radiation1.addCollimatedRadiationSource();
        radiation1.setSourceFlux(source, "PAR", 1000.f);
        radiation1.updateGeometry();
 
        // Try to run a band that doesn't exist
        bool exception_thrown = false;
        std::string error_message;
        try {
            radiation1.runBand("INVALID_BAND");
        } catch (const std::runtime_error &e) {
            exception_thrown = true;
            error_message = e.what();
            DOCTEST_CHECK(error_message.find("INVALID_BAND") != std::string::npos);
            DOCTEST_CHECK(error_message.find("not a valid band") != std::string::npos);
        } catch (const std::out_of_range &e) {
            // This is the bug - should throw helios_runtime_error, not out_of_range
            DOCTEST_FAIL("Caught std::out_of_range instead of helios_runtime_error. This indicates the bug is present.");
        }
        DOCTEST_CHECK_MESSAGE(exception_thrown, "Expected helios_runtime_error for invalid band");
    }
 
    // Test 2: Vector with mixed valid and invalid bands
    DOCTEST_SUBCASE("Mixed valid and invalid bands") {
        Context context2;
        RadiationModel radiation2 = RadiationModelTestHelper::createWithSharedDevice(&context2);
        radiation2.disableMessages();
 
        uint uuid = context2.addPatch(make_vec3(0, 0, 0), make_vec2(1, 1));
        radiation2.addRadiationBand("PAR");
        radiation2.addRadiationBand("NIR");
        uint source = radiation2.addCollimatedRadiationSource();
        radiation2.setSourceFlux(source, "PAR", 1000.f);
        radiation2.setSourceFlux(source, "NIR", 500.f);
        radiation2.updateGeometry();
 
        // Try to run bands where some exist and some don't
        std::vector<std::string> bands = {"PAR", "INVALID_BAND", "NIR"};
        bool exception_thrown = false;
        std::string error_message;
        try {
            radiation2.runBand(bands);
        } catch (const std::runtime_error &e) {
            exception_thrown = true;
            error_message = e.what();
            DOCTEST_CHECK(error_message.find("INVALID_BAND") != std::string::npos);
            DOCTEST_CHECK(error_message.find("not a valid band") != std::string::npos);
        } catch (const std::out_of_range &e) {
            // This is the bug - should throw helios_runtime_error, not out_of_range
            DOCTEST_FAIL("Caught std::out_of_range instead of helios_runtime_error. This indicates the bug is present.");
        }
        DOCTEST_CHECK_MESSAGE(exception_thrown, "Expected helios_runtime_error for invalid band in vector");
    }
 
    // Test 3: All invalid bands in vector
    DOCTEST_SUBCASE("All invalid bands") {
        Context context3;
        RadiationModel radiation3 = RadiationModelTestHelper::createWithSharedDevice(&context3);
        radiation3.disableMessages();
 
        uint uuid = context3.addPatch(make_vec3(0, 0, 0), make_vec2(1, 1));
        radiation3.addRadiationBand("PAR");
        uint source = radiation3.addCollimatedRadiationSource();
        radiation3.setSourceFlux(source, "PAR", 1000.f);
        radiation3.updateGeometry();
 
        // Try to run multiple bands that don't exist
        std::vector<std::string> bands = {"INVALID1", "INVALID2"};
        bool exception_thrown = false;
        std::string error_message;
        try {
            radiation3.runBand(bands);
        } catch (const std::runtime_error &e) {
            exception_thrown = true;
            error_message = e.what();
            // Should catch the first invalid band
            bool found_invalid = error_message.find("INVALID1") != std::string::npos || error_message.find("INVALID2") != std::string::npos;
            DOCTEST_CHECK(found_invalid);
            DOCTEST_CHECK(error_message.find("not a valid band") != std::string::npos);
        } catch (const std::out_of_range &e) {
            // This is the bug - should throw helios_runtime_error, not out_of_range
            DOCTEST_FAIL("Caught std::out_of_range instead of helios_runtime_error. This indicates the bug is present.");
        }
        DOCTEST_CHECK_MESSAGE(exception_thrown, "Expected helios_runtime_error for all invalid bands");
    }
}
 
GPU_TEST_CASE("RadiationModel - Segmentation Mask to Image Coordinate Alignment") {
    // This test validates that segmentation mask coordinates correctly align with camera images
    // by creating patches at known locations and verifying their bbox coordinates match the image
 
    Context context;
 
    // Create 4 patches at known positions forming a cross pattern
    uint top_patch = context.addPatch(make_vec3(0, 0, 1.5), make_vec2(0.5, 0.5));
    uint bottom_patch = context.addPatch(make_vec3(0, 0, -1.5), make_vec2(0.5, 0.5));
    uint left_patch = context.addPatch(make_vec3(-1.5, 0, 0), make_vec2(0.5, 0.5));
    uint right_patch = context.addPatch(make_vec3(1.5, 0, 0), make_vec2(0.5, 0.5));
 
    // Tag patches with unique IDs
    context.setPrimitiveData(top_patch, "patch_id", uint(1));
    context.setPrimitiveData(bottom_patch, "patch_id", uint(2));
    context.setPrimitiveData(left_patch, "patch_id", uint(3));
    context.setPrimitiveData(right_patch, "patch_id", uint(4));
 
    // Set up radiation model
    RadiationModel radiationmodel = RadiationModelTestHelper::createWithSharedDevice(&context);
    radiationmodel.disableMessages();
 
    CameraProperties cam_props;
    cam_props.camera_resolution = make_int2(128, 128);
    cam_props.HFOV = 60;
    cam_props.focal_plane_distance = 10;
    cam_props.lens_diameter = 0.0f;
 
    radiationmodel.addRadiationCamera("test_cam", {"SW"}, make_vec3(0, -10, 0), // Camera looking from -Y toward origin
                                      make_vec3(0, 0, 0), cam_props, 1);
 
    radiationmodel.addRadiationBand("SW");
    radiationmodel.setScatteringDepth("SW", 1);
 
    uint source = radiationmodel.addCollimatedRadiationSource(make_vec3(0, 1, 0));
    radiationmodel.setSourceFlux(source, "SW", 1000.f);
 
    radiationmodel.updateGeometry();
    radiationmodel.runBand("SW");
 
    // Write camera image and segmentation masks
    std::string image_file = radiationmodel.writeCameraImage("test_cam", {"SW"}, "test_alignment", "./");
 
    radiationmodel.writeImageSegmentationMasks("test_cam", "patch_id", 1u, "test_alignment_masks.json", image_file, {}, false);
 
    // Read the JSON file to get bounding boxes
    std::ifstream json_file("test_alignment_masks.json");
    DOCTEST_REQUIRE(json_file.is_open());
 
    std::stringstream buffer;
    buffer << json_file.rdbuf();
    json_file.close();
 
    nlohmann::json coco_json = nlohmann::json::parse(buffer.str());
 
    // Read the camera pixel UUID data
    std::vector<uint> pixel_UUIDs;
    context.getGlobalData("camera_test_cam_pixel_UUID", pixel_UUIDs);
 
    // For each annotation, verify the bbox encloses ALL pixels with that patch's UUID
    for (const auto &ann: coco_json["annotations"]) {
        int bbox_x = ann["bbox"][0];
        int bbox_y = ann["bbox"][1];
        int bbox_w = ann["bbox"][2];
        int bbox_h = ann["bbox"][3];
 
        // Get the segmentation to find which patch this is
        std::vector<int> seg_coords = ann["segmentation"][0];
 
        // Sample a pixel inside this bbox to determine which patch UUID it corresponds to
        int sample_x = bbox_x + bbox_w / 2;
        int sample_y = bbox_y + bbox_h / 2;
        uint sample_UUID = pixel_UUIDs.at(sample_y * 128 + sample_x) - 1;
 
        if (!context.doesPrimitiveExist(sample_UUID)) {
            continue;
        }
 
        // Find all pixels with this same UUID
        int min_x = 128, max_x = 0, min_y = 128, max_y = 0;
        bool found_any = false;
 
        for (int j = 0; j < 128; j++) {
            for (int i = 0; i < 128; i++) {
                uint UUID = pixel_UUIDs.at(j * 128 + i) - 1;
                if (UUID == sample_UUID) {
                    min_x = std::min(min_x, i);
                    max_x = std::max(max_x, i);
                    min_y = std::min(min_y, j);
                    max_y = std::max(max_y, j);
                    found_any = true;
                }
            }
        }
 
        if (found_any) {
            // Verify bbox from JSON matches actual pixel extent (allow 2-pixel tolerance for edge effects)
            DOCTEST_CHECK_MESSAGE(bbox_x <= min_x + 2, "Bbox x-min should match or slightly exceed actual pixels");
            DOCTEST_CHECK_MESSAGE(bbox_x + bbox_w >= max_x - 2, "Bbox x-max should match or slightly exceed actual pixels");
            DOCTEST_CHECK_MESSAGE(bbox_y <= min_y + 2, "Bbox y-min should match or slightly exceed actual pixels");
            DOCTEST_CHECK_MESSAGE(bbox_y + bbox_h >= max_y - 2, "Bbox y-max should match or slightly exceed actual pixels");
        }
    }
 
    // Cleanup
    std::remove("test_alignment_masks.json");
    std::remove(image_file.c_str());
}
 
GPU_TEST_CASE("RadiationModel - Mask Spatial Ordering Matches Image") {
    // Verify that left/right/top/bottom spatial relationships are preserved between image and masks
 
    Context context;
 
    // Create 3 patches in a horizontal line: left, center, right
    // Camera looks from (0,-10,0) toward origin, so patches should face -Y (rotated 90° about X axis)
    SphericalCoord rotation = make_SphericalCoord(M_PI / 2, 0); // 90° pitch to face -Y
    uint left_patch = context.addPatch(make_vec3(-2, 0, 0), make_vec2(0.8, 1.5), rotation);
    uint center_patch = context.addPatch(make_vec3(0, 0, 0), make_vec2(0.8, 1.5), rotation);
    uint right_patch = context.addPatch(make_vec3(2, 0, 0), make_vec2(0.8, 1.5), rotation);
 
    // Tag with IDs
    context.setPrimitiveData(left_patch, "patch_id", uint(10));
    context.setPrimitiveData(center_patch, "patch_id", uint(20));
    context.setPrimitiveData(right_patch, "patch_id", uint(30));
 
    RadiationModel radiationmodel = RadiationModelTestHelper::createWithSharedDevice(&context);
    radiationmodel.disableMessages();
 
    CameraProperties cam_props;
    cam_props.camera_resolution = make_int2(128, 128);
    cam_props.HFOV = 70;
    cam_props.focal_plane_distance = 10;
    cam_props.lens_diameter = 0.0f;
 
    radiationmodel.addRadiationCamera("test_cam", {"SW"}, make_vec3(0, -10, 0), make_vec3(0, 0, 0), cam_props, 1);
 
    radiationmodel.addRadiationBand("SW");
    radiationmodel.setScatteringDepth("SW", 1);
 
    uint source = radiationmodel.addCollimatedRadiationSource(make_vec3(0, 1, 0));
    radiationmodel.setSourceFlux(source, "SW", 1000.f);
 
    radiationmodel.updateGeometry();
    radiationmodel.runBand("SW");
 
    // Verify patches are visible in pixel data
    std::vector<uint> pixel_UUIDs_check;
    context.getGlobalData("camera_test_cam_pixel_UUID", pixel_UUIDs_check);
    int patch_hits = 0;
    for (uint uuid: pixel_UUIDs_check) {
        if (uuid > 0 && context.doesPrimitiveExist(uuid - 1)) {
            if (context.doesPrimitiveDataExist(uuid - 1, "patch_id")) {
                patch_hits++;
            }
        }
    }
    DOCTEST_INFO("Pixels hitting patches with patch_id: " << patch_hits);
    DOCTEST_REQUIRE_MESSAGE(patch_hits > 0, "Camera should hit at least some patches");
 
    // Write segmentation masks
    std::string image_file = radiationmodel.writeCameraImage("test_cam", {"SW"}, "spatial_test", "./");
    radiationmodel.writeImageSegmentationMasks("test_cam", "patch_id", 1u, "spatial_test_masks.json", image_file, {}, false);
 
    // Read JSON
    std::ifstream json_file("spatial_test_masks.json");
    DOCTEST_REQUIRE(json_file.is_open());
 
    std::stringstream buffer;
    buffer << json_file.rdbuf();
    json_file.close();
 
    nlohmann::json coco_json = nlohmann::json::parse(buffer.str());
 
    // Debug: check if annotations exist
    DOCTEST_INFO("Number of annotations: " << coco_json["annotations"].size());
 
    // Find bbox center x-coordinates for each patch ID
    std::map<int, int> patch_center_x; // patch_id -> center_x
 
    for (const auto &ann: coco_json["annotations"]) {
        int cat_id = ann["category_id"];
        int bbox_x = ann["bbox"][0];
        int bbox_w = ann["bbox"][2];
        int center_x = bbox_x + bbox_w / 2;
 
        // Map category_id back to patch_id (we set them both to 1u in writeImageSegmentationMasks)
        // We need to look at the actual labels to find which is which
        // Since all have category_id=1, we can't distinguish them this way
        // Instead, check the bbox positions
        patch_center_x[center_x] = center_x; // Just store for now
    }
 
    // We should have 3 annotations
    DOCTEST_CHECK_EQ(coco_json["annotations"].size(), 3);
 
    // Extract and sort the center x coordinates
    std::vector<int> centers;
    for (const auto &ann: coco_json["annotations"]) {
        int bbox_x = ann["bbox"][0];
        int bbox_w = ann["bbox"][2];
        centers.push_back(bbox_x + bbox_w / 2);
    }
    std::sort(centers.begin(), centers.end());
 
    // Verify spatial ordering: centers should be increasing from left to right
    if (centers.size() == 3) {
        DOCTEST_CHECK_MESSAGE(centers[0] < centers[1], "Left patch should be left of center patch");
        DOCTEST_CHECK_MESSAGE(centers[1] < centers[2], "Center patch should be left of right patch");
 
        // Verify they're reasonably spaced (not all clustered)
        int spacing1 = centers[1] - centers[0];
        int spacing2 = centers[2] - centers[1];
        DOCTEST_CHECK_MESSAGE(spacing1 > 5, "Patches should be visibly separated in x");
        DOCTEST_CHECK_MESSAGE(spacing2 > 5, "Patches should be visibly separated in x");
        DOCTEST_CHECK_MESSAGE(abs(spacing1 - spacing2) < spacing1 * 0.5, "Spacing should be roughly uniform");
    }
 
    // Cleanup
    std::remove("spatial_test_masks.json");
    std::remove(image_file.c_str());
}
 
GPU_TEST_CASE("RadiationModel - Data Label Maps Match Segmentation Mask Coordinates") {
    // Validates that writePrimitiveDataLabelMap and writeObjectDataLabelMap use the same
    // coordinate system as segmentation masks by comparing their outputs
 
    Context context;
 
    // Create 3 tiles (returning primitive UUIDs) with distinct primitive and object data values
    std::vector<uint> patch1_uuids = context.addTile(make_vec3(-1.5, 0, 0), make_vec2(0.8, 2), make_SphericalCoord(0, 0), make_int2(1, 1));
    std::vector<uint> patch2_uuids = context.addTile(make_vec3(0, 0, 0), make_vec2(0.8, 2), make_SphericalCoord(0, 0), make_int2(1, 1));
    std::vector<uint> patch3_uuids = context.addTile(make_vec3(1.5, 0, 0), make_vec2(0.8, 2), make_SphericalCoord(0, 0), make_int2(1, 1));
 
    // Create polymesh objects for object data
    uint obj1 = context.addPolymeshObject(patch1_uuids);
    uint obj2 = context.addPolymeshObject(patch2_uuids);
    uint obj3 = context.addPolymeshObject(patch3_uuids);
 
    // Set primitive data
    context.setPrimitiveData(patch1_uuids, "patch_id", uint(10));
    context.setPrimitiveData(patch2_uuids, "patch_id", uint(20));
    context.setPrimitiveData(patch3_uuids, "patch_id", uint(30));
 
    // Set object data
    context.setObjectData(obj1, "obj_id", uint(100));
    context.setObjectData(obj2, "obj_id", uint(200));
    context.setObjectData(obj3, "obj_id", uint(300));
 
    RadiationModel radiationmodel = RadiationModelTestHelper::createWithSharedDevice(&context);
    radiationmodel.disableMessages();
 
    CameraProperties cam_props;
    cam_props.camera_resolution = make_int2(64, 64);
    cam_props.HFOV = 90;
    cam_props.focal_plane_distance = 10;
    cam_props.lens_diameter = 0.0f;
 
    radiationmodel.addRadiationCamera("test_cam", {"SW"}, make_vec3(0, 0, 5), make_vec3(0, 0, 0), cam_props, 1);
 
    radiationmodel.addRadiationBand("SW");
    radiationmodel.setScatteringDepth("SW", 1);
 
    uint source = radiationmodel.addCollimatedRadiationSource(make_vec3(0, 0, 1));
    radiationmodel.setSourceFlux(source, "SW", 1000.f);
 
    radiationmodel.updateGeometry();
    radiationmodel.runBand("SW");
 
    // Write all outputs
    std::string image_file = radiationmodel.writeCameraImage("test_cam", {"SW"}, "coord_match_test", "./");
    radiationmodel.writePrimitiveDataLabelMap("test_cam", "patch_id", "coord_match_primdata", "./", 0, 0.0f);
    radiationmodel.writeObjectDataLabelMap("test_cam", "obj_id", "coord_match_objdata", "./", 0, 0.0f);
    radiationmodel.writeImageSegmentationMasks_ObjectData("test_cam", "obj_id", 1u, "./coord_match_masks.json", image_file, {}, false);
 
    // Read primitive data label map
    std::ifstream prim_file("test_cam_coord_match_primdata_00000.txt");
    DOCTEST_REQUIRE(prim_file.is_open());
    std::vector<float> prim_labels;
    float val;
    while (prim_file >> val) {
        prim_labels.push_back(val);
    }
    prim_file.close();
    DOCTEST_REQUIRE_EQ(prim_labels.size(), 64 * 64);
 
    // Read object data label map
    std::ifstream obj_file("test_cam_coord_match_objdata_00000.txt");
    DOCTEST_REQUIRE(obj_file.is_open());
    std::vector<float> obj_labels;
    while (obj_file >> val) {
        obj_labels.push_back(val);
    }
    obj_file.close();
    DOCTEST_REQUIRE_EQ(obj_labels.size(), 64 * 64);
 
    // Read JSON masks
    std::ifstream json_file("./coord_match_masks.json");
    DOCTEST_REQUIRE(json_file.is_open());
    std::stringstream buffer;
    buffer << json_file.rdbuf();
    json_file.close();
    nlohmann::json coco_json = nlohmann::json::parse(buffer.str());
 
    // For each annotation, verify that the bbox region contains consistent data values
    // Sample multiple pixels across the bbox region to detect horizontal/vertical flips
    int total_annotations = coco_json["annotations"].size();
    DOCTEST_REQUIRE_MESSAGE(total_annotations == 3, "Should have 3 annotations, got " << total_annotations);
 
    // Expected values based on world positions:
    // Left patch (world X=-1.5): obj_id=100, should appear at low image-x
    // Center patch (world X=0): obj_id=200, should appear at middle image-x
    // Right patch (world X=+1.5): obj_id=300, should appear at high image-x
 
    // Sort annotations by bbox x-position to get left, center, right
    std::vector<std::tuple<int, int, int, int, int>> ann_data; // x, y, w, h, index
    for (size_t idx = 0; idx < coco_json["annotations"].size(); idx++) {
        const auto &ann = coco_json["annotations"][idx];
        ann_data.push_back({ann["bbox"][0].get<int>(), ann["bbox"][1].get<int>(), ann["bbox"][2].get<int>(), ann["bbox"][3].get<int>(), static_cast<int>(idx)});
    }
    std::sort(ann_data.begin(), ann_data.end()); // Sort by x position
 
    // Expected object IDs from left to right IN MASK/LABEL MAP COORDINATE SPACE
    // Dev's backend implementation produces unflipped coordinates (world order matches image order)
    std::vector<uint> expected_obj_ids = {100, 200, 300};
 
    for (size_t i = 0; i < ann_data.size(); i++) {
        auto [bbox_x, bbox_y, bbox_w, bbox_h, ann_idx] = ann_data[i];
        uint expected_obj_value = expected_obj_ids[i];
 
        // Verify label map has the SAME value in this bbox region
        int correct_value_count = 0;
        int total_pixels = 0;
 
        for (int dy = 0; dy < bbox_h; dy++) {
            for (int dx = 0; dx < bbox_w; dx++) {
                int px = bbox_x + dx;
                int py = bbox_y + dy;
 
                if (px < 0 || px >= 64 || py < 0 || py >= 64)
                    continue;
 
                float obj_value = obj_labels[py * 64 + px];
 
                // Check if label map has the CORRECT value (not just any non-zero)
                if (fabs(obj_value - expected_obj_value) < 1.0f) {
                    correct_value_count++;
                }
                total_pixels++;
            }
        }
 
        float match_percentage = 100.0f * correct_value_count / total_pixels;
 
        // Sample what value we're actually getting at bbox center
        int center_x = bbox_x + bbox_w / 2;
        int center_y = bbox_y + bbox_h / 2;
        float sample_actual_value = obj_labels[center_y * 64 + center_x];
 
        // If coordinates match correctly, bbox region should have the CORRECT value (not wrong patch's value)
        DOCTEST_CHECK_MESSAGE(match_percentage > 80.0f, "At least 80% of bbox pixels should have CORRECT data value in label map. "
                                                        "If this fails, label map coordinates are flipped relative to mask. Got "
                                                                << match_percentage << "%");
    }
 
    // Cleanup
    std::remove("test_cam_coord_match_primdata_00000.txt");
    std::remove("test_cam_coord_match_objdata_00000.txt");
    std::remove("./coord_match_masks.json");
    std::remove(image_file.c_str());
}
 
GPU_TEST_CASE("RadiationModel - Pixel Label UUID Mapping With Non-Sequential Object Ordering") {
    // Verifies that writePrimitiveDataLabelMap reports correct data values when
    // buildGeometryData reorders primitives by parent object, causing the internal
    // context_UUIDs ordering to differ from UUID assignment order.
    //
    // Setup: Create a polymesh object (objID > 0) on the LEFT with low UUIDs, then an
    // orphan patch (objID 0) on the RIGHT with a higher UUID. buildGeometryData sorts by
    // objID, placing the orphan (high UUID) before the polymesh (low UUIDs) in its internal
    // ordering. The test checks spatial correctness: left pixels should have element_type=1
    // (polymesh) and right pixels should have element_type=2 (orphan).
 
    Context context;
 
    SphericalCoord up_rotation = make_SphericalCoord(0, 0);
 
    // Step 1: Create patches on the LEFT and group into a polymesh — gets low UUIDs, objID > 0
    std::vector<uint> obj_patch_UUIDs;
    for (int i = 0; i < 9; i++) {
        float x = -1.5f + (i % 3) * 0.5f;
        float y = (i / 3) * 0.5f - 0.5f;
        obj_patch_UUIDs.push_back(context.addPatch(make_vec3(x, y, 0), make_vec2(0.45, 0.45), up_rotation));
    }
    context.addPolymeshObject(obj_patch_UUIDs);
 
    // Step 2: Create orphan patch on the RIGHT — gets higher UUID, parent object ID = 0
    uint orphan_UUID = context.addPatch(make_vec3(1.5, 0, 0), make_vec2(1.5, 1.5), up_rotation);
 
    // Verify the setup creates the non-sequential ordering needed to trigger the bug
    DOCTEST_REQUIRE_EQ(context.getPrimitiveParentObjectID(orphan_UUID), 0u);
    DOCTEST_REQUIRE_GT(context.getPrimitiveParentObjectID(obj_patch_UUIDs.front()), 0u);
    DOCTEST_REQUIRE_GT(orphan_UUID, obj_patch_UUIDs.back());
 
    // Set distinct element_type values: 1 = polymesh (left), 2 = orphan (right)
    context.setPrimitiveData(obj_patch_UUIDs, "element_type", 1u);
    context.setPrimitiveData(orphan_UUID, "element_type", 2u);
 
    // Set up radiation model with camera looking straight down
    RadiationModel radiationmodel = RadiationModelTestHelper::createWithSharedDevice(&context);
    radiationmodel.disableMessages();
 
    CameraProperties cam_props;
    cam_props.camera_resolution = make_int2(64, 64);
    cam_props.HFOV = 90;
    cam_props.focal_plane_distance = 5;
    cam_props.lens_diameter = 0.0f;
 
    radiationmodel.addRadiationCamera("test_cam", {"SW"}, make_vec3(0, 0, 5), make_vec3(0, 0, 0), cam_props, 1);
 
    radiationmodel.addRadiationBand("SW");
    radiationmodel.setScatteringDepth("SW", 1);
 
    uint source = radiationmodel.addCollimatedRadiationSource(make_vec3(0, 0, 1));
    radiationmodel.setSourceFlux(source, "SW", 1000.f);
 
    radiationmodel.updateGeometry();
    radiationmodel.runBand("SW");
 
    // Write the label map and read it back
    radiationmodel.writePrimitiveDataLabelMap("test_cam", "element_type", "uuid_mapping_test", "./", 0, 0.0f);
 
    std::ifstream label_file("test_cam_uuid_mapping_test_00000.txt");
    DOCTEST_REQUIRE(label_file.is_open());
    std::vector<float> labels;
    float val;
    while (label_file >> val) {
        labels.push_back(val);
    }
    label_file.close();
    DOCTEST_REQUIRE_EQ(labels.size(), 64u * 64u);
 
    // Check spatial correctness: left-side pixels (columns 0-31) should be polymesh (1)
    // or sky (nan), right-side pixels (columns 32-63) should be orphan (2) or sky (nan).
    // The polymesh is at x=-1.5 (image left) and the orphan is at x=+1.5 (image right).
    int left_polymesh = 0, left_orphan = 0;
    int right_polymesh = 0, right_orphan = 0;
 
    for (int j = 0; j < 64; j++) {
        for (int i = 0; i < 64; i++) {
            float label = labels[j * 64 + i];
            if (std::isnan(label)) continue;
 
            uint label_uint = static_cast<uint>(label);
            bool is_left = (i < 32);
 
            if (is_left) {
                if (label_uint == 1u) left_polymesh++;
                else if (label_uint == 2u) left_orphan++;
            } else {
                if (label_uint == 1u) right_polymesh++;
                else if (label_uint == 2u) right_orphan++;
            }
        }
    }
 
    // Polymesh (element_type=1) should appear on the left, orphan (element_type=2) on the right.
    // If the UUID mapping is broken, the values will be swapped.
    DOCTEST_CHECK_MESSAGE(left_polymesh > 0, "Polymesh patches (element_type=1) should appear on the left side of the image");
    DOCTEST_CHECK_MESSAGE(right_orphan > 0, "Orphan patch (element_type=2) should appear on the right side of the image");
    DOCTEST_CHECK_MESSAGE(left_orphan == 0,
        "No orphan labels should appear on the left side (got " << left_orphan << " — indicates UUID mapping error)");
    DOCTEST_CHECK_MESSAGE(right_polymesh == 0,
        "No polymesh labels should appear on the right side (got " << right_polymesh << " — indicates UUID mapping error)");
 
    std::remove("test_cam_uuid_mapping_test_00000.txt");
}
 
GPU_TEST_CASE("Material Backend Migration - Spectrum Interpolation Integration") {
    // Test that spectrum interpolation configs are properly applied in buildMaterialData()
 
    helios::Context context;
    RadiationModel radiationmodel = RadiationModelTestHelper::createWithSharedDevice(&context);
    radiationmodel.disableMessages();
 
    // Create spectral data for different ages
    std::vector<helios::vec2> spectrum_young = {{400, 0.1}, {500, 0.15}, {600, 0.2}, {700, 0.25}};
    std::vector<helios::vec2> spectrum_old = {{400, 0.5}, {500, 0.55}, {600, 0.6}, {700, 0.65}};
 
    context.setGlobalData("rho_young", spectrum_young);
    context.setGlobalData("rho_old", spectrum_old);
 
    // Create test primitive
    uint uuid = context.addPatch(helios::make_vec3(0, 0, 0), helios::make_vec2(1, 1));
    context.setPrimitiveData(uuid, "leaf_age", 8.0f); // Should select "rho_old" (closer to 10 than 0)
 
    // Set up interpolation config
    std::vector<uint> uuids = {uuid};
    std::vector<std::string> spectra = {"rho_young", "rho_old"};
    std::vector<float> values = {0.0f, 10.0f};
    radiationmodel.interpolateSpectrumFromPrimitiveData(uuids, spectra, values, "leaf_age", "reflectivity_spectrum");
 
    // Add band with wavelength bounds for spectral integration
    radiationmodel.addRadiationBand("PAR", 400.f, 700.f);
    radiationmodel.disableEmission("PAR"); // Disable emission to avoid energy conservation errors
    radiationmodel.setScatteringDepth("PAR", 1); // Enable scattering so material calculation runs
 
    // Add source with constant flux
    uint source = radiationmodel.addCollimatedRadiationSource();
    radiationmodel.setSourceFlux(source, "PAR", 1000.f);
 
    // Update geometry and run - this triggers buildMaterialData()
    radiationmodel.updateGeometry();
    radiationmodel.runBand("PAR");
 
    // Verify that interpolation was applied
    std::string assigned_spectrum;
    DOCTEST_REQUIRE(context.doesPrimitiveDataExist(uuid, "reflectivity_spectrum"));
    context.getPrimitiveData(uuid, "reflectivity_spectrum", assigned_spectrum);
    DOCTEST_CHECK(assigned_spectrum == "rho_old");
}
 
GPU_TEST_CASE("Material Backend Migration - Camera Weighted Materials") {
    // Test that camera-weighted materials are correctly calculated with spectral responses
 
    helios::Context context;
    RadiationModel radiationmodel = RadiationModelTestHelper::createWithSharedDevice(&context);
    radiationmodel.disableMessages();
 
    // Create object spectrum (reflectivity)
    std::vector<helios::vec2> object_spectrum = {{400, 0.1}, {500, 0.3}, {600, 0.5}, {700, 0.7}};
    context.setGlobalData("object_rho", object_spectrum);
 
    // Create camera spectral response (Gaussian-like, peaked at 550nm)
    std::vector<helios::vec2> camera_response = {{400, 0.2}, {500, 0.8}, {600, 0.8}, {700, 0.2}};
    context.setGlobalData("camera_green", camera_response);
 
    // Create source spectrum (sunlight-like)
    std::vector<helios::vec2> source_spectrum = {{400, 0.8}, {500, 1.0}, {600, 1.0}, {700, 0.9}};
    context.setGlobalData("sunlight", source_spectrum);
 
    // Create test primitive with spectral reflectivity
    uint uuid = context.addPatch(helios::make_vec3(0, 0, 0), helios::make_vec2(1, 1));
    context.setPrimitiveData(uuid, "reflectivity_spectrum", std::string("object_rho"));
 
    // Add band with wavelength bounds
    radiationmodel.addRadiationBand("VIS", 400.f, 700.f);
    radiationmodel.disableEmission("VIS"); // Disable emission to avoid energy conservation errors
    radiationmodel.setScatteringDepth("VIS", 1); // Enable scattering for camera rendering
 
    // Add source with spectrum
    uint source = radiationmodel.addCollimatedRadiationSource();
    radiationmodel.setSourceFlux(source, "VIS", 1000.f);
    radiationmodel.setSourceSpectrum(source, "sunlight");
 
    // Add camera with spectral response
    CameraProperties cam_props;
    cam_props.camera_resolution = helios::make_int2(10, 10);
    cam_props.HFOV = 45.f;
    cam_props.focal_plane_distance = 2.0f;
    cam_props.lens_diameter = 0.0f; // Pinhole
 
    std::vector<std::string> band_labels = {"VIS"};
    radiationmodel.addRadiationCamera("test_cam", band_labels, helios::make_vec3(0, -5, 0), helios::make_vec3(0, 0, 0), cam_props, 1);
    radiationmodel.setCameraSpectralResponse("test_cam", "VIS", "camera_green");
 
    // Update and run
    radiationmodel.updateGeometry();
    radiationmodel.runBand("VIS");
 
    // Verify camera data was generated
    DOCTEST_CHECK(context.doesGlobalDataExist("camera_test_cam_VIS"));
 
    // Get camera data
    if (context.doesGlobalDataExist("camera_test_cam_VIS")) {
        std::vector<float> camera_data;
        context.getGlobalData("camera_test_cam_VIS", camera_data);
        DOCTEST_CHECK(camera_data.size() == 100); // 10x10 pixels
    }
}
 
GPU_TEST_CASE("RadiationModel - Specular Reflection Camera Rendering") {
    // Test that setting specular_exponent affects camera rendering
    // This verifies specular reflection is enabled and working correctly
 
    Context context;
    RadiationModel radiation = RadiationModelTestHelper::createWithSharedDevice(&context);
    radiation.disableMessages();
 
    // Create patch at origin facing +Z
    uint UUID = context.addPatch(make_vec3(0, 0, 0), make_vec2(1, 1));
    context.setPrimitiveData(UUID, "twosided_flag", uint(1));
 
    // Set low diffuse reflectivity to isolate specular contribution
    std::vector<helios::vec2> reflectivity = {make_vec2(400, 0.05f), make_vec2(700, 0.05f)};
    context.setGlobalData("reflectivity", reflectivity);
    context.setPrimitiveData(UUID, "reflectivity_spectrum", "reflectivity");
 
    std::vector<helios::vec2> zero_transmissivity = {make_vec2(400, 0.0f), make_vec2(700, 0.0f)};
    context.setGlobalData("zero_transmissivity", zero_transmissivity);
    context.setPrimitiveData(UUID, "transmissivity_spectrum", "zero_transmissivity");
 
    // Setup radiation band and source
    radiation.addRadiationBand("SUN");
    radiation.setScatteringDepth("SUN", 1);
 
    helios::vec3 sun_direction = helios::make_vec3(0, 0, 1); // Sun above (direction points TO sun)
    uint source = radiation.addCollimatedRadiationSource(sun_direction);
    radiation.setSourceFlux(source, "SUN", 1000.0f);
    radiation.setDirectRayCount("SUN", 10000);
    radiation.setDiffuseRayCount("SUN", 0);
    radiation.disableEmission("SUN");
 
    // Camera looking straight down at patch
    helios::vec3 camera_pos = helios::make_vec3(0, 0, 2.0f);
    helios::vec3 camera_lookat = helios::make_vec3(0, 0, 0);
    CameraProperties cam_props;
    cam_props.camera_resolution = make_int2(32, 32);
    cam_props.lens_diameter = 0.0f;
    cam_props.focal_plane_distance = 2.0f;
    cam_props.HFOV = 30.0f;
    radiation.addRadiationCamera("test_cam", {"SUN"}, camera_pos, camera_lookat, cam_props, 100);
 
    std::vector<helios::vec2> camera_response = {make_vec2(400, 1.0f), make_vec2(700, 1.0f)};
    context.setGlobalData("camera_response", camera_response);
    radiation.setCameraSpectralResponse("test_cam", "SUN", "camera_response");
 
    // TEST 1: specular_exponent = -1 (disabled)
    {
        capture_cout capture;
        context.setPrimitiveData(UUID, "specular_exponent", -1.0f);
        radiation.updateGeometry();
        radiation.runBand("SUN");
    }
 
    std::vector<float> pixels_no_specular;
    context.getGlobalData("camera_test_cam_SUN", pixels_no_specular);
 
    float sum_no_specular = 0.0f;
    for (float p: pixels_no_specular) {
        sum_no_specular += p;
    }
    float avg_no_specular = sum_no_specular / (float)pixels_no_specular.size();
 
    // TEST 2: specular_exponent = 50 (strong specular highlight)
    {
        capture_cout capture;
        context.setPrimitiveData(UUID, "specular_exponent", 50.0f);
        radiation.updateGeometry();
        radiation.runBand("SUN");
    }
 
    std::vector<float> pixels_with_specular;
    context.getGlobalData("camera_test_cam_SUN", pixels_with_specular);
 
    float sum_with_specular = 0.0f;
    for (float p: pixels_with_specular) {
        sum_with_specular += p;
    }
    float avg_with_specular = sum_with_specular / (float)pixels_with_specular.size();
 
    float difference = avg_with_specular - avg_no_specular;
 
    DOCTEST_MESSAGE("No specular avg: " << avg_no_specular << ", With specular avg: " << avg_with_specular << ", Difference: " << difference);
 
    // Specular should add a visible highlight when sun, camera, and normal are aligned
    DOCTEST_CHECK_MESSAGE(difference > 5.0f, "Specular exponent should increase camera intensity. "
                                                       "No specular: "
                                                               << avg_no_specular << ", With specular: " << avg_with_specular << ", Difference: " << difference);
}
 
GPU_TEST_CASE("RadiationModel - Specular Reflection Multiple Cameras") {
    // Test that specular reflection works correctly with multiple cameras.
    // Each camera should independently see specular highlights based on its own
    // viewing geometry relative to the light source.
 
    Context context;
    RadiationModel radiation = RadiationModelTestHelper::createWithSharedDevice(&context);
    radiation.disableMessages();
 
    // Create patch at origin facing +Z
    uint UUID = context.addPatch(make_vec3(0, 0, 0), make_vec2(1, 1));
    context.setPrimitiveData(UUID, "twosided_flag", uint(1));
 
    std::vector<helios::vec2> reflectivity = {make_vec2(400, 0.05f), make_vec2(700, 0.05f)};
    context.setGlobalData("reflectivity", reflectivity);
    context.setPrimitiveData(UUID, "reflectivity_spectrum", "reflectivity");
 
    std::vector<helios::vec2> zero_transmissivity = {make_vec2(400, 0.0f), make_vec2(700, 0.0f)};
    context.setGlobalData("zero_transmissivity", zero_transmissivity);
    context.setPrimitiveData(UUID, "transmissivity_spectrum", "zero_transmissivity");
 
    context.setPrimitiveData(UUID, "specular_exponent", 50.0f);
 
    radiation.addRadiationBand("SUN");
    radiation.setScatteringDepth("SUN", 1);
 
    helios::vec3 sun_direction = helios::make_vec3(0, 0, 1); // Sun directly above
    uint source = radiation.addCollimatedRadiationSource(sun_direction);
    radiation.setSourceFlux(source, "SUN", 1000.0f);
    radiation.setDirectRayCount("SUN", 10000);
    radiation.setDiffuseRayCount("SUN", 0);
    radiation.disableEmission("SUN");
 
    CameraProperties cam_props;
    cam_props.camera_resolution = make_int2(32, 32);
    cam_props.lens_diameter = 0.0f;
    cam_props.focal_plane_distance = 2.0f;
    cam_props.HFOV = 30.0f;
 
    std::vector<helios::vec2> camera_response = {make_vec2(400, 1.0f), make_vec2(700, 1.0f)};
    context.setGlobalData("camera_response", camera_response);
 
    // Camera A: directly above, aligned with sun → strong specular
    radiation.addRadiationCamera("cam_A", {"SUN"}, make_vec3(0, 0, 2), make_vec3(0, 0, 0), cam_props, 100);
    radiation.setCameraSpectralResponse("cam_A", "SUN", "camera_response");
 
    // Camera B: also directly above (different label) → should also see strong specular
    radiation.addRadiationCamera("cam_B", {"SUN"}, make_vec3(0, 0, 2), make_vec3(0, 0, 0), cam_props, 100);
    radiation.setCameraSpectralResponse("cam_B", "SUN", "camera_response");
 
    {
        capture_cout capture;
        radiation.updateGeometry();
        radiation.runBand("SUN");
    }
 
    // Get results for both cameras
    std::vector<float> pixels_A, pixels_B;
    context.getGlobalData("camera_cam_A_SUN", pixels_A);
    context.getGlobalData("camera_cam_B_SUN", pixels_B);
 
    float sum_A = 0.0f, sum_B = 0.0f;
    for (float p : pixels_A) sum_A += p;
    for (float p : pixels_B) sum_B += p;
    float avg_A = sum_A / (float)pixels_A.size();
    float avg_B = sum_B / (float)pixels_B.size();
 
    // Pure diffuse baseline: reflectivity(0.05) * flux(1000) / pi ≈ 15.9
    float diffuse_baseline = 15.0f;
 
    DOCTEST_MESSAGE("Camera A avg: " << avg_A << ", Camera B avg: " << avg_B << ", Diffuse baseline ~" << diffuse_baseline);
 
    // Both cameras should see specular (both are at the same position, both see the highlight)
    DOCTEST_CHECK_MESSAGE(avg_A > diffuse_baseline * 2.0f, "Camera A should show specular highlight. avg_A: " << avg_A);
    DOCTEST_CHECK_MESSAGE(avg_B > diffuse_baseline * 2.0f, "Camera B should show specular highlight. avg_B: " << avg_B);
 
    // Both cameras are in the same position, so their values should be similar
    float ratio = (avg_A > avg_B) ? avg_B / avg_A : avg_A / avg_B;
    DOCTEST_CHECK_MESSAGE(ratio > 0.8f, "Both cameras should see similar specular intensity. "
                                        "avg_A: " << avg_A << ", avg_B: " << avg_B << ", ratio: " << ratio);
}
 
GPU_TEST_CASE("RadiationModel More Than 4 Simultaneous Radiation Bands") {
    // Verify the Vulkan backend has no hard-coded 4-band limit.
    // Run 6 bands simultaneously and check that each receives the correct flux
    // from an overhead collimated source hitting an opaque patch.
 
    const int Nbands = 6;
    const float error_threshold = 0.005f;
    const uint Ndirect = 10000;
 
    Context context;
    RadiationModel radiation = RadiationModelTestHelper::createWithSharedDevice(&context);
    radiation.disableMessages();
 
    // One opaque patch at origin facing up
    uint UUID = context.addPatch(make_vec3(0, 0, 0), make_vec2(1, 1), nullrotation);
 
    // Collimated source straight overhead
    uint src = radiation.addCollimatedRadiationSource(make_vec3(0, 0, 1));
 
    std::vector<std::string> band_names;
    std::vector<float> expected_flux;
 
    for (int b = 0; b < Nbands; b++) {
        std::string name = "band_" + std::to_string(b);
        band_names.push_back(name);
        float flux = float(b + 1) * 100.f; // 100, 200, 300, 400, 500, 600
        expected_flux.push_back(flux);
 
        radiation.addRadiationBand(name);
        radiation.disableEmission(name);
        radiation.setSourceFlux(src, name, flux);
        radiation.setDirectRayCount(name, Ndirect);
    }
 
    radiation.updateGeometry();
    radiation.runBand(band_names);
 
    for (int b = 0; b < Nbands; b++) {
        float measured;
        context.getPrimitiveData(UUID, ("radiation_flux_" + band_names[b]).c_str(), measured);
        float rel_error = std::abs(measured - expected_flux[b]) / expected_flux[b];
        DOCTEST_CHECK_MESSAGE(rel_error <= error_threshold, "Band " << band_names[b] << ": expected " << expected_flux[b] << ", got " << measured << " (error " << rel_error << ")");
    }
}
 
// ===========================================================================
// Bug regression tests for OptiX 8 camera rendering
// ===========================================================================
 
GPU_TEST_CASE("RadiationModel - Camera triangle vs patch rendering parity") {
    // Regression test: triangles must produce non-zero camera radiance when lit,
    // matching patch behavior. A bug in __closesthit__camera() computed the surface
    // normal incorrectly for triangles (using patch canonical vertices instead of
    // triangle canonical vertices), causing it to read radiation_out from the wrong
    // face buffer and producing black pixels for all triangle primitives.
 
    Context context;
    RadiationModel radiation = RadiationModelTestHelper::createWithSharedDevice(&context);
    radiation.disableMessages();
 
    // Create a patch and a triangle side by side at z=0, both facing up (+z).
    // The patch is on the left (x<0), the triangle on the right (x>0).
    float reflectivity = 0.5f;
 
    uint patch_id = context.addPatch(make_vec3(-0.25f, 0, 0), make_vec2(0.4f, 0.4f));
    context.setPrimitiveData(patch_id, "reflectivity_SW", reflectivity);
    context.setPrimitiveData(patch_id, "twosided_flag", uint(0));
 
    // Triangle covering roughly the same area as the patch, on the right side
    uint tri_id = context.addTriangle(make_vec3(0.05f, -0.2f, 0),
                                      make_vec3(0.45f, -0.2f, 0),
                                      make_vec3(0.25f, 0.2f, 0));
    context.setPrimitiveData(tri_id, "reflectivity_SW", reflectivity);
 
    // Single radiation band with scattering
    radiation.addRadiationBand("SW");
    radiation.disableEmission("SW");
    radiation.setDirectRayCount("SW", 250);
    radiation.setDiffuseRayCount("SW", 100);
    radiation.setScatteringDepth("SW", 1);
 
    // Collimated source from above (zenith)
    uint src = radiation.addCollimatedRadiationSource(make_vec3(0, 0, 1));
    radiation.setSourceFlux(src, "SW", 500.f);
 
    // Camera looking straight down at the scene
    CameraProperties cam_props;
    cam_props.camera_resolution = make_int2(64, 64);
    cam_props.HFOV = 60.0f;
    cam_props.lens_diameter = 0.0f;
    radiation.addRadiationCamera("test_cam", {"SW"},
                                 make_vec3(0, 0, 1.5f),   // above scene
                                 make_vec3(0, 0, 0),       // look at center
                                 cam_props, 50);
 
    radiation.updateGeometry();
    radiation.runBand("SW");
 
    auto pixel_data = radiation.getCameraPixelData("test_cam", "SW");
    DOCTEST_REQUIRE(pixel_data.size() == 64 * 64);
 
    // Sample pixels over the patch region (left half, center rows).
    // Camera image is flipped horizontally (ii = resolution.x - i - 1),
    // so world-left (x<0) appears on the right side of the pixel buffer.
    // With a 60-deg HFOV looking from z=1.5 at z=0, the viewable width is
    // ~1.73m. The patch at x=-0.25 maps to approximately pixel column 48-56 (right side).
    // The triangle at x=+0.25 maps to approximately pixel column 8-16 (left side).
    float patch_sum = 0;
    int patch_count = 0;
    float tri_sum = 0;
    int tri_count = 0;
 
    // Patch region (right side of image = world left where patch is)
    for (int j = 24; j < 40; j++) {
        for (int i = 40; i < 56; i++) {
            patch_sum += pixel_data[j * 64 + i];
            patch_count++;
        }
    }
 
    // Triangle region (left side of image = world right where triangle is)
    for (int j = 24; j < 40; j++) {
        for (int i = 8; i < 24; i++) {
            tri_sum += pixel_data[j * 64 + i];
            tri_count++;
        }
    }
 
    float patch_avg = patch_sum / float(patch_count);
    float tri_avg = tri_sum / float(tri_count);
 
    // Both regions must have non-zero average radiance (lit surfaces)
    DOCTEST_CHECK_MESSAGE(patch_avg > 0.0f,
                          "Patch region average radiance should be > 0, got " << patch_avg);
    DOCTEST_CHECK_MESSAGE(tri_avg > 0.0f,
                          "Triangle region average radiance should be > 0, got " << tri_avg);
 
    // Triangle and patch averages should be within the same order of magnitude
    // (both have the same reflectivity and similar illumination geometry)
    if (patch_avg > 0.0f && tri_avg > 0.0f) {
        float ratio = tri_avg / patch_avg;
        DOCTEST_CHECK_MESSAGE(ratio > 0.1f,
                              "Triangle/patch radiance ratio too low: " << ratio
                              << " (tri_avg=" << tri_avg << ", patch_avg=" << patch_avg << ")");
        DOCTEST_CHECK_MESSAGE(ratio < 10.0f,
                              "Triangle/patch radiance ratio too high: " << ratio
                              << " (tri_avg=" << tri_avg << ", patch_avg=" << patch_avg << ")");
    }
}
 
GPU_TEST_CASE("RadiationModel - Multi-tile camera rendering consistency") {
    // Regression test: when camera resolution × antialiasing samples exceeds maxRays
    // (~1 billion), the render is split into multiple tiles. A bug in __raygen__camera()
    // used camera_resolution (tile dimensions) instead of camera_resolution_full (full
    // image dimensions) when computing ray directions, causing pixels in tiles 2+ to
    // point in the wrong direction and produce black output.
    //
    // The iPhone12ProMAX camera at 3024×4032 with 100 AA samples produces ~1.22 billion
    // rays, triggering 2-tile rendering.
 
    Context context;
    RadiationModel radiation = RadiationModelTestHelper::createWithSharedDevice(&context);
    radiation.disableMessages();
 
    // Minimal scene: single ground patch filling the camera view
    std::vector<uint> ground = context.addTile(make_vec3(0, 0, 0), make_vec2(10.0f, 10.0f),
                                               make_SphericalCoord(0, 0), make_int2(1, 1));
    context.setPrimitiveData(ground, "reflectivity_red", 0.3f);
    context.setPrimitiveData(ground, "reflectivity_green", 0.3f);
    context.setPrimitiveData(ground, "reflectivity_blue", 0.3f);
    context.setPrimitiveData(ground, "twosided_flag", uint(0));
 
    // Sun source
    SphericalCoord sun_dir = make_SphericalCoord(deg2rad(45), 0);
    uint src = radiation.addSunSphereRadiationSource(sun_dir);
    radiation.setSourceSpectrum(src, "solar_spectrum_ASTMG173");
 
    // RGB bands with scattering (matching tutorial 12 setup)
    radiation.addRadiationBand("red");
    radiation.disableEmission("red");
    radiation.setScatteringDepth("red", 1);
    radiation.setDiffuseRadiationExtinctionCoeff("red", 0.2f, sun_dir);
    radiation.copyRadiationBand("red", "green");
    radiation.copyRadiationBand("red", "blue");
 
    radiation.setDiffuseSpectrum("solar_spectrum_ASTMG173");
    radiation.setDiffuseSpectrumIntegral(100.f);
 
    // iPhone12ProMAX: 3024×4032, 100 AA → ~1.22B rays → triggers 2-tile rendering
    vec3 cam_pos = make_vec3(0, -2, 3);
    vec3 cam_lookat = make_vec3(0, 0, 0);
 
    {
        capture_cout capture;
        radiation.addRadiationCameraFromLibrary("iphone_cam", "iPhone12ProMAX",
                                                cam_pos, cam_lookat, 100);
    }
 
    radiation.updateGeometry();
 
    {
        capture_cout capture;
        radiation.runBand({"red", "green", "blue"});
    }
 
    // Get camera resolution (should be 3024×4032)
    CameraProperties props = radiation.getCameraParameters("iphone_cam");
    int W = props.camera_resolution.x;
    int H = props.camera_resolution.y;
    DOCTEST_REQUIRE(W == 3024);
    DOCTEST_REQUIRE(H == 4032);
 
    auto pixel_red = radiation.getCameraPixelData("iphone_cam", "red");
    DOCTEST_REQUIRE(pixel_red.size() == (size_t)W * H);
 
    // With maxRays = 1B and 100 AA at 3024×4032:
    //   rays_per_row = 100 × 3024 = 302,400
    //   max_rows_per_tile = floor(1B / 302,400) = 3550
    //   Tile 1: rows 0..3549 (3024×3550)
    //   Tile 2: rows 3550..4031 (3024×482)
    // With the bug, ALL pixels in tile 2 (rows 3550-4031) would be black.
 
    // Sample pixels from tile 1 (top region, rows 500-600)
    float tile1_sum = 0;
    int tile1_count = 0;
    for (int j = 500; j < 600; j++) {
        for (int i = W / 4; i < 3 * W / 4; i += 10) { // sparse sampling for speed
            tile1_sum += pixel_red[j * W + i];
            tile1_count++;
        }
    }
 
    // Sample pixels from tile 2 (bottom region, rows 3600-3700)
    float tile2_sum = 0;
    int tile2_count = 0;
    for (int j = 3600; j < 3700; j++) {
        for (int i = W / 4; i < 3 * W / 4; i += 10) { // sparse sampling for speed
            tile2_sum += pixel_red[j * W + i];
            tile2_count++;
        }
    }
 
    float tile1_avg = tile1_sum / float(tile1_count);
    float tile2_avg = tile2_sum / float(tile2_count);
 
    // Both tile regions should have non-zero radiance (looking at a lit ground patch)
    DOCTEST_CHECK_MESSAGE(tile1_avg > 0.0f,
                          "Tile 1 (rows 500-600) average radiance should be > 0, got " << tile1_avg);
    DOCTEST_CHECK_MESSAGE(tile2_avg > 0.0f,
                          "Tile 2 (rows 3600-3700) average radiance should be > 0, got " << tile2_avg);
 
    // The two regions should have similar radiance (same ground patch, similar viewing angle)
    if (tile1_avg > 0.0f && tile2_avg > 0.0f) {
        float ratio = tile2_avg / tile1_avg;
        DOCTEST_CHECK_MESSAGE(ratio > 0.1f,
                              "Tile 2/tile 1 radiance ratio too low: " << ratio
                              << " (tile1=" << tile1_avg << ", tile2=" << tile2_avg << ")");
        DOCTEST_CHECK_MESSAGE(ratio < 10.0f,
                              "Tile 2/tile 1 radiance ratio too high: " << ratio
                              << " (tile1=" << tile1_avg << ", tile2=" << tile2_avg << ")");
    }
}
 
// ============================================================================
// SIF V&V Tier 1 (v2): Fluspect-B C++ port vs MATLAB reference
// ============================================================================
//
// Loads reference Mf/Mb kernels generated by SCOPE v2.0's fluspect_B_CX.m
// (via plugins/radiation/spectral_data/export_fluspect_optipar.m) for the
// SCOPE default leaf biochemistry, then runs the C++ FluspectB port with the
// same inputs and asserts element-wise agreement to within 1e-4 (relative).
//
// This is a pure-CPU test of the kernel computation — no ray tracing, no GPU.
 
namespace {
 
    struct FluspectReferenceConfig {
        float Cab, Cca, Cw, Cdm, Cs, Cant, Cp, Cbc, N, fqe, V2Z;
        float wle_step, wlf_step;
    };
 
    FluspectReferenceConfig load_fluspect_reference_config() {
        FluspectReferenceConfig c{};
        const std::filesystem::path p = helios::resolveFilePath("plugins/radiation/tests/reference/fluspect_reference_config.csv");
        std::ifstream f(p);
        DOCTEST_REQUIRE_MESSAGE(f.good(), "Failed to open " << p.string());
        std::string line;
        while (std::getline(f, line)) {
            if (line.empty() || line[0] == '#' || line.substr(0, 3) == "key") continue;
            const auto comma = line.find(',');
            if (comma == std::string::npos) continue;
            const std::string key = line.substr(0, comma);
            const float val = std::stof(line.substr(comma + 1));
            if      (key == "Cab")      c.Cab = val;
            else if (key == "Cca")      c.Cca = val;
            else if (key == "Cw")       c.Cw = val;
            else if (key == "Cdm")      c.Cdm = val;
            else if (key == "Cs")       c.Cs = val;
            else if (key == "Cant")     c.Cant = val;
            else if (key == "Cp")       c.Cp = val;
            else if (key == "Cbc")      c.Cbc = val;
            else if (key == "N")        c.N = val;
            else if (key == "fqe")      c.fqe = val;
            else if (key == "V2Z")      c.V2Z = val;
            else if (key == "wle_step") c.wle_step = val;
            else if (key == "wlf_step") c.wlf_step = val;
        }
        return c;
    }
 
    // Load a 2D matrix CSV emitted by export_fluspect_optipar.m. Format:
    //   # comment lines
    //   ,<wle_0>,<wle_1>,...
    //   <wlf_0>,<m_00>,<m_01>,...
    //   <wlf_1>,<m_10>,<m_11>,...
    // Returns the matrix as matrix[i_wlf][j_wle] and fills out the wle/wlf grids.
    std::vector<std::vector<double>> load_matrix_csv(const std::filesystem::path &p,
                                                     std::vector<float> &wle_out,
                                                     std::vector<float> &wlf_out) {
        std::ifstream f(p);
        DOCTEST_REQUIRE_MESSAGE(f.good(), "Failed to open " << p.string());
        std::string line;
        wle_out.clear();
        wlf_out.clear();
        std::vector<std::vector<double>> M;
 
        // Skip comment lines
        while (std::getline(f, line)) {
            if (line.empty() || line[0] == '#') continue;
            break;  // this line is the header (wle grid)
        }
        // Parse header: ",400,405,..."
        std::stringstream hs(line);
        std::string cell;
        bool first = true;
        while (std::getline(hs, cell, ',')) {
            if (first) { first = false; continue; }  // skip the blank first cell
            wle_out.push_back(std::stof(cell));
        }
        // Parse data rows
        while (std::getline(f, line)) {
            if (line.empty() || line[0] == '#') continue;
            std::stringstream ds(line);
            std::vector<double> row;
            bool is_first = true;
            while (std::getline(ds, cell, ',')) {
                if (is_first) {
                    wlf_out.push_back(std::stof(cell));
                    is_first = false;
                    continue;
                }
                row.push_back(std::stod(cell));
            }
            if (!row.empty()) M.push_back(std::move(row));
        }
        return M;
    }
 
} // namespace
 
DOCTEST_TEST_CASE("SIF V&V Tier 1 (v2): Fluspect-B C++ port matches MATLAB reference") {
    // 1. Load Optipar coefficients from the shipped XML.
    FluspectOptipar optipar;
    const std::filesystem::path optipar_xml = helios::resolveFilePath("plugins/radiation/spectral_data/fluspect_B_optipar.xml");
    loadFluspectOptipar(optipar_xml.string(), optipar);
    DOCTEST_CHECK(optipar.wavelengths_nm.size() > 1000);  // sanity
 
    // 2. Load reference Mf/Mb and biochemistry/grid metadata.
    const FluspectReferenceConfig cfg = load_fluspect_reference_config();
    std::vector<float> ref_wle, ref_wlf;
    const auto Mf_ref = load_matrix_csv(helios::resolveFilePath("plugins/radiation/tests/reference/fluspect_reference_Mf.csv"), ref_wle, ref_wlf);
    std::vector<float> ref_wle2, ref_wlf2;
    const auto Mb_ref = load_matrix_csv(helios::resolveFilePath("plugins/radiation/tests/reference/fluspect_reference_Mb.csv"), ref_wle2, ref_wlf2);
    DOCTEST_REQUIRE(ref_wle == ref_wle2);
    DOCTEST_REQUIRE(ref_wlf == ref_wlf2);
    DOCTEST_REQUIRE(Mf_ref.size() == ref_wlf.size());
 
    // 3. Run the C++ port with identical inputs.
    FluspectBiochemistry biochem;
    biochem.Cab  = cfg.Cab;
    biochem.Cca  = cfg.Cca;
    biochem.Cw   = cfg.Cw;
    biochem.Cdm  = cfg.Cdm;
    biochem.Cs   = cfg.Cs;
    biochem.Cant = cfg.Cant;
    biochem.Cp   = cfg.Cp;
    biochem.Cbc  = cfg.Cbc;
    biochem.N    = cfg.N;
    biochem.fqe  = cfg.fqe;
    biochem.V2Z  = cfg.V2Z;
    const FluspectKernel out = computeFluspectKernel(biochem, optipar, cfg.wle_step);
 
    // 4. Grid agreement.
    DOCTEST_REQUIRE(out.wle.size() == ref_wle.size());
    DOCTEST_REQUIRE(out.wlf.size() == ref_wlf.size());
    for (size_t j = 0; j < out.wle.size(); ++j) {
        DOCTEST_CHECK(out.wle[j] == doctest::Approx(ref_wle[j]).epsilon(1e-5));
    }
    for (size_t i = 0; i < out.wlf.size(); ++i) {
        DOCTEST_CHECK(out.wlf[i] == doctest::Approx(ref_wlf[i]).epsilon(1e-5));
    }
 
    // 5. Element-wise agreement on Mf and Mb.
    // Tolerance rationale: MATLAB uses double throughout; C++ port uses double
    // internally and stores float outputs. Monte-Carlo-free routine, no stochastic
    // noise. Relative tolerance 1e-4 on magnitudes above 1e-10 (small-value floor
    // avoids divide-by-zero on wavelengths where emission is essentially zero).
    size_t n_total = 0, n_checked_Mf = 0, n_checked_Mb = 0;
    double max_rel_err_Mf = 0.0, max_rel_err_Mb = 0.0;
    for (size_t i = 0; i < out.wlf.size(); ++i) {
        for (size_t j = 0; j < out.wle.size(); ++j) {
            const double cf = out.Mf[i][j];
            const double cb = out.Mb[i][j];
            const double rf = Mf_ref[i][j];
            const double rb = Mb_ref[i][j];
            if (std::abs(rf) > 1e-10) {
                max_rel_err_Mf = std::max(max_rel_err_Mf, std::abs(cf - rf) / std::abs(rf));
                ++n_checked_Mf;
            }
            if (std::abs(rb) > 1e-10) {
                max_rel_err_Mb = std::max(max_rel_err_Mb, std::abs(cb - rb) / std::abs(rb));
                ++n_checked_Mb;
            }
            ++n_total;
        }
    }
    DOCTEST_MESSAGE("Fluspect Mf max relative error: " << max_rel_err_Mf);
    DOCTEST_MESSAGE("Fluspect Mb max relative error: " << max_rel_err_Mb);
    DOCTEST_MESSAGE("Elements compared: Mf=" << n_checked_Mf << "/" << n_total
                     << " Mb=" << n_checked_Mb << "/" << n_total
                     << " (rest below 1e-10 magnitude floor — anti-Stokes wavelengths)");
    // Sanity: at least 90% of kernel elements should be above the floor for this
    // biochemistry (otherwise the kernel is degenerate or the test data wrong).
    DOCTEST_CHECK(n_checked_Mf > 0.9 * n_total);
    DOCTEST_CHECK(n_checked_Mb > 0.9 * n_total);
    DOCTEST_CHECK(max_rel_err_Mf < 1e-4);
    DOCTEST_CHECK(max_rel_err_Mb < 1e-4);
}
 
// ============================================================================
// SIF test helpers
// ============================================================================
//
// The SIF v2 design authors leaf biochemistry as a named global-data vector and
// stamps the label as "fluspect_spectrum" primitive data. Production code uses
// LeafOptics::run() to do this; the radiation plugin's selfTest avoids pulling
// the LeafOptics plugin dependency by writing the global data + primitive data
// directly. See FluspectB.h / LeafOptics.cpp for the canonical field order.
 
namespace {
    // Write a fluspect_biochem_<label> vector<float> to global data and stamp
    // "fluspect_spectrum" = label on each UUID. 11-field order matches LeafOptics::run().
    void sif_stamp_biochem(Context &ctx, const std::vector<uint> &UUIDs, const std::string &label,
                           float Cab = 40.f, float Cca = 10.f, float Cw = 0.009f, float Cdm = 0.012f,
                           float Cs = 0.f, float Cant = 1.f, float Cp = 0.f, float Cbc = 0.f,
                           float N = 1.5f, float V2Z = 0.f, float fqe = 1.f) {
        const std::string full_label = "fluspect_biochem_" + label;
        std::vector<float> biochem = {Cab, Cca, Cw, Cdm, Cs, Cant, Cp, Cbc, N, V2Z, fqe};
        ctx.setGlobalData(full_label.c_str(), biochem);
        ctx.setPrimitiveData(UUIDs, "fluspect_spectrum", full_label);
    }
} // namespace
 
// ============================================================================
// SIF V&V Tier 2 (v2): end-to-end pipeline with solar source + SIF camera
// ============================================================================
//
// Full v2 pipeline exercise. Scene: one leaf at origin, large absorbing sensor
// directly overhead, collimated sun with ASTM G173 spectrum. addSIFCamera
// registers the SIF bands as SIF-emitting and auto-creates an excitation-band
// set covering 400-750 nm. runBand({"SIF_red", "SIF_farred"}) triggers:
//   1. Excitation bands ray-traced (picking up solar flux).
//   2. Per-leaf APAR captured into apar_buffer.
//   3. Fluspect-B kernel computed from Cab=40, N=1.5 etc.
//   4. Per-band source emission written to sif_emission_buffer.
//   5. SIF_red and SIF_farred ray-traced with Fluspect-derived emission.
// The test asserts the sensor above the leaf receives nonzero flux in both
// bands, the fluorescence_yield primitive data is in the [0, 0.1] range, and
// the camera pixel data exists for both bands.
 
GPU_TEST_CASE("SIF V&V Tier 2 (v2): full pipeline with solar source + SIF camera") {
    Context ctx;
 
    // Single leaf, one-sided, at origin.
    uint leaf = ctx.addPatch(make_vec3(0, 0, 0), make_vec2(1, 1));
    ctx.setPrimitiveData(leaf, "twosided_flag", uint(0));
    sif_stamp_biochem(ctx, {leaf}, "t2");
    ctx.setPrimitiveData(leaf, "electron_transport_ratio", 0.5f);
    ctx.setPrimitiveData(leaf, "temperature", 298.15f);
 
    // Absorbing sensor above the leaf (catches upward emission). Sized to capture
    // nearly all upward hemisphere emission from the small leaf below without
    // significantly shadowing the oblique solar source.
    const float sensor_side = 1.f;
    uint sensor = ctx.addPatch(make_vec3(0, 0, 0.2f), make_vec2(sensor_side, sensor_side),
                                make_SphericalCoord(M_PI, 0));
    ctx.setPrimitiveData(sensor, "twosided_flag", uint(0));
 
    RadiationModel radiation = RadiationModelTestHelper::createWithSharedDevice(&ctx);
    radiation.disableMessages();
 
    // SIF emission bands (image channels for the camera).
    radiation.addRadiationBand("SIF_red", 680.f, 700.f);
    radiation.addRadiationBand("SIF_farred", 730.f, 760.f);
    radiation.setDirectRayCount("SIF_red", 500);
    radiation.setDirectRayCount("SIF_farred", 500);
    radiation.setDiffuseRayCount("SIF_red", 500);
    radiation.setDiffuseRayCount("SIF_farred", 500);
    radiation.setScatteringDepth("SIF_red", 1);     // at least one bounce so camera rays pick up emission
    radiation.setScatteringDepth("SIF_farred", 1);
 
    // Oblique collimated solar source (45 deg from vertical) with ASTM G173
    // solar spectrum. The oblique incidence angle ensures light reaches the leaf
    // without being fully blocked by the sensor sitting directly above it.
    // Flux per excitation band is integrated from the spectrum via integrateSpectrum().
    uint sun = radiation.addCollimatedRadiationSource(make_vec3(1.f, 0.f, 1.f));
    radiation.setSourceSpectrum(sun, "solar_spectrum_direct_ASTMG173");
 
    // SIF camera positioned at side angle so its rays reach the leaf without being
    // blocked by the sensor patch above. Camera at (2, 0, 0.3) looking toward (0, 0, 0).
    SIFCameraProperties cam_props;
    cam_props.camera_resolution = make_int2(16, 16);
    cam_props.HFOV = 30.f;
    cam_props.excitation_bin_width_nm = 50.f;   // 7 bins; coarse for test speed
    radiation.addSIFCamera("sif_cam", {"SIF_red", "SIF_farred"},
                            make_vec3(2.f, 0.f, 0.3f), make_vec3(0, 0, 0), cam_props, 1);
 
    DOCTEST_CHECK(radiation.isSIFCamera("sif_cam"));
    DOCTEST_CHECK(!radiation.isSIFCamera("nonexistent"));
 
    radiation.updateGeometry();
    const std::vector<std::string> sif_bands = {"SIF_red", "SIF_farred"};
    radiation.runBand(sif_bands);
 
    // Leaf-level Phi_F diagnostic.
    DOCTEST_REQUIRE(ctx.doesPrimitiveDataExist(leaf, "fluorescence_yield"));
    float phi_f = -1.f;
    ctx.getPrimitiveData(leaf, "fluorescence_yield", phi_f);
    DOCTEST_CHECK(phi_f > 0.f);
    DOCTEST_CHECK(phi_f < 0.1f);
    DOCTEST_MESSAGE("Leaf Phi_F = " << phi_f);
 
    // Sensor flux: nonzero in both bands, far-red dominates red source emission
    // (Fluspect-B source ratio with Cab=40 is ~1.15 red:farred, but red reabsorbs
    // inside the leaf more than farred — so post-leaf emission is farred-dominated).
    float flux_red = 0.f, flux_farred = 0.f;
    ctx.getPrimitiveData(sensor, "radiation_flux_SIF_red", flux_red);
    ctx.getPrimitiveData(sensor, "radiation_flux_SIF_farred", flux_farred);
    DOCTEST_MESSAGE("Sensor F_red=" << flux_red << " F_farred=" << flux_farred
                     << " ratio=" << (flux_red / std::max(flux_farred, 1e-12f)));
    DOCTEST_CHECK(std::isfinite(flux_red));
    DOCTEST_CHECK(std::isfinite(flux_farred));
    DOCTEST_CHECK(flux_red > 0.f);
    DOCTEST_CHECK(flux_farred > 0.f);
 
    // Camera pixel data per band: all pixels finite and non-negative, with at least one
    // pixel per band receiving nonzero flux (catches a zeroed-out camera pipeline).
    auto pixels_red = radiation.getCameraPixelData("sif_cam", "SIF_red");
    auto pixels_farred = radiation.getCameraPixelData("sif_cam", "SIF_farred");
    DOCTEST_CHECK(pixels_red.size() == 16 * 16);
    DOCTEST_CHECK(pixels_farred.size() == 16 * 16);
    float max_pixel_red = 0.f, max_pixel_farred = 0.f;
    for (float v : pixels_red) {
        DOCTEST_CHECK(std::isfinite(v));
        DOCTEST_CHECK(v >= 0.f);
        if (v > max_pixel_red) max_pixel_red = v;
    }
    for (float v : pixels_farred) {
        DOCTEST_CHECK(std::isfinite(v));
        DOCTEST_CHECK(v >= 0.f);
        if (v > max_pixel_farred) max_pixel_farred = v;
    }
    DOCTEST_CHECK(max_pixel_red > 0.f);
    DOCTEST_CHECK(max_pixel_farred > 0.f);
}
 
// ============================================================================
// SIF V&V Tier 3 (v2): multi-camera pipeline with distinct excitation resolutions
// ============================================================================
//
// Verifies the full multi-camera, multi-excitation-resolution pipeline actually
// produces correct per-band emission and nonzero sensor flux — not just band
// registration. Two SIF cameras at different excitation bin widths are bound
// to disjoint emission bands (because each emission band must have a single
// authoritative bin width, enforced by addSIFCamera). The test asserts that:
//
//   (a) Cameras with the same bin width share an internal excitation set.
//   (b) Cameras with different bin widths each get their own set.
//   (c) addSIFCamera errors cleanly when a band is double-bound to mismatched
//       bin widths.
//   (d) The full pipeline runs end-to-end with two distinct bin widths and
//       produces nonzero sensor flux for each emission band.
//   (e) isSIFCamera correctly distinguishes SIF cameras from regular ones.
 
GPU_TEST_CASE("SIF V&V Tier 3 (v2): multi-camera pipeline with distinct excitation resolutions") {
    Context ctx;
 
    // Emitting leaf at origin with full Fluspect-B biochemistry and photosynthesis state.
    uint leaf = ctx.addPatch(make_vec3(0, 0, 0), make_vec2(1, 1));
    ctx.setPrimitiveData(leaf, "twosided_flag", uint(0));
    sif_stamp_biochem(ctx, {leaf}, "t3");
    ctx.setPrimitiveData(leaf, "electron_transport_ratio", 0.5f);
    ctx.setPrimitiveData(leaf, "temperature", 298.15f);
 
    // Small absorbing sensor directly above the leaf for upward-flux capture.
    const float sensor_side = 1.f;
    uint sensor = ctx.addPatch(make_vec3(0, 0, 0.2f), make_vec2(sensor_side, sensor_side),
                                make_SphericalCoord(M_PI, 0));
    ctx.setPrimitiveData(sensor, "twosided_flag", uint(0));
 
    RadiationModel radiation = RadiationModelTestHelper::createWithSharedDevice(&ctx);
    radiation.disableMessages();
 
    // Two disjoint SIF emission bands — one for each camera's resolution.
    radiation.addRadiationBand("SIF_red_fine", 680.f, 700.f);   // 10 nm bin width camera
    radiation.addRadiationBand("SIF_red_coarse", 680.f, 700.f); // 25 nm bin width camera
    radiation.addRadiationBand("SIF_farred_fine", 730.f, 760.f);
    for (const auto &b : {"SIF_red_fine", "SIF_red_coarse", "SIF_farred_fine"}) {
        radiation.setDirectRayCount(b, 500);
        radiation.setDiffuseRayCount(b, 500);
        radiation.setScatteringDepth(b, 0);
    }
 
    // Oblique solar source with ASTM G173 spectrum — drives nonzero excitation APAR.
    uint sun = radiation.addCollimatedRadiationSource(make_vec3(1.f, 0.f, 1.f));
    radiation.setSourceSpectrum(sun, "solar_spectrum_direct_ASTMG173");
 
    SIFCameraProperties cam10;
    cam10.camera_resolution = make_int2(8, 8);
    cam10.HFOV = 20.f;
    cam10.excitation_bin_width_nm = 10.f;
 
    SIFCameraProperties cam10_second = cam10;  // same bin width → dedup path
 
    SIFCameraProperties cam25;
    cam25.camera_resolution = make_int2(8, 8);
    cam25.HFOV = 20.f;
    cam25.excitation_bin_width_nm = 25.f;
 
    // cam_a: 10 nm bin width, flags SIF_red_fine + SIF_farred_fine
    radiation.addSIFCamera("cam_a", {"SIF_red_fine", "SIF_farred_fine"},
                            make_vec3(0, 0, 1), make_vec3(0, 0, 0), cam10, 1);
    // cam_b: also 10 nm → reuses the same excitation set; flags nothing new.
    // Use an already-flagged band (dedup of sif_emission_bands is inherent since it's a set).
    radiation.addSIFCamera("cam_b", {"SIF_farred_fine"},
                            make_vec3(0, 0.5f, 1), make_vec3(0, 0, 0), cam10_second, 1);
    // cam_c: 25 nm bin width → gets its own excitation set; uses a disjoint emission band.
    radiation.addSIFCamera("cam_c", {"SIF_red_coarse"},
                            make_vec3(0.5f, 0, 1), make_vec3(0, 0, 0), cam25, 1);
 
    // (a) + (e): isSIFCamera introspection.
    DOCTEST_CHECK(radiation.isSIFCamera("cam_a"));
    DOCTEST_CHECK(radiation.isSIFCamera("cam_b"));
    DOCTEST_CHECK(radiation.isSIFCamera("cam_c"));
    DOCTEST_CHECK(!radiation.isSIFCamera("nonexistent"));
 
    // Regular (non-SIF) camera on the same bands — should NOT be flagged as SIF.
    CameraProperties regular_props;
    regular_props.camera_resolution = make_int2(8, 8);
    regular_props.HFOV = 20.f;
    radiation.addRadiationCamera("regular_cam", {"SIF_red_fine"},
                                  make_vec3(1, 1, 1), make_vec3(0, 0, 0), regular_props, 1);
    DOCTEST_CHECK(!radiation.isSIFCamera("regular_cam"));
 
    // (b): Both the 10 nm and 25 nm internal band sets exist. If dedup failed, duplicate
    // addRadiationBand calls would have been caught by the doesBandExist guard, so this
    // only verifies creation, not dedup. Dedup is inherent from the std::map keyed on
    // bin width.
    DOCTEST_CHECK(radiation.doesBandExist("_SIF_exc_10_400_410"));
    DOCTEST_CHECK(radiation.doesBandExist("_SIF_exc_10_740_750"));
    DOCTEST_CHECK(radiation.doesBandExist("_SIF_exc_25_400_425"));
    DOCTEST_CHECK(radiation.doesBandExist("_SIF_exc_25_725_750"));
 
    // (c): binding the same emission band to different bin widths must error.
    {
        capture_cerr cap;
        DOCTEST_CHECK_THROWS_AS(
            radiation.addSIFCamera("cam_conflict", {"SIF_red_fine"},
                                    make_vec3(2, 0, 1), make_vec3(0, 0, 0), cam25, 1),
            std::runtime_error);
    }
 
    // (d): full pipeline with two distinct excitation sets. Both emission bands should
    // produce nonzero sensor flux. Critical check: if the multi-set iteration bug were
    // still present, cam_c's band SIF_red_coarse would silently receive zero flux.
    radiation.updateGeometry();
    const std::vector<std::string> sif_bands_list = {"SIF_red_fine", "SIF_red_coarse", "SIF_farred_fine"};
    radiation.runBand(sif_bands_list);
 
    float flux_red_fine = 0.f, flux_red_coarse = 0.f, flux_farred_fine = 0.f;
    ctx.getPrimitiveData(sensor, "radiation_flux_SIF_red_fine", flux_red_fine);
    ctx.getPrimitiveData(sensor, "radiation_flux_SIF_red_coarse", flux_red_coarse);
    ctx.getPrimitiveData(sensor, "radiation_flux_SIF_farred_fine", flux_farred_fine);
    DOCTEST_MESSAGE("Sensor F_red_fine=" << flux_red_fine
                     << " F_red_coarse=" << flux_red_coarse
                     << " F_farred_fine=" << flux_farred_fine);
    DOCTEST_CHECK(flux_red_fine > 0.f);
    DOCTEST_CHECK(flux_red_coarse > 0.f);
    DOCTEST_CHECK(flux_farred_fine > 0.f);
 
    // Both bin widths integrate APAR over the same excitation range (400-750 nm), but the
    // Fluspect-B kernel is sampled at fewer discrete wle points for coarser bins. For a
    // kernel that varies across wle, coarser sampling carries a quantization bias — so
    // fine and coarse flux values are expected to differ. We assert rough agreement
    // (within a factor of 3) as a sanity check that both pipelines are producing
    // physically meaningful nonzero emission, not a convergence claim.
    DOCTEST_CHECK(flux_red_coarse > 0.33f * flux_red_fine);
    DOCTEST_CHECK(flux_red_coarse < 3.f * flux_red_fine);
}
 
// ============================================================================
// SIF V&V: actionable warnings for common setup mistakes
// ============================================================================
//
// Verifies that Helios emits specific, actionable warnings for common SIF
// misconfigurations — silent zero output is far worse than a warning because the
// user has no clue why their scene is blank. Each case tests one pitfall in
// isolation using capture_cerr to verify the warning text.
 
GPU_TEST_CASE("SIF warnings: no source spectrum set") {
    Context ctx;
    uint leaf = ctx.addPatch(make_vec3(0, 0, 0), make_vec2(1, 1));
    sif_stamp_biochem(ctx, {leaf}, "warn_no_spec");
    ctx.setPrimitiveData(leaf, "electron_transport_ratio", 0.5f);
    RadiationModel radiation = RadiationModelTestHelper::createWithSharedDevice(&ctx);
    radiation.addRadiationBand("SIF_red", 680.f, 700.f);
 
    // Add a source but DO NOT set its spectrum. Expected: addSIFCamera warns.
    uint sun = radiation.addCollimatedRadiationSource(make_vec3(0, 0, 1));
    (void) sun;
 
    SIFCameraProperties cam_props;
    cam_props.camera_resolution = make_int2(4, 4);
    cam_props.HFOV = 20.f;
    cam_props.excitation_bin_width_nm = 50.f;
 
    std::string captured;
    {
        capture_cerr cap;
        radiation.addSIFCamera("warn_cam_no_spectrum", {"SIF_red"},
                                make_vec3(0, 0, 1), make_vec3(0, 0, 0), cam_props, 1);
        captured = cap.get_captured_output();
    }
    DOCTEST_CHECK(captured.find("no radiation source has a spectrum set") != std::string::npos);
}
 
GPU_TEST_CASE("SIF warnings: no fluspect_spectrum on any primitive") {
    Context ctx;
    // Primitive with electron_transport_ratio but no fluspect_spectrum — triggers
    // the "biochemistry missing" branch in addSIFCamera's coverage scan.
    uint leaf = ctx.addPatch(make_vec3(0, 0, 0), make_vec2(1, 1));
    ctx.setPrimitiveData(leaf, "electron_transport_ratio", 0.5f);
    RadiationModel radiation = RadiationModelTestHelper::createWithSharedDevice(&ctx);
    radiation.addRadiationBand("SIF_red", 680.f, 700.f);
    uint sun = radiation.addCollimatedRadiationSource(make_vec3(0, 0, 1));
    radiation.setSourceSpectrum(sun, "solar_spectrum_direct_ASTMG173");
 
    SIFCameraProperties cam_props;
    cam_props.camera_resolution = make_int2(4, 4);
    cam_props.HFOV = 20.f;
    cam_props.excitation_bin_width_nm = 50.f;
 
    std::string captured;
    {
        capture_cerr cap;
        radiation.addSIFCamera("warn_no_biochem", {"SIF_red"},
                                make_vec3(0, 0, 1), make_vec3(0, 0, 0), cam_props, 1);
        captured = cap.get_captured_output();
    }
    DOCTEST_CHECK(captured.find("fluspect_spectrum") != std::string::npos);
}
 
GPU_TEST_CASE("SIF warnings: leaves have biochemistry but lack electron_transport_ratio at runtime") {
    // The electron_transport_ratio check happens at runBand() time (inside
    // computeSIFEmission), not at addSIFCamera() setup time — because photosynthesis
    // typically runs between camera setup and radiation dispatch. This test verifies
    // the runtime warning fires and that no setup-time warning fires about missing etr.
    Context ctx;
    uint leaf = ctx.addPatch(make_vec3(0, 0, 0), make_vec2(1, 1));
    sif_stamp_biochem(ctx, {leaf}, "warn_no_etr");
    // No electron_transport_ratio is set on the leaf, ever.
 
    RadiationModel radiation = RadiationModelTestHelper::createWithSharedDevice(&ctx);
    radiation.addRadiationBand("SIF_red", 680.f, 700.f);
    radiation.setScatteringDepth("SIF_red", 1);
    uint sun = radiation.addCollimatedRadiationSource(make_vec3(1.f, 0.f, 1.f));
    radiation.setSourceSpectrum(sun, "solar_spectrum_direct_ASTMG173");
 
    SIFCameraProperties cam_props;
    cam_props.camera_resolution = make_int2(4, 4);
    cam_props.HFOV = 20.f;
    cam_props.excitation_bin_width_nm = 50.f;
 
    // Setup-time: no warning about electron_transport_ratio should fire, because the
    // absence is expected before photosynthesis has been run.
    std::string setup_captured;
    {
        capture_cerr cap;
        radiation.addSIFCamera("warn_no_etr", {"SIF_red"},
                                make_vec3(0, 0, 1), make_vec3(0, 0, 0), cam_props, 1);
        setup_captured = cap.get_captured_output();
    }
    DOCTEST_CHECK(setup_captured.find("electron_transport_ratio") == std::string::npos);
 
    // Runtime: computeSIFEmission warns about missing electron_transport_ratio.
    std::string runtime_captured;
    {
        capture_cerr cap;
        radiation.updateGeometry();
        const std::vector<std::string> sif_bands = {"SIF_red"};
        radiation.runBand(sif_bands);
        runtime_captured = cap.get_captured_output();
    }
    DOCTEST_CHECK(runtime_captured.find("electron_transport_ratio") != std::string::npos);
}
 
GPU_TEST_CASE("SIF warnings: camera bound to band with scattering depth 0") {
    Context ctx;
    ctx.addPatch(make_vec3(0, 0, 0), make_vec2(1, 1));
 
    RadiationModel radiation = RadiationModelTestHelper::createWithSharedDevice(&ctx);
    // Regular (non-SIF) band with scatteringDepth = 0 (the default).
    radiation.addRadiationBand("PAR", 400.f, 700.f);
    DOCTEST_REQUIRE(radiation.doesBandExist("PAR"));
 
    CameraProperties cam_props;
    cam_props.camera_resolution = make_int2(4, 4);
    cam_props.HFOV = 20.f;
 
    std::string captured;
    {
        capture_cerr cap;
        radiation.addRadiationCamera("warn_scatter0", {"PAR"},
                                      make_vec3(0, 0, 1), make_vec3(0, 0, 0), cam_props, 1);
        captured = cap.get_captured_output();
    }
    DOCTEST_CHECK(captured.find("scatteringDepth == 0") != std::string::npos);
    DOCTEST_CHECK(captured.find("Camera pixels for this band will be zero") != std::string::npos);
}
 
// ============================================================================
// SIF: leaf rho/tau from LeafOptics don't satisfy ε+ρ+τ=1 — conservation check
// must not fire for SIF bands because the Fluspect-B kernel, not ε·σ·T⁴, is the
// emission source. Regression test for the crash reported in projects/SIF_camera.
// ============================================================================
GPU_TEST_CASE("SIF: non-blackbody leaf optics (rho+tau<1) should not trip ε+ρ+τ=1 check") {
    Context ctx;
    uint leaf = ctx.addPatch(make_vec3(0, 0, 0), make_vec2(1, 1));
    ctx.setPrimitiveData(leaf, "twosided_flag", uint(0));
    sif_stamp_biochem(ctx, {leaf}, "conserv_test");
    ctx.setPrimitiveData(leaf, "electron_transport_ratio", 0.5f);
    ctx.setPrimitiveData(leaf, "temperature", 298.15f);
 
    // Leaf optics that violate Stefan-Boltzmann ε+ρ+τ=1 with ε=1 (the default):
    // rho=0.4, tau=0.43 (typical PROSPECT values at 740 nm). Pre-fix, these would
    // crash in validateAndCorrectMaterialProperties with the "sum to 1" error.
    ctx.setPrimitiveData(leaf, "reflectivity_SIF_farred",   0.4f);
    ctx.setPrimitiveData(leaf, "transmissivity_SIF_farred", 0.43f);
 
    RadiationModel radiation = RadiationModelTestHelper::createWithSharedDevice(&ctx);
    radiation.disableMessages();
    radiation.addRadiationBand("SIF_farred", 730.f, 760.f);
    radiation.setScatteringDepth("SIF_farred", 2);
 
    uint sun = radiation.addCollimatedRadiationSource(make_vec3(1.f, 0.f, 1.f));
    radiation.setSourceSpectrum(sun, "solar_spectrum_direct_ASTMG173");
 
    SIFCameraProperties cam_props;
    cam_props.camera_resolution = make_int2(4, 4);
    cam_props.HFOV = 20.f;
    cam_props.excitation_bin_width_nm = 50.f;
    radiation.addSIFCamera("cam_cons", {"SIF_farred"}, make_vec3(0, 0, 1), make_vec3(0, 0, 0), cam_props, 1);
 
    radiation.updateGeometry();
    const std::vector<std::string> sif_bands = {"SIF_farred"};
    DOCTEST_CHECK_NOTHROW(radiation.runBand(sif_bands));
}
 
// ============================================================================
// SIF: disabled emission on a SIF band is soft-overridden with a warning
// ============================================================================
GPU_TEST_CASE("SIF: disabled emission on a SIF band is soft-overridden with warning") {
    Context ctx;
    uint leaf = ctx.addPatch(make_vec3(0, 0, 0), make_vec2(1, 1));
    ctx.setPrimitiveData(leaf, "twosided_flag", uint(0));
    sif_stamp_biochem(ctx, {leaf}, "override_test");
    ctx.setPrimitiveData(leaf, "electron_transport_ratio", 0.5f);
    ctx.setPrimitiveData(leaf, "temperature", 298.15f);
 
    RadiationModel radiation = RadiationModelTestHelper::createWithSharedDevice(&ctx);
    // Note: messages ENABLED so we can capture the override warning.
    radiation.addRadiationBand("SIF_farred", 730.f, 760.f);
    radiation.setScatteringDepth("SIF_farred", 1);
 
    uint sun = radiation.addCollimatedRadiationSource(make_vec3(1.f, 0.f, 1.f));
    radiation.setSourceSpectrum(sun, "solar_spectrum_direct_ASTMG173");
 
    SIFCameraProperties cam_props;
    cam_props.camera_resolution = make_int2(4, 4);
    cam_props.HFOV = 20.f;
    cam_props.excitation_bin_width_nm = 50.f;
    radiation.addSIFCamera("cam_override", {"SIF_farred"}, make_vec3(0, 0, 1), make_vec3(0, 0, 0), cam_props, 1);
 
    // User disables emission after registering the SIF camera. Expected: runBand
    // re-enables it for the dispatch and emits the "sif_emission_reenabled" warning.
    radiation.disableEmission("SIF_farred");
 
    std::string captured;
    {
        capture_cerr cap;
        radiation.updateGeometry();
        const std::vector<std::string> sif_bands = {"SIF_farred"};
        radiation.runBand(sif_bands);
        captured = cap.get_captured_output();
    }
    DOCTEST_CHECK(captured.find("has emission disabled") != std::string::npos);
    DOCTEST_CHECK(captured.find("Re-enabling emission") != std::string::npos);
}
 
// ============================================================================
// SIF: excitation_scattering_depth propagates to internal excitation bands,
// and is NOT emitted as per-band warnings (even at depth 0 with leaf rho/tau set).
// ============================================================================
GPU_TEST_CASE("SIF: excitation_scattering_depth propagates to excitation bands and suppresses per-band warning spam") {
    Context ctx;
    uint leaf = ctx.addPatch(make_vec3(0, 0, 0), make_vec2(1, 1));
    sif_stamp_biochem(ctx, {leaf}, "depth_test");
    ctx.setPrimitiveData(leaf, "electron_transport_ratio", 0.5f);
 
    // Give the leaf per-band rho/tau that would normally trigger the warning.
    // We use a coarse bin width so there are only a few excitation bands — the
    // warning-suppression test doesn't need many bands to be convincing.
    RadiationModel radiation_a = RadiationModelTestHelper::createWithSharedDevice(&ctx);
    // Messages left ENABLED so that the per-band warning would fire if unsuppressed.
    radiation_a.addRadiationBand("SIF_red", 680.f, 700.f);
    radiation_a.setScatteringDepth("SIF_red", 1);
    uint sun_a = radiation_a.addCollimatedRadiationSource(make_vec3(1.f, 0.f, 1.f));
    radiation_a.setSourceSpectrum(sun_a, "solar_spectrum_direct_ASTMG173");
 
    SIFCameraProperties cam_a;
    cam_a.camera_resolution = make_int2(4, 4);
    cam_a.HFOV = 20.f;
    cam_a.excitation_bin_width_nm = 50.f;
    cam_a.excitation_scattering_depth = 0;  // default, explicit for clarity
    radiation_a.addSIFCamera("cam_scat0", {"SIF_red"}, make_vec3(0, 0, 1), make_vec3(0, 0, 0), cam_a, 1);
 
    // Also give the auto-generated excitation bands non-default rho/tau on the leaf.
    // If the per-band "_SIF_exc_*" warning suppression in runBand is broken, we'll
    // see ~7 warning lines (one per sub-band). With the suppression working, zero.
    for (float wmin = 400.f; wmin < 750.f; wmin += 50.f) {
        const float wmax = std::min(750.f, wmin + 50.f);
        std::ostringstream oss;
        oss << "_SIF_exc_50_" << wmin << "_" << wmax;
        const std::string label = oss.str();
        ctx.setPrimitiveData(leaf, ("reflectivity_" + label).c_str(), 0.05f);
        ctx.setPrimitiveData(leaf, ("transmissivity_" + label).c_str(), 0.01f);
    }
 
    std::string captured;
    {
        capture_cout cap;
        radiation_a.updateGeometry();
        const std::vector<std::string> sif_bands = {"SIF_red"};
        radiation_a.runBand(sif_bands);
        captured = cap.get_captured_output();
    }
    // No per-band "scattering iterations are disabled" warnings should appear for
    // any "_SIF_exc_*" bands.
    const bool exc_warning_absent = (captured.find("_SIF_exc_") == std::string::npos) ||
                                     (captured.find("scattering iterations are disabled") == std::string::npos);
    DOCTEST_CHECK(exc_warning_absent);
 
    // --- Second scene: camera with excitation_scattering_depth = 2 ---
    // Verify the depth propagated by checking that the bands' internal scatteringDepth
    // reflects the requested value. We can inspect this indirectly via the public
    // setScatteringDepth/getBand API — just confirm we can read back the current depth
    // via a side-effect-free path. Here we set via addSIFCamera and then manually
    // call setScatteringDepth to verify it doesn't down-grade the existing value.
    Context ctx2;
    uint leaf2 = ctx2.addPatch(make_vec3(0, 0, 0), make_vec2(1, 1));
    sif_stamp_biochem(ctx2, {leaf2}, "depth_test_2");
    ctx2.setPrimitiveData(leaf2, "electron_transport_ratio", 0.5f);
 
    RadiationModel radiation_b = RadiationModelTestHelper::createWithSharedDevice(&ctx2);
    radiation_b.disableMessages();
    radiation_b.addRadiationBand("SIF_red", 680.f, 700.f);
    radiation_b.setScatteringDepth("SIF_red", 1);
    uint sun_b = radiation_b.addCollimatedRadiationSource(make_vec3(1.f, 0.f, 1.f));
    radiation_b.setSourceSpectrum(sun_b, "solar_spectrum_direct_ASTMG173");
 
    SIFCameraProperties cam_b;
    cam_b.camera_resolution = make_int2(4, 4);
    cam_b.HFOV = 20.f;
    cam_b.excitation_bin_width_nm = 50.f;
    cam_b.excitation_scattering_depth = 2;
    radiation_b.addSIFCamera("cam_scat2", {"SIF_red"}, make_vec3(0, 0, 1), make_vec3(0, 0, 0), cam_b, 1);
 
    // Excitation bands should have scatteringDepth == 2. There's no public accessor
    // for band scattering depth; confirm the behavior by a runBand which should NOT
    // crash and should produce well-formed output.
    radiation_b.updateGeometry();
    const std::vector<std::string> sif_bands_b = {"SIF_red"};
    DOCTEST_CHECK_NOTHROW(radiation_b.runBand(sif_bands_b));
}