xac_compute_sparse_volume.cpp

Go to the documentation of this file.

/******************************************************************************
 * Copyright 2023 NVIDIA Corporation. All rights reserved.
 *****************************************************************************/
// Sparse volume setup for xac compute example.
 
#include "xac_compute_sparse_volume.h"
#include "xac_compute_scene_tool.h"
#include <nv/index/isparse_volume_scene_element.h>
#include <nv/index/isparse_volume_rendering_properties.h>
 
#include <nv/index/app/forwarding_logger.h>
#include <nv/index/app/string_dict.h> // get_*
 
#include "sparse_volume_exporter.h"
 
namespace xac_compute {
namespace sparse_volume {
 
 
static const char* svol_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"
"                                                                               \n"
"    NV_IDX_DEVICE_INLINE_MEMBER void initialize()                              \n"
"    {                                                                          \n"
"    }                                                                          \n"
"\n"
;
 
static const char* program_end =
"}; \n"
;
 
static const char* svol_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"
"\n"
;
 
static const char* svol_compute_program =
"   // The user program for compute.                                            \n"
"   NV_IDX_DEVICE_INLINE_MEMBER                                                 \n"
"   int compute(                                                                \n"
"       const Data_point_info_self&  data_point_info,        // read-only       \n"
"       Data_point_output&           data_output)                               \n"
"   {                                                                           \n"
"       const unsigned int attr_idx = 0;                                        \n"
"       const auto& vol = state.self;                                           \n"
"       float v = vol.get_attribute<float>(attr_idx, data_point_info);          \n"
"                                                                               \n"
"       v = 1.f - v * 0.9f;  // Modify value v.                                 \n"
"                                                                               \n"
"       // Write modified value to data point output.                           \n"
"       data_output.write_value<float>(attr_idx, v);                            \n"
"                                                                               \n"
"       return NV_IDX_PROG_OK;                                                  \n"
"   }                                                                           \n"
"\n"
;
 
static const char* plane_sample_function =
"    NV_IDX_DEVICE_INLINE_MEMBER  bool sample_func(                                                                 \n"
"        const float3&   scene_position,                                                                            \n"
"        float&          sample_value,                                                                              \n"
"        float4&         color) const                                                                               \n"
"    {                                                                                                              \n"
"        // Access the first Sparse_volume available (works only if volume is active)                               \n"
"        if (state.scene.get_number_of_elements<xac::Sparse_volume>() == 0) {                                       \n"
"            return false;                                                                                          \n"
"        }                                                                                                          \n"
"        const xac::Sparse_volume& volume = state.scene.access_by_id<xac::Sparse_volume>(0);                        \n"
"                                                                                                                   \n"
"        if (state.scene.get_number_of_elements<xac::Colormap>() == 0) {                                            \n"
"            return false;                                                                                          \n"
"        }                                                                                                          \n"
"                                                                                                                   \n"
"        const float3 sample_pos = transform_point(volume.get_scene_to_object_transform(), scene_position);         \n"
"        if (!xaclib::is_inside_bounding_box(volume.get_volume_bbox_min(), volume.get_volume_bbox_max(),            \n"
"            sample_pos))                                                                                           \n"
"        {                                                                                                          \n"
"            return false;                                                                                          \n"
"        }                                                                                                          \n"
"                                                                                                                   \n"
"        const uint attr_index = 0u;                                                                                \n"
"        const auto sampler = volume.generate_sampler<float,                                                        \n"
"            xac::Volume_filter_mode::TRILINEAR, xac::Volume_classification_mode::POST_INTERPOLATION>(attr_index);  \n"
"                                                                                                                   \n"
"        sample_value = sampler.fetch_sample(sample_pos);                                                           \n"
"                                                                                                                   \n"
"        const xac::Colormap colormap = volume.get_colormap();                                                      \n"
"        color = colormap.lookup(sample_value);                                                                     \n"
"                                                                                                                   \n"
"        return true;                                                                                               \n"
"    }                                                                                                              \n"
"\n"
;
 
 
 
 
static const Program_source svol_program = {
    svol_program_begin,
    program_end,
    svol_color_program,
    svol_compute_program 
};
 
 
 
 
 
#define SVOL_MODEL 1
/*
    svol_bucky64_uint8
 
        opt_map["svol.input_file_base_name"] = "bucky_C60_64_64_64";
        opt_map["svol.input_directory"]      = ".";
        opt_map["svol.input_file_extension"] = ".vol";
        opt_map["svol.size"]                 = "64 64 64";
 
        from: -56.44580078125 -1.99575769901276 76.410285949707
        dir: 0.822186231613159 0.390750795602798 -0.413912683725357
        up: -0.223093569278717 0.890190124511719 0.397229105234146
 
    svol_bucky128_uint8
 
        opt_map["svol.input_file_base_name"] = "bucky_C60Large_128_128_128";
        opt_map["svol.input_directory"]      = ".";
        opt_map["svol.input_file_extension"] = ".vol";
        opt_map["svol.size"]                 = "128 128 128";
        'from':     '-112.29296875 -7.79020595550537 154.107467651367',
        'dir':      '0.822186231613159 0.390750795602798 -0.413912683725357',
        'up':       '-0.223093569278717 0.890190124511719 0.397229105234146',
*/
 
 
 
 
void Sparse_volume_setup::register_classes(nv::index::IIndex* index_interface) const
{
    // empty
}
 
 
void Sparse_volume_setup::add_arguments(Option_map& opt_map) const
{
#if (SVOL_MODEL == 1)
    opt_map["svol.input_file_base_name"] = "bucky_C60_64_64_64";
    opt_map["svol.size"] = "64 64 64";
#endif
#if (SVOL_MODEL == 2)
    opt_map["svol.input_file_base_name"] = "bucky_C60Large_128_128_128";
    opt_map["svol.size"] = "128 128 128";
#endif
    opt_map["svol.input_directory"] = ".";
    opt_map["svol.input_file_extension"] = ".vol";
    opt_map["svol.format"] = "uint8";
    opt_map["svol.ordering"] = "xyz";
    opt_map["svol.filter_mode"] = "trilinear";
    opt_map["svol.brick_size"] = "60 60 60";
    opt_map["svol.brick_border"] = "2";
    opt_map["svol.preintegration"] = "0";
    opt_map["svol.lod_render"] = "0";
    opt_map["svol.show_lod"] = "0";
}
 
 
void Sparse_volume_setup::usage_info(Usage_helper& usage) const
{
    usage.opt("svol.input_directory", "DIR", "Directory of the input volume.");
    usage.opt("svol.input_file_base_name", "NAME", "File base-name of the input volume (without extension).");
    usage.opt("svol.input_file_extension", "EXT", "File extension of the input volume.");
    usage.opt("svol.format", "FORMAT", "Voxel format (uint8, float32).");
    usage.opt("svol.size", "X Y Z", "Volume size.");
    usage.opt("svol.ordering", "NAME", "Input volume axis-ordering (xyz, zyx).");
    usage.opt("svol.filter_mode", "NAME", "Volume filter (nearest, trilinear).");
    usage.opt("svol.brick_size", "X Y Z", "Brick size in voxels.");
    usage.opt("svol.brick_border", "n", "Brick border in voxels.");
    usage.opt("svol.preintegration", "bool", "Render using the pre-integration-based volume rendering technique.");
    usage.opt("svol.lod_render", "bool", "Render using the level-of-detail volume rendering technique.");
    usage.opt("svol.show_lod", "bool", "Show the level-of-detail structure used but the volume rendering technique.");
}
 
 
const char* Sparse_volume_setup::get_roi_string() const
{
    return "0 0 0  126 126 126";
}
 
struct Svol_load_info 
{
    std::string         input_dir;
    std::string         input_file_base;
    std::string         input_file_ext;
    Bbox3i              svol_bbox_i;
    mi::neuraylib::Tag  svol_element_tag;
};
 
static void load_sparse_volume_data(
    Nvindex_access&                   nvindex_accessor,    
    Svol_load_info&                   load_info,
    const Option_map&                 opt_map,
    nv::index::IScene*                scene,
    mi::neuraylib::IDice_transaction* transaction)
{
    const Vec3u   svol_input_size = nv::index::app::get_vector_from_string<mi::Uint32,3>(opt_map["svol.size"]);
    const Bbox3f  svol_input_bbox(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));
 
    const Bbox3i  svol_bbox_i(
        static_cast<mi::Sint32>(floorf(svol_input_bbox.min.x)),
        static_cast<mi::Sint32>(floorf(svol_input_bbox.min.y)),
        static_cast<mi::Sint32>(floorf(svol_input_bbox.min.z)),
        static_cast<mi::Sint32>(ceilf(svol_input_bbox.max.x)),
        static_cast<mi::Sint32>(ceilf(svol_input_bbox.max.y)),
        static_cast<mi::Sint32>(ceilf(svol_input_bbox.max.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"]      = load_info.input_dir;
    sparse_volume_opt["input_file_base_name"] = load_info.input_file_base;
    sparse_volume_opt["input_file_extension"] = load_info.input_file_ext;
    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(
            nvindex_accessor.get_application_layer_interface(),
            "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));
 
    load_info.svol_element_tag = transaction->store_for_reference_counting(svol_scene_elem.get());
    load_info.svol_bbox_i = svol_bbox_i;
}
 
 
 
bool Sparse_volume_setup::create_scene(
    Nvindex_access&                     nvindex_accessor,    
    Scene_info&                         scene_info,
    const Bbox3f&                       roi_bbox,
    mi::neuraylib::Tag                  session_tag,
    const Option_map&                   opt_map,
    mi::neuraylib::IDice_transaction*   transaction) const
{
    Scene_tool scene_tool(session_tag, transaction);
 
    m_info.svol_group_tag = scene_tool.add_new_group();
 
    // Create a color map using an external utility function.
    const mi::Sint32 colormap_entry_id = 41; // same as demo application's colormap file 40  (41)
    mi::neuraylib::Tag colormap_tag = create_colormap(colormap_entry_id, scene_tool.scene.get(), transaction);
    check_success(colormap_tag.is_valid());
 
 
    // Sparse volume scene element/importer
    Svol_load_info ldinfo;
    ldinfo.input_dir        = opt_map["svol.input_directory"];
    ldinfo.input_file_base  = opt_map["svol.input_file_base_name"];
    ldinfo.input_file_ext   = opt_map["svol.input_file_extension"];
    
    load_sparse_volume_data(nvindex_accessor, ldinfo, opt_map, scene_tool.scene.get(), transaction);
    check_success(ldinfo.svol_element_tag.is_valid());
 
    m_info.svol_element_tag  = ldinfo.svol_element_tag;
    m_info.svol_element_bbox = ldinfo.svol_bbox_i;
 
 
    // Append the volume sample program before the volume element
    scene_tool.current_group->append(colormap_tag, transaction);
 
    add_render_props(opt_map, scene_tool);
 
    std::pair<mi::neuraylib::Tag, std::string> prg_info = add_user_program(
        Volume_sample_program,
        nv::index::app::get_sint32(opt_map["user_program_mode"]),
        scene_info.rtc_program_source,
        svol_program, 
        scene_tool);
    scene_info.compute_launch_info.compute_program_tag = prg_info.first;
    scene_info.rtc_program_source = prg_info.second;
    scene_info.compute_launch_info.scene_element_tag = m_info.svol_element_tag;
    scene_tool.current_group->append(m_info.svol_element_tag, transaction);
 
    std::stringstream sstr;
    sstr << "Created a sparse volume: size = [" << opt_map["svol.size"] << "], tag = " << m_info.svol_element_tag.id;
    INFO_LOG << sstr.str();
 
    return true;
}
 
//index::camera::eye_point = 130.661270141602 30.0881538391113 79.4874954223633
//index::camera::view_direction = -0.906582176685333 0.0041832085698843 - 0.422008663415909
//index::camera::up_direction = 0 1 0
 
void Sparse_volume_setup::setup_camera(
    mi::neuraylib::Tag                  camera_tag,
    const Option_map&                   opt_map,
    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());
 
#if (SVOL_MODEL == 1)
    Vec3f from(-56.44580078125f, -1.99575769901276f, 76.410285949707f);
    Vec3f to(0.822186231613159f, 0.390750795602798f, -0.413912683725357f);
    Vec3f up(-0.223093569278717f, 0.890190124511719f, 0.397229105234146f);
#endif
#if (SVOL_MODEL == 2)
    Vec3f from(-112.29296875f, -7.79020595550537f, 154.107467651367f);
    Vec3f to(0.822186231613159f, 0.390750795602798f, -0.413912683725357f);
    Vec3f up(-0.223093569278717f, 0.890190124511719f, 0.397229105234146f);
#endif
 
    if (nv::index::app::get_sint32(opt_map["compute_plane"]) != 0) {
        from = Vec3f(130.661270141602f, 30.0881538391113f, 79.4874954223633f);
        to = Vec3f(-0.906582176685333f, 0.0041832085698843f, -0.422008663415909f);
        up = Vec3f(0.f, 1.f, 0.f);
    }
    
    Vec3f viewdir = to;// - from;
    viewdir.normalize();
 
    cam->set(from, viewdir, up);
    cam->set_aperture(0.033f);
    cam->set_focal(0.03f);
    cam->set_clip_min(0.001f);
    cam->set_clip_max(1500.0f);
}
 
 
 
 
 
bool Sparse_volume_setup::export_scene_data(
    mi::neuraylib::Tag                  session_tag,
    const Option_map&                   opt_map,
    mi::neuraylib::IDice_transaction*   transaction) const
{
    std::string svol_export_filename = 
        opt_map["export_directory"] +
        opt_map["export_file_name"] +
        opt_map["export_file_ext"];
    if (svol_export_filename.empty()) {
        return true;
    }
    INFO_LOG << "Exporting sparse volume data to " << svol_export_filename;
    if (!export_sparse_volume_data(
        m_info.svol_element_tag,
        m_info.svol_element_bbox,
        svol_export_filename,
        session_tag,
        transaction))
    {
        ERROR_LOG << "Failed to export sparse volume data "
            << "(volume scene element: " << m_info.svol_element_tag
            << ", volume export box: " << m_info.svol_element_bbox
            << ", export file: " << svol_export_filename << ").";
        return false;
    }
 
    return true;
}
 
 
void Sparse_volume_setup::unload_scene(
    mi::neuraylib::Tag                  session_tag, 
    const Option_map&                   opt_map, 
    mi::neuraylib::IDice_transaction*   transaction) const
{
    // 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());
 
    mi::base::Handle<nv::index::IStatic_scene_group> group(
        transaction->edit<nv::index::IStatic_scene_group>(m_info.svol_group_tag));
    check_success(group.is_valid_interface());
 
    group->remove(m_info.svol_element_tag, transaction);
 
    transaction->remove(m_info.svol_element_tag);
    m_info.svol_element_tag = mi::neuraylib::Tag();
    m_info.svol_element_bbox.clear();
}
 
 
bool Sparse_volume_setup::can_reload() const
{
    return true;
}
 
 
bool Sparse_volume_setup::reload_scene(
    Nvindex_access&                     nvindex_accessor,
    mi::neuraylib::Tag                  session_tag, 
    const Option_map&                   opt_map, 
    mi::neuraylib::IDice_transaction*   transaction) const
{
    // 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());
 
 
    // Sparse volume scene element/importer
    Svol_load_info ldinfo;
    ldinfo.input_dir        = opt_map["export_directory"];
    ldinfo.input_file_base  = opt_map["export_file_name"];
    ldinfo.input_file_ext   = opt_map["export_file_ext"];
    
    if (ldinfo.input_dir == "") { ldinfo.input_dir = "."; }
 
    load_sparse_volume_data(nvindex_accessor, ldinfo, opt_map, scene.get(), transaction);
    check_success(ldinfo.svol_element_tag.is_valid());
 
    m_info.svol_element_tag  = ldinfo.svol_element_tag;
    m_info.svol_element_bbox = ldinfo.svol_bbox_i;
 
    // reconnect to scene group
    mi::base::Handle<nv::index::IStatic_scene_group> group(
        transaction->edit<nv::index::IStatic_scene_group>(m_info.svol_group_tag));
    check_success(group.is_valid_interface());
 
    group->append(m_info.svol_element_tag, transaction);
    return true;
}
 
 
 
bool Sparse_volume_setup::supports_compute_plane() const
{
    return true;
}
 
 
const char* Sparse_volume_setup::plane_sample_func() const
{
    return plane_sample_function;
}
 
 
void Sparse_volume_setup::add_render_props(
    const Option_map&   opt_map,
    Scene_tool&         scene_tool)
{
    // Sparse volume rendering properties
    mi::base::Handle<nv::index::ISparse_volume_rendering_properties> svol_render_prop;
    scene_tool.create_attribute(svol_render_prop);
 
    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(Vec3f(0.f, 0.f, 0.f));
 
    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);
 
    scene_tool.store_and_add_to_group(svol_render_prop);
}
 
 
 
}//sparse_volume
}//xac_compute