create_annotations.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/ifont.h>
#include <nv/index/iindex.h>
#include <nv/index/ilabel.h>
#include <nv/index/ilight.h>
#include <nv/index/iline_set.h>
#include <nv/index/imaterial.h>
#include <nv/index/ipoint_set.h>
#include <nv/index/iscene.h>
 
#include <mi/math.h>
 
#include <nv/index/app/string_dict.h>
#include <nv/index/app/index_connect.h>
 
#include "utility/canvas_utility.h"
 
#include <iostream>
#include <sstream>
 
//----------------------------------------------------------------------
// Create_annotations application class
class Create_annotations:
    public nv::index::app::Index_connect
{
public:
    Create_annotations()
        :
        Index_connect(),
        m_is_unittest(false)
    {
        // INFO_LOG << "DEBUG: create_annotations_index_connect() ctor";
    }
 
    virtual ~Create_annotations()
    {
        // Note: Index_connect::~Index_connect() will be called after here.
        // INFO_LOG << "DEBUG: ~create_annotations_index_connect() dtor";
    }
 
    // launch application
    mi::Sint32 launch();
 
protected:
    virtual bool evaluate_options(nv::index::app::String_dict& sdict) CPP11_OVERRIDE;
    // override for unittest support
    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:
    // Create point set in the scene.
    //
    // \param[in] scene_edit      IScene interface
    // \param[in] dice_transaction dice transaction
    // \return true when success
    mi::neuraylib::Tag create_scene(
        nv::index::IScene*                scene_edit,
        mi::neuraylib::IDice_transaction* dice_transaction);
    
    // set a group node's transformation matrix
    //
    // \param[in] group_node_tag group node tag to be set
    // \param[in] frame_id   a frame id. The translation is depends on this id
    // \param[in] dice_transaction dice transaction
    void set_transformation(
        const mi::neuraylib::Tag&         group_node_tag,
        mi::Uint32                        frame_id,
        mi::neuraylib::IDice_transaction* dice_transaction) const;
    
    // setup camera to see this example scene
    //
    // \param[in] cam  a camera
    void setup_camera(nv::index::IPerspective_camera* cam) 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_icons options
    std::string                                                                       m_outfname;
    bool                                                                              m_is_unittest;
    std::string                                                                       m_verify_image_fname_sequence;
    std::string                                                                       m_font_fpath;
};
 
//----------------------------------------------------------------------
mi::Sint32 Create_annotations::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());
 
        // 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()));
 
        mi::neuraylib::Tag scene_group_tag = mi::neuraylib::NULL_TAG;
        mi::neuraylib::Tag camera_tag      = mi::neuraylib::NULL_TAG;
 
        {
            // 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());
 
                //----------------------------------------------------------------------
                // Scene setup: add annotation shape, scene parameters, camera.
                //----------------------------------------------------------------------
                // Add an hierarchical scene description node to the scene
                scene_group_tag = create_scene(scene_edit.get(), dice_transaction.get());
                check_success(scene_group_tag.is_valid());
 
                // 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());
                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
                const mi::math::Bbox_struct< mi::Float32, 3 > xyz_roi_st = {
                    {   0.0f,   0.0f,   0.0f, },
                    { 500.0f, 500.0f, 500.0f, },
                };
 
                // 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);
            }
            dice_transaction->commit();
        }
 
        // Rendering
        {
            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());
            {
                const std::string fname = get_output_file_name(m_outfname, 0);
                std::stringstream verify_image_fname;
                if(!m_verify_image_fname_sequence.empty())
                {
                    verify_image_fname << m_verify_image_fname_sequence << "000.ppm";
                }
                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();
                }
 
                // verify the generated frame
                if (!(verify_canvas_result(get_application_layer_interface(),
                                           m_image_file_canvas.get(), verify_image_fname.str(), get_options())))
                {
                    exit_code = 1;
                }
            }
            dice_transaction->commit();
        }
 
        for(mi::Uint32 i = 1; i < 20; ++i)
        {
            {
                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());
                {
                    set_transformation(scene_group_tag, i, dice_transaction.get());
                }
                dice_transaction->commit();
            }
                
            const std::string fname = get_output_file_name(m_outfname, i);
 
            std::stringstream verify_image_fname;
            if(!m_verify_image_fname_sequence.empty())
            {
                const size_t BUFSZ = 64;
                char buf[BUFSZ];
                snprintf(buf, BUFSZ - 1, "%03d.ppm", i);
                verify_image_fname << m_verify_image_fname_sequence << buf;
            }
 
            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(), verify_image_fname.str(), get_options())))
            {
                exit_code = 1;
            }
        }
        
    }
 
    return exit_code;
}
 
 
//----------------------------------------------------------------------
bool Create_annotations::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_verify_image_fname_sequence = sdict.get("verify_image_fname_sequence", "");
    m_font_fpath                  = sdict.get("font_fpath");
 
    info_cout(std::string("running ") + com_name, sdict);
    info_cout("outfname = ["                       + m_outfname +
              "], verify_image_fname_sequence = [" + m_verify_image_fname_sequence +
              "], 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"
 
            << "        [-font_fpath FONT_FILE_PATH]\n"
            << "            font file path. (default: " << m_font_fpath << ")\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"
 
            << "        [-verify_image_fname_sequence [image_fname]]\n"
            << "            when image_fname exist, verify the rendering image. (default: ["
            << sdict.get("verify_image_fname_sequence") << "])\n"
 
            << "        [-unittest bool]\n"
            << "            when true, unit test mode (create smaller volume). "
            << "(default: " << sdict.get("unittest") << ")"
            << std::endl;
        exit(1);
    }
 
    return true;
}
 
//----------------------------------------------------------------------
mi::neuraylib::Tag Create_annotations::create_scene(
    nv::index::IScene*                scene_edit,
    mi::neuraylib::IDice_transaction* dice_transaction)
{
    check_success(scene_edit       != 0);
    check_success(dice_transaction != 0);
 
    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());
 
    // Set up the transformation matrix
    mi::math::Matrix<mi::Float32, 4, 4> transform_mat(1.f);
    // Add a translation
    transform_mat.translate(mi::math::Vector<mi::Float32, 3>(5.0f, 0.0f, 0.0f));
    group_node->set_transform(transform_mat);
 
    // 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);
    }
 
    // Add font to the scene description
    mi::base::Handle<nv::index::IFont> font(scene_edit->create_attribute<nv::index::IFont>());
    check_success(font.is_valid_interface());
 
    if(font->set_file_name(m_font_fpath.c_str()))
    {
        INFO_LOG << "set the font path [" << m_font_fpath << "]";
    }
    else
    {
        ERROR_LOG << "Can not find the font path [" << m_font_fpath << "], "
                  << "the rendering result may not correct.";
    }
    font->set_font_resolution(64.0f);
    const mi::neuraylib::Tag font_tag = dice_transaction->store_for_reference_counting(font.get());
    check_success(font_tag.is_valid());
    group_node->append(font_tag, dice_transaction);
    // Add a label layout to the scene description
    mi::base::Handle<nv::index::ILabel_layout> label_layout(scene_edit->create_attribute<nv::index::ILabel_layout>());
    check_success(label_layout.is_valid_interface());
    const mi::Float32 padding = 15.0f;
    label_layout->set_padding(padding);
    mi::math::Color_struct foreground; foreground.r = 0.9f; foreground.g = 0.8f; foreground.b = 0.8f; foreground.a = 0.8f;
    mi::math::Color_struct background; background.r = 0.4f; background.g = 0.5f; background.b = 0.4f; background.a = 0.5f;
    label_layout->set_color(foreground, background);
    const mi::neuraylib::Tag label_layout_tag = dice_transaction->store_for_reference_counting(label_layout.get());
    check_success(label_layout_tag.is_valid());
    group_node->append(label_layout_tag, dice_transaction);
 
    // Some constants used to setup the scene (lines, points, labels) later...
    const mi::Float32 x_min = 0.f;
    const mi::Float32 x_max = 400.f;
    const mi::Float32 y_min = 0.f;
    const mi::Float32 y_max = 400.f;
 
    {
        // Point coordinates and its attributes. According to the
        // attributes, color and radius are defined.
        std::vector< mi::math::Vector_struct< mi::Float32, 3> > point_pos_vec;
        std::vector< mi::math::Color_struct>                    per_point_color;
        std::vector< mi::Float32 >                              per_point_radius;
 
        std::vector< mi::math::Vector_struct< mi::Float32, 3> > segment_vertices;
        std::vector< mi::math::Color_struct>                    color_per_segment;
        std::vector< mi::Float32 >                              width_per_segment;
        mi::math::Vector_struct< mi::Float32, 3> v0; v0.x = x_min; v0.y = y_min; v0.z = 30.f;
        mi::math::Vector_struct< mi::Float32, 3> v1; v1.x = x_max; v1.y = y_min; v1.z = 30.f;
        mi::math::Vector_struct< mi::Float32, 3> v2; v2.x = x_max; v2.y = y_max; v2.z = 30.f;
        mi::math::Vector_struct< mi::Float32, 3> v3; v3.x = x_min; v3.y = y_max; v3.z = 30.f;
 
        segment_vertices.push_back(v0); segment_vertices.push_back(v1);
        segment_vertices.push_back(v1); segment_vertices.push_back(v2);
        segment_vertices.push_back(v2); segment_vertices.push_back(v3);
        segment_vertices.push_back(v3); segment_vertices.push_back(v0);
        point_pos_vec.push_back(v0);
        point_pos_vec.push_back(v1);
        point_pos_vec.push_back(v2);
        point_pos_vec.push_back(v3);
 
        mi::math::Color_struct color;
        color.r = 0.8f; color.g = 0.8f; color.b = 0.8f; color.a = 1.f;
        color_per_segment.push_back(color);
        color_per_segment.push_back(color);
        color_per_segment.push_back(color);
        color_per_segment.push_back(color);
        per_point_color.push_back(color); per_point_color.push_back(color);
        per_point_color.push_back(color); per_point_color.push_back(color);
 
        width_per_segment.push_back(2.f);
        width_per_segment.push_back(2.f);
        width_per_segment.push_back(2.f);
        width_per_segment.push_back(2.f);
        per_point_radius.push_back(3.f); per_point_radius.push_back(3.f);
        per_point_radius.push_back(3.f); per_point_radius.push_back(3.f);
 
        // Create line set using the scene's factory
        mi::base::Handle<nv::index::ILine_set> line_set(scene_edit->create_shape<nv::index::ILine_set>());
        check_success(line_set.is_valid_interface());
        // ... set the line style such a dashed or dotted or solid linestyle (see ILine_set)
        line_set->set_line_style(nv::index::ILine_set::LINE_STYLE_DOTTED);
        // ... set the line type. Currently only line segments are supported (see ILine_set)
        line_set->set_line_type(nv::index::ILine_set::LINE_TYPE_SEGMENTS);
        // ... and the lines with colors and widths all in line segment order.
        line_set->set_lines(&segment_vertices[0], segment_vertices.size());
        line_set->set_colors(&color_per_segment[0], color_per_segment.size());
        line_set->set_widths(&width_per_segment[0], width_per_segment.size());
        
        // Add the points to the database
        const mi::neuraylib::Tag line_set_tag = dice_transaction->store_for_reference_counting(line_set.get());
        // if you are not registered Line_set, the next check fails.
        check_success(line_set_tag.is_valid());
        group_node->append(line_set_tag, dice_transaction);
 
        // Create point set using the scene's factory.
        mi::base::Handle<nv::index::IPoint_set> point_set(scene_edit->create_shape<nv::index::IPoint_set>());
        check_success(point_set.is_valid_interface());
        // ... set the point styles (see IPoint_set)
        // ... and the vertices with colors and radii.
        point_set->set_vertices(&point_pos_vec[0], point_pos_vec.size());
        point_set->set_colors(&per_point_color[0], per_point_color.size());
        point_set->set_radii(&per_point_radius[0], per_point_radius.size());
 
        // Storing the point set in the database.
        const mi::neuraylib::Tag point_set_scene_element_tag = dice_transaction->store_for_reference_counting(point_set.get());
        check_success(point_set_scene_element_tag.is_valid());
        group_node->append(point_set_scene_element_tag, dice_transaction);
    }
 
    {
        mi::math::Color_struct color;
        color.r = 0.8f; color.g = 0.8f; color.b = 0.9f; color.a = 1.f;
        const mi::Float32 x_spacing = 25.f;
        const mi::Float32 y_height = 10.f;
        std::vector< mi::math::Vector_struct< mi::Float32, 3> > segment_vertices;
        std::vector< mi::math::Color_struct>                    color_per_segment;
        std::vector< mi::Float32 >                              width_per_segment;
        mi::math::Vector_struct< mi::Float32, 3> v0; v0.x = x_min; v0.y = y_min; v0.z = 30.f;
        mi::math::Vector_struct< mi::Float32, 3> v1; v1.x = x_max; v1.y = y_min; v1.z = 30.f;
 
        for(mi::Float32 i=x_min; i<=x_max; i+=x_spacing)
        {
            v0.x = i; v0.y = y_max; v0.z = 30.f;
            v1.x = i; v1.y = y_max+y_height; v1.z = 30.f;
            if(mi::math::fmod(i,100.f) == 0) v1.y+=y_height;
 
            segment_vertices.push_back(v0); segment_vertices.push_back(v1);
            color_per_segment.push_back(color);
            width_per_segment.push_back(2.f);
 
            if(mi::math::fmod(i,100.f) == 0.f)
            {
                mi::base::Handle<nv::index::ILabel_2D> label(scene_edit->create_shape<nv::index::ILabel_2D>());
                check_success(label.is_valid_interface());
                std::stringstream sstr;
                sstr << i;
                label->set_text(sstr.str().c_str());
                const mi::Float32 height = 40.f;
                const mi::Float32 width = 40.f;
                mi::math::Vector_struct<mi::Float32, 3>  position; position.x = v1.x-(width/2);  position.y = v1.y+y_height;  position.z = v1.z;
                mi::math::Vector_struct<mi::Float32, 2>  right; right.x = 1.f;  right.y = 0.f;
                mi::math::Vector_struct<mi::Float32, 2>  up; up.x = 0.f;  up.y = 1.f;
                // To test 'compute_label_width' create a label with width = -1 (auto width)
                // and then call label->compute_label_width() with the current font and label layout
                // the function will return the calculated label frame width for perfect fitting of the text
                // taking into account the frame-height, font, text and padding. 
                label->set_geometry(position, right, up, height, width);//-1);
                // INFO_LOG << "Label :" << sstr.str() << ", width = " << label->compute_label_width(font.get(), label_layout.get());
                const mi::neuraylib::Tag label_tag = dice_transaction->store_for_reference_counting(label.get());
                check_success(label_tag.is_valid());
                group_node->append(label_tag, dice_transaction);
            }
        }
 
        // Create line set using the scene's factory
        mi::base::Handle<nv::index::ILine_set> line_set(scene_edit->create_shape<nv::index::ILine_set>());
        check_success(line_set.is_valid_interface());
        // ... set the line style such a dashed or dotted or solid linestyle (see ILine_set)
        line_set->set_line_style(nv::index::ILine_set::LINE_STYLE_SOLID);
        // ... set the line type. Currently only line segments are supported (see ILine_set)
        line_set->set_line_type(nv::index::ILine_set::LINE_TYPE_SEGMENTS);
        // ... and the lines with colors and widths all in line segment order.
        line_set->set_lines(&segment_vertices[0], segment_vertices.size());
        line_set->set_colors(&color_per_segment[0], color_per_segment.size());
        line_set->set_widths(&width_per_segment[0], width_per_segment.size());
        
        const mi::neuraylib::Tag line_set_tag = dice_transaction->store_for_reference_counting(line_set.get());
        // if you are not registered Line_set, the next check fails.
        check_success(line_set_tag.is_valid());
        group_node->append(line_set_tag, dice_transaction);
    }
 
    {
        mi::base::Handle<nv::index::ILabel_layout> label_layout(scene_edit->create_attribute<nv::index::ILabel_layout>());
        check_success(label_layout.is_valid_interface());
        const mi::Float32 padding = 10.f;
        label_layout->set_padding(padding);
        mi::math::Color_struct foreground; foreground.r = 0.9f; foreground.g = 0.95f; foreground.b = 0.99f; foreground.a = 1.0f;
        mi::math::Color_struct background; background.r = 0.4f; background.g = 0.5f; background.b = 0.4f; background.a = 0.5f;
        label_layout->set_color(foreground, background);
        const mi::neuraylib::Tag label_layout_tag = dice_transaction->store_for_reference_counting(label_layout.get());
        check_success(label_layout_tag.is_valid());
        group_node->append(label_layout_tag, dice_transaction);
 
        mi::base::Handle<nv::index::ILabel_3D> label(scene_edit->create_shape<nv::index::ILabel_3D>());
        check_success(label.is_valid_interface());
        label->set_text("slice...");
        mi::math::Vector_struct<mi::Float32, 3>  position; position.x = x_max;  position.y = y_max;  position.z = 30.f;
        mi::math::Vector_struct<mi::Float32, 3>  right; right.x = 0.f;  right.y = -1.f;  right.z = 0.f;
        mi::math::Vector_struct<mi::Float32, 3>  up; up.x = 1.f;  up.y = 0.f;  up.z = 0.f;
        const mi::Float32 height = 40.f;
        const mi::Float32 width = 120.f;
        label->set_geometry(position, right, up, height, width);
        const mi::neuraylib::Tag label_tag = dice_transaction->store_for_reference_counting(label.get());
        check_success(label_tag.is_valid());
        group_node->append(label_tag, dice_transaction);
    }
 
    mi::neuraylib::Tag group_node_tag = dice_transaction->store_for_reference_counting(group_node.get());
    check_success(group_node_tag.is_valid());
 
    // Define the root and attributes that are active globally
    mi::base::Handle<nv::index::IDirectional_light> light_global(scene_edit->create_attribute<nv::index::IDirectional_light>());
    check_success(light_global.is_valid_interface());
    const mi::neuraylib::Tag light_global_tag = dice_transaction->store_for_reference_counting(light_global.get());
    check_success(light_global_tag.is_valid());
    scene_edit->append(light_global_tag, dice_transaction);
 
    scene_edit->append(group_node_tag, dice_transaction);
 
    INFO_LOG << "Hierarchical scene description creation complete.";
    return group_node_tag;
}
 
//----------------------------------------------------------------------
void Create_annotations::set_transformation(
    const mi::neuraylib::Tag&         group_node_tag,
    mi::Uint32                        frame_id,
    mi::neuraylib::IDice_transaction* dice_transaction) const
{
    mi::base::Handle< nv::index::ITransformed_scene_group > group_node(
        dice_transaction->edit<nv::index::ITransformed_scene_group>(group_node_tag));
    check_success(group_node.is_valid_interface());
 
    // Set up the transformation matrix
    mi::math::Matrix<mi::Float32, 4, 4> transform_mat(1.f);
    // Add a translation
    mi::Float32 z = static_cast<mi::Float32>(frame_id) * 10.0f;
    transform_mat.translate(mi::math::Vector<mi::Float32, 3>(5.0f, 0.0f, z));
    group_node->set_transform(transform_mat);
}
 
//----------------------------------------------------------------------
void Create_annotations::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( 100.0f, 254.0f,  550.0f);
    mi::math::Vector< mi::Float32, 3 > const to  ( 255.0f, 255.0f, -255.0f);
    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(10.0f);
    cam->set_clip_max(5000.0f);
}
 
//----------------------------------------------------------------------
nv::index::IFrame_results* Create_annotations::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();
}
 
//----------------------------------------------------------------------
// This example shows how to create annotation shapes in the scene.
int main(int argc, const char* argv[])
{
    nv::index::app::String_dict sdict;
    sdict.insert("dice::verbose", "3");                         // log level
    sdict.insert("dice::network::mode", "OFF");                 // network mode
    sdict.insert("font_fpath", "/usr/share/fonts/dejavu/DejaVuSans.ttf"); // font path
    sdict.insert("outfname", "frame_create_annotations");       // output file base name
    sdict.insert("verify_image_fname_sequence", "");            // for unit test
    sdict.insert("unittest", "0");                              // default 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.
 
    // index setting
    sdict.insert("index::config::set_monitor_performance_values", "yes");
    sdict.insert("index::service", "rendering_and_compositing");
    sdict.insert("index::cuda_debug_checks", "no");
 
    // application_layer component loading
    sdict.insert("index::app::components::application_layer::component_name_list",
                 "canvas_infrastructure image io");
 
    // Initialize application
    Create_annotations create_annotations;
    create_annotations.initialize(argc, argv, sdict);
    check_success(create_annotations.is_initialized());
 
    // launch the application. creating the scene and rendering.
    const mi::Sint32 exit_code = create_annotations.launch();
    INFO_LOG << "Shutting down ...";
 
    return exit_code;
}