Example for the HTTP server

[Previous] [Next] [Up]

This example imports a scene file, renders the scene, and serves the image via an HTTP server

New Topics

• Running an HTTP server

Detailed Description

Running an HTTP server

This example provides a very simple HTTP server which just serves one particular image. The image is rendered in the same way as in the Example for Rendering. See HTTP server for a general introduction to the HTTP server.

This examples uses a simple request handler which always serves a fixed image, independent of the requested URL, etc. A response handler is installed to set the content type to 'image/jpeg'. Note that this is just done for illustration purposes. The content type could also be set directly by the request handler.

Example Source

Source Code Location: examples/example_http_server.cpp

/******************************************************************************
 * Copyright 2023 NVIDIA Corporation. All rights reserved.
 *****************************************************************************/
 
// examples/example_http_server.cpp
//
// Imports a scene file, renders the scene, and serves the image via the HTTP server
//
// The example expects the following command line arguments:
//
//   example_rendering <scene_file> <mdl_path> <port>
//
// scene_file       some scene file, e.g., main.mi
// mdl_path         path to the MDL modules, e.g., iray-<version>/mdl
// port             port for the HTTP server
 
#include <iostream>
 
#include <mi/neuraylib.h>
 
// Include code shared by all examples.
#include "example_shared.h"
// Include an implementation of IRender_target.
#include "example_render_target_simple.h"
 
// Simple request handler which always sends the buffer passed in the constructor
class Request_handler : public mi::base::Interface_implement<mi::http::IRequest_handler>
{
public:
    // Constructor. Stores the passed buffer.
    Request_handler( mi::neuraylib::IBuffer* buffer)
      : m_buffer( buffer, mi::base::DUP_INTERFACE) { }
 
    // Send buffer contents over the connection.
    bool handle( mi::http::IConnection* connection)
    {
        connection->enqueue( m_buffer.get());
        return true;
    }
private:
    // The stored buffer
    mi::base::Handle<mi::neuraylib::IBuffer> m_buffer;
};
 
// Simple response handler which always sets the content type for JPG images
class Response_handler : public mi::base::Interface_implement<mi::http::IResponse_handler>
{
public:
    void handle( mi::http::IConnection* connection)
    {
        mi::http::IResponse* iresponse( connection->get_response());
        iresponse->set_header( "Content-Type", "image/jpeg");
    }
};
 
void configuration( mi::neuraylib::INeuray* neuray, const char* mdl_path)
{
    // Configure the neuray library. Here we set the search path for .mdl files.
    mi::base::Handle<mi::neuraylib::IRendering_configuration> rc(
        neuray->get_api_component<mi::neuraylib::IRendering_configuration>());
    check_success( rc->add_mdl_path( mdl_path) == 0);
    check_success( rc->add_mdl_path( ".") == 0);
 
    // Load the OpenImageIO, Iray Photoreal, and .mi importer plugins.
    mi::base::Handle<mi::neuraylib::IPlugin_configuration> pc(
        neuray->get_api_component<mi::neuraylib::IPlugin_configuration>());
    check_success( pc->load_plugin_library( "nv_openimageio" MI_BASE_DLL_FILE_EXT) == 0);
    check_success( pc->load_plugin_library( "libiray" MI_BASE_DLL_FILE_EXT) == 0);
    check_success( pc->load_plugin_library( "mi_importer" MI_BASE_DLL_FILE_EXT) == 0);
}
 
mi::base::Handle<mi::neuraylib::IBuffer> rendering(
    mi::neuraylib::INeuray* neuray, const char* scene_file)
{
    // Get the database, the global scope of the database, and create a transaction in the global
    // scope for importing the scene file and storing the scene.
    mi::base::Handle<mi::neuraylib::IDatabase> database(
        neuray->get_api_component<mi::neuraylib::IDatabase>());
    check_success( database.is_valid_interface());
    mi::base::Handle<mi::neuraylib::IScope> scope(
        database->get_global_scope());
    mi::base::Handle<mi::neuraylib::ITransaction> transaction(
        scope->create_transaction());
    check_success( transaction.is_valid_interface());
 
    // Import the scene file
    mi::base::Handle<mi::neuraylib::IImport_api> import_api(
        neuray->get_api_component<mi::neuraylib::IImport_api>());
    check_success( import_api.is_valid_interface());
    mi::base::Handle<const mi::IString> uri( import_api->convert_filename_to_uri( scene_file));
    mi::base::Handle<const mi::neuraylib::IImport_result> import_result(
        import_api->import_elements( transaction.get(), uri->get_c_str()));
    check_success( import_result->get_error_number() == 0);
 
    // Create the scene object
    mi::base::Handle<mi::neuraylib::IScene> scene(
        transaction->create<mi::neuraylib::IScene>( "Scene"));
    scene->set_rootgroup(       import_result->get_rootgroup());
    scene->set_options(         import_result->get_options());
    scene->set_camera_instance( import_result->get_camera_inst());
    transaction->store( scene.get(), "the_scene");
 
    // Create the render context using the Iray Photoreal render mode
    scene = transaction->edit<mi::neuraylib::IScene>( "the_scene");
    mi::base::Handle<mi::neuraylib::IRender_context> render_context(
        scene->create_render_context( transaction.get(), "iray"));
    check_success( render_context.is_valid_interface());
    mi::base::Handle<mi::IString> scheduler_mode( transaction->create<mi::IString>());
    scheduler_mode->set_c_str( "batch");
    render_context->set_option( "scheduler_mode", scheduler_mode.get());
    scene = 0;
 
    // Create the render target and render the scene
    mi::base::Handle<mi::neuraylib::IImage_api> image_api(
        neuray->get_api_component<mi::neuraylib::IImage_api>());
    mi::base::Handle<mi::neuraylib::IRender_target> render_target(
        new Render_target( image_api.get(), "Color", 512, 384));
    check_success( render_context->render( transaction.get(), render_target.get(), 0) >= 0);
 
    // Access the first canvas of the render target
    mi::base::Handle<mi::neuraylib::ICanvas> canvas( render_target->get_canvas( 0));
 
    // Convert content of the canvas to a JPG image
    mi::base::Handle<mi::neuraylib::IBuffer> buffer(
        image_api->create_buffer_from_canvas( canvas.get(), "jpg", "Rgb", "100"));
 
    transaction->commit();
 
    return buffer;
}
 
void run_http_server(
    mi::neuraylib::INeuray* neuray, mi::neuraylib::IBuffer* buffer, const char* port)
{
    // Create a server instance
    mi::base::Handle<mi::http::IFactory> http_factory(
        neuray->get_api_component<mi::http::IFactory>());
    mi::base::Handle<mi::http::IServer> http_server(
        http_factory->create_server());
 
    // Install our request and response handlers
    mi::base::Handle<mi::http::IRequest_handler> request_handler( new Request_handler( buffer));
    http_server->install( request_handler.get());
    mi::base::Handle<mi::http::IResponse_handler> response_handler( new Response_handler());
    http_server->install( response_handler.get());
 
    // Assemble server address
    std::string address = "0.0.0.0:";
    address += port;
 
    // Run server for fixed time interval
    http_server->start( address.c_str());
    sleep_seconds( 30);
    http_server->shutdown();
}
 
int main( int argc, char* argv[])
{
    // Collect command line parameters
    if( argc != 4) {
        std::cerr << "Usage: example_http_server <scene_file> <mdl_path> <port>" << std::endl;
        keep_console_open();
        return EXIT_FAILURE;
    }
    const char* scene_file  = argv[1];
    const char* mdl_path    = argv[2];
    const char* port        = argv[3];
 
    // Access the neuray library
    mi::base::Handle<mi::neuraylib::INeuray> neuray( load_and_get_ineuray());
    check_success( neuray.is_valid_interface());
 
    // Configure the neuray library
    configuration( neuray.get(), mdl_path);
 
    // Start the neuray library
    mi::Sint32 result = neuray->start();
    check_start_success( result);
 
    // Do the actual rendering
    mi::base::Handle<mi::neuraylib::IBuffer> buffer = rendering( neuray.get(), scene_file);
 
    // Serve image via HTTP server on given port
    run_http_server( neuray.get(), buffer.get(), port);
    buffer = 0;
 
    // Shut down the neuray library
    check_success( neuray->shutdown() == 0);
    neuray = 0;
 
    // Unload the neuray library
    check_success( unload());
 
    keep_console_open();
    return EXIT_SUCCESS;
}

[Previous] [Next] [Up]