vktStructuredVolume volume;
vktStructuredVolumeCreate(&volume,
                          64,64,64,           /* dimensions */
                          vktDataFormatUInt8, /* 8 bit per voxel */
                          1.f,1.f,1.f,        /* x/y/z voxel size / slice distance */
                          0.f,                /* float val that min. value is mapped to */
                          1.f)                /* float val that min. value is mapped to */

vktFillSV(volume, .1f);                       /* fill structured volume (SV) */
vktStructuredVolumeDestroy(volume);

vkt::RawFile file("/home/user/file.raw", "r");
vkt::Vec3i dims = file.getDims();
vkt::DataFormat dataFormat = file.getDataFormat();

vkt::InputStream is(file);

vkt::StructuredVolume volume(dims.x, dims.y, dims.z, dataFormat);
is.read(volume);

vkt::StructuredVolume volume2(32,32,32,vkt::DataFormat::UInt8);
vkt::CopyRange(volume,      // copy to volume
               volume2,     // ... from volume2
               2,2,2,       // from voxel position (2,2,2)
               8,8,8,       // to (but excluding) voxel position (8,8,8)
               1,1,1);      // save range beginning at (1,1,1) in destination volume

volume1 = vkt.StructuredVolume(16,16,16,
                               vkt.Dataformat_UInt16, # 16 bit volume
                               1.,1.,1.,
                               0.,1.);

volume2 = vkt.StructuredVolume(16,16,16,
                               vkt.Dataformat_UInt16,
                               1.,1.,1.,
                               0.,1.);

# Load, resample and render a structured volume
vkt read -i /home/user/file.raw | vkt resample --data-format uint16 -dims 16 16 16 | vkt render

# Declare a structured volume, fill with 1's, and render
vkt declare-sv --dims 32 32 32 --data-format uint8 | vkt fill --value 1 | vkt render

# Similar to before, but with range fill
vkt declare-sv --dims 32 32 32 --data-format uint8 | vkt fill --value 0.05 | vkt fill-range --value 1 --first 0 0 0 --last 8 8 8 | vkt render

# Load and render with multi scattering and a user-supplied RGBA LUT
vkt read -i /home/user/file.raw | vkt render --render-algo multi-scattering --rgba-lookup-table 1 1 1 0  0.2 0.0 0.2 0.2  0.0 0.8 0.8 0.8  1 1 0 1

# 1-d transfer function lookup table
rgba = [
    1., 1., 1., .005,
    0., .1, .1, .25,
    .5, .5, .7, .5,
    .7, .7, .07, .75,
    1., .3, .3, 1.
    ]
lut = vkt.LookupTable(5,1,1,vkt.ColorFormat_RGBA32F)
lut.setData(rgba)

# render state stores render settings
rs = vkt.RenderState()

#rs.renderAlgo = vkt.RenderAlgo_RayMarching
#rs.renderAlgo = vkt.RenderAlgo_ImplicitIso
rs.renderAlgo = vkt.RenderAlgo_MultiScattering

# resources like lookup tables, volumes, etc. are
# managed by volkit and can be accessed via handles
rs.rgbaLookupTable = lut.getResourceHandle()

# Rendering call
vkt.Render(volume, rs)

// Get the current execution policy of this thread
vkt::ExecutionPolicy ep = vkt::GetThreadExecutionPolicy();
ep.device = vkt::ExecutionPolicy::Device::CPU; // set CPU (this is the default)

// Ensuing computations are performed on the CPU
vkt::SumRange(dest, source, 0,0,0, 32,32,32);

// Switch to GPU
ep.device = vkt::ExecutionPolicy::Device::GPU;

// Only when the volumes are accessed is the data copied to the GPU
// Also, the ensuing computations are performed on the GPU
vkt::SafeDiff(dest, source);

// Switch back to CPU
ep.device = vkt::ExecutionPolicy::Device::CPU;

// Data can be explicitly copied by calling migrate()
source.migrate(); // copy data back to CPU

// Next, dest will be migrated to the CPU, too, while source isn't touched
vkt::SafeSum(dest, source);