dynamic_point_set.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/ipoint_set.h>
#include <nv/index/iscene.h>
#include <nv/index/isession.h>
 
#include <iostream>
#include <sstream>
 
#include "utility/frame_command.h"
 
#include <nv/index/app/index_connect.h>
#include <nv/index/app/string_dict.h>
#include <nv/index/app/time_functions.h>
 
//----------------------------------------------------------------------
class Dynamic_point_set:
    public nv::index::app::Index_connect
{
public:
    Dynamic_point_set()
        :
        Index_connect(),
        m_is_unittest(false),
        m_max_iter(0),
        m_resolution_x(0),
        m_resolution_y(0),
        m_roi_x(0),
        m_roi_y(0),
        m_roi_z(0),
        m_is_save_all_frame(false),
        m_is_animation_on(false)
    {
        // INFO_LOG << "DEBUG: Dynamic_point_set() ctor";
    }
 
    virtual ~Dynamic_point_set()
    {
        // Note: Index_connect::~Index_connect() will be called after here.
        // INFO_LOG << "DEBUG: ~Dynamic_point_set() 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:
    // attribute to color map example
    // \param[in] attrib attribute value
    // \return color defined by an attribute
    mi::math::Color_struct get_color_st_from_attribute(mi::Sint32 attrib) const;
    // attribute to radius map example
    // \param[in] attrib attribute value
    // \return a radius corresponding to the attribute value
    mi::Float32 get_radius_from_attribute(mi::Sint32 attrib) const;
    // create point set in the scene.
    // \param[in]  session_tag session tag
    // \param[in]  dice_transaction dice transaction
    void create_point_set(
        const mi::neuraylib::Tag&         session_tag,
        mi::neuraylib::IDice_transaction* dice_transaction);
    
    // translate point set
    //
    // \param[in] point_set_tag point set tag to translate the position
    // \param[in] trans_delta_vec translation delta vector
    // \param[in] dice_transaction dice transaction
    void translate_point_set(
        const mi::neuraylib::Tag&                 point_set_tag,
        const mi::math::Vector< mi::Float32, 3 >& trans_delta_vec,
        mi::neuraylib::IDice_transaction*         dice_transaction) const;
    // delete scene element
    // \param[in] scene_element_tag scene element tag to be deleted
    // \param[in] transform_tag     transform tag
    // \param[in] dice_transaction  dice transaction
    void delete_scene_element(
        const mi::neuraylib::Tag&         scene_element_tag,
        const mi::neuraylib::Tag&         transform_tag,
        mi::neuraylib::IDice_transaction* dice_transaction) const;
    
    // All top view
    //
    // Note: this function assumes that the screen shape is height <=
    // width resolution.
    //
    // \param[in]  vbbox  viewing bounding box
    // \param[in]  aspect aspect ratio of the screen
    // \param[in]  fovy_2 half of fov of y in radian
    // \param[out] from   camera from
    // \param[out] to     camera to
    // \param[out] up     camera up
    // \param[out] clip_min cliping plane min distance
    // \param[out] clip_max cliping plane max distance
    void get_top_view_param(const mi::math::Bbox<mi::Float32, 3>& vbbox,
                            const mi::Float32                     aspect,
                            const mi::Float32                     fovy_2,
                            mi::math::Vector< mi::Float32, 3 >&   from,
                            mi::math::Vector< mi::Float32, 3 >&   to,
                            mi::math::Vector< mi::Float32, 3 >&   up,
                            mi::Float32                       &   clip_min,
                            mi::Float32                       &   clip_max) const;
    
    // get resolution from opt
    mi::math::Vector<mi::Uint32, 2> get_resolution() const;
    
    // setup camera to see this example scene
    // \param[in] cam        a camera
    // \param[in] roi_max    region of interest max (min is fixed to (0,0,0)
    // \param[in] dice_transaction dice transaction
    void setup_camera(
        nv::index::IPerspective_camera*        cam,
        const mi::math::Vector<mi::Uint32, 3>& roi_max,
        mi::neuraylib::IDice_transaction*      dice_transaction) const;
    
    // set up as the main host
    // \return true when success
    bool setup_main_host();
    
    // animate point
    // \param[in] session_tag session tag
    // \param[in] frame_idx  current frame index used for animate the point set
    // \param[in] dice_transaction dice transaction
    void animate_point(
        const mi::neuraylib::Tag&         session_tag,
        mi::Sint32                        frame_idx,
        mi::neuraylib::IDice_transaction* dice_transaction);
    
    // 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;
    
    // update the scene and render a frame
    // \param[in] frame_idx current frame index
    // \return true when success
    bool update_scene_and_render_frame(mi::Sint32 frame_idx);
    
    // main host rendering loop
    // \return true when success
    bool mainhost_rendering_loop();
 
    // set up dynamic scene: points
    void setup_animation();
 
    // 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;
    mi::Sint32                                                                        m_max_iter;
    mi::Uint32                                                                        m_resolution_x;
    mi::Uint32                                                                        m_resolution_y;
    mi::Sint32                                                                        m_roi_x;
    mi::Sint32                                                                        m_roi_y;
    mi::Sint32                                                                        m_roi_z;
    bool                                                                              m_is_save_all_frame;
    bool                                                                              m_is_animation_on;
    // group node tag which contains point_set
    mi::neuraylib::Tag                                                                m_point_set_group_tag;
    // point_set tag
    mi::neuraylib::Tag                                                                m_point_set_tag;
    // dynamic scene commands. Use as a stack
    std::vector<Frame_command>                                                        m_frame_command_vec;
};
 
//----------------------------------------------------------------------
mi::Sint32 Dynamic_point_set::launch()
{
    // required on host side too
    nv::index::app::util::time::sleep(0.1f); // wait for 0.1 second
 
    // setup main host
    check_success(setup_main_host());
 
    // set up dynamic scene
    setup_animation();
 
    // call main host rendering loop
    mainhost_rendering_loop();
 
    return 0;
}
 
//----------------------------------------------------------------------
bool Dynamic_point_set::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("max_iter", "20");
        sdict.insert("outfname", ""); // turn off file output in the unit test mode
        sdict.insert("dice::verbose", "2");
    }
 
    m_outfname          = sdict.get("outfname");
    m_max_iter          = nv::index::app::get_sint32(sdict.get("max_iter"));
    m_resolution_x      = nv::index::app::get_uint32(sdict.get("resolution_x"));
    m_resolution_y      = nv::index::app::get_uint32(sdict.get("resolution_y"));
    m_roi_x             = nv::index::app::get_sint32(sdict.get("roi_x"));
    m_roi_y             = nv::index::app::get_sint32(sdict.get("roi_y"));
    m_roi_z             = nv::index::app::get_sint32(sdict.get("roi_z"));
    m_is_save_all_frame = nv::index::app::get_bool(sdict.get("is_save_all_frame"));
    m_is_animation_on   = nv::index::app::get_bool(sdict.get("is_animation_on"));
 
    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
            << "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"
 
            << "        [-dice::network::multicast_address address]\n"
            << "            set multicast address. (default: "
            << sdict.get("dice::network::multicast_address") + ")\n"
 
            << "        [-max_iter number_of_iteration]\n"
            << "            set rendering loop iterations. default: " << m_max_iter
            << " frames\n"
 
            << "        [-resolution_x int] [-resolution_y int]\n"
            << "            screen resolution x and y. (default " << m_resolution_x
            << " " << m_resolution_y<< ")\n"
 
            << "        [-roi_x int] [-roi_y int] [-roi_z int]\n"
            << "            region of interest max position.\n"
            << "            (The min position is set to (0,0,0).)\n"
            << "            (default: " << m_roi_x << " " << m_roi_y << " " << m_roi_z << ")\n"
 
            << "        [-outfname string]\n"
            << "            output ppm file base name. When "", no output.\n"
            << "            The frame number and extension(.ppm) will be added.\n"
            << "            (default: " << m_outfname << ")\n"
 
            << "        [-is_save_all_frame bool]\n"
            << "            when 1, save only the last frame. (default: "
            << m_is_save_all_frame << ")\n"
 
            << "        [-is_animation_on bool]\n"
            << "            when 1, points are animated in every frame. (default: "
            << m_is_animation_on << ")\n"
 
            << "        [-unittest bool]\n"
            << "            when true, unit test mode (create smaller volume). "
            << "(default: " << m_is_unittest << ")"
            << std::endl;
        exit(1);
    }
    return true;
}
 
//----------------------------------------------------------------------
mi::math::Color_struct Dynamic_point_set::get_color_st_from_attribute(mi::Sint32 attrib) const
{
    const mi::Sint32 intval = abs(attrib);
    mi::math::Color_struct col;
    const mi::Float32 coef = 1.0f / 15.0f;
    col.r = coef * static_cast< mi::Float32 >(intval & 15);
    col.g = coef * static_cast< mi::Float32 >((intval >> 4) & 15);
    col.b = coef * static_cast< mi::Float32 >((intval >> 8) & 15);
    col.a = 1.0;
 
    return col;
}
 
//----------------------------------------------------------------------
mi::Float32 Dynamic_point_set::get_radius_from_attribute(mi::Sint32 attrib) const
{
    const mi::Float32 rad = static_cast< mi::Float32 >(abs(attrib) % 12);
    return rad;
}
 
//----------------------------------------------------------------------
void Dynamic_point_set::create_point_set(
    const mi::neuraylib::Tag&         session_tag,
    mi::neuraylib::IDice_transaction* dice_transaction)
{
    check_success(session_tag.is_valid());
    check_success(dice_transaction != 0);
 
    mi::base::Handle<nv::index::ISession const> session(
        dice_transaction->access<nv::index::ISession const>(
            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());
 
    mi::base::Handle<nv::index::ITransformed_scene_group> group_node(
        scene_edit->create_scene_group<nv::index::ITransformed_scene_group>());
    check_success(group_node.is_valid_interface());
 
    // add a light and a material
    {
        // Add a light
        mi::base::Handle<nv::index::IDirectional_headlight> headlight(
            scene_edit->create_attribute<nv::index::IDirectional_headlight>());
        check_success(headlight.is_valid_interface());
        const mi::math::Color_struct color_intensity = { 1.0f, 1.0f, 1.0f, 1.0f, };
        headlight->set_intensity(color_intensity);
        headlight->set_direction(mi::math::Vector<mi::Float32, 3>(1.0f, -1.0f, -1.0f));
        const mi::neuraylib::Tag headlight_tag = dice_transaction->store_for_reference_counting(headlight.get());
        check_success(headlight_tag.is_valid());
        group_node->append(headlight_tag, dice_transaction);
 
        // add material for 3D points shape (the material is only effective for 3D shape)
        mi::base::Handle<nv::index::IPhong_gl> phong_1(scene_edit->create_attribute<nv::index::IPhong_gl>());
        check_success(phong_1.is_valid_interface());
        phong_1->set_ambient(mi::math::Color(0.3f, 0.3f, 0.3f, 1.0f));
        phong_1->set_diffuse(mi::math::Color(0.4f, 0.4f, 0.4f, 1.0f));
        phong_1->set_specular(mi::math::Color(0.4f));
        phong_1->set_shininess(100.f);
        const mi::neuraylib::Tag phong_1_tag = dice_transaction->store_for_reference_counting(phong_1.get());
        check_success(phong_1_tag.is_valid());
        group_node->append(phong_1_tag, dice_transaction);
    }
 
    // Point coordinates and its attributes. According to the
    // attributes, color and radius are defined.
    // Here, we create two point sets.
    std::vector< mi::math::Vector_struct< mi::Float32, 3> > point_pos_vec;
    std::vector< mi::math::Color_struct >                   color_vec;
    std::vector< mi::Float32 >                              radii_vec;
 
    // square shaped positions
    const mi::Sint32  column_count= 20;
    const mi::Sint32  point_count = 200;
    const mi::Float32 x_mag = 25.0;
    const mi::Float32 y_mag = 25.0;
    const mi::Float32 z     = 30.0;
    const mi::Float32 y_offset = 0.0f;
    for(mi::Sint32 i = 0; i < point_count; ++i){
        mi::math::Vector_struct< mi::Float32, 3> pos;
        pos.x = static_cast< mi::Float32 >(i % column_count) * x_mag;
        pos.y = static_cast< mi::Float32 >(i / column_count) * y_mag + y_offset;
        pos.z = z;
        point_pos_vec.push_back(pos);
        color_vec.push_back(get_color_st_from_attribute(i));
        radii_vec.push_back(get_radius_from_attribute(i));
    }
 
    // Create a point sets
    mi::base::Handle< nv::index::IPoint_set > point_set(scene_edit->create_shape<nv::index::IPoint_set>());
    check_success(point_set.is_valid_interface());
 
    nv::index::IPoint_set::Point_style style =nv::index::IPoint_set::SHADED_CIRCLE;
    point_set->set_point_style(style);
    point_set->set_vertices(&point_pos_vec[0], point_pos_vec.size());
    point_set->set_colors(  &color_vec[0],     color_vec.size());
    point_set->set_radii(   &radii_vec[0],     radii_vec.size());
 
    // Add the points to the database
    m_point_set_tag = dice_transaction->store_for_reference_counting(point_set.get());
    // if you are not registered Attribute_point_set, the next check fails.
    check_success(m_point_set_tag.is_valid());
 
    // Add to the scene description
    group_node->append(m_point_set_tag, dice_transaction);
    INFO_LOG << "Added point_set (size: " << point_count << ") to the scene (tag id: "
             << m_point_set_tag.id << ").";
 
    m_point_set_group_tag = dice_transaction->store_for_reference_counting(group_node.get());
    check_success(m_point_set_group_tag.is_valid());
    scene_edit->append(m_point_set_group_tag, dice_transaction);
}
 
//----------------------------------------------------------------------
void Dynamic_point_set::translate_point_set(
    const mi::neuraylib::Tag&                 point_set_tag,
    const mi::math::Vector< mi::Float32, 3 >& trans_delta_vec,
    mi::neuraylib::IDice_transaction*         dice_transaction) const
{
    check_success(point_set_tag.is_valid());
    check_success(dice_transaction != 0);
 
    mi::base::Handle< nv::index::IPoint_set > point_set(
        dice_transaction->edit< nv::index::IPoint_set >(point_set_tag));
    check_success(point_set.is_valid_interface());
 
    mi::Size const vertex_count = point_set->get_nb_vertices();
    if(vertex_count == 0)
    {
        // no vertices
        return;
    }
 
    mi::math::Vector_struct<mi::Float32, 3> const * const p_vtx = point_set->get_vertices();
    check_success(p_vtx != 0);
 
    std::vector< mi::math::Vector_struct<mi::Float32, 3> > vcopy;
    vcopy.reserve(vertex_count);
 
    for(mi::Uint32 i = 0; i < vertex_count; ++i)
    {
        mi::math::Vector_struct<mi::Float32, 3> vpos = p_vtx[i];
        vpos.x += trans_delta_vec.x;
        vpos.y += trans_delta_vec.y;
        vpos.z += trans_delta_vec.z;
        vcopy.push_back(vpos);
    }
    check_success(vcopy.size() == vertex_count);
 
    point_set->set_vertices(&(vcopy[0]), vcopy.size());
}
 
//----------------------------------------------------------------------
void Dynamic_point_set::delete_scene_element(
    const mi::neuraylib::Tag&         scene_element_tag,
    const mi::neuraylib::Tag&         transform_tag,
    mi::neuraylib::IDice_transaction* dice_transaction) const
{
    check_success(scene_element_tag.is_valid());
    check_success(transform_tag.is_valid());
    check_success(dice_transaction != 0);
 
    mi::base::Handle<nv::index::ITransformed_scene_group> group_node(
        dice_transaction->edit<nv::index::ITransformed_scene_group>(transform_tag));
    check_success(group_node.is_valid_interface());
 
    group_node->remove(scene_element_tag, dice_transaction);
 
    std::stringstream sstr;
    sstr << "scene element: " << scene_element_tag.id;
    DEBUG_LOG << sstr.str() << " was removed from the scene.";
}
 
//----------------------------------------------------------------------
void Dynamic_point_set::get_top_view_param(const mi::math::Bbox<mi::Float32, 3>& vbbox,
                                           const mi::Float32                     aspect,
                                           const mi::Float32                     fovy_2,
                                           mi::math::Vector< mi::Float32, 3 >&   from,
                                           mi::math::Vector< mi::Float32, 3 >&   to,
                                           mi::math::Vector< mi::Float32, 3 >&   up,
                                           mi::Float32                       &   clip_min,
                                           mi::Float32                       &   clip_max) const
{
    check_success((0.0 < fovy_2) && (fovy_2 < M_PI_2));
    const mi::Float32 dist = static_cast<mi::Float32>((0.6 * mi::math::euclidean_distance(vbbox.max, vbbox.min)) /
                                                      (sqrt(2.0) * tan(fovy_2)));
    from = -(dist * mi::math::Vector< mi::Float32, 3 >(0.0f, 0.0f, -1.0f)) + vbbox.center();
    to   = vbbox.center();
    up   = mi::math::Vector< mi::Float32, 3 >(0.0f, 1.0f, 0.0f);
    clip_min = 0.1f  * dist;
    clip_max = 10.0f * dist;
}
 
//----------------------------------------------------------------------
mi::math::Vector<mi::Uint32, 2> Dynamic_point_set::get_resolution() const
{
    mi::math::Vector<mi::Uint32, 2> res(m_resolution_x, m_resolution_y);
    if((res.x == 0) || (res.y == 0))
    {
        ERROR_LOG << "illegal_resolution setting: [" << res.x << "x" << res.y << "], use 1024x1024.";
        res.x = 1024;
        res.y = 1024;
    }
    return res;
}
 
//----------------------------------------------------------------------
void Dynamic_point_set::setup_camera(
    nv::index::IPerspective_camera*        cam,
    const mi::math::Vector<mi::Uint32, 3>& roi_max,
    mi::neuraylib::IDice_transaction*      dice_transaction) const
{
    check_success(cam != 0);
 
    cam->set_aperture(0.033f);
    cam->set_focal(0.03f);
 
    const mi::math::Vector<mi::Uint32, 2> res = get_resolution();
    const mi::Float32 pix_aspect_ratio_1x1 = 1.0f;
    // static_cast< mi::Float32 >(res.x) / static_cast< mi::Float32 >(res.y);
 
    cam->set_aspect(pix_aspect_ratio_1x1);
 
    // get top view for this scene
    mi::math::Bbox< mi::Float32, 3 > const
        vbbox(0.0f, 0.0f, 0.0f,
              static_cast< mi::Float32>(roi_max.x), static_cast< mi::Float32>(roi_max.y),
              static_cast< mi::Float32>(roi_max.z));
    mi::math::Vector< mi::Float32, 3 > from(0.0f, 0.0f, 0.0f);
    mi::math::Vector< mi::Float32, 3 > to  (0.0f, 0.0f, 0.0f);
    mi::math::Vector< mi::Float32, 3 > up  (0.0f, 0.0f, 0.0f);
    mi::Float32 clip_min =  0.1f;
    mi::Float32 clip_max = 10.0f;
    get_top_view_param(vbbox,
                       static_cast<mi::Float32>(cam->get_aspect()),
                       static_cast<mi::Float32>((cam->get_fov_y_rad() / 2.0)),
                       from, to, up, clip_min, clip_max);
 
    INFO_LOG << "set camera resolution [" << res.x << " " << res.y
             << "], aspect_ratio: " << pix_aspect_ratio_1x1;
 
    mi::math::Vector<mi::Float32, 3> viewdir = to - from;
    viewdir.normalize();
 
    cam->set(from, viewdir, up);
    cam->set_clip_min(clip_min);
    cam->set_clip_max(clip_max);
}
 
//----------------------------------------------------------------------
bool Dynamic_point_set::setup_main_host()
{
    // roi max
    mi::math::Vector< mi::Uint32, 3 > roi_max(m_roi_x, m_roi_y, m_roi_z);
    for(mi::Sint32 i = 0; i < 3; ++i)
    {
        if(roi_max[i] <= 0)
        {
            ERROR_LOG << "illegal roi setting: [" << i <<"] = " << roi_max[i] << ", use 1024.";
            roi_max[i] = 1024;
        }
    }
 
    // Access the IndeX rendering query interface
    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()));
 
    // 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());
        //----------------------------------------------------------------------
        // Scene setup
 
        // no scene setup in the start up 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::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());
 
        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(), roi_max, dice_transaction.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 = get_resolution();
        m_image_file_canvas->set_resolution(buffer_resolution);
 
        // Set up the scene
        mi::math::Bbox_struct< mi::Float32, 3 > const xyz_roi_st = {
            { 0.0f, 0.0f, 0.0f, },
            { static_cast< mi::Float32 >(roi_max.x),
              static_cast< mi::Float32 >(roi_max.y),
              static_cast< mi::Float32 >(roi_max.z), },
        };
 
        // set the region of interest
        const mi::math::Bbox< mi::Float32, 3 > xyz_roi(xyz_roi_st);
        check_success(xyz_roi.is_volume());
        scene_edit->set_clipped_bounding_box(xyz_roi_st);
 
        // 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.
        check_success(camera_tag.is_valid());
        scene_edit->set_camera(camera_tag);
 
        INFO_LOG << "ROI set to [0, 0, 0]-[" << roi_max.x << ", " << roi_max.y << ", " << roi_max.z << "]";
    }
    dice_transaction->commit();
 
    INFO_LOG << "Initialization complete.";
 
    return true;
}
 
//----------------------------------------------------------------------
void Dynamic_point_set::animate_point(
    const mi::neuraylib::Tag&         session_tag,
    mi::Sint32                        frame_idx,
    mi::neuraylib::IDice_transaction* dice_transaction)
{
    if(m_frame_command_vec.empty())
    {
        // no more processing commands
        return;
    }
 
    if(m_frame_command_vec.back().get_frame() != frame_idx)
    {
        return;
    }
 
    Frame_command fc = m_frame_command_vec.back(); // copy
    check_success(!m_frame_command_vec.empty());
    m_frame_command_vec.pop_back();
 
    INFO_LOG << "execute command: " << fc.to_string();
    const std::string & com = fc.get_command();
    if(com == "create")
    {
        if(m_point_set_tag.is_valid())
        {
            ERROR_LOG << "create: Point set has been already created. ignored.";
            return;
        }
        create_point_set(session_tag, dice_transaction);
    }
    else if(com == "delete")
    {
        if(!(m_point_set_tag.is_valid()))
        {
            ERROR_LOG << ("delete: Point set doesn't exist. ignored.");
            return;
        }
        delete_scene_element(m_point_set_tag,
                             m_point_set_group_tag,
                             dice_transaction);
        m_point_set_tag = mi::neuraylib::NULL_TAG;
    }
    else if(com == "translate_delta")
    {
        if(!(m_point_set_tag.is_valid()))
        {
            ERROR_LOG << ("translate_delta: Point set doesn't exist. ignored.");
            return;
        }
        std::vector< std::string > args = fc.get_argument();
        check_success(args.size() == 4);
        mi::math::Vector< mi::Float32, 3 > trans_delta_vec(nv::index::app::get_float32(args[1]),
                                                           nv::index::app::get_float32(args[2]),
                                                           nv::index::app::get_float32(args[3]));
        translate_point_set(m_point_set_tag,
                            trans_delta_vec,
                            dice_transaction);
    }
    else
    {
        ERROR_LOG << ("unknown command [" + com + "]. ignored.");
    }
}
 
//----------------------------------------------------------------------
nv::index::IFrame_results* Dynamic_point_set::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();
}
 
//----------------------------------------------------------------------
bool Dynamic_point_set::update_scene_and_render_frame(mi::Sint32 frame_idx)
{
    bool success = true;
 
    mi::base::Handle<mi::neuraylib::IDice_transaction> dice_transaction(create_transaction());
    check_success(dice_transaction.is_valid_interface());
    {
        // Change the scene element, camera, etc. here. This example
        // does not change any, but usually you can change camera
        // parameters, add/remove scene elements here.
        animate_point(m_session_tag, frame_idx, dice_transaction.get());
    }
    dice_transaction->commit();
 
 
    // Render a frame and save the rendered image to a file.
    // Only save the file at the end of the iteration.
    std::string fname = "";
    if (m_is_save_all_frame)
    {
        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::base::Handle<nv::index::IError_set> err_set(frame_results->get_error_set());
        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();
        success = false;
    }
 
    return success;
}
 
//----------------------------------------------------------------------
bool Dynamic_point_set::mainhost_rendering_loop()
{
    check_success(m_max_iter > 0);
    const mi::Sint32 max_frame_count = m_max_iter - 1;
    INFO_LOG << "set max iteration: " << m_max_iter;
    INFO_LOG << "set is_save_all_frame: " << (m_is_save_all_frame ? "true" : "false");
 
    // rendering loop
    bool is_ok = true;
    for(mi::Sint32 i = 0; i < m_max_iter; ++i)
    {
        if((!m_is_save_all_frame) && (i != max_frame_count))
        {
            m_is_save_all_frame = true;
        }
 
        is_ok = update_scene_and_render_frame(i);
        if(!is_ok)
        {
            break;
        }
    }
 
    INFO_LOG << "Finished main host rendering loop.";
 
    return is_ok;
}
 
//----------------------------------------------------------------------
void Dynamic_point_set::setup_animation() 
{
    // commands
    std::vector< std::string > com_create;
    com_create.push_back("create");
    std::vector< std::string > com_translate;
    com_translate.push_back("translate_delta");
    com_translate.push_back("20.0"); // dx
    com_translate.push_back("20.0"); // dy
    com_translate.push_back("20.0"); // dz
 
    std::vector< std::string > com_delete;
    com_delete.push_back("delete");
 
    m_frame_command_vec.push_back(Frame_command(5, com_create));
 
    for(mi::Sint32 i = 10; i < 20; ++i)
    {
        m_frame_command_vec.push_back(Frame_command(i, com_translate));
    }
    m_frame_command_vec.push_back(Frame_command(22, com_delete));
 
    if(!m_is_unittest)
    {
        // non unit test mode
        // create and delete again
        mi::Sint32 const base_frame = 30;
        mi::Sint32 const interval   = 5; // must be larger than offset
        mi::Sint32 const iter       = 3;
        for(mi::Sint32 i = 0; i < iter; ++i)
        {
            mi::Sint32 iter_base = base_frame + (i * interval);
            mi::Sint32 offset = 0;
            m_frame_command_vec.push_back(Frame_command(iter_base + offset, com_create));
            ++offset;
            m_frame_command_vec.push_back(Frame_command(iter_base + offset, com_translate));
            ++offset;
            m_frame_command_vec.push_back(Frame_command(iter_base + offset, com_delete));
            ++offset;
            check_success(offset < interval);
        }
    }
 
    std::sort(m_frame_command_vec.begin(), m_frame_command_vec.end(), Frame_command_sorter());
 
    // descendant order: debug print (need this int)
    assert(!(m_frame_command_vec.empty()));
    for(mi::Sint32 i = static_cast<mi::Sint32>(m_frame_command_vec.size() - 1); i >=0 ; --i)
    {
        // std::cout << "idx: " << i << std::endl;
        DEBUG_LOG << m_frame_command_vec.at(i).to_string();
    }
}
 
//----------------------------------------------------------------------
// main for dynamic_point_set
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", "224.1.3.2"); // default multicast address
    sdict.insert("max_iter", "40");                                // default max rendering loop iterations
    sdict.insert("resolution_x", "1024");                          // X resolution
    sdict.insert("resolution_y", "1024");                          // Y resolution
    sdict.insert("roi_x", "512");                                  // region of interest max X
    sdict.insert("roi_y", "512");                                  // region of interest max Y
    sdict.insert("roi_z", "512");                                  // region of interest max Z
    sdict.insert("outfname", "frame_dynamic_point");               // output file base name
    sdict.insert("is_save_all_frame", "0");                        // save all frame
    sdict.insert("is_animation_on", "1");                          // points animation
    sdict.insert("point_rendering_mode", "raytracing");            // point rendering mode
    sdict.insert("point_radius_mode", "object_space");             // point radius mode
    sdict.insert("unittest", "0");                                 // unit test 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.
 
    // 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");
 
    // Initialize application
    Dynamic_point_set dynamic_point_set;
    dynamic_point_set.initialize(argc, argv, sdict);
    check_success(dynamic_point_set.is_initialized());
 
    // launch the application. creating the scene and rendering.
    const mi::Sint32 exit_code = dynamic_point_set.launch();
    INFO_LOG << "Shutting down ...";
 
    return exit_code;
}