create_line_styles.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/icolormap.h>
#include <nv/index/iconfig_settings.h>
#include <nv/index/iindex.h>
#include <nv/index/iline_set.h>
#include <nv/index/iscene.h>
#include <nv/index/iscene_group.h>
#include <nv/index/isession.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_line_style:
    public nv::index::app::Index_connect
{
public:
    struct Line_test_params
    {
        mi::Uint32 num_points;
        mi::Uint32 line_style;
        mi::Uint32 caps_style;
    };
 
 
    Create_line_style()
        :
        Index_connect()
    {
        // INFO_LOG << "DEBUG: Create_line_style() ctor";
    }
 
    virtual ~Create_line_style()
    {
        // Note: Index_connect::~Index_connect() will be called after here.
        // INFO_LOG << "DEBUG: ~Create_line_style() 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:
    mi::Float32 random(mi::Float32 min, mi::Float32 max) const;
    mi::math::Color_struct jetmap(mi::Float32 v, mi::Float32 vmin, mi::Float32 vmax) const;
    
    // Create scene.
    // \param[in] params line parameters          
    // \param[in] scene_edit       IScene for the scene edit.
    // \param[in] dice_transaction dice transaction
    // \return true when success
    bool create_scene(
        const Line_test_params&           params,
        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;
 
    // 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_line_style options
    std::string                                                                       m_outfname;
    bool                                                                              m_is_unittest;
    std::string                                                                       m_verify_image_fname;
    Line_test_params                                                                  m_line_params;
};
 
//----------------------------------------------------------------------
mi::Sint32 Create_line_style::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()));
 
        {
            // 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< 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: hierarchical scene description root node,
                // scene parameters, camera.
                //----------------------------------------------------------------------
                // create a hierarchical scene description
                check_success(create_scene(m_line_params, 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_struct< mi::Float32, 3 > xyz_roi_st = {
                    {   0.0f,   0.0f,   0.0f, },
                    { 650.0f, 650.0f, 650.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);
 
                INFO_LOG << "transformed: " << scene_edit->get_transform_matrix();
 
                // Set the current camera to the scene.
                check_success(camera_tag.is_valid());
                scene_edit->set_camera(camera_tag);
            }
            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_line_style::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     = sdict.get("verify_image_fname");
    m_line_params.num_points = nv::index::app::get_uint32(sdict.get("num_points"));
    m_line_params.line_style = nv::index::app::get_uint32(sdict.get("line_style"));
    m_line_params.caps_style = nv::index::app::get_uint32(sdict.get("caps_style"));
 
    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"
            
            << "        [-num_points int]\n"
            << "            number of points used for every shape in the test."
            << "(default: " << m_line_params.num_points << ")\n"
 
            << "        [-line_style int]\n"
            << "            set the line dash pattern (0-9)."
            << "(default: " << m_line_params.line_style << ")\n"
            
            << "        [-caps_style int]\n"
            << "            set the cap style (0-2)."
            << "(default: " << m_line_params.caps_style << ")\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 [image_fname]]\n"
            << "            when image_fname exist, verify the rendering image. (default: ["
            << m_verify_image_fname << "])\n"
 
            << "        [-unittest bool]\n"
            << "            when true, unit test mode (create smaller volume). "
            << "(default: " << m_is_unittest << ")"
            << std::endl;
        exit(1);
    }
    return true;
}
 
//----------------------------------------------------------------------
mi::Float32 Create_line_style::random(mi::Float32 min, mi::Float32 max) const
{
    mi::Float32 t = rand()/(1.f + RAND_MAX);
    
    return (min + (max - min)*t);
}
 
//----------------------------------------------------------------------
mi::math::Color_struct Create_line_style::jetmap(mi::Float32 v, mi::Float32 vmin, mi::Float32 vmax) const
{
   mi::math::Color_struct c = {1.0f, 1.0f, 1.0f, 1.0f};
   mi::Float32 dv;
 
   if (v < vmin)
      v = vmin;
   if (v > vmax)
      v = vmax;
   dv = vmax - vmin;
 
   if (v < (vmin + 0.25f * dv)) 
   {
      c.r = 0.f;
      c.g = 4.f * (v - vmin) / dv;
   } 
   else if (v < (vmin + 0.5f * dv)) 
   {
      c.r = 0.f;
      c.b = 1.f + 4.f * (vmin + 0.25f * dv - v) / dv;
   } 
   else if (v < (vmin + 0.75f * dv)) 
   {
      c.r = 4.f * (v - vmin - 0.5f * dv) / dv;
      c.b = 0.f;
   } 
   else 
   {
      c.g = 1.f + 4.f * (vmin + 0.75f * dv - v) / dv;
      c.b = 0.f;
   }
 
   return(c);
} 
 
//----------------------------------------------------------------------
bool Create_line_style::create_scene(
    const Line_test_params&           params,
    nv::index::IScene*                scene_edit,
    mi::neuraylib::IDice_transaction* dice_transaction)
{
    check_success(scene_edit       != 0);
    check_success(dice_transaction != 0);
 
    const mi::Float32 PI_f = static_cast<mi::Float32>(M_PI); // pi of Float32
    
    // Set up the transformation matrix, define a translation and create and store the scene group
    mi::math::Matrix<mi::Float32, 4, 4> transform_mat(1.f);
    transform_mat.translate(mi::math::Vector<mi::Float32, 3>(240.f, 300.f, 0.f));
    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());
    group_node->set_transform(transform_mat);
 
    // set up line style
    nv::index::ILine_set::Line_style line_style = (nv::index::ILine_set::Line_style)params.line_style;
    
    // set up cap style
    nv::index::ILine_set::Cap_style cap_style = (nv::index::ILine_set::Cap_style)params.caps_style;
 
    mi::Uint32 num_points = params.num_points;
    mi::Float32 min_width = 1.5f, max_width = 10.f;
 
    //  set up color per vertice
    std::vector<mi::math::Color_struct> colors;
    colors.resize(num_points);
    for(mi::Uint32 i=0; i<num_points; i++)
        colors[i] = jetmap((mi::Float32)i/(mi::Float32)(num_points-1), 0.f, 1.f);
    
    {   //creating a line-set in segments mode
        mi::math::Bbox< mi::Float32, 3 > bbox;
        bbox.min.x = -200.f;
        bbox.min.y = 330.f;
        bbox.min.z = -150.f;
        bbox.max.x = 210.f;
        bbox.max.y = 150.f;
        bbox.max.z = 150.f;
    
        mi::Uint32 num_segments = num_points-1;
        std::vector< mi::math::Vector_struct<mi::Float32, 3> > segment_points;
        segment_points.resize(num_segments*2);
        std::vector<mi::Float32> widths;
        widths.resize(num_segments);
        
        srand(39377);
        for(mi::Uint32 i=0; i<num_segments; i++)
        {
            segment_points[2*i].x =  random(bbox.min.x, bbox.max.x);
            segment_points[2*i].y =  random(bbox.min.y, bbox.max.y);
            segment_points[2*i].z =  random(bbox.min.z, bbox.max.z);
            
            segment_points[2*i+1].x =  random(bbox.min.x, bbox.max.x);
            segment_points[2*i+1].y =  random(bbox.min.y, bbox.max.y);
            segment_points[2*i+1].z =  random(bbox.min.z, bbox.max.z);
            
            mi::Float32 t = random(0.f, 1.f);
            widths[i] = min_width + (max_width - min_width)*t*t;
        }
        
        mi::base::Handle<nv::index::ILine_set> line_set1(scene_edit->create_shape<nv::index::ILine_set>());
        check_success(line_set1.is_valid_interface());
    
        // set line type
        line_set1->set_line_type(nv::index::ILine_set::LINE_TYPE_SEGMENTS);
        
        // set points
        line_set1->set_lines(&segment_points[0], num_segments*2);
        
        // set colors
        line_set1->set_colors(&colors[0], num_segments);
 
        // set widths
        line_set1->set_widths(&widths[0], num_segments);
        
        //set line style
        line_set1->set_line_style(line_style);
        
        //set cap style
        line_set1->set_cap_style(cap_style);
 
        // append path to the group node
        const mi::neuraylib::Tag line_set1_tag = dice_transaction->store_for_reference_counting(line_set1.get());
        check_success(line_set1_tag.is_valid());
        group_node->append(line_set1_tag, dice_transaction);
    }
    
    {   //creating a line-set in path mode
 
        // set up points
        std::vector< mi::math::Vector_struct<mi::Float32, 3> > points;
        points.resize(num_points);
        
        for(mi::Uint32 i=0; i<num_points; i++)
        {
            mi::Float32 t = (mi::Float32)i/(mi::Float32)(num_points-1);
            t = 2.f*t - 1.f;
            
            points[i].x = t*300.f - 50.f;
            points[i].y = t*t*t*t*t*t*t*300.f + 20.f;
            points[i].z = 10.f;
        }
 
        // set up widths
        std::vector<mi::Float32> widths;
        widths.resize(num_points);
        for(mi::Uint32 i=0; i<num_points; i++)
        {
            mi::Float32 t = (mi::Float32)i/(mi::Float32)(num_points-1);
            widths[i] = min_width + (1.5f*max_width - min_width)*0.5f*(sinf(4.f*static_cast<mi::Float32>(PI_f)*t) + 1.f);
        }
        
        mi::base::Handle<nv::index::ILine_set> line_set2(scene_edit->create_shape<nv::index::ILine_set>());
        check_success(line_set2.is_valid_interface());
    
        // set line type
        line_set2->set_line_type(nv::index::ILine_set::LINE_TYPE_PATH);
        
        // set points
        line_set2->set_lines(&points[0], num_points);
        
        // set colors
        line_set2->set_colors(&colors[0], num_points);
 
        // set widths
        line_set2->set_widths(&widths[0], num_points);
        
        //set line style
        line_set2->set_line_style(line_style);
        
        //set cap style
        line_set2->set_cap_style(cap_style);
 
        // append path to the group node
        const mi::neuraylib::Tag line_set1_tag = dice_transaction->store_for_reference_counting(line_set2.get());
        check_success(line_set1_tag.is_valid());
        group_node->append(line_set1_tag, dice_transaction);
    }
    
    {   //creating a line-set in loop mode
    
        // set up points
        std::vector< mi::math::Vector_struct<mi::Float32, 3> > points;
        points.resize(num_points);
        
        for(mi::Uint32 i=0; i<num_points; i++)
        {
            mi::Float32 t = (mi::Float32)i/(mi::Float32)num_points;
            
            points[i].x = sinf(2.f * PI_f * t + PI_f/2.f)*250.f;
            points[i].y = sinf(4.f * PI_f * t) * 150.f - 150;
            points[i].z = sinf(2.f * PI_f * t) * 10.f;
        }
    
        // set up widths
        std::vector<mi::Float32> widths;
        widths.resize(num_points);
        for(mi::Uint32 i=0; i<num_points; i++)
        {
            mi::Float32 t = (mi::Float32)i/(mi::Float32)(num_points-1);
            widths[i] = min_width + (max_width - min_width)*0.5f*(sinf(2.f*PI_f*t + PI_f/2.f) + 1.f);
        }
    
        mi::base::Handle<nv::index::ILine_set> line_set3(scene_edit->create_shape<nv::index::ILine_set>());
        check_success(line_set3.is_valid_interface());
    
        // set line type
        line_set3->set_line_type(nv::index::ILine_set::LINE_TYPE_LOOP);
        
        // set points
        line_set3->set_lines(&points[0], num_points);
        
        // set colors
        line_set3->set_colors(&colors[0], num_points);
 
        // set widths
        line_set3->set_widths(&widths[0], num_points);
        
        //set line style
        line_set3->set_line_style(line_style);
        
        //set cap style
        line_set3->set_cap_style(cap_style);
 
        // append path to the group node
        const mi::neuraylib::Tag line_set3_tag = dice_transaction->store_for_reference_counting(line_set3.get());
        check_success(line_set3_tag.is_valid());
        group_node->append(line_set3_tag, dice_transaction);
    }
 
    const mi::neuraylib::Tag group_node_tag = dice_transaction->store_for_reference_counting(group_node.get());
    check_success(group_node_tag.is_valid());
    scene_edit->append(group_node_tag, dice_transaction);
 
    return true;
}
 
//----------------------------------------------------------------------
void Create_line_style::setup_camera(
    nv::index::IPerspective_camera* cam) const
{
    // Set the camera parameters to see the whole scene
    mi::math::Vector< mi::Float32, 3 > const from( 234.0f, 604.0f,  500.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_line_style::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 paths.
int main(int argc, const char* argv[])
{
    nv::index::app::String_dict sdict;
    sdict.insert("dice::verbose", "3");                         // log level
    sdict.insert("outfname", "frame_create_line_styles");       // output file base name
    sdict.insert("verify_image_fname", "");                     // for unit test
    sdict.insert("unittest", "0");                              // default mode
    sdict.insert("num_points", "12");                           // 12 points (default)
    sdict.insert("line_style", "0");                            // solid line style (default)
    sdict.insert("caps_style", "2");                            // no cape (default)
    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
    Create_line_style create_line_style;
    create_line_style.initialize(argc, argv, sdict);
    check_success(create_line_style.is_initialized());
 
    // launch the application. creating the scene and rendering.
    const mi::Sint32 exit_code = create_line_style.launch();
    INFO_LOG << "Shutting down ...";
 
    return exit_code;
}