embedded_heightfield_geometry.cpp

Go to the documentation of this file.

/******************************************************************************
 * Copyright 2023 NVIDIA Corporation. All rights reserved.
 *****************************************************************************/
 
#include <nv/index/icamera.h>
#include <nv/index/iconfig_settings.h>
#include <nv/index/idata_sample.h>
#include <nv/index/iindex.h>
#include <nv/index/ilight.h>
#include <nv/index/imaterial.h>
#include <nv/index/iregular_heightfield.h>
#include <nv/index/iheightfield_pick_result.h>
#include <nv/index/iscene.h>
#include <nv/index/isession.h>
#include <nv/index/itexture_filter_mode.h>
#include <nv/index/isparse_volume_rendering_properties.h>
 
#include "utility/app_rendering_context.h"
#include "utility/canvas_utility.h"
#include "utility/example_shared.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 <iostream>
#include <sstream>
 
//----------------------------------------------------------------------
class Embedded_heightfield_geometry:
    public nv::index::app::Index_connect
{
public:
    Embedded_heightfield_geometry()
        :
        Index_connect()
    {
        // INFO_LOG << "DEBUG: Embedded_heightfield_geometry() ctor";
    }
 
    virtual ~Embedded_heightfield_geometry()
    {
        // Note: Index_connect::~Index_connect() will be called after here.
        // INFO_LOG << "DEBUG: ~Embedded_heightfield_geometry() 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:
    void setup_camera(nv::index::IPerspective_camera* cam) const;
    void pick_call(
        const mi::math::Vector_struct<mi::Uint32, 2>& pick_location,
        mi::neuraylib::IDice_transaction*             dice_transaction) const;
    void setup_scene(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;
 
    // 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;
    mi::base::Handle<nv::index::IIndex_scene_query>                                   m_index_query;
    // Create_icons options
    std::string                                                                       m_outfname;
    bool                                                                              m_is_unittest;
    std::string                                                                       m_verify_image_fname;
    std::string                                                                       m_heightfield;
    std::string                                                                       m_mask;
    std::string                                                                       m_geometry;
    std::string                                                                       m_voxel_format;
    std::string                                                                       m_render;
    mi::Float32                                                                       m_size;
    std::string                                                                       m_texture;
    bool                                                                              m_use_texture;
    bool                                                                              m_zoom;
    bool                                                                              m_pick;
    mi::Uint32                                                                        m_supersampling;
};
 
//----------------------------------------------------------------------
mi::Sint32 Embedded_heightfield_geometry::launch()
{
    mi::Sint32 exit_code = 0;
    {
        m_cluster_configuration = get_index_interface()->get_api_component<nv::index::ICluster_configuration>();
        check_success(m_cluster_configuration.is_valid_interface());
 
        // create image canvas in application_layer
        m_image_file_canvas = create_image_file_canvas(get_application_layer_interface());
        check_success(m_image_file_canvas.is_valid_interface());
 
        m_index_query = get_index_interface()->get_api_component<nv::index::IIndex_scene_query>();
        check_success(m_index_query.is_valid_interface());
 
        // Verify that the local host has joined, this may fail when there is a license problem
        check_success(is_local_host_joined(m_cluster_configuration.get()));
 
        {
            // Create our 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());
            {
                // Create an IndeX session
                m_session_tag = m_index_session->create_session(dice_transaction.get());
                check_success(m_session_tag.is_valid());
 
                if(m_supersampling > 0)
                {
                    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::IConfig_settings> config_settings(
                        dice_transaction->edit<nv::index::IConfig_settings>(session->get_config()));
                    check_success(config_settings.is_valid_interface());
 
                    // Enable supersampling
                    config_settings->set_rendering_samples(m_supersampling);
                }
 
 
                // Create the scene
                setup_scene(dice_transaction.get());
            }
            dice_transaction->commit();
        }
 
        // Render the scene
        {
            const mi::Sint32  frame_idx = 0;
            const std::string fname     = get_output_file_name(m_outfname, frame_idx);
            m_image_file_canvas->set_rgba_file_name(fname.c_str());
 
            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();
                exit_code = 1;
            }
 
            // Verify the generated image
            if (!verify_canvas_result(get_application_layer_interface(),
                                      m_image_file_canvas.get(), m_verify_image_fname, get_options()))
            {
                exit_code = 1;
            }
        }
 
        // Picking
        {
            // Create our 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());
            {
                if (m_pick)
                {
                    pick_call(mi::math::Vector<mi::Uint32, 2>(386, 322), dice_transaction.get());
                    pick_call(mi::math::Vector<mi::Uint32, 2>(98, 318),  dice_transaction.get());
                    pick_call(mi::math::Vector<mi::Uint32, 2>(422, 555), dice_transaction.get());
                    pick_call(mi::math::Vector<mi::Uint32, 2>(1024 - 962, 1024 - 453), dice_transaction.get());
 
                    // Picks a line in zoom mode
                    pick_call(mi::math::Vector<mi::Uint32, 2>(524, 496), dice_transaction.get());
 
                    // Pick a point in zoom mode
                    pick_call(mi::math::Vector<mi::Uint32, 2>(405, 578), dice_transaction.get());
                }
            }
            // Finish the picking transaction
            dice_transaction->commit();
        }
    }
    return exit_code;
}
 
//----------------------------------------------------------------------
bool Embedded_heightfield_geometry::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_heightfield        = sdict.get("heightfield");
    m_mask               = sdict.get("mask");
    m_geometry           = sdict.get("geometry");
    m_voxel_format       = sdict.get("voxel_format");
    m_render             = sdict.get("render");
    m_size               = nv::index::app::get_float32(sdict.get("size"));
    m_texture            = sdict.get("texture");
    m_use_texture        = (m_texture != "none");
    m_zoom               = nv::index::app::get_bool(sdict.get("zoom", "false"));
    m_pick               = nv::index::app::get_bool(sdict.get("pick", "false"));
    m_supersampling      = nv::index::app::get_uint32(sdict.get("supersampling"));
 
    info_cout("running " + com_name, sdict);
    info_cout("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"
            << "            print out this message\n"
            << "        [-dice::verbose severity_level]\n"
            << "            verbose severity level (3 is info). (default: " + sdict.get("dice::verbose") << ")\n"
 
            << "        [-outfname string]\n"
            << "            output ppm file base name. When empty, no output.\n"
            << "            A frame number and extension (.ppm) will be added.\n"
            << "            (default: [" << m_outfname << "])\n"
 
            << "        [-verify_image_fname image_fname]\n"
            << "            when image_fname exist, verify the rendering image.\n"
            << "            (default: [" << m_verify_image_fname << "])\n"
 
            << "        [-unittest bool]\n"
            << "            when true, unit test mode.\n"
            << "            (default: [" << m_is_unittest << "])\n"
 
            << "        [-heightfield ppm_file]\n"
            << "            filename of a grayscale PPM image that represents the heightfield.\n"
            << "            (default: [" << m_heightfield << "])\n"
 
            << "        [-mask pgm_file]\n"
            << "            filename of a monochrome PGM image that will be used as a mask on the heightfield,\n"
            << "            creating hole and therefore isolated points and connecting lines.\n"
            << "            (default: [" << m_mask << "])\n"
 
            << "        [-geometry mode]\n"
            << "            NOTE: THIS MODE == volume IS DISABLED.\n"
            << "            color modes for embedded heightfield geometry.\n"
            << "            Available modes: none, fixed, material, volume, texture\n"
            << "            (default: [" << m_geometry << "])\n"
 
            << "        [-voxel_format format]\n"
            << "            voxel format for the volume geometry mode.\n"
            << "            Available formats: uint8, rgba8\n"
            << "            (default: [" << m_voxel_format << "])\n"
 
            << "        [-render mode]\n"
            << "            rendering modes for embedded heightfield geometry.\n"
            << "            Available modes: z-axis, screen, raster\n"
            << "            (default: [" << m_render << "])\n"
 
            << "        [-size float]\n"
            << "            geometry size for z-axis or screen, ignored for raster.\n"
            << "            (default: [" << m_size << "])\n"
 
            << "        [-texture mode]\n"
            << "            map a computed texture onto the heightfield.\n"
            << "            Available modes: none, mandelbrot\n"
            << "            (default: " << m_texture << ")\n"
 
            << "        [-zoom bool]\n"
            << "            zoom in to show details of the geometry.\n"
            << "            (default: [" << m_zoom << "])\n"
 
            << "        [-pick bool]\n"
            << "            apply picking operation at various screen positions.\n"
            << "            (default: [" << m_pick << "])\n"
 
            << "        [-supersampling int]\n"
            << "            apply supersampling using the given number of samples. If set to '0' supersampling is disabled.\n"
            << "            (default: [" << m_supersampling << "])\n"
 
            << std::endl;
 
        std::exit(1);
    }
    return true;
}
 
//----------------------------------------------------------------------
void Embedded_heightfield_geometry::setup_camera(nv::index::IPerspective_camera* cam) const
{
    // Set the camera parameters to see the whole scene
    mi::math::Vector<mi::Float32, 3> from;
    mi::math::Vector<mi::Float32, 3> to;
    mi::math::Vector<mi::Float32, 3> up(0.f, 0.f, 1.0);
 
    if (m_zoom)
    {
        from = mi::math::Vector<mi::Float32, 3>(200.f, 60.f, 100.f);
        to   = mi::math::Vector<mi::Float32, 3>(170.f, 20.f, 70.f);
    }
    else
    {
        from = mi::math::Vector<mi::Float32, 3>(-0.f, -50.f, 200.f);
        to   = mi::math::Vector<mi::Float32, 3>(150.f, 150.f, 0.f);
    }
 
    mi::math::Vector<mi::Float32, 3> viewdir = to - from;
    viewdir.normalize();
 
    cam->set(from, viewdir, up);
    cam->set_aperture(0.033f);
    cam->set_aspect(1.0f);
    cam->set_focal(0.03f);
    cam->set_clip_min(2.0f);
    cam->set_clip_max(1000.0f);
}
 
//----------------------------------------------------------------------
void Embedded_heightfield_geometry::pick_call(
    const mi::math::Vector_struct<mi::Uint32, 2>& pick_location,
    mi::neuraylib::IDice_transaction*             dice_transaction) const
{
    INFO_LOG << "Picking at screen position: " << pick_location;
 
    // Run the picking operation
    mi::base::Handle<nv::index::IScene_pick_results> scene_pick_results(
        m_index_query->pick(pick_location, m_image_file_canvas.get(), m_session_tag, dice_transaction));
 
    // Print the picking result
    const mi::Uint32 nb_results = scene_pick_results->get_nb_results();
    if (nb_results > 0)
    {
        INFO_LOG << "Number of pick results: " << nb_results;
        for (mi::Uint32 i=0; i < nb_results; i++)
        {
            // Generic information
            const mi::base::Handle<nv::index::IScene_pick_result> result(scene_pick_results->get_result(i));
 
            std::stringstream log_out;
            log_out << "Intersection no. " << i << "\n"
                    << "\t\t Element (tag)           " << result->get_scene_element().id << "\n"
                    << "\t\t Sub index:              " << result->get_scene_element_sub_index() << "\n"
                    << "\t\t Distance:               " << result->get_distance() << "\n"
                    << "\t\t Position (local space): " << result->get_intersection() << "\n"
                    << "\t\t Color (evaluated):      " << result->get_color() << "\n";
 
            const mi::base::Handle<const nv::index::IData_sample> data_sample(result->get_data_sample());
            if (data_sample)
            {
                const mi::base::Handle<const nv::index::IData_sample_uint8>   ds_uint8(data_sample->get_interface<const nv::index::IData_sample_uint8>());
                const mi::base::Handle<const nv::index::IData_sample_uint16>  ds_uint16(data_sample->get_interface<const nv::index::IData_sample_uint16>());
                const mi::base::Handle<const nv::index::IData_sample_float32> ds_float32(data_sample->get_interface<const nv::index::IData_sample_float32>());
                const mi::base::Handle<const nv::index::IData_sample_rgba8>   ds_rgba8(data_sample->get_interface<const nv::index::IData_sample_rgba8>());
                if (ds_uint8) {
                    log_out << "\t Data sample:     " << mi::Uint32(ds_uint8->get_sample_value()) << "\n";
                }
                else if (ds_uint16) {
                    log_out << "\t Data sample:     " << ds_uint16->get_sample_value() << "\n";
                }
                else if (ds_float32) {
                    log_out << "\t Data sample:     " << ds_float32->get_sample_value() << "\n";
                }
                else if (ds_rgba8) {
                    log_out << "\t Data sample:     " << ds_rgba8->get_sample_value() << "\n";
                }
            }
 
            INFO_LOG << log_out.str();
 
            // Shape-specific information
            if (result->get_intersection_info_class() == nv::index::IHeightfield_pick_result::IID())
            {
                mi::base::Handle<const nv::index::IHeightfield_pick_result> compute_pick_result(
                    result->get_interface<const nv::index::IHeightfield_pick_result>());
                if (compute_pick_result && compute_pick_result->is_computing_enabled())
                {
                    INFO_LOG << "Specific pick results for computed heightfield texture:";
                    INFO_LOG << "\t Computed color value:    " << compute_pick_result->get_computed_color();
                }
            }
        }
    }
    else
    {
        INFO_LOG << "No result at pick position: " << pick_location;
    }
}
 
//----------------------------------------------------------------------
void Embedded_heightfield_geometry::setup_scene(
    mi::neuraylib::IDice_transaction* dice_transaction)
{
    // Access the session
    mi::base::Handle<const nv::index::ISession> session(
        dice_transaction->access<nv::index::ISession>(m_session_tag));
    check_success(session.is_valid_interface());
 
    // Edit the scene
    mi::base::Handle<nv::index::IScene> scene_edit(
        dice_transaction->edit<nv::index::IScene>(session->get_scene()));
    check_success(scene_edit.is_valid_interface());
 
    // Create static group node where all the scene elements will be attached
    mi::base::Handle<nv::index::IStatic_scene_group> static_group_node(
        scene_edit->create_scene_group<nv::index::IStatic_scene_group>());
    check_success(static_group_node.is_valid_interface());
 
    mi::neuraylib::Tag colormap_tag;
    if (m_geometry == "volume")
    {
        // Create a color map using an external utility function.
        const mi::Sint32 colormap_entry_id = 40; // same as demo application's colormap file 40
        colormap_tag                       = create_colormap(colormap_entry_id, scene_edit.get(), dice_transaction);
        check_success(colormap_tag.is_valid());
    }
 
    // Create the heightfield
    mi::neuraylib::Tag                     heightfield_tag;
    const mi::math::Vector<mi::Uint32, 2>  heightfield_size(300, 300);
    const mi::math::Vector<mi::Float32, 2> elevation_range(0.f, 300.f);
    {
        // Creating a ppm heightfield  importer.
        nv::index::app::String_dict heightfield_opt;
        heightfield_opt.insert("args::type",       "heightfield");
        heightfield_opt.insert("args::importer",   "nv::index::plugin::legacy_importer.PPM_heightfield_importer");
        heightfield_opt.insert("args::input_file", m_heightfield);
        {
            std::stringstream sstr;
            sstr << heightfield_size.x << " " << heightfield_size.y;
            heightfield_opt.insert("args::size",  sstr.str());
        }
        heightfield_opt.insert("args::importer_scale",  "0.3");
        heightfield_opt.insert("args::importer_offset", "0");
        heightfield_opt.insert("args::importer_binary_mask", m_mask);
        {
            std::stringstream sstr;
            sstr << elevation_range.x << " " << elevation_range.y;
            heightfield_opt.insert("args::range", sstr.str());
        }
        nv::index::IDistributed_data_import_callback* importer_callback =
            get_importer_from_application_layer(
                get_application_layer_interface(),
                "nv::index::plugin::legacy_importer.PPM_heightfield_importer",
                heightfield_opt);
 
        // Heightfield scene element
        const mi::Float32                      rotate_k = 0.f;
        const mi::math::Vector<mi::Float32, 3> translate(0.f, 0.f, 1.f);
        const mi::math::Vector<mi::Float32, 3> scale(1.f, 1.f, 1.f);
        mi::base::Handle<nv::index::IRegular_heightfield> heightfield_scene_element(
            scene_edit->create_regular_heightfield(
                scale, rotate_k, translate,
                heightfield_size,
                elevation_range,
                importer_callback,
                dice_transaction));
        check_success(heightfield_scene_element.is_valid_interface());
 
        if (m_geometry == "volume")
        {
            // Enable volume mapping for the heightfield
            heightfield_scene_element->set_colormap_mapping(true);
            heightfield_scene_element->assign_colormap(colormap_tag);
        }
 
        heightfield_tag = dice_transaction->store_for_reference_counting(heightfield_scene_element.get());
        check_success(heightfield_tag.is_valid());
    }
 
    // Add a light, a material, a rendering property, and a colormap
    {
        // 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    color_intensity(1.f, 1.f, 1.f, 1.f);
        headlight->set_intensity(color_intensity);
        headlight->set_direction(mi::math::Vector<mi::Float32, 3>(1.f, -1.f, -1.f));
        const mi::neuraylib::Tag headlight_tag = dice_transaction->store_for_reference_counting(headlight.get());
        check_success(headlight_tag.is_valid());
        static_group_node->append(headlight_tag, dice_transaction);
 
        // Material for the heightfield
        mi::base::Handle<nv::index::IPhong_gl> material(scene_edit->create_attribute<nv::index::IPhong_gl>());
        check_success(material.is_valid_interface());
 
        if (m_use_texture)
        {
            // Use just ambient white with texture
            material->set_ambient(mi::math::Color(1.f));
            material->set_diffuse(mi::math::Color(0.f));
            material->set_specular(mi::math::Color(0.f));
        }
        else
        {
            // Define a more interesting greenish material
            material->set_ambient(mi::math::Color(0.f, 0.1f, 0.0f));
            material->set_diffuse(mi::math::Color(0.f, 0.8f, 0.2f));
            material->set_specular(mi::math::Color(0.3f));
            material->set_shininess(100.f);
        }
 
        const mi::neuraylib::Tag material_tag
            = dice_transaction->store_for_reference_counting(material.get());
        check_success(material_tag.is_valid());
        static_group_node->append(material_tag, dice_transaction);
 
        // Add a sparse_volume_render_properties to the scene.
        mi::base::Handle<nv::index::ISparse_volume_rendering_properties> sparse_render_prop(
            scene_edit->create_attribute<nv::index::ISparse_volume_rendering_properties>());
        sparse_render_prop->set_filter_mode(nv::index::SPARSE_VOLUME_FILTER_NEAREST);
        sparse_render_prop->set_sampling_distance(             1.0);
        sparse_render_prop->set_reference_sampling_distance(   1.0);
        sparse_render_prop->set_voxel_offsets(                 mi::math::Vector<mi::Float32, 3>(0.0f, 0.0f, 0.0f));
        sparse_render_prop->set_preintegrated_volume_rendering(false);
        sparse_render_prop->set_lod_rendering_enabled(         false);
        sparse_render_prop->set_lod_pixel_threshold(           2.0);
        sparse_render_prop->set_debug_visualization_option(    0);
        const mi::neuraylib::Tag sparse_render_prop_tag
            = dice_transaction->store_for_reference_counting(sparse_render_prop.get());
        check_success(sparse_render_prop_tag.is_valid());
        static_group_node->append(sparse_render_prop_tag, dice_transaction);
 
        // Add a colormap to the scene.
        const mi::Sint32 colormap_entry_id    = 1; // same as demo application's colormap file 1
        const mi::neuraylib::Tag colormap_tag =
            create_colormap(colormap_entry_id, scene_edit.get(), dice_transaction);
        check_success(colormap_tag.is_valid());
        static_group_node->append(colormap_tag, dice_transaction);
    }
 
    // Optionally map a computed texture onto the heightfield
    if (m_use_texture)
    {
        // Mandelbrot texture
        if (m_texture == "mandelbrot")
        {
            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());
            static_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>());
            // 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'.
            // Create the computed texture, with a size fitting the heightfield:
            mi::base::Handle<nv::index::app::data_analysis_and_processing::ISample_tool_set> tool_set(processing->get_sample_tool_set());
            mi::base::Handle<nv::index::IDistributed_compute_technique> mapping(
                tool_set->create_mandelbrot_2d_technique(
                    mi::math::Vector<mi::Float32, 2>(heightfield_size), nv::index::IDistributed_compute_destination_buffer_2d_texture::FORMAT_RGBA_FLOAT32));
 
            // Add the mapping to the scene before the heightfield
            mi::neuraylib::Tag mapping_tag = dice_transaction->store_for_reference_counting(mapping.get());
            check_success(mapping_tag.is_valid());
            static_group_node->append(mapping_tag, dice_transaction);
        }
        else
        {
            ERROR_LOG << "Unknown texture mode '" << m_texture << "'";
            check_success(false);
        }
    }
 
    // Configure rendering of the embedded geometry
    if (m_geometry == "fixed")
    {
        // Rendering mode
        nv::index::IHeightfield_geometry_settings::Render_mode render_mode =
            nv::index::IHeightfield_geometry_settings::RENDER_DEFAULT;
        if (m_render == "z-axis")
        {
            render_mode = nv::index::IHeightfield_geometry_settings::RENDER_Z_AXIS_ALIGNED;
        }
        else if (m_render == "screen")
        {
            render_mode = nv::index::IHeightfield_geometry_settings::RENDER_SCREEN_ALIGNED;
        }
        else if (m_render == "raster")
        {
            render_mode = nv::index::IHeightfield_geometry_settings::RENDER_RASTERIZED;
 
            // Use fixed geometry size in rasterized mode (only use for picking)
            m_size = 2.0f;
        }
        else
        {
            ERROR_LOG << "Unknown render mode '" << m_render << "'";
            check_success(false);
        }
 
        //
        // Use separate settings for points and lines
        //
 
        // Settings for isolated points
        mi::base::Handle<nv::index::IHeightfield_geometry_settings> point_settings(
            scene_edit->create_attribute<nv::index::IHeightfield_geometry_settings>());
        check_success(point_settings.is_valid_interface());
        // Apply this attribute only to isolated points
        point_settings->set_type_mask(nv::index::IHeightfield_geometry_settings::TYPE_ISOLATED_POINTS);
        // Use a fixed color with no lighting
        point_settings->set_color_mode(nv::index::IHeightfield_geometry_settings::MODE_FIXED);
        // Blue points please
        point_settings->set_color(mi::math::Color(0.f, 0.f, 1.f));
        // Enable rendering of seed points
        point_settings->set_visible(true);
        // Set requested render mode
        point_settings->set_render_mode(render_mode);
        // Line width / point radius
        point_settings->set_geometry_size(m_size);
 
        const mi::neuraylib::Tag point_settings_tag
            = dice_transaction->store_for_reference_counting(point_settings.get());
        check_success(point_settings_tag.is_valid());
        static_group_node->append(point_settings_tag, dice_transaction);
 
        // Settings for seed lines
        mi::base::Handle<nv::index::IHeightfield_geometry_settings> line_settings(
            scene_edit->create_attribute<nv::index::IHeightfield_geometry_settings>());
        check_success(line_settings.is_valid_interface());
        // Apply this attribute only to connecting lines
        line_settings->set_type_mask(nv::index::IHeightfield_geometry_settings::TYPE_CONNECTING_LINES);
        // Use a fixed color with no lighting
        line_settings->set_color_mode(nv::index::IHeightfield_geometry_settings::MODE_FIXED);
        // Red lines please
        line_settings->set_color(mi::math::Color(1.f, 0.f, 0.f));
        // Enable rendering of seed lines
        line_settings->set_visible(true);
        // Set requested render mode
        line_settings->set_render_mode(render_mode);
        // Line width / point radius
        line_settings->set_geometry_size(m_size);
 
        const mi::neuraylib::Tag line_settings_tag
            = dice_transaction->store_for_reference_counting(line_settings.get());
        check_success(line_settings_tag.is_valid());
        static_group_node->append(line_settings_tag, dice_transaction);
    }
    else if (m_geometry != "none")
    {
        //
        // Use the same settings for points and lines
        //
        mi::base::Handle<nv::index::IHeightfield_geometry_settings> geometry_settings(
            scene_edit->create_attribute<nv::index::IHeightfield_geometry_settings>());
        check_success(geometry_settings.is_valid_interface());
 
        // Apply this attribute to both isolated points and connecting lines
        geometry_settings->set_type_mask(
            nv::index::IHeightfield_geometry_settings::TYPE_ISOLATED_POINTS |
            nv::index::IHeightfield_geometry_settings::TYPE_CONNECTING_LINES);
 
        if (m_geometry == "material")
        {
            // Apply the heightfield material on the embedded geometry
            geometry_settings->set_color_mode(nv::index::IHeightfield_geometry_settings::MODE_MATERIAL);
        }
        else if (m_geometry == "volume")
        {
            // Map the volume texture on the embedded geometry
            geometry_settings->set_color_mode(nv::index::IHeightfield_geometry_settings::MODE_VOLUME_TEXTURE);
        }
        else if (m_geometry == "texture")
        {
            // Map the computed heightfield texture on the embedded geometry
            geometry_settings->set_color_mode(nv::index::IHeightfield_geometry_settings::MODE_COMPUTED_TEXTURE);
        }
        else
        {
            ERROR_LOG << "Unknown geometry mode '" << m_geometry << "'";
            check_success(false);
        }
 
        // Set color to white (the default), it will modulate the material or texture color
        geometry_settings->set_color(mi::math::Color(1.f, 1.f, 1.f));
        // Enable rendering (default)
        geometry_settings->set_visible(true);
 
        const mi::neuraylib::Tag geometry_settings_tag
            = dice_transaction->store_for_reference_counting(geometry_settings.get());
        check_success(geometry_settings_tag.is_valid());
        static_group_node->append(geometry_settings_tag, dice_transaction);
    }
 
    // Create an artifical volume if requested
    if (m_geometry == "volume")
    {
        // Set up parameter for the synthetic volume generation technique
        const mi::math::Vector<mi::Uint32, 3> volume_size(
            heightfield_size.x, heightfield_size.y, static_cast<mi::Uint32>(elevation_range.y));
        const mi::math::Bbox<mi::Uint32, 3> bbox(
            mi::math::Vector<mi::Uint32, 3>(0), volume_size);
 
        // Creating a sparse volume synthetic volume generator.
        nv::index::app::String_dict        sparse_volume_opt;
        sparse_volume_opt.insert("args::type",     "sparse_volume");
        sparse_volume_opt.insert("args::importer", "synthetic");
        std::stringstream                         sstr;
        sstr << "0 0 0 " << volume_size.x << " " << volume_size.y << " " << volume_size.z;
        sparse_volume_opt.insert("args::bbox",           sstr.str());
        sparse_volume_opt.insert("args::voxel_format",   "uint8");
        sparse_volume_opt.insert("args::synthetic_type", "sphere_0");
        nv::index::IDistributed_data_import_callback* importer_callback =
            get_importer_from_application_layer(
                get_application_layer_interface(),
                "nv::index::plugin::base_importer.Sparse_volume_generator_synthetic",
                sparse_volume_opt);
        const mi::math::Bbox<mi::Float32, 3> ijk_bbox(0.0f, 0.0f, 0.0f,
                                                      static_cast<mi::Float32>(volume_size.x),
                                                      static_cast<mi::Float32>(volume_size.y),
                                                      static_cast<mi::Float32>(volume_size.z));
        const mi::math::Matrix<mi::Float32, 4, 4> transform_mat(1.0f); // Identity matrix
        mi::base::Handle<nv::index::ISparse_volume_scene_element> volume_scene_element(
            scene_edit->create_sparse_volume(ijk_bbox, transform_mat, importer_callback, dice_transaction));
        check_success(volume_scene_element.is_valid_interface());
 
        // Do not render the volume directly, just map it onto the heightfield
        volume_scene_element->set_enabled(false);
 
        const mi::neuraylib::Tag volume_tag = dice_transaction->store_for_reference_counting(volume_scene_element.get());
        check_success(volume_tag.is_valid());
 
        static_group_node->append(volume_tag, dice_transaction);
    }
 
    // Append the heightfield to the scene group after all other scene elements
    static_group_node->append(heightfield_tag, dice_transaction);
    mi::neuraylib::Tag static_group_node_tag =
        dice_transaction->store_for_reference_counting(static_group_node.get());
    check_success(static_group_node_tag.is_valid());
 
    // Append the static scene group to the scene
    scene_edit->append(static_group_node_tag, dice_transaction);
 
    // Create a camera and adjust its parameters
    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());
 
    scene_edit->set_camera(camera_tag);
 
    const mi::math::Vector<mi::Uint32, 2> buffer_resolution(1024, 1024);
    m_image_file_canvas->set_resolution(buffer_resolution);
 
    // Define the region of interest
    const mi::math::Bbox<mi::Float32, 3> region_of_interest(
        0.f, 0.f, 0.f,
        static_cast<mi::Float32>(heightfield_size.x),
        static_cast<mi::Float32>(heightfield_size.y),
        static_cast<mi::Float32>(elevation_range.y));
    scene_edit->set_clipped_bounding_box(region_of_interest);
}
 
//----------------------------------------------------------------------
nv::index::IFrame_results* Embedded_heightfield_geometry::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_embedded_heightfield_geometry"); // output file base name
    sdict.insert("verify_image_fname", ""); // for unit test
    sdict.insert("unittest", "0"); // unit test mode
 
    sdict.insert("heightfield", "../embedded_heightfield_geometry/spiral.ppm");
    sdict.insert("mask", "../embedded_heightfield_geometry/spiral-mask.pgm");
    sdict.insert("texture", "none");
    sdict.insert("geometry", "fixed");
    sdict.insert("voxel_format", "uint8");
    sdict.insert("render", "z-axis");
    sdict.insert("size", "0.5");
    sdict.insert("zoom", "0");
    sdict.insert("pick", "1");
    sdict.insert("supersampling", "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.
 
    // Disabled until height_field can reference a sparse volume in the test code 2020-02-24
    if (sdict.get("geometry") == "volume")
    {
        ERROR_LOG << "geometry == volume is currently not supported.";
        return 1;
    }
 
    // 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 data_analysis_and_processing");
    sdict.insert("index::app::plugins::base_importer::enabled",   "true");
    sdict.insert("index::app::plugins::legacy_importer::enabled", "true");
 
    // Initialize application
    Embedded_heightfield_geometry embedded_heightfield_geometry;
    embedded_heightfield_geometry.initialize(argc, argv, sdict);
    check_success(embedded_heightfield_geometry.is_initialized());
 
    // launch the application. creating the scene and rendering.
    const mi::Sint32 exit_code = embedded_heightfield_geometry.launch();
    INFO_LOG << "Shutting down ...";
 
    return exit_code;
}