parallel_volume_editing.cpp

Go to the documentation of this file.

/******************************************************************************
 * Copyright 2023 NVIDIA Corporation. All rights reserved.
 *****************************************************************************/
 
#include <mi/dice.h>
 
// Include code shared by all examples.
#include "utility/example_shared.h"
 
#include <nv/index/icamera.h>
#include <nv/index/icolormap.h>
#include <nv/index/iindex.h>
#include <nv/index/iscene.h>
#include <nv/index/isession.h>
#include <nv/index/isparse_volume_rendering_properties.h>
 
#include "utility/app_rendering_context.h"
#include "utility/canvas_utility.h"
 
#include <nv/index/app/idata_analysis_and_processing.h>
#include <nv/index/app/index_connect.h>
#include <nv/index/app/string_dict.h>
#include <nv/index/app/time_functions.h>
 
#include <iostream>
#include <sstream>
 
//----------------------------------------------------------------------
class Parallel_volume_editing:
        public nv::index::app::Index_connect
{
public:
    Parallel_volume_editing()
        :
        Index_connect()
    {
        // INFO_LOG << "DEBUG: Parallel_volume_editing() ctor";
    }
 
    virtual ~Parallel_volume_editing()
    {
        // Note: Index_connect::~Index_connect() will be called after here.
        // INFO_LOG << "DEBUG: ~Parallel_volume_editing() 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:
    // Just create a nice colormap
    mi::math::Color_struct jetmap(mi::Float32 v, mi::Float32 vmin, mi::Float32 vmax) const;
    nv::index::IColormap* create_colormap(nv::index::IScene* scene) const;
    void edit_volume_data(
        mi::neuraylib::Tag                sparse_volume_tag,
        mi::neuraylib::Tag                session_tag,
        mi::neuraylib::IDice_transaction* dice_transaction) const;
    // setup camera to see this example scene
    void setup_camera(nv::index::IPerspective_camera* cam) const;
    // render a frame
    // \param[in] output_fname     output rendering image filename
    // \return performance values
    nv::index::IFrame_results* render_frame(const std::string& output_fname) 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_verify_image_fname;
    std::string                                                                       m_verify_image_fname_second;
    bool                                                                              m_perlin_noise;
    std::string                                                                       m_unittest_verify_image_fbase;
    std::string                                                                       m_unittest_verify_image_fbase_second;
};
 
//----------------------------------------------------------------------
mi::Sint32 Parallel_volume_editing::launch()
{
    mi::Sint32 exit_code = 0;
 
    // Get DiCE database components
    {
        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()));
 
        // The volume tag refering the volume for editing.
        mi::neuraylib::Tag sparse_volume_tag = mi::neuraylib::NULL_TAG;
 
        // Initialization and scene setup
        {
            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());
            {
                // Setup the session and scene.
                m_session_tag = m_index_session->create_session(dice_transaction.get());
                check_success(m_session_tag.is_valid());
 
                // Adjust the global configuration.
                {
                    // Access the session instance from the database.
                    mi::base::Handle<const nv::index::ISession> session(
                        dice_transaction->access<const nv::index::ISession>(m_session_tag));
                    check_success(session.is_valid_interface());
                }
 
                // Create and set up the scene.
                {
                    // Access the session instance from the database.
                    mi::base::Handle<const nv::index::ISession> session(
                        dice_transaction->access<const nv::index::ISession>(m_session_tag));
                    check_success(session.is_valid_interface());
                
                    // Access (edit mode) the scene instance from the database.
                    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 static group node for large data and append the volume
                    mi::base::Handle<nv::index::IStatic_scene_group> static_group(
                        scene_edit->create_scene_group<nv::index::IStatic_scene_group>());
                    check_success(static_group.is_valid_interface());
 
                    // Parameter to feed the synthetic volume generation technique
                    mi::math::Vector<mi::Uint32, 3> volume_size(1020, 1020, 1020);
                    const mi::math::Bbox<mi::Uint32, 3> bbox(
                        mi::math::Vector<mi::Uint32, 3>(0),
                        volume_size);
 
                    {
                        // Add a sparse_volume_render_properties to the scene.
                        mi::base::Handle<nv::index::ISparse_volume_rendering_properties> sparse_render_prop(
                            scene_edit->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.5f, 0.5f, 0.5f));
                        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.get());
                        INFO_LOG << "Created a sparse_render_prop_tag: tag = " << sparse_render_prop_tag;
 
                        // Add a colormap to the scene
                        mi::base::Handle<nv::index::IColormap> colormap(create_colormap(scene_edit.get()));
                        check_success(colormap.is_valid_interface());
                        const mi::neuraylib::Tag colormap_tag = dice_transaction->store_for_reference_counting(colormap.get());
                        static_group->append(colormap_tag, dice_transaction.get());
                        INFO_LOG << "Add a colormap to the scene: tag = " << colormap_tag;
                    }
                    
                    // 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",       "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",   "uint8");
                    sparse_volume_opt.insert("args::synthetic_type", "default");
                    if (m_perlin_noise)
                    {
                        sparse_volume_opt.insert("args::synthetic_type",               "perlin_noise");
                        sparse_volume_opt.insert("args::parameter::cube_unit",         "400");
                        sparse_volume_opt.insert("args::parameter::time",              "0");
                        sparse_volume_opt.insert("args::parameter::terms",             "5");
                        sparse_volume_opt.insert("args::parameter::turbulence_weight", "1 1 1 1");
                        sparse_volume_opt.insert("args::parameter::abs_noise",         "0");
                        sparse_volume_opt.insert("args::parameter::ridged",            "1");
                    }
                    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 a scene element that represents a sparse volume.
                    mi::math::Matrix<mi::Float32, 4, 4> transform_mat(1.0f); // Identity matrix
 
                    const mi::math::Bbox<mi::Float32, 3> ijk_bbox(
                        mi::math::Vector<mi::Float32, 3 >(0.0f), 
                        mi::math::Vector<mi::Float32, 3 >(static_cast<mi::Float32>(volume_size.x), 
                                                          static_cast<mi::Float32>(volume_size.y), 
                                                          static_cast<mi::Float32>(volume_size.z)));
 
                    mi::base::Handle<nv::index::ISparse_volume_scene_element> sparse_volume(
                        scene_edit->create_sparse_volume(ijk_bbox, transform_mat, generator, dice_transaction.get()));
                    check_success(sparse_volume.is_valid_interface());
                    sparse_volume->set_enabled(true);
 
                
                    // ... and store the volume scene element in the distributed database ...
                    sparse_volume_tag = dice_transaction->store_for_reference_counting(sparse_volume.get());
                    check_success(sparse_volume_tag.is_valid());
 
                    static_group->append(sparse_volume_tag, dice_transaction.get());
                    mi::neuraylib::Tag static_group_tag = dice_transaction->store_for_reference_counting(static_group.get());
                    check_success(static_group_tag.is_valid());
                
                    // append the static scene group to the hierarchical scene description.
                    scene_edit->append(static_group_tag, dice_transaction.get());
 
                    std::stringstream sstr;
                    sstr << "Created a synthetic volume: size = ["
                         << volume_size.x << " " << volume_size.y << " " << volume_size.z
                         << "], tag = " << sparse_volume_tag.id;
                    INFO_LOG << sstr.str();
 
                    // Create a camera and adjust the camera parameter.
                    mi::base::Handle< nv::index::IPerspective_camera > cam(
                        scene_edit->create_camera<nv::index::IPerspective_camera>());
                    check_success(cam.is_valid_interface());
                    setup_camera(cam.get());
                    const mi::neuraylib::Tag camera_tag = dice_transaction->store(cam.get());
                    check_success(camera_tag.is_valid());
                    // ... and add the camera to the scene.
                    scene_edit->set_camera(camera_tag);
                
                    const mi::math::Vector<mi::Uint32, 2> buffer_resolution(1024, 1024);
                    m_image_file_canvas->set_resolution(buffer_resolution);
 
                    // Define a region of interest for the entire scene in the
                    // scene's global coordinate system.
                    const mi::math::Bbox_struct<mi::Float32, 3> region_of_interest =
                        {
                            { 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(region_of_interest);
 
                    // Finally, optionally adjust the scene's coordinate system
                    mi::math::Matrix<mi::Float32, 4, 4> transform(
                        1.0f,  0.0f,  0.0f,  0.0f,
                        0.0f,  1.0f,  0.0f,  0.0f,
                        0.0f,  0.0f, -1.0f,  0.0f, // adjust for coordinate system
                        0.0f,  0.0f,  0.0f,  1.0f
                        );
                    scene_edit->set_transform_matrix(transform);
                }
            }
            dice_transaction->commit();
        }
 
        // Render the initial scene
        {
            // 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(m_outfname, frame_idx);
 
            mi::base::Handle<nv::index::IFrame_results> frame_results(render_frame(fname));
            const mi::base::Handle<nv::index::IError_set> err_set(frame_results->get_error_set());
            if (err_set->any_errors())
            {
                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();
                exit_code = 1;
            }
 
            // verify the generated frame
            if (!verify_canvas_result(get_application_layer_interface(),
                                      m_image_file_canvas.get(), m_verify_image_fname, get_options()))
            {
                exit_code = 1;
            }
        }
 
        // --------- EDITING THE VOLUME ------------
        {
            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());
            {
                edit_volume_data(sparse_volume_tag, m_session_tag, dice_transaction.get());
            }
            dice_transaction->commit();
        }
            
        // Render the edited scene
        {
            // Render a frame and save the rendered image to a file.
            const mi::Sint32  frame_idx = 0;
            const std::string fname = "edited_" + get_output_file_name(m_outfname, frame_idx);
            mi::base::Handle<nv::index::IFrame_results> frame_results(render_frame(fname));
 
            const mi::base::Handle<nv::index::IError_set> err_set(frame_results->get_error_set());
            if (err_set->any_errors())
            {
                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 << "NVIDIA IndeX rendering call failed with the following error(s): " << '\n'
                          << os.str();
            }
 
            // verify the generated frame
            if (!verify_canvas_result(get_application_layer_interface(),
                                      m_image_file_canvas.get(), m_verify_image_fname_second, get_options()))
            {
                exit_code = 1;
            }
        }
    }
 
    return exit_code;
}
 
//----------------------------------------------------------------------
bool Parallel_volume_editing::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("outfname", "");  // turn off file output in the unit test mode
        sdict.insert("dice::verbose", "2");
        const std::string vimage_base1 = sdict.get("unittest_verify_image_fbase");
        const std::string vimage_base2 = sdict.get("unittest_verify_image_fbase_second");
        if(!vimage_base1.empty())
        {
            sdict.get("verify_image_fname")        = vimage_base1 + ".ppm";
        }
        if(!vimage_base2.empty())
        {
            sdict.get("verify_image_fname_second") = vimage_base2 + ".ppm";
        }
    }
 
    m_outfname                           = sdict.get("outfname");
    m_verify_image_fname                 = sdict.get("verify_image_fname");
    m_verify_image_fname_second          = sdict.get("verify_image_fname_second");
    m_perlin_noise                       = nv::index::app::get_bool(sdict.get("perlin_noise", "false"));
    m_unittest_verify_image_fbase        = sdict.get("unittest_verify_image_fbase");
    m_unittest_verify_image_fbase_second = sdict.get("unittest_verify_image_fbase_second");
 
    info_cout(std::string("running ") + com_name, sdict);
    info_cout("outfname = ["              + m_outfname +
              "], verify_image_fname = [" + m_verify_image_fname +
              "], verify_image_fname_second = [" + m_verify_image_fname_second +
              "], dice::verbose = "       + sdict.get("dice::verbose"), sdict);
 
    // print help and exit if -h
    if (sdict.is_defined("h"))
    {
        std::cout
            << "info: Usage: " << com_name << " [option]\n"
            << "Option: [-h]\n"
            << "            print out this message\n"
 
            << "        [-dice::verbose severity_level INT]\n"
            << "            verbose severity level by INT (3 is info).\n"
            << "            (default: " + sdict.get("dice::verbose") << ")\n"
 
            << "        [-perlin_noise BOOL]\n"
            << "            when true, use Perlin noise to generate the volume, instead of\n"
            << "            a simpler color scheme. Note that this can be computationally expensive.\n"
            << "            (default: [" << m_perlin_noise << "])\n"
 
            << "        [-outfname FILE_BASENAME]\n"
            << "            output ppm file base name. When empty, no output.\n"
            << "            A frame number and extension (.ppm) will be added.\n"
            << "            (default: [" << m_outfname << "])\n"
 
            << "        [-verify_image_fname REF_IMAGE_FILENAME]\n"
            << "            when REF_IMAGE_FILENAME exist, verify the first rendered image.\n"
            << "            (default: [" << m_verify_image_fname << "])\n"
 
            << "        [-verify_image_fname_second REF_IMAGE_FILENAME]\n"
            << "            when REF_IMAGE_FILENAME exist, verify the second rendered image.\n"
            << "            (default: [" << m_verify_image_fname_second << "])\n"
 
            << "        [-unittest BOOL]\n"
            << "            when true, unit test mode. \n"
            << "            (default: [" << m_is_unittest << "])"
 
            << "        [-unittest_verify_image_fbase REF_IMAGE_FILENAME]\n"
            << "            when REF_IMAGE_FILENAME exist, verify the first rendered image.\n"
            << "            Only effective with -unittest 1.\n"
            << "            (default: [" << m_unittest_verify_image_fbase << "])\n"
 
            << "        [-unittest_verify_image_fbase_second REF_IMAGE_FILENAME]\n"
            << "            when REF_IMAGE_FILENAME exist, verify the second rendered image.\n"
            << "            Only effective with -unittest 1.\n"
            << "            (default: [" << m_unittest_verify_image_fbase_second << "])\n"
 
            << std::endl;
        exit(1);
    }
    return true;
}
 
//----------------------------------------------------------------------
mi::math::Color_struct Parallel_volume_editing::jetmap(mi::Float32 v, mi::Float32 vmin, mi::Float32 vmax) const
{
   mi::math::Color_struct c = {1.f, 1.f, 1.f, 0.01f};
   mi::Float32 dv;
 
   if (v < vmin)
      v = vmin;
   if (v > vmax)
      v = vmax;
   dv = vmax - vmin;
 
   if (v < (vmin + 0.25f * dv)) 
   {
      c.r = 0.f;
      c.g = 4.f * (v - vmin) / dv;
   } 
   else if (v < (vmin + 0.5f * dv)) 
   {
      c.r = 0.f;
      c.b = 1.f + 4.f * (vmin + 0.25f * dv - v) / dv;
   } 
   else if (v < (vmin + 0.75f * dv)) 
   {
      c.r = 4.f * (v - vmin - 0.5f * dv) / dv;
      c.b = 0.f;
   } 
   else 
   {
      c.g = 1.f + 4.f * (vmin + 0.75f * dv - v) / dv;
      c.b = 0.f;
   }
 
   return(c);
} 
 
//----------------------------------------------------------------------
nv::index::IColormap* Parallel_volume_editing::create_colormap(nv::index::IScene* scene) const
{
    nv::index::IColormap* colormap = scene->create_attribute<nv::index::IColormap>();
    check_success(colormap != 0);
    std::vector<mi::math::Color_struct> colormap_entries;
    colormap_entries.resize(256);
    for(mi::Uint32 i=0; i<256; ++i)
    {
        colormap_entries[i] = jetmap((static_cast<mi::Float32>(i)+0.5f)/256.0f, 0.0f, 1.0f);
    }
    
    // Set the the colormap values.
    colormap->set_colormap(&colormap_entries[0], colormap_entries.size());
    return colormap;
}
 
//----------------------------------------------------------------------
void Parallel_volume_editing::edit_volume_data(
    mi::neuraylib::Tag                sparse_volume_tag,
    mi::neuraylib::Tag                session_tag,
    mi::neuraylib::IDice_transaction* dice_transaction) const
{
    // Access the session
    mi::base::Handle<const nv::index::ISession> session(
        dice_transaction->access<nv::index::ISession>(session_tag));
    check_success(session.is_valid_interface());
 
    // Access to the sparse volume scene element 
    mi::base::Handle<const nv::index::ISparse_volume_scene_element> sparse_volume(
        dice_transaction->access<nv::index::ISparse_volume_scene_element>(sparse_volume_tag));
    check_success(sparse_volume.is_valid_interface());
    const mi::math::Bbox<mi::Float32, 3> query_bbox_f32 = sparse_volume->get_bounding_box();
 
    // Access the distribution scheme
    const mi::neuraylib::Tag dist_layout_tag = 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());
 
    const mi::math::Bbox<mi::Sint32, 3> query_bbox_s32(query_bbox_f32);
    mi::base::Handle<nv::index::IDistributed_data_locality> svol_data_locality(
        distribution_layout->get_data_locality<nv::index::ISparse_volume_scene_element>(sparse_volume_tag, query_bbox_f32, dice_transaction));
    check_success(svol_data_locality.is_valid_interface());
 
    // Determine the host ids of all hosts in the cluster which store parts of the volume data
    for (mi::Uint32 i=0; i < svol_data_locality->get_nb_cluster_nodes(); ++i)
    {
        // Host id 0 specifies that this subregion has not yet been loaded.
        // This should not happen.
        check_success(svol_data_locality->get_cluster_node(i) != 0);
        const mi::Uint32 host_id = svol_data_locality->get_cluster_node(i);
        INFO_LOG << "Cluster host "
                 << svol_data_locality->get_cluster_node(i)
                 << " is responsible for processing "
                 << svol_data_locality->get_nb_bounding_box(host_id)
                 << " problems.";
    }
 
    // Set up distributed editing process.
    const mi::Float64 start_time = nv::index::app::util::time::get_time();
    const mi::Uint8 voxel_value = 255;
    // 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(
            sparse_volume_tag,
            voxel_value,
            query_bbox_s32));
    check_success(algo.is_valid_interface());
    // Start the fragmented job
    distribution_layout->create_scheduler()->execute(algo.get(), dice_transaction);
 
    // Performance measurements
    const mi::Float64 end_time = nv::index::app::util::time::get_time();
    const mi::Float64 elapsed_time = end_time - start_time;
    INFO_LOG << "Total elapsed time for volume edit: " << elapsed_time;
}
 
//----------------------------------------------------------------------
void Parallel_volume_editing::setup_camera(nv::index::IPerspective_camera* cam) const
{
    check_success(cam != 0);
 
    // Set the camera parameters to see the whole scene
    const mi::math::Vector< mi::Float32, 3 > from(2048.f, 1536.f,-756.f);
    const mi::math::Vector< mi::Float32, 3 > to  ( 512.f, 512.2f,-512.7f);
    const mi::math::Vector< mi::Float32, 3 > up  (   0.f,   0.f,   -1.f);
    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);
}
 
//----------------------------------------------------------------------
nv::index::IFrame_results* Parallel_volume_editing::render_frame(const std::string& output_fname) const
{
    check_success(m_index_rendering.is_valid_interface());
 
    // set output filename, empty string is valid
    m_image_file_canvas->set_rgba_file_name(output_fname.c_str());
 
    check_success(m_session_tag.is_valid());
 
    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();
 
    frame_results->retain();
    return frame_results.get();
}
 
//----------------------------------------------------------------------
// This example shows how to edit a sparse volume in parallel.
int main(int argc, const char* argv[])
{
    nv::index::app::String_dict sdict;
    sdict.insert("dice::verbose", "3");                        // log level
    sdict.insert("dice::network::multicast_address", "");       // default multicast address. empty means network is disabled.
    sdict.insert("dice::network::cluster_interface", "");       // default cluster interface address
    sdict.insert("perlin_noise", "0");
 
    sdict.insert("outfname", "frame_parallel_volume_editing");  // output file base name
    sdict.insert("verify_image_fname", "");                     // 
    sdict.insert("verify_image_fname_second", "");
    sdict.insert("unittest_verify_image_fbase", "");            // for unit test
    sdict.insert("unittest_verify_image_fbase_second", "");     // for unit test
    sdict.insert("unittest", "0");                              // default mode
    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");
    // plugin: base_importer
    sdict.insert("index::app::plugins::base_importer::enabled", "true");
 
    // Initialize application
    Parallel_volume_editing parallel_volume_editing;
    parallel_volume_editing.initialize(argc, argv, sdict);
    check_success(parallel_volume_editing.is_initialized());
 
    // launch the application. creating the scene and rendering.
    const mi::Sint32 exit_code = parallel_volume_editing.launch();
    INFO_LOG << "Shutting down ...";
 
    return exit_code;
}