create_plane.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/iconfig_settings.h>
#include <nv/index/iindex.h>
#include <nv/index/ilight.h>
#include <nv/index/imaterial.h>
#include <nv/index/iplane.h>
#include <nv/index/iscene.h>
#include <nv/index/iscene_group.h>
#include <nv/index/isession.h>
#include <nv/index/itexture_filter_mode.h>
 
#include "utility/canvas_utility.h"
 
#include <nv/index/app/idata_analysis_and_processing.h>
#include <nv/index/app/index_connect.h>
#include <nv/index/app/string_dict.h>
#include <nv/index/app/time_functions.h>
 
#include <iostream>
#include <sstream>
 
//----------------------------------------------------------------------
class Create_plane:
    public nv::index::app::Index_connect
{
public:
    Create_plane()
        :
        Index_connect(),
        m_is_unittest(false),
        m_supersampling(false),
        m_is_large_translate(false)
    {
        // INFO_LOG << "DEBUG: Create_plane() ctor";
    }
 
    virtual ~Create_plane()
    {
        // Note: Index_connect::~Index_connect() will be called after here.
        // INFO_LOG << "DEBUG: ~Create_plane() 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:
    // create plane instances
    void create_planes(
        nv::index::IScene*                scene_edit,
        mi::neuraylib::IDice_transaction* dice_transaction);
 
    // setup camera to see this example scene
    void setup_camera(nv::index::IPerspective_camera* cam) const;
 
    // setup a far away camera for a extreme transformation handling test
    //
    // This value is based on Bugzilla 11567
    // Attachment: Two complete screen dump with 188853_8578 build case
    void setup_extreme_transformed_camera(nv::index::IPerspective_camera* cam) const;
    
    // setup a large scene transform for the extreme
    // transformation handling test
    //
    // This value is based on Bugzilla 11567
    // Attachment: Two complete screen dump with 188853_8578 build case
    mi::math::Matrix<mi::Float32, 4, 4> get_extreme_transformed_matrix() 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;
    bool                                                                              m_supersampling;
    bool                                                                              m_is_large_translate;
};
 
//----------------------------------------------------------------------
mi::Sint32 Create_plane::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
        const int max_retry = 3;
        for (int retry = 0; retry < max_retry; ++retry)
        {
            if (m_cluster_configuration->get_number_of_hosts() == 0)
            {
                INFO_LOG << "no host joined yet, retry "
                         << (retry + 1) << "/" << max_retry;
                nv::index::app::util::time::sleep(0.3f);
            }
        }
        check_success(m_cluster_configuration->get_number_of_hosts() != 0);
 
        {
            // Obtain a DiCE transaction
            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<nv::index::ISession>(m_session_tag));
                check_success(session.is_valid_interface());
 
                mi::base::Handle< nv::index::IScene > scene_edit(
                    dice_transaction->edit< nv::index::IScene >(session->get_scene()));
                check_success(scene_edit.is_valid_interface());
 
                // Enable supersampling
                if (m_supersampling)
                {
                    INFO_LOG << "Enable supersampling.";
 
                    mi::base::Handle<nv::index::IConfig_settings> config_settings(
                        dice_transaction->edit<nv::index::IConfig_settings>(session->get_config()));
                    check_success(config_settings.is_valid_interface());
 
                    config_settings->set_rendering_samples(8);
                }
 
                //----------------------------------------------------------------------
                // Scene setup: add textured planes
                //----------------------------------------------------------------------
                create_planes(scene_edit.get(), dice_transaction.get());
 
                mi::base::Handle< nv::index::IPerspective_camera > cam(
                    scene_edit->create_camera<nv::index::IPerspective_camera>());
                check_success(cam.is_valid_interface());
 
                mi::math::Vector<mi::Uint32, 2> buffer_resolution;
                if (m_is_large_translate)
                {
                    INFO_LOG << "large translate test mode.";
                    setup_extreme_transformed_camera(cam.get());
                    buffer_resolution = mi::math::Vector<mi::Uint32, 2>(1602, 934);
                }
                else
                {
                    setup_camera(cam.get());
                    buffer_resolution = mi::math::Vector<mi::Uint32, 2>(512, 512);
                }
                const mi::neuraylib::Tag camera_tag = dice_transaction->store(cam.get());
                check_success(camera_tag.is_valid());
 
                m_image_file_canvas->set_resolution(buffer_resolution);
 
                // Set up the scene and define the region of interest
                const mi::math::Bbox_struct<mi::Float32, 3> xyz_roi_st = {
                    { -1000.0f, -1000.0f, -1000.0f, },
                    {  1000.0f,  1000.0f,  1000.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
                    );
 
                if(m_is_large_translate)
                {
                    transform_mat = get_extreme_transformed_matrix();
                }
 
                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);
            }
            // Commit the transaction used for initializing
            dice_transaction->commit();
        }
 
        // Rendering
        {
            // Render the frame 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_plane::evaluate_options(nv::index::app::String_dict& sdict)
{
    const std::string com_name = sdict.get("command:", "<unknown_command>");
    m_is_unittest = nv::index::app::get_bool(sdict.get("unittest", "false"));
    
    if (m_is_unittest)
    {
        if (nv::index::app::get_bool(sdict.get("is_call_from_test", "false")))
        {
            sdict.insert("is_dump_comparison_image_when_failed", "0");
        }
        sdict.insert("outfname", "");  // turn off file output in the unit test mode
        sdict.insert("dice::verbose", "2");
    }
 
    // set own options
    m_outfname           = sdict.get("outfname");
    m_verify_image_fname = sdict.get("verify_image_fname");
    m_supersampling      = nv::index::app::get_bool(sdict.get("supersampling", "false"));
    m_is_large_translate = nv::index::app::get_bool(sdict.get("is_large_translate", "false"));
 
    info_cout(std::string("running ") + com_name, sdict);
    info_cout("outfname = ["       + sdict.get("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"
 
            << "        [-supersampling bool]\n"
            << "            when true then supersampling is enabled."
            << "(default: " << m_supersampling << ")\n"
 
            << "        [-is_large_translate bool]\n"
            << "            on/off large translation mode."
            << "(default: " << m_is_large_translate << ")\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. "
            << m_is_unittest << "])"
            << std::endl;
        exit(1);
    }
    return true;
}
 
//----------------------------------------------------------------------
void Create_plane::create_planes(
    nv::index::IScene*                scene_edit,
    mi::neuraylib::IDice_transaction* dice_transaction)
{
    check_success(scene_edit != 0);
 
    // Add a scene group where the shapes should be added
    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 a fully ambient material for the planes, so that lighting doesn't matter
        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(1.0f, 1.0f, 1.0f));
        phong_1->set_diffuse(mi::math::Color(0.0f));
        phong_1->set_specular(mi::math::Color(0.0f));
 
        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);
    }
 
    //
    // Plane 1: RGBA mode, axis aligned, no filtering
    //
    {
        // Place plane centered in the origin, normal pointing along the z-axis
        mi::math::Vector<mi::Float32, 3> plane_point(-400.f, -250.f, 1.0f);
        mi::math::Vector<mi::Float32, 3> plane_normal(0.f, 0.f, 1.f);
        mi::math::Vector<mi::Float32, 3> plane_up(0.f, 1.f, 0.f);
        mi::math::Vector<mi::Float32, 2> plane_extent(800.0f, 500.0f);
 
        mi::base::Handle<nv::index::ITexture_filter_mode> tex_filter(
            scene_edit->create_attribute<nv::index::ITexture_filter_mode_nearest_neighbor>());
        check_success(tex_filter.is_valid_interface());
        mi::neuraylib::Tag tex_filter_tag = dice_transaction->store_for_reference_counting(tex_filter.get());
        check_success(tex_filter_tag.is_valid());
        group_node->append(tex_filter_tag, dice_transaction);
 
        // Access an application layer component that provides some sample techniques such as the mandelbrot for 2d surfaces:
        mi::base::Handle<nv::index::app::data_analysis_and_processing::IData_analysis_and_processing> processing(
            get_application_layer_interface()->get_api_component<nv::index::app::data_analysis_and_processing::IData_analysis_and_processing>());
        check_success(processing.is_valid_interface());
        // Create a mandelbrot technique and add it to the scene. For more details on how to implement the mandelbrot, please review the provided
        // source that was shipped with the application layer component 'nv::index::app::data_analysis_and_processing::IData_analysis_and_processing'.
        mi::base::Handle<nv::index::IDistributed_compute_technique> mapping(
            processing->get_sample_tool_set()->create_mandelbrot_2d_technique(
                plane_extent, nv::index::IDistributed_compute_destination_buffer_2d_texture::FORMAT_RGBA_FLOAT32));
 
        mi::neuraylib::Tag mapping_tag = dice_transaction->store_for_reference_counting(mapping.get());
        check_success(mapping_tag.is_valid());
        group_node->append(mapping_tag, dice_transaction);
 
        mi::base::Handle<nv::index::IPlane> plane(
            scene_edit->create_shape<nv::index::IPlane>());
        check_success(plane.is_valid_interface());
        plane->set_point(plane_point);
        plane->set_normal(plane_normal);
        plane->set_up(plane_up);
        plane->set_extent(plane_extent);
 
        mi::neuraylib::Tag plane_tag = dice_transaction->store_for_reference_counting(plane.get());
        check_success(plane_tag.is_valid());
        group_node->append(plane_tag, dice_transaction);
    }
 
    //
    // Plane 2: Color map mode, arbitrary orientation, use texture filtering
    //
    {
        mi::math::Vector<mi::Float32, 3> plane_point(-50.0f, 50.0f, 700.0f);
        mi::math::Vector<mi::Float32, 3> plane_normal(1.f, 1.f, 1.f);
        mi::math::Vector<mi::Float32, 3> plane_up(-1.f, 1.f, 0.f);
        mi::math::Vector<mi::Float32, 2> plane_extent(400.0f, 400.0f);
 
        const bool enable_texture_filtering = true;
        const mi::Sint32 colormap_entry_id = 40; // same as demo application's colormap file 40
        mi::neuraylib::Tag colormap_tag =
            create_colormap(colormap_entry_id, scene_edit, dice_transaction);
        check_success(colormap_tag.is_valid());
        group_node->append(colormap_tag, dice_transaction);
 
        mi::base::Handle<nv::index::ITexture_filter_mode> tex_filter;
 
        if (enable_texture_filtering)
        {
            tex_filter = scene_edit->create_attribute<nv::index::ITexture_filter_mode_linear>();
        }
        else
        {
            tex_filter = scene_edit->create_attribute<nv::index::ITexture_filter_mode_nearest_neighbor>();
        }
        check_success(tex_filter.is_valid_interface());
        mi::neuraylib::Tag tex_filter_tag = dice_transaction->store_for_reference_counting(tex_filter.get());
        check_success(tex_filter_tag.is_valid());
        group_node->append(tex_filter_tag, dice_transaction);
 
        // Access an application layer component that provides some sample techniques such as the mandelbrot for 2d surfaces:
        mi::base::Handle<nv::index::app::data_analysis_and_processing::IData_analysis_and_processing> processing(
            get_application_layer_interface()->get_api_component<nv::index::app::data_analysis_and_processing::IData_analysis_and_processing>());
        check_success(processing.is_valid_interface());
        // Create a mandelbrot technique and add it to the scene. For more details on how to implement the mandelbrot, please review the provided
        // source that was shipped with the application layer component 'nv::index::app::data_analysis_and_processing::IData_analysis_and_processing'.
        mi::base::Handle<nv::index::IDistributed_compute_technique> mapping(
            processing->get_sample_tool_set()->create_mandelbrot_2d_technique(
                plane_extent, nv::index::IDistributed_compute_destination_buffer_2d_texture::FORMAT_SCALAR_UINT8));
        check_success(mapping.is_valid_interface());
        mi::neuraylib::Tag mapping_tag = dice_transaction->store_for_reference_counting(mapping.get());
        check_success(mapping_tag.is_valid());
        group_node->append(mapping_tag, dice_transaction);
 
        mi::base::Handle<nv::index::IPlane> plane(
            scene_edit->create_shape<nv::index::IPlane>());
        check_success(plane.is_valid_interface());
        plane->set_point(plane_point);
        plane->set_normal(plane_normal);
        plane->set_up(plane_up);
        plane->set_extent(plane_extent);
 
        mi::neuraylib::Tag plane_tag = dice_transaction->store_for_reference_counting(plane.get());
        check_success(plane_tag.is_valid());
        group_node->append(plane_tag, dice_transaction);
    }
 
    // Finally append everything to the root of the hierachical scene description
    mi::neuraylib::Tag group_tag = dice_transaction->store_for_reference_counting(group_node.get());
    check_success(group_tag.is_valid());
    scene_edit->append(group_tag, dice_transaction);
}
 
//----------------------------------------------------------------------
// setup camera to see this example scene
void Create_plane::setup_camera(nv::index::IPerspective_camera* cam) const
{
    check_success(cam != 0);
 
    // Set the camera parameters to see the whole scene.
    const mi::math::Vector<mi::Float32, 3> from(100.0f, 0.0f, -1000.0f);
    const mi::math::Vector<mi::Float32, 3> to  (0.0f, 250.0f, 0.0f);
    const mi::math::Vector<mi::Float32, 3> up  (0.0f, 1.0f, 0.0f);
    mi::math::Vector<mi::Float32, 3> viewdir = to - from;
    viewdir.normalize();
 
    cam->set(from, viewdir, up);
    cam->set_aperture(0.033f);
    cam->set_aspect(1.0f);
    cam->set_focal(0.03f);
    cam->set_clip_min(80.0f);
    cam->set_clip_max(5000.0f);
}
 
//----------------------------------------------------------------------
void Create_plane::setup_extreme_transformed_camera(
    nv::index::IPerspective_camera* cam) const
{
    check_success(cam != 0);
    // *** Camera:
    // index::camera::eye_point = 1808409.125 9981818 10948.5126953125
    // index::camera::view_direction = (1808409.125 9981818 -1500) - eye_point
    // index::camera::up_direction = 0 1 0
    // index::camera::aspect = 1.7152034261242
    // index::camera::aperture = 0.033
    // index::camera::focal = 0.03
    // index::camera::clip_min = 124.485130310059
    // index::camera::clip_max = 17585.455078125
    // index::canvas_resolution = 1602 934
 
    // Adjusted the camera position for p = 23+1.
    mi::math::Vector< mi::Float32, 3 > const from( 1805060.125f + 5120.0f, 9978520.0f + 0.0f,    -30720.0f);
    mi::math::Vector< mi::Float32, 3 > const to  ( 1805060.125f + 0.0f,    9978520.0f + 2560.0f,      0.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.71520f); // not 1.7152034261242f, see IEEE754
    cam->set_focal(0.03f);
    cam->set_clip_min(124.485f); // not 124.485130310059f, see IEEE754
    cam->set_clip_max(17585.6f); // not 17585.55078125f,   see IEEE754
 
    INFO_LOG << "Set camera extreme mode";
}
 
//----------------------------------------------------------------------
mi::math::Matrix<mi::Float32, 4, 4> Create_plane::get_extreme_transformed_matrix() const
{
    // transform =
    //  [ 20.6100006103516   0                0       1805060
    //    0                 20.6100006103516  0       9978520
    //    0                  0               -4       0
    //    0                  0                0       1       ]
 
    mi::math::Matrix<mi::Float32, 4, 4> transform_mat(
        20.0f,       0.0f,       0.0f,  0.0f,
        0.0f,        20.0f,      0.0f,  0.0f,
        0.0f,        0.0f,      -20.0f,  0.0f,
        1805060.0f,  9978520.0f, 0.0f,  1.0f
        );
    return transform_mat;
}
 
//----------------------------------------------------------------------
nv::index::IFrame_results* Create_plane::render_frame(const std::string& output_fname) const
{
    check_success(m_index_rendering.is_valid_interface());
 
    // set output filename, empty string is valid
    m_image_file_canvas->set_rgba_file_name(output_fname.c_str());
 
    check_success(m_session_tag.is_valid());
 
    mi::base::Handle<mi::neuraylib::IDice_transaction> dice_transaction(
        m_global_scope->create_transaction<mi::neuraylib::IDice_transaction>());
    check_success(dice_transaction.is_valid_interface());
 
    m_index_session->update(m_session_tag, dice_transaction.get());
 
    mi::base::Handle<nv::index::IFrame_results> frame_results(
        m_index_rendering->render(
            m_session_tag,
            m_image_file_canvas.get(),
            dice_transaction.get()));
    check_success(frame_results.is_valid_interface());
 
    dice_transaction->commit();
 
    frame_results->retain();
    return frame_results.get();
}
 
//----------------------------------------------------------------------
int main(int argc, const char* argv[])
{
    nv::index::app::String_dict sdict;
    sdict.insert("dice::verbose", "3");                         // log level
    sdict.insert("outfname", "frame_create_plane");             // output file base name
    sdict.insert("verify_image_fname", "");                     // for unit test
    sdict.insert("unittest", "0");                              // default mode
    sdict.insert("supersampling", "0");                         // disable supersampling (default)
    sdict.insert("is_large_translate", "0");                    // large translation mode (default 0)
    sdict.insert("is_dump_comparison_image_when_failed", "1");  // default: dump images when failed.
    sdict.insert("is_call_from_test", "0");                     // default: not call from make check.
 
    // dice setting
    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 data_analysis_and_processing");
 
    // Initialize application
    Create_plane create_plane;
    create_plane.initialize(argc, argv, sdict);
    check_success(create_plane.is_initialized());
 
    // launch the application. creating the scene and rendering.
    const mi::Sint32 exit_code = create_plane.launch();
    INFO_LOG << "Shutting down ...";
 
    return exit_code;
}