distributed_sparse_volume_data.cpp

Go to the documentation of this file.

/******************************************************************************
 * Copyright 2023 NVIDIA Corporation. All rights reserved.
 *****************************************************************************/
 
#include <iostream>
#include <limits>
#include <sstream>
#include <vector>
 
#include <mi/dice.h>
 
// Include code shared by all examples.
#include "utility/example_shared.h"
 
#include <nv/index/icamera.h>
#include <nv/index/iconfig_settings.h>
#include <nv/index/idistributed_data_access.h>
#include <nv/index/iindex.h>
#include <nv/index/ilight.h>
#include <nv/index/imaterial.h>
#include <nv/index/iscene.h>
#include <nv/index/isession.h>
#include <nv/index/isparse_volume_subset.h>
#include <nv/index/isparse_volume_rendering_properties.h>
 
#include <nv/index/app/forwarding_logger.h>
#include <nv/index/app/idata_analysis_and_processing.h>
#include <nv/index/app/index_connect.h>
#include <nv/index/app/string_dict.h>
 
//----------------------------------------------------------------------
class Distributed_sparse_volume_data:
    public nv::index::app::Index_connect
{
public:
    Distributed_sparse_volume_data()
        :
        Index_connect()
    {
        // INFO_LOG << "DEBUG: Distributed_sparse_volume_data() ctor";
    }
 
    virtual ~Distributed_sparse_volume_data()
    {
        // Note: Index_connect::~Index_connect() will be called after here.
        // INFO_LOG << "DEBUG: ~Distributed_sparse_volume_data() 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);
    }
 
private:
    mi::Size calc_offset(const mi::math::Vector<mi::Sint32, 3>& p, const mi::math::Vector<mi::Uint32, 3>& s, mi::Uint32 b) const;
    mi::Float32 analyze_sparse_volume_data(
        mi::neuraylib::IDice_transaction* dice_transaction) const;
    // Edit the data in the volume
    // \param[in] dice_transaction transaction
    void edit_sparse_volume_data(
        mi::neuraylib::IDice_transaction* dice_transaction) const;
    // Export the data in the volume
    // \param[in] dice_transaction transaction
    // \returns average of the data in the volume
    mi::Float32 export_sparse_volume_data(
        mi::neuraylib::IDice_transaction* dice_transaction) const;
    void render_frame(const std::string& output_filename) const;
 
    // Create a synthetic sparse volume to the scene.
    mi::neuraylib::Tag create_synthetic_volume(
        const nv::index::ISession*             session,
        const mi::math::Vector<mi::Uint32, 3>& volume_size,
        mi::neuraylib::IDice_transaction*      dice_transaction) const;
    std::vector<mi::Uint32> evaluate_sparse_volume_data_locality(
        const nv::index::IDistributed_data_locality* data_locality,
        const mi::math::Bbox<mi::Sint32, 3>&         query_bound,
        const mi::neuraylib::Tag&                    scene_element_tag,
        const std::string&                           scene_element_type) const;
    // Get brick's clamped bboxes
    //
    // \param[in]  svol_data_subset_desc
    // \param[in]  brick_idx
    // \param[in]  brick_position
    // \param[in]  query_bbox_s32
    // \param[out] out_brick_box_subdata_clamped
    // \param[out] out_brick_box_clamped
    void get_brick_clamped_bbox(
        const nv::index::ISparse_volume_subset_data_descriptor* svol_data_subset_desc,
        const mi::Uint32                                        brick_idx,
        const mi::math::Vector<mi::Sint32, 3>&                  brick_position,
        const mi::math::Bbox<mi::Sint32, 3>&                    query_bbox_s32,
        mi::math::Bbox<mi::Sint32, 3>&                          out_brick_box_subdata_clamped,
        mi::math::Bbox<mi::Sint32, 3>&                          out_brick_box_clamped) const;
 
    // 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_voxel_format;
    mi::neuraylib::Tag                                                                m_sparse_volume_tag;
};
 
//----------------------------------------------------------------------
mi::Sint32 Distributed_sparse_volume_data::launch()
{
    m_cluster_configuration = get_index_interface()->get_api_component<nv::index::ICluster_configuration>();
    check_success(m_cluster_configuration.is_valid_interface());
 
    // create image canvas in application_layer
    m_image_file_canvas = create_image_file_canvas(get_application_layer_interface());
    check_success(m_image_file_canvas.is_valid_interface());
 
    // Verifying that local host has joined
    // This may fail when there is a license problem.
    check_success(is_local_host_joined(m_cluster_configuration.get()));
 
    {
        mi::base::Handle<mi::neuraylib::IDice_transaction> dice_transaction(create_transaction());
        check_success(dice_transaction.is_valid_interface());
        {
            // Setup session information
            m_session_tag = m_index_session->create_session(dice_transaction.get());
            check_success(m_session_tag.is_valid());
 
            mi::base::Handle<const nv::index::ISession> session(dice_transaction->access<nv::index::ISession>(m_session_tag));
            check_success(session.is_valid_interface());
 
            // Setup the session's configuration
            {
                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());
 
                // All data should be uploaded immediately, even when it is not initially visible
                edit_config_settings->set_force_data_upload(true);
 
                // Set smaller subcube size in unit test mode
                if (m_is_unittest)
                {
                    const mi::math::Vector<mi::Uint32, 3> subcube_size(30);
                    mi::math::Vector<mi::Float32, 3> minimal_volume_scaling;
                    edit_config_settings->get_minimal_volume_scaling(minimal_volume_scaling);
                    edit_config_settings->set_subcube_configuration(
                        subcube_size,
                        edit_config_settings->get_subcube_border_size(),
                        edit_config_settings->get_continuous_volume_translation_supported(),
                        edit_config_settings->get_volume_rotation_supported(),
                        minimal_volume_scaling);
                }
            }
 
            //----------------------------------------------------------------------
            // Scene setup: add volume data, scene parameters
            //----------------------------------------------------------------------
 
            // the Size of the volume and the global scene transformation used below.
            mi::math::Vector<mi::Uint32, 3> volume_size(1000, 1000, 1000);
            mi::math::Matrix<mi::Float32, 4, 4> transform(
                0.02f, 0.0f,  0.0f,  0.0f,
                0.0f,  0.02f, 0.0f,  0.0f,
                0.0f,  0.0f, -0.02f, 0.0f, // adjust for coordinate system
                0.0f,  0.0f,  0.0f,  1.0f
                );
 
            // Use a smaller volume but a larger global scene scaling in unit test mode, to speed things up.
            if (m_is_unittest)
            {
                volume_size = mi::math::Vector<mi::Uint32, 3>(100, 100, 100);
                transform = mi::math::Matrix<mi::Float32, 4, 4>(
                    0.2f, 0.0f,  0.0f,  0.0f,
                    0.0f,  0.2f, 0.0f,  0.0f,
                    0.0f,  0.0f, -0.2f, 0.0f, // adjust for coordinate system
                    0.0f,  0.0f,  0.0f,  1.0f
                    );                
            }
    
            m_sparse_volume_tag = create_synthetic_volume(session.get(), volume_size, dice_transaction.get());
            check_success(m_sparse_volume_tag.is_valid());
            INFO_LOG << "Created a synthetic sparse volume dataset: size = "
                     << "[" << volume_size.x << " " << volume_size.y << " " << volume_size.z << "], " << "tag = " << m_sparse_volume_tag.id;
 
            // Set up the scene and the camera
            mi::base::Handle<nv::index::IScene> scene_edit(dice_transaction->edit<nv::index::IScene>(session->get_scene()));
            check_success(scene_edit.is_valid_interface());
 
            // Set region of interest to fit the volume in this example
            const mi::math::Bbox<mi::Float32, 3> global_roi(
                0.0f, 0.0f, 0.0f,
                static_cast<mi::Float32>(volume_size.x),
                static_cast<mi::Float32>(volume_size.y),
                static_cast<mi::Float32>(volume_size.z));
            scene_edit->set_clipped_bounding_box(global_roi);
            scene_edit->set_transform_matrix(transform);
 
            // Create a camera and set the camera parameters to see the whole volume data.
            mi::base::Handle< nv::index::IPerspective_camera > cam(
                scene_edit->create_camera<nv::index::IPerspective_camera>());
            check_success(cam.is_valid_interface());
 
            const mi::math::Vector< mi::Float32, 3 > from(-6.0f, 35.0f,   7.0f);
            const mi::math::Vector< mi::Float32, 3 > to  ( 9.0f, 14.f,  -11.0f);
            const mi::math::Vector< mi::Float32, 3 > up  ( 0.0f, -0.10f,  1.0f);
            mi::math::Vector<mi::Float32, 3> viewdir = to - from;
            viewdir.normalize();
 
            cam->set(from, viewdir, up);
            cam->set_aperture(0.033f);
            cam->set_aspect(1.0f);
            cam->set_focal(0.03f);
            cam->set_clip_min(2.0f);
            cam->set_clip_max(400.0f);
 
            const mi::neuraylib::Tag camera_tag = dice_transaction->store(cam.get());
            check_success(camera_tag.is_valid());
 
            scene_edit->set_camera(camera_tag);
 
            const mi::math::Vector<mi::Uint32, 2> canvas_resolution(1024, 1024);
            m_image_file_canvas->set_resolution(canvas_resolution);
        }
        dice_transaction->commit();
    }
    
    // The following block invokes the example code/functionality:
    {
        INFO_LOG << "Render the initial sparse 3D volume ...";
        mi::Sint32 frame_idx = 0;
        {
            const std::string outfname = get_output_file_name(m_outfname, frame_idx);        
            ++frame_idx;
            render_frame(outfname);
        }
 
        // Applying operations to the volume now ...
        INFO_LOG << "Analyzing the sparse volume data ...";
        {
            mi::base::Handle<mi::neuraylib::IDice_transaction> dice_transaction(create_transaction());
            check_success(dice_transaction.is_valid_interface());
            {
                mi::Float32 value = analyze_sparse_volume_data(dice_transaction.get());
                INFO_LOG << "voxel_format: " << m_voxel_format << ", unittest: " << m_is_unittest << ", generated value: " << value;
 
                if (m_voxel_format == "uint8")
                {
                    if (m_is_unittest)
                    {
                        check_success(fabs(value - 225.47f) < (255.0f/1000.0f)); // (255.0f/1000.0f) 0.1%
                    }
                    else
                    {
                        check_success(fabs(value - 237.931f) < (255.0f/1000.0f)); // (255.0f/1000.0f) 0.1%
                    }
                }
                else if (m_voxel_format == "rgba8")
                {
                    if (m_is_unittest)
                    {
                        check_success(fabs(value - 126.25) < (255.0f/1000.0f)); // (255.0f/1000.0f) 0.1%
                    }
                    else
                    {
                        check_success(fabs(value - 50.625) < (255.0f/1000.0f)); // (255.0f/1000.0f) 0.1%
                    }
                }
                else if (m_voxel_format == "sint16")
                {
                    if (m_is_unittest)
                    {
                        check_success(fabs(value - 29044.3f) < (65535.0f/1000.0f)); // (65535.0f/1000.0f) 0.1%
                    }
                    else
                    {
                        check_success(fabs(value - 30577.9f) < (65535.0f/1000.0f)); // (65535.0f/1000.0f) 0.1%
                    }
                }
                else if (m_voxel_format == "float32")        
                {
                    if (m_is_unittest)
                    {
                        check_success(fabs(value - 0.886378f) < (1.0f/1000.0f)); // (1.0f/1000.0f) 0.1%
                    }
                    else
                    {
                        check_success(fabs(value - 0.935178) < (1.0f/1000.0f)); // (1.0f/1000.0f) 0.1%
                    }
                }
                else
                {
                    ERROR_LOG << "Unknown voxel format: " << m_voxel_format;
                }
            }
            dice_transaction->commit();
        }
 
        INFO_LOG << "Editing the sparse volume data ...";
        {
            mi::base::Handle<mi::neuraylib::IDice_transaction> dice_transaction(create_transaction());
            check_success(dice_transaction.is_valid_interface());
            {
                edit_sparse_volume_data(dice_transaction.get());
            }
            dice_transaction->commit();
        }
 
        INFO_LOG << "Render the edited sparse 3D volume ...";
        {
            const std::string outfname = get_output_file_name(m_outfname, frame_idx);        
            ++frame_idx;
            render_frame(outfname);
        }
 
        INFO_LOG << "Analyzing the sparse volume data after editing ...";
        {
            mi::base::Handle<mi::neuraylib::IDice_transaction> dice_transaction(create_transaction());
            check_success(dice_transaction.is_valid_interface());
            {
                mi::Float32 value = analyze_sparse_volume_data(dice_transaction.get());
                // Set all values to 42.0
                check_success(value == 42.0f);
            }
            dice_transaction->commit();
        }
 
        INFO_LOG << "Exporting subset of the sparse volume data ...";
        {
            mi::base::Handle<mi::neuraylib::IDice_transaction> dice_transaction(create_transaction());
            check_success(dice_transaction.is_valid_interface());
            {
                mi::Float32 value = export_sparse_volume_data(dice_transaction.get());
        
                INFO_LOG << "voxel_format: " << m_voxel_format << ", unittest: " << m_is_unittest << ", export value: " << value;
 
                if (m_voxel_format == "uint8")
                {
                    if (m_is_unittest)
                    {
                        check_success(fabs(value - 165.244f) < (255.0f/1000.0f)); // (255.0f/1000.0f) 0.1%
                    }
                    else
                    {
                        check_success(fabs(value - 171.237f) < (255.0f/1000.0f)); // (255.0f/1000.0f) 0.1%
                    }
                }
                else if (m_voxel_format == "rgba8")
                {
                    if (m_is_unittest)
                    {
                        check_success(fabs(value - 118.402f) < (255.0f/1000.0f)); // (255.0f/1000.0f) 0.1%
                    }
                    else
                    {
                        check_success(fabs(value - 2.40677f) < (255.0f/1000.0f)); // (255.0f/1000.0f) 0.1%
                    }
                }
                else if (m_voxel_format == "sint16")
                {
                    if (m_is_unittest)
                    {
                        check_success(fabs(value - 19539.6f) < (65535.0f/1000.0f)); // (65535.0f/1000.0f) 0.1%
                    }
                    else
                    {
                        check_success(fabs(value - 20579.5f) < (65535.0f/1000.0f)); // (65535.0f/1000.0f) 0.1%
                    }
                }
                else if (m_voxel_format == "float32")        
                {
                    if (m_is_unittest)
                    {
                        check_success(fabs(value - 13.6316f) < (1.0f/1000.0f)); // (1.0f/1000.0f) 0.1%
                    }
                    else
                    {
                        check_success(fabs(value - 11.4886f) < (1.0f/1000.0f)); // (1.0f/1000.0f) 0.1%
                    }
                }
                else
                {
                    ERROR_LOG << "Unknown voxel format: " << m_voxel_format;
                }
            }
            dice_transaction->commit();
        }
    }
 
    return 0;
}
 
//----------------------------------------------------------------------
bool Distributed_sparse_volume_data::evaluate_options(nv::index::app::String_dict& sdict)
{
    const std::string com_name = sdict.get("command:", "<unknown_command>");
    m_is_unittest = nv::index::app::get_bool(sdict.get("unittest", "false"));
    
    if (m_is_unittest)
    {
        if (nv::index::app::get_bool(sdict.get("is_call_from_test", "false")))
        {
            sdict.insert("is_dump_comparison_image_when_failed", "0");
        }
        sdict.insert("dice::verbose", "2");
        sdict.insert("outfname", "");
    }
 
    m_outfname     = sdict.get("outfname");
    m_voxel_format = sdict.get("voxel_format");
 
    info_cout(std::string("Running ") + com_name, sdict);
 
    // print help and exit if -h
    if (sdict.is_defined("h"))
    {
        std::cout
            << "info: Usage: " << com_name <<" [option]\n"
            << "Option: [-h]\n"
            << "            print this message\n"
 
            << "        [-dice::network::multicast_address address]\n"
            << "            set multicast address. (default: ["
            << sdict.get("dice::network::multicast_address") + "])\n"
 
            << "        [-dice::network::cluster_interface]\n"
            << "            set cluster interface. (default: ["
            << sdict.get("dice::network::cluster_interface") + "])\n"
 
            << "        [-voxel_format VOXEL_FORMAT]\n"
            << "            the voxel format. 'uint8', 'rgba8', 'sint16', 'float32' \n"
            << "            (default: [" << m_voxel_format << "])\n"
            
            // Note: subcube_size is [30 30 30], the generator shows
            // multiple same generate bounds. Because that generate
            // bounds has a subcube. These subcubes are shared in a
            // brick. Thus, they show multiple times.
            << "        [-unittest bool]\n"
            << "            when true, unit test mode (create smaller volume). Also small subcube_size."
            << sdict.get("unittest") + "])\n"
 
            << std::endl;
        exit(1);
    }
 
    return true;
}
 
//----------------------------------------------------------------------
mi::Size Distributed_sparse_volume_data::calc_offset(const mi::math::Vector<mi::Sint32, 3>& p, const mi::math::Vector<mi::Uint32, 3>& s, mi::Uint32 b) const
{
    const mi::Size o =   static_cast<mi::Size>(p.x + b)
                       + static_cast<mi::Size>(p.y + b) * s.x
                       + static_cast<mi::Size>(p.z + b) * s.x * s.y;
    return o;
} 
 
//----------------------------------------------------------------------
mi::neuraylib::Tag Distributed_sparse_volume_data::create_synthetic_volume(
    const nv::index::ISession*             session,
    const mi::math::Vector<mi::Uint32, 3>& volume_size,
    mi::neuraylib::IDice_transaction*      dice_transaction) const
{
    check_success(dice_transaction != 0);
    check_success(volume_size.x > 0 && volume_size.y > 0 && volume_size.z > 0);
 
    const mi::math::Bbox<mi::Uint32, 3> volume_bbox(mi::math::Vector<mi::Uint32, 3>(0), volume_size);
 
    // A synthetic volume generator relies on the data import functionality of NVIDIA IndeX. Instead of reading data from disk,
    // the data is created on the fly.
    // sparse volume creation parameter
    nv::index::app::String_dict sparse_volume_opt;
    sparse_volume_opt.insert("args::type",     "sparse_volume");
    sparse_volume_opt.insert("args::importer", "nv::index::plugin::base_importer.Sparse_volume_generator_synthetic");
    {
        std::stringstream sstr;
        sstr << "0 0 0 " << volume_size.x << " " << volume_size.y << " " << volume_size.z;
        sparse_volume_opt.insert("args::bbox", sstr.str());
    }
    sparse_volume_opt.insert("args::voxel_format",                 m_voxel_format);
    sparse_volume_opt.insert("args::synthetic_type",               "perlin_noise");
    sparse_volume_opt.insert("args::parameter::cube_unit",         "1024");
    sparse_volume_opt.insert("args::parameter::time",              "0");
    sparse_volume_opt.insert("args::parameter::terms",             "2");
    sparse_volume_opt.insert("args::parameter::turbulence_weight", "1 1 1 1");
    sparse_volume_opt.insert("args::parameter::abs_noise",         "false");
    sparse_volume_opt.insert("args::parameter::ridged",            "true");
    nv::index::IDistributed_data_import_callback* generator = 
        get_importer_from_application_layer(
            get_application_layer_interface(),
            "nv::index::plugin::base_importer.Sparse_volume_generator_synthetic",
            sparse_volume_opt);
                
    // Create the volume scene element using the above importer and parameters and the scene (that is part of the session).
    mi::base::Handle<nv::index::IScene> scene(dice_transaction->edit<nv::index::IScene>(session->get_scene()));
    check_success(scene.is_valid_interface());
 
    mi::math::Matrix<mi::Float32, 4, 4>    transform_mat(1.0f); // Identity matrix
    const bool                             is_rendering_enabled = true;
    const mi::math::Bbox<mi::Float32, 3>   ijk_bbox(volume_bbox);
    mi::base::Handle<nv::index::ISparse_volume_scene_element> svol_scene_element(
        scene->create_sparse_volume(ijk_bbox, transform_mat, generator, dice_transaction));
    check_success(svol_scene_element.is_valid_interface());
    svol_scene_element->set_enabled(is_rendering_enabled);
 
    if(svol_scene_element.is_valid_interface())
    {
        const mi::neuraylib::Tag svol_scene_element_tag = dice_transaction->store_for_reference_counting(svol_scene_element.get());
        check_success(svol_scene_element_tag.is_valid());
 
        // Create static group node for large data and append the volume
        mi::base::Handle<nv::index::IStatic_scene_group> static_group(scene->create_scene_group<nv::index::IStatic_scene_group>());
        check_success(static_group.is_valid_interface());
        {
            // Add a sparse_volume_render_properties to the scene.
            mi::base::Handle<nv::index::ISparse_volume_rendering_properties> sparse_render_prop(
                scene->create_attribute<nv::index::ISparse_volume_rendering_properties>());
            sparse_render_prop->set_filter_mode(nv::index::SPARSE_VOLUME_FILTER_NEAREST);
            sparse_render_prop->set_sampling_distance(             1.0);
            sparse_render_prop->set_reference_sampling_distance(   1.0);
            sparse_render_prop->set_voxel_offsets(                 mi::math::Vector<mi::Float32, 3>(0.0f, 0.0f, 0.0f));
            sparse_render_prop->set_preintegrated_volume_rendering(false);
            sparse_render_prop->set_lod_rendering_enabled(         false);
            sparse_render_prop->set_lod_pixel_threshold(           2.0);
            sparse_render_prop->set_debug_visualization_option(    0);
            const mi::neuraylib::Tag sparse_render_prop_tag
                = dice_transaction->store_for_reference_counting(sparse_render_prop.get());
            check_success(sparse_render_prop_tag.is_valid());
            static_group->append(sparse_render_prop_tag, dice_transaction);
            INFO_LOG << "Created a sparse_render_prop_tag: tag = " << sparse_render_prop_tag;
 
            // Add a colormap to the scene.
            const mi::Sint32 colormap_entry_id = 1; // same as demo application's colormap file 1
            const mi::neuraylib::Tag colormap_tag = 
                create_colormap(colormap_entry_id, scene.get(), dice_transaction);
            check_success(colormap_tag.is_valid());
            static_group->append(colormap_tag, dice_transaction);
        }
 
        static_group->append(svol_scene_element_tag, dice_transaction);
        const mi::neuraylib::Tag static_group_tag = dice_transaction->store_for_reference_counting(static_group.get());
        check_success(static_group_tag.is_valid());
 
        // Add the new volume to the hierarchical scene description
        scene->append(static_group_tag, dice_transaction);
 
        return svol_scene_element_tag;
    }
 
    return mi::neuraylib::NULL_TAG;
}
 
//----------------------------------------------------------------------
std::vector<mi::Uint32> Distributed_sparse_volume_data::evaluate_sparse_volume_data_locality(
    const nv::index::IDistributed_data_locality* svol_data_locality,
    const mi::math::Bbox<mi::Sint32, 3>&         query_bound,
    const mi::neuraylib::Tag&                    scene_element_tag,
    const std::string&                           scene_element_type) const
{
    // Determine all host in the cluster that store part of the distributed data (here: sparse volume).
    std::vector<mi::Uint32> cluster_host_ids;
    std::ostringstream hosts;
    std::ostringstream locality_report;
    for(mi::Uint32 i = 0; i < svol_data_locality->get_nb_cluster_nodes(); ++i)
    {
        // A host id=0 indicates that an issue occurred, e.g., no data has been loaded or no distribution scheme has been set up.
        check_success(svol_data_locality->get_cluster_node(i) != 0);
 
        const mi::Uint32 host_id = svol_data_locality->get_cluster_node(i);
        cluster_host_ids.push_back(host_id);
 
        // The remaining part is just for reporting/logging.
        hosts << host_id << " ";
 
        const mi::Size nb_subregions = svol_data_locality->get_nb_bounding_box(host_id);
        locality_report << "Host " << host_id << " stores part of the distributed data in the following " << nb_subregions << " regions:\n";
        for(mi::Uint32 j = 0; j < nb_subregions; ++j)
        {
            const mi::math::Bbox<mi::Sint32, 3> bbox = svol_data_locality->get_bounding_box(host_id, j);
            locality_report << "  " << (j+1) << ")\t" << bbox;
            if(j < nb_subregions-1)
            {
                locality_report << "\n";
            }
        }
    }
    INFO_LOG << "\n"
             << "Data locality for a " << scene_element_type
             << " with tag id "        << scene_element_tag.id
             << " and query region "   << query_bound << "\n"
             << "The distributed data is located on the following hosts (ids): [ " << hosts.str() << "]." << "\n"
             << locality_report.str()
             << "\n";
 
    return cluster_host_ids;
}
 
//----------------------------------------------------------------------
void Distributed_sparse_volume_data::get_brick_clamped_bbox(
    const nv::index::ISparse_volume_subset_data_descriptor* svol_data_subset_desc,
    const mi::Uint32                                        brick_idx,
    const mi::math::Vector<mi::Sint32, 3>&                  brick_position,
    const mi::math::Bbox<mi::Sint32, 3>&                    query_bbox_s32,
    mi::math::Bbox<mi::Sint32, 3>&                          out_brick_box_subdata_clamped,
    mi::math::Bbox<mi::Sint32, 3>&                          out_brick_box_clamped) const
{
    check_success(svol_data_subset_desc != 0);
 
    const mi::math::Vector<mi::Sint32, 3> query_bbox_ext_s32 = query_bbox_s32.extent();
 
    const mi::math::Vector<mi::Uint32,3> svol_data_brick_dim = svol_data_subset_desc->get_subset_data_brick_dimensions();
    const mi::Uint32 svol_data_brick_border                  = svol_data_subset_desc->get_subset_data_brick_shared_border_size();
 
    const mi::math::Vector<mi::Sint32, 3> brick_pos_vol           = mi::math::Vector<mi::Sint32, 3>(brick_position) + mi::math::Vector<mi::Sint32, 3>(svol_data_brick_border);
 
    const mi::math::Bbox<mi::Sint32, 3> brick_box_global          = mi::math::Bbox<mi::Sint32, 3>(brick_pos_vol,
                                                                                                  brick_pos_vol + mi::math::Vector<mi::Sint32, 3>(svol_data_brick_dim) 
                                                                                                  - 2 * mi::math::Vector<mi::Sint32, 3>(svol_data_brick_border));
    const mi::math::Bbox<mi::Sint32, 3> brick_box_subdata         = mi::math::Bbox<mi::Sint32, 3>(brick_box_global.min - query_bbox_s32.min,
                                                                                                  brick_box_global.max - query_bbox_s32.min);
    // max clamp with [[0,0,0], ext.size()]
    const mi::math::Bbox<mi::Sint32, 3> brick_box_subdata_clamped = mi::math::Bbox<mi::Sint32, 3>(mi::math::clamp(brick_box_subdata.min, mi::math::Vector<mi::Sint32, 3>(0u), query_bbox_ext_s32),
                                                                                                  mi::math::clamp(brick_box_subdata.max, mi::math::Vector<mi::Sint32, 3>(0u), query_bbox_ext_s32));
    const mi::math::Bbox<mi::Sint32, 3> brick_box_global_clamped  = mi::math::Bbox<mi::Sint32, 3>(brick_box_subdata_clamped.min + query_bbox_s32.min,
                                                                                                  brick_box_subdata_clamped.max + query_bbox_s32.min);
    const mi::math::Bbox<mi::Sint32, 3> brick_box_clamped         = mi::math::Bbox<mi::Sint32, 3>(brick_box_global_clamped.min - brick_pos_vol,
                                                                                                  brick_box_global_clamped.max - brick_pos_vol);
 
    out_brick_box_subdata_clamped = brick_box_subdata_clamped;
    out_brick_box_clamped         = brick_box_clamped;
}
 
//----------------------------------------------------------------------
mi::Float32 Distributed_sparse_volume_data::analyze_sparse_volume_data(
    mi::neuraylib::IDice_transaction* dice_transaction) const
{
    mi::base::Handle<const nv::index::ISession> the_session(dice_transaction->access<nv::index::ISession>(m_session_tag));
    check_success(the_session.is_valid_interface());
 
    mi::base::Handle<const nv::index::ISparse_volume_scene_element> sparse_volume(dice_transaction->access<nv::index::ISparse_volume_scene_element>(m_sparse_volume_tag));
    check_success(sparse_volume.is_valid_interface());
 
    const mi::math::Vector<mi::Sint32, 2> trace(50, 50);
    const mi::math::Bbox<mi::Sint32, 3> query_bbox_s32(
        trace.x, trace.y, 0,
        trace.x + 1, trace.y + 1, static_cast<mi::Uint32>(sparse_volume->get_bounding_box().max.z));
    const mi::math::Bbox<mi::Float32, 3> query_bbox_f32(query_bbox_s32);
 
    // Access the distribution scheme
    const mi::neuraylib::Tag dist_layout_tag = the_session->get_distribution_layout();
    check_success(dist_layout_tag.is_valid());
 
    mi::base::Handle<const nv::index::IData_distribution> distribution_layout(dice_transaction->access<nv::index::IData_distribution>(dist_layout_tag));
    check_success(distribution_layout.is_valid_interface());
 
    // Find out on which hosts the data is located and print this information
    mi::base::Handle<nv::index::IDistributed_data_locality> svol_data_locality(
        distribution_layout->get_data_locality<nv::index::ISparse_volume_scene_element>(m_sparse_volume_tag, query_bbox_f32, dice_transaction));
    check_success(svol_data_locality.is_valid_interface());
 
    // Determine all host in the cluster that store part of the distributed data.
    std::vector<mi::Uint32> cluster_host_ids = evaluate_sparse_volume_data_locality(svol_data_locality.get(), query_bbox_s32, m_sparse_volume_tag, sparse_volume->get_class_name());
 
    // Create the access factory
    const mi::neuraylib::Tag data_access_tag = the_session->get_data_access_factory();
    check_success(data_access_tag.is_valid());
 
    mi::base::Handle<const nv::index::IDistributed_data_access_factory> svol_access_factory(
        dice_transaction->access<nv::index::IDistributed_data_access_factory>(data_access_tag));
    check_success(svol_access_factory.is_valid_interface());
 
    mi::base::Handle<nv::index::IDistributed_data_access> svol_data_access(
        svol_access_factory->create_distributed_data_access<nv::index::ISparse_volume_scene_element>(m_sparse_volume_tag));
    check_success(svol_data_access.is_valid_interface());
 
    // Now retrieve the data
    check_success(svol_data_access->access(query_bbox_f32, dice_transaction) >= 0);
 
    const mi::math::Bbox<mi::Float32, 3> effective_bbox_f32 = svol_data_access->get_bounding_box();
    check_success(effective_bbox_f32 == query_bbox_f32);
 
    mi::Float32 avg = -1.0f;        
 
    mi::base::Handle<const nv::index::IDistributed_data_subset>                 data_subset(svol_data_access->get_distributed_data_subset());
    mi::base::Handle<const nv::index::ISparse_volume_subset>                    svol_data_subset(data_subset->get_interface<const nv::index::ISparse_volume_subset>());
    check_success(svol_data_subset.is_valid_interface());
 
    mi::base::Handle<const nv::index::ISparse_volume_attribute_set_descriptor>  svol_data_attrib_desc(svol_data_subset->get_attribute_set_descriptor());
    mi::base::Handle<const nv::index::ISparse_volume_subset_data_descriptor>    svol_data_subset_desc(svol_data_subset->get_subset_data_descriptor());
 
    const mi::Uint32 svol_attrib_index_0 = 0u;
    nv::index::ISparse_volume_attribute_set_descriptor::Attribute_parameters svol_attrib_param_0;
    check_success(svol_data_attrib_desc->get_attribute_parameters(svol_attrib_index_0, svol_attrib_param_0));
 
    const nv::index::Sparse_volume_voxel_format svol_voxel_fmt      = svol_attrib_param_0.format;
    const mi::Sint32                            svol_voxel_fmt_size = nv::index::get_sizeof(svol_voxel_fmt);
 
    const mi::math::Vector<mi::Sint32, 3> query_bbox_ext_s32 = query_bbox_s32.extent(); // size (= query_bbox_s32.max() - query_bbox_s32.min())
 
    const mi::Size svol_query_buffer_size = 
        static_cast<mi::Size>(query_bbox_ext_s32.x) *
        static_cast<mi::Size>(query_bbox_ext_s32.y) *
        static_cast<mi::Size>(query_bbox_ext_s32.z) *
        svol_voxel_fmt_size;
 
    mi::Uint8* svol_query_buffer = new mi::Uint8[svol_query_buffer_size];
 
    const mi::math::Vector<mi::Uint32,3> svol_data_brick_dim = svol_data_subset_desc->get_subset_data_brick_dimensions();
    const mi::Uint32 svol_data_brick_border                  = svol_data_subset_desc->get_subset_data_brick_shared_border_size();
    const mi::Uint32 svol_subset_nb_bricks                   = svol_data_subset_desc->get_subset_number_of_data_bricks();
    for (mi::Uint32 b = 0u; b < svol_subset_nb_bricks; ++b)
    {
        const nv::index::ISparse_volume_subset_data_descriptor::Data_brick_info brick_info     = svol_data_subset_desc->get_subset_data_brick_info(b);
        const nv::index::ISparse_volume_subset::Data_brick_buffer_info          brick_data_nfo = svol_data_subset->access_brick_data_buffer(b, svol_attrib_index_0);
 
        const mi::Uint8* svol_brick_data_raw = reinterpret_cast<mi::Uint8*>(brick_data_nfo.data);
        if (svol_brick_data_raw == NULL) 
        {
            ERROR_LOG << "error accessing brick data pointer "
                      << "(brick_idx: "    << b
                      << ", brick_level: " << brick_info.brick_lod_level << ").";
            delete [] svol_query_buffer;
            check_success(false);
        }
 
        mi::math::Bbox<mi::Sint32, 3> brick_box_subdata_clamped;
        mi::math::Bbox<mi::Sint32, 3> brick_box_clamped;
        get_brick_clamped_bbox(svol_data_subset_desc.get(), b, brick_info.brick_position, query_bbox_s32, brick_box_subdata_clamped, brick_box_clamped);
 
        for (mi::Uint32 z = 0u; z < static_cast<mi::Uint32>(brick_box_subdata_clamped.extent().z); ++z)
        {
            for (mi::Uint32 y = 0u; y < static_cast<mi::Uint32>(brick_box_subdata_clamped.extent().y); ++y) 
            {
                const mi::math::Vector<mi::Sint32, 3> line_pos_dst =
                    mi::math::Vector<mi::Sint32, 3>(brick_box_subdata_clamped.min.x,
                                                    brick_box_subdata_clamped.min.y + y,
                                                    brick_box_subdata_clamped.min.z + z);
 
                const mi::Size dst_off = calc_offset(line_pos_dst, mi::math::Vector<mi::Uint32, 3>(query_bbox_ext_s32), 0u);
                
                const mi::math::Vector<mi::Sint32, 3> line_pos_src = 
                    mi::math::Vector<mi::Sint32, 3>(brick_box_clamped.min.x,
                                                    brick_box_clamped.min.y + y,
                                                    brick_box_clamped.min.z + z);
                const mi::Size src_off =  calc_offset(line_pos_src, svol_data_brick_dim, svol_data_brick_border);
 
                const mi::Size line_size = static_cast<mi::Size>(brick_box_subdata_clamped.extent().x) * svol_voxel_fmt_size;
 
                memcpy(svol_query_buffer   + dst_off * svol_voxel_fmt_size,
                       svol_brick_data_raw + src_off * svol_voxel_fmt_size,
                       line_size);
            }
        }
    }
 
    if(svol_voxel_fmt == nv::index::SPARSE_VOLUME_VOXEL_FORMAT_UINT8)
    {
        // Average the contents of the trace
        const mi::Uint8* voxel_data = svol_query_buffer;
 
        mi::Sint64 sum = 0;
        mi::Sint64 count = static_cast<mi::Sint64>(effective_bbox_f32.max.z - effective_bbox_f32.min.z);
        for (mi::Sint64 k = 0; k < count; ++k)
        {
            sum += static_cast<mi::Sint64>(voxel_data[k]);
        }
 
        avg = static_cast<mi::Float32>(sum) / static_cast<mi::Float32>(count);
        INFO_LOG << "Tracing 8-bit volume: [" << trace.x << ", " << trace.y
                 << ", " << query_bbox_s32.min.z << ":" << query_bbox_s32.max.z - 1 << "]: "
                 << "count=" << count << ", sum=" << sum << ", avg=" << avg;
    }
    else if(svol_voxel_fmt == nv::index::SPARSE_VOLUME_VOXEL_FORMAT_UINT8_4)
    {
        // Average the contents of the trace
        const mi::math::Vector_struct<mi::Uint8, 4>* voxel_data = 
            reinterpret_cast< mi::math::Vector_struct<mi::Uint8, 4>*>(svol_query_buffer);
 
        mi::Sint64 sum = 0;
        mi::Sint64 count = static_cast<mi::Sint64>(effective_bbox_f32.max.z - effective_bbox_f32.min.z);
        for (mi::Sint64 k = 0; k < count; ++k)
        {
            mi::math::Vector<mi::Uint8, 4> voxel_v(voxel_data[k]);
            mi::math::Vector<mi::Float32, 4> voxel_f32_4(voxel_v);
            sum += static_cast<mi::Sint64>(((voxel_f32_4.x + voxel_f32_4.y + voxel_f32_4.z) / 3.0f));
        }
 
        avg = static_cast<mi::Float32>(sum) / static_cast<mi::Float32>(count);
        INFO_LOG << "Tracing rgba8 volume: [" << trace.x << ", " << trace.y
                 << ", " << query_bbox_s32.min.z << ":" << query_bbox_s32.max.z - 1 << "]: "
                 << "count=" << count << ", sum=" << sum << ", avg=" << avg;
    }
    else if(svol_voxel_fmt == nv::index::SPARSE_VOLUME_VOXEL_FORMAT_SINT16)
    {
        // Average the contents of the trace
        const mi::Sint16* voxel_data = reinterpret_cast<mi::Sint16*>(svol_query_buffer);
 
        mi::Sint64 sum = 0;
        mi::Sint64 count = static_cast<mi::Sint64>(effective_bbox_f32.max.z - effective_bbox_f32.min.z);
        for (mi::Sint64 k = 0; k < count; ++k)
        {
            sum += voxel_data[k];
        }
 
        avg = static_cast<mi::Float32>(sum) / static_cast<mi::Float32>(count);
        INFO_LOG << "Tracing sint16 volume: [" << trace.x << ", " << trace.y
                 << ", " << query_bbox_s32.min.z << ":" << query_bbox_s32.max.z - 1 << "]: "
                 << "count=" << count << ", sum=" << sum << ", avg=" << avg;
    }
    else if(svol_voxel_fmt == nv::index::SPARSE_VOLUME_VOXEL_FORMAT_FLOAT32)
    {
        // Average the contents of the trace
        const mi::Float32* voxel_data = reinterpret_cast<mi::Float32*>(svol_query_buffer);
 
        mi::Float32 sum = 0;
        mi::Sint64 count = static_cast<mi::Sint64>(effective_bbox_f32.max.z - effective_bbox_f32.min.z);
        for (mi::Sint64 k = 0; k < count; ++k)
        {
            sum += voxel_data[k];
        }
 
        avg = static_cast<mi::Float32>(sum) / static_cast<mi::Float32>(count);
        INFO_LOG << "Tracing uint16 volume: [" << trace.x << ", " << trace.y
                 << ", " << query_bbox_s32.min.z << ":" << query_bbox_s32.max.z - 1 << "]: "
                 << "count=" << count << ", sum=" << sum << ", avg=" << avg;
    }
    else
    {
        ERROR_LOG << "Analyze volume data failed: data access on not-known volume type.";
    }
 
    return avg;
}
 
//----------------------------------------------------------------------
void Distributed_sparse_volume_data::edit_sparse_volume_data(
    mi::neuraylib::IDice_transaction* dice_transaction) const
{
    mi::base::Handle<const nv::index::ISession> the_session(
        dice_transaction->access<nv::index::ISession>(m_session_tag));
    check_success(the_session.is_valid_interface());
 
    mi::base::Handle<const nv::index::ISparse_volume_scene_element> sparse_volume(
        dice_transaction->access<nv::index::ISparse_volume_scene_element>(m_sparse_volume_tag));
    check_success(sparse_volume.is_valid_interface());
 
    const mi::math::Vector<mi::Sint32, 2> trace(50, 50);
    const mi::math::Bbox<mi::Sint32, 3> query_bbox_s32(
        trace.x, trace.y, 0,
        trace.x + 1, trace.y + 1, static_cast<mi::Sint32>(sparse_volume->get_bounding_box().max.z));
    INFO_LOG << "The sparse volume will be edited inside the following 3D bounding box: " << query_bbox_s32 << ".";
    const mi::math::Bbox<mi::Float32, 3> query_bbox_f32(query_bbox_s32);
 
    // Access the distribution scheme
    const mi::neuraylib::Tag dist_layout_tag = the_session->get_distribution_layout();
    check_success(dist_layout_tag.is_valid());
 
    mi::base::Handle<const nv::index::IData_distribution> distribution_layout(dice_transaction->access<nv::index::IData_distribution>(dist_layout_tag));
    check_success(distribution_layout.is_valid_interface());
 
    // Distribution layout
    mi::base::Handle<nv::index::IDistributed_data_locality> svol_data_locality(
        distribution_layout->get_data_locality<nv::index::ISparse_volume_scene_element>(m_sparse_volume_tag, query_bbox_f32, dice_transaction));
    check_success(svol_data_locality.is_valid_interface());
 
    // Determine all host in the cluster that store part of the distributed data (here: sparse volume).
    std::vector<mi::Uint32> cluster_host_ids = evaluate_sparse_volume_data_locality(
        svol_data_locality.get(), query_bbox_s32, m_sparse_volume_tag, sparse_volume->get_class_name());
 
    // Set up distributed algorithm and start the job
    const mi::Sint32 voxel_value   = 42;    // just some "arbitrary" number
 
    // Access an application layer component that provides some sample distributed jobs: 
    mi::base::Handle<nv::index::app::data_analysis_and_processing::IData_analysis_and_processing> processing(
        get_application_layer_interface()->get_api_component<nv::index::app::data_analysis_and_processing::IData_analysis_and_processing>());    
    check_success(processing.is_valid_interface());
    // Create a job that distributed to all nodes/GPUs and add edits the volume data.
    // For more details on how to implement the mandelbrot, please review the provided 
    // source that was shipped with the application layer component 'nv::index::app::data_analysis_and_processing::IData_analysis_and_processing'. 
    mi::base::Handle<nv::index::IDistributed_data_job> algo(processing->get_sample_tool_set()->create_sparse_volume_voxel_value_setting(
            m_sparse_volume_tag,
            voxel_value,
            query_bbox_s32));
    distribution_layout->create_scheduler()->execute(algo.get(), dice_transaction);
}
 
//----------------------------------------------------------------------
mi::Float32 Distributed_sparse_volume_data::export_sparse_volume_data(
    mi::neuraylib::IDice_transaction* dice_transaction) const
{
    mi::base::Handle<const nv::index::ISession> the_session(dice_transaction->access<nv::index::ISession>(m_session_tag));
    check_success(the_session.is_valid_interface());
 
    mi::base::Handle<const nv::index::ISparse_volume_scene_element> sparse_volume(dice_transaction->access<nv::index::ISparse_volume_scene_element>(m_sparse_volume_tag));
    check_success(sparse_volume.is_valid_interface());
 
    // Select what subset of the volume should be exported
    mi::math::Bbox<mi::Sint32, 3> query_bbox_s32(sparse_volume->get_bounding_box());
    query_bbox_s32.min += (query_bbox_s32.max - query_bbox_s32.min) / 4;
    query_bbox_s32.max -= (query_bbox_s32.max - query_bbox_s32.min) / 4;
    const mi::math::Bbox<mi::Float32, 3> query_bbox_f32(query_bbox_s32);
 
    // Access the distribution scheme
    const mi::neuraylib::Tag dist_layout_tag = the_session->get_distribution_layout();
    check_success(dist_layout_tag.is_valid());
 
    mi::base::Handle<const nv::index::IData_distribution> distribution_layout(dice_transaction->access<nv::index::IData_distribution>(dist_layout_tag));
    check_success(distribution_layout.is_valid_interface());
 
    // Find out on which hosts the data is located and print this information
    mi::base::Handle<nv::index::IDistributed_data_locality> svol_data_locality(
        distribution_layout->get_data_locality<nv::index::ISparse_volume_scene_element>(m_sparse_volume_tag, query_bbox_f32, dice_transaction));
    check_success(svol_data_locality.is_valid_interface());
 
    // Determine all host in the cluster that store part of the distributed data.
    std::vector<mi::Uint32> cluster_host_ids = evaluate_sparse_volume_data_locality(svol_data_locality.get(), query_bbox_s32, m_sparse_volume_tag, sparse_volume->get_class_name());
 
    // Create the access factory
    const mi::neuraylib::Tag data_access_tag = the_session->get_data_access_factory();
    check_success(data_access_tag.is_valid());
 
    mi::base::Handle<const nv::index::IDistributed_data_access_factory> svol_access_factory(
        dice_transaction->access<nv::index::IDistributed_data_access_factory>(data_access_tag));
    check_success(svol_access_factory.is_valid_interface());
 
    mi::base::Handle<nv::index::IDistributed_data_access> svol_data_access(
        svol_access_factory->create_distributed_data_access<nv::index::ISparse_volume_scene_element>(m_sparse_volume_tag));
    check_success(svol_data_access.is_valid_interface());
 
    // Now retrieve the data
    check_success(svol_data_access->access(query_bbox_f32, dice_transaction) >= 0);
 
    const mi::math::Bbox<mi::Float32, 3> effective_bbox_f32 = svol_data_access->get_bounding_box();
    check_success(effective_bbox_f32 == query_bbox_f32);
 
    mi::Float32 avg = -1.0f;        
 
    mi::base::Handle<const nv::index::IDistributed_data_subset>                 data_subset(svol_data_access->get_distributed_data_subset());
    mi::base::Handle<const nv::index::ISparse_volume_subset>                    svol_data_subset(data_subset->get_interface<const nv::index::ISparse_volume_subset>());
    check_success(svol_data_subset.is_valid_interface());
 
    mi::base::Handle<const nv::index::ISparse_volume_attribute_set_descriptor>  svol_data_attrib_desc(svol_data_subset->get_attribute_set_descriptor());
    mi::base::Handle<const nv::index::ISparse_volume_subset_data_descriptor>    svol_data_subset_desc(svol_data_subset->get_subset_data_descriptor());
 
    const mi::Uint32 svol_attrib_index_0 = 0u;
    nv::index::ISparse_volume_attribute_set_descriptor::Attribute_parameters svol_attrib_param_0;
    check_success(svol_data_attrib_desc->get_attribute_parameters(svol_attrib_index_0, svol_attrib_param_0));
 
    const nv::index::Sparse_volume_voxel_format svol_voxel_fmt      = svol_attrib_param_0.format;
    const mi::Sint32                            svol_voxel_fmt_size = nv::index::get_sizeof(svol_voxel_fmt);
 
    // const mi::math::Vector<mi::Sint32, 3> query_bbox_ext_s32 = query_bbox_s32.extent(); // size (= query_bbox_s32.max() - query_bbox_s32.min())
    const mi::math::Vector<mi::Uint32,3> svol_data_brick_dim = svol_data_subset_desc->get_subset_data_brick_dimensions();
    const mi::Uint32 svol_data_brick_border                  = svol_data_subset_desc->get_subset_data_brick_shared_border_size();
    const mi::Uint32 svol_subset_nb_bricks                   = svol_data_subset_desc->get_subset_number_of_data_bricks();
 
    mi::Sint64 sum       = 0;
    mi::Sint64 nb_voxels = 0;
 
    if(svol_voxel_fmt == nv::index::SPARSE_VOLUME_VOXEL_FORMAT_UINT8)
    {
        for (mi::Uint32 b = 0u; b < svol_subset_nb_bricks; ++b)
        {
            const nv::index::ISparse_volume_subset_data_descriptor::Data_brick_info brick_info     = svol_data_subset_desc->get_subset_data_brick_info(b);
            const nv::index::ISparse_volume_subset::Data_brick_buffer_info          brick_data_nfo = svol_data_subset->access_brick_data_buffer(b, svol_attrib_index_0);
            const mi::Uint8* svol_brick_data_raw = reinterpret_cast<mi::Uint8*>(brick_data_nfo.data);
            check_success (svol_brick_data_raw != 0);
 
            mi::math::Bbox<mi::Sint32, 3> brick_box_subdata_clamped;
            mi::math::Bbox<mi::Sint32, 3> brick_box_clamped;
            get_brick_clamped_bbox(svol_data_subset_desc.get(), b, brick_info.brick_position, query_bbox_s32, brick_box_subdata_clamped, brick_box_clamped);
            for (mi::Uint32 z = 0u; z < static_cast<mi::Uint32>(brick_box_subdata_clamped.extent().z); ++z)
            {
                for (mi::Uint32 y = 0u; y < static_cast<mi::Uint32>(brick_box_subdata_clamped.extent().y); ++y) 
                {
                    const mi::math::Vector<mi::Sint32, 3> line_pos_src = 
                        mi::math::Vector<mi::Sint32, 3>(brick_box_clamped.min.x,
                                                        brick_box_clamped.min.y + y,
                                                        brick_box_clamped.min.z + z);
                    const mi::Size src_off =  calc_offset(line_pos_src, svol_data_brick_dim, svol_data_brick_border);
 
                    // Average the contents with trace by trace
                    const mi::Uint8* voxel_data = svol_brick_data_raw + src_off * svol_voxel_fmt_size;
                    mi::Sint64 count = static_cast<mi::Sint64>(effective_bbox_f32.max.z - effective_bbox_f32.min.z);
                    for (mi::Sint64 k = 0; k < count; ++k)
                    {
                        sum += static_cast<mi::Sint64>(voxel_data[k]);
                    }
                    nb_voxels += count;
                }
            }
        }
        avg = static_cast<mi::Float32>(sum) / static_cast<mi::Float32>(nb_voxels);
        INFO_LOG << "Average voxel value in exported data: " << avg << " of " << nb_voxels;
    }
    else if(svol_voxel_fmt == nv::index::SPARSE_VOLUME_VOXEL_FORMAT_UINT8_4)
    {
        for (mi::Uint32 b = 0u; b < svol_subset_nb_bricks; ++b)
        {
            const nv::index::ISparse_volume_subset_data_descriptor::Data_brick_info brick_info     = svol_data_subset_desc->get_subset_data_brick_info(b);
            const nv::index::ISparse_volume_subset::Data_brick_buffer_info          brick_data_nfo = svol_data_subset->access_brick_data_buffer(b, svol_attrib_index_0);
            const mi::Uint8* svol_brick_data_raw = reinterpret_cast<mi::Uint8*>(brick_data_nfo.data);
            check_success (svol_brick_data_raw != 0);
 
            mi::math::Bbox<mi::Sint32, 3> brick_box_subdata_clamped;
            mi::math::Bbox<mi::Sint32, 3> brick_box_clamped;
            get_brick_clamped_bbox(svol_data_subset_desc.get(), b, brick_info.brick_position, query_bbox_s32, brick_box_subdata_clamped, brick_box_clamped);
            for (mi::Uint32 z = 0u; z < static_cast<mi::Uint32>(brick_box_subdata_clamped.extent().z); ++z)
            {
                for (mi::Uint32 y = 0u; y < static_cast<mi::Uint32>(brick_box_subdata_clamped.extent().y); ++y) 
                {
                    const mi::math::Vector<mi::Sint32, 3> line_pos_src = 
                        mi::math::Vector<mi::Sint32, 3>(brick_box_clamped.min.x,
                                                        brick_box_clamped.min.y + y,
                                                        brick_box_clamped.min.z + z);
                    const mi::Size src_off =  calc_offset(line_pos_src, svol_data_brick_dim, svol_data_brick_border);
 
                    // Average the contents with trace by trace
                    const mi::math::Vector_struct<mi::Uint8, 4>* voxel_data = 
                        reinterpret_cast<const  mi::math::Vector_struct<mi::Uint8, 4>* >(svol_brick_data_raw + src_off * svol_voxel_fmt_size);
                    mi::Sint64 count = static_cast<mi::Sint64>(effective_bbox_f32.max.z - effective_bbox_f32.min.z);
                    for (mi::Sint64 k = 0; k < count; ++k)
                    {
                        sum += (static_cast<mi::Sint64>(voxel_data[k].x) + 
                                static_cast<mi::Sint64>(voxel_data[k].y) + 
                                static_cast<mi::Sint64>(voxel_data[k].z)) / 3;
                    }
                    nb_voxels += count;
                }
            }
        }
        avg = static_cast<mi::Float32>(sum) / static_cast<mi::Float32>(nb_voxels);
        INFO_LOG << "Average voxel value in exported data: " << avg << " of " << nb_voxels;
    }
    else if(svol_voxel_fmt == nv::index::SPARSE_VOLUME_VOXEL_FORMAT_SINT16)
    {
        for (mi::Uint32 b = 0u; b < svol_subset_nb_bricks; ++b)
        {
            const nv::index::ISparse_volume_subset_data_descriptor::Data_brick_info brick_info     = svol_data_subset_desc->get_subset_data_brick_info(b);
            const nv::index::ISparse_volume_subset::Data_brick_buffer_info          brick_data_nfo = svol_data_subset->access_brick_data_buffer(b, svol_attrib_index_0);
            const mi::Uint8* svol_brick_data_raw = reinterpret_cast<mi::Uint8*>(brick_data_nfo.data);
            check_success (svol_brick_data_raw != 0);
 
            mi::math::Bbox<mi::Sint32, 3> brick_box_subdata_clamped;
            mi::math::Bbox<mi::Sint32, 3> brick_box_clamped;
            get_brick_clamped_bbox(svol_data_subset_desc.get(), b, brick_info.brick_position, query_bbox_s32, brick_box_subdata_clamped, brick_box_clamped);
            for (mi::Uint32 z = 0u; z < static_cast<mi::Uint32>(brick_box_subdata_clamped.extent().z); ++z)
            {
                for (mi::Uint32 y = 0u; y < static_cast<mi::Uint32>(brick_box_subdata_clamped.extent().y); ++y) 
                {
                    const mi::math::Vector<mi::Sint32, 3> line_pos_src = 
                        mi::math::Vector<mi::Sint32, 3>(brick_box_clamped.min.x,
                                                        brick_box_clamped.min.y + y,
                                                        brick_box_clamped.min.z + z);
                    const mi::Size src_off =  calc_offset(line_pos_src, svol_data_brick_dim, svol_data_brick_border);
 
                    // Average the contents with trace by trace
                    const mi::Sint16* voxel_data = reinterpret_cast<const mi::Sint16*>(svol_brick_data_raw + src_off * svol_voxel_fmt_size);
                    mi::Sint64 count = static_cast<mi::Sint64>(effective_bbox_f32.max.z - effective_bbox_f32.min.z);
                    for (mi::Sint64 k = 0; k < count; ++k)
                    {
                        sum += voxel_data[k];
                    }
                    nb_voxels += count;
                }
            }
        }
        avg = static_cast<mi::Float32>(sum) / static_cast<mi::Float32>(nb_voxels);
        INFO_LOG << "Average voxel value in exported data: " << avg << " of " << nb_voxels;
    }
    else if(svol_voxel_fmt == nv::index::SPARSE_VOLUME_VOXEL_FORMAT_FLOAT32)
    {
        for (mi::Uint32 b = 0u; b < svol_subset_nb_bricks; ++b)
        {
            const nv::index::ISparse_volume_subset_data_descriptor::Data_brick_info brick_info     = svol_data_subset_desc->get_subset_data_brick_info(b);
            const nv::index::ISparse_volume_subset::Data_brick_buffer_info          brick_data_nfo = svol_data_subset->access_brick_data_buffer(b, svol_attrib_index_0);
            const mi::Uint8* svol_brick_data_raw = reinterpret_cast<mi::Uint8*>(brick_data_nfo.data);
            check_success (svol_brick_data_raw != 0);
 
            mi::math::Bbox<mi::Sint32, 3> brick_box_subdata_clamped;
            mi::math::Bbox<mi::Sint32, 3> brick_box_clamped;
            get_brick_clamped_bbox(svol_data_subset_desc.get(), b, brick_info.brick_position, query_bbox_s32, brick_box_subdata_clamped, brick_box_clamped);
            for (mi::Uint32 z = 0u; z < static_cast<mi::Uint32>(brick_box_subdata_clamped.extent().z); ++z)
            {
                for (mi::Uint32 y = 0u; y < static_cast<mi::Uint32>(brick_box_subdata_clamped.extent().y); ++y) 
                {
                    const mi::math::Vector<mi::Sint32, 3> line_pos_src = 
                        mi::math::Vector<mi::Sint32, 3>(brick_box_clamped.min.x,
                                                        brick_box_clamped.min.y + y,
                                                        brick_box_clamped.min.z + z);
                    const mi::Size src_off =  calc_offset(line_pos_src, svol_data_brick_dim, svol_data_brick_border);
 
                    // Average the contents with trace by trace
                    const mi::Float32* voxel_data = 
                        reinterpret_cast<const mi::Float32*>(svol_brick_data_raw + src_off * svol_voxel_fmt_size);
                    mi::Sint64 count = static_cast<mi::Sint64>(effective_bbox_f32.max.z - effective_bbox_f32.min.z);
                    for (mi::Sint64 k = 0; k < count; ++k)
                    {
                        sum += static_cast<mi::Sint64>(voxel_data[k]);
                    }
                    nb_voxels += count;
                }
            }
        }
        avg = static_cast<mi::Float32>(sum) / static_cast<mi::Float32>(nb_voxels);
        INFO_LOG << "Average voxel value in exported data: " << avg << " of " << nb_voxels;
    }
    else 
    {
        ERROR_LOG << "unknown voxel_format: " << svol_voxel_fmt;
    }
    return avg;
}
 
//----------------------------------------------------------------------
void Distributed_sparse_volume_data::render_frame(
    const std::string& output_filename) const
{
    // Rendering to a file by means of the file canvas
    m_image_file_canvas->set_rgba_file_name(output_filename.c_str()); // No output if empty string
 
    mi::base::Handle<mi::neuraylib::IDice_transaction> dice_transaction(
        m_global_scope->create_transaction<mi::neuraylib::IDice_transaction>());
    check_success(dice_transaction.is_valid_interface());
 
    m_index_session->update(m_session_tag, dice_transaction.get());
 
    mi::base::Handle<nv::index::IFrame_results> frame_results(
        m_index_rendering->render(
            m_session_tag,
            m_image_file_canvas.get(),
            dice_transaction.get()));
    check_success(frame_results.is_valid_interface());
 
    dice_transaction->commit();
}
 
//----------------------------------------------------------------------
// The API example illustrates the use of the general distributed computing concepts
// data locality, access and edit applied to a sysnthetic sparse volume dataset.
int main(int argc, const char* argv[])
{
    nv::index::app::String_dict sdict;
    sdict.insert("dice::verbose", "3");                               // log level
    sdict.insert("unittest", "0");                                    // default mode
    sdict.insert("outfname", "frame_distributed_sparse_volume_data"); // output file base name
    sdict.insert("verify_image_fname", "");                           // for unit test
    sdict.insert("dice::network::multicast_address", "224.1.3.2");    // default multicast address
    sdict.insert("dice::network::cluster_interface", "");             // default cluster interface address
    sdict.insert("voxel_format", "uint8");                            // default voxel_format
    sdict.insert("is_dump_comparison_image_when_failed", "1");        // default: dump images when failed.
    sdict.insert("is_call_from_test", "0");                           // default: not call from make check.
 
    // DiCE settings
    sdict.insert("dice::network::mode", "OFF");
 
    // IndeX settings
    sdict.insert("index::config::set_monitor_performance_values", "true");
    sdict.insert("index::service", "rendering_and_compositing");
    sdict.insert("index::cuda_debug_checks", "false");
    
    // Application_layer settings
    sdict.insert("index::app::components::application_layer::component_name_list",
                 "canvas_infrastructure image io data_analysis_and_processing");
    sdict.insert("index::app::plugins::base_importer::enabled", "true");
 
    // Initialize the NVIDIA IndeX library
    Distributed_sparse_volume_data distributed_data_example;
    distributed_data_example.initialize(argc, argv, sdict);
    check_success(distributed_data_example.is_initialized());
 
    // launch the application. creating the scene and rendering.
    const mi::Sint32 exit_code = distributed_data_example.launch();
    INFO_LOG << "Shutting down ...";
 
    return exit_code;
}