def main():
# Volume dimensions
dims = vkt.Vec3i()
dims.x = 120
dims.y = 66
dims.z = 49
# Brick size
brickSize = vkt.Vec3i()
brickSize.x = 16
brickSize.y = 16
brickSize.z = 16
# Halo / ghost cells
haloSizeNeg = vkt.Vec3i()
haloSizeNeg.x = 1
haloSizeNeg.y = 1
haloSizeNeg.z = 1
haloSizePos = vkt.Vec3i()
haloSizePos.x = 1
haloSizePos.y = 1
haloSizePos.z = 1
dataFormat = vkt.DataFormat_UInt8
mappingLo = 0.
mappingHi = 1.
distX = 1.
distY = 1.
distZ = 1.
volume = vkt.StructuredVolume(dims.x, dims.y, dims.z, dataFormat, distX,
distY, distZ, mappingLo, mappingHi)
# Put some values in
vkt.Fill(volume, .1)
# The destination data structure
decomp = vkt.Array3D_StructuredVolume()
# Preallocate storage for the decomposition
vkt.BrickDecomposeResize(decomp, volume, brickSize, haloSizeNeg,
haloSizePos)
# Compute the decomposition
vkt.BrickDecompose(decomp, volume, brickSize, haloSizeNeg, haloSizePos)
vkt.Render(decomp[vkt.Vec3i()])
def main():
if len(sys.argv) < 2:
print("Usage: ", sys.argv[0], "file.raw")
return
file = vkt.RawFile(sys.argv[1], "r")
dims = file.getDims()
if dims.x * dims.y * dims.y < 1:
print("Cannot parse dimensions from file name")
return
bpv = file.getBytesPerVoxel()
if bpv == 0:
print("Cannot parse bytes per voxel from file name, guessing 1...")
bpv = 1
volume = vkt.StructuredVolume(dims.x, dims.y, dims.z, bpv)
ips = vkt.InputStream(file)
ips.read(volume)
# Print statistics for the whole volume
aggr = vkt.Aggregates()
vkt.ComputeAggregates(volume, aggr)
printStatistics(aggr, 0, 0, 0, dims.x, dims.y, dims.z)
print('\n')
# Compute a brick decomposition and print per-brick statistics
brickSize = vkt.Vec3i()
brickSize.x = 100
brickSize.y = 100
brickSize.z = 100
decomp = vkt.Array3D_StructuredVolume()
vkt.BrickDecomposeResize(decomp, volume, brickSize)
vkt.BrickDecompose(decomp, volume, brickSize)
for z in range(0, decomp.dims().z):
for y in range(0, decomp.dims().y):
for x in range(0, decomp.dims().x):
firstX = x * brickSize.x
firstY = y * brickSize.y
firstZ = z * brickSize.z
lastX = min(volume.getDims().x, firstX + brickSize.x)
lastY = min(volume.getDims().y, firstY + brickSize.y)
lastZ = min(volume.getDims().z, firstZ + brickSize.z)
aggr = vkt.Aggregates()
# Compute aggregates only for the brick range
vkt.ComputeAggregatesRange(volume, aggr, firstX, firstY,
firstZ, lastX, lastY, lastZ)
printStatistics(aggr, firstX, firstY, firstZ, lastX, lastY,
lastZ)
print('\n')
def main():
dims = vkt.Vec3i()
dims.x = 32
dims.y = 32
dims.z = 32
bpv = 1
volume1 = vkt.StructuredVolume(dims.x, dims.y, dims.z, bpv)
# CPU rendering
renderState = vkt.RenderState()
renderState.renderAlgo = vkt.RenderAlgo_MultiScattering
vkt.Render(volume1, renderState)
def main():
dims = vkt.Vec3i()
dims.x = 32
dims.y = 32
dims.z = 32
dataFormat = vkt.DataFormat_UInt8
volume1 = vkt.StructuredVolume(dims.x, dims.y, dims.z, dataFormat)
# CPU rendering
renderState = vkt.RenderState()
renderState.renderAlgo = vkt.RenderAlgo_MultiScattering
vkt.Render(volume1, renderState)
def main():
# Create a structured volume
dims = vkt.Vec3i()
dims.x = 256
dims.y = 128
dims.z = 100
dataFormat = vkt.DataFormat_UInt8
volume = vkt.StructuredVolume(
dims.x, dims.y, dims.z,
dataFormat,
1., 1., 1., # dist
0., 1. # mapping
)
vkt.Fill(volume, .1)
vkt.FillRange(
volume,
64,4,4,
192,124,96,
1.
)
# Destination volume; has the same size as the original one
rotatedVolume = vkt.StructuredVolume(
dims.x, dims.y, dims.z,
dataFormat,
1., 1., 1.,
0., 1.
)
vkt.Fill(rotatedVolume, .1)
# Rotate the volume with rotation center in the middle
axis = vkt.Vec3f()
axis.x = 1.
axis.y = .3
axis.z = 0.
angleInRadians = 45.*math.pi/180
centerOfRotation = vkt.Vec3f()
centerOfRotation.x = dims.x * .5
centerOfRotation.y = dims.y * .5
centerOfRotation.z = dims.z * .5
vkt.Rotate(
rotatedVolume,
volume,
axis,
angleInRadians,
centerOfRotation
)
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)
renderState = vkt.RenderState()
renderState.renderAlgo = vkt.RenderAlgo_MultiScattering
renderState.rgbaLookupTable = lut.getResourceHandle();
vkt.Render(rotatedVolume, renderState)