render_frame.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/iindex.h>
#include <nv/index/isession.h>
#include <nv/index/iscene.h>
#include <nv/index/icamera.h>
 
#include <iostream>
#include <sstream>
 
#include <nv/index/app/application_layer_common_utility.h>
#include <nv/index/app/forwarding_logger.h>
#include <nv/index/app/index_connect.h>
#include <nv/index/app/string_dict.h>
#include <nv/index/app/time_functions.h>
 
//----------------------------------------------------------------------
class Render_frame:
        public nv::index::app::Index_connect
{
public:
    Render_frame()
        :
        Index_connect(),
        m_test_set_roi(true)
    {
        // INFO_LOG << "DEBUG: Render_frame() ctor";
    }
 
    virtual ~Render_frame()
    {
        // Note: Index_connect::~Index_connect() will be called after here.
        // INFO_LOG << "DEBUG: ~Render_frame() 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:
    // Setup camera to see this example scene
    // \param[in] cam    a camera
    void setup_camera(nv::index::IPerspective_camera* cam) const;
    // set up a scene for this example.
    //   - Set region of interest to the scene
    //   - Set default transformation matrix to the scene
    //   - Set the current active camera to the scene
    void setup_render_frame_scene(
        nv::index::IScene*                             scene_edit,
        const mi::math::Bbox_struct< mi::Float32, 3 >& xyz_roi_st,
        const mi::neuraylib::Tag&                      camera_tag,
        mi::neuraylib::IDice_transaction*              dice_transaction) 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;
    bool                                                                              m_test_set_roi;
};
 
//----------------------------------------------------------------------
mi::Sint32 Render_frame::launch()
{
    mi::Sint32 exit_code = 0;
    {
        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()));
 
        // Setup scene
        {
            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< nv::index::ISession const > session(
                    dice_transaction->access< nv::index::ISession const >(
                        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());
 
                //----------------------------------------------------------------------
                // Scene setup: Put nothing in the scene in this example
                //----------------------------------------------------------------------
 
                // 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(512, 512);
                m_image_file_canvas->set_resolution(buffer_resolution);
 
                // Set up the scene
                if(m_test_set_roi)
                {
                    mi::math::Bbox_struct< mi::Float32, 3 > const xyz_roi_st = {
                        { 0.0f, 0.0f, 0.0f, },
                        { 1.0f, 1.0f, 1.0f, },
                    };
                    setup_render_frame_scene(scene_edit.get(), xyz_roi_st, camera_tag,
                                             dice_transaction.get());
                }
                else
                {
                    ERROR_LOG << "The following error message about an invalid region of interest is expected";
                    // test case: not valid ROI set
                    mi::math::Bbox_struct< mi::Float32, 3 > const zero_xyz_roi_st = {
                        { 0.0f, 0.0f, 0.0f, },
                        { 0.0f, 0.0f, 0.0f, },
                    };
                    setup_render_frame_scene(scene_edit.get(), zero_xyz_roi_st, camera_tag,
                                             dice_transaction.get());
                }
            }
            dice_transaction->commit();
        }
 
        // Rendering call
        {
            // Set up the canvas according to the camera setup. It is
            // still valid if output_fname.empty() == true (no output
            // file)
            const mi::Sint32  frame_idx = 0;
            const std::string output_fname = get_output_file_name(m_outfname, frame_idx);
            m_image_file_canvas->set_rgba_file_name(output_fname.c_str());
 
            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();
        }
    }
    return exit_code;
}
 
//----------------------------------------------------------------------
bool Render_frame::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");
    }
 
    m_outfname     = sdict.get("outfname", "");
    m_test_set_roi = nv::index::app::get_bool(sdict.get("test_set_roi", "false"));
 
    info_cout(std::string("running ") + com_name, sdict);
    info_cout(std::string("outfname = [") + m_outfname +
              "], dice::verbose = "       + sdict.get("dice::verbose"), sdict);
 
    // print help and exit if -h
    if(sdict.is_defined("h"))
    {
        std::cout
            << "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"
            << "        [-outfname string]\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"
            << "        [-test_set_roi bool]\n"
            << "            when false, no ROI set.\n"
            << "            (default: [" << m_test_set_roi << "])\n"
            << std::endl;
        exit(1);
    }
    return true;
}
 
//----------------------------------------------------------------------
void Render_frame::setup_camera(nv::index::IPerspective_camera* cam) const
{
    check_success(cam != 0);
 
    // Set the camera parameters to see the whole scene
    mi::math::Vector< mi::Float32, 3 > const from(-3.67f, 24.35f, -40.85f);
    mi::math::Vector< mi::Float32, 3 > const to  ( 9.5, 9.5, -9.5);
    mi::math::Vector< mi::Float32, 3 > const 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(2.0f);
    cam->set_clip_max(420.0f);
}
 
//----------------------------------------------------------------------
void Render_frame::setup_render_frame_scene(
    nv::index::IScene*                             scene_edit,
    const mi::math::Bbox_struct< mi::Float32, 3 >& xyz_roi_st,
    const mi::neuraylib::Tag&                      camera_tag,
    mi::neuraylib::IDice_transaction*              dice_transaction) const
{
    check_success(dice_transaction != 0);
 
    // set the region of interest
    const mi::math::Bbox< mi::Float32, 3 > xyz_roi(xyz_roi_st);
    if(xyz_roi.is_volume())
    {
        scene_edit->set_clipped_bounding_box(xyz_roi_st);
    }
    else
    {
        INFO_LOG << "ROI has no volume, not set the ROI.";
    }
 
    // Set the scene 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.
    check_success(camera_tag.is_valid());
    scene_edit->set_camera(camera_tag);
}
 
//----------------------------------------------------------------------
// This examples shows how to use render call.
int main(int argc, const char* argv[])
{
    nv::index::app::String_dict sdict;
    sdict.insert("dice::verbose", "3");             // log level
    sdict.insert("outfname", "frame_render_frame"); // output file base name
    sdict.insert("unittest", "0");                  // default mode
    sdict.insert("test_set_roi", "1");              // ROI set/no-set test
    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");
 
    // Initialize application
    Render_frame render_frame;
    render_frame.initialize(argc, argv, sdict);
    check_success(render_frame.is_initialized());
 
    // launch the application. creating the scene and rendering.
    const mi::Sint32 exit_code = render_frame.launch();
    INFO_LOG << "Shutting down ...";
 
    return exit_code;
}