isparse_volume_subset.h

Go to the documentation of this file.

/******************************************************************************
 * Copyright 2023 NVIDIA Corporation. All rights reserved.
 *****************************************************************************/
 
#ifndef NVIDIA_INDEX_ISPARSE_VOLUME_SUBSET_H
#define NVIDIA_INDEX_ISPARSE_VOLUME_SUBSET_H
 
#include <mi/dice.h>
#include <mi/base/interface_declare.h>
#include <mi/math/vector.h>
 
#include <nv/index/idistributed_data_subset.h>
 
namespace nv {
namespace index {
 
enum Sparse_volume_voxel_format
{
    SPARSE_VOLUME_VOXEL_FORMAT_UINT8          = 0x00,   
    SPARSE_VOLUME_VOXEL_FORMAT_UINT8_2,                 
    SPARSE_VOLUME_VOXEL_FORMAT_UINT8_4,                 
    SPARSE_VOLUME_VOXEL_FORMAT_SINT8,                   
    SPARSE_VOLUME_VOXEL_FORMAT_SINT8_2,                 
    SPARSE_VOLUME_VOXEL_FORMAT_SINT8_4,                 
    SPARSE_VOLUME_VOXEL_FORMAT_UINT16,                  
    SPARSE_VOLUME_VOXEL_FORMAT_UINT16_2,                
    SPARSE_VOLUME_VOXEL_FORMAT_UINT16_4,                
    SPARSE_VOLUME_VOXEL_FORMAT_SINT16,                  
    SPARSE_VOLUME_VOXEL_FORMAT_SINT16_2,                
    SPARSE_VOLUME_VOXEL_FORMAT_SINT16_4,                
    SPARSE_VOLUME_VOXEL_FORMAT_FLOAT16,                 
    SPARSE_VOLUME_VOXEL_FORMAT_FLOAT16_2,               
    SPARSE_VOLUME_VOXEL_FORMAT_FLOAT16_4,               
    SPARSE_VOLUME_VOXEL_FORMAT_FLOAT32,                 
    SPARSE_VOLUME_VOXEL_FORMAT_FLOAT32_2,               
    SPARSE_VOLUME_VOXEL_FORMAT_FLOAT32_4,               
 
    SPARSE_VOLUME_VOXEL_FORMAT_COUNT,
    SPARSE_VOLUME_VOXEL_FORMAT_INVALID = SPARSE_VOLUME_VOXEL_FORMAT_COUNT
};
 
inline mi::Sint32 get_sizeof(const nv::index::Sparse_volume_voxel_format fmt)
{
    switch (fmt)
    {
    case nv::index::SPARSE_VOLUME_VOXEL_FORMAT_UINT8:     return     sizeof(mi::Uint8);
    case nv::index::SPARSE_VOLUME_VOXEL_FORMAT_UINT8_2:   return 2 * sizeof(mi::Uint8);
    case nv::index::SPARSE_VOLUME_VOXEL_FORMAT_UINT8_4:   return 4 * sizeof(mi::Uint8);
    case nv::index::SPARSE_VOLUME_VOXEL_FORMAT_SINT8:     return     sizeof(mi::Sint8);
    case nv::index::SPARSE_VOLUME_VOXEL_FORMAT_SINT8_2:   return 2 * sizeof(mi::Sint8);
    case nv::index::SPARSE_VOLUME_VOXEL_FORMAT_SINT8_4:   return 4 * sizeof(mi::Sint8);
    case nv::index::SPARSE_VOLUME_VOXEL_FORMAT_UINT16:    return     sizeof(mi::Uint16);
    case nv::index::SPARSE_VOLUME_VOXEL_FORMAT_UINT16_2:  return 2 * sizeof(mi::Uint16);
    case nv::index::SPARSE_VOLUME_VOXEL_FORMAT_UINT16_4:  return 4 * sizeof(mi::Uint16);
    case nv::index::SPARSE_VOLUME_VOXEL_FORMAT_SINT16:    return     sizeof(mi::Sint16);
    case nv::index::SPARSE_VOLUME_VOXEL_FORMAT_SINT16_2:  return 2 * sizeof(mi::Sint16);
    case nv::index::SPARSE_VOLUME_VOXEL_FORMAT_SINT16_4:  return 4 * sizeof(mi::Sint16);
    case nv::index::SPARSE_VOLUME_VOXEL_FORMAT_FLOAT16:   return     sizeof(mi::Sint16);
    case nv::index::SPARSE_VOLUME_VOXEL_FORMAT_FLOAT16_2: return 2 * sizeof(mi::Sint16);
    case nv::index::SPARSE_VOLUME_VOXEL_FORMAT_FLOAT16_4: return 4 * sizeof(mi::Sint16);
    case nv::index::SPARSE_VOLUME_VOXEL_FORMAT_FLOAT32:   return     sizeof(mi::Float32);
    case nv::index::SPARSE_VOLUME_VOXEL_FORMAT_FLOAT32_2: return 2 * sizeof(mi::Float32);
    case nv::index::SPARSE_VOLUME_VOXEL_FORMAT_FLOAT32_4: return 4 * sizeof(mi::Float32);
    default:
        return 0;
    }
}
 
class IVolume_device_data_buffer :
    public mi::base::Interface_declare<0x60d74933,0xd556,0x49de,0xaa,0xbc,0x5d,0xa7,0xaa,0xc1,0x4c,0x50>
{
public:
    virtual bool                                is_valid() const = 0;
 
    virtual Sparse_volume_voxel_format          get_data_format() const = 0;
 
    virtual mi::math::Vector<mi::Sint32, 3>     get_data_position() const = 0;
 
    virtual mi::math::Vector<mi::Uint32, 3>     get_data_extent() const = 0;
    
    virtual void*                               get_device_data() const = 0;
 
    virtual mi::Size                            get_data_size() const = 0;
 
    virtual mi::Sint32                          get_gpu_device_id() const = 0;
};
 
class ISparse_volume_attribute_set_descriptor :
    public mi::base::Interface_declare<0x728bb4d5,0x1d77,0x42da,0x81,0x1c,0x39,0xa3,0x34,0x56,0x26,0xa4,
                                       IDistributed_data_attribute_set_descriptor>
{
public:
    struct Attribute_parameters
    {
        Sparse_volume_voxel_format  format;             
    };
 
    virtual bool    setup_attribute(
                        mi::Uint32                  attrib_index,
                        const Attribute_parameters& attrib_params) = 0;
 
    virtual bool    get_attribute_parameters(
                        mi::Uint32                  attrib_index,
                        Attribute_parameters&       attrib_params) const = 0;
};
 
class ISparse_volume_subset_data_descriptor :
    public mi::base::Interface_declare<0xad2ab72c,0xab33,0x4357,0xb6,0xd5,0x5a,0xcd,0xb9,0xf9,0x62,0xca,
                                       IDistributed_data_subset_data_descriptor>
{
public:
    struct Data_brick_info
    {
        mi::math::Vector_struct<mi::Sint32, 3>  brick_position;                 
        mi::math::Bbox_struct<mi::Sint32, 3>    brick_bbox_base_level_strict;   
        mi::math::Bbox_struct<mi::Sint32, 3>    brick_bbox_base_level_extended; 
        mi::Uint32                              brick_lod_level;                
    };
 
public:
    virtual mi::Uint32                              get_dataset_number_of_lod_levels() const = 0;
 
    virtual mi::math::Bbox_struct<mi::Sint32, 3>    get_dataset_lod_level_box(mi::Uint32 lod_level) const = 0;
 
    virtual mi::math::Vector_struct<mi::Uint32, 3>  get_dataset_lod_level_resolution(mi::Uint32 lod_level) const = 0;
 
    virtual mi::math::Vector_struct<mi::Uint32, 3>  get_subset_data_brick_dimensions() const = 0;
 
    virtual mi::Uint32                              get_subset_data_brick_shared_border_size() const = 0;
 
    virtual mi::math::Bbox_struct<mi::Sint32, 3>    get_subset_lod_data_bounds(mi::Uint32 lod_level) const = 0;
 
    virtual mi::math::Vector_struct<mi::Uint32, 2>  get_subset_lod_level_range() const = 0;
 
    virtual mi::Uint32                              get_subset_number_of_data_bricks() const = 0;
    
    virtual const Data_brick_info                   get_subset_data_brick_info(mi::Uint32 brick_index) const = 0;
 
    virtual mi::Uint32                              get_lod_subset_number_of_data_bricks() const = 0;
    
    virtual mi::Uint32                              get_lod_subset_data_brick_index(mi::Uint32 lod_brick_index) const = 0;
 
    virtual mi::math::Matrix_struct<mi::Float32, 4, 4> get_dataset_transform() const = 0;
};
 
class ISparse_volume_subset :
    public mi::base::Interface_declare<0x1dfa0274,0xcf8,0x4f4c,0xa8,0x65,0x24,0xd0,0xae,0xf5,0x89,0x31,
                                       IDistributed_data_subset>
{
public:
    struct Data_brick_buffer_info
    {
        void*           data;               
        mi::Size        size;               
        mi::Sint32      gpu_device_id;      
        bool            is_pinned_memory;   
    };
 
    enum Data_transformation
    {
        DATA_TRANSFORMATION_NONE            = 0,  
        DATA_TRANSFORMATION_FLIP_AXIS_ORDER = 1   
    };
 
    enum Data_brick_state
    {
        BRICK_STATE_EMPTY   = 0x00u,
        BRICK_STATE_FILLED,
        BRICK_STATE_HOMOGENEOUS
    };
 
public:
 
    virtual const ISparse_volume_attribute_set_descriptor*  get_attribute_set_descriptor() const = 0;
 
    virtual const ISparse_volume_subset_data_descriptor*    get_subset_data_descriptor() const = 0;
 
    virtual bool                            write_brick_data(
                                                mi::Uint32          brick_subset_idx,
                                                mi::Uint32          brick_attrib_idx,
                                                const void*         src_values,
                                                mi::Sint32          gpu_device_id,
                                                Data_transformation brick_data_transform = DATA_TRANSFORMATION_NONE) = 0;
 
    virtual bool                            write_brick_data(
                                                mi::Uint32                          brick_subset_idx,
                                                mi::Uint32                          brick_attrib_idx,
                                                const mi::neuraylib::IRDMA_buffer*  src_rdma_buffer,
                                                Data_transformation                 brick_data_transform = DATA_TRANSFORMATION_NONE) = 0;
 
    virtual bool                            write_brick_data_multiple(
                                                const mi::Uint32*                   brick_subset_indices,
                                                const mi::Uint32*                   brick_attrib_indices,
                                                mi::Uint32                          nb_input_bricks,
                                                const mi::Size*                     src_rdma_buffer_offsets,
                                                const mi::neuraylib::IRDMA_buffer*  src_rdma_buffer,
                                                Data_transformation                 brick_data_transform = DATA_TRANSFORMATION_NONE) = 0;
 
    virtual const Data_brick_buffer_info    access_brick_data_buffer(
                                                mi::Uint32  brick_subset_idx,
                                                mi::Uint32  brick_attrib_idx) = 0;
    virtual const Data_brick_buffer_info    access_brick_data_buffer(
                                                mi::Uint32  brick_subset_idx,
                                                mi::Uint32  brick_attrib_idx) const = 0;
 
    virtual mi::neuraylib::IRDMA_buffer*    access_brick_data_buffer_rdma(
                                                mi::neuraylib::IRDMA_context* rdma_ctx,
                                                mi::Uint32                    brick_subset_idx,
                                                mi::Uint32                    brick_attrib_idx) = 0;
 
    virtual bool                            set_brick_homogeneous_value(
                                                mi::Uint32      brick_subset_idx,
                                                mi::Uint32      brick_attrib_idx,
                                                const void*     brick_homog_value) = 0;
 
    virtual const void*                     get_brick_homogeneous_value(
                                                mi::Uint32      brick_subset_idx,
                                                mi::Uint32      brick_attrib_idx) const = 0;
    virtual bool                            set_background_value(
                                                mi::Uint32      attrib_idx,
                                                const void*     background_value) = 0;
 
    virtual const void*                     get_background_value(
                                                mi::Uint32      attrib_idx) const = 0;
 
    virtual void                            set_brick_state(
                                                mi::Uint32       brick_subset_idx,
                                                mi::Uint32       brick_attrib_idx,
                                                Data_brick_state brick_state) = 0;
    virtual Data_brick_state                get_brick_state(
                                                mi::Uint32       brick_subset_idx,
                                                mi::Uint32       brick_attrib_idx) const = 0;
 
    virtual bool store_internal_data_representation(const char* output_filename) const = 0;
    virtual bool load_internal_data_representation(const char*  input_filename) = 0;
 
    // Experimental API
    // \note WORK IN PROGRESS
    // - will be refactored into a separate device-data interface exposing device available data
    //   if it is available in the particular context of usage
    // - this is future work as we have to work out how to handle the existing APIs for writing
    //   directly to the GPU (write_brick_data(), especially with IRDMA_buffer interface).
    // - for now we will expose currently required methods directly. they will return invalid
    //   GPU-resources when no GPU-device access is given at the particular point
    // - the plan is to currently have these methods working for the inferencing-technique
    //   APIs added
    //
 
    enum Sub_data_gen_flags
    {
        SUB_DATA_GEN_DEFAULT                = 0x00u,    
        SUB_DATA_GEN_INCLUDE_BORDER_VOXELS  = 0x01u,    
        SUB_DATA_GEN_NO_CLIP_REQUEST_VOLUME = 0x02u     
    };
 
    virtual IVolume_device_data_buffer* allocate_volume_sub_data_device(
                                                mi::Uint32                             subdata_attrib_idx,
                                                mi::math::Vector_struct<mi::Sint32, 3> subdata_position,
                                                mi::math::Vector_struct<mi::Uint32, 3> subdata_extent,
                                                mi::Uint32                             subdata_flags = SUB_DATA_GEN_DEFAULT) const = 0;
 
    virtual bool                        fill_volume_sub_data_buffer(
                                                 IVolume_device_data_buffer*        subdata_volume_buffer) const = 0;
 
    virtual bool                        write_from_volume_sub_data_buffer(
                                                const IVolume_device_data_buffer*   subdata_volume_buffer) const = 0;
 
 
};
 
} // namespace index
} // namespace nv
 
#endif // NVIDIA_INDEX_ISPARSE_VOLUME_SUBSET_H