ray_sampling.cpp

Go to the documentation of this file.

/******************************************************************************
 * Copyright 2023 NVIDIA Corporation. All rights reserved.
 *****************************************************************************/
 
 
#include "ray_sampling_irregular_volume.h"
#include "ray_sampling_sparse_volume.h"
#include "ray_sampling_heightfield.h"
#include "ray_sampling_lod_heightfield.h"
#include "ray_sampling_trianglemesh.h"
#include "ray_sampling_simple_shapes.h"
#include "ray_sampling_overlap.h"
 
 
// Include code shared by all examples.
#define USE_NVINDEX_ACCESS
#include "utility/example_shared.h"
 
 
#include <nv/index/icamera.h>
#include <nv/index/iindex.h>
#include <nv/index/iscene.h>
#include <nv/index/isession.h>
#include <nv/index/icolormap.h>
#include <nv/index/isampling_rays.h>
#include <nv/index/iindex_debug_configuration.h>
 
#include <nv/index/app/index_connect_.h> // FIXME should be updated to index_connect.h
 
#include "utility/app_rendering_context.h"
#include "utility/canvas_utility.h"
#include "utility/example_performance_logger.h"
 
#include <iostream>
#include <sstream>
#include <fstream>
#include <iomanip>
#include <vector>
#include <algorithm>
 
//----------------------------------------------------------------------
namespace {                     // anonymous namespace for the local functions
//----------------------------------------------------------------------
class Create_ray_sampling_index_connect:
        public nv::index::app::Index_connect
{
public:
    Create_ray_sampling_index_connect()
        :
        Index_connect()
    {
        // INFO_LOG << "DEBUG: Create_ray_sampling_index_connect() ctor";
    }
 
    virtual ~Create_ray_sampling_index_connect()
    {
        // Note: Index_connect::~Index_connect() will be called after here.
        // INFO_LOG << "DEBUG: ~Create_ray_sampling_index_connect() dtor";
    }
 
    // launch application
    mi::Sint32 launch();
 
protected:
    // virtual bool evaluate_options(nv::index::app::String_dict& sdict) CPP11_OVERRIDE;
    // override
    virtual bool initialize_networking(
        mi::neuraylib::INetwork_configuration* network_configuration,
        nv::index::app::String_dict&           options) CPP11_OVERRIDE
    {
        check_success(network_configuration != 0);
 
        check_success(options.is_defined("unittest"));
        const bool is_unittest = nv::index::app::get_bool(options.get("unittest"));
        if (is_unittest)
        {
            info_cout("NETWORK: disabled networking mode.", options);
            network_configuration->set_mode(mi::neuraylib::INetwork_configuration::MODE_OFF);
            return true;
        }
 
        return initialize_networking_as_default_udp(network_configuration, options);
    }
protected:
 
private:
    // This session tag
    mi::neuraylib::Tag                                                                m_session_tag;
    // NVIDIA IndeX cluster configuration
    mi::base::Handle<nv::index::ICluster_configuration>                               m_cluster_configuration;
    // Application layer image file canvas (a render target)
    mi::base::Handle<nv::index::app::canvas_infrastructure::IIndex_image_file_canvas> m_image_file_canvas;    
    // Create_icons options
    std::string                                                                       m_outfname;
    bool                                                                              m_is_unittest;
    // std::string                                                                       m_verify_image_fname_sequence;
    // std::string                                                                       m_verify_image_fname;
 
};
 
 
// //----------------------------------------------------------------------
// mi::Sint32 launch()
// {
 
// }
 
// //----------------------------------------------------------------------
// bool evaluate_options(nv::index::app::String_dict& sdict)
// {
 
// }
 
//----------------------------------------------------------------------
 
// Generate rays from the camera.
class Camera_ray_generator
{
public:
    // Setup ray generator using current scene and camera and image resolution.
    Camera_ray_generator(
        const nv::index::IScene* scene,
        const nv::index::ICamera* camera,
        const mi::math::Vector<mi::Uint32, 2>& resolution);
 
    // Generate a ray with origin at camera position and direction controlled
    // by pixel coordinates (using the orientation and projection settings of the camera).
    bool compute_ray(
        float raster_x,
        float raster_y,
        mi::math::Vector<mi::Float32, 3>& ray_origin,
        mi::math::Vector<mi::Float32, 3>& ray_direction) const;
 
    const mi::math::Vector<mi::Uint32, 2>& resolution() const {
        return m_resolution;
    }
 
private:
    struct Params
    {
        mi::math::Vector<mi::Float32, 3>        ray_origin;
        mi::math::Vector<mi::Float32, 3>        right;
        mi::math::Vector<mi::Float32, 3>        up;
        mi::math::Vector<mi::Float32, 3>        to;
        float                                   x_mult;
        float                                   y_mult;
        mi::math::Vector<mi::Float32, 3>        image_origin;
        mi::math::Matrix<mi::Float32, 4, 4>     object_to_world_inv;
        bool                                    orthographic;
    };
 
    Params                          m_params;
    mi::math::Vector<mi::Uint32, 2> m_resolution;
    bool                            m_valid;
};
 
mi::math::Matrix<mi::Float64, 4, 4> get_camera_matrix(
    const nv::index::ICamera* camera,
    const mi::math::Vector<mi::Float32, 3>& global_translate)
{
    mi::math::Vector<mi::Float64, 3> eyepos(camera->get_eye_point());
    eyepos -= mi::math::Vector<mi::Float64, 3>(global_translate);
    mi::math::Vector<mi::Float64, 3> up_direction(camera->get_up_direction());
 
    // Camera orthonormal basis. gluLookat manner (right hand)
    mi::math::Vector<mi::Float64, 3> zdir(camera->get_view_direction());
    zdir = -zdir; // -view dir
    zdir.normalize();
    mi::math::Vector<mi::Float64, 3> xdir = mi::math::cross(up_direction, zdir);
    xdir.normalize();
    mi::math::Vector<mi::Float64, 3> ydir = mi::math::cross(zdir, xdir);
    ydir.normalize();
 
    mi::math::Matrix<mi::Float64, 4, 4> lookat_mat(
        xdir.x, ydir.x, zdir.x, 0.,
        xdir.y, ydir.y, zdir.y, 0.,
        xdir.z, ydir.z, zdir.z, 0.,
        // reverse translation of origin in camera basis.
        -mi::math::dot(xdir, eyepos),
        -mi::math::dot(ydir, eyepos),
        -mi::math::dot(zdir, eyepos),
        1.0);
    return lookat_mat;
}
 
 
 
Camera_ray_generator::Camera_ray_generator(
    const nv::index::IScene* scene,
    const nv::index::ICamera* camera,
    const mi::math::Vector<mi::Uint32, 2>& resolution)
    : m_resolution(resolution)
    , m_valid(false)
{
    const bool is_persp_camera = nv::index::IPerspective_camera::compare_iid(camera->get_iid());
    const bool is_ortho_camera = nv::index::IOrthographic_camera::compare_iid(camera->get_iid());
    if (!is_persp_camera && !is_ortho_camera) {
        return;
    }
 
    m_params.orthographic = is_ortho_camera;
 
    mi::Float32 focal_length = 1.f;
    mi::Float32 aperture = 0.33f;
    mi::Float32 aspect = 1.f;
 
    if (is_persp_camera) {
        mi::base::Handle<const nv::index::IPerspective_camera> p_camera;
        p_camera = camera->get_interface<const nv::index::IPerspective_camera>();
        focal_length = static_cast<mi::Float32>(p_camera->get_focal());
        aperture = static_cast<mi::Float32>(p_camera->get_aperture());
        aspect = static_cast<mi::Float32>(p_camera->get_aspect());
    }
    if (is_ortho_camera) {
        mi::base::Handle<const nv::index::IOrthographic_camera> o_camera;
        o_camera = camera->get_interface<const nv::index::IOrthographic_camera>();
        focal_length = 1.f;
        aperture = static_cast<mi::Float32>(o_camera->get_aperture());
        aspect = static_cast<mi::Float32>(o_camera->get_aspect());
    }
    if (focal_length <= 0.f) { return; }
    if (aperture <= 0.f) { return; }
    if (aspect <= 0.f) { return; }
    if ((resolution.x == 0) || (resolution.y == 0)) { return; }
 
 
    const mi::math::Matrix<mi::Float32, 4, 4> scene_xform = scene->get_transform_matrix();
    const mi::math::Vector<mi::Float32, 3> scene_translation(scene_xform.wx, scene_xform.wy, scene_xform.wz);
    const mi::math::Matrix<mi::Float64, 4, 4> world_to_camera = get_camera_matrix(camera, scene_translation);
    mi::math::Matrix<mi::Float64, 4, 4> world_to_camera_inv = world_to_camera;
    world_to_camera_inv.invert();
 
    // origin = row3
    mi::math::Vector<mi::Float32, 3> origin(
        static_cast<float>(world_to_camera_inv.wx),
        static_cast<float>(world_to_camera_inv.wy),
        static_cast<float>(world_to_camera_inv.wz));
 
    // right = -row0
    m_params.right.x = static_cast<float>(-world_to_camera_inv.xx);
    m_params.right.y = static_cast<float>(-world_to_camera_inv.xy);
    m_params.right.z = static_cast<float>(-world_to_camera_inv.xz);
    m_params.right.normalize();
 
    // up = -row1
    m_params.up.x = static_cast<float>(-world_to_camera_inv.yx);
    m_params.up.y = static_cast<float>(-world_to_camera_inv.yy);
    m_params.up.z = static_cast<float>(-world_to_camera_inv.yz);
    m_params.up.normalize();
 
    // to = -row2
    m_params.to.x = static_cast<float>(-world_to_camera_inv.zx);
    m_params.to.y = static_cast<float>(-world_to_camera_inv.zy);
    m_params.to.z = static_cast<float>(-world_to_camera_inv.zz);
    m_params.to.normalize();
    m_params.to *= focal_length;
 
 
    // object_to_world is scene transform without translation
    mi::math::Matrix<mi::Float32, 4, 4> object_to_world = scene_xform;
    object_to_world.wx = 0.f;
    object_to_world.wy = 0.f;
    object_to_world.wz = 0.f;
    m_params.object_to_world_inv = object_to_world;
    m_params.object_to_world_inv.invert();
 
    m_params.ray_origin = mi::math::transform_point(m_params.object_to_world_inv, origin);
 
    const mi::Float32 frustumwidth = aperture;
    const mi::Float32 frustumheight = frustumwidth / aspect;
    m_params.x_mult = frustumwidth / static_cast<float>(resolution.x);
    m_params.y_mult = frustumheight / static_cast<float>(resolution.y);
    m_params.image_origin =
        (-0.5f * frustumwidth) * m_params.right +
        (-0.5f * frustumheight) * m_params.up;
 
    m_valid = true;
}
 
 
bool Camera_ray_generator::compute_ray(
    float raster_x,
    float raster_y,
    mi::math::Vector<mi::Float32, 3>& ray_origin,
    mi::math::Vector<mi::Float32, 3>& ray_direction) const
{
    if (!m_valid)  return false;
 
    // Compute pixel index value in the viewing plane to compute the ray through the pixel
    const mi::math::Vector<mi::Float32, 3> x = m_params.right * (m_params.x_mult * raster_x);
    const mi::math::Vector<mi::Float32, 3> y = m_params.up * (m_params.y_mult * raster_y);
 
    const mi::math::Vector<mi::Float32, 3> pixel = m_params.image_origin + x + y;
 
    using mi::math::transform_vector;
    if (m_params.orthographic) {
        // Orthographic projection
        // Ray origin in object space
        ray_origin = m_params.ray_origin - transform_vector(m_params.object_to_world_inv, pixel);
        ray_direction = transform_vector(m_params.object_to_world_inv, m_params.to);
    }
    else {
        // Perspective projection
        ray_origin = m_params.ray_origin;
        // Ray direction: transform from world to object space
        ray_direction = transform_vector(m_params.object_to_world_inv, m_params.to - pixel);
    }
    ray_direction.normalize();
 
    return true;
}
 
//----------------------------------------------------------------------
// Start IndeX service
void start_nvindex_service(
    Nvindex_access&                                nvindex_accessor,
    std::map<std::string, std::string>&            opt_map,
    const ray_sampling::IRay_sampling_scene_setup* scene_setup)
{
    info_cout(std::string("NVIDIA IndeX version: ") + nvindex_accessor.get_interface()->get_version(), opt_map);
 
    initialize_log_module(nvindex_accessor, opt_map);
 
    // Register serializable classes
    scene_setup->register_classes(nvindex_accessor.get_interface().get());
 
    // check the triangle mesh serializer/deserializer
    // Do not use remote logging
    mi::base::Handle<mi::neuraylib::IDebug_configuration> debug_configuration(
        nvindex_accessor.get_interface()->get_api_component<mi::neuraylib::IDebug_configuration>());
    check_success(debug_configuration.is_valid_interface());
    debug_configuration->set_option("check_serializer_store=1");
 
 
    mi::base::Handle<nv::index::IIndex_debug_configuration> index_debug_cfg(
        nvindex_accessor.get_interface()->get_api_component<nv::index::IIndex_debug_configuration>());
    check_success(index_debug_cfg.is_valid_interface());
    if (has_key(opt_map, "cuda_rtc_print_kernel_info")) {
        index_debug_cfg->set_option("cuda_rtc_print_kernel_info=1");
    }
    if (has_key(opt_map, "cuda_rtc_load_sources_from_file")) {
        index_debug_cfg->set_option("cuda_rtc_load_sources_from_file=1");
    }
    if (has_key(opt_map, "cuda_rtc_debug_info")) {
        index_debug_cfg->set_option("cuda_rtc_debug_info=1");
    }
    if (has_key(opt_map, "cuda_rtc_disable")) {
        index_debug_cfg->set_option("cuda_rtc_disable=1");
    }
    if (nv::index::app::get_bool(opt_map["profile"]) == true) {
        index_debug_cfg->set_option("performance_values_wait=1");
    }
 
    // Start IndeX library && application_layer
    nvindex_accessor.start_service();
}
 
 
void dump_text(const std::string& filename, const std::string& text)
{
    if (filename.empty()) { return; }
    WARN_LOG << "Dumping user program '" << filename << "'";
    std::ofstream fs(filename.c_str());
    if (fs) {
        fs << text;
    }
    fs.close();
}
 
void load_text(const std::string& filename, std::string& text)
{
    if (filename.empty()) { return; }
    WARN_LOG << "Loading user program '" << filename << "'";
    std::ifstream fs(filename.c_str(), std::ios_base::binary);
    if (fs) {
        fs.seekg(0, std::ios_base::end);
        const size_t text_size = static_cast<size_t>(fs.tellg());
        fs.seekg(0);
        std::vector<char> buf(text_size + 1, '\0');
        fs.read(buf.data(), text_size);
        text = buf.data();
    }
    fs.close();
}
 
 
nv::index::IColormap* create_colormap(nv::index::IScene* scene)
{
    nv::index::IColormap* colormap = scene->create_attribute<nv::index::IColormap>();
    std::vector<mi::math::Color_struct> colormap_entries;
 
    colormap_entries.resize(256);
    for(mi::Uint32 i=0; i<256; ++i)
    {
        colormap_entries[i].r = (255.f-static_cast<mi::Float32>(i))/255.f;
        colormap_entries[i].g = (255.f-static_cast<mi::Float32>(255 - i))/255.f;
        colormap_entries[i].b = 1.f;
        colormap_entries[i].a = 0.5f;
    }
    
    // Set colormap domain
    colormap->set_domain_boundary_mode(nv::index::IColormap::CLAMP_TO_EDGE);
    colormap->set_domain(0.2f, 1.0f);
 
    // Set the the colormap values.
    colormap->set_colormap(&(colormap_entries[0]), colormap_entries.size());
    return colormap;
}
 
 
 
//----------------------------------------------------------------------
void view_all_bbox(
    const mi::math::Vector<mi::Float32, 3>& from,
    const mi::math::Vector<mi::Float32, 3>& up,
    const mi::math::Bbox< mi::Float32, 3>&  bbox,
    const mi::neuraylib::Tag&   camera_tag,
    const mi::neuraylib::Tag&   scene_tag,
    mi::neuraylib::IDice_transaction* dice_transaction)
{
    check_success(dice_transaction != 0);
 
    if(bbox.empty())
    {
        WARN_LOG << "Un-initialized bounding box and not updating the camera settings.";
        return;
    }
 
    {
        mi::base::Handle<nv::index::IPerspective_camera> 
            camera(dice_transaction->edit<nv::index::IPerspective_camera>(camera_tag));
        check_success(camera.is_valid_interface());
 
        mi::base::Handle<const nv::index::IScene> scene(dice_transaction->access<const nv::index::IScene>(scene_tag));
        check_success(scene.is_valid_interface());
 
        // Compute the new camera parameters
        const mi::math::Bbox< mi::Float32, 3>& global_roi_bbox = scene->get_clipped_bounding_box();
        const mi::math::Matrix<mi::Float32, 4, 4>& transform_mat = scene->get_transform_matrix();
        const mi::math::Vector<mi::Float32, 3> new_min(mi::math::transform_point(transform_mat, global_roi_bbox.min));
        const mi::math::Vector<mi::Float32, 3> new_max(mi::math::transform_point(transform_mat, global_roi_bbox.max));
        const mi::math::Bbox< mi::Float32, 3> transformed_bbox(new_min, new_max);
        const mi::math::Vector<mi::Float32, 3>& center = transformed_bbox.center();
        const mi::Float32 rad = mi::math::euclidean_distance(transformed_bbox.max, transformed_bbox.min) / 2.0f;
 
        const mi::Float32 fov_rad_2 = static_cast<mi::Float32>(camera->get_fov_y_rad() / 2.0);
        const mi::Float32 dist = rad / static_cast<mi::Float32>(tan(fov_rad_2));
 
        const mi::Float32 clip_min = 0.1f * dist;
        const mi::Float32 clip_max = 10.f * dist;
        camera->set_clip_min(clip_min);
        camera->set_clip_max(clip_max);
 
        const mi::math::Vector<mi::Float32, 3> eyepos = -dist * from + center;
        mi::math::Vector<mi::Float32, 3> viewdir = center - eyepos;
        check_success(viewdir.normalize());
 
        camera->set(eyepos, viewdir, up);
 
        INFO_LOG << "view_all_box: " << eyepos << viewdir << up << " clip:" << clip_min << " " << clip_max;
    }
}
 
//----------------------------------------------------------------------
// render a frame
//
// \param[in] arc              application rendering context
// \param[in] output_fname     output rendering image filename
nv::index::IFrame_results* render_frame(
    App_rendering_context&            arc,
    const std::string&                output_fname)
{
    check_success(arc.m_iindex_rendering.is_valid_interface());
 
    // set output filename, empty string is valid
    arc.m_image_canvas->set_rgba_file_name(output_fname.c_str());
 
    check_success(arc.m_session_tag.is_valid());
 
    mi::base::Handle<mi::neuraylib::IDice_transaction> dice_transaction(
        arc.m_global_scope->create_transaction<mi::neuraylib::IDice_transaction>());
    check_success(dice_transaction.is_valid_interface());
 
    arc.m_iindex_session->update(arc.m_session_tag, dice_transaction.get());
 
    mi::base::Handle<nv::index::IFrame_results> frame_results(
        arc.m_iindex_rendering->render(
            arc.m_session_tag,
            arc.m_image_canvas.get(),
            dice_transaction.get()));
    check_success(frame_results.is_valid_interface());
 
    dice_transaction->commit();
 
    frame_results->retain();
    return frame_results.get();
}
 
 
//----------------------------------------------------------------------
void setup_app_context(App_rendering_context& arc, Nvindex_access& nvindex_accessor)
{
    arc.m_database = nvindex_accessor.get_interface()->get_api_component<mi::neuraylib::IDatabase>();
    check_success(arc.m_database.is_valid_interface());
 
    arc.m_global_scope = arc.m_database->get_global_scope();
    check_success(arc.m_global_scope.is_valid_interface());
 
    // IIndex session to create a session
    arc.m_iindex_session = nvindex_accessor.get_interface()->get_api_component<nv::index::IIndex_session>();
    check_success(arc.m_iindex_session.is_valid_interface());
 
    arc.m_iindex_rendering = nvindex_accessor.get_interface()->create_rendering_interface();
    check_success(arc.m_iindex_rendering.is_valid_interface());
 
    arc.m_icluster_configuration = nvindex_accessor.get_interface()->get_api_component<nv::index::ICluster_configuration>();
    check_success(arc.m_icluster_configuration.is_valid_interface());
 
    // create image canvas in application_layer
    arc.m_image_canvas = nvindex_accessor.create_image_file_canvas();
    check_success(arc.m_image_canvas.is_valid_interface());
}
 
 
const unsigned int num_scenes = 8;
const ray_sampling::IRay_sampling_scene_setup* get_scene_setup(int i)
{
    static const irregular_volume::Irregular_volume_setup   ivol_setup;
    static const sparse_volume::Sparse_volume_setup         svol_setup;
    static const heightfield::Heightfield_setup             hfield_setup;
    static const lod_heightfield::Lod_heightfield_setup     lodhfield_setup;
    static const trianglemesh::Trianglemesh_setup           trimesh_setup;
    static const simple_shapes::Simple_shapes_setup         shapes_setup;
    static const overlap::Overlapping_samples_setup         overlap_setup;
 
    const ray_sampling::IRay_sampling_scene_setup* scene_setup = &ivol_setup;
 
    switch (i) {
    // case 0 (regular volume) has been removed
    case 1: scene_setup = &ivol_setup; break;
    case 2: scene_setup = &svol_setup; break;
    case 3: scene_setup = &hfield_setup; break;
    case 4: scene_setup = &lodhfield_setup; break;
    case 5: scene_setup = &trimesh_setup; break;
    case 6: scene_setup = &shapes_setup; break;
    case 7: scene_setup = &overlap_setup; break;
    };
    return scene_setup;
}
 
 
bool is_overlap_scene(/*const*/ std::map<std::string, std::string>& opt_map)
{
    return opt_map["scene"] == "7";
}
 
// const char* scene_name(int i)
// {
//     if (const ray_sampling::IRay_sampling_scene_setup* stp = get_scene_setup(i)) {
//         return stp->name();
//     }
//     return "<Unknown Scene>";
// }
 
 
//----------------------------------------------------------------------
const ray_sampling::IRay_sampling_scene_setup* handle_arguments(
    std::map<std::string, std::string>& opt_map, 
    int argc, char* argv[])
{
    const std::string com_name(argv[0]);
    opt_map["user_program_mode"] = "2";
    opt_map["user_values"] = "1";
    opt_map["scene"] = "0";
    opt_map["profile"] = "0";                                   // default: no profiling 
    opt_map["run_sampling"] = "1";
 
    opt_map["dice::verbose"] = "3";                             // log level
    opt_map["roi"] = "0 0 0  0 0 0";                            // input roi
    opt_map["outfname"] = "frame_ray_sampling";                 // output image file base name
    opt_map["verify_image_fname"] = "";                         // for unit test
    opt_map["unittest"] = "0";                                  // default mode
    opt_map["is_dump_comparison_image_when_failed"] = "1";      // default: dump images when failed.
    opt_map["is_call_from_test"] = "0";                         // default: not call from make check.
    opt_map["export_sample_file"] = "";
    opt_map["verify_sample_file"] = "";
 
    for (unsigned int i = 0; i < num_scenes; ++i) {
        get_scene_setup(i)->add_arguments(opt_map);
    }
 
    process_command_line(argc, argv, opt_map);
 
    if (nv::index::app::get_bool(opt_map["unittest"]))
    {
        if (nv::index::app::get_bool(opt_map["is_call_from_test"]))
        {
            opt_map["is_dump_comparison_image_when_failed"] = "0";
        }
        opt_map["outfname"] = "";  // turn off file output in the unit test mode
        opt_map["dice::verbose"] = "2";
    }
    info_cout(std::string("running ") + com_name, opt_map);
    info_cout(std::string("outfname = [") + opt_map["outfname"] +
        "], verify_image_fname = [" + opt_map["verify_image_fname"] +
        "], dice::verbose = " + opt_map["dice::verbose"], opt_map);
 
    // print help and exit if -h
    if (opt_map.find("h") != opt_map.end()) {
        const char* indent = "        ";
        std::cout
            << "info: Usage: " << com_name << " [option]\n"
            << "Option: [-h]\n"
            << "            Print this message\n\n";
 
        std::cout
            << indent << "[-scene n] \n"
            << indent << "    Choose scene type (default: " << opt_map["scene"] << ")\n"
            << indent << "      0: regular volume ... removed\n"
            << indent << "      1: irregular volume  (ivol)\n"
            << indent << "      2: sparse volume     (svol)\n"
            << indent << "      3: heightfield       (hfield)\n"
            << indent << "      4: lod heightfield   (lodhfield)\n"
            << indent << "      5: triangle mesh     (tmesh)\n"
            << indent << "      6: shapes    (plane, sphere, cone, cylinder) \n"
            << indent << "      7: overlap   (overlapping volumes and surfaces) \n\n"
 
            << indent << "[-user_program_mode n] \n"
            << indent << "    Enable user programs for scene elements (0:none, 1:only render, 2:with inquiry method)\n"
            << indent << "    (default: " << opt_map["user_program_mode"] << ")\n"
            << indent << "[-user_values bool] \n"
            << indent << "    Enable user values for picking, (default: " << opt_map["user_values"] << ")\n"
            << indent << "[-load_user_program FILENAME] \n"
            << indent << "    Load user program from file. \n"
            << indent << "[-dump_user_program FILENAME] \n"
            << indent << "    Dump builtin user program to file. \n"
            << indent << "[-profile bool]\n"
            << indent << "    Enable performance profiling (default:" << opt_map["profile"] << ")\n"
            << indent << "[-run_sampling n]\n"
            << indent << "    How to perform ray sampling 1:post-render, 2:pre-render, 3:pre+post-render\n"
            << indent << "    (default: " << opt_map["run_sampling"] << ")\n"
            << indent << "[-export_sample_file name] \n"
            << indent << "    Export file with sample values.\n"
            << indent << "[-verify_sample_file name] \n"
            << indent << "    Verify sample values with file.\n"
            << std::endl;
 
        for (unsigned int i = 0; i < num_scenes; ++i) {
            get_scene_setup(i)->usage_info(std::cout, indent, opt_map);
            std::cout << "\n";
        }
 
        std::cout
            << indent << "[-dice::verbose severity_level]\n"
            << indent << "    Verbosity level (3 is info.). (default: " + opt_map["dice::verbose"] << ")\n\n"
            << indent << "[-roi \"float float float float float float\"]\n"
            << indent << "    Bounding box representing the region of interest (roi).\n"
            << indent << "[-outfname string]\n"
            << indent << "    Name of the output ppm image file. When empty, no image file will be written.\n"
            << indent << "    A frame number and the extension (.ppm) will be added.\n"
            << indent << "    (default: '" << opt_map["outfname"] << "')\n\n"
            << indent << "[-verify_image_fname [image_fname]]\n"
            << indent << "    When image_fname exist, verify the rendering image.\n"
            << indent << "    (default: '" << opt_map["verify_image_fname"] << "')\n\n"
            << indent << "[-unittest bool]\n"
            << indent << "    When true, unit test mode.\n"
            << indent << "    (default: " << opt_map["unittest"] << ")\n"
            << std::endl;
        exit(1);
    }
 
    int iscene = nv::index::app::get_sint32(opt_map["scene"]);
    const ray_sampling::IRay_sampling_scene_setup* scene_setup = get_scene_setup(iscene);
 
    return scene_setup;
}
 
 
//----------------------------------------------------------------------
void setup_scene(
    Nvindex_access&                                nvindex_accessor,
    const ray_sampling::IRay_sampling_scene_setup* scene_setup,
    App_rendering_context&                         arc,
    /*const*/ std::map<std::string, std::string>&  opt_map)
{
    mi::base::Handle<mi::neuraylib::IDice_transaction> dice_transaction(
        arc.m_global_scope->create_transaction<mi::neuraylib::IDice_transaction>());
    check_success(dice_transaction.is_valid_interface());
    mi::neuraylib::IDice_transaction* transaction = dice_transaction.get();
 
    // Setup session information
    arc.m_session_tag = arc.m_iindex_session->create_session(transaction);
    check_success(arc.m_session_tag.is_valid());
    mi::base::Handle<const nv::index::ISession> session(
        transaction->access<const nv::index::ISession>(arc.m_session_tag));
    check_success(session.is_valid_interface());
 
    {
        mi::base::Handle<nv::index::IConfig_settings> config_settings(
            transaction->edit<nv::index::IConfig_settings>(session->get_config()));
        check_success(config_settings.is_valid_interface());
 
        scene_setup->adjust_configuration(config_settings.get(), opt_map);
 
        // test serial render/composite
        if (false) {
            config_settings->set_parallel_rendering_and_compositing(false);
        }
    }
    //----------------------------------------------------------------------
    // Scene setup: hierarchical scene description root node,
    // scene parameters, camera.
    //----------------------------------------------------------------------
    mi::math::Bbox< mi::Float32, 3> roi_bbox = nv::index::app::get_bbox_from_string<mi::Float32,3>(std::string(opt_map["roi"]));
    if (roi_bbox.empty() || roi_bbox.is_point()) {
        roi_bbox = nv::index::app::get_bbox_from_string<mi::Float32,3>(scene_setup->get_roi_string());
    }
 
    // Create a hierarchical scene description 
    ray_sampling::Scene_info scene_info;
    if (has_key(opt_map, "load_user_program")) {
        load_text(opt_map["load_user_program"], scene_info.rtc_program_source);
    }
 
    check_success(scene_setup->create_scene(
                      nvindex_accessor.get_application_layer_interface(), 
                      scene_info, roi_bbox, arc.m_session_tag, opt_map, transaction));
 
    if (has_key(opt_map, "dump_user_program")) {
        dump_text(opt_map["dump_user_program"], scene_info.rtc_program_source);
    }
 
    mi::neuraylib::Tag camera_tag = mi::neuraylib::NULL_TAG;
    {
        mi::base::Handle< nv::index::IScene > scene_edit(
            dice_transaction->edit<nv::index::IScene>(session->get_scene()));
        check_success(scene_edit.is_valid_interface());
 
        // Create and edit a camera. Data distribution is based on the camera. 
        // (Because only visible massive data are considered)
        mi::base::Handle< nv::index::IPerspective_camera > cam(
            scene_edit->create_camera<nv::index::IPerspective_camera>());
        check_success(cam.is_valid_interface());
        camera_tag = dice_transaction->store(cam.get());
        check_success(camera_tag.is_valid());
    }
 
    scene_setup->setup_camera(camera_tag, transaction);
    const mi::math::Vector<mi::Uint32, 2> buffer_resolution(1024, 1024);
    arc.m_image_canvas->set_resolution(buffer_resolution);
 
    // scope for scene edit
    {
        mi::base::Handle<nv::index::IScene> scene(
            transaction->edit<nv::index::IScene>(session->get_scene()));
        check_success(scene.is_valid_interface());
 
        // The the colormap to demonstrate color index color mapping.
        mi::base::Handle<nv::index::IColormap> colormap(create_colormap(scene.get()));
        check_success(colormap.is_valid_interface());
 
        // Store in DiCE database.
        const mi::neuraylib::Tag colormap_tag = transaction->store_for_reference_counting(
            colormap.get(), mi::neuraylib::NULL_TAG, "colormap");
        check_success(colormap_tag.is_valid());
        scene->prepend(colormap_tag, transaction);
 
 
        // Set the region of interest.
        check_success(roi_bbox.is_volume());
        scene->set_clipped_bounding_box(roi_bbox);
 
 
        // Set the scene global transformation matrix.
        // only change the coordinate system
        const float sc = scene_setup->get_scene_scaling();
        const mi::math::Matrix<mi::Float32, 4, 4> transform_mat(
            sc,  0.f, 0.f, 0.f,
            0.f, sc,  0.f, 0.f,
            0.f, 0.f, -sc, 0.f,
            0.f, 0.f, 0.f, 1.f
        );
        scene->set_transform_matrix(transform_mat);
 
 
        // Set the current camera to the scene.
        scene->set_camera(camera_tag);
    }
 
    if (false) {
        const mi::math::Vector<mi::Float32, 3> from(0.0f, 0.0f, 1.0f);
        const mi::math::Vector<mi::Float32, 3> up(0.0f, 1.0f, 0.0f);
        view_all_bbox(from, up, roi_bbox, camera_tag, session->get_scene(), transaction);
    }
    transaction->commit();
}
 
 
//----------------------------------------------------------------------
void handle_errors(const nv::index::IError_set* err_set)
{
    std::ostringstream os;
    const mi::Uint32 nb_err = err_set->get_nb_errors();
    for (mi::Uint32 e = 0; e < nb_err; ++e)
    {
        if (e != 0) os << '\n';
        const mi::base::Handle<nv::index::IError> err(err_set->get_error(e));
        os << err->get_error_string();
    }
 
    ERROR_LOG << "IIndex_rendering rendering call failed with the following error(s): " << '\n'
        << os.str();
}
 
 
//----------------------------------------------------------------------
void setup_performance_monitoring(
    App_rendering_context&                          arc,
    /*const*/ std::map<std::string, std::string>&   opt_map)
{
    check_success(arc.m_global_scope.is_valid_interface());
    mi::base::Handle<mi::neuraylib::IDice_transaction> dice_transaction(
        arc.m_global_scope->create_transaction<mi::neuraylib::IDice_transaction>());
    check_success(dice_transaction.is_valid_interface());
    {
        check_success(arc.m_session_tag.is_valid());
        mi::base::Handle<const nv::index::ISession> session(
            dice_transaction->access<nv::index::ISession const>(arc.m_session_tag));
        check_success(session.is_valid_interface());
 
        mi::base::Handle<nv::index::IConfig_settings> edit_config_settings(
            dice_transaction->edit<nv::index::IConfig_settings>(session->get_config()));
        check_success(edit_config_settings.is_valid_interface());
 
        // performance related configuration examples.
        const bool do_profiling = nv::index::app::get_bool(opt_map["profile"]);
        edit_config_settings->set_monitor_performance_values(do_profiling);
    }
    dice_transaction->commit();
}
 
 
//----------------------------------------------------------------------
void print_performance(
    const nv::index::IPerformance_values*           performance_values,
    /*const*/ std::map<std::string, std::string>&   opt_map,
    const char*                                     info = "")
{
    if (!performance_values)  return;
    if (nv::index::app::get_bool(opt_map["profile"]) == false) {
        return;
    }
 
    Performance_table_logger perf_logger;
 
    char const* const time_keys[] = {
        // "time_rendering_horizon"
        "time_rendering_volume",
        // "time_rendering_volume_and_horizon"
        // "time_intersection_lines_points",
        "time_rendering_only",
        "time_gpu_upload",
        // "time_gpu_download",
        "time_rendering",
        "time_rendering_total_sum",
        "time_compositing_stage",
        // "time_image_compositing",
        // "time_image_transfer",
        "time_total_rendering",
        // "time_total_compositing",
        // "time_total_final_compositing",
        "time_complete_frame",
        // "time_frame_setup"
        // "time_frame_finish"
        // "time_avg_rendering",
        0
    };
    char const* const value_keys[] = {
        "frames_per_second",
        // "nb_subcubes"
        // "nb_subcubes_rendered"
        // "size_volume_data_rendered",
        // "size_horizon_data_rendered"
        // "nb_horizon_triangles_rendered",
        // "size_volume_data_upload"
        // "size_rendering_results_download",
        // "size_pinned_host_memory"
        // "size_unpinned_host_memory"
        // "size_gpu_memory",
        // "nb_fragments",
        // "is_using_gpu",
        // "size_span_transfer",
        // "size_span_transfer_compressed",
        // "size_intermediate_image_transfer",
        // "size_intermediate_image_transfer_compressed",
        // "size_intermediate_image_composited",
        // "nb_composited_leafs"
        // "nb_considered_leafs_per_span",
        // "nb_active_hosts",
        // "nb_horizontal_spans"
        // "nb_rendering_results_in_queue",
        0,
    };
 
    perf_logger.append_keys(time_keys);
    perf_logger.append_keys(value_keys);
 
    INFO_LOG << info << " " << perf_logger.get_table(performance_values);
}
 
void print_sampling_performance(
    const nv::index::IRay_sampling_result*          smpl_result,
    /*const*/ std::map<std::string, std::string>&   opt_map)
 
{
    if (smpl_result) {
        const mi::base::Handle<const nv::index::IPerformance_values> performance_values(
            smpl_result->get_performance_values());
        print_performance(performance_values.get(), opt_map, "Ray Sampling");
    }
}
 
 
void print_performance(
    const nv::index::IFrame_results*                frame_results,
    /*const*/ std::map<std::string, std::string>&   opt_map)
{
    if (frame_results) {
        const mi::base::Handle<const nv::index::IPerformance_values> performance_values(
            frame_results->get_performance_values());
        print_performance(performance_values.get(), opt_map, "Rendering");
    }
}
 
//----------------------------------------------------------------------
 
template<typename T>
struct Print_one { void print(std::ostream& os, const T& item) { os << item; } };
 
template<>
struct Print_one<mi::math::Color_struct> {
    void print(std::ostream& os, const mi::math::Color_struct& c) {
        os << "(" << c.r << " " << c.g << " " << c.b << " " << c.a << ")";
    }
};
 
 
struct Printer
{
    Printer() : item_sep(" ") {}
 
    std::string item_sep;
    std::string postfix;
 
    template<typename T>
    void print_array(std::ostream& os, const T* items, mi::Uint32 nb_items) const {
        Print_one<T> p;
        for (mi::Uint32 i = 0; i < nb_items; ++i) {
            p.print(os, items[i]); os << item_sep;
        }
        os << postfix;
    }
 
    template<typename T>
    void print(std::ostream& os, const std::vector<T>& vec) const {
        this->print_array(os, vec.data(), static_cast<mi::Uint32>(vec.size()));
    }
 
    template<typename T>
    void print_masked(std::ostream& os, const T* items, mi::Uint32 nb_items,
        const mi::Uint32* masks, const mi::Uint32 mask) const
    {
        Print_one<T> p;
        for (mi::Uint32 i = 0; i < nb_items; ++i) {
            if (masks[i] & mask) {
                p.print(os, items[i]);
            }
            else {
                p.print(os, T(0));
            }
            os << item_sep;
        }
        os << postfix;
    }
 
    template<typename T>
    void print_masked(std::ostream& os, std::vector<T>& vec,
        const std::vector<mi::Uint32> masks, const mi::Uint32 mask) const
    {
        this->print_masked(os, vec.data(), static_cast<mi::Uint32>(vec.size()),
            masks.data(), mask);
    }
};
 
//=================================================================================================
//
//                             Example of ray sampling.
//
//-------------------------------------------------------------------------------------------------
 
inline void make_camera_ray(
    nv::index::IRay_sampling_query::Ray& ray,
    const Camera_ray_generator& camera_ray_gen,
    float raster_x, float raster_y)
{
    mi::math::Vector<mi::Float32, 3> origin, direction;
    camera_ray_gen.compute_ray(raster_x, raster_y, origin, direction);
    ray.origin = origin;
    ray.direction = direction;
    ray.range.x = 0.f;
    ray.range.y = 1.0e30f;
}
 
inline float pixel_center_adjusted(unsigned int v) { return float(v) + 0.5f; }
 
 
 
 
void setup_sample_rays(
    const Camera_ray_generator& ray_gen,
    nv::index::IRay_sampling_query::Ray* rays, 
    mi::Uint32 nb_rays)
{
    float center_x = static_cast<float>(pixel_center_adjusted(ray_gen.resolution().x / 2));
    float center_y = static_cast<float>(pixel_center_adjusted(ray_gen.resolution().y / 2));
 
    for (mi::Uint32 i=0; i < nb_rays; ++i) {
        float x = center_x + float(i);
        float y = center_y + float(i/4);
        make_camera_ray(rays[i], ray_gen, x, y);
    }
}
 
 
//----------------------------------------------------------------------
 
mi::base::Handle<const nv::index::IRay_sampling_result>
perform_ray_sampling(
    App_rendering_context&  arc,
    nv::index::IIndex*      nvindex,
    /*const*/ std::map<std::string, std::string>& opt_map)
{
 
    mi::base::Handle<mi::neuraylib::IDice_transaction> transaction(
        arc.m_global_scope->create_transaction<mi::neuraylib::IDice_transaction>());
    check_success(transaction.is_valid_interface());
 
    mi::base::Handle<const nv::index::ISession> session(
        transaction->access<const nv::index::ISession>(arc.m_session_tag));
    check_success(session.is_valid_interface());
 
    mi::base::Handle<const nv::index::IScene> scene(
        transaction->access<const nv::index::IScene>(session->get_scene()));
    check_success(scene.is_valid_interface());
 
    mi::base::Handle<const nv::index::ICamera> camera(
        transaction->access<const nv::index::ICamera>(scene->get_camera()));
    check_success(camera.is_valid_interface());
 
    Camera_ray_generator ray_gen(
        scene.get(),
        camera.get(),
        arc.m_image_canvas->get_resolution());
 
 
    // needed?
    arc.m_iindex_session->update(arc.m_session_tag, transaction.get());
 
 
    // Access the ray sampling interface.
    mi::base::Handle<nv::index::IRay_sampling> ray_sampling(
        nvindex->get_api_component<nv::index::IRay_sampling>());
    check_success(ray_sampling.is_valid_interface());
 
 
    const bool enable_user_values =
        nv::index::app::get_bool(opt_map["user_values"]) &&
        (nv::index::app::get_sint32(opt_map["user_program_mode"]) >= 2);
    mi::base::Handle<nv::index::IRay_sampling_value_format> user_value_format;
    if (enable_user_values) {
        // Create user value format.
        // This is optional, only needed when the CUDA render program writes user values.
        // The value format is shared by all CUDA render programs of the scene.
        // 
        user_value_format = ray_sampling->create_sampling_value_format();
        check_success(user_value_format.is_valid_interface());
        const mi::Uint32 nb_values = 3;
        const mi::Uint32 value_sizes[nb_values] = {
            static_cast<mi::Uint32>(sizeof(mi::Float32)),
            static_cast<mi::Uint32>(sizeof(mi::Sint32)),
            static_cast<mi::Uint32>(sizeof(mi::math::Vector<mi::Float32, 3>)), // Representing a normal (x,y,z).
        };
        user_value_format->set_value_sizes(value_sizes, nb_values);
    }
 
    // Create ray sampling query.
    mi::base::Handle<nv::index::IRay_sampling_query> ray_query(ray_sampling->create_sampling_query());
    check_success(ray_query.is_valid_interface());
 
 
    // Set up the query.
    const mi::Uint32 max_samples = 1000;
    const mi::Uint32 nb_rays = 1;
    nv::index::IRay_sampling_query::Ray rays[nb_rays];
 
 
    if (is_overlap_scene(opt_map)) {
        // generate ray through explicit pixel
        make_camera_ray(rays[0], ray_gen, 313, 1024 - 444);
    }
    else {
        setup_sample_rays(ray_gen, rays, nb_rays);
    }
 
    ray_query->set_rays(rays, nb_rays);
    ray_query->set_max_samples(max_samples);
    check_success(ray_query->is_valid());
 
    // Perform the query.
    mi::base::Handle<const nv::index::IRay_sampling_result> smpl_result;
    smpl_result = ray_sampling->sample_scene(
        ray_query.get(),
        user_value_format.get(),
        arc.m_iindex_rendering.get(),
        arc.m_session_tag,
        transaction.get());
 
    transaction->commit();
 
 
    return smpl_result;
}
 
 
//----------------------------------------------------------------------
 
void print_sampling_diagnostics(
    const nv::index::IRay_sampling_result* smpl_result,
    mi::neuraylib::IDice_transaction*      dice_transaction)
{
    check_success(smpl_result != NULL);
    if (!smpl_result->is_valid()) {
        ERROR_LOG << "Invalid ray sampling result.";
        return;
    }
 
    mi::base::Handle<const nv::index::IRay_sampling_query> query(smpl_result->get_query());
    mi::base::Handle<const nv::index::IRay_sampling_value_format> value_format(smpl_result->get_value_format());
 
    check_success(query.is_valid_interface());
    if (query->get_nb_rays() < 1) {
        return;
    }
 
    const mi::Uint32 ray_idx = 0;
    const mi::Uint32 nb_samples = smpl_result->get_nb_samples(ray_idx);
    std::ostringstream ss;
    ss << "Ray sampling - got  " << nb_samples << "  samples.";
 
    if (nb_samples == 0) {
        INFO_LOG << ss.str();
        return;
    }
 
    // Restrict print-out to first 15 samples.
    const mi::Uint32 nb_first_samples = std::min(nb_samples, 15u);
    nv::index::IRay_sampling_result::Sample_range srange;
    srange.first_sample = 0;
    srange.nb_samples = nb_first_samples;
    srange.ray_index = ray_idx;
 
 
    std::vector<mi::Float32> distances(nb_first_samples);
    check_success(smpl_result->get_distances(srange, distances.data()));
 
    std::vector<mi::math::Color_struct> colors(nb_first_samples);
    check_success(smpl_result->get_colors(srange, colors.data()));
 
    std::vector<mi::Uint32> object_ids(nb_first_samples);
    check_success(smpl_result->get_object_ids(srange, object_ids.data()));
 
 
    Printer printer;
    printer.postfix = nb_first_samples < nb_samples ? " ..." : "";
 
    ss << "\ndistances: \n  " << std::setprecision(4);
    printer.print(ss, distances);
 
    ss << "\ncolors: \n  " << std::setprecision(3);
    printer.item_sep = "\n  ";
    printer.print(ss, colors);
 
    ss << "\nobject ids: \n  ";
    printer.item_sep = " ";
    printer.print(ss, object_ids);
 
 
    // Inspect object info.
    ss << "\nobject infos: #" << smpl_result->get_nb_object_infos() << "\n";
    // We could enumerate all object_infos from 0 to get_nb_object_infos()
    // but instead we collect all object ids found in the given sample range for demonstration purposes.
    std::vector<mi::Uint32> all_obj_ids = object_ids;
    std::sort(all_obj_ids.begin(), all_obj_ids.end());
    all_obj_ids.resize(std::distance(all_obj_ids.begin(),
        std::unique(all_obj_ids.begin(), all_obj_ids.end())));
    for (std::vector<mi::Uint32>::const_iterator it = all_obj_ids.begin(); 
        it != all_obj_ids.end(); ++it)
    {
        ss << "  [" << *it << "]: ";
        mi::base::Handle<const nv::index::IRay_sampling_object_info> obj_info(
            smpl_result->get_object_info(*it));
        if (!obj_info.is_valid_interface()) {
            ss << "INVALID";
        }
        else {
            mi::neuraylib::Tag tag = obj_info->get_scene_element();
            ss << "tag: " << tag;
            if (const char* name = dice_transaction->tag_to_name(tag)) {
                ss << " ('" << name << "')";
            }
            mi::base::Handle<const nv::index::IScene_path> scene_path(
                obj_info->get_scene_path());
            if (scene_path.is_valid_interface()) {
                ss << "  scene_path: ";
                for (mi::Uint32 si = 0, nb = scene_path->get_length(); si < nb; ++si) {
                    ss << scene_path->get_node(si) << " ";
                }
            }
        }
        ss << "\n";
    }
 
 
    // user values
    if (value_format.is_valid_interface()) {
        check_success(value_format->get_nb_values() == 3);
        check_success(value_format->get_value_size(0) == static_cast<mi::Uint32>(sizeof(float)));
 
        std::vector<mi::Float32>                        values1(nb_first_samples);
        std::vector<mi::Sint32>                         values2(nb_first_samples);
        std::vector<mi::math::Vector<mi::Float32, 3> >  values3(nb_first_samples);
        std::vector<mi::Uint32> value_masks(nb_first_samples);
        check_success(smpl_result->get_user_value_masks(srange, value_masks.data()));
        check_success(smpl_result->get_user_values(srange, 0 /*value_index*/, values1.data()));
        check_success(smpl_result->get_user_values(srange, 1 /*value_index*/, values2.data()));
        check_success(smpl_result->get_user_values(srange, 2 /*value_index*/, values3.data()));
        ss << "\nuser value masks: \n  ";
        printer.item_sep = " ";
        printer.print(ss, value_masks);
 
        ss << "\nuser values1: \n  ";
        printer.item_sep = "\n  ";
        printer.print_masked(ss, values1, value_masks, 1u << 0);
        ss << "\nuser values2: \n  ";
        printer.item_sep = " ";
        printer.print_masked(ss, values2, value_masks, 1u << 1);
        ss << "\nuser values3: \n  ";
        printer.item_sep = "\n  ";
        printer.print_masked(ss, values3, value_masks, 1u << 2);
    }
 
    INFO_LOG << ss.str();
}
 
 
//----------------------------------------------------------------------
 
void determine_first_opaque_sample(const nv::index::IRay_sampling_result* smpl_result)
{
    const char* info = "   Determine first opaque sample:\n  ";
 
    check_success(smpl_result != 0);
    if (!smpl_result->is_valid()) {
        ERROR_LOG << info << "Invalid ray sampling result.\n";
        return;
    }
 
    mi::base::Handle<const nv::index::IRay_sampling_query> query(smpl_result->get_query());
    mi::base::Handle<const nv::index::IRay_sampling_value_format> value_format(smpl_result->get_value_format());
    
    check_success(query.is_valid_interface());
    if (query->get_nb_rays() < 1) {
        ERROR_LOG << info << "No sample ray.\n";
        return;
    }
 
    const mi::Uint32 ray_idx = 0;
    const mi::Uint32 nb_samples = smpl_result->get_nb_samples(ray_idx);
 
    if (nb_samples == 0) {
        INFO_LOG << info << "No sample found.\n";
        return;
    }
 
    nv::index::IRay_sampling_result::Sample_range srange;
    srange.first_sample = 0;
    srange.nb_samples   = nb_samples;
    srange.ray_index    = ray_idx;
 
    std::vector<mi::math::Color_struct> colors(nb_samples);
    check_success(smpl_result->get_colors(srange, colors.data()));
 
    mi::Uint32 opaque_idx = nb_samples;
    for (mi::Uint32 i = 0; i < nb_samples; ++i) {
        if (colors[i].a >= 0.99f) {
            opaque_idx = i;
            break;
        }
    }
    if (opaque_idx == nb_samples) {
        INFO_LOG << info << "No opaque color was found in samples.\n";
        return;
    }
 
    srange.first_sample = opaque_idx;
    srange.nb_samples = 1;
 
    const mi::math::Color color = colors[opaque_idx];
 
    mi::Float32 distance = 0.f;
    check_success(smpl_result->get_distances(srange, &distance));
    mi::Uint32 obj_id = 0;
    check_success(smpl_result->get_object_ids(srange, &obj_id));
 
    mi::base::Handle<const nv::index::IRay_sampling_object_info> 
        obj_info(smpl_result->get_object_info(obj_id));
    if (!obj_info.is_valid_interface())
    {
        ERROR_LOG << info << "The scene element id " << obj_id << " does not refer to a valid scene element tag.\n";
        return;
    }
 
    const mi::neuraylib::Tag& scene_element_tag = obj_info->get_scene_element();
 
    INFO_LOG << info << "The first opaque color value is at sample " << opaque_idx << " with color " << color 
        << "\n  and extracted from the scene element tag id " << scene_element_tag.id << "."
        << "\n  The distance of the sample from the camera is " << distance << ".\n";
}
 
 
//----------------------------------------------------------------------
// Find the ray segment length between samples to perform opacity correction.
// Take distance between current and previous sample of same object_id as segment length.
// If the current sample is a surface sample, the result makes no sense (not checked here).
mi::Float32 get_ray_segment_length(
    mi::Uint32 isample,
    const std::vector<mi::Float32>& distances,
    const std::vector<mi::Uint32>& object_ids)
{
    const mi::Uint32 nb_samples = static_cast<mi::Uint32>(distances.size());
    if (nb_samples <= 1 || isample >= nb_samples) {
        return 0.f;
    }
    const mi::Uint32 obj_id = object_ids[isample];
    // for first sample, take distance to next sample of same object
    if (isample == 0) {
        mi::Uint32 inext = isample + 1;
        if (inext < nb_samples && object_ids[inext] == obj_id) {
            return distances[inext] - distances[isample];
        }
    }
    else {
        mi::Uint32 iprev = isample - 1;
        if (object_ids[iprev] == obj_id) {
            return distances[isample] - distances[iprev];
        }
    }
    return 0.f;
}
 
 
// Perform opacity correction for volume sample.
mi::Float32 opacity_correction(
    mi::Float32 alpha,          // opacity
    mi::Float32 sampling_ratio) // ratio of used sample distance to the base sample distance (usually 1)
{
    if (sampling_ratio < 1.0e-6f)  sampling_ratio = 1.0e-6f;
    return 1.f - powf(1.f - alpha, sampling_ratio);
}
 
 
// Get opacity corrected alpha value of sample.
mi::Float32 opacity_corrected_alpha(
    mi::Uint32 isample,
    const mi::Float32 alpha,
    const std::vector<mi::Float32>& distances,
    const std::vector<mi::Uint32>& object_ids)
{
    mi::Float32 seglen = get_ray_segment_length(isample, distances, object_ids);
    if (seglen == 0.f)  return alpha;
 
    const mi::Float32 ref_seg_len = 1.f;    // reference sampling distance
    return opacity_correction(alpha, seglen / ref_seg_len);
}
 
void determine_accumulated_alpha_value(
    mi::Float32                             threshold,
    const nv::index::IRay_sampling_result*  smpl_result)
{
    const char* info = "   Determine accumulated alpha value:\n  ";
 
    check_success(smpl_result != 0);
    if (!smpl_result->is_valid()) {
        ERROR_LOG << info << "Invalid ray sampling result.\n";
        return;
    }
 
    mi::base::Handle<const nv::index::IRay_sampling_query> query(smpl_result->get_query());
    mi::base::Handle<const nv::index::IRay_sampling_value_format> value_format(smpl_result->get_value_format());
 
    check_success(query.is_valid_interface());
    if (query->get_nb_rays() < 1) {
        ERROR_LOG << info << "No sample ray.\n";
        return;
    }
 
    const mi::Uint32 ray_idx = 0;
    const mi::Uint32 nb_samples = smpl_result->get_nb_samples(ray_idx);
 
    if (nb_samples == 0) {
        INFO_LOG << info << "No sample found.\n";
        return;
    }
 
    nv::index::IRay_sampling_result::Sample_range srange;
    srange.first_sample = 0;
    srange.nb_samples = nb_samples;
    srange.ray_index = ray_idx;
 
    std::vector<mi::Float32> distances(nb_samples);
    check_success(smpl_result->get_distances(srange, distances.data()));
 
    std::vector<mi::math::Color_struct> colors(nb_samples);
    check_success(smpl_result->get_colors(srange, colors.data()));
 
    std::vector<mi::Uint32> object_ids(nb_samples);
    check_success(smpl_result->get_object_ids(srange, object_ids.data()));
 
    mi::math::Color dst(0.f);   // Accumulated result.
    mi::Uint32 thresh_idx = nb_samples;
    for (mi::Uint32 i = 0; i < nb_samples; ++i)
    {
        const mi::math::Color& src = colors[i];
        const mi::Float32 src_alpha = opacity_corrected_alpha(i, src.a, distances, object_ids);
        // front-to_back compositing (non-premultiplied alpha)
        const mi::Float32 da_sa = (1.0f - dst.a) * src_alpha;
        dst.r = mi::math::saturate(dst.r + da_sa * src.r);
        dst.g = mi::math::saturate(dst.g + da_sa * src.g);
        dst.b = mi::math::saturate(dst.b + da_sa * src.b);
        dst.a = mi::math::saturate(dst.a + da_sa);
 
        if (dst.a >= threshold)
        {
            thresh_idx = i;
            break;
        }
    }
 
    if (thresh_idx == nb_samples) {
        INFO_LOG << info << "The accumulated color's alpha did not reach the given threshold " 
            << threshold << " when determining the accumulated alpha along the given ray sampling.\n";
        return;
    }
 
    const mi::math::Color   accumulated_color = dst;
 
    srange.first_sample = thresh_idx;
    srange.nb_samples = 1;
    mi::Float32 distance = 0.f;
    check_success(smpl_result->get_distances(srange, &distance));
    mi::Uint32 obj_id = 0;
    check_success(smpl_result->get_object_ids(srange, &obj_id));
 
    mi::base::Handle<const nv::index::IRay_sampling_object_info> obj_info(smpl_result->get_object_info(obj_id));
    if (!obj_info.is_valid_interface()) {
        ERROR_LOG << info << "The scene element id " << obj_id << " does not refer to a valid scene element tag.";
    }
    else {
        const mi::neuraylib::Tag_struct& scene_element_tag = obj_info->get_scene_element();
        INFO_LOG << info << "Based on an alpha threshold of " << threshold 
            << " the accumulated color is " << accumulated_color << "."
            << "\n  The threshold has been reached at sample " << thresh_idx 
            << "\n  when sampling the scene element with tag id " << scene_element_tag.id
            << "\n  at a distance of " << distance << " from the camera.\n";
    }
}
 
//----------------------------------------------------------------------
 
 
 
void print_sampling_info(
    const mi::base::Handle<const nv::index::IRay_sampling_result>& smpl_result,
    App_rendering_context&  arc,
    /*const*/ std::map<std::string, std::string>& opt_map)
{
    mi::base::Handle<mi::neuraylib::IDice_transaction> transaction(
        arc.m_global_scope->create_transaction<mi::neuraylib::IDice_transaction>());
    check_success(transaction.is_valid_interface());
 
    // Use the sampling result.
    print_sampling_diagnostics(smpl_result.get(), transaction.get());
 
    if (!is_overlap_scene(opt_map)) {
        determine_first_opaque_sample(smpl_result.get());
 
        determine_accumulated_alpha_value(0.95f, smpl_result.get());
 
        print_sampling_performance(smpl_result.get(), opt_map);
    }
 
    transaction->commit();
}
 
//----------------------------------------------------------------------
} // namespace anonymous
//----------------------------------------------------------------------
 
//=================================================================================================
// Testing functionality
 
namespace test {
 
// compare floats with relative error margin
inline bool equal_float_relative(float a, float b, const float rel_eps=1.0e-4f)
{
    const float magnitude = std::max(fabsf(a), fabsf(b));
    return fabsf(a - b) <= (magnitude * rel_eps);
}
 
struct Sampling_data
{
    std::vector<mi::Float32>                        distances;
    std::vector<mi::math::Color_struct>             colors;
    std::vector<mi::Uint32>                         object_ids;
    std::vector<mi::Float32>                        values1;
    std::vector<mi::Sint32>                         values2;
    std::vector<mi::math::Vector<mi::Float32, 3> >  values3;
    std::vector<mi::Uint32>                         value_masks;
 
    void resize(mi::Uint32 new_size, bool user_values) 
    {
        distances.resize(new_size);
        colors.resize(new_size);
        object_ids.resize(new_size);
        const mi::Uint32 user_size = user_values ? new_size : 0;
        values1.resize(user_size);
        values2.resize(user_size);
        values3.resize(user_size);
        value_masks.resize(user_size);
    }
};
 
template<typename T> struct Stream_one { 
    void write(std::ostream& os, const T& item)     { os << item; }
    void read(std::istream& is, T& item)            { is >> item; } 
};
 
template<> struct Stream_one<mi::math::Color_struct> {
    void write(std::ostream& os, const mi::math::Color_struct& c) {
        os << c.r << " " << c.g << " " << c.b << " " << c.a << " ";
    }
    void read(std::istream& is, mi::math::Color_struct& c) {
        is >> c.r >> c.g >> c.b  >> c.a;
    }
};
 
template<typename VE, mi::Size VDIM> struct Stream_one< mi::math::Vector<VE, VDIM> > {
    void write(std::ostream& os, const mi::math::Vector<VE, VDIM>& v) {
        for (mi::Size i = 0; i < VDIM; ++i) { os << v[i] << " "; }
    }
    void read(std::istream& is, mi::math::Vector<VE, VDIM>& v) {
        for (mi::Size i = 0; i < VDIM; ++i) { is >> v[i]; }
    }
};
 
template<typename T> struct Verify_one {
    // precise comparison by default
    bool verify(const T& a, const T& b) const { return a == b; }
};
template<> struct Verify_one<float> {
    // relative epsilon for floating point
    bool verify(const float& a, const float& b) const { return equal_float_relative(a, b); }
};
template<> struct Verify_one<mi::math::Color_struct> {
    bool verify(const mi::math::Color_struct& a, const mi::math::Color_struct& b) const {
        Verify_one<float> ver;
        if (!ver.verify(a.r, b.r)) return false;
        if (!ver.verify(a.g, b.g)) return false;
        if (!ver.verify(a.b, b.b)) return false;
        if (!ver.verify(a.a, b.a)) return false;
        return true;
    }
};
template<typename VE, mi::Size VDIM> struct Verify_one< mi::math::Vector<VE, VDIM> > {
    bool verify(const mi::math::Vector<VE, VDIM>& a, const mi::math::Vector<VE, VDIM>& b) const {
        Verify_one<float> ver;
        for (mi::Size i = 0; i < VDIM; ++i) {
            if (!ver.verify(a[i], b[i])) return false; 
        }
        return true;
    }
};
 
template<typename T> void write_array(std::ostream& os, const std::vector<T>& v) 
{
    typedef typename std::vector<T>::size_type sz_type;
    const sz_type nb = v.size();
    os << nb << "  ";
    Stream_one<T> s;
    for (sz_type i = 0; i < nb; ++i) {
        s.write(os, v[i]);
        os << " ";
    }
    os << '\n';
}
template<typename T> void read_array(std::istream& is, std::vector<T>& v)
{
    typedef typename std::vector<T>::size_type sz_type;
    sz_type nb = 0;
    is >> nb;
    v.resize(nb);
    Stream_one<T> s;
    for (sz_type i = 0; i < nb; ++i) {
        s.read(is, v[i]);
    }
}
 
template<typename T> bool verify_array(const std::vector<T>& v, const std::vector<T>& ref_v)
{
    typedef typename std::vector<T>::size_type sz_type;
    const sz_type nb = v.size();
    if (nb != ref_v.size()) return false;
 
    Verify_one<T> ver;
    for (sz_type i = 0; i < nb; ++i) {
        if (!ver.verify(v[i], ref_v[i])) {
            return false;
        }
    }
    return true;
}
 
 
void write_sampling_data(std::ostream& os, const Sampling_data& smpl_data) 
{
    write_array(os, smpl_data.distances);
    write_array(os, smpl_data.colors);
    //write_array(os, smpl_data.object_ids); // might not be unique
    write_array(os, smpl_data.value_masks);
    write_array(os, smpl_data.values1);
    write_array(os, smpl_data.values2);
    write_array(os, smpl_data.values3);
}
 
void read_sampling_data(std::istream& is, Sampling_data& smpl_data)
{
    read_array(is, smpl_data.distances);
    read_array(is, smpl_data.colors);
    read_array(is, smpl_data.value_masks);
    read_array(is, smpl_data.values1);
    read_array(is, smpl_data.values2);
    read_array(is, smpl_data.values3);
}
 
int verify_sample_data(const Sampling_data& smpl_data, const Sampling_data& ref_smpl_data)
{
    if (!verify_array(smpl_data.distances,      ref_smpl_data.distances))   return 201;
    if (!verify_array(smpl_data.colors,         ref_smpl_data.colors))      return 202;
    if (!verify_array(smpl_data.value_masks,    ref_smpl_data.value_masks)) return 203;
    if (!verify_array(smpl_data.values1,        ref_smpl_data.values1))     return 204;
    if (!verify_array(smpl_data.values2,        ref_smpl_data.values2))     return 205;
    if (!verify_array(smpl_data.values3,        ref_smpl_data.values3))     return 206;
    return 0;
}
 
 
template <typename T>
void get_masked_user_value(
    const nv::index::IRay_sampling_result* smpl_result,
    const nv::index::IRay_sampling_result::Sample_range& srange,
    mi::Uint32 user_value_index,
    const std::vector<mi::Uint32>& value_masks,
    std::vector<T>& values,
    const T& default_value)
{
    smpl_result->get_user_values(srange, user_value_index, values.data());
    const mi::Uint32 mask = 1u << user_value_index;
    for (mi::Uint32 i = 0; i < srange.nb_samples; ++i) {
        if ((value_masks[i] & mask) == 0) {
            values[i] = default_value;
        }
    }
}
 
void get_sample_data(
    const nv::index::IRay_sampling_result* smpl_result,
    const nv::index::IRay_sampling_result::Sample_range& srange,
    bool has_user_values,
    Sampling_data& smpl_data)
{
    smpl_data.resize(srange.nb_samples, has_user_values);
 
    smpl_result->get_distances(srange, smpl_data.distances.data());
    smpl_result->get_colors(srange, smpl_data.colors.data());
    //smpl_result->get_object_ids (srange, smpl_data.object_ids.data());
 
    if (has_user_values) {
        smpl_result->get_user_value_masks(srange, smpl_data.value_masks.data());
        get_masked_user_value(smpl_result, srange, 0, smpl_data.value_masks, smpl_data.values1, 0.f);
        get_masked_user_value(smpl_result, srange, 1, smpl_data.value_masks, smpl_data.values2, 0);
        get_masked_user_value(smpl_result, srange, 2, smpl_data.value_masks, smpl_data.values3, mi::math::Vector<mi::Float32, 3>(0.f, 0.f, 0.f));
    }
}
 
 
 
// Write samples of all rays into stream.
// Format:
// 
// {nb_rays}
// {ray_idx nb_samples has_user_values}
//   {nb_distances, ...}
//   {nb_colors, ...}
//   {nb_value_masks, ...}
//   {nb_values1, ...}
//   {nb_values2, ...}
//   {nb_values3, ...}
// {ray_idx}
//   ...
// 
void export_sampling_result(
    std::ostream&                          os,
    mi::Uint32                             max_nb_samples,
    const nv::index::IRay_sampling_result* smpl_result)
{
    if (!smpl_result->is_valid()) {
        return;
    }
 
    mi::base::Handle<const nv::index::IRay_sampling_query> query(smpl_result->get_query());
    mi::base::Handle<const nv::index::IRay_sampling_value_format> value_format(smpl_result->get_value_format());
 
    if (!query.is_valid_interface()) {
        return;
    }
    const mi::Uint32 nb_rays = query->get_nb_rays();
    if (nb_rays < 1) {
        return;
    }
 
    os << nb_rays << '\n';
 
    Sampling_data smpl_data;
    const bool has_user_values = value_format.is_valid_interface();
 
    for (mi::Uint32 ray_idx = 0; ray_idx < nb_rays; ++ray_idx)
    {
        const mi::Uint32 nb_samples = smpl_result->get_nb_samples(ray_idx);
        const mi::Uint32 nb_first_samples = std::min(nb_samples, max_nb_samples);
 
        os << ray_idx << " " << nb_first_samples << " " << has_user_values << '\n';
 
        if (nb_samples == 0) {
            continue;
        }
 
        nv::index::IRay_sampling_result::Sample_range srange;
        srange.first_sample = 0;
        srange.nb_samples = nb_first_samples;
        srange.ray_index = ray_idx;
 
        get_sample_data(smpl_result, srange, has_user_values, smpl_data);
 
        write_sampling_data(os, smpl_data);
    }
}
 
 
void import_sampling_result(
    std::istream& is,
    std::vector<Sampling_data>& smpl_data)
{
    mi::Uint32 nb_rays = 0;
    is >> nb_rays;
    smpl_data.resize(nb_rays);
 
    for (mi::Uint32 ray_idx = 0; ray_idx < nb_rays; ++ray_idx)
    {
        mi::Uint32 in_ray_idx = 0;
        mi::Uint32 nb_values = 0;
        int has_user_values = 0;
        is >> in_ray_idx >> nb_values >> has_user_values;
        if (nb_values == 0) {
            continue;
        }
        smpl_data[ray_idx].resize(nb_values, has_user_values != 0);
        read_sampling_data(is, smpl_data[ray_idx]);
    }
}
 
 
std::string make_sample_filename(
    const std::string& basename,
    /*const*/ std::map<std::string, std::string>& opt_map,
    const std::string& info)
{
    const int user_prg = nv::index::app::get_sint32(opt_map["user_program_mode"]);
 
    std::string filename = basename;
    if (!filename.empty()) {
        filename.append("__");
        filename.append(opt_map["scene"]);
        filename.append("_");
        filename.append(opt_map["user_program_mode"]);
        if (user_prg >= 2) {
            filename.append("_");
            filename.append(opt_map["user_values"]);
        }
        filename.append("_");
        filename.append(info);  // post, pre
        filename.append(".samples");
    }
    return filename;
}
 
void export_sample_file(
    const nv::index::IRay_sampling_result* smpl_result,
    /*const*/ std::map<std::string, std::string>& opt_map,
    const std::string& basename,
    const std::string& info)
{
    std::string filename = make_sample_filename(basename, opt_map, info);
    std::ofstream export_file(filename.c_str(), std::ios::out | std::ios::trunc);
    export_sampling_result(export_file, 1000, smpl_result);
}
 
 
int verify_sample_file(
    const nv::index::IRay_sampling_result* smpl_result,
    /*const*/ std::map<std::string, std::string>& opt_map,
    const std::string& basename,
    const std::string& info)
{
    std::vector<Sampling_data> ref_smpl_data;
    {
        std::string filename = make_sample_filename(basename, opt_map, info);
        std::ifstream import_file(filename.c_str());
        import_sampling_result(import_file, ref_smpl_data);
        if (ref_smpl_data.empty()) {
            return 100;
        }
    }
 
    if (!smpl_result->is_valid()) {
        return 101;
    }
 
    mi::base::Handle<const nv::index::IRay_sampling_query> query(smpl_result->get_query());
    mi::base::Handle<const nv::index::IRay_sampling_value_format> value_format(smpl_result->get_value_format());
 
    if (!query.is_valid_interface()) {
        return 102;
    }
    const mi::Uint32 nb_rays = query->get_nb_rays();
    if (nb_rays < 1) {
        return 103;
    }
    if (nb_rays != static_cast<mi::Uint32>(ref_smpl_data.size())) {
        return 104;
    }
 
    Sampling_data smpl_data;
    const bool has_user_values = value_format.is_valid_interface();
 
    for (mi::Uint32 ray_idx = 0; ray_idx < nb_rays; ++ray_idx)
    {
        const Sampling_data& ref_samples = ref_smpl_data[ray_idx];
 
        const mi::Uint32 nb_samples = smpl_result->get_nb_samples(ray_idx);
        const mi::Uint32 nb_ref_samples = static_cast<mi::Uint32>(ref_samples.distances.size());
 
        if (nb_samples != nb_ref_samples)  return 105;
 
        const mi::Uint32 nb_first_samples = std::min(nb_samples, nb_ref_samples);
        if (nb_first_samples == 0) continue;
 
        nv::index::IRay_sampling_result::Sample_range srange;
        srange.first_sample = 0;
        srange.nb_samples = nb_first_samples;
        srange.ray_index = ray_idx;
 
        get_sample_data(smpl_result, srange, has_user_values, smpl_data);
 
        int code = verify_sample_data(smpl_data, ref_samples);
        if (code != 0) {
            return code;
        }
    }
    return 0;
}
 
 
int handle_verification(
    const nv::index::IRay_sampling_result* smpl_result,
    /*const*/ std::map<std::string, std::string>& opt_map,
    const std::string& info)
{
    int code = 0;
    if (!opt_map["export_sample_file"].empty()) {
        export_sample_file(smpl_result, opt_map, opt_map["export_sample_file"], info);
    }
    if (!opt_map["verify_sample_file"].empty()) {
        std::string ref_filename = opt_map["verify_sample_file"];
        code = test::verify_sample_file(smpl_result, opt_map, ref_filename, info);
        if (code != 0) {
            ERROR_LOG << "Verification failed (" << info << "): " << code;
        }
        else {
            INFO_LOG << "Verification succeeded (" << info << ")";
        }
    }
    return code;
}
 
//----------------------------------------------------------------------
} // namespace anonymous
//----------------------------------------------------------------------
 
//=================================================================================================
 
int main(int argc, char* argv[])
{
    std::map<std::string, std::string> opt_map;
    const ray_sampling::IRay_sampling_scene_setup* scene_setup = 
        handle_arguments(opt_map, argc, argv);
 
    // Load IndeX library
    const std::string comp_dso_prefix = "libnvindex_application_layer_";
    const std::string plug_dso_prefix = "libnvindex_plugin_";
    Nvindex_access nvindex_accessor;
    check_success(nvindex_accessor.load_library());
    check_success(nvindex_accessor.load_application_layer_library());
    check_success(nvindex_accessor.load_application_layer_component((comp_dso_prefix + "canvas_infrastructure").c_str())); 
    check_success(nvindex_accessor.load_application_layer_component((comp_dso_prefix + "data_analysis_and_processing").c_str()));
    check_success(nvindex_accessor.load_application_layer_component((comp_dso_prefix + "image").c_str())); 
    check_success(nvindex_accessor.load_application_layer_component((comp_dso_prefix + "io").c_str())); 
    check_success(nvindex_accessor.load_application_layer_plugin(   (plug_dso_prefix + "base_importer").  c_str())); 
    check_success(nvindex_accessor.load_application_layer_plugin(   (plug_dso_prefix + "legacy_importer").c_str())); 
 
    start_nvindex_service(nvindex_accessor, opt_map, scene_setup);
    if (!nvindex_accessor.is_initialized())
    {
        info_cout("Fatal error! Initialization of the IndeX library failed.", opt_map);
        return 1;
    }
 
    mi::Sint32 exit_code = 0;
 
    const char* sep_line = "----------------------------------------------------------------------------";
    {
        App_rendering_context arc;
        setup_app_context(arc, nvindex_accessor);
 
        // Verifying that local host has joined. This may fail when there is a license problem.
        check_success(arc.is_local_host_joined());
 
        INFO_LOG << "\n" << sep_line << "\n    Ray Sampling Example - Scene " << scene_setup->name() << "\n" << sep_line;
 
        // Scene setup
        {
            setup_scene(nvindex_accessor, scene_setup, arc, opt_map);
        }
 
        setup_performance_monitoring(arc, opt_map);
 
        const mi::Uint32 ray_sampling_mode = nv::index::app::get_uint32(opt_map["run_sampling"]);
 
        // Ray sampling, pre-render
        if (ray_sampling_mode >= 2) 
        {
            mi::base::Handle<const nv::index::IRay_sampling_result> smpl_result =
                perform_ray_sampling(arc, nvindex_accessor.get_interface().get(), opt_map);
            INFO_LOG << sep_line;
            print_sampling_info(smpl_result, arc, opt_map);
 
            const int code = test::handle_verification(smpl_result.get(), opt_map, "pre");
            if (code != 0) {
                exit_code = code;
            }
        }
 
        // Rendering
        {
            // Render a frame and save the rendered image to a file.
            const mi::Sint32  frame_idx = 0;
            const std::string fname = get_output_file_name(opt_map["outfname"], frame_idx);
 
 
            INFO_LOG << sep_line;
            INFO_LOG << "Rendering one frame \n";
            mi::base::Handle<const nv::index::IFrame_results> frame_results(
                render_frame(arc, fname));
 
 
            mi::base::Handle<const nv::index::IError_set> err_set(frame_results->get_error_set());
            if (err_set->any_errors())
            {
                handle_errors(err_set.get());
                exit_code = 1;
            }
 
            print_performance(frame_results.get(), opt_map);
 
            // verify the generated frame
            if (!(verify_canvas_result(nvindex_accessor.get_application_layer_interface(),
                                       arc.m_image_canvas.get(), opt_map["verify_image_fname"], opt_map)))
            {
                exit_code = 1;
            }
        }
 
        // Ray sampling, post-render
        if (ray_sampling_mode == 1 || ray_sampling_mode == 3)
        {
            mi::base::Handle<const nv::index::IRay_sampling_result> smpl_result =
                perform_ray_sampling(arc, nvindex_accessor.get_interface().get(), opt_map);
            INFO_LOG << sep_line;
            print_sampling_info(smpl_result, arc, opt_map);
 
            const int code = test::handle_verification(smpl_result.get(), opt_map, "post");
            if (code != 0) {
                exit_code = code;
            }
        }
        arc.shutdown();
    }
    nvindex_accessor.shutdown();
 
    return exit_code;
}