vktStructuredVolume volume;
vktStructuredVolumeCreate(&volume,
                          64,64,64,    /* dimensions */
                          1,           /* bytes 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();
uint16_t bpv = file.getBytesPerVoxel();

vkt::InputStream is(file);

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

vkt::StructuredVolume volume2(32,32,32,1);
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,
                               2,           # 16 bit volume
                               1.,1.,1.,
                               0.,1.);

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

# Fill the volume
vkt.Fill(volume1, .02)

# Fill corner [ (0,0,0), (4,4,4) ) with .1
vkt.FillRange(volume1, 0,0,0, 4,4,4, .1)

# Compute 3D prefix sum and store result in volume2
vkt.Scan(volume2, volume1)

# 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);