ray_sampling_sparse_volume.h

Go to the documentation of this file.

/******************************************************************************
 * Copyright 2023 NVIDIA Corporation. All rights reserved.
 *****************************************************************************/
#ifndef EXAMPLES_RAY_SAMPLING_SPARSE_VOLUME_H
#define EXAMPLES_RAY_SAMPLING_SPARSE_VOLUME_H
 
#include "ray_sampling_scenes.h"
 
#include <nv/index/isparse_volume_scene_element.h>
#include <nv/index/isparse_volume_rendering_properties.h>
 
#include <nv/index/app/forwarding_logger.h>
 
namespace sparse_volume {
 
static const char* program_begin =
";NV_IDX_XAC_VERSION_1_0                                                         \n"
"                                                                               \n"
"class Volume_sample_program                                                    \n"
"{                                                                              \n"
"    NV_IDX_VOLUME_SAMPLE_PROGRAM                                               \n"
"                                                                               \n"
"public:                                                                        \n"
"    const nv::index::xac::Colormap colormap = state.self.get_colormap();       \n"
"    int counter;                                                               \n"
"                                                                               \n"
"    NV_IDX_DEVICE_INLINE_MEMBER void initialize()                              \n"
"    {                                                                          \n"
"        counter = 0;                                                           \n"
"    }                                                                          \n"
"                                                                               \n"
;
 
static const char* program_end =
"}; \n"
;
 
static const char* color_program =
"    // The user program used for rendering.                                    \n"
"    NV_IDX_DEVICE_INLINE_MEMBER int execute(                                   \n"
"        const Sample_info_self&  sample_info,                                  \n"
"              Sample_output&     sample_output)                                \n"
"    {                                                                          \n"
"        const auto& svol = state.self;                                         \n"
"        const auto svol_sampler = svol.generate_sampler<float>(0u,             \n"
"              sample_info.sample_context);                                     \n"
"        const float v = svol_sampler.fetch_sample(                             \n"
"                          sample_info.sample_position_object_space);           \n"
"        sample_output.set_color(colormap.lookup(v));                           \n"
"        return NV_IDX_PROG_OK;                                                 \n"
"    }                                                                          \n"
;
 
static const char* inquire_program =
"    // The user program used for picking.                                      \n"
"    NV_IDX_DEVICE_INLINE_MEMBER int inquire(                                   \n"
"            const Sample_info_self&  sample_info,                              \n"
"            Query_results&           query_results)                            \n"
"    {                                                                          \n"
"        // write some attribute value of current sample                        \n"
"        const unsigned int attr_idx = 0u;                                      \n"
"        const auto& svol = state.self;                                         \n"
"        const auto svol_sampler = svol.generate_sampler<float>(attr_idx,       \n"
"              sample_info.sample_context);                                     \n"
"        const float v = svol_sampler.fetch_sample(                             \n"
"                          sample_info.sample_position_object_space);           \n"
"        query_results.write_value<float>(0u /*user_value_idx*/, v);            \n"
"                                                                               \n"
"        counter += 1;                                                          \n"
"        if (counter & 1) {                                                     \n"
"            // write every other counter as user value                         \n"
"            query_results.write_value<int>(1u /*user_value_idx*/, counter);    \n"
"        }                                                                      \n"
"                                                                               \n"
//"        const float3 normal = make_float3(1.f, 0.3f, 0.1f);                    \n"
"        const float3 normal = sample_info.scene_position;                      \n"
"        query_results.write_value<float3>(2u /*user_value_idx*/, normal);      \n"
"                                                                               \n"
"        return NV_IDX_PROG_OK;                                                 \n"
"                                                                               \n"
"        // we can stop sampling:                                               \n"
"        //return NV_IDX_PROG_TERMINATE_PROGRAM_INSTANCE;                       \n"
"    }                                                                          \n"
;
 
 
class Sparse_volume_setup : public ray_sampling::IRay_sampling_scene_setup
{
public:
    const char* name() const { return "Sparse Volume"; }
 
    void register_classes(nv::index::IIndex* index_interface) const
    {
        // empty
    }
 
    void add_arguments(std::map<std::string, std::string>& opt_map) const
    {
        opt_map["svol.input_file_base_name"] = "";
        opt_map["svol.input_directory"]      = "";
        opt_map["svol.input_file_extension"] = ".idx_vraw";
        opt_map["svol.format"]               = "uint8";
        opt_map["svol.size"]                 = "500 500 1500";
        opt_map["svol.ordering"]             = "xyz";
        opt_map["svol.filter_mode"]          = "nearest";
        opt_map["svol.preintegration"]       = "0";
        opt_map["svol.lod_render"]           = "0";
        opt_map["svol.show_lod"]             = "0";
    }
 
    void usage_info(std::ostream& os, const char* indent, std::map<std::string, std::string>& opt_map) const
    {
        os << indent << "[-svol.input_directory VOLUME_DIR]\n"
            << indent << "    the directory of the input volume.  \n"
            << indent << "    (default: [" << opt_map["svol.input_directory"] << "])\n"
            << indent << "[-svol.input_file_base_name VOLUME_BASE_NAME]\n"
            << indent << "    the file base-name of the input volume (without extension).  \n"
            << indent << "    (default: [" << opt_map["svol.input_file_base_name"] << "])\n"
            << indent << "[-svol.input_file_extension VOLUME_FILE_EXT]\n"
            << indent << "    the file extension of the input volume.  \n"
            << indent << "    (default: [" << opt_map["svol.input_file_extension"] << "])\n"
            << indent << "[-svol.format VOXEL_FORMAT]\n"
            << indent << "    the voxel format. 'uint8', 'float32' \n"
            << indent << "    (default: [" << opt_map["svol.format"] << "])\n"
            << indent << "[-svol.size SIZE_X SIZE_Y SIZE_Z]\n"
            << indent << "    the volume size. \n"
            << indent << "    (default: [" << opt_map["svol.size"] << "])\n"
            << indent << "[-svol.ordering ORDER_NAME]\n"
            << indent << "    the input volume axis-ordering. 'xyz', 'zyx'. \n"
            << indent << "    (default: [" << opt_map["svol.ordering"] << "])\n"
            << indent << "[-svolfilter_mode FILTER_NAME]\n"
            << indent << "    the string filter_name defines the volume filter. 'nearest', 'trilinear' \n"
            << indent << "    (default: [" << opt_map["svol.filter_mode"] << "])\n"
            << indent << "[-svol.preintegration BOOL]\n"
            << indent << "    render using the pre-integration-based volume\n"
            << indent << "    rendering technique.\n"
            << indent << "    (default: " << opt_map["svol.preintegration"] << ")\n"
            << indent << "[-svol.lod_render BOOL]\n"
            << indent << "    render using the level-of-detail volume\n"
            << indent << "    rendering technique.\n"
            << indent << "    (default: " << opt_map["svol.lod_render"] << ")\n"
            << indent << "[-svol.show_lod BOOL]\n"
            << indent << "    show the level-of-detail structure used but the volume\n"
            << indent << "    rendering technique.\n"
            << indent << "    (default: " << opt_map["svol.lod_render"] << ")\n";
    }
 
    const char* get_roi_string() const
    {
        return "0 0 0  500 500 500";
    }
 
    bool create_scene(
        nv::index::app::IApplication_layer*     app_layer,        
        Scene_info&                             scene_info,
        const mi::math::Bbox< mi::Float32, 3>&  roi_bbox,
        const mi::neuraylib::Tag&               session_tag,
        std::map<std::string, std::string>&     opt_map,
        mi::neuraylib::IDice_transaction*       transaction) const
    {
        check_success(session_tag.is_valid());
        check_success(transaction != 0);
 
        // Access the session instance from the database.
        mi::base::Handle<const nv::index::ISession> session(
            transaction->access<const nv::index::ISession>(session_tag));
        check_success(session.is_valid_interface());
 
        // Access (edit mode) the scene instance from the database.
        mi::base::Handle<nv::index::IScene> scene(
            transaction->edit<nv::index::IScene>(session->get_scene()));
        check_success(scene.is_valid_interface());
 
        // Create a color map using an external utility function.
        const mi::Sint32 colormap_entry_id = 41; // same as demo application's colormap file 40
        mi::neuraylib::Tag colormap_tag = create_colormap(colormap_entry_id, scene.get(), transaction);
        check_success(colormap_tag.is_valid());
 
        // Sparse volume rendering properties
        mi::base::Handle<nv::index::ISparse_volume_rendering_properties> svol_render_prop(
            scene->create_attribute<nv::index::ISparse_volume_rendering_properties>());
 
        const std::string   filter_mode = opt_map["svol.filter_mode"];
        if (filter_mode == "nearest")
        {
            svol_render_prop->set_filter_mode(nv::index::SPARSE_VOLUME_FILTER_NEAREST);
        }
        else if (filter_mode == "trilinear")
        {
            svol_render_prop->set_filter_mode(nv::index::SPARSE_VOLUME_FILTER_TRILINEAR_POST);
        }
 
        const bool use_preint_render = nv::index::app::get_bool(opt_map["svol.preintegration"]);
        svol_render_prop->set_preintegrated_volume_rendering(use_preint_render);
 
        svol_render_prop->set_voxel_offsets(mi::math::Vector<mi::Float32, 3>(0.5f, 0.5f, 0.5f));
 
        const bool use_lod_render = nv::index::app::get_bool(opt_map["svol.lod_render"]);
        svol_render_prop->set_lod_rendering_enabled(use_lod_render);
        svol_render_prop->set_lod_pixel_threshold(2.5f);
 
        const bool show_lod_render = nv::index::app::get_bool(opt_map["svol.show_lod"]);
        svol_render_prop->set_debug_visualization_option(show_lod_render ? 2u : 0u);
 
        const mi::neuraylib::Tag svol_render_prop_tag = transaction->store_for_reference_counting(svol_render_prop.get());
        check_success(svol_render_prop_tag.is_valid());
 
        const mi::math::Vector<mi::Uint32, 3> svol_input_size = nv::index::app::get_vector_from_string<mi::Uint32,3>(opt_map["svol.size"]);
        const mi::math::Bbox<mi::Float32, 3>  svol_input_bbox = mi::math::Bbox<mi::Float32, 3>(0.0f, 0.0f, 0.0f,
            static_cast<mi::Float32>(svol_input_size.x),
            static_cast<mi::Float32>(svol_input_size.y),
            static_cast<mi::Float32>(svol_input_size.z));
 
        // sparse volume creation parameter
        std::map<std::string, std::string> sparse_volume_opt;
        sparse_volume_opt["type"]                 = "sparse_volume";
        sparse_volume_opt["importer"]             = "nv::index::plugin::base_importer.Sparse_volume_importer_raw";
        sparse_volume_opt["input_directory"]      = opt_map["svol.input_directory"];
        sparse_volume_opt["input_file_base_name"] = opt_map["svol.input_file_base_name"];
        sparse_volume_opt["input_file_extension"] = opt_map["svol.input_file_extension"];
        sparse_volume_opt["convert_zyx_to_xyz"]   = (opt_map["svol.ordering"] != "xyz") ? "true" : "false";
        sparse_volume_opt["bbox"]                 = "0 0 0 " + opt_map["svol.size"];
        sparse_volume_opt["voxel_format"]         = opt_map["svol.format"];
                
        nv::index::IDistributed_data_import_callback* importer_callback = 
            get_importer_from_application_layer(
                app_layer,
                "nv::index::plugin::base_importer.Sparse_volume_importer_raw",
                sparse_volume_opt);
 
        const mi::math::Matrix<mi::Float32, 4, 4> svol_transform(1.0f);
        mi::base::Handle<nv::index::ISparse_volume_scene_element> svol_scene_elem(
            scene->create_sparse_volume(svol_input_bbox, svol_transform, importer_callback, transaction));
 
        const mi::neuraylib::Tag svol_scene_elem_tag = transaction->store_for_reference_counting(svol_scene_elem.get());
        check_success(svol_scene_elem_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());
 
        // Append the volume sample program before the volume element
        static_group->append(colormap_tag, transaction);
        static_group->append(svol_render_prop_tag, transaction);
 
        const int user_prg = nv::index::app::get_sint32(opt_map["user_program_mode"]);
        if (user_prg) {
            mi::base::Handle<nv::index::IRendering_kernel_program> sampling_program(
                scene->create_attribute<nv::index::IVolume_sample_program>());
            check_success(sampling_program.is_valid_interface());
 
            std::string program_src = scene_info.rtc_program_source;
            if (program_src.empty()) {
                program_src = program_begin;
                program_src.append(color_program);
                if (user_prg > 1) {
                    program_src.append(inquire_program);
                }
                program_src.append(program_end);
                scene_info.rtc_program_source = program_src;
            }
            sampling_program->set_program_source(program_src.c_str());
            mi::neuraylib::Tag prog_tag = transaction->store_for_reference_counting(sampling_program.get());
            check_success(prog_tag.is_valid());
 
            static_group->append(prog_tag, transaction);
        }
 
        static_group->append(svol_scene_elem_tag, transaction);
 
        mi::neuraylib::Tag static_group_tag =
            transaction->store_for_reference_counting(static_group.get());
        check_success(static_group_tag.is_valid());
 
        // append the static scene group to the hierachical scene description.
        scene->append(static_group_tag, transaction);
 
        std::stringstream sstr;
        sstr << "Created a LOD volume: size = ["
            << svol_input_size.x << " " << svol_input_size.y << " " << svol_input_size.z
            << "], tag = " << svol_scene_elem_tag.id;
        INFO_LOG << sstr.str();
 
        return true;
    }
 
    void setup_camera(
        const mi::neuraylib::Tag&         camera_tag,
        mi::neuraylib::IDice_transaction* transaction) const
    {
        check_success(camera_tag.is_valid());
        check_success(transaction != 0);
        mi::base::Handle<nv::index::IPerspective_camera>
            cam(transaction->edit<nv::index::IPerspective_camera>(camera_tag));
        check_success(cam.is_valid_interface());
 
        const mi::math::Vector< mi::Float32, 3 > from(-0.340944170951843f, -0.170461803674698f, 0.0734406113624573f);
        const mi::math::Vector< mi::Float32, 3 > to  (0.702501833438873f, 0.492376863956451f, -0.513864099979401f);
        const mi::math::Vector< mi::Float32, 3 > up  (0.371015131473541f, 0.362788468599319f, 0.854828774929047f);
        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(0.001f);
        cam->set_clip_max(400.0f);
    }
 
    virtual float get_scene_scaling() const { return 0.001f; }
 
};
 
 
}//sparse_volume
 
#endif