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) 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) rs = vkt.RenderState() #rs.renderAlgo = vkt.RenderAlgo_RayMarching #rs.renderAlgo = vkt.RenderAlgo_ImplicitIso rs.renderAlgo = vkt.RenderAlgo_MultiScattering rs.rgbaLookupTable = lut.getResourceHandle() vkt.Render(volume, rs)
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(): #--- Create a volume ---------------------------------- bpv = 1 mappingLo = 0. mappingHi = 1. distX = 1. distY = 1. distZ = 1. volume = vkt.StructuredVolume(8, 8, 8, bpv, distX, distY, distZ, mappingLo, mappingHi) # Fill the volume vkt.Fill(volume, .02) #--- ScanRange----------------------------------------- # Note how dst and src are the same vkt.ScanRange( volume, # dst volume, # src 0, 0, 0, 4, 4, 4, 0, 0, 0) # In the following, some components of first > last vkt.ScanRange(volume, volume, 7, 0, 0, 3, 4, 4, 0, 0, 0) vkt.ScanRange(volume, volume, 0, 7, 0, 4, 3, 4, 0, 0, 0) vkt.ScanRange(volume, volume, 0, 0, 7, 4, 4, 3, 0, 0, 0) vkt.ScanRange(volume, volume, 7, 7, 0, 3, 3, 4, 0, 0, 0) vkt.ScanRange(volume, volume, 0, 7, 7, 4, 3, 3, 0, 0, 0) vkt.ScanRange(volume, volume, 7, 0, 7, 3, 4, 3, 0, 0, 0) vkt.ScanRange(volume, volume, 7, 7, 7, 3, 3, 3, 0, 0, 0) #--- Render ------------------------------------------- # Render volume renderState = vkt.RenderState() vkt.Render(volume, renderState)
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(): # 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.VolumeFile(sys.argv[1], vkt.OpenMode_Read) hdr = file.getHeader() if not hdr.isStructured: print("No valid volume file\n") return dims = hdr.dims if dims.x * dims.y * dims.y < 1: print("Cannot parse dimensions from file name") return bpv = hdr.bytesPerVoxel 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) 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) # Switch execution to GPU (remove those lines for CPU rendering) ep = vkt.GetThreadExecutionPolicy() ep.device = vkt.ExecutionPolicy.Device_GPU vkt.SetThreadExecutionPolicy(ep) rs = vkt.RenderState() #rs.renderAlgo = vkt.RenderAlgo_RayMarching #rs.renderAlgo = vkt.RenderAlgo_ImplicitIso rs.renderAlgo = vkt.RenderAlgo_MultiScattering rs.rgbaLookupTable = lut.getResourceHandle() vkt.Render(volume, rs)
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)