def __init__(self, module_manager):
SimpleVTKClassModuleBase.__init__(
self, module_manager,
vtk.vtkStructuredPointsReader(), 'Reading vtkStructuredPoints.',
(), ('vtkStructuredPoints',),
replaceDoc=True,
inputFunctions=None, outputFunctions=None)
def main(argv):
if len(argv) < 2:
print "usage:",argv[0]," data.vtk"
exit(1)
data_fn = argv[1]
reader = vtk.vtkStructuredPointsReader()
reader.SetFileName(data_fn)
reader.Update()
data = reader.GetOutput()
updateColorOpacity()
# composite function (using ray tracing)
compositeFunction = vtk.vtkVolumeRayCastCompositeFunction()
volumeMapper = vtk.vtkVolumeRayCastMapper()
volumeMapper.SetVolumeRayCastFunction(compositeFunction)
volumeMapper.SetInput(data)
# make the volume
#volume = vtk.vtkVolume()
global volume
volume.SetMapper(volumeMapper)
volume.SetProperty(volumeProperty)
# renderer
renderer = vtk.vtkRenderer()
renderWin = vtk.vtkRenderWindow()
renderWin.AddRenderer(renderer)
renderInteractor = vtk.vtkRenderWindowInteractor()
renderInteractor.SetRenderWindow(renderWin)
renderInteractor.AddObserver( vtk.vtkCommand.KeyPressEvent, keyPressed )
renderer.AddVolume(volume)
renderer.SetBackground(0,0,0)
renderWin.SetSize(400, 400)
renderInteractor.Initialize()
renderWin.Render()
renderInteractor.Start()
def load_data_file(filename):
reader = vtk.vtkStructuredPointsReader()
reader.SetFileName(filename)
reader.Update()
Image = reader.GetOutput()
array = VTKtoNumpy(Image)
array = array.astype(float)
return array
def ReadVTKImageFile(self):
if (self.InputFileName == ''):
self.PrintError('Error: no InputFileName.')
self.PrintLog('Reading VTK image file.')
reader = vtk.vtkStructuredPointsReader()
reader.SetFileName(self.InputFileName)
reader.Update()
self.Image = reader.GetOutput()
def readSimulationData(self,_i):
# self.counter+=1
# if self.counter>3:
# return
# print "self.drawMutex=",self.drawMutex
self.drawMutex.lock()
# print "self.readFileSem.available()=",self.readFileSem.available()
self.readFileSem.acquire()
self.newFileBeingLoaded=True # this flag is used to prevent calling draw function when new data is read from hard drive
# print "LOCKED self.newFileBeingLoaded=",self.newFileBeingLoaded
# self.drawMutex.lock()
if _i >= len(self.ldsFileList):
return
fileName = self.ldsFileList[_i]
self.simulationDataReader = vtk.vtkStructuredPointsReader()
self.currentFileName = os.path.join(self.ldsDir,fileName)
self.simulationDataReader.SetFileName(self.currentFileName)
# print "path= ", os.path.join(self.ldsDir,fileName)
self.simulationDataReader.Update()
self.simulationData = self.simulationDataReader.GetOutput()
# print "self.simulationData",self.simulationData
# print 'dimensions=',self.simulationData.GetDimensions()
#updating fieldDim each time we read data
import CompuCell
self.fieldDimPrevious=self.fieldDim
# self.fieldDimPrevious=CompuCell.Dim3D()
dimFromVTK=self.simulationData.GetDimensions()
self.fieldDim=CompuCell.Dim3D(dimFromVTK[0],dimFromVTK[1],dimFromVTK[2])
#
# self.fieldDim.x=dimFromVTK[0]
# self.fieldDim.y=dimFromVTK[1]
# self.fieldDim.z=dimFromVTK[2]
# print 'self.fieldDim=',self.fieldDim
# print "vtkStructuredPointsReader ERROR CODE=",self.simulationDataReader.GetErrorCode()
self.currentStep = self.frequency * _i
self.setCurrentStep(self.currentStep)
# print "self.frequency=",self.frequency," _i=",self.frequency
# print "\n\n\n\n FINISHED RUNNING readSimulationData step ",self.currentStep," \n\n\n"
self.drawMutex.unlock()
self.readFileSem.release()
def readVTKSP(fn): ''' reads a vtk structured points object from a file ''' sp_reader = vtk.vtkStructuredPointsReader() sp_reader.SetFileName(fn) sp_reader.Update() sp = sp_reader.GetOutput() return sp
def createReader(self,fileName): #I dont care about different types of readers for now #If i get a different file then i can mod reader here or something reader = vtk.vtkStructuredPointsReader() reader.SetFileName(fileName) reader.ReadAllVectorsOn() reader.ReadAllScalarsOn() reader.Update() self.determineCenterForCuttingPlane(reader) return reader
def VTKSPtoNumpyFromFile(fn): ''' reads a .vts file into a numpy array args: @a fn - string, filename of .sp file to read ''' reader = vtk.vtkStructuredPointsReader() reader.SetFileName(fn) reader.Update() sp = reader.GetOutput() return VTKSPtoNumpy(sp)
def readVTKVolume(name):
try:
reader = vtk.vtkStructuredPointsReader()
reader.SetFileName( name )
reader.Update()
print "Input volume:", name
vol = reader.GetOutput()
reader = None
return vol
except:
print "VTK volume reader failed"
exc_type, exc_value, exc_traceback = sys.exc_info()
traceback.print_exception(exc_type, exc_value, exc_traceback, limit=2, file=sys.stdout)
return None
def calculate_vtk_max_pointwise_difference(file1,file2,tol=1e-6):
arrays = [0]*2
reader = vtk.vtkStructuredPointsReader()
for i, fname in enumerate([file1, file2]):
reader.SetFileName(fname)
reader.Update()
data = reader.GetOutput().GetPointData()
arrays[i] = np.array([vtk_to_numpy(data.GetArray(n)) for n in range(data.GetNumberOfArrays())])
try:
return np.allclose(arrays[0],arrays[1],rtol=0,atol=tol), np.max(np.abs(arrays[0]-arrays[1]))
except:
return False, np.inf
def parse_vtk(vtk_file, sim_dict, data_fields):
dim = sim_dict['dim']
reader = vtk.vtkStructuredPointsReader()
# reader = vtkUnstructuredGridReader()
reader.SetFileName(vtk_file)
reader.Update()
field_data = reader.GetOutput()
out_data = {}
for data_field in data_fields:
out_data[data_field] = vtk_to_numpy(
field_data.GetPointData().GetArray(data_field)).reshape((dim['x'],
dim['y']))
reader.CloseVTKFile()
return out_data
def main(argv):
if len(argv) < 2:
print "usage:",argv[0]," data.vtk"
exit(1)
data_fn = argv[1]
reader = vtk.vtkStructuredPointsReader()
reader.SetFileName(data_fn)
reader.Update()
data = reader.GetOutput()
skin = vtk.vtkMarchingCubes()
skin.ComputeNormalsOn()
skin.ComputeGradientsOn()
skin.SetValue(0, rgb[0][0])
skin.SetInput(data)
skin_mapper = vtk.vtkPolyDataMapper()
skin_mapper.SetInputConnection(skin.GetOutputPort())
skin_mapper.ScalarVisibilityOff()
skin_actor = vtk.vtkActor()
skin_property = vtk.vtkProperty()
skin_property.SetColor(rgb[0][1], rgb[0][2], rgb[0][3])
skin_property.SetOpacity(opacity[0][1])
skin_actor.SetProperty(skin_property)
skin_actor.SetMapper(skin_mapper)
bone = vtk.vtkMarchingCubes()
bone.ComputeNormalsOn()
bone.ComputeGradientsOn()
bone.SetValue(0, rgb[1][0])
bone.SetInput(data)
bone_mapper = vtk.vtkPolyDataMapper()
bone_mapper.SetInputConnection(bone.GetOutputPort())
bone_mapper.ScalarVisibilityOff()
bone_actor = vtk.vtkActor()
bone_actor.GetProperty().SetColor(rgb[1][1], rgb[1][2], rgb[1][3])
bone_actor.GetProperty().SetOpacity(opacity[1][1])
bone_actor.SetMapper(bone_mapper)
renderer = vtk.vtkRenderer()
renderWin = vtk.vtkRenderWindow()
renderWin.AddRenderer(renderer)
renderInteractor = vtk.vtkRenderWindowInteractor()
renderInteractor.SetRenderWindow(renderWin)
renderer.AddActor(skin_actor)
#renderer.AddActor(bone_actor)
renderer.SetBackground(0,0,0)
renderWin.SetSize(400, 400)
renderInteractor.Initialize()
renderWin.Render()
renderInteractor.Start()
def create_reader (self):
"Create the corresponding reader."
debug ("In VtkDataReader::create_reader ()")
# set up the reader
if self.file_name == "":
raise IOError, "No filename specifed for the data handler!"
self.grid_type = find_data_type (self.file_name)
if self.grid_type == "STRUCTURED_GRID":
self.reader = vtk.vtkStructuredGridReader ()
elif self.grid_type == "STRUCTURED_POINTS":
self.reader = vtk.vtkStructuredPointsReader ()
elif self.grid_type == "RECTILINEAR_GRID":
self.reader = vtk.vtkRectilinearGridReader ()
elif self.grid_type == "POLYDATA":
self.reader = vtk.vtkPolyDataReader ()
elif self.grid_type == "UNSTRUCTURED_GRID":
self.reader = vtk.vtkUnstructuredGridReader ()
def _create_structured_points_pyvtk(x, y, z):
"""Creates a vtkStructuredPoints object given input data in the
form of arrays. This uses pyvtk to do the job and generates a
temporary file in the process.
Input Arguments:
x -- Array of x-coordinates. These should be regularly spaced.
y -- Array of y-coordinates. These should be regularly spaced.
z -- Array of z values for the x, y values given. The values
should be computed such that the z values are computed as x
varies fastest and y next.
"""
import pyvtk
import tempfile, os
nx = len(x)
ny = len(y)
nz = len(z)
assert nx*ny == nz, "len(x)*len(y) != len(z). "\
"You passed nx=%d, ny=%d, nz=%d"%(nx, ny, nz)
xmin, ymin = x[0], y[0]
dx, dy= (x[1] - x[0]), (y[1] - y[0])
# create a vtk data file
sp = pyvtk.StructuredPoints ((nx, ny, 1), (xmin, ymin, 0), (dx, dy, 1))
pd = pyvtk.PointData(pyvtk.Scalars(z, name='Scalars',
lookup_table="default"))
d = pyvtk.VtkData(sp, pd, "Surf data")
file_name = tempfile.mktemp(suffix='.vtk')
d.tofile(file_name, format='ascii')
# read the created file - yes this is circuitous but works for now.
reader = vtk.vtkStructuredPointsReader()
reader.SetFileName(file_name)
reader.Update()
# cleanup.
os.remove(file_name)
return reader.GetOutput()
def load_maps(mol,rendmod,gfx,atomcol): mol.reader = vtk.vtkStructuredPointsReader() mol.reader.SetFileName(mol.mod.dfn) mol.reader.Update() #by calling Update() we read the file mol.iso = vtk.vtkMarchingContourFilter() mol.iso.UseScalarTreeOn() mol.iso.ComputeNormalsOn() mol.iso.SetInputConnection(mol.reader.GetOutputPort()) mol.iso.SetValue(0,mol.mod.isov*mol.mod.sigavg[0]+mol.mod.sigavg[1]) clean = vtk.vtkCleanPolyData() clean.SetInputConnection(mol.iso.GetOutputPort()) clean.ConvertStripsToPolysOn() smooth = vtk.vtkWindowedSincPolyDataFilter() smooth.SetInputConnection(clean.GetOutputPort()) smooth.BoundarySmoothingOn() smooth.GenerateErrorVectorsOn() smooth.GenerateErrorScalarsOn() smooth.NormalizeCoordinatesOn() smooth.NonManifoldSmoothingOn() smooth.FeatureEdgeSmoothingOn() smooth.SetEdgeAngle(90) smooth.SetFeatureAngle(90) smooth.Update() mol.mapper = vtk.vtkOpenGLPolyDataMapper() mol.mapper.SetInputConnection(smooth.GetOutputPort()) ### <- connection here mol.mapper.ScalarVisibilityOff() mol.mapper.Update() mol.acteur= vtk.vtkOpenGLActor() mol.acteur.SetMapper(mol.mapper) mol.acteur.GetProperty().SetColor(mol.col) if rendmod==5: mol.acteur.GetProperty().SetRepresentationToSurface() elif rendmod==6: mol.acteur.GetProperty().SetRepresentationToWireframe() elif rendmod==7: mol.acteur.GetProperty().SetRepresentationToPoints() else : mol.acteur.GetProperty().SetRepresentationToSurface() mol.acteur.GetProperty().SetInterpolationToGouraud() mol.acteur.GetProperty().SetSpecular(.4) mol.acteur.GetProperty().SetSpecularPower(10) gfx.renderer.AddActor(mol.acteur) gfx.renwin.Render()
def read_data(file_in,dens_inc=False):
"""
Reads in data from file_in.vtk into x, y, z, b, u
"""
import vtk as vtk
from vtk.util.numpy_support import vtk_to_numpy
from numpy import rollaxis, reshape, array
#Some vtk bookkeeping and object stuff
reader = vtk.vtkStructuredPointsReader()
reader.SetFileName(file_in)
reader.ReadAllVectorsOn()
reader.ReadAllScalarsOn()
reader.Update()
data = reader.GetOutput()
dim = data.GetDimensions()
nx = dim[0] - 1
ny = dim[1] - 1
nz = dim[2] - 1
D = data.GetSpacing()
N = (nx, ny, nz)
#Read the raw data from the vtk file
#u = vtk_to_numpy(data.GetCellData().GetArray('velocity')).reshape(nx, ny, nz, 3,order='F')
#b = vtk_to_numpy(data.GetCellData().GetArray('cell_centered_B')).reshape(nx, ny, nz, 3,order='F')
## #Convert to C-order and make a the 1st array index the vector component
#b = array([b[...,0].ravel(order='F').reshape(nx,ny,nz), b[...,1].ravel(order='F').reshape(nx,ny,nz), b[...,2].ravel(order='F').reshape(nx,ny,nz)])
#u = array([u[...,0].ravel(order='F').reshape(nx,ny,nz), u[...,1].ravel(order='F').reshape(nx,ny,nz), u[...,2].ravel(order='F').reshape(nx,ny,nz)])
## #Read the raw data from the vtk file
u = vtk_to_numpy(data.GetCellData().GetArray('velocity')).reshape(nz,ny,nx,3)
b = vtk_to_numpy(data.GetCellData().GetArray('cell_centered_B')).reshape(nz, ny, nx,3)
if(dens_inc):
rho = vtk_to_numpy(data.GetCellData().GetArray('density')).reshape(nz,ny,nx)
return (N,D,b.T,u.T,rho.T)
#u = ascontiguousarray(array([u[...,0], u[...,1], u[...,2]]))
#b = ascontiguousarray(array([b[...,0], b[...,1], b[...,2]]))
#u = u.transpose(3,2,1,0)
#b = b.transpose(3,2,1,0)
return (N, D, b.T, u.T)
def read_vtk(filename, skipGrid = False, reshape = False):
reader = vtkStructuredPointsReader()
reader.SetFileName(filename)
# reader.SetDataByteOrderToBigEndian()
# reader.ReadAllVectorsOn()
# reader.ReadAllScalarsOn()
reader.Update()
data = reader.GetOutput()
dim = data.GetDimensions()
vec = list(dim)
vec = [i-1 for i in dim]
vec.append(3)
# print dim
# print vec
# print data.GetPointData()
try:
u = VN.vtk_to_numpy(data.GetPointData().GetArray('Re'))
except AttributeError:
#older file format
u = VN.vtk_to_numpy(data.GetPointData().GetArray('scalar_field'))
x = np.zeros(data.GetNumberOfPoints())
y = np.zeros(data.GetNumberOfPoints())
z = np.zeros(data.GetNumberOfPoints())
if not skipGrid:
# Looping over all the point takes a while... perhaps there is a faster way
for i in range(data.GetNumberOfPoints()):
x[i],y[i],z[i] = data.GetPoint(i)
if reshape:
u = u.reshape(dim,order='F')
x = x.reshape(dim,order='F')
y = y.reshape(dim,order='F')
z = z.reshape(dim,order='F')
return (u, np.array([x,y,z]))
def readvtk(path, datatype='polydata'):
"""Read VTK-file.
Args:
path: Path to file.
type: 'imagedata', 'polydata', 'unstructeredgrid'
"""
if datatype=='imagedata':
reader = vtk.vtkStructuredPointsReader()
elif datatype=='polydata':
reader = vtk.vtkPolyDataReader()
elif datatype=='unstructeredgrid':
reader = vtk.vtkUnstructuredGridReader()
else:
print 'Invalid datatype'
reader.SetFileName(path)
reader.Update()
return reader.GetOutput()
def readDisplacement(filename):
reader = vtk.vtkStructuredPointsReader();reader.SetFileName(filename);
reader.Update();
grid = reader.GetOutput();
Dimensions=grid.GetExtent();
NumPixX=Dimensions[1]+1;
NumPixY=Dimensions[3]+1;
centre = grid.GetCenter();
bounds = grid.GetBounds();
reader.SetScalarsName(reader.GetScalarsNameInFile(0));reader.Update();structuredPoints = reader.GetOutput();
pd=structuredPoints.GetPointData();
scalars=pd.GetScalars(reader.GetScalarsNameInFile(0));
numPoints = scalars.GetSize();
U=numpy.zeros([numPoints/2,1]);
V=numpy.zeros([numPoints/2,1]);
for i in range(0,(numPoints-1)/2):
U[i]=scalars.GetValue(2*i);
V[i]=scalars.GetValue(2*i+1);
return {'U':U.reshape(NumPixY,NumPixX), 'V':V.reshape(NumPixY,NumPixX) }
def readSimulationDataNonBlocking(self,_i):
self.newFileBeingLoaded=True # this flag is used to prevent calling draw function when new data is read from hard drive
# print "LOCKED self.newFileBeingLoaded=",self.newFileBeingLoaded
# self.drawMutex.lock()
if _i >= len(self.ldsFileList):
return False
fileName = self.ldsFileList[_i]
self.simulationDataReader = vtk.vtkStructuredPointsReader()
self.currentFileName = os.path.join(self.ldsDir,fileName)
print 'self.currentFileName=',self.currentFileName
extractedMCS = self.extractMCSNumberFromFileName(self.currentFileName)
if extractedMCS < 0:
extractedMCS = _i
self.simulationDataReader.SetFileName(self.currentFileName)
# print "path= ", os.path.join(self.ldsDir,fileName)
dataReaderIntAddr = self.__ui.extractAddressIntFromVtkObject(self.simulationDataReader)
self.__ui.fieldExtractor.readVtkStructuredPointsData(dataReaderIntAddr) # swig wrapper on top of vtkStructuredPointsReader.Update() - releases GIL, hence can be used in multithreaded program that does not block GUI
# # # self.simulationDataReader.Update() # does not erlease GIL - VTK ISSUE - cannot be used in multithreaded program - blocks GUI
self.simulationData = self.simulationDataReader.GetOutput()
import CompuCell
self.fieldDimPrevious=self.fieldDim
# self.fieldDimPrevious=CompuCell.Dim3D()
dimFromVTK=self.simulationData.GetDimensions()
self.fieldDim=CompuCell.Dim3D(dimFromVTK[0],dimFromVTK[1],dimFromVTK[2])
self.currentStep = extractedMCS
# # # self.currentStep = self.frequency * _i # this is how we set CMS for CML reading before
self.setCurrentStep(self.currentStep)
return True
def readPicture(filename):
reader = vtk.vtkStructuredPointsReader()
reader.SetFileName(filename)
reader.Update()
grid = reader.GetOutput()
Dimensions=grid.GetExtent()
NumPixX=Dimensions[1]+1
NumPixY=Dimensions[3]+1
centre = grid.GetCenter()
bounds = grid.GetBounds()
reader.SetScalarsName(reader.GetScalarsNameInFile(0));
reader.Update();
structuredPoints = reader.GetOutput();
pd=structuredPoints.GetPointData();
scalars=pd.GetScalars(reader.GetScalarsNameInFile(0));
numPoints = scalars.GetSize()
Img=numpy.zeros([numPoints,1])
for i in range(0,(numPoints-1)):
Img[i]=scalars.GetValue(i);
return Img.reshape(NumPixY,NumPixX);
def __init__(self, module_manager):
# call parent constructor
ModuleBase.__init__(self, module_manager)
self._reader = vtk.vtkStructuredPointsReader()
# ctor for this specific mixin
FilenameViewModuleMixin.__init__(
self,
'Select a filename',
'VTK data (*.vtk)|*.vtk|All files (*)|*',
{'vtkStructuredPointsReader': self._reader})
module_utils.setup_vtk_object_progress(
self, self._reader,
'Reading vtk structured points data')
# set up some defaults
self._config.filename = ''
self.sync_module_logic_with_config()
def LoadVolume(self):
""" loads the volume - this only happens once during the lifetime of the application """
if len(sys.argv) < 2:
print " Error - please provide a file name (.vtk)"
exit
fileName = sys.argv[1]
extension = fileName.split('.')[-1]
if extension == "vtk":
reader = vtk.vtkStructuredPointsReader()
reader.SetFileName( fileName )
reader.Update()
elif extension == "tif":
reader = vtk.vtkTIFFReader()
reader.SetFileName( fileName )
reader.Update()
else:
print " Unknown file type ", extension
return reader.GetOutput()
def transformVolume(self, inputVolume, outputVolume, transformationMatrix):
# Normalize matrix so it preserve its scaling (diagonal elements are
# equal to 1)
M = self.__normalizeMatrix(transformationMatrix)
reader = vtk.vtkStructuredPointsReader()
reader.SetFileName(inputVolume)
reader.Update()
reader.GetOutput().UpdateInformation()
matrix = vtk.vtkMatrix4x4()
matrix.DeepCopy((
M[0,0], M[0,1], M[0,2], M[0,3],
M[1,0], M[1,1], M[1,2], M[1,3],
M[2,0], M[2,1], M[2,2], M[2,3],
M[3,0], M[3,1], M[3,2], M[3,3]
))
# Extract a slice in the desired orientation
reslice = vtk.vtkImageReslice()
reslice.SetInputConnection(reader.GetOutputPort())
reslice.SetResliceAxes(matrix)
reslice.AutoCropOutputOff()
reslice.SetInterpolationModeToNearestNeighbor()
#reslice.SetInterpolationModeToLinear()
print >>sys.stderr,'M=\n',M
ch = vtk.vtkImageChangeInformation()
ch.SetInput(reslice.GetOutput())
ch.SetOutputOrigin(*OUTPUT_VOLUME_ORIGIN)
ch.SetOutputSpacing(*OUTPUT_VOLUME_SPACING)
ch.Update()
writer = vtk.vtkStructuredPointsWriter()
writer.SetFileTypeToBinary()
writer.SetInput(ch.GetOutput())
writer.SetFileName(outputVolume)
writer.Update()
def readStrain(filename):
reader = vtk.vtkStructuredPointsReader();reader.SetFileName(filename);
reader.Update();
grid = reader.GetOutput();
Dimensions=grid.GetExtent();
NumPixX=Dimensions[1]+1;
NumPixY=Dimensions[3]+1;
centre = grid.GetCenter();
bounds = grid.GetBounds();
reader.SetScalarsName(reader.GetScalarsNameInFile(0));reader.Update();structuredPoints = reader.GetOutput();
pd=structuredPoints.GetPointData();
scalars=pd.GetScalars(reader.GetScalarsNameInFile(0));
numPoints = scalars.GetSize();
grad11=numpy.zeros([numPoints/4,1]);
grad12=numpy.zeros([numPoints/4,1]);
grad21=numpy.zeros([numPoints/4,1]);
grad22=numpy.zeros([numPoints/4,1]);
for i in range(0,(numPoints-1)/4):
grad11[i]=scalars.GetValue(4*i);
grad12[i]=scalars.GetValue(4*i+1);
grad21[i]=scalars.GetValue(4*i+2);
grad22[i]=scalars.GetValue(4*i+3);
return {'grad11':grad11.reshape(NumPixY,NumPixX), 'grad12':grad12.reshape(NumPixY,NumPixX),'grad21':grad21.reshape(NumPixY,NumPixX),'grad22':grad22.reshape(NumPixY,NumPixX)}
ipwz.EnabledOn()
self.Xswitch = 1
self.Yswitch = 1
self.Zswitch = 1
elif key == "l":
if self.liver == 1:
renderer.RemoveActor(liverActor)
self.liver = 0
self.render_window.Render()
else:
renderer.AddActor(liverActor)
self.liver = 1
self.render_window.Render()
# image reader
filename1 = "ctscan_ez.vtk"
reader1 = vtk.vtkStructuredPointsReader()
reader1.SetFileName( filename1 )
reader1.Update()
W,H,D = reader1.GetOutput().GetDimensions()
a1,b1 = reader1.GetOutput().GetScalarRange()
print "Range of image: %d--%d" %(a1,b1)
filename2 = "ctscan_ez_bin.vtk"
reader2 = vtk.vtkStructuredPointsReader()
reader2.SetFileName( filename2 )
reader2.Update()
a2,b2 = reader2.GetOutput().GetScalarRange()
print "Range of segmented image: %d--%d" %(a2,b2)
def Main():
global ren
print "data: %s" % sys.argv[1]
reader = vtk.vtkStructuredPointsReader()
reader.SetFileName(sys.argv[1])
# Create the standard renderer, render window and interactor
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
iren.RemoveObservers('RightButtonPressEvent')
iren.AddObserver('RightButtonPressEvent', print_camera_settings, 1.0)
iren.AddObserver('RightButtonPressEvent', after_print_camera_settings,
-1.0)
datapoints = [[420, 0.1, 0.1, 1, 0.0001], [950, 0, 0.8, 1, 0.0002],
[1642, 0.1, 0, 1, 1]]
# Create transfer mapping scalar value to opacity
opacityTransferFunction = vtk.vtkPiecewiseFunction()
for p in datapoints:
opacityTransferFunction.AddPoint(p[0], p[4])
# Create transfer mapping scalar value to color
colorTransferFunction = vtk.vtkColorTransferFunction()
for p in datapoints:
colorTransferFunction.AddHSVPoint(p[0], p[1], p[2], p[3])
# The property describes how the data will look
volumeProperty = vtk.vtkVolumeProperty()
volumeProperty.SetColor(colorTransferFunction)
volumeProperty.SetScalarOpacity(opacityTransferFunction)
volumeProperty.ShadeOn()
volumeProperty.SetInterpolationTypeToLinear()
# The mapper / ray cast function know how to render the data
compositeFunction = vtk.vtkVolumeRayCastCompositeFunction()
volumeMapper = vtk.vtkVolumeRayCastMapper()
volumeMapper.SetVolumeRayCastFunction(compositeFunction)
volumeMapper.SetInputConnection(reader.GetOutputPort())
volumeMapper.SetSampleDistance(0.1)
print "sample distance: %f" % volumeMapper.GetSampleDistance()
# The volume holds the mapper and the property and
# can be used to position/orient the volume
volume = vtk.vtkVolume()
volume.SetMapper(volumeMapper)
volume.SetProperty(volumeProperty)
ren.AddVolume(volume)
ren.SetBackground(0, 0, 0)
ren.GetActiveCamera().SetViewUp(-0.033792287793636924,
0.000854723562570334, -0.9994285120674231)
ren.GetActiveCamera().SetPosition(-308.155681140229, -119.92183136577268,
117.3094068139949)
ren.GetActiveCamera().SetFocalPoint(91.14654767513275, 104.1683804243803,
104.0)
ren.GetActiveCamera().SetClippingRange(191.00826351112892,
795.369621458024)
renWin.SetSize(1600, 900)
renWin.Render()
renWin.AddObserver("AbortCheckEvent", CheckAbort)
iren.Initialize()
renWin.Render()
iren.Start()
# This is a simple volume rendering example that uses a # vtkVolumeRayCast mapper import vtk from vtk.util.misc import vtkGetDataRoot VTK_DATA_ROOT = vtkGetDataRoot() # Create the standard renderer, render window and interactor ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) # Create the reader for the data reader = vtk.vtkStructuredPointsReader() reader.SetFileName(VTK_DATA_ROOT + "/Data/ironProt.vtk") # Create transfer mapping scalar value to opacity opacityTransferFunction = vtk.vtkPiecewiseFunction() opacityTransferFunction.AddPoint(20, 0.0) opacityTransferFunction.AddPoint(255, 0.2) # Create transfer mapping scalar value to color colorTransferFunction = vtk.vtkColorTransferFunction() colorTransferFunction.AddRGBPoint(0.0, 0.0, 0.0, 0.0) colorTransferFunction.AddRGBPoint(64.0, 1.0, 0.0, 0.0) colorTransferFunction.AddRGBPoint(128.0, 0.0, 0.0, 1.0) colorTransferFunction.AddRGBPoint(192.0, 0.0, 1.0, 0.0) colorTransferFunction.AddRGBPoint(255.0, 0.0, 0.2, 0.0)
def main():
fileName = r"carotid.vtk"
colors = vtk.vtkNamedColors()
ren1 = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren1)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
# Create the pipeline.
reader = vtk.vtkStructuredPointsReader()
reader.SetFileName(fileName)
psource = vtk.vtkPointSource()
psource.SetNumberOfPoints(25)
psource.SetCenter(133.1, 116.3, 5.0)
psource.SetRadius(2.0)
threshold = vtk.vtkThresholdPoints()
threshold.SetInputConnection(reader.GetOutputPort())
threshold.ThresholdByUpper(275)
streamers = vtk.vtkStreamTracer()
streamers.SetInputConnection(reader.GetOutputPort())
streamers.SetSourceConnection(psource.GetOutputPort())
streamers.SetMaximumPropagation(100.0)
streamers.SetInitialIntegrationStep(0.2)
streamers.SetTerminalSpeed(.01)
streamers.Update()
scalarRange = [0] * 2
scalarRange[0] = streamers.GetOutput().GetPointData().GetScalars(
).GetRange()[0]
scalarRange[1] = streamers.GetOutput().GetPointData().GetScalars(
).GetRange()[1]
tubes = vtk.vtkTubeFilter()
tubes.SetInputConnection(streamers.GetOutputPort())
tubes.SetRadius(0.3)
tubes.SetNumberOfSides(6)
tubes.SetVaryRadius(0)
lut = vtk.vtkLookupTable()
lut.SetHueRange(.667, 0.0)
lut.Build()
streamerMapper = vtk.vtkPolyDataMapper()
streamerMapper.SetInputConnection(tubes.GetOutputPort())
streamerMapper.SetScalarRange(scalarRange[0], scalarRange[1])
streamerMapper.SetLookupTable(lut)
streamerActor = vtk.vtkActor()
streamerActor.SetMapper(streamerMapper)
# Speed contours.
iso = vtk.vtkContourFilter()
iso.SetInputConnection(reader.GetOutputPort())
iso.SetValue(0, 175)
isoMapper = vtk.vtkPolyDataMapper()
isoMapper.SetInputConnection(iso.GetOutputPort())
isoMapper.ScalarVisibilityOff()
isoActor = vtk.vtkActor()
isoActor.SetMapper(isoMapper)
isoActor.GetProperty().SetRepresentationToWireframe()
isoActor.GetProperty().SetOpacity(0.25)
# Outline
outline = vtk.vtkOutlineFilter()
outline.SetInputConnection(reader.GetOutputPort())
outlineMapper = vtk.vtkPolyDataMapper()
outlineMapper.SetInputConnection(outline.GetOutputPort())
outlineActor = vtk.vtkActor()
outlineActor.SetMapper(outlineMapper)
outlineActor.GetProperty().SetColor(0., 0., 0.)
# Add the actors to the renderer, set the background and size.
ren1.AddActor(outlineActor)
ren1.AddActor(streamerActor)
ren1.AddActor(isoActor)
ren1.SetBackground(1., 1., 1.)
renWin.SetSize(640, 480)
ren1.ResetCamera()
ren1.ResetCameraClippingRange()
# Render the image.
renWin.Render()
iren.Start()
def main():
fileName = get_program_parameters()
colors = vtk.vtkNamedColors()
ren1 = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren1)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
# Create the pipeline.
#
reader = vtk.vtkStructuredPointsReader()
reader.SetFileName(fileName)
psource = vtk.vtkPointSource()
psource.SetNumberOfPoints(25)
psource.SetCenter(133.1, 116.3, 5.0)
psource.SetRadius(2.0)
threshold = vtk.vtkThresholdPoints()
threshold.SetInputConnection(reader.GetOutputPort())
threshold.ThresholdByUpper(275)
streamers = vtk.vtkStreamTracer()
streamers.SetInputConnection(reader.GetOutputPort())
streamers.SetSourceConnection(psource.GetOutputPort())
# streamers.SetMaximumPropagationUnitToTimeUnit()
streamers.SetMaximumPropagation(100.0)
# streamers.SetInitialIntegrationStepUnitToCellLengthUnit()
streamers.SetInitialIntegrationStep(0.2)
streamers.SetTerminalSpeed(.01)
streamers.Update()
scalarRange = [0] * 2
scalarRange[0] = streamers.GetOutput().GetPointData().GetScalars(
).GetRange()[0]
scalarRange[1] = streamers.GetOutput().GetPointData().GetScalars(
).GetRange()[1]
print("range: ", scalarRange[0], ", ", scalarRange[1])
tubes = vtk.vtkTubeFilter()
tubes.SetInputConnection(streamers.GetOutputPort())
tubes.SetRadius(0.3)
tubes.SetNumberOfSides(6)
tubes.SetVaryRadius(0)
lut = vtk.vtkLookupTable()
lut.SetHueRange(.667, 0.0)
lut.Build()
streamerMapper = vtk.vtkPolyDataMapper()
streamerMapper.SetInputConnection(tubes.GetOutputPort())
streamerMapper.SetScalarRange(scalarRange[0], scalarRange[1])
streamerMapper.SetLookupTable(lut)
streamerActor = vtk.vtkActor()
streamerActor.SetMapper(streamerMapper)
# Speed contours.
iso = vtk.vtkContourFilter()
iso.SetInputConnection(reader.GetOutputPort())
iso.SetValue(0, 175)
isoMapper = vtk.vtkPolyDataMapper()
isoMapper.SetInputConnection(iso.GetOutputPort())
isoMapper.ScalarVisibilityOff()
isoActor = vtk.vtkActor()
isoActor.SetMapper(isoMapper)
isoActor.GetProperty().SetRepresentationToWireframe()
isoActor.GetProperty().SetOpacity(0.25)
# Outline
outline = vtk.vtkOutlineFilter()
outline.SetInputConnection(reader.GetOutputPort())
outlineMapper = vtk.vtkPolyDataMapper()
outlineMapper.SetInputConnection(outline.GetOutputPort())
outlineActor = vtk.vtkActor()
outlineActor.SetMapper(outlineMapper)
outlineActor.GetProperty().SetColor(colors.GetColor3d("Black"))
# Add the actors to the renderer, set the background and size.
#
ren1.AddActor(outlineActor)
ren1.AddActor(streamerActor)
ren1.AddActor(isoActor)
ren1.SetBackground(colors.GetColor3d("Wheat"))
renWin.SetSize(640, 480)
cam1 = vtk.vtkCamera()
cam1.SetClippingRange(17.4043, 870.216)
cam1.SetFocalPoint(136.71, 104.025, 23)
cam1.SetPosition(204.747, 258.939, 63.7925)
cam1.SetViewUp(-0.102647, -0.210897, 0.972104)
cam1.Zoom(1.6)
ren1.SetActiveCamera(cam1)
# Render the image.
#
renWin.Render()
iren.Start()
def main():
fileNames = [""] * 2
fileNames[0], fileNames[1] = get_program_parameters()
# Generate the other vecAnim file names. There are 8 of them.
tmpFn = fileNames[1][:-5]
for i in range(2, 9):
fileNames.append(tmpFn + str(i) + ".vtk")
colors = vtk.vtkNamedColors()
# Setup the render window, renderer, and interactor.
renderer = vtk.vtkRenderer()
renderWindow = vtk.vtkRenderWindow()
renderWindow.AddRenderer(renderer)
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetRenderWindow(renderWindow)
# Read the data.
#
# Create the pipeline.
#
reader = vtk.vtkStructuredPointsReader()
reader.SetFileName(fileNames[0])
threshold = vtk.vtkThresholdPoints()
threshold.SetInputConnection(reader.GetOutputPort())
threshold.ThresholdByUpper(200)
line = vtk.vtkLineSource()
line.SetResolution(1)
lines = vtk.vtkGlyph3D()
lines.SetInputConnection(threshold.GetOutputPort())
lines.SetSourceConnection(line.GetOutputPort())
lines.SetScaleFactor(0.005)
lines.SetScaleModeToScaleByScalar()
lines.Update()
vectorMapper = vtk.vtkPolyDataMapper()
vectorMapper.SetInputConnection(lines.GetOutputPort())
vectorMapper.SetScalarRange(lines.GetOutput().GetScalarRange())
vectorActor = vtk.vtkActor()
vectorActor.SetMapper(vectorMapper)
vectorActor.GetProperty().SetOpacity(0.99)
vectorActor.GetProperty().SetLineWidth(1.5)
# Outline
outline = vtk.vtkOutlineFilter()
outline.SetInputConnection(reader.GetOutputPort())
outlineMapper = vtk.vtkPolyDataMapper()
outlineMapper.SetInputConnection(outline.GetOutputPort())
outlineActor = vtk.vtkActor()
outlineActor.SetMapper(outlineMapper)
outlineActor.GetProperty().SetColor(colors.GetColor3d("Black"))
# Texture maps.
textureMaps = list()
for i in range(2, len(fileNames)):
tmap = vtk.vtkStructuredPointsReader()
tmap.SetFileName(fileNames[i])
texture = vtk.vtkTexture()
texture.SetInputConnection(tmap.GetOutputPort())
texture.InterpolateOff()
texture.RepeatOff()
textureMaps.append(texture)
vectorActor.SetTexture(textureMaps[0])
# Add the actors to the renderer, set the background and size.
#
renderer.AddActor(vectorActor)
renderer.AddActor(outlineActor)
cam1 = vtk.vtkCamera()
cam1.SetClippingRange(17.4043, 870.216)
cam1.SetFocalPoint(136.71, 104.025, 23)
cam1.SetPosition(204.747, 258.939, 63.7925)
cam1.SetViewUp(-0.102647, -0.210897, 0.972104)
cam1.Zoom(1.5)
renderer.SetActiveCamera(cam1)
renderer.SetBackground(colors.GetColor3d("Wheat"))
renderWindow.SetSize(640, 480)
# Go into a loop.
for j in range(0, 100):
for i in range(0, len(textureMaps)):
vectorActor.SetTexture(textureMaps[i])
renderWindow.Render()
interactor.Start()
def Main():
global ren
print "data: %s" % sys.argv[1]
reader = vtk.vtkStructuredPointsReader()
reader.SetFileName(sys.argv[1])
# Create the standard renderer, render window and interactor
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
iren.RemoveObservers('RightButtonPressEvent')
iren.AddObserver('RightButtonPressEvent', print_camera_settings, 1.0)
iren.AddObserver('RightButtonPressEvent', after_print_camera_settings,
-1.0)
datapoints = [[0, 0.66, 0, 1, 0], [900, 0.66, 0.1, 1, 0.009],
[10000, 0.66, 0.3, 1, 0.01], [20000, 0.66, 0.5, 1, 0.3],
[30000, 0.66, 1, 1, 1]]
# Create transfer mapping scalar value to opacity
opacityTransferFunction = vtk.vtkPiecewiseFunction()
for p in datapoints:
opacityTransferFunction.AddPoint(p[0], p[4])
# Create transfer mapping scalar value to color
colorTransferFunction = vtk.vtkColorTransferFunction()
for p in datapoints:
colorTransferFunction.AddHSVPoint(p[0], p[1], p[2], p[3])
# The property describes how the data will look
volumeProperty = vtk.vtkVolumeProperty()
volumeProperty.SetColor(colorTransferFunction)
volumeProperty.SetScalarOpacity(opacityTransferFunction)
volumeProperty.ShadeOn()
volumeProperty.SetInterpolationTypeToLinear()
# The mapper / ray cast function know how to render the data
compositeFunction = vtk.vtkVolumeRayCastCompositeFunction()
volumeMapper = vtk.vtkVolumeRayCastMapper()
volumeMapper.SetVolumeRayCastFunction(compositeFunction)
volumeMapper.SetInputConnection(reader.GetOutputPort())
volumeMapper.SetSampleDistance(0.1)
print "sample distance: %f" % volumeMapper.GetSampleDistance()
# The volume holds the mapper and the property and
# can be used to position/orient the volume
volume = vtk.vtkVolume()
volume.SetMapper(volumeMapper)
volume.SetProperty(volumeProperty)
ren.AddVolume(volume)
ren.SetBackground(0, 0, 0)
ren.GetActiveCamera().SetViewUp(0.2320640509325283, 0.6216278154231228,
0.748147803149258)
ren.GetActiveCamera().SetPosition(-86.30842917477719, -55.80182530081589,
297.63908735650085)
ren.GetActiveCamera().SetFocalPoint(199.18608617782593, 149.5, 38.5)
ren.GetActiveCamera().SetClippingRange(4.197001562269691,
982.4499004768599)
renWin.SetSize(1600, 900)
renWin.Render()
renWin.AddObserver("AbortCheckEvent", CheckAbort)
iren.Initialize()
renWin.Render()
iren.Start()
def testimageMCAll(self):
# Create the RenderWindow, Renderer and both Actors
#
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
# create pipeline
#
slc = vtk.vtkStructuredPointsReader()
slc.SetFileName(VTK_DATA_ROOT + "/Data/ironProt.vtk")
colors = ["flesh", "banana", "grey", "pink", "carrot", "gainsboro", "tomato", "gold", "thistle", "chocolate"]
types = ["UnsignedChar", "Char", "Short", "UnsignedShort", "Int", "UnsignedInt", "Long", "UnsignedLong", "Float", "Double"]
i = 1
c = 0
clip = list()
cast = list()
iso = list()
mapper = list()
actor = list()
colorWrapper = self.Colors()
for idx, vtkType in enumerate(types):
clip.append(vtk.vtkImageClip())
clip[idx].SetInputConnection(slc.GetOutputPort())
clip[idx].SetOutputWholeExtent(-1000, 1000, -1000, 1000, i, i + 5)
i += 5
cast.append(vtk.vtkImageCast())
eval('cast[idx].SetOutputScalarTypeTo' + vtkType + '()')
cast[idx].SetInputConnection(clip[idx].GetOutputPort())
cast[idx].ClampOverflowOn()
iso.append(vtk.vtkMarchingContourFilter())
iso[idx].SetInputConnection(cast[idx].GetOutputPort())
iso[idx].GenerateValues(1, 30, 30)
mapper.append(vtk.vtkPolyDataMapper())
mapper[idx].SetInputConnection(iso[idx].GetOutputPort())
mapper[idx].ScalarVisibilityOff()
actor.append(vtk.vtkActor())
actor[idx].SetMapper(mapper[idx])
# actor[idx].Actor.GetProperty().SetDiffuseColor(lindex.colors.c.lindex.colors.c+1.lindex.colors.c+1)
actor[idx].GetProperty().SetDiffuseColor(colorWrapper.GetRGBColor(colors[c]))
actor[idx].GetProperty().SetSpecularPower(30)
actor[idx].GetProperty().SetDiffuse(.7)
actor[idx].GetProperty().SetSpecular(.5)
c += 1
ren.AddActor(actor[idx])
outline = vtk.vtkOutlineFilter()
outline.SetInputConnection(slc.GetOutputPort())
outlineMapper = vtk.vtkPolyDataMapper()
outlineMapper.SetInputConnection(outline.GetOutputPort())
outlineActor = vtk.vtkActor()
outlineActor.SetMapper(outlineMapper)
outlineActor.VisibilityOff()
# Add the actors to the renderer, set the background and size
#
ren.AddActor(outlineActor)
ren.SetBackground(0.9, .9, .9)
ren.ResetCamera()
ren.GetActiveCamera().SetViewAngle(30)
ren.GetActiveCamera().Elevation(20)
ren.GetActiveCamera().Azimuth(20)
ren.GetActiveCamera().Zoom(1.5)
ren.ResetCameraClippingRange()
renWin.SetSize(400, 400)
# render and interact with data
iRen = vtk.vtkRenderWindowInteractor()
iRen.SetRenderWindow(renWin);
renWin.Render()
img_file = "imageMCAll.png"
vtk.test.Testing.compareImage(iRen.GetRenderWindow(), vtk.test.Testing.getAbsImagePath(img_file), threshold=25)
vtk.test.Testing.interact()
def createVisualization(self):
if self.alreadyCall:
return
self.alreadyCall = True
global renderer, renderWindow, renderWindowInteractor, reader, reader_Bones, reader_Blood, reader_Skin, isovalue, BonesMapper, BonesActor, BloodActor, BloodMapper, SkinActor, SkinMapper, volume, volumeMapper, ClippingPlane, ImagePlane, iss, ctf
renderWindow = self.getView('-1')
renderer = renderWindow.GetRenderers().GetFirstRenderer()
# Read the volumetric image
filename_vol = "CT.vtk"
reader = vtk.vtkStructuredPointsReader()
reader.SetFileName(filename_vol)
reader.Update()
# Read the meshes
filename_mesh = "Bones.obj"
reader_Bones = vtk.vtkOBJReader()
reader_Bones.SetFileName(filename_mesh)
reader_Bones.Update()
filename_mesh = "Skin.obj"
reader_Skin = vtk.vtkOBJReader()
reader_Skin.SetFileName(filename_mesh)
reader_Skin.Update()
filename_mesh = "Blood.obj"
reader_Blood = vtk.vtkOBJReader()
reader_Blood.SetFileName(filename_mesh)
reader_Blood.Update()
# Shift and scale input data between 0 and 255
range = 255
a, b = reader.GetOutput().GetScalarRange()
iss = vtk.vtkImageShiftScale()
iss.SetInputData(reader.GetOutput())
iss.SetShift(-a)
iss.SetScale(range / (b - a))
iss.SetOutputScalarTypeToUnsignedChar()
# Volume mapper
volumeMapper = vtk.vtkGPUVolumeRayCastMapper()
volumeMapper.SetInputConnection(iss.GetOutputPort())
volumeMapper.SetBlendModeToIsoSurface()
####################### COLOR FUNCTION #######################
colorTransferFunction = vtk.vtkColorTransferFunction()
#Background
colorTransferFunction.AddRGBPoint(0.0, 0.0, 0.0, 0.0)
#Lungs
colorTransferFunction.AddRGBPoint(30.0, 0.9059, 0.6314, 0.6902)
colorTransferFunction.AddRGBPoint(40.0, 0.9059, 0.6314, 0.6902)
#General Tissue
colorTransferFunction.AddRGBPoint(50, 1.0, 1.0, 0.0)
colorTransferFunction.AddRGBPoint(60, 1.0, 1.0, 0.0)
#Cardiac Tissue 1.0000 0.3882 0.2784
colorTransferFunction.AddRGBPoint(61.0, 1.0, 0.3882, 0.2784)
colorTransferFunction.AddRGBPoint(75.0, 1.0, 0.3882, 0.2784)
#Blood
colorTransferFunction.AddRGBPoint(85, 1.0, 0.0, 0.0)
colorTransferFunction.AddRGBPoint(105, 1.0, 0.0, 0.0)
#Bones
colorTransferFunction.AddRGBPoint(110, 1.0, 1.0, 1.0)
####################### OPACITY FUNCTION #######################
opacityTransferFunction_ct = vtk.vtkPiecewiseFunction()
#Background
opacityTransferFunction_ct.AddPoint(25.0, 0.0)
#Lungs
opacityTransferFunction_ct.AddPoint(30.0, 0.0)
opacityTransferFunction_ct.AddPoint(40.0, 0.0)
opacityTransferFunction_ct.AddPoint(40.1, 0.1)
#General Tissue
opacityTransferFunction_ct.AddPoint(50.0, 0.05)
opacityTransferFunction_ct.AddPoint(64.0, 0.05)
# Cardiac Tissue
opacityTransferFunction_ct.AddPoint(65.0, 1)
opacityTransferFunction_ct.AddPoint(75.0, 1)
# Blood
opacityTransferFunction_ct.AddPoint(85.0, 0.03)
opacityTransferFunction_ct.AddPoint(100.0, 0.03)
#Bones
opacityTransferFunction_ct.AddPoint(110.0, 0.5)
####################### GRADIENT FUNCTION #######################
val_grad = 0
gradient_function_ct = vtk.vtkPiecewiseFunction()
gradient_function_ct.AddPoint(val_grad, 1.0)
####################### VOLUME #######################
#Properties
isovalue = 75.0
volumeProperty = vtk.vtkVolumeProperty()
volumeProperty.GetIsoSurfaceValues().SetValue(0, isovalue)
volumeProperty.SetColor(colorTransferFunction)
volumeProperty.SetScalarOpacity(opacityTransferFunction_ct)
volumeProperty.SetGradientOpacity(gradient_function_ct)
volumeProperty.ShadeOn()
volumeProperty.SetInterpolationTypeToLinear()
#Volume
volume = self.volume
volume.SetMapper(volumeMapper)
volume.SetProperty(volumeProperty)
volume.VisibilityOn()
# Mesh Mappers and actors
BonesMapper = vtk.vtkPolyDataMapper()
BonesActor = vtk.vtkActor()
BonesMapper.SetInputConnection(reader_Bones.GetOutputPort())
BonesActor.SetMapper(BonesMapper)
BonesActor.GetProperty().SetColor(0.93, 0.92, 0.756)
BonesActor.GetProperty().SetOpacity(0.9)
BloodMapper = vtk.vtkPolyDataMapper()
BloodActor = vtk.vtkActor()
BloodMapper.SetInputConnection(reader_Blood.GetOutputPort())
BloodActor.SetMapper(BloodMapper)
BloodActor.GetProperty().SetColor(1.0, 0, 0)
SkinMapper = vtk.vtkPolyDataMapper()
SkinActor = vtk.vtkActor()
SkinMapper.SetInputConnection(reader_Skin.GetOutputPort())
SkinActor.SetMapper(SkinMapper)
SkinActor.GetProperty().SetColor(1.0, 0.8, 0.8)
SkinActor.GetProperty().SetOpacity(0.6)
# Renderer & renderWindow
renderer.AddVolume(volume)
renderer.AddActor(BonesActor)
renderer.AddActor(SkinActor)
renderer.AddActor(BloodActor)
# Clipping ImagePlane
ClippingPlane = vtk.vtkPlane()
ClippingPlane.SetNormal([1.0, 0.0, 0.0])
xmin, xmax, ymin, ymax, zmin, zmax = volume.GetBounds()
ClippingPlane.SetOrigin((xmin + xmax) / 2, (ymin + ymax) / 2,
(zmin + zmax) / 2)
volumeMapper.AddClippingPlane(ClippingPlane)
volume.Update()
# Outline
outlineData = vtk.vtkOutlineFilter()
outlineData.SetInputConnection(reader.GetOutputPort())
mapOutline = vtk.vtkPolyDataMapper()
mapOutline.SetInputConnection(outlineData.GetOutputPort())
outline = vtk.vtkActor()
outline.SetMapper(mapOutline)
outline.GetProperty().SetColor(1.0, 1.0, 0.0)
renderer.AddActor(outline)
# Cutter
BonesMapper.AddClippingPlane(ClippingPlane)
SkinMapper.AddClippingPlane(ClippingPlane)
BloodMapper.AddClippingPlane(ClippingPlane)
####################### CREATE PLANES #######################
# Grayscale Colormap
ctf = vtk.vtkLookupTable()
ctf.SetTableRange(0, 1)
ctf.SetHueRange(1.0, 1.0)
ctf.SetSaturationRange(0.0, 0.0)
ctf.SetValueRange(0, 1)
ctf.Build()
# Window Interactor
renderWindowInteractor = vtk.vtkRenderWindowInteractor()
renderWindowInteractor.SetRenderWindow(renderWindow)
renderWindowInteractor.GetInteractorStyle(
).SetCurrentStyleToTrackballCamera()
renderWindowInteractor.EnableRenderOff()
# ImagePlane
ImagePlane = vtk.vtkImagePlaneWidget()
ImagePlane.SetInputConnection(iss.GetOutputPort())
ImagePlane.SetPlaneOrientationToXAxes()
ImagePlane.SetLookupTable(ctf)
ImagePlane.SetSlicePosition(int((ymax + ymin) / 2))
# ImagePlane.SetPicker(picker)
ImagePlane.DisplayTextOn()
ImagePlane.SetInteractor(renderWindowInteractor)
ImagePlane.EnabledOn()
ImagePlane.SetLeftButtonAction(1)
ImagePlane.SetMiddleButtonAction(0)
def ImagePlaneScript(obj, event):
ClipPlaneOrigin = tuple(
map(sum,
zip(obj.GetOrigin(), tuple(-i for i in obj.GetNormal()))))
ClippingPlane.SetOrigin(ClipPlaneOrigin)
ClippingPlane.SetNormal(obj.GetNormal())
ImagePlane.AddObserver('InteractionEvent', ImagePlaneScript)
ImagePlane.InteractionOn()
# Renderer & render window
renderer.ResetCamera()
renderWindow.Render()
return self.resetCamera()
def Main():
global isovalue, contours, planeSource1, planeSource2, planeSource3, plane1, plane2, plane3, clipper1, clipper2, clipper3, clipX, clipY, clipZ
print "data: %s" % sys.argv[1]
reader = vtk.vtkStructuredPointsReader()
reader.SetFileName(sys.argv[1])
reader.Update()
clipX = 0
clipY = 0
clipZ = 0
r = reader.GetOutput().GetScalarRange()
datamin = r[0]
datamax = r[1]
isovalue = (datamax+datamin)/2.0
for i in range(2, len(sys.argv)):
if sys.argv[i] == "--val":
isovalue = float(sys.argv[i+1])
print "isovalue: %f"%isovalue
if sys.argv[i] == "--clip":
clipX = float(sys.argv[i+1])
clipY = float(sys.argv[i+2])
clipZ = float(sys.argv[i+3])
print "clip (%f,%f,%f)" %(clipX,clipY,clipZ)
contours = vtk.vtkContourFilter()
contours.SetInputConnection(reader.GetOutputPort());
contours.ComputeNormalsOn()
contours.SetValue(0, isovalue)
lut = vtk.vtkColorTransferFunction()
lut.SetColorSpaceToHSV()
lut.AddHSVPoint(datamin,0,1,1)
dis = (datamax-datamin)/7
for i in range(0,8):
lut.AddHSVPoint(datamin+dis*i,0.1*i,1,1)
planeSource1 = vtk.vtkPlaneSource()
planeSource1.SetNormal(1,0,0)
planeSource1.SetOrigin(clipX,0,0)
planeSource2 = vtk.vtkPlaneSource()
planeSource2.SetNormal(0,1,0)
planeSource2.SetOrigin(0,clipY,0)
planeSource3 = vtk.vtkPlaneSource()
planeSource3.SetNormal(0,0,1)
planeSource3.SetOrigin(0,0,clipZ)
plane1 = vtk.vtkPlane()
plane1.SetNormal(planeSource1.GetNormal())
plane1.SetOrigin(planeSource1.GetOrigin())
clipper1 = vtk.vtkClipPolyData()
clipper1.SetClipFunction(plane1)
clipper1.SetInputConnection(contours.GetOutputPort())
clipper1.Update()
plane2 = vtk.vtkPlane()
plane2.SetNormal(planeSource2.GetNormal())
plane2.SetOrigin(planeSource2.GetOrigin())
clipper2 = vtk.vtkClipPolyData()
clipper2.SetClipFunction(plane2)
clipper2.SetInputConnection(clipper1.GetOutputPort())
clipper2.Update()
plane3 = vtk.vtkPlane()
plane3.SetNormal(planeSource3.GetNormal())
plane3.SetOrigin(planeSource3.GetOrigin())
clipper3 = vtk.vtkClipPolyData()
clipper3.SetClipFunction(plane3)
clipper3.SetInputConnection(clipper2.GetOutputPort())
clipper3.Update()
clipperMapper = vtk.vtkPolyDataMapper()
clipperMapper.SetLookupTable(lut)
clipperMapper.SetInputConnection(clipper3.GetOutputPort())
colorBar = vtkScalarBarActor()
colorBar.SetLookupTable(clipperMapper.GetLookupTable())
colorBar.SetTitle("isovalue")
colorBar.SetNumberOfLabels(6)
colorBar.SetLabelFormat("%4.0f")
colorBar.SetPosition(0.9, 0.1)
colorBar.SetWidth(0.1)
colorBar.SetHeight(0.7)
clipperActor=vtk.vtkActor()
clipperActor.GetProperty().SetRepresentationToWireframe()
clipperActor.SetMapper(clipperMapper)
backFaces = vtk.vtkProperty()
backFaces.SetSpecular(0)
backFaces.SetDiffuse(0)
backFaces.SetAmbient(0)
backFaces.SetAmbientColor(1,0,0)
clipperActor.SetBackfaceProperty(backFaces)
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
ren.AddActor(clipperActor)
ren.AddActor(colorBar)
ren.ResetCamera()
ren.SetBackground(0.2,0.3,0.4)
ren.ResetCameraClippingRange()
renWin.SetSize(1200, 600)
isovalueSlider = vtk.vtkSliderRepresentation2D()
isovalueSlider.SetMinimumValue(datamin)
isovalueSlider.SetMaximumValue(datamax)
isovalueSlider.SetValue(isovalue)
isovalueSlider.SetTitleText("isovalue")
isovalueSlider.GetPoint1Coordinate().SetCoordinateSystemToNormalizedDisplay()
isovalueSlider.GetPoint1Coordinate().SetValue(0.0, 0.4)
isovalueSlider.GetPoint2Coordinate().SetCoordinateSystemToNormalizedDisplay()
isovalueSlider.GetPoint2Coordinate().SetValue(0.2, 0.4)
isovalueSlider.SetSliderLength(0.02)
isovalueSlider.SetSliderWidth(0.03)
isovalueSlider.SetEndCapLength(0.01)
isovalueSlider.SetEndCapWidth(0.03)
isovalueSlider.SetTubeWidth(0.005)
isovalueSlider.SetLabelFormat("%3.0lf")
isovalueSlider.SetTitleHeight(0.02)
isovalueSlider.SetLabelHeight(0.02)
SliderWidget1 = vtk.vtkSliderWidget()
SliderWidget1.SetInteractor(iren)
SliderWidget1.SetRepresentation(isovalueSlider)
SliderWidget1.KeyPressActivationOff()
SliderWidget1.SetAnimationModeToAnimate()
SliderWidget1.SetEnabled(True)
SliderWidget1.AddObserver("InteractionEvent", isovalueSliderHandler)
clipXSlider = vtk.vtkSliderRepresentation2D()
clipXSlider.SetMinimumValue(0)
clipXSlider.SetMaximumValue(300)
clipXSlider.SetValue(clipX)
clipXSlider.SetTitleText("X")
clipXSlider.GetPoint1Coordinate().SetCoordinateSystemToNormalizedDisplay()
clipXSlider.GetPoint1Coordinate().SetValue(0.0, 0.3)
clipXSlider.GetPoint2Coordinate().SetCoordinateSystemToNormalizedDisplay()
clipXSlider.GetPoint2Coordinate().SetValue(0.2, 0.3)
clipXSlider.SetSliderLength(0.02)
clipXSlider.SetSliderWidth(0.03)
clipXSlider.SetEndCapLength(0.01)
clipXSlider.SetEndCapWidth(0.03)
clipXSlider.SetTubeWidth(0.005)
clipXSlider.SetLabelFormat("%1.2lf")
clipXSlider.SetTitleHeight(0.02)
clipXSlider.SetLabelHeight(0.02)
SliderWidget2 = vtk.vtkSliderWidget()
SliderWidget2.SetInteractor(iren)
SliderWidget2.SetRepresentation(clipXSlider)
SliderWidget2.KeyPressActivationOff()
SliderWidget2.SetAnimationModeToAnimate()
SliderWidget2.SetEnabled(True)
SliderWidget2.AddObserver("InteractionEvent", clipXSliderHandler)
clipYSlider = vtk.vtkSliderRepresentation2D()
clipYSlider.SetMinimumValue(0)
clipYSlider.SetMaximumValue(300)
clipYSlider.SetValue(clipY)
clipYSlider.SetTitleText("Y")
clipYSlider.GetPoint1Coordinate().SetCoordinateSystemToNormalizedDisplay()
clipYSlider.GetPoint1Coordinate().SetValue(0.0, 0.2)
clipYSlider.GetPoint2Coordinate().SetCoordinateSystemToNormalizedDisplay()
clipYSlider.GetPoint2Coordinate().SetValue(0.2, 0.2)
clipYSlider.SetSliderLength(0.02)
clipYSlider.SetSliderWidth(0.03)
clipYSlider.SetEndCapLength(0.01)
clipYSlider.SetEndCapWidth(0.03)
clipYSlider.SetTubeWidth(0.005)
clipYSlider.SetLabelFormat("%1.2lf")
clipYSlider.SetTitleHeight(0.02)
clipYSlider.SetLabelHeight(0.02)
SliderWidget3 = vtk.vtkSliderWidget()
SliderWidget3.SetInteractor(iren)
SliderWidget3.SetRepresentation(clipYSlider)
SliderWidget3.KeyPressActivationOff()
SliderWidget3.SetAnimationModeToAnimate()
SliderWidget3.SetEnabled(True)
SliderWidget3.AddObserver("InteractionEvent", clipYSliderHandler)
clipZSlider = vtk.vtkSliderRepresentation2D()
clipZSlider.SetMinimumValue(0)
clipZSlider.SetMaximumValue(300)
clipZSlider.SetValue(clipZ)
clipZSlider.SetTitleText("Z")
clipZSlider.GetPoint1Coordinate().SetCoordinateSystemToNormalizedDisplay()
clipZSlider.GetPoint1Coordinate().SetValue(0.0, 0.1)
clipZSlider.GetPoint2Coordinate().SetCoordinateSystemToNormalizedDisplay()
clipZSlider.GetPoint2Coordinate().SetValue(0.2, 0.1)
clipZSlider.SetSliderLength(0.02)
clipZSlider.SetSliderWidth(0.03)
clipZSlider.SetEndCapLength(0.01)
clipZSlider.SetEndCapWidth(0.03)
clipZSlider.SetTubeWidth(0.005)
clipZSlider.SetLabelFormat("%1.2lf")
clipZSlider.SetTitleHeight(0.02)
clipZSlider.SetLabelHeight(0.02)
SliderWidget4 = vtk.vtkSliderWidget()
SliderWidget4.SetInteractor(iren)
SliderWidget4.SetRepresentation(clipZSlider)
SliderWidget4.KeyPressActivationOff()
SliderWidget4.SetAnimationModeToAnimate()
SliderWidget4.SetEnabled(True)
SliderWidget4.AddObserver("InteractionEvent", clipZSliderHandler)
# Render
iren.Initialize()
renWin.Render()
iren.Start()
def main(argv):
if len(argv) < 2:
print "usage: ",argv[0]," <data>"
exit(1)
data_fn = argv[1]
data = None
if data_fn.find('.vtk') != -1:
reader = vtk.vtkStructuredPointsReader()
reader.SetFileName(data_fn)
reader.Update()
data = reader.GetOutput()
elif data_fn.find('.dcm') != -1:
reader =vtk.vtkDICOMImageReader()
reader.SetFileName(data_fn)
reader.Update()
data = reader.GetOutput()
ptdata = data.GetPointData()
scalars = ptdata.GetScalars()
data_range = scalars.GetValueRange()
print "data range:",data_range
contourer = vtk.vtkContourFilter()
if data_fn.find('body') != -1:
contourer.GenerateValues(10,data_range[0],data_range[1])
#contourer.GenerateValues(5,data_range[0],data_range[1])
elif data_fn.find('brain') != -1:
contourer.GenerateValues(10,data_range[0],data_range[1])
elif data_fn.find('artichoke') != -1:
contourer.GenerateValues(50,data_range[0],data_range[1])
elif data_fn.find('watermelon') != -1:
contourer.GenerateValues(20,data_range[0],data_range[1])
#contourer.GenerateValues(5,data_range[0],data_range[1])
else:
contourer.GenerateValues(10,data_range[0],data_range[1])
#contourer.SetNumberOfContours(3)
#contourer.SetValue(0, 100)
#contourer.SetValue(1, 300)
#contourer.SetValue(2, 400)
contourer.SetInput(data)
contourer.Update()
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(contourer.GetOutputPort())
actor = vtk.vtkActor()
actor.SetMapper(mapper)
renderer = vtk.vtkRenderer()
renderWindow = vtk.vtkRenderWindow()
renderWindow.SetSize(700,700)
renderWindow.AddRenderer(renderer)
renderer.AddActor(actor)
renderer.SetBackground(0.4,0.3,0.2)
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetRenderWindow(renderWindow)
renderWindow.Render()
interactor.Start()
def main():
# vtkFlyingEdges3D was introduced in VTK >= 8.2
use_flying_edges = vtk_version_ok(8, 2, 0)
colors = vtk.vtkNamedColors()
colors.SetColor('SkinColor', [240, 184, 160, 255])
colors.SetColor('BackfaceColor', [255, 229, 200, 255])
colors.SetColor('BkgColor', [51, 77, 102, 255])
file_name, threshold, largest_surface = get_program_parameters()
# Load data
reader = vtk.vtkStructuredPointsReader()
reader.SetFileName(file_name)
# Create a 3D model using flying edges or marching cubes
if use_flying_edges:
try:
mc = vtk.vtkFlyingEdges3D()
except AttributeError:
mc = vtk.vtkMarchingCubes()
else:
mc = vtk.vtkMarchingCubes()
mc.SetInputConnection(reader.GetOutputPort())
mc.ComputeNormalsOn()
mc.ComputeGradientsOn()
mc.SetValue(0, threshold) # second value acts as threshold
# To remain largest region
confilter = vtk.vtkPolyDataConnectivityFilter()
confilter.SetInputConnection(mc.GetOutputPort())
confilter.SetExtractionModeToLargestRegion()
# Create a mapper
mapper = vtk.vtkPolyDataMapper()
if largest_surface:
mapper.SetInputConnection(confilter.GetOutputPort())
else:
mapper.SetInputConnection(mc.GetOutputPort())
mapper.ScalarVisibilityOff()
# Visualize
actor = vtk.vtkActor()
actor.GetProperty().SetColor(colors.GetColor3d('SkinColor'))
back_prop = vtk.vtkProperty()
back_prop.SetDiffuseColor(colors.GetColor3d('BackfaceColor'))
actor.SetBackfaceProperty(back_prop)
actor.SetMapper(mapper)
renderer = vtk.vtkRenderer()
renderer.AddActor(actor)
renderer.SetBackground(colors.GetColor3d('SlateGray'))
renderer.GetActiveCamera().SetViewUp(0.0, 0.0, 1.0)
renderer.GetActiveCamera().SetPosition(0.0, 1.0, 0.0)
renderer.GetActiveCamera().SetFocalPoint(0.0, 0.0, 0.0)
renderer.ResetCamera()
renderer.GetActiveCamera().Azimuth(30.0)
renderer.GetActiveCamera().Elevation(30.0)
ren_win = vtk.vtkRenderWindow()
ren_win.AddRenderer(renderer)
ren_win.SetSize(640, 480)
ren_win.SetWindowName('ExtractLargestIsosurface')
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(ren_win)
ren_win.Render()
iren.Initialize()
iren.Start()
def read_files(loc):
"""
:rtype : vector
"""
dircont = sorted(glob.glob(loc + '/test*.vtk'))
if len(dircont) == 0:
print 'po de fichiers'
print 'con'
#quit()
count = 0
for i in dircont:
# reader = vtkRectilinearGridReader()
reader = vtkStructuredPointsReader()
reader.SetFileName(i)
reader.ReadAllScalarsOn()
reader.ReadAllVectorsOn()
reader.Update()
data = reader.GetOutput()
dim = data.GetDimensions()
nx = dim[0] #- 1
ny = dim[1] #- 1
nz = dim[2] #- 1
bounds = data.GetBounds()
xmin = bounds[0]
xmax = bounds[1]
ymin = bounds[2]
ymax = bounds[3]
zmin = bounds[4]
zmax = bounds[5]
domain = np.array([xmin, xmax, ymin, ymax, zmin, zmax])
print 'file:', i
print 'dim:', dim
# arrowglyph = data.GetCellData().GetArray('internalMesh/U')
arrowglyph = data.GetPointData().GetArray('U')
# print data.GetCellData()
vectU = vn.vtk_to_numpy(arrowglyph)
# vectU[vectU < -20] = 'NaN'
# if np.all(vectU) < np.array([1e-8,1e-8,1e-8])):
if (count == 0):
U = np.empty((nx, ny, nz, len(dim), len(dircont)))
s = i = j = k = 0
for k in xrange(nz):
for j in xrange(ny):
for i in xrange(nx):
U[i, j, k, :, count] = vectU[s]
s += 1
count += 1
dt = 0.05
tphys = count * dt
print 'tphys = ', tphys
print 'Files read'
print '<<<<<<<<<>>>>>>>>>>'
return U, nx, ny, nz, dim, tphys, dt, domain
def Main():
global ren
# Create the RenderWindow, Renderer and both Actors
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.SetMultiSamples(0)
renWin.AddRenderer(ren)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
iren.RemoveObservers('RightButtonPressEvent')
iren.AddObserver('RightButtonPressEvent', print_camera_settings, 1.0)
iren.AddObserver('RightButtonPressEvent', after_print_camera_settings,
-1.0)
print "data: %s %s" % (sys.argv[1], sys.argv[2])
cfdreader = vtk.vtkStructuredPointsReader()
cfdreader.SetFileName(sys.argv[1])
# setup wing data
wingReader = vtk.vtkUnstructuredGridReader()
wingReader.SetFileName(sys.argv[2])
wingReader.Update()
wingMapper = vtk.vtkDataSetMapper()
wingMapper.SetInputConnection(wingReader.GetOutputPort())
wingActor = vtk.vtkActor()
wingActor.SetMapper(wingMapper)
wingActor.GetProperty().SetColor(.4, .4, .4)
bRakesToActor = [True, True, True]
bWingToActor = True
datamin = 0
datamax = 230
lut = vtk.vtkColorTransferFunction()
lut.SetColorSpaceToHSV()
lut.AddHSVPoint(datamin, 0, 1, 1)
dis = float(datamax - datamin) / 7
for i in range(0, 8):
lut.AddHSVPoint(float(datamin + dis * i), 0.1 * i, 1, 1)
colorBar = vtk.vtkScalarBarActor()
colorBar.SetLookupTable(lut)
colorBar.SetTitle("")
colorBar.SetNumberOfLabels(6)
colorBar.SetLabelFormat("%4.0f")
colorBar.SetPosition(0.9, 0.1)
colorBar.SetWidth(0.05)
colorBar.SetHeight(0.4)
ren.AddActor(colorBar)
rakes = [vtk.vtkLineSource(), vtk.vtkLineSource(), vtk.vtkLineSource()]
rakes[0].SetPoint1(-230, -230, 0)
rakes[0].SetPoint2(230, 230, 0)
rakes[0].SetResolution(50)
rakes[1].SetPoint1(230, -230, 0)
rakes[1].SetPoint2(-230, 230, 0)
rakes[1].SetResolution(50)
# rakes[2].SetPoint1(0, -200, 10)
# rakes[2].SetPoint2(0, 200, 10)
# rakes[2].SetResolution(50)
for i in range(0, len(rakes)):
rakeMapper = vtk.vtkPolyDataMapper()
rakeMapper.SetInputConnection(rakes[i].GetOutputPort())
rakeActor = vtk.vtkActor()
rakeActor.SetMapper(rakeMapper)
integ = vtk.vtkRungeKutta4()
streamLine = vtk.vtkStreamLine()
streamLine.SetInputConnection(cfdreader.GetOutputPort())
streamLine.SetSourceConnection(rakes[i].GetOutputPort())
streamLine.SetMaximumPropagationTime(50)
streamLine.SetIntegrationStepLength(.1)
streamLine.SetStepLength(0.001)
streamLine.SetIntegrationDirectionToForward()
streamLine.SetIntegrator(integ)
streamLine.SpeedScalarsOn()
scalarSurface = vtk.vtkRuledSurfaceFilter()
scalarSurface.SetInputConnection(streamLine.GetOutputPort())
scalarSurface.SetOffset(0)
scalarSurface.SetOnRatio(0)
# scalarSurface.PassLinesOn()
scalarSurface.SetRuledModeToPointWalk()
# scalarSurface.SetDistanceFactor(40)
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(scalarSurface.GetOutputPort())
mapper.SetLookupTable(lut)
mapper.SetScalarRange(cfdreader.GetOutput().GetScalarRange())
actor = vtk.vtkActor()
actor.SetMapper(mapper)
actor.GetProperty().SetColor(0, 1, 0)
actor.GetProperty().SetOpacity(0.5)
if bRakesToActor[i]:
ren.AddActor(actor)
if bWingToActor:
ren.AddActor(wingActor)
ren.SetBackground(0, 0, 0)
renWin.SetSize(1600, 900)
ren.ResetCamera()
ren.GetActiveCamera().SetClippingRange(417.55784439078775,
1491.5763714138557)
ren.GetActiveCamera().SetFocalPoint(118.72183980792761,
0.00012969970703125,
36.469017028808594)
ren.GetActiveCamera().SetPosition(680.0192576650034, 16.65944318371372,
790.5781258299678)
ren.GetActiveCamera().SetViewUp(-0.802117714199773, -0.005112780752923929,
0.5971440630533839)
# Render
iren.Initialize()
renWin.Render()
iren.Start()
def __init__(self,dti):
self.print_counter=11
ren = vtk.vtkRenderer()
self.dti_reader = vtk.vtkStructuredPointsReader()
self.dti_reader.SetFileName(dti)
self.geo_Mapper=vtk.vtkPolyDataMapper()
self.geo_Mapper.SetInputConnection(self.dti_reader.GetOutputPort())
#glyph actor
#geo_actor = vtk.vtkActor()
#geo_actor.SetMapper(geo_Mapper)
#ren.AddActor(geo_actor)
self.arrowColor = vtk.vtkColorTransferFunction()
self.update_look_up_table()
self.plane1=None
for i in range(0,3):
if i==0:
x=126.0
y=0.0
z=0.0
if i==1:
x=126.0
y=126.0
z=0.0
if i==2:
x=0.0
y=0.0
z=69.0
plane_mapper=self.create_cut_acto_plane(x,y,z,i)
ren.AddActor(self.create_glyph(plane_mapper))
#this is done
#Add renderer to renderwindow and render
self.renWin = vtk.vtkRenderWindow()
self.renWin.AddRenderer(ren)
self.renWin.SetSize(1920, 1080)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(self.renWin)
iren.AddObserver('RightButtonPressEvent', self.capture_image, 1.0)
"""
#Slider 1
sliderRep1=vtk.vtkSliderWidget()
sliderRep1.SetInteractor(iren)
sliderRep1.SetRepresentation(self.create_color_slider("X-Position",0.02,0.15,0,220,65))
sliderRep1.SetEnabled(True)
sliderRep1.AddObserver("InteractionEvent", self.change_iso)
"""
# Scalar Bar actor
scalar_bar = vtk.vtkScalarBarActor()
scalar_bar.SetOrientationToHorizontal()
scalar_bar.SetLookupTable(self.arrowColor)
scalar_bar.SetTitle("Color map")
scalar_bar.SetLabelFormat("%5.2f")
scalar_bar.SetMaximumHeightInPixels(300)
scalar_bar.SetMaximumWidthInPixels(100)
# Scalar Bar Widget
scalar_bar_widget = vtk.vtkScalarBarWidget()
scalar_bar_widget.SetInteractor(iren)
scalar_bar_widget.SetScalarBarActor(scalar_bar)
scalar_bar_widget.On()
ren.SetBackground(0,0,0)
self.renWin.Render()
iren.Start()
def testimageMCAll(self):
# Create the RenderWindow, Renderer and both Actors
#
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
# create pipeline
#
slc = vtk.vtkStructuredPointsReader()
slc.SetFileName(VTK_DATA_ROOT + "/Data/ironProt.vtk")
colors = [
"flesh", "banana", "grey", "pink", "carrot", "gainsboro", "tomato",
"gold", "thistle", "chocolate"
]
types = [
"UnsignedChar", "Char", "Short", "UnsignedShort", "Int",
"UnsignedInt", "Long", "UnsignedLong", "Float", "Double"
]
i = 1
c = 0
clip = list()
cast = list()
iso = list()
mapper = list()
actor = list()
colorWrapper = self.Colors()
for idx, vtkType in enumerate(types):
clip.append(vtk.vtkImageClip())
clip[idx].SetInputConnection(slc.GetOutputPort())
clip[idx].SetOutputWholeExtent(-1000, 1000, -1000, 1000, i, i + 5)
i += 5
cast.append(vtk.vtkImageCast())
eval('cast[idx].SetOutputScalarTypeTo' + vtkType + '()')
cast[idx].SetInputConnection(clip[idx].GetOutputPort())
cast[idx].ClampOverflowOn()
iso.append(vtk.vtkMarchingContourFilter())
iso[idx].SetInputConnection(cast[idx].GetOutputPort())
iso[idx].GenerateValues(1, 30, 30)
mapper.append(vtk.vtkPolyDataMapper())
mapper[idx].SetInputConnection(iso[idx].GetOutputPort())
mapper[idx].ScalarVisibilityOff()
actor.append(vtk.vtkActor())
actor[idx].SetMapper(mapper[idx])
# actor[idx].Actor.GetProperty().SetDiffuseColor(lindex.colors.c.lindex.colors.c+1.lindex.colors.c+1)
actor[idx].GetProperty().SetDiffuseColor(
colorWrapper.GetRGBColor(colors[c]))
actor[idx].GetProperty().SetSpecularPower(30)
actor[idx].GetProperty().SetDiffuse(.7)
actor[idx].GetProperty().SetSpecular(.5)
c += 1
ren.AddActor(actor[idx])
outline = vtk.vtkOutlineFilter()
outline.SetInputConnection(slc.GetOutputPort())
outlineMapper = vtk.vtkPolyDataMapper()
outlineMapper.SetInputConnection(outline.GetOutputPort())
outlineActor = vtk.vtkActor()
outlineActor.SetMapper(outlineMapper)
outlineActor.VisibilityOff()
# Add the actors to the renderer, set the background and size
#
ren.AddActor(outlineActor)
ren.SetBackground(0.9, .9, .9)
ren.ResetCamera()
ren.GetActiveCamera().SetViewAngle(30)
ren.GetActiveCamera().Elevation(20)
ren.GetActiveCamera().Azimuth(20)
ren.GetActiveCamera().Zoom(1.5)
ren.ResetCameraClippingRange()
renWin.SetSize(400, 400)
# render and interact with data
iRen = vtk.vtkRenderWindowInteractor()
iRen.SetRenderWindow(renWin)
renWin.Render()
img_file = "imageMCAll.png"
vtk.test.Testing.compareImage(
iRen.GetRenderWindow(),
vtk.test.Testing.getAbsImagePath(img_file),
threshold=25)
vtk.test.Testing.interact()
def _read(self):
reader = vtkStructuredPointsReader()
reader.SetFileName(self.filename)
reader.Update()
self._image = reader.GetOutput()
def main():
dataFn1, dataFn2, textureFn = get_program_parameters()
colors = vtk.vtkNamedColors()
# Read the data.
pl3d = vtk.vtkMultiBlockPLOT3DReader()
pl3d.SetXYZFileName(dataFn1)
pl3d.SetQFileName(dataFn2)
pl3d.SetScalarFunctionNumber(100)
pl3d.SetVectorFunctionNumber(202)
pl3d.Update()
output = pl3d.GetOutput().GetBlock(0)
# Make the wall (floor).
wall = vtk.vtkStructuredGridGeometryFilter()
wall.SetInputData(output)
wall.SetExtent(0, 100, 0, 0, 0, 100)
wallMap = vtk.vtkPolyDataMapper()
wallMap.SetInputConnection(wall.GetOutputPort())
wallMap.ScalarVisibilityOff()
wallActor = vtk.vtkActor()
wallActor.SetMapper(wallMap)
wallActor.GetProperty().SetColor(colors.GetColor3d("PeachPuff"))
# Make the fin (rear wall)
fin = vtk.vtkStructuredGridGeometryFilter()
fin.SetInputData(output)
fin.SetExtent(0, 100, 0, 100, 0, 0)
finMap = vtk.vtkPolyDataMapper()
finMap.SetInputConnection(fin.GetOutputPort())
finMap.ScalarVisibilityOff()
finActor = vtk.vtkActor()
finActor.SetMapper(finMap)
finActor.GetProperty().SetColor(colors.GetColor3d("DarkSlateGray"))
# Get the texture.
tmap = vtk.vtkStructuredPointsReader()
tmap.SetFileName(textureFn)
texture = vtk.vtkTexture()
texture.SetInputConnection(tmap.GetOutputPort())
texture.InterpolateOff()
texture.RepeatOff()
# Create the rendering window, renderer, and interactive renderer.
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
# Make the planes to threshold and texture.
plane = list()
thresh = list()
planeMap = list()
planeActor = list()
# Define the extents of planes that we will use.
planeExtents = [[10, 10, 0, 100, 0, 100], [30, 30, 0, 100, 0, 100],
[35, 35, 0, 100, 0, 100]]
# Now set up the pipeline.
for i in range(0, len(planeExtents)):
plane.append(vtk.vtkStructuredGridGeometryFilter())
plane[i].SetInputData(output)
plane[i].SetExtent(*planeExtents[i])
thresh.append(vtk.vtkThresholdTextureCoords())
thresh[i].SetInputConnection(plane[i].GetOutputPort())
thresh[i].SetInputConnection(plane[i].GetOutputPort())
# If you want an image similar to Fig 9-43(a) in the VTK textbook,
# set thresh[i].ThresholdByUpper(1.5) for all planes.
if i == 1:
thresh[i].ThresholdByLower(1.5)
elif i == 2:
thresh[i].ThresholdBetween(1.5, 1.8)
else:
thresh[i].ThresholdByUpper(1.5)
planeMap.append(vtk.vtkDataSetMapper())
planeMap[i].SetInputConnection(thresh[i].GetOutputPort())
planeMap[i].SetScalarRange(output.GetScalarRange())
planeActor.append(vtk.vtkActor())
planeActor[i].SetMapper(planeMap[i])
planeActor[i].SetTexture(texture)
# The slight transparency gives a nice effect.
planeActor[i].GetProperty().SetOpacity(0.999)
ren.AddActor(planeActor[i])
# Get an outline of the data set for context.
outline = vtk.vtkStructuredGridOutlineFilter()
outline.SetInputData(output)
outlineMapper = vtk.vtkPolyDataMapper()
outlineMapper.SetInputConnection(outline.GetOutputPort())
outlineActor = vtk.vtkActor()
outlineActor.SetMapper(outlineMapper)
outlineProp = outlineActor.GetProperty()
outlineProp.SetColor(colors.GetColor3d("Black"))
# Add the remaining actors to the renderer, set the background and size.
ren.AddActor(outlineActor)
ren.AddActor(wallActor)
ren.AddActor(finActor)
ren.SetBackground(colors.GetColor3d("MistyRose"))
renWin.SetSize(512, 512)
cam = vtk.vtkCamera()
cam.SetClippingRange(1.51176, 75.5879)
cam.SetFocalPoint(2.33749, 2.96739, 3.61023)
cam.SetPosition(10.8787, 5.27346, 15.8687)
cam.SetViewAngle(30)
cam.SetViewUp(-0.0610856, 0.987798, -0.143262)
ren.SetActiveCamera(cam)
iren.Initialize()
iren.Start()
def Main():
global ren
print "data: %s" % sys.argv[1]
reader = vtk.vtkStructuredPointsReader()
reader.SetFileName(sys.argv[1])
isosurfaces = [
[3413, 0.1, 0.2, 1, 0.4],
[18090, 0.1, 0.6, 1, 0.6],
[41983, 0.1, 0.9, 1, 0.9],
]
ren = vtk.vtkRenderer()
for surface in isosurfaces:
lut = vtk.vtkColorTransferFunction()
lut.SetColorSpaceToHSV()
lut.AddHSVPoint(surface[0], surface[1], surface[2], surface[3])
contours = vtk.vtkContourFilter()
contours.SetInputConnection(reader.GetOutputPort())
contours.ComputeNormalsOn()
contours.SetValue(0, surface[0])
mapper = vtk.vtkDataSetMapper()
mapper.SetInputConnection(contours.GetOutputPort())
mapper.SetLookupTable(lut)
mapper.ImmediateModeRenderingOff()
actor = vtk.vtkActor()
actor.SetMapper(mapper)
actor.GetProperty().SetOpacity(surface[4])
ren.AddActor(actor)
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
iren.RemoveObservers('RightButtonPressEvent')
iren.AddObserver('RightButtonPressEvent', print_camera_settings, 1.0)
iren.AddObserver('RightButtonPressEvent', after_print_camera_settings,
-1.0)
# for depth peeling
ren.SetUseDepthPeeling(1)
ren.SetMaximumNumberOfPeels(4) # default 4
ren.SetOcclusionRatio(0) # default 0
ren.ResetCamera()
ren.SetBackground(0, 0, 0)
ren.GetActiveCamera().SetViewUp(0.2320640509325283, 0.6216278154231228,
0.748147803149258)
ren.GetActiveCamera().SetPosition(-86.30842917477719, -55.80182530081589,
297.63908735650085)
ren.GetActiveCamera().SetFocalPoint(199.18608617782593, 149.5, 38.5)
ren.GetActiveCamera().SetClippingRange(4.197001562269691,
982.4499004768599)
# for depth peeling
renWin.SetAlphaBitPlanes(1)
renWin.SetMultiSamples(0)
renWin.SetSize(1600, 900)
# Render
iren.Initialize()
renWin.Render()
iren.Start()
def read_file(filename):
reader = vtk.vtkStructuredPointsReader()
reader.SetFileName(filename)
reader.Update()
return reader
lut.RemovePoint(colorVar1)
colorVar1 = pos
lut.AddRGBPoint(colorVar1, 0, 0.25, 0.5)
def vtkSliderCallback2(obj, event):
sliderRepres2 = obj.GetRepresentation()
pos = sliderRepres2.GetValue()
global colorVar2
lut.RemovePoint(colorVar2)
colorVar2 = pos
lut.AddRGBPoint(colorVar2, 1, 1, 0.5)
# Load bathymetry dataset
bathymetryReader = vtk.vtkStructuredPointsReader()
bathymetryReader.SetFileName(sys.argv[1])
colorVar1 = -4500
colorVar2 = 2000
# Setup color mapping
lut = vtk.vtkColorTransferFunction()
lut.SetColorSpaceToRGB()
lut.AddRGBPoint(-9000, 0, 0, 0)
lut.AddRGBPoint(colorVar1, 0, 0.25, 0.5)
lut.AddRGBPoint(-1, 0, 1, 1)
lut.AddRGBPoint(0, 0.25, 0.75, 0)
lut.AddRGBPoint(colorVar2, 1, 1, 0.5)
lut.AddRGBPoint(4000, 1, 1, 1)
def testContour3DAll(self):
# On older Macs, 10 is too low. Due to what looks like a driver bug
# spectral lighting behaves sort of weird and produces small differences
threshold = 30
# Create the RenderWindow, Renderer and both Actors
#
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
# create pipeline
#
slc = vtk.vtkStructuredPointsReader()
slc.SetFileName(VTK_DATA_ROOT + "/Data/ironProt.vtk")
actorColors = ["flesh", "banana", "grey", "pink", "carrot", "gainsboro", "tomato", "gold", "thistle", "chocolate"]
types = ["UnsignedChar", "Char", "Short", "UnsignedShort", "Int", "UnsignedInt", "Long", "UnsignedLong", "Float", "Double"]
i = 1
c = 0
clip = list()
cast = list()
iso = list()
mapper = list()
actor = list()
colors = self.Colors()
for idx, vtkType in enumerate(types):
clip.append(vtk.vtkImageClip())
clip[idx].SetInputConnection(slc.GetOutputPort())
clip[idx].SetOutputWholeExtent(-1000, 1000, -1000, 1000, i, i + 5)
i += 5
cast.append(vtk.vtkImageCast())
eval("cast[idx].SetOutputScalarTypeTo" + vtkType)
cast[idx].SetInputConnection(clip[idx].GetOutputPort())
cast[idx].ClampOverflowOn()
iso.append(vtk.vtkContourFilter())
iso[idx].SetInputConnection(cast[idx].GetOutputPort())
iso[idx].GenerateValues(1, 30, 30)
iso[idx].ComputeScalarsOff()
iso[idx].ComputeGradientsOff()
mapper.append(vtk.vtkPolyDataMapper())
mapper[idx].SetInputConnection(iso[idx].GetOutputPort())
mapper[idx].ImmediateModeRenderingOn()
actor.append(vtk.vtkActor())
actor[idx].SetMapper(mapper[idx])
eval('actor[idx].GetProperty().SetDiffuseColor(colors.GetRGBColor("' + actorColors[idx] + '"))')
actor[idx].GetProperty().SetSpecularPower(30)
actor[idx].GetProperty().SetDiffuse(.7)
actor[idx].GetProperty().SetSpecular(.5)
c += 3
ren.AddActor(actor[idx])
outline = vtk.vtkOutlineFilter()
outline.SetInputConnection(slc.GetOutputPort())
outlineMapper = vtk.vtkPolyDataMapper()
outlineMapper.SetInputConnection(outline.GetOutputPort())
outlineActor = vtk.vtkActor()
outlineActor.SetMapper(outlineMapper)
outlineActor.VisibilityOff()
# Add the actors to the renderer, set the background and size
#
ren.AddActor(outlineActor)
ren.SetBackground(0.9, .9, .9)
ren.ResetCamera()
ren.GetActiveCamera().SetViewAngle(30)
ren.GetActiveCamera().Elevation(20)
ren.GetActiveCamera().Azimuth(20)
ren.GetActiveCamera().Zoom(1.5)
ren.ResetCameraClippingRange()
renWin.SetSize(400, 400)
# render and interact with data
iRen = vtk.vtkRenderWindowInteractor()
iRen.SetRenderWindow(renWin);
renWin.Render()
img_file = "contour3DAll.png"
vtk.test.Testing.compareImage(iRen.GetRenderWindow(), vtk.test.Testing.getAbsImagePath(img_file), threshold=25)
vtk.test.Testing.interact()
def streampoints(filename):
reader = vtk.vtkStructuredPointsReader()
reader.SetFileName(filename)
reader.Update()
outline=vtk.vtkOutlineFilter()
outline.SetInputConnection(reader.GetOutputPort())
lineMapper = vtk.vtkDataSetMapper()
lineMapper.SetInputConnection(outline.GetOutputPort())
lineActor = vtk.vtkActor()
lineActor.SetMapper(lineMapper)
pdata=vtk.vtkPolyData()
points=vtk.vtkPoints()
#Selecting source for Streamtracer
ns=200
r=100
Z=25
for i in range(0, ns):
a=(2*i*pi)/ns
X=r*cos(a)
Y=r*sin(a)
# for Z in range(0,256):
points.InsertNextPoint(float(X),float(Y),float(Z))
pdata.SetPoints(points)
integ0 = vtk.vtkRungeKutta4()
integ1 = vtk.vtkRungeKutta4()
integ2 = vtk.vtkRungeKutta4()
# Defining controller for vtkDistributedStreamTracer
controller=vtk.vtkMPIController()
Stream0 = vtk.vtkDistributedStreamTracer()
#Stream0 = vtk.vtkStreamTracer()
Stream0.SetInputConnection(reader.GetOutputPort())
Stream0.SetSource(line0.GetOutput())
#Stream0.SetSource(pdata)
# Setting the parameters for Integration. Here you can change the integration parameters according to your desire.
Stream0.SetMaximumPropagation(255)
Stream0.SetController(controller)
Stream0.SetInitialIntegrationStepUnitToCellLengthUnit()
Stream0.SetMaximumIntegrationStep(2000)
Stream0.SetInitialIntegrationStep(0.5)
Stream0.SetIntegrator(integ0)
Stream0.SetIntegrationDirectionToBoth()
Stream0.Update()
# Visualizing streamline as a tube.Here you can change the radius of the streamtube by changing the values of radius.
streamTube0 = vtk.vtkTubeFilter()
streamTube0.SetInputConnection(Stream0.GetOutputPort())
streamTube0.SetRadius(0.25)
streamTube0.SetNumberOfSides(16)
#streamTube0.SetVaryRadiusToVaryRadiusByVector()
mapStreamTube0 = vtk.vtkPolyDataMapper()
mapStreamTube0.SetInputConnection(streamTube0.GetOutputPort())
#mapStreamTube.SetScalarRange(reader.GetOutput())
streamTubeActor0 = vtk.vtkActor()
streamTubeActor0.SetMapper(mapStreamTube0)
streamTubeActor0.GetProperty().BackfaceCullingOn()
streamTubeActor0.GetProperty().SetColor(0, 1, 1)
Stream1 = vtk.vtkDistributedStreamTracer()
#Stream0 = vtk.vtkStreamTracer()
Stream1.SetInputConnection(reader.GetOutputPort())
Stream1.SetSource(line1.GetOutput())
#Stream0.SetSource(pdata)
Stream1.SetMaximumPropagation(255)
Stream1.SetController(controller)
Stream1.SetInitialIntegrationStepUnitToCellLengthUnit()
Stream1.SetMaximumIntegrationStep(2000)
Stream1.SetInitialIntegrationStep(0.5)
Stream1.SetIntegrator(integ1)
Stream1.SetIntegrationDirectionToBoth()
Stream1.Update()
streamTube1= vtk.vtkTubeFilter()
streamTube1.SetInputConnection(Stream0.GetOutputPort())
streamTube1.SetRadius(0.25)
streamTube1.SetNumberOfSides(12)
#streamTube1.SetVaryRadiusToVaryRadiusByVector()
mapStreamTube1 = vtk.vtkPolyDataMapper()
mapStreamTube1.SetInputConnection(streamTube1.GetOutputPort())
#mapStreamTube.SetScalarRange(reader.GetOutput())
streamTubeActor1 = vtk.vtkActor()
streamTubeActor1.SetMapper(mapStreamTube1)
streamTubeActor1.GetProperty().BackfaceCullingOn()
streamTubeActor1.GetProperty().SetColor(0.5, 0.25, 1)
#ren.AddActor(lineActor)
Stream2 = vtk.vtkDistributedStreamTracer()
#Stream0 = vtk.vtkStreamTracer()
Stream2.SetInputConnection(reader.GetOutputPort())
Stream2.SetSource(line2.GetOutput())
#Stream2.SetSource(line1.GetOutput())
#Stream2.SetSource(line0.GetOutput())
#Stream0.SetSource(pdata)
Stream2.SetMaximumPropagation(255)
Stream2.SetController(controller)
Stream2.SetInitialIntegrationStepUnitToCellLengthUnit()
Stream2.SetMaximumIntegrationStep(2000)
Stream2.SetInitialIntegrationStep(0.5)
Stream2.SetIntegrator(integ2)
Stream2.SetIntegrationDirectionToBoth()
Stream2.Update()
streamTube2= vtk.vtkTubeFilter()
streamTube2.SetInputConnection(Stream0.GetOutputPort())
streamTube2.SetRadius(0.25)
streamTube2.SetNumberOfSides(12)
#streamTube2.SetVaryRadiusToVaryRadiusByVector()
mapStreamTube2 = vtk.vtkPolyDataMapper()
mapStreamTube2.SetInputConnection(streamTube2.GetOutputPort())
#mapStreamTube.SetScalarRange(reader.GetOutput())
streamTubeActor2 = vtk.vtkActor()
streamTubeActor2.SetMapper(mapStreamTube2)
streamTubeActor2.GetProperty().BackfaceCullingOn()
streamTubeActor2.GetProperty().SetColor(0, .025, 0.125)
# ren.AddActor(lineActor)
# Adding the streanline to the actor for rendering
ren.AddActor(streamTubeActor0)
ren.AddActor(streamTubeActor1)
#ren.AddActor(streamTubeActor2)
renWin.Render()
ren.ResetCamera()
# Selecting renderer good position and focal point. Here You can change the camera positin for viewing a good image that you need.
ren.GetActiveCamera().SetPosition(0, 1,0)
ren.GetActiveCamera().SetFocalPoint(0,0,0)
ren.GetActiveCamera().SetViewUp(0,0 , 1)
ren.GetActiveCamera().Dolly(1.4)
ren.ResetCameraClippingRange()
largestreamline=vtk.vtkRenderLargeImage()
largestreamline.SetInput(ren)
largestreamline.SetMagnification(9)
#cam1 = ren.GetActiveCamera().Zoom(z)
#cam1 = ren.GetActiveCamera().Elevation(2)
#cam1 = ren.GetActiveCamera().Azimuth(-5)
#ren.SetActiveCamera(cam1)
ren.ResetCamera()
# Writing .PNG Images of the streamlines with images.
writer = vtk.vtkPNGWriter()
writer.SetInputConnection(largestreamline.GetOutputPort())
writer.SetFileName("Streamline.png")
writer.Modified()
writer.Write()
def main():
colors = vtk.vtkNamedColors()
fileName = get_program_parameters()
# hidden sphere
sphere1 = vtk.vtkSphereSource()
sphere1.SetRadius(0.5)
innerMapper = vtk.vtkPolyDataMapper()
innerMapper.SetInputConnection(sphere1.GetOutputPort())
innerSphere = vtk.vtkActor()
innerSphere.SetMapper(innerMapper)
innerSphere.GetProperty().SetColor(colors.GetColor3d('BlanchedAlmond'))
# sphere to texture
sphere2 = vtk.vtkSphereSource()
sphere2.SetRadius(1.0)
sphere2.SetPhiResolution(21)
sphere2.SetThetaResolution(21)
pts = [0.0] * 6
points = vtk.vtkPoints()
points.SetNumberOfPoints(2)
points.SetPoint(0, pts[:3])
points.SetPoint(1, pts[3:])
nrms = [0.0] * 6
nrms[0] = 1.0
nrms[4] = 1.0
normals = vtk.vtkDoubleArray()
normals.SetNumberOfComponents(3)
normals.SetNumberOfTuples(2)
normals.SetTuple(0, nrms[:3])
normals.SetTuple(1, nrms[3:])
planes = vtk.vtkPlanes()
planes.SetPoints(points)
planes.SetNormals(normals)
tcoords = vtk.vtkImplicitTextureCoords()
tcoords.SetInputConnection(sphere2.GetOutputPort())
tcoords.SetRFunction(planes)
outerMapper = vtk.vtkDataSetMapper()
outerMapper.SetInputConnection(tcoords.GetOutputPort())
tmap = vtk.vtkStructuredPointsReader()
tmap.SetFileName(fileName)
texture = vtk.vtkTexture()
texture.SetInputConnection(tmap.GetOutputPort())
texture.InterpolateOff()
texture.RepeatOff()
outerSphere = vtk.vtkActor()
outerSphere.SetMapper(outerMapper)
outerSphere.SetTexture(texture)
outerSphere.GetProperty().SetColor(colors.GetColor3d('LightSalmon'))
renWin = vtk.vtkRenderWindow()
iren = vtk.vtkRenderWindowInteractor()
aren = vtk.vtkRenderer()
iren.SetRenderWindow(renWin)
renWin.AddRenderer(aren)
aren.AddActor(innerSphere)
aren.AddActor(outerSphere)
aren.SetBackground(colors.GetColor3d('SlateGray'))
aren.GetActiveCamera().Azimuth(-30)
aren.GetActiveCamera().Elevation(-30)
aren.ResetCamera()
renWin.SetSize(500, 500)
renWin.SetWindowName('TextureCutSphere')
# interact with data
renWin.Render()
iren.Initialize()
iren.Start()
def __init__(self,dti):
self.print_counter=0
ren = vtk.vtkRenderer()
self.dti_reader = vtk.vtkStructuredPointsReader()
self.dti_reader.SetFileName(dti)
"""
self.geo_Mapper=vtk.vtkPolyDataMapper()
self.geo_Mapper.SetInputConnection(self.dti_reader.GetOutputPort())
"""
tensor_extractor = vtk.vtkExtractTensorComponents()
tensor_extractor.SetInputConnection(self.dti_reader.GetOutputPort())
tensor_extractor.ExtractScalarsOn()
tensor_extractor.Update()
self.dti_reader.GetOutput().GetPointData().SetScalars(tensor_extractor.GetOutput().GetPointData().GetScalars())
self.dti_reader.Update()
self.arrowColor = vtk.vtkColorTransferFunction()
self.update_look_up_table()
#------------NEW CODE BEGINS HERE----------
[xposc, yposc, zposc] = self.dti_reader.GetOutput().GetCenter()
for k in range(20, 30,2):
for i in range(10, 20):
ren.AddActor(self.create_hyper_stream_line(xposc+i, yposc+k, zposc))
#------------NEW CODE ENDS HERE------------
#Add renderer to renderwindow and render
self.renWin = vtk.vtkRenderWindow()
self.renWin.AddRenderer(ren)
self.renWin.SetSize(1920, 1080)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(self.renWin)
iren.AddObserver('RightButtonPressEvent', self.capture_image, 1.0)
# Scalar Bar actor
scalar_bar = vtk.vtkScalarBarActor()
scalar_bar.SetOrientationToHorizontal()
scalar_bar.SetLookupTable(self.arrowColor)
scalar_bar.SetTitle("Color map")
scalar_bar.SetLabelFormat("%5.5f")
scalar_bar.SetMaximumHeightInPixels(300)
scalar_bar.SetMaximumWidthInPixels(100)
# Scalar Bar Widget
scalar_bar_widget = vtk.vtkScalarBarWidget()
scalar_bar_widget.SetInteractor(iren)
scalar_bar_widget.SetScalarBarActor(scalar_bar)
scalar_bar_widget.On()
ren.SetBackground(0,0,0)
self.renWin.Render()
iren.Start()
def loadStructuredPoints(filename):
"""Load a ``vtkStructuredPoints`` object from file."""
reader = vtk.vtkStructuredPointsReader()
reader.SetFileName(filename)
reader.Update()
return reader.GetOutput()
def main():
colors = vtk.vtkNamedColors()
textureFile, motorFile = get_program_parameters()
# Create the Renderer, RenderWindow and RenderWindowInteractor.
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
# Create the cutting planes.
planes = vtk.vtkPlanes()
points = vtk.vtkPoints()
norms = vtk.vtkFloatArray()
norms.SetNumberOfComponents(3)
points.InsertPoint(0, 0.0, 0.0, 0.0)
norms.InsertTuple3(0, 0.0, 0.0, 1.0)
points.InsertPoint(1, 0.0, 0.0, 0.0)
norms.InsertTuple3(1, -1.0, 0.0, 0.0)
planes.SetPoints(points)
planes.SetNormals(norms)
# Get the texture.
texReader = vtk.vtkStructuredPointsReader()
texReader.SetFileName(textureFile)
texture = vtk.vtkTexture()
texture.SetInputConnection(texReader.GetOutputPort())
texture.InterpolateOff()
texture.RepeatOff()
# Set up the pipelines for the parts of the motor.
# We will use lists of pipeline objects.
numberOfParts = 5
byu = list()
normals = list()
tex = list()
byuMapper = list()
byuActor = list()
partColours = [
'cold_grey', 'peacock', 'raw_sienna', 'banana', 'peach_puff'
]
# Use this to control which parts to display.
displayParts = [True] * numberOfParts
# If displayParts[2] = False then an image like that in the VTK tests is produced.
# Build the pipelines.
for i in range(0, numberOfParts):
byu.append(vtk.vtkBYUReader())
byu[i].SetGeometryFileName(motorFile)
byu[i].SetPartNumber(i + 1)
normals.append(vtk.vtkPolyDataNormals())
normals[i].SetInputConnection(byu[i].GetOutputPort())
tex.append(vtk.vtkImplicitTextureCoords())
tex[i].SetInputConnection(normals[i].GetOutputPort())
tex[i].SetRFunction(planes)
# tex[i].FlipTextureOn()
byuMapper.append(vtk.vtkDataSetMapper())
byuMapper[i].SetInputConnection(tex[i].GetOutputPort())
byuActor.append(vtk.vtkActor())
byuActor[i].SetMapper(byuMapper[i])
byuActor[i].SetTexture(texture)
byuActor[i].GetProperty().SetColor(colors.GetColor3d(partColours[i]))
ren.AddActor(byuActor[i])
if displayParts[i]:
byuActor[i].VisibilityOn()
else:
byuActor[i].VisibilityOff()
ren.SetBackground(colors.GetColor3d('AliceBlue'))
renWin.SetSize(512, 512)
renWin.SetWindowName('Motor')
camera = vtk.vtkCamera()
camera.SetFocalPoint(0.0286334, 0.0362996, 0.0379685)
camera.SetPosition(1.37067, 1.08629, -1.30349)
camera.SetViewAngle(17.673)
camera.SetClippingRange(1, 10)
camera.SetViewUp(-0.376306, -0.5085, -0.774482)
ren.SetActiveCamera(camera)
# Render the image.
iren.Initialize()
iren.Start()
def Main():
global vmin, vmax, w_value, datamin, datamax, lut, SliderRepres1, SliderRepres2, SliderRepres3
# Load bathymetry dataset
bathymetryReader = vtk.vtkStructuredPointsReader()
bathymetryReader.SetFileName(sys.argv[1])
bathymetryReader.Update()
r = bathymetryReader.GetOutput().GetPointData().GetScalars().GetRange()
datamin = r[0]
datamax = r[1]
vmin = datamin + (datamax-datamin)*0.4
vmax = datamin + (datamax-datamin)*0.6
w_value = (datamax-datamin)/20
# Setup color mapping
lut = vtk.vtkColorTransferFunction()
lut.SetColorSpaceToHSV()
# Load bathymetry data into Geometry Filter
geometry = vtk.vtkImageDataGeometryFilter()
geometry.SetInputConnection(bathymetryReader.GetOutputPort())
mapper = vtk.vtkDataSetMapper()
mapper.SetInputConnection(geometry.GetOutputPort())
mapper.SetLookupTable(lut)
mapper.ImmediateModeRenderingOff()
# Setup color mapping bar
colorBar = vtkScalarBarActor()
colorBar.SetLookupTable(mapper.GetLookupTable())
colorBar.SetTitle("color map")
colorBar.SetNumberOfLabels(6)
colorBar.SetLabelFormat("%4.0f")
colorBar.SetPosition(0.9, 0.1)
colorBar.SetWidth(0.1)
colorBar.SetHeight(0.7)
actor = vtk.vtkActor()
actor.SetMapper(mapper)
# Create renderer stuff
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
iren = vtk.vtkRenderWindowInteractor()
# Specify interaction with 2D image
style = vtk.vtkInteractorStyleImage()
style.SetInteractionModeToImage2D()
iren.SetInteractorStyle(style)
iren.SetRenderWindow(renWin)
# Add the actors to the renderer, set the background and size
ren.AddActor(actor)
ren.AddActor(colorBar)
ren.ResetCamera()
ren.SetBackground(0, 0, 0)
ren.ResetCameraClippingRange()
renWin.SetSize(1280, 800)
# Add vtkSliderWidget
SliderRepres1 = vtk.vtkSliderRepresentation2D()
min = datamin+1
max = datamax-2
SliderRepres1.SetMinimumValue(min)
SliderRepres1.SetMaximumValue(max)
SliderRepres1.SetTitleText("vmin")
SliderRepres1.GetPoint1Coordinate().SetCoordinateSystemToNormalizedDisplay()
SliderRepres1.GetPoint1Coordinate().SetValue(0.1, 0.1)
SliderRepres1.GetPoint2Coordinate().SetCoordinateSystemToNormalizedDisplay()
SliderRepres1.GetPoint2Coordinate().SetValue(0.3, 0.1)
SliderRepres1.SetSliderLength(0.02)
SliderRepres1.SetSliderWidth(0.03)
SliderRepres1.SetEndCapLength(0.01)
SliderRepres1.SetEndCapWidth(0.03)
SliderRepres1.SetTubeWidth(0.005)
SliderRepres1.SetLabelFormat("%3.0lf")
SliderRepres1.SetTitleHeight(0.02)
SliderRepres1.SetLabelHeight(0.02)
SliderWidget1 = vtk.vtkSliderWidget()
SliderWidget1.SetInteractor(iren)
SliderWidget1.SetRepresentation(SliderRepres1)
SliderWidget1.KeyPressActivationOff()
SliderWidget1.SetAnimationModeToAnimate()
SliderWidget1.SetEnabled(True)
SliderWidget1.AddObserver("InteractionEvent", vminSliderHandler)
# Add vtkSliderWidget
SliderRepres2 = vtk.vtkSliderRepresentation2D()
min = datamin+2
max = datamax-1
SliderRepres2.SetMinimumValue(min)
SliderRepres2.SetMaximumValue(max)
SliderRepres2.SetTitleText("vmax")
SliderRepres2.GetPoint1Coordinate().SetCoordinateSystemToNormalizedDisplay()
SliderRepres2.GetPoint1Coordinate().SetValue(0.4, 0.1)
SliderRepres2.GetPoint2Coordinate().SetCoordinateSystemToNormalizedDisplay()
SliderRepres2.GetPoint2Coordinate().SetValue(0.6, 0.1)
SliderRepres2.SetSliderLength(0.02)
SliderRepres2.SetSliderWidth(0.03)
SliderRepres2.SetEndCapLength(0.01)
SliderRepres2.SetEndCapWidth(0.03)
SliderRepres2.SetTubeWidth(0.005)
SliderRepres2.SetLabelFormat("%3.0lf")
SliderRepres2.SetTitleHeight(0.02)
SliderRepres2.SetLabelHeight(0.02)
SliderWidget2 = vtk.vtkSliderWidget()
SliderWidget2.SetInteractor(iren)
SliderWidget2.SetRepresentation(SliderRepres2)
SliderWidget2.KeyPressActivationOff()
SliderWidget2.SetAnimationModeToAnimate()
SliderWidget2.SetEnabled(True)
SliderWidget2.AddObserver("InteractionEvent", vmaxSliderHandler)
# Add vtkSliderWidget
SliderRepres3 = vtk.vtkSliderRepresentation2D()
min = 1
max = (datamax-datamin)/10
SliderRepres3.SetMinimumValue(min)
SliderRepres3.SetMaximumValue(max)
SliderRepres3.SetTitleText("w")
SliderRepres3.GetPoint1Coordinate().SetCoordinateSystemToNormalizedDisplay()
SliderRepres3.GetPoint1Coordinate().SetValue(0.7, 0.1)
SliderRepres3.GetPoint2Coordinate().SetCoordinateSystemToNormalizedDisplay()
SliderRepres3.GetPoint2Coordinate().SetValue(0.9, 0.1)
SliderRepres3.SetSliderLength(0.02)
SliderRepres3.SetSliderWidth(0.03)
SliderRepres3.SetEndCapLength(0.01)
SliderRepres3.SetEndCapWidth(0.03)
SliderRepres3.SetTubeWidth(0.005)
SliderRepres3.SetLabelFormat("%3.0lf")
SliderRepres3.SetTitleHeight(0.02)
SliderRepres3.SetLabelHeight(0.02)
SliderWidget3 = vtk.vtkSliderWidget()
SliderWidget3.SetInteractor(iren)
SliderWidget3.SetRepresentation(SliderRepres3)
SliderWidget3.KeyPressActivationOff()
SliderWidget3.SetAnimationModeToAnimate()
SliderWidget3.SetEnabled(True)
SliderWidget3.AddObserver("InteractionEvent", wSliderHandler)
updateUI()
iren.Initialize()
renWin.Render()
iren.Start()
def __init__(self, filename, renderer):
self.renderer = renderer
reader = vtk.vtkStructuredPointsReader()
#reader.SetFileName('/home/mcc/src/devel/extract_mri_slices/braintest2.vtk')
reader.SetFileName(filename)
# we want to move this from its (.87 .92 .43) esque position to something more like 'the center'
# how to do this?!?
# ALTERNATIVELY: we want to use vtkInteractorStyleTrackballActor
# somewhere instead of the interactor controlling the main window and 3 planes
imagedata = reader.GetOutput()
#reader.SetFileName(filename)
cf = vtk.vtkContourFilter()
cf.SetInput(imagedata)
# ???
cf.SetValue(0, 1)
deci = vtk.vtkDecimatePro()
deci.SetInput(cf.GetOutput())
deci.SetTargetReduction(.1)
deci.PreserveTopologyOn()
smoother = vtk.vtkSmoothPolyDataFilter()
smoother.SetInput(deci.GetOutput())
smoother.SetNumberOfIterations(100)
# XXX try to call SetScale directly on actor..
#self.scaleTransform = vtk.vtkTransform()
#self.scaleTransform.Identity()
#self.scaleTransform.Scale(.1, .1, .1)
#transformFilter = vtk.vtkTransformPolyDataFilter()
#transformFilter.SetTransform(self.scaleTransform)
#transformFilter.SetInput(smoother.GetOutput())
#cf.SetValue(1, 2)
#cf.SetValue(2, 3)
#cf.GenerateValues(0, -1.0, 1.0)
#deci = vtk.vtkDecimatePro()
#deci.SetInput(cf.GetOutput())
#deci.SetTargetReduction(0.8) # decimate_value
normals = vtk.vtkPolyDataNormals()
#normals.SetInput(transformFilter.GetOutput())
normals.SetInput(smoother.GetOutput())
normals.FlipNormalsOn()
"""
tags = vtk.vtkFloatArray()
tags.InsertNextValue(1.0)
tags.InsertNextValue(0.5)
tags.InsertNextValue(0.7)
tags.SetName("tag")
"""
lut = vtk.vtkLookupTable()
lut.SetHueRange(0, 0)
lut.SetSaturationRange(0, 0)
lut.SetValueRange(0.2, 0.55)
contourMapper = vtk.vtkPolyDataMapper()
contourMapper.SetInput(normals.GetOutput())
contourMapper.SetLookupTable(lut)
###contourMapper.SetColorModeToMapScalars()
###contourMapper.SelectColorArray("tag")
self.contours = vtk.vtkActor()
self.contours.SetMapper(contourMapper)
#if (do_wireframe):
#self.contours.GetProperty().SetRepresentationToWireframe()
#elif (do_surface):
self.contours.GetProperty().SetRepresentationToSurface()
self.contours.GetProperty().SetInterpolationToGouraud()
self.contours.GetProperty().SetOpacity(1.0)
self.contours.GetProperty().SetAmbient(0.1)
self.contours.GetProperty().SetDiffuse(0.1)
self.contours.GetProperty().SetSpecular(0.1)
self.contours.GetProperty().SetSpecularPower(0.1)
# XXX arbitrarily setting scale to this
#self.contours.SetScale(.1, .1,.1)
renderer.AddActor(self.contours)
# XXX: mcc will this work?!?
print "PlaneWidgetsXYZ.set_image_data: setting EventHandler.set_vtkactor(self.contours)!"
EventHandler().set_vtkactor(self.contours)
def Main():
global ren
print "data: %s" % sys.argv[1]
reader = vtk.vtkStructuredPointsReader()
reader.SetFileName(sys.argv[1])
isosurfaces = [
[500,0.1,0.3,1,0.3],
[1158,0.1,0.6,1,0.5],
[2750,0.1,1,1,1]
]
ren = vtk.vtkRenderer()
for surface in isosurfaces:
lut = vtk.vtkColorTransferFunction()
lut.SetColorSpaceToHSV()
lut.AddHSVPoint(surface[0],surface[1],surface[2],surface[3])
contours = vtk.vtkContourFilter()
contours.SetInputConnection(reader.GetOutputPort());
contours.ComputeNormalsOn()
contours.SetValue(0, surface[0])
mapper = vtk.vtkDataSetMapper()
mapper.SetInputConnection(contours.GetOutputPort())
mapper.SetLookupTable(lut)
mapper.ImmediateModeRenderingOff()
actor = vtk.vtkActor()
actor.SetMapper(mapper)
actor.GetProperty().SetOpacity(surface[4])
ren.AddActor(actor)
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
iren.RemoveObservers('RightButtonPressEvent')
iren.AddObserver('RightButtonPressEvent', print_camera_settings, 1.0)
iren.AddObserver('RightButtonPressEvent', after_print_camera_settings, -1.0)
# for depth peeling
ren.SetUseDepthPeeling(1)
ren.SetMaximumNumberOfPeels(4) # default 4
ren.SetOcclusionRatio(0) # default 0
ren.ResetCamera()
ren.SetBackground(0,0,0)
ren.ResetCameraClippingRange()
ren.GetActiveCamera().SetViewUp(-0.033792287793636924, 0.000854723562570334, -0.9994285120674231)
ren.GetActiveCamera().SetPosition(-308.155681140229, -119.92183136577268, 117.3094068139949 )
ren.GetActiveCamera().SetFocalPoint(91.14654767513275, 104.1683804243803, 104.0)
ren.GetActiveCamera().SetClippingRange(191.00826351112892, 795.369621458024)
# for depth peeling
renWin.SetAlphaBitPlanes(1)
renWin.SetMultiSamples(0)
renWin.SetSize(1600, 900)
# Render
iren.Initialize()
renWin.Render()
iren.Start()
# This is a simple volume rendering example that uses a # vtkVolumeRayCast mapper import vtk from vtk.util.misc import vtkGetDataRoot VTK_DATA_ROOT = vtkGetDataRoot() # Create the standard renderer, render window and interactor ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) # Create the reader for the data reader = vtk.vtkStructuredPointsReader() reader.SetFileName(VTK_DATA_ROOT + "/Data/ironProt.vtk") # Create transfer mapping scalar value to opacity opacityTransferFunction = vtk.vtkPiecewiseFunction() opacityTransferFunction.AddPoint(20, 0.0) opacityTransferFunction.AddPoint(255, 0.2) # Create transfer mapping scalar value to color colorTransferFunction = vtk.vtkColorTransferFunction() colorTransferFunction.AddRGBPoint(0.0, 0.0, 0.0, 0.0) colorTransferFunction.AddRGBPoint(64.0, 1.0, 0.0, 0.0) colorTransferFunction.AddRGBPoint(128.0, 0.0, 0.0, 1.0) colorTransferFunction.AddRGBPoint(192.0, 0.0, 1.0, 0.0) colorTransferFunction.AddRGBPoint(255.0, 0.0, 0.2, 0.0)
def main():
fileName = get_program_parameters()
colors = vtk.vtkNamedColors()
# This is a simple volume rendering example that
# uses a vtkFixedPointVolumeRayCastMapper
# Create the standard renderer, render window
# and interactor.
ren1 = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren1)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
# Create the reader for the data.
reader = vtk.vtkStructuredPointsReader()
reader.SetFileName(fileName)
# Create transfer mapping scalar value to opacity.
opacityTransferFunction = vtk.vtkPiecewiseFunction()
opacityTransferFunction.AddPoint(20, 0.0)
opacityTransferFunction.AddPoint(255, 0.2)
# Create transfer mapping scalar value to color.
colorTransferFunction = vtk.vtkColorTransferFunction()
colorTransferFunction.AddRGBPoint(0.0, 0.0, 0.0, 0.0)
colorTransferFunction.AddRGBPoint(64.0, 1.0, 0.0, 0.0)
colorTransferFunction.AddRGBPoint(128.0, 0.0, 0.0, 1.0)
colorTransferFunction.AddRGBPoint(192.0, 0.0, 1.0, 0.0)
colorTransferFunction.AddRGBPoint(255.0, 0.0, 0.2, 0.0)
# The property describes how the data will look.
volumeProperty = vtk.vtkVolumeProperty()
volumeProperty.SetColor(colorTransferFunction)
volumeProperty.SetScalarOpacity(opacityTransferFunction)
volumeProperty.ShadeOn()
volumeProperty.SetInterpolationTypeToLinear()
# The mapper / ray cast function know how to render the data.
volumeMapper = vtk.vtkFixedPointVolumeRayCastMapper()
volumeMapper.SetInputConnection(reader.GetOutputPort())
# The volume holds the mapper and the property and
# can be used to position/orient the volume.
volume = vtk.vtkVolume()
volume.SetMapper(volumeMapper)
volume.SetProperty(volumeProperty)
ren1.AddVolume(volume)
ren1.SetBackground(colors.GetColor3d('Wheat'))
ren1.GetActiveCamera().Azimuth(45)
ren1.GetActiveCamera().Elevation(30)
ren1.ResetCameraClippingRange()
ren1.ResetCamera()
renWin.SetSize(600, 600)
renWin.SetWindowName('SimpleRayCast')
renWin.Render()
iren.Start()
def main(vector_file, magnitude_file):
num_critical_points = 6
CriticalPoints = vtk.vtkPoints()
CriticalPoints.InsertNextPoint(35, 14, 20)
CriticalPoints.InsertNextPoint(55, 15, 20)
CriticalPoints.InsertNextPoint(65, 45, 19)
CriticalPoints.InsertNextPoint(45, 44.8, 20)
CriticalPoints.InsertNextPoint(20, 29.7, 19.8)
CriticalPoints.InsertNextPoint(10, 32.2, 16.1)
ColorRange = vtk.vtkLookupTable()
ColorRange.SetTableRange(0, 1)
ColorRange.SetHueRange(0, 1)
ColorRange.SetSaturationRange(1, 1)
ColorRange.SetAlphaRange(0.3, 0.5)
ColorRange.Build()
reader = vtk.vtkStructuredPointsReader()
reader.SetFileName(vector_file)
reader.Update()
mags = reader.GetOutput()
range1 = mags.GetScalarRange()
v0 = range1[0]
v1 = range1[1]
reader_magnitude = vtk.vtkStructuredPointsReader()
reader_magnitude.SetFileName(magnitude_file)
reader_magnitude.Update()
# All entities initialized equal to number of critical points
sphere1, stream1, scalarSurface1, tube1, dataMapper1, dataActor1, criticalMarker1, criticalMapper1, criticalActor1, probe1, mask1, glyph1, glyphMapper1, glyphActor1, plane1 = (
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
[],
)
for i in range(0, num_critical_points):
sphere1.append(vtk.vtkSphereSource())
stream1.append(vtk.vtkStreamLine())
scalarSurface1.append(vtk.vtkRuledSurfaceFilter())
tube1.append(vtk.vtkTubeFilter())
dataMapper1.append(vtk.vtkPolyDataMapper())
dataActor1.append(vtk.vtkActor())
criticalMarker1.append(vtk.vtkSphereSource())
criticalMapper1.append(vtk.vtkPolyDataMapper())
criticalActor1.append(vtk.vtkActor())
probe1.append(vtk.vtkProbeFilter())
mask1.append(vtk.vtkMaskPoints())
glyph1.append(vtk.vtkGlyph3D())
glyphMapper1.append(vtk.vtkPolyDataMapper())
glyphActor1.append(vtk.vtkActor())
plane1.append(vtk.vtkPlaneSource())
integ = vtk.vtkRungeKutta4()
cone = vtk.vtkConeSource()
cone.SetResolution(8)
cone.SetHeight(1.0)
cone.SetRadius(0.2)
transform = vtk.vtkTransform()
transform.Translate(0, 0, 0)
transformFilter = vtk.vtkTransformPolyDataFilter()
transformFilter.SetInput(cone.GetOutput())
transformFilter.SetTransform(transform)
outline = vtk.vtkOutlineFilter()
outline.SetInput(reader.GetOutput())
outlineMapper = vtk.vtkPolyDataMapper()
outlineMapper.SetInput(outline.GetOutput())
outlineActor = vtk.vtkActor()
outlineActor.SetMapper(outlineMapper)
outlineActor.GetProperty().SetColor(1, 1, 1)
bar = vtk.vtkScalarBarActor()
bar.SetLookupTable(ColorRange)
renderer = vtk.vtkRenderer()
for i in range(0, num_critical_points):
sphere1[i].SetRadius(2)
sphere1[i].SetCenter(
CriticalPoints.GetPoint(i)[0], CriticalPoints.GetPoint(i)[1], CriticalPoints.GetPoint(i)[2]
)
sphere1[i].SetThetaResolution(1)
stream1[i].SetInput(reader.GetOutput())
stream1[i].SetSource(sphere1[i].GetOutput())
stream1[i].SetIntegrator(integ)
stream1[i].SetMaximumPropagationTime(500)
stream1[i].SetIntegrationStepLength(0.1)
stream1[i].SetIntegrationDirectionToIntegrateBothDirections()
stream1[i].SetStepLength(0.1)
scalarSurface1[i].SetInput(stream1[i].GetOutput())
scalarSurface1[i].SetOffset(0)
scalarSurface1[i].SetOnRatio(2)
scalarSurface1[i].PassLinesOn()
scalarSurface1[i].SetRuledModeToPointWalk()
scalarSurface1[i].SetDistanceFactor(50)
tube1[i].SetInput(scalarSurface1[i].GetOutput())
tube1[i].SetRadius(0.1)
tube1[i].SetNumberOfSides(6)
dataMapper1[i].SetInput(tube1[i].GetOutput())
dataMapper1[i].SetScalarRange(v0, v1)
dataMapper1[i].SetLookupTable(ColorRange)
dataActor1[i].SetMapper(dataMapper1[i])
# renderer.AddActor(dataActor1[i])
criticalMarker1[i].SetRadius(1.0)
criticalMarker1[i].SetCenter(
CriticalPoints.GetPoint(i)[0], CriticalPoints.GetPoint(i)[1], CriticalPoints.GetPoint(i)[2]
)
criticalMarker1[i].SetThetaResolution(10)
criticalMapper1[i].SetInput(criticalMarker1[i].GetOutput())
criticalActor1[i].SetMapper(criticalMapper1[i])
criticalActor1[i].GetProperty().SetColor(1, 1, 0)
criticalActor1[i].GetProperty().SetOpacity(0.5)
# renderer.AddActor(criticalActor1[i])
probe1[i].SetInput(stream1[i].GetOutput())
probe1[i].SetSource(reader.GetOutput())
mask1[i].SetInput(probe1[i].GetOutput())
mask1[i].SetOnRatio(60)
mask1[i].RandomModeOn()
glyph1[i].SetInput(mask1[i].GetOutput())
glyph1[i].SetSource(transformFilter.GetOutput())
glyph1[i].SetScaleModeToScaleByVector()
glyph1[i].SetScaleFactor(2)
glyph1[i].SetVectorModeToUseVector()
glyph1[i].SetColorModeToColorByVector()
glyphMapper1[i].SetInput(glyph1[i].GetOutput())
glyphMapper1[i].SetLookupTable(ColorRange)
glyphActor1[i].SetMapper(glyphMapper1[i])
# renderer.AddActor(glyphActor1[i])
# removeActors1(renderer, dataActor, criticalActor, glyphActor, dataActor1, criticalActor1, glyphActor1)
mags = reader.GetOutput()
bounds = mags.GetBounds()
x0 = bounds[0]
x1 = bounds[1]
y0 = bounds[2]
y1 = bounds[3]
z0 = bounds[4]
z1 = bounds[5]
range1 = mags.GetScalarRange()
v0 = range1[0]
v1 = range1[1]
plane1[0].SetOrigin(x0, y0, z0)
plane1[0].SetPoint1(x0, y1, z0)
plane1[0].SetPoint2(x0, y0, z1)
plane1[1].SetOrigin(x0, y0, z0)
plane1[1].SetPoint1(x0, y1, z0)
plane1[1].SetPoint2(x1, y0, z0)
plane1[2].SetOrigin(x0, y0, z0)
plane1[2].SetPoint1(x0, y0, z1)
plane1[2].SetPoint2(x1, y0, z0)
plane1[3].SetOrigin(x1, y1, z1)
plane1[3].SetPoint1(x1, y1, z0)
plane1[3].SetPoint2(x1, y0, z1)
plane1[4].SetOrigin(x1, y1, z1)
plane1[4].SetPoint1(x0, y1, z1)
plane1[4].SetPoint2(x1, y1, z0)
plane1[5].SetOrigin(x1, y1, z1)
plane1[5].SetPoint1(x0, y1, z1)
plane1[5].SetPoint2(x1, y1, z0)
for i in range(0, num_critical_points):
plane1[i].SetResolution(5, 5)
stream1[i].SetSource(plane1[i].GetOutput())
renderer.AddActor(dataActor1[i])
renderer.AddActor(glyphActor1[i])
glyph1[i].SetScaleFactor(4)
renderer.AddActor(bar)
renderer.AddActor(outlineActor)
for i in range(0, num_critical_points):
renderer.AddActor(criticalActor1[i])
renderer_window = vtk.vtkRenderWindow()
renderer_window.AddRenderer(renderer)
renderer_window.SetSize(512, 512)
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetRenderWindow(renderer_window)
style = vtk.vtkInteractorStyleTrackballCamera()
interactor.SetInteractorStyle(style)
renderer.AddActor(bar)
renderer.AddActor(outlineActor)
renderer_window.Render()
interactor.Start()
def Main():
global datamin, datamax, lut, renWin
# Load bathymetry dataset
bathymetryReader = vtk.vtkStructuredPointsReader()
bathymetryReader.SetFileName(sys.argv[1])
bathymetryReader.Update()
r = bathymetryReader.GetOutput().GetPointData().GetScalars().GetRange()
datamin = r[0]
datamax = r[1]
loadContinuousFile(sys.argv[2])
loadDiscreteFile(sys.argv[3])
# Setup color mapping
lut = vtk.vtkColorTransferFunction()
lut.SetColorSpaceToHSV()
# Load bathymetry data into Geometry Filter
geometry = vtk.vtkImageDataGeometryFilter()
geometry.SetInputConnection(bathymetryReader.GetOutputPort())
mapper = vtk.vtkDataSetMapper()
mapper.SetInputConnection(geometry.GetOutputPort())
mapper.SetLookupTable(lut)
mapper.ImmediateModeRenderingOff()
# Setup color mapping bar
colorBar = vtkScalarBarActor()
colorBar.SetLookupTable(mapper.GetLookupTable())
colorBar.SetTitle("color map")
colorBar.SetNumberOfLabels(6)
colorBar.SetLabelFormat("%4.0f")
colorBar.SetPosition(0.9, 0.1)
colorBar.SetWidth(0.07)
colorBar.SetHeight(0.8)
actor = vtk.vtkActor()
actor.SetMapper(mapper)
# Create renderer stuff
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
renWin.SetSize(1280, 800)
# Add the actors to the renderer, set the background and size
ren.AddActor(actor)
ren.AddActor(colorBar)
ren.ResetCamera()
ren.SetBackground(0, 0, 0)
ren.ResetCameraClippingRange()
root = Tkinter.Tk()
root.title('Task 2. MRI Data')
frame = Tkinter.Frame(root)
frame.pack(fill=Tkinter.BOTH, expand="false", side=Tkinter.TOP)
mode = Tkinter.IntVar()
mode.set(1)
Tkinter.Radiobutton(frame,
text="Continuous color map",
padx=20,
variable=mode,
value=1,
command=showContinuous).pack(anchor=Tkinter.W)
Tkinter.Radiobutton(frame,
text="Discrete color map",
padx=20,
variable=mode,
value=2,
command=showDiscrete).pack(anchor=Tkinter.W)
# Setup for rendering window interactor
renWinInteract = vtkTkRenderWindowInteractor(frame,
rw=renWin,
width=1280,
height=800)
# Specify interaction with 2D image
style = vtk.vtkInteractorStyleImage()
style.SetInteractionModeToImage2D()
renWinInteract.SetInteractorStyle(style)
renWinInteract.Initialize()
renWinInteract.pack(side='top', fill='both', expand="false")
renWinInteract.Start()
updateUI(0)
renWin.Render()
root.mainloop()
def __init__(self,delta,wing):
self.arrowColor = vtk.vtkColorTransferFunction()
self.update_look_up_table()
self.print_counter=0
self.ren = vtk.vtkRenderer()
self.geo_reader = vtk.vtkUnstructuredGridReader()
self.geo_reader.SetFileName(wing)
self.vec_reader = vtk.vtkStructuredPointsReader()
self.vec_reader.SetFileName(delta)
""" This is for drawing the wing,"""
geo_Mapper=vtk.vtkDataSetMapper()
geo_Mapper.SetInputConnection(self.geo_reader.GetOutputPort())
geo_actor = vtk.vtkActor()
geo_actor.SetMapper(geo_Mapper)
self.ren.AddActor(geo_actor)
"""End of adding the wing """
self.ren.AddActor(self.create_stream_line(25,150,0,0.5))
#Add renderer to renderwindow and render
self.renWin = vtk.vtkRenderWindow()
self.renWin.AddRenderer(self.ren)
self.renWin.SetSize(1920, 1080)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(self.renWin)
iren.AddObserver('RightButtonPressEvent', self.capture_image, 1.0)
# Scalar Bar actor
scalar_bar = vtk.vtkScalarBarActor()
scalar_bar.SetOrientationToHorizontal()
scalar_bar.SetLookupTable(self.arrowColor)
scalar_bar.SetTitle("Color map")
scalar_bar.SetLabelFormat("%5.2f")
scalar_bar.SetMaximumHeightInPixels(300)
scalar_bar.SetMaximumWidthInPixels(60)
# Scalar Bar Widget
scalar_bar_widget = vtk.vtkScalarBarWidget()
scalar_bar_widget.SetInteractor(iren)
scalar_bar_widget.SetScalarBarActor(scalar_bar)
scalar_bar_widget.On()
self.ren.SetBackground(0,0,0)
self.renWin.Render()
iren.Start()
