create_irregular_volume.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/iindex.h>
#include <nv/index/ilight.h>
#include <nv/index/imaterial.h>
#include <nv/index/iirregular_volume_scene_element.h>
#include <nv/index/iirregular_volume_subset.h>
#include <nv/index/iscene.h>
#include <nv/index/iconfig_settings.h>
#include <nv/index/iscene_group.h>
#include <nv/index/isession.h>
#include <nv/index/icolormap.h>
#include <nv/index/itexture.h>
#include <nv/index/ishading_model.h>
 
#include <nv/index/app/index_connect.h>
#include <nv/index/app/string_dict.h>
 
#include "utility/app_rendering_context.h"
#include "utility/canvas_utility.h"
 
#include <iostream>
#include <sstream>
 
//----------------------------------------------------------------------
class Create_irregular_volume:
    public nv::index::app::Index_connect
{
public:
    Create_irregular_volume()
        :
        Index_connect()
    {
        // INFO_LOG << "DEBUG: Create_irregular_volume() ctor";
    }
 
    virtual ~Create_irregular_volume()
    {
        // Note: Index_connect::~Index_connect() will be called after here.
        // INFO_LOG << "DEBUG: ~Create_irregular_volume() 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);
    }
    // override
    virtual bool initialize_debug_configuration(
        mi::neuraylib::IDebug_configuration* debug_configuration,
        nv::index::app::String_dict&         options) CPP11_OVERRIDE
    {
        check_success(debug_configuration != 0);
        debug_configuration->set_option("check_serializer_store=1");
        return true;
    }
private:
    nv::index::IColormap* create_colormap(nv::index::IScene* scene);
 
    // Create the scene with an irregular volume.
    //
    // \param[in] ivol_file        an irregular volume file name.
    // \param[in] ivol_bbox        bounding box of the irregular volume, this is also needed for the view computation.
    // \param[in] ivol_max_seg_len length of the longest edge in the irregular volume mesh.
    // \param[in] scene_edit       IScene interface
    // \param[in] dice_transaction dice transaction
    //
    // \return true when success
    //
    bool create_scene(
        const std::string&                     ivol_file,
        const mi::math::Bbox<mi::Float32, 3>&  ivol_bbox,
        const mi::Float32                      ivol_max_seg_len,
        nv::index::IScene*                     scene_edit,
        mi::neuraylib::IDice_transaction*      dice_transaction);
 
    // setup camera to see this example scene
    //
    // \param[in] cam a camera
    void setup_camera(nv::index::IPerspective_camera* cam) const;
 
    void view_all_bbox(
        const mi::math::Vector<mi::Float32, 3>& from,
        const mi::math::Vector<mi::Float32, 3>& up,
        const mi::math::Bbox< mi::Float32, 3 >& bbox,
        const mi::neuraylib::Tag&               camera_tag,
        nv::index::IScene*                      scene_edit,
        mi::neuraylib::IDice_transaction*       dice_transaction) 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_irregular_volume
    bool                          m_is_unittest;
    std::string                   m_ivol_file;
    mi::Float32                   m_ivol_max_seg_len;   
    mi::math::Bbox<mi::Float32,3> m_roi;              
    bool                          m_ivol_set_pickable;
    std::string                   m_outfname;
    std::string                   m_verify_image_fname;
    bool                          m_supersampling;
};
 
//----------------------------------------------------------------------
mi::Sint32 Create_irregular_volume::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());
 
        mi::base::Handle<nv::index::IIndex_scene_query> iindex_query(
            get_index_interface()->get_api_component<nv::index::IIndex_scene_query>());
        check_success(iindex_query.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()));
        {
            // DiCE database access
            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 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<const nv::index::ISession>(m_session_tag));
                check_success(session.is_valid_interface());
 
                mi::base::Handle< nv::index::IScene > scene_edit(
                    dice_transaction->edit< nv::index::IScene >(session->get_scene()));
                check_success(scene_edit.is_valid_interface());
 
                // Enable supersampling
                if (m_supersampling)
                {
                    mi::base::Handle<nv::index::IConfig_settings> config_settings(
                        dice_transaction->edit<nv::index::IConfig_settings>(session->get_config()));
                    check_success(config_settings.is_valid_interface());
 
                    config_settings->set_rendering_samples(8);
                }
 
                //----------------------------------------------------------------------
                // Scene setup: hierarchical scene description root node,
                // scene parameters, camera.
                //----------------------------------------------------------------------
                // Create a hierarchical scene description that contains the triangle mesh
                check_success(create_scene(m_ivol_file, m_roi, m_ivol_max_seg_len, scene_edit.get(), dice_transaction.get()));
 
                // Create and edit a camera. Data distribution is based on
                // the camera. (Because only visible massive data are
                // considered)
                mi::base::Handle< nv::index::IPerspective_camera > cam(
                    scene_edit->create_camera<nv::index::IPerspective_camera>());
                check_success(cam.is_valid_interface());
                setup_camera(cam.get());
                const mi::neuraylib::Tag camera_tag = dice_transaction->store(cam.get());
                check_success(camera_tag.is_valid());
 
                const mi::math::Vector<mi::Uint32, 2> buffer_resolution(1024, 1024);
                m_image_file_canvas->set_resolution(buffer_resolution);
 
                // Set up the scene
                // const mi::math::Bbox< mi::Float32, 3 > xyz_roi_st = m_roi;
 
                // The the colormap to demonstrate color index color mapping.
                mi::base::Handle<nv::index::IColormap> colormap(create_colormap(scene_edit.get()));
                check_success(colormap.is_valid_interface());
 
                // Store in DiCE database.
                const mi::neuraylib::Tag colormap_tag = dice_transaction->store_for_reference_counting(
                    colormap.get(), mi::neuraylib::NULL_TAG, "colormap");
                check_success(colormap_tag.is_valid());
                scene_edit->prepend(colormap_tag, dice_transaction.get());
 
                // Set the region of interest.
                check_success(m_roi.is_volume());
                scene_edit->set_clipped_bounding_box(m_roi);
 
                // Set the scene global transformation matrix.
                // only change the coordinate system
                mi::math::Matrix<mi::Float32, 4, 4> transform_mat(
                    1.0f,  0.0f,  0.0f,  0.0f,
                    0.0f,  1.0f,  0.0f,  0.0f,
                    0.0f,  0.0f, -1.0f,  0.0f,
                    0.0f,  0.0f,  0.0f,  1.0f
                    );
 
                scene_edit->set_transform_matrix(transform_mat);
 
                // Set the current camera to the scene.
                scene_edit->set_camera(camera_tag);
 
                const mi::math::Vector<mi::Float32, 3> from(0.0f, 0.0f, 1.0f);
                const mi::math::Vector<mi::Float32, 3> up  (0.0f, 1.0f, 0.0f);
                view_all_bbox(from, up, m_roi, camera_tag, scene_edit.get(), dice_transaction.get());
            }
            dice_transaction->commit();
        }
 
        // Rendering
        {
            // Render a frame and save the rendered image to a file.
            const mi::Sint32  frame_idx = 0;
            const std::string fname = get_output_file_name(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;
            }
        }
    }
 
    return exit_code;
}
//----------------------------------------------------------------------
bool Create_irregular_volume::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");
    }
 
    // Set own options
    m_ivol_file          = sdict.get("ivol_file");
    m_ivol_max_seg_len   = nv::index::app::get_float32(sdict.get("ivol_max_seg_len"));
    m_roi                = nv::index::app::get_bbox_from_string<mi::Float32,3>(std::string(sdict.get("roi")));                
    m_ivol_set_pickable  = nv::index::app::get_bool(sdict.get("ivol_set_pickable"));
    m_outfname           = sdict.get("outfname", "");
    m_verify_image_fname = sdict.get("verify_image_fname", "");
    m_supersampling      = nv::index::app::get_bool(sdict.get("supersampling"));
        
    info_cout(std::string("running ") + com_name, sdict);
    info_cout(std::string("outfname = [") + m_outfname +
              "], verify_image_fname = [" + m_verify_image_fname +
              "], 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"
            << "            printout this message\n"
 
            << "        [-dice::verbose severity_level]\n"
            << "            verbose severity level (3 is info.). (default: " + sdict.get("dice::verbose")
            << ")\n"
 
            << "        [-ivol_file string]\n"
            << "            name of the irregular volume file (in .ts format). When empty, the default file will be used.\n"
            << "            (default: [" << m_ivol_file << "])\n"
 
            << "        [-ivol_max_seg_len float]\n"
            << "            the length of the longest edge in the irregular volume mesh.\n"
            << "            (default: [" << m_ivol_max_seg_len << "])\n"
 
            << "        [-roi \"float float float float float float\"]\n"
            << "            the bounding box representing the region of interest (roi).\n"
            << "            (default: [" << m_roi << "])\n"
 
            << "        [-ivol_set_pickable bool]\n"
            << "            enable/disable picking for the mesh."
            << "(default: " << m_ivol_set_pickable << ")\n"
 
            << "        [-outfname string]\n"
            << "            name of the output ppm image file. When empty, no image file will be written.\n"
            << "            A frame number and the extension (.ppm) will be added.\n"
            << "            (default: [" << m_outfname << "])\n"
            
            << "        [-verify_image_fname [image_fname]]\n"
            << "            when image_fname exist, verify the rendering image. (default: ["
            << m_verify_image_fname << "])\n"
 
            << "        [-supersampling bool]\n"
            << "            when true then supersampling is enabled."
            << " (default: " << m_supersampling << ")\n"
 
            << "        [-unittest bool]\n"
            << "            when true, unit test mode."
            << " (default: " << m_is_unittest << ")"
            << std::endl;
        exit(1);
    }
    return true;
}
 
//----------------------------------------------------------------------
nv::index::IColormap* Create_irregular_volume::create_colormap(nv::index::IScene* scene)
{
    nv::index::IColormap* colormap = scene->create_attribute<nv::index::IColormap>();
    std::vector<mi::math::Color_struct> colormap_entries;
 
    colormap_entries.resize(256);
    for(mi::Uint32 i=0; i<256; ++i)
    {
        colormap_entries[i].r = (256.f-static_cast<mi::Float32>(i))/256.f;
        colormap_entries[i].g = (256.f-static_cast<mi::Float32>(255 - i))/256.f;
        colormap_entries[i].b = 1.f;
        colormap_entries[i].a = 0.5f;
    }
 
    // Set colormap domain
    colormap->set_domain_boundary_mode(nv::index::IColormap::CLAMP_TO_EDGE);
    colormap->set_domain(0.2f, 1.0f);
 
    // Set the the colormap values.
    colormap->set_colormap(&(colormap_entries[0]), colormap_entries.size());
    return colormap;
}
 
//----------------------------------------------------------------------
bool Create_irregular_volume::create_scene(
    const std::string&                     ivol_file,
    const mi::math::Bbox<mi::Float32, 3>&  ivol_bbox,
    const mi::Float32                      ivol_max_seg_len,
    nv::index::IScene*                     scene_edit,
    mi::neuraylib::IDice_transaction*      dice_transaction)
{
    check_success(scene_edit != 0);
    check_success(dice_transaction != 0);
 
    // Irregular volume
    std::stringstream sstr;
    sstr << m_roi.min.x << " " << m_roi.min.y << " " << m_roi.min.z << " " 
         << m_roi.max.x << " " << m_roi.max.y << " " << m_roi.max.z;
    const std::string roi_str = sstr.str();
    
    nv::index::app::String_dict irregular_volume_opt;
    irregular_volume_opt.insert("args::type",       "sparse_volume");
    irregular_volume_opt.insert("args::importer",   "nv::index::plugin::base_importer.Irregular_volume_importer");
    irregular_volume_opt.insert("args::input_file", m_ivol_file.c_str());
    irregular_volume_opt.insert("args::bbox",       roi_str.c_str());
 
    nv::index::IDistributed_data_import_callback* importer_callback =
        get_importer_from_application_layer(get_application_layer_interface(),
                                            "nv::index::plugin::base_importer.Irregular_volume_importer",
                                            irregular_volume_opt);
 
    // Create the triangle mesh scene element
    mi::base::Handle<nv::index::IIrregular_volume_scene_element> ivol_elem(
        scene_edit->create_irregular_volume(ivol_bbox, ivol_max_seg_len, importer_callback, dice_transaction));
    check_success(ivol_elem != 0);
 
    // Scene element properties
    ivol_elem->set_enabled(true);
    ivol_elem->set_pickable(m_ivol_set_pickable);
 
    // Storing the irregular volume in the data (base) store
    mi::neuraylib::Tag ivol_tag = dice_transaction->store_for_reference_counting(ivol_elem.get());
    check_success(ivol_tag.is_valid());
 
    // Create a static scene group
    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());
 
    // append mesh to the static scene group
    static_group->append(ivol_tag, dice_transaction);
 
    mi::neuraylib::Tag static_group_tag = dice_transaction->store(static_group.get());
    check_success(static_group_tag.is_valid());
 
    // append the static scene group to the hierachical scene description.
    scene_edit->append(static_group_tag, dice_transaction);
 
    return true;
}
 
//----------------------------------------------------------------------
void Create_irregular_volume::setup_camera(nv::index::IPerspective_camera* cam) const
{
    check_success(cam != 0);
 
    // Initialize the camera with some default parameters ...
    const mi::math::Vector< mi::Float32, 3 > from( 0.0f, 0.0f,-5.0f);
    const mi::math::Vector< mi::Float32, 3 > to  ( 0.0f, 0.0f, 0.0f);
    const mi::math::Vector< mi::Float32, 3 > up  ( 0.0f, 1.0f, 0.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(10.0f);
    cam->set_clip_max(5000.0f);
}
 
//----------------------------------------------------------------------
void Create_irregular_volume::view_all_bbox(
    const mi::math::Vector<mi::Float32, 3>& from,
    const mi::math::Vector<mi::Float32, 3>& up,
    const mi::math::Bbox< mi::Float32, 3 >& bbox,
    const mi::neuraylib::Tag&               camera_tag,
    nv::index::IScene*                      scene_edit,
    mi::neuraylib::IDice_transaction*       dice_transaction) const
{
    check_success(dice_transaction != 0);
 
    if(bbox.empty())
    {
        WARN_LOG << "Un-initialized bounding box and not updating the camera settings.";
        return;
    }
 
    {
        mi::base::Handle<nv::index::IPerspective_camera> camera(dice_transaction->edit<nv::index::IPerspective_camera>(camera_tag));
        check_success(camera.is_valid_interface());
 
        // Compute the new camera parameters
        const mi::math::Bbox< mi::Float32, 3 >& global_roi_bbox  = scene_edit->get_clipped_bounding_box();
        const mi::math::Matrix<mi::Float32, 4, 4>& transform_mat = scene_edit->get_transform_matrix();
        const mi::math::Vector<mi::Float32, 3> new_min(mi::math::transform_point(transform_mat, global_roi_bbox.min));
        const mi::math::Vector<mi::Float32, 3> new_max(mi::math::transform_point(transform_mat, global_roi_bbox.max));
        const mi::math::Bbox< mi::Float32, 3 > transformed_bbox(new_min, new_max);
        const mi::math::Vector<mi::Float32, 3>& min    = transformed_bbox.min;
        const mi::math::Vector<mi::Float32, 3>& max    = transformed_bbox.max;
        const mi::math::Vector<mi::Float32, 3>& center = transformed_bbox.center();
        const mi::Float32 rad = mi::math::euclidean_distance(max, min) / 2.0f;
 
        const mi::Float32 fov_rad_2 = static_cast<mi::Float32>(camera->get_fov_y_rad() / 2.0);
        const mi::Float32 dist = rad / static_cast<mi::Float32>(tan(fov_rad_2));
 
        const mi::math::Vector<mi::Float32, 3> eyepos = -(1.f * dist * from) + center;
        camera->set_eye_point(eyepos);
        camera->set_up_direction(up);
 
        const mi::Float32 clip_min = 0.1f * dist;
        const mi::Float32 clip_max = 10.0f * 1.f * dist;
 
        camera->set_clip_min(clip_min);
        camera->set_clip_max(clip_max);
 
        mi::math::Vector<mi::Float32, 3> viewdir = center - eyepos;
        check_success(viewdir.normalize());
        camera->set_view_direction(viewdir);
    }
}
 
//----------------------------------------------------------------------
nv::index::IFrame_results* Create_irregular_volume::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();
}
 
//----------------------------------------------------------------------
int main(int argc, const char* argv[])
{
    nv::index::app::String_dict sdict;
    sdict.insert("dice::verbose", "3");                              // log level
    sdict.insert("ivol_file", "../create_irregular_volume/spx.ts");  // input triangle mesh file name
    sdict.insert("ivol_max_seg_len", "1.07534");                     // maximum segment length in the irregular volume mesh
    sdict.insert("roi", "4.061 0.000 -8.670 10.000 6.947 0.725");    // input roi
    sdict.insert("outfname", "frame_create_irregular_volume");       // output file base name
    sdict.insert("verify_image_fname", "");                          // for unit test
    sdict.insert("unittest", "0");                                   // default mode
    sdict.insert("supersampling", "0");                              // disable supersampling (default)
    sdict.insert("ivol_set_pickable", "1");                          // define is the mesh shall be pickable
    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.
 
    // Load IndeX library via Index_connect
    sdict.insert("dice::network::mode", "OFF");
 
    // index setting
    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 component loading
    sdict.insert("index::app::components::application_layer::component_name_list",
                  "canvas_infrastructure image io");
    sdict.insert("index::app::plugins::base_importer::enabled", "true");
 
    Create_irregular_volume create_irregular_volume;
    create_irregular_volume.initialize(argc, argv, sdict);
 
    // launch the application. creating the scene and rendering.
    const mi::Sint32 exit_code = create_irregular_volume.launch();
    INFO_LOG << "Shutting down ...";
 
    return exit_code;
}