NVIDIA Index example code nvidia_logo_transpbg.gif Up
create_attribute_line_set.cpp
Go to the documentation of this file.
1/******************************************************************************
2 * Copyright 2023 NVIDIA Corporation. All rights reserved.
3 *****************************************************************************/
6
7#include <mi/dice.h>
8
9// Include code shared by all examples.
10#include "utility/example_shared.h"
11
12#include <nv/index/icamera.h>
13#include <nv/index/iindex.h>
14#include <nv/index/iscene.h>
15#include <nv/index/isession.h>
16
17// This example depends on the following extra classes.
18// - Attribute_line_set
19#include "attribute_line_set.h"
20
21#include <nv/index/app/string_dict.h>
22#include <nv/index/app/forwarding_logger.h>
23#include <nv/index/app/index_connect.h>
24
25#include "utility/canvas_utility.h"
26
27#include <iostream>
28#include <sstream>
29
30//----------------------------------------------------------------------
31// Create_attribute_line_set application class
33 public nv::index::app::Index_connect
34{
35public:
37 :
38 Index_connect()
39 {
40 // INFO_LOG << "DEBUG: Create_attribute_line_set() ctor";
41 }
42
44 {
45 // Note: Index_connect::~Index_connect() will be called after here.
46 // INFO_LOG << "DEBUG: ~Create_attribute_line_set() dtor";
47 }
48
49 // launch application
50 mi::Sint32 launch();
51
52protected:
53 virtual bool evaluate_options(nv::index::app::String_dict& sdict) CPP11_OVERRIDE;
55 mi::neuraylib::INetwork_configuration* network_configuration,
56 nv::index::app::String_dict& options) CPP11_OVERRIDE
57 {
58 check_success(network_configuration != 0);
59
60 check_success(options.is_defined("unittest"));
61 const bool is_unittest = nv::index::app::get_bool(options.get("unittest"));
62 if (is_unittest)
63 {
64 info_cout("NETWORK: disabled networking mode.", options);
65 network_configuration->set_mode(mi::neuraylib::INetwork_configuration::MODE_OFF);
66 return true;
67 }
68
69 return initialize_networking_as_default_udp(network_configuration, options);
70 }
71
72 // override
74 mi::neuraylib::IDice_configuration* configuration_interface,
75 nv::index::app::String_dict& options) CPP11_OVERRIDE
76 {
77 bool is_registered = false;
78 is_registered = get_index_interface()->register_serializable_class<Attribute_line_set>();
79 check_success(is_registered);
80 return is_registered;
81 }
82
83private:
84 // create line set in the scene.
85 //
86 // \param[in] scene_edit IScene for editing.
87 // \param[in] dice_transaction dice transaction
88 // \return true when success
89 bool create_attribute_line_set(
90 nv::index::IScene* scene_edit,
91 mi::neuraylib::IDice_transaction* dice_transaction);
92
93 // setup camera to see this example scene
94 //
95 // \param[in] cam a camera to be set
96 void setup_camera(
97 nv::index::IPerspective_camera* cam) const;
98
99 // render a frame
100 //
101 // \param[in] output_fname output rendering image filename
102 // \return performance values
103 nv::index::IFrame_results* render_frame(
104 const std::string& output_fname) const;
105
106
107 // This session tag
108 mi::neuraylib::Tag m_session_tag;
109 // NVIDIA IndeX cluster configuration
110 mi::base::Handle<nv::index::ICluster_configuration> m_cluster_configuration;
111 // Application layer image file canvas (a render target)
112 mi::base::Handle<nv::index::app::canvas_infrastructure::IIndex_image_file_canvas> m_image_file_canvas;
113 // Create_icons options
114 std::string m_outfname;
115 bool m_is_unittest;
116 std::string m_verify_image_fname;
117
118};
119
120//----------------------------------------------------------------------
122{
123 mi::Sint32 exit_code = 0;
124
125 // Get DiCE database components
126 {
127 m_cluster_configuration =
128 get_index_interface()->get_api_component<nv::index::ICluster_configuration>();
129 check_success(m_cluster_configuration.is_valid_interface());
130
131 // create image canvas in application_layer
132 m_image_file_canvas = create_image_file_canvas(get_application_layer_interface());
133 check_success(m_image_file_canvas.is_valid_interface());
134
135 // Verifying that local host has joined
136 // This may fail when there is a license problem.
137 check_success(is_local_host_joined(m_cluster_configuration.get()));
138
139 {
140 // DiCE database access
141 mi::base::Handle<mi::neuraylib::IDice_transaction> dice_transaction(
142 m_global_scope->create_transaction<mi::neuraylib::IDice_transaction>());
143 check_success(dice_transaction.is_valid_interface());
144 {
145 // Setup session information
146 m_session_tag =
147 m_index_session->create_session(dice_transaction.get());
148 check_success(m_session_tag.is_valid());
149 mi::base::Handle< nv::index::ISession const > session(
150 dice_transaction->access< nv::index::ISession const >(
151 m_session_tag));
152 check_success(session.is_valid_interface());
153
154 mi::base::Handle< nv::index::IScene > scene_edit(
155 dice_transaction->edit< nv::index::IScene >(session->get_scene()));
156 check_success(scene_edit.is_valid_interface());
157
158 //----------------------------------------------------------------------
159 // Scene setup: add line set shape, scene parameters, camera.
160 //----------------------------------------------------------------------
161 // Add line set shape to the scene
162 check_success(create_attribute_line_set(scene_edit.get(), dice_transaction.get()));
163
164 // Create and edit a camera. Data distribution is based on
165 // the camera. (Because only visible massive data are
166 // considered)
167 mi::base::Handle< nv::index::IPerspective_camera > cam(
168 scene_edit->create_camera<nv::index::IPerspective_camera>());
169 check_success(cam.is_valid_interface());
170 setup_camera(cam.get());
171
172 const mi::neuraylib::Tag camera_tag = dice_transaction->store(cam.get());
173 check_success(camera_tag.is_valid());
174
175 const mi::math::Vector<mi::Uint32, 2> buffer_resolution(512, 512);
176 m_image_file_canvas->set_resolution(buffer_resolution);
177
178 // Set up the scene
179 mi::math::Bbox_struct< mi::Float32, 3 > const xyz_roi_st = {
180 { 0.0f, 0.0f, 0.0f, },
181 { 500.0f, 500.0f, 500.0f, },
182 };
183
184 // set the region of interest
185 const mi::math::Bbox< mi::Float32, 3 > xyz_roi(xyz_roi_st);
186 check_success(xyz_roi.is_volume());
187 scene_edit->set_clipped_bounding_box(xyz_roi_st);
188
189 // Set the scene global transformation matrix.
190 // only change the coordinate system
191 mi::math::Matrix<mi::Float32, 4, 4> transform_mat(
192 1.0f, 0.0f, 0.0f, 0.0f,
193 0.0f, 1.0f, 0.0f, 0.0f,
194 0.0f, 0.0f, -1.0f, 0.0f,
195 0.0f, 0.0f, 0.0f, 1.0f
196 );
197 scene_edit->set_transform_matrix(transform_mat);
198
199 // Set the current camera to the scene.
200 check_success(camera_tag.is_valid());
201 scene_edit->set_camera(camera_tag);
202 }
203 // Finish the setup transaction
204 dice_transaction->commit();
205 }
206
207 // Rendering
208 {
209 mi::Sint32 const frame_idx = 0;
210 std::string const fname = get_output_file_name(m_outfname, frame_idx);
211 mi::base::Handle<nv::index::IFrame_results> frame_results(render_frame(fname));
212
213 const mi::base::Handle<nv::index::IError_set> err_set(frame_results->get_error_set());
214 if (err_set->any_errors())
215 {
216 std::ostringstream os;
217 const mi::Uint32 nb_err = err_set->get_nb_errors();
218 for (mi::Uint32 e = 0; e < nb_err; ++e)
219 {
220 if (e != 0) os << '\n';
221 const mi::base::Handle<nv::index::IError> err(err_set->get_error(e));
222 os << err->get_error_string();
223 }
224
225 ERROR_LOG << "IIndex_rendering rendering call failed with the following error(s): " << '\n'
226 << os.str();
227 exit_code = 1;
228 }
229
230 // verify the generated frame
231 if (!(verify_canvas_result(get_application_layer_interface(),
232 m_image_file_canvas.get(), m_verify_image_fname, get_options())))
233 {
234 exit_code = 1;
235 }
236 }
237 }
238 // index_connect shutdown
239
240 return exit_code;
241}
242
243//----------------------------------------------------------------------
244bool Create_attribute_line_set::evaluate_options(nv::index::app::String_dict& sdict)
245{
246 const std::string com_name = sdict.get("command:", "<unknown_command>");
247 m_is_unittest = nv::index::app::get_bool(sdict.get("unittest", "false"));
248
249 if (m_is_unittest)
250 {
251 if (nv::index::app::get_bool(sdict.get("is_call_from_test", "false")))
252 {
253 sdict.insert("is_dump_comparison_image_when_failed", "0");
254 }
255 sdict.insert("outfname", ""); // turn off file output in the unit test mode
256 sdict.insert("dice::verbose", "2");
257 }
258
259 m_outfname = sdict.get("outfname");
260 m_verify_image_fname = sdict.get("verify_image_fname");
261
262 info_cout(std::string("running ") + com_name, sdict);
263 info_cout("outfname = [" + m_outfname +
264 "], verify_image_fname = [" + m_verify_image_fname +
265 "], dice::verbose = " + sdict.get("dice::verbose"), sdict);
266
267 // print help and exit if -h
268 if(sdict.is_defined("h"))
269 {
270 std::cout
271 << "info: Usage: " << com_name << " [option]\n"
272 << "Option: [-h]\n"
273 << " printout this message\n"
274 << " [-dice::verbose severity_level]\n"
275 << " verbose severity level (3 is info.). (default: " + sdict.get("dice::verbose")
276 << ")\n"
277 << " [-outfname string]\n"
278 << " output ppm file base name. When empty, no output.\n"
279 << " A frame number and extension (.ppm) will be added.\n"
280 << " (default: [" << m_outfname << "])\n"
281 << " [-verify_image_fname [image_fname]]\n"
282 << " when image_fname exist, verify the rendering image. (default: ["
283 << m_verify_image_fname << "])\n"
284 << " [-unittest bool]\n"
285 << " when true, unit test mode (create smaller volume). "
286 << "(default: " << m_is_unittest << ")"
287 << std::endl;
288 exit(1);
289 }
290 return true;
291}
292
293//----------------------------------------------------------------------
294bool Create_attribute_line_set::create_attribute_line_set(
295 nv::index::IScene* scene_edit,
296 mi::neuraylib::IDice_transaction* dice_transaction)
297{
298 check_success(scene_edit != 0);
299 check_success(dice_transaction != 0);
300
301 // hierarchical scene description node for the point set
302 mi::base::Handle<nv::index::ITransformed_scene_group> group_node(
303 scene_edit->create_scene_group<nv::index::ITransformed_scene_group>());
304 check_success(group_node.is_valid_interface());
305
306 // Line coordinates and its attributes. According to the
307 // attributes, color and width are defined.
308 // Here, we create two line sets.
309 std::vector< mi::math::Vector_struct< mi::Float32, 3> > line_seg_vec[2];
310 std::vector< mi::Float32 > attribute_vec[2];
311
312 // Square shaped positions
313 const mi::Sint32 column_count = 20;
314 const mi::Sint32 line_segment_count = 201;
315 const mi::Sint32 line_set_count = 2;
316 const mi::Float32 x_org = 0.0;
317 const mi::Float32 y_org = 0.0;
318 const mi::Float32 x_mag = 25.0;
319 const mi::Float32 y_mag = 25.0;
320 const mi::Float32 z = 30.0;
321 const mi::Float32 y_offset[2] = { 0.0f, 280.0f };
322 for(mi::Sint32 i = 0; i < line_segment_count; ++i)
323 {
324 mi::math::Vector_struct< mi::Float32, 3> pos[2];
325 for(mi::Sint32 j = 0; j < line_set_count; ++j)
326 {
327 pos[j].x = x_org + static_cast< mi::Float32 >(i % column_count) * x_mag;
328 pos[j].y = y_org + static_cast< mi::Float32 >(i / column_count) * y_mag + y_offset[j];
329 pos[j].z = z;
330 line_seg_vec[j]. push_back(pos[j]);
331 attribute_vec[j].push_back(static_cast< mi::Float32 >(i));
332 }
333 }
334
335 // Create two line sets
336 for(mi::Sint32 j = 0; j < 2; ++j)
337 {
338 // Create attribute_line_set scene element and add it to the scene
339 mi::base::Handle<Attribute_line_set> line_set(
340 new Attribute_line_set(line_seg_vec[j], attribute_vec[j]));
341
342 // Add the line segments to the database
343 mi::neuraylib::Tag const line_set_scene_element_tag =
344 dice_transaction->store_for_reference_counting(line_set.get());
345 // if you are not registered Attribute_line_set, the next check fails.
346 check_success(line_set_scene_element_tag.is_valid());
347 // Add to the scene description
348 group_node->append(line_set_scene_element_tag, dice_transaction);
349 INFO_LOG << "Added line_set (size: " << line_set_count << ") to the scene (tag id: "
350 << line_set_scene_element_tag.id << ").";
351 }
352
353 mi::neuraylib::Tag group_node_tag = dice_transaction->store_for_reference_counting(group_node.get());
354 check_success(group_node_tag.is_valid());
355 scene_edit->append(group_node_tag, dice_transaction);
356
357 return true;
358}
359
360//----------------------------------------------------------------------
361void Create_attribute_line_set::setup_camera(
362 nv::index::IPerspective_camera* cam) const
363{
364 check_success(cam != 0);
365
366 // Set the camera parameters to see the whole scene
367 mi::math::Vector< mi::Float32, 3 > const from( 254.0f, 254.0f, 550.0f);
368 mi::math::Vector< mi::Float32, 3 > const to ( 255.0f, 255.0f, -255.0f);
369 mi::math::Vector< mi::Float32, 3 > const up ( 0.0f, 1.0f, 0.0f);
370 mi::math::Vector<mi::Float32, 3> viewdir = to - from;
371 viewdir.normalize();
372
373 cam->set(from, viewdir, up);
374 cam->set_aperture(0.033f);
375 cam->set_aspect(1.0f);
376 cam->set_focal(0.03f);
377 cam->set_clip_min(10.0f);
378 cam->set_clip_max(5000.0f);
379}
380
381//----------------------------------------------------------------------
382// render a frame
383//
384// \param[in] output_fname output rendering image filename
385// \return performance values
386nv::index::IFrame_results* Create_attribute_line_set::render_frame(
387 const std::string& output_fname) const
388{
389 check_success(m_index_rendering.is_valid_interface());
390
391 // set output filename, empty string is valid
392 m_image_file_canvas->set_rgba_file_name(output_fname.c_str());
393
394 check_success(m_session_tag.is_valid());
395
396 mi::base::Handle<mi::neuraylib::IDice_transaction> dice_transaction(
397 m_global_scope->create_transaction<mi::neuraylib::IDice_transaction>());
398 check_success(dice_transaction.is_valid_interface());
399
400 m_index_session->update(m_session_tag, dice_transaction.get());
401
402 mi::base::Handle<nv::index::IFrame_results> frame_results(
403 m_index_rendering->render(
404 m_session_tag,
405 m_image_file_canvas.get(),
406 dice_transaction.get()));
407 check_success(frame_results.is_valid_interface());
408
409 dice_transaction->commit();
410
411 frame_results->retain();
412 return frame_results.get();
413}
414
415//----------------------------------------------------------------------
416int main(int argc, const char* argv[])
417{
418 nv::index::app::String_dict sdict;
419 sdict.insert("dice::verbose", "3"); // log level
420 sdict.insert("dice::network::mode", "OFF"); // network mode
421 sdict.insert("outfname", "frame_create_attribute_line_set"); // output file base name
422 sdict.insert("verify_image_fname", ""); // for unit test
423 sdict.insert("unittest", "0"); // default mode
424 sdict.insert("is_dump_comparison_image_when_failed", "1"); // default: dump images when failed.
425 sdict.insert("is_call_from_test", "0"); // default: not call from make check.
426
427 // Load IndeX library via Index_connect
428 // index setting
429 sdict.insert("index::config::set_monitor_performance_values", "true");
430 sdict.insert("index::service", "rendering_and_compositing");
431 sdict.insert("index::cuda_debug_checks", "false");
432
433 // application_layer component loading
434 sdict.insert("index::app::components::application_layer::component_name_list",
435 "canvas_infrastructure image io");
436
437 // Initialize application
438 Create_attribute_line_set create_attribute_line_set;
439 create_attribute_line_set.initialize(argc, argv, sdict);
440 check_success(create_attribute_line_set.is_initialized());
441
442 // launch the application. creating the scene and rendering.
443 const mi::Sint32 exit_code = create_attribute_line_set.launch();
444 INFO_LOG << "Shutting down ...";
445
446 return exit_code;
447}
attribute line set as an example implementation
An example of line set that contains 3D line segments (stored as vertices in a array) and a color as ...
virtual bool evaluate_options(nv::index::app::String_dict &sdict) CPP11_OVERRIDE
virtual bool initialize_networking(mi::neuraylib::INetwork_configuration *network_configuration, nv::index::app::String_dict &options) CPP11_OVERRIDE
virtual bool register_serializable_classes(mi::neuraylib::IDice_configuration *configuration_interface, nv::index::app::String_dict &options) CPP11_OVERRIDE
int main(int argc, const char *argv[])
#define check_success(expr)