xac_compute_app.cpp

Go to the documentation of this file.

/******************************************************************************
 * Copyright 2023 NVIDIA Corporation. All rights reserved.
 *****************************************************************************/
 
#include "xac_compute_app.h"
#include "xac_compute_scenes.h"
#include "xac_compute_scene_tool.h"
#include "xac_compute_plane.h"
#define USE_NVINDEX_ACCESS
#include "utility/example_shared.h"
#include "utility/app_rendering_context.h"
#include "utility/canvas_utility.h"
#include "utility/example_performance_logger.h"
#include <nv/index/icamera.h>
#include <nv/index/iindex.h>
#include <nv/index/iscene.h>
#include <nv/index/isession.h>
#include <nv/index/icolormap.h>
#include <nv/index/iindex_debug_configuration.h>
 
 
namespace xac_compute {
 
 
void get_default_options(Option_map& opt_map)
{
    opt_map["user_program_mode"] = "2";
    opt_map["scene"]             = "0";
    opt_map["profile"]           = "0";                  // default: no profiling 
    opt_map["run_compute"]       = "1";
    opt_map["compute_plane"]     = "0";
    opt_map["compute_roi"]       = "0 0 0  0 0 0";       // empty == complete
    opt_map["export_scene"]      = "0";
    opt_map["export_directory"]  = "";
    opt_map["export_file_name"]  = "";
    opt_map["export_file_ext"]   = "";
 
    opt_map["use_cluster"]                          = "0";                    // 1 to enable cluster, use cluster_rendering_remotehost
    opt_map["dice::verbose"]                        = "3";                    // log level
    opt_map["dice::network::multicast_address"]     = "224.1.3.2";
    opt_map["roi"]                                  = "0 0 0  0 0 0";         // input roi
    opt_map["outfname"]                             = "frame_xac_compute";    // output image file base name
    opt_map["unittest"]                             = "0";
    opt_map["is_dump_comparison_image_when_failed"] = "1";
    opt_map["is_call_from_test"]                    = "0";
 
    for (int i = 0, n = get_num_scenes(); i < n; ++i) {
        get_scene_setup(i)->add_arguments(opt_map);
    }
    Plane_setup plane_setup;
    plane_setup.add_arguments(opt_map);
}
 
 
 
std::string get_usage(const Option_map& opt_map)
{
    Usage_helper usage(opt_map);
    usage.stream() << "Option: [-h]\n            Print this message\n\n";
 
    usage.opt("scene", "n");
    usage.line("0: sparse volume     (svol)");
    usage.line("1: tiled heightfield (hfield)");
    usage.line("2: triangle mesh     (tmesh)");
    usage.line();
    usage.opt("user_program_mode",  "n", "Enable user programs for scene elements (0:none, 1:only render, 2:with compute method).");    
    usage.opt("load_user_program",  "FILENAME", "Load user program from file.");
    usage.opt("dump_user_program",  "FILENAME", "Dump builtin user program to file.");
    usage.opt("load_plane_user_program", "FILENAME", "Load user program for plane from file.");
    usage.opt("dump_plane_user_program", "FILENAME", "Dump builtin user program for plane to file.");
    usage.opt("profile",            "bool", "Enable performance profiling.");
    usage.opt("run_compute",        "n", "How to perform compute 1:post-render, 2:pre-render, 3:pre+post-render.");
    usage.opt("compute_plane",      "n", "Use XAC compute plane feature.");
    usage.opt("compute_roi",        "\"float float float  float float float\"", "Region of interest for compute (box min, box max).");
    usage.opt("subcube_size",       "X Y Z", "Set global subcube size (default: 510 510 510)");
    usage.opt("subcube_border",     "n",     "Set global subcube border size (default: 1)");
    usage.opt("export_scene",       "bool", "Export computed scene data.");
    usage.opt("export_directory",   "DIR", "Directory for scene exports.");
    usage.opt("export_file_name",   "NAME", "Base name of export file");
    usage.opt("export_file_ext",    ".EXT", "File extension of export file, including dot.");
    usage.line();
    for (int i = 0, n = get_num_scenes(); i < n; ++i) {
        get_scene_setup(i)->usage_info(usage);
        usage.line();
    }
    Plane_setup plane_setup;
    plane_setup.usage_info(usage);
 
    usage.line();
 
 
    usage.opt("dice::verbose",      "level",    "Verbosity level (3 is info.).");
    usage.opt("use_cluster",        "bool",     "Enable cluster mode, use cluster_rendering_remotehost as server.");
    usage.opt("dice::network::multicast_address", "224.1.3.2", "Multicast adddress for cluster mode.");
    usage.opt("roi",                "\"float float float float float float\"", "Bounding box of the region of interest (roi).");
    usage.opt("outfname",           "FILENAME", "Filename of the output ppm image file. When empty, no image file will be written.");
    usage.line("A frame number and the extension (.ppm) will be added.");
    usage.opt("verify_image_fname_<n>", "FILENAME", "When file with FILENAME exist, verify the rendering image (n: 0,1,2).");
    usage.opt("unittest",           "bool", "When true, unit test mode.");
 
    return usage.text();
}
 
//----------------------------------------------------------------------
 
void start_nvindex_service(
    Nvindex_access&                              nvindex_accessor,
    const Option_map&                            opt_map,
    const xac_compute::IXac_compute_scene_setup* scene_setup)
{
    info_cout(std::string("NVIDIA IndeX version: ") + nvindex_accessor.get_interface()->get_version(), opt_map.get_map());
 
    initialize_log_module(nvindex_accessor, opt_map.get_map());
 
    // Register serializable classes
    scene_setup->register_classes(nvindex_accessor.get_interface().get());
 
    // check the triangle mesh serializer/deserializer
    // Do not use remote logging
    mi::base::Handle<mi::neuraylib::IDebug_configuration> debug_configuration(
        nvindex_accessor.get_interface()->get_api_component<mi::neuraylib::IDebug_configuration>());
    check_success(debug_configuration.is_valid_interface());
    debug_configuration->set_option("check_serializer_store=1");
 
 
    mi::base::Handle<nv::index::IIndex_debug_configuration> index_debug_cfg(
        nvindex_accessor.get_interface()->get_api_component<nv::index::IIndex_debug_configuration>());
    check_success(index_debug_cfg.is_valid_interface());
    if (has_key(opt_map, "cuda_rtc_print_kernel_info")) {
        index_debug_cfg->set_option("cuda_rtc_print_kernel_info=1");
    }
    if (has_key(opt_map, "cuda_rtc_load_sources_from_file")) {
        index_debug_cfg->set_option("cuda_rtc_load_sources_from_file=1");
    }
    if (has_key(opt_map, "cuda_rtc_disable")) {
        index_debug_cfg->set_option("cuda_rtc_disable=1");
    }
    if (nv::index::app::get_bool(opt_map["profile"]) == true) {
        index_debug_cfg->set_option("performance_values_wait=1");
    }
 
    // Configure networking
    const bool is_unittest = nv::index::app::get_bool(opt_map["unittest"]);
    bool enable_cluster = nv::index::app::get_bool(opt_map["use_cluster"]) && !is_unittest;
    
    mi::neuraylib::INetwork_configuration::Mode net_mode = enable_cluster ?
        mi::neuraylib::INetwork_configuration::MODE_UDP :
        mi::neuraylib::INetwork_configuration::MODE_OFF;
 
    mi::base::Handle<mi::neuraylib::INetwork_configuration> inetwork_configuration(
        nvindex_accessor.get_interface()->get_api_component<mi::neuraylib::INetwork_configuration>());
    check_success(inetwork_configuration.is_valid_interface());
    inetwork_configuration->set_mode(net_mode);
 
    if (enable_cluster) {
        info_cout("NETWORK: Enabling UDP networking mode.", opt_map.get_map());
 
        const std::string multicast_addr(opt_map["dice::network::multicast_address"]);
        INFO_LOG << "info: NETWORK: UDP network is configured with multicast address ["
            << multicast_addr << "].";
        inetwork_configuration->set_multicast_address(multicast_addr.c_str());
 
        INFO_LOG << "info: NETWORK: no cluster interface address is set. "
            << "If you have multiple network card on a machine, you need to set this.";
        // const std::string cluster_if_adder("172.16.0.0/22:10001");
        // check_success(inetwork_configuration->set_cluster_interface(cluster_if_adder.c_str() == 0);
 
        // Define service mode to rendering and compositing (main host)
        mi::base::Handle<nv::index::ICluster_configuration> rendering_properties_query(
            nvindex_accessor.get_interface()->get_api_component<nv::index::ICluster_configuration>());
        rendering_properties_query->set_service_mode("rendering_and_compositing");
    }
 
    // Start IndeX library && application_layer
    nvindex_accessor.start_service();
}
 
 
 
//----------------------------------------------------------------------
 
void setup_app_context(App_rendering_context& arc, Nvindex_access& nvindex_accessor)
{
    arc.m_database = nvindex_accessor.get_interface()->get_api_component<mi::neuraylib::IDatabase>();
    check_success(arc.m_database.is_valid_interface());
 
    arc.m_global_scope = arc.m_database->get_global_scope();
    check_success(arc.m_global_scope.is_valid_interface());
 
    // IIndex session to create a session
    arc.m_iindex_session = nvindex_accessor.get_interface()->get_api_component<nv::index::IIndex_session>();
    check_success(arc.m_iindex_session.is_valid_interface());
 
    arc.m_iindex_rendering = nvindex_accessor.get_interface()->create_rendering_interface();
    check_success(arc.m_iindex_rendering.is_valid_interface());
 
    arc.m_icluster_configuration = nvindex_accessor.get_interface()->get_api_component<nv::index::ICluster_configuration>();
    check_success(arc.m_icluster_configuration.is_valid_interface());
 
    // create image canvas in application_layer
    arc.m_image_canvas = nvindex_accessor.create_image_file_canvas();
    check_success(arc.m_image_canvas.is_valid_interface());
}
 
 
//----------------------------------------------------------------------
 
static void view_all_bbox(
    const Vec3f&        from,
    const Vec3f&        up,
    const Bbox3f&       bbox,
    mi::neuraylib::Tag  camera_tag,
    mi::neuraylib::Tag  scene_tag,
    mi::neuraylib::IDice_transaction* dice_transaction)
{
    check_success(dice_transaction != 0);
 
    if (bbox.empty())
    {
        WARN_LOG << "Un-initialized bounding box and not updating the camera settings.";
        return;
    }
 
    {
        mi::base::Handle<nv::index::IPerspective_camera>
            camera(dice_transaction->edit<nv::index::IPerspective_camera>(camera_tag));
        check_success(camera.is_valid_interface());
 
        mi::base::Handle<const nv::index::IScene> scene(dice_transaction->access<const nv::index::IScene>(scene_tag));
        check_success(scene.is_valid_interface());
 
        // Compute the new camera parameters
        const Bbox3f& global_roi_bbox = scene->get_clipped_bounding_box();
        const Mat4f& transform_mat = scene->get_transform_matrix();
        const Vec3f new_min(mi::math::transform_point(transform_mat, global_roi_bbox.min));
        const Vec3f new_max(mi::math::transform_point(transform_mat, global_roi_bbox.max));
        const Bbox3f transformed_bbox(new_min, new_max);
        const Vec3f& center = transformed_bbox.center();
        const mi::Float32 rad = mi::math::euclidean_distance(transformed_bbox.max, transformed_bbox.min) / 2.0f;
 
        const mi::Float32 fov_rad_2 = static_cast<mi::Float32>(camera->get_fov_y_rad() / 2.0);
        const mi::Float32 dist = rad / static_cast<mi::Float32>(tan(fov_rad_2));
 
        const mi::Float32 clip_min = 0.1f * dist;
        const mi::Float32 clip_max = 10.f * dist;
        camera->set_clip_min(clip_min);
        camera->set_clip_max(clip_max);
 
        const Vec3f eyepos = -dist * from + center;
        Vec3f viewdir = center - eyepos;
        check_success(viewdir.normalize());
 
        camera->set(eyepos, viewdir, up);
 
        INFO_LOG << "view_all_box: " << eyepos << viewdir << up << " clip:" << clip_min << " " << clip_max;
    }
}
 
 
//----------------------------------------------------------------------
 
void setup_scene(
    Nvindex_access&                              nvindex_accessor,
    const xac_compute::IXac_compute_scene_setup* scene_setup,
    Compute_launch_info&                         info,
    App_rendering_context&                       arc,
    const Option_map&                            opt_map)
{
    mi::base::Handle<mi::neuraylib::IDice_transaction> dice_transaction(
        arc.m_global_scope->create_transaction<mi::neuraylib::IDice_transaction>());
    check_success(dice_transaction.is_valid_interface());
    mi::neuraylib::IDice_transaction* transaction = dice_transaction.get();
 
    // Setup session information
    arc.m_session_tag = arc.m_iindex_session->create_session(transaction);
    check_success(arc.m_session_tag.is_valid());
    mi::base::Handle<const nv::index::ISession> session(
        transaction->access<const nv::index::ISession>(arc.m_session_tag));
    check_success(session.is_valid_interface());
 
    {
        mi::base::Handle<nv::index::IConfig_settings> config_settings(
            transaction->edit<nv::index::IConfig_settings>(session->get_config()));
        check_success(config_settings.is_valid_interface());
 
        if (opt_map.has_key("svol.brick_size") && opt_map.has_key("svol.brick_border")) {
            nv::index::IConfig_settings::Sparse_volume_config svol_cfg =
                config_settings->get_sparse_volume_configuration();
            svol_cfg.brick_dimensions = nv::index::app::get_vector_from_string<mi::Uint32,3>(opt_map["svol.brick_size"]);
            svol_cfg.brick_shared_border_size = nv::index::app::get_uint32(opt_map["svol.brick_border"]);
            if (!config_settings->set_sparse_volume_configuration(svol_cfg)) {
                ERROR_LOG << "Could not set sparse volume configuration.";
            }            
        }
 
        if (opt_map.has_key("subcube_size")) {
            const Vec3u subcube_size = nv::index::app::get_vector_from_string<mi::Uint32,3>(opt_map["subcube_size"]); // def. 510
            const mi::Uint32 subcube_border = opt_map.has_key("subcube_border") ?
                nv::index::app::get_uint32(opt_map["subcube_border"]) : 1;
 
            config_settings->set_subcube_configuration(
                subcube_size, subcube_border,
                false /*support_continuous_volume_translation*/,
                false /*support_volume_rotation*/,
                Vec3f(1.f, 1.f, 1.f) /*minimal_volume_scaling*/
            );
        }
 
        // test serial render/composite
        if (false) {
            config_settings->set_parallel_rendering_and_compositing(false);
        }
    }
 
    //----------------------------------------------------------------------
    // Scene setup: hierarchical scene description root node,
    // scene parameters, camera.
    //----------------------------------------------------------------------
    Bbox3f roi_bbox = nv::index::app::get_bbox_from_string<mi::Float32,3>(opt_map["roi"]);
    if (roi_bbox.empty() || roi_bbox.is_point()) {
        roi_bbox = nv::index::app::get_bbox_from_string<mi::Float32,3>(scene_setup->get_roi_string());
    }
 
 
    // Create scene 
    Scene_info scene_info;
    scene_info.compute_launch_info.compute_roi = nv::index::app::get_bbox_from_string<mi::Float32,3>(opt_map["compute_roi"]);
    scene_info.compute_launch_info.scene_roi = roi_bbox;
 
    std::string text_filename = opt_map["load_user_program"];
    if (!text_filename.empty()) {
        load_text(text_filename, scene_info.rtc_program_source);
    }
    std::string plane_text_filename = opt_map["load_plane_user_program"];
    if (!plane_text_filename.empty()) {
        load_text(plane_text_filename, scene_info.plane_rtc_program_source);
    }
 
 
    if (nv::index::app::get_sint32(opt_map["compute_plane"]) != 0) {
        if (!scene_setup->supports_compute_plane()) {
            ERROR_LOG << "Scene does not support XAC compute plane feature.";
        }
    }
 
    check_success(scene_setup->create_scene(nvindex_accessor, scene_info, roi_bbox, arc.m_session_tag, opt_map, transaction));
 
    // Add compute plane group.
    if (nv::index::app::get_sint32(opt_map["compute_plane"]) != 0) {
        Scene_tool scene_tool(arc.m_session_tag, transaction);
 
        // Disable the scene element to see only the plane.
        const mi::neuraylib::Tag compute_target_tag = scene_info.compute_launch_info.scene_element_tag;
        mi::base::Handle<nv::index::IScene_element> scene_elem(
            scene_tool.transaction->edit<nv::index::IScene_element>(compute_target_tag));
        if (scene_elem) {
            scene_elem->set_enabled(false);
        }
 
        Plane_setup plane_setup;
        plane_setup.add_compute_plane_group(
            compute_target_tag, 
            scene_setup->plane_sample_func(),
            opt_map, scene_info, scene_tool);
    }
 
 
    text_filename = opt_map["dump_user_program"];
    if (!text_filename.empty()) {
        dump_text(text_filename, scene_info.rtc_program_source);
    }
    plane_text_filename = opt_map["dump_plane_user_program"];
    if (!plane_text_filename.empty()) {
        dump_text(plane_text_filename, scene_info.plane_rtc_program_source);
    }
    info = scene_info.compute_launch_info;
 
    const Vec2u buffer_resolution(1024, 1024);
    arc.m_image_canvas->set_resolution(buffer_resolution);
 
    // scope for scene edit
    mi::neuraylib::Tag camera_tag = mi::neuraylib::NULL_TAG;
    {
        mi::base::Handle<nv::index::IScene> scene(
            transaction->edit<nv::index::IScene>(session->get_scene()));
        check_success(scene.is_valid_interface());
 
        // 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->create_camera<nv::index::IPerspective_camera>());
        check_success(cam.is_valid_interface());
        mi::neuraylib::Tag camera_tag = dice_transaction->store(cam.get());
 
        check_success(camera_tag.is_valid());
        scene_setup->setup_camera(camera_tag, opt_map, transaction);
 
        // The the colormap to demonstrate color index color mapping.
        //mi::base::Handle<nv::index::IColormap> colormap(create_colormap(scene.get()));
        //check_success(colormap.is_valid_interface());
        // Store in DiCE database.
        //const mi::neuraylib::Tag colormap_tag = transaction->store_for_reference_counting(
        //    colormap.get(), mi::neuraylib::NULL_TAG, "colormap");
        //check_success(colormap_tag.is_valid());
        //scene->prepend(colormap_tag, transaction);
 
 
        // Set the region of interest.
        check_success(roi_bbox.is_volume());
        scene->set_clipped_bounding_box(roi_bbox);
 
 
        // Set the scene global transformation matrix.
        // only change the coordinate system
        const Vec3f sc = scene_setup->get_scene_scaling();
        const Mat4f transform_mat(
            sc.x, 0.f, 0.f, 0.f,
            0.f, sc.y, 0.f, 0.f,
            0.f, 0.f, sc.z, 0.f,
            0.f, 0.f, 0.f, 1.f
        );
        scene->set_transform_matrix(transform_mat);
 
 
        // Set the current camera to the scene.
        scene->set_camera(camera_tag);
    }
 
    if (false) {
        const Vec3f from(0.0f, 0.0f, 1.0f);
        const Vec3f up(0.0f, 1.0f, 0.0f);
        view_all_bbox(from, up, roi_bbox, camera_tag, session->get_scene(), transaction);
    }
    transaction->commit();
}
 
//----------------------------------------------------------------------
 
bool export_scene_data(
    const xac_compute::IXac_compute_scene_setup* scene_setup,
    App_rendering_context&  arc,
    const Option_map&       opt_map)
{
    mi::base::Handle<mi::neuraylib::IDice_transaction> dice_transaction(
        arc.m_global_scope->create_transaction<mi::neuraylib::IDice_transaction>());
    check_success(dice_transaction.is_valid_interface());
 
    const bool ok = scene_setup->export_scene_data(arc.m_session_tag, opt_map, dice_transaction.get());
    if (!ok) {
        ERROR_LOG << "Failed to export scene data.";
    }
    dice_transaction->commit();
    return ok;
}
 
//----------------------------------------------------------------------
 
void setup_performance_monitoring(
    App_rendering_context&  arc,
    const Option_map&       opt_map)
{
    check_success(arc.m_global_scope.is_valid_interface());
    mi::base::Handle<mi::neuraylib::IDice_transaction> dice_transaction(
        arc.m_global_scope->create_transaction<mi::neuraylib::IDice_transaction>());
    check_success(dice_transaction.is_valid_interface());
    {
        check_success(arc.m_session_tag.is_valid());
        mi::base::Handle<const nv::index::ISession> session(
            dice_transaction->access<nv::index::ISession const>(arc.m_session_tag));
        check_success(session.is_valid_interface());
 
        mi::base::Handle<nv::index::IConfig_settings> edit_config_settings(
            dice_transaction->edit<nv::index::IConfig_settings>(session->get_config()));
        check_success(edit_config_settings.is_valid_interface());
 
        // performance related configuration examples.
        const bool do_profiling = nv::index::app::get_bool(opt_map["profile"]);
        edit_config_settings->set_monitor_performance_values(do_profiling);
    }
    dice_transaction->commit();
}
 
 
 
void print_performance(
    const nv::index::IPerformance_values*   performance_values,
    const Option_map&                       opt_map,
    const char*                             info)
{
    if (!performance_values)  return;
    if (nv::index::app::get_bool(opt_map["profile"]) == false) {
        return;
    }
 
    Performance_table_logger perf_logger;
 
    char const* const time_keys[] = {
        // "time_rendering_horizon"
        "time_rendering_volume",
        // "time_rendering_volume_and_horizon"
        // "time_intersection_lines_points",
        "time_rendering_only",
        "time_gpu_upload",
        // "time_gpu_download",
        "time_rendering",
        "time_rendering_total_sum",
        "time_compositing_stage",
        // "time_image_compositing",
        // "time_image_transfer",
        "time_total_rendering",
        // "time_total_compositing",
        // "time_total_final_compositing",
        "time_complete_frame",
        // "time_frame_setup"
        // "time_frame_finish"
        // "time_avg_rendering",
        0
    };
    char const* const value_keys[] = {
        "frames_per_second",
        // "nb_subcubes"
        // "nb_subcubes_rendered"
        // "size_volume_data_rendered",
        // "size_horizon_data_rendered"
        // "nb_horizon_triangles_rendered",
        // "size_volume_data_upload"
        // "size_rendering_results_download",
        // "size_pinned_host_memory"
        // "size_unpinned_host_memory"
        // "size_gpu_memory",
        // "nb_fragments",
        // "is_using_gpu",
        // "size_span_transfer",
        // "size_span_transfer_compressed",
        // "size_intermediate_image_transfer",
        // "size_intermediate_image_transfer_compressed",
        // "size_intermediate_image_composited",
        // "nb_composited_leafs"
        // "nb_considered_leafs_per_span",
        // "nb_active_hosts",
        // "nb_horizontal_spans"
        // "nb_rendering_results_in_queue",
        0,
    };
 
    perf_logger.append_keys(time_keys);
    perf_logger.append_keys(value_keys);
 
    INFO_LOG << info << " " << perf_logger.get_table(performance_values);
}
 
 
 
void print_performance(
    const nv::index::IFrame_results*    frame_results,
    const Option_map&                   opt_map)
{
    if (frame_results) {
        const mi::base::Handle<const nv::index::IPerformance_values> performance_values(
            frame_results->get_performance_values());
        print_performance(performance_values.get(), opt_map, "Rendering");
    }
}
 
//----------------------------------------------------------------------
 
// render a frame
nv::index::IFrame_results* render_frame(
    App_rendering_context&            arc,
    const std::string&                output_fname)
{
    check_success(arc.m_iindex_rendering.is_valid_interface());
 
    // set output filename, empty string is valid
    arc.m_image_canvas->set_rgba_file_name(output_fname.c_str());
 
    check_success(arc.m_session_tag.is_valid());
 
    mi::base::Handle<mi::neuraylib::IDice_transaction> dice_transaction(
        arc.m_global_scope->create_transaction<mi::neuraylib::IDice_transaction>());
    check_success(dice_transaction.is_valid_interface());
 
    arc.m_iindex_session->update(arc.m_session_tag, dice_transaction.get());
 
    mi::base::Handle<nv::index::IFrame_results> frame_results(
        arc.m_iindex_rendering->render(
            arc.m_session_tag,
            arc.m_image_canvas.get(),
            dice_transaction.get()));
    check_success(frame_results.is_valid_interface());
 
    dice_transaction->commit();
 
    frame_results->retain();
    return frame_results.get();
}
 
 
 
 
}//xac_compute